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'addestramento

Per prepararti alla formazione, puoi preelaborare i dati utilizzando una varietà di AWS servizi, tra cui Amazon AWS Glue, Amazon RedshiftEMR, Amazon Relational Database Service e Amazon Athena. Dopo la preelaborazione, pubblica i dati in un bucket di Amazon S3. Per la formazione, i dati devono essere sottoposti a una serie di conversioni e trasformazioni, tra cui:

Quando usi Amazon SageMaker nella parte di addestramento dell'algoritmo, assicurati di caricare tutti i dati contemporaneamente. Se vengono aggiunti altri dati a quella posizione, deve essere effettuata una nuova chiamata di addestramento per creare un nuovo modello.

Tipi di contenuto supportati da algoritmi integrati

La tabella seguente elenca alcuni dei valori ContentType comunemente supportati e gli algoritmi che li utilizzano:

ContentTypes per algoritmi integrati

Per un riepilogo dei parametri utilizzati da ciascun algoritmo, consulta la documentazione per i singoli algoritmi o questa tabella.

Utilizzo della modalità Pipe

In modalità Pipe, il processo di addestramento trasmette i dati direttamente da Amazon Simple Storage Service (Amazon S3). Lo streaming può fornire tempi di avvio più rapidi per i processi di addestramento e un throughput migliore. Ciò è in contrasto con la Modalità file, in cui i dati di Amazon S3 vengono archiviati nei volumi delle istanze di addestramento. La modalità File utilizza lo spazio su disco per archiviare sia gli artefatti del modello finale che il set di dati di addestramento completo. Trasmettendo i dati direttamente da Amazon S3 in modalità Pipe, riduci le dimensioni dei volumi di Amazon Elastic Block Store delle istanze di addestramento. La modalità Pipe richiede solo lo spazio su disco sufficiente per l'archiviazione degli artefatti del modello finale. Consulta AlgorithmSpecification per ulteriori informazioni sulla modalità di input di addestramento.

Utilizzo del formato CSV

Molti SageMaker algoritmi di Amazon supportano l'addestramento con dati in CSV formato. Per utilizzare i dati in CSV formato per l'addestramento, nella specifica del canale di dati di input, specifica text/csv come. ContentType Amazon SageMaker richiede che un CSV file non abbia un record di intestazione e che la variabile di destinazione sia nella prima colonna. Per eseguire algoritmi di apprendimento non supervisionati che non hanno un target, specifica il numero di colonne di etichette nel tipo di contenuto. Ad esempio, in questo caso 'content_type=text/csv;label_size=0'. Per ulteriori informazioni, consulta Now use Pipe mode con CSV set di dati per un addestramento più rapido sugli algoritmi SageMaker integrati di Amazon.

Utilizzo del formato RecOrdio

Nel formato protobuf RecOrdio, SageMaker converte ogni osservazione nel set di dati in una rappresentazione binaria come set di float da 4 byte, quindi la carica nel campo dei valori protobuf. Se usi Python per la preparazione dei dati, ti consigliamo vivamente di utilizzare queste trasformazioni esistenti. Tuttavia, se si utilizza un'altra lingua, il file di definizione protobuf riportato di seguito fornisce lo schema utilizzato per convertire i dati in formato protobuf. 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;
 }

Dopo aver creato il buffer del protocollo, archivialo in una posizione Amazon S3 a cui SageMaker Amazon può accedere e che può essere trasferita come parte InputDataConfig di. create_training_job

Deserializzazione modello formato

SageMaker I modelli Amazon vengono archiviati come model.tar.gz nel bucket S3 specificato nel OutputDataConfig S3OutputPath parametro della create_training_job chiamata. Il bucket S3 deve trovarsi nella stessa AWS regione dell'istanza del notebook. È possibile specificare la maggior parte di questi artefatti del modello durante la creazione di un modello di hosting. Puoi anche aprirli e rivederli nella tua istanza del notebook. Quando model.tar.gz è untarred, contienemodel_algo-1, che è un oggetto Apache serializzato. MXNet Ad esempio, puoi usare quanto segue per caricare il modello k-means nella memoria e visualizzarlo:

import mxnet as mx
print(mx.ndarray.load('model_algo-1'))