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à.
# Parametri per gli algoritmi integrati
La tabella seguente elenca i parametri per ciascuno degli algoritmi forniti da Amazon SageMaker AI.
| Nome algoritmo | Nome canale | Modalità di input per l'addestramento | Tipo di file | Classe di istanza | Parallelizzabile |
| --- | --- | --- | --- | --- | --- |
| AutoGluon-Tabulare | addestramento e (facoltativamente) convalida | File | CSV | CPU o GPU (solo istanza singola) | No |
| BlazingText | Addestramento | File o Pipe | File di testo (una frase per riga con token separati da spazio) | CPU o GPU (solo istanza singola) | No |
| CatBoost | addestramento e (facoltativamente) convalida | File | CSV | CPU (solo istanza singola) | No |
| Previsioni DeepAR | addestrare e (facoltativamente) testare | File | Linee JSON o parquet | CPU o GPU | Sì |
| Macchine di fattorizzazione | addestrare e (facoltativamente) testare | File o Pipe | recordIO-protobuf | CPU (GPU per dati a densità alta) | Sì |
| Classificazione delle immagini - MXNet | addestra e convalida (facoltativamente) train\$1lst, validation\$1lst e model | File o Pipe | recordIO o file immagine (.jpg o.png) | GPU | Sì |
| Classificazione delle immagini - TensorFlow | Addestramento e convalida | File | file di immagine (.jpg, .jpeg o.png) | CPU o GPU | Sì (solo su più istanze GPUs su una singola istanza) |
| IP Insights | addestramento e (facoltativamente) convalida | File | CSV | CPU o GPU | Sì |
| K-Means | addestrare e (facoltativamente) testare | File o Pipe | recordIO-protobuf o CSV | CPU o GPUCommon (dispositivo GPU singolo su una o più istanze) | No |
| K-Nearest-Neighbors (K-nn) | addestrare e (facoltativamente) testare | File o Pipe | recordIO-protobuf o CSV | CPU o GPU (singolo dispositivo GPU su una o più istanze) | Sì |
| LDA | addestrare e (facoltativamente) testare | File o Pipe | recordIO-protobuf o CSV | CPU (solo istanza singola) | No |
| LightGBM | addestra/addestramento e (facoltativamente) convalida | File | CSV | CPU | Sì |
| Linear Learner | addestra e (facoltativamente) convalida, test o entrambi | File o Pipe | recordIO-protobuf o CSV | CPU o GPU | Sì |
| Modello argomento neurale | addestramento e (facoltativamente) convalida, test o entrambi | File o Pipe | recordIO-protobuf o CSV | CPU o GPU | Sì |
| Object2Vec | addestramento e (facoltativamente) convalida, test o entrambi | File | JSON Lines | CPU o GPU (solo istanza singola) | No |
| Rilevamento di oggetti - MXNet | addestramento e convalida (facoltativamente) train\$1annotation, validation\$1annotation e model | File o Pipe | recordIO o file immagine (.jpg o.png) | GPU | Sì |
| Rilevamento di oggetti - TensorFlow | Addestramento e convalida | File | file di immagine (.jpg, .jpeg o.png) | GPU | Sì (solo su più istanze GPUs su una singola istanza) |
| PCA | addestrare e (facoltativamente) testare | File o Pipe | recordIO-protobuf o CSV | CPU o GPU | Sì |
| Random Cut Forest | addestrare e (facoltativamente) testare | File o Pipe | recordIO-protobuf o CSV | CPU | Sì |
| Segmentazione semantica | addestramento e convalida train\$1annotation, validation\$1annotation e (facoltativamente) label\$1map e model | File o Pipe | File di immagine | GPU (solo istanza singola) | No |
| Modellazione Seq2Seq | addestramento, convalida e vocab | File | recordIO-protobuf | GPU (solo istanza singola) | No |
| TabTransformer | addestramento e (facoltativamente) convalida | File | CSV | CPU o GPU (solo istanza singola) | No |
| Classificazione del testo - TensorFlow | Addestramento e convalida | File | CSV | CPU o GPU | Sì (solo su più istanze GPUs su una singola istanza) |
| XGBoost (0,90-1, 0,90-2, 1,0-1, 1,2-1, 1,2-21) | addestramento e (facoltativamente) convalida | File o Pipe | CSV, libSVM o Parquet | CPU (o GPU per 1.2-1) | Sì |
Gli algoritmi che sono *parallelizzabili* possono essere distribuiti su più istanze di calcolo a scopo di addestramento distribuito.
I seguenti argomenti forniscono informazioni sui formati di dati, sui tipi di istanze Amazon EC2 consigliati e sui CloudWatch log comuni a tutti gli algoritmi integrati forniti da Amazon AI. SageMaker
**Nota**
Per cercare l'immagine URIs Docker degli algoritmi integrati gestiti dall' SageMaker intelligenza artificiale, consulta [Docker](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths) Registry Paths and Example Code.
**Topics**
+ [Formati di dati comuni per l'addestramento](cdf-training.md)
+ [Formati di dati comuni per l’inferenza](cdf-inference.md)
+ [Tipi di istanza per gli algoritmi integrati](cmn-info-instance-types.md)
+ [Log per gli algoritmi integrati](common-info-all-sagemaker-models-logs.md)
# Formati di dati comuni per l'addestramento
Per prepararti alla formazione, puoi preelaborare i dati utilizzando una varietà di AWS servizi, tra cui Amazon EMR AWS Glue, Amazon Redshift, Amazon Relational Database Service e Amazon Athena. Dopo la preelaborazione, pubblica i dati in un bucket di Amazon S3. Per l’addestramento, i dati devono essere sottoposti a una serie di conversioni e trasformazioni, tra cui:
+ Serializzazione dei dati di addestramento (gestita da te)
+ Deserializzazione dei dati di addestramento (gestita dall'algoritmo)
+ Serializzazione del modello di addestramento (gestita dall'algoritmo)
+ Deserializzazione del modello preparato (facoltativo, gestito da te)
Quando utilizzi Amazon SageMaker AI 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.
**Topics**
+ [Tipi di contenuto supportati da algoritmi integrati](#cdf-common-content-types)
+ [Utilizzo della modalità Pipe](#cdf-pipe-mode)
+ [Utilizzare il formato CSV](#cdf-csv-format)
+ [Utilizzo del formato RecOrdio](#cdf-recordio-format)
+ [Deserializzazione modello formato](#td-deserialization)
## Tipi di contenuto supportati da algoritmi integrati
La tabella seguente elenca alcuni dei valori [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) comunemente supportati e gli algoritmi che li utilizzano:
ContentTypes per algoritmi integrati
| ContentType | Algoritmo |
| --- | --- |
| application/x-image | Algoritmo di rilevamento degli oggetti, segmentazione semantica |
| application/x-recordio | Algoritmo di rilevamento oggetti |
| applicazione/ x-recordio-protobuf | Macchine di fattorizzazione, K-Means, K-nn, allocazione latente di Dirichlet, Linear Learner, NTM, PCA, RCF, Sequence-to-Sequence |
| application/jsonlines | BlazingText, DeepAr |
| immagine/jpeg | Algoritmo di rilevamento degli oggetti, segmentazione semantica |
| immagine/png | Algoritmo di rilevamento degli oggetti, segmentazione semantica |
| text/csv | IP Insights, K-Means, k-NN, allocazione latente di Dirichlet, Linear Learner, NTM, PCA, RCF, XGBoost |
| text/libsvm | XGBoost |
Per un riepilogo dei parametri utilizzati da ciascun algoritmo, consulta la documentazione per i singoli algoritmi o questa [tabella](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html).
## 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 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html) per ulteriori informazioni sulla modalità di input di addestramento.
## Utilizzare il formato CSV
Molti algoritmi di SageMaker intelligenza artificiale di Amazon supportano l'addestramento con dati in formato CSV. Per utilizzare i dati in formato CSV per l'addestramento, nella specifica del canale di dati di input, specificare **text/csv** come [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). Amazon SageMaker AI richiede che un file CSV 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\$1type=text/csv;label\$1size=0'**. Per ulteriori informazioni, consulta [Ora usa la modalità Pipe con i set di dati CSV per un addestramento più rapido sugli algoritmi integrati di Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/now-use-pipe-mode-with-csv-datasets-for-faster-training-on-amazon-sagemaker-built-in-algorithms/).
## Utilizzo del formato RecOrdio
Nel formato protobuf ReCordio, SageMaker AI converte ogni osservazione nel set di dati in una rappresentazione binaria come un insieme 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 AI protobuf. SageMaker
**Nota**
Per un esempio che mostra come convertire l'array numPy comune nel formato recordIO protobuf, consulta l'*[introduzione alle macchine di fattorizzazione con 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;
}
```
Dopo aver creato il buffer del protocollo, archivialo in una posizione Amazon S3 a cui SageMaker Amazon AI può accedere e che può essere trasferita come parte `InputDataConfig` di esso. `create_training_job`
**Nota**
Per tutti gli algoritmi di SageMaker intelligenza artificiale di Amazon, l'`ChannelName`input `InputDataConfig` deve essere impostato `train` su. Anche alcuni algoritmi supportano una convalida o un test `input channels`. Sono in genere utilizzati per valutare le prestazioni del modello utilizzando un set di dati di controllo. I set di dati controllo non sono utilizzati nell'addestramento iniziale, ma possono essere utilizzati per perfezionare ulteriormente il modello.
## Deserializzazione modello formato
I modelli Amazon SageMaker AI sono 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, contiene`model_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'))
```
# Formati di dati comuni per l’inferenza
Gli algoritmi di SageMaker intelligenza artificiale di Amazon accettano e producono diversi tipi MIME per i payload HTTP utilizzati per recuperare previsioni online e in mini-batch. Puoi utilizzare più AWS servizi per trasformare o preelaborare i record prima di eseguire l'inferenza. Come minimo, devi convertire i dati per quanto segue:
+ Serializzazione richiesta di inferenza (gestita da te)
+ Deserializzazione richiesta di inferenza (gestita dall'algoritmo)
+ Serializzazione risposta di inferenza (gestita dall'algoritmo)
+ Deserializzazione risposta di inferenza (gestita da te)
**Topics**
+ [Conversione dei dati per la serializzazione delle richieste di inferenza](#ir-serialization)
+ [Conversione dei dati per la deserializzazione delle risposte di inferenza](#ir-deserialization)
+ [Formati di richiesta comuni per tutti gli algoritmi](#common-in-formats)
+ [Utilizzo della trasformazione in batch con gli algoritmi integrati](#cm-batch)
## Conversione dei dati per la serializzazione delle richieste di inferenza
Le opzioni relative SageMaker ai tipi di contenuto per le richieste di inferenza dell'algoritmo di Amazon AI includono: `text/csv``application/json`, e`application/x-recordio-protobuf`. Gli algoritmi che non supportano tutti questi tipi possono supportarne altri. XGBoost, ad esempio, supporta solo i supporti `text/csv` di questo elenco, ma supporta `text/libsvm` anche.
Per `text/csv` il valore dell'argomento corpo a `invoke_endpoint` deve essere una stringa con delle virgole che separano i valori di ogni funzionalità. Ad esempio, un record per un modello con quattro funzionalità potrebbe essere simile a `1.5,16.0,14,23.0`. Qualsiasi trasformazione eseguita sui dati dell'addestramento deve essere eseguita sui dati prima di ottenere l'inferenza. L'ordine delle funzionalità è rilevante e non deve essere modificato.
`application/json` è molto più flessibile e offre diversi formati possibili che gli sviluppatori possono utilizzare nelle loro applicazioni. A un livello elevato, in JavaScript, il payload potrebbe essere simile al seguente:
```
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
}
}
]
}
```
Hai le seguenti opzioni per specificare `dataElement`:
**Equivalenti buffer di protocollo**
```
// Has the same format as the protocol buffers implementation described for training.
let dataElement = {
"keys": [],
"values": [],
"shape": []
}
```
**Vettore numerico semplice**
```
// 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
}
}
```
**Per record multipli**
```
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 ]
}
]
}
```
## Conversione dei dati per la deserializzazione delle risposte di inferenza
Gli algoritmi di SageMaker intelligenza artificiale di Amazon restituiscono JSON in diversi layout. Ad alto livello, la struttura è:
```
let response = {
"predictions": [{
// Fields in the response object are defined on a per algorithm-basis.
}]
}
```
I campi inclusi nelle previsioni presentano differisce nei diversi algoritmi. Seguono degli esempi di output per l'algoritmo k-means.
**Inferenza singolo record**
```
let response = {
"predictions": [{
"closest_cluster": 5,
"distance_to_cluster": 36.5
}]
}
```
**Inferenza multi-record**
```
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
}
]
}
```
**Inferenza multi-record con input 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 Gli algoritmi di intelligenza artificiale supportano anche il formato JSONLINES, in cui il contenuto della risposta per record è lo stesso del formato JSON. La struttura multi-record è una raccolta di oggetti di risposta per record separati da caratteri di nuova riga. Il contenuto della risposta per l' KMeans algoritmo integrato per 2 punti dati di input è:
```
{"distance_to_cluster": 23.40593910217285, "closest_cluster": 0.0}
{"distance_to_cluster": 27.250282287597656, "closest_cluster": 0.0}
```
Durante l'esecuzione della trasformazione in batch, consigliamo di utilizzare il tipo di risposta `jsonlines` impostando il campo `Accept` in `CreateTransformJobRequest` su `application/jsonlines`.
## Formati di richiesta comuni per tutti gli algoritmi
La maggior parte degli algoritmi utilizza molti dei seguenti formati di richiesta di inferenza.
### Formato della richiesta JSON
**Content type:** application/JSON
**Formato a densità alta**
```
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]
}
}
}
]
}
```
**Formato a densità bassa**
```
{
"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]
}
}
},
]
}
```
### Formato della richiesta JSONLINES
**Content type:** application/JSONLINES
**Formato a densità alta**
Un singolo record in formato a densità alta può essere rappresentato come:
```
{ "features": [1.5, 16.0, 14.0, 23.0] }
```
oppure:
```
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
```
**Formato a densità bassa**
Un singolo record in formato a densità bassa è rappresentato come:
```
{"data": {"features": { "keys": [26, 182, 232, 243, 431], "shape": [2000], "values": [1, 1, 1, 4, 1] } } }
```
Più record sono rappresentati come una raccolta delle rappresentazioni di record singolo, separate da caratteri di nuova riga:
```
{"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] }
```
### Formato della richiesta CSV
**Content type:** text/CSV; label\$1size=0
**Nota**
Il supporto CSV non è disponibile per la fattorizzazione delle macchine.
### Formato della richiesta RECORDIO
Tipo di contenuto: applicazione/ x-recordio-protobuf
## Utilizzo della trasformazione in batch con gli algoritmi integrati
Durante l'esecuzione della trasformazione in batch, consigliamo di utilizzare il tipo di risposta JSONLINES anziché JSON, se supportato dall'algoritmo. A tale scopo, imposta il campo `Accept` in `CreateTransformJobRequest` su `application/jsonlines`.
Quando crei un processo di trasformazione, `SplitType` deve essere impostato in base al `ContentType` dei dati di input. Analogamente, `AssembleWith` deve essere impostato in base al campo `Accept` in `CreateTransformJobRequest`. Per impostare questi campi, utilizza la tabella seguente:
| ContentType | Consigliato SplitType |
| --- | --- |
| application/x-recordio-protobuf | RecordIO |
| text/csv | Line |
| application/jsonlines | Line |
| application/json | None |
| application/x-image | None |
| image/\$1 | None |
| Accettare | Consigliato AssembleWith |
| --- | --- |
| application/x-recordio-protobuf | None |
| application/json | None |
| application/jsonlines | Line |
Per ulteriori informazioni sui formati di risposta per determinati algoritmi, consulta quanto segue:
+ [Formati di inferenza DeepAR](deepar-in-formats.md)
+ [Formati di risposta delle macchine di fattorizzazione](fm-in-formats.md)
+ [Formati di dati di inferenza di IP Insights](ip-insights-inference-data-formats.md)
+ [Formati di risposta k-Means](km-in-formats.md)
+ [Formati di richieste e risposte k-NN](kNN-inference-formats.md)
+ [Formati di risposta di Linear Learner](LL-in-formats.md)
+ [Formati della risposta NTM](ntm-in-formats.md)
+ [Formati dei dati per l'inferenza Object2Vec](object2vec-inference-formats.md)
+ [Incorporamenti del codificatore per Object2Vec](object2vec-encoder-embeddings.md)
+ [Formati della risposta PCA](PCA-in-formats.md)
+ [Formati della risposta RCF](rcf-in-formats.md)
# Tipi di istanza per gli algoritmi integrati
La maggior parte degli algoritmi di SageMaker intelligenza artificiale di Amazon è stata progettata per sfruttare l'elaborazione tramite GPU per la formazione. Nonostante i costi più elevati per istanza, i corsi di GPUs formazione sono più rapidi, il che li rende più convenienti. Le eccezioni sono riportate in questa guida.
Per ulteriori informazioni sulle istanze EC2 supportate, consulta [Dettagli dell’istanza](https://aws.amazon.com/sagemaker-ai/pricing/#Instance_details).
La dimensione e il tipo di dati possono avere conseguenze su quale configurazione hardware è più efficace. Quando lo stesso modello è addestrato su base ricorrente, il testing iniziale su un'ampia gamma di tipi di istanza può rilevare configurazioni che sono più convenienti a lungo termine. Inoltre, gli algoritmi che si allenano nel modo più efficiente GPUs potrebbero non GPUs richiedere un'inferenza efficiente. Esercitati per determinare la soluzione più conveniente dal punto di vista dei costi. Per ottenere una raccomandazione automatica sull'istanza o eseguire test di carico personalizzati, usa [Amazon SageMaker Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html).
Per ulteriori informazioni sulle specifiche hardware di SageMaker intelligenza artificiale, consulta [i prezzi di Amazon SageMaker AI](https://aws.amazon.com/sagemaker/ai/pricing/).
**UltraServers**
UltraServers collega più istanze Amazon EC2 utilizzando un'interconnessione acceleratrice a bassa latenza e larghezza di banda elevata. Sono progettati per gestire carichi di lavoro su larga scala che richiedono una potenza di elaborazione significativa. AI/ML Per ulteriori informazioni, consulta [Amazon EC2 UltraServers](https://aws.amazon.com/ec2/ultraservers/). Per iniziare UltraServers, consulta [Prenotare piani di formazione per i tuoi job o HyperPod cluster di formazione](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html).
Per iniziare a usare UltraServers Amazon SageMaker AI, [crea un piano di formazione](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html). Una volta UltraServer che il tuo è disponibile nel piano di formazione, crea un lavoro di formazione con l' Console di gestione AWS API Amazon SageMaker AI o AWS CLI. Ricordati di specificare il tipo di UltraServer istanza che hai acquistato nel piano di formazione.
E UltraServer può eseguire uno o più lavori alla volta. UltraServers raggruppa le istanze, il che offre una certa flessibilità in termini di allocazione delle UltraServer capacità all'interno dell'organizzazione. Durante la configurazione dei lavori, ricorda anche le linee guida sulla sicurezza dei dati della tua organizzazione, poiché le istanze di una di esse UltraServer possono accedere ai dati di un altro lavoro in un'altra istanza sulla stessa. UltraServer
Se riscontri un guasto hardware in UltraServer, l' SageMaker IA tenta automaticamente di risolvere il problema. Man mano che l' SageMaker IA indaga e risolve il problema, potresti ricevere notifiche e azioni tramite Eventi o. AWS Health Supporto AWS
Una volta terminato il processo di formazione, l' SageMaker intelligenza artificiale interrompe le istanze, ma queste rimangono disponibili nel piano di formazione se il piano è ancora attivo. Per mantenere UltraServer attiva un'istanza al termine di un processo, puoi utilizzare [pool caldi gestiti](https://docs.aws.amazon.com/sagemaker/latest/dg/train-warm-pools.html).
Se il tuo piano di formazione ha una capacità sufficiente, puoi persino eseguire diversi lavori di formazione su più livelli UltraServers. Per impostazione predefinita, ogni istanza UltraServer è dotata di 18 istanze, di cui 17 istanze e 1 istanza di riserva. Se hai bisogno di più istanze, devi acquistarne altre. UltraServers Quando si crea un lavoro di formazione, è possibile configurare il modo in cui i lavori vengono posizionati UltraServers utilizzando il `InstancePlacementConfig` parametro.
Se non configuri l'inserimento lavorativo, l' SageMaker IA assegna automaticamente i lavori alle istanze all'interno del tuo. UltraServer Questa strategia predefinita si basa sul massimo impegno e dà priorità al riempimento di tutte le istanze in un'unica UltraServer istanza prima di utilizzarne un'altra. UltraServer Ad esempio, se richiedi 14 istanze e ne hai 2 UltraServers nel tuo piano di allenamento, l' SageMaker IA utilizza tutte le istanze della prima. UltraServer Se hai richiesto 20 istanze e ne hai 2 UltraServers nel tuo piano di allenamento, l' SageMaker IA utilizzerà tutte le 17 istanze nella prima UltraServer e poi ne utilizzerà 3 nella seconda. UltraServer Le istanze utilizzate NVLink per comunicare, ma individuali UltraServer UltraServers utilizzano Elastic Fabric Adapter (EFA), che potrebbe influire sulle prestazioni di addestramento dei modelli.
# Log per gli algoritmi integrati
Gli algoritmi di SageMaker intelligenza artificiale di Amazon producono CloudWatch log di Amazon, che forniscono informazioni dettagliate sul processo di formazione. **Per visualizzare i log, nella console di AWS gestione, scegli, scegli **Logs **CloudWatch****, quindi scegli il gruppo/log. aws/sagemaker/TrainingJobs** Ogni processo di addestramento ha un flusso di log per ogni nodo su cui è stato addestrato. Il nome del flusso di log inizia con il valore specificato nel parametro `TrainingJobName` al momento della creazione del processo.
**Nota**
Se un processo fallisce e i log non vengono visualizzati CloudWatch, è probabile che si sia verificato un errore prima dell'inizio dell'allenamento. I motivi includono la specificazione dell'immagine di addestramento o la posizione S3 sbagliata.
I contenuti dei log variano in base all'algoritmo. Tuttavia, in genere puoi trovare le informazioni riportate di seguito:
+ La conferma degli argomenti forniti all'inizio del log
+ Errori durante l'addestramento
+ Misurazione dell'accuratezza di un algoritmo e prestazione numerica
+ Tempistiche dell'algoritmo e le sue principali fasi
## Errori comuni
Se un processo di addestramento ha esito negativo, alcune informazioni sul fallimento vengono fornite dal valore restituito `FailureReason` nella descrizione del processo di addestramento, come segue:
```
sage = boto3.client('sagemaker')
sage.describe_training_job(TrainingJobName=job_name)['FailureReason']
```
Gli altri sono riportati solo nei CloudWatch log. Gli errori più comuni sono i seguenti:
1. La specificazione sbagliata di un iperparametro o la specificazione di un iperparametro non valido per l'algoritmo.
**Dal registro CloudWatch **
```
[10/16/2017 23:45:17 ERROR 139623806805824 train.py:48]
Additional properties are not allowed (u'mini_batch_siz' was
unexpected)
```
1. Specificazione di un valore non valido per un iperparametro.
**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. Formato file protobuf inaccurato.
**Dal CloudWatch registro**
```
[10/17/2017 18:01:04 ERROR 140234860816192 train.py:48] cannot
copy sequence with size 785 to array axis with dimension 784
```