Os 5 kits de ferramentas mais comumente usados para otimização de hiperparâmetros de modelos de aprendizado de máquina

Otimizar hiperparâmetros é sempre uma tarefa crítica para garantir o desempenho ideal do modelo. Normalmente, técnicas como busca em grade, busca aleatória e otimização bayesiana são os principais métodos utilizados.

Hoje compartilharei vários kits de ferramentas Python comumente usados ​​para otimização de hiperparâmetros de modelo, como segue:

• scikit-learn: Use pesquisa em grade ou pesquisa aleatória em valores de parâmetros especificados.
• HyperparameterHunter: construído sobre o scikit-learn para torná-lo mais fácil de usar.
• Optuna: Usando busca aleatória, estimador de Parzen (TPE) e treinamento de base populacional.
• Hyperopt: Use pesquisa aleatória e TPE.
• Talos: Construído em Keras para facilitar o uso.

Intercâmbio de tecnologia

A tecnologia deve ser partilhada e comunicada e não é recomendado trabalhar à porta fechada. Uma pessoa pode ir muito rápido e um grupo de pessoas pode ir mais longe.

Este artigo é resumido e compartilhado por amigos do grupo de fãs. Se você também deseja aprender, se comunicar e obter informações, pode ingressar no grupo de comunicação para obtê-las. O grupo tem mais de 2.000 membros. A melhor maneira de adicionar notas é: fonte + direção de interesse, que é fácil de encontrar. Amigos que pensam como você.

Método ①, adicionar conta WeChat: dkl88194, observações: de CSDN + adicionar grupo
Método ②, pesquisar conta pública no WeChat: aprendizagem Python e mineração de dados, resposta em segundo plano: adicionar grupo < /span>

Agora, vamos dar uma olhada em alguns exemplos de código Python usando essas bibliotecas para otimização de hiperparâmetros do modelo autoencoder:

from keras.layers import Input, Dense
from keras.models import Model

# define the Autoencoder
input_layer = Input(shape=(784,))
encoded = Dense(32, activation='relu')(input_layer)
decoded = Dense(784, activation='sigmoid')(encoded)
autoencoder = Model(input_layer, decoded)
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
autoencoder.fit(X_train, X_train, epochs=100, batch_size=256, validation_data=(X_test, X_test))

scikit-aprender

from sklearn.model_selection import GridSearchCV

# define the parameter values that should be searched
param_grid = {
    
    'batch_size': [64, 128, 256], 'epochs': [50, 100, 150]}

# create a KFold cross-validator
kfold = KFold(n_splits=10, random_state=7)

# create the grid search object
grid = GridSearchCV(estimator=autoencoder, param_grid=param_grid, cv=kfold)

# fit the grid search object to the training data
grid_result = grid.fit(X_train, X_train)

# print the best parameters and the corresponding score
print(f'Best parameters: {
      
      grid_result.best_params_}')
print(f'Best score: {
      
      grid_result.best_score_}')

HiperparâmetroHunter

import HyperparameterHunter as hh

# create a HyperparameterHunter object
hunter = hh.HyperparameterHunter(input_data=X_train, output_data=X_train, model_wrapper=hh.ModelWrapper(autoencoder))

# define the hyperparameter search space
hunter.setup(objective='val_loss', metric='val_loss', optimization_mode='minimize', max_trials=100)
hunter.add_experiment(parameters=hh.Real(0.1, 1, name='learning_rate', digits=3, rounding=4))
hunter.add_experiment(parameters=hh.Real(0.1, 1, name='decay', digits=3, rounding=4))

# perform the hyperparameter search
hunter.hunt(n_jobs=1, gpu_id='0')

# print the best hyperparameters and the corresponding score
print(f'Best hyperparameters: {
      
      hunter.best_params}')
print(f'Best score: {
      
      hunter.best_score}')

Hiperóptico

from hyperopt import fmin, tpe, hp

# define the parameter space
param_space = {
    
    'batch_size': hp.quniform('batch_size', 64, 256, 1), 'epochs': hp.quniform('epochs', 50, 150, 1)}

# define the objective function
def objective(params):
    autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
    autoencoder.fit(X_train, X_train, batch_size=params['batch_size'], epochs=params['epochs'], verbose=0)
    scores = autoencoder.evaluate(X_test, X_test, verbose=0)
    return {
    
    'loss': scores, 'status': STATUS_OK}

# perform the optimization
best = fmin(objective, param_space, algo=tpe.suggest, max_evals=100)

# print the best parameters and the corresponding score
print(f'Best parameters: {
      
      best}')
print(f'Best score: {
      
      objective(best)}')

Optar

import optuna

# define the objective function
def objective(trial):
    batch_size = trial.suggest_int('batch_size', 64, 256)
    epochs = trial.suggest_int('epochs', 50, 150)
    autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
    autoencoder.fit(X_train, X_train, batch_size=batch_size, epochs=epochs, verbose=0)
    score = autoencoder.evaluate(X_test, X_test, verbose=0)
    return score

# create the Optuna study
study = optuna.create_study()

# optimize the hyperparameters
study.optimize(objective, n_trials=100)

# print the best parameters and the corresponding score
print(f'Best parameters: {
      
      study.best_params}')
print(f'Best score: {
      
      study.best_value}')

Talos

import talos

# define the parameter space
param_space = {
    
    'learning_rate': [0.1, 0.01, 0.001], 'decay': [0.1, 0.01, 0.001]}

# define the objective function
def objective(params):
    autoencoder.compile(optimizer='adam', loss='binary_crossentropy', lr=params['learning_rate'], decay=params['decay'])
    history = autoencoder.fit(X_train, X_train, epochs=100, batch_size=256, validation_data=(X_test, X_test), verbose=0)
    score = history.history['val_loss'][-1]
    return score

# perform the optimization
best = talos.Scan(X_train, X_train, params=param_space, model=autoencoder, experiment_name='autoencoder').best_params(objective, n_trials=100)

# print the best parameters and the corresponding score
print(f'Best parameters: {
      
      best}')
print(f'Best score: {
      
      objective(best)}')