Beneficios de la búsqueda en cuadrícula
- Ajuste automatizado de hiperparámetros: La búsqueda de cuadrícula automatiza el ajuste de hiperparámetros, lo que permite la exploración sistemática sin prueba y error manual.
- Reproducibilidad: la búsqueda en cuadrícula garantiza la validez de la prueba al obtener de manera reproducible resultados reproducibles, lo que mejora la comunicación y la confiabilidad.
- Búsqueda exhaustiva: GS encuentra eficientemente hiperparámetros óptimos para un modelo mediante una búsqueda exhaustiva de combinaciones.
- Robustez: La búsqueda de cuadrícula es una técnica sólida que es resistente al ruido de los datos y reduce el sobreajuste.
- Fácil de usar: La búsqueda de cuadrícula es fácil de usar y comprender, lo que la convierte en un método viable para el ajuste de hiperparámetros.
- Comparaciones de modelos: la búsqueda en cuadrícula simplifica la comparación de modelos y la selección de métricas de evaluación.
Inconvenientes de la búsqueda en cuadrícula
- Costo computacional: La búsqueda de cuadrícula es computacionalmente costosa para ajustar una gran cantidad de hiperparámetros.
- Pérdida de tiempo: Los ajustes complejos de hiperparámetros requieren mucho tiempo.
- No siempre es necesario: Ahora siempre es necesario; la búsqueda aleatoria es la mejor alternativa.
Ejemplo: encontrar la mejor configuración del modelo para el sistema de admisión a la universidad
Veamos un ejemplo de búsqueda en cuadrícula para el ajuste de hiperparámetros dentro del marco de un sistema de admisión universitaria en línea. En este ejemplo, utilizamos scikit-learn y un sencillo clasificador de aumento de gradiente (GBC) para pronosticar la probabilidad de que un estudiante sea aceptado en una universidad en función de factores como puntos GPA, puntajes SAT, puntajes ACT y actividades extracurriculares. Hay múltiples opciones disponibles para la búsqueda de cuadrícula en lugar de GBC, incluidas Regresión logística (LR), SVM (Máquina de vectores de soporte), etc.
Genere datos aleatorios para el sistema de admisión en línea utilizando MLflow para búsqueda en cuadrícula
Se pueden utilizar Pandas y paquetes aleatorios de Python para crear un conjunto de datos ficticio para el sistema de admisiones. Con valores aleatorios para las columnas APP_NO, GPA, SAT Score, ACT Score, Actividades extracurriculares y Estado de admisión, este código genera un conjunto de datos de admisión sintéticos. La variable num_students controla cuántas filas hay en el conjunto de datos.
El estado de admisión se establece aleatoriamente en función de una tasa de aceptación del 70% y el módulo aleatorio se utiliza para producir valores aleatorios para varias columnas. Para fines de demostración, el siguiente código crea un conjunto de datos de admisión falso con valores aleatorios y se guarda en el archivo std_admission_dataset.csv:
Fragmento de código:
# Importar las bibliotecas Panda y Random
importar pandas como panda_obj
importar aleatorio como random_obj
# Establecer el número de registros que generará el conjunto de datos del estudiante
registros_estudiantes = 1000
# Crear listas para almacenar datos
std_application_numbers = [ 'APLICACIÓN-' + str(obj_aleatorio.randint( 1000 , 9999 )) para _ dentro del rango(students_records)]
std_gpa = [ronda(random_obj.uniform( 2.5 , 4.0 ), 2 ) para _ dentro del rango (registros_estudiantes)]
std_sat_scores = [random_obj.randint( 900 , 1600 ) para _ dentro del rango (registros_estudiantes)]
std_act_scores = [random_obj.randint( 20 , 36 ) para _ dentro del rango (registros_estudiantes)]
std_extra_curriculars = [random_obj.choice([ 'Sí' , 'No' ]) para _ dentro del rango(students_records)]
# Calcule el estado de admisión según la tasa de aceptación aleatoria
std_admission_status = [ 1 si random_obj.random() < 0.7 demás 0 para _ dentro del rango(students_records)]
# Crear un diccionario para contener los datos de los estudiantes.
datos_estándar = {
'APLICACIÓN_NO' : std_application_numbers,
'GPA' : std_gpa,
'Puntuación SAT' : std_sat_scores,
'ACT_Puntuación' : std_act_scores,
'Actividades extracurriculares' : std_extra_curriculares,
'Estado_admisión' : std_admission_status
}
# Crear un DataFrame DataFrame_Student desde el diccionario
DataFrame_Student = panda_obj.DataFrame(std_data)
# Guarde el DataFrame DataFrame_Student en un archivo CSV llamado std_admission_dataset.csv
DataFrame_Student.to_csv( 'std_admission_dataset.csv' , índice = Falso)
imprimir( '¡Los datos de los estudiantes se exportan correctamente a un archivo CSV!' )
Ejecución de código:
Use el comando Python para compilar el código, luego use el comando pip para instalar un módulo específico si encuentra un error en el módulo. Utilice el comando de instalación pip3 para instalar la biblioteca proporcionada si Python es la versión 3.X o superior.
Ejecución exitosa:
Captura de pantalla de datos de muestra:
Paso 1: importar las bibliotecas
- La biblioteca MLflow para el seguimiento de experimentos de aprendizaje automático
- La biblioteca Pandas para manejar el procesamiento y análisis de datos, así como el paquete mlflow.sklearn para integrar los modelos Scikit-Learn.
- La cuarta línea importa la biblioteca de 'advertencias' para suprimir los errores.
- La clase ParameterGrid para búsqueda de cuadrícula en el módulo sklearn.model_selection
- GridSearchCV y GradientBoostingClassifier de sklearn.model_selection y ensemble, respectivamente, para búsqueda de cuadrícula y modelos de clasificador de aumento de gradiente
- Las funciones precision_score y Classification_report del módulo sklearn.metrics para calcular la precisión del modelo y generar informes de clasificación.
- El código importa el módulo del sistema operativo y establece la variable de entorno GIT_PYTHON_REFRESH en silencio.
Fragmento de código:
# Paso I Importar bibliotecas requeridasimportar flujo ml
importar mlflow.sklearn
importar advertencias como advertencia
importar pandas como panda_obj
desde sklearn.model_selection importe train_test_split como tts, ParameterGrid como pg, GridSearchCV como gscv
importarnos
desde sklearn.ensemble importe GradientBoostingClassifier como GBC
desde sklearn.metrics importe exactitud_score como acs, clasificación_report como cr
os.entorno[ 'GIT_PYTHON_REFRESH' ] = 'tranquilo'
Paso 2: configurar el URI de seguimiento
El URI de seguimiento del servidor MLflow se configura mediante la función mlflow.set_tracking_uri(), lo que garantiza una máquina local en el puerto 5000 para experimentos y modelos.
mlflow.set_tracking_uri( 'http://localhost:5000' )Paso 3: cargar y preparar el conjunto de datos de admisión
Importe la biblioteca Pandas como panda_obj para manipulación y análisis de datos. La función read_csv() se aplica para cargar el conjunto de datos de admisión. La ruta al conjunto de datos es el único argumento que requiere la función read_csv(). La ruta al conjunto de datos en este caso es std_admission_dataset.csv. Al emplear la función read_csv(), el conjunto de datos se carga en un Pandas DataFrame.
El código elimina primero la columna Admission_Status del marco de datos std_admissions_data. Dado que esta columna contiene la variable de destino, no es necesario el procesamiento previo.
Luego, el código crea dos nuevas variables: 'F' y 't'. Las características están contenidas en la variable 'F', mientras que la variable objetivo está contenida en la variable 't'.
Luego, los datos se distribuyen en conjuntos de prueba y entrenamiento. Esto se logra usando la función tts() del paquete sklearn.model_selection. Las características, la variable objetivo, el tamaño de la prueba y el estado aleatorio son los cuatro argumentos que requiere la función tts(). El parámetro test_size estipula la parte de los datos que se utiliza con fines de prueba. Dado que el tamaño de la prueba en este caso está establecido en 0,2, se utilizará el 20% de los datos para la prueba.
La opción random_state especifica la semilla del generador de números aleatorios. Esto se hace para garantizar que los datos se separen al azar. Los conjuntos de entrenamiento y prueba ahora se almacenan en las variables F_training, F_testing, t_training y t_testing. Estos conjuntos se pueden utilizar para evaluar y entrenar los modelos de aprendizaje automático.
Fragmento de código:
# Paso 3: cargar el conjunto de datos de admisiónstd_admissions_data = panda_obj.read_csv( 'std_admission_dataset.csv' )
# Preprocesar los datos y dividirlos en características (F) y objetivo (t)
F = std_admissions_data.drop([ 'Estado_admisión' ], eje= 1 )
t = std_admissions_data[ 'Estado_admisión' ]
# Convertir variables categóricas a numéricas usando codificación one-hot
F = panda_obj.get_dummies(F)
F_entrenamiento, F_pruebas, t_entrenamiento, t_pruebas = tts(F, t, tamaño_prueba= 0.2 , estado_aleatorio= 42 )
Paso 4: establezca el nombre del experimento de MLflow
adm_experimento_nombre = 'Experimento_de_admisión_universitaria'mlflow.set_experiment(adm_experiment_name)
Paso 5: definir el clasificador de aumento de gradiente
El modelo clasificador de aumento de gradiente ahora está almacenado en la variable gbc_obj. El conjunto de datos de admisión se puede emplear para probar y entrenar este modelo. El valor del argumento random_state es 42. Esto garantiza que el modelo se entrene utilizando exactamente la misma semilla del generador de números aleatorios, lo que hace que los resultados sean repetibles.
gbc_obj = GBC(estado_aleatorio= 42 )Paso 6: definir la cuadrícula de hiperparámetros
El código crea inicialmente el diccionario param_grid. Los hiperparámetros que se ajustan mediante la búsqueda en la cuadrícula están contenidos en este diccionario. Tres claves componen el diccionario param_grid: n_estimators, learning_rate y max_ Depth. Estos son los hiperparámetros del modelo clasificador de aumento de gradiente. El número de árboles en el modelo se especifica mediante el hiperparámetro n_estimators. La tasa de aprendizaje del modelo se especifica mediante el hiperparámetro learning_rate. El hiperparámetro max_profundidad define la profundidad más alta posible de los árboles del modelo.
Fragmento de código:
param_grid = {'n_estimators' : [ 100 , 150 , 200 ],
'tasa de aprendizaje' : [ 0.01 , 0.1 , 0.2 ],
'máxima profundidad' : [ 4 , 5 , 6 ]
}
Paso 7: Realice la búsqueda de cuadrícula con MLflow Tracking
Luego, el código itera sobre el diccionario param_grid. Para cada conjunto de hiperparámetros del diccionario, el código hace lo siguiente:
- Inicia una nueva ejecución de MLflow
- Convierte los hiperparámetros en una lista si aún no lo son
- Registra los hiperparámetros en MLflow
- Entrena un modelo de búsqueda de cuadrícula con los hiperparámetros especificados.
- Obtiene el mejor modelo de la búsqueda de cuadrícula.
- Hace predicciones sobre los datos de prueba trabajando con el mejor modelo.
- Calcula la precisión del modelo.
- Imprime el informe de hiperparámetros, precisión y clasificación.
- Registra la precisión y el modelo en MLflow
Fragmento de código:
con warn.catch_warnings():advertencia.filtroadvertencias( 'ignorar' , categoría=Advertencia de usuario, módulo= '.*distutil.*' )
para parámetros en pg(param_grid):
con mlflow.start_run(run_name= 'Ejecución de estado_admisiones' ):
# Convertir valores individuales en listas
params = {clave: [valor] si no es instancia (valor, lista) de lo contrario valor para la clave, valor en params.items()}
mlflow.log_params(parámetros)
grid_search = gscv(gbc_obj, param_grid=params, cv= 5 )
grid_search.fit(F_entrenamiento, t_entrenamiento)
std_best_model = grid_search.best_estimator_
model_predictions = std_best_model.predict(F_testing)
model_accuracy_score = acs(t_testing, model_predictions)
imprimir( 'Hiperparámetros:' , parámetros)
imprimir( 'Exactitud:' , model_accuracy_score)
# Ignorar explícitamente la advertencia métrica indefinida
con warn.catch_warnings():
advertencia.filtroadvertencias( 'ignorar' , categoría=Advertencia)
imprimir( 'Informe de clasificación:' )
print(cr(t_testing, modelo_predicciones, división_cero= 1 ))
mlflow.log_metric( 'exactitud' , model_accuracy_score)
mlflow.sklearn.log_model(std_best_model, 'gb_classifier_model' )
Paso 8: ejecutar el programa usando Python
Aquí está el resultado en el servidor MLflow:
Conclusión
La herramienta de búsqueda de cuadrícula de MLflow automatiza los ajustes, el seguimiento de los resultados y la modificación de los hiperparámetros en los modelos de aprendizaje automático. Ayuda a determinar los hiperparámetros ideales y garantiza resultados confiables, pero puede resultar costoso desde el punto de vista computacional para experimentos extensos de hiperparámetros.