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.
# Parameter für integrierte Algorithmen
In der folgenden Tabelle sind die Parameter für jeden der von Amazon SageMaker AI bereitgestellten Algorithmen aufgeführt.
| Name des Algorithmus | Kanalname | Trainingseingabemodus | Dateityp | Instance-Klasse | Parallelisierbar |
| --- | --- | --- | --- | --- | --- |
| AutoGluon-Tabellarisch | "train" und (optional) "validation" | Datei | CSV | CPU oder GPU (nur einzelne Instance) | Nein |
| BlazingText | "train" | Datei oder Pipe | Textdatei (ein Satz pro Zeile mit durch Leerzeichen getrennten Token) | CPU oder GPU (nur einzelne Instance) | Nein |
| CatBoost | "train" und (optional) "validation" | Datei | CSV | CPU (nur einzelne Instance) | Nein |
| DeepAR-Prognosen | "train" und (optional) "test" | Datei | JSON-Lines oder Parquet | CPU oder GPU | Ja |
| Factorization Machines | "train" und (optional) "test" | Datei oder Pipe | recordIO-protobuf | CPU (GPU für Daten mit hoher Dichte) | Ja |
| Bildklassifizierung - MXNet | "train" und "validation", (optional) "train\$1lst", "validation\$1lst" und "model" | Datei oder Pipe | recordIO oder Bilddateien (JPEG oder PNG) | GPU | Ja |
| Bildklassifizierung - TensorFlow | Training und Validierung | Datei | Bilddateien (.jpg, .jpeg oder .png) | CPU oder GPU | Ja (nur für mehrere GPUs auf einer einzigen Instanz) |
| IP Insights | "train" und (optional) "validation" | Datei | CSV | CPU oder GPU | Ja |
| K-Means | "train" und (optional) "test" | Datei oder Pipe | recordIO-protobuf oder CSV | CPU oder GPUCommon (einzelnes GPU-Gerät auf einer oder mehreren Instanzen) | Nein |
| K-Nearest-Neighbors (k-NN) | "train" und (optional) "test" | Datei oder Pipe | recordIO-protobuf oder CSV | CPU- oder GPU (einzelnes GPU-Gerät auf einer oder mehreren Instances) | Ja |
| LDA | "train" und (optional) "test" | Datei oder Pipe | recordIO-protobuf oder CSV | CPU (nur einzelne Instance) | Nein |
| LightGBM | "train/training" und (optional) "validation" | Datei | CSV | CPU | Ja |
| Lineares Lernen | "train" und (optional) "validation", "test" oder beides | Datei oder Pipe | recordIO-protobuf oder CSV | CPU oder GPU | Ja |
| Neural Topic Modeling | "train" und (optional) "validation", "test" oder beides | Datei oder Pipe | recordIO-protobuf oder CSV | CPU oder GPU | Ja |
| Object2Vec | "train" und (optional) "validation", "test" oder beides | Datei | JSON-Lines | CPU oder GPU (nur einzelne Instance) | Nein |
| Objekterkennung - MXNet | "train" und "validation", (optional) "train\$1annotation", "validation\$1annotation" und "model" | Datei oder Pipe | recordIO oder Bilddateien (JPEG oder PNG) | GPU | Ja |
| Objekterkennung - TensorFlow | Training und Validierung | Datei | Bilddateien (.jpg, .jpeg oder .png) | GPU | Ja (nur für mehrere GPUs auf einer einzigen Instanz) |
| PCA | "train" und (optional) "test" | Datei oder Pipe | recordIO-protobuf oder CSV | CPU oder GPU | Ja |
| Random Cut Forest | "train" und (optional) "test" | Datei oder Pipe | recordIO-protobuf oder CSV | CPU | Ja |
| Semantische Segmentierung | "train" und "validation", "train\$1annotation", "validation\$1annotation" und (optional) "label\$1map" und "model" | Datei oder Pipe | Abbildungsdateien | GPU (nur einzelne Instance) | Nein |
| Seq2Seq Modeling | "train", "validation" und "vocab" | Datei | recordIO-protobuf | GPU (nur einzelne Instance) | Nein |
| TabTransformer | "train" und (optional) "validation" | Datei | CSV | CPU oder GPU (nur einzelne Instance) | Nein |
| Textklassifizierung - TensorFlow | Training und Validierung | Datei | CSV | CPU oder GPU | Ja (nur für mehrere GPUs auf einer einzigen Instanz) |
| XGBoost (0,90-1, 0,90-2, 1,0-1, 1,2-1, 1,2-21) | "train" und (optional) "validation" | Datei oder Pipe | CSV, LibSVM oder Parquet | CPU (oder GPU für 1.2-1) | Ja |
Algorithmen, die *parallelisierbar* sind, lassen sich für verteilte Trainings auf mehreren Datenverarbeitungs-Instances bereitstellen.
Die folgenden Themen enthalten Informationen zu Datenformaten, empfohlenen Amazon EC2 EC2-Instance-Typen und CloudWatch Protokollen, die allen von Amazon SageMaker AI bereitgestellten integrierten Algorithmen gemeinsam sind.
**Anmerkung**
Informationen zum Docker-Image der integrierten Algorithmen, die URIs von SageMaker KI verwaltet werden, finden Sie unter [Docker-Registrierungspfade und Beispielcode](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths).
**Topics**
+ [Gängige Datenformate für Trainings](cdf-training.md)
+ [Gängige Datenformate für die Inferenz](cdf-inference.md)
+ [Instance-Typen für integrierte Algorithmen.](cmn-info-instance-types.md)
+ [Protokolle für integrierte Algorithmen](common-info-all-sagemaker-models-logs.md)
# Gängige Datenformate für Trainings
Zur Vorbereitung auf das Training können Sie Ihre Daten mit einer Vielzahl von AWS Services vorverarbeiten, darunter Amazon EMR AWS Glue, Amazon Redshift, Amazon Relational Database Service und Amazon Athena. Veröffentlichen Sie nach der Vorverarbeitung die Daten in einem Amazon-S3-Bucket. Für Trainings müssen die Daten eine Reihe von Konvertierungen und Umwandlungen durchlaufen. Hierzu gehören:
+ Serialisierung der Trainingsdaten (durchgeführt von Ihnen)
+ Deserialisierung der Trainingsdaten (durchgeführt vom Algorithmus)
+ Serialisierung des Trainingssmodells (durchgeführt vom Algorithmus)
+ Deserialisierung des trainierten Modells (optional, durchgeführt von Ihnen)
Wenn Sie Amazon SageMaker AI im Trainingsteil des Algorithmus verwenden, stellen Sie sicher, dass Sie alle Daten auf einmal hochladen. Wenn diesem Speicherort mehr Daten hinzugefügt werden, würde ein neuer Trainingsaufruf vorgenommen werden müssen, um ein völlig neues Modell zu erstellen.
**Topics**
+ [Inhaltstypen, die von integrierten Algorithmen unterstützt werden](#cdf-common-content-types)
+ [Verwenden des Pipe-Modus](#cdf-pipe-mode)
+ [Verwenden des CSV-Formats](#cdf-csv-format)
+ [Verwenden des RecordIO-Formats](#cdf-recordio-format)
+ [Deserialisierung des trainierten Modells](#td-deserialization)
## Inhaltstypen, die von integrierten Algorithmen unterstützt werden
In der folgenden Tabelle sind einige der häufig unterstützten [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType) Werte und die Algorithmen, die sie verwenden, aufgeführt:
ContentTypes für integrierte Algorithmen
| ContentType | Algorithmus |
| --- | --- |
| application/x-image | Algorithmus zur Objekterkennung, Semantische Segmentierung |
| application/x-recordio | Objekterkennungsalgorithmus |
| Anwendung/ x-recordio-protobuf | Faktorisierungsmaschinen, K-Means, k-NN, latente Dirichlet-Allokation, Linear Learner, NTM, PCA, RCF, Sequence-to-Sequence |
| application/jsonlines | BlazingText, DeepAR |
| image/jpeg | Algorithmus zur Objekterkennung, Semantische Segmentierung |
| image/png | Algorithmus zur Objekterkennung, Semantische Segmentierung |
| text/csv | IP-Einblicke, K-Means, k-NN, latente Dirichlet-Zuordnung, Linear Learner, NTM, PCA, RCF, XGBoost |
| text/libsvm | XGBoost |
Eine Zusammenfassung der Parameter, die von den einzelnen Algorithmen verwendet werden, finden Sie in der Dokumentation der einzelnen Algorithmen oder dieser [Tabelle](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html).
## Verwenden des Pipe-Modus
Im *Pipe-Modus* streamt Ihr Trainingsauftrag Daten direkt aus Amazon Simple Storage Service (Amazon S3). Das Streamen kann schnellere Startzeiten für Trainingsaufträge und besseren Durchsatz ermöglichen. Dies steht im Gegensatz zum *Dateimodus*, in dem Ihre Daten aus Amazon S3 auf den Volumes der Trainings-Instance gespeichert werden. Im Dateimodus wird Festplattenspeicher zur Speicherung Ihrer endgültigen Modellartefakte sowie Ihres vollständigen Trainingsdatensatzes benötigt. Indem Sie Ihre Daten im Pipe-Modus direkt von Amazon S3 streamen, reduzieren Sie die Größe der Amazon Elastic Block Store-Volumen Ihrer Trainings-Instances. Im Pipe-Modus ist genug Festplattenspeicher zum Speichern Ihrer endgültigen Modellartefakte erforderlich. Weitere Details zum Trainingseingangsmodus finden Sie unter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html).
## Verwenden des CSV-Formats
Viele Amazon SageMaker AI-Algorithmen unterstützen das Training mit Daten im CSV-Format. Um Daten im CSV-Format für das Training zu verwenden, geben Sie **text/csv** in der Spezifikation des Eingabedatenkanals als [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType) an. Amazon SageMaker AI erfordert, dass eine CSV-Datei keinen Header-Datensatz hat und dass sich die Zielvariable in der ersten Spalte befindet. Um Algorithmen für unüberwachtes Lernen, die kein Ziel haben, auszuführen, geben Sie die Anzahl der Bezeichnungsspalten im Inhaltstyp ein. In diesem Fall z. B. **'content\$1type=text/csv;label\$1size=0'**. Weitere Informationen finden Sie unter [Verwenden Sie jetzt den Pipe-Modus mit CSV-Datensätzen, um die integrierten Algorithmen von Amazon SageMaker AI schneller zu trainieren](https://aws.amazon.com/blogs/machine-learning/now-use-pipe-mode-with-csv-datasets-for-faster-training-on-amazon-sagemaker-built-in-algorithms/).
## Verwenden des RecordIO-Formats
Im Protobuf-RecordIO-Format konvertiert SageMaker AI jede Beobachtung im Datensatz in eine binäre Darstellung als Satz von 4-Byte-Floats und lädt sie dann in das Protobuf-Wertefeld. Wenn Sie Python für die Aufbereitung Ihrer Daten verwenden, empfehlen wir dringend, diese vorhandenen Transformationen zu verwenden. Wenn Sie jedoch eine andere Sprache verwenden, enthält die folgende Protobuf-Definitionsdatei das Schema, mit dem Sie Ihre Daten in das AI-Protobuf-Format konvertieren. SageMaker
**Anmerkung**
Ein Beispiel, das zeigt, wie das häufig verwendete numPy-Array in das protobuf-recordIO-Format konvertiert wird, finden Sie unter *[An Introduction to Factorization Machines with MNIST](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/factorization_machines_mnist/factorization_machines_mnist.html)*.
```
syntax = "proto2";
package aialgs.data;
option java_package = "com.amazonaws.aialgorithms.proto";
option java_outer_classname = "RecordProtos";
// A sparse or dense rank-R tensor that stores data as doubles (float64).
message Float32Tensor {
// Each value in the vector. If keys is empty, this is treated as a
// dense vector.
repeated float values = 1 [packed = true];
// If key is not empty, the vector is treated as sparse, with
// each key specifying the location of the value in the sparse vector.
repeated uint64 keys = 2 [packed = true];
// An optional shape that allows the vector to represent a matrix.
// For example, if shape = [ 10, 20 ], floor(keys[i] / 20) gives the row,
// and keys[i] % 20 gives the column.
// This also supports n-dimensonal tensors.
// Note: If the tensor is sparse, you must specify this value.
repeated uint64 shape = 3 [packed = true];
}
// A sparse or dense rank-R tensor that stores data as doubles (float64).
message Float64Tensor {
// Each value in the vector. If keys is empty, this is treated as a
// dense vector.
repeated double values = 1 [packed = true];
// If this is not empty, the vector is treated as sparse, with
// each key specifying the location of the value in the sparse vector.
repeated uint64 keys = 2 [packed = true];
// An optional shape that allows the vector to represent a matrix.
// For example, if shape = [ 10, 20 ], floor(keys[i] / 10) gives the row,
// and keys[i] % 20 gives the column.
// This also supports n-dimensonal tensors.
// Note: If the tensor is sparse, you must specify this value.
repeated uint64 shape = 3 [packed = true];
}
// A sparse or dense rank-R tensor that stores data as 32-bit ints (int32).
message Int32Tensor {
// Each value in the vector. If keys is empty, this is treated as a
// dense vector.
repeated int32 values = 1 [packed = true];
// If this is not empty, the vector is treated as sparse with
// each key specifying the location of the value in the sparse vector.
repeated uint64 keys = 2 [packed = true];
// An optional shape that allows the vector to represent a matrix.
// For Exmple, if shape = [ 10, 20 ], floor(keys[i] / 10) gives the row,
// and keys[i] % 20 gives the column.
// This also supports n-dimensonal tensors.
// Note: If the tensor is sparse, you must specify this value.
repeated uint64 shape = 3 [packed = true];
}
// Support for storing binary data for parsing in other ways (such as JPEG/etc).
// This is an example of another type of value and may not immediately be supported.
message Bytes {
repeated bytes value = 1;
// If the content type of the data is known, stores it.
// This allows for the possibility of using decoders for common formats
// in the future.
optional string content_type = 2;
}
message Value {
oneof value {
// The numbering assumes the possible use of:
// - float16, float128
// - int8, int16, int32
Float32Tensor float32_tensor = 2;
Float64Tensor float64_tensor = 3;
Int32Tensor int32_tensor = 7;
Bytes bytes = 9;
}
}
message Record {
// Map from the name of the feature to the value.
//
// For vectors and libsvm-like datasets,
// a single feature with the name `values`
// should be specified.
map features = 1;
// An optional set of labels for this record.
// Similar to the features field above, the key used for
// generic scalar / vector labels should be 'values'.
map label = 2;
// A unique identifier for this record in the dataset.
//
// Whilst not necessary, this allows better
// debugging where there are data issues.
//
// This is not used by the algorithm directly.
optional string uid = 3;
// Textual metadata describing the record.
//
// This may include JSON-serialized information
// about the source of the record.
//
// This is not used by the algorithm directly.
optional string metadata = 4;
// An optional serialized JSON object that allows per-record
// hyper-parameters/configuration/other information to be set.
//
// The meaning/interpretation of this field is defined by
// the algorithm author and may not be supported.
//
// This is used to pass additional inference configuration
// when batch inference is used (e.g. types of scores to return).
optional string configuration = 5;
}
```
Nachdem Sie den Protokollpuffer erstellt haben, speichern Sie ihn an einem Amazon S3 S3-Speicherort, auf den Amazon SageMaker AI zugreifen kann und der als Teil `InputDataConfig` übergeben werden kann`create_training_job`.
**Anmerkung**
Für alle Amazon SageMaker AI-Algorithmen `InputDataConfig` muss `ChannelName` der Eingang auf gesetzt sein`train`. Einige Algorithmen unterstützen auch eine Validierung oder testen `input channels`. Diese werden in der Regel verwendet, um die Leistung des Modells mithilfe eines Holdout-Datasets zu bewerten. Holdout-Datasets werden im anfänglichen Training nicht verwendet, können aber eingesetzt werden, um das Modell weiter zu optimieren.
## Deserialisierung des trainierten Modells
Amazon SageMaker AI-Modelle werden als model.tar.gz im S3-Bucket gespeichert, der im `OutputDataConfig` `S3OutputPath` Parameter des `create_training_job` Aufrufs angegeben ist. Der S3-Bucket muss sich in derselben AWS Region wie die Notebook-Instance befinden. Sie können die meisten dieser Modellartefakte beim Erstellen eines Hosting-Modells angeben. Sie können sie auch in Ihrer Notebook-Instance öffnen und überprüfen. Wenn untarred `model.tar.gz` ist, enthält es`model_algo-1`, was ein serialisiertes Apache-Objekt ist. MXNet Sie verwenden zum Beispiel Folgendes, um das k-means-Modell in den Arbeitsspeicher zu laden und anzuzeigen:
```
import mxnet as mx
print(mx.ndarray.load('model_algo-1'))
```
# Gängige Datenformate für die Inferenz
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
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": {
"": 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
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
Die meisten Algorithmen verwenden viele der folgenden Inferenzanforderungsformate.
### JSON-Anfrageformat
**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
**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
**Inhaltstyp:** text/CSV; label\$1size=0
**Anmerkung**
CSV-Unterstützung ist für Factorization Machines nicht verfügbar.
### RECORDIO-Anfrageformat
Inhaltstyp: Anwendung/ x-recordio-protobuf
## Verwenden der Stapeltransformation mit integrierten Algorithmen
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)
# Instance-Typen für integrierte Algorithmen.
Die meisten SageMaker KI-Algorithmen von Amazon wurden so entwickelt, dass sie GPU-Computing für das Training nutzen. Trotz der höheren Kosten pro Instanz sollten Sie schneller GPUs trainieren, was sie kostengünstiger macht. Ausnahmen sind in diesem Handbuch aufgeführt.
Weitere Informationen zu den unterstützten EC2-Instances finden Sie unter [Instance-Details](https://aws.amazon.com/sagemaker-ai/pricing/#Instance_details).
Größe und Art von Daten können einen großen Einfluss darauf haben, welche Hardwarekonfiguration am effektivsten ist. Wenn dasselbe Modell wiederholt trainiert wird, können mit ersten Tests über ein Spektrum an Instance-Typen hinweg Konfigurationen ermittelt werden, die langfristig kostengünstiger sind. Darüber hinaus benötigen Algorithmen, die am effizientesten trainieren, GPUs möglicherweise GPUs keine effiziente Inferenz. Experimentieren Sie, um die kostengünstigste Lösung zu finden. Verwenden Sie [Amazon SageMaker Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html) Recommender, um eine automatische Instance-Empfehlung zu erhalten oder benutzerdefinierte Auslastungstests durchzuführen.
Weitere Informationen zu SageMaker KI-Hardwarespezifikationen finden Sie unter [Amazon SageMaker AI-Preise](https://aws.amazon.com/sagemaker/ai/pricing/).
**UltraServers**
UltraServers verbinden Sie mehrere Amazon EC2 EC2-Instances mithilfe einer Accelerator-Verbindung mit niedriger Latenz und hoher Bandbreite. Sie sind darauf ausgelegt, umfangreiche AI/ML Workloads zu bewältigen, die eine erhebliche Rechenleistung erfordern. Weitere Informationen finden Sie unter [Amazon EC2 UltraServers](https://aws.amazon.com/ec2/ultraservers/). Informationen zu den ersten Schritten finden Sie unter [Reservieren von Schulungsplänen für Ihre Schulungsjobs oder HyperPod -cluster](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html). UltraServers
Um mit Amazon SageMaker AI UltraServers zu beginnen, [erstellen Sie einen Schulungsplan](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html). Sobald Ihre im Schulungsplan verfügbar UltraServer ist, erstellen Sie einen Schulungsjob mit der AWS-Managementkonsole Amazon SageMaker AI API oder AWS CLI. Denken Sie daran, den UltraServer Instance-Typ, den Sie gekauft haben, im Trainingsplan anzugeben.
An UltraServer kann einen oder mehrere Jobs gleichzeitig ausführen. UltraServers gruppiert Instanzen zusammen, was Ihnen eine gewisse Flexibilität bei der Zuteilung Ihrer UltraServer Kapazität in Ihrer Organisation bietet. Beachten Sie bei der Konfiguration Ihrer Jobs auch die Datenschutzrichtlinien Ihrer Organisation, da Instanzen in einer Instanz auf Daten für einen anderen Job in derselben UltraServer Instanz zugreifen UltraServer können.
Wenn Sie in der auf Hardwarefehler stoßen UltraServer, versucht SageMaker KI automatisch, das Problem zu lösen. Während SageMaker KI das Problem untersucht und behebt, erhalten Sie möglicherweise Benachrichtigungen und Aktionen über AWS Health Ereignisse oder. AWS Support
Sobald dein Trainingsjob beendet ist, stoppt SageMaker KI die Instanzen, aber sie bleiben in deinem Trainingsplan verfügbar, sofern der Plan noch aktiv ist. Um eine Instanz auch nach Abschluss eines Jobs am UltraServer Laufen zu halten, kannst du [verwaltete Warm-Pools](https://docs.aws.amazon.com/sagemaker/latest/dg/train-warm-pools.html) verwenden.
Wenn Ihr Trainingsplan über genügend Kapazität verfügt, können Sie Trainingsjobs sogar für mehrere Aufgaben ausführen UltraServers. Standardmäßig umfasst jede UltraServer Instanz 18 Instanzen, die aus 17 Instanzen und einer Ersatzinstanz bestehen. Wenn Sie mehr Instances benötigen, müssen Sie mehr kaufen UltraServers. Wenn Sie einen Schulungsjob erstellen, können Sie UltraServers mithilfe des `InstancePlacementConfig` Parameters konfigurieren, wie Jobs platziert werden.
Wenn Sie die Stellenvermittlung nicht konfigurieren, SageMaker ordnet KI die Stellen automatisch Ihren Instanzen zu. UltraServer Diese Standardstrategie basiert auf einem Best-Effort-Prinzip, bei dem es darum geht, alle Instanzen in einer einzigen zu besetzen, UltraServer bevor eine andere verwendet wird. UltraServer Wenn Sie beispielsweise 14 Instanzen anfordern und 2 UltraServers in Ihrem Trainingsplan haben, verwendet SageMaker KI alle Instanzen der ersten Instanz. UltraServer Wenn du 20 Instanzen angefordert hast und 2 UltraServers in deinem Trainingsplan hast, verwendet SageMaker KI alle 17 Instanzen in der ersten Instanz UltraServer und dann 3 von der zweiten UltraServer. Instanzen innerhalb einer UltraServer Anwendung kommunizieren, einzelne UltraServers Benutzer verwenden NVLink jedoch den Elastic Fabric Adapter (EFA), was sich auf die Trainingsleistung des Modells auswirken kann.
# Protokolle für integrierte Algorithmen
Die SageMaker KI-Algorithmen von Amazon erstellen CloudWatch Amazon-Logs, die detaillierte Informationen zum Trainingsprozess enthalten. Um die Protokolle anzuzeigen **CloudWatch**, wählen Sie in der AWS Managementkonsole **Logs** und dann die aws/sagemaker/TrainingJobs **Log-Gruppe**/aus. Jeder Trainingsauftrag hat einen Protokollstream pro Knoten, in dem er trainiert wurde. Der Protokoll-Streamname beginnt mit dem Wert, der im `TrainingJobName`-Parameter beim Erstellen des Auftrags angegeben wurde.
**Anmerkung**
Wenn ein Job fehlschlägt und keine Protokolle angezeigt werden CloudWatch, ist es wahrscheinlich, dass vor Beginn der Schulung ein Fehler aufgetreten ist. Ein Grund kann die Angabe des falschen Trainings-Images oder des falschen S3-Speicherorts sein.
Der Inhalt von Protokollen unterscheidet sich je nach Algorithmus. Sie können jedoch in der Regel die folgenden Informationen finden:
+ Bestätigung der zu Beginn des Protokolls bereitgestellten Argumente
+ Fehler, die während des Trainings auftraten
+ Messung der Genauigkeit eines Algorithmus oder numerischen Leistung
+ Zeitabläufe für den Algorithmus und alle wichtigen Phasen innerhalb des Algorithmus
## Häufige Fehler
Wenn ein Trainingsauftrag fehlschlägt, werden einige Details zu dem Fehler vom `FailureReason`-Rückgabewert in der Trainingsauftragsbeschreibung bereitgestellt, wie etwa folgende:
```
sage = boto3.client('sagemaker')
sage.describe_training_job(TrainingJobName=job_name)['FailureReason']
```
Andere werden nur in den CloudWatch Protokollen gemeldet. Zu den häufigen Fehlern gehören:
1. Falsches Angeben eines Hyperparameters oder Angeben eines Hyperparameters, der für den Algorithmus ungültig ist.
**Aus dem CloudWatch Protokoll**
```
[10/16/2017 23:45:17 ERROR 139623806805824 train.py:48]
Additional properties are not allowed (u'mini_batch_siz' was
unexpected)
```
1. Angeben eines ungültigen Werts für einen Hyperparameter.
**FailureReason**
```
AlgorithmError: u'abc' is not valid under any of the given
schemas\n\nFailed validating u'oneOf' in
schema[u'properties'][u'feature_dim']:\n {u'oneOf':
[{u'pattern': u'^([1-9][0-9]*)$', u'type': u'string'},\n
{u'minimum': 1, u'type': u'integer'}]}\
```
**FailureReason**
```
[10/16/2017 23:57:17 ERROR 140373086025536 train.py:48] u'abc'
is not valid under any of the given schemas
```
1. Falsches protobuf-Dateiformat.
**Aus dem CloudWatch Logbuch**
```
[10/17/2017 18:01:04 ERROR 140234860816192 train.py:48] cannot
copy sequence with size 785 to array axis with dimension 784
```