hyperparameter_hunter

Hyperparamètre

Économisez et apprenez automatiquement les résultats de l'expérience, conduisant à une optimisation persistante à long terme qui se souvient de tous vos tests.

HyperParameterHunter fournit un emballage pour les algorithmes d'apprentissage automatique qui enregistre toutes les données importantes. Simplifiez le processus de réglage de l'expérimentation et de l'hyperparamètre en permettant à l'hyperparamètre de faire le travail acharné d'enregistrer, d'organiser et d'apprendre de vos tests - tout en utilisant les mêmes bibliothèques que vous faites déjà. Ne laissez aucune de vos expériences se perdre et commencez à faire une optimisation de l'hyperparamètre comme il était censé être.

• Installation: pip install hyperparameter-hunter
• Source: https://github.com/huntermcgushion/hyperparameter_hunter
• Documentation: https://hyperparameter-hunter.readthedocs.io

Caractéristiques

• Enregistrez automatiquement les résultats de l'expérience
• Optimisation de l'hyperparamètre vraiment informé qui utilise automatiquement des expériences passées
• Éliminez le code du chaudron pour les boucles de validation croisée, la prévision et la notation
• Arrêtez de vous soucier de garder une trace des hyperparamètres, des scores ou de relancer les mêmes expériences
• Utilisez les bibliothèques et les services publics que vous aimez déjà

Comment utiliser Hyperparamètrehunter

Ne pensez pas à HyperParameterHunter comme une autre bibliothèque d'optimisation que vous faites ressortir uniquement à l'heure de l'optimisation de l'hyperparamètre. Bien sûr, il fait l'optimisation, mais il vaut mieux considérer HyperParameterHunter comme votre propre boîte à outils / assistant d'apprentissage automatique.

L'idée est de commencer à utiliser HyperParameterHunter immédiatement. Exécutez toutes vos expériences de référence / ponctuels à travers.

Plus vous utilisez HyperParameterHunter, meilleur sera vos résultats. Si vous l'utilisez simplement pour l'optimisation, bien sûr, cela fera ce que vous voulez, mais cela manque le point de HyperparameterHunter.

Si vous l'avez utilisé pour l'expérimentation et l'optimisation tout au long de votre projet, alors lorsque vous décidez de faire une optimisation par hyperparamètre, HyperparameterHunter est déjà conscient de tout ce que vous avez fait, et c'est à ce moment-là que HyperparameterHunter fait quelque chose de remarquable. Il ne commence pas l'optimisation à partir de zéro comme les autres bibliothèques. Il commence à partir de toutes les expériences et des cycles d'optimisation précédents que vous avez déjà traversés.

Commencer

1) Environnement:

Configurez un environnement pour organiser des expériences et des résultats d'optimisation.
Toutes les expériences ou les tours d'optimisation que nous effectuons utiliseront notre environnement actif.

 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) Expérimentation individuelle:

Effectuez des expériences avec vos bibliothèques préférées simplement en fournissant des initialiseurs et des hyperparamètres modèles

Kéras

 # 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) Optimisation de l'hyperparamètre:

Tout comme les expériences, mais si vous souhaitez optimiser un hyperparamètre, utilisez les classes importées ci-dessous

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

Kéras

 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 ()

Structure du fichier de sortie

Ceci est une simple illustration de la structure de fichiers que vous pouvez vous attendre à ce que votre Experiment généreuse. Pour une description approfondie de la structure du répertoire et du contenu des différents fichiers, consultez la section Présentation de la structure des fichiers dans la documentation. Cependant, les éléments essentiels sont les suivants:

1. Une Experiment ajoute un fichier à chaque sous-répertoire hyperparameterhunterassets / expériences , nommé par experiment_id
2. Chaque Experiment ajoute également une entrée à HyperParameterHunterAssets / Leadboards / GlobAladerboard.csv
3. Personnaliser les fichiers créés via file_blacklist de Environment et do_full_save KWARGS (documenté ici)

 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

Si vous aimez être à la pointe et que vous voulez tous les derniers développements, exécutez:

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

Si vous souhaitez contribuer à HyperParameterHunter, commencez ici.

Je ne comprends toujours pas

C'est OK. Ne vous sentez pas mal. C'est un peu bizarre de vous envelopper la tête. Voici un exemple qui illustre comment tout est lié:

 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) 

Bibliothèques testées

• Kéras
• scikit-apprend
• LightGBM
• Catboost
• Xgboost
• rgf_python
• ... plus sur le chemin

Gotchas / FAQ

Ce sont certaines choses qui pourraient "getcha"

Général:

• Vous ne pouvez pas fournir des points de recherche initiaux à OptPro ?
  • C'est intentionnel. Si vous voulez que vos tours d'optimisation commencent par des points de recherche spécifiques (que vous n'avez pas encore enregistrés), effectuez simplement un CVExperiment avant d'initialiser votre OptPro
  • En supposant que les deux ont les mêmes hyperparamètres de ligne directrice et l' Experiment s'inscrit dans l'espace de recherche défini par votre OptPro , l'optimiseur se trouvera et lira dans les résultats de l' Experiment
  • Gardez à l'esprit que vous voudrez probablement supprimer l' Experiment après l'avoir fait une fois, car les résultats ont été enregistrés. Le laisser là-bas ne fera que exécuter la même Experiment encore et encore
• Après avoir changé les choses dans mon répertoire "HyperparameterHunterAssets", tout a cessé de fonctionner
  • Ouais, ne fais pas ça. Surtout pas avec des "descriptions", des "classements" ou des "TestedKeys"
  • HyperParameterHunter comprend ce qui se passe en lisant directement ces fichiers.
  • Les supprimer ou le changement de contenu peut briser beaucoup de fonctionnalité d'Hyperparamètrehunter

Keras:

• Vous ne trouvez pas d'expériences similaires avec des réseaux de neurones denses / activation simples?
  • Cela est probablement causé par la commutation entre l'utilisation d'une couche Activation séparée et la fourniture d'une couche Dense avec l' activation kwarg
  • Chaque couche est traitée comme son propre petit ensemble d'hyperparamètres (tout en étant un hyperparamètre, lui-même), ce qui signifie qu'en ce qui concerne l'hyperparamètre, les deux exemples suivants ne sont pas équivalents:
    • Dense(10, activation='sigmoid')
    • Dense(10); Activation('sigmoid')
  • Nous y travaillons, mais pour l'instant, la solution de contournement est juste pour être cohérente avec la façon dont vous ajoutez des activations à vos modèles
    • Soit utiliser des couches Activation séparées, soit fournir des kwargs activation à d'autres couches et respectez-le!
• Vous ne pouvez pas optimiser les arguments model.compile : optimizer et optimizer_params en même temps?
  • Cela se produit parce que optimizers de Keras s'attendent à des arguments différents
  • Par exemple, lorsque optimizer=Categorical(['adam', 'rmsprop']) , il existe deux dicts possibles d' optimizer_params
  • Pour l'instant, vous ne pouvez optimiser que optimizer et optimizer_params séparément
  • Une bonne façon de le faire peut être de sélectionner quelques optimisateurs que vous souhaitez tester et de ne pas fournir de valeur optimizer_params . De cette façon, chaque optimizer utilisera ses paramètres par défaut
    • Ensuite, vous pouvez sélectionner quel optimizer était le meilleur et définir optimizer=<best optimizer> , puis passer à Tuning optimizer_params , avec des arguments spécifiques à l' optimizer que vous avez sélectionné

Catboost:

• Vous ne trouvez pas d'expériences similaires pour Catboost?
  • Cela peut se produire parce que les valeurs par défaut pour les kwargs attendues dans les méthodes du modèle __init__ de Catboost sont définies ailleurs, et les valeurs d'espace réservées de None dans leurs signatures
  • Pour cette raison, HyperParameterHunter suppose que la valeur par défaut d'un argument n'est vraiment None si vous ne fournissez pas explicitement une valeur pour cet argument
  • Ce n'est évidemment pas le cas, mais je n'arrive pas à comprendre où se trouvent les valeurs par défaut réelles utilisées par Catboost, donc si quelqu'un sait comment remédier à cette situation, j'aimerais votre aide!