hyperparameter_hunter

HyperparameterHunter

Salvar e aprender automaticamente com os resultados do experimento, levando a uma otimização persistente de longo prazo que se lembra de todos os seus testes.

O HyperParameterHunter fornece um invólucro para algoritmos de aprendizado de máquina que salva todos os dados importantes. Simplifique o processo de ajuste de experimentação e hiperparâmetro, permitindo que o HyperParameterHunter faça o trabalho duro de gravar, organizar e aprender com seus testes - enquanto usa as mesmas bibliotecas que você já faz. Não deixe que nenhum de seus experimentos seja desperdiçado e comece a fazer otimização de hiperparâmetro da maneira que deveria ser.

• INSTALAÇÃO: pip install hyperparameter-hunter
• Fonte: https://github.com/hunstermcgushion/hyperparameter_hunter
• Documentação: https://hyperparameter-hunter.readthedocs.io

Características

• Gravar automaticamente os resultados do experimento
• Otimização de hiperparâmetro verdadeiramente informada que usa automaticamente experimentos anteriores
• Elimine o código de caldeira para loops de validação cruzada, previsão e pontuação
• Pare de se preocupar em acompanhar os hiperparâmetros, pontuações ou executar novamente os mesmos experimentos
• Use as bibliotecas e utilitários que você já ama

Como usar o HyperParameterHunter

Não pense no HyperparameterHunter como outra biblioteca de otimização que você traz apenas na hora de fazer otimização de hiperparâmetro. Obviamente, faz otimização, mas é melhor ver o HyperParameterHunter como sua caixa de ferramentas/assistente de aprendizado de máquina pessoal.

A idéia é começar a usar o HyperParameterHunter imediatamente. Execute todas as suas experiências de referência/ponta-de-referência.

Quanto mais você usar o HyperParameterHunter, melhores serão seus resultados. Se você apenas usá -lo para otimização, com certeza, fará o que você deseja, mas isso está perdendo o ponto do HyperParameterHunter.

Se você o usa para experimentação e otimização ao longo de todo o curso do seu projeto, quando você decide fazer otimização de hiperparâmetro, o HyperparameterHunter já está ciente de tudo o que você fez, e foi aí que o HyperParameterHunter faz algo notável. Não começa a otimização do zero, como outras bibliotecas. Começa a partir de todas as experiências e rodadas de otimização anteriores que você já passou por ele.

Começando

1) Ambiente:

Configure um ambiente para organizar experimentos e resultados de otimização.
Quaisquer experimentos ou rodadas de otimização que realizamos usarão nosso ambiente ativo.

 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) Experimentação individual:

Realize experimentos com suas bibliotecas favoritas simplesmente fornecendo aos inicializadores de modelos e hiperparâmetro

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) Otimização de hiperparâmetro:

Assim como experimentos, mas se você quiser otimizar um hiperparâmetro, use as classes importadas abaixo

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

Estrutura de arquivo de saída

Esta é uma ilustração simples da estrutura de arquivos que você pode esperar que seus Experiment sejam gerados. Para uma descrição aprofundada da estrutura do diretório e o conteúdo dos vários arquivos, consulte a seção Visão geral da estrutura do arquivo na documentação. No entanto, os itens essenciais são os seguintes:

1. Um Experiment adiciona um arquivo a cada subdiretório HyperParameterHuNTERASSETSETS/EXPERIMENTS , nomeado por experiment_id
2. Cada Experiment também adiciona uma entrada para hyperparameterhunterassets/liderança/globaladerboard.csv
3. Personalize quais arquivos são criados por meio do Environment file_blacklist e do_full_save Kwargs (documentado aqui)

 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>

Instalação

 pip install hyperparameter-hunter

Se você gosta de estar na ponta e deseja todos os desenvolvimentos mais recentes, execute:

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

Se você deseja contribuir para o HyperParameterHunter, comece aqui.

Eu ainda não entendo

Isso está ok. Não se sinta mal. É um pouco estranho envolver sua cabeça. Aqui está um exemplo que ilustra como tudo está relacionado:

 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) 

Bibliotecas testadas

• Keras
• Scikit-Learn
• LightGBM
• Catboost
• Xgboost
• rgf_python
• ... mais a caminho

Botchas/FAQs

Estas são algumas coisas que podem "getcha"

Em geral:

• Não é possível fornecer pontos de pesquisa iniciais para OptPro ?
  • Isso é intencional. Se você deseja que suas rodadas de otimização comecem com pontos de pesquisa específicos (que você ainda não gravou), basta executar um CVExperiment antes de inicializar seu OptPro
  • Supondo que os dois tenham os mesmos hiperparâmetros de diretrizes e o Experiment se encaixe no espaço de pesquisa definido pelo seu OptPro , o otimizador será localizado e lido nos resultados do Experiment
  • Lembre -se de que você provavelmente desejará remover o Experiment depois de fazer isso uma vez, pois os resultados foram salvos. Deixando lá apenas executará o mesmo Experiment repetidamente
• Depois de mudar as coisas no meu diretório "hyperparameterhunterassets", tudo parou de funcionar
  • Sim, não faça isso. Especialmente não com "descrições", "tabelas de classificação" ou "Testedkeys"
  • O HyperParameterHunter descobre o que está acontecendo lendo esses arquivos diretamente.
  • Removendo -os ou alterar seu conteúdo pode quebrar muito a funcionalidade do HyperParameterHunter

Keras:

• Não consegue encontrar experimentos semelhantes com redes neurais de densas/ativação simples?
  • Isso provavelmente é causado pela alternância entre o uso de uma camada Activation separada e o fornecimento de uma camada Dense com a activation Kwarg
  • Cada camada é tratada como seu próprio pequeno conjunto de hiperparâmetros (além de ser um hiperparâmetro, o próprio), o que significa que, no que diz respeito ao hiperparameterhunter, os dois exemplos a seguir não são equivalentes:
    • Dense(10, activation='sigmoid')
    • Dense(10); Activation('sigmoid')
  • Estamos trabalhando nisso, mas por enquanto, a solução alternativa é apenas para ser consistente com a forma como você adiciona ativações aos seus modelos
    • Use camadas Activation separadas ou forneça Kwargs activation para outras camadas e fique com ela!
• Não é possível otimizar os argumentos model.compile : optimizer e optimizer_params ao mesmo tempo?
  • Isso acontece porque optimizers de Keras esperam argumentos diferentes
  • Por exemplo, quando optimizer=Categorical(['adam', 'rmsprop']) , existem dois ditos possíveis diferentes de optimizer_params
  • Por enquanto, você pode otimizar apenas optimizer e optimizer_params separadamente
  • Uma boa maneira de fazer isso pode ser selecionar alguns otimizadores que você deseja testar e não fornecer um valor optimizer_params . Dessa forma, cada optimizer usará seus parâmetros padrão
    • Em seguida, você pode selecionar qual optimizer foi o melhor e definir optimizer=<best optimizer> e depois passar para ajustar optimizer_params , com argumentos específicos para o optimizer que você selecionou

Catboost:

• Não consegue encontrar experimentos semelhantes para o Catboost?
  • Isso pode estar acontecendo porque os valores padrão para os Kwargs esperados nos métodos do modelo de Catboost __init__ são definidos em outro lugar e dados os valores de None espaço de espaço reservado em suas assinaturas
  • Por causa disso, o HyperParameterHunter assume que o valor padrão para um argumento realmente não é None se você não fornecer explicitamente um valor para esse argumento
  • Obviamente, esse não é o caso, mas não consigo descobrir onde estão localizados os valores padrão reais usados ​​pelo Catboost; portanto, se alguém souber como remediar essa situação, eu adoraria sua ajuda!