Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Gängige Datenformate für die Inferenz
<a name="cdf-inference"></a>

Die SageMaker KI-Algorithmen von Amazon akzeptieren und erzeugen verschiedene MIME-Typen für die HTTP-Payloads, die beim Abrufen von Online- und Mini-Batch-Vorhersagen verwendet werden. Sie können mehrere AWS Dienste verwenden, um Datensätze zu transformieren oder vorzuverarbeiten, bevor Sie die Inferenz ausführen. Sie müssen die Daten mindestens für Folgendes konvertieren:
+ Serialisierung der Inferenzanforderung (durchgeführt von Ihnen) 
+ Deserialisierung der Inferenzanforderung (durchgeführt vom Algorithmus) 
+ Serialisierung der Inferenzantwort (durchgeführt vom Algorithmus) 
+ Deserialisierung der Inferenzantwort (durchgeführt von Ihnen) 

**Topics**
+ [Konvertieren von Daten für die Serialisierung von Inferenzanforderungen](#ir-serialization)
+ [Konvertieren von Daten für die Deserialisierung von Inferenzantworten](#ir-deserialization)
+ [Gängige Anforderungsformate für alle Algorithmen](#common-in-formats)
+ [Verwenden der Stapeltransformation mit integrierten Algorithmen](#cm-batch)

## Konvertieren von Daten für die Serialisierung von Inferenzanforderungen
<a name="ir-serialization"></a>

Zu den Inhaltstypoptionen für Inferenzanfragen des Amazon SageMaker AI-Algorithmus gehören: `text/csv``application/json`, und`application/x-recordio-protobuf`. Algorithmen, die nicht alle diese Typen unterstützen, können andere Typen unterstützen. XGBoostunterstützt beispielsweise nur `text/csv` aus dieser Liste, unterstützt aber auch`text/libsvm`.

Für `text/csv` sollte der Wert für das Body-Argument für `invoke_endpoint` eine Zeichenfolge mit durch Kommata getrennten Werten für jede Funktion sein. Ein Datensatz für ein Modell mit vier Funktionen könnte etwa so aussehen: `1.5,16.0,14,23.0`. Alle mit den Trainingsdaten durchgeführten Umwandlungen sollten auch für die Daten durchgeführt werden, bevor Inferenzen abgerufen werden. Die Reihenfolge der Funktionen ist wichtig und muss unverändert bleiben. 

`application/json` ist flexibler und stellt eine Vielzahl möglicher Formate für Entwickler bereit, die sie in ihren Anwendungen verwenden können. Auf einer höheren Ebene, in JavaScript, könnte die Nutzlast wie folgt aussehen: 

```
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
       }
    }
  ]
}
```

Sie haben die folgenden Optionen für das Angeben von `dataElement`: 

**Protokollpufferentsprechung**

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

**Einfacher numerischer Vektor **

```
// 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
  }
}
```

**Für mehrere Datensätze**

```
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 ]
    }
  ]
}
```

## Konvertieren von Daten für die Deserialisierung von Inferenzantworten
<a name="ir-deserialization"></a>

Die SageMaker KI-Algorithmen von Amazon geben JSON in verschiedenen Layouts zurück. Grundsätzlich ist dies die Struktur:

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

Die Felder, die in Voraussagen enthalten sind, sind für die verschiedenen Algorithmen unterschiedlich. Im Folgenden sehen Sie Beispiele für die Ausgabe für den k-means-Algorithmus.

**Einzeldatensatz-Inferenz** 

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

**Multi-Datensatz-Inferenz**

```
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
    }
  ]
}
```

**Multi-Datensatz-Inferenz mit protobuf-Eingabe **

```
{
  "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 KI-Algorithmen unterstützen auch das JSONLINES-Format, bei dem der Inhalt der Antwort pro Datensatz dem Inhalt im JSON-Format entspricht. Die Multi-Datensatz-Struktur ist eine Sammlung aus Antwortobjekten pro Datensatz, die durch Zeilenumbruchzeichen getrennt sind. Der Antwortinhalt für den integrierten KMeans Algorithmus für 2 Eingabedatenpunkte lautet:

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

Bei der Ausführung einer Stapeltransformation empfehlen wir, den `jsonlines`-Antworttyp zu verwenden, indem das `Accept`-Feld im `CreateTransformJobRequest` auf `application/jsonlines` festgelegt wird.

## Gängige Anforderungsformate für alle Algorithmen
<a name="common-in-formats"></a>

Die meisten Algorithmen verwenden viele der folgenden Inferenzanforderungsformate.

### JSON-Anfrageformat
<a name="cm-json"></a>

**Inhaltstyp:** application/JSON

**Format mit hoher Dichte**

```
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 mit geringer Dichte**

```
{
	"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]
				}
			}
		},
	]
}
```

### JSONLINES-Anfrageformat
<a name="cm-jsonlines"></a>

**Inhaltstyp:** application/JSONLINES

**Format mit hoher Dichte**

Für die Darstellung eines einzelnen Datensatzes im Format mit hoher Dichte gibt es zwei Möglichkeiten:

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

oder:

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

**Format mit geringer Dichte**

Ein einzelner Datensatz im Format mit geringer Dichte wird wie folgt dargestellt:

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

Mehrere Datensätze werden als Sammlung der Einzeldatensatz-Darstellungen repräsentiert und durch Zeilenumbruchzeichen getrennt:

```
{"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] }
```

### CSV-Anfrageformat
<a name="cm-csv"></a>

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

**Anmerkung**  
CSV-Unterstützung ist für Factorization Machines nicht verfügbar.

### RECORDIO-Anfrageformat
<a name="cm-recordio"></a>

Inhaltstyp: Anwendung/ x-recordio-protobuf

## Verwenden der Stapeltransformation mit integrierten Algorithmen
<a name="cm-batch"></a>

Bei der Ausführung der Stapeltransformation empfehlen wir, den JSONLINES-Antworttyp anstelle von JSON zu verwenden, sofern dieser vom Algorithmus unterstützt wird. Setzen Sie dazu das Feld `Accept` in `CreateTransformJobRequest` auf `application/jsonlines`.

Wenn Sie einen Umwandlungsauftrag erstellen, muss `SplitType` basierend auf `ContentType` der Eingabedaten festgelegt werden. Entsprechend muss `AssembleWith` abhängig vom `Accept`-Feld in der `CreateTransformJobRequest` entsprechend eingestellt werden. Verwenden Sie die folgende Tabelle, um diese Felder festzulegen:


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


| Accept | Empfohlen AssembleWith | 
| --- | --- | 
| application/x-recordio-protobuf | None | 
| application/json | None | 
| application/jsonlines | Line | 

Weitere Informationen zu Antwortformaten für bestimmte Algorithmen finden Sie in den folgenden Artikeln:
+ [DeepAR-Inferenzformate](deepar-in-formats.md)
+ [Factorization Machines Antwortformate](fm-in-formats.md)
+ [IP Insights-Inferenzdatenformate](ip-insights-inference-data-formats.md)
+ [k-Means-Antwortformate](km-in-formats.md)
+ [k-NN-Anforderungs- und Antwortformate](kNN-inference-formats.md)
+ [Antwortformate von linearen Learnern](LL-in-formats.md)
+ [NTM-Antwortformate](ntm-in-formats.md)
+ [Datenformate für Object2Vec-Inferenzen](object2vec-inference-formats.md)
+ [Encoder-Einbettungen für Object2Vec](object2vec-encoder-embeddings.md)
+ [PCA-Antwortformate](PCA-in-formats.md)
+ [RCF-Antwortformate](rcf-in-formats.md)