modelos de aprendizaje automatico python

Una guía para seleccionar modelos de aprendizaje automático en Python

Los científicos de datos deben tener una buena comprensión de cómo seleccionar las mejores funciones cuando se trata de la construcción de modelos. Esta guía le ayudará a empezar.

La creación de modelos de aprendizaje automático estables, precisos e interpretables es una tarea importante para las empresas de muchos sectores diferentes. Las predicciones del modelo de aprendizaje automático deben ser estables en el tiempo a medida que se actualizan los datos de entrenamiento subyacentes. Los cambios drásticos en los datos debido a eventos imprevistos pueden provocar un deterioro significativo en el rendimiento del modelo.

El ajuste de hiperparámetros del modelo puede realizar los cambios necesarios en los modelos de aprendizaje automático que dan cuenta de los cambios estadísticos en los datos a lo largo del tiempo. También es importante comprender las diversas formas de probar sus modelos según la cantidad de datos que tenga y, en consecuencia, la estabilidad de las predicciones de su modelo. Además, los modelos más útiles usan entradas o características que son procesables e interpretables.

Dado este requisito, los científicos de datos deben comprender bien cómo seleccionar las mejores funciones. Por supuesto, la experiencia en el dominio permite la mejor selección de funciones. Los métodos adicionales de selección de funciones, como la prueba de modelos, la selección de funciones y el ajuste de modelos, pueden ayudar a crear modelos precisos que se pueden usar para producir información procesable. La combinación de la experiencia en el dominio con un conocimiento profundo de la selección de funciones permite a las empresas aprovechar al máximo las predicciones del modelo de aprendizaje automático. 

Pruebas de modelos, selección de funciones y ajuste de hiperparámetros

  • La prueba de modelos es una parte clave de la construcción de modelos. Cuando se realiza correctamente, la prueba garantiza que su modelo sea estable y no esté sobreajustado. Los tres métodos más conocidos de prueba de modelo son la división aleatoria de prueba de tren, la validación cruzada de K-fold y la validación cruzada de dejar uno fuera.
  • La selección de características es otra parte importante de la creación de modelos, ya que afecta directamente el rendimiento y la interpretabilidad del modelo. El método más simple de selección de características es el manual, idealmente guiado por la experiencia en el dominio. El científico de datos elige diferentes conjuntos de características hasta que está satisfecho con el rendimiento en el conjunto de validación. Por lo general, tiene un conjunto de prueba de reserva, separado del conjunto de validación, que prueba una vez al final del desarrollo del modelo, para evitar el sobreajuste. Existen métodos adicionales, como SelectKBest, que automatizan el proceso.
  • El ajuste de hiperparámetros es la última parte importante de la construcción de modelos. Aunque la mayoría de los paquetes de aprendizaje automático vienen con parámetros predeterminados que generalmente brindan un rendimiento decente, generalmente se necesitan ajustes adicionales para construir modelos altamente precisos. Este proceso se puede realizar manualmente seleccionando diferentes valores de parámetros y probando el modelo mediante la validación en la muestra de los datos de entrenamiento hasta que esté satisfecho con el rendimiento. 

La prueba de modelos es una parte clave de la construcción de modelos. Cuando se realiza correctamente, la prueba garantiza que su modelo sea estable y no esté sobreajustado. Los tres métodos más conocidos de prueba de modelo son la división aleatoria de prueba de tren, la validación cruzada de K-fold y la validación cruzada de dejar uno fuera.

La división aleatoria de prueba de tren es el método más simple: se toma una muestra aleatoria de los datos para formar un conjunto de datos de prueba, mientras que los datos restantes se usan para el entrenamiento. La validación cruzada de K-fold divide aleatoriamente los datos en K partes (llamadas pliegues) donde un pliegue se usa para probar y los pliegues restantes se usan para probar. El método consiste en iterar sobre cada pliegue hasta que todos los datos se hayan utilizado para entrenar y probar el modelo. A continuación, se promedia el rendimiento entre los pliegues. Por último, dejar uno fuera es similar a los pliegues en K, pero utiliza un solo punto de datos para la prueba y los datos restantes para el entrenamiento. Itera sobre cada punto de datos hasta que todos los datos se hayan utilizado para pruebas y entrenamiento. Según el tamaño de sus datos y cuánto le gustaría minimizar el sesgo, puede preferir un método u otro.

La selección de características es otra parte importante de la creación de modelos, ya que afecta directamente el rendimiento y la interpretabilidad del modelo. El método más simple de selección de características es el manual, idealmente guiado por la experiencia en el dominio. El científico de datos elige diferentes conjuntos de características hasta que está satisfecho con el rendimiento en el conjunto de validación. Por lo general, tiene un conjunto de prueba de reserva, separado del conjunto de validación, que prueba una vez al final del desarrollo del modelo, para evitar el sobreajuste. Existen métodos adicionales, como SelectKBest, que automatizan el proceso. Estos son particularmente útiles si sus datos tienen muchas columnas donde la selección manual de funciones puede convertirse en una tarea engorrosa. Filtrar el tamaño del conjunto de entrada puede ayudar a que la predicción del modelo sea más fácil de interpretar y, posteriormente, hacer que las predicciones sean más procesables.

El ajuste de hiperparámetros es la última parte importante de la construcción de modelos. Aunque la mayoría de los paquetes de aprendizaje automático vienen con parámetros predeterminados que generalmente brindan un rendimiento decente, generalmente se necesitan ajustes adicionales para construir modelos altamente precisos. Este proceso se puede realizar manualmente seleccionando diferentes valores de parámetros y probando el modelo mediante la validación en la muestra de los datos de entrenamiento hasta que esté satisfecho con el rendimiento. Los paquetes específicos de Python también pueden permitirle buscar en el espacio de hiperparámetros la mayoría de los algoritmos y seleccionar los parámetros que ofrecen el mejor rendimiento. 

Discutiremos cómo aplicar estos métodos para probar, ajustar y seleccionar un modelo de aprendizaje automático para la tarea de clasificación. Específicamente, consideraremos la tarea de predecir la rotación de clientes, donde la rotación se define como el evento de que un cliente abandone una empresa. Usaremos los datos ficticios de abandono de empresas de telecomunicaciones disponibles públicamente . 

Relacionado: Una guía completa para la visualización de datos de Python con Matplotlib y Seaborn

Lectura y visualización de datos de telecomunicaciones

Para comenzar, importemos la biblioteca de Pandas y leamos los datos de telecomunicaciones en un marco de datos de Pandas:

import pandas as pd 

df = pd.read_csv(“telco.csv”)

print(df.head())
selección de modelo de aprendizaje automático
Imagen: Captura de pantalla del autor

Métodos para dividir datos para entrenamiento y pruebas

División aleatoria de prueba de tren 

El primer método de prueba que discutiremos es la división aleatoria de prueba de tren. Construyamos un modelo simple que tome la permanencia del cliente y los cargos mensuales como entradas y prediga si el cliente abandonará o no. Aquí, nuestras entradas serán la tenencia y los cargos mensuales y nuestra salida será la rotación. Primero, vamos a convertir los valores de abandono en números enteros binarios legibles por máquina usando el método np.where() del paquete numpy:

import numpy as np 

df['Churn_binary'] = np.where(df['Churn'] == 'Yes', 1, 0)

Ahora, importemos el método train_test_split desde el módulo de selección de modelo en Scikit-learn:

from sklearn.model_selection  import train_test_split

Como se explica en la documentación, el método train_test_split divide los datos en subconjuntos de prueba y entrenamiento aleatorios. Para realizar la división, primero definimos nuestra entrada y salida en términos de variables llamadas X e y, respectivamente:

X = df[['tenure', 'MonthlyCharges']]

y = df['churn']

A continuación, pasamos estas variables al método train_test_split, que devuelve subconjuntos aleatorios para la entrada de entrenamiento y la entrada de prueba, así como para la salida de entrenamiento y la salida de prueba. En Python, cuando un método o una función devuelve varios valores, normalmente son tuplas. Tendremos que desempaquetar las tuplas de retorno y almacenar los valores correctos en nuestras variables de entrenamiento y prueba:

X_train, X_test, y_train, y_test = train_test_split(X, y)

También podemos especificar un parámetro llamado random_state. Este es un parámetro de barajado que controla cómo se dividen aleatoriamente los datos. Si le damos un valor entero, nos aseguramos de reproducir la misma división en cada ejecución:

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state =42)

Entonces es sencillo entrenar y probar un modelo usando subconjuntos de entrenamiento y prueba. Por ejemplo, para entrenar un bosque aleatorio:

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier()

model.fit(X_train, y_train)

y_pred = model.predict(X_test)

Luego puede usar y_test e y_pred para evaluar el rendimiento de su modelo. Recuerde considerar si tiene o no datos dependientes del tiempo. Si este es el caso, en lugar de una división aleatoria, divida sus datos a lo largo de una fecha. Si usa una división aleatoria, incluirá datos futuros en su conjunto de entrenamiento y sus predicciones estarán sesgadas. 

En la práctica, una división de prueba de tren aleatoria es útil para generar un conjunto de validación de reserva que se usa para probar una vez que se ha completado la selección de características y el ajuste del modelo. Esto asegura que su modelo no esté sobreajustado y reduce la posibilidad de sesgar mal su modelo. 

Validación cruzada de pliegues en K 

La validación cruzada de K-fold es el proceso de dividir los datos en partes de un número entero (K) y usar una parte para probar y el resto para entrenar. Este proceso se realiza de forma iterativa hasta que todos los datos se hayan utilizado para el entrenamiento y las pruebas. La documentación para el método de validación cruzada se puede encontrar aquí

Para implementar los pliegues en K, importamos KFold desde el módulo de selección de modelos en Scikit-learn:

from sklearn.model_selection import KFold

folds = KFold(n_splits=5)

folds.get_n_splits(X)

for train_index, test_index in folds.split(X):

    X_train, X_test, y_train, y_test = X.iloc[train_index], X.iloc[test_index], y.iloc[train_index], y.iloc[test_index]

    model = RandomForestClassifier()

    model.fit(X_train, y_train)

    y_pred = model.predict(X_test)

    fold+=1

    print(f"Accurac in fold {fold}:", accuracy_score(y_pred, y_test))
selección de modelo de aprendizaje automático
Imagen: Captura de pantalla del autor.

Dentro del bucle for, puede entrenar y probar su modelo en diferentes pliegues. Aquí, solo usamos cinco pliegues, pero puede cambiar el parámetro n_splits en el método KFold para que sea el número que desee. Cuantos más pliegues use, menos sesgo habrá en la salida de su modelo.

Este proceso le permite analizar la estabilidad del rendimiento de su modelo a través de métricas como la varianza. También se suele utilizar para tareas como el ajuste de modelos y la selección de características, que trataremos en breve.

Idealmente, desea el modelo más preciso con la variación más baja en el rendimiento. La baja variación de rendimiento significa que el modelo es más estable y, en consecuencia, más confiable.  

Dejar uno fuera Validación cruzada

Dejar uno fuera es similar a K-fold, pero en lugar de usar un subconjunto muestreado aleatoriamente para entrenamiento y prueba, se usa un solo punto de datos para probar mientras que el resto se usa para entrenamiento. Este proceso también se realiza de forma iterativa hasta que todos los datos se hayan utilizado para el entrenamiento y las pruebas:

loo = LeaveOneOut()

for train_index, test_index in loo.split(X):

    X_train, X_test, y_train, y_test = X.iloc[train_index], X.iloc[test_index], y.iloc[train_index], y.iloc[test_index]

Este método se usa típicamente para conjuntos de datos más pequeños. En mi experiencia, he encontrado que esto es particularmente útil para pequeños conjuntos de datos de desequilibrio. Tenga en cuenta que, dado que está entrenando su modelo n veces, donde n es el tamaño de los datos, este enfoque puede ser computacionalmente intensivo para grandes conjuntos de datos. 

Métodos de selección de características para la construcción de modelos

Además de la selección manual de funciones, que normalmente se realiza mediante un análisis exploratorio de datos y el uso de experiencia en el dominio, puede usar algunos paquetes de Python para la selección de funciones. Aquí, discutiremos el método SelectKBest. La documentación de SelectKBest se puede encontrar aquí . Primero, importemos los paquetes necesarios:

from sklearn.feature_selection import SelectKBest, f_classif

import matplotlib.pyplot as plt

Seleccionaremos entre cargos mensuales, tenencia y cargos totales. Primero, necesitamos limpiar la columna de cargos totales:

df['TotalCharges'] = df['TotalCharges'].replace(' ', np.nan)

df['TotalCharges'].fillna(0, inplace = True)

df['TotalCharges']  = df['TotalCharges'].astype(float)

Deberíamos seleccionar características en un conjunto de entrenamiento, para no sesgar nuestro modelo. Redefinamos nuestra entrada y salida:

X = df[['tenure', 'MonthlyCharges', 'TotalCharges']]

y = df['Churn']

Ahora, realicemos nuestra división de prueba de tren aleatoria:

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state= 42)

A continuación, definamos nuestro objeto selector. Pasaremos nuestras características y la salida:

numerical_predictors = ["MonthlyCharges", "TotalCharges", "tenure" ]

numerical_selector = SelectKBest(f_classif, k=3)

numerical_selector.fit(X_train[numerical_predictors], y_train)

Ahora, podemos trazar las puntuaciones de nuestras funciones. Generamos puntajes para cada característica tomando un logaritmo negativo de los valores p para cada característica:

num_scores = -np.log10(numerical_selector.pvalues_)




plt.bar(range(len(numerical_predictors)), num_scores)

plt.xticks(range(len(numerical_predictors)), numerical_predictors, rotation='vertical')

plt.show()
selección de modelo de aprendizaje automático
Imagen: Captura de pantalla del autor

Podemos ver que la tenencia tiene la puntuación más alta, lo cual tiene sentido. Intuitivamente, los clientes que han estado en la empresa durante más tiempo tienen menos probabilidades de abandonar. Quiero enfatizar que, en la práctica, la selección de funciones debe realizarse en datos de entrenamiento. Además, para mejorar la confiabilidad de las funciones seleccionadas, puede ejecutar una validación cruzada de K-fold y tomar el puntaje promedio para cada función y usar los resultados para la selección de funciones. 

Relacionado: Cómo agregar listas en Python

Ajuste de hiperparámetros 

Además de las pruebas de modelos y la selección de funciones, el ajuste de hiperparámetros del modelo es otra parte muy importante de la creación de modelos. La idea es buscar los parámetros del modelo que dan el mejor rendimiento.

El método RandomizedSearchCV de Scikit-learn le permite realizar una búsqueda aleatoria de parámetros para un estimador. La documentación para RandomizedSearchCV se puede encontrar aquí. Aquí, realizaremos una búsqueda aleatoria de parámetros de bosque aleatorios. Comenzamos definiendo una cuadrícula de valores de parámetros de bosque aleatorios. Primero, especifiquemos una lista de la cantidad de árboles que usaremos en el bosque aleatorio:

n_estimators = [50, 100, 200]

Luego, especificamos la cantidad de características a considerar en cada división

max_features = ['auto', 'sqrt', 'log2']

También especificamos el número máximo de niveles en un árbol:

max_depth = [int(x) for x in np.linspace(10, 30, num = 5)]

max_depth.append(None)

El número mínimo de muestras requeridas para dividir un nodo:

min_samples_split = [2, 5, 10]

El número mínimo de muestras requeridas en cada nodo hoja:

min_samples_leaf = [1, 2, 4]

Y, por último, si usaremos o no muestreo bootstrap:

bootstrap = [True, False]

Ahora podemos especificar un diccionario que será nuestra cuadrícula de parámetros:

random_grid = {'n_estimators': n_estimators,

               'max_features': max_features,

               'max_depth': max_depth,

               'min_samples_split': min_samples_split,

               'min_samples_leaf': min_samples_leaf,

               'bootstrap': bootstrap}

Definamos también un objeto de modelo de bosque aleatorio:

model = RandomForestClassifier()

De manera similar a la selección de características, el ajuste de hiperparámetros del modelo debe realizarse en los datos de entrenamiento. Para continuar, importemos RandomizedSearchCV desde Scikit-learn:

from sklearn.model_selection import RandomizedSearchCV

A continuación, definimos un objeto RandomizedSearchCV. En el objeto, pasamos nuestro modelo de bosque aleatorio, la cuadrícula aleatoria y el número de iteraciones para cada búsqueda aleatoria.

Observe que hay un parámetro llamado cv, que es para validación cruzada. Usamos este parámetro para definir el número de pliegues que se usarán para la validación, tal como lo hicimos para los pliegues K. Nuevamente, nos gustaría encontrar el conjunto de parámetros aleatorios del bosque que brindan el mejor rendimiento del modelo y RandomizedSearchCV calcula el rendimiento del modelo mediante la validación cruzada.

El parámetro verbose muestra el resultado de cada iteración. Dado que tenemos tres pliegues y tres iteraciones, deberíamos ver el resultado de nueve ejecuciones de prueba:

rf_random = RandomizedSearchCV(estimator = model, param_distributions 

= random_grid, n_iter = 3, cv =3, verbose=2, random_state=42)

Después de definir el objeto RandomizedSearchCV, podemos ajustarlo a nuestros datos de entrenamiento:

rf_random.fit(X_train, y_train)
selección de modelo de aprendizaje automático
Imagen: Captura de pantalla del autor.

Al realizar el ajuste, podemos generar los parámetros que brindan el mejor rendimiento:

parameters = rf_random.best_params_

print(parameters)
selección de modelo de aprendizaje automático
Imagen: Captura de pantalla del autor.

Puede aumentar el número de iteraciones para buscar y probar más parámetros. Cuanto mayor sea el número de iteraciones, más probable es que encuentre un modelo de mejor rendimiento del conjunto de hiperparámetros. Obviamente, cuantos más parámetros busque y pruebe, más tiempo llevará el cálculo.

Tenga en cuenta que en una máquina o computadora portátil típica, este proceso puede volverse intratable para conjuntos de datos muy grandes y es posible que deba usar herramientas informáticas distribuidas, como bloques de datos. Hay otras herramientas de ajuste de hiperparámetros que también es útil conocer. Por ejemplo, GridSearchCV realiza una búsqueda exhaustiva en toda la grilla. Esto significa que se prueban todas las combinaciones posibles de parámetros. Este método es una buena opción si tiene suficiente poder de cómputo. 

Comience ahora con la construcción de modelos

Tener una buena comprensión de qué herramientas están disponibles para construir modelos robustos de aprendizaje automático es una habilidad que todo científico de datos debería tener. Ser capaz de preparar datos para el entrenamiento y las pruebas, seleccionar características y ajustar los parámetros del modelo es necesario para construir modelos estables cuyas predicciones sean confiables. Además, tener estas herramientas en su bolsillo trasero puede ahorrar una cantidad significativa de horas de trabajo, ya que estos métodos automatizan lo que de otro modo se haría manualmente. Estas técnicas, cuando se utilizan correctamente, pueden reducir el riesgo de deterioro del modelo que puede costar a las empresas millones de dólares en el futuro. 

Comprender cómo configurar correctamente las pruebas de modelos también es vital para asegurarse de que no ajuste demasiado sus modelos. Por ejemplo, si no divide correctamente sus datos para el entrenamiento y las pruebas, las pruebas de su modelo pueden darle una falsa sensación de precisión del modelo, lo que puede resultar muy costoso para una empresa. En el caso de abandono, si su modelo es engañosamente preciso, puede dirigirse incorrectamente a clientes con anuncios y descuentos que en realidad no es probable que abandonen. Esto puede resultar en millones perdidos en dólares publicitarios.

Para reducir el riesgo de sobreajustar y sobrestimar el rendimiento del modelo, es crucial tener un conjunto de pruebas de retención (como el que generamos a partir de la división aleatoria de pruebas de trenes) en el que realizamos una sola prueba después del ajuste del modelo y la selección de funciones en el entrenamiento. datos. Además, los métodos de validación cruzada nos brindan una buena comprensión de cuán estables son nuestros modelos tanto en términos de ajuste del modelo como de selección de funciones. La validación cruzada nos permite ver cómo varía el rendimiento en múltiples pruebas. Idealmente, nos gustaría seleccionar las características y los parámetros del modelo que brindan el mejor rendimiento con la variación más baja en el rendimiento del modelo. La baja variación en el rendimiento del modelo significa que las predicciones del modelo son más confiables y de menor riesgo. 

La selección de funciones también es muy importante, ya que puede ayudar a filtrar una cantidad potencialmente grande de entradas. No importa qué tan preciso sea un modelo, será muy difícil interpretar cómo los valores de 1,000 características, por ejemplo, determinan si un cliente abandonará o no. La selección de características, junto con la experiencia en el dominio, puede ayudar a los científicos de datos a seleccionar e interpretar las características más importantes para predecir un resultado.

El ajuste de hiperparámetros también es un paso esencial necesario para lograr un rendimiento óptimo del modelo. Si bien los valores de parámetros predeterminados proporcionados por los paquetes de aprendizaje automático de Scikit-learn generalmente brindan un rendimiento decente, se requiere un ajuste del modelo para lograr modelos muy precisos. Por ejemplo, con el churn, cuanto más precisamente pueda dirigirse a los clientes que probablemente abandonarán una empresa, menos dinero se perderá por clientes mal orientados y más aumentará el valor de por vida del cliente de los clientes con alto riesgo de irse. 

Tener una gran familiaridad con las herramientas disponibles para configurar pruebas de modelos, seleccionar funciones y realizar ajustes de modelos es un conjunto de habilidades invaluable para los científicos de datos en cualquier industria. Tener este conocimiento puede ayudar a los científicos de datos a construir modelos robustos y confiables que pueden agregar un valor significativo a una empresa, lo que resulta en ahorros de recursos en términos de dinero y mano de obra, así como también aumenta las ganancias de la empresa. El código de esta publicación está disponible en GitHub