hyperparameter_hunter

Hyperparameterhunter

Speichern und lernen Sie automatisch aus experimentellen Ergebnissen, was zu einer langfristigen, anhaltenden Optimierung führt, die sich an alle Ihre Tests erinnert.

Hyperparameterhunter bietet einen Wrapper für Algorithmen für maschinelles Lernen, der alle wichtigen Daten spart. Vereinfachen Sie das Experimentieren und den Hyperparameter -Abstimmungsprozess, indem Sie Hyperparameterhunter die harte Aufzeichnung, Organisation und Lernen aus Ihren Tests durchführen lassen, während Sie dieselben Bibliotheken verwenden, die Sie bereits durchführen. Lassen Sie sich nicht von Ihren Experimenten verschwenden und beginnen Sie die Hyperparameteroptimierung so, wie es sein sollte.

• Installation: pip install hyperparameter-hunter
• Quelle: https://github.com/huntermcgus/hyperparameter_hunter
• Dokumentation: https://hyperparameter-hunter.readthedocs.io

Merkmale

• Erfassen Sie automatisch Experimentergebnisse
• Wirklich informierte Hyperparameteroptimierung, die automatisch frühere Experimente verwendet
• Beseitigen Sie den Kesselplattencode für Kreuzvalidierungsschleifen, Vorhersagen und Bewertungen
• Hör auf, dir Sorgen zu machen, Hyperparameter, Punktzahlen oder die gleichen Experimente erneut zu verfolgen
• Verwenden Sie die Bibliotheken und Dienstprogramme, die Sie bereits lieben

So verwenden Sie Hyperparameterhunter

Denken Sie nicht an Hyperparameterhunter als eine weitere Optimierungsbibliothek, die Sie nur dann herausbringen, wenn es Zeit für die Hyperparameteroptimierung durchführt. Natürlich ist es optimiert, aber es ist besser, Hyperparameterhunter als Ihren eigenen Toolbox/Assistenten für persönliches maschinelles Lernen zu betrachten.

Die Idee ist, sofort Hyperparameterhunter zu verwenden. Führen Sie alle Ihre Benchmark-/einmaligen Experimente durch.

Je mehr Sie Hyperparameterhunter verwenden, desto besser werden Ihre Ergebnisse sein. Wenn Sie es nur zur Optimierung verwenden, wird es sicher, was Sie wollen, aber das fehlt den Punkt des Hyperparameterhunter.

Wenn Sie es für Experimente und Optimierung entlang des gesamten Verlaufs Ihres Projekts verwendet haben, ist Hyperparameterhunter bereits alles, was Sie getan haben, Hyperparameterhunter, wenn Sie sich für eine Hyperparameteroptimierung entscheiden, und dann macht Hyperparameterhunter etwas Bemerkenswertes. Es startet nicht wie andere Bibliotheken von Grund auf neu. Es beginnt mit allen Experimenten und früheren Optimierungsrunden, die Sie bereits durchlaufen haben.

Erste Schritte

1) Umgebung:

Richten Sie eine Umgebung ein, um Experimente und Optimierungsergebnisse zu organisieren.
Alle Experimente oder Optimierungsrunden, die wir durchführen, werden unsere aktive Umgebung nutzen.

 from hyperparameter_hunter import Environment , CVExperiment
import pandas as pd
from sklearn . datasets import load_breast_cancer
from sklearn . model_selection import StratifiedKFold

data = load_breast_cancer ()
df = pd . DataFrame ( data = data . data , columns = data . feature_names )
df [ 'target' ] = data . target

env = Environment (
    train_dataset = df ,  # Add holdout/test dataframes, too
    results_path = 'path/to/results/directory' ,  # Where your result files will go
    metrics = [ 'roc_auc_score' ],  # Callables, or strings referring to `sklearn.metrics`
    cv_type = StratifiedKFold ,  # Class, or string in `sklearn.model_selection`
    cv_params = dict ( n_splits = 5 , shuffle = True , random_state = 32 )
)

2) individuelles Experimentieren:

Führen Sie Experimente mit Ihren Lieblingsbibliotheken durch, indem Sie einfach Modellinitialisierer und Hyperparameter bereitstellen

Keras

 # Same format used by `keras.wrappers.scikit_learn`. Nothing new to learn
def build_fn ( input_shape ):  # `input_shape` calculated for you
    model = Sequential ([
        Dense ( 100 , kernel_initializer = 'uniform' , input_shape = input_shape , activation = 'relu' ),
        Dropout ( 0.5 ),
        Dense ( 1 , kernel_initializer = 'uniform' , activation = 'sigmoid' )
    ])  # All layer arguments saved (whether explicit or Keras default) for future use
    model . compile ( optimizer = 'adam' , loss = 'binary_crossentropy' , metrics = [ 'accuracy' ])
    return model

experiment = CVExperiment (
    model_initializer = KerasClassifier ,
    model_init_params = build_fn ,  # We interpret your build_fn to save hyperparameters in a useful, readable format
    model_extra_params = dict (
        callbacks = [ ReduceLROnPlateau ( patience = 5 )],  # Use Keras callbacks
        batch_size = 32 , epochs = 10 , verbose = 0  # Fit/predict arguments
    )
)

Sklearn

 experiment = CVExperiment (
    model_initializer = LinearSVC ,  # (Or any of the dozens of other SK-Learn algorithms)
    model_init_params = dict ( penalty = 'l1' , C = 0.9 )  # Default values used and recorded for kwargs not given
)

Xgboost

 experiment = CVExperiment (
    model_initializer = XGBClassifier ,
    model_init_params = dict ( objective = 'reg:linear' , max_depth = 3 , n_estimators = 100 , subsample = 0.5 )
)

Lightgbm

 experiment = CVExperiment (
    model_initializer = LGBMClassifier ,
    model_init_params = dict ( boosting_type = 'gbdt' , num_leaves = 31 , max_depth = - 1 , min_child_samples = 5 , subsample = 0.5 )
)

Catboost

 experiment = CVExperiment (
    model_initializer = CatboostClassifier ,
    model_init_params = dict ( iterations = 500 , learning_rate = 0.01 , depth = 7 , allow_writing_files = False ),
    model_extra_params = dict ( fit = dict ( verbose = True ))  # Send kwargs to `fit` and other extra methods
)

RGF

 experiment = CVExperiment (
    model_initializer = RGFClassifier ,
    model_init_params = dict ( max_leaf = 1000 , algorithm = 'RGF' , min_samples_leaf = 10 )
)

3) Hyperparameteroptimierung:

Genau wie Experimente, aber wenn Sie einen Hyperparameter optimieren möchten, verwenden Sie die unten importierten Klassen

 from hyperparameter_hunter import Real , Integer , Categorical
from hyperparameter_hunter import optimization as opt

Keras

 def build_fn ( input_shape ):
    model = Sequential ([
        Dense ( Integer ( 50 , 150 ), input_shape = input_shape , activation = 'relu' ),
        Dropout ( Real ( 0.2 , 0.7 )),
        Dense ( 1 , activation = Categorical ([ 'sigmoid' , 'softmax' ]))
    ])
    model . compile (
        optimizer = Categorical ([ 'adam' , 'rmsprop' , 'sgd' , 'adadelta' ]),
        loss = 'binary_crossentropy' , metrics = [ 'accuracy' ]
    )
    return model

optimizer = opt . RandomForestOptPro ( iterations = 7 )
optimizer . forge_experiment (
    model_initializer = KerasClassifier ,
    model_init_params = build_fn ,
    model_extra_params = dict (
        callbacks = [ ReduceLROnPlateau ( patience = Integer ( 5 , 10 ))],
        batch_size = Categorical ([ 32 , 64 ]),
        epochs = 10 , verbose = 0
    )
)
optimizer . go ()

Sklearn

 optimizer = opt . DummyOptPro ( iterations = 42 )
optimizer . forge_experiment (
    model_initializer = AdaBoostClassifier ,  # (Or any of the dozens of other SKLearn algorithms)
    model_init_params = dict (
        n_estimators = Integer ( 75 , 150 ),
        learning_rate = Real ( 0.8 , 1.3 ),
        algorithm = 'SAMME.R'
    )
)
optimizer . go ()

Xgboost

 optimizer = opt . BayesianOptPro ( iterations = 10 )
optimizer . forge_experiment (
    model_initializer = XGBClassifier ,
    model_init_params = dict (
        max_depth = Integer ( low = 2 , high = 20 ),
        learning_rate = Real ( 0.0001 , 0.5 ),
        n_estimators = 200 ,
        subsample = 0.5 ,
        booster = Categorical ([ 'gbtree' , 'gblinear' , 'dart' ]),
    )
)
optimizer . go ()

Lightgbm

 optimizer = opt . BayesianOptPro ( iterations = 100 )
optimizer . forge_experiment (
    model_initializer = LGBMClassifier ,
    model_init_params = dict (
        boosting_type = Categorical ([ 'gbdt' , 'dart' ]),
        num_leaves = Integer ( 5 , 20 ),
        max_depth = - 1 ,
        min_child_samples = 5 ,
        subsample = 0.5
    )
)
optimizer . go ()

Catboost

 optimizer = opt . GradientBoostedRegressionTreeOptPro ( iterations = 32 )
optimizer . forge_experiment (
    model_initializer = CatBoostClassifier ,
    model_init_params = dict (
        iterations = 100 ,
        eval_metric = Categorical ([ 'Logloss' , 'Accuracy' , 'AUC' ]),
        learning_rate = Real ( low = 0.0001 , high = 0.5 ),
        depth = Integer ( 4 , 7 ),
        allow_writing_files = False
    )
)
optimizer . go ()

RGF

 optimizer = opt . ExtraTreesOptPro ( iterations = 10 )
optimizer . forge_experiment (
    model_initializer = RGFClassifier ,
    model_init_params = dict (
        max_leaf = 1000 ,
        algorithm = Categorical ([ 'RGF' , 'RGF_Opt' , 'RGF_Sib' ]),
        l2 = Real ( 0.01 , 0.3 ),
        normalize = Categorical ([ True , False ]),
        learning_rate = Real ( 0.3 , 0.7 ),
        loss = Categorical ([ 'LS' , 'Expo' , 'Log' , 'Abs' ])
    )
)
optimizer . go ()

Ausgabedateistruktur

Dies ist eine einfache Abbildung der Dateistruktur, von der Sie erwarten können, dass Ihre Experiment generieren. Eine eingehende Beschreibung der Verzeichnisstruktur und des Inhalts der verschiedenen Dateien finden Sie im Abschnitt "Dateistrukturübersicht in der Dokumentation". Das Nötigste ist jedoch wie folgt:

1. Ein Experiment fügt jeder Hyperparameterhunterassets/Experimente eine Datei hinzu, die von experiment_id benannt ist
2. Jedes Experiment fügt auch einen Eintrag in Hyperparameterhunterassets/Ranglisten/Globalleaderboard.csv hinzu
3. Passen Sie an, welche Dateien über file_blacklist von Environment erstellt werden und do_full_save kwargs (hier dokumentiert)

 HyperparameterHunterAssets
|   Heartbeat.log
|
└───Experiments
|   |
|   └───Descriptions
|   |   |   <Files describing Experiment results, conditions, etc.>.json
|   |
|   └───Predictions<OOF/Holdout/Test>
|   |   |   <Files containing Experiment predictions for the indicated dataset>.csv
|   |
|   └───Heartbeats
|   |   |   <Files containing the log produced by the Experiment>.log
|   |
|   └───ScriptBackups
|       |   <Files containing a copy of the script that created the Experiment>.py
|
└───Leaderboards
|   |   GlobalLeaderboard.csv
|   |   <Other leaderboards>.csv
|
└───TestedKeys
|   |   <Files named by Environment key, containing hyperparameter keys>.json
|
└───KeyAttributeLookup
    |   <Files linking complex objects used in Experiments to their hashes>

Installation

 pip install hyperparameter-hunter

Wenn Sie gerne auf dem neuesten Stand sind und die neuesten Entwicklungen möchten, rennen Sie:

 pip install git+https://github.com/HunterMcGushion/hyperparameter_hunter.git

Wenn Sie zum Hyperparameterhunter beitragen möchten, beginnen Sie hier.

Ich verstehe es immer noch nicht

Das ist in Ordnung. Fühle dich nicht schlecht. Es ist ein bisschen komisch, Ihren Kopf herumzuwickeln. Hier ist ein Beispiel, das zeigt, wie alles verwandt ist:

 from hyperparameter_hunter import Environment , CVExperiment , BayesianOptPro , Integer
from hyperparameter_hunter . utils . learning_utils import get_breast_cancer_data
from xgboost import XGBClassifier

# Start by creating an `Environment` - This is where you define how Experiments (and optimization) will be conducted
env = Environment (
    train_dataset = get_breast_cancer_data ( target = 'target' ),
    results_path = 'HyperparameterHunterAssets' ,
    metrics = [ 'roc_auc_score' ],
    cv_type = 'StratifiedKFold' ,
    cv_params = dict ( n_splits = 10 , shuffle = True , random_state = 32 ),
)

# Now, conduct an `Experiment`
# This tells HyperparameterHunter to use the settings in the active `Environment` to train a model with these hyperparameters
experiment = CVExperiment (
    model_initializer = XGBClassifier ,
    model_init_params = dict (
        objective = 'reg:linear' ,
        max_depth = 3
    )
)

# That's it. No annoying boilerplate code to fit models and record results
# Now, the `Environment`'s `results_path` directory will contain new files describing the Experiment just conducted

# Time for the fun part. We'll set up some hyperparameter optimization by first defining the `OptPro` (Optimization Protocol) we want
optimizer = BayesianOptPro ( verbose = 1 )

# Now we're going to say which hyperparameters we want to optimize.
# Notice how this looks just like our `experiment` above
optimizer . forge_experiment (
    model_initializer = XGBClassifier ,
    model_init_params = dict (
        objective = 'reg:linear' ,  # We're setting this as a constant guideline - Not one to optimize
        max_depth = Integer ( 2 , 10 )  # Instead of using an int like the `experiment` above, we provide a space to search
    )
)
# Notice that our range for `max_depth` includes the `max_depth=3` value we used in our `experiment` earlier

optimizer . go ()  # Now, we go

assert experiment . experiment_id in [ _ [ 2 ] for _ in optimizer . similar_experiments ]
# Here we're verifying that the `experiment` we conducted first was found by `optimizer` and used as learning material
# You can also see via the console that we found `experiment`'s saved files, and used it to start optimization

last_experiment_id = optimizer . current_experiment . experiment_id
# Let's save the id of the experiment that was just conducted by `optimizer`

optimizer . go ()  # Now, we'll start up `optimizer` again...

# And we can see that this second optimization round learned from both our first `experiment` and our first optimization round
assert experiment . experiment_id in [ _ [ 2 ] for _ in optimizer . similar_experiments ]
assert last_experiment_id in [ _ [ 2 ] for _ in optimizer . similar_experiments ]
# It even did all this without us having to tell it what experiments to learn from

# Now think about how much better your hyperparameter optimization will be when it learns from:
# - All your past experiments, and
# - All your past optimization rounds
# And the best part: HyperparameterHunter figures out which experiments are compatible all on its own
# You don't have to worry about telling it that KFold=5 is different from KFold=10,
# Or that max_depth=12 is outside of max_depth=Integer(2, 10) 

Getestete Bibliotheken

• Keras
• Scikit-Learn
• Lightgbm
• Catboost
• Xgboost
• rgf_python
• ... mehr auf dem Weg

Gotchas/faqs

Dies sind einige Dinge, die "Getcha" könnten

Allgemein:

• Sie können OptPro keine ersten Suchpunkte angeben?
  • Dies ist beabsichtigt. Wenn Sie möchten, dass Ihre Optimierungsrunden mit bestimmten Suchpunkten beginnen (die Sie noch nicht aufgezeichnet haben), führen Sie einfach ein CVExperiment durch, bevor Sie Ihr OptPro initialisieren
  • Angenommen, die beiden haben die gleichen Richtlinienhyperparameter und das Experiment passt in den von Ihrem OptPro definierten Suchraum, und der Optimierer befindet sich in den Ergebnissen des Experiment und lesen
  • Denken Sie daran, dass Sie das Experiment wahrscheinlich entfernen möchten, nachdem Sie es einmal gemacht haben, da die Ergebnisse gespeichert wurden. Es wird das gleiche Experiment immer wieder durchführen
• Nachdem alles in meinem Verzeichnis "Hyperparameterhunterassets" geändert wurde, hörte alles auf, zu funktionieren
  • Ja, tu das nicht. Besonders nicht mit "Beschreibungen", "Bestenlisten" oder "TestedKeys"
  • Hyperparameterhunter ermittelt, was vor sich geht, indem Sie diese Dateien direkt lesen.
  • Das Entfernen oder Ändern ihres Inhalts kann eine Menge Hyperparameterhunter -Funktionalität brechen

Keras:

• Sie können ähnliche Experimente nicht mit einfachen dichten/Aktivierung neuronaler Netzwerke finden?
  • Dies wird wahrscheinlich durch Schalten zwischen der Verwendung einer separaten Activation und der Bereitstellung einer Dense Schicht mit dem activation verursacht
  • Jede Schicht wird als eigene kleine Hyperparameter (sowie ein Hyperparameter selbst) behandelt, was bedeutet, dass die folgenden zwei Beispiele nicht gleichwertig sind:
    • Dense(10, activation='sigmoid')
    • Dense(10); Activation('sigmoid')
  • Wir arbeiten daran, aber im Moment soll die Problemumgehung nur damit übereinstimmen, wie Sie Ihren Modellen Aktivierungen hinzufügen
    • Verwenden Sie entweder separate Activation oder geben Sie activation für andere Schichten an und bleiben Sie dabei!
• Sie können die Argumente model.compile nicht optimieren: optimizer und optimizer_params gleichzeitig?
  • Dies geschieht, weil optimizers von Keras unterschiedliche Argumente erwarten
  • Zum Beispiel, wenn optimizer=Categorical(['adam', 'rmsprop']) , gibt es zwei verschiedene mögliche Diktate von optimizer_params
  • Im Moment können Sie optimizer und optimizer_params nur separat optimieren
  • Eine gute Möglichkeit, dies zu tun, könnte darin bestehen, einige Optimierer auszuwählen, die Sie testen möchten, und keinen optimizer_params -Wert bereitstellen. Auf diese Weise verwendet jeder optimizer seine Standardparameter
    • Anschließend können Sie auswählen, welcher optimizer der beste war, und setze optimizer=<best optimizer> und dann mit den von Ihnen ausgewählten optimizer spezifischen Argumenten für den Tuning optimizer_params .

Catboost:

• Sie können ähnliche Experimente für Catboost nicht finden?
  • Dies kann geschehen, da die Standardwerte für die KWARGs, die in Catboost -Modell __init__ -Methoden None werden
  • Aus diesem Grund None Hyperparameterhunter davon aus
  • Dies ist offensichtlich nicht der Fall, aber ich kann einfach nicht herausfinden, wo sich die tatsächlichen Standardwerte von Catboost befinden. Wenn also jemand weiß, wie man diese Situation behebt, würde ich Ihre Hilfe lieben!