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à.

# Algoritmi SageMaker AI integrati per dati di testo
<a name="algorithms-text"></a>

SageMaker L'intelligenza artificiale fornisce algoritmi personalizzati per l'analisi dei documenti testuali utilizzati nell'elaborazione del linguaggio naturale, nella classificazione o riepilogo dei documenti, nella modellazione o classificazione degli argomenti e nella trascrizione o traduzione linguistica.
+ [BlazingText algoritmo](blazingtext.md): un'implementazione altamente ottimizzata di Word2vec e algoritmi di classificazione del testo che si adattano facilmente a set di dati di grandi dimensioni. È utile per molte attività successive di elaborazione del linguaggio naturale (NLP).
+ [Algoritmo Allocazione latente di Dirichlet (LDA, Latent Dirichlet Allocation)](lda.md): un algoritmo idoneo per determinare gli argomenti in un set di documenti. Si tratta di un *algoritmo non supervisionato* e pertanto non utilizza dati di esempio con risposte durante l'addestramento.
+ [Algoritmo Modello neurale di argomenti (NTM)](ntm.md): un'altra tecnica non supervisionata per determinare gli argomenti in un set di documenti, utilizzando un approccio di rete neurale.
+ [Algoritmo Object2Vec](object2vec.md): un algoritmo di incorporamento neurale generico che può essere utilizzato per sistemi di raccomandazione, classificazione di documenti e incorporamento di frasi.
+ [Sequence-to-Sequence Algoritmo](seq-2-seq.md): questo algoritmo supervisionato è utilizzato comunemente per la traduzione automatica neurale. 
+ [Classificazione del testo - TensorFlow](text-classification-tensorflow.md): un algoritmo supervisionato che supporta l’apprendimento del trasferimento con modelli preaddestrati disponibili per la classificazione del testo. 


| Nome algoritmo | Nome canale | Modalità di input per l'addestramento | Tipo di file | Classe di istanza | Parallelizzabile | 
| --- | --- | --- | --- | --- | --- | 
| BlazingText | Addestramento | File o Pipe | File di testo (una frase per riga con token separati da spazio)  | GPU (solo istanza singola) o CPU | No | 
| LDA | addestrare e (facoltativamente) testare | File o Pipe | recordIO-protobuf o CSV | CPU (solo istanza singola) | No | 
| Modello argomento neurale | addestramento e (facoltativamente) convalida, test o entrambi | File o Pipe | recordIO-protobuf o CSV | GPU o CPU | Sì | 
| Object2Vec | addestramento e (facoltativamente) convalida, test o entrambi | File | JSON Lines  | GPU o CPU (solo istanza singola) | No | 
| Modellazione Seq2Seq | addestramento, convalida e vocab | File | recordIO-protobuf | GPU (solo istanza singola) | No | 
| Classificazione del testo - TensorFlow | Addestramento e convalida | File | CSV | CPU o GPU | Sì (solo su più istanze GPUs su una singola istanza) | 

# BlazingText algoritmo
<a name="blazingtext"></a>

L' BlazingText algoritmo Amazon SageMaker AI fornisce implementazioni altamente ottimizzate di Word2vec e algoritmi di classificazione del testo. L'algoritmo Word2vec è utile per molte attività di elaborazione del linguaggio naturale (NLP) downstream, come l'analisi di valutazione, il riconoscimento di entità con nome, la traduzione automatica e così via. La classificazione del testo è un compito rilevante per le applicazioni che eseguono ricerche sul Web, recupero di informazioni, classifiche e classificazione dei documenti.

L'algoritmo Word2vec mappa le parole ai vettori distribuiti di alta qualità. La rappresentazione vettoriale risultante di una parola viene chiamata *incorporamento di parola*. Le parole semanticamente simili corrispondono a vettori vicini. In questo modo, gli incorporamenti di parola acquisiscono le relazioni semantiche tra le parole. 

Molte applicazioni di elaborazione del linguaggio naturale (NLP) apprendono gli incorporamenti di parola tramite l’addestramento di ampie raccolte di documenti. Queste rappresentazioni vettoriali già addestrate forniscono informazioni sulla semantica e sulle distribuzioni di parole che solitamente migliorano la generalizzabilità di altri modelli successivamente addestrati su una quantità di dati più limitata. La maggior parte degli algoritmi Word2vec non sono ottimizzati per architetture di CPU multi-core. Ciò rende difficile il ridimensionamento di set di dati di grandi dimensioni. 

Con l' BlazingText algoritmo, puoi scalare facilmente set di dati di grandi dimensioni. Simile a Word2vec, fornisce le architetture Skip-gram e di formazione continua bag-of-words (CBOW). BlazingText[l'implementazione dell'algoritmo di classificazione del testo multiclasse e multietichetta supervisionato estende il classificatore di testo FastText per utilizzare l'accelerazione GPU con kernel CUDA personalizzati.](https://docs.nvidia.com/cuda/index.html) Puoi addestrare un modello per oltre un miliardo di parole in un paio di minuti usando una CPU multi-core o una GPU. Inoltre, si ottengono prestazioni pari a quelle degli algoritmi di classificazione del testo di deep learning. state-of-the-art

L' BlazingText algoritmo non è parallelizzabile. Per ulteriori informazioni sui parametri relativi alla formazione, consulta [Docker Registry Paths for SageMaker ](https://docs.aws.amazon.com/en_us/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html) Built-in Algorithms.

 BlazingText Gli algoritmi di SageMaker intelligenza artificiale offrono le seguenti funzionalità:
+ Addestramento accelerato del classificatore di testo FastText su CPUs multi-core o GPU e GPUs Word2Vec sull'utilizzo di kernel CUDA altamente ottimizzati. [Per ulteriori informazioni, consulta: Scalabilità e accelerazione di Word2Vec utilizzando più applicazioni. BlazingText GPUs](https://dl.acm.org/citation.cfm?doid=3146347.3146354)
+ [Vettori di parola potenziati con le informazioni sulle parole secondarie](https://arxiv.org/abs/1607.04606) tramite l'apprendimento delle rappresentazioni vettoriali per n-grammi di caratteri. Questo approccio consente di BlazingText generare vettori significativi per le parole out-of-vocabulary (OOV) rappresentando i relativi vettori come la somma dei vettori n-gram (sottoparola) di caratteri.
+ `batch_skipgram` `mode` per l'algoritmo Word2Vec che consente un addestramento più veloce e il calcolo distribuito su più nodi della CPU. `batch_skipgram` `mode` esegue il mini-batch utilizzando la strategia Negative Sample Sharing per convertire le operazioni BLAS di livello 1 in operazioni BLAS di livello 3. In tal modo si utilizzano efficacemente le istruzioni di aggiunta multipla delle architetture moderne. Per ulteriori informazioni, consulta [Parallelizzazione di Word2Vec in memoria condivisa e distribuita](https://arxiv.org/pdf/1604.04661.pdf).

Per riassumere, le seguenti modalità sono supportate da istanze di diversi tipi: BlazingText 


| Modalità |  Word2Vec (apprendimento non supervisionato)  |  Classificazione del testo (apprendimento supervisionato)  | 
| --- | --- | --- | 
|  Istanza CPU singola  |  `cbow` `Skip-gram` `Batch Skip-gram`  |  `supervised`  | 
|  Istanza GPU singola (con 1 o più) GPUs  |  `cbow` `Skip-gram`  |  `supervised` con una GPU  | 
|  Istanze CPU multiple  | Batch Skip-gram  | Nessuno | 

Per ulteriori informazioni sulla matematica alla base BlazingText, vedi [BlazingText: Scaling and Accelerating](https://dl.acm.org/citation.cfm?doid=3146347.3146354) Word2Vec using Multiple. GPUs

**Topics**
+ [Interfaccia BlazingText di input/output per l'algoritmo](#bt-inputoutput)
+ [Raccomandazione dell'istanza EC2 per l'algoritmo BlazingText](#blazingtext-instances)
+ [BlazingText Notebook di esempio](#blazingtext-sample-notebooks)
+ [BlazingText Iperparametri](blazingtext_hyperparameters.md)
+ [Ottimizza un modello BlazingText](blazingtext-tuning.md)

## Interfaccia BlazingText di input/output per l'algoritmo
<a name="bt-inputoutput"></a>

L' BlazingText algoritmo prevede un singolo file di testo preelaborato con token separati da spazi. Ogni riga del file deve contenere una sola frase. Se devi usare più file di testo per l’addestramento, concatenali in un unico file e carica il file nel rispettivo canale.

### Formato dei dati di addestramento e convalida
<a name="blazingtext-data-formats"></a>

#### Formato dei dati di addestramento e convalida per l'algoritmo Word2Vec
<a name="blazingtext-data-formats-word2vec"></a>

Per l’addestramento di Word2Vec, carica il file nel canale *train*. Non sono supportati altri canali. Il file deve contenere una frase di addestramento per riga.

#### Formato dei dati di addestramento e convalida per l'algoritmo di classificazione del testo
<a name="blazingtext-data-formats-text-class"></a>

Per la modalità supervisionata, puoi addestrare con la modalità file o con il formato di testo manifest aumentato.

##### Addestramento con la modalità di file
<a name="blazingtext-data-formats-text-class-file-mode"></a>

Per la `supervised` modalità, il training/validation file dovrebbe contenere una frase di addestramento per riga insieme alle etichette. Le etichette sono parole precedute dalla stringa *\$1\$1label\$1\$1*. Ecco un esempio di training/validation file:

```
__label__4  linux ready for prime time , intel says , despite all the linux hype , the open-source movement has yet to make a huge splash in the desktop market . that may be about to change , thanks to chipmaking giant intel corp .

__label__2  bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly as the indian skippers return to international cricket was short lived .
```

**Nota**  
L'ordine delle etichette all'interno della frase non è rilevante. 

Carica il file di addestramento nel canale di addestramento e, facoltativamente, carica il file di convalida nel canale di convalida.

##### Addestramento con il formato di testo manifest aumentato
<a name="blazingtext-data-formats-text-class-augmented-manifest"></a>

La modalità supervisionata per le istanze CPU supporta anche il formato di manifest aumentato che ti consente di addestrare in modalità pipe senza dover creare file RecordIO. Quando si usa questo formato, è necessario generare un file manifest S3 che contenga l'elenco delle frasi e delle etichette corrispondenti. Il formato del file manifest deve essere in [JSON Lines](http://jsonlines.org/) dove ogni riga rappresenta un esempio. Le frasi sono specificate utilizzando il tag `source` e l'etichetta può essere specificata utilizzando il tag `label`. È necessario specificare i tag `source` e `label` nel valore del parametro `AttributeNames` come specificato nella richiesta.

```
{"source":"linux ready for prime time , intel says , despite all the linux hype", "label":1}
{"source":"bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly", "label":2}
```

L’addestramento multi-etichetta è supportato anche specificando un array di etichette JSON.

```
{"source":"linux ready for prime time , intel says , despite all the linux hype", "label": [1, 3]}
{"source":"bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly", "label": [2, 4, 5]}
```

Per ulteriori informazioni sui file manifest aumentati, consulta [File di manifesto aumentati nei job di addestramento](augmented-manifest.md).

### Artefatti del modello e inferenza
<a name="blazingtext-artifacts-inference"></a>

#### Artefatti del modello per l'algoritmo Word2Vec
<a name="blazingtext--artifacts-inference-word2vec"></a>

Per l'addestramento con Word2Vec, gli artefatti del modello sono costituiti da *vectors.txt*, che contiene la words-to-vectors mappatura, e *vectors.bin*, un file binario utilizzato BlazingText per l'hosting, l'inferenza o entrambi. *vectors.txt* memorizza i vettori in un formato compatibile con altri strumenti come Gensim e Spacy. Ad esempio, un utente Gensim può eseguire i seguenti comandi per caricare il file vectors.txt:

```
from gensim.models import KeyedVectors
word_vectors = KeyedVectors.load_word2vec_format('vectors.txt', binary=False)
word_vectors.most_similar(positive=['woman', 'king'], negative=['man'])
word_vectors.doesnt_match("breakfast cereal dinner lunch".split())
```

Se il parametro di valutazione è impostato su `True`, viene creato un ulteriore file, *eval.json*. Questo file contiene i risultati di valutazione di somiglianza (usando i coefficienti di correlazione per la classifica di Spearman) nel set di dati WS-353. Viene restituito il numero di parole del set di dati WS-353 che non sono presenti nel corpus dell’addestramento.

Per le richieste di inferenza, il modello accetta un file JSON contenente un elenco di stringhe e restituisce un elenco di vettori. Se la parola non è disponibile nel vocabolario, l'inferenza restituisce un vettore di zeri. Se le subwords sono impostate su `True` durante l'addestramento, il modello è in grado di generare vettori per out-of-vocabulary parole (OOV).

##### Richiesta JSON di esempio
<a name="word2vec-json-request"></a>

Mime-type:` application/json`

```
{
"instances": ["word1", "word2", "word3"]
}
```

#### Artefatti del modello per l'algoritmo di classificazione del testo
<a name="blazingtext-artifacts-inference-text-class"></a>

L'addestramento con output supervisionati crea un file *model.bin* che può essere utilizzato dall'hosting. BlazingText Per l'inferenza, il BlazingText modello accetta un file JSON contenente un elenco di frasi e restituisce un elenco delle etichette previste e dei punteggi di probabilità corrispondenti. Ogni frase deve essere una stringa con token, parole o entrambi separati da spazio.

##### Richiesta JSON di esempio
<a name="text-class-json-request"></a>

Mime-type:` application/json`

```
{
 "instances": ["the movie was excellent", "i did not like the plot ."]
}
```

Per impostazione predefinita, il server restituisce un solo previsione, quella con la massima probabilità. Per recuperare le prime *k* previsioni, è possibile impostare *k* nella configurazione, come segue:

```
{
 "instances": ["the movie was excellent", "i did not like the plot ."],
 "configuration": {"k": 2}
}
```

Perché BlazingText, i `accept` parametri ` content-type` and devono essere uguali. Per la trasformazione in batch, entrambi devono essere `application/jsonlines`. Se differiscono, il campo `Accept` viene ignorato. Il formato dell'input è il seguente:

```
content-type: application/jsonlines

{"source": "source_0"}
{"source": "source_1"}

if you need to pass the value of k for top-k, then you can do it in the following way:

{"source": "source_0", "k": 2}
{"source": "source_1", "k": 3}
```

Il formato dell'output è il seguente:

```
accept: application/jsonlines


{"prob": [prob_1], "label": ["__label__1"]}
{"prob": [prob_1], "label": ["__label__1"]}

If you have passed the value of k to be more than 1, then response will be in this format:

{"prob": [prob_1, prob_2], "label": ["__label__1", "__label__2"]}
{"prob": [prob_1, prob_2], "label": ["__label__1", "__label__2"]}
```

Sia per la modalità supervisionata (classificazione del testo) che per quella non supervisionata (Word2Vec), i file binari (*\$1.bin)* prodotti da possono essere BlazingText utilizzati in modo incrociato da FastText e viceversa. È possibile utilizzare file binari prodotti BlazingText da FastText. Allo stesso modo, è possibile ospitare i modelli binari creati con BlazingText FastText utilizzando.

Ecco un esempio di come utilizzare un modello generato BlazingText con FastText:

```
#Download the model artifact from S3
aws s3 cp s3://<YOUR_S3_BUCKET>/<PREFIX>/model.tar.gz model.tar.gz

#Unzip the model archive
tar -xzf model.tar.gz

#Use the model archive with fastText
fasttext predict ./model.bin test.txt
```

Tuttavia, i file binari sono supportati solo quando si esegue l’addestramento su CPU e GPU singola; l’addestramento su multi-GPU non produrrà file binari.

## Raccomandazione dell'istanza EC2 per l'algoritmo BlazingText
<a name="blazingtext-instances"></a>

Per `cbow` e `skipgram` modalità, BlazingText supporta istanze con CPU singola e GPU singola. Entrambe le modalità supportano l'apprendimento degli incorporamenti di `subwords`. Per ottenere la massima velocità senza compromettere l'accuratezza, ti consigliamo di utilizzare un'istanza ml.p3.2xlarge. 

Per la `batch_skipgram` modalità, BlazingText supporta istanze CPU singole o multiple. Quando ti alleni su più istanze, imposta il valore del `S3DataDistributionType` campo dell'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html)oggetto a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)cui passi. `FullyReplicated` BlazingTextsi occupa della distribuzione dei dati tra le macchine.

Per la modalità di classificazione del testo supervisionata, consigliamo un'istanza C5 se il set di dati per l’addestramento è inferiore a 2 GB. Per set di dati più grandi, usa un'istanza con una singola GPU. BlazingText supporta istanze P2, P3, G4dn e G5 per l'addestramento e l'inferenza.

## BlazingText Notebook di esempio
<a name="blazingtext-sample-notebooks"></a>

Per un notebook di esempio che addestra e implementa l' BlazingText algoritmo di SageMaker intelligenza artificiale per generare vettori di parole, consulta [Learning](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/blazingtext_word2vec_text8/blazingtext_word2vec_text8.html) Word2Vec Word Representations using. BlazingText Per istruzioni sulla creazione e l'accesso alle istanze di notebook Jupyter che puoi utilizzare per eseguire l'esempio in AI, vedi. 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 I notebook di esempio di modellazione dell'argomento che utilizzano gli algoritmi BlazingText sono disponibili nella sezione con l'**introduzione agli algoritmi Amazon**. Per aprire un notebook, seleziona la relativa scheda **Usa**, quindi scegli **Crea copia**.

# BlazingText Iperparametri
<a name="blazingtext_hyperparameters"></a>

Quando avvii un processo di addestramento con una richiesta `CreateTrainingJob`, specifichi un algoritmo di addestramento. È inoltre possibile specificare iperparametri specifici dell'algoritmo come mappe. string-to-string Gli iperparametri dell' BlazingText algoritmo dipendono dalla modalità utilizzata: Word2Vec (senza supervisione) e Text Classification (supervisionata).

## Iperparametri Word2Vec
<a name="blazingtext_hyperparameters_word2vec"></a>

La tabella seguente elenca gli iperparametri per l'algoritmo di addestramento BlazingText Word2Vec fornito da Amazon AI. SageMaker 


| Nome parametro | Description | 
| --- | --- | 
| mode |  L'architettura Word2vec utilizzata per l’addestramento. **Campo obbligatorio** Valori validi: `batch_skipgram`, `skipgram` o `cbow`  | 
| batch\$1size |  La dimensione di ogni batch quando `mode` è impostato su `batch_skipgram`. Imposta su un numero tra 10 e 20. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 11  | 
| buckets |  Il numero di bucket hash da utilizzare per le parole secondarie. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 2000000  | 
| epochs |  Il numero di pass completi tramite i dati di addestramento. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 5  | 
| evaluation |  [Se il modello addestrato viene valutato utilizzando il test -353. WordSimilarity](http://www.gabrilovich.com/resources/data/wordsim353/wordsim353.html) **Opzionale** Valori validi: (booleani) `True` o `False` Valore predefinito: `True`  | 
| learning\$1rate |  L'incremento utilizzato per gli aggiornamenti dei parametri. **Opzionale** Valori validi: float positivi Valore predefinito: 0,05  | 
| min\$1char |  Il numero minimo di caratteri da utilizzare per n-grammi di parole secondarie/caratteri. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 3  | 
| min\$1count |  Le parole che appaiono meno di `min_count` volte vengono eliminate. **Opzionale** Valori validi: numeri interi non negativi Valore predefinito: 5  | 
| max\$1char |  Il numero massimo di caratteri da utilizzare per n-grammi di parole secondarie/caratteri. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 6  | 
| negative\$1samples |  Il numero di Negative Sample per la strategia Negative Sample Sharing. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 5  | 
| sampling\$1threshold |  Il limite di occorrenza delle parole. Le parole che appaiono con maggiore frequenza nei dati di addestramento sono casualmente sottocampionate. **Opzionale** Valori validi: frazioni positive. L'intervallo consigliato è (0, 1e-3) Valore predefinito: 0.0001  | 
| subwords |  Indica se eseguire o meno l’addestramento degli incorporamenti delle parole secondarie. **Opzionale** Valori validi: (booleani) `True` o `False` Valore predefinito: `False`  | 
| vector\$1dim |  La dimensione dei vettori di parola che l'algoritmo impara. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 100  | 
| window\$1size |  Le dimensioni della finestra contestuale. La finestra contestuale è il numero di parole che circondano la parola di target utilizzata per l’addestramento. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 5  | 

## Iperparametri di classificazione del testo
<a name="blazingtext_hyperparameters_text_class"></a>

La tabella seguente elenca gli iperparametri per l'algoritmo di training sulla classificazione del testo fornito da Amazon SageMaker AI.

**Nota**  
Sebbene alcuni parametri siano comuni tra la modalità di classificazione del testo e Word2Vec, potrebbero avere significati diversi a seconda del contesto.


| Nome parametro | Description | 
| --- | --- | 
| mode |  La modalità di addestramento. **Campo obbligatorio** Valori validi: `supervised`  | 
| buckets |  Il numero di bucket hash da utilizzare per n-grammi di parole. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 2000000  | 
| early\$1stopping |  Indica se interrompere l’addestramento nel caso in cui l'accuratezza della convalida non migliora dopo a numero `patience` di epoche (Unix epochs). Tieni presente che è necessario un canale di convalida se si utilizza l'arresto anticipato. **Opzionale** Valori validi: (booleani) `True` o `False` Valore predefinito: `False`  | 
| epochs |  Il numero massimo di pass completi tramite i dati di addestramento. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 5  | 
| learning\$1rate |  L'incremento utilizzato per gli aggiornamenti dei parametri. **Opzionale** Valori validi: float positivi Valore predefinito: 0,05  | 
| min\$1count |  Le parole che appaiono meno di `min_count` volte vengono eliminate. **Opzionale** Valori validi: numeri interi non negativi Valore predefinito: 5  | 
| min\$1epochs |  Il numero minimo di epoche (Unix epochs) da addestrare prima che venga richiamata la logica di arresto precoce. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 5  | 
| patience |  Il numero di epoche (Unix epochs) da attendere prima di applicare l'arresto precoce quando non viene effettuato alcun progresso sul set di convalida. Usato solo quando `early_stopping` è `True`. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 4  | 
| vector\$1dim |  La dimensione del livello di incorporamento. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 100  | 
| word\$1ngrams |  Il numero di caratteristiche n-gramma di parole da utilizzare. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 2  | 

# Ottimizza un modello BlazingText
<a name="blazingtext-tuning"></a>

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).

## Metriche calcolate dall'algoritmo BlazingText
<a name="blazingtext-metrics"></a>

L'algoritmo BlazingText Word2Vec (`skipgram``cbow`, e le `batch_skipgram` modalità) riporta su una singola metrica durante l'allenamento:. `train:mean_rho` Questo parametro viene calcolato sui [set di dati di similarità per parola WS-353](https://aclweb.org/aclwiki/WordSimilarity-353_Test_Collection_(State_of_the_art)). Quando si ottimizzano i valori degli iperparametri per l'algoritmo Word2Vec, utilizza questo parametro come obiettivo.

L'algoritmo di classificazione del BlazingText testo (`supervised`modalità), riporta anche su una singola metrica durante l'allenamento: il. `validation:accuracy` Quando si ottimizzano i valori degli iperparametri per l'algoritmo di classificazione del testo, utilizza questi parametri come obiettivo.


| Nome parametro | Description | Direzione dell'ottimizzazione | 
| --- | --- | --- | 
| train:mean\$1rho |  L'elemento media\$1rho (il coefficiente di correlazione per la classifica di Spearman) sui [set di dati di similarità per parola WS-353](http://alfonseca.org/pubs/ws353simrel.tar.gz)  |  Massimizza  | 
| validation:accuracy |  L'accuratezza della classificazione sul set di dati di convalida specificato dall'utente  |  Massimizza  | 

## Iperparametri regolabili BlazingText
<a name="blazingtext-tunable-hyperparameters"></a>

### Iperparametri ottimizzabili per l'algoritmo Word2Vec
<a name="blazingtext-tunable-hyperparameters-word2vec"></a>

Ottimizza un modello Amazon SageMaker AI BlazingText Word2Vec con i seguenti iperparametri. Gli iperparametri che hanno il maggiore impatto sui parametri obiettivo Word2Vec sono: `mode`, ` learning_rate`, `window_size`, `vector_dim` e `negative_samples`.


| Nome parametro | Tipo parametro | Intervalli o valori consigliati | 
| --- | --- | --- | 
| batch\$1size |  `IntegerParameterRange`  |  [8-32]  | 
| epochs |  `IntegerParameterRange`  |  [5-15]  | 
| learning\$1rate |  `ContinuousParameterRange`  |  MinValue: 0,005,: 0,01 MaxValue  | 
| min\$1count |  `IntegerParameterRange`  |  [0-100]  | 
| mode |  `CategoricalParameterRange`  |  [`'batch_skipgram'`, `'skipgram'`, `'cbow'`]  | 
| negative\$1samples |  `IntegerParameterRange`  |  [5-25]  | 
| sampling\$1threshold |  `ContinuousParameterRange`  |  MinValue: 0,001, 0,001 MaxValue  | 
| vector\$1dim |  `IntegerParameterRange`  |  [32-300]  | 
| window\$1size |  `IntegerParameterRange`  |  [1-10]  | 

### Iperparametri ottimizzabili per l'algoritmo di classificazione del testo
<a name="blazingtext-tunable-hyperparameters-text_class"></a>

Ottimizza un modello di classificazione BlazingText del testo Amazon SageMaker AI con i seguenti iperparametri.


| Nome parametro | Tipo parametro | Intervalli o valori consigliati | 
| --- | --- | --- | 
| buckets |  `IntegerParameterRange`  |  [1000000-10000000]  | 
| epochs |  `IntegerParameterRange`  |  [5-15]  | 
| learning\$1rate |  `ContinuousParameterRange`  |  MinValue: 0,005, MaxValue: 0,01  | 
| min\$1count |  `IntegerParameterRange`  |  [0-100]  | 
| vector\$1dim |  `IntegerParameterRange`  |  [32-300]  | 
| word\$1ngrams |  `IntegerParameterRange`  |  [1-3]  | 

# Algoritmo Allocazione latente di Dirichlet (LDA, Latent Dirichlet Allocation)
<a name="lda"></a>

L’algoritmo Amazon SageMaker AI Latent Dirichlet Allocation (LDA) è un algoritmo di apprendimento senza supervisione che tenta di descrivere un set di osservazioni come una combinazione di diverse categorie. LDA viene generalmente utilizzato per individuare un numero di argomenti specificati dall'utente, condivisi da documenti all'interno di un corpus di testo. Qui ogni osservazione è un documento, le caratteristiche sono la presenza (o conteggio occorrenza) di ciascuna parola e le categorie sono gli argomenti. Poiché il metodo non è supervisionato, gli argomenti non sono specificati in anticipo e il loro allineamento con il modo in cui un umano può naturalmente classificare documenti non è garantito. Gli argomenti vengono appresi sotto forma di una distribuzione di probabilità sulle parole incontrate in ogni documento. Ogni documento, a sua volta, viene descritto come una combinazione di argomenti.

Il contenuto esatto di due documenti con combinazioni di argomenti simili non sarà lo stesso. Tuttavia, in generale, puoi supporre che questi documenti utilizzino più di frequente un sottoinsieme di parole condiviso, rispetto a un documento proveniente da un gruppo diverso di argomenti. Questo consente a LDA di scoprire questi gruppi di parole e utilizzarli per formare argomenti. Facciamo un esempio molto semplice: se disponi di un gruppo di documenti in cui le sole parole in essi riportate sono: *mangiare*, *dormire*, *giocare*, *miagolare* e *abbaiare*, LDA può generare argomenti come i seguenti:


| **Argomento** | *mangiare* | *dormire*  | *giocare* | *miagolare* | *abbaiare* | 
| --- | --- | --- | --- | --- | --- | 
| Argomento 1  | 0,1  | 0.3  | 0,2  | 0,4  | 0,0  | 
| Argomento 2  | 0.2  | 0.1 | 0,4  | 0,0  | 0,3  | 

Puoi dedurre che i documenti che hanno maggiori probabilità di appartenere all'Argomento 1 riguardano i gatti (che possono *miagolare* e *dormire*) e che i documenti che rientrano nell'Argomento 2 riguardano i cani (che preferiscono *giocare* e *abbaiare*). Questi argomenti possono essere trovati anche se le parole cane e gatto non compaiono in alcun testo. 

**Topics**
+ [Scelta tra Latent Dirichlet Allocation (LDA) e modello neurale di argomenti (NTM)](#lda-or-ntm)
+ [Interfaccia di input/output per l'algoritmo LDA](#lda-inputoutput)
+ [Raccomandazione istanza EC2 per l'algoritmo LDA](#lda-instances)
+ [Notebook di esempio di LDA](#LDA-sample-notebooks)
+ [Come funziona LDA](lda-how-it-works.md)
+ [Iperparametri LDA](lda_hyperparameters.md)
+ [Ottimizzazione di un modello LDA](lda-tuning.md)

## Scelta tra Latent Dirichlet Allocation (LDA) e modello neurale di argomenti (NTM)
<a name="lda-or-ntm"></a>

I modelli tematici sono comunemente usati per produrre argomenti a partire da corpus che (1) racchiudono in modo coerente il significato semantico e (2) descrivono bene i documenti. Pertanto, i modelli tematici mirano a ridurre al minimo le perplessità e massimizzare la coerenza degli argomenti. 

Perplexity è una metrica intrinseca di valutazione della modellazione del linguaggio che misura l'inverso della media geometrica di verosimiglianza per parola nei dati di test. Un punteggio di perplessità inferiore indica migliori prestazioni di generalizzazione. La ricerca ha dimostrato che la probabilità calcolata per parola spesso non è in linea con il giudizio umano e può essere del tutto non correlata, pertanto è stata introdotta la coerenza tra gli argomenti. Ogni argomento dedotto dal modello è composto da parole e la coerenza degli argomenti viene calcolata in base alle prime N parole per quel particolare argomento del modello. Viene spesso definita come la media o la mediana dei punteggi di somiglianza verbale a coppie delle parole di quell'argomento, ad esempio Pointwise Mutual Information (PMI). Un modello promettente genera argomenti coerenti o argomenti con punteggi di coerenza tematici elevati. 

Sebbene l'obiettivo sia quello di sviluppare un modello tematico che riduca al minimo le perplessità e massimizzi la coerenza degli argomenti, spesso c'è un compromesso tra LDA e NTM. Una recente ricerca di Amazon, Dinget et al., 2018 ha dimostrato che NTM è promettente per raggiungere un'elevata coerenza tematica, ma LDA addestrato con campionamento Gibbs collassato genera maggiori perplessità. Esiste un compromesso tra perplessità e coerenza tematica. Dal punto di vista della praticità per quanto riguarda l'hardware e la potenza di calcolo, l'hardware SageMaker NTM è più flessibile di LDA e può scalare meglio perché NTM può essere eseguito su CPU e GPU e può essere parallelizzato su più istanze GPU, mentre LDA supporta solo l'addestramento della CPU a singola istanza. 

**Topics**
+ [Scelta tra Latent Dirichlet Allocation (LDA) e modello neurale di argomenti (NTM)](#lda-or-ntm)
+ [Interfaccia di input/output per l'algoritmo LDA](#lda-inputoutput)
+ [Raccomandazione istanza EC2 per l'algoritmo LDA](#lda-instances)
+ [Notebook di esempio di LDA](#LDA-sample-notebooks)
+ [Come funziona LDA](lda-how-it-works.md)
+ [Iperparametri LDA](lda_hyperparameters.md)
+ [Ottimizzazione di un modello LDA](lda-tuning.md)

## Interfaccia di input/output per l'algoritmo LDA
<a name="lda-inputoutput"></a>

LDA prevede che i dati vengano forniti nel canale di addestramento e, facoltativamente, supporta un canale di test, valutato dal modello finale. LDA supporta entrambi i formati di file `recordIO-wrapped-protobuf` (a densità alta e bassa) e `CSV`. Per `CSV`, i dati devono essere a densità alta e avere una dimensione pari al *numero di record \$1 dimensione vocabolario*. LDA può essere addestrato in modalità File o Pipe quando si utilizza protobuf con wrapping di recordIO, ma solo in modalità File per il formato `CSV`.

Per inferenza, sono supportati i tipi di contenuti `text/csv`, `application/json` e `application/x-recordio-protobuf`. I dati a densità bassa possono anche essere trasmessi per `application/json` e `application/x-recordio-protobuf`. L'inferenza del modello LDA restituisce le previsioni `application/json` o `application/x-recordio-protobuf` **, che includono il vettore `topic_mixture` di ogni osservazione.

Consulta [Notebook di esempio di LDA](#LDA-sample-notebooks) per maggiori dettagli sui formati dei file di addestramento e inferenza.

## Raccomandazione istanza EC2 per l'algoritmo LDA
<a name="lda-instances"></a>

Attualmente il modello LDA supporta solo l’addestramento CPU a istanza singola. Le istanze CPU sono raccomandate per l'hosting/l'inferenza.

## Notebook di esempio di LDA
<a name="LDA-sample-notebooks"></a>

Per un notebook di esempio che mostra come addestrare l’algoritmo SageMaker AI Latent Dirichlet Allocation su un set di dati e come implementare il modello addestrato per eseguire le inferenze sulle combinazioni di argomenti nei documenti di input, consulta [Introduzione a SageMaker AI LDA](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lda_topic_modeling/LDA-Introduction.html). Per istruzioni su come creare e accedere alle istanze del notebook Jupyter che puoi utilizzare per eseguire l’esempio in SageMaker AI, consulta [Istanze SageMaker per notebook Amazon](nbi.md). Dopo aver creato e aperto un’istanza del notebook, scegli la scheda **Esempi di SageMaker AI** per visualizzare un elenco di tutti gli esempi di SageMaker AI. I notebook di esempio di modellazione dell'argomento che utilizzano gli algoritmi NTM sono disponibili nella sezione con l'**introduzione agli algoritmi di Amazon**. Per aprire un notebook, fai clic sulla relativa scheda **Use (Utilizza)** e seleziona **Create copy (Crea copia)**.

# Come funziona LDA
<a name="lda-how-it-works"></a>

Amazon SageMaker AI LDA è un algoritmo di apprendimento senza supervisione che tenta di descrivere un set di osservazioni come una combinazione di categorie distinte. Queste categorie sono di per sé una distribuzione di probabilità sulle caratteristiche. LDA è un modello di probabilità generativa, ovvero che tenta di fornire un modello per la distribuzione di output e input in base a variabili latenti. Questo si oppone ai modelli discriminativi, che tentano di apprendere il modo in cui gli input sono mappati agli output.

Puoi utilizzare LDA per un'ampia gamma di attività, dal clustering di clienti in base agli acquisti di prodotti all'analisi armonica automatica in musica. Tuttavia, è più comunemente associato al topic modeling in corpora di testo. Le osservazioni vengono definite documenti. Il set di caratteristiche viene definito vocabolario. Una funzione viene definita parola. Inoltre, le categorie risultanti vengono definite argomenti.

**Nota**  
La lemmatizzazione aumenta in modo significativo le prestazioni e la precisione dell'algoritmo. Prendi in considerazione la possibilità di eseguire una pre-elaborazione di qualsiasi dato di testo di input. Per ulteriori informazioni, consulta [Stemming e lemmatizzazione](https://nlp.stanford.edu/IR-book/html/htmledition/stemming-and-lemmatization-1.html).

Un modello LDA è definito da due parametri:
+ α - Una stima precedente sulla probabilità dell'argomento (in altre parole, la frequenza media con cui si verifica ogni argomento all'interno di un determinato documento). 
+ β - Una raccolta di argomenti k in cui a ogni argomento è fornita una distribuzione di probabilità sul vocabolario utilizzato in un corpus documento, nota anche come "distribuzione argomento-parola".

LDA è un modello del tipo "borsa di parole", ovvero dove l'ordine delle parole non è rilevante. LDA è un modello generativo dove ogni documento viene generato parola per parola, scegliendo un gruppo di argomenti θ ∼ Dirichlet(α). 

 Per ogni parola nel documento: 
+  Scegli un argomento z ∼ Multinomial(θ) 
+  Scegli la distribuzione argomento-parola β\$1z corrispondente. 
+  Estrai una parola w ∼ Multinomial(β\$1z). 

Quando addestri il modello, l'obiettivo è trovare i parametri α e β, che massimizzano la probabilità che il corpus di testo venga generato dal modello.

I metodi più comuni per valutare il modello LDA utilizzano le tecniche di campionamento di Gibbs o di massimizzazione dell'aspettativa (EM, Expectation Maximization). Il modello Amazon SageMaker AI LDA utilizza la decomposizione spettrale dei tensori. Questo offre diversi vantaggi:
+  **Garanzie teoriche sui risultati**. Il metodo EM standard converge unicamente verso optima locali, che sono spesso di scarsa qualità. 
+  **Facile parallelizzabilità**. Il lavoro può essere facilmente ripartito sui documenti di input in addestramento e inferenza. Gli approcci del metodo EM e del campionamento di Gibbs possono essere parallelizzati, ma non così facilmente. 
+  **Rapidità**. Sebbene presenti un basso costo di iterazione, il metodo EM tende a ridurre i tassi di convergenza. Il campionamento di Gibbs, inoltre, tende a ridurre i tassi di convergenza e richiede un numero elevato di campioni. 

A un alto livello, l'algoritmo di decomposizione tensore segue questa procedura:

1.  L'obiettivo è calcolare la decomposizione spettrale di un tensore **V** x **V** x **V**, che riepiloga i momenti dei documenti del nostro corpus. **V** rappresenta la dimensione del vocabolario (in altre parole, il numero di parole distinte in tutti i documenti). I componenti spettrali di questo tensore sono i parametri LDA α e β, che massimizzano la probabilità generale del corpus di documento. Tuttavia, poiché le dimensioni del vocabolario tendono a essere grandi, questo tensore **V** x **V** x **V** è troppo voluminoso per essere archiviato nella memoria. 

1.  Al contrario, utilizza una matrice d'inerzia **V** x **V**, che è l'analogo bidimensionale del tensore della fase 1, per trovare un matrice di sbiancamento della dimensione **V** x **k**. Questa matrice può essere utilizzata per convertire la matrice d'inerzia **V** x **V** in una matrice d'identità **k** x **k**. **k** è il numero di argomenti nel modello. 

1.  Questa stessa matrice di sbiancamento può quindi essere utilizzata per trovare un tensore più piccolo **k** x **k** x **k**. Una volta decomposto spettralmente, questo tensore include componenti che hanno una semplice relazione con i componenti del tensore **V** x **V** x **V**. 

1.  Il metodo dei *minimi quadrati alternati* viene utilizzato per decomporre il tensore più piccolo **k** x *k* x **k**. Questo offre un sostanziale miglioramento dell'utilizzo della memoria e della velocità. I parametri α e β possono essere reperiti "sbiancando" questi output nella decomposizione spettrale. 

Una volta trovati i parametri del modello LDA, puoi trovare le combinazioni di argomenti per ogni documento. Puoi utilizzare la discesa stocastica del gradiente per massimizzare la probabilità di osservare una combinazione di argomenti specifici corrispondente a questi dati.

La qualità degli argomenti può essere migliorata aumentando il numero di argomenti da cercare nell’addestramento, quindi filtrando quelli di scarsa qualità. Questa operazione viene eseguita automaticamente in SageMaker AI LDA: viene trattato il 25% in più degli argomenti e vengono restituiti solo quelli con i maggiori prior di Dirichlet associati. Per eseguire ulteriore filtraggio e analisi degli argomenti, puoi aumentare il numero degli argomenti e modificare il modello LDA risultante come segue:

```
> import mxnet as mx
> alpha, beta = mx.ndarray.load(‘model.tar.gz’)
> # modify alpha and beta
> mx.nd.save(‘new_model.tar.gz’, [new_alpha, new_beta])
> # upload to S3 and create new SageMaker model using the console
```

Per ulteriori informazioni sugli algoritmi per LDA e sull’implementazione di SageMaker AI, consulta i riferimenti seguenti:
+ Animashree Anandkumar, Rong Ge, Daniel Hsu, Sham M Kakade e Matus Telgarsky. *Tensor Decompositions for Learning Latent Variable Models*, Journal of Machine Learning Research, 15:2773–2832, 2014.
+  David M Blei, Andrew Y Ng e Michael I Jordan. *Allocazione latente di Dirichlet (LDA, Latent Dirichlet Allocation)*. Journal of Machine Learning Research, 3 (gen):993–1022, 2003.
+  Thomas L Griffiths e Mark Steyvers. *Finding Scientific Topics*. Proceedings of the National Academy of Sciences, 101(suppl 1):5228–5235, 2004. 
+  Tamara G Kolda e Brett W Bader. *Tensor Decompositions and Applications*. SIAM Review, 51(3):455–500, 2009. 

# Iperparametri LDA
<a name="lda_hyperparameters"></a>

Nella richiesta `CreateTrainingJob` puoi specificare l'algoritmo di addestramento. Puoi anche specificare gli iperparametri specifichi dell'algoritmo come mappe stringa a stringa. La tabella seguente elenca gli iperparametri per l’algoritmo di addestramento LDA fornito da Amazon SageMaker AI. Per ulteriori informazioni, consulta [Come funziona LDA](lda-how-it-works.md).


| Nome parametro | Descrizione | 
| --- | --- | 
| num\$1topics |  Il numero di argomenti per LDA da trovare all'interno dei dati. **Campo obbligatorio** Valori validi: numeri interi positivi  | 
| feature\$1dim |  La dimensione del vocabolario del corpus di documento di input. **Campo obbligatorio** Valori validi: numeri interi positivi  | 
| mini\$1batch\$1size |  Il numero totale di documenti nel corpus di documento di input. **Campo obbligatorio** Valori validi: numeri interi positivi  | 
| alpha0 |  Supposizione iniziale per il parametro di concentrazione: la somma degli elementi del prior Dirichlet. I valori piccoli hanno maggiore probabilità di generare combinazioni di argomenti a densità bassa e valori grandi (maggiori di 1,0) producono combinazioni più uniformi.  **Opzionale** Valori validi: float positivi Valore predefinito: 1.0  | 
| max\$1restarts |  Il numero di riavvii da eseguire durante la fase di decomposizione spettrale dei minimi quadrati alternati (ALS) dell'algoritmo. Può essere utilizzato per trovare minima locali di qualità migliore a scapito dell'elaborazione aggiuntiva. Generalmente non richiede alcuna regolazione.  **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 10  | 
| max\$1iterations |  Il numero massimo di iterazioni da eseguire durante la fase ALS dell'algoritmo. Può essere utilizzato per trovare minima di qualità migliore a scapito dell'elaborazione aggiuntiva. Generalmente non richiede alcuna regolazione.  **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 1000  | 
| tol |  La tolleranza di errore target per la fase ALS dell'algoritmo. Può essere utilizzato per trovare minima di qualità migliore a scapito dell'elaborazione aggiuntiva. Generalmente non richiede alcuna regolazione.  **Opzionale** Valori validi: float positivi Valore predefinito: 1e-8  | 

# Ottimizzazione di un modello LDA
<a name="lda-tuning"></a>

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.

LDA è un algoritmo di modellazione dell'argomento non supervisionato che tenta di descrivere un set di osservazioni (documenti) come una combinazione di categorie distinte (argomenti). Il parametro "per-word log-likelihood" (PWLL) misura la probabilità che un set di argomenti addestrato (modello LDA) descriva accuratamente un set di dati del documento di test. I valori maggiori di PWLL indicano che i dati del test vengono descritti con maggiore probabilità dal modello LDA.

Per ulteriori informazioni sull'ottimizzazione del modello, consulta [Ottimizzazione automatica dei modelli con AI SageMaker](automatic-model-tuning.md).

## Parametri calcolati dall'algoritmo LDA
<a name="lda-metrics"></a>

L'algoritmo LDA usa un singolo parametro durante l’addestramento: `test:pwll`. Quando ottimizzi un modello, scegli questo parametro come obiettivo.


| Nome parametro | Descrizione | Direzione dell'ottimizzazione | 
| --- | --- | --- | 
| test:pwll | Per-word log-likelihood sul set di dati di test. La probabilità che il set di dati di test è accuratamente descritto dal modello LDA appreso. | Massimizza | 

## Iperparametri LDA ottimizzabili
<a name="lda-tunable-hyperparameters"></a>

Puoi ottimizzare i seguenti iperparametri per l'algoritmo LDA. Entrambi gli iperparametri `alpha0` e `num_topics`, possono interessare il parametro obiettivo LDA (`test:pwll`). Se non conosci i valori ottimali per questi iperparametri che massimizzano la per-word log-likelihood e producono un modello LDA accurato, l'ottimizzazione automatica dei modelli può aiutare a trovarli.


| Nome parametro | Tipo parametro | Intervalli consigliati | 
| --- | --- | --- | 
| alpha0 | ContinuousParameterRanges | MinValue: 0,1, MaxValue: 10 | 
| num\$1topics | IntegerParameterRanges | MinValue: 1, MaxValue: 150 | 

# Algoritmo Modello neurale di argomenti (NTM)
<a name="ntm"></a>

Amazon SageMaker AI NTM è un algoritmo di apprendimento non supervisionato che viene utilizzato per organizzare un corpus di documenti in *argomenti* che contengono raggruppamenti di parole in base alla loro distribuzione statistica. I documenti che contengono frequenti occorrenze di parole come "bici", "auto", "treno", "chilometraggio" e "velocità" potrebbero condividere un argomento sul "trasporto", ad esempio. La modellazione degli argomenti può essere utilizzata per classificare o riepilogare i documenti in base agli argomenti rilevati o per recuperare informazioni o consigliare i contenuti in base alle somiglianze tra argomenti. Gli argomenti dei documenti che NTM apprende sono caratterizzati come una *rappresentazione latente* perché gli argomenti sono dedotti dalle distribuzioni di parole osservate nel corpus. La semantica degli argomenti solitamente viene dedotta esaminando le parole più importanti che contengono. Poiché il metodo non è supervisionato, viene preventivamente specificato solo il numero di argomenti e non gli argomenti stessi. Inoltre, non è possibile garantire l'allineamento degli argomenti con la capacità umana di categorizzare naturalmente dei documenti.

La modellazione degli argomenti offre un modo per visualizzare i contenuti di un ampio corpus di documenti in termini di argomenti appresi. I documenti relativi a ogni argomento possono essere indicizzati o ricercati in base alle relative etichette. Le rappresentazioni latenti dei documenti possono essere utilizzate anche per individuare documenti simili nell'ambito degli argomenti. È inoltre possibile utilizzare le rappresentazioni latenti dei documenti che il modello di argomenti apprende per inserirle in un altro algoritmo supervisionato, come un classificatore di documenti. Poiché le rappresentazioni latenti dei documenti dovrebbero acquisire la semantica dei documenti soggiacenti, gli algoritmi basati in parte su tali rappresentazioni dovrebbero funzionare meglio rispetto a quelli basati solo su caratteristiche lessicali.

Sebbene sia possibile utilizzare sia gli algoritmi Amazon SageMaker AI NTM che LDA per la modellazione degli argomenti, si tratta di algoritmi distinti e ci si può aspettare che producano risultati diversi sugli stessi dati di input.

Per ulteriori informazioni sulla matematica alla base di NTM, consulta [Neural Variational Inference for Text Processing](https://arxiv.org/pdf/1511.06038.pdf).

**Topics**
+ [Interfaccia di input/output per l'algoritmo NTM](#NTM-inputoutput)
+ [Raccomandazione istanza EC2 per l'algoritmo NTM](#NTM-instances)
+ [Notebook di esempio NTM](#NTM-sample-notebooks)
+ [Iperparametri NTM](ntm_hyperparameters.md)
+ [Ottimizzazione di un modello NTM](ntm-tuning.md)
+ [Formati della risposta NTM](ntm-in-formats.md)

## Interfaccia di input/output per l'algoritmo NTM
<a name="NTM-inputoutput"></a>

Amazon SageMaker AI Neural Topic Model supporta quattro canali di dati: addestramento, convalida, test e ausiliario. I canali di dati di convalida, test e ausiliari sono opzionali. Se specifichi uno qualsiasi di questi canali opzionali, imposta il valore del parametro `S3DataDistributionType` su `FullyReplicated`. Se si forniscono i dati di convalida, la perdita relativa a questi dati viene registrata per ogni epoca e il modello interrompe l’addestramento non appena rileva che la perdita di convalida non sta migliorando. Se non si forniscono i dati di convalida, l'algoritmo si interrompe con anticipo in base ai dati di addestramento; tuttavia questa procedura può risultare meno efficiente. Se si forniscono i dati di test, l'algoritmo riferisce la perdita dei dati di test dal modello finale. 

I canali dei dati di addestramento, convalida e test per NTM supportano i formati di file `recordIO-wrapped-protobuf` (a densità alta e bassa) e `CSV`. Per il formato `CSV`, ogni riga deve essere rappresentata in modo denso con conteggi zero per le parole assenti nel documento corrispondente e deve avere la dimensione pari a: (numero di record) \$1 (dimensione del vocabolario). Puoi utilizzare la modalità file o la modalità pipe per addestrare i modelli sui dati formattati come `recordIO-wrapped-protobuf` o `CSV`. Il canale ausiliario viene utilizzato per fornire un file di testo che contiene il vocabolario. Fornendo il file di vocabolario, gli utenti possono vedere le parole principali di ciascuno degli argomenti stampate nel registro anziché il loro numero intero. IDs Il file di vocabolario consente inoltre a NTM di calcolare i punteggi WETC (Word Embedding Topic Coherence), un nuovo parametro visualizzato nel log che acquisisce in modo efficace la somiglianza tra le parole principali di ciascun argomento. `ContentType`Per il canale ausiliario`text/plain`, ogni riga contiene una sola parola, nell'ordine corrispondente al numero intero fornito nei dati. IDs Il file di vocabolario deve essere denominato `vocab.txt` e attualmente è supportata solo la codifica UTF-8. 

Per l'inferenza, sono supportati i tipi di contenuti `text/csv`, `application/json`, `application/jsonlines` e `application/x-recordio-protobuf`. I dati a densità bassa possono anche essere trasmessi per `application/json` e `application/x-recordio-protobuf`. L'inferenza del modello NTM restituisce le previsioni `application/json` o `application/x-recordio-protobuf` **, che includono il vettore `topic_weights` di ogni osservazione.

Consulta il [post del blog](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-neural-topic-model-now-supports-auxiliary-vocabulary-channel-new-topic-evaluation-metrics-and-training-subsampling/) per maggiori dettagli sull'uso del canale ausiliario e dei punteggi WETC. Per ulteriori informazioni su come calcolare il punteggio WETC, consulta l'argomento sulla [modellazione di argomenti neurali che supportano la coerenza](https://arxiv.org/pdf/1809.02687.pdf). Abbiamo usato il WETC a coppie descritto in questo paper per l'Amazon SageMaker AI Neural Topic Model.

Per ulteriori informazioni sui formati di file di input e output, consulta [Formati della risposta NTM](ntm-in-formats.md) per l'inferenza e i [Notebook di esempio NTM](#NTM-sample-notebooks).

## Raccomandazione istanza EC2 per l'algoritmo NTM
<a name="NTM-instances"></a>

L’addestramento NTM supporta entrambi i tipi di istanze GPU e CPU. Si consigliano le istanze GPU, ma per determinati carichi di lavoro, le istanze CPU possono comportare costi di addestramento inferiori. Le istanze CPU dovrebbero essere sufficienti per l'interferenza. L'addestramento NTM supporta famiglie di istanze GPU P2, P3, G4dn e G5 per l'addestramento e l'inferenza.

## Notebook di esempio NTM
<a name="NTM-sample-notebooks"></a>

Per un taccuino di esempio che utilizza l'algoritmo SageMaker AI NTM per scoprire argomenti nei documenti a partire da una fonte di dati sintetica in cui sono note le distribuzioni degli argomenti, consulta l'[Introduzione](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/ntm_synthetic/ntm_synthetic.html) alle funzionalità di base di NTM. Per istruzioni su come creare e accedere 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 un'istanza di notebook e averla aperta, seleziona la scheda **Esempi di SageMaker AI** per visualizzare un elenco di tutti gli esempi di IA. SageMaker I notebook di esempio di modellazione dell'argomento che utilizzano gli algoritmi NTM sono disponibili nella sezione con l'**introduzione agli algoritmi di Amazon**. Per aprire un notebook, fai clic sulla relativa scheda **Use (Utilizza)** e seleziona **Create copy (Crea copia)**.

# Iperparametri NTM
<a name="ntm_hyperparameters"></a>

La tabella seguente elenca gli iperparametri che puoi impostare per l'algoritmo Amazon SageMaker AI Neural Topic Model (NTM).


| Nome parametro | Description | 
| --- | --- | 
|  `feature_dim`  |  La dimensione del vocabolario del set di dati. **Campo obbligatorio** Valori validi: numeri interi positivi (min: 1, max: 1,000,000)  | 
| num\$1topics |  Il numero di argomenti richiesti. **Campo obbligatorio** Valori validi: numeri interi positivi (min: 2, max: 1000)  | 
| batch\$1norm |  Indica se utilizzare la normalizzazione in batch durante l’addestramento. **Opzionale** Valori validi: *true* o *false* Valore predefinito: *false*  | 
| clip\$1gradient |  La grandezza massima di ogni componente gradiente. **Opzionale** Valori validi: float (min: 1e-3) Valore predefinito: Infinity  | 
| encoder\$1layers |  Il numero di livelli nel codificatore e le dimensioni dell'output di ogni livello. Se impostato su *auto*, l'algoritmo utilizza due livelli di dimensioni 3 x `num_topics` e 2 x `num_topics` rispettivamente.  **Opzionale** Valori validi: elenco separato da virgole di numeri interi positivi o *auto* Valore predefinito: *auto*  | 
| encoder\$1layers\$1activation |  La funzione di attivazione da utilizzare nei livelli del codificatore. **Opzionale** Valori validi:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/ntm_hyperparameters.html) Valore predefinito: `sigmoid`  | 
| epochs |  Numero massimo di passate sui dati di addestramento. **Opzionale** Valori validi: numeri interi positivi (min: 1) Valore predefinito: 50  | 
| learning\$1rate |  La velocità di apprendimento dell'ottimizzatore. **Opzionale** Valori validi: float (min: 1e-6, max: 1.0) Valore predefinito: 0,001  | 
| mini\$1batch\$1size |  Il numero di esempi in ogni mini-batch. **Opzionale** Valori validi: numeri interi positivi (min: 1, max: 10000) Valore predefinito: 256  | 
| num\$1patience\$1epochs |  Il numero di epoche (Unix epoch) successive in base al quale il criterio di arresto precoce viene valutato. L'arresto precoce viene attivato quando la modifica della funzione di perdita scende al di sotto della `tolerance` specificata nell'ultimo numero di epoche (Unix epochs) `num_patience_epochs`. Per disabilitare l'esclusione dello stopword precoce, imposta `num_patience_epochs` su un valore maggiore di `epochs`. **Opzionale** Valori validi: numeri interi positivi (min: 1) Valore predefinito: 3  | 
| optimizer |  L'ottimizzatore da utilizzare per l’addestramento. **Opzionale** Valori validi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/ntm_hyperparameters.html) Valore predefinito: `adadelta`  | 
| rescale\$1gradient |  Il fattore di ridimensionamento per il gradiente. **Opzionale** Valori validi: float (min: 1e-3, max: 1.0) Valore predefinito: 1.0  | 
| sub\$1sample |  La frazione dei dati di addestramento da campionare per l’addestramento per ogni epoca (Unix epoch). **Opzionale** Valori validi: float (min: 0.0, max: 1.0) Valore predefinito: 1.0  | 
| tolerance |  La modifica relativa massima nella funzione di perdita. L'arresto precoce viene attivato quando la modifica della funzione di perdita scende al di sotto di questo valore nell'ultimo numero di epoche (Unix epochs) `num_patience_epochs`. **Opzionale** Valori validi: float (min: 1e-6, max: 0.1) Valore predefinito: 0,001  | 
| weight\$1decay |   Il coefficiente di decadimento del peso. Aggiunge la regolarizzazione L2. **Opzionale** Valori validi: float (min: 0.0, max: 1.0) Valore predefinito: 0.0  | 

# Ottimizzazione di un modello NTM
<a name="ntm-tuning"></a>

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.

Amazon SageMaker AI NTM è un algoritmo di apprendimento non supervisionato che apprende le rappresentazioni latenti di grandi raccolte di dati discreti, come un corpus di documenti. Le rappresentazioni latenti utilizzano le variabili dedotte che non sono direttamente misurate per modellare le osservazioni in un set di dati. L'ottimizzazione automatica dei modelli su NTM aiuta a trovare il modello che riduce al minimo la perdita rispetto ai dati di addestramento o di convalida. La *perdita di addestramento* misura il grado di adattabilità del modello ai dati di addestramento. La *perdita di convalida* misura il modo in cui il modello può generalizzare i dati sui quali non è stato addestrato. La perdita di addestramento bassa indica che un modello si adatta bene ai dati di addestramento. La perdita di convalida bassa indica che un modello non ha eseguito l'overfitting dei dati di addestramento e pertanto deve essere in grado di modellare i documenti con cui non è stato addestrato. Di solito, è preferibile che entrambe le perdite siano piccole. Tuttavia, la riduzione al minimo della perdita di addestramento può comportare un overfitting e aumentare la perdita di convalida, il che ridurrebbe la generalità del modello. 

Per ulteriori informazioni sull'ottimizzazione del modello, consulta [Ottimizzazione automatica dei modelli con AI SageMaker](automatic-model-tuning.md).

## Parametri calcolati dall'algoritmo NTM
<a name="ntm-metrics"></a>

L'algoritmo NTM restituisce un singolo parametro che viene calcolato durante l’addestramento: `validation:total_loss`. La perdita totale è la somma della perdita di ricostruzione e della divergenza Kullback-Leibler. Quando ottimizzi i valori degli iperparametri, scegli questo parametro come obiettivo.


| Nome parametro | Description | Direzione dell'ottimizzazione | 
| --- | --- | --- | 
| validation:total\$1loss |  Perdita totale su set di convalida  |  Minimizza  | 

## Iperparametri NTM ottimizzabili
<a name="ntm-tunable-hyperparameters"></a>

Puoi ottimizzare i seguenti iperparametri per l'algoritmo NTM. Di solito impostando un valore basso per `mini_batch_size` e un valore piccolo per `learning_rate` vengono restituite meno perdite di convalida, anche se l’addestramento potrebbe richiede più tempo. Le perdite di convalida basse non producono necessariamente più argomenti coerenti secondo l'interpretazione dalle persone. L'effetto di altri iperparametri sull’addestramento e la perdita di convalida può variare da set di dati a set di dati. Per vedere quali valori sono compatibili, consulta [Iperparametri NTM](ntm_hyperparameters.md).


| Nome parametro | Tipo parametro | Intervalli consigliati | 
| --- | --- | --- | 
| encoder\$1layers\$1activation |  CategoricalParameterRanges  |  ['sigmoid', 'tanh', 'relu']  | 
| learning\$1rate |  ContinuousParameterRange  |  MinValue: 1e-4,: 0,1 MaxValue  | 
| mini\$1batch\$1size |  IntegerParameterRanges  |  MinValue: 16:2048 MaxValue  | 
| optimizer |  CategoricalParameterRanges  |  ['sgd', 'adam', 'adadelta']  | 
| rescale\$1gradient |  ContinuousParameterRange  |  MinValue: 0,1,: 1,0 MaxValue  | 
| weight\$1decay |  ContinuousParameterRange  |  MinValue: 0,0, MaxValue: 1,0  | 

# Formati della risposta NTM
<a name="ntm-in-formats"></a>

Tutti gli algoritmi integrati di Amazon SageMaker AI aderiscono al formato di inferenza di input comune descritto in Common [Data Formats](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) - Inference. Questo argomento contiene un elenco dei formati di output disponibili per l'algoritmo AI NTM. SageMaker 

## Formato della risposta JSON
<a name="ntm-json"></a>

```
{
    "predictions":    [
        {"topic_weights": [0.02, 0.1, 0,...]},
        {"topic_weights": [0.25, 0.067, 0,...]}
    ]
}
```

## Formato della risposta JSONLINES
<a name="ntm-jsonlines"></a>

```
{"topic_weights": [0.02, 0.1, 0,...]}
{"topic_weights": [0.25, 0.067, 0,...]}
```

## Formato della risposta RECORDIO
<a name="ntm-recordio"></a>

```
[
    Record = {
        features = {},
        label = {
            'topic_weights': {
                keys: [],
                values: [0.25, 0.067, 0, ...]  # float32
            }
        }
    },
    Record = {
        features = {},
        label = {
            'topic_weights': {
                keys: [],
                values: [0.25, 0.067, 0, ...]  # float32
            }
        }
    }  
]
```

# Algoritmo Object2Vec
<a name="object2vec"></a>

L'algoritmo Amazon SageMaker AI Object2Vec è un algoritmo di incorporamento neurale generico altamente personalizzabile. Può apprendere incorporamenti a densità alta e bassa dimensionalità di oggetti ad alta dimensionalità. Gli incorporamenti vengono appresi in modo tale che la semantica della relazione tra coppie di oggetti nello spazio originale sia conservata nello spazio di incorporamento. Ad esempio, puoi utilizzare gli incorporamenti appresi per calcolare in modo efficiente i neighbors più vicini degli oggetti e per visualizzare i cluster naturali degli oggetti correlati nello spazio a bassa dimensione. È inoltre possibile utilizzare gli incorporamenti come caratteristiche degli oggetti corrispondenti nelle attività supervisionate downstream, come la classificazione o la regressione. 

Object2Vec generalizza la nota tecnica di incorporamento Word2Vec per le parole ottimizzata nell'intelligenza artificiale. SageMaker [BlazingText algoritmo](blazingtext.md) Per un post sul blog che spiega come applicare Object2Vec ad alcuni casi d'uso pratici, consulta Introduzione ad [Amazon AI](https://aws.amazon.com/blogs/machine-learning/introduction-to-amazon-sagemaker-object2vec/) Object2Vec. SageMaker 

**Topics**
+ [Interfaccia di I/O per l'algoritmo Object2Vec](#object2vec-inputoutput)
+ [Raccomandazione istanza EC2 per l'algoritmo Object2Vec](#object2vec--instances)
+ [Notebook di esempio di Object2Vec](#object2vec-sample-notebooks)
+ [Come funziona Object2Vec](object2vec-howitworks.md)
+ [Iperparametri Object2Vec](object2vec-hyperparameters.md)
+ [Ottimizzazione di un modello Object2Vec](object2vec-tuning.md)
+ [Formato dei dati per l’addestramento Object2Vec](object2vec-training-formats.md)
+ [Formati dei dati per l'inferenza Object2Vec](object2vec-inference-formats.md)
+ [Incorporamenti del codificatore per Object2Vec](object2vec-encoder-embeddings.md)

## Interfaccia di I/O per l'algoritmo Object2Vec
<a name="object2vec-inputoutput"></a>

Puoi utilizzare Object2Vec su diversi tipi di dati di input, come negli esempi seguenti:


| Tipo di dati di input | Esempio | 
| --- | --- | 
|  Coppie frase-frase  | "Una partita di calcio con più maschi che giocano". e "Alcuni uomini praticano uno sport". | 
|  Coppie etichette-sequenza  | I tag di genere del film "Titanic", ad esempio "Romantico" e "Drammatico", e la sua descrizione breve: "Titanic di James Cameron è un film epico, romantico e d'azione ambientato durante lo sfortunato viaggio inaugurale dell'R.M.S. Titanic. Era il transatlantico più lussuoso della sua epoca, una nave dei sogni, che alla fine ha portato alla morte oltre 1.500 persone nelle acque ghiacciate dell'Atlantico del Nord nelle prime ore del 15 aprile 1912". | 
|  Coppie cliente-cliente  |  ID cliente di Jane e ID cliente di Jackie.  | 
|  Coppie prodotto-prodotto  |  ID prodotto del calcio e ID prodotto del basket.  | 
|  Coppie utente revisione elemento-elemento  |  ID di un utente e degli articoli che ha acquistato, ad esempio mela, pera e arancia.  | 

Per trasformare i dati di input nei formati supportati, è necessario pre-elaborarli. Attualmente, Object2Vec supporta due tipi di input in modo nativo: 
+ Un token discreto, rappresentato come elenco di un singolo `integer-id`. Ad esempio, `[10]`.
+ Sequenze di token discreti, rappresentati come elenchi di `integer-ids`. Ad esempio, `[0,12,10,13]`.

L'oggetto in ciascuna coppia può essere asimmetrico. Ad esempio, le coppie possono essere (token, sequenza) o (token, token) o (sequenza, sequenza). Per gli input token, l'algoritmo supporta gli incorporamenti semplici come codificatori compatibili. Per le sequenze di vettori di token, l'algoritmo supporta come codificatori:
+  Incorporamenti a pool medio
+  Reti neurali convoluzionali gerarchiche (), CNNs
+  Memoria bidirezionale a lungo termine multistrato (Bi) LSTMs 

L'etichetta di input per ogni coppia può essere una delle seguenti:
+ Un'etichetta categorica che esprime la relazione tra gli oggetti nella coppia 
+ Un punteggio che esprime la forza della somiglianza tra i due oggetti 

Per le etichette di categoria utilizzate nella classificazione, l'algoritmo supporta la funzione di perdita di entropia incrociata. Per le etichette basate sulle valutazioni o sul punteggio utilizzate nella regressione, l'algoritmo supporta la funzione di perdita dell'errore quadratico medio (MSE). Specifica le funzioni di perdita con l'iperparametro `output_layer` durante il processo di addestramento del modello.

## Raccomandazione istanza EC2 per l'algoritmo Object2Vec
<a name="object2vec--instances"></a>

Il tipo di istanza Amazon Elastic Compute Cloud (Amazon EC2) utilizzato varia a seconda del fatto che tu sia in fase di addestramento o esecuzione di inferenze. 

Per l’addestramento di un modello con l'algoritmo Object2Vec su una CPU, inizia con un'istanza ml.m5.2xlarge. Per l’addestramento su una GPU, inizia con un'istanza ml.p2.xlarge. Se l'addestramento richiede troppo tempo su questa istanza, puoi usare un'istanza maggiore. Al momento, l'algoritmo Object2Vec può eseguire l'addestramento solo su un singolo computer. Tuttavia, offre supporto per più versioni. GPUs Object2Vec supporta famiglie di istanze GPU P2, P3, G4dn e G5 per l'addestramento e l'inferenza.

Per l'inferenza con un modello Object2Vec addestrato con rete neurale profonda, consigliamo di utilizzare l'istanza con GPU ml.p3.2xlarge. A causa della limitata memoria della GPU, è possibile specificare la variabile di ambiente `INFERENCE_PREFERRED_MODE` per ottimizzare il comportamento nel caso in cui sia caricata sulla GPU la rete di inferenza [Ottimizzazione GPU: Classificazione o Regressione](object2vec-inference-formats.md#object2vec-inference-gpu-optimize-classification) o [Ottimizzazione GPU: Encoder Embeddings](object2vec-encoder-embeddings.md#object2vec-inference-gpu-optimize-encoder-embeddings).

## Notebook di esempio di Object2Vec
<a name="object2vec-sample-notebooks"></a>
+ [Utilizzo di Object2Vec per codificare frasi in incorporamenti a lunghezza fissa](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/object2vec_sentence_similarity/object2vec_sentence_similarity.html)

# Come funziona Object2Vec
<a name="object2vec-howitworks"></a>

Quando usi l'algoritmo Amazon SageMaker AI Object2Vec, segui il flusso di lavoro standard: elabora i dati, addestra il modello e produci inferenze. 

**Topics**
+ [Fase 1: elaborazione dei dati](#object2vec-step-1-data-preprocessing)
+ [Fase 2: addestramento di un modello](#object2vec-step-2-training-model)
+ [Fase 3: produzione di inferenze](#object2vec-step-3-inference)

## Fase 1: elaborazione dei dati
<a name="object2vec-step-1-data-preprocessing"></a>

Durante la preelaborazione, i dati devono essere convertiti nel formato di file di testo [JSON Lines](http://jsonlines.org/) specificato in [Formato dei dati per l’addestramento Object2Vec](object2vec-training-formats.md). Per ottenere la massima precisione durante l’addestramento, inoltre, occorre mischiare casualmente i dati prima di immetterli nel modello. Il processo per generare permutazioni casuali dipende dal linguaggio utilizzato. Per Python, si può utilizzare `np.random.shuffle`; per Unix `shuf`.

## Fase 2: addestramento di un modello
<a name="object2vec-step-2-training-model"></a>

L'algoritmo SageMaker AI Object2Vec ha i seguenti componenti principali:
+ **due canali di ingresso**: i canali di ingresso accettano come input un paio di oggetti dello stesso tipo o di tipo diverso e li passano a codificatori indipendenti e personalizzabili.
+ **due codificatori**: i due codificatori, enc0 ed enc1, convertono ogni oggetto in un vettore di incorporamento a lunghezza fissa. Gli incorporamenti degli oggetti codificati nella coppia vengono quindi inviati a un comparatore.
+ **un comparatore**: il comparatore confronta gli incorporamenti in modi diversi e restituisce punteggi che indicano la forza della relazione tra gli oggetti accoppiati. Nel punteggio di output, per una coppia di frasi. Ad esempio, 1 indica una relazione forte tra una coppia di frasi e 0 rappresenta una relazione debole. 

Durante l’addestramento, l'algoritmo accetta coppie di oggetti e le etichette di relazione o i punteggi corrispondenti come input. Gli oggetti in ciascuna coppia possono essere di tipi diversi, che illustrato in precedenza Se gli input a entrambi i codificatori sono costituiti dalle stesse unità a livello di token, è possibile utilizzare un livello di incorporamento di token condiviso impostando l'iperparametro `tied_token_embedding_weight` su `True` durante la creazione del processo di addestramento. Questo è possibile, ad esempio, quando si confrontano frasi che hanno entrambe unità a livello di token di parola. Per generare esempi negativi a una determinata velocità, imposta l'iperparametro `negative_sampling_rate` sul rapporto desiderato tra esempi negativi e positivi. Questo iperparametro velocizza l'apprendimento della distinzione tra gli esempi positivi osservati nei dati di addestramento e gli esempi negativi che difficilmente vengono osservati. 

Le coppie di oggetti vengono passate attraverso codificatori indipendenti e personalizzabili che sono compatibili con i tipi di input degli oggetti corrispondenti. I codificatori convertono ogni oggetto di una coppia in un vettore di incorporamento a lunghezza fissa di pari lunghezza. La coppia di vettori viene passata a un operatore di confronto, che assembla i vettori in un unico vettore utilizzando il valore specificato nell'iperparametro `comparator_list`. Il vettore assemblato passa quindi attraverso un percettrone multistrato (MLP), che produce un output che la funzione di perdita confronta con le etichette specificate. Questo confronto restituisce la forza della relazione tra gli oggetti nella coppia prevista dal modello. La figura seguente mostra il flusso di lavoro.

![\[Architettura dell'algoritmo Object2Vec dagli input di dati ai punteggi\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/object2vec-training-image.png)


## Fase 3: produzione di inferenze
<a name="object2vec-step-3-inference"></a>

Dopo l’addestramento del modello, puoi utilizzare il codificatore addestrato per preelaborare gli oggetti di input o per eseguire due tipi di inferenza:
+ Per convertire gli oggetti di input singleton in incorporamenti a lunghezza fissa usando il codificatore corrispondente
+ Per prevedere il punteggio o l'etichetta della relazione tra una coppia di oggetti di input

Il server di inferenza calcola automaticamente i tipi richiesti in base ai dati di input. Per ottenere gli incorporamenti come output, fornisci un solo input. Per prevedere il punteggio o l'etichetta della relazione, fornisci entrambi gli input nella coppia.

# Iperparametri Object2Vec
<a name="object2vec-hyperparameters"></a>

Nella richiesta `CreateTrainingJob` puoi specificare l'algoritmo di addestramento. È inoltre possibile specificare iperparametri specifici dell'algoritmo come mappe. string-to-string La tabella seguente elenca gli iperparametri per l'algoritmo di addestramento Object2Vec.


| Nome parametro | Description | 
| --- | --- | 
| enc0\$1max\$1seq\$1len |  La lunghezza massima della sequenza per il codificatore enc0. **Campo obbligatorio** Valori validi: 1 ≤ numero intero ≤ 5000  | 
| enc0\$1vocab\$1size |  La dimensione del vocabolario di token enc0. **Campo obbligatorio** Valori validi: 2 ≤ numero intero ≤ 3000000  | 
| bucket\$1width |  La differenza consentita tra la lunghezza della sequenza di dati quando il bucketing è abilitato. Per abilitare il bucketing, specifica un valore diverso da zero per questo parametro. **Opzionale** Valori validi: 0 ≤ numero intero ≤ 100 Valore predefinito: 0 (nessun bucketing)  | 
| comparator\$1list |  Elenco utilizzato per personalizzare il modo in cui vengono confrontati due incorporamenti. Il livello dell'operatore comparatore di Object2Vec accetta le codifiche di entrambi i codificatori come input e restituisce un singolo vettore come output. Questo vettore è una concatenazione di vettori secondari. I valori stringa passati a `comparator_list` e l'ordine in cui vengono passati determinano il modo in cui questi vettori secondari vengono assemblati. Ad esempio, se `comparator_list="hadamard, concat"`, l'operatore comparatore costruisce il vettore concatenando il prodotto Hadamard di due codifiche e la concatenazione di due codifiche. Se invece `comparator_list="hadamard"`, l'operatore comparatore costruisce il vettore come prodotto hadamard solo di due codifiche.  **Opzionale** Valori validi: una stringa che contiene qualsiasi combinazione dei nomi dei tre operatori binari: `hadamard`, `concat` o `abs_diff`. L'algoritmo Object2Vec attualmente richiede che le due codifiche vettoriali abbiano la stessa dimensione. Questi operatori producono i vettori secondari come segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/object2vec-hyperparameters.html) Valore predefinito: `"hadamard, concat, abs_diff"`  | 
| dropout |  La probabilità di dropout per i livelli di rete. Il *dropout* è una forma di regolarizzazione utilizzata nelle reti neurali che riduce l'overfitting mediante il taglio dei neuroni codipendenti. **Opzionale** Valori validi: 0,0 ≤ float ≤ 1,0 Valore predefinito: 0.0  | 
| early\$1stopping\$1patience |  Viene applicato il numero di epoche (Unix epochs) consecutive senza miglioramenti consentiti prima della sospensione anticipata. Il miglioramento è definito con l'iperparametro `early_stopping_tolerance`. **Opzionale** Valori validi: 1 ≤ numero intero ≤ 5 Valore predefinito: 3  | 
| early\$1stopping\$1tolerance |  La riduzione della funzione di perdita che un algoritmo deve raggiungere tra epoche (Unix epochs) consecutive per evitare l'arresto precoce dopo la conclusione del numero di epoche (Unix epochs) consecutive specificate nell'iperparametro `early_stopping_patience`. **Opzionale** Valori validi: 0,000001 ≤ float ≤ 0,1 Valore predefinito: 0,01  | 
| enc\$1dim |  La dimensione dell'output del livello di incorporamento. **Opzionale** Valori validi: 4 ≤ numero intero ≤ 10000 Valore predefinito: 4096  | 
| enc0\$1network |  Il modello di rete per il codificatore enc0. **Opzionale** Valori validi: `hcnn`, `bilstm` o `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/object2vec-hyperparameters.html) Valore predefinito: `hcnn`  | 
| enc0\$1cnn\$1filter\$1width |  La larghezza del filtro del codificatore enc0 della rete neurale convoluzionale (CNN). **Condizionale** Valori validi: 1 ≤ numero intero ≤ 9 Valore predefinito: 3  | 
| enc0\$1freeze\$1pretrained\$1embedding |  Indica se congelare i pesi di incorporamento già addestrati di enc0. **Condizionale** Valori validi: `True` o `False` Valore predefinito: `True`  | 
| enc0\$1layers  |  Il numero di livelli nel codificatore enc0. **Condizionale** Valori validi: `auto` o 1 ≤ numero intero ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/object2vec-hyperparameters.html) Valore predefinito: `auto`  | 
| enc0\$1pretrained\$1embedding\$1file |  Il nome del file di incorporamento token enc0 già addestrato nel canale di dati ausiliari. **Condizionale** Valori validi: stringa con caratteri alfanumerici, trattino basso o punto. [A-Za-z0-9\$1.\$1\$1]  Valore predefinito: "" (stringa vuota)  | 
| enc0\$1token\$1embedding\$1dim |  La dimensione dell'output del livello di incorporamento token enc0. **Condizionale** Valori validi: 2 ≤ numero intero ≤ 1000 Valore predefinito: 300  | 
| enc0\$1vocab\$1file |  Il file di vocabolario per mappare i token enc0 preaddestrati che incorporano i vettori nel vocabolario numerico. IDs **Condizionale** Valori validi: stringa con caratteri alfanumerici, trattino basso o punto. [A-Za-z0-9\$1.\$1\$1]  Valore predefinito: "" (stringa vuota)  | 
| enc1\$1network |  Il modello di rete per il codificatore enc1. Se vuoi che il codificatore enc1 utilizzi lo stesso modello di rete di enc0, inclusi i valori degli iperparametri, imposta il valore su `enc0`.   Anche quando le reti dei codificatori enc0 ed enc1 hanno architetture simmetriche, non è possibile condividere i valori dei parametri per queste reti non sono supportati.  **Opzionale** Valori validi: `enc0`, `hcnn`, `bilstm` o `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/object2vec-hyperparameters.html) Valore predefinito: `enc0`  | 
| enc1\$1cnn\$1filter\$1width |  La larghezza del filtro del codificatore CNN enc1. **Condizionale** Valori validi: 1 ≤ numero intero ≤ 9 Valore predefinito: 3  | 
| enc1\$1freeze\$1pretrained\$1embedding |  Indica se congelare i pesi di incorporamento già addestrati di enc1. **Condizionale** Valori validi: `True` o `False` Valore predefinito: `True`  | 
| enc1\$1layers  |  Il numero di livelli nel codificatore enc1. **Condizionale** Valori validi: `auto` o 1 ≤ numero intero ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/object2vec-hyperparameters.html) Valore predefinito: `auto`  | 
| enc1\$1max\$1seq\$1len |  La lunghezza massima della sequenza per il codificatore enc1. **Condizionale** Valori validi: 1 ≤ numero intero ≤ 5000  | 
| enc1\$1pretrained\$1embedding\$1file |  Il nome del file di incorporamento token enc1 già addestrato nel canale di dati ausiliari. **Condizionale** Valori validi: stringa con caratteri alfanumerici, trattino basso o punto. [A-Za-z0-9\$1.\$1\$1]  Valore predefinito: "" (stringa vuota)  | 
| enc1\$1token\$1embedding\$1dim |  La dimensione dell'output del livello di incorporamento token enc1. **Condizionale** Valori validi: 2 ≤ numero intero ≤ 1000 Valore predefinito: 300  | 
| enc1\$1vocab\$1file |  Il file di vocabolario per mappare gli incorporamenti di token enc1 preaddestrati al vocabolario. IDs **Condizionale** Valori validi: stringa con caratteri alfanumerici, trattino basso o punto. [A-Za-z0-9\$1.\$1\$1]  Valore predefinito: "" (stringa vuota)  | 
| enc1\$1vocab\$1size |  La dimensione del vocabolario di token enc0. **Condizionale** Valori validi: 2 ≤ numero intero ≤ 3000000  | 
| epochs |  Il numero di epoche (Unix epochs) da eseguire per l’addestramento.  **Opzionale** Valori validi: 1 ≤ numero intero ≤ 100 Valore predefinito: 30  | 
| learning\$1rate |  La velocità di apprendimento per l’addestramento. **Opzionale** Valori validi: 1,0E-6 ≤ float ≤ 1,0 Valore predefinito: 0.0004  | 
| mini\$1batch\$1size |  La dimensione del batch in cui è suddiviso il set di dati per un `optimizer` durante l’addestramento. **Opzionale** Valori validi: 1 ≤ numero intero ≤ 10000 Valore predefinito: 32  | 
| mlp\$1activation |  Il tipo di funzione di attivazione per il livello di percezione multistrato (MLP). **Opzionale** Valori validi: `tanh`, `relu` o `linear` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/object2vec-hyperparameters.html) Valore predefinito: `linear`  | 
| mlp\$1dim |  La dimensione dell'output dai livelli MLP. **Opzionale** Valori validi: 2 ≤ numero intero ≤ 10000 Valore predefinito: 512  | 
| mlp\$1layers |  Numero di livelli MLP nella rete. **Opzionale** Valori validi: 0 ≤ numero intero ≤ 10 Valore predefinito: 2  | 
| negative\$1sampling\$1rate |  Il rapporto tra gli esempi negativi, generati per agevolare l’addestramento dell'algoritmo, e gli esempi positivi che vengono forniti dagli utenti. Gli esempi negativi sono dati che difficilmente si osservano nella realtà e sono etichettati negativamente per l’addestramento. Sono utili per addestrare un modello a distinguere tra gli esempi positivi osservati e gli esempi negativi. Per specificare il rapporto tra gli esempi negativi e gli esempi positivi usati per l’addestramento, imposta il valore su un numero intero positivo. Ad esempio, se l'algoritmo viene addestrato su dati di input in cui tutti gli esempi sono positivi e si imposta `negative_sampling_rate` su 2, l'algoritmo Object2Vec genera internamente due esempi negativi per ogni esempio positivo. Se non vuoi generare o utilizzare esempi negativi durante l’addestramento, imposta il valore su 0.  **Opzionale** Valori validi: 0 ≤ numero intero Valore predefinito: 0 (disattivato)  | 
| num\$1classes |  Il numero di classi per l’addestramento di classificazione. Amazon SageMaker AI ignora questo iperparametro per problemi di regressione. **Opzionale** Valori validi: 2 ≤ numero intero ≤ 30 Valore predefinito: 2  | 
| optimizer |  Il tipo di ottimizzazione. **Opzionale** Valori validi: `adadelta`, `adagrad`, `adam`, `sgd` o `rmsprop`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/object2vec-hyperparameters.html) Valore predefinito: `adam`  | 
| output\$1layer |  Il tipo di livello di output in cui si specifica che l'attività è una regressione o classificazione. **Opzionale** Valori validi: `softmax` o `mean_squared_error` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/object2vec-hyperparameters.html) Valore predefinito: `softmax`  | 
| tied\$1token\$1embedding\$1weight |  Indica se utilizzare un livello di incorporamento condiviso per entrambi i codificatori. Se gli input per entrambi i codificatori usano le stesse unità a livello di token, utilizza un livello di incorporamento token condiviso. Ad esempio, per una raccolta di documenti, se un codificatore codifica frasi e un altro codifica interi documenti, puoi utilizzare un livello di incorporamento token condiviso. Questo perché sia le frasi che i documenti sono costituiti da token parola dallo stesso vocabolario. **Opzionale** Valori validi: `True` o `False` Valore predefinito: `False`  | 
| token\$1embedding\$1storage\$1type |  Modalità di aggiornamento gradiente utilizzata durante l’addestramento: quando viene usata la modalità `dense`, l'ottimizzatore calcola la matrice dell'intero gradiente per il livello di incorporamento token anche se la maggior parte delle righe del gradiente ha valore zero. Quando viene usata la modalità `sparse`, l'ottimizzatore memorizza solo le righe del gradiente effettivamente utilizzate nel mini-batch. Se vuoi che l'algoritmo esegua aggiornamenti del gradiente di tipo lazy, che calcolano i gradienti solo nelle righe diverse da zero e che accelerano l’addestramento, specifica `row_sparse`. L'impostazione del valore su `row_sparse` vincola i valori disponibili per altri iperparametri nel modo seguente:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/object2vec-hyperparameters.html) **Opzionale** Valori validi: `dense` o `row_sparse` Valore predefinito: `dense`  | 
| weight\$1decay |  Il parametro di decadimento peso utilizzato per l'ottimizzazione. **Opzionale** Valori validi: 0 ≤ float ≤ 10000 Valore predefinito: 0 (nessun decadimento)  | 

# Ottimizzazione di un modello Object2Vec
<a name="object2vec-tuning"></a>

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. Per il parametro obiettivo, puoi usare uno dei 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 Object2Vec
<a name="object2vec-metrics"></a>

L'algoritmo Object2Vec ha i parametri di classificazione e di regressione. Il tipo `output_layer` determina quale parametro puoi utilizzare per l'ottimizzazione automatica del modello. 

### Parametri di regressione calcolati dall'algoritmo Object2Vec
<a name="object2vec-regressor-metrics"></a>

L'algoritmo restituisce un parametro di regressione errore quadratico medio che viene calcolato durante il test e la convalida. Quando si ottimizza il modello per le attività di regressione, scegli questo parametro come obiettivo.


| Nome parametro | Description | Direzione dell'ottimizzazione | 
| --- | --- | --- | 
| test:mean\$1squared\$1error | Errore quadratico medio | Minimizza | 
| validation:mean\$1squared\$1error | Errore quadratico medio | Minimizza | 

### Parametri di classificazione calcolati dall'algoritmo Object2Vec
<a name="object2vec-classification-metrics"></a>

L'algoritmo Object2Vec restituisce i parametri di accuratezza e classificazione di entropia incrociata, che vengono calcolati durante il test e la convalida. Quando ottimizzi il modello per attività di classificazione, scegli uno di questi parametri come obiettivo.


| Nome parametro | Description | Direzione dell'ottimizzazione | 
| --- | --- | --- | 
| test:accuracy | Accuratezza | Massimizza | 
| test:cross\$1entropy | Entropia incrociata | Minimizza | 
| validation:accuracy | Accuratezza | Massimizza | 
| validation:cross\$1entropy | Entropia incrociata | Minimizza | 

## Iperparametri Object2Vec ottimizzabili
<a name="object2vec-tunable-hyperparameters"></a>

È possibile ottimizzare i seguenti iperparametri per l'algoritmo Object2Vec.


| Nome iperparametro | Tipo di iperparametro | Intervalli e valori consigliati | 
| --- | --- | --- | 
| dropout | ContinuousParameterRange | MinValue: MaxValue 0,0,: 1,0 | 
| early\$1stopping\$1patience | IntegerParameterRange | MinValue: 1, MaxValue: 5 | 
| early\$1stopping\$1tolerance | ContinuousParameterRange | MinValue: 0,001, MaxValue 0,1 | 
| enc\$1dim | IntegerParameterRange | MinValue: 4, MaxValue 4096 | 
| enc0\$1cnn\$1filter\$1width | IntegerParameterRange | MinValue: 1, MaxValue: 5 | 
| enc0\$1layers | IntegerParameterRange | MinValue: 1, MaxValue: 4 | 
| enc0\$1token\$1embedding\$1dim | IntegerParameterRange | MinValue: 5, MaxValue: 30 | 
| enc1\$1cnn\$1filter\$1width | IntegerParameterRange | MinValue: 1, MaxValue: 5 | 
| enc1\$1layers | IntegerParameterRange | MinValue: 1, MaxValue: 4 | 
| enc1\$1token\$1embedding\$1dim | IntegerParameterRange | MinValue: 5, MaxValue: 30 | 
| epochs | IntegerParameterRange | MinValue: 4, MaxValue: 20 | 
| learning\$1rate | ContinuousParameterRange | MinValue: 1e-6, MaxValue: 1,0 | 
| mini\$1batch\$1size | IntegerParameterRange | MinValue: 1, 8192 MaxValue | 
| mlp\$1activation | CategoricalParameterRanges |  [`tanh`, `relu`, `linear`]  | 
| mlp\$1dim | IntegerParameterRange | MinValue: 16, MaxValue 1024 | 
| mlp\$1layers | IntegerParameterRange | MinValue: 1, MaxValue: 4 | 
| optimizer | CategoricalParameterRanges | [`adagrad`, `adam`, `rmsprop`, `sgd`, `adadelta`] | 
| weight\$1decay | ContinuousParameterRange | MinValue: 0,0, MaxValue: 1,0 | 

# Formato dei dati per l’addestramento Object2Vec
<a name="object2vec-training-formats"></a>

Quando esegui l’addestramento con l’algoritmo Object2Vec, assicurati che i dati di input della tua richiesta siano in formato JSON Lines, in cui ogni riga rappresenta un singolo punto dati.

## Input: formato della richiesta JSON Lines
<a name="object2vec-in-training-data-jsonlines"></a>

Content-type: application/jsonlines

```
{"label": 0, "in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4], "in1": [16, 21, 13, 45, 14, 9, 80, 59, 164, 4]}
{"label": 1, "in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4], "in1": [22, 32, 13, 25, 1016, 573, 3252, 4]}
{"label": 1, "in0": [774, 14, 21, 206], "in1": [21, 366, 125]}
```

Gli elementi "in0" e "in1" sono gli input per encoder0 ed encoder1 rispettivamente. Lo stesso formato è valido per i problemi di classificazione e di regressione. Per la regressione, il campo `"label"` accetta input con valori reali.

# Formati dei dati per l'inferenza Object2Vec
<a name="object2vec-inference-formats"></a>

La pagina seguente descrive i formati di richiesta di input e output di risposta per ottenere l'inferenza del punteggio dal modello Amazon SageMaker AI Object2Vec.

## Ottimizzazione GPU: Classificazione o Regressione
<a name="object2vec-inference-gpu-optimize-classification"></a>

A causa della limitata memoria della GPU, è possibile specificare la variabile di ambiente `INFERENCE_PREFERRED_MODE` per ottimizzare il comportamento nel caso in cui sia caricata sulla GPU la rete di inferenza classificazione/regressione o [Output: Encoder Embedding](object2vec-encoder-embeddings.md#object2vec-out-encoder-embeddings-data). Se la maggior parte dell'inferenza riguarda aspetti di classificazione o regressione, specificare `INFERENCE_PREFERRED_MODE=classification`. Di seguito è riportato un esempio di Batch Transform dell'utilizzo di 4 istanze di p3.2xlarge ottimizzate per l'inferenza: classification/regression 

```
transformer = o2v.transformer(instance_count=4,
                              instance_type="ml.p2.xlarge",
                              max_concurrent_transforms=2,
                              max_payload=1,  # 1MB
                              strategy='MultiRecord',
                              env={'INFERENCE_PREFERRED_MODE': 'classification'},  # only useful with GPU
                              output_path=output_s3_path)
```

## Input: formato della richiesta di classificazione o regressione
<a name="object2vec-in-inference-data"></a>

Content-type: application/json

```
{
  "instances" : [
    {"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4], "in1": [16, 21, 13, 45, 14, 9, 80, 59, 164, 4]},
    {"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4], "in1": [22, 32, 13, 25, 1016, 573, 3252, 4]},
    {"in0": [774, 14, 21, 206], "in1": [21, 366, 125]}
  ]
}
```

Content-type: application/jsonlines

```
{"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4], "in1": [16, 21, 13, 45, 14, 9, 80, 59, 164, 4]}
{"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4], "in1": [22, 32, 13, 25, 1016, 573, 3252, 4]}
{"in0": [774, 14, 21, 206], "in1": [21, 366, 125]}
```

Per i problemi di classificazione, la lunghezza del vettore dei punteggi corrisponde a `num_classes`. Per i problemi di regressione, la lunghezza è 1.

## Output: formato della risposta di classificazione o regressione
<a name="object2vec-out-inference-data"></a>

Accept: application/json

```
{
    "predictions": [
        {
            "scores": [
                0.6533935070037842,
                0.07582679390907288,
                0.2707797586917877
            ]
        },
        {
            "scores": [
                0.026291321963071823,
                0.6577019095420837,
                0.31600672006607056
            ]
        }
    ]
}
```

Accept: application/jsonlines

```
{"scores":[0.195667684078216,0.395351558923721,0.408980727195739]}
{"scores":[0.251988261938095,0.258233487606048,0.489778339862823]}
{"scores":[0.280087798833847,0.368331134319305,0.351581096649169]}
```

Nei formati di classificazione e di regressione, i punteggi si applicano a singole etichette. 

# Incorporamenti del codificatore per Object2Vec
<a name="object2vec-encoder-embeddings"></a>

La pagina seguente elenca i formati di richiesta di input e output di risposta per ottenere l'inferenza che incorpora l'encoder dal modello Amazon SageMaker AI Object2Vec.

## Ottimizzazione GPU: Encoder Embeddings
<a name="object2vec-inference-gpu-optimize-encoder-embeddings"></a>

L'incorporamento è una mappatura da oggetti discreti, come le parole, a vettori di numeri reali.

A causa della limitata memoria della GPU, è possibile specificare la variabile di ambiente `INFERENCE_PREFERRED_MODE` per ottimizzare il comportamento nel caso in cui sia caricata sulla GPU la rete di inferenza [Formati dei dati per l'inferenza Object2Vec](object2vec-inference-formats.md) o encoder embedding. Se la maggior parte dell'inferenza riguarda aspetti di encoder embedding, specificare`INFERENCE_PREFERRED_MODE=embedding`. Di seguito è riportato un esempio di utilizzo di trasformazione in batch usando 4 istanze di p3.2xlarge ottimizzate per l'inferenza di encoder embedding:

```
transformer = o2v.transformer(instance_count=4,
                              instance_type="ml.p2.xlarge",
                              max_concurrent_transforms=2,
                              max_payload=1,  # 1MB
                              strategy='MultiRecord',
                              env={'INFERENCE_PREFERRED_MODE': 'embedding'},  # only useful with GPU
                              output_path=output_s3_path)
```

## Input: Encoder Embedding
<a name="object2vec-in-encoder-embeddings-data"></a>

Content-type: application/json; infer\$1max\$1seqlens=<FWD-LENGTH>,<BCK-LENGTH>

Dove <FWD-LENGTH> e <BCK-LENGTH> sono numeri interi compresi nell'intervallo [1.5000] e definiscono la lunghezza massima delle sequenze per il codificatore avanti e indietro.

```
{
  "instances" : [
    {"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4]},
    {"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4]},
    {"in0": [774, 14, 21, 206]}
  ]
}
```

Content-type: application/jsonlines; infer\$1max\$1seqlens=<FWD-LENGTH>,<BCK-LENGTH>

Dove <FWD-LENGTH> e <BCK-LENGTH> sono numeri interi compresi nell'intervallo [1.5000] e definiscono la lunghezza massima delle sequenze per il codificatore avanti e indietro.

```
{"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4]}
{"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4]}
{"in0": [774, 14, 21, 206]}
```

In entrambi questi formati, si specifica un solo tipo di input, `“in0”` o `“in1.”` Il servizio di inferenza richiama il codificatore corrispondente e genera gli incorporamenti per ciascuna istanza. 

## Output: Encoder Embedding
<a name="object2vec-out-encoder-embeddings-data"></a>

Content-type: application/json

```
{
  "predictions": [
    {"embeddings":[0.057368703186511,0.030703511089086,0.099890425801277,0.063688032329082,0.026327300816774,0.003637571120634,0.021305780857801,0.004316598642617,0.0,0.003397724591195,0.0,0.000378780066967,0.0,0.0,0.0,0.007419463712722]},
    {"embeddings":[0.150190666317939,0.05145975202322,0.098204270005226,0.064249359071254,0.056249320507049,0.01513972133398,0.047553978860378,0.0,0.0,0.011533712036907,0.011472506448626,0.010696629062294,0.0,0.0,0.0,0.008508535102009]}
  ]
}
```

Content-type: application/jsonlines

```
{"embeddings":[0.057368703186511,0.030703511089086,0.099890425801277,0.063688032329082,0.026327300816774,0.003637571120634,0.021305780857801,0.004316598642617,0.0,0.003397724591195,0.0,0.000378780066967,0.0,0.0,0.0,0.007419463712722]}
{"embeddings":[0.150190666317939,0.05145975202322,0.098204270005226,0.064249359071254,0.056249320507049,0.01513972133398,0.047553978860378,0.0,0.0,0.011533712036907,0.011472506448626,0.010696629062294,0.0,0.0,0.0,0.008508535102009]}
```

La lunghezza del vettore degli incorporamenti emessi dal servizio di inferenza è uguale al valore di uno degli iperparametri che specifichi in fase di addestramento: `enc0_token_embedding_dim`, `enc1_token_embedding_dim` o `enc_dim`.

# Sequence-to-Sequence Algoritmo
<a name="seq-2-seq"></a>

Amazon SageMaker AI Sequence to Sequence è un algoritmo di apprendimento supervisionato in cui l'input è una sequenza di token (ad esempio testo, audio) e l'output generato è un'altra sequenza di token. Le applicazioni di esempio includono: traduzione automatica (immissione di una frase da una lingua e previsione di quale frase sarebbe in un'altra lingua), riepilogo del testo (immissione di una stringa di parole più lunga e previsione di una stringa di parole più breve, ovvero un riepilogo), speech-to-text (clip audio convertite in frasi di output in token). Recentemente, i problemi in questo dominio sono stati risolti con modelli di rete neurale profonda che hanno ottimizzato le prestazioni rispetto alle precedenti metodologie. Amazon SageMaker AI seq2seq utilizza i modelli Recurrent Neural Networks (RNNs) e Convolutional Neural Network (CNN) con attenzione come architetture codificatore-decodificatore. 

**Topics**
+ [Interfaccia di Sequence-to-Sequence input/output per l'algoritmo](#s2s-inputoutput)
+ [Raccomandazione dell'istanza EC2 Sequence-to-Sequence per l'algoritmo](#s2s-instances)
+ [Sequence-to-Sequence Notebook di esempio](#seq-2-seq-sample-notebooks)
+ [Funzionamento di Sequence-to-Sequence](seq-2-seq-howitworks.md)
+ [Sequence-to-Sequence Iperparametri](seq-2-seq-hyperparameters.md)
+ [Ottimizza un Sequence-to-Sequence modello](seq-2-seq-tuning.md)

## Interfaccia di Sequence-to-Sequence input/output per l'algoritmo
<a name="s2s-inputoutput"></a>

**Addestramento**

SageMaker AI seq2seq prevede dati in formato recordio-protobuf. Tuttavia, i token sono previsti come numeri interi, non come valori in virgola mobile, come si fa di solito.

Nel [notebook di esempio seq2seq](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html) è incluso uno script per la conversione dei dati da file di testo tokenizzati al formato protobuf. In generale, raggruppa i dati in tensori interi a 32 bit e genera i file di vocabolario richiesti, necessari per interferenza e calcolo dei parametri.

Una volta completata la preelaborazione, l'algoritmo può essere richiamato per l’addestramento. L'algoritmo prevede tre canali:
+ `train`: deve contenere i dati di addestramento (ad esempio, il file `train.rec` generato dallo script di preelaborazione).
+ `validation`: deve contenere i dati di convalida (ad esempio, il file `val.rec` generato dallo script di preelaborazione).
+ `vocab`: deve contenere i due file di vocabolario (`vocab.src.json` e `vocab.trg.json`). 

Se l'algoritmo non rileva alcun dato in questi tre canali, si verifica un errore nell’addestramento.

**Inferenza**

Per gli endpoint ospitati, l'inferenza supporta due formati di dati. Per eseguire l'inferenza utilizzando token di testo separati da spazio, utilizza il formato `application/json`. In alternativa, utilizza il formato `recordio-protobuf` per lavorare con i dati codificati come numeri interi. Entrambe le modalità supportano la ripartizione in batch dei dati di input. Il formato `application/json` consente inoltre di visualizzare la matrice di attenzione.
+ `application/json`: si aspetta l'input in formato JSON e restituisce l'output in formato JSON. I tipi di contenuto e accettazione devono essere `application/json`. Ogni sequenza deve essere una stringa con token separati da spazi vuoti. Questo formato è consigliato quando il numero di sequenze di origine nel batch è esiguo. Inoltre, supporta le seguenti opzioni di configurazione aggiuntive:

  `configuration`: \$1`attention_matrix`: `true`\$1: restituisce la matrice di attenzione per la specifica sequenza di input.
+ `application/x-recordio-protobuf`: si aspetta l'input nel formato `recordio-protobuf` e restituisce l'output in `recordio-protobuf format`. I tipi di contenuto e accettazione devono essere `applications/x-recordio-protobuf`. Per questo formato, le sequenze di origine devono essere convertite in un elenco di numeri interi per la successiva codifica di protobuf. Questo formato è consigliato per l'inferenza in blocco.

Per la trasformazione in batch, l'inferenza supporta il formato JSON Lines. La trasformazione in batch prevede l'input in formato JSON Lines e restituisce l'output in formato JSON Lines. I tipi di contenuto e accettazione devono essere `application/jsonlines`. Il formato dell'input è il seguente:

```
content-type: application/jsonlines

{"source": "source_sequence_0"}
{"source": "source_sequence_1"}
```

Il formato della risposta è il seguente:

```
accept: application/jsonlines

{"target": "predicted_sequence_0"}
{"target": "predicted_sequence_1"}
```

Per ulteriori informazioni su come serializzare e deserializzare gli input e gli output in formati specifici per l'interferenza, consulta [Sequence-to-Sequence Notebook di esempio](#seq-2-seq-sample-notebooks).

## Raccomandazione dell'istanza EC2 Sequence-to-Sequence per l'algoritmo
<a name="s2s-instances"></a>

L'algoritmo Amazon SageMaker AI seq2seq supporta solo tipi di istanze GPU e può essere addestrato solo su una singola macchina. Tuttavia, puoi utilizzare istanze con più istanze. GPUs L'algoritmo seq2seq supporta le famiglie di istanze GPU P2, P3, G4dn e G5.

## Sequence-to-Sequence Notebook di esempio
<a name="seq-2-seq-sample-notebooks"></a>

Per un taccuino di esempio che mostra come utilizzare l'algoritmo SageMaker AI Sequence to Sequence per addestrare un modello di traduzione inglese-tedesco, vedi Esempio di traduzione automatica inglese-tedesco utilizzando AI [Seq2Seq](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html). SageMaker Per istruzioni su come creare e accedere 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 un'istanza di notebook e averla aperta, seleziona la scheda **Esempi di SageMaker AI** per visualizzare un elenco di tutti gli esempi di IA. SageMaker I notebook di esempio di modellazione dell'argomento che utilizzano gli algoritmi NTM sono disponibili nella sezione con l'**introduzione agli algoritmi di Amazon**. Per aprire un notebook, fai clic sulla relativa scheda **Use (Utilizza)** e seleziona **Create copy (Crea copia)**.

# Funzionamento di Sequence-to-Sequence
<a name="seq-2-seq-howitworks"></a>

In genere, una rete neurale per la sequence-to-sequence modellazione è composta da alcuni livelli, tra cui: 
+ Un **livello di incorporamento**. In questo layer, la matrice di input, ossia token di input codificati in modo sparso (ad esempio, con codifica one-hot), viene mappata a un layer di caratteristiche dense. Ciò è necessario perché un vettore di caratteristiche ad alta dimensione è più in grado di codificare le informazioni relative a un particolare token (parola per corpora di testo) rispetto a un vettore semplice. one-hot-encoded È inoltre prassi standard inizializzare questo layer di incorporamento con un vettore di parole già addestrato come [FastText](https://fasttext.cc/)o [Glove](https://nlp.stanford.edu/projects/glove/) o inizializzarlo in modo casuale e apprendere i parametri durante l'allenamento. 
+ Un **livello codificatore**. Una volta che i token di input sono stati mappati in uno spazio caratteristico altamente dimensionale, la sequenza viene trasmessa a un layer codificatore per comprimere tutte le informazioni provenienti dal layer di integrazione dell'input (dell'intera sequenza) in un vettore caratteristico a lunghezza fissa. Di solito, un codificatore è costituito da reti di tipo RNN come memoria a lungo-breve termine (LSTM, Long Short Term Memory) o unità ricorrenti vincolare (GRU, Gated Recurrent Unit) (il [blog di Colah](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) spiega in modo approfondito la memoria LSTM). 
+ Un **livello decodificatore**. Il layer decodificatore acquisisce il vettore caratteristico codificato e produce la sequenza di output dei token. Inoltre, di solito questo layer è costruito con architetture RNN (LSTM e GRU). 

L'intero modello viene preparato congiuntamente per aumentare al massimo la possibilità di sequenza di destinazione considerata la sequenza di origine. Questo modello è stato introdotto per la prima volta da [Sutskever e altri](https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf) nel 2014. 

**Meccanismo di attenzione**. Lo svantaggio di un framework codificatore-decodificatore è che le prestazioni del modello diminuiscono mano a mano che la lunghezza della sequenza di origine aumenta; questo a causa del limite imposto alla quantità di informazioni che può contenere il vettore caratteristico codificato a lunghezza fissa. Per risolvere questo problema, nel 2015 Bahdanau e altri ha proposto il [meccanismo di attenzione](https://arxiv.org/pdf/1409.0473.pdf). In un meccanismo di attenzione, il decodificatore tenta di trovare la posizione in cui le informazioni più rilevanti potrebbero trovarsi nella sequenza del codificatore e le utilizza con le parole precedentemente decodificate per prevedere il successivo token nella sequenza. 

Per ulteriori dettagli, consulta il whitepaper [Effective Approaches to Attention-based Neural Machine Translation](https://arxiv.org/abs/1508.04025) di Luong e altri che spiega e semplifica i calcoli per i vari meccanismi di attenzione. Inoltre, il whitepaper [Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation](https://arxiv.org/abs/1609.08144) di Wu e altri descrive l'architettura di Google per la traduzione automatica, che si avvale di ignorare le connessioni tra i livelli codificatore e decodificatore.

# Sequence-to-Sequence Iperparametri
<a name="seq-2-seq-hyperparameters"></a>

La tabella seguente elenca gli iperparametri che puoi impostare durante l'allenamento con l'algoritmo Amazon SageMaker AI Sequence-to-Sequence (seq2seq).


| Nome parametro | Description | 
| --- | --- | 
| batch\$1size | Dimensioni del mini-batch per la discesa del gradiente. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 64 | 
| beam\$1size | Lunghezza del fascio per la relativa ricerca. Utilizzato durante l’addestramento per il calcolo di `bleu` e durante l'inferenza. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 5 | 
| bleu\$1sample\$1size | Numero di istanze da cui prelevare il set di dati di convalida per decodificare e calcolare il punteggio `bleu` durante l’addestramento. Imposta su -1 per utilizzare il set completo di convalida (se `bleu` viene scelto come `optimized_metric`). **Opzionale** Valori validi: numero intero Valore predefinito: 0 | 
| bucket\$1width | Restituisce i bucket (di origine, di destinazione) fino a (`max_seq_len_source`, `max_seq_len_target`). La parte più lunga dei dati utilizza passaggi di, `bucket_width` mentre la parte più corta utilizza passaggi ridimensionati in base al rapporto di lunghezza medio. target/source Se un lato raggiunge la sua lunghezza massima prima dell'altro, la larghezza dei bucket extra su quel lato viene fissata su quel lato di `max_len`. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 10 | 
| bucketing\$1enabled | Imposta su `false` per disattivare il bucketing, svolgere alla lunghezza massima. **Opzionale** Valori validi: `true` o `false` Valore predefinito: `true` | 
| checkpoint\$1frequency\$1num\$1batches | Checkpoint e valutazione ogni x batch. Questo iperparametro di checkpoint viene passato all'algoritmo seq2seq dell' SageMaker IA per l'arresto anticipato e il recupero del modello migliore. Il checkpoint dell'algoritmo viene eseguito localmente nel contenitore di addestramento dell'algoritmo e non è compatibile con il checkpoint AI. SageMaker L'algoritmo salva temporaneamente i checkpoint su un percorso locale e memorizza l'artefatto del modello migliore nel percorso di output del modello in S3 dopo l'interruzione del processo di addestramento. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 1000 | 
| checkpoint\$1threshold | Numero massimo del modello di checkpoint consentito per non migliorare in `optimized_metric` sul set di dati di convalida prima che l’addestramento venga arrestato. Questo iperparametro di checkpoint viene passato all'algoritmo seq2seq dell' SageMaker IA per l'arresto anticipato e il recupero del modello migliore. Il checkpoint dell'algoritmo viene eseguito localmente nel contenitore di addestramento dell'algoritmo e non è compatibile con il checkpoint AI. SageMaker L'algoritmo salva temporaneamente i checkpoint su un percorso locale e memorizza l'artefatto del modello migliore nel percorso di output del modello in S3 dopo l'interruzione del processo di addestramento. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 3 | 
| clip\$1gradient | Ritagliare i valori di gradiente assoluto maggiori di questo. Impostare su negativo per disattivare. **Opzionale** Valori validi: float. Valore predefinito: 1 | 
| cnn\$1activation\$1type | Il tipo di attivazione `cnn` da utilizzare. **Opzionale** Valori validi: stringa. Uno tra `glu`, `relu`, `softrelu`, `sigmoid` o `tanh`. Valore predefinito: `glu` | 
| cnn\$1hidden\$1dropout | Probabilità di dropout tra layer convoluzionali. **Opzionale** Valori validi: Float. Intervallo in [0,1]. Valore predefinito: 0 | 
| cnn\$1kernel\$1width\$1decoder | Larghezza kernel per il decodificatore `cnn`. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 5 | 
| cnn\$1kernel\$1width\$1encoder | Larghezza kernel per il codificatore `cnn`. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 3 | 
| cnn\$1num\$1hidden | Numero di unità nascoste `cnn` per codificatore e decodificatore. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 512 | 
| decoder\$1type | Tipo di decodificatore. **Opzionale** Valori validi: stringa. `rnn` o `cnn`. Valore predefinito: *rnn* | 
| embed\$1dropout\$1source | Probabilità di dropout per le integrazioni lato origine. **Opzionale** Valori validi: Float. Intervallo in [0,1]. Valore predefinito: 0 | 
| embed\$1dropout\$1target | Probabilità di dropout per le integrazioni lato destinazione. **Opzionale** Valori validi: Float. Intervallo in [0,1]. Valore predefinito: 0 | 
| encoder\$1type | Tipo di codificatore. L'architettura `rnn` è basata sul meccanismo di attenzione di Bahdanau e altri e l'architettura *cnn* si basa su Gehring e altri **Opzionale** Valori validi: stringa. `rnn` o `cnn`. Valore predefinito: `rnn` | 
| fixed\$1rate\$1lr\$1half\$1life | Half life per la velocità di apprendimento in termini di numero di checkpoint per i pianificatori `fixed_rate_`\$1. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 10 | 
| learning\$1rate | Velocità di apprendimento iniziale. **Opzionale** Valori validi: float. Valore predefinito: 0.0003 | 
| loss\$1type | Funzione di perdita per l'apprendimento. **Opzionale** Valori validi: stringa. `cross-entropy` Valore predefinito: `cross-entropy` | 
| lr\$1scheduler\$1type | Tipo di pianificatore della velocità di apprendimento. `plateau_reduce` indica una riduzione della velocità di apprendimento quando `optimized_metric` su livelli fissi di `validation_accuracy`. `inv_t` indica il decadimento temporale inverso. `learning_rate`/(1\$1`decay_rate`\$1t) **Opzionale** Valori validi: stringa. Uno tra `plateau_reduce`, `fixed_rate_inv_t` o `fixed_rate_inv_sqrt_t`. Valore predefinito: `plateau_reduce` | 
| max\$1num\$1batches | Numero massimo di updates/batches da elaborare. -1 per infinito. **Opzionale** Valori validi: numero intero Valore predefinito: -1 | 
| max\$1num\$1epochs | Numero massimo di epoch da trasmettere tramite i dati di addestramento prima che il fitting venga arrestato. L’addestramento continua fino a questo numero di epoch anche se la precisione di convalida non migliora trasmettendo questo parametro. Ignorato se non trasmesso. **Opzionale** Valori validi: numeri interi positivi minori o uguali a max\$1num\$1epochs. Valore predefinito: nessuno | 
| max\$1seq\$1len\$1source | Lunghezza massima per la sequenza di origine. Le sequenze più lunghe verranno troncate a questa lunghezza. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 100  | 
| max\$1seq\$1len\$1target | Lunghezza massima per la sequenza di destinazione. Le sequenze più lunghe verranno troncate a questa lunghezza. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 100 | 
| min\$1num\$1epochs | Numero minimo di epoche (Unix epochs) che l’addestramento deve eseguire prima di essere arrestato dalle condizioni `early_stopping`. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 0 | 
| momentum | Costante di momento utilizzata per `sgd`. Non trasmettere questo parametro se usi `adam` o `rmsprop`. **Opzionale** Valori validi: float. Valore predefinito: nessuno | 
| num\$1embed\$1source | Dimensioni di incorporamento per i token di origine. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 512 | 
| num\$1embed\$1target | Dimensioni di integrazione per i token di destinazione. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 512 | 
| num\$1layers\$1decoder | Numero di livelli per decodificatore *rnn* o *cnn*. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 1 | 
| num\$1layers\$1encoder | Numero di livelli per codificatore `rnn` o `cnn`. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 1 | 
| optimized\$1metric | Parametri per l'ottimizzazione con arresto precoce. **Opzionale** Valori validi: stringa. Uno tra `perplexity`, `accuracy` o `bleu`. Valore predefinito: `perplexity` | 
| optimizer\$1type | Ottimizzatore da cui scegliere. **Opzionale** Valori validi: stringa. Uno tra `adam`, `sgd` o `rmsprop`. Valore predefinito: `adam` | 
| plateau\$1reduce\$1lr\$1factor | Fattore con cui moltiplicare la velocità di apprendimento (per `plateau_reduce`). **Opzionale** Valori validi: float. Valore predefinito: 0.5 | 
| plateau\$1reduce\$1lr\$1threshold | Per il pianificatore `plateau_reduce`, moltiplicare la velocità di apprendimento con il fattore di riduzione se `optimized_metric` non è migliorato per i vari checkpoint. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 3 | 
| rnn\$1attention\$1in\$1upper\$1layers | Trasmissione dell'attenzione ai livelli superiori di *rnn*, come il documento Google NMT. Applicabile solo se viene utilizzato più di un layer. **Opzionale** Valori validi: booleani (`true` o `false`) Valore predefinito: `true` | 
| rnn\$1attention\$1num\$1hidden | Numero di unità nascoste per i livelli di attenzione. Valore predefinito:`rnn_num_hidden`. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: `rnn_num_hidden` | 
| rnn\$1attention\$1type | Modello di attenzione per codificatori. `mlp` si riferisce a concat e bilinear si riferisce al concetto generale del documento di Luong e altri. **Opzionale** Valori validi: stringa. Uno tra `dot`, `fixed`, `mlp` o `bilinear`. Valore predefinito: `mlp` | 
| rnn\$1cell\$1type | Tipo specifico di architettura `rnn`. **Opzionale** Valori validi: stringa. `lstm` o `gru`. Valore predefinito: `lstm` | 
| rnn\$1decoder\$1state\$1init | Modalità di inizializzazione degli stati del decodificatore `rnn` dai codificatori. **Opzionale** Valori validi: stringa. Uno tra `last`, `avg` o `zero`. Valore predefinito: `last` | 
| rnn\$1first\$1residual\$1layer | Primo livello *rnn* ad avere una connessione residua, applicabile solo se il numero di livelli nel codificatore o nel decodificatore è superiore a 1. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 2 | 
| rnn\$1num\$1hidden | Numero di unità nascoste *rnn* per codificatore e decodificatore. Deve essere un multiplo di 2 in quanto per impostazione predefinita l'algoritmo utilizza la tecnica Long Term Short Term Memory (LSTM) bidirezionale. **Opzionale** Valori validi: numeri interi pari positivi Valore predefinito: 1024 | 
| rnn\$1residual\$1connections | Aggiunta di connessione residua alla rete *rnn* nello stack. Il numero di layer deve essere superiore a 1. **Opzionale** Valori validi: booleani (`true` o `false`) Valore predefinito: `false` | 
| rnn\$1decoder\$1hidden\$1dropout | Probabilità di dropout per lo stato nascosto che combina il contesto con lo stato nascosto *rnn* nel decodificatore. **Opzionale** Valori validi: Float. Intervallo in [0,1]. Valore predefinito: 0 | 
| training\$1metric | Parametri di tracciamento dell’addestramento sui dati di convalida. **Opzionale** Valori validi: stringa. `perplexity` o `accuracy`. Valore predefinito: `perplexity` | 
| weight\$1decay | Decadimento del peso costante. **Opzionale** Valori validi: float. Valore predefinito: 0 | 
| weight\$1init\$1scale | Dimensionamento dell'inizializzazione del peso (per l'inizializzazione `uniform` e `xavier`).  **Opzionale** Valori validi: float. Valore predefinito: 2.34 | 
| weight\$1init\$1type | Tipo di inizializzazione del peso.  **Opzionale** Valori validi: stringa. `uniform` o `xavier`. Valore predefinito: `xavier` | 
| xavier\$1factor\$1type | Tipo di fattore xavier. **Opzionale** Valori validi: stringa. Uno tra `in`, `out` o `avg`. Valore predefinito: `in` | 

# Ottimizza un Sequence-to-Sequence modello
<a name="seq-2-seq-tuning"></a>

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).

## Metriche calcolate dall'algoritmo Sequence-to-Sequence
<a name="seq-2-seq-metrics"></a>

L'algoritmo sequence to sequence restituisce tre parametri che vengono calcolati durante l’addestramento. Scegline uno come obiettivo da ottimizzare durante l'ottimizzazione dei valori degli iperparametri.


| Nome parametro | Description | Direzione dell'ottimizzazione | 
| --- | --- | --- | 
| validation:accuracy |  Accuratezza calcolata su un set di dati di convalida.  |  Massimizza  | 
| validation:bleu |  Punteggio [Bleu](https://en.wikipedia.org/wiki/BLEU) calcolato su un set di dati di convalida. Poiché il calcolo BLEU è costoso, puoi scegliere di eseguirlo su un sottocampione casuale del set di dati di convalida per accelerare il processo di addestramento in generale. Utilizza il parametro `bleu_sample_size` per specificare il sottocampione.  |  Massimizza  | 
| validation:perplexity |  [Perplexity](https://en.wikipedia.org/wiki/Perplexity), è una funzione di perdita calcolata su un set di dati di convalida. Perplexity misura l'entropia incrociata tra un esempio empirico e la distribuzione predetta da un modello e quindi fornisce una misura che indica il livello di attendibilità delle predizioni dei valori di esempio, i modelli in grado di predire un esempio hanno un valore di Perplexity basso.  |  Minimizza  | 

## Iperparametri regolabili Sequence-to-Sequence
<a name="seq-2-seq-tunable-hyperparameters"></a>

È possibile ottimizzare i seguenti iperparametri per l'algoritmo SageMaker AI Sequence to Sequence. Gli iperparametri che hanno il maggiore impatto sui parametri obiettivo sequence to sequence sono: `batch_size`, `optimizer_type`, `learning_rate`, `num_layers_encoder` e `num_layers_decoder`.


| Nome parametro | Tipo parametro | Intervalli consigliati | 
| --- | --- | --- | 
| num\$1layers\$1encoder |  IntegerParameterRange  |  [1-10]  | 
| num\$1layers\$1decoder |  IntegerParameterRange  |  [1-10]  | 
| batch\$1size |  CategoricalParameterRange  |  [16,32,64,128,256,512,1024,2048]  | 
| optimizer\$1type |  CategoricalParameterRange  |  ['adam', 'sgd', 'rmsprop']  | 
| weight\$1init\$1type |  CategoricalParameterRange  |  ['xavier', 'uniform']  | 
| weight\$1init\$1scale |  ContinuousParameterRange  |  Per il tipo xavier:: 2.0, MinValue MaxValue: 3.0 Per il tipo uniforme:: -1.0, MinValue: 1.0 MaxValue  | 
| learning\$1rate |  ContinuousParameterRange  |  MinValue: 0,0005, 0,2 MaxValue  | 
| weight\$1decay |  ContinuousParameterRange  |  MinValue: 0,0, 0,1 MaxValue  | 
| momentum |  ContinuousParameterRange  |  MinValue: 0,5, MaxValue 0,9  | 
| clip\$1gradient |  ContinuousParameterRange  |  MinValue: 1,0, MaxValue: 5,0  | 
| rnn\$1num\$1hidden |  CategoricalParameterRange  |  Applicabile solo alle reti neurali ricorrenti ()RNNs. [128,256,512,1024,2048]   | 
| cnn\$1num\$1hidden |  CategoricalParameterRange  |  Applicabile solo alle reti neurali convoluzionali (). CNNs [128,256,512,1024,2048]   | 
| num\$1embed\$1source |  IntegerParameterRange  |  [256-512]  | 
| num\$1embed\$1target |  IntegerParameterRange  |  [256-512]  | 
| embed\$1dropout\$1source |  ContinuousParameterRange  |  MinValue: 0,0, 0,5 MaxValue  | 
| embed\$1dropout\$1target |  ContinuousParameterRange  |  MinValue: 0,0, MaxValue 0,5  | 
| rnn\$1decoder\$1hidden\$1dropout |  ContinuousParameterRange  |  MinValue: 0,0, MaxValue 0,5  | 
| cnn\$1hidden\$1dropout |  ContinuousParameterRange  |  MinValue: 0,0, MaxValue 0,5  | 
| lr\$1scheduler\$1type |  CategoricalParameterRange  |  ['plateau\$1reduce', 'fixed\$1rate\$1inv\$1t', 'fixed\$1rate\$1inv\$1sqrt\$1t']  | 
| plateau\$1reduce\$1lr\$1factor |  ContinuousParameterRange  |  MinValue: 0,1, MaxValue 0,5  | 
| plateau\$1reduce\$1lr\$1threshold |  IntegerParameterRange  |  [1-5]  | 
| fixed\$1rate\$1lr\$1half\$1life |  IntegerParameterRange  |  [10-30]  | 

# Classificazione del testo - TensorFlow
<a name="text-classification-tensorflow"></a>

[L'algoritmo Amazon SageMaker AI Text Classification è un TensorFlow algoritmo di apprendimento supervisionato che supporta il trasferimento dell'apprendimento con molti modelli preaddestrati dall'TensorFlow Hub.](https://tfhub.dev/) Usa il trasferimento dell’apprendimento per ottimizzare uno dei modelli preaddestrati disponibili sul tuo set di dati, anche se non è disponibile una grande quantità di dati di testo. L'algoritmo di classificazione del testo prende una stringa di testo come input e restituisce una probabilità per ogni etichetta di classe. I set di dati di addestramento devono essere in formato CSV. Questa pagina include informazioni sui consigli sulle istanze di Amazon EC2 e notebook di esempio per la classificazione del testo -. TensorFlow

**Topics**
+ [Come usare l'algoritmo SageMaker AI Text Classification - TensorFlow](text-classification-tensorflow-how-to-use.md)
+ [Interfaccia di input e output per l'algoritmo Text Classification TensorFlow](text-classification-tensorflow-inputoutput.md)
+ [Raccomandazione dell'istanza Amazon EC2 per l'algoritmo di classificazione del testo TensorFlow](#text-classification-tensorflow-instances)
+ [Classificazione del testo: TensorFlow taccuini di esempio](#text-classification-tensorflow-sample-notebooks)
+ [Come TensorFlow funziona la classificazione del testo](text-classification-tensorflow-HowItWorks.md)
+ [TensorFlow Modelli Hub](text-classification-tensorflow-Models.md)
+ [Classificazione del testo - TensorFlow Iperparametri](text-classification-tensorflow-Hyperparameter.md)
+ [Ottimizzazione di una classificazione del testo - modello TensorFlow](text-classification-tensorflow-tuning.md)

# Come usare l'algoritmo SageMaker AI Text Classification - TensorFlow
<a name="text-classification-tensorflow-how-to-use"></a>

Puoi utilizzare Text Classification TensorFlow , come algoritmo integrato di Amazon SageMaker AI. La sezione seguente descrive come utilizzare la classificazione del testo, TensorFlow con SageMaker AI Python SDK. Per informazioni su come utilizzare la classificazione del testo, TensorFlow dall'interfaccia utente di Amazon SageMaker Studio Classic, consulta[SageMaker JumpStart modelli preaddestrati](studio-jumpstart.md).

L' TensorFlow algoritmo Text Classification supporta l'apprendimento tramite trasferimento utilizzando uno qualsiasi dei TensorFlow modelli preaddestrati compatibili. Per un elenco di tutti i modelli preaddestrati disponibili, consulta [TensorFlow Modelli Hub](text-classification-tensorflow-Models.md). Ogni modello preaddestrato ne ha `model_id` univoco. L'esempio seguente utilizza BERT Base Uncased (`model_id`:`tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2`) per ottimizzare un set di dati personalizzato. I modelli preaddestrati sono tutti pre-scaricati dall' TensorFlow Hub e archiviati in bucket Amazon S3 in modo che i lavori di formazione possano essere eseguiti in isolamento di rete. Usa questi artefatti di addestramento basati su modelli pregenerati per costruire un AI Estimator. SageMaker 

Innanzitutto, recupera l'URI dell'immagine Docker, l'URI dello script di addestramento e l'URI del modello preaddestrato. Quindi, modifica gli iperparametri per adattarli al tuo caso. Puoi vedere un dizionario Python di tutti gli iperparametri disponibili e i loro valori predefiniti con `hyperparameters.retrieve_default`. Per ulteriori informazioni, consulta [Classificazione del testo - TensorFlow Iperparametri](text-classification-tensorflow-Hyperparameter.md). Usa questi valori per costruire un AI Estimator. SageMaker 

**Nota**  
I valori predefiniti degli iperparametri sono diversi per i diversi modelli. Ad esempio, per i modelli più grandi, la dimensione del batch predefinita è inferiore. 

Questo esempio utilizza il set di dati [https://www.tensorflow.org/datasets/catalog/glue#gluesst2](https://www.tensorflow.org/datasets/catalog/glue#gluesst2), che contiene recensioni di film positive e negative. Abbiamo pre-scaricato il set di dati e lo abbiamo reso disponibile con Amazon S3. Per ottimizzare il tuo modello, chiama `.fit` utilizzando la posizione Amazon S3 del tuo set di dati di addestramento. Qualsiasi bucket S3 utilizzato in un notebook deve trovarsi nella stessa AWS regione dell'istanza del notebook che vi accede.

```
from sagemaker import image_uris, model_uris, script_uris, hyperparameters
from sagemaker.estimator import Estimator

model_id, model_version = "tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2", "*"
training_instance_type = "ml.p3.2xlarge"

# Retrieve the Docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)

# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")

# Retrieve the pretrained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

# Retrieve the default hyperparameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)

# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"

# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/SST2/"

training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"

output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tc-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"

# Create an Estimator instance
tf_tc_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
)

# Launch a training job
tf_tc_estimator.fit({"training": training_dataset_s3_path}, logs=True)
```

Per ulteriori informazioni su come utilizzare l' TensorFlowalgoritmo di classificazione del SageMaker testo per trasferire l'apprendimento su un set di dati personalizzato, consulta il taccuino [Introduzione a JumpStart -](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb) Text Classification.

# Interfaccia di input e output per l'algoritmo Text Classification TensorFlow
<a name="text-classification-tensorflow-inputoutput"></a>

Ciascuno dei modelli preaddestrati elencati in TensorFlow Hub Models può essere ottimizzato per qualsiasi set di dati composto da frasi di testo con un numero qualsiasi di classi. Il modello preaddestrato collega un livello di classificazione al modello Incorporamento di testo e inizializza i parametri del livello su valori casuali. La dimensione di output del livello di classificazione viene determinata in base al numero di classi rilevate nei dati di input. 

Fai attenzione a come formattare i dati di allenamento da inserire nel modello Text Classification. TensorFlow 
+ **Formato di input dei dati di addestramento:** una directory contenente un file `data.csv`. Ogni riga della prima colonna deve avere etichette di classe intere comprese tra 0 e il numero di classi. Ogni riga della seconda colonna deve contenere i dati di testo corrispondenti.

Di seguito è riportato un esempio di un file CSV di input. Tieni presente che il file non deve avere alcuna intestazione. Il file deve essere ospitato in un bucket Amazon S3 con un percorso simile al seguente: `s3://bucket_name/input_directory/`. Tieni presente che il simbolo `/` finale è obbligatorio.

```
|   |  |
|---|---|
|0 |hide new secretions from the parental units|
|0 |contains no wit , only labored gags|
|1 |that loves its characters and communicates something rather beautiful about human nature|
|...|...|
```

## Addestramento incrementale
<a name="text-classification-tensorflow-incremental-training"></a>

È possibile avviare l'addestramento di un nuovo modello utilizzando gli artefatti di un modello precedentemente addestrato con l'intelligenza artificiale. SageMaker L'addestramento incrementale consente di risparmiare tempo quando vuoi sottoporre ad addestramento un nuovo modello con dati uguali o simili.

**Nota**  
Puoi creare un modello di classificazione testuale SageMaker AI solo con un altro TensorFlow modello di classificazione del testo addestrato all' SageMaker intelligenza artificiale. TensorFlow 

Puoi utilizzare qualsiasi set di dati per l'addestramento incrementale, purché il set di classi rimanga lo stesso. La fase di addestramento incrementale è simile alla fase di ottimizzazione, ma invece di iniziare con un modello preaddestrato, si inizia con un modello ottimizzato esistente. 

Per ulteriori informazioni sull'utilizzo dell'addestramento incrementale con l' TensorFlow algoritmo SageMaker AI Text Classification, consulta il quaderno di esempio [Introduzione a JumpStart - Text Classification](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).

## Inferenza con l'algoritmo di classificazione del testo TensorFlow
<a name="text-classification-tensorflow-inference"></a>

Puoi ospitare il modello perfezionato che risulta dal tuo corso di formazione sulla classificazione del TensorFlow testo per l'inferenza. Qualsiasi formato di testo non elaborato per l'inferenza deve essere di tipo di contenuto `application/x-text`.

L'esecuzione dell'inferenza produce valori di probabilità, etichette di classe per tutte le classi e l'etichetta prevista corrispondente all'indice di classe con la probabilità più alta codificato in formato JSON. Il TensorFlow modello Text Classification elabora una singola stringa per richiesta e restituisce solo una riga. Di seguito è riportato un esempio di risposta in formato JSON:

```
accept: application/json;verbose

{"probabilities": [prob_0, prob_1, prob_2, ...],
"labels": [label_0, label_1, label_2, ...],
"predicted_label": predicted_label}
```

Se `accept` è impostato su `application/json`, il modello emette solo le probabilità. 

## Raccomandazione dell'istanza Amazon EC2 per l'algoritmo di classificazione del testo TensorFlow
<a name="text-classification-tensorflow-instances"></a>

L' TensorFlow algoritmo Text Classification supporta tutte le istanze di CPU e GPU per l'addestramento, tra cui:
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`
+ `ml.g4dn.xlarge`
+ `ml.g4dn.16.xlarge`
+ `ml.g5.xlarge`
+ `ml.g5.48xlarge`

Ti consigliamo le istanze GPU con più memoria per l’addestramento con batch di grandi dimensioni. Per l'inferenza puoi utilizzare sia le istanze CPU (come M5) che quelle GPU (P2, P3, G4dn o G5). Per un elenco completo delle istanze di SageMaker formazione e inferenza AWS nelle diverse regioni, consulta [Amazon SageMaker ](https://aws.amazon.com/sagemaker/pricing/) Pricing.

## Classificazione del testo: TensorFlow taccuini di esempio
<a name="text-classification-tensorflow-sample-notebooks"></a>

Per ulteriori informazioni su come utilizzare l' TensorFlow algoritmo SageMaker AI Text Classification per trasferire l'apprendimento su un set di dati personalizzato, consulta il taccuino [Introduzione a JumpStart -](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb) Text Classification.

Per istruzioni su come creare e accedere alle istanze del notebook Jupyter da utilizzare per eseguire l'esempio in AI, consulta. SageMaker [Istanze SageMaker per notebook Amazon](nbi.md) Dopo aver creato un'istanza di notebook e averla aperta, seleziona la scheda **Esempi SageMaker AI** per visualizzare un elenco di tutti gli esempi di IA. SageMaker Per aprire un notebook, seleziona la relativa scheda **Utilizza** e scegli **Crea copia**.

# Come TensorFlow funziona la classificazione del testo
<a name="text-classification-tensorflow-HowItWorks"></a>

L' TensorFlow algoritmo Text Classification - prende il testo così come lo classifica in una delle etichette della classe di output. Le reti di deep learning come [BERT](https://arxiv.org/pdf/1810.04805.pdf) sono estremamente accurate per la classificazione del testo. Esistono anche reti di deep learning addestrate su set di dati di testo di grandi dimensioni, come ad esempio TextNet, che contiene più di 11 milioni di testi con circa 11.000 categorie. Dopo che una rete è stata addestrata con TextNet i dati, è possibile perfezionare la rete su un set di dati con particolare attenzione per eseguire attività di classificazione del testo più specifiche. L' TensorFlow algoritmo Amazon SageMaker AI Text Classification supporta il transfer learning su molti modelli preaddestrati disponibili nell' TensorFlow Hub.

In base al numero di etichette delle classi nei dati di allenamento, al TensorFlow modello preformato di tua scelta viene associato un livello di classificazione del testo. Il livello di classificazione è costituito da uno livello dropout, un livello denso e un livello completamente connesso con regolarizzatore norma 2 inizializzato con pesi casuali. Puoi modificare i valori degli iperparametri per la percentuale di dropout del livello di dropout e il fattore di regolarizzazione L2 per il livello denso.

Puoi ottimizzare l'intera rete (incluso il modello preaddestrato) o solo il livello di classificazione superiore in base ai nuovi dati di addestramento. Con questo metodo di trasferimento dell'addestramento, puoi eseguire l’addestramento di set di dati più piccoli.

# TensorFlow Modelli Hub
<a name="text-classification-tensorflow-Models"></a>

I seguenti modelli preaddestrati sono disponibili per l'uso per il trasferimento dell'apprendimento con l' TensorFlow algoritmo di classificazione del testo. 

I seguenti modelli variano in modo significativo in termini di dimensioni, numero di parametri del modello, tempo di addestramento e latenza di inferenza per un determinato set di dati. Il modello migliore per il tuo caso d'uso dipende dalla complessità del set di dati di ottimizzazione e dai requisiti richiesti in termini di tempo di addestramento, latenza di inferenza o precisione del modello.


| Nome modello | `model_id` | Origine | 
| --- | --- | --- | 
|  BERT Base Uncased  | `tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3) | 
|  BERT Base Cased  | `tensorflow-tc-bert-en-cased-L-12-H-768-A-12-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3) | 
|  BERT Base Multilingual Cased  | `tensorflow-tc-bert-multi-cased-L-12-H-768-A-12-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3) | 
|  Small BERT L-2\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-128-A-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1) | 
|  Small BERT L-2\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-256-A-4` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1) | 
|  Small BERT L-2\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-512-A-8` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1) | 
|  Small BERT L-2\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-768-A-12` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1) | 
|  Small BERT L-4\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-128-A-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1) | 
|  Small BERT L-4\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-256-A-4` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1) | 
|  Small BERT L-4\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-512-A-8` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1) | 
|  Small BERT L-4\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-768-A-12` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1) | 
|  Small BERT L-6\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-128-A-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1) | 
|  Small BERT L-6\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-256-A-4` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1) | 
|  Small BERT L-6\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-512-A-8` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1) | 
|  Small BERT L-6\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-768-A-12` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1) | 
|  Small BERT L-8\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-128-A-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1) | 
|  Small BERT L-8\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-256-A-4` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1) | 
|  Small BERT L-8\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-512-A-8` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1) | 
|  Small BERT L-8\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-768-A-12` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1) | 
|  Small BERT L-10\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-128-A-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1) | 
|  Small BERT L-10\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-256-A-4` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1) | 
|  Small BERT L-10\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-512-A-8` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1) | 
|  Small BERT L-10\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-768-A-12` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1) | 
|  Small BERT L-12\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-128-A-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1) | 
|  Small BERT L-12\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-256-A-4` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1) | 
|  Small BERT L-12\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-512-A-8` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1) | 
|  Small BERT L-12\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-768-A-12` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1) | 
|  BERT Large Uncased  | `tensorflow-tc-bert-en-uncased-L-24-H-1024-A-16-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/3) | 
|  BERT Large Cased  | `tensorflow-tc-bert-en-cased-L-24-H-1024-A-16-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/bert_en_cased_L-24_H-1024_A-16/3) | 
|  BERT Large Uncased Whole Word Masking  | `tensorflow-tc-bert-en-wwm-uncased-L-24-H-1024-A-16-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/bert_en_wwm_uncased_L-24_H-1024_A-16/3) | 
|  BERT Large Cased Whole Word Masking  | `tensorflow-tc-bert-en-wwm-cased-L-24-H-1024-A-16-2` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/bert_en_wwm_cased_L-24_H-1024_A-16/3) | 
|  ALBERT Base  | `tensorflow-tc-albert-en-base` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/albert_en_base/2) | 
|  ELECTRA Small\$1\$1  | `tensorflow-tc-electra-small-1` | [TensorFlow Collegamento all'hub](https://tfhub.dev/google/electra_small/2) | 
|  ELECTRA Base  | `tensorflow-tc-electra-base-1` | [TensorFlow Collegamento all'hub](https://tfhub.dev/google/electra_base/2) | 
|  BERT Base Wikipedia e BooksCorpus  | `tensorflow-tc-experts-bert-wiki-books-1` | [TensorFlow Collegamento all'hub](https://tfhub.dev/google/experts/bert/wiki_books/2) | 
|  BERT Base MEDLINE/ PubMed  | `tensorflow-tc-experts-bert-pubmed-1` | [TensorFlow Collegamento all'hub](https://tfhub.dev/google/experts/bert/pubmed/2) | 
|  Talking Heads Base  | `tensorflow-tc-talking-heads-base` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1) | 
|  Talking Heads Large  | `tensorflow-tc-talking-heads-large` | [TensorFlow Collegamento all'hub](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_large/1) | 

# Classificazione del testo - TensorFlow Iperparametri
<a name="text-classification-tensorflow-Hyperparameter"></a>

Gli iperparametri sono parametri impostati prima che un modello di machine learning inizi l'apprendimento. I seguenti iperparametri sono supportati dall' TensorFlow algoritmo Object Detection integrato di Amazon SageMaker AI. Per ulteriori informazioni sull'ottimizzazione iperparametri, consulta [Ottimizzazione di una classificazione del testo - modello TensorFlow](text-classification-tensorflow-tuning.md). 


| Nome parametro | Description | 
| --- | --- | 
| batch\$1size |  Le dimensioni del batch per l’addestramento. Per l'addestramento su istanze con più istanze GPUs, questa dimensione del batch viene utilizzata in tutto. GPUs  Valori validi: numeri interi positivi. Valore predefinito: `32`.  | 
| beta\$11 |  La beta1 per gli ottimizzatori `"adam"` e `"adamw"`. Rappresenta la percentuale di decadimento esponenziale per stime di primo momento. Ignorato per altri ottimizzatori. Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `0.9`.  | 
| beta\$12 |  La beta2 per gli ottimizzatori `"adam"` e `"adamw"`. Rappresenta la percentuale di decadimento esponenziale per stime di secondo momento. Ignorato per altri ottimizzatori. Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `0.999`.  | 
| dropout\$1rate | La percentuale di dropout per il livello di dropout nel livello di classificazione superiore. Usato solo quando `reinitialize_top_layer` è impostato su `"True"`. Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `0.2` | 
| early\$1stopping |  Imposta su `"True"` per utilizzare la logica di arresto precoce durante l’addestramento. Se `"False"`, l'arresto anticipato non viene utilizzato. Valori validi: stringa: (`"True"` o `"False"`). Valore predefinito: `"False"`.  | 
| early\$1stopping\$1min\$1delta | La modifica minima necessaria per qualificarsi come miglioramento. Una variazione assoluta inferiore al valore di early\$1stopping\$1min\$1delta non si qualifica come miglioramento. Usato solo quando early\$1stopping è impostato su "True".Valori validi: float, intervallo: [`0.0`, `1.0`].Valore predefinito: `0.0`. | 
| early\$1stopping\$1patience |  Il numero di epoche in cui continuare l’addestramento senza alcun miglioramento. Usato solo quando `early_stopping` è impostato su `"True"`. Valori validi: numeri interi positivi. Valore predefinito: `5`.  | 
| epochs |  Il numero di epoche (Unix epochs) di addestramento. Valori validi: numeri interi positivi. Valore predefinito: `10`.  | 
| epsilon |  L'epsilon per gli ottimizzatori `"adam"`, `"rmsprop"`, `"adadelta"` e `"adagrad"`. Di solito è impostato su un piccolo valore per evitare la divisione per 0. Ignorato per altri ottimizzatori. Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `1e-7`.  | 
| initial\$1accumulator\$1value |  Il valore iniziale per gli accumulatori o i valori di momento per parametro per l'ottimizzatore `"adagrad"`. Ignorato per altri ottimizzatori. Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `0.0001`.  | 
| learning\$1rate | La velocità di apprendimento dell'ottimizzatore. Valori validi: float, intervallo: [`0.0`, `1.0`].Valore predefinito: `0.001`. | 
| momentum |  Il momento per gli ottimizzatori `"sgd"` e `"nesterov"`. Ignorato per altri ottimizzatori. Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `0.9`.  | 
| optimizer |  Il tipo di ottimizzazione. Per ulteriori informazioni, consulta [Ottimizzatori](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers) nella TensorFlow documentazione. Valori validi: stringa, uno dei seguenti valori: (`"adamw"`, `"adam"`, `"sgd"`, `"nesterov"`, `"rmsprop"`,` "adagrad"`, `"adadelta"`). Valore predefinito: `"adam"`.  | 
| regularizers\$1l2 |  Il fattore di regolarizzazione L2 per il livello denso nel livello di classificazione. Usato solo quando `reinitialize_top_layer` è impostato su `"True"`. Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `0.0001`.  | 
| reinitialize\$1top\$1layer |  Se impostato su `"Auto"`, i parametri del livello di classificazione superiore vengono reinizializzati durante l’ottimizzazione. Per l'addestramento incrementale, i parametri del livello di classificazione superiore non vengono reinizializzati a meno che non siano impostati su `"True"`. Valori validi: stringa, uno dei seguenti valori: (`"Auto"`, `"True"` o `"False"`). Valore predefinito: `"Auto"`.  | 
| rho |  Il fattore di sconto per il gradiente degli ottimizzatori `"adadelta"` e `"rmsprop"`. Ignorato per altri ottimizzatori.  Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `0.95`.  | 
| train\$1only\$1on\$1top\$1layer |  Se `"True"`, solo i parametri del livello di classificazione superiore vengono ottimizzati. Se `"False"`, tutti i parametri del modello vengono ottimizzati. Valori validi: stringa: (`"True"` o `"False"`). Valore predefinito: `"False"`.  | 
| validation\$1split\$1ratio |  La frazione di dati di addestramento da dividere casualmente per creare dati di convalida. Utilizzata solo se i dati di convalida non vengono forniti attraverso il canale `validation`. Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `0.2`.  | 
| warmup\$1steps\$1fraction |  La frazione del numero totale di fasi di aggiornamento del gradiente, in cui il tasso di apprendimento aumenta da 0 al tasso di apprendimento iniziale durante il riscaldamento. Utilizzato solo con l'ottimizzatore `adamw`. Valori validi: float, intervallo: [`0.0`, `1.0`]. Valore predefinito: `0.1`.  | 

# Ottimizzazione di una classificazione del testo - modello TensorFlow
<a name="text-classification-tensorflow-tuning"></a>

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).

## Metriche calcolate dall'algoritmo Text Classification TensorFlow
<a name="text-classification-tensorflow-metrics"></a>

Fate riferimento alla tabella seguente per scoprire quali metriche vengono calcolate dall'algoritmo di classificazione del testo. TensorFlow 


| Nome parametro | Description | Direzione dell'ottimizzazione | Modello regex | 
| --- | --- | --- | --- | 
| validation:accuracy | Il rapporto tra il numero di previsioni corrette e il numero totale di previsioni effettuate. | Massimizza | `val_accuracy=([0-9\\.]+)` | 

## Classificazione del testo regolabile: iperparametri TensorFlow
<a name="text-classification-tensorflow-tunable-hyperparameters"></a>

Ottimizza un modello di classificazione del testo con i seguenti iperparametri. Gli iperparametri che hanno il maggiore impatto sui parametri obiettivo di classificazione del testo sono: `batch_size`, `learning_rate` e `optimizer`. Modifica gli iperparametri correlati all'ottimizzatore, come ad esempio `momentum`, `regularizers_l2`, `beta_1`, `beta_2` e `eps` in base all’`optimizer` selezionato. Ad esempio usa `beta_1` e `beta_2` solo quando `adamw` o `adam` è `optimizer`.

Per ulteriori informazioni su quali iperparametri vengono utilizzati in ogni `optimizer`, consulta [Classificazione del testo - TensorFlow Iperparametri](text-classification-tensorflow-Hyperparameter.md).


| Nome parametro | Tipo parametro | Intervalli consigliati | 
| --- | --- | --- | 
| batch\$1size | IntegerParameterRanges | MinValue: 4, MaxValue: 128 | 
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6, MaxValue: 0,99 | 
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6,: 0,99 MaxValue | 
| eps | ContinuousParameterRanges | MinValue: 1e-8,: 1,0 MaxValue | 
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6,: 0,5 MaxValue | 
| momentum | ContinuousParameterRanges | MinValue: 0,0, 0,99 MaxValue | 
| optimizer | CategoricalParameterRanges | ['adamw', 'adam', 'sgd', 'rmsprop', 'nesterov', 'adagrad', 'adadelta'] | 
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0,0, 0,99 MaxValue | 
| train\$1only\$1on\$1top\$1layer | CategoricalParameterRanges | ['True', 'False'] |