Download do Auto PyTorch - Auto PyTorch Download de código fonte

Auto-Pytorch

Enquanto as primeiras estruturas do Automl se concentram na otimização de dutos tradicionais de ML e seus hiperparâmetros, outra tendência no Automl é se concentrar na pesquisa de arquitetura neural. Para reunir o melhor desses dois mundos, desenvolvemos o Auto-Pytorch , que otimiza a arquitetura de rede e os hiperparâmetros de treinamento para permitir o aprendizado profundo totalmente automatizado (AUTODL).

O Auto-Pytorch é desenvolvido principalmente para suportar dados tabulares (classificação, regressão) e dados de séries temporais (previsão). Os recursos mais recentes do Auto-Pytorch para dados tabulares são descritos no documento "Tabular automaticamente-pytorch: Multi-Fidelity Metalearning para um Autodl eficiente e robusto" (veja abaixo o Bibtex Ref). Detalhes sobre as tarefas de previsão de séries temporais multi-horizontal podem ser encontradas no artigo "Aprendizagem profunda automatizada eficiente para a previsão de séries temporais" (também veja abaixo o bibtex ref).

Além disso, encontre a documentação aqui.

A partir da v0.1.0, o Autopytorch foi atualizado para melhorar ainda mais a usabilidade, a robustez e a eficiência usando o SMAC como o pacote de otimização subjacente, além de alterar a estrutura do código. Portanto, passar de v0.0.2 para v0.1.0 quebrará a compatibilidade. Caso você queira usar a API antiga, pode encontrá -la em master_old .

Fluxo de trabalho

A descrição aproximada do fluxo de trabalho do auto-pytorch é desenhada na figura a seguir.

Na figura, os dados são fornecidos pelo usuário e o portfólio é um conjunto de configurações de redes neurais que funcionam bem em diversos conjuntos de dados. A versão atual suporta apenas o portfólio ganancioso , conforme descrito no Tabular de papel auto-pytorch: Multi-Fidelity Metalearning para um autodl eficiente e robusto Este portfólio é usado para iniciar a otimização do SMAC. Em outras palavras, avaliamos o portfólio em dados fornecidos como configurações iniciais. Então a API inicia os seguintes procedimentos:

Validar dados de entrada : processe cada tipo de dados, por exemplo, dados codificadores codificadores, para que o auto-pytorch possa ser tratado.
Crie conjunto de dados : Crie um conjunto de dados que possa ser tratado nesta API com uma opção de validação cruzada ou divisões de espera.
Avalie linhas de base
- DataSet tabular *1: Treine cada algoritmo no pool predefinido com uma configuração fixa de hiperparâmetro e modelo dummy da sklearn.dummy que representa o pior desempenho possível.
- Conjunto de dados de previsão de séries temporais : treine um preditor dummy que repete o último valor observado em cada série
Pesquise por SMAC :
um. Determinar regras de orçamento e corte por hiperband
b. Amostra uma configuração de hiperparâmetro de pipeline *2 por SMAC
c. Atualizar as observações por resultados obtidos
d. Repita um. - c. Até o orçamento acabar
Crie o melhor conjunto para o conjunto de dados fornecido a partir das observações e seleção de modelos do conjunto.

*1: As linhas de base são um pool predefinido de algoritmos de aprendizado de máquina, por exemplo, LightGBM e Machine de vetor de suporte, para resolver a tarefa de regressão ou classificação no conjunto de dados fornecido

*2: Uma configuração de hiperparâmetro de pipeline especifica a escolha dos componentes, por exemplo, algoritmo de destino, a forma das redes neurais, em cada etapa e (que especifica a escolha dos componentes em cada etapa e seus hiperparâmetros correspondentes.

Instalação

Instalação do Pypi

pip install autoPyTorch

Auto-pytorch para previsão de séries temporais requer dependências adicionais

pip install autoPyTorch[forecasting]

Instalação manual

Recomendamos o uso da Anaconda para o desenvolvimento da seguinte maneira:

 # Following commands assume the user is in a cloned directory of Auto-Pytorch

# We also need to initialize the automl_common repository as follows
# You can find more information about this here:
# https://github.com/automl/automl_common/
git submodule update --init --recursive

# Create the environment
conda create -n auto-pytorch python=3.8
conda activate auto-pytorch
conda install swig
python setup.py install

Da mesma forma, para instalar todas as dependências para o auto-pytorch-timeries queecasting:

git submodule update --init --recursive

conda create -n auto-pytorch python=3.8
conda activate auto-pytorch
conda install swig
pip install -e[forecasting]

Exemplos

Em poucas palavras:

 from autoPyTorch . api . tabular_classification import TabularClassificationTask

# data and metric imports
import sklearn . model_selection
import sklearn . datasets
import sklearn . metrics
X , y = sklearn . datasets . load_digits ( return_X_y = True )
X_train , X_test , y_train , y_test = 
        sklearn . model_selection . train_test_split ( X , y , random_state = 1 )

# initialise Auto-PyTorch api
api = TabularClassificationTask ()

# Search for an ensemble of machine learning algorithms
api . search (
    X_train = X_train ,
    y_train = y_train ,
    X_test = X_test ,
    y_test = y_test ,
    optimize_metric = 'accuracy' ,
    total_walltime_limit = 300 ,
    func_eval_time_limit_secs = 50
)

# Calculate test accuracy
y_pred = api . predict ( X_test )
score = api . score ( y_pred , y_test )
print ( "Accuracy score" , score )

Para tarefas de previsão de séries temporais

 from autoPyTorch . api . time_series_forecasting import TimeSeriesForecastingTask

# data and metric imports
from sktime . datasets import load_longley
targets , features = load_longley ()

# define the forecasting horizon
forecasting_horizon = 3

# Dataset optimized by APT-TS can be a list of np.ndarray/ pd.DataFrame where each series represents an element in the 
# list, or a single pd.DataFrame that records the series
# index information: to which series the timestep belongs? This id can be stored as the DataFrame's index or a separate
# column
# Within each series, we take the last forecasting_horizon as test targets. The items before that as training targets
# Normally the value to be forecasted should follow the training sets
y_train = [ targets [: - forecasting_horizon ]]
y_test = [ targets [ - forecasting_horizon :]]

# same for features. For uni-variant models, X_train, X_test can be omitted and set as None
X_train = [ features [: - forecasting_horizon ]]
# Here x_test indicates the 'known future features': they are the features known previously, features that are unknown
# could be replaced with NAN or zeros (which will not be used by our networks). If no feature is known beforehand,
# we could also omit X_test
known_future_features = list ( features . columns )
X_test = [ features [ - forecasting_horizon :]]

start_times = [ targets . index . to_timestamp ()[ 0 ]]
freq = '1Y'

# initialise Auto-PyTorch api
api = TimeSeriesForecastingTask ()

# Search for an ensemble of machine learning algorithms
api . search (
    X_train = X_train ,
    y_train = y_train ,
    X_test = X_test , 
    optimize_metric = 'mean_MAPE_forecasting' ,
    n_prediction_steps = forecasting_horizon ,
    memory_limit = 16 * 1024 ,  # Currently, forecasting models use much more memories
    freq = freq ,
    start_times = start_times ,
    func_eval_time_limit_secs = 50 ,
    total_walltime_limit = 60 ,
    min_num_test_instances = 1000 ,  # proxy validation sets. This only works for the tasks with more than 1000 series
    known_future_features = known_future_features ,
)

# our dataset could directly generate sequences for new datasets
test_sets = api . dataset . generate_test_seqs ()

# Calculate test accuracy
y_pred = api . predict ( test_sets )
score = api . score ( y_pred , y_test )
print ( "Forecasting score" , score )

Para mais exemplos, incluindo a personalização do espaço de pesquisa, analisando o código, etc, confira a pasta examples

$ cd examples/

O código para o artigo está disponível em examples/ensemble na filial tpami.2021.3067763.

Contribuindo

Se você deseja contribuir com o Auto-Pytorch, clone o repositório e consulte nosso ramo atual de desenvolvimento

$ git checkout development

Licença

Este programa é um software livre: você pode redistribuí -lo e/ou modificá -lo nos termos da licença Apache 2.0 (consulte o arquivo de licença).

Este programa é distribuído na esperança de que seja útil, mas sem garantia; sem a garantia implícita de comercialização ou aptidão para uma finalidade específica.

Você deve ter recebido uma cópia da Licença Apache 2.0 junto com este programa (consulte o arquivo de licença).

Referência

Consulte a filial TPAMI.2021.3067763 para reproduzir o papel auto-pytorch Tabular: Meti-Fidelity Metalearning para um Autodl eficiente e robusto .

  @article { zimmer-tpami21a ,
  author = { Lucas Zimmer and Marius Lindauer and Frank Hutter } ,
  title = { Auto-PyTorch Tabular: Multi-Fidelity MetaLearning for Efficient and Robust AutoDL } ,
  journal = { IEEE Transactions on Pattern Analysis and Machine Intelligence } ,
  year = { 2021 } ,
  note = { also available under https://arxiv.org/abs/2006.13799 } ,
  pages = { 3079 - 3090 }
}

 @incollection { mendoza-automlbook18a ,
  author    = { Hector Mendoza and Aaron Klein and Matthias Feurer and Jost Tobias Springenberg and Matthias Urban and Michael Burkart and Max Dippel and Marius Lindauer and Frank Hutter } ,
  title     = { Towards Automatically-Tuned Deep Neural Networks } ,
  year      = { 2018 } ,
  month     = dec,
  editor    = { Hutter, Frank and Kotthoff, Lars and Vanschoren, Joaquin } ,
  booktitle = { AutoML: Methods, Sytems, Challenges } ,
  publisher = { Springer } ,
  chapter   = { 7 } ,
  pages     = { 141--156 }
}

 @article { deng-ecml22 ,
  author    = { Difan Deng and Florian Karl and Frank Hutter and Bernd Bischl and Marius Lindauer } ,
  title     = { Efficient Automated Deep Learning for Time Series Forecasting } ,
  year      = { 2022 } ,
  booktitle = { Machine Learning and Knowledge Discovery in Databases. Research Track
               - European Conference, {ECML} {PKDD} 2022 } ,
  url       = { https://doi.org/10.48550/arXiv.2205.05511 } ,
}