hyperparameter_hunter

Hiperparameterhunter

Guardar y aprender automáticamente de los resultados del experimento, lo que lleva a una optimización persistente a largo plazo que recuerda todas sus pruebas.

Hyperparameterhunter proporciona un envoltorio para algoritmos de aprendizaje automático que guarda todos los datos importantes. Simplifique la experimentación y el proceso de ajuste de hiperparameter al permitir que HyperParameterhunter haga el trabajo duro de grabar, organizar y aprender de sus pruebas, todo mientras usa las mismas bibliotecas que ya hace. No permita que ninguno de sus experimentos se desperdicie y comience a hacer la optimización de hiperparameter de la manera que debía ser.

• Instalación: pip install hyperparameter-hunter
• Fuente: https://github.com/huntermcgushion/hyperparameter_hunter
• Documentación: https://hyperparameter-hunter.readthedocs.io

Características

• Registre automáticamente los resultados del experimento
• Optimización de hiperparameter verdaderamente informada que utiliza automáticamente experimentos pasados
• Eliminar el código de la placa para bucles de validación cruzada, predicción y puntuación
• Deja de preocuparte por realizar un seguimiento de los hiperparámetros, puntajes o volver a ejecutar los mismos experimentos
• Use las bibliotecas y los servicios públicos que ya amas

Cómo usar Hyperparameterhunter

No piense en Hyperparameterhunter como otra biblioteca de optimización que usted solo saca cuando es hora de hacer la optimización de hiperparameter. Por supuesto, hace optimización, pero es mejor ver HyperParameterHunter como su propia caja de herramientas/asistente de aprendizaje automático personal.

La idea es comenzar a usar HyperparameterHunter de inmediato. Ejecute todos sus experimentos de referencia/único a través de él.

Cuanto más use HyperParameterHunter, mejores serán sus resultados. Si solo lo usa para la optimización, claro, hará lo que desea, pero eso le falta el punto de Hyperparameterhunter.

Si lo ha estado utilizando para experimentación y optimización a lo largo de todo el curso de su proyecto, entonces cuando decide hacer optimización de hiperparameter, Hyperparameterhunter ya es consciente de todo lo que ha hecho, y es cuando Hyperparameterhunter hace algo notable. No comienza a la optimización desde cero como otras bibliotecas. Comienza desde todos los experimentos y rondas de optimización anteriores que ya ha realizado.

Empezando

1) Entorno:

Configure un entorno para organizar experimentos y resultados de optimización.
Cualquier experimento u rondas de optimización que realicemos utilizará nuestro entorno activo.

 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) Experimentación individual:

Realice experimentos con sus bibliotecas favoritas simplemente proporcionando inicializadores de modelos e hiperparametros

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

Gatboost

 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) Optimización de hiperparameter:

Al igual que los experimentos, pero si desea optimizar un hiperparámetro, use las clases importadas a continuación

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

Gatboost

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

Estructura de archivo de salida

Esta es una ilustración simple de la estructura del archivo que puede esperar que generen sus Experiment . Para obtener una descripción en profundidad de la estructura del directorio y el contenido de los diversos archivos, consulte la sección Descripción general de la estructura del archivo en la documentación. Sin embargo, los elementos esenciales son los siguientes:

1. Un Experiment agrega un archivo a cada subdirectorio de HyperparameterhunterAssets/Experiments , nombrado por experiment_id
2. Cada Experiment también agrega una entrada a HyperParameterhunterassets/Riadingboards/GlobalLeaderboard.csv
3. Personalizar qué archivos se crean a través de file_blacklist y do_full_save kwargs de Environment (documentado aquí)

 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>

Instalación

 pip install hyperparameter-hunter

Si te gusta estar en la vanguardia y quieres todos los desarrollos más recientes, ejecute:

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

Si desea contribuir a HyperparameterHunter, comience aquí.

Todavía no lo entiendo

Eso está bien. No te sientas mal. Es un poco extraño envolver la cabeza. Aquí hay un ejemplo que ilustra cómo está todo 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 probadas

• Keras
• lear
• Lightgbm
• Gatboost
• Xgboost
• rgf_python
• ... más en camino

Gotchas/Preguntas frecuentes

Estas son algunas cosas que podrían "Getcha"

General:

• ¿No puedes proporcionar puntos de búsqueda iniciales a OptPro ?
  • Esto es intencional. Si desea que sus rondas de optimización comiencen con puntos de búsqueda específicos (que aún no ha grabado), simplemente realice un CVExperiment antes de inicializar su OptPro
  • Suponiendo que los dos tienen los mismos hiperparámetros de directriz y el Experiment se ajuste dentro del espacio de búsqueda definido por su OptPro , el optimizador se ubicará y leerá en los resultados del Experiment
  • Tenga en cuenta que probablemente querrá eliminar el Experiment después de haberlo hecho una vez, ya que los resultados se han guardado. Dejarlo allí simplemente ejecutará el mismo Experiment una y otra vez
• Después de cambiar las cosas en mi directorio de "Hyperparameterhunterassets", todo dejó de funcionar
  • Sí, no hagas eso. Especialmente no con "descripciones", "tablas de clasificación" o "keys probados"
  • Hyperparameterhunter descubre lo que está sucediendo leyendo estos archivos directamente.
  • Eliminarlos o cambiar su contenido puede romper mucha funcionalidad de Hyperparameterhunter

Keras:

• ¿No puedes encontrar experimentos similares con redes neuronales simples densas/de activación?
  • Esto probablemente sea causado por cambiar entre usar una capa Activation separada y proporcionar una capa Dense con la activation kwarg
  • Cada capa se trata como su propio pequeño conjunto de hiperparámetros (además de ser un hiperparámetro en sí), lo que significa que en lo que respecta a Hyperparameterhunter, los siguientes dos ejemplos no son equivalentes:
    • Dense(10, activation='sigmoid')
    • Dense(10); Activation('sigmoid')
  • Estamos trabajando en esto, pero por ahora, la solución es ser consistente con la forma en que agrega activaciones a sus modelos.
    • ¡Use capas Activation separadas o proporcione Kwargs activation a otras capas, y quédese con ello!
• optimizer_params No optimizer puede optimizar el model.compile .
  • Esto sucede porque optimizers de Keras esperan diferentes argumentos
  • Por ejemplo, cuando optimizer=Categorical(['adam', 'rmsprop']) , hay dos dictados posibles diferentes de optimizer_params
  • Por ahora, solo puede optimizar optimizer y optimizer_params por separado
  • Una buena manera de hacerlo podría ser seleccionar algunos optimizadores que desee probar y no proporcionar un valor optimizer_params . De esa manera, cada optimizer utilizará sus parámetros predeterminados
    • Luego puede seleccionar qué optimizer fue el mejor y establecer optimizer=<best optimizer> , luego pasar a ajustar optimizer_params , con argumentos específicos para el optimizer que seleccionó

Catboost:

• ¿No puedes encontrar experimentos similares para Catboost?
  • Esto puede estar sucediendo porque los valores predeterminados para los Kwargs esperados en los métodos __init__ de modelo de Catboost se definen en otro lugar, y se dan los valores de marcador de posición de None en sus firmas
  • Debido a esto, Hyperparameterhunter supone que el valor predeterminado para un argumento es realmente None si no proporciona explícitamente un valor para ese argumento
  • Obviamente, este no es el caso, pero parece que no puedo descubrir dónde se encuentran los valores predeterminados reales utilizados por Catboost, por lo que si alguien sabe cómo remediar esta situación, ¡me encantaría su ayuda!