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

# Formati di dati comuni per l’inferenza
<a name="cdf-inference"></a>

Gli algoritmi di SageMaker intelligenza artificiale di Amazon accettano e producono diversi tipi MIME per i payload HTTP utilizzati per recuperare previsioni online e in mini-batch. Puoi utilizzare più AWS servizi per trasformare o preelaborare i record prima di eseguire l'inferenza. Come minimo, devi convertire i dati per quanto segue:
+ Serializzazione richiesta di inferenza (gestita da te) 
+ Deserializzazione richiesta di inferenza (gestita dall'algoritmo) 
+ Serializzazione risposta di inferenza (gestita dall'algoritmo) 
+ Deserializzazione risposta di inferenza (gestita da te) 

**Topics**
+ [Conversione dei dati per la serializzazione delle richieste di inferenza](#ir-serialization)
+ [Conversione dei dati per la deserializzazione delle risposte di inferenza](#ir-deserialization)
+ [Formati di richiesta comuni per tutti gli algoritmi](#common-in-formats)
+ [Utilizzo della trasformazione in batch con gli algoritmi integrati](#cm-batch)

## Conversione dei dati per la serializzazione delle richieste di inferenza
<a name="ir-serialization"></a>

Le opzioni relative SageMaker ai tipi di contenuto per le richieste di inferenza dell'algoritmo di Amazon AI includono: `text/csv``application/json`, e`application/x-recordio-protobuf`. Gli algoritmi che non supportano tutti questi tipi possono supportarne altri. XGBoost, ad esempio, supporta solo i supporti `text/csv` di questo elenco, ma supporta `text/libsvm` anche.

Per `text/csv` il valore dell'argomento corpo a `invoke_endpoint` deve essere una stringa con delle virgole che separano i valori di ogni funzionalità. Ad esempio, un record per un modello con quattro funzionalità potrebbe essere simile a `1.5,16.0,14,23.0`. Qualsiasi trasformazione eseguita sui dati dell'addestramento deve essere eseguita sui dati prima di ottenere l'inferenza. L'ordine delle funzionalità è rilevante e non deve essere modificato. 

`application/json` è molto più flessibile e offre diversi formati possibili che gli sviluppatori possono utilizzare nelle loro applicazioni. A un livello elevato, in JavaScript, il payload potrebbe essere simile al seguente: 

```
let request = {
  // Instances might contain multiple rows that predictions are sought for.
  "instances": [
    {
      // Request and algorithm specific inference parameters.
      "configuration": {},
      // Data in the specific format required by the algorithm.
      "data": {
         "<field name>": dataElement
       }
    }
  ]
}
```

Hai le seguenti opzioni per specificare `dataElement`: 

**Equivalenti buffer di protocollo**

```
// Has the same format as the protocol buffers implementation described for training.
let dataElement = {
  "keys": [],
  "values": [],
  "shape": []
}
```

**Vettore numerico semplice**

```
// An array containing numeric values is treated as an instance containing a
// single dense vector.
let dataElement = [1.5, 16.0, 14.0, 23.0]

// It will be converted to the following representation by the SDK.
let converted = {
  "features": {
    "values": dataElement
  }
}
```

**Per record multipli**

```
let request = {
  "instances": [
    // First instance.
    {
      "features": [ 1.5, 16.0, 14.0, 23.0 ]
    },
    // Second instance.
    {
      "features": [ -2.0, 100.2, 15.2, 9.2 ]
    }
  ]
}
```

## Conversione dei dati per la deserializzazione delle risposte di inferenza
<a name="ir-deserialization"></a>

Gli algoritmi di SageMaker intelligenza artificiale di Amazon restituiscono JSON in diversi layout. Ad alto livello, la struttura è:

```
let response = {
  "predictions": [{
    // Fields in the response object are defined on a per algorithm-basis.
  }]
}
```

I campi inclusi nelle previsioni presentano differisce nei diversi algoritmi. Seguono degli esempi di output per l'algoritmo k-means.

**Inferenza singolo record** 

```
let response = {
  "predictions": [{
    "closest_cluster": 5,
    "distance_to_cluster": 36.5
  }]
}
```

**Inferenza multi-record**

```
let response = {
  "predictions": [
    // First instance prediction.
    {
      "closest_cluster": 5,
      "distance_to_cluster": 36.5
    },
    // Second instance prediction.
    {
      "closest_cluster": 2,
      "distance_to_cluster": 90.3
    }
  ]
}
```

**Inferenza multi-record con input protobuf**

```
{
  "features": [],
  "label": {
    "closest_cluster": {
      "values": [ 5.0 ] // e.g. the closest centroid/cluster was 1.0
    },
    "distance_to_cluster": {
      "values": [ 36.5 ]
    }
  },
  "uid": "abc123",
  "metadata": "{ "created_at": '2017-06-03' }"
}
```

SageMaker Gli algoritmi di intelligenza artificiale supportano anche il formato JSONLINES, in cui il contenuto della risposta per record è lo stesso del formato JSON. La struttura multi-record è una raccolta di oggetti di risposta per record separati da caratteri di nuova riga. Il contenuto della risposta per l' KMeans algoritmo integrato per 2 punti dati di input è:

```
{"distance_to_cluster": 23.40593910217285, "closest_cluster": 0.0}
{"distance_to_cluster": 27.250282287597656, "closest_cluster": 0.0}
```

Durante l'esecuzione della trasformazione in batch, consigliamo di utilizzare il tipo di risposta `jsonlines` impostando il campo `Accept` in `CreateTransformJobRequest` su `application/jsonlines`.

## Formati di richiesta comuni per tutti gli algoritmi
<a name="common-in-formats"></a>

La maggior parte degli algoritmi utilizza molti dei seguenti formati di richiesta di inferenza.

### Formato della richiesta JSON
<a name="cm-json"></a>

**Content type:** application/JSON

**Formato a densità alta**

```
let request =   {
    "instances":    [
        {
            "features": [1.5, 16.0, 14.0, 23.0]
        }
    ]
}


let request =   {
    "instances":    [
        {
            "data": {
                "features": {
                    "values": [ 1.5, 16.0, 14.0, 23.0]
                }
            }
        }
    ]
}
```

**Formato a densità bassa**

```
{
	"instances": [
		{"data": {"features": {
					"keys": [26, 182, 232, 243, 431],
					"shape": [2000],
					"values": [1, 1, 1, 4, 1]
				}
			}
		},
		{"data": {"features": {
					"keys": [0, 182, 232, 243, 431],
					"shape": [2000],
					"values": [13, 1, 1, 4, 1]
				}
			}
		},
	]
}
```

### Formato della richiesta JSONLINES
<a name="cm-jsonlines"></a>

**Content type:** application/JSONLINES

**Formato a densità alta**

Un singolo record in formato a densità alta può essere rappresentato come:

```
{ "features": [1.5, 16.0, 14.0, 23.0] }
```

oppure:

```
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
```

**Formato a densità bassa**

Un singolo record in formato a densità bassa è rappresentato come:

```
{"data": {"features": { "keys": [26, 182, 232, 243, 431], "shape": [2000], "values": [1, 1, 1, 4, 1] } } }
```

Più record sono rappresentati come una raccolta delle rappresentazioni di record singolo, separate da caratteri di nuova riga:

```
{"data": {"features": { "keys": [0, 1, 3], "shape": [4], "values": [1, 4, 1] } } }
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
{ "features": [1.5, 16.0, 14.0, 23.0] }
```

### Formato della richiesta CSV
<a name="cm-csv"></a>

**Content type:** text/CSV; label\$1size=0

**Nota**  
Il supporto CSV non è disponibile per la fattorizzazione delle macchine.

### Formato della richiesta RECORDIO
<a name="cm-recordio"></a>

Tipo di contenuto: applicazione/ x-recordio-protobuf

## Utilizzo della trasformazione in batch con gli algoritmi integrati
<a name="cm-batch"></a>

Durante l'esecuzione della trasformazione in batch, consigliamo di utilizzare il tipo di risposta JSONLINES anziché JSON, se supportato dall'algoritmo. A tale scopo, imposta il campo `Accept` in `CreateTransformJobRequest` su `application/jsonlines`.

Quando crei un processo di trasformazione, `SplitType` deve essere impostato in base al `ContentType` dei dati di input. Analogamente, `AssembleWith` deve essere impostato in base al campo `Accept` in `CreateTransformJobRequest`. Per impostare questi campi, utilizza la tabella seguente:


| ContentType | Consigliato SplitType | 
| --- | --- | 
| application/x-recordio-protobuf | RecordIO | 
| text/csv | Line | 
| application/jsonlines | Line | 
| application/json | None | 
| application/x-image | None | 
| image/\$1 | None | 


| Accettare | Consigliato AssembleWith | 
| --- | --- | 
| application/x-recordio-protobuf | None | 
| application/json | None | 
| application/jsonlines | Line | 

Per ulteriori informazioni sui formati di risposta per determinati algoritmi, consulta quanto segue:
+ [Formati di inferenza DeepAR](deepar-in-formats.md)
+ [Formati di risposta delle macchine di fattorizzazione](fm-in-formats.md)
+ [Formati di dati di inferenza di IP Insights](ip-insights-inference-data-formats.md)
+ [Formati di risposta k-Means](km-in-formats.md)
+ [Formati di richieste e risposte k-NN](kNN-inference-formats.md)
+ [Formati di risposta di Linear Learner](LL-in-formats.md)
+ [Formati della risposta NTM](ntm-in-formats.md)
+ [Formati dei dati per l'inferenza Object2Vec](object2vec-inference-formats.md)
+ [Incorporamenti del codificatore per Object2Vec](object2vec-encoder-embeddings.md)
+ [Formati della risposta PCA](PCA-in-formats.md)
+ [Formati della risposta RCF](rcf-in-formats.md)