IN-P3/docs/Summary.org

#+TITLE: Práctica 3
#+SUBTITLE: Inteligencia de Negocio
#+AUTHOR: Amin Kasrou Aouam
#+DATE: 2021-01-12
#+PANDOC_OPTIONS: template:~/.pandoc/templates/eisvogel.latex
#+PANDOC_OPTIONS: listings:t
#+PANDOC_OPTIONS: toc:t
#+PANDOC_METADATA: lang=es
#+PANDOC_METADATA: titlepage:t
#+PANDOC_METADATA: listings-no-page-break:t
#+PANDOC_METADATA: toc-own-page:t
#+PANDOC_METADATA: table-use-row-colors:t
#+PANDOC_METADATA: logo:/home/coolneng/Photos/Logos/UGR.png
* Práctica 3
** Introducción

En esta práctica, resolveremos un problema de clasificación multiclase, en concreto, trataremos de predecir la categoría de precio de una serie de coches

** Preprocesamiento de datos
*** Valores nulos

Nuestro /dataset/ contiene bastantes valores nulos, optamos por estrategias diferentes según las columnas:

- Eliminación: tipo marchas, descuento, ciudad
- Imputación: asientos, motor cc, potencia

El criterio que seleccionamos es el número de instancias nulas, en el caso de que sean muchas optamos por imputar, para mantener un número adecuado de datos.

La implementación se encuentra en la siguiente función:

#+begin_src python
def process_null_values(df_list):
    drop_columns = ["tipo_marchas", "descuento", "ciudad"]
    fill_columns = ["asientos", "motor_cc", "potencia"]
    for df in df_list:
        for column in fill_columns:
            if column == "asientos":
                df[column].fillna(value=df[column].median(), inplace=True)
            else:
                df[column].fillna(
                    value=df[column].str.extract("(\d+)").mean(), inplace=True
                )
        df.drop(columns=drop_columns, inplace=True)
        df.dropna(inplace=True)
    return df_list
#+end_src

*** Valores no numéricos

Ciertas columnas contienen valores alfanúmericos, aunque se nos proporcionan distintos archivos CSV para realizar un /mapping/. En este caso, utilizamos un *LabelEncoder*, y como entrada le damos el CSV correspondiente.

Es primordial usar el mismo /LabelEncoder/ para los datos de entrenamiento como de test. La implementación se encuentra en la siguiente función:

#+begin_src python
def encode_columns(df_list):
    label_encoder = LabelEncoder()
    files = [
        "ao",
        "asientos",
        "combustible",
        "consumo",
        "kilometros",
        "mano",
        "motor_cc",
        "nombre",
        "potencia",
    ]
    for data in files:
        for df in df_list:
            label = label_encoder.fit(read_csv("data/" + data + ".csv", squeeze=True))
            if data == "ao":
                df["año"] = label.transform(df["año"])
            else:
                df[data] = label.transform(df[data])
    return df_list
#+end_src

*** Balanceo de clases

Observamos que la mayoría de coches son de la categoría de precio 3, lo cual no es idóneo para entrenar un modelo de inteligencia artificial.

Debemos realizar un balanceo de las clases, en este caso optamos por usar el modelo *SMOTEEEN*, que combina un /over-sampling/ mediante *SMOTE* y una limpieza gracias a /Edited Nearest Neighbours (ENN)/.

La implementación se encuentra en esta función:

#+begin_src python
def balance_training_data(df):
    smote_enn = SMOTEENN(random_state=42)
    data, target = split_data_target(df=df, dataset="data")
    balanced_data, balanced_target = smote_enn.fit_resample(data, target)
    balanced_data_df = DataFrame(
        balanced_data, columns=df.columns.difference(["precio_cat"])
    )
    balanced_target_df = DataFrame(balanced_target, columns=["precio_cat"])
    return balanced_data_df, balanced_target_df
#+end_src

** Elección de algoritmo

Elegimos el algoritmo *GradientBoostingClassifier*, que pertenece a los algoritmos de /ensemble/. Éstos combinan las predicciones de varios clasificadores, con el objetivo de mejorar la generalización y la robustez de las predicciones.

En particular, pertenece a la familia de /boosting methods/, cuya característica es que los clasificadores se crean de forma secuencial, y uno de ellos trata de reducir el sesgo de los demás.

** Resultados obtenidos

Al ejecutar el programa en local obtenemos los siguientes resultados:

#+CAPTION: Resultados de ejecución
[[./assets/F1.png]]

Desafortunadamente, en la plataforma Kaggle obtenemos unos resultados pésimos:

#+CAPTION: Resultados de Kaggle
[[./assets/F2.png]]

** Análisis de resultados

Debido a la discrepancia entre los resultados de la ejecución en local, y de la plataforma Kaggle, intuimos que debe de haber un problema en el preprocesamiento de datos.

También es posible que el modelo no sea óptimo para la tarea, aunque no justificaría un rendimiento tan bajo, puede contribuir a ello.