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à.
# Creazione di un container con algoritmi e modelli personalizzati
Se nessuno dei contenitori SageMaker AI esistenti soddisfa le tue esigenze e non disponi di un contenitore esistente, potresti dover creare un nuovo contenitore Docker. Le sezioni seguenti mostrano come creare contenitori Docker con i tuoi algoritmi di addestramento e inferenza da utilizzare con l'intelligenza artificiale. SageMaker
**Topics**
+ [Container con algoritmi di addestramento personalizzati](your-algorithms-training-algo.md)
+ [Container con codice di inferenza personalizzato](your-algorithms-inference-main.md)
# Container con algoritmi di addestramento personalizzati
Questa sezione spiega come Amazon SageMaker AI interagisce con un contenitore Docker che esegue il tuo algoritmo di addestramento personalizzato. Utilizza queste informazioni per scrivere codice di addestramento e creare un'immagine Docker per i tuoi algoritmi di addestramento.
**Topics**
+ [In che modo Amazon SageMaker AI gestisce la tua immagine di formazione](your-algorithms-training-algo-dockerfile.md)
+ [In che modo Amazon SageMaker AI fornisce informazioni sulla formazione](your-algorithms-training-algo-running-container.md)
+ [Esecuzione di un addestramento con EFA](your-algorithms-training-efa.md)
+ [In che modo Amazon SageMaker AI segnala il successo e il fallimento di un algoritmo](your-algorithms-training-signal-success-failure.md)
+ [In che modo Amazon SageMaker AI elabora i risultati della formazione](your-algorithms-training-algo-output.md)
# In che modo Amazon SageMaker AI gestisce la tua immagine di formazione
Puoi utilizzare uno script del punto di ingresso personalizzato per automatizzare l'infrastruttura per l'addestramento in un ambiente di produzione. Se passi lo script entrypoint nel contenitore Docker, puoi anche eseguirlo come script autonomo senza ricostruire le immagini. SageMaker L'intelligenza artificiale elabora l'immagine di allenamento utilizzando uno script entrypoint del contenitore Docker.
In questa sezione viene descritto come utilizzare un punto di ingresso personalizzato senza utilizzare il toolkit. [Se desideri utilizzare un punto di ingresso personalizzato ma non hai familiarità con la configurazione manuale di un contenitore Docker, ti consigliamo di utilizzare invece la libreria di strumenti di formazione. SageMaker ](https://github.com/aws/sagemaker-training-toolkit) Per ulteriori informazioni su come utilizzare il toolkit di addestramento, consulta [Adattamento del container di addestramento](adapt-training-container.md).
Per impostazione predefinita, l' SageMaker intelligenza artificiale cerca uno script chiamato all'interno del contenitore. `train` Puoi anche fornire manualmente il tuo punto di ingresso personalizzato utilizzando i `ContainerEntrypoint` parametri `ContainerArguments` e dell'[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API.
Sono disponibili le due opzioni seguenti per configurare manualmente il container Docker per l'esecuzione della tua immagine.
+ Utilizza l'[CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API e un contenitore Docker con un'istruzione entrypoint contenuta al suo interno.
+ Usa l'API `CreateTrainingJob` e trasmetti lo script di addestramento dall'esterno del tuo container Docker.
Se inoltri lo script di addestramento dall'esterno del tuo container Docker, non devi ricostruire il container Docker quando aggiorni lo script. Puoi anche utilizzare diversi script da eseguire nello stesso container.
Lo script del punto di ingresso deve contenere il codice di addestramento per l'immagine. Se utilizzi il parametro opzionale `source_dir` all'interno di uno [strumento di valutazione](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html), dovrebbe fare riferimento al percorso Amazon S3 relativo alla cartella contenente lo script del punto di ingresso. Puoi fare riferimento a più file utilizzando il parametro `source_dir`. Se non utilizzi `source_dir`, puoi specificare il punto di ingresso utilizzando il parametro `entry_point`. Per un esempio di script entrypoint personalizzato che contiene uno stimatore, consulta [Bring Your Own](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-script-mode/sagemaker-script-mode.html) Model with AI Script Model. SageMaker
SageMaker L'addestramento sui modelli AI supporta i bucket di directory S3 Express One Zone ad alte prestazioni come posizione di input dei dati per la modalità file, la modalità file veloce e la modalità pipe. È anche possibile utilizzare i bucket di directory S3 Express One Zone per archiviare l’output dell’addestramento. Per utilizzare S3 Express One Zone, fornisci l’URI di un bucket di directory S3 Express One Zone anziché di un bucket Amazon S3 per uso generico. Puoi crittografare i dati di output SageMaker AI solo in bucket di directory con crittografia lato server con chiavi gestite di Amazon S3 (SSE-S3). La crittografia lato server con AWS KMS chiavi (SSE-KMS) non è attualmente supportata per l'archiviazione dei dati di output AI nei bucket di directory. SageMaker Per ulteriori informazioni, consulta [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html).
## Esecuzione di un processo di addestramento con uno script del punto di ingresso incluso nel container Docker
SageMaker L'intelligenza artificiale può eseguire uno script di ingresso incluso nel contenitore Docker.
+ Per impostazione predefinita, Amazon SageMaker AI esegue il seguente contenitore.
```
docker run image train
```
+ SageMaker L'intelligenza artificiale sostituisce qualsiasi istruzione [CMD](https://docs.docker.com/engine/reference/builder/#cmd) predefinita in un contenitore specificando l'`train`argomento dopo il nome dell'immagine. Nel tuo container Docker, usa il seguente modulo `exec` dell'istruzione `ENTRYPOINT`.
```
ENTRYPOINT ["executable", "param1", "param2", ...]
```
L'esempio seguente illustra come specificare un'istruzione di punto di ingresso python chiamata `k-means-algorithm.py`.
```
ENTRYPOINT ["python", "k-means-algorithm.py"]
```
Il modulo `exec` dell'istruzione `ENTRYPOINT` avvia l'eseguibile direttamente, non come figlio di `/bin/sh`. Ciò gli consente di ricevere segnali simili e provenienti da. `SIGTERM` `SIGKILL` SageMaker APIs Le seguenti condizioni si applicano quando si utilizza il SageMaker APIs.
+ L'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API presenta una condizione di arresto che impone all' SageMaker IA di interrompere l'addestramento dei modelli dopo un periodo di tempo specifico.
+ Quanto segue mostra l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html). Questo API rilascia l'equivalente del comando `docker stop`, con un timeout di due minuti, per arrestare in modo normale il container specificato.
```
docker stop -t 120
```
Il comando tenta di arrestare il container in esecuzione inviando un segnale `SIGTERM`. Dopo il timeout di 2 minuti, l'API invia `SIGKILL` e blocca forzatamente i container. Se il container gestisce il segnale `SIGTERM` normalmente ed esce entro 120 secondi dalla ricezione, non viene inviato alcun segnale `SIGKILL`.
Se desideri accedere agli artefatti intermedi del modello dopo che l' SageMaker IA ha interrotto l'addestramento, aggiungi il codice per gestire il salvataggio degli artefatti nel tuo gestore. `SIGTERM`
+ Se prevedi di utilizzare i dispositivi GPU per l’addestramento del modello, assicurati che i tuoi container siano compatibili con `nvidia-docker`. Includi soltanto il tooklit CUDA sui container; non raggruppare i driver NVIDIA con l'immagine. Per ulteriori informazioni su `nvidia-docker`, consulta [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
+ Non puoi usare l'`tini`inizializzatore come script di ingresso nei contenitori SageMaker AI perché viene confuso dagli argomenti and. `train` `serve`
+ `/opt/ml`e tutte le sottodirectory sono riservate tramite training. SageMaker Quando crei l'immagine Docker del tuo algoritmo, assicurati di non inserire in questa directory i dati richiesti dall'algoritmo. Se lo fai, i dati potrebbero non essere più visibili durante l'addestramento.
Per raggruppare gli script di shell o Python all'interno dell'immagine Docker o per fornire lo script in un bucket Amazon S3 o utilizzando (CLI), continua con AWS Command Line Interface la sezione seguente.
### Raggruppa lo script di shell (interprete di comandi) in un container Docker
Se desideri raggruppare uno script di shell personalizzato all'interno della tua immagine Docker, completa la seguente procedura.
1. Copia lo script di shell (interprete di comandi) dalla directory di lavoro all'interno del container Docker. Il seguente frammento di codice copia uno script del punto di ingresso personalizzato `custom_entrypoint.sh` dalla directory di lavoro corrente a un container Docker situato in `mydir`. L'esempio seguente presuppone che nell'immagine Docker di base sia installato Python.
```
FROM :
# Copy custom entrypoint from current dir to /mydir on container
COPY ./custom_entrypoint.sh /mydir/
```
1. Crea e invia con notifica push un container Docker all’Amazon Elastic Container Registry ([Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) seguendo le istruzioni riportate nella sezione [Push di un’immagine Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) nella Guida per l’utente *Amazon ECR*.
1. Avvia il processo di formazione eseguendo il comando seguente. AWS CLI
```
aws --region sagemaker create-training-job \
--training-job-name \
--role-arn \
--algorithm-specification '{ \
"TrainingInputMode": "File", \
"TrainingImage": "", \
"ContainerEntrypoint": ["/bin/sh"], \
"ContainerArguments": ["/mydir/custom_entrypoint.sh"]}' \
--output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \
--resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \
--stopping-condition '{"MaxRuntimeInSeconds": 180}'
```
### Raggruppa il tuo script Python in un container Docker
Per raggruppare uno script Python personalizzato all'interno della tua immagine Docker, completa la seguente procedura.
1. Copia lo script Python dalla tua directory di lavoro all'interno del tuo container Docker. Il seguente frammento di codice copia uno script del punto di ingresso personalizzato `custom_entrypoint.py` dalla directory di lavoro corrente a un container Docker situato in `mydir`.
```
FROM :
# Copy custom entrypoint from current dir to /mydir on container
COPY ./custom_entrypoint.py /mydir/
```
1. Avvia il processo di formazione eseguendo il AWS CLI comando seguente.
```
--algorithm-specification '{ \
"TrainingInputMode": "File", \
"TrainingImage": "", \
"ContainerEntrypoint": ["python"], \
"ContainerArguments": ["/mydir/custom_entrypoint.py"]}' \
```
## Esecuzione di un processo di addestramento con uno script del punto di ingresso al di fuori del container Docker
Puoi usare il tuo container Docker per l’addestramento e inserire uno script del punto di ingresso dall'esterno del container Docker. Ci sono alcuni vantaggi nello strutturare lo script del punto di ingresso all'esterno del container. Se aggiorni lo script di ingresso, non devi ricostruire il container Docker. Puoi anche utilizzare diversi script da eseguire nello stesso container.
Specificate la posizione dello script di formazione utilizzando i `ContainerArguments` parametri `ContainerEntrypoint` e dell'[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API. Questi punti di ingresso e argomenti si comportano allo stesso modo dei punti di ingresso e degli argomenti Docker. I valori di questi parametri hanno la precedenza su quelli corrispondenti `ENTRYPOINT` o `CMD` forniti come parte del container Docker.
Quando inoltrii il tuo script del punto di ingresso personalizzato al tuo container di addestramento Docker, gli input forniti determinano il comportamento del container.
+ Ad esempio, se fornite solo`ContainerEntrypoint`, la sintassi della richiesta che utilizza l' CreateTrainingJob API è la seguente.
```
{
"AlgorithmSpecification": {
"ContainerEntrypoint": ["string"],
...
}
}
```
Quindi, il backend SageMaker di formazione esegue il punto di ingresso personalizzato come segue.
```
docker run --entrypoint image
```
**Nota**
Se `ContainerEntrypoint` fornito, il backend di SageMaker formazione esegue l'immagine con il punto di ingresso specificato e sostituisce l'impostazione predefinita nell'immagine. `ENTRYPOINT`
+ Se fornisci solo`ContainerArguments`, SageMaker AI presuppone che il contenitore Docker contenga uno script di ingresso. La sintassi della richiesta che utilizza l'API `CreateTrainingJob` è la seguente.
```
{
"AlgorithmSpecification": {
"ContainerArguments": ["arg1", "arg2"],
...
}
}
```
Il backend SageMaker di formazione esegue il punto di ingresso personalizzato come segue.
```
docker run image
```
+ Se fornisci sia l’opzione `ContainerEntrypoint` che `ContainerArguments`, la sintassi della richiesta tramite l'API `CreateTrainingJob` è la seguente.
```
{
"AlgorithmSpecification": {
"ContainerEntrypoint": ["string"],
"ContainerArguments": ["arg1", "arg2"],
...
}
}
```
Il backend SageMaker di formazione gestisce il punto di ingresso personalizzato come segue.
```
docker run --entrypoint image
```
Puoi utilizzare qualsiasi origine `InputDataConfig` supportata nell'API `CreateTrainingJob` per fornire uno script del punto di ingresso per eseguire la tua immagine di addestramento.
### Inserimento dello script del tuo punto di ingresso in un bucket Amazon S3
Per fornire uno script entrypoint personalizzato utilizzando un bucket S3, utilizza il `S3DataSource` parametro dell'[DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)API per specificare la posizione dello script. Se utilizzi il parametro `S3DataSource`, i seguenti requisiti sono necessari.
+ [InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)Deve essere del tipo. `File`
+ L'[S3 DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource) deve essere`FullyReplicated`.
L'esempio seguente presenta uno script chiamato custom\$1entrypoint.sh inserito nel percorso di un bucket S3 `s3:////custom_entrypoint.sh`.
```
#!/bin/bash
echo "Running custom_entrypoint.sh"
echo "Hello you have provided the following arguments: " "$@"
```
Successivamente, devi impostare la configurazione del canale dati di input per eseguire un processo di addestramento. Fatelo utilizzando AWS CLI direttamente o con un file JSON.
#### Configura il canale dati di input utilizzando AWS CLI un file JSON
Per configurare il canale dati di input con un file JSON, utilizzate AWS CLI come mostrato nella seguente struttura di codice. Assicurati che tutti i seguenti campi utilizzino la sintassi della richiesta definita nell'[CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)API.
```
// run-my-training-job.json
{
"[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-AlgorithmSpecification)": {
"ContainerEntrypoint": ["/bin/sh"],
"ContainerArguments": ["/opt/ml/input/data//custom_entrypoint.sh"],
...
},
"[InputDataConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-InputDataConfig)": [
{
"[ChannelName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-ChannelName)": "",
"[DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-DataSource)": {
"[S3DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)": {
"[S3DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataDistributionType)": "FullyReplicated",
"[S3DataType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataType)": "S3Prefix",
"[S3Uri](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3Uri)": "s3:///"
}
},
"[InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)": "File",
},
...]
}
```
Quindi, esegui il AWS CLI comando per avviare il processo di formazione dal file JSON come segue.
```
aws sagemaker create-training-job --cli-input-json file://run-my-training-job.json
```
#### Configura il canale dati di input utilizzando direttamente AWS CLI
Per configurare il canale dati di input senza un file JSON, utilizzate la seguente struttura di AWS CLI codice.
```
aws --region sagemaker create-training-job \
--training-job-name \
--role-arn \
--algorithm-specification '{ \
"TrainingInputMode": "File", \
"TrainingImage": "", \
"ContainerEntrypoint": ["/bin/sh"], \
"ContainerArguments": ["/opt/ml/input/data//custom_entrypoint.sh"]}' \
--input-data-config '[{ \
"ChannelName":"", \
"DataSource":{ \
"S3DataSource":{ \
"S3DataType":"S3Prefix", \
"S3Uri":"s3:///", \
"S3DataDistributionType":"FullyReplicated"}}}]' \
--output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \
--resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \
--stopping-condition '{"MaxRuntimeInSeconds": 180}'
```
# In che modo Amazon SageMaker AI fornisce informazioni sulla formazione
Questa sezione spiega come l' SageMaker intelligenza artificiale rende disponibili le informazioni sulla formazione, come dati di addestramento, iperparametri e altre informazioni di configurazione, nel contenitore Docker.
Quando invii una [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)richiesta all' SageMaker IA per avviare l'addestramento del modello, specifichi il percorso Amazon Elastic Container Registry (Amazon ECR) dell'immagine Docker che contiene l'algoritmo di addestramento. È inoltre necessario specificare la posizione di Amazon Simple Storage Service (Amazon S3) in cui vengono archiviati i dati di addestramento e i parametri specifici dell'algoritmo. SageMaker L'intelligenza artificiale mette queste informazioni a disposizione del contenitore Docker in modo che l'algoritmo di addestramento possa utilizzarle. Questa sezione spiega come rendere queste informazioni disponibili al tuo container Docker. Per informazioni sulla creazione di un processo di addestramento, consulta `CreateTrainingJob`. Per ulteriori informazioni sul modo in cui i contenitori SageMaker AI organizzano le informazioni, consulta[SageMaker Toolkit di formazione e inferenza](amazon-sagemaker-toolkits.md).
**Topics**
+ [Iperparametri](#your-algorithms-training-algo-running-container-hyperparameters)
+ [Variabili di ambiente](#your-algorithms-training-algo-running-container-environment-variables)
+ [Configurazione dei dati di input](#your-algorithms-training-algo-running-container-inputdataconfig)
+ [Dati di addestramento](#your-algorithms-training-algo-running-container-trainingdata)
+ [Configurazione dell’addestramento distribuito](#your-algorithms-training-algo-running-container-dist-training)
## Iperparametri
SageMaker L'intelligenza artificiale rende disponibili gli iperparametri di una `CreateTrainingJob` richiesta nel contenitore Docker del `/opt/ml/input/config/hyperparameters.json` file.
Di seguito è riportato un esempio di configurazione iperparametrica in `hyperparameters.json` per specificare gli `num_round` e gli `eta` iperparametri nell'operazione per. `CreateTrainingJob` [XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html)
```
{
"num_round": "128",
"eta": "0.001"
}
```
[Per un elenco completo degli iperparametri che possono essere utilizzati per l' XGBoost algoritmo integrato di SageMaker intelligenza artificiale, vedi Iperparametri. XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost_hyperparameters.html)
Gli iperparametri che puoi ottimizzare dipendono dall'algoritmo che stai addestrando. Per un elenco degli iperparametri disponibili per un algoritmo integrato di SageMaker intelligenza artificiale, trovali elencati in **Iperparametri** sotto il link dell'algoritmo in Use [Amazon SageMaker AI Built-in Algorithms or](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html) Pre-training Models.
## Variabili di ambiente
SageMaker L'intelligenza artificiale imposta le seguenti variabili di ambiente nel tuo contenitore:
+ TRAINING\$1JOB\$1NAME: specificato nel parametro `TrainingJobName` della richiesta `CreateTrainingJob`.
+ TRAINING\$1JOB\$1ARN: il nome della risorsa Amazon (ARN) del processo di addestramento restituito come `TrainingJobArn` nella risposta `CreateTrainingJob`.
+ Tutte le variabili di ambiente specificate nel parametro [Ambiente](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-Environment) nella richiesta `CreateTrainingJob`.
## Configurazione dei dati di input
SageMaker L'intelligenza artificiale rende disponibili le informazioni sul canale dati contenute nel `InputDataConfig` parametro della `CreateTrainingJob` richiesta nel `/opt/ml/input/config/inputdataconfig.json` file nel contenitore Docker.
Ad esempio, supponiamo di specificare tre canali di dati (`train``evaluation`, e`validation`) nella richiesta. SageMaker L'IA fornisce il seguente codice JSON:
```
{
"train" : {"ContentType": "trainingContentType",
"TrainingInputMode": "File",
"S3DistributionType": "FullyReplicated",
"RecordWrapperType": "None"},
"evaluation" : {"ContentType": "evalContentType",
"TrainingInputMode": "File",
"S3DistributionType": "FullyReplicated",
"RecordWrapperType": "None"},
"validation" : {"TrainingInputMode": "File",
"S3DistributionType": "FullyReplicated",
"RecordWrapperType": "None"}
}
```
**Nota**
SageMaker L'intelligenza artificiale fornisce al contenitore solo informazioni pertinenti su ciascun canale di dati (ad esempio, il nome del canale e il tipo di contenuto), come mostrato nell'esempio precedente. `S3DistributionType`verrà impostato come `FullyReplicated` se si specificasse EFS o FSx Lustre come origini dati di input.
## Dati di addestramento
Il parametro `TrainingInputMode` nella `AlgorithmSpecification` della richiesta [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) specifica in che modo il set di dati di addestramento viene reso disponibile per il container. Sono disponibili le modalità di input seguenti:
+ **Modalità `File`**
Se usi `File` mode come `TrainingInputMode` valore, SageMaker AI imposta i seguenti parametri nel tuo contenitore.
+ Il parametro `TrainingInputMode` viene scritto in `inputdataconfig.json` come "File".
+ La directory del tuo canale dati viene scritta in `/opt/ml/input/data/channel_name`.
Se utilizzi `File` la modalità, l' SageMaker IA crea una directory per ogni canale. Ad esempio, se hai tre canali denominati `training``validation`, e`testing`, SageMaker AI crea le seguenti tre directory nel tuo contenitore Docker:
+ `/opt/ml/input/data/training`
+ `/opt/ml/input/data/validation`
+ `/opt/ml/input/data/testing`
La modalità `File` supporta le seguenti origini dati.
+ Amazon Simple Storage Service (Amazon S3)
+ Amazon Elastic File System (Amazon EFS)
+ Amazon FSx per Lustre
**Nota**
I canali che utilizzano fonti di dati di file system come Amazon EFS e Amazon FSx devono utilizzare `File` la modalità. In questo caso, il percorso della directory fornito nel canale viene montato in `/opt/ml/input/data/channel_name`.
+ **Modalità `FastFile`**
Se utilizzi la `FastFile` modalità come modalità`TrainingInputNodeParameter`, l' SageMaker intelligenza artificiale imposta i seguenti parametri nel tuo contenitore.
+ Analogamente alla modalità `File`, nella modalità `FastFile` il tuo parametro `TrainingInputMode` viene scritto in `inputdataconfig.json` come "File".
+ La directory del tuo canale dati viene scritta in `/opt/ml/input/data/channel_name`.
La modalità `FastFile` supporta le seguenti origini dati.
+ Simple Storage Service (Amazon S3)
Se utilizzi la modalità `FastFile`, la directory dei canali viene montata con l'autorizzazione di sola lettura.
Storicamente, la modalità `File` precedeva la modalità `FastFile`. Per garantire la compatibilità con le versioni precedenti, gli algoritmi che supportano la modalità `File` possono funzionare senza problemi anche con la modalità `FastFile`, purché il parametro `TrainingInputMode` sia impostato su `File` in `inputdataconfig.json.`.
**Nota**
I canali che utilizzano la modalità `FastFile` devono utilizzare un `S3DataType` di "S3Prefix".
La modalità `FastFile` presenta una visualizzazione di cartelle che utilizza la barra in avanti (`/`) come delimitatore per raggruppare oggetti Amazon S3 nelle cartelle. I prefissi `S3Uri` non devono corrispondere a un nome parziale di cartella. Ad esempio, se un set di dati Amazon S3 contiene `s3://amzn-s3-demo-bucket/train-01/data.csv`, allora non sono consentiti né `s3://amzn-s3-demo-bucket/train` né `s3://amzn-s3-demo-bucket/train-01` come prefissi `S3Uri`.
Consigliamo di utilizzare una barra finale per definire un canale corrispondente a una cartella. Ad esempio, il canale `s3://amzn-s3-demo-bucket/train-01/` per la cartella `train-01`. Senza la barra finale, il canale sarebbe ambiguo se esistesse un'altra cartella `s3://amzn-s3-demo-bucket/train-011/` o un file `s3://amzn-s3-demo-bucket/train-01.txt/`.
+ **Modalità `Pipe`**
+ Il parametro `TrainingInputMode` scritto in `inputdataconfig.json`: "Pipe"
+ Directory del canale dati nel container Docker: `/opt/ml/input/data/channel_name_epoch_number`
+ Fonti di dati supportate: Amazon S3
Devi leggere da una pipe separata per ogni canale. Ad esempio, se hai tre canali denominati `training`, `validation` e `testing`, devi leggere dalle seguenti pipe:
+ `/opt/ml/input/data/training_0, /opt/ml/input/data/training_1, ...`
+ `/opt/ml/input/data/validation_0, /opt/ml/input/data/validation_1, ...`
+ `/opt/ml/input/data/testing_0, /opt/ml/input/data/testing_1, ...`
Leggi le pipe sequenzialmente. Ad esempio, se hai un canale che si chiama `training`, leggi le pipe in questa sequenza:
1. Apri `/opt/ml/input/data/training_0` in modalità lettura e leggilo su end-of-file (EOF) oppure, se hai finito con la prima epoca, chiudi il file pipe in anticipo.
1. Dopo aver chiuso il primo file pipe, cerca `/opt/ml/input/data/training_1` e leggilo finché non hai completato la seconda epoca e così via.
Se il file per una determinata epoca non esiste ancora, il tuo codice potrebbe dover riprovare finché non viene creata la pipe. Non c'è alcuna restrizione di sequenziamento sui tipi di canale. Ad esempio, puoi leggere più epoche per il canale `training`, e iniziare a leggere il canale `validation` solo quando sei pronto. In alternativa, li puoi leggere simultaneamente se il tuo algoritmo lo richiede.
Per un esempio di notebook Jupyter che mostra come usare la modalità Pipe quando porti il tuo contenitore, vedi [Bring your own pipe-mode](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/pipe_bring_your_own/pipe_bring_your_own.ipynb) algorithm to Amazon AI. SageMaker
SageMaker L'addestramento sui modelli AI supporta i bucket di directory S3 Express One Zone ad alte prestazioni come posizione di input dei dati per la modalità file, la modalità fast file e la modalità pipe. Per utilizzare S3 Express One Zone, inserisci la posizione del bucket di directory S3 Express One Zone anziché un bucket Amazon S3 per uso generico. Fornisci l’ARN per il ruolo IAM con la policy di controllo degli accessi e delle autorizzazioni richiesta. Fare riferimento a [AmazonSageMakerFullAccesspolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html) per ulteriori dettagli. Puoi crittografare i dati di output SageMaker AI solo in bucket di directory con crittografia lato server con chiavi gestite di Amazon S3 (SSE-S3). La crittografia lato server con AWS KMS chiavi (SSE-KMS) non è attualmente supportata per l'archiviazione dei dati di output AI nei bucket di directory. SageMaker Per ulteriori informazioni, consulta [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html).
## Configurazione dell’addestramento distribuito
Se stai eseguendo corsi di formazione distribuiti con più contenitori, l' SageMaker intelligenza artificiale rende disponibili le informazioni su tutti i contenitori nel file. `/opt/ml/input/config/resourceconfig.json`
Per abilitare la comunicazione tra contenitori, questo file JSON contiene informazioni per tutti i contenitori. SageMaker L'intelligenza artificiale rende questo file disponibile per entrambi gli algoritmi`File`. `Pipe` Il file fornisce le informazioni che seguono:
+ `current_host`: il nome del container corrente sulla rete di container. Ad esempio, `algo-1`. I valori host possono cambiare in qualsiasi momento. Non scrivere codice con valori specifici per questa variabile.
+ `hosts`: l'elenco dei nomi di tutti i container nella rete di container, ordinato in ordine lessicografico. Ad esempio, `["algo-1", "algo-2", "algo-3"]` per un cluster a tre nodi. I container possono utilizzare questi nomi per gestire altri container sulla rete di container. I valori host possono cambiare in qualsiasi momento. Non scrivere codice con valori specifici per queste variabili.
+ `network_interface_name`: il nome dell'interfaccia di rete esposta al tuo container. Ad esempio, container che eseguono l'interfaccia MPI (Message Passing Interface) possono utilizzare questa informazione per impostare il nome dell'interfaccia di rete.
+ Non utilizzare le informazioni in `/etc/hostname` o `/etc/hosts` perché potrebbero non essere accurate.
+ Le informazioni sul nome host potrebbero non essere immediatamente disponibili per il container degli algoritmi. Ti consigliamo di aggiungere una policy per i nuovi tentativi sulle operazioni di risoluzione del nome host man mano che i nodi diventano disponibili nel cluster.
Di seguito è riportato un file di esempio sul nodo 1 in un cluster a tre nodi.
```
{
"current_host": "algo-1",
"hosts": ["algo-1","algo-2","algo-3"],
"network_interface_name":"eth1"
}
```
# Esecuzione di un addestramento con EFA
SageMaker L'intelligenza artificiale fornisce l'integrazione con i dispositivi [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) per accelerare le applicazioni di High Performance Computing (HPC) e machine learning. Questa integrazione consente di sfruttare un dispositivo EFA per eseguire processi di addestramento distribuiti. Puoi aggiungere l'integrazione EFA a un contenitore Docker esistente da aggiungere all'IA. SageMaker Le seguenti informazioni descrivono come configurare il proprio container per utilizzare un dispositivo EFA per i processi di addestramento distribuiti.
## Prerequisiti
Il contenitore deve soddisfare le specifiche del [contenitore SageMaker di formazione](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-dockerfile.html).
## Installazione dei pacchetti EFA richiesti
Il container deve scaricare e installare il [ software EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html). Ciò consente al container di riconoscere il dispositivo EFA e fornisce versioni compatibili di Libfabric e Open MPI.
Tutti gli strumenti come MPI e NCCL devono essere installati e gestiti all'interno del container per essere utilizzati come parte del processo di addestramento abilitato EFA. Per un elenco di tutte le versioni EFA disponibili, consulta [Verifica del programma di installazione EFA utilizzando un checksum](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-verify.html). L'esempio seguente mostra come modificare il file Docker del container abilitato EFA per installare EFA, MPI, OFI, NCCL e NCCL-TEST.
**Nota**
Quando si utilizza PyTorch con EFA sul contenitore, la versione NCCL del contenitore deve corrispondere alla versione NCCL dell'installazione. PyTorch Per verificare la versione PyTorch NCCL, usa il seguente comando:
```
torch.cuda.nccl.version()
```
```
ARG OPEN_MPI_PATH=/opt/amazon/openmpi/
ENV NCCL_VERSION=2.7.8
ENV EFA_VERSION=1.30.0
ENV BRANCH_OFI=1.1.1
#################################################
## EFA and MPI SETUP
RUN cd $HOME \
&& curl -O https://s3-us-west-2.amazonaws.com/aws-efa-installer/aws-efa-installer-${EFA_VERSION}.tar.gz \
&& tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
&& cd aws-efa-installer \
&& ./efa_installer.sh -y --skip-kmod -g \
ENV PATH="$OPEN_MPI_PATH/bin:$PATH"
ENV LD_LIBRARY_PATH="$OPEN_MPI_PATH/lib/:$LD_LIBRARY_PATH"
#################################################
## NCCL, OFI, NCCL-TEST SETUP
RUN cd $HOME \
&& git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
&& cd nccl \
&& make -j64 src.build BUILDDIR=/usr/local
RUN apt-get update && apt-get install -y autoconf
RUN cd $HOME \
&& git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
&& cd aws-ofi-nccl \
&& ./autogen.sh \
&& ./configure --with-libfabric=/opt/amazon/efa \
--with-mpi=/opt/amazon/openmpi \
--with-cuda=/usr/local/cuda \
--with-nccl=/usr/local --prefix=/usr/local \
&& make && make install
RUN cd $HOME \
&& git clone https://github.com/NVIDIA/nccl-tests \
&& cd nccl-tests \
&& make MPI=1 MPI_HOME=/opt/amazon/openmpi CUDA_HOME=/usr/local/cuda NCCL_HOME=/usr/local
```
## Considerazioni sulla creazione di un container
Il dispositivo EFA è montato sul container come indicato `/dev/infiniband/uverbs0` nell'elenco dei dispositivi accessibili al container. Nelle istanze P4d, il container ha accesso a 4 dispositivi EFA. I dispositivi EFA sono riportati nell'elenco dei dispositivi accessibili al container come:
+ `/dev/infiniband/uverbs0`
+ `/dev/infiniband/uverbs1`
+ `/dev/infiniband/uverbs2`
+ `/dev/infiniband/uverbs3`
Per ottenere informazioni sul nome host, sui nomi host dei peer e sull'interfaccia di rete (per MPI) dal file `resourceconfig.json` fornito a ciascuna istanza di container, consulta [Distributed Training Configuration](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training). Il container gestisce il normale traffico TCP tra peer tramite le interfacce di rete elastiche (ENI) predefinite, mentre gestisce il traffico OFI (bypassando il kernel) attraverso il dispositivo EFA.
## Verifica che il tuo dispositivo EFA sia riconosciuto
Per verificare che il tuo dispositivo EFA sia riconosciuto, esegui il comando seguente dall'interno del container.
```
/opt/amazon/efa/bin/fi_info -p efa
```
L'aspetto dell'output sarà simile al seguente.
```
provider: efa
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-rdm
version: 2.0
type: FI_EP_RDM
protocol: FI_PROTO_EFA
provider: efa
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-dgrm
version: 2.0
type: FI_EP_DGRAM
protocol: FI_PROTO_EFA
provider: efa;ofi_rxd
fabric: EFA-fe80::e5:56ff:fe34:56a8
domain: efa_0-dgrm
version: 1.0
type: FI_EP_RDM
protocol: FI_PROTO_RXD
```
## Esecuzione di un processo di addestramento con EFA
Dopo aver creato un contenitore compatibile con EFA, puoi eseguire un processo di formazione con EFA utilizzando un SageMaker AI Estimator nello stesso modo in cui faresti con qualsiasi altra immagine Docker. Per ulteriori informazioni sulla registrazione del container e sul suo utilizzo per l’addestramento, consulta [Adapting your own training container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step5).
# In che modo Amazon SageMaker AI segnala il successo e il fallimento di un algoritmo
Un algoritmo di addestramento indica se ha funzionato o meno utilizzando il codice di uscita del suo processo.
Un'esecuzione di addestramento che funziona deve uscire con un codice di uscita 0 e un'esecuzione di addestramento non riuscita deve uscire con un codice di uscita diverso da zero. Verranno convertite in `Completed` e `Failed` nel `TrainingJobStatus` restituito da `DescribeTrainingJob`. Questo codice di uscita di convenzione è standard ed è facilmente implementato in tutti i linguaggi. Ad esempio, in Python, puoi utilizzare `sys.exit(1)` per segnalare un errore nell'uscita e l'esecuzione fino alla fine della routine principale farà uscire Python con il codice 0.
Nel caso di errori, l'algoritmo può scrivere una descrizione dell'errore nel file di errore. Per ulteriori informazioni, consulta la prossima sezione.
# In che modo Amazon SageMaker AI elabora i risultati della formazione
Poiché il tuo algoritmo viene eseguito in un container, genera output, tra cui lo stato del processo di addestramento e artefatti del modello e di output. Il tuo algoritmo deve scrivere queste informazioni nei file seguenti, che si trovano nella directory del container `/output`. Amazon SageMaker AI elabora le informazioni contenute in questa directory come segue:
+ `/opt/ml/model`— Il tuo algoritmo dovrebbe scrivere tutti gli artefatti finali del modello in questa directory. SageMaker AI copia questi dati come un singolo oggetto in formato tar compresso nella posizione S3 specificata nella richiesta. `CreateTrainingJob` Se più contenitori in un singolo processo di formazione scrivono in questa directory, dovrebbero assicurarsi che non ci `file/directory` siano conflitti tra i nomi. SageMaker L'IA aggrega il risultato in un file TAR e lo carica su S3 al termine del processo di formazione.
+ `/opt/ml/output/data`— Il tuo algoritmo dovrebbe scrivere gli artefatti che desideri archiviare diversi dal modello finale in questa directory. SageMaker AI copia questi dati come un singolo oggetto in formato tar compresso nella posizione S3 specificata nella richiesta. `CreateTrainingJob` Se più contenitori in un singolo processo di formazione scrivono in questa directory, dovrebbero assicurarsi che non ci `file/directory` siano conflitti tra i nomi. SageMaker L'IA aggrega il risultato in un file TAR e lo carica su S3 al termine del processo di formazione.
+ `/opt/ml/output/failure`: se si verifica un errore nell’addestramento, dopo che l'output dell'algoritmo è completato (ad esempio, registrazione), il tuo algoritmo deve scrivere la descrizione dell'errore in questo file. In `DescribeTrainingJob` risposta, SageMaker AI restituisce i primi 1024 caratteri di questo file come. `FailureReason`
È possibile specificare un bucket S3 generico o di directory per archiviare l’output dell’addestramento. I bucket di directory utilizzano solo la classe di archiviazione Amazon S3 Express One Zone, progettata per carichi di lavoro o applicazioni con requisiti di prestazioni elevati che richiedono una latenza costante di pochi millisecondi. Scegli il tipo di bucket più adatto ai requisiti applicativi e di prestazioni. Per ulteriori informazioni sui bucket di directory S3, consulta [Bucket di directory](https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html) nella *Guida per l’utente di Amazon Simple Storage Service*.
**Nota**
Puoi crittografare i dati di output SageMaker AI solo nei bucket di directory S3 con crittografia lato server con chiavi gestite di Amazon S3 (SSE-S3). La crittografia lato server con AWS KMS chiavi (SSE-KMS) non è attualmente supportata per l'archiviazione dei dati di output AI nei bucket di directory. SageMaker
# Container con codice di inferenza personalizzato
Puoi utilizzare Amazon SageMaker AI per interagire con i container Docker ed eseguire codice di inferenza personalizzato in due modi:
+ Per utilizzare il tuo codice di inferenza con un endpoint persistente e ottenere una previsione alla volta, utilizza i servizi di hosting di SageMaker AI.
+ Per utilizzare il tuo codice di inferenza per ottenere previsioni per un intero set di dati, utilizza la trasformazione in batch di SageMaker AI.
**Topics**
+ [Codice di inferenza personalizzato con servizi di hosting](your-algorithms-inference-code.md)
+ [Codice di inferenza personalizzato con la trasformazione in batch](your-algorithms-batch-code.md)
# Codice di inferenza personalizzato con servizi di hosting
Questa sezione spiega come Amazon SageMaker AI interagisce con un contenitore Docker che esegue il tuo codice di inferenza per i servizi di hosting. Utilizza queste informazioni per scrivere il codice di inferenza e creare un'immagine Docker.
**Topics**
+ [In che modo l' SageMaker intelligenza artificiale gestisce la tua immagine di inferenza](#your-algorithms-inference-code-run-image)
+ [In che modo l' SageMaker IA carica gli artefatti del modello](#your-algorithms-inference-code-load-artifacts)
+ [Come il tuo container deve rispondere alle richieste di inferenza](#your-algorithms-inference-code-container-response)
+ [Come il tuo container deve rispondere alle richieste di controllo dello stato (Ping)](#your-algorithms-inference-algo-ping-requests)
+ [Contratto container per supportare funzionalità di streaming bidirezionale](#your-algorithms-inference-algo-bidi)
+ [Utilizzo di un registro Docker privato per container di inferenza in tempo reale](your-algorithms-containers-inference-private.md)
## In che modo l' SageMaker intelligenza artificiale gestisce la tua immagine di inferenza
Per configurare un container per l'esecuzione come un eseguibile, utilizza un'istruzione `ENTRYPOINT` in un Dockerfile. Tenere presente quanto segue:
+ Per l'inferenza dei modelli, l' SageMaker intelligenza artificiale esegue il contenitore come:
```
docker run image serve
```
SageMaker L'IA sostituisce `CMD` le istruzioni predefinite in un contenitore specificando l'`serve`argomento dopo il nome dell'immagine. L'argomento `serve` sostituisce gli argomenti che fornisci con il comando `CMD` nel Dockerfile.
+ SageMaker L'IA si aspetta che tutti i contenitori vengano eseguiti con utenti root. Crea il tuo container in modo che utilizzi solo utenti root. Quando l' SageMaker intelligenza artificiale esegue il contenitore, gli utenti che non dispongono dell'accesso a livello di root possono causare problemi di autorizzazione.
+ Ti consigliamo di utilizzare il modulo `exec` dell'istruzione `ENTRYPOINT`:
```
ENTRYPOINT ["executable", "param1", "param2"]
```
Esempio:
```
ENTRYPOINT ["python", "k_means_inference.py"]
```
Il modulo `exec` dell'istruzione `ENTRYPOINT` avvia l'eseguibile direttamente, non come figlio di `/bin/sh`. Ciò gli consente di ricevere segnali simili `SIGTERM` e provenienti `SIGKILL` dalle operazioni dell' SageMaker API, il che è un requisito.
Ad esempio, quando si utilizza l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API per creare un endpoint, l' SageMaker intelligenza artificiale fornisce il numero di istanze di calcolo ML richieste dalla configurazione dell'endpoint, specificato nella richiesta. SageMaker L'IA esegue il contenitore Docker su tali istanze.
Se riduci il numero di istanze che eseguono il backup dell'endpoint (chiamando l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)API), SageMaker AI esegue un comando per arrestare il contenitore Docker sulle istanze che vengono terminate. Il comando invia il segnale `SIGTERM` e poi invia il segnale `SIGKILL` trenta secondi più tardi.
Se aggiorni l'endpoint (chiamando l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API), SageMaker AI avvia un altro set di istanze di calcolo ML ed esegue i contenitori Docker che contengono il tuo codice di inferenza su di esse. Poi esegue un comando per interrompere il precedente container Docker. Per interrompere un container Docker, il comando invia il segnale `SIGTERM` e poi invia il segnale `SIGKILL` 30 secondi più tardi.
+ SageMaker AI utilizza la definizione del contenitore fornita nella [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)richiesta per impostare le variabili di ambiente e il nome host DNS per il contenitore nel modo seguente:
+ Imposta le variabili di ambiente utilizzando la `ContainerDefinition.Environment` string-to-string mappa.
+ Imposta l'hostname DNS utilizzando `ContainerDefinition.ContainerHostname`.
+ Se prevedi di utilizzare dispositivi GPU per le inferenze di modelli (specificando le istanze di calcolo ML basate su GPU nella richiesta `CreateEndpointConfig`), accertati che i container siano compatibili con `nvidia-docker`. Non aggregare i driver NVIDIA con l'immagine. Per ulteriori informazioni su `nvidia-docker`, consulta [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
+ Non puoi usare l'`tini`inizializzatore come punto di ingresso nei contenitori SageMaker AI perché viene confuso dagli argomenti `train` and`serve`.
## In che modo l' SageMaker IA carica gli artefatti del modello
Nella richiesta [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API, puoi utilizzare il `S3DataSource` parametro `ModelDataUrl` o per identificare la posizione S3 in cui sono archiviati gli artefatti del modello. SageMaker L'intelligenza artificiale copia gli artefatti del modello dalla posizione S3 alla `/opt/ml/model` directory per essere utilizzati dal codice di inferenza. Il container ha accesso in sola lettura a `/opt/ml/model`. Non scrivere in questa directory.
Il valore di `ModelDataUrl` deve puntare a un file tar.gz. Altrimenti, l' SageMaker IA non scaricherà il file.
Se hai addestrato il tuo modello all' SageMaker intelligenza artificiale, gli artefatti del modello vengono salvati come un singolo file tar compresso in Amazon S3. Se hai addestrato il tuo modello al di fuori dell' SageMaker intelligenza artificiale, devi creare questo singolo file tar compresso e salvarlo in una posizione S3. SageMaker AI decomprime questo file tar nella directory/opt/ml/modelprima dell'avvio del contenitore.
Per distribuire modelli di grandi dimensioni, consigliamo di seguire [Implementazione di modelli non compressi](large-model-inference-uncompressed.md).
## Come il tuo container deve rispondere alle richieste di inferenza
Per ottenere inferenze, l'applicazione client invia una richiesta POST all'endpoint AI. SageMaker SageMaker L'IA passa la richiesta al contenitore e restituisce il risultato dell'inferenza dal contenitore al client.
Per ulteriori informazioni sulle richieste di inferenza che il contenitore riceverà, consulta le seguenti azioni nel *riferimento all'API di Amazon SageMaker AI*:
+ [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)
+ [ InvokeEndpointAsync](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointAsync.html)
+ [ InvokeEndpointWithResponseStream](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html)
+ [ InvokeEndpointWithResponseStream](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithBidirectionalStream.html)
**Requisiti per i container di inferenza**
Per rispondere alle richieste di inferenza, il container deve soddisfare i seguenti requisiti:
+ SageMaker AI rimuove tutte le `POST` intestazioni tranne quelle supportate da. `InvokeEndpoint` SageMaker L'IA potrebbe aggiungere intestazioni aggiuntive. I container dell'inferenza devono essere in grado di ignorare queste intestazioni aggiuntive.
+ Per ricevere le richieste di inferenza, il container deve disporre di un server Web in ascolto sulla porta 8080 e deve accettare le richieste `POST` agli endpoint `/invocations` e `/ping`.
+ I container di modello del cliente devono accettare le richieste di connessione socket entro 250 ms.
+ I container di modello del cliente devono rispondere alle richieste entro 60 secondi. Il modello stesso può avere un tempo di elaborazione massimo di 60 secondi prima di rispondere a `/invocations`. Se il modello impiega 50-60 secondi di tempo di elaborazione, il timeout del socket dell'SDK deve essere impostato su 70 secondi.
+ Il contenitore modello di un cliente che supporta lo streaming bidirezionale deve:
+ supportare WebSockets le connessioni sulla porta da 8080 a/invocations-bidirectional-stream per impostazione predefinita.
+ dispongono di un server Web in ascolto sulla porta 8080 e devono accettare le richieste POST agli endpoint /ping.
+ Oltre ai controlli dello stato del contenitore tramite HTTP, il contenitore deve rispondere con Pong Frame per ([RFC6455](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)), per l'invio di WebSocket Ping Frame.
**Example funzioni di invocazione**
Negli esempi seguenti viene illustrato come il codice nel container può elaborare richieste di inferenza. Questi esempi gestiscono le richieste inviate dalle applicazioni client utilizzando l' InvokeEndpoint azione.
FastAPI è un framework web per la creazione APIs con Python.
```
from fastapi import FastAPI, status, Request, Response
. . .
app = FastAPI()
. . .
@app.post('/invocations')
async def invocations(request: Request):
# model() is a hypothetical function that gets the inference output:
model_resp = await model(Request)
response = Response(
content=model_resp,
status_code=status.HTTP_200_OK,
media_type="text/plain",
)
return response
. . .
```
In questo esempio, la `invocations` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations`
Flask è un framework per lo sviluppo di applicazioni web con Python.
```
import flask
. . .
app = flask.Flask(__name__)
. . .
@app.route('/invocations', methods=["POST"])
def invoke(request):
# model() is a hypothetical function that gets the inference output:
resp_body = model(request)
return flask.Response(resp_body, mimetype='text/plain')
```
In questo esempio, la `invoke` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations`
**Example funzioni di invocazione per le richieste di streaming**
Gli esempi seguenti mostrano come il codice nel container di inferenza può elaborare le richieste di inferenza in streaming. Questi esempi gestiscono le richieste inviate dalle applicazioni client utilizzando l'azione InvokeEndpointWithResponseStream .
Quando un container gestisce una richiesta di inferenza in streaming, restituisce l'inferenza del modello in blocchi incrementali man mano che il modello le genera. Le applicazioni client iniziano a ricevere risposte immediatamente quando sono disponibili. Non è necessario attendere che il modello generi l'intera risposta. Puoi implementare lo streaming per supportare esperienze interattive veloci, come chatbot, assistenti virtuali e generatori di musica.
FastAPI è un framework web per la creazione APIs con Python.
```
from starlette.responses import StreamingResponse
from fastapi import FastAPI, status, Request
. . .
app = FastAPI()
. . .
@app.post('/invocations')
async def invocations(request: Request):
# Streams inference response using HTTP chunked encoding
async def generate():
# model() is a hypothetical function that gets the inference output:
yield await model(Request)
yield "\n"
response = StreamingResponse(
content=generate(),
status_code=status.HTTP_200_OK,
media_type="text/plain",
)
return response
. . .
```
In questo esempio, la `invocations` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations` Per lo streaming della risposta, l'esempio utilizza la classe `StreamingResponse` dal framework Starlette.
Flask è un framework per lo sviluppo di applicazioni web con Python.
```
import flask
. . .
app = flask.Flask(__name__)
. . .
@app.route('/invocations', methods=["POST"])
def invocations(request):
# Streams inference response using HTTP chunked encoding
def generate():
# model() is a hypothetical function that gets the inference output:
yield model(request)
yield "\n"
return flask.Response(
flask.stream_with_context(generate()), mimetype='text/plain')
. . .
```
In questo esempio, la `invocations` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations` Per lo streaming della risposta, l'esempio utilizza la funzione `flask.stream_with_context` del framework Flask.
**Example Esempi di funzioni di invocazione per lo streaming bidirezionale**
Gli esempi seguenti mostrano come il codice del contenitore può elaborare richieste e risposte di inferenza in streaming. Questi esempi gestiscono le richieste di streaming inviate dalle applicazioni client utilizzando l' InvokeEndpointWithBidirectionalStreamazione.
Un contenitore con funzionalità di streaming bidirezionale gestisce le richieste di inferenza in streaming in cui le parti vengono generate in modo incrementale sul client e trasmesse al contenitore. Restituisce l'inferenza del modello al client sotto forma di una serie di parti man mano che il modello le genera. Le applicazioni client iniziano a ricevere risposte immediatamente quando sono disponibili. Non è necessario attendere che la richiesta sia completamente generata dal client o che il modello generi l'intera risposta. Puoi implementare lo streaming bidirezionale per supportare esperienze interattive veloci, come chatbot, assistenti vocali interattivi di intelligenza artificiale e traduzioni in tempo reale per un'esperienza più in tempo reale.
FastAPI è un framework web per la creazione APIs con Python.
```
import sys
import asyncio
import json
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.responses import JSONResponse
import uvicorn
app = FastAPI()
...
@app.websocket("/invocations-bidirectional-stream")
async def websocket_invoke(websocket: WebSocket):
"""
WebSocket endpoint with RFC 6455 ping/pong and fragmentation support
Handles:
- Text messages (JSON) - including fragmented frames
- Binary messages - including fragmented frames
- Ping frames (automatically responds with pong)
- Pong frames (logs receipt)
- Fragmented frames per RFC 6455 Section 5.4
"""
await manager.connect(websocket)
# Fragment reassembly buffers per RFC 6455 Section 5.4
text_fragments = []
binary_fragments = []
while True:
# Use receive() to handle all WebSocket frame types
message = await websocket.receive()
print(f"Received message: {message}")
if message["type"] == "websocket.receive":
if "text" in message:
# Handle text frames (including fragments)
text_data = message["text"]
more_body = message.get("more_body", False)
if more_body:
# This is a fragment, accumulate it
text_fragments.append(text_data)
print(f"Received text fragment: {len(text_data)} chars (more coming)")
else:
# This is the final frame or a complete message
if text_fragments:
# Reassemble fragmented message
text_fragments.append(text_data)
complete_text = "".join(text_fragments)
text_fragments.clear()
print(f"Reassembled fragmented text message: {len(complete_text)} chars total")
await handle_text_message(websocket, complete_text)
else:
# Complete message in single frame
await handle_text_message(websocket, text_data)
elif "bytes" in message:
# Handle binary frames (including fragments)
binary_data = message["bytes"]
more_body = message.get("more_body", False)
if more_body:
# This is a fragment, accumulate it
binary_fragments.append(binary_data)
print(f"Received binary fragment: {len(binary_data)} bytes (more coming)")
else:
# This is the final frame or a complete message
if binary_fragments:
# Reassemble fragmented message
binary_fragments.append(binary_data)
complete_binary = b"".join(binary_fragments)
binary_fragments.clear()
print(f"Reassembled fragmented binary message: {len(complete_binary)} bytes total")
await handle_binary_message(websocket, complete_binary)
else:
# Complete message in single frame
await handle_binary_message(websocket, binary_data)
elif message["type"] == "websocket.ping":
# Handle ping frames - RFC 6455 Section 5.5.2
ping_data = message.get("bytes", b"")
print(f"Received PING frame with payload: {ping_data}")
# FastAPI automatically sends pong response
elif message["type"] == "websocket.pong":
# Handle pong frames
pong_data = message.get("bytes", b"")
print(f"Received PONG frame with payload: {pong_data}")
elif message["type"] == "websocket.close":
# Handle close frames - RFC 6455 Section 5.5.1
close_code = message.get("code", 1000)
close_reason = message.get("reason", "")
print(f"Received CLOSE frame - Code: {close_code}, Reason: '{close_reason}'")
# Send close frame response if not already closing
try:
await websocket.close(code=close_code, reason=close_reason)
print(f"Sent CLOSE frame response - Code: {close_code}")
except Exception as e:
print(f"Error sending close frame: {e}")
break
elif message["type"] == "websocket.disconnect":
print("Client initiated disconnect")
break
else:
print(f"Received unknown message type: {message['type']}")
break
async def handle_binary_message(websocket: WebSocket, binary_data: bytes):
"""Handle incoming binary messages (complete or reassembled from fragments)"""
print(f"Processing complete binary message: {len(binary_data)} bytes")
try:
# Echo back the binary data
await websocket.send_bytes(binary_data)
except Exception as e:
print(f"Error handling binary message: {e}")
async def handle_text_message(websocket: WebSocket, data: str):
"""Handle incoming text messages"""
try:
# Send response back to the same client
await manager.send_personal_message(data, websocket)
except Exception as e:
print(f"Error handling text message: {e}")
def main():
if len(sys.argv) > 1 and sys.argv[1] == "serve":
print("Starting server on port 8080...")
uvicorn.run(app, host="0.0.0.0", port=8080)
else:
print("Usage: python app.py serve")
sys.exit(1)
if __name__ == "__main__":
main()
```
In questo esempio, la `websocket_invoke` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations-bidirectional-stream` Mostra la gestione delle richieste di streaming e lo streaming delle risposte al client.
## Come il tuo container deve rispondere alle richieste di controllo dello stato (Ping)
SageMaker L'intelligenza artificiale lancia nuovi contenitori di inferenza nelle seguenti situazioni:
+ Risposta a `CreateEndpoint` `UpdateEndpoint` e chiamate API `UpdateEndpointWeightsAndCapacities`
+ Applicazione di patch di sicurezza
+ Sostituzione delle istanze non integre
Subito dopo l'avvio del contenitore, l' SageMaker IA inizia a inviare richieste GET periodiche all'endpoint. `/ping`
Il più semplice requisito per il container è di rispondere con un codice di stato HTTP 200 e un corpo vuoto. Ciò indica all' SageMaker IA che il contenitore è pronto ad accettare richieste di inferenza sull'endpoint. `/invocations`
Se il container non inizia a passare i controlli dell’integrità rispondendo costantemente con 200 secondi durante gli 8 minuti successivi all’avvio, l’avvio della nuova istanza ha esito negativo. Ciò causa un errore in `CreateEndpoint` e lascia l’endpoint in uno stato di errore. L’aggiornamento richiesto da `UpdateEndpoint` non viene completato, le patch di sicurezza non verranno applicate e le istanze non integre non vengono sostituite.
Nonostante la barra minima per il container è di fornire uno 200 statico, uno sviluppatore di container può utilizzare questa funzionalità per eseguire maggiori controlli. Il timeout della richiesta sui tentativi `/ping` è 2 secondi.
Inoltre, un contenitore in grado di gestire richieste di streaming bidirezionali deve rispondere con un Pong Frame (per WebSocket protocollo [RFC6455](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) a un Ping Frame. Se non viene ricevuto alcun Pong Frame per 5 Ping consecutivi, la connessione al contenitore verrà chiusa dalla SageMaker piattaforma AI. SageMaker La piattaforma AI risponderà anche ai Ping Frames del container modello con Pong Frames.
## Contratto container per supportare funzionalità di streaming bidirezionale
Se desideri ospitare il tuo contenitore modello come endpoint SageMaker AI che supporta funzionalità di streaming bidirezionale, il contenitore modello deve supportare il seguente contratto:
**1. Etichetta Docker bidirezionale**
Il contenitore del modello dovrebbe avere un'etichetta Docker che indichi alla piattaforma SageMaker AI che la funzionalità di streaming bidirezionale è supportata su questo contenitore.
```
com.amazonaws.sagemaker.capabilities.bidirectional-streaming=true
```
**2. Support WebSocket Connection per le chiamate**
Il contenitore modello di un cliente che supporta lo streaming bidirezionale deve supportare per impostazione predefinita WebSockets le connessioni sulla porta 8080 to. `/invocations-bidirectional-stream`
Questo percorso può essere sovrascritto passando X-Amzn-SageMaker-Model l'intestazione -Invocation-Path quando si richiama l'API. InvokeEndpointWithBidirectionalStream Inoltre, gli utenti possono specificare una stringa di query da aggiungere a questo percorso passando l'intestazione -Query-String quando richiamano l'API. X-Amzn-SageMaker-Model InvokeEndpointWithBidirectionalStream
**3. Richiedi la gestione dello stream**
I payload di input dell' InvokeEndpointWithBidirectionalStream API vengono trasmessi in streaming come una serie di PayloadParts, che è solo un wrapper di un blocco binario («Bytes»:): ******
```
{
"PayloadPart": {
"Bytes": ,
"DataType": ,
"CompletionState":
"P":
}
}
```
**3.1. Frame di dati**
SageMaker AI passa l'input PayloadParts al contenitore del modello come frame di WebSocket dati ([RFC6455-Section-5.6](https://datatracker.ietf.org/doc/html/rfc6455#section-5.6))
1. SageMaker L'IA non ispeziona il blocco binario.
1. Alla ricezione di un input PayloadPart
+ SageMaker L'IA crea esattamente un WebSocket Data Frame da`PayloadPart.Bytes`, quindi lo passa al contenitore del modello.
+ Se`PayloadPart.DataType = UTF8`, SageMaker AI crea un frame di dati di testo
+ Se `PayloadPart.DataType` non presenta o`PayloadPart.DataType = BINARY`, SageMaker AI crea un Binary Data Frame
1. Per una sequenza di PayloadParts con e terminata da un con`PayloadPart.CompletionState = PARTIAL`, l' SageMaker IA li traduce in un PayloadPart messaggio WebSocket frammentato [RFC6455-Section-5.4](https://datatracker.ietf.org/doc/html/rfc6455#section-5.4): Frammentazione: `PayloadPart.CompletionState = COMPLETE`
+ La larghezza iniziale `PayloadPart.CompletionState = PARTIAL` verrà tradotta in un Data Frame, PayloadPart con FIN bit clear WebSocket .
+ Il PayloadParts with successivo `PayloadPart.CompletionState = PARTIAL` verrà tradotto in WebSocket Continuation Frames con FIN bit clear.
+ Il risultato finale PayloadPart `PayloadPart.CompletionState = COMPLETE` verrà tradotto in WebSocket Continuation Frame con bit FIN impostato.
1. SageMaker L'IA non codifica o decodifica il blocco binario dall'input PayloadPart, i byte vengono passati al contenitore del modello così com'è.
1. SageMaker L'intelligenza artificiale non combina più input in uno solo. PayloadParts BinaryDataFrame
1. SageMaker L'intelligenza artificiale non suddivide un input PayloadPart in più BinaryDataFrames input.
**Esempio: flusso di messaggi frammentato**
```
Client sends:
PayloadPart 1: {Bytes: "Hello ", DataType: "UTF8", CompletionState: "PARTIAL"}
PayloadPart 2: {Bytes: "World", DataType: "UTF8", CompletionState: "COMPLETE"}
Container receives:
Frame 1: Text Data Frame with "Hello " (FIN=0)
Frame 2: Continuation Frame with "World" (FIN=1)
```
**3.2. Telai di controllo**
Oltre ai Data Frames, SageMaker AI invia anche Control Frames al contenitore del modello ([RFC6455-Section-5.5](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5)):
1. Close Frame: L' SageMaker IA può inviare Close Frame ([RFC6455-Section-5.5.1](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.1)) al contenitore del modello se la connessione viene chiusa per qualsiasi motivo.
1. Ping Frame: l' SageMaker IA invia Ping Frame ([RFC6455-Section-5.5.2](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2)) una volta ogni 60 secondi, il contenitore del modello deve rispondere con Pong Frame. Se non viene ricevuto alcun Pong Frame ([RFC6455-Section-5.5.3](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) per 5 Ping consecutivi, la connessione verrà chiusa dall'IA. SageMaker
1. Pong Frame: SageMaker AI risponderà ai Ping Frame del contenitore modello con Pong Frames.
**4. Gestione del flusso di risposta**
L'output viene trasmesso in streaming come una serie di PayloadParts, ModelStreamErrors o InternalStreamFailures.
```
{
"PayloadPart": {
"Bytes": ,
"DataType": ,
"CompletionState": ,
},
"ModelStreamError": {
"ErrorCode": ,
"Message":
},
"InternalStreamFailure": {
"Message":
}
}
```
**4.1. Frame di dati**
SageMaker L'IA converte i frame di dati ricevuti dal contenitore del modello in output PayloadParts:
1. Dopo aver ricevuto un WebSocket Text Data Frame dal contenitore del modello, l' SageMaker IA ottiene i byte grezzi dal Text Data Frame e li avvolge in una risposta PayloadPart, nel frattempo impostata. `PayloadPart.DataType = UTF8`
1. Quando riceve un WebSocket Binary Data Frame dal contenitore del modello, l' SageMaker IA avvolge direttamente i byte dal frame di dati in una risposta, nel frattempo impostata. PayloadPart `PayloadPart.DataType = BINARY`
1. [Per i messaggi frammentati come definiti nella RFC6455 -Section-5.4: Frammentazione:](https://datatracker.ietf.org/doc/html/rfc6455#section-5.4)
+ Il Data Frame iniziale con FIN bit clear verrà tradotto in un with. PayloadPart `PayloadPart.CompletionState = PARTIAL`
+ I successivi Continuation Frames con FIN bit clear verranno tradotti in PayloadParts with`PayloadPart.CompletionState = PARTIAL`.
+ Il Continuation Frame finale con set di bit FIN verrà tradotto in PayloadPart with. `PayloadPart.CompletionState = COMPLETE`
1. SageMaker L'IA non codifica o decodifica i byte ricevuti dai contenitori del modello, i byte vengono passati al contenitore del modello così com'è.
1. SageMaker L'IA non combina più frame di dati ricevuti dal contenitore del modello in un'unica risposta. PayloadPart
1. SageMaker L'intelligenza artificiale non suddivide un Data Frame ricevuto dal contenitore del modello in più risposte PayloadParts.
**Esempio: Streaming Response Flow**
```
Container sends:
Frame 1: Text Data Frame with "Generating" (FIN=0)
Frame 2: Continuation Frame with " response..." (FIN=1)
Client receives:
PayloadPart 1: {Bytes: "Generating", DataType: "UTF8", CompletionState: "PARTIAL"}
PayloadPart 2: {Bytes: " response...", DataType: "UTF8", CompletionState: "COMPLETE"}
```
**4.2. Telai di controllo**
SageMaker L'IA risponde ai seguenti Control Frames dal contenitore del modello:
1. Dopo aver ricevuto un Close Frame ([RFC6455-Section-5.5.1](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.1)) dal contenitore del modello, SageMaker AI ModelStreamError inserirà il codice di stato ([RFC6455-Section-7.4](https://datatracker.ietf.org/doc/html/rfc6455#section-7.4)) e i messaggi di errore e lo trasmetterà all'utente finale.
1. Alla ricezione di un Ping Frame ([RFC6455-Section-5.5.2](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2)) dal contenitore del modello, l'IA risponderà con Pong Frame. SageMaker
1. Pong Frame ([RFC6455-Section-5.5.3](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)): Se non viene ricevuto alcun Pong Frame per 5 ping consecutivi, la connessione verrà chiusa dall'IA. SageMaker
# Utilizzo di un registro Docker privato per container di inferenza in tempo reale
L'hosting Amazon SageMaker AI ti consente di utilizzare le immagini archiviate in Amazon ECR per creare contenitori per l'inferenza in tempo reale per impostazione predefinita. Facoltativamente, puoi creare container per l'inferenza in tempo reale da immagini in un registro Docker privato. Il registro privato deve essere accessibile da un Amazon VPC nel tuo account. I modelli creati in base alle immagini archiviate nel registro Docker privato devono essere configurati per connettersi allo stesso VPC in cui è accessibile il registro Docker privato. Per ulteriori informazioni sulla connessione del modello a un VPC, consulta [Offri agli endpoint ospitati dall' SageMaker intelligenza artificiale l'accesso alle risorse nel tuo Amazon VPC](host-vpc.md).
Il registro Docker deve essere protetto con un certificato TLS di un'autorità di certificazione (CA) pubblica nota.
**Nota**
Il tuo registro Docker privato deve consentire il traffico in entrata dai gruppi di sicurezza specificati nella configurazione VPC per il tuo modello, in modo che l'hosting SageMaker AI sia in grado di estrarre le immagini del modello dal tuo registro.
SageMaker L'intelligenza artificiale può estrarre immagini di modelli DockerHub se esiste un percorso verso una rete Internet aperta all'interno del tuo VPC.
**Topics**
+ [Archiviazione delle immagini in un registro Docker privato diverso da Amazon Elastic Container Registry](#your-algorithms-containers-inference-private-registry)
+ [Utilizzo di un'immagine da un registro Docker privato per l'inferenza in tempo reale](#your-algorithms-containers-inference-private-use)
+ [Consenti all' SageMaker IA di autenticarsi in un registro Docker privato](#inference-private-docker-authenticate)
+ [Creazione della funzione Lambda](#inference-private-docker-lambda)
+ [Concedi a Lamba l’autorizzazione per il tuo ruolo di esecuzione](#inference-private-docker-perms)
+ [Creazione di un endpoint VPC di interfaccia per Lambda](#inference-private-docker-vpc-interface)
## Archiviazione delle immagini in un registro Docker privato diverso da Amazon Elastic Container Registry
Per utilizzare un registro Docker privato per archiviare le tue immagini per l'inferenza SageMaker AI in tempo reale, crea un registro privato accessibile dal tuo Amazon VPC. Per informazioni sulla creazione di un registro Docker, consulta [Deploy a registry server](https://docs.docker.com/registry/deploying/) nella documentazione Docker. Il registro Docker deve rispettare quanto segue:
+ Il registro deve essere un registro [Registro Docker HTTP API V2](https://docs.docker.com/registry/spec/api/).
+ Il registro Docker deve essere accessibile dallo stesso VPC specificato nel parametro `VpcConfig` al momento della creazione del modello.
## Utilizzo di un'immagine da un registro Docker privato per l'inferenza in tempo reale
Quando crei un modello e lo distribuisci su un hosting SageMaker AI, puoi specificare che utilizzi un'immagine del tuo registro Docker privato per creare il contenitore di inferenza. Specificalo nell'oggetto `ImageConfig` nel parametro `PrimaryContainer` che inoltri a una chiamata alla funzione [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model).
**Per utilizzare un'immagine archiviata nel registro Docker privato per il container di inferenza**
1. Crea l'oggetto di configurazione dell'immagine e specifica un valore `Vpc` per il campo `RepositoryAccessMode`.
```
image_config = {
'RepositoryAccessMode': 'Vpc'
}
```
1. Se il registro Docker privato richiede l'autenticazione, aggiungi un oggetto `RepositoryAuthConfig` all'oggetto di configurazione dell'immagine. Per il `RepositoryCredentialsProviderArn` campo dell'`RepositoryAuthConfig`oggetto, specifica l'Amazon Resource Name (ARN) di una AWS Lambda funzione che fornisce credenziali che consentono all' SageMaker IA di autenticarsi nel tuo registro Docker privato. Per informazioni su come creare la funzione Lambda per fornire l'autenticazione, consulta [Consenti all' SageMaker IA di autenticarsi in un registro Docker privato](#inference-private-docker-authenticate).
```
image_config = {
'RepositoryAccessMode': 'Vpc',
'RepositoryAuthConfig': {
'RepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName'
}
}
```
1. Crea l'oggetto container principale da trasferire a `create_model`, utilizzando l'oggetto di configurazione dell'immagine creato nella fase precedente.
Fornisci la tua immagine in formato [digest](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier). Se fornisci l'immagine utilizzando il `:latest` tag, c'è il rischio che l' SageMaker intelligenza artificiale recuperi una versione dell'immagine più recente di quella prevista. L'utilizzo del modulo riepilogativo garantisce che l' SageMaker intelligenza artificiale estragga la versione dell'immagine desiderata.
```
primary_container = {
'ContainerHostname': 'ModelContainer',
'Image': 'myteam.myorg.com/docker-local/my-inference-image:',
'ImageConfig': image_config
}
```
1. Specifica il nome del modello e il ruolo di esecuzione che desideri inoltrare a `create_model`.
```
model_name = 'vpc-model'
execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole'
```
1. Specifica uno o più gruppi di sicurezza e sottoreti per la configurazione VPC per il tuo modello. Il registro Docker privato deve consentire il traffico in ingresso dai gruppi di sicurezza specificati. Le sottoreti specificate devono trovarsi nello stesso VPC del registro Docker privato.
```
vpc_config = {
'SecurityGroupIds': ['sg-0123456789abcdef0'],
'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1']
}
```
1. Ottieni un client AI Boto3 SageMaker .
```
import boto3
sm = boto3.client('sagemaker')
```
1. Crea il modello richiamando `create_model`, utilizzando i valori specificati nelle fasi precedenti per i parametri `PrimaryContainer` e `VpcConfig`.
```
try:
resp = sm.create_model(
ModelName=model_name,
PrimaryContainer=primary_container,
ExecutionRoleArn=execution_role_arn,
VpcConfig=vpc_config,
)
except Exception as e:
print(f'error calling CreateModel operation: {e}')
else:
print(resp)
```
1. Infine, richiama [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) e [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) per creare l'endpoint di hosting, utilizzando il modello creato nella fase precedente.
```
endpoint_config_name = 'my-endpoint-config'
sm.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
'VariantName': 'MyVariant',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.t2.medium'
},
],
)
endpoint_name = 'my-endpoint'
sm.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
sm.describe_endpoint(EndpointName=endpoint_name)
```
## Consenti all' SageMaker IA di autenticarsi in un registro Docker privato
[Per estrarre un'immagine di inferenza da un registro Docker privato che richiede l'autenticazione, crea una AWS Lambda funzione che fornisca le credenziali e fornisci l'Amazon Resource Name (ARN) della funzione Lambda quando chiami create\$1model.](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) Quando l' SageMaker intelligenza artificiale viene eseguita`create_model`, chiama la funzione Lambda specificata per ottenere le credenziali per l'autenticazione nel registro Docker.
## Creazione della funzione Lambda
Crea una AWS Lambda funzione che restituisca una risposta con il seguente modulo:
```
def handler(event, context):
response = {
"Credentials": {"Username": "username", "Password": "password"}
}
return response
```
A seconda di come configuri l'autenticazione per il tuo registro Docker privato, le credenziali restituite dalla funzione Lambda possono significare una delle seguenti cose:
+ Se configuri il registro Docker privato per utilizzare l'autenticazione di base, fornisci le credenziali di accesso per l'autenticazione nel registro.
+ Se configuri il tuo registro Docker privato per utilizzare l'autenticazione con token bearer, le credenziali di accesso vengono inviate al tuo server di autorizzazione, che restituisce un token bearer che può quindi essere utilizzato per l'autenticazione nel registro Docker privato.
## Concedi a Lamba l’autorizzazione per il tuo ruolo di esecuzione
Il ruolo di esecuzione utilizzato per chiamare `create_model` deve disporre delle autorizzazioni per chiamare AWS Lambda le funzioni. Aggiungi quanto segue alla policy sulle autorizzazioni del tuo ruolo di esecuzione.
```
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:*myLambdaFunction*"
]
}
```
*myLambdaFunction*Dov'è il nome della tua funzione Lambda. Per informazioni su come modificare le autorizzazioni per un ruolo, consulta [Modifying a role permissions policy (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) nella *Guida per l’utente AWS Identity and Access Management *.
**Nota**
Un ruolo di esecuzione a cui è associata la policy `AmazonSageMakerFullAccess` gestita è autorizzato a chiamare qualsiasi funzione Lambda con **SageMaker**nel suo nome.
## Creazione di un endpoint VPC di interfaccia per Lambda
Crea un endpoint di interfaccia in modo che Amazon VPC possa comunicare con la tua funzione AWS Lambda senza inviare traffico su Internet. Per informazioni su come svolgere questa operazione, consulta [Configuring interface VPC endpoints for Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) nella *AWS Lambda Guida per gli sviluppatori*.
SageMaker L'hosting AI invia una richiesta tramite il tuo VPC a`lambda.region.amazonaws.com`, per chiamare la tua funzione Lambda. Se scegli il Nome DNS privato quando crei l'endpoint di interfaccia, Amazon Route 53 indirizza la chiamata all'endpoint dell'interfaccia Lambda. Se utilizzi un provider DNS diverso, assicurati di mappare `lambda.region.amazonaws.com` all'endpoint dell'interfaccia Lambda.
# Codice di inferenza personalizzato con la trasformazione in batch
Questa sezione spiega come Amazon SageMaker AI interagisce con un contenitore Docker che esegue il tuo codice di inferenza per la trasformazione in batch. Utilizza queste informazioni per scrivere il codice di inferenza e creare un'immagine Docker.
**Topics**
+ [In che modo l' SageMaker intelligenza artificiale gestisce la tua immagine di inferenza](#your-algorithms-batch-code-run-image)
+ [In che modo l' SageMaker IA carica gli artefatti del modello](#your-algorithms-batch-code-load-artifacts)
+ [Come i container servono le richieste](#your-algorithms-batch-code-how-containe-serves-requests)
+ [Come il tuo container deve rispondere alle richieste di inferenza](#your-algorithms-batch-code-how-containers-should-respond-to-inferences)
+ [Come il tuo container deve rispondere alle richieste di controllo dello stato (Ping)](#your-algorithms-batch-algo-ping-requests)
## In che modo l' SageMaker intelligenza artificiale gestisce la tua immagine di inferenza
Per configurare un container per l'esecuzione come un eseguibile, utilizza un'istruzione `ENTRYPOINT` in un Dockerfile. Tenere presente quanto segue:
+ Per le trasformazioni in batch, l' SageMaker intelligenza artificiale richiama il modello per tuo conto. SageMaker L'IA esegue il contenitore come:
```
docker run image serve
```
L'input per le trasformazioni in batch deve essere in un formato che possa essere suddiviso in file più piccoli da elaborare in parallelo. [Questi formati includono CSV, [JSON, JSON](https://www.json.org/json-en.html)[Lines](https://jsonlines.org/) e [TFRecord](https://www.tensorflow.org/tutorials/load_data/tfrecord)ReCordio.](https://mesos.apache.org/documentation/latest/recordio/)
SageMaker L'IA sostituisce le `CMD` istruzioni predefinite in un contenitore specificando l'argomento dopo il nome dell'immagine. `serve` L'argomento `serve` sostituisce gli argomenti che fornisci con il comando `CMD` nel Dockerfile.
+ Ti consigliamo di utilizzare il modulo `exec` dell'istruzione `ENTRYPOINT`:
```
ENTRYPOINT ["executable", "param1", "param2"]
```
Esempio:
```
ENTRYPOINT ["python", "k_means_inference.py"]
```
+ SageMaker L'intelligenza artificiale imposta le variabili di ambiente specificate nel [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)e [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)sul contenitore. Inoltre, vengono popolate le seguenti variabili di ambiente:
+ `SAGEMAKER_BATCH` è impostato su `true` quando il container esegue una trasformazione in batch.
+ `SAGEMAKER_MAX_PAYLOAD_IN_MB` è impostato sul payload di dimensioni più grandi che viene inviato al container tramite HTTP.
+ `SAGEMAKER_BATCH_STRATEGY` è impostato su `SINGLE_RECORD` quando il container invia un singolo record per effettuare le invocazioni e chiamare `MULTI_RECORD` quando il container riceve tutti i record che rientrano nel payload.
+ `SAGEMAKER_MAX_CONCURRENT_TRANSFORMS` è impostato sul numero massimo di richieste di `/invocations` che possono essere aperte contemporaneamente.
**Nota**
Le ultime tre variabili di ambiente provengono dalla chiamata API effettuata dall'utente. Se l'utente non ne imposta i valori, le variabili non vengono inoltrate. In questo caso, sono utilizzati i valori predefiniti o i valori richiesti dall'algoritmo (in risposta a `/execution-parameters`).
+ Se prevedi di utilizzare dispositivi GPU per le inferenze di modelli (specificando le istanze di calcolo ML basate su GPU nella richiesta `CreateTransformJob`), accertati che i container siano compatibili con nvidia-docker. Non aggregare i driver NVIDIA con l'immagine. Per ulteriori informazioni su nvidia-docker, consulta [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
+ Non puoi usare l'`init`inizializzatore come punto di ingresso nei contenitori SageMaker AI perché viene confuso dagli argomenti «train and serve».
## In che modo l' SageMaker IA carica gli artefatti del modello
In una richiesta [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), le definizioni del container comprendono il parametro `ModelDataUrl`, che identifica la posizione in Amazon S3 in cui sono archiviati gli artefatti del modello. Quando si utilizza l' SageMaker intelligenza artificiale per eseguire inferenze, utilizza queste informazioni per determinare da dove copiare gli artefatti del modello. Gli artefatti vengono copiati nella directory `/opt/ml/model` nel container Docker per essere utilizzati dal codice di inferenza.
Il parametro di `ModelDataUrl` deve puntare a un file tar.gz. Altrimenti, l' SageMaker IA non può scaricare il file. Se si addestra un modello in SageMaker intelligenza artificiale, gli artefatti vengono salvati in un unico file tar compresso in Amazon S3. Se addestra un modello in un altro framework, devi archiviare gli artefatti del modello in Amazon S3 come file tar compresso. SageMaker AI decomprime questo file tar e lo salva nella `/opt/ml/model` directory del contenitore prima dell'inizio del processo di trasformazione in batch.
## Come i container servono le richieste
I container devono implementare un server Web che risponde a invocazioni e richieste ping sulla porta 8080. Per le trasformazioni in batch, hai la possibilità di impostare algoritmi per implementare le richieste di parametri di esecuzione per fornire una configurazione di runtime dinamica all'IA. SageMaker SageMaker L'intelligenza artificiale utilizza i seguenti endpoint:
+ `ping`—Utilizzato per controllare periodicamente lo stato del contenitore. SageMaker L'IA attende un codice di `200` stato HTTP e un corpo vuoto per una richiesta ping riuscita prima di inviare una richiesta di invocazione. Puoi utilizzare una richiesta ping per caricare un modello in memoria per generare inferenza quando vengono inviate richieste di invocazioni.
+ (Facoltativo) `execution-parameters`: consente all'algoritmo di fornire i parametri di sincronizzazione ottimali per un processo durante il runtime. In base alla memoria e alla CPUs disponibilità di un contenitore, l'algoritmo sceglie i `MaxPayloadInMB` valori e i valori appropriati `MaxConcurrentTransforms` per il lavoro. `BatchStrategy`
Prima di chiamare la richiesta di invocazione, l' SageMaker IA tenta di richiamare la richiesta dei parametri di esecuzione. Quando si crea un processo di trasformazione in batch, è possibile fornire valori per i `MaxConcurrentTransforms` parametri, e. `BatchStrategy` `MaxPayloadInMB` SageMaker L'IA determina i valori per questi parametri utilizzando questo ordine di precedenza:
1. I valori dei parametri forniti al momento della creazione della richiesta `CreateTransformJob`.
1. I valori restituiti dal contenitore del modello quando l' SageMaker IA richiama l'endpoint-parameters di esecuzione>
1. I valori predefiniti del parametro, elencati nella seguente tabella.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/your-algorithms-batch-code.html)
La risposta per una richiesta execution-parameters `GET` è un oggetto JSON con chiavi per i parametri `MaxConcurrentTransforms`, `BatchStrategy` e `MaxPayloadInMB`. Di seguito è riportato un esempio di risposta valida:
```
{
“MaxConcurrentTransforms”: 8,
“BatchStrategy": "MULTI_RECORD",
"MaxPayloadInMB": 6
}
```
## Come il tuo container deve rispondere alle richieste di inferenza
Per ottenere inferenze, Amazon SageMaker AI invia una richiesta POST al contenitore di inferenza. Il corpo della richiesta POST contiene dati da Amazon S3. Amazon SageMaker AI passa la richiesta al contenitore e ne restituisce il risultato dell'inferenza, salvando i dati della risposta ad Amazon S3.
Per ricevere le richieste di inferenza, il container deve disporre di un server Web in ascolto sulla porta 8080 e deve accettare le richieste all'endpoint `/invocations`. Il timeout della richiesta di inferenza e il numero massimo di tentativi possono essere configurati tramite `[ModelClientConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelClientConfig.html)`.
## Come il tuo container deve rispondere alle richieste di controllo dello stato (Ping)
Il più semplice requisito per il container è di rispondere con un codice di stato HTTP 200 e un corpo vuoto. Ciò indica all' SageMaker IA che il contenitore è pronto ad accettare richieste di inferenza sull'endpoint. `/invocations`
Nonostante la barra minima per il container è di fornire uno 200 statico, uno sviluppatore di container può utilizzare questa funzionalità per eseguire maggiori controlli. Il timeout della richiesta sui tentativi `/ping` è 2 secondi.