Voordelen van rasterzoeken
- Geautomatiseerde afstemming van hyperparameters: Grid search automatiseert de afstemming van hyperparameters, waardoor systematische verkenning mogelijk is zonder handmatig vallen en opstaan.
- Reproduceerbaarheid: Grid search verzekert de validiteit van de test door reproduceerbaar de reproduceerbare resultaten te verkrijgen, wat de communicatie en betrouwbaarheid verbetert.
- Uitgebreid zoeken: GS vindt efficiënt optimale hyperparameters voor een model door uitvoerig naar combinaties te zoeken.
- Robuustheid: Grid search is een robuuste techniek die bestand is tegen gegevensruis, waardoor overfitting wordt verminderd.
- Eenvoudig te gebruiken: Grid search is eenvoudig te gebruiken en te begrijpen, waardoor het een haalbare methode is voor het afstemmen van hyperparameters.
- Modelvergelijkingen: Rasterzoeken vereenvoudigt de modelvergelijking en selectie van evaluatiestatistieken.
Nadelen van rasterzoeken
- Berekeningskosten: Het zoeken naar rasters is rekenkundig duur voor het afstemmen van een groot aantal hyperparameters.
- Tijdrovend: Het is tijdrovend voor complexe hyperparameteraanpassingen.
- Niet altijd nodig: Het is nu altijd vereist; willekeurig zoeken is het beste alternatief hiervoor.
Voorbeeld: het vinden van de beste modelinstellingen voor het universitaire toelatingssysteem
Laten we eens kijken naar een voorbeeld van een rasterzoekopdracht voor het afstemmen van hyperparameters binnen het raamwerk van een online toelatingssysteem voor universiteiten. In dit voorbeeld gebruiken we de scikit-learn en een eenvoudige Gradient Boosting Classifier (GBC)-classifier om de kans te voorspellen dat een student wordt toegelaten tot een universiteit op basis van factoren zoals GPA-punten, SAT-scores, ACT-scores en buitenschoolse activiteiten. Er zijn meerdere opties beschikbaar voor het zoeken naar rasters in plaats van GBC, waaronder Logistic Regression (LR), SVM (Support Vector Machine), enz.
Genereer willekeurige gegevens voor online toelatingssysteem met behulp van MLflow voor Grid Search
Python’s Panda’s en willekeurige pakketten kunnen worden gebruikt om een fictieve dataset voor het toelatingssysteem te creëren. Met willekeurige waarden voor de kolommen APP_NO, GPA, SAT Score, ACT Score, Buitenschoolse activiteiten en Toelatingsstatus genereert deze code een synthetische toelatingsgegevensset. De variabele num_students bepaalt hoeveel rijen er in de gegevensset zijn.
De toelatingsstatus wordt willekeurig ingesteld op basis van een acceptatiepercentage van 70%, en de willekeurige module wordt gebruikt om willekeurige waarden voor meerdere kolommen te produceren. Voor demonstratiedoeleinden maakt het volgende codestuk een nep-toelatingsgegevensset met willekeurige waarden en wordt deze opgeslagen in het bestand std_admission_dataset.csv:
Codefragment:
# Importeer de Panda- en Random-bibliotheken
importeer panda's als panda_obj
importeer willekeurig als random_obj
# Stel het aantal records in dat de studentendataset moet genereren
studenten_records = 1000
# Maak lijsten om gegevens op te slaan
std_application_numbers = [ 'APP-' + str(willekeurige_obj.randint( 1000 , 9999 )) voor _ binnen bereik(studenten_records)]
std_gpa = [ronde(willekeurige_obj.uniform( 2.5 , 4.0 ), 2 ) voor _ binnen bereik(studenten_records)]
std_sat_scores = [willekeurige_obj.randint( 900 , 1600 ) voor _ binnen bereik(studenten_records)]
std_act_scores = [willekeurige_obj.randint( twintig , 36 ) voor _ binnen bereik(studenten_records)]
std_extra_curriculars = [willekeurige_obj.choice([ 'Ja' , 'Nee' ]) voor _ binnen bereik(studenten_records)]
# Bereken de toelatingsstatus op basis van het willekeurige acceptatiepercentage
std_admission_status = [ 1 if random_obj.random() < 0,7 anders 0 voor _ binnen bereik(studenten_records)]
# Maak een woordenboek om de leerlinggegevens in op te slaan
std_data = {
'APPLICATIE_NO' : std_applicatie_nummers,
'GPA' : std_gpa,
'SAT_Score' : std_sat_scores,
'ACT_Score' : std_act_scores,
'Buitenschoolse activiteiten' : std_extra_curriculaires,
'Toelating_Status' : std_toelating_status
}
# Maak een DataFrame DataFrame_Student uit het woordenboek
DataFrame_Student = panda_obj.DataFrame(std_data)
# Sla het DataFrame DataFrame_Student op in een CSV-bestand met de naam std_admission_dataset.csv
DataFrame_Student.to_csv( 'std_admission_dataset.csv' , index=Onwaar)
afdrukken( 'Studentengegevens succesvol geëxporteerd naar CSV-bestand!' )
Code-uitvoering:
Gebruik de Python-opdracht om de code te compileren en gebruik vervolgens de pip-opdracht om een specifieke module te installeren als u een modulefout tegenkomt. Gebruik de opdracht pip3 install om de gegeven bibliotheek te installeren als Python versie 3.X of hoger is.
Succesvolle uitvoering:
Voorbeeldgegevensscreenshot:
Stap 1: importeer de bibliotheken
- De MLflow-bibliotheek voor het bijhouden van machine learning-experimenten
- De Pandas-bibliotheek voor het verwerken en analyseren van gegevens, evenals het mlflow.sklearn-pakket voor het integreren van de Scikit-Learn-modellen
- De vierde regel importeert de bibliotheek 'waarschuwingen' om de fouten te onderdrukken
- De klasse ParameterGrid voor het zoeken naar rasters in de module sklearn.model_selection
- GridSearchCV en GradientBoostingClassifier van respectievelijk sklearn.model_selection en ensemble, voor grid search en gradiëntversterkende classificatiemodellen
- De functies accuratesse_score en classificatie_report van de module sklearn.metrics om de nauwkeurigheid van het model te berekenen en classificatierapporten te genereren
- De code importeert de OS-module en stelt de omgevingsvariabele GIT_PYTHON_REFRESH in op stil.
Codefragment:
# Stap-I Importeer vereiste bibliothekenmlflow importeren
importeer mlflow.sklearn
importeer waarschuwingen als waarschuwing
importeer panda's als panda_obj
van sklearn.model_selection import train_test_split als tts, ParameterGrid als pg, GridSearchCV als gscv
Importeer ons
van sklearn.ensemble importeer GradientBoostingClassifier als GBC
van sklearn.metrics importeer accuratesse_score als acs, classificatie_report als cr
os.omgeving[ 'Git_Python_refresh' ] = 'rustig'
Stap 2: Stel de tracking-URI in
De tracking-URI van de MLflow-server wordt ingesteld met behulp van de functie mlflow.set_tracking_uri(), waardoor een lokale machine op poort 5000 wordt gegarandeerd voor experimenten en modellen.
mlflow.set_tracking_uri( 'http://localhost:5000' )Stap 3: Laad de toelatingsgegevensset en bereid deze voor
Importeer de Pandas-bibliotheek als panda_obj voor gegevensmanipulatie en -analyse. De functie read_csv() wordt toegepast om de toelatingsdataset te laden. Het pad naar de gegevensset is het enige argument dat vereist is voor de functie read_csv(). Het pad naar de gegevensset in dit exemplaar is std_admission_dataset.csv. Door gebruik te maken van de functie read_csv() wordt de dataset in een Pandas DataFrame geladen.
De kolom Admission_Status uit het dataframe std_admissions_data wordt eerst door de code verwijderd. Omdat deze kolom de doelvariabele bevat, is voorbewerking niet nodig.
Vervolgens creëert de code twee nieuwe variabelen: “F” en “t”. De kenmerken zijn opgenomen in de “F”-variabele, terwijl de doelvariabele is opgenomen in de “t”-variabele.
De gegevens worden vervolgens verdeeld in test- en trainingssets. Dit wordt bereikt met behulp van de functie tts() uit het pakket sklearn.model_selection. De kenmerken, de doelvariabele, de testgrootte en de willekeurige status zijn de vier argumenten die vereist zijn voor de functie tts(). De parameter test_size bepaalt welk deel van de gegevens wordt gebruikt voor testdoeleinden. Omdat de testgrootte in dit geval is ingesteld op 0,2, wordt 20% van de gegevens voor de test gebruikt.
De optie random_state specificeert het zaad van de generator voor willekeurige getallen. Dit wordt gedaan om ervoor te zorgen dat de gegevens willekeurig worden gescheiden. De trainings- en testsets worden nu opgeslagen in de variabelen F_training, F_testing, t_training en t_testing. Deze sets kunnen worden gebruikt om de machine learning-modellen te evalueren en te trainen.
Codefragment:
# Stap 3: Laad de toelatingsdatasetstd_admissions_data = panda_obj.read_csv( 'std_admission_dataset.csv' )
# Bewerk de gegevens voor en splits ze op in features (F) en target (t)
F = std_admissions_data.drop([ 'Toelating_Status' ], as= 1 )
t = std_admissions_data[ 'Toelating_Status' ]
# Converteer categorische variabelen naar numeriek met behulp van one-hot-codering
F = panda_obj.get_dummies(F)
F_training, F_testing, t_training, t_testing = tts(F, t, test_size= 0,2 , willekeurige_status= 42 )
Stap 4: Stel de MLflow-experimentnaam in
adm_experimentnaam = 'Universiteit_Toelating_Experiment'mlflow.set_experiment(adm_experiment_name)
Stap 5: Definieer de Gradient Boosting Classifier
Het gradiëntversterkende classificatiemodel wordt nu opgeslagen in de gbc_obj variabele. De toelatingsdataset kan worden gebruikt om dit model te testen en te trainen. De waarde van het argument random_state is 42. Dit garandeert dat het model wordt getraind met exact hetzelfde generator-zaad voor willekeurige getallen, waardoor de uitkomsten herhaalbaar zijn.
gbc_obj = GBC(willekeurige_status= 42 )Stap 6: Definieer het hyperparameterraster
De code maakt in eerste instantie het param_grid-woordenboek. In dit woordenboek zijn de hyperparameters opgenomen die via de rasterzoekopdracht worden aangepast. Drie sleutels vormen het param_grid-woordenboek: n_estimators, learning_rate en max_ depth. Dit zijn de hyperparameters van het gradiëntversterkende classificatiemodel. Het aantal bomen in het model wordt gespecificeerd door de hyperparameter n_estimators. De leersnelheid van het model wordt gespecificeerd via de hyperparameter learning_rate. De hyperparameter max_diepte definieert de hoogst mogelijke diepte van de bomen van het model.
Codefragment:
param_grid = {'n_schatters' :[ 100 , 150 , 200 ],
'leersnelheid' :[ 0,01 , 0,1 , 0,2 ],
'maximale diepte' :[ 4 , 5 , 6 ]
}
Stap 7: Voer de rasterzoekopdracht uit met MLflow Tracking
De code herhaalt vervolgens het param_grid-woordenboek. Voor elke set hyperparameters in het woordenboek doet de code het volgende:
- Start een nieuwe MLflow-uitvoering
- Converteert de hyperparameters naar een lijst als ze nog geen lijst zijn
- Registreert de hyperparameters naar MLflow
- Traint een rasterzoekmodel met de opgegeven hyperparameters
- Haalt het beste model uit de rasterzoekopdracht
- Maakt voorspellingen op basis van de testgegevens die het beste model vormen
- Berekent de nauwkeurigheid van het model
- Drukt het hyperparameters-, nauwkeurigheids- en classificatierapport af
- Registreert de nauwkeurigheid en het model in MLflow
Codefragment:
met warn.catch_warnings():warn.filterwarnings( 'negeren' , categorie=Gebruikerswaarschuwing, module= '.*distutil.*' )
voor params in pg(param_grid):
met mlflow.start_run(run_name= 'Toelatingen_Status uitvoeren' ):
# Converteer afzonderlijke waarden naar lijsten
params = {sleutel: [waarde] indien niet isinstance(waarde, lijst) else waarde voor sleutel, waarde in 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_testen, model_voorspellingen)
afdrukken( 'Hyperparameters:' , parameters)
afdrukken( 'Nauwkeurigheid:' , model_accuracy_score)
# Negeer expliciet de UndefinedMetricWarning
met warn.catch_warnings():
warn.filterwarnings( 'negeren' , categorie=Waarschuwing)
afdrukken( 'Classificatierapport:' )
print(cr(t_testing, model_predictions, zero_division= 1 ))
mlflow.log_metric( 'nauwkeurigheid' , model_accuracy_score)
mlflow.sklearn.log_model(std_best_model, 'gb_classifier_model' )
Stap 8: Voer het programma uit met Python
Hier is de uitvoer op de MLflow-server:
Conclusie
De grid-zoektool van MLflow automatiseert het tweaken, het volgen van de resultaten en het aanpassen van de hyperparameters in machine learning-modellen. Het helpt bij het bepalen van de ideale hyperparameters en zorgt voor betrouwbare resultaten, maar kan rekentechnisch duur zijn voor uitgebreide hyperparameterexperimenten.