Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Formats de données courants pour l’inférence
Les algorithmes Amazon SageMaker AI acceptent et produisent différents types MIME pour les charges utiles HTTP utilisées pour récupérer les prédictions en ligne et par mini-lots. Vous pouvez utiliser plusieurs AWS services pour transformer ou prétraiter des enregistrements avant d'exécuter l'inférence. Au minimum, vous devez convertir les données pour les éléments suivants :
+ Sérialisation de demandes d’inférence (gérée par vous)
+ Désérialisation de demandes d’inférence (gérée par l’algorithme)
+ Sérialisation de réponses d’inférence (gérée par l’algorithme)
+ Désérialisation de réponses d’inférence (gérée par vous)
**Topics**
+ [Conversion des données pour la sérialisation de demandes d’inférence](#ir-serialization)
+ [Conversion des données pour la désérialisation de demandes d’inférence](#ir-deserialization)
+ [Formats de demande courants pour les algorithmes](#common-in-formats)
+ [Utilisation de la transformation par lots avec les algorithmes intégrés](#cm-batch)
## Conversion des données pour la sérialisation de demandes d’inférence
Les options de type de contenu pour les demandes d'inférence d'algorithmes Amazon SageMaker AI incluent : `text/csv``application/json`, et`application/x-recordio-protobuf`. Les algorithmes qui ne prennent pas en charge tous ces types peuvent en prendre en charge d'autres types. XGBoost, par exemple, uniquement les supports `text/csv` de cette liste, mais également les supports`text/libsvm`.
Pour `text/csv`, la valeur de l'argument Body envoyé à `invoke_endpoint` doit être une chaîne avec des virgules entre les valeurs pour chaque fonction. Par exemple, un enregistrement pour un modèle ayant quatre fonctions peut ressembler à `1.5,16.0,14,23.0`. Les transformations effectuées sur les données d'entraînement doivent également être exécutées sur les données avant d'obtenir l'inférence. L'ordre des fonctions est pris en compte et doit rester inchangé.
`application/json` est plus flexible et offre plusieurs formats possibles pouvant être utilisés par les développeurs dans leurs applications. À un niveau élevé, dans JavaScript, la charge utile peut ressembler à ce qui suit :
```
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": {
"": dataElement
}
}
]
}
```
Vous avez les possibilités suivantes pour spécifier l'élément `dataElement` :
**Équivalent des Protocol Buffers**
```
// Has the same format as the protocol buffers implementation described for training.
let dataElement = {
"keys": [],
"values": [],
"shape": []
}
```
**Vecteur numérique simple**
```
// 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
}
}
```
**Pour plusieurs enregistrements**
```
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 ]
}
]
}
```
## Conversion des données pour la désérialisation de demandes d’inférence
Les algorithmes Amazon SageMaker AI renvoient du JSON dans plusieurs mises en page. À un haut niveau, la structure est la suivante :
```
let response = {
"predictions": [{
// Fields in the response object are defined on a per algorithm-basis.
}]
}
```
Les champs inclus dans les prédictions diffèrent d'un algorithme à l'autre. Voici des exemples de sorties pour l'algorithme des k-moyennes (k-means).
**Inférence à enregistrement unique**
```
let response = {
"predictions": [{
"closest_cluster": 5,
"distance_to_cluster": 36.5
}]
}
```
**Inférence à enregistrements multiples**
```
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
}
]
}
```
**Inférence à enregistrements multiples avec entrée 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 Les algorithmes d'intelligence artificielle prennent également en charge le format JSONLINES, où le contenu de réponse par enregistrement est le même que celui du format JSON. La structure à plusieurs enregistrements est une collection d’objets de réponse par enregistrement séparés par des caractères de saut de ligne. Le contenu de réponse de l' KMeans algorithme intégré pour 2 points de données d'entrée est le suivant :
```
{"distance_to_cluster": 23.40593910217285, "closest_cluster": 0.0}
{"distance_to_cluster": 27.250282287597656, "closest_cluster": 0.0}
```
Pendant l'exécution de la transformation par lots, nous recommandons d'utiliser la réponse du type `jsonlines` en définissant le champ `Accept` dans `CreateTransformJobRequest` sur `application/jsonlines`.
## Formats de demande courants pour les algorithmes
La plupart des algorithmes utilisent un grand nombre des formats de demande d’inférence suivants.
### Format de demande JSON
**Type de contenu :** application/JSON
**Format dense**
```
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]
}
}
}
]
}
```
**Format clairsemé**
```
{
"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]
}
}
},
]
}
```
### Format de demande JSONLINES
**Type de contenu :** application/JSONLINES
**Format dense**
Un seul enregistrement au format dense peut être représenté comme suit :
```
{ "features": [1.5, 16.0, 14.0, 23.0] }
```
ou :
```
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
```
**Format clairsemé**
Un seul enregistrement au format fragmenté est représenté comme suit :
```
{"data": {"features": { "keys": [26, 182, 232, 243, 431], "shape": [2000], "values": [1, 1, 1, 4, 1] } } }
```
Plusieurs enregistrements sont représentés sous la forme d’une collection de représentations à un seul enregistrement, séparées par des caractères de saut de ligne :
```
{"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] }
```
### Format de demande CSV
**Type de contenu :** text/CSV; label\_size=0
**Note**
La prise en charge du format CSV n'est pas disponible pour l'algorithme Factorization Machines.
### Format de demande RECORDIO
Type de contenu : application/ x-recordio-protobuf
## Utilisation de la transformation par lots avec les algorithmes intégrés
Lors de l'exécution de la transformation par lots, nous recommandons d'utiliser les réponses du type JSONLINES plutôt que JSON, si l'algorithme les prend en charge. Pour ce faire, définissez le champ `Accept` dans `CreateTransformJobRequest` sur `application/jsonlines`.
Lorsque vous créez une tâche de transformation, `SplitType` doit être défini en fonction du `ContentType` des données d’entrée. De même, selon le champ `Accept` dans `CreateTransformJobRequest`, `AssembleWith` doit être défini en conséquence. Utilisez le tableau suivant pour définir ces champs :
| ContentType | Recommandé SplitType |
| --- | --- |
| application/x-recordio-protobuf | RecordIO |
| text/csv | Line |
| application/jsonlines | Line |
| application/json | None |
| application/x-image | None |
| image/\* | None |
| Accept | Recommandé AssembleWith |
| --- | --- |
| application/x-recordio-protobuf | None |
| application/json | None |
| application/jsonlines | Line |
Pour plus d'informations sur les formats de réponse pour les algorithmes spécifiques, consultez les éléments suivants :
+ [Formats d'inférence DeepAR](deepar-in-formats.md)
+ [Formats de réponse Factorization Machines](fm-in-formats.md)
+ [Formats de données d'inférence IP Insights](ip-insights-inference-data-formats.md)
+ [Formats de réponse des k-moyennes](km-in-formats.md)
+ [Formats de demande et de réponse k-NN](kNN-inference-formats.md)
+ [Formats de réponse d'apprentissage linéaire](LL-in-formats.md)
+ [Formats de la réponse NTM](ntm-in-formats.md)
+ [Format de données pour l'inférence d'Object2Vec](object2vec-inference-formats.md)
+ [Intégrations de l'encodeur pour Object2Vec](object2vec-encoder-embeddings.md)
+ [Formats de la réponse PCA](PCA-in-formats.md)
+ [Formats de la réponse RCF](rcf-in-formats.md)