Predicción de accidentes de tránsito con redes neuronales artificiales

La Ciudad de México es una de las ciudades más grandes del mundo, con una población de más de 21 millones de habitantes. En 2020, la Ciudad de México reportó 71,038 accidentes de tráfico, con 636 muertes y 9,685 lesiones. Este número es alarmante y muestra la importancia de tomar medidas para prevenir accidentes de tráfico.

Mayor número de accidentes 2020

Una manera en la que la inteligencia artificial y las redes neuronales pueden ayudar a prevenir accidentes de tráfico es a través del análisis de datos. Por ejemplo, los datos recopilados de las cámaras de tráfico, semáforos y sensores pueden ser utilizados para identificar patrones que indiquen zonas de alta peligrosidad o situaciones de tráfico riesgosas. Este tipo de análisis puede ser realizado mediante el uso de redes neuronales, que son sistemas de aprendizaje automático que simulan el funcionamiento del cerebro humano. Las redes neuronales pueden ser entrenadas para identificar patrones y predecir resultados basados en datos históricos.

Un ejemplo de cómo se puede utilizar una red neuronal para mejorar la seguridad vial es en un sistema de alerta de frenado de emergencia. Este sistema utiliza sensores instalados en el automóvil para detectar peligros y, si es necesario, activar el frenado de emergencia para evitar un choque. Una red neuronal se puede utilizar para entrenar el sistema para identificar diferentes tipos de peligros, como peatones cruzando la calle o vehículos detenidos en la carretera. Para ejemplificar lo anterior, vamos a implementar una red neuronal en Python para predecir la probabilidad de un accidente automovilístico en la Ciudad de México. Utilizaremos un conjunto de datos de la Ciudad de México que contiene información sobre accidentes de tráfico, como el número y tipo de vehículos involucrados, las condiciones del tiempo y de la carretera, y la hora del día.

Primero, importamos las bibliotecas necesarias:

import pandas as pd

import numpy as np

import tensorflow as tf

from tensorflow import keras

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

Luego, cargaremos los datos y crearemos un conjunto de variables predictoras (también conocidas como características) y una variable objetivo (es decir, la variable que deseamos predecir):

# Datos recolectados

datos = pd.read_csv("accidentes.csv")

# Seleccionamos las variables que van a predecir

caracteristicas = datos.drop(['accidente'], axis=1)

# Seleccionar variable objetivo

objetivo = datos['accidente']

Dividiremos los datos en un conjunto de entrenamiento y un conjunto de prueba para entrenar y evaluar el modelo:

# Dividir los datos en un conjunto de entrenamiento y prueba

X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(caracteristicas, objetivo, test_size=0.2, random_state=42)

Luego, normalizamos las variables predictivas utilizando la transformación estándar de sklearn:

# Crear la transformación estándar para normalizar los datos

transformacion = StandardScaler()

# Ajustar y transformar los datos de entrenamiento

X_entrenamiento_norm = transformacion.fit_transform(X_entrenamiento)

# Transformar los datos de prueba

X_prueba_norm = transformacion.transform(X_prueba)

A continuación, crearemos una red neuronal utilizando Keras de TensorFlow:

# Crear la red neuronal

modelo = keras.Sequential([

    keras.layers.Dense(64, activation='relu', input_shape=(X_entrenamiento_norm.shape[1],)),

    keras.layers.Dense(32, activation='relu'),

    keras.layers.Dense(16, activation='relu'),

    keras.layers.Dense(1, activation='sigmoid')

])

# Compilar la red neuronal

modelo.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

Entrenaremos la red neuronal utilizando el conjunto de entrenamiento:

# Entrenar el modelo

modelo.fit(X_entrenamiento_norm, y_entrenamiento, epochs=10, batch_size=32)

Finalmente, evaluar el modelo con el conjunto de prueba:

# Evaluar el modelo

puntuacion = modelo.evaluate(X_prueba_norm, y_prueba)

# Mostrar la puntuación de pérdida y la precisión del modelo

print("Pérdida:", puntuacion[0])

print("Precisión:", puntuacion[1])

Si se creó correctamente el modelo y se cargaron los datos correctamente, se  debería ver una salida similar a la siguiente:

Epoch 1/10
7115/7115 [==============================] - 1s 37us/sample - loss: 0.5839 - accuracy: 0.7076
Epoch 2/10
7115/7115 [==============================] - 0s 26us/sample - loss: 0.5073 - accuracy: 0.7510
Epoch 3/10
7115/7115 [==============================] - 0s 27us/sample - loss: 0.4895 - accuracy: 0.7623
Epoch 4/10
7115/7115 [==============================] - 0s 26us/sample - loss: 0.4783 - accuracy: 0.7671
Epoch 5/10
7115/7115 [==============================] - 0s 26us/sample - loss: 0.4727 - accuracy: 0.7693
Epoch 6/10
7115/7115 [==============================] - 0s 25us/sample - loss: 0.4667 - accuracy: 0.7710
Epoch 7/10
7115/7115 [==============================] - 0s 26us/sample - loss: 0.4621 - accuracy: 0.7759
Epoch 8/10
7115/7115 [==============================] - 0s 25us/sample - loss: 0.4593 - accuracy: 0.7764
Epoch 9/10
7115/7115 [==============================] - 0s 25us/sample - loss: 0.4556 - accuracy: 0.7794
Epoch 10/10
7115/7115 [==============================] - 0s 27us/sample - loss: 0.4542 - accuracy: 0.7831
1779/1779 [==============================] - 0s 34us/sample - loss: 0.4664 - accuracy: 0.7714
Pérdida: 0.4664111651696596
Precisión: 0.7714218

En este ejemplo, la red neuronal tiene una precisión de aproximadamente el 77%. Esto significa que, dadas las características de un accidente, el modelo puede predecir con precisión si ese accidente es un accidente automovilístico o no en aproximadamente el 77% de los casos.

Si no estás familiarizado con la programación, seguro todo esto te parecerá complicado, pero déjame decirte que en realidad, mucho del código es solo ajustarlo a tus necesidades, porque ya existen librerías y códigos base para hacer este tipo de predicciones. Ahora aquí te detallo paso a paso que significan estos resultados. Te explico un poco mas a detalle que estamos viendo en el código.

El primer conjunto de líneas muestra el progreso del modelo durante el entrenamiento. En cada época (Epoch) o iteración, se indica la pérdida de la red neuronal y la precisión (accuracy) lograda en ese momento. La pérdida es una medida del error cometido por el modelo al hacer las predicciones, mientras que la precisión indica qué tan bien está funcionando el modelo.

En la segunda parte de la salida, se muestra la pérdida y la precisión del modelo en los datos de evaluación o prueba. En este caso, el modelo tiene una pérdida de 0.466 y una precisión (accuracy) de 0.771. La precisión es una medida del número de aciertos del modelo en relación con el total de ejemplos de prueba.

• "Epoch 1/10" indica que se realizarán 10 épocas de entrenamiento. Una época es un ciclo completo de pasar todos los datos de entrenamiento a través de la red neuronal.
• "7115/7115" muestra el tamaño del lote (batch size) utilizado durante el entrenamiento. En este caso, se están utilizando los 7115 datos de entrenamiento en cada época.
• "loss" se refiere a la función de pérdida utilizada para medir qué tan bien está funcionando la red neuronal. En este caso, se está utilizando la pérdida de entropía cruzada binaria.
• "accuracy" muestra la precisión de la red neuronal en cada época, es decir, qué tan bien está clasificando los datos de entrenamiento.

Después de cada época, se muestra el resultado de la pérdida y la precisión en los datos de entrenamiento.

Al final del entrenamiento, se muestra la pérdida y la precisión en los datos de prueba. Estos datos son diferentes de los datos de entrenamiento y se utilizan para evaluar la capacidad de generalización de la red neuronal.

En este caso, la red neuronal muestra una pérdida final de 0.4664 y una precisión de 0.7714 en los datos de prueba. Esto indica que la red neuronal tiene una buena capacidad para predecir la probabilidad de un accidente automovilístico, 77% es un muy buen número si consideramos una red neuronal tan pequeña y unos datos a lo mejor no tan completos.

Es importante destacar que este es solo un ejemplo básico de cómo implementar una red neuronal para predecir la probabilidad de un accidente automovilístico. En una aplicación real, se requeriría un conjunto de datos más grande y complejo, así como un ajuste de hiperparámetros y una validación adecuada para obtener resultados más precisos.

¿Esto ayuda realmente a prevenir accidentes? Pues si, la idea es que si podemos predecir con que frecuencia ocurren accidentes en cierto punto, las autoridades puedes realizar cambios en la vialidad, he implementar distintas medidas para evitar que sigan sucediendo.

Héctor.