Grid Search med MLflow

Grid Search Med Mlflow



Hyperparametre i maskinlæringsmodeller er optimeret ved hjælp af grid search-tilgangen. En bruger kan hurtigt sammenligne flere hyperparameterindstillinger og finde ud af, hvilke der klarer sig bedst, fordi MLflow holder styr på resultaterne af gittersøgningseksperimenter. I MLflow kan gittersøgningseksperimentet hurtigt deles med andre teammedlemmer. Ved hjælp af MLflow kan den mest effektive model fra et netsøgningseksperiment implementeres.

Fordele ved Grid Search

  • Automatiseret hyperparameterjustering: Grid search automatiserer hyperparameter tuning, som tillader systematisk udforskning uden manuel forsøg og fejl.
  • Reproducerbarhed: Gittersøgning sikrer testvaliditet ved reproducerbar at opnå de reproducerbare resultater, hvilket forbedrer kommunikation og pålidelighed.
  • Udtømmende søgning: GS finder effektivt optimale hyperparametre for en model ved udtømmende at søge efter kombinationer.
  • Robusthed: Grid search er en robust teknik, der er modstandsdygtig over for datastøj, hvilket reducerer overfitting.
  • Enkel at bruge: Gittersøgning er enkel at bruge og forstå, hvilket gør det til en brugbar metode til tuning af hyperparameter.
  • Modelsammenligninger: Gittersøgning forenkler valget af modelsammenligning og evalueringsmetrikker.

Ulemper ved Grid Search

  • Beregningsomkostninger: Gittersøgning er beregningsmæssigt dyrt for at tune et stort antal hyperparametre.
  • Tidskrævende: Det er tidskrævende for komplekse hyperparameterjusteringer.
  • Ikke altid nødvendigt: Det er nu altid påkrævet; tilfældig søgning er det bedste alternativ til det.

Eksempel: Find de bedste modelindstillinger for universitetsadgangssystemet

Lad os se på et gittersøgningseksempel for hyperparameterjustering inden for rammerne af et online universitetsoptagelsessystem. I dette eksempel bruger vi scikit-learn og en ligetil Gradient Boosting Classifier (GBC) klassifikator til at forudsige en studerendes sandsynlighed for at blive optaget på et universitet baseret på faktorer som GPA-point, SAT-score, ACT-score og aktiviteter uden for pensum. Flere muligheder er tilgængelige for netsøgning i stedet for GBC, herunder logistisk regression (LR), SVM (Support Vector Machine) osv.

Generer tilfældige data til onlineadgangssystem ved hjælp af MLflow til gittersøgning

Pythons Pandaer og tilfældige pakker kan bruges til at skabe et fiktivt datasæt til adgangssystemet. Med tilfældige værdier for kolonnerne APP_NO, GPA, SAT Score, ACT Score, Ekstracurricular Activities og Admission Status genererer denne kode et syntetisk adgangsdatasæt. Variablen num_students styrer, hvor mange rækker der er i datasættet.







Optagelsesstatussen er tilfældigt indstillet baseret på en acceptrate på 70 %, og det tilfældige modul bruges til at producere tilfældige værdier for flere kolonner. Til demonstrationsformål opretter følgende kodestykke et falsk adgangsdatasæt med tilfældige værdier og gemmes i filen std_admission_dataset.csv:



Kodestykke:



# Importer Panda- og Random-bibliotekerne
importer pandaer som panda_obj
import tilfældig som random_obj

# Indstil antallet af poster, som elevdatasættet skal generere
students_records = 1000

# Opret lister for at gemme data
std_ansøgningsnumre = [ 'APP-' + str(random_obj.randint( 1000 , 9999 )) for _ in range(students_records)]
std_gpa = [runde(random_obj.uniform( 2.5 , 4.0 ), 2 ) for _ inden for rækkevidde(studenter_records)]
std_sat_scores = [random_obj.randint( 900 , 1600 ) for _ inden for rækkevidde(studenter_records)]
std_act_scores = [random_obj.randint( tyve , 36 ) for _ inden for rækkevidde(studenter_records)]
std_extra_curriculars = [random_obj.choice([ 'Ja' , 'Ingen' ]) for _ inden for rækkevidde(studenter_records)]

# Beregn optagelsesstatus baseret på tilfældig acceptrate
std_admission_status = [ 1 if random_obj.random() < 0,7 andet 0 for _ inden for rækkevidde(elever_records)]

# Opret en ordbog til at opbevare elevdataene
std_data = {

'APPLICATION_NO' : standard_applikationsnumre,

'GPA' : std_gpa,

'SAT_Score' : std_sat_scores,

'ACT_Score' : std_act_scores,

'Extracurricular_Activities' : std_extra_curriculars,

'Admission_Status' : std_admission_status

}

# Opret en DataFrame DataFrame_Student fra ordbogen
DataFrame_Student = panda_obj.DataFrame(std_data)

# Gem DataFrame DataFrame_Student i en CSV-fil ved navn std_admission_dataset.csv
DataFrame_Student.to_csv( 'std_admission_dataset.csv' , indeks=False)
Print( 'Elevdata blev eksporteret til CSV-fil!' )

Kodeudførelse:

Brug Python-kommandoen til at kompilere koden, og brug derefter pip-kommandoen til at installere et specifikt modul, hvis du støder på en modulfejl. Brug kommandoen pip3 install til at installere det givne bibliotek, hvis Python er version 3.X eller nyere.





Vellykket udførelse:



Eksempel på dataskærmbillede:

Trin 1: Importer bibliotekerne

  • MLflow-biblioteket til sporing af maskinlæringseksperimenter
  • Pandas-biblioteket til håndtering af databehandling og analyse samt mlflow.sklearn-pakken til integration af Scikit-Learn-modellerne
  • Den fjerde linje importerer 'advarsler'-biblioteket for at undertrykke fejlene
  • ParameterGrid-klassen til gittersøgning i sklearn.model_selection-modulet
  • GridSearchCV og GradientBoostingClassifier fra henholdsvis sklearn.model_selection og ensemble til gridsøgning og gradientboostende klassificeringsmodeller
  • Acracy_score og classification_report fungerer fra sklearn.metrics-modulet til at beregne modelnøjagtigheden og generere klassifikationsrapporter
  • Koden importerer OS-modulet og sætter GIT_PYTHON_REFRESH miljøvariablen til stille.

Kodestykke:

# Trin-I Importer nødvendige biblioteker
importer 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
import os
fra sklearn.ensemble importerer GradientBoostingClassifier som GBC
fra sklearn.metrics importer accuracy_score som acs, classification_report som cr
os.environ[ 'GIT_PYTHON_REFRESH' ] = 'rolige'

Trin 2: Indstil sporings-URI

MLflow-serverens sporings-URI indstilles ved hjælp af mlflow.set_tracking_uri()-funktionen, hvilket sikrer en lokal maskine på port 5000 til eksperimenter og modeller.

mlflow.set_tracking_uri( 'http://localhost:5000' )

Trin 3: Indlæs og klargør adgangsdatasættet

Importer Pandas-biblioteket som panda_obj til datamanipulation og -analyse. Read_csv()-funktionen anvendes til at indlæse adgangsdatasættet. Stien til datasættet er det eneste argument, der kræves af read_csv()-funktionen. Stien til datasættet i dette tilfælde er std_admission_dataset.csv. Ved at anvende funktionen read_csv() indlæses datasættet i en Pandas DataFrame.

Admission_Status kolonnen fra std_admissions_data DataFrame fjernes først af koden. Da denne kolonne indeholder målvariablen, er forbehandling ikke nødvendig.

Derefter opretter koden to nye variable: 'F' og 't'. Funktionerne er indeholdt i 'F'-variablen, mens målvariablen er indeholdt i 't'-variablen.

Dataene fordeles derefter i test- og træningssæt. Dette opnås ved hjælp af tts()-funktionen fra pakken sklearn.model_selection. Funktionerne, målvariablen, teststørrelsen og den tilfældige tilstand er de fire argumenter, der kræves af tts()-funktionen. Parameteren test_size angiver den del af dataene, der bruges til testformål. Da teststørrelsen i dette tilfælde er sat til 0,2, vil 20 % af dataene blive brugt til testen.

Valgmuligheden tilfældig_tilstand specificerer tilfældigt talgeneratorens frø. Dette gøres for at sikre, at dataene adskilles tilfældigt. Trænings- og testsættene er nu gemt i variablerne F_training, F_testing, t_training og t_testing. Disse sæt kan bruges til at evaluere og træne maskinlæringsmodellerne.

Kodestykke:

# Trin-3: Indlæs adgangsdatasættet
std_admissions_data = panda_obj.read_csv( 'std_admission_dataset.csv' )

# Forbehandle dataene og opdele dem i funktioner (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 hjælp af one-hot-kodning
F = panda_obj.get_dummies(F)
F_training, F_testing, t_training, t_testing = tts(F, t, test_size= 0,2 , tilfældig_tilstand= 42 )

Trin 4: Indstil MLflow-eksperimentnavnet

adm_eksperiment_navn = 'Universitetsoptagelseseksperiment'
mlflow.set_experiment(adm_experiment_name)

Trin 5: Definer Gradient Boosting Classifier

Gradientforstærkende klassificeringsmodellen er nu gemt i gbc_obj-variablen. Adgangsdatasættet kan bruges til at teste og træne denne model. Værdien af ​​random_state-argumentet er 42. Dette garanterer, at modellen trænes ved at bruge nøjagtig det samme tilfældige talgenerator-seed, som gør resultaterne gentagelige.

gbc_obj = GBC(tilfældig_tilstand= 42 )

Trin 6: Definer hyperparametergitteret

Koden opretter oprindeligt param_grid-ordbogen. Hyperparametrene, der justeres via gittersøgningen, er indeholdt i denne ordbog. Tre nøgler udgør param_grid-ordbogen: n_estimators, learning_rate og max_depth. Disse er den gradientforstærkende klassificeringsmodels hyperparametre. Antallet af træer i modellen er specificeret af hyperparameteren n_estimators. Modellens indlæringshastighed er specificeret via hyperparameteren learning_rate. Hyperparameteren max_depth definerer den højest mulige dybde af modellens træer.

Kodestykke:

param_grid = {

'n_estimators' :[ 100 , 150 , 200 ],

'læringsrate' :[ 0,01 , 0,1 , 0,2 ],

'max_depth' :[ 4 , 5 , 6 ]

}

Trin 7: Udfør Grid Search med MLflow Tracking

Koden itererer derefter over param_grid-ordbogen. For hvert sæt hyperparametre i ordbogen gør koden følgende:

  • Starter en ny MLflow-kørsel
  • Konverterer hyperparametrene til en liste, hvis de ikke allerede er en liste
  • Loger hyperparametrene til MLflow
  • Træner en gittersøgningsmodel med de angivne hyperparametre
  • Får den bedste model fra gittersøgningen
  • Foretager forudsigelser om testdata, der fungerer som den bedste model
  • Beregner modellens nøjagtighed
  • Udskriver hyperparametre, nøjagtighed og klassifikationsrapport
  • Logger nøjagtigheden og modellen til MLflow

Kodestykke:

med warn.catch_warnings():
warn.filterwarnings( 'ignorere' , kategori=Brugeradvarsel, modul= '.*distutil.*' )
for params i pg(param_grid):
med mlflow.start_run(run_name= 'Admissions_Status Run' ):
# Konverter enkelte værdier til lister
params = {nøgle: [værdi] hvis ikke er instance(værdi, liste) ellers værdi for nøgle, værdi 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)
Print( 'Hyperparametre:' , params)
Print( 'Nøjagtighed:' , model_accuracy_score)
# Ignorer eksplicit UndefinedMetricWarning
med warn.catch_warnings():
warn.filterwarnings( 'ignorere' , kategori=Advarsel)
Print( 'Klassificeringsrapport:' )
print(cr(t_testing, model_predictions, zero_division= 1 ))
mlflow.log_metric( 'nøjagtighed' , model_accuracy_score)
mlflow.sklearn.log_model(std_bedste_model, 'gb_classifier_model' )

Trin 8: Udfør programmet ved hjælp af Python

Her er outputtet på MLflow-serveren:

Konklusion

MLflows grid-søgeværktøj automatiserer tweaking, sporing af resultaterne og ændring af hyperparametrene i maskinlæringsmodeller. Det hjælper med at bestemme de ideelle hyperparametre og sikrer de pålidelige resultater, men det kan være beregningsmæssigt dyrt for omfattende hyperparametereksperimenter.