Alle machine learning-modellen hebben een reeks hyperparameters of argumenten die door de beoefenaar moeten worden gespecificeerd.

Een logistisch regressiemodel heeft bijvoorbeeld verschillende oplossers die worden gebruikt om coëfficiënten te vinden die ons de best mogelijke output kunnen geven. Elke oplosser gebruikt een ander algoritme om een ​​optimaal resultaat te vinden, en geen van deze algoritmen is absoluut beter dan de andere. Het is moeilijk te zeggen welke oplosser het beste presteert op uw dataset, tenzij u ze allemaal probeert.

De beste hyperparameter is subjectief en verschilt per dataset. De Scikit-Leren bibliotheek in Python heeft een set standaard hyperparameters die redelijk goed presteren op alle modellen, maar deze zijn niet noodzakelijkerwijs de beste voor elk probleem.

De enige manier om de best mogelijke hyperparameters voor uw dataset te vinden, is met vallen en opstaan, wat het belangrijkste concept is hyperparameter optimalisatie.

Simpel gezegd, hyperparameteroptimalisatie is een techniek waarbij u door een reeks waarden moet zoeken om een ​​subset van resultaten te vinden die de beste prestaties leveren voor een bepaalde dataset.

Er zijn twee populaire technieken die worden gebruikt om hyperparameteroptimalisatie uit te voeren: raster en willekeurig zoeken.

Grid zoeken

Bij het uitvoeren van hyperparameteroptimalisatie moeten we eerst a definiëren parameterruimte or parameterraster, waar we een set mogelijke hyperparameterwaarden opnemen die kunnen worden gebruikt om het model te bouwen.

De rasterzoektechniek wordt vervolgens gebruikt om deze hyperparameters in een matrixachtige structuur te plaatsen en het model wordt getraind op elke combinatie van hyperparameterwaarden.

Vervolgens wordt het model met de beste prestaties geselecteerd.

Willekeurig zoeken

Terwijl zoeken in rasters naar elke mogelijke combinatie van hyperparameters kijkt om het beste model te vinden, selecteert en test willekeurig zoeken alleen een willekeurige combinatie van hyperparameters.

Deze techniek neemt willekeurige steekproeven uit een raster van hyperparameters in plaats van een uitputtende zoekopdracht uit te voeren.

We kunnen het totale aantal runs specificeren dat de willekeurige zoekopdracht moet proberen voordat het beste model wordt geretourneerd.

Nu je een basiskennis hebt van hoe willekeurig zoeken en zoeken in rasters werken, zal ik je laten zien hoe je deze technieken implementeert met behulp van de Scikit-Learn-bibliotheek.

Stap 1: De dataset laden

Download de Wijnkwaliteit dataset op Kaggle en typ de volgende regels code om deze te lezen met behulp van de Pandas bibliotheek:

panda's importeren als pd df = pd.read_csv('winequality-red.csv') df.head()

De kop van het dataframe ziet er als volgt uit:

Stap 2: Voorverwerking van gegevens

De doelvariabele “kwaliteit” bevat waarden tussen 1 en 10.

We zullen dit omzetten in een binaire classificatietaak door een waarde van 0 toe te kennen aan alle datapunten met een kwaliteitswaarde kleiner dan of gelijk aan 5, en een waarde van 1 aan de overige waarnemingen:

importeer numpy as np df['target'] = np.where(df['quality']>5, 1, 0)

Laten we de afhankelijke en onafhankelijke variabelen in dit dataframe splitsen:

df2 = df.drop(['kwaliteit'],axis=1) X = df2.drop(['target'],axis=1) y = df2[['target']]

Stap 3: het bouwen van het model

Laten we nu een willekeurige bosclassificatie instantiëren. We zullen de hyperparameters van dit model afstemmen om het beste algoritme voor onze dataset te creëren:

van sklearn.ensemble importeren RandomForestClassifier rf = RandomForestClassifier()

Stap 4: Grid Search implementeren met Scikit-Learn

De hyperparameterruimte definiëren

We zullen nu proberen de volgende set hyperparameters van dit model aan te passen:

1. "Maximale diepte": Deze hyperparameter vertegenwoordigt het maximale niveau van elke boom in het random forest-model. Een diepere boom presteert goed en legt veel informatie vast over de trainingsgegevens, maar zal niet goed generaliseren naar testgegevens. Deze waarde is standaard ingesteld op "None" in de Scikit-Learn-bibliotheek, wat betekent dat de bomen volledig kunnen worden uitgebreid.
2. "Max_functies": Het maximale aantal functies dat het willekeurige forest-model bij elke splitsing mag proberen. Standaard is deze waarde in Scikit-Learn ingesteld op de vierkantswortel van het totale aantal variabelen in de dataset.
3. "N_schatters": Het aantal beslissingsbomen in het forest. Het standaard aantal schatters in Scikit-Learn is 10.
4. "Min_samples_leaf": het minimale aantal monsters dat nodig is om bij het bladknooppunt van elke boom te zijn. De standaardwaarde is 1 in Scikit-Learn.
5. "Min_samples_split": Het minimale aantal monsters dat nodig is om een ​​interne knoop van elke boom te splitsen. De standaardwaarde is 2 in Scikit-Learn.

We gaan nu een woordenboek maken met meerdere mogelijke waarden voor alle bovenstaande hyperparameters. Dit wordt ook wel de hyperparameter ruimte, en zal worden doorzocht om de beste combinatie van argumenten te vinden:

grid_space={'max_depth':[3,5,10,Geen], 'n_estimators':[10,100,200], 'max_features':[1,3,5,7], 'min_samples_leaf':[1,2,3] , 'min_samples_split':[1,2,3] }

Rasterzoekopdracht uitvoeren

Nu moeten we de zoekopdracht uitvoeren om de beste hyperparametercombinatie voor het model te vinden:

van sklearn.model_selection importeren GridSearchCV grid = GridSearchCV(rf,param_grid=grid_space,cv=3,scoring='accuracy') model_grid = grid.fit(X,y)

Modelresultaten evalueren

Laten we ten slotte de beste modelnauwkeurigheid afdrukken, samen met de set hyperparameters die deze score opleverden:

print('Beste hyperparameters zijn: '+str(model_grid.best_params_)) print('Beste score is: '+str(model_grid.best_score_))

Het beste model leverde een nauwkeurigheidsscore op van ongeveer 0.74, en de hyperparameters zijn als volgt:

Laten we nu willekeurig zoeken op dezelfde dataset om te zien of we vergelijkbare resultaten krijgen.

Stap 5: Willekeurig zoeken implementeren met Scikit-Learn

De hyperparameterruimte definiëren

Laten we nu de hyperparameterruimte definiëren om willekeurig zoeken te implementeren. Deze parameterruimte kan een groter waardenbereik hebben dan degene die we hebben gebouwd voor zoeken in rasters, aangezien willekeurig zoeken niet elke afzonderlijke combinatie van hyperparameters uitprobeert.

Het bemonstert willekeurig hyperparameters om de beste te vinden, wat betekent dat in tegenstelling tot rasterzoeken, willekeurig zoeken snel door een groot aantal waarden kan kijken.

van scipy.stats import randint rs_space={'max_depth':list(np.arange(10, 100, step=10)) + [Geen], 'n_estimators':np.arange(10, 500, step=50), 'max_features':randint(1,7), 'criterium':['gini','entropy'], 'min_samples_leaf':randint(1,4), 'min_samples_split':np.arange(2, 10, step= 2) }

Willekeurig zoeken

Voer de volgende regels code uit om willekeurig te zoeken op het model: (Merk op dat we hebben gespecificeerd n_iter=500, wat betekent dat de willekeurige zoekopdracht 500 keer wordt uitgevoerd voordat het beste model wordt gekozen. U kunt experimenteren met een ander aantal iteraties om te zien welke u optimale resultaten geeft. Houd er rekening mee dat een groot aantal iteraties zal resulteren in betere prestaties, maar tijdrovend is).

van sklearn.model_selection importeren RandomizedSearchCV rf = RandomForestClassifier() rf_random = RandomizedSearchCV(rf, spatie, n_iter=500, scoren='accuracy', n_jobs=-1, cv=3) model_random = rf_random.fit(X,y)

Modelresultaten evalueren

Voer nu de volgende regels code uit om de beste hyperparameters af te drukken die zijn gevonden door willekeurig te zoeken, samen met de hoogste nauwkeurigheid van het beste model:

print('Beste hyperparameters zijn: '+str(model_random.best_params_)) print('Beste score is: '+str(model_random.best_score_))

De beste hyperparameters gevonden door willekeurig zoeken zijn als volgt:

De hoogste nauwkeurigheid van alle gebouwde modellen is ook ongeveer 0.74.

Merk op dat zowel rasterzoeken als willekeurig zoeken redelijk goed presteerden op de dataset. Houd er rekening mee dat als u een willekeurige zoekopdracht uitvoert op dezelfde code, uw resultaten uiteindelijk heel anders kunnen zijn dan wat ik hierboven heb weergegeven.

Dit komt omdat het een zeer groot parameterraster doorzoekt met behulp van willekeurige initialisatie, wat resultaten kan opleveren die dramatisch variëren elke keer dat u de techniek gebruikt.

Volledige code

Hier is de volledige code die in de zelfstudie wordt gebruikt:

# importeert panda's importeren als pd importeert numpy als np uit sklearn.ensemble importeert RandomForestClassifier uit sklearn.model_selection importeert GridSearchCV uit scipy.stats importeert randint uit sklearn.model_selection importeert RandomizedSearchCV # leest de dataset df = pd.read_csv('winequality-red.csv ') # voorbewerking df['target'] = np.where(df['quality']>5, 1, 0) df2 = df.drop(['quality'],axis=1) X = df2.drop( ['target'],axis=1) y = df2[['target']] # willekeurig bos initialiseren rf = RandomForestClassifier() # raster zoeken cv grid_space={'max_depth':[3,5,10,None], 'n_schatters':[10,100,200], 'max_features':[1,3,5,7], 'min_samples_leaf':[1,2,3], 'min_samples_split':[1,2,3] } grid = GridSearchCV( rf,param_grid=grid_space,cv=3,scoring='accuracy') model_grid = grid.fit(X,y) # grid zoekresultaten print('Beste grid zoek hyperparameters zijn: '+str(model_grid.best_params_)) print( 'Beste grid zoekscore is: '+str(model_grid.best_score_)) # random search cv rs_space={'max_depth':list(np.arange(10, 100, step=10)) + [None], 'n_estimators' :np.arange(10, 500, step=50), 'max_features':randint(1,7), 'criterium':['gini','entropy'], 'min_samples_leaf':randint(1,4), 'min_samples_split':np.arange(2, 10, step=2) } rf = RandomForestClassifier() rf_random = RandomizedSearchCV(rf, rs_space, n_iter=500, scoring='accuracy', n_jobs=-1, cv=3) model_random = rf_random.fit(X,y) # willekeurige willekeurige zoekresultaten print('Beste willekeurige zoekhyperparameters zijn: '+str(model_random.best_params_)) print('Beste willekeurige zoekscore is: '+str(model_random.best_score_))

Als u ooit merkt dat u probeert te kiezen tussen rasterzoeken en willekeurig zoeken, volgen hier enkele tips om u te helpen beslissen welke u wilt gebruiken:

1. Gebruik rasterzoekopdracht als u al een reeks bekende hyperparameterwaarden hebt die goed zullen presteren. Zorg ervoor dat u uw parameterruimte klein houdt, omdat het zoeken naar rasters extreem tijdrovend kan zijn.
2. Gebruik willekeurig zoeken op een breed scala aan waarden als u nog geen idee heeft van de parameters die goed zullen presteren op uw model. Willekeurig zoeken is sneller dan zoeken in een raster en moet altijd worden gebruikt als u een grote parameterruimte hebt.
3. Het is ook een goed idee om zowel willekeurig zoeken als rasterzoeken te gebruiken om de best mogelijke resultaten te krijgen.

U kunt eerst willekeurig zoeken met een grote parameterruimte, omdat dit sneller is. Gebruik vervolgens de beste hyperparameters die zijn gevonden door willekeurig te zoeken om het parameterraster te verfijnen en voer een kleiner bereik van waarden in voor het zoeken naar het raster.

 
 
Natasha Selvaraj is een autodidactische datawetenschapper met een passie voor schrijven. Je kunt contact met haar opnemen op LinkedIn.