Fordeler med Grid Search
- Automatisert hyperparameterinnstilling: Rutenettsøk automatiserer hyperparameterinnstilling som tillater systematisk utforskning uten manuell prøving og feiling.
- Reproduserbarhet: Rutenettsøk sikrer testvaliditet ved å oppnå reproduserbare resultater som forbedrer kommunikasjon og pålitelighet.
- Uttømmende søk: GS finner effektivt optimale hyperparametre for en modell ved å søke uttømmende etter kombinasjoner.
- Robusthet: Rutenettsøk er en robust teknikk som er motstandsdyktig mot datastøy som reduserer overtilpasning.
- Enkel å bruke: Rutenettsøk er enkelt å bruke og forstå, noe som gjør det til en levedyktig metode for hyperparameterinnstilling.
- Modellsammenligninger: Rutenettsøk forenkler utvalget av modellsammenligninger og evalueringsberegninger.
Ulemper med Grid Search
- Beregningskostnad: Rutenettsøk er beregningsmessig dyrt for å justere et stort antall hyperparametre.
- Tidkrevende: Det er tidkrevende for komplekse hyperparameterjusteringer.
- Ikke alltid nødvendig: Det er nå alltid påkrevd; tilfeldig søk er det beste alternativet til det.
Eksempel: Finne de beste modellinnstillingene for universitetsopptakssystem
La oss se på et nettsøk-eksempel for hyperparameterinnstilling innenfor rammen av et nettbasert universitetsopptakssystem. I dette eksemplet bruker vi scikit-learn og en enkel Gradient Boosting Classifier (GBC) klassifisering for å forutsi en students sannsynlighet for å bli akseptert på et universitet basert på faktorer som GPA-poeng, SAT-poeng, ACT-poeng og aktiviteter utenom faget. Flere alternativer er tilgjengelige for rutenettsøk i stedet for GBC, inkludert Logistic Regression (LR), SVM (Support Vector Machine), etc.
Generer tilfeldige data for online opptakssystem ved å bruke MLflow for Grid Search
Pythons Pandas og tilfeldige pakker kan brukes til å lage et fiktivt datasett for opptakssystemet. Med tilfeldige verdier for kolonnene APP_NO, GPA, SAT Score, ACT Score, Extracurricular Activities og Admission Status, genererer denne koden et syntetisk opptaksdatasett. Variabelen num_students kontrollerer hvor mange rader det er i datasettet.
Opptaksstatusen er tilfeldig satt basert på en akseptgrad på 70 %, og den tilfeldige modulen brukes til å produsere tilfeldige verdier for flere kolonner. For demonstrasjonsformål oppretter følgende kodebit et falskt opptaksdatasett med tilfeldige verdier og lagres i filen std_admission_dataset.csv:
Kodebit:
# Importer Panda- og Random-bibliotekene
importer pandaer som panda_obj
importer tilfeldig som random_obj
# Angi antall poster som elevdatasettet skal generere
student_records = 1000
# Opprett lister for å lagre data
std_application_numbers = [ 'APP-' + str(random_obj.randint( 1000 , 9999 )) for _ in range(students_records)]
std_gpa = [runde(random_obj.uniform( 2.5 , 4.0 ), 2 ) for _ in range(students_records)]
std_sat_scores = [random_obj.randint( 900 , 1600 ) for _ in range(students_records)]
std_act_scores = [random_obj.randint( tjue , 36 ) for _ in range(students_records)]
std_extra_curriculars = [random_obj.choice([ 'Ja' , 'Nei' ]) for _ in range(students_records)]
# Beregn opptaksstatus basert på tilfeldig akseptrate
std_admission_status = [ 1 if random_obj.random() < 0,7 ellers 0 for _ innen rekkevidde(studenter_poster)]
# Lag en ordbok for å holde studentdataene
std_data = {
'APPLICATION_NO' : std_application_numbers,
'GPA' : std_gpa,
'SAT_Score' : std_sat_scores,
'ACT_Score' : std_act_scores,
'Fritidsaktiviteter' : std_extra_curriculars,
'Admission_Status' : std_admission_status
}
# Lag en DataFrame DataFrame_Student fra ordboken
DataFrame_Student = panda_obj.DataFrame(std_data)
# Lagre DataFrame DataFrame_Student i en CSV-fil kalt std_admission_dataset.csv
DataFrame_Student.to_csv( 'std_admission_dataset.csv' , indeks=False)
skrive ut( 'Elevdata ble eksportert til CSV-fil!' )
Kodeutførelse:
Bruk Python-kommandoen til å kompilere koden, og bruk deretter pip-kommandoen til å installere en spesifikk modul hvis du støter på en modulfeil. Bruk kommandoen pip3 install for å installere det gitte biblioteket hvis Python er versjon 3.X eller høyere.
Vellykket utførelse:
Eksempel på dataskjermbilde:
Trinn 1: Importer bibliotekene
- MLflow-biblioteket for sporing av maskinlæringseksperimenter
- Pandas-biblioteket for håndtering av databehandling og analyse, samt mlflow.sklearn-pakken for integrering av Scikit-Learn-modellene
- Den fjerde linjen importerer 'advarsler'-biblioteket for å undertrykke feilene
- ParameterGrid-klassen for rutenettsøk i modulen sklearn.model_selection
- GridSearchCV og GradientBoostingClassifier fra henholdsvis sklearn.model_selection og ensemble for grid search og gradient boosting classifier modeller
- Acracy_score og classification_report funksjoner fra sklearn.metrics-modulen for å beregne modellnøyaktigheten og generere klassifiseringsrapporter
- Koden importerer OS-modulen og setter GIT_PYTHON_REFRESH miljøvariabelen til stille.
Kodebit:
# Trinn-I Importer nødvendige bibliotekerimportere mlflow
import mlflow.sklearn
import advarsler som advare
importer pandaer som panda_obj
fra sklearn.model_selection importer train_test_split som tts, ParameterGrid som pg, GridSearchCV som gscv
importere oss
fra sklearn.ensemble importerer GradientBoostingClassifier som GBC
fra sklearn.metrics importer accuracy_score som acs, classification_report som cr
os.environ[ 'GIT_PYTHON_REFRESH' ] = 'stille'
Trinn 2: Angi sporings-URI
MLflow-serverens sporings-URI er satt ved hjelp av mlflow.set_tracking_uri()-funksjonen, som sikrer en lokal maskin på port 5000 for eksperimenter og modeller.
mlflow.set_tracking_uri( 'http://localhost:5000' )Trinn 3: Last inn og klargjør opptaksdatasettet
Importer Pandas-biblioteket som panda_obj for datamanipulering og analyse. Read_csv()-funksjonen brukes for å laste opptaksdatasettet. Banen til datasettet er det eneste argumentet som kreves av read_csv()-funksjonen. Banen til datasettet i dette tilfellet er std_admission_dataset.csv. Ved å bruke read_csv()-funksjonen, lastes datasettet inn i en Pandas DataFrame.
Admission_Status-kolonnen fra std_admissions_data DataFrame fjernes først av koden. Siden denne kolonnen inneholder målvariabelen, er det ikke nødvendig med forhåndsbehandling.
Deretter oppretter koden to nye variabler: 'F' og 't'. Funksjonene er inneholdt i 'F'-variabelen, mens målvariabelen er inneholdt i 't'-variabelen.
Dataene blir deretter distribuert til test- og treningssett. Dette oppnås ved å bruke funksjonen tts() fra pakken sklearn.model_selection. Funksjonene, målvariabelen, teststørrelsen og den tilfeldige tilstanden er de fire argumentene som kreves av tts()-funksjonen. Test_size-parameteren angir delen av dataene som brukes til testformål. Siden teststørrelsen i dette tilfellet er satt til 0,2, vil 20 % av dataene bli brukt til testen.
Alternativet random_state spesifiserer tilfeldig tallgeneratorens frø. Dette gjøres for å sikre at dataene skilles tilfeldig. Trenings- og testsettene er nå lagret i variablene F_training, F_testing, t_training og t_testing. Disse settene kan brukes til å evaluere og trene maskinlæringsmodellene.
Kodebit:
# Trinn-3: Last inn opptaksdatasettetstd_admissions_data = panda_obj.read_csv( 'std_admission_dataset.csv' )
# Forbehandle dataene og del inn i funksjoner (F) og mål (t)
F = std_admissions_data.drop([ 'Admission_Status' ], akse= 1 )
t = standard_admissions_data[ 'Admission_Status' ]
# Konverter kategoriske variabler til numeriske ved hjelp av en-hot-koding
F = panda_obj.get_dummies(F)
F_trening, F_testing, t_trening, t_testing = tts(F, t, test_size= 0,2 , random_state= 42 )
Trinn 4: Angi navnet på MLflow-eksperimentet
adm_experiment_name = 'Universitetet_opptakseksperiment'mlflow.set_experiment(adm_experiment_name)
Trinn 5: Definer Gradient Boosting Classifier
Gradientforsterkende klassifiseringsmodell er nå lagret i gbc_obj-variabelen. Opptaksdatasettet kan brukes til å teste og trene denne modellen. Verdien av random_state-argumentet er 42. Dette garanterer at modellen trenes ved å bruke nøyaktig samme tilfeldig tallgenerator-seed som gjør resultatene repeterbare.
gbc_obj = GBC(tilfeldig_tilstand= 42 )Trinn 6: Definer Hyperparameter Grid
Koden oppretter først param_grid-ordboken. Hyperparametrene som justeres via rutenettsøket finnes i denne ordboken. Tre taster utgjør param_grid-ordboken: n_estimators, learning_rate og max_depth. Dette er hyperparametrene til den gradientforsterkende klassifiseringsmodellen. Antall trær i modellen er spesifisert av hyperparameteren n_estimators. Modellens læringshastighet spesifiseres via hyperparameteren learning_rate. Hyperparameteren max_depth definerer høyest mulig dybde av modellens trær.
Kodebit:
param_grid = {'n_estimators' :[ 100 , 150 , 200 ],
'læringsrate' :[ 0,01 , 0,1 , 0,2 ],
'max_depth' :[ 4 , 5 , 6 ]
}
Trinn 7: Utfør Grid Search med MLflow Tracking
Koden itererer deretter over param_grid-ordboken. For hvert sett med hyperparametre i ordboken gjør koden følgende:
- Starter en ny MLflow-kjøring
- Konverterer hyperparametrene til en liste hvis de ikke allerede er en liste
- Logger hyperparametrene til MLflow
- Trener en rutenettsøkemodell med de spesifiserte hyperparametrene
- Får den beste modellen fra rutenettsøket
- Gir spådommer om testdata som fungerer som den beste modellen
- Beregner nøyaktigheten til modellen
- Skriver ut hyperparametere, nøyaktighet og klassifiseringsrapport
- Logger nøyaktigheten og modellen til MLflow
Kodebit:
med warn.catch_warnings():warn.filterwarnings( 'overse' , category=Brukeradvarsel, modul= '.*distutil.*' )
for paramer i pg(param_grid):
med mlflow.start_run(run_name= 'Admissions_Status Run' ):
# Konverter enkeltverdier til lister
params = {key: [value] if not isinstance(value, list) else verdi for nøkkel, verdi i 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)
skrive ut( 'Hyperparametere:' , params)
skrive ut( 'Nøyaktighet:' , model_accuracy_score)
# Ignorer eksplisitt UndefinedMetricWarning
med warn.catch_warnings():
warn.filterwarnings( 'overse' , kategori=advarsel)
skrive ut( 'Klassifiseringsrapport:' )
print(cr(t_testing, model_predictions, zero_division= 1 ))
mlflow.log_metric( 'nøyaktighet' , model_accuracy_score)
mlflow.sklearn.log_model(std_beste_modell, 'gb_classifier_model' )
Trinn 8: Kjør programmet ved å bruke Python
Her er utdataene på MLflow-serveren:
Konklusjon
MLflows grid-søkeverktøy automatiserer tilpasning, sporing av resultatene og modifisering av hyperparametrene i maskinlæringsmodeller. Det hjelper til med å bestemme de ideelle hyperparametrene og sikrer pålitelige resultater, men kan være beregningsmessig dyrt for omfattende hyperparametereksperimenter.