Avantajele căutării în grilă
- Reglare automată a hiperparametrilor: Căutarea în grilă automatizează reglarea hiperparametrului, ceea ce permite explorarea sistematică fără încercări și erori manuale.
- Reproductibilitate: Căutarea în grilă asigură validitatea testului prin obținerea reproductibilă a rezultatelor reproductibile, ceea ce îmbunătățește comunicarea și fiabilitatea.
- Căutare exhaustivă: GS găsește eficient hiperparametrii optimi pentru un model prin căutarea exhaustivă a combinațiilor.
- Robusteţe: Căutarea în grilă este o tehnică robustă care este rezistentă la zgomotul de date, ceea ce reduce supraadaptarea.
- Simplu de utilizat: Căutarea în grilă este ușor de utilizat și de înțeles, ceea ce o face o metodă viabilă pentru reglarea hiperparametrului.
- Comparații de modele: căutarea în grilă simplifică compararea modelelor și selectarea valorilor de evaluare.
Dezavantajele căutării în grilă
- Costul de calcul: Căutarea în grilă este costisitoare din punct de vedere computațional pentru reglarea unui număr mare de hiperparametri.
- Consumă timp: Este consumator de timp pentru ajustări complexe ale hiperparametrilor.
- Nu întotdeauna este necesar: Acum este întotdeauna necesar; căutarea aleatorie este cea mai bună alternativă la aceasta.
Exemplu: Găsirea celui mai bun model de setări pentru sistemul de admitere la universitate
Să ne uităm la un exemplu de căutare în grilă pentru reglarea hiperparametrului în cadrul unui sistem online de admitere la universitate. În acest exemplu, folosim scikit-learn și un clasificator simplu cu gradul de creștere a gradului (GBC) pentru a estima probabilitatea unui student de a fi acceptat la o universitate pe baza unor factori precum punctele GPA, scorurile SAT, scorurile ACT și activitățile extracurriculare. Sunt disponibile mai multe opțiuni pentru căutarea în grilă în loc de GBC, inclusiv regresia logistică (LR), SVM (Mașină vectorială de suport) etc.
Generați date aleatorii pentru sistemul de admitere online folosind MLflow pentru căutare în grilă
Pandas și pachetele aleatoare ale lui Python pot fi folosite pentru a crea un set de date fictiv pentru sistemul de admitere. Cu valori aleatorii pentru coloanele APP_NO, GPA, Scor SAT, Scor ACT, Activități extracurriculare și Starea admiterii, acest cod generează un set de date sintetice de admitere. Variabila num_students controlează câte rânduri există în setul de date.
Starea de admitere este setată aleatoriu pe baza unei rate de acceptare de 70%, iar modulul aleatoriu este folosit pentru a produce valori aleatorii pentru mai multe coloane. În scopuri demonstrative, următorul cod creează un set de date de admitere fals cu valori aleatorii și este salvat în fișierul std_admission_dataset.csv:
Fragment de cod:
# Importă bibliotecile Panda și Random
importa panda ca panda_obj
import aleatoriu ca random_obj
# Setați numărul de înregistrări pe care să le genereze setul de date pentru elev
elevii_records = 1000
# Creați liste pentru a stoca date
std_application_numbers = [ „APP-” + str(random_obj.randint( 1000 , 9999 )) pentru _ în interval (students_records)]
std_gpa = [round(random_obj.uniform( 2.5 , 4.0 ), 2 ) pentru _ în interval (students_records)]
std_sat_scores = [random_obj.randint( 900 , 1600 ) pentru _ în interval (students_records)]
std_act_scores = [random_obj.randint( douăzeci , 36 ) pentru _ în interval (students_records)]
std_extra_curriculars = [random_obj.choice([ 'Da' , 'Nu' ]) pentru _ în interval (students_records)]
# Calculați statutul de admitere pe baza ratei de acceptare aleatorie
std_admission_status = [ 1 dacă random_obj.random() < 0,7 altfel 0 pentru _ în interval (students_records)]
# Creați un dicționar pentru a păstra datele studenților
std_data = {
„APPLICATION_NO” : std_application_numbers,
„GPA” : std_gpa,
„SAT_Score” : std_sat_scores,
„ACT_Score” : std_act_scores,
'Activitati extracuriculare' : std_extra_curriculars,
„Stare_admitere” : std_admission_status
}
# Creați un DataFrame DataFrame_Student din dicționar
DataFrame_Student = panda_obj.DataFrame(std_data)
# Salvați DataFrame DataFrame_Student într-un fișier CSV numit std_admission_dataset.csv
DataFrame_Student.to_csv( „std_admission_dataset.csv” , index=fals)
imprimare( „Exportarea cu succes a datelor elevilor în fișierul CSV!” )
Executarea codului:
Utilizați comanda Python pentru a compila codul, apoi utilizați comanda pip pentru a instala un anumit modul dacă întâmpinați o eroare de modul. Utilizați comanda pip3 install pentru a instala biblioteca dată dacă Python este versiunea 3.X sau mai mare.
Execuție cu succes:
Exemplu de captură de ecran de date:
Pasul 1: importați bibliotecile
- Biblioteca MLflow pentru urmărirea experimentelor de învățare automată
- Biblioteca Pandas pentru manipularea procesării și analizei datelor, precum și pachetul mlflow.sklearn pentru integrarea modelelor Scikit-Learn
- A patra linie importă biblioteca „avertismente” pentru a suprima erorile
- Clasa ParameterGrid pentru căutarea în grilă în modulul sklearn.model_selection
- GridSearchCV și GradientBoostingClassifier de la sklearn.model_selection și, respectiv, ensemble, pentru căutarea în grilă și modelele de clasificare pentru creșterea gradientului
- Funcțiile accuracy_score și classification_report din modulul sklearn.metrics pentru a calcula acuratețea modelului și a genera rapoarte de clasificare
- Codul importă modulul OS și setează variabila de mediu GIT_PYTHON_REFRESH la silențios.
Fragment de cod:
# Pasul I Import bibliotecile necesareimport mlflow
import mlflow.sklearn
importați avertismente ca warn
importa panda ca panda_obj
din sklearn.model_selection import train_test_split ca tts, ParameterGrid ca pg, GridSearchCV ca gscv
importă-ne
din sklearn.ensemble import GradientBoostingClassifier ca GBC
din sklearn.metrics import accuracy_score ca acs, classification_report ca cr
os.environ[ „GIT_PYTHON_REFRESH” ] = 'Liniște'
Pasul 2: Setați URI-ul de urmărire
URI-ul de urmărire al serverului MLflow este setat folosind funcția mlflow.set_tracking_uri(), asigurând o mașină locală pe portul 5000 pentru experimente și modele.
mlflow.set_tracking_uri( „http://localhost:5000” )Pasul 3: Încărcați și pregătiți setul de date de admitere
Importați biblioteca Pandas ca panda_obj pentru manipularea și analiza datelor. Funcția read_csv() este aplicată pentru a încărca setul de date de admitere. Calea către setul de date este singurul argument cerut de funcția read_csv(). Calea către setul de date în această instanță este std_admission_dataset.csv. Prin folosirea funcției read_csv(), setul de date este încărcat într-un Pandas DataFrame.
Coloana Admission_Status din std_admissions_data DataFrame este mai întâi eliminată de cod. Deoarece această coloană conține variabila țintă, preprocesarea nu este necesară.
Apoi, codul creează două variabile noi: „F” și „t”. Caracteristicile sunt conținute în variabila „F”, în timp ce variabila țintă este conținută în variabila „t”.
Datele sunt apoi distribuite în seturi de testare și antrenament. Acest lucru se realizează folosind funcția tts() din pachetul sklearn.model_selection. Caracteristicile, variabila țintă, dimensiunea testului și starea aleatorie sunt cele patru argumente cerute de funcția tts(). Parametrul test_size stipulează porțiunea de date care este utilizată în scopuri de testare. Deoarece dimensiunea testului în acest caz este setată la 0,2, 20% din date vor fi utilizate pentru test.
Opțiunea random_state specifică generatorul de numere aleatorii. Acest lucru se face pentru a se asigura că datele sunt separate la întâmplare. Seturile de antrenament și testare sunt acum stocate în variabilele F_training, F_testing, t_training și t_testing. Aceste seturi pot fi folosite pentru a evalua și antrena modelele de învățare automată.
Fragment de cod:
# Pasul-3: Încărcați setul de date de admiterestd_admissions_data = panda_obj.read_csv( „std_admission_dataset.csv” )
# Preprocesați datele și împărțiți-le în caracteristici (F) și țintă (t)
F = std_admissions_data.drop([ „Stare_admitere” ], axa= 1 )
t = std_admissions_data[ „Stare_admitere” ]
# Convertiți variabilele categoriale în numerice folosind codificarea one-hot
F = panda_obj.get_dummies(F)
F_training, F_testing, t_training, t_testing = tts(F, t, test_size= 0,2 , stare_aleatorie= 42 )
Pasul 4: Setați numele experimentului MLflow
adm_experiment_name = „Experiment_admitere_Universitate”mlflow.set_experiment(adm_experiment_name)
Pasul 5: Definiți clasificatorul pentru creșterea gradului
Modelul de clasificator pentru creșterea gradientului este acum stocat în variabila gbc_obj. Setul de date de admitere poate fi folosit pentru a testa și antrena acest model. Valoarea argumentului random_state este 42. Acest lucru garantează că modelul este antrenat folosind exact același generator de numere aleatoare, ceea ce face ca rezultatele să fie repetabile.
gbc_obj = GBC(stare_aleatorie= 42 )Pasul 6: Definiți grila de hiperparametri
Codul creează inițial dicționarul param_grid. Hiperparametrii care sunt ajustați prin căutarea în grilă sunt conținuti în acest dicționar. Trei chei alcătuiesc dicționarul param_grid: n_estimators, learning_rate și max_depth. Aceștia sunt hiperparametrii modelului de clasificator de creștere a gradientului. Numărul de arbori din model este specificat de hiperparametrul n_estimators. Rata de învățare a modelului este specificată prin hiperparametrul learning_rate. Hiperparametrul max_depth definește cea mai mare adâncime posibilă a arborilor modelului.
Fragment de cod:
param_grid = {'n_estimators' :[ 100 , 150 , 200 ],
„rata_de_învățare” :[ 0,01 , 0,1 , 0,2 ],
'adancime maxima' :[ 4 , 5 , 6 ]
}
Pasul 7: Efectuați căutarea în grilă cu MLflow Tracking
Codul iterează apoi peste dicționarul param_grid. Pentru fiecare set de hiperparametri din dicționar, codul face următoarele:
- Pornește o nouă rulare MLflow
- Convertește hiperparametrii într-o listă dacă nu sunt deja o listă
- Înregistrează hiperparametrii în MLflow
- Antrenează un model de căutare în grilă cu hiperparametrii specificați
- Obține cel mai bun model din căutarea în grilă
- Face predicții asupra datelor de testare care funcționează cel mai bun model
- Calculează acuratețea modelului
- Imprimă raportul de hiperparametri, acuratețe și clasificare
- Înregistrează acuratețea și modelul în MLflow
Fragment de cod:
cu warn.catch_warnings():warn.filterwarnings( 'ignora' , categorie=Avertisment utilizator, modul= '.*dutil.*' )
pentru parametrii din pg(param_grid):
cu mlflow.start_run(run_name= „Admissions_Status Run” ):
# Convertiți valorile individuale în liste
params = {key: [valoare] dacă nu isinstance(valoare, listă) altfel valoare pentru cheie, valoare în 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)
imprimare( „Hiperparametri:” , parametri)
imprimare( 'Precizie:' , model_accuracy_score)
# Ignorați în mod explicit UndefinedMetricWarning
cu warn.catch_warnings():
warn.filterwarnings( 'ignora' , categorie=Avertisment)
imprimare( „Raport de clasificare:” )
print(cr(t_testing, model_predictions, zero_division= 1 ))
mlflow.log_metric( 'precizie' , model_accuracy_score)
mlflow.sklearn.log_model(std_best_model, „gb_classifier_model” )
Pasul 8: Executați programul folosind Python
Iată rezultatul de pe serverul MLflow:
Concluzie
Instrumentul de căutare grilă al MLflow automatizează modificarea, urmărirea rezultatelor și modificarea hiperparametrilor din modelele de învățare automată. Ajută la determinarea hiperparametrilor ideali și asigură rezultate fiabile, dar poate fi costisitor din punct de vedere computațional pentru experimente extinse de hiperparametri.