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à.
# Algoritmo Object2Vec
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
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
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
+ [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
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
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
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
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
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
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
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
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
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
È 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
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
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
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 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
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
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
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
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
Content-type: application/json; infer\$1max\$1seqlens=,
Dove e 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=,
Dove e 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
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`.