Algoritmo de previsão DeepAR - Amazon SageMaker
Interface de entrada/saída para o algoritmo DeepAR Melhores práticas para usar o algoritmo DeepARRecomendações de instâncias do EC2 para o algoritmo DeepARBlocos de anotações de amostra

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Algoritmo de previsão DeepAR

O algoritmo de previsão DeepAR do Amazon SageMaker DeepAR é um algoritmo de aprendizado supervisionado para previsão de séries temporais escalares (unidimensionais) usando redes neurais recorrentes (RNN). Os métodos clássicos de previsão, como média móvel integrada autorregressiva (ARIMA) ou suavização exponencial (ETS), definem um único modelo para cada série temporal individual. Em seguida, eles usam esse modelo para extrapolar séries temporais no futuro.

Em muitos aplicativos, no entanto, você pode ter muitas séries temporais semelhantes em um conjunto de unidades transversais. Por exemplo, você pode ter agrupamentos de séries temporais para a demanda por diferentes produtos, cargas de servidores e solicitações de páginas da Web. Para esse tipo de aplicativo, é possível se beneficiar com o treinamento de um único modelo de forma conjunta em todas as séries temporais. O DeepAR adota essa abordagem. Quando seu conjunto de dados contém centenas de séries temporais relacionadas, o DeepAR supera os métodos padrão ARIMA e ETS. Você também pode usar o modelo treinado para gerar previsões para novas séries temporais semelhantes às que foram treinadas.

A entrada de treinamento para o algoritmo DeepAR é de uma ou, preferencialmente, mais séries temporais target que foram geradas pelo mesmo processo ou processos semelhantes. Com base nesse conjunto de dados de entrada, o algoritmo treina um modelo que aprende uma aproximação desse processo/processos e o usa para prever a evolução das séries temporais de destino. Cada série temporal de destino pode ser opcionalmente associada a um vetor de atributos categóricos estáticos (independente do tempo) fornecido pelo campo cat e a um vetor de séries temporais dinâmicas (dependente do tempo) fornecido pelo campo dynamic_feat. O SageMaker treina o DeepAR obtendo amostras aleatórias de exemplos de treinamento de cada série temporal de destino no conjunto de dados de treinamento. Cada exemplo de treinamento consiste em um par de janelas de previsão e contexto adjacentes com comprimentos predefinidos fixos. Para controlar até que ponto no passado a rede pode se estender, use o hiperparâmetro context_length. Para controlar até que ponto no futuro é possível fazer previsões, use o hiperparâmetro prediction_length. Para obter mais informações, consulte Como o algoritmo DeepAR funciona.

Tópicos

Interface de entrada/saída para o algoritmo DeepAR

O DeepAR é compatível com dois canais de dados. O canal necessário train descreve o conjunto de dados de treinamento. O canal opcional test descreve um conjunto de dados que o algoritmo usa para avaliar a precisão do modelo após o treinamento. Você pode fornecer conjuntos de dados de treinamento e teste no formato de linhas JSON. Os arquivos podem estar no formato de arquivo gzip ou Parquet.

Ao especificar os caminhos para os dados de treinamento e teste, você pode especificar um único arquivo ou um diretório que contenha vários arquivos, que podem ser armazenados em subdiretórios. Se você especificar um diretório, o DeepAR usará todos os arquivos nesse diretório como entradas para o canal correspondente, exceto aqueles que começam com um ponto (.) e aqueles denominados _SUCCESS. Isso garante que você possa usar diretamente as pastas de saída produzidas por trabalhos do Spark como canais de entrada para seus trabalhos de treinamento do DeepAR.

Por padrão, o modelo DeepAR determina o formato de entrada da extensão do arquivo (.json, .json.gz ou .parquet) no caminho de entrada especificado. Se o caminho não terminar em uma dessas extensões, você deverá especificar explicitamente o formato no SDK for Python. Use o parâmetro content_type da classe s3_input classe.

Os registros nos seus arquivos de entrada devem conter os seguintes campos:

  • start—Uma string com o formato YYYY-MM-DD HH:MM:SS. O timestamp inicial não pode conter informações de fuso horário.

  • target—Uma matriz de valores de ponto flutuante ou números inteiros que representam a série temporal. Você pode codificar valores ausentes como literais null ou como strings "NaN" em JSON ou como valores de ponto flutuante nan em Parquet.

  • dynamic_feat (opcional)—Uma matriz de matrizes de valores de ponto flutuante ou números inteiros que representam o vetor de séries temporais de atributos personalizados (atributos dinâmicos). Se você definir esse campo, todos os registros deverão ter o mesmo número de matrizes internas (o mesmo número de séries temporais de recursos). Além disso, cada matriz interna deve ter o mesmo comprimento que o valor target associado prediction_length. Valores ausentes não têm suporte nos recursos. Por exemplo, se as séries temporais de destino representam a demanda de diferentes produtos, um dynamic_feat associado pode ser uma série temporal booleana que indica se uma promoção foi aplicada (1) a determinado produto ou não (0): 

    {"start": ..., "target": [1, 5, 10, 2], "dynamic_feat": [[0, 1, 1, 0]]}

  • cat (opcional)—Uma matriz de atributos categóricos que podem ser usados para codificar os grupos aos quais o registro pertence. Recursos categóricos devem ser codificados como uma sequência baseada em 0 de números inteiros positivos. Por exemplo, o domínio categórico {R, G, B} pode ser codificado como {0, 1, 2}. Todos os valores de cada domínio categórico devem ser representados no conjunto de dados de treinamento. Isso porque o algoritmo DeepAR pode prever apenas as categorias que foram observadas durante o treinamento. E cada recurso categórico é incorporado em um espaço de baixa dimensão cuja dimensionalidade é controlada pelo hiperparâmetro embedding_dimension. Para obter mais informações, consulte Hiperparâmetros do DeepAR.

Se você usar um arquivo JSON, ele deverá estar no formato JSON Lines. Por exemplo:

{"start": "2009-11-01 00:00:00", "target": [4.3, "NaN", 5.1, ...], "cat": [0, 1], "dynamic_feat": [[1.1, 1.2, 0.5, ...]]}
{"start": "2012-01-30 00:00:00", "target": [1.0, -5.0, ...], "cat": [2, 3], "dynamic_feat": [[1.1, 2.05, ...]]}
{"start": "1999-01-30 00:00:00", "target": [2.0, 1.0], "cat": [1, 4], "dynamic_feat": [[1.3, 0.4]]}

Neste exemplo, cada série temporal tem dois recursos categóricos associados e um recurso de série temporal.

Para Parquet, você usa os mesmos três campos como colunas. Além disso, "start" pode ser do tipo datetime. Você pode compactar arquivos Parquet usando a biblioteca de compactação gzip (gzip) ou Snappy (snappy).

Se o algoritmo for treinado sem os campos cat e dynamic_feat, ele aprenderá um modelo "global", que é um modelo independente da identidade específica das séries temporais de destino em tempo de inferência, e condicionado somente na forma.

Se o modelo estiver condicionado aos dados de recursos cat e dynamic_feat fornecidos para cada série temporal, a previsão provavelmente será influenciada pelo caractere das séries temporais com os recursos cat correspondentes. Por exemplo, se a série temporal target representar a demanda de itens de vestuário, você poderá associar um vetor bidimensional cat que codifica o tipo de item (por exemplo, 0 = sapatos, 1 = vestimenta) no primeiro componente e a cor de um item ( por exemplo, 0 = vermelho, 1 = azul) no segundo componente. Uma exemplo de entrada seria exibida da seguinte forma:

{ "start": ..., "target": ..., "cat": [0, 0], ... } # red shoes
{ "start": ..., "target": ..., "cat": [1, 1], ... } # blue dress

No momento da inferência, você pode solicitar previsões para destinos com valores cat, que são combinações dos valores cat observados nos dados de treinamento, por exemplo:

{ "start": ..., "target": ..., "cat": [0, 1], ... } # blue shoes
{ "start": ..., "target": ..., "cat": [1, 0], ... } # red dress

As diretrizes a seguir se aplicam a dados de treinamento:

  • O horário de início e a duração da série temporal podem ser diferentes. Por exemplo, na comercialização, os produtos geralmente entram no catálogo de varejo em datas diferentes, portanto, as datas de início diferem naturalmente. No entanto, todas as séries devem ter a mesma frequência, número de recursos categóricos e número de recursos dinâmicos.

  • Embaralhe o arquivo de treinamento em relação à posição da série temporal no arquivo. Em outras palavras, a série temporal deve ocorrer em ordem aleatória no arquivo.

  • Certifique-se de definir o campo start corretamente. O algoritmo usa o timestamp start para derivar os recursos internos.

  • Se você usar recursos categóricos (cat), todas as séries temporais deverão ter o mesmo número de recursos categóricos. Se o conjunto de dados contiver o campo cat, o algoritmo o usará e extrairá a cardinalidade dos grupos do conjunto de dados. Por padrão, cardinality é "auto". Se o conjunto de dados contiver o campo cat, mas você não quiser usá-lo, poderá desabilitá-lo definindo cardinality como "". Se um modelo tiver sido treinado usando um recurso cat, você deverá incluí-lo para inferência.

  • Se o seu conjunto de dados contiver o campo dynamic_feat, o algoritmo o usará automaticamente. Todas as séries temporais precisam ter o mesmo número de séries temporais de recursos. Os pontos de tempo em cada uma das séries temporais de recursos correspondem um a um aos pontos de tempo no destino. Além disso, a entrada no campo dynamic_feat deve ter o mesmo comprimento que target. Se o conjunto de dados contiver o campo dynamic_feat, mas você não quiser usá-lo, desabilite-o definindo (num_dynamic_feat como ""). Se o modelo tiver sido treinado com o campo dynamic_feat, você deverá fornecer esse campo para inferência. Além disso, cada um dos recursos deve ter o comprimento do destino fornecido mais o prediction_length. Em outras palavras, você deverá fornecer o valor do recurso no futuro.

Se você especificar os dados do canal teste opcional, o algoritmo DeepAR avaliará o modelo treinado com diferentes métricas de precisão. O algoritmo calculará a raiz do erro quadrático médio (RMSE) nos dados de teste da seguinte forma:

Fórmula RMSE: Sqrt(1/nT(Sum[i,t](y-hat(i,t)-y(i,t))^2))

yi,t é o verdadeiro valor da série temporal i no momento t. ŷi,t é a previsão média. A soma refere-se a todas as séries temporais n no conjunto de teste e aos últimos momentos Τ de cada série temporal, em que Τ corresponde ao horizonte de previsão. Para especificar a extensão do horizonte de previsão, defina o hiperparâmetro prediction_length. Para obter mais informações, consulte Hiperparâmetros do DeepAR.

Além disso, o algoritmo avalia a precisão da distribuição da previsão usando a perda de quantil ponderada. Para um quantil no intervalo [0, 1], a perda de quantil ponderada é definida da seguinte forma:

Perda de quantil

qi,t(τ) é o quantil τ da distribuição que o modelo prevê. Para especificar para quais quantis calcular a perda, defina o hiperparâmetro test_quantiles. Além destes, a média das perdas de quantil prescritas é relatada como parte dos logs de treinamento. Para obter mais informações, consulte Hiperparâmetros do DeepAR.

Para inferência, o DeepAR aceita o formato JSON e os seguintes campos:

  • "instances", que inclui uma ou mais séries temporais no formato JSON Lines

  • Um nome de "configuration", que inclui parâmetros para gerar a previsão

Para obter mais informações, consulte Formatos de inferência do DeepAR.

Melhores práticas para usar o algoritmo DeepAR

Ao preparar seus dados de série temporal, siga estas práticas recomendadas para obter os melhores resultados:

  • Exceto ao dividir seu conjunto de dados para treinamento e teste, sempre forneça toda a série temporal para treinamento, teste e ao chamar o modelo para inferência. Independentemente de como você definir context_length, não divida a série temporal ou forneça apenas uma parte dela. O modelo usa pontos de dados mais atrás do que o valor definido em context_length para o recurso de valores com atraso.

  • Ao ajustar um modelo DeepAR, você pode dividir o conjunto de dados para criar um conjunto de dados de treinamento e um conjunto de dados de teste. Em uma avaliação típica, você testaria o modelo na mesma série temporal usada para treinamento, mas nos pontos de tempo prediction_length futuros que seguem imediatamente depois do último ponto de tempo visível durante o treinamento. É possível criar conjuntos de dados de treinamento e teste que atendem a esse critério usando o conjunto de dados inteiro (a duração total de todas as séries temporais disponíveis) como um conjunto de testes e removendo os últimos pontos prediction_length de cada série temporal para treinamento. Durante o treinamento, o modelo não vê os valores de destino para os pontos de tempo em que ele é avaliado durante o teste. Durante o teste, o algoritmo retém os últimos pontos prediction_length de cada série temporal do conjunto de testes e gera uma previsão. Em seguida, ele compara a previsão com os valores retidos. Você pode criar avaliações mais complexas repetindo as séries temporais várias vezes no conjunto de testes, mas cortando-as em diferentes endpoints. Com essa abordagem, a média de métricas de precisão é calculada sobre várias previsões de diferentes pontos de tempo. Para obter mais informações, consulte Ajustar um modelo DeepAR.

  • Evite usar valores muito grandes (>400) para prediction_length, pois isso torna o modelo lento e menos preciso. Se quiser prever mais para o futuro, considere agregar seus dados em uma frequência mais baixa. Por exemplo, use 5min em vez de 1min.

  • Como atrasos são usados, um modelo pode retornar ainda mais na série temporal do que o valor especificado para context_length. Portanto, você não precisa definir esse parâmetro como um valor grande. Recomendamos começar com o valor que você usou para prediction_length.

  • Recomendamos treinar um modelo DeepAR em todas as séries temporais que estiverem disponíveis. Embora um modelo DeepAR treinado em uma única série temporal possa funcionar bem, os algoritmos de previsão padrão, como o ARIMA ou o ETS, podem fornecer resultados mais precisos. O algoritmo DeepAR começa a superar os métodos padrão quando seu conjunto de dados contém centenas de séries temporais relacionadas. Atualmente, o DeepAR requer que o número total de observações disponíveis em todas as séries temporais de treinamento seja pelo menos 300.

Recomendações de instâncias do EC2 para o algoritmo DeepAR

Você pode treinar o DeepAR em instâncias de GPU e CPU e em configurações de uma ou várias máquinas. Recomendamos começar com uma única instância de CPU (por exemplo, ml.c4.2xlarge ou ml.c4.4xlarge) e alternar para instâncias de GPU e várias máquinas somente quando necessário. O uso de GPUs e várias máquinas melhora o throughput apenas para modelos maiores (com muitas células por camada e várias camadas) e para tamanhos grandes de minilotes (por exemplo, maiores que 512).

Para inferência, o DeepAR oferece suporte apenas para instâncias de CPU.

A especificação de valores grandes para context_length, prediction_length, num_cells, num_layers ou mini_batch_size pode criar modelos muito grandes para instâncias pequenas. Nesse caso, use um tipo de instância maior ou reduza os valores para esses parâmetros. Esse problema também ocorre com frequência ao executar trabalhos de ajuste de hiperparâmetros. Nesse caso, use um tipo de instância grande o suficiente para o trabalho de ajuste de modelo e considere limitar os valores superiores dos parâmetros críticos para evitar falhas de trabalho.

Blocos de anotações de amostra do DeepAR

Para um bloco de anotações de amostra que mostra como preparar um conjunto de dados de série temporal para treinar o algoritmo DeepAR do e como implantar o modelo treinado para realizar inferências, consulte Demonstração do DeepAR em um conjunto de dados de eletricidade, que ilustra os atributos avançados do DeepAR em um conjunto de dados do mundo real. Para obter instruções sobre como criar e acessar instâncias de caderno Jupyter que você pode utilizar para executar o exemplo em SageMaker, consulte Instâncias do Amazon SageMaker Notebook. Depois de criar e abrir uma instância de bloco de anotações, escolha a guia Exemplos do SageMaker para ver uma lista de todos os exemplos do SageMaker. Para abrir um bloco de anotações, escolha sua guia Use (Uso) e depois escolha Create copy (Criar cópia).