Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Usa l'algoritmo di SageMaker previsione AI DeepAR
L'algoritmo di previsione Amazon SageMaker AI DeepAR è un algoritmo di apprendimento supervisionato per la previsione di serie temporali scalari (unidimensionali) utilizzando reti neurali ricorrenti (RNN). I metodi di previsione tradizionali, ad esempio il Modello autoregressivo integrato a media mobile (ARIMA, Autoregressive Integrated Moving Average) o il Livellamento esponenziale (ETS, Exponential Smoothing), associano un singolo modello a ogni singola serie temporale. Quindi utilizzano il modello per estrapolare le serie temporali in futuro.
In molte applicazioni, tuttavia, sono presenti molte serie temporali simili in un set di unità trasversali. Ad esempio, potresti avere raggruppamenti di serie temporali per la richiesta di diversi prodotti, carichi del server e pagine Web. Per questo tipo di applicazione, è possibile utilizzare l’addestramento di un singolo modello per tutte le serie temporali. DeepAR adotta questo approccio. Quando il set di dati contiene centinaia di serie temporali correlate, DeepAR ottiene risultati migliori rispetto ai metodi ARIMA ed ETS standard. È anche possibile utilizzare il modello addestrato per generare previsioni per le nuove serie temporali simili a quelle su cui è stato addestrato.
L'input di addestramento per l'algoritmo DeepAR è una o, preferibilmente, più serie temporali `target` che sono state generate dallo stesso processo o da processi simili. Sulla base di questo set di dati di input, l'algoritmo addestra un modello che ne apprende un'approssimazione e la utilizza per prevedere l'evoluzione della serie temporale target. process/processes Ogni serie temporale target può essere opzionalmente associata a un vettore di caratteristiche di categoria (indipendenti dal tempo) statiche fornite dal campo `cat` e un vettore di serie temporali (dipendenti dal tempo) dinamiche fornite dal campo `dynamic_feat`. SageMaker L'intelligenza artificiale addestra il modello DeepAR campionando casualmente esempi di addestramento da ciascuna serie temporale target nel set di dati di addestramento. Ogni esempio di addestramento è costituito da una coppia di finestre di contesto e di previsione adiacenti con lunghezze predefinite fisse. Per controllare fino a quando nel passato può vedere la rete, usa l'iperparametro `context_length`. Per controllare fino a quando possono essere proiettate le previsioni future, usa l'iperparametro `prediction_length`. Per ulteriori informazioni, consulta [Come funziona l'algoritmo DeepAR](deepar_how-it-works.md).
**Topics**
+ [Interfaccia di input/output per l'algoritmo DeepAR](#deepar-inputoutput)
+ [Best practice per l'utilizzo dell'algoritmo DeepAR](#deepar_best_practices)
+ [Raccomandazioni dell'istanza EC2 per l'algoritmo DeepAR](#deepar-instances)
+ [Notebook di esempio di DeepAR](#deepar-sample-notebooks)
+ [Come funziona l'algoritmo DeepAR](deepar_how-it-works.md)
+ [Iperparametri DeepAR](deepar_hyperparameters.md)
+ [Ottimizzazione di un modello DeepAR](deepar-tuning.md)
+ [Formati di inferenza DeepAR](deepar-in-formats.md)
## Interfaccia di input/output per l'algoritmo DeepAR
DeepAR supporta due canali di dati. Il canale `train` obbligatorio descrive il set di dati di addestramento. Il canale `test` facoltativo descrive un set di dati che viene utilizzato dall'algoritmo per valutare l'accuratezza del modello dopo l’addestramento. Puoi fornire i set di dati di test e addestramento nel formato [JSON Lines](http://jsonlines.org/). I file possono essere nel formato gzip o [Parquet](https://parquet.apache.org/).
Quando specifichi i percorsi per i dati di addestramento e di test, puoi indicare un singolo file o una directory contenente più file che possono essere memorizzati in sottodirectory. Se specifichi una directory, DeepAR utilizza come input del canale corrispondente tutti i file presenti nella directory, ad eccezione di quelli che iniziano con un punto (.) e quelli denominati *\$1SUCCESS*. In tal modo puoi utilizzare direttamente le cartelle di output prodotte dai processi Spark come canali di input per i processi di addestramento DeepAR.
Per impostazione predefinita, il modello DeepAR determina il formato di input dall'estensione del file (`.json`, `.json.gz` o `.parquet`) nel percorso di input specificato. Se il percorso non termina in una di queste estensioni, devi specificare esplicitamente il formato SDK per Python. Utilizza il parametro `content_type` della classe [s3\$1input](https://sagemaker.readthedocs.io/en/stable/session.html#sagemaker.session.s3_input).
I record dei file di input devono contenere i seguenti campi:
+ `start`: una stringa con il formato `YYYY-MM-DD HH:MM:SS`. Il timestamp iniziale non è in grado di contenere le informazioni sul fuso orario.
+ `target`: una matrice di numeri interi o valori a virgola mobile che rappresentano le serie temporali. Puoi codificare i valori mancanti come letterali `null` o come stringhe `"NaN"` in JSON oppure come valori in virgola mobile `nan` in Parquet.
+ `dynamic_feat` (opzionale): una matrice di matrici di numeri interi o valori a virgola mobile che rappresenta il vettore delle serie temporali di funzionalità personalizzate (funzionalità dinamiche). Se imposti questo campo, tutti i record devono avere lo stesso numero di matrici interne (lo stesso numero di serie temporali di caratteristiche). Inoltre, ogni matrice interna deve avere la stessa lunghezza del valore `target` associato più `prediction_length`. I valori mancanti non sono supportati nelle caratteristiche. Ad esempio, se la serie temporale target rappresenta la richiesta di prodotti diversi, un `dynamic_feat` associato potrebbe essere una serie temporale booleana che indica se una promozione è stata applicata (1) o meno (0) al prodotto specifico:
```
{"start": ..., "target": [1, 5, 10, 2], "dynamic_feat": [[0, 1, 1, 0]]}
```
+ `cat` (opzionale): una serie di funzionalità categoriali che possono essere utilizzate per codificare i gruppi a cui appartiene il record. Le caratteristiche di categoria devono essere codificate come una sequenza in base 0 di numeri interi positivi. Ad esempio, il dominio di categoria \$1R, G, B\$1 può essere codificato come \$10, 1, 2\$1. Tutti i valori di ciascun dominio di categoria devono essere rappresentati nel set di dati di addestramento. In tal modo l'algoritmo DeepAR può prevedere solo le categorie che sono state osservate durante l’addestramento. Inoltre, ciascuna caratteristica di categoria è incorporata in uno spazio a bassa dimensione le cui dimensioni sono supervisionate dall'iperparametro `embedding_dimension`. Per ulteriori informazioni, consulta [Iperparametri DeepAR](deepar_hyperparameters.md).
Se usi un file JSON, il formato del file deve essere [JSON Lines](http://jsonlines.org/). Esempio:
```
{"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]]}
```
In questo esempio, ogni serie temporale ha due caratteristiche di categoria associate e le caratteristiche di una serie temporale.
Per Parquet, puoi usare gli stessi tre campi come colonne. Inoltre, `"start"` può essere il tipo `datetime`. Puoi comprimere i file Parquet usando gzip (`gzip`) o la libreria di compressione Snappy (`snappy`).
Se l'algoritmo viene addestrato senza i campi `cat` e `dynamic_feat`, apprende un modello "globale", che è un modello indipendente rispetto all'identità specifica della serie temporale target durante l'inferenza ed è subordinato solo alla sua forma.
Se il modello è subordinato ai dati caratteristica `cat` e `dynamic_feat` forniti per ogni serie temporale, la previsione sarà probabilmente influenzata dal carattere della serie temporale con le caratteristiche `cat` corrispondenti. Ad esempio, se la serie temporale `target` rappresenta la richiesta di articoli di vestiario, puoi associare un vettore `cat` bidimensionale che codifica il tipo di articolo (ad esempio 0 = scarpe, 1 = vestito) nel primo componente e il colore di un articolo (ad esempio, 0 = rosso, 1 = blu) nel secondo componente. L'aspetto di un input di esempio è simile al seguente.
```
{ "start": ..., "target": ..., "cat": [0, 0], ... } # red shoes
{ "start": ..., "target": ..., "cat": [1, 1], ... } # blue dress
```
Durante l'inferenza, puoi richiedere previsioni per target con valori `cat` che sono combinazioni dei valori `cat` osservati nei dati di addestramento, ad esempio:
```
{ "start": ..., "target": ..., "cat": [0, 1], ... } # blue shoes
{ "start": ..., "target": ..., "cat": [1, 0], ... } # red dress
```
Le seguenti linee guida si applicano ai dati di addestramento:
+ L'ora di inizio e la durata della serie temporale può differire. Ad esempio, nel marketing, i prodotti spesso sono inseriti in un catalogo di vendita al dettaglio in date diverse, pertanto la loro date di inizio differiscono naturalmente. Tutte le serie devono, tuttavia, avere la stessa frequenza, il numero di caratteristiche di categoria e il numero di caratteristiche dinamiche.
+ Il file di addestramento viene ordinato casualmente in base alla posizione delle serie temporali nel file. In altre parole, le serie temporali sono disposte in ordine casuale nel file.
+ Assicurati di impostare correttamente il campo `start`. L'algoritmo usa il timestamp `start` per determinare le caratteristiche interne.
+ Se utilizzi le caratteristiche di categoria (`cat`), tutte le serie temporali devono avere lo stesso numero di caratteristiche di categoria. Se il set di dati contiene il campo `cat`, l'algoritmo lo utilizza ed estrae la cardinalità dei gruppi dal set di dati. Per impostazione predefinita, `cardinality` è `"auto"`. Se il set di dati contiene il campo `cat`, ma non lo vuoi utilizzare, puoi disabilitarlo impostando `cardinality` su `""`. Se un modello è stato addestrato utilizzando una caratteristica `cat`, è necessario includerla per l'inferenza.
+ Se il set di dati contiene il campo `dynamic_feat`, l'algoritmo lo utilizza automaticamente. Tutte le serie temporali devono avere lo stesso numero di serie temporali di caratteristiche. I punti temporali di ciascuna serie temporale delle funzionalità corrispondono one-to-one ai punti temporali dell'obiettivo. Inoltre, la voce nel campo `dynamic_feat` deve avere la stessa lunghezza della voce nel campo `target`. Se il set di dati contiene il campo `dynamic_feat`, ma non lo vuoi utilizzare, puoi disabilitarlo impostando `num_dynamic_feat` su `""`. Se il modello è stato addestrato con il campo `dynamic_feat`, è necessario specificare il campo per l'inferenza. Inoltre, ciascuna delle caratteristiche deve avere la lunghezza del target fornito in aggiunta alla `prediction_length`. In altre parole, sarà necessario fornire il valore della caratteristica in futuro.
Se specifichi dati di canale di testing opzionali, l'algoritmo DeepAR valuta il modello addestrato con parametri di precisione differenti. L'algoritmo calcola la radice dell'errore quadratico medio (RMSE) sui dati di test come segue:
-y(i,t))^2))\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/deepar-1.png)
dove *y**i*,*t* è il valore true della serie temporale *i* al momento *t* e *ŷ**i*,*t* corrisponde alla previsione media. La somma è superiore a tutte le serie temporali *n* nel set di test e agli ultimi punti temporali T per ogni serie temporale, dove Τ corrisponde all'orizzonte di previsione. Puoi specificare la lunghezza dell'orizzonte di previsione impostando l'iperparametro `prediction_length`. Per ulteriori informazioni, consulta [Iperparametri DeepAR](deepar_hyperparameters.md).
Inoltre, l'accuratezza della distribuzione della previsione viene valutata dall'algoritmo utilizzando la perdita quantile ponderata. Per un quantile nell'intervallo [0, 1], la perdita quantile ponderata è definita come segue:
![\[Equazione ponderata della perdita quantile.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/deepar-2.png)
dove *q**i*,*t*(τ) è il quantile τ della distribuzione che il modello prevede. Per specificare per quali quantili calcolare la perdita, puoi imposta l'iperparametro `test_quantiles`. Inoltre, la media delle perdite quantile prescritte viene riportata come parte dei log di addestramento. Per informazioni, consulta [Iperparametri DeepAR](deepar_hyperparameters.md).
Per l'inferenza, DeepAR accetta il formato JSON e i seguenti campi:
+ `"instances"`, che include una o più serie temporali in formato JSON Lines
+ Un nome di `"configuration"`, che comprende i parametri per la generazione della previsione
Per ulteriori informazioni, consulta [Formati di inferenza DeepAR](deepar-in-formats.md).
## Best practice per l'utilizzo dell'algoritmo DeepAR
Quando prepari i dati delle serie temporali, segui queste best practice per ottenere i risultati migliori:
+ Fornisci sempre l'intera serie temporale per l’addestramento, il test e la chiamata del modello per l'inferenza, eccetto quando dividi il set di dati per l’addestramento e il test. Indipendentemente dal modo in cui imposti `context_length`, non suddividere la serie temporale oppure specificane solo una parte. Il modello utilizza i punti di dati più indietro rispetto al valore impostato in `context_length` per la caratteristica dei valori ritardati.
+ Quando ottimizzi un modello DeepAR, puoi dividere il set di dati per creare un set di dati di addestramento e un set di dati di test. In una valutazione tipica, esegui il test del modello sulle stesse serie temporali utilizzate per l’addestramento, ma sui futuri punti temporali `prediction_length` che seguono immediatamente dopo l'ultimo punto temporale visibile durante l’addestramento. Puoi creare set di dati di addestramento e di test che soddisfano questo criterio utilizzando l'intero set di dati (l'intera durata di tutte le serie temporali disponibili) come set di test e rimuovendo gli ultimi punti `prediction_length` da ogni serie temporale per l’addestramento. Durante l’addestramento, il modello non vede i valori di target per i punti temporali su cui viene valutato per il test. Durante il test, l'algoritmo trattiene gli ultimi punti `prediction_length` di ogni serie temporale nel set di test e genera una previsione. Quindi confronta la previsione con i valori trattenuti. Puoi creare valutazioni più complesse ripetendo le serie temporali più volte nel set di test, ma tagliandole in corrispondenza di diversi endpoint. Grazie a questo approccio, i parametri di accuratezza vengono calcolati su più previsioni da diversi punti temporali. Per ulteriori informazioni, consulta [Ottimizzazione di un modello DeepAR](deepar-tuning.md).
+ Evita di utilizzare valori molto grandi (>400) per `prediction_length` perché rende il modello lento e meno accurato. Se vuoi eseguire previsioni ancora più nel futuro, considera l'aggregazione dei dati a una frequenza inferiore. Ad esempio, utilizza `5min` anziché `1min`.
+ Dal momento che vengono utilizzati i ritardi, un modello può guardare più indietro nelle serie temporali rispetto al valore specificato per `context_length`. Pertanto, non è necessario impostare questo parametro su un valore elevato. Ti consigliamo di iniziare con il valore utilizzato per `prediction_length`.
+ Consigliamo di eseguire il training di un modello DeepAR su tutte le serie temporali disponibili. Sebbene un modello DeepAR addestrato su una singola serie temporale possa comunque funzionare bene, gli algoritmi di previsione standard, come ARIMA o ETS, potrebbero fornire risultati più accurati. L'algoritmo DeepAR inizia a ottenere risultati migliori dei metodi standard quando il set di dati contiene centinaia di serie temporali correlate. Al momento, DeepAR richiede che il numero totale di osservazioni disponibili in tutte le serie temporali di addestramento sia almeno 300.
## Raccomandazioni dell'istanza EC2 per l'algoritmo DeepAR
Puoi addestrare DeepAR su entrambe le istanze GPU e CPU e nelle impostazioni a macchina singola e a macchine multiple. Ti consigliamo di iniziare con un'istanza CPU singola (ad esempio, ml.c4.2xlarge o ml.c4.4xlarge) e di passare a istanze GPU e a macchine multiple solo quando necessario. L'utilizzo GPUs di più macchine migliora la produttività solo per i modelli più grandi (con molte celle per strato e molti strati) e per mini-batch di grandi dimensioni (ad esempio, più di 512).
Per l'inferenza, DeepAR supporta solo le istanze CPU.
La specifica di valori elevati per `context_length`, `prediction_length`, `num_cells`, `num_layers` o `mini_batch_size` può creare modelli che sono troppo grandi per le istanze small. In questo caso, utilizza un tipo di istanza più grande o riduci i valori per questi parametri. Questo problema si verifica spesso anche durante l'esecuzione dei processi di ottimizzazione iperparametri. In tal caso, utilizza un tipo di istanza sufficientemente grande per il processo di ottimizzazione del modello e prendi in considerazione la limitazione dei valori superiori dei parametri critici per evitare errori di processo.
## Notebook di esempio di DeepAR
Per un taccuino di esempio che mostra come preparare un set di dati di serie temporali per addestrare l'algoritmo SageMaker AI DeepAR e come implementare il modello addestrato per eseguire inferenze, [vedi la demo di DeepAR sul set di dati sull'elettricità, che illustra le funzionalità avanzate di DeepAR su](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/deepar_electricity/DeepAR-Electricity.html) un set di dati del mondo reale. Per istruzioni sulla creazione e l'accesso alle istanze di notebook Jupyter da utilizzare per eseguire l'esempio in AI, consulta. SageMaker [Istanze SageMaker per notebook Amazon](nbi.md) Dopo aver creato e aperto un'istanza di notebook, scegli la scheda **Esempi SageMaker AI** per visualizzare un elenco di tutti gli esempi di IA. SageMaker Per aprire un notebook, seleziona la relativa scheda **Use (Utilizza)** e scegli **Create copy (Crea copia)**.
Per ulteriori informazioni sull'algoritmo Amazon SageMaker AI DeepAR, consulta i seguenti post di blog:
+ [Ora disponibile in Amazon SageMaker AI: algoritmo DeepAR per previsioni di serie temporali più accurate](https://aws.amazon.com/blogs/machine-learning/now-available-in-amazon-sagemaker-deepar-algorithm-for-more-accurate-time-series-forecasting/)
+ [Previsione approfondita della domanda con Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/deep-demand-forecasting-with-amazon-sagemaker/)
# Come funziona l'algoritmo DeepAR
Durante l’addestramento, DeepAR accetta un set di dati di addestramento e un set di dati di test facoltativo. Utilizza il set di dati di test per valutare il modello di addestramento. In generale, i set di dati non devono contenere lo stesso set di serie temporali. Puoi utilizzare un modello addestrato su un determinato set di addestramento per generare previsioni per il futuro della serie temporale nel set di addestramento e per altre serie temporali. I set di dati di addestramento e di test sono costituiti da una o, preferibilmente, più serie temporali di target. Ogni serie temporale di target può essere associata facoltativamente a un vettore di serie temporali di caratteristiche e a un vettore di caratteristiche di categoria. Per ulteriori informazioni, consulta [Interfaccia di input/output per l'algoritmo DeepAR](deepar.md#deepar-inputoutput).
Ad esempio, il seguente è un elemento di un set di addestramento indicizzato da *i* che è costituito da una serie temporale di target, *Zi,t*, e da due serie temporali di caratteristiche associate, *Xi,1,t* e *Xi,2,t*:
![\[Figura 1: serie temporali di target e serie temporali di caratteristiche associate\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/ts-full-159.base.png)
Le serie temporali di target potrebbero contenere valori mancanti, rappresentati da interruzioni di riga nelle serie temporali. DeepAR supporta solo le serie temporali di caratteristiche che saranno note in futuro. In questo modo è possibile considerare scenari ipotetici. scenari Cosa succede, ad esempio, se cambio il prezzo di un prodotto?
Ogni serie temporale di target può anche essere associata a una serie di caratteristiche di categoria. Puoi utilizzare queste caratteristiche per codificare a quali raggruppamenti appartiene una serie temporale. Le caratteristiche di categoria consentono al modello di apprendere il comportamento tipico dei gruppi, che può utilizzare per aumentare l'accuratezza del modello. DeepAR implementa questo modello tramite l'apprendimento di un vettore di incorporamento per ogni gruppo che acquisisce le proprietà comuni di tutte le serie temporali nel gruppo.
## Come funzionano le serie temporali di caratteristiche nell'algoritmo DeepAR
Per facilitare l'apprendimento di modelli dipendenti dal tempo, come i picchi durante i fine settimana, DeepAR crea automaticamente serie temporali basate sulla frequenza delle serie temporali di target. Utilizza queste serie temporali di caratteristiche derivate con le serie temporali di caratteristiche personalizzate fornite durante l’addestramento e l'inferenza. La seguente figura mostra due di queste caratteristiche di serie temporali derivate: *ui,1,t* rappresenta l'ora del giorno e *ui,2,t* il giorno della settimana.
![\[Figura 2: serie temporali derivate\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/ts-full-159.derived.png)
L'algoritmo DeepAR genera automaticamente queste serie temporali di caratteristiche. La seguente tabella elenca le caratteristiche derivate per le frequenze temporali di base supportate.
| Frequenza delle serie temporali | Caratteristiche derivate |
| --- | --- |
| Minute | `minute-of-hour`, `hour-of-day`, `day-of-week`, `day-of-month`, `day-of-year` |
| Hour | `hour-of-day`, `day-of-week`, `day-of-month`, `day-of-year` |
| Day | `day-of-week`, `day-of-month`, `day-of-year` |
| Week | `day-of-month`, `week-of-year` |
| Month | month-of-year |
DeepAR addestra un modello campionando a caso diversi esempi di addestramento da ciascuna delle serie temporali nel set di dati di addestramento. Ogni esempio di addestramento è costituito da una coppia di finestre di contesto e di previsione adiacenti con lunghezze predefinite fisse. L'iperparametro `context_length` controlla fino a che punto la rete può vedere nel passato e l'iperparametro `prediction_length` controlla quanto lontano possono essere fatte le previsioni future. Durante l’addestramento, l'algoritmo ignora gli elementi di addestramento contenenti serie temporali più brevi della lunghezza di previsione specificata. La figura seguente rappresenta cinque esempi con lunghezze di contesto di 12 ore e lunghezze di previsione di 6 ore ricavate dall'elemento *i*. Per brevità, abbiamo omesso le serie temporali di caratteristiche *xi,1,t* e *ui,2,t*.
![\[Figura 3: serie temporali campionate\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/ts-full-159.sampled.png)
Per acquisire modelli di stagionalità, DeepAR immette inoltre automaticamente valori ritardati di serie temporali di target. Nell'esempio con frequenza oraria, per ogni indice temporale, *t = T*, il modello espone i valori *zi,t*, che si sono verificati circa uno, due e tre giorni nel passato.
![\[Figura 4: serie temporali ritardate\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/ts-full-159.lags.png)
Per l'inferenza, il modello sottoposto al training prende come input le serie temporali target che potrebbero o meno essere state utilizzate durante il training e prevede una distribuzione di probabilità per i prossimi valori `prediction_length`. Poiché DeepAR è addestrato sull'intero set di dati, la previsione tiene conto dei modelli appresi da serie temporali simili.
Per informazioni sulla matematica dietro DeepAR, consulta [DeepAR: Probabilistic Forecasting with Autoregressive Recurrent Networks](https://arxiv.org/abs/1704.04110).
# Iperparametri DeepAR
La tabella seguente elenca gli iperparametri che puoi impostare durante l'allenamento con l'algoritmo di previsione Amazon SageMaker AI DeepAR.
| Nome parametro | Description |
| --- | --- |
| context\$1length | Il numero di punti temporali ottenuti dal modello prima di effettuare la previsione. Il valore di questo parametro deve essere più o meno lo stesso di `prediction_length`. Il modello, inoltre, riceve input ritardati dalla destinazione, perciò `context_length` può essere molto inferiore rispetto alle stagionalità tipiche. Ad esempio, una serie temporale giornaliera può avere una stagionalità annuale. Il modello include automaticamente un ritardo di un anno, pertanto la lunghezza del contesto può essere inferiore a un anno. I valori di ritardo che il modello preleva dipendono dalla frequenza della serie temporale. Ad esempio, i valori di ritardo per la frequenza giornaliera sono settimana precedente, 2 settimane, 3 settimane, 4 settimane e anno. **Campo obbligatorio** Valori validi: numeri interi positivi |
| epochs | Numero massimo di passate sui dati di addestramento. Il valore ottimale dipende dalle dimensioni dei dati e dalla velocità di apprendimento. Consulta anche `early_stopping_patience`. I valori tipici sono compresi tra 10 e 1000. **Campo obbligatorio** Valori validi: numeri interi positivi |
| prediction\$1length | Numero di fasi temporali che il modello è in grado di prevedere, noto anche come orizzonte di previsione. Il modello addestrato genera sempre previsioni con questa durata. Non è in grado di generare previsioni più lunghe. Il valore `prediction_length` viene fissato quando un modello viene addestrato e non può essere modificato in un secondo momento. **Campo obbligatorio** Valori validi: numeri interi positivi |
| time\$1freq | Granularità della serie temporale nel set di dati. Utilizza `time_freq` per selezionare i ritardi e le funzionalità relative alla data. Il modello supporta solo le seguenti frequenze di base. Inoltre, supporta più frequenze di base. Ad esempio, `5min` specifica una frequenza di 5 minuti. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/deepar_hyperparameters.html) **Campo obbligatorio** I valori validi: un numero intero seguito da *M*, *W*, *D*, *H* o *min*. Ad esempio, `5min`. |
| cardinality | Quando utilizzi la caratteristiche di categoria (`cat`), `cardinality` è una matrice che specifica il numero di categorie (gruppi) per ogni caratteristica di categoria. Imposta il valore su `auto` per dedurre la cardinalità dai dati. La modalità `auto` funziona anche quando nel set di dati non vengono utilizzate caratteristiche di categoria. Questa è l'impostazione consigliata per il parametro. Imposta la cardinalità su `ignore` per forzare DeepAR a non utilizzare le caratteristiche di categoria, anche se presenti nei dati. Per eseguire ulteriori convalide dei dati, è possibile impostare esplicitamente questo parametro sul valore effettivo. Ad esempio, se vengono fornite due caratteristiche di categoria in cui la prima ha 2 e l'altra ha 3 valori possibili, imposta il parametro su [2, 3]. Per ulteriori informazioni su come utilizzare la caratteristica di categoria, consulta la sezione dei dati nella pagina della documentazione principale di DeepAR. **Opzionale** I valori validi: `auto`, `ignore`, array di interi positivi, stringa vuota oppure Valore predefinito: `auto` |
| dropout\$1rate | Tasso di abbandono da utilizzare durante l’addestramento. Il modello utilizza la regolarizzazione del metodo zoneout. Per ogni iterazione un sottoinsieme casuale di neuroni nascosti non viene aggiornato. I valori tipici sono inferiori a 0,2. **Opzionale** Valori validi: float. Valore predefinito: 0,1 |
| early\$1stopping\$1patience | Se questo parametro è impostato, l’addestramento si interrompe quando non si registrano progressi entro il numero specificato di `epochs`. Il modello con la perdita più bassa viene restituito come modello finale. **Opzionale** Valori validi: numero intero |
| embedding\$1dimension | La dimensione del vettore di incorporamento appreso per caratteristica di categoria (lo stesso valore è utilizzato per tutte le caratteristiche di categoria). Il modello DeepAR può apprendere modelli di serie temporali a livello di gruppo quando viene fornita una caratteristica di raggruppamento categorica. Per eseguire questa operazione, il modello apprende un vettore di incorporamento di dimensioni `embedding_dimension` per ciascun gruppo e acquisisce le proprietà comuni a tutte le serie temporali del gruppo. Un valore `embedding_dimension` più grande consente al modello di acquisire modelli più complessi. Tuttavia, perché l'aumento di `embedding_dimension` aumenti il numero di parametri nel modello, sono necessari più dati di addestramento per apprendere correttamente questi parametri. I valori tipici di questo parametro sono compresi tra 10 e 100. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 10 |
| learning\$1rate | Velocità di apprendimento utilizzata durante l’addestramento. I valori tipici sono compresi tra 1e-4 e 1e-1. **Opzionale** Valori validi: float. Valore predefinito: 1e-3 |
| likelihood | Il modello genera una previsione probabilistica e può fornire quantili della distribuzione e restituire campioni. A seconda dei tuoi dati, seleziona una probabilità appropriata (modello di disturbo) utilizzata per le stime di incertezza. È possibile selezionare le probabilità seguenti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/deepar_hyperparameters.html) **Opzionale** Valori validi: uno tra *gaussian (gaussiano)*, *beta*, *negative-binomial (binomial negativo)*, *student-T (T studente)* e *deterministic-L1 (L1 deterministico)*. Valore predefinito: `student-T` |
| mini\$1batch\$1size | Dimensione dei mini batch usati durante l’addestramento. I valori tipici sono compresi tra 32 e 512. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 128 |
| num\$1cells | Numero di celle da utilizzare in ciascun livello nascosto delle reti neurali ricorrenti (RNN). I valori tipici sono compresi tra 30 e 100. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 40 |
| num\$1dynamic\$1feat | Il numero di `dynamic_feat` forniti nei dati. Imposta il valore su `auto` per dedurre il numero di caratteristiche dinamiche dai dati. La modalità `auto` funziona anche quando nel set di dati non vengono utilizzate caratteristiche dinamiche. Questa è l'impostazione consigliata per il parametro. Per forzare DeepAR a non utilizzare le caratteristiche dinamiche, anche se presenti nei dati, imposta `num_dynamic_feat` su `ignore`. Per eseguire ulteriori convalide dei dati, è possibile impostare esplicitamente questo parametro sul numero intero effettivo. Ad esempio, se vengono fornite due caratteristiche dinamiche, imposta questo valore su 2. **Opzionale** I valori validi: `auto`, `ignore`, numero intero positivo o stringa vuota Valore predefinito: `auto` |
| num\$1eval\$1samples | Il numero di esempi utilizzati per ogni serie temporale quando si calcolano i parametri di accuratezza del test. Questo parametro non ha alcuna influenza sull’addestramento o sul modello finale. In particolare, è possibile eseguire le query sul modello con un numero di esempi diverso. Questo parametro influisce solo sui punteggi di accuratezza riportati nel canale di test dopo l’addestramento. I valori più piccoli producono una valutazione più rapidamente, ma i punteggi di valutazione sono in genere peggiori e meno accurati. Quando si valuta con quantili più elevati, ad esempio 0,95, può essere importante aumentare il numero di esempi di valutazione. **Opzionale** Valori validi: numero intero Valore predefinito: 100 |
| num\$1layers | Numero di livelli nascosti nelle reti neurali ricorrenti (RNN). I valori tipici sono compresi tra 1 e 4. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 2 |
| test\$1quantiles | Quantili per i quali calcolare lo scarto quantile sul canale di test. **Opzionale** Valori validi: array di float Valore predefinito: [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] |
# Ottimizzazione di un modello DeepAR
L'*ottimizzazione automatica dei modelli*, nota anche come ottimizzazione degli iperparametri, trova la versione migliore di un modello eseguendo molti processi che testano un intervallo di iperparametri sul set di dati. Scegli gli iperparametri ottimizzabili, un intervallo di valori per ciascuno di essi e un parametro obiettivo. Puoi scegliere il parametro obiettivo tra i parametri calcolati dall'algoritmo. L'ottimizzazione automatica del modello ricerca gli iperparametri scelti per trovare la combinazione di valori che restituisce il modello che ottimizza il parametro obiettivo.
Per ulteriori informazioni sull'ottimizzazione del modello, consulta [Ottimizzazione automatica dei modelli con AI SageMaker](automatic-model-tuning.md).
## Parametri calcolati dall'algoritmo DeepAR
L'algoritmo DeepAR restituisce tre parametri che vengono calcolati durante l’addestramento. Quando ottimizzi un modello, scegli uno di questi parametri come obiettivo. Per l'obiettivo, utilizza l'accuratezza di previsione su un canale di test fornito (consigliato) o la perdita dell’addestramento. Per consigli sulla training/test suddivisione per l'algoritmo DeepAr, vedere. [Best practice per l'utilizzo dell'algoritmo DeepAR](deepar.md#deepar_best_practices)
| Nome parametro | Description | Direzione dell'ottimizzazione |
| --- | --- | --- |
| test:RMSE | La radice dell'errore quadratico medio tra la previsione e il target effettivo calcolato sul set di test. | Minimizza |
| test:mean\$1wQuantileLoss | Le perdite quantile complessive medie calcolate sul set di test. Per controllare quali quantili vengono utilizzati, imposta l'iperparametro `test_quantiles`. | Minimizza |
| train:final\$1loss | La perdita di probabilità log negativa dell’addestramento è stata calcolata in media sull'ultima epoca (Unix epoch) di addestramento per il modello. | Minimizza |
## Iperparametri ottimizzabili per l'algoritmo DeepAR
Ottimizza un modello DeepAR con i seguenti iperparametri. Gli iperparametri che hanno il maggiore impatto, elencati partendo dal maggior impatto, sui parametri obiettivo DeepAR sono: `epochs`, `context_length`, `mini_batch_size`, `learning_rate` e `num_cells`.
| Nome parametro | Tipo parametro | Intervalli consigliati |
| --- | --- | --- |
| epochs | `IntegerParameterRanges` | MinValue: 1, MaxValue: 1000 |
| context\$1length | `IntegerParameterRanges` | MinValue: 1, MaxValue 20 |
| mini\$1batch\$1size | `IntegerParameterRanges` | MinValue: 32, MaxValue 1028 |
| learning\$1rate | `ContinuousParameterRange` | MinValue: 1e-5,: 1e-1 MaxValue |
| num\$1cells | `IntegerParameterRanges` | MinValue: 30,: 20 MaxValue |
| num\$1layers | `IntegerParameterRanges` | MinValue: 1, MaxValue: 8 |
| dropout\$1rate | `ContinuousParameterRange` | MinValue: 0,00, MaxValue 0,2 |
| embedding\$1dimension | `IntegerParameterRanges` | MinValue: 1, MaxValue: 50 |
# Formati di inferenza DeepAR
La pagina seguente descrive i formati di richiesta e risposta per l'inferenza con il modello Amazon SageMaker AI DeepAR.
## Formati della richiesta JSON DeepAR
Esegui la query a un modello addestrato utilizzando l'endpoint del modello. L'endpoint necessita del seguente formato di richiesta JSON.
Nella richiesta, il campo `instances` corrisponde alla serie temporale che deve essere prevista dal modello.
Se il modello è stato sottoposto a training con categorie, devi fornire un `cat` per ogni istanza. Se il modello è stato addestrato senza il campo `cat`, il modello deve essere omesso.
Se il modello è stato addestrato con una serie temporale di caratteristiche personalizzate (`dynamic_feat`), devi fornire lo stesso numero di valori `dynamic_feat` per ogni istanza. Ognuno di essi deve avere una lunghezza data da `length(target) + prediction_length`, dove gli ultimi valori `prediction_length` corrispondono ai punti temporali futuri che saranno previsti. Se il modello è stato addestrato senza serie temporali personalizzate, il campo non deve essere incluso nella richiesta.
```
{
"instances": [
{
"start": "2009-11-01 00:00:00",
"target": [4.0, 10.0, "NaN", 100.0, 113.0],
"cat": [0, 1],
"dynamic_feat": [[1.0, 1.1, 2.1, 0.5, 3.1, 4.1, 1.2, 5.0, ...]]
},
{
"start": "2012-01-30",
"target": [1.0],
"cat": [2, 1],
"dynamic_feat": [[2.0, 3.1, 4.5, 1.5, 1.8, 3.2, 0.1, 3.0, ...]]
},
{
"start": "1999-01-30",
"target": [2.0, 1.0],
"cat": [1, 3],
"dynamic_feat": [[1.0, 0.1, -2.5, 0.3, 2.0, -1.2, -0.1, -3.0, ...]]
}
],
"configuration": {
"num_samples": 50,
"output_types": ["mean", "quantiles", "samples"],
"quantiles": ["0.5", "0.9"]
}
}
```
Il campo `configuration` è facoltativo. `configuration.num_samples` imposta il numero di percorsi di esempio generati dal modello per stimare la media e i quantili. `configuration.output_types` descrive le informazioni che vengono restituite nella richiesta. I valori validi sono `"mean"``"quantiles"` e `"samples"`. Se specifichi `"quantiles"`, ciascuno dei valori di quantili in `configuration.quantiles` viene restituito come serie temporale. Se specifichi `"samples"`, il modello restituisce anche i campioni non elaborati utilizzati per calcolare le altre uscite.
## Formati della risposta JSON DeepAR
Di seguito è riportato il formato di una risposta, dove `[...]` sono matrici di numeri:
```
{
"predictions": [
{
"quantiles": {
"0.9": [...],
"0.5": [...]
},
"samples": [...],
"mean": [...]
},
{
"quantiles": {
"0.9": [...],
"0.5": [...]
},
"samples": [...],
"mean": [...]
},
{
"quantiles": {
"0.9": [...],
"0.5": [...]
},
"samples": [...],
"mean": [...]
}
]
}
```
DeepAR ha un timeout di risposta di 60 secondi. Quando si passano più serie temporali in una singola richiesta, le previsioni vengono generate in modo sequenziale. Poiché la previsione per ciascuna serie temporale richiede in genere da 300 ad almeno 1000 millisecondi a seconda delle dimensioni del modello, il passaggio di troppe serie temporali in una singola richiesta può causare il timeout. È meglio inviare meno serie temporali per richiesta e inviare più richieste. Dal momento che l'algoritmo DeepAR utilizza più worker per istanza, è possibile ottenere un throughput molto più elevato inviando più richieste in parallelo.
Per impostazione predefinita, DeepAR utilizza un worker per CPU per l'inferenza, se c'è sufficiente memoria per CPU. Se il modello è di grandi dimensioni e non c'è abbastanza memoria per eseguire un modello su ciascuna CPU, il numero di worker è ridotto. Il numero di worker utilizzati per l'inferenza può essere sovrascritto utilizzando la variabile di ambiente (ad `MODEL_SERVER_WORKERS` esempio, impostando`MODEL_SERVER_WORKERS=1`) quando si chiama l'API AI. SageMaker [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)
## Trasformazione in batch con l'algoritmo DeepAR
La previsione DeepAR supporta l'inferenza utilizzando la trasformazione in batch dai dati utilizzando il formato JSON Lines. In questo formato, ogni record è rappresentato su una singola riga come oggetto JSON e le righe sono separate da caratteri di nuova riga. Il formato è identico al formato JSON Lines utilizzato per l’addestramento del modello. Per informazioni, consulta [Interfaccia di input/output per l'algoritmo DeepAR](deepar.md#deepar-inputoutput). Esempio:
```
{"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]]}
```
**Nota**
Quando crei il processo di trasformazione con [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html), imposta il valore `BatchStrategy` su `SingleRecord` e il valore `SplitType` nella configurazione [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html) su `Line`, poiché al momento i valori di default provocano errori di runtime.
Simile al formato della richiesta di inferenza dell'endpoint ospitato, il `cat` e i campi `dynamic_feat` per ogni istanza sono obbligatori se sono vere entrambe le seguenti condizioni:
+ Il modello viene addestrato su un set di dati che contiene il `cat` e i campi `dynamic_feat`.
+ I valori corrispondenti `cardinality` e `num_dynamic_feat` utilizzati nel processo di addestramento non sono impostati su `"".`
Diversamente dall'inferenza dell'endpoint ospitato, il campo di configurazione viene impostato una volta per l'intero processo di inferenza batch utilizzando una variabile di ambiente denominata `DEEPAR_INFERENCE_CONFIG`. Il valore di `DEEPAR_INFERENCE_CONFIG` può essere passato quando il modello viene creato da una chiamata all'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html). Se `DEEPAR_INFERENCE_CONFIG` non è specificato nell'ambiente del container, il container di inferenza utilizza il seguente valore predefinito:
```
{
"num_samples": 100,
"output_types": ["mean", "quantiles"],
"quantiles": ["0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9"]
}
```
Anche l'output è in formato JSON Lines, con una riga per previsione, nell'ordine identico all'ordine di istanza nel file di input corrispondente. Le previsioni sono codificate come oggetti identici a quelli restituiti dalle risposte in modalità di inferenza online. Esempio:
```
{ "quantiles": { "0.1": [...], "0.2": [...] }, "samples": [...], "mean": [...] }
```
Nota che nella [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html)configurazione della [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)richiesta SageMaker AI i client devono impostare esplicitamente il valore su`Line`, poiché il `AssembleWith` valore predefinito `None` concatena tutti gli oggetti JSON sulla stessa riga.
Ad esempio, ecco una [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)richiesta SageMaker AI per un job DeepAr con una personalizzazione: `DEEPAR_INFERENCE_CONFIG`
```
{
"BatchStrategy": "SingleRecord",
"Environment": {
"DEEPAR_INFERENCE_CONFIG" : "{ \"num_samples\": 200, \"output_types\": [\"mean\"] }",
...
},
"TransformInput": {
"SplitType": "Line",
...
},
"TransformOutput": {
"AssembleWith": "Line",
...
},
...
}
```