Avantatges de la cerca de graella
- Ajust automàtic d'hiperparàmetres: La cerca de quadrícula automatitza l'ajustament dels hiperparàmetres que permet l'exploració sistemàtica sense prova i error manual.
- Reproductibilitat: la cerca en quadrícula garanteix la validesa de les proves obtenint de manera reproductible els resultats reproduïbles que milloren la comunicació i la fiabilitat.
- Cerca exhaustiva: GS troba de manera eficient els hiperparàmetres òptims per a un model mitjançant la cerca exhaustiva de combinacions.
- Robustesa: La cerca de quadrícula és una tècnica robusta que és resistent al soroll de dades que redueix el sobreajustament.
- Fàcil d'utilitzar: La cerca de quadrícula és senzilla d'utilitzar i entendre, cosa que la converteix en un mètode viable per a l'ajustament d'hiperparàmetres.
- Comparacions de models: la cerca en quadrícula simplifica la comparació de models i la selecció de mètriques d'avaluació.
Inconvenients de la cerca de graella
- Cost computacional: La cerca de quadrícula és costosa computacionalment per ajustar un gran nombre d'hiperparàmetres.
- que consumeix temps: Els ajustos d'hiperparàmetres complexos requereixen molt de temps.
- No sempre és necessari: Ara sempre es requereix; la cerca aleatòria és la millor alternativa.
Exemple: trobar la millor configuració del model per al sistema d'admissió a la universitat
Vegem un exemple de cerca de quadrícula per a l'ajustament d'hiperparàmetres dins del marc d'un sistema d'admissió a la universitat en línia. En aquest exemple, utilitzem el scikit-learn i un classificador senzill del Gradient Boosting Classifier (GBC) per predir la probabilitat d'un estudiant de ser acceptat a una universitat en funció de factors com ara punts GPA, puntuacions SAT, puntuacions ACT i activitats extracurriculars. Hi ha diverses opcions disponibles per a la cerca de quadrícula en lloc de GBC, inclosa la regressió logística (LR), SVM (màquina vectorial de suport), etc.
Genereu dades aleatòries per al sistema d'admissió en línia mitjançant MLflow per a la cerca de graella
Els Pandas i els paquets aleatoris de Python es poden utilitzar per crear un conjunt de dades fictici per al sistema d'admissions. Amb valors aleatoris per a les columnes APP_NO, GPA, SAT Score, ACT Score, Activitats extracurriculars i Admission Status, aquest codi genera un conjunt de dades d'admissió sintètic. La variable num_students controla quantes files hi ha al conjunt de dades.
L'estat d'admissió s'estableix aleatòriament en funció d'una taxa d'acceptació del 70% i el mòdul aleatori s'utilitza per produir valors aleatoris per a diverses columnes. Amb finalitats de demostració, la peça de codi següent crea un conjunt de dades d'admissió fals amb valors aleatoris i es desa al fitxer std_admission_dataset.csv:
Fragment de codi:
# Importa les biblioteques Panda i Random
importar pandes com a panda_obj
importar aleatoriament com a random_obj
# Estableix el nombre de registres per generar el conjunt de dades de l'estudiant
estudiants_records = 1000
# Creeu llistes per emmagatzemar dades
nombres_aplicació_estd = [ 'APP-' + str(random_obj.randint( 1000 , 9999 )) per a _ a l'interval(registres_estudiants)]
std_gpa = [round(random_obj.uniform( 2.5 , 4.0 ), 2 ) per _ dins l'interval(registres_estudiants)]
std_sat_scores = [random_obj.randint( 900 , 1600 ) per _ dins l'interval(registres_estudiants)]
std_act_scores = [random_obj.randint( 20 , 36 ) per _ dins l'interval(registres_estudiants)]
std_extra_curriculars = [random_obj.choice([ 'Sí' , 'No' ]) per a _ a l'interval(registres_estudiants)]
# Calcula l'estat d'admissió en funció de la taxa d'acceptació aleatòria
std_admission_status = [ 1 if random_obj.random() < 0.7 altra cosa 0 per a _ dins l'interval(registres_estudiants)]
# Creeu un diccionari per contenir les dades dels estudiants
std_data = {
'APPLICATION_NO' : números_d'aplicació_estd,
'GPA' : std_gpa,
'SAT_Score' : std_sat_scores,
'ACT_Score' : std_act_scores,
'Activitats extraescolars' : std_extra_curriculars,
'Estat_admissió' : std_admission_status
}
# Creeu un DataFrame DataFrame_Student des del diccionari
DataFrame_Student = panda_obj.DataFrame(std_data)
# Deseu el DataFrame DataFrame_Student en un fitxer CSV anomenat std_admission_dataset.csv
DataFrame_Student.to_csv( 'std_admission_dataset.csv' , índex=fals)
imprimir( 'Les dades de l'estudiant exporten correctament al fitxer CSV!' )
Execució del codi:
Utilitzeu l'ordre Python per compilar el codi i, a continuació, utilitzeu l'ordre pip per instal·lar un mòdul específic si trobeu un error de mòdul. Utilitzeu l'ordre d'instal·lació pip3 per instal·lar la biblioteca donada si Python és la versió 3.X o superior.
Execució correcta:
Captura de pantalla de dades de mostra:
Pas 1: importa les biblioteques
- La biblioteca MLflow per al seguiment d'experiments d'aprenentatge automàtic
- La biblioteca Pandas per gestionar el processament i anàlisi de dades, així com el paquet mlflow.sklearn per integrar els models Scikit-Learn
- La quarta línia importa la biblioteca 'advertències' per suprimir els errors
- La classe ParameterGrid per a la cerca de quadrícula al mòdul sklearn.model_selection
- GridSearchCV i GradientBoostingClassifier de sklearn.model_selection i ensemble, respectivament, per als models de classificador de cerca de quadrícula i d'augment del gradient
- Les funcions accuracy_score i classification_report del mòdul sklearn.metrics per calcular la precisió del model i generar informes de classificació
- El codi importa el mòdul del sistema operatiu i estableix la variable d'entorn GIT_PYTHON_REFRESH en silenci.
Fragment de codi:
# Pas I Importa les biblioteques necessàriesimportar mlflow
importar mlflow.sklearn
importa els avisos com a advertència
importar pandes com a panda_obj
des de sklearn.model_selection importar train_test_split com a tts, ParameterGrid com a pg, GridSearchCV com a gscv
importa'ns
des de sklearn.ensemble importa GradientBoostingClassifier com a GBC
des de sklearn.metrics importar accuracy_score com a acs, classification_report com a cr
os.environ[ 'GIT_PYTHON_REFRESH' ] = 'tranquil'
Pas 2: configureu l'URI de seguiment
L'URI de seguiment del servidor MLflow s'estableix mitjançant la funció mlflow.set_tracking_uri(), que garanteix una màquina local al port 5000 per a experiments i models.
mlflow.set_tracking_uri( 'http://localhost:5000' )Pas 3: Carregueu i prepareu el conjunt de dades d'admissió
Importeu la biblioteca Pandas com a panda_obj per a la manipulació i anàlisi de dades. La funció read_csv() s'aplica per carregar el conjunt de dades d'admissió. El camí al conjunt de dades és l'únic argument que requereix la funció read_csv(). El camí al conjunt de dades en aquesta instància és std_admission_dataset.csv. Mitjançant l'ús de la funció read_csv(), el conjunt de dades es carrega en un Pandas DataFrame.
La columna Admission_Status del DataFrame std_admissions_data s'elimina primer pel codi. Com que aquesta columna conté la variable objectiu, no és necessari el preprocessament.
Aleshores, el codi crea dues variables noves: 'F' i 't'. Les característiques es troben a la variable 'F', mentre que la variable objectiu està continguda a la variable 't'.
A continuació, les dades es distribueixen en conjunts de proves i formació. Això s'aconsegueix mitjançant la funció tts() del paquet sklearn.model_selection. Les característiques, la variable objectiu, la mida de la prova i l'estat aleatori són els quatre arguments que requereix la funció tts(). El paràmetre test_size estipula la part de les dades que s'utilitzen per a la prova. Com que la mida de la prova en aquest cas s'estableix en 0,2, el 20% de les dades s'utilitzaran per a la prova.
L'opció random_state especifica la llavor del generador de números aleatoris. Això es fa per garantir que les dades es separen a l'atzar. Els conjunts d'entrenament i proves s'emmagatzemen ara a les variables F_training, F_testing, t_training i t_testing. Aquests conjunts es poden utilitzar per avaluar i entrenar els models d'aprenentatge automàtic.
Fragment de codi:
# Pas-3: Carregueu el conjunt de dades d'admissióstd_admissions_data = panda_obj.read_csv( 'std_admission_dataset.csv' )
# Preprocessar les dades i dividir-les en funcions (F) i objectiu (t)
F = std_admissions_data.drop([ 'Estat_admissió' ], eix= 1 )
t = dades_estd_admissions[ 'Estat_admissió' ]
# Converteix variables categòriques en numèriques mitjançant una codificació única
F = panda_obj.get_dummies(F)
F_training, F_testing, t_training, t_test = tts(F, t, test_size= 0.2 , estat_atzar= 42 )
Pas 4: definiu el nom de l'experiment MLflow
nom_experiment_adm = 'Experiment_admissió_universitat'mlflow.set_experiment(adm_experiment_name)
Pas 5: definiu el classificador d'augment del gradient
El model de classificador per augmentar el gradient ara s'emmagatzema a la variable gbc_obj. El conjunt de dades d'admissió es pot utilitzar per provar i entrenar aquest model. El valor de l'argument random_state és 42. Això garanteix que el model s'entrena utilitzant exactament la mateixa llavor del generador de nombres aleatoris que fa que els resultats siguin repetibles.
gbc_obj = GBC(estat_atzar= 42 )Pas 6: definiu la graella d'hiperparàmetres
El codi crea inicialment el diccionari param_grid. Els hiperparàmetres que s'ajusten mitjançant la cerca de graella es troben en aquest diccionari. Tres claus conformen el diccionari param_grid: n_estimators, learning_rate i max_depth. Aquests són els hiperparàmetres del model de classificador que augmenta el gradient. El nombre d'arbres del model l'especifica l'hiperparàmetre n_estimators. La taxa d'aprenentatge del model s'especifica mitjançant l'hiperparàmetre learning_rate. L'hiperparàmetre max_depth defineix la profunditat més alta possible dels arbres del model.
Fragment de codi:
param_grid = {'n_estimators' : [ 100 , 150 , 200 ],
'taxa_d'aprenentatge' : [ 0.01 , 0.1 , 0.2 ],
'max_depth' : [ 4 , 5 , 6 ]
}
Pas 7: Realitzeu la cerca de quadrícula amb el seguiment de MLflow
A continuació, el codi itera sobre el diccionari param_grid. Per a cada conjunt d'hiperparàmetres del diccionari, el codi fa el següent:
- Inicia una nova execució de MLflow
- Converteix els hiperparàmetres en una llista si encara no són una llista
- Registra els hiperparàmetres a MLflow
- Entrena un model de cerca de quadrícula amb els hiperparàmetres especificats
- Obté el millor model de la cerca de quadrícula
- Fa prediccions sobre les dades de proves amb el millor model
- Calcula la precisió del model
- Imprimeix l'informe d'hiperparàmetres, precisió i classificació
- Registra la precisió i el model a MLflow
Fragment de codi:
amb warn.catch_warnings():warn.filterwarnings( 'ignorar' , categoria=Avís d'usuari, mòdul= '.*dutil.*' )
per als paràmetres a pg(param_grid):
amb mlflow.start_run(run_name= 'Execució d'Admissions_Status' ):
# Converteix valors únics en llistes
params = {clau: [valor] si no és instància (valor, llista) sinó valor per a clau, valor a params.items ()}
mlflow.log_params(params)
grid_search = gscv(gbc_obj, param_grid=params, cv= 5 )
grid_search.fit(F_training, t_training)
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àmetres:' , paràmetres)
imprimir( 'Precisió:' , model_accuracy_score)
# Ignoreu explícitament l'Avís de la mètrica no definit
amb warn.catch_warnings():
warn.filterwarnings( 'ignorar' , categoria=Avís)
imprimir( 'Informe de classificació:' )
print(cr(t_test, model_predictions, zero_division= 1 ))
mlflow.log_metric( 'exactitud' , model_accuracy_score)
mlflow.sklearn.log_model(std_best_model, 'gb_classifier_model' )
Pas 8: executeu el programa amb Python
Aquí teniu la sortida al servidor MLflow:
Conclusió
L'eina de cerca de quadrícula de MLflow automatitza l'ajustament, el seguiment dels resultats i la modificació dels hiperparàmetres dels models d'aprenentatge automàtic. Ajuda a determinar els hiperparàmetres ideals i garanteix els resultats fiables, però pot ser computacionalment costós per a experiments d'hiperparàmetres extensos.