Rutenettsøk med MLflow

Rutenettsok Med Mlflow



Hyperparametere i maskinlæringsmodeller er optimalisert ved hjelp av grid search-tilnærmingen. En bruker kan raskt sammenligne flere hyperparameterinnstillinger og finne hvilke som gir best resultater fordi MLflow holder styr på resultatene av rutenettsøkeksperimenter. I MLflow kan rutenettsøk-eksperimentet raskt deles med andre teammedlemmer. Ved å bruke MLflow kan den mest effektive modellen fra et nettsøk-eksperiment distribueres.

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 biblioteker
importere 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 opptaksdatasettet
std_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.