Hipótesis 4🚩 - David-informatica/Pruebas GitHub Wiki

Tarjeta GOLD📀

Para llevar a cabo el prepocesado de los datos se tienen en cuenta los aquellos que son necesarios para abordar la hipótesis. Estos datos se procesan utilizando los siguientes métodos:

Se extraen las diferentes partes de los datasets que nos seran utiles a la hora de tratar la hipótesis y se añade una nueva columna que nos permitirá contar los accidentes por carretera y por año.

hipotesis4_dataset = pd.merge(collision_accidents_information, traffic_density, on=["year", "road_name", "Local Authority Code"], how="inner")
hipotesis4_dataset["accident_count"] = hipotesis4_dataset.groupby(["year", "road_name","Local Authority Code"]).transform("count")
hipotesis4_dataset = hipotesis4_dataset.drop_duplicates(subset=["year", "Local Authority Code", "road_name"])

Después de añadir los accidentes del año anterior y reordenar las columnas resultantes, se eliminan tanto los valores de las carreteras que no tuvieron acciedentes el año anterior (son valores nulos), y también se elimina el año 2023 (por decisión del grupo).

final_hipotisis4_dataset = final_hipotisis4_dataset.dropna(subset=['accident_count_last_year'])
final_hipotisis4_dataset["accident_count_last_year"] = final_hipotisis4_dataset[ "accident_count_last_year"].astype(int)
final_hipotisis4_dataset = final_hipotisis4_dataset[final_hipotisis4_dataset['year'] != 2023]

[!IMPORTANT] El objetivo de esta hipótesis es desarrollar un modelo predictivo para estimar el número de accidentes de tráfico y evaluar si es posible predecir la cantidad de accidentes de tráfico en el año 2023.

Para esto nos centraremos en carreteras específicas utilizando datos históricos entre 2020 y 2022, usando un conjunto de variables como la densidad de tráfico, los accidentes ocurridos el año anterior y otros factores relevantes. Los datos de 2023 se emplearon para validar la precisión de los modelos

Análisis exploratorio y visualización de datos

A continuación, se describe el análisis realizado para entender y tratar los datos que serviran de entrenamiento:

Alcance de los datos

  • Rango temporal: 2020-2022 (el 2019 y el 2023 se excluyen por razones específicas del modelo).
  • Características clave: Incluyen datos sobre densidad de tráfico, número de accidentes del año anterior y carreteras divididas por distritos.

Análisis de correlacion de variables

Se usó el coeficiente de Spearman para medir la relación entre las variables. Los resultados sugieren que:

  • La correlación entre la densidad de tráfico y los accidentes de tráfico es moderada, pero no estrictamente lineal.
  • La correlación entre accident_count y accident_count_last_year es fuerte, dado que los cambios de un año a otro no son significativos.
numeric_data = df.select_dtypes(include=['number'])

corr_matrix = numeric_data.corr(method='spearman')

plt.figure(figsize=(8, 6))
sns.heatmap(corr_matrix, annot=True, cmap="coolwarm", fmt=".2f", linewidths=0.5)
plt.title("Correlación entre variables del dataset 4")
plt.show()

Codificación de variables categóricas

Se utilizó LabelEncoder para codificar las variables categóricas, como Local Authority Code y road_name.

def codify_categorical_variables(dataframe):
    df_modified = dataframe.copy()

    codifier = LabelEncoder()

    df_modified['Local Authority Code'] = codifier.fit_transform(df_modified['Local Authority Code'])
    print("Mapeo de códigos para 'Local Authority Code':")
    for codigo, categoria in enumerate(codifier.classes_):
        print(f"  {categoria} -> {codigo}")

    df_modified['road_name'] = codifier.fit_transform(df_modified['road_name'])
    print("\nMapeo de códigos para 'road_name':")
    for codigo, categoria in enumerate(codifier.classes_):
        print(f"  {categoria} -> {codigo}")

    return df_modified

df_h3 = codify_categorical_variables(df)

Carreteras analizadas

Cinco carreteras específicas fueron seleccionadas para evaluar los modelos:

  1. A10 (Hackney)
  • Accidentes en 2023: 1340
  • Densidad de tráfico: 21110
  1. A112 (Waltham Forest)
  • Accidentes en 2023: 870
  • Densidad de tráfico: 14565
  1. A315 (Hounslow)
  • Accidentes en 2023: 1554
  • Densidad de tráfico: 12624
  1. A40 (Westminster)
  • Accidentes en 2023: 354
  • Densidad de tráfico: 8228
  1. A329 (Reading)
  • Accidentes en 2023: 1184
  • Densidad de tráfico: 12747

Modelos de regresión aplicados

Se entrenaron varios modelos de regresión: Random Forest, Decision Tree, KNN, y Gradient Boosting, usando diferentes métodos de búsqueda de hiperparámetros.

Random Forest con Grid Search
def Grid_Search_Random_Forest(X_train, y_train):
    param_grid = { ... }
    rf = RandomForestRegressor()
    grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=3, scoring='neg_mean_squared_error')
    grid_search.fit(X_train, y_train)
    return grid_search.best_estimator_
Decision Tree con Random Search
def Random_Search_Decision_Tree(X_train, y_train):
    param_dist = { ... }  
    dt = DecisionTreeRegressor()
    random_search = RandomizedSearchCV(estimator=dt, param_distributions=param_dist, cv=3)
    random_search.fit(X_train, y_train)
    return random_search.best_estimator_
KNN utilizando Optuna
def Optuna_KNN(x_train, x_test, y_train, y_test):
    study = optuna.create_study(direction='minimize')
    study.optimize(lambda trial: objective(trial, x_train, x_test, y_train, y_test), n_trials=1000)
    return study.best_model

Gradient Boosting con Random Search

def Random_Search_Gradient_Boosting(X_train, y_train):
    param_dist = { ... }
    gb = GradientBoostingRegressor()
    random_search = RandomizedSearchCV(estimator=gb, param_distributions=param_dist, cv=3)
    random_search.fit(X_train, y_train)
    return random_search.best_estimator_

Predicciones, evaluación e interpretación

def train_and_predict(df):
    X = df["Local Authority Code", "road_name", "all_motor_vehicles", "accident_count_last_year"](/David-informatica/Pruebas/wiki/"Local-Authority-Code",-"road_name",-"all_motor_vehicles",-"accident_count_last_year")
    y = df["accident_count"]
    x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
    
    # Predicciones por modelo
    results = { ... }

[!NOTE]

  • Random Forest predice el número de accidentes con una precisión moderada.
  • Decision Tree mostró una predicción sólida.
  • KNN resultó ser el modelo menos efectivo.
  • Gradient Boosting ofreció los mejores resultados en términos de precisión.
Modelo Hackney (A10) Waltham Forest (A112) Hounslow (A315) Westminster (A40) Reading (A329)
Decision Tree 1528.78 946.25 1433.78 391.11 1106.38
KNN 1248.05 974.96 822.55 231.47 836.67
Random Forest 1496.00 1007.90 1344.15 284.68 818.69
Gradient Boosting 1528.78 970.84 1253.68 297.58 1005.65

Cálculo del error porcentual medio

def calculate_mape(real_values, predicted_values):
    mape = [ ... ]  # Cálculo del error porcentual
    return sum(mape) / len(mape)

Conclusiones preliminares

Este enfoque permite predecir con precisión razonable los accidentes en carreteras específicas. Esto puede ser útil para implementar medidas preventivas y reducir los accidentes en el futuro.

  • Mejor modelo: Decision Tree, con un error porcentual absoluto medio (MAPE) del 9.43%.
  • Recomendación: Ampliar los datos disponibles y usar un rango temporal más amplio para mejorar aún más la precisión de los modelos.