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 Trainings

Zur Vorbereitung auf das Training können Sie Ihre Daten mit einer Vielzahl von AWS Services vorverarbeiten, darunter Amazon AWS Glue, Amazon RedshiftEMR, Amazon Relational Database Service und Amazon Athena. Veröffentlichen Sie nach der Vorverarbeitung die Daten in einem Amazon-S3-Bucket. Für das Training müssen die Daten eine Reihe von Konvertierungen und Transformationen durchlaufen, darunter:

Wenn Sie Amazon SageMaker 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.

Inhaltstypen, die von integrierten Algorithmen unterstützt werden

In der folgenden Tabelle sind einige der häufig unterstützten ContentType Werte und die Algorithmen, die sie verwenden, aufgeführt:

ContentTypes für integrierte Algorithmen

Eine Zusammenfassung der Parameter, die von den einzelnen Algorithmen verwendet werden, finden Sie in der Dokumentation der einzelnen Algorithmen oder dieser Tabelle.

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

Format verwenden CSV

Viele SageMaker Amazon-Algorithmen unterstützen das Training mit Daten im CSV Format. Um Daten im CSV Format für das Training zu verwenden, geben Sie in der Spezifikation für den Eingabedatenkanal den text/csv Wert als an ContentType. Amazon SageMaker verlangt, 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_type=text/csv;label_size=0'. Weitere Informationen finden Sie unter Verwenden Sie jetzt den Pipe-Modus mit CSV Datensätzen, um das Training mit den SageMaker integrierten Algorithmen von Amazon zu beschleunigen.

Verwenden des RecordIO-Formats

SageMaker Konvertiert im Format protobuf recordIO 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 Protobuf-Format konvertieren. SageMaker

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<string, Value> 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<string, Value> 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 zugreifen SageMaker kann und der als Teil InputDataConfig übergeben werden kanncreate_training_job.

Deserialisierung des trainierten Modells

SageMaker Amazon-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 esmodel_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'))