

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

# Eseguire processi di inferenza in batch
<a name="autopilot-deploy-models-batch"></a>

L'inferenza in batch, nota anche come inferenza offline, genera previsioni di modelli su un batch di osservazioni. L'inferenza in batch è una buona opzione per set di dati di grandi dimensioni o se non è necessaria una risposta immediata a una richiesta di previsione del modello. Al contrario, l'inferenza online ([inferenza in tempo reale](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-deploy-models.html#autopilot-deploy-models-realtime)) genera previsioni in tempo reale. È possibile effettuare inferenze in batch da un modello Autopilot utilizzando [SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/), l'interfaccia utente Autopilot (UI), l'SDK [AWS per](https://aws.amazon.com/sdk-for-python/) Python (boto3) o (). AWS Command Line Interface [AWS CLI](https://docs.aws.amazon.com/cli/)

Le schede seguenti mostrano tre opzioni per la distribuzione del modello: Utilizzo dell'interfaccia utente Autopilot o utilizzo per la distribuzione da account diversi. APIs APIs Queste istruzioni presuppongono che tu abbia già creato un modello in Autopilot. Se non disponi di un modello, consulta [Creare processi di regressione o classificazione per dati tabulari utilizzando l’API AutoML](autopilot-automate-model-development-create-experiment.md). Per vedere degli esempi relativi a ciascuna opzione, apri ogni scheda.

## Implementa un modello utilizzando l'interfaccia utente di Autopilot
<a name="autopilot-deploy-models-batch-ui"></a>

L'interfaccia utente di Autopilot contiene utili menu a discesa, interruttori, suggerimenti e altro per aiutarti a navigare nell’implementazione del modello.

Le fasi seguenti mostrano come implementare un modello da un esperimento Autopilot per le previsioni in batch. 

1. **Accedi a [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)e seleziona Studio dal pannello di navigazione.**

1. Nel riquadro di navigazione a sinistra, seleziona **Studio**.

1. In **Inizia**, seleziona il dominio in cui desideri avviare l'applicazione Studio. Se il tuo profilo utente appartiene a un solo dominio, non vedi l’opzione per la selezione di un dominio.

1. Seleziona il profilo utente per il quale desideri avviare l’applicazione Studio Classic. Se non è presente alcun profilo utente nel dominio, scegli **Crea un profilo utente**. Per ulteriori informazioni, consulta [Aggiungi profili utente](https://docs.aws.amazon.com/sagemaker/latest/dg/domain-user-profile-add.html).

1. Scegli **Avvia Studio**. Se il profilo utente appartiene a uno spazio condiviso, scegli **Spazi aperti**. 

1. Quando si apre la console SageMaker Studio Classic, scegli il pulsante **Launch SageMaker Studio**.

1. Seleziona **AutoML** dal riquadro di navigazione a sinistra.

1. In **Nome**, seleziona l'esperimento Autopilot corrispondente al modello che desideri implementare. Si aprirà una nuova scheda **PROCESSO AUTOPILOT**.

1. Nella sezione **Nome modello**, seleziona il modello che desideri distribuire.

1. Scegli **Distribuisci modello**. Si aprirà una nuova scheda.

1. Scegli **Crea previsioni in batch** nella parte superiore della pagina.

1. Per la **Configurazione del processo di trasformazione batch**, inserisci il **tipo di istanza**, il **conteggio istanze** e altre informazioni facoltative.

1. Nella sezione **Configurazione dei dati di input**, apri il menu a discesa. 

   1. Per il **tipo di dati S3**, scegli **ManifestFile**o **S3Prefix**.

   1. **Per il **tipo Split**, scegliete **Line**, **RecOrdio **TFRecord****o None.**

   1. Per **Compressione**, scegli **Gzip** o **Nessuno**. 

1. Per **Posizione S3**, inserisci la posizione del bucket Amazon S3 dei dati di input e altre informazioni facoltative.

1. In **Configurazione dei dati di output**, inserisci il bucket S3 per i dati di output e scegli come [assemblare l'output](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#sagemaker-Type-TransformOutput-AssembleWith) del tuo processo. 

   1. Per **Configurazione aggiuntiva (opzionale)**, puoi inserire un tipo MIME e una **Chiave di crittografia S3**.

1. Per il **filtraggio di input/output e l'unione dei dati (facoltativo)**, è necessario immettere un' JSONpath espressione per filtrare i dati di input, unire i dati della sorgente di input con i dati di output e immettere un' JSONpath espressione per filtrare i dati di output. 

   1. [Per esempi per ogni tipo di filtro, consulta l'API. DataProcessing ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html#sagemaker-Type-DataProcessing-InputFilter)

1. Per eseguire previsioni in batch sul set di dati di input, seleziona **Crea processo di trasformazione in batch**. Viene visualizzata una nuova scheda **Processi di trasformazione di batch**.

1. Nella scheda **Processi di trasformazione di batch**: individua il nome del tuo processo nella sezione **Stato**. Quindi controlla lo stato di avanzamento del processo. 

## Distribuisci utilizzando SageMaker APIs
<a name="autopilot-deploy-models-batch-steps"></a>

Per utilizzarlo SageMaker APIs per l'inferenza in batch, ci sono tre passaggi:

1. **Ottieni le definizioni dei candidati** 

   Le definizioni candidate di [InferenceContainers](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLCandidate.html#sagemaker-Type-AutoMLCandidate-InferenceContainers)vengono utilizzate per creare un modello di SageMaker intelligenza artificiale. 

   L'esempio seguente mostra come utilizzare l'[DescribeAutoMLJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeAutoMLJob.html)API per ottenere le definizioni dei candidati per il miglior modello candidato. Vedi il AWS CLI comando seguente come esempio.

   ```
   aws sagemaker describe-auto-ml-job --auto-ml-job-name {{<job-name>}} --region {{<region>}}
   ```

   Usa l'[ListCandidatesForAutoMLJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListCandidatesForAutoMLJob.html)API per elencare tutti i candidati. Il comando seguente AWS CLI è un esempio.

   ```
   aws sagemaker list-candidates-for-auto-ml-job --auto-ml-job-name {{<job-name>}} --region {{<region>}}
   ```

1. **Crea un modello di SageMaker intelligenza artificiale**

   Per creare un modello di SageMaker intelligenza artificiale utilizzando l'[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API, utilizza le definizioni dei contenitori dei passaggi precedenti. Il comando seguente AWS CLI è un esempio.

   ```
   aws sagemaker create-model --model-name '{{<your-custom-model-name>}}' \
                       --containers ['{{<container-definition1}}>, {{<container-definition2>}}, {{<container-definition3>}}]' \
                       --execution-role-arn '{{<execution-role-arn>}}' --region '{{<region>}}
   ```

1. **Crea un processo di trasformazione dell' SageMaker IA** 

   L'esempio seguente crea un processo di trasformazione SageMaker AI con l'[CreateTransformJob](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-transform-job.html)API. Vedi il AWS CLI comando seguente come esempio.

   ```
   aws sagemaker create-transform-job --transform-job-name '{{<your-custom-transform-job-name>}}' --model-name '{{<your-custom-model-name-from-last-step>}}'\
   --transform-input '{
           "DataSource": {
               "S3DataSource": {
                   "S3DataType": "S3Prefix", 
                   "S3Uri": "{{<your-input-data>}}" 
               }
           },
           "ContentType": "{{text/csv}}",
           "SplitType": "Line"
       }'\
   --transform-output '{
           "S3OutputPath": "{{<your-output-path>}}",
           "AssembleWith": "Line" 
       }'\
   --transform-resources '{
           "InstanceType": "{{<instance-type>}}", 
           "InstanceCount": {{1}}
       }' --region '{{<region>}}'
   ```

Controlla lo stato di avanzamento del processo di trasformazione utilizzando l'[DescribeTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTransformJob.html)API. Vedi il AWS CLI comando seguente come esempio.

```
aws sagemaker describe-transform-job --transform-job-name '{{<your-custom-transform-job-name>}}' --region {{<region>}}
```

Al termine del lavoro, il risultato previsto sarà disponibile in `<your-output-path>`. 

Il nome file di output presenta il formato seguente: `<input_data_file_name>.out`. Ad esempio, se il file di input è `text_x.csv`, il nome di output sarà `text_x.csv.out`.

Le seguenti schede mostrano esempi di codice per SageMaker Python SDK, AWS SDK for Python (boto3) e. AWS CLI

------
#### [ SageMaker Python SDK ]

L'esempio seguente utilizza **[SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html)** per fare previsioni in batch.

```
from sagemaker import AutoML

sagemaker_session= sagemaker.session.Session()

job_name = '{{test-auto-ml-job}}' # your autopilot job name
automl = AutoML.attach(auto_ml_job_name=job_name)
output_path = '{{s3://test-auto-ml-job/output}}'
input_data = '{{s3://test-auto-ml-job/test_X.csv}}'

# call DescribeAutoMLJob API to get the best candidate definition
best_candidate = automl.describe_auto_ml_job()['BestCandidate']
best_candidate_name = best_candidate['CandidateName']

# create model
model = automl.create_model(name=best_candidate_name, 
               candidate=best_candidate)

# create transformer
transformer = model.transformer(instance_count={{1}}, 
    instance_type='{{ml.m5.2xlarge}}',
    assemble_with='Line',
    output_path=output_path)

# do batch transform
transformer.transform(data=input_data,
                      split_type='Line',
                       content_type='{{text/csv}}',
                       wait=True)
```

------
#### [ AWS SDK for Python (boto3) ]

 L’esempio seguente utilizza **AWS SDK per Python (boto3)** per fare previsioni in batch.

```
import sagemaker 
import boto3

session = sagemaker.session.Session()

sm_client = boto3.client('sagemaker', region_name='{{us-west-2}}')
role = '{{arn:aws:iam::1234567890:role/sagemaker-execution-role}}'
output_path = '{{s3://test-auto-ml-job/output}}'
input_data = '{{s3://test-auto-ml-job/test_X.csv}}'

best_candidate = sm_client.describe_auto_ml_job(AutoMLJobName=job_name)['BestCandidate']
best_candidate_containers = best_candidate['InferenceContainers']
best_candidate_name = best_candidate['CandidateName']

# create model
reponse = sm_client.create_model(
    ModelName = best_candidate_name,
    ExecutionRoleArn = role,
    Containers = best_candidate_containers 
)

# Lauch Transform Job
response = sm_client.create_transform_job(
    TransformJobName=f'{best_candidate_name}-transform-job',
    ModelName=model_name,
    TransformInput={
        'DataSource': {
            'S3DataSource': {
                'S3DataType': 'S3Prefix',
                'S3Uri': input_data
            }
        },
        'ContentType': "{{text/csv}}",
        'SplitType': 'Line'
    },
    TransformOutput={
        'S3OutputPath': output_path,
        'AssembleWith': 'Line',
    },
    TransformResources={
        'InstanceType': '{{ml.m5.2xlarge}}',
        'InstanceCount': {{1}},
    },
)
```

Il processo di inferenza batch restituisce una risposta nel formato seguente.

```
{'TransformJobArn': '{{arn:aws:sagemaker:us-west-2:1234567890:transform-job/test-transform-job}}',
 'ResponseMetadata': {'RequestId': '659f97fc-28c4-440b-b957-a49733f7c2f2',
  'HTTPStatusCode': 200,
  'HTTPHeaders': {'x-amzn-requestid': '659f97fc-28c4-440b-b957-a49733f7c2f2',
   'content-type': 'application/x-amz-json-1.1',
   'content-length': '96',
   'date': 'Thu, 11 Aug 2022 22:23:49 GMT'},
  'RetryAttempts': 0}}
```

------
#### [ AWS Command Line Interface (AWS CLI) ]

1. **Ottieni le definizioni di candidati** utilizzando il seguente esempio di codice.

   ```
   aws sagemaker describe-auto-ml-job --auto-ml-job-name '{{test-automl-job}}' --region {{us-west-2}}
   ```

1. **Crea il modello** utilizzando il seguente esempio di codice.

   ```
   aws sagemaker create-model --model-name '{{test-sagemaker-model}}'
   --containers '[{
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-sklearn-automl:2.5-1-cpu-py3",
       "ModelDataUrl": "{{s3://amzn-s3-demo-bucket/out/test-job1/data-processor-models/test-job1-dpp0-1-e569ff7ad77f4e55a7e549a/output/model.tar.gz}}",
       "Environment": {
           "AUTOML_SPARSE_ENCODE_RECORDIO_PROTOBUF": "1",
           "AUTOML_TRANSFORM_MODE": "feature-transform",
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "application/x-recordio-protobuf",
           "SAGEMAKER_PROGRAM": "sagemaker_serve",
           "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code"
       }
   }, {
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-xgboost:1.3-1-cpu-py3",
       "ModelDataUrl": "{{s3://amzn-s3-demo-bucket/out/test-job1/tuning/flicdf10v2-dpp0-xgb/test-job1E9-244-7490a1c0/output/model.tar.gz}}",
       "Environment": {
           "MAX_CONTENT_LENGTH": "20971520",
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "text/csv",
           "SAGEMAKER_INFERENCE_OUTPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_SUPPORTED": "predicted_label,probability,probabilities" 
       }
   }, {
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-sklearn-automl:2.5-1-cpu-py3", 
       "ModelDataUrl": "{{s3://amzn-s3-demo-bucket/out/test-job1/data-processor-models/test-job1-dpp0-1-e569ff7ad77f4e55a7e549a/output/model.tar.gz}}", 
       "Environment": { 
           "AUTOML_TRANSFORM_MODE": "inverse-label-transform", 
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "text/csv", 
           "SAGEMAKER_INFERENCE_INPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_OUTPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_SUPPORTED": "predicted_label,probability,labels,probabilities", 
           "SAGEMAKER_PROGRAM": "sagemaker_serve", 
           "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code" 
       } 
   }]' \
   --execution-role-arn '{{arn:aws:iam::1234567890:role/sagemaker-execution-role}}' \
   --region '{{us-west-2}}'
   ```

1. **Crea il processo di trasformazione** utilizzando il seguente esempio di codice.

   ```
   aws sagemaker create-transform-job --transform-job-name '{{test-tranform-job}}'\
    --model-name '{{test-sagemaker-model}}'\
   --transform-input '{
           "DataSource": {
               "S3DataSource": {
                   "S3DataType": "S3Prefix",
                   "S3Uri": "{{s3://amzn-s3-demo-bucket/data.csv}}"
               }
           },
           "ContentType": "{{text/csv}}",
           "SplitType": "Line"
       }'\
   --transform-output '{
           "S3OutputPath": "{{s3://amzn-s3-demo-bucket/output/}}",
           "AssembleWith": "Line"
       }'\
   --transform-resources '{
           "InstanceType": "{{ml.m5.2xlarge}}",
           "InstanceCount": {{1}}
       }'\
   --region '{{us-west-2}}'
   ```

1. **Controlla l’avanzamento del processo di trasformazione** utilizzando il seguente esempio di codice. 

   ```
   aws sagemaker describe-transform-job --transform-job-name  '{{test-tranform-job}}' --region {{us-west-2}}
   ```

   Di seguito è riportata la risposta del processo di trasformazione.

   ```
   {
       "TransformJobName": "{{test-tranform-job}}",
       "TransformJobArn": "{{arn:aws:sagemaker:us-west-2:1234567890:transform-job/test-tranform-job}}",
       "TransformJobStatus": "InProgress",
       "ModelName": "{{test-model}}",
       "TransformInput": {
           "DataSource": {
               "S3DataSource": {
                   "S3DataType": "S3Prefix",
                   "S3Uri": "{{s3://amzn-s3-demo-bucket/data.csv}}"
               }
           },
           "ContentType": "{{text/csv}}",
           "CompressionType": "None",
           "SplitType": "Line"
       },
       "TransformOutput": {
           "S3OutputPath": "{{s3://amzn-s3-demo-bucket/output/}}",
           "AssembleWith": "Line",
           "KmsKeyId": ""
       },
       "TransformResources": {
           "InstanceType": "{{ml.m5.2xlarge}}",
           "InstanceCount": {{1}}
       },
       "CreationTime": 1662495635.679,
       "TransformStartTime": 1662495847.496,
       "DataProcessing": {
           "InputFilter": "$",
           "OutputFilter": "$",
           "JoinSource": "None"
       }
   }
   ```

   Dopo che `TransformJobStatus` cambia in `Completed`, puoi controllare il risultato dell'inferenza in `S3OutputPath`.

------

## Implementa modelli da account diversi
<a name="autopilot-deploy-models-batch-across-accounts"></a>

Per creare un processo di inferenza in batch in un account diverso da quello in cui è stato generato il modello, segui le istruzioni riportate in [Implementa modelli da account diversi](autopilot-deploy-models-realtime.md#autopilot-deploy-models-realtime-across-accounts). Quindi puoi creare modelli e processi di trasformazione seguendo i [Distribuisci utilizzando SageMaker APIs](#autopilot-deploy-models-batch-steps).