Otimização paralela de hiperparâmetros (HPO) em Container Runtime para ML

A API do Snowflake ML Hyperparameter Optimization (HPO) é um framework independente de modelo que permite o ajuste eficiente e paralelo de hiperparâmetros de modelos usando algoritmos de ajuste populares.

Hoje, essa API está disponível para uso em um Snowflake Notebook configurado para usar o Container Runtime no Snowpark Container Services (SPCS). Depois que você criar esse notebook, poderá:

  • Treinar um modelo usando qualquer pacote de código aberto e usar esta API para distribuir o processo de ajuste de hiperparâmetros

  • Treinar um modelo usando as APIs de treinamento distribuído do Snowflake ML e dimensione HPO e, ao mesmo tempo, dimensione cada uma das execuções de treinamento

A carga de trabalho do HPO, iniciada no Notebook, é executada dentro do Snowpark Container Services nas instâncias CPU ou GPU e é dimensionada para os núcleos (CPUs ou GPUs) disponíveis em um único nó no pool de computação SPCS.

A HPO API paralelizada oferece os seguintes benefícios:

  • Uma única API que lida automaticamente com todas as complexidades da distribuição do treinamento em vários recursos

  • A capacidade de treinar com praticamente qualquer framework ou algoritmo usando estruturas de código aberto ML ou APIs de modelagem do Snowflake ML

  • Uma seleção de opções de ajuste e amostragem, incluindo algoritmos de pesquisa Bayesiana e aleatória, juntamente com várias funções de amostragem contínuas e não contínuas

  • Forte integração com o restante do Snowflake; por exemplo, ingestão eficiente de dados por meio do Snowflake Datasets ou Dataframes e captura automática da linhagem do ML

Exemplos

Este exemplo ilustra um caso de uso típico do HPO, primeiro ingerindo dados de uma tabela Snowflake por meio do Container Runtime DataConnector API e, em seguida, definindo uma função de treinamento que cria um modelo XGBoost. A interface Tuner fornece a funcionalidade de ajuste, com base na função de treinamento e no espaço de pesquisa fornecidos.

from snowflake.ml.modeling.tune import get_tuner_context
from snowflake.ml.modeling import tune

# Define a training function, with any models you choose within it.
def train_func():
    # A context object provided by HPO API to expose data for the current HPO trial
    tuner_context = get_tuner_context()
    config = tuner_context.get_hyper_params()
    dm = tuner_context.get_dataset_map()

    model = xgb.XGBClassifier(**config, random_state=42)
    model.fit(dm["x_train"].to_pandas(), dm["y_train"].to_pandas())
    accuracy = accuracy_score(
        dm["y_train"].to_pandas(), model.predict(dm["x_train"].to_pandas())
    )
    tuner_context.report(metrics={"accuracy": accuracy}, model=model)

tuner = tune.Tuner(
    train_func=train_func,
    search_space={
        "n_estimators": tune.uniform(50, 200),
        "max_depth": tune.uniform(3, 10),
        "learning_rate": tune.uniform(0.01, 0.3),
    },
    tuner_config=tune.TunerConfig(
        metric="accuracy",
        mode="max",
        search_alg=search_algorithm.BayesOpt(),
        num_trials=2,
        max_concurrent_trials=1,
    ),
)

tuner_results = tuner.run(dataset_map=dataset_map)
# Access the best result info with tuner_results.best_result
Copy

O resultado esperado é semelhante a este:

accuracy  should_checkpoint  trial_id   time_total_s  config/learning_rate  config/max_depth  config/n_estimators
1.0       True               ec632254   7.161971      0.118617              9.655             159.799091

O objeto tuner_results contém todos os resultados, o melhor modelo e o caminho do melhor modelo.

print(tuner_results.results)
print(tuner_results.best_model)
print(tuner_results.best_model_path)
Copy

Visão geral do API

A HPO API está no namespace snowflake.ml.modeling.tune. A principal HPO API é a classe tune.Tuner. Ao instanciar essa classe, você especifica o seguinte:

  • Uma função de treinamento que se ajusta a um modelo

  • Um espaço de pesquisa (tune.SearchSpace) que define o método de amostragem de hiperparâmetros

  • Um objeto de configuração do sintonizador (tune.TunerConfig) que define o algoritmo de pesquisa, a métrica a ser otimizada e o número de tentativas

Depois de instanciar Tuner, chame seu método run com um mapa de conjunto de dados (que especifica um DataConnector para cada conjunto de dados de entrada) para iniciar o processo de ajuste.

Para obter mais informações, execute os seguintes comandos Python para obter a documentação de cada classe:

from snowflake.ml.modeling import tune

help(tune.Tuner)
help(tune.TunerConfig)
help(tune.SearchSpace)
Copy

Limitações

A otimização bayesiana funciona apenas com a função de amostragem uniforme. A otimização bayesiana se baseia em processos gaussianos como modelos substitutos e, portanto, requer espaços de pesquisa contínuos. Ele é incompatível com parâmetros discretos amostrados usando os métodos tune.randint ou tune.choice. Para contornar essa limitação, use tune.uniform e converta o parâmetro dentro da função de treinamento ou mude para um algoritmo de amostragem que lide com espaços discretos e contínuos, como tune.RandomSearch.

Solução de problemas

Mensagem de erro

Causas possíveis

Possíveis soluções

Configuração inválida do espaço de pesquisa: BayesOpt exige que todas as funções de amostragem sejam do tipo ‘Uniforme”.

A otimização bayesiana funciona apenas com amostragem uniforme, não com amostras discretas. (Consulte Limitações acima.)

  • Use o tune.uniform e converta o resultado em sua função de treinamento.

  • Mudar para o algoritmo RandomSearch, que aceita amostras discretas e não discretas.

Recursos insuficientes de CPU. Necessário: 16, Disponível: 8. Pode se referir a CPU ou GPU. O número de recursos necessários e disponíveis pode ser diferente.

max_concurrent_trials é definido como um valor maior do que os núcleos disponíveis.

A mensagem de erro completa descreve várias opções que você pode tentar.
Linguagem: Português