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à.
# Opzioni di hosting
I seguenti argomenti descrivono le opzioni di hosting SageMaker AI in tempo reale disponibili insieme a come configurare, richiamare ed eliminare ciascuna opzione di hosting.
**Topics**
+ [Endpoint per modelli singoli](realtime-single-model.md)
+ [Endpoint multi-modello](multi-model-endpoints.md)
+ [Endpoint multi-container](multi-container-endpoints.md)
+ [Pipeline di inferenza in Amazon AI SageMaker](inference-pipelines.md)
+ [Elimina endpoint e risorse](realtime-endpoints-delete-resources.md)
# Endpoint per modelli singoli
È possibile creare, aggiornare ed eliminare gli endpoint di inferenza in tempo reale che ospitano un modello singolo con Amazon SageMaker Studio, AWS SDK per Python (Boto3), SageMaker Python SDK o l’AWS CLI. Per le procedure e alcuni esempi di codice, consulta [Implementazione di modelli per l’inferenza in tempo reale](realtime-endpoints-deploy-models.md).
# Endpoint multi-modello
Gli endpoint a più modelli offrono una soluzione scalabile ed economica per la distribuzione di un numero elevato di modelli. Utilizzano lo stesso parco di risorse e un container di servizio condiviso per l’hosting di tutti i tuoi modelli. Questa caratteristica riduce i costi di hosting migliorando l'utilizzo degli endpoint rispetto all'utilizzo di endpoint a singolo modello. Riduce anche il sovraccarico di implementazione perché Amazon SageMaker AI gestisce il caricamento dei modelli in memoria e il loro ridimensionamento in base ai modelli di traffico verso l'endpoint.
Il diagramma seguente mostra come funzionano gli endpoint a più modelli rispetto agli endpoint a modello singolo.
![\[Diagramma che mostra come gli endpoint multi-modello ospitano i modelli rispetto agli endpoint a modello singolo.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/multi-model-endpoints-diagram.png)
Gli endpoint a più modelli sono ideali per ospitare un gran numero di modelli che utilizzano lo stesso framework ML su un container di servizio condiviso. Se hai un mix di modelli con accesso frequente e non, un endpoint multi-modello può servire in modo efficiente questo traffico con meno risorse e maggiori risparmi. L'applicazione deve tollerare le occasionali penalità di latenza legate all'avvio a freddo che si verificano quando si richiamano modelli utilizzati di rado.
Gli endpoint a più modelli supportano l'hosting di modelli basati su CPU e GPU. Utilizzando modelli basati su GPU, è possibile ridurre i costi di implementazione del modello attraverso un maggiore utilizzo dell'endpoint e delle relative istanza a calcolo accelerato.
Gli endpoint a più modelli consentono inoltre la condivisione temporale delle risorse della memoria tra i modelli. Questo comportamento funziona meglio quando i modelli sono abbastanza simili per dimensioni e latenza di invocazione. In questo caso, gli endpoint a più modelli possono utilizzare in modo efficace le istanze in tutti i modelli. Se hai modelli con transazioni al secondo (TPS) o requisiti di latenza significativamente più elevati, è consigliabile ospitarli su endpoint dedicati.
È possibile utilizzare endpoint a più modelli con le seguenti funzionalità:
+ [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html)e VPCs
+ [Dimensionamento automatico](multi-model-endpoints-autoscaling.md)
+ [Pipeline di inferenza seriali](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) (ma solo un container a più modelli può essere incluso in una pipeline di inferenza)
+ Test A/B
Puoi utilizzare AWS SDK per Python (Boto) o la console SageMaker AI per creare un endpoint multimodello. Per gli endpoint a più modelli supportati dalla CPU, puoi creare endpoint con container personalizzati integrando la libreria [Multi Model Server](https://github.com/awslabs/multi-model-server).
**Topics**
+ [Come funzionano gli endpoint a più modelli](#how-multi-model-endpoints-work)
+ [Notebook di esempio per endpoint a più modelli](#multi-model-endpoint-sample-notebooks)
+ [Algoritmi, framework e istanze supportati per endpoint multi-modello](multi-model-support.md)
+ [Raccomandazioni sulle istanze per le distribuzioni di endpoint a più modelli](multi-model-endpoint-instance.md)
+ [Creare un endpoint a più modelli](create-multi-model-endpoint.md)
+ [Invocare un endpoint a più modelli](invoke-multi-model-endpoint.md)
+ [Aggiungere o rimuovere modelli](add-models-to-endpoint.md)
+ [Crea il tuo contenitore per gli endpoint multimodello di intelligenza artificiale SageMaker](build-multi-model-build-container.md)
+ [Sicurezza degli endpoint a più modelli](multi-model-endpoint-security.md)
+ [CloudWatch Metriche per le implementazioni di endpoint multimodello](multi-model-endpoint-cloudwatch-metrics.md)
+ [Imposta il comportamento di memorizzazione nella cache del modello di SageMaker endpoint multimodello AI](multi-model-caching.md)
+ [Imposta le Policy di dimensionamento automatico per le implementazioni di endpoint a più modelli](multi-model-endpoints-autoscaling.md)
## Come funzionano gli endpoint a più modelli
SageMaker L'intelligenza artificiale gestisce il ciclo di vita dei modelli ospitati su endpoint multimodello nella memoria del contenitore. Invece di scaricare tutti i modelli da un bucket Amazon S3 nel contenitore quando crei l'endpoint, l' SageMaker intelligenza artificiale li carica e li memorizza nella cache dinamicamente quando li richiami. Quando l' SageMaker IA riceve una richiesta di invocazione per un particolare modello, esegue le seguenti operazioni:
1. Instrada la richiesta a un'istanza dietro l'endpoint.
1. Scarica il modello dal bucket S3 nel volume di storage di tale istanza.
1. Carica il modello nella memoria del container (CPU o GPU, a seconda che siano presenti istanze supportate da CPU o GPU) su quella istanza a calcolo accelerato. Se il modello è già caricato nella memoria del contenitore, l'invocazione è più veloce perché l' SageMaker IA non ha bisogno di scaricarlo e caricarlo.
SageMaker L'IA continua a indirizzare le richieste di un modello all'istanza in cui il modello è già caricato. Tuttavia, se il modello riceve molte richieste di chiamata e sono presenti istanze aggiuntive per l'endpoint multimodello, l' SageMaker IA indirizza alcune richieste a un'altra istanza per soddisfare il traffico. Se il modello non è già caricato nella seconda istanza, viene scaricato nel volume di storage dell'istanza e caricato nella memoria del container.
Quando l'utilizzo della memoria di un'istanza è elevato e l' SageMaker intelligenza artificiale deve caricare un altro modello in memoria, scarica i modelli inutilizzati dal contenitore dell'istanza per garantire che ci sia abbastanza memoria per caricare il modello. I modelli scaricati rimangono sul volume di storage dell'istanza e possono essere caricati nella memoria del container in un secondo momento senza essere scaricati nuovamente dal bucket S3. Se il volume di archiviazione dell'istanza raggiunge la sua capacità, l' SageMaker IA elimina tutti i modelli inutilizzati dal volume di archiviazione.
Per eliminare un modello, interrompi l'invio di richieste ed eliminalo dal bucket S3. SageMaker L'intelligenza artificiale fornisce funzionalità endpoint multimodello in un contenitore di servizio. L'aggiunta e l'eliminazione di modelli da un endpoint a più modelli non richiede l'aggiornamento dell'endpoint. Per aggiungere un modello, caricalo nel bucket S3 e richiamalo. Per utilizzarlo non sono necessarie modifiche al codice.
**Nota**
Quando si aggiorna un endpoint a più modelli, le richieste di invocazione iniziali sull'endpoint potrebbero subire latenze più elevate poiché Smart Routing negli endpoint a più modelli si adatta al modello di traffico. Tuttavia, una appreso il modello di traffico, è possibile riscontrare basse latenze per i modelli utilizzati più di frequente. I modelli utilizzati meno frequentemente possono subire alcune latenze di avvio a freddo poiché i modelli vengono caricati dinamicamente su un'istanza.
## Notebook di esempio per endpoint a più modelli
Per ulteriori informazioni su come utilizzare gli endpoint a più modelli, puoi provare i seguenti notebook di esempio:
+ Esempi di endpoint a più modelli che utilizzano istanze basate su CPU:
+ [Notebook di XGBoost esempio per endpoint multimodello](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html): questo notebook mostra come implementare più XGBoost modelli su un endpoint.
+ Notebook di [esempio BYOC per endpoint multimodel: questo taccuino](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_bring_your_own/multi_model_endpoint_bring_your_own.html) mostra come configurare e implementare un container per il cliente che supporti gli endpoint multimodello nell'intelligenza artificiale. SageMaker
+ Esempio di endpoint a più modelli che utilizzano istanze basate su GPU:
+ [Esegui più modelli di deep learning GPUs con Amazon SageMaker AI Multi-model endpoint (MME)](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb): questo notebook mostra come utilizzare un container NVIDIA Triton Inference per distribuire ResNet -50 modelli su un endpoint multimodello.
Per istruzioni su come creare e accedere a istanze di notebook Jupyter da utilizzare per eseguire gli esempi precedenti in AI, consulta. SageMaker [Istanze SageMaker per notebook Amazon](nbi.md) Dopo aver creato un'istanza di notebook e averla aperta, scegli la scheda **Esempi SageMaker AI** per visualizzare un elenco di tutti gli esempi di IA. SageMaker Il notebook per endpoint a più modelli si trova nella sezione **FUNZIONALITÀ AVANZATA**. Per aprire un notebook, seleziona la relativa scheda **Utilizza** e scegli **Crea copia**.
Per ulteriori informazioni sui casi d'uso per endpoint a più modelli, consulta i seguenti blog e risorse:
+ Video: [hosting di migliaia di modelli sull' SageMaker intelligenza artificiale](https://www.youtube.com/watch?v=XqCNTWmHsLc&t=751s)
+ Video: [SageMaker AI ML per SaaS](https://www.youtube.com/watch?v=BytpYlJ3vsQ)
+ Blog: [Come scalare l'inferenza del machine learning per casi d'uso SaaS multi-tenant](https://aws.amazon.com/blogs/machine-learning/how-to-scale-machine-learning-inference-for-multi-tenant-saas-use-cases/)
+ Caso di studio: [Veeva Systems](https://aws.amazon.com/partners/success/advanced-clinical-veeva/)
# Algoritmi, framework e istanze supportati per endpoint multi-modello
Per informazioni sugli algoritmi, i framework e i tipi di istanza che è possibile utilizzare con gli endpoint a più modelli, consulta le sezioni seguenti.
## Algoritmi, framework e istanze supportati per endpoint a più modelli che utilizzano istanze supportate da CPU
I container di inferenza per i seguenti algoritmi e framework supportano endpoint a più modelli:
+ [XGBoost algoritmo con Amazon SageMaker AI](xgboost.md)
+ [Algoritmo K-Nearest Neighbors (k-NN)](k-nearest-neighbors.md)
+ [Algoritmo di apprendimento lineare](linear-learner.md)
+ [Algoritmo Random Cut Forest (RCF)](randomcutforest.md)
+ [Risorse da utilizzare TensorFlow con Amazon SageMaker AI](tf.md)
+ [Risorse per usare Scikit-learn con Amazon AI SageMaker](sklearn.md)
+ [Risorse per l'utilizzo di Apache MXNet con Amazon SageMaker AI](mxnet.md)
+ [Risorse da utilizzare PyTorch con Amazon SageMaker AI](pytorch.md)
Per utilizzare qualsiasi altro framework o algoritmo, utilizza il toolkit di inferenza SageMaker AI per creare un contenitore che supporti endpoint multimodello. Per informazioni, consulta [Crea il tuo contenitore per gli endpoint multimodello di intelligenza artificiale SageMaker](build-multi-model-build-container.md).
Gli endpoint a più modelli supportano tutti i tipi di istanze CPU.
## Algoritmi, framework e istanze supportati per endpoint a più modelli che utilizzano istanze supportate da GPU
[L'hosting di più modelli basati su GPU su endpoint multimodello è supportato tramite il server AI Triton Inference. SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Questo supporta tutti i principali framework di inferenza come NVIDIA® TensorRT™, Python, XGBoost ONNX, MXNet scikit-learn PyTorch, OpenVINO, C\$1\$1 personalizzato e altri. RandomForest
Per utilizzare qualsiasi altro framework o algoritmo, puoi usare il back-end Triton per Python o C\$1\$1 per scrivere la logica del modello e servire qualsiasi modello personalizzato. Dopo aver preparato il server, puoi iniziare a implementare centinaia di modelli di Deep Learning dietro un unico endpoint.
Gli endpoint a più modelli supportano i seguenti tipi di istanze GPU:
| Famiglia di istanze | Tipo di istanza | v CPUs | GiB di memoria per vCPU | GPUs | Memoria GPU |
| --- | --- | --- | --- | --- | --- |
| p2 | ml.p2.xlarge | 4 | 15,25 | 1 | 12 |
| p3 | ml.p3.2xlarge | 8 | 7,62 | 1 | 16 |
| g5 | ml.g5.xlarge | 4 | 4 | 1 | 24 |
| g5 | ml.g 5.2xlarg | 8 | 4 | 1 | 24 |
| g5 | ml.g 5,4xlarge | 16 | 4 | 1 | 24 |
| g5 | ml.g 5,8xlarge | 32 | 4 | 1 | 24 |
| g5 | ml.g 5,16xlarge | 64 | 4 | 1 | 24 |
| g4dn | ml.g4dn.xlarge | 4 | 4 | 1 | 16 |
| g4dn | ml.g4dn.2xlarge | 8 | 4 | 1 | 16 |
| g4dn | ml.g4dn.4xlarge | 16 | 4 | 1 | 16 |
| g4dn | ml.g4dn.8xlarge | 32 | 4 | 1 | 16 |
| g4dn | ml.g4dn.16xlarge | 64 | 4 | 1 | 16 |
# Raccomandazioni sulle istanze per le distribuzioni di endpoint a più modelli
Ci sono diversi elementi da considerare quando si seleziona un tipo di istanza SageMaker AI ML per un endpoint multimodello:
+ Assegna una capacità sufficiente di [Amazon Elastic Block Store (Amazon EBS)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) per tutti i modelli che devono essere serviti.
+ Bilancia le prestazioni (riduci al minimo gli avvii a freddo) e i costi (non sovraccaricare la capacità delle istanze). Per informazioni sulla dimensione del volume di archiviazione che SageMaker AI allega per ogni tipo di istanza per un endpoint e per un endpoint multimodello, consulta. [Volumi di archiviazione delle istanze](host-instance-storage.md)
+ Per un container configurato per l'esecuzione in modalità `MultiModel`, il volume di storage assegnato per le sue istanze è più grande rispetto alla modalità predefinita `SingleModel`. Ciò consente di memorizzare nella cache più modelli nel volume di storage dell'istanza rispetto alla modalità `SingleModel`.
Quando scegli un tipo di istanza SageMaker AI ML, considera quanto segue:
+ Gli endpoint a più modelli sono attualmente supportati per tutti i tipi di istanze CPU e per i tipi di istanze a GPU singola.
+ Per la distribuzione del traffico (modelli di accesso) ai modelli da ospitare dietro l'endpoint a più modelli, insieme alla dimensione del modello (quanti modelli possono essere caricati in memoria sull'istanza) tieni a mente le seguenti informazioni:
+ Pensate alla quantità di memoria su un'istanza come spazio di cache per i modelli da caricare e al numero di v CPUs come limite di concorrenza per eseguire inferenze sui modelli caricati (supponendo che l'invocazione di un modello sia vincolata alla CPU).
+ Per le istanze basate su CPU, il numero di v CPUs influisce sul numero massimo di chiamate simultanee per istanza (supponendo che l'invocazione di un modello sia vincolata alla CPU). Una quantità maggiore di v CPUs consente di richiamare contemporaneamente più modelli unici.
+ Per le istanze supportate da GPU, una quantità maggiore di memoria dell'istanza e della GPU consente di avere più modelli caricati e pronti a servire le richieste di inferenza.
+ Sia per le istanze supportate dalla CPU che per quelle supportate dalla GPU è necessario avere un po' di memoria "slack" disponibile in modo che i modelli non utilizzati possano essere scaricati, soprattutto per gli endpoint a più modelli con più istanze. Se un'istanza o una zona di disponibilità non riesce, i modelli su tali istanze verranno reindirizzati ad altre istanze dietro l'endpoint.
+ Determina la tua tolleranza ai tempi loading/downloading :
+ Le famiglie di tipi di istanze d (ad esempio m5d, c5d o r5d) e g5s sono dotate di un'unità SSD NVMe (non volatile memory express) che offre I/O prestazioni elevate e può ridurre il tempo necessario per scaricare i modelli nel volume di archiviazione e il contenitore per caricare il modello dal volume di archiviazione.
+ Poiché i tipi di istanze d e g5 sono dotati di uno storage NVMe SSD, SageMaker AI non collega un volume di storage Amazon EBS a queste istanze di calcolo ML che ospitano l'endpoint multimodello. Il dimensionamento automatico funziona meglio quando i modelli sono di dimensioni simili e omogenei, ovvero quando hanno requisiti di latenza di inferenza e risorse simili.
È inoltre possibile utilizzare le seguenti indicazioni per ottimizzare il caricamento dei modelli sugli endpoint a più modelli:
**Scelta di un tipo di istanza che non può contenere tutti i modelli di destinazione in memoria**
In alcuni casi, potresti scegliere di ridurre i costi scegliendo un tipo di istanza che non può contenere tutti i modelli di destinazione in memoria contemporaneamente. SageMaker L'intelligenza artificiale scarica dinamicamente i modelli quando esaurisce la memoria per fare spazio a un nuovo modello mirato. Per i modelli non richiesti di frequente, sacrifichi la latenza di carico dinamica. Nei casi con esigenze di latenza più severe, è possibile optare per tipi di istanza più grandi o per più istanze. Investire tempo in anticipo per i test e l'analisi delle prestazioni aiuta ad avere implementazioni di produzione di successo.
**Valutare le visite alla cache del tuo modello**
CloudWatch Le metriche di Amazon possono aiutarti a valutare i tuoi modelli. Per ulteriori informazioni sui parametri che puoi utilizzare con endpoint a più modelli, consulta [CloudWatch Metriche per le implementazioni di endpoint multimodello](multi-model-endpoint-cloudwatch-metrics.md).
Puoi utilizzare la statistica `Average` del parametro `ModelCacheHit` per monitorare il rapporto delle richieste in cui il modello è già caricato. Puoi utilizzare la statistica `SampleCount` per il parametro `ModelUnloadingTime` per monitorare il numero di richieste di scarico inviate al container in un periodo di tempo. Se i modelli vengono scaricati troppo frequentemente (un indicatore di *thrashing* in cui i modelli vengono scaricati e caricati di nuovo perché lo spazio nella cache è insufficiente per il set di lavoro di modelli), è consigliabile utilizzare un tipo di istanza più grande con più memoria o aumentare il numero di istanze dietro l'endpoint a più modelli. Per gli endpoint a più modelli con più istanze, tieni presente che un modello può essere caricato su più di 1 istanza.
# Creare un endpoint a più modelli
Puoi utilizzare la console SageMaker AI o creare un endpoint AWS SDK per Python (Boto) multimodello. Per creare un endpoint basato su CPU o GPU tramite la console, consulta la procedura della console nelle sezioni seguenti. Se desideri creare un endpoint multimodello con AWS SDK per Python (Boto), utilizza la procedura CPU o GPU descritta nelle sezioni seguenti. I flussi di lavoro della CPU e GPU sono simili ma presentano diverse differenze, come i requisiti del container.
**Topics**
+ [Creare un endpoint a più modelli (console)](#create-multi-model-endpoint-console)
+ [Crea un endpoint multimodello utilizzando con CPUs AWS SDK per Python (Boto3)](#create-multi-model-endpoint-sdk-cpu)
+ [Crea un endpoint multimodello utilizzando con GPUs AWS SDK per Python (Boto3)](#create-multi-model-endpoint-sdk-gpu)
## Creare un endpoint a più modelli (console)
È possibile creare endpoint a più modelli supportati da CPU e GPU tramite la console. Utilizza la seguente procedura per creare un endpoint multimodello tramite la console AI. SageMaker
**Per creare un endpoint a più modelli (console)**
1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Scegliere **Model (Modello)**, quindi dal gruppo **Inference (Inferenza)** scegliere **Create model (Crea modello)**.
1. Per **Model name (Nome modello)**, immettere un nome.
1. Per il **ruolo IAM**, scegli o crea un ruolo IAM a cui è collegata la policy IAM `AmazonSageMakerFullAccess`.
1. Nella sezione **Definizione container** per **Fornisci artefatti dì modello e immagine di inferenza** scegliere **Utilizza più modelli**.
![\[La sezione della pagina di creazione dei modelli in cui è possibile scegliere Utilizza più modelli.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/mme-create-model-ux-2.PNG)
1. Per **Immagine del container dell'inferenza**, inserisci il percorso Amazon ECR per l'immagine del container desiderata.
Per i modelli GPU, è necessario utilizzare un container supportato da NVIDIA Triton Inference Server. Per un elenco di immagini di container che funzionano con endpoint supportati da GPU, consulta [Container di inferenza Triton NVIDIA (solo supporto SM)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only). Per ulteriori informazioni su NVIDIA Triton Inference Server, consulta [Use Triton Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Server with AI. SageMaker
1. Scegli **Crea modello**.
1. Distribuire l'endpoint a più modelli come si farebbe con un endpoint a singolo modello. Per istruzioni, consulta [Implementa il modello su AI Hosting Services SageMaker](ex1-model-deployment.md#ex1-deploy-model).
## Crea un endpoint multimodello utilizzando con CPUs AWS SDK per Python (Boto3)
Utilizza la sezione seguente per creare un endpoint a più modelli supportato da istanze di CPU. Puoi creare un endpoint multimodello utilizzando Amazon SageMaker AI [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model)e [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs proprio come creeresti un endpoint a modello singolo, ma con due modifiche. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) Quando si definisce il container del modello, è necessario passare un nuovo valore del parametro `Mode`: `MultiModel`. È inoltre necessario passare il campo `ModelDataUrl` che specifica il prefisso in S3 Amazon dove si trovano gli artefatti del modello, anziché il percorso di un artefatto di singolo modello, come si farebbe quando si distribuisce un singolo modello.
[Per un notebook di esempio che utilizza l' SageMaker intelligenza artificiale per distribuire più XGBoost modelli su un endpoint, consulta Multi-Model Endpoint Sample Notebook. XGBoost ](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html)
Nella procedura seguente vengono illustrate le fasi chiave utilizzate nell'esempio per creare un endpoint a più modelli supportato dalla CPU.
**Per distribuire il modello (AWS SDK per Python (Boto 3))**
1. Procurati un container con un'immagine che supporti la l'implementazione di endpoint a più modelli. Per un elenco di algoritmi e container di framework integrati che supportano endpoint a più modelli, consulta [Algoritmi, framework e istanze supportati per endpoint multi-modello](multi-model-support.md). Per questo esempio, utilizziamo l'algoritmo integrato [Algoritmo K-Nearest Neighbors (k-NN)](k-nearest-neighbors.md). Chiamiamo la funzione di utilità [SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` per ottenere l'indirizzo per l'immagine dell'algoritmo integrato K-Nearest Neighbors.
```
import sagemaker
region = sagemaker_session.boto_region_name
image = sagemaker.image_uris.retrieve("knn",region=region)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
```
1. Procurati un client AWS SDK per Python (Boto3) SageMaker AI e crea il modello che utilizza questo contenitore.
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. (Facoltativo) Se si utilizza una pipeline di inferenza seriale, ottenere i container aggiuntivi da includere nella pipeline e includerli nell'argomento `Containers` di `CreateModel`:
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**Nota**
È possibile utilizzare un solo multi-model-enabled endpoint in una pipeline di inferenza seriale.
1. (Facoltativo) Se il tuo caso d'uso non trae vantaggio dalla memorizzazione nella cache del modello, imposta il valore del campo `ModelCacheSetting` del parametro `MultiModelConfig` su `Disabled` e includilo nell'argomento `Container` della chiamata a `create_model`. Il valore di default del campo `ModelCacheSetting` è `Enabled`.
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. Configurare l'endpoint a più modelli per il modello. Si consiglia di configurare gli endpoint con almeno due istanze. Ciò consente all' SageMaker intelligenza artificiale di fornire un set di previsioni ad alta disponibilità su più zone di disponibilità per i modelli.
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.m4.xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
**Nota**
È possibile utilizzare un solo multi-model-enabled endpoint in una pipeline di inferenza seriale.
1. Creare l'endpoint a più modelli utilizzando i parametri `EndpointName` e `EndpointConfigName`.
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
## Crea un endpoint multimodello utilizzando con GPUs AWS SDK per Python (Boto3)
Utilizza la sezione seguente per creare un endpoint a più modelli supportato da istanze di GPU. Crei un endpoint multimodello utilizzando Amazon SageMaker AI [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model)e in [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs modo analogo alla creazione di endpoint a modello singolo, ma ci sono diverse modifiche. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) Quando si definisce il container del modello, è necessario passare un nuovo valore del parametro `Mode`: `MultiModel`. È inoltre necessario passare il campo `ModelDataUrl` che specifica il prefisso in S3 Amazon dove si trovano gli artefatti del modello, anziché il percorso di un artefatto di singolo modello, come si farebbe quando si distribuisce un singolo modello. Per gli endpoint a più modelli supportati da GPU, devi anche utilizzare un container con NVIDIA Triton Inference Server ottimizzato per l'esecuzione su istanze GPU. Per un elenco di immagini di container che funzionano con endpoint supportati da GPU, consulta [Container di inferenza Triton NVIDIA (solo supporto SM)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only).
Per un notebook di esempio che dimostra come creare un endpoint multimodello supportato da GPUs, consulta [Esegui più modelli di deep learning con GPUs Amazon SageMaker AI Multi-model](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb) endpoint (MME).
Nella procedura seguente vengono illustrate le fasi chiave per creare un endpoint a più modelli supportato dalla GPU.
**Per distribuire il modello (AWS SDK per Python (Boto 3))**
1. Definizione dell'immagine del container. [Per creare un endpoint multimodello con supporto GPU per i ResNet modelli, definisci il contenitore per utilizzare l'immagine del server NVIDIA Triton.](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Questo container supporta endpoint a più modelli ed è ottimizzato per l'esecuzione su istanze GPU. Chiamiamo la funzione di utilità [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` per ottenere l'indirizzo dell'immagine. Esempio:
```
import sagemaker
region = sagemaker_session.boto_region_name
// Find the sagemaker-tritonserver image at
// https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-triton/resnet50/triton_resnet50.ipynb
// Find available tags at https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only
image = ".dkr.ecr..amazonaws.com/sagemaker-tritonserver:".format(
account_id=account_id_map[region], region=region
)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel',
"Environment": {"SAGEMAKER_TRITON_DEFAULT_MODEL_NAME": "resnet"},
}
```
1. Ottieni un client AWS SDK per Python (Boto3) SageMaker AI e crea il modello che utilizza questo contenitore.
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. (Facoltativo) Se si utilizza una pipeline di inferenza seriale, ottenere i container aggiuntivi da includere nella pipeline e includerli nell'argomento `Containers` di `CreateModel`:
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**Nota**
È possibile utilizzare un solo multi-model-enabled endpoint in una pipeline di inferenza seriale.
1. (Facoltativo) Se il tuo caso d'uso non trae vantaggio dalla memorizzazione nella cache del modello, imposta il valore del campo `ModelCacheSetting` del parametro `MultiModelConfig` su `Disabled` e includilo nell'argomento `Container` della chiamata a `create_model`. Il valore di default del campo `ModelCacheSetting` è `Enabled`.
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. Configurare l'endpoint a più modelli con istanze supportate da GPU per il modello. Ti consigliamo di configurare gli endpoint con più di un'istanza per consentire un'elevata disponibilità e maggiori accessi alla cache.
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.g4dn.4xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
1. Creare l'endpoint a più modelli utilizzando i parametri `EndpointName` e `EndpointConfigName`.
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
# Invocare un endpoint a più modelli
Per richiamare un endpoint multimodello, usa l'[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) SageMaker AI Runtime proprio come richiameresti un endpoint a modello singolo, con una sola modifica. Passa un nuovo parametro `TargetModel` che specifica i modelli di destinazione nell'endpoint. La `InvokeEndpoint` richiesta SageMaker AI Runtime supporta `X-Amzn-SageMaker-Target-Model` una nuova intestazione che segue il percorso relativo del modello specificato per l'invocazione. Il sistema SageMaker AI costruisce il percorso assoluto del modello combinando il prefisso fornito come parte della chiamata `CreateModel` API con il percorso relativo del modello.
Le seguenti procedure sono le stesse per gli endpoint a più modelli supportati da CPU e GPU.
------
#### [ AWS SDK for Python (Boto 3) ]
La seguente richiesta di previsione di esempio utilizza [AWS SDK per Python (Boto 3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html) nel notebook di esempio.
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName = "",
ContentType = "text/csv",
TargetModel = ".tar.gz",
Body = body)
```
------
#### [ AWS CLI ]
L'esempio seguente mostra come creare una richiesta CSW con due righe utilizzando il simbolo AWS Command Line Interface (AWS CLI):
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name "" \
--body "1.0,2.0,5.0"$'\n'"2.0,3.0,4.0" \
--content-type "text/csv" \
--target-model ".tar.gz"
output_file.txt
```
Se l'inferenza ha avuto successo, viene effettuata una `output_file.txt` con informazioni sulle richieste di inferenza. Per altri esempi su come fare previsioni con AWS CLI, consulta [Fare previsioni con the AWS CLI](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#making-predictions-with-the-aws-cli) nella documentazione di SageMaker Python SDK.
------
L'endpoint a più modelli carica dinamicamente i modelli di destinazione in base alle esigenze. Puoi osservare questo comportamento quando si esegue il [notebook di esempio MME](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html) in quanto esegue l'iterazione di invocazioni casuali su più modelli di destinazione ospitati dietro un singolo endpoint. La prima richiesta per un determinato modello necessita di più tempo perché il modello deve essere scaricato da Amazon Simple Storage Service (Amazon S3) e caricato in memoria. Si tratta del cosiddetto *avvio a freddo* e, negli endpoint a più modelli, si prevede che venga ottimizzato per migliorare il rapporto prezzo/prestazioni dei clienti. Le chiamate successive terminano più velocemente perché non c'è alcun sovraccarico aggiuntivo dopo il caricamento del modello.
**Nota**
Per le istanze basate su GPU, il codice di risposta HTTP con 507 dal container GPU indica una mancanza di memoria o di altre risorse. Ciò fa sì che i modelli non utilizzati vengano scaricati dal container per caricare i modelli utilizzati più di frequente.
## Riprova le richieste relative agli errori ModelNotReadyException
La prima volta che chiami un modello `invoke_endpoint`, questo viene scaricato da Amazon Simple Storage Service e caricato nel container di inferenza. In questo modo la risposta alla prima chiamata impiega più tempo. Le chiamate successive allo stesso modello terminano più velocemente, perché il modello è già caricato.
SageMaker L'intelligenza artificiale restituisce una risposta per una chiamata `invoke_endpoint` entro 60 secondi. Alcuni modelli sono troppo grandi per essere scaricati entro 60 secondi. Se il caricamento del modello non termina prima del limite di timeout di 60 secondi, la richiesta di `invoke_endpoint` restituisce il codice di errore `ModelNotReadyException` e il modello continua a essere scaricato e caricato nel container di inferenza per un massimo di 360 secondi. Se ricevi un codice di errore `ModelNotReadyException` per una richiesta di `invoke_endpoint`, riprova la richiesta. Per impostazione predefinita, le `invoke_endpoint` richieste di ripetizione AWS SDKs per Python (Boto 3) (utilizzando la [modalità Legacy retry](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#legacy-retry-mode)) e Java riprovano che generano errori. `ModelNotReadyException` Puoi configurare la strategie di ripetizione. per continuare a ripetere la richiesta per un massimo di 360 secondi. Se prevedi che il modello impieghi più di 60 secondi per essere scaricato e caricato nel container, imposta il timeout del socket SDK su 70 secondi. Per ulteriori informazioni sulla configurazione della strategia di ripetizione di AWS SDK per Python (Boto3), consulta [Configurazione di una modalità di ripetizione](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#configuring-a-retry-mode). Il codice seguente mostra un esempio che configura la strategia di ripetizione per ritentare le chiamate a `invoke_endpoint` per un massimo di 180 secondi.
```
import boto3
from botocore.config import Config
# This example retry strategy sets the retry attempts to 2.
# With this setting, the request can attempt to download and/or load the model
# for upto 180 seconds: 1 orginal request (60 seconds) + 2 retries (120 seconds)
config = Config(
read_timeout=70,
retries={
'max_attempts': 2 # This value can be adjusted to 5 to go up to the 360s max timeout
}
)
runtime_sagemaker_client = boto3.client('sagemaker-runtime', config=config)
```
# Aggiungere o rimuovere modelli
Puoi distribuire modelli aggiuntivi a un endpoint a più modelli e invocarli immediatamente tramite quell'endpoint. Quando si aggiunge un nuovo modello, non è necessario aggiornare o disattivare l'endpoint e in tal modo eviti il costo della creazione e dell'esecuzione di un endpoint separato per ogni nuovo modello. Il processo di aggiunta e rimozione dei modelli è lo stesso degli endpoint a più modelli basati su CPU e GPU.
SageMaker L'intelligenza artificiale scarica i modelli inutilizzati dal contenitore quando l'istanza raggiunge la capacità di memoria ed è necessario scaricare altri modelli nel contenitore. SageMaker L'intelligenza artificiale elimina anche gli artefatti del modello inutilizzati dal volume di archiviazione dell'istanza quando il volume raggiunge la capacità massima ed è necessario scaricare nuovi modelli. La prima invocazione a un modello appena aggiunto impiega più tempo perché l'endpoint richiede tempo per scaricare il modello da S3 nella memoria del container nell'istanza che ospita l'endpoint.
Con l'endpoint già in esecuzione, copia un nuovo set di artefatti del modello nella posizione S3 di Amazon in cui archivi i modelli.
```
# Add an AdditionalModel to the endpoint and exercise it
aws s3 cp AdditionalModel.tar.gz s3://amzn-s3-demo-bucket/path/to/artifacts/
```
**Importante**
Per aggiornare un modello, procedi come faresti per aggiungere un nuovo modello. Utilizza un nome nuovo e univoco. Non sovrascrivere gli artefatti del modello in S3 di Amazon perché la versione precedente del modello potrebbe ancora essere caricata nei container o nel volume di storage delle istanze nell'endpoint. Le invocazioni al nuovo modello potrebbero richiamare la versione precedente del modello.
Le applicazioni client possono richiedere le previsioni dal modello di destinazione aggiuntivo non appena viene archiviato in S3.
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName='',
ContentType='text/csv',
TargetModel='AdditionalModel.tar.gz',
Body=body)
```
Per eliminare un modello da un endpoint a più modelli, interrompi l'invocazione del modello dai client e rimuovilo dal percorso S3 in cui sono archiviati gli artefatti del modello.
# Crea il tuo contenitore per gli endpoint multimodello di intelligenza artificiale SageMaker
Fai riferimento alle seguenti sezioni per portare il tuo container e le tue dipendenze su endpoint a più modelli.
**Topics**
+ [Implementa le tue dipendenze degli endpoint a più modelli su istanze basate su CPU](#build-multi-model-container-cpu)
+ [Implementa le tue dipendenze degli endpoint a più modelli su istanze basate su GPU](#build-multi-model-container-gpu)
+ [Usa l'AI Inference Toolkit SageMaker](#multi-model-inference-toolkit)
+ [Contratto per container personalizzati per endpoint a più modelli](mms-container-apis.md)
## Implementa le tue dipendenze degli endpoint a più modelli su istanze basate su CPU
Se nessuna delle immagini predefinite dei container soddisfa le tue esigenze, puoi creare un container personalizzato da utilizzare con endpoint a più modelli basati su CPU.
Le immagini personalizzate di Amazon Elastic Container Registry (Amazon ECR) distribuite in SageMaker Amazon AI devono rispettare il contratto di base descritto in che regola il SageMaker modo [Codice di inferenza personalizzato con servizi di hosting](your-algorithms-inference-code.md) in cui l'IA interagisce con un contenitore Docker che esegue il tuo codice di inferenza. Affinché un container sia in grado di caricare e servire più modelli contemporaneamente, è necessario seguire alcuni comportamenti aggiuntivi. APIs Questo contratto aggiuntivo include nuovi modelli APIs per caricare, elencare, ottenere e scaricare e un'API diversa per richiamare i modelli. Esistono anche diversi comportamenti per gli scenari di errore che APIs è necessario rispettare. Per indicare che il container è conforme ai requisiti aggiuntivi, puoi aggiungere il seguente comando al Dockerfile:
```
LABEL com.amazonaws.sagemaker.capabilities.multi-models=true
```
SageMaker L'intelligenza artificiale inserisce anche una variabile di ambiente nel contenitore
```
SAGEMAKER_MULTI_MODEL=true
```
Se stai creando un endpoint multimodello per una pipline di inferenza seriale, il file Docker deve avere le etichette necessarie per le pipeline di inferenza seriale e multimodello. Per ulteriori informazioni sulle pipeline di informazioni seriali, vedere [Esecuzione di previsioni in tempo reale con una pipeline di inferenza](inference-pipeline-real-time.md).
Per semplificare l'implementazione di questi requisiti per un container personalizzato, sono disponibili due librerie:
+ [Multi Model Server](https://github.com/awslabs/multi-model-server) è un framework open source per fornire modelli di machine learning che possono essere installati in contenitori per fornire il front-end che soddisfi i requisiti per il nuovo contenitore di endpoint multimodello. APIs Fornisce le funzionalità di front-end HTTP e gestione del modello richieste dagli endpoint a più modelli per ospitare più modelli all'interno di un singolo container, caricare modelli e scaricare modelli dal container in modo dinamico ed eseguire l'inferenza su un modello caricato specifico. Fornisce inoltre un back-end integrabile che supporta un gestore back-end personalizzato integrabile in cui puoi implementare il tuo algoritmo.
+ [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) è una libreria che avvia Multi Model Server con una configurazione e impostazioni che lo rendono compatibile con gli endpoint AI multimodello. SageMaker Consente inoltre di modificare parametri per prestazioni importanti, ad esempio il numero di worker per modello, in base alle esigenze dello scenario.
## Implementa le tue dipendenze degli endpoint a più modelli su istanze basate su GPU
La funzionalità Bring your own container (BYOC) su endpoint multimodello con istanze supportate da GPU non è attualmente supportata dalle librerie Multi Model Server e AI Inference Toolkit. SageMaker
[https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Per importare le tue dipendenze, puoi creare il tuo contenitore usando [NVIDIA](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Triton Inference Server supportato dall' SageMaker intelligenza artificiale come immagine di base del tuo file Docker:
```
FROM 301217895009.dkr.ecr.us-west-2.amazonaws.com/sagemaker-tritonserver:22.07-py3
```
**Importante**
I container con Triton Inference Server sono gli unici container supportati che puoi utilizzare per endpoint a più modelli basati su GPU.
## Usa l'AI Inference Toolkit SageMaker
**Nota**
L' SageMaker AI Inference Toolkit è supportato solo per endpoint multimodello supportati da CPU. L' SageMaker AI Inference Toolkit non è attualmente supportato per gli endpoint multimodello supportati da GPU.
I container predefiniti che supportano gli endpoint a più modelli sono elencati in [Algoritmi, framework e istanze supportati per endpoint multi-modello](multi-model-support.md). Se vuoi utilizzare qualsiasi altro framework o algoritmo, devi creare un container. Il modo più semplice per farlo è utilizzare [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) per estendere un contenitore precostruito esistente. Il toolkit di inferenza SageMaker AI è un'implementazione per il server multimodello (MMS) che crea endpoint che possono essere implementati nell'intelligenza artificiale. SageMaker [Per un notebook di esempio che mostra come configurare e distribuire un contenitore personalizzato che supporti gli endpoint multimodello nell' SageMaker intelligenza artificiale, consulta il Multi-Model Endpoint BYOC Sample Notebook.](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_bring_your_own)
**Nota**
Il toolkit di inferenza SageMaker AI supporta solo i gestori di modelli Python. Se desideri implementare il tuo gestore in qualsiasi altra lingua, devi creare il tuo contenitore che implementi l'endpoint multimodello aggiuntivo. APIs Per informazioni, consulta [Contratto per container personalizzati per endpoint a più modelli](mms-container-apis.md).
**Per estendere un contenitore utilizzando il toolkit di inferenza AI SageMaker**
1. Crea un handler di modelli. In MMS è previsto un handler di modelli, ossia un file Python che implementa funzioni per preelaborare, ottenere previsioni dal modello ed elaborare l'output in un handler di modelli. Per un esempio di handler di modelli, consulta [model\$1handler.py](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/model_handler.py) nel notebook di esempio.
1. Importa il toolkit di inferenza e utilizza la funzione `model_server.start_model_server` per avviare MMS. L'esempio seguente proviene dal file `dockerd-entrypoint.py` del notebook di esempio. Tieni presente che la chiamata a `model_server.start_model_server` passa l'handler di modelli descritto nella fase precedente:
```
import subprocess
import sys
import shlex
import os
from retrying import retry
from subprocess import CalledProcessError
from sagemaker_inference import model_server
def _retry_if_error(exception):
return isinstance(exception, CalledProcessError or OSError)
@retry(stop_max_delay=1000 * 50,
retry_on_exception=_retry_if_error)
def _start_mms():
# by default the number of workers per model is 1, but we can configure it through the
# environment variable below if desired.
# os.environ['SAGEMAKER_MODEL_SERVER_WORKERS'] = '2'
model_server.start_model_server(handler_service='/home/model-server/model_handler.py:handle')
def main():
if sys.argv[1] == 'serve':
_start_mms()
else:
subprocess.check_call(shlex.split(' '.join(sys.argv[1:])))
# prevent docker exit
subprocess.call(['tail', '-f', '/dev/null'])
main()
```
1. Nel tuo `Dockerfile`, copia l'handler di modelli dalla prima fase e specifica il file Python della fase precedente come punto di ingresso nel `Dockerfile`. Le seguenti righe provengono dal [Dockerfile](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/Dockerfile) utilizzato nel notebook di esempio:
```
# Copy the default custom service file to handle incoming data and inference requests
COPY model_handler.py /home/model-server/model_handler.py
# Define an entrypoint script for the docker image
ENTRYPOINT ["python", "/usr/local/bin/dockerd-entrypoint.py"]
```
1. Crea e registra il container. Il seguente script di shell del notebook di esempio costruisce il container e lo carica in un repository Amazon Elastic Container Registry nel tuo account AWS :
```
%%sh
# The name of our algorithm
algorithm_name=demo-sagemaker-multimodel
cd container
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi
# Get the login command from ECR and execute it directly
$(aws ecr get-login --region ${region} --no-include-email)
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -q -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
Ora puoi utilizzare questo contenitore per implementare endpoint multimodello nell'intelligenza artificiale. SageMaker
**Topics**
+ [Implementa le tue dipendenze degli endpoint a più modelli su istanze basate su CPU](#build-multi-model-container-cpu)
+ [Implementa le tue dipendenze degli endpoint a più modelli su istanze basate su GPU](#build-multi-model-container-gpu)
+ [Usa l'AI Inference Toolkit SageMaker](#multi-model-inference-toolkit)
+ [Contratto per container personalizzati per endpoint a più modelli](mms-container-apis.md)
# Contratto per container personalizzati per endpoint a più modelli
Per gestire più modelli, il contenitore deve supportare una serie di modelli APIs che consentano ad Amazon SageMaker AI di comunicare con il container per caricare, elencare, ricevere e scaricare i modelli secondo necessità. `model_name`Viene utilizzato nel nuovo set di APIs come parametro di input chiave. Si prevede che il container del cliente tenga traccia dei modelli caricati utilizzando `model_name` come chiave di mappatura. Inoltre, `model_name` è un identificatore opaco e non è necessariamente il valore del parametro `TargetModel` passato nell'API `InvokeEndpoint`. Il `TargetModel` valore originale della `InvokeEndpoint` richiesta viene passato al contenitore APIs come `X-Amzn-SageMaker-Target-Model` intestazione che può essere utilizzata per scopi di registrazione.
**Nota**
[Gli endpoint multimodello per le istanze basate su GPU sono attualmente supportati solo con il contenitore NVIDIA Triton Inference Server di SageMaker AI.](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Questo container implementa già il contratto definito di seguito. I clienti possono utilizzare direttamente questo container con i loro endpoint GPU a più modelli, senza alcun intervento aggiuntivo.
Puoi configurare quanto segue APIs sui tuoi contenitori per endpoint multimodello basati su CPU.
**Topics**
+ [Caricamento modello API](#multi-model-api-load-model)
+ [Elenco modelli API](#multi-model-api-list-model)
+ [Ottenere un modello API](#multi-model-api-get-model)
+ [Scarica modello API](#multi-model-api-unload-model)
+ [Invocare un modello API](#multi-model-api-invoke-model)
## Caricamento modello API
Indica al container di caricare un particolare modello presente nel campo `url` del corpo nella memoria del container del cliente e di tenerne traccia con il `model_name` assegnato. Dopo aver caricato un modello, il container deve essere pronto per servire le richieste di inferenza utilizzando questo `model_name`.
```
POST /models HTTP/1.1
Content-Type: application/json
Accept: application/json
{
"model_name" : "{model_name}",
"url" : "/opt/ml/models/{model_name}/model",
}
```
**Nota**
Se `model_name` è già caricato, l'API restituisce il codice 409. Ogni volta che un modello non può essere caricato a causa della mancanza di memoria o di qualsiasi altra risorsa, questa API dovrebbe restituire un codice di stato HTTP 507 all' SageMaker IA, che quindi avvia lo scaricamento dei modelli inutilizzati da recuperare.
## Elenco modelli API
Restituisce l'elenco dei modelli caricati nella memoria del container del cliente.
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
Questa API supporta anche la paginazione.
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
SageMaker L'IA può inizialmente chiamare l'API List Models senza fornire un valore per. `next_page_token` Se un campo `nextPageToken` viene restituito come parte della risposta, verrà fornito come valore per `next_page_token` in una successiva chiamata List Models (Elenco modelli). Se `nextPageToken` non viene restituito, significa che non ci sono più modelli da restituire.
## Ottenere un modello API
Questa è una semplice API di lettura sull'entità `model_name`.
```
GET /models/{model_name} HTTP/1.1
Accept: application/json
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
}
```
**Nota**
Se l'entità `model_name` non è caricata, l'API restituisce il codice 404.
## Scarica modello API
Indica alla piattaforma SageMaker AI di indicare al container del cliente di scaricare un modello dalla memoria. Viene quindi iniziata l'espulsione di un modello candidato come determinato dalla piattaforma quando avvia il processo di caricamento di un nuovo modello. Le risorse assegnate a `model_name` devono essere recuperate dal container quando l'API restituisce una risposta.
```
DELETE /models/{model_name}
```
**Nota**
Se l'entità `model_name` non è caricata, l'API restituisce il codice 404.
## Invocare un modello API
Effettua una richiesta di previsione dal particolare `model_name` fornito. La `InvokeEndpoint` richiesta SageMaker AI Runtime supporta `X-Amzn-SageMaker-Target-Model` una nuova intestazione che segue il percorso relativo del modello specificato per la chiamata. Il sistema SageMaker AI costruisce il percorso assoluto del modello combinando il prefisso fornito come parte della chiamata `CreateModel` API con il percorso relativo del modello.
```
POST /models/{model_name}/invoke HTTP/1.1
Content-Type: ContentType
Accept: Accept
X-Amzn-SageMaker-Custom-Attributes: CustomAttributes
X-Amzn-SageMaker-Target-Model: [relativePath]/{artifactName}.tar.gz
```
**Nota**
Se l'entità `model_name` non è caricata, l'API restituisce il codice 404.
Inoltre, nelle istanze GPU, in caso di `InvokeEndpoint` errore a causa della mancanza di memoria o di altre risorse, questa API dovrebbe restituire un codice di stato HTTP 507 all' SageMaker IA, che quindi avvia lo scarico dei modelli inutilizzati da recuperare.
# Sicurezza degli endpoint a più modelli
I modelli e i dati in un endpoint a più modelli si trovano insieme nel volume di storage dell'istanza e nella memoria del container. Tutte le istanze per gli endpoint Amazon SageMaker AI vengono eseguite su un singolo contenitore tenant di tua proprietà. Solo i tuoi modelli possono essere eseguiti sull'endpoint a più modelli. È tua responsabilità gestire la mappatura delle richieste ai modelli e fornire agli utenti l'accesso ai modelli di destinazione corretti. SageMaker L'intelligenza artificiale utilizza [i ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) per fornire policy basate sull'identità IAM da utilizzare per specificare azioni e risorse consentite o negate e le condizioni in base alle quali le azioni sono consentite o negate.
Per impostazione predefinita, un principale IAM con le autorizzazioni [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) su un endpoint multi-modello può invocare qualsiasi modello all'indirizzo del prefisso S3 definito nell'operazione [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), a condizione che il ruolo di esecuzione IAM definito nell'operazione disponga delle autorizzazioni per scaricare il modello. Se è necessario limitare l'accesso [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) a un set limitato di modelli in S3, è possibile eseguire una delle seguenti operazioni:
+ Limitare le chiamate `InvokeEndpont` a modelli specifici ospitati nell'endpoint utilizzando la chiave di condizione IAM `sagemaker:TargetModel`. Ad esempio, il criterio seguente consente le richieste `InvokeEndpont` solo quando il valore del campo `TargetModel` corrisponde a una delle espressioni regolari specificate:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource":
"arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": ["company_a/*", "common/*"]
}
}
}
]
}
```
------
Per informazioni sulle chiavi di condizione SageMaker AI, consulta [Condition Keys for Amazon SageMaker AI](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys) nella *Guida per l'AWS Identity and Access Management utente*.
+ Creare endpoint multimodello con prefissi S3 più restrittivi.
Per ulteriori informazioni su come l' SageMaker IA utilizza i ruoli per gestire l'accesso agli endpoint ed eseguire operazioni per tuo conto, consulta[Come utilizzare i ruoli di esecuzione dell' SageMaker IA](sagemaker-roles.md). I clienti potrebbero inoltre avere determinati requisiti di isolamento dei dati dettati dai propri requisiti di conformità che possono essere soddisfatti utilizzando le identità IAM.
# CloudWatch Metriche per le implementazioni di endpoint multimodello
Amazon SageMaker AI fornisce parametri per gli endpoint in modo da poter monitorare la frequenza di accesso alla cache, il numero di modelli caricati e i tempi di attesa dei modelli per il caricamento, il download e il caricamento su un endpoint multimodello. Alcune metriche sono diverse per gli endpoint multimodello basati su CPU e GPU, pertanto le sezioni seguenti descrivono i CloudWatch parametri di Amazon che puoi utilizzare per ogni tipo di endpoint multimodello.
Per maggiori informazioni sui parametri, consulta **Parametri di caricamento del modello di endpoint a più modelli** e **Parametri dell'istanza del modello di endpoint a più modelli** in [Metriche di Amazon SageMaker AI in Amazon CloudWatch](monitoring-cloudwatch.md). I parametri per modello non sono supportati.
## CloudWatch metriche per endpoint multimodello supportati da CPU
Puoi monitorare i seguenti parametri sugli endpoint a più modelli basati su CPU.
Il `AWS/SageMaker` namespace include il seguente modello di caricamento delle metriche dalle chiamate a. [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)
I parametri sono disponibili a una frequenza di 1 minuto.
Per informazioni sulla durata di conservazione dei CloudWatch parametri, consulta [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)*Amazon CloudWatch API* Reference.
**Parametri di caricamento del modello di endpoint multi-modello**
| Metrica | Description |
| --- | --- |
| ModelLoadingWaitTime | L'intervallo di tempo in cui una richiesta di invocazione ha atteso il download o il caricamento del modello di destinazione o entrambi per eseguire l'inferenza. Unità: microsecondi Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| ModelUnloadingTime | L'intervallo di tempo necessario per scaricare il modello tramite la chiamata API `UnloadModel` del container. Unità: microsecondi Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| ModelDownloadingTime | L'intervallo di tempo impiegato per scaricare il modello da Amazon Simple Storage Service (Amazon S3). Unità: microsecondi Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| ModelLoadingTime | L'intervallo di tempo necessario per caricare il modello tramite la chiamata API `LoadModel` del container. Unità: microsecondi Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| ModelCacheHit | Numero di richieste `InvokeEndpoint` inviate all'endpoint a più modelli per cui il modello è già stato caricato. La statistica media mostra il rapporto tra richieste per le quali il modello è già stato caricato. Unità: nessuna Statistiche valide: media, somma, numero di esempi |
**Dimensioni per i parametri di caricamento del modello endpoint a più modelli**
| Dimensione | Description |
| --- | --- |
| EndpointName, VariantName | Filtra i parametri di invocazione dell'endpoint per il valore `ProductionVariant` dell'endpoint e della variante specificati. |
Gli spazi dei nomi `/aws/sagemaker/Endpoints` includono i seguenti parametri di istanza dalle chiamate a [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html).
I parametri sono disponibili a una frequenza di 1 minuto.
Per informazioni sulla durata di conservazione dei CloudWatch parametri, consulta [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)*Amazon CloudWatch API* Reference.
**Parametri dell'istanza del modello endpoint a più modelli**
| Metrica | Description |
| --- | --- |
| LoadedModelCount | Numero di modelli caricati nei container dell'endpoint a più modelli. Questo parametro viene emesso per istanza. La statistica media con un periodo di 1 minuto indica il numero medio di modelli caricati per istanza. La statistica somma indica il numero totale di modelli caricati in tutte le istanze dell'endpoint. I modelli tracciati da questo parametro non sono necessariamente univoci perché un modello potrebbe essere caricato in più container dell'endpoint. Unità: nessuna Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| CPUUtilization | La somma dell'utilizzo di ogni singolo core della CPU. L'utilizzo della CPU di ciascun core è compreso tra 0 e 100. Ad esempio, se ce ne sono quattro CPUs, l'`CPUUtilization`intervallo è compreso tra 0% e 400%. Per le varianti dell'endpoint, il valore è la somma dell'utilizzo delle CPU dei container principali e supplementari sull'istanza. Unità: percentuale |
| MemoryUtilization | Percentuale di memoria utilizzata dai container su un'istanza. Questo intervallo di valori è compreso tra 0% e 100%. Per le varianti dell'endpoint, il valore è la somma dell'utilizzo di memoria dei container principali e supplementari sull'istanza. Unità: percentuale |
| DiskUtilization | Percentuale di spazio su disco utilizzata dai container su un'istanza. Questo intervallo di valori è compreso tra 0% e 100%. Per le varianti dell'endpoint, il valore è la somma dell'utilizzo dello spazio su disco dei container principali e supplementari sull'istanza. Unità: percentuale |
## CloudWatch metriche per le implementazioni di endpoint multimodello con GPU
Puoi monitorare i seguenti parametri sugli endpoint a più modelli basati su GPU.
Il `AWS/SageMaker` namespace include il seguente modello di caricamento delle metriche dalle chiamate a. [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)
I parametri sono disponibili a una frequenza di 1 minuto.
Per informazioni sulla durata di conservazione dei CloudWatch parametri, consulta [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)*Amazon CloudWatch API* Reference.
**Parametri di caricamento del modello di endpoint multi-modello**
| Metrica | Description |
| --- | --- |
| ModelLoadingWaitTime | L'intervallo di tempo in cui una richiesta di invocazione ha atteso il download o il caricamento del modello di destinazione o entrambi per eseguire l'inferenza. Unità: microsecondi Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| ModelUnloadingTime | L'intervallo di tempo necessario per scaricare il modello tramite la chiamata API `UnloadModel` del container. Unità: microsecondi Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| ModelDownloadingTime | L'intervallo di tempo impiegato per scaricare il modello da Amazon Simple Storage Service (Amazon S3). Unità: microsecondi Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| ModelLoadingTime | L'intervallo di tempo necessario per caricare il modello tramite la chiamata API `LoadModel` del container. Unità: microsecondi Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| ModelCacheHit | Numero di richieste `InvokeEndpoint` inviate all'endpoint a più modelli per cui il modello è già stato caricato. La statistica media mostra il rapporto tra richieste per le quali il modello è già stato caricato. Unità: nessuna Statistiche valide: media, somma, numero di esempi |
**Dimensioni per i parametri di caricamento del modello endpoint a più modelli**
| Dimensione | Description |
| --- | --- |
| EndpointName, VariantName | Filtra i parametri di invocazione dell'endpoint per il valore `ProductionVariant` dell'endpoint e della variante specificati. |
Gli spazi dei nomi `/aws/sagemaker/Endpoints` includono i seguenti parametri di istanza dalle chiamate a [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html).
I parametri sono disponibili a una frequenza di 1 minuto.
Per informazioni sulla durata di conservazione dei CloudWatch parametri, consulta [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)*Amazon CloudWatch API* Reference.
**Parametri dell'istanza del modello endpoint a più modelli**
| Metrica | Description |
| --- | --- |
| LoadedModelCount | Numero di modelli caricati nei container dell'endpoint a più modelli. Questo parametro viene emesso per istanza. La statistica media con un periodo di 1 minuto indica il numero medio di modelli caricati per istanza. La statistica somma indica il numero totale di modelli caricati in tutte le istanze dell'endpoint. I modelli tracciati da questo parametro non sono necessariamente univoci perché un modello potrebbe essere caricato in più container dell'endpoint. Unità: nessuna Statistiche valide: media, somma, minimo, massimo, numero di esempi |
| CPUUtilization | La somma dell'utilizzo di ogni singolo core della CPU. L'utilizzo della CPU di ciascun core è compreso tra 0 e 100. Ad esempio, se ce ne sono quattro CPUs, l'`CPUUtilization`intervallo è compreso tra 0% e 400%. Per le varianti dell'endpoint, il valore è la somma dell'utilizzo delle CPU dei container principali e supplementari sull'istanza. Unità: percentuale |
| MemoryUtilization | Percentuale di memoria utilizzata dai container su un'istanza. Questo intervallo di valori è compreso tra 0% e 100%. Per le varianti dell'endpoint, il valore è la somma dell'utilizzo di memoria dei container principali e supplementari sull'istanza. Unità: percentuale |
| GPUUtilization | Percentuale di unità GPU utilizzata dai container su un'istanza. Il valore può variare tra 0 e 100 e viene moltiplicato per il numero di. GPUs Ad esempio, se ce ne sono quattro GPUs, l'`GPUUtilization`intervallo è compreso tra 0% e 400%. Per le varianti dell'endpoint, il valore è la somma dell'utilizzo delle GPU dei container principali e supplementari sull'istanza. Unità: percentuale |
| GPUMemoryUtilization | Percentuale di memoria GPU utilizzata dai container su un'istanza. L'intervallo di valori è 0‐100 e viene moltiplicato per il numero di. GPUs Ad esempio, se ce ne sono quattro GPUs, l'`GPUMemoryUtilization`intervallo è 0%-400%. Per le varianti dell'endpoint, il valore è la somma dell'utilizzo di memoria GPU dei container principali e supplementari sull'istanza. Unità: percentuale |
| DiskUtilization | Percentuale di spazio su disco utilizzata dai container su un'istanza. Questo intervallo di valori è compreso tra 0% e 100%. Per le varianti dell'endpoint, il valore è la somma dell'utilizzo dello spazio su disco dei container principali e supplementari sull'istanza. Unità: percentuale |
# Imposta il comportamento di memorizzazione nella cache del modello di SageMaker endpoint multimodello AI
Per impostazione predefinita, gli endpoint a più modelli memorizzano nella memoria (CPU o GPU, a seconda che si disponga di istanze supportate da CPU o GPU) e su disco per fornire inferenze a bassa latenza. I modelli memorizzati nella cache vengono scaricati ed and/or eliminati dal disco solo quando un contenitore esaurisce la memoria o lo spazio su disco per ospitare un nuovo modello di destinazione.
È possibile modificare il comportamento di memorizzazione nella cache di un endpoint a più modelli e abilitare o disabilitare esplicitamente la memorizzazione nella cache del modello impostando il parametro `ModelCacheSetting` quando si chiama [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model).
Consigliamo di impostare il valore del parametro `ModelCacheSetting` su `Disabled` per i casi d'uso che non traggono vantaggio dalla memorizzazione nella cache dei modelli. Ad esempio, quando è necessario fornire un numero elevato di modelli dall'endpoint, ma ogni modello viene richiamato una sola volta (o molto raramente). In questi casi d'uso, l'impostazione del valore del parametro `ModelCacheSetting` a `Disabled` consente transazioni al secondo (TPS) più elevate per le richieste `invoke_endpoint` rispetto alla modalità di memorizzazione nella cache predefinita. Il TPS più elevato in questi casi d'uso è dovuto al fatto che l' SageMaker IA esegue le seguenti operazioni dopo la richiesta: `invoke_endpoint`
+ Scarica in modo asincrono il modello dalla memoria e lo elimina dal disco immediatamente dopo la sua chiamata.
+ Consente una maggiore concomitanza per il download e il caricamento dei modelli nel container di inferenza. Per gli endpoint basati su CPU e GPU, la concorrenza è un fattore del numero di v dell'istanza CPUs del contenitore.
Per linee guida sulla scelta di un tipo di istanza SageMaker AI ML per un endpoint multimodello, consulta. [Raccomandazioni sulle istanze per le distribuzioni di endpoint a più modelli](multi-model-endpoint-instance.md)
# Imposta le Policy di dimensionamento automatico per le implementazioni di endpoint a più modelli
SageMaker Gli endpoint AI multimodello supportano completamente la scalabilità automatica, che gestisce le repliche dei modelli per garantire la scalabilità dei modelli in base ai modelli di traffico. Ti consigliamo di configurare il tuo endpoint a più modelli e le dimensioni delle istanze in base a [Raccomandazioni sulle istanze per le distribuzioni di endpoint a più modelli](multi-model-endpoint-instance.md) e di impostare il dimensionamento automatico dell'endpoint in base all'istanza. Le frequenze di invocazione utilizzate per attivare un evento di dimensionamento automatico si basano sul set aggregato di previsioni per l'intero set di modelli serviti dall'endpoint. Per ulteriori dettagli sulla configurazione della scalabilità automatica degli endpoint, consulta [Automatically Scale Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html) Models.
Puoi configurare policy di auto scaling con parametri predefiniti e personalizzati su endpoint a più modelli supportati da CPU e GPU.
**Nota**
SageMaker Le metriche degli endpoint multimodello di intelligenza artificiale sono disponibili con una granularità di un minuto.
## Definizione di una policy di dimensionamento
Per specificare i parametri e i valori di target per una policy di dimensionamento, puoi configurare una policy di dimensionamento di monitoraggio dei target. Puoi utilizzare un parametro personalizzato o predefinito.
La configurazione di policy di dimensionamento è rappresentata da un blocco JSON. Salvi la tua configurazione di policy di dimensionamento come un blocco JSON in un file di testo. Si utilizza quel file di testo quando si richiama l'API AWS CLI Application Auto Scaling. Per ulteriori informazioni sulla sintassi della configurazione della policy, consulta `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)` in *Application Auto Scaling API Reference*.
Le seguenti opzioni sono disponibili per definire una configurazione di una policy di dimensionamento di monitoraggio dei target.
### Utilizzo di un parametro predefinito
Per definire rapidamente una policy di dimensionamento con monitoraggio delle destinazioni per una variante, utilizza il parametro predefinito `SageMakerVariantInvocationsPerInstance`. `SageMakerVariantInvocationsPerInstance` è il numero medio di volte al minuto in cui ogni istanza per una variante viene richiamata. Consigliamo fortemente di utilizzare questo parametro.
Per utilizzare un parametro predefinito in una policy di dimensionamento, crea una configurazione di monitoraggio dei target per la tua policy. Nella configurazione di monitoraggio dei target, includi un `PredefinedMetricSpecification` per il parametro predefinito e un `TargetValue` per il valore target del parametro.
L'esempio seguente è una tipica configurazione di policy per il dimensionamento di monitoraggio dei target per una variante. In questa configurazione, utilizziamo il parametro predefinito `SageMakerVariantInvocationsPerInstance` per regolare il numero di istanze di variante in modo che ogni istanza abbia un parametro `InvocationsPerInstance` di `70`.
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "InvocationsPerInstance"
}
}
```
**Nota**
È consigliabile utilizzarlo `InvocationsPerInstance` durante l'utilizzo di endpoint a più modelli. Il `TargetValue` di questo parametro dipende dai requisiti di latenza dell'applicazione. Ti consigliamo inoltre di testare il carico degli endpoint per impostare valori dei parametri di dimensionamento. Per ulteriori informazioni sui test di carico e sulla configurazione della scalabilità automatica per gli endpoint, consulta il blog [Configurazione degli endpoint di inferenza con scalabilità automatica in Amazon](https://aws.amazon.com/blogs/machine-learning/configuring-autoscaling-inference-endpoints-in-amazon-sagemaker/) AI. SageMaker
### Utilizzo di un parametro personalizzato
Se hai bisogno di definire una policy di dimensionamento di monitoraggio dei target che soddisfi i tuoi requisiti personalizzati, definisci un parametro personalizzato. Puoi definire un parametro personalizzato in base a qualsiasi parametro di variante di produzione metrica che si modifica in proporzione al dimensionamento.
Non SageMaker tutte le metriche di intelligenza artificiale funzionano per il tracciamento degli obiettivi. Il parametro deve essere un parametro di utilizzo valido e deve descrivere quanto impegnata è un'istanza. Il valore del parametro deve aumentare o diminuire in proporzione inversa al numero di istanze di variante. Ciò significa che il valore del parametro deve diminuire quando il numero di istanze aumenta.
**Importante**
Prima di distribuire la scalabilità automatica nella produzione, devi testare la scalabilità automatica con il tuo parametro personalizzato.
#### Esempio di parametro personalizzato per un endpoint a più modelli supportato da CPU
L'esempio seguente è una configurazione di monitoraggio dei target per una policy di dimensionamento. In questa configurazione, per un modello chiamato `my-model`, un parametro personalizzato di `CPUUtilization` regola il conteggio delle istanze sull'endpoint in base a un utilizzo medio della CPU del 50% in tutte le istanze.
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
#### Esempio di parametro personalizzato per un endpoint a più modelli supportato da GPU
L'esempio seguente è una configurazione di monitoraggio dei target per una policy di dimensionamento. In questa configurazione, per un modello chiamato `my-model`, un parametro personalizzato di `GPUUtilization` regola il conteggio delle istanze sull'endpoint in base a un utilizzo medio della GPU del 50% in tutte le istanze.
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "GPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
## Aggiunta di un periodo di attesa
Per aggiungere un periodo di attesa per il dimensionamento dell'endpoint, specifica un valore, in secondi, per `ScaleOutCooldown`. In maniera simile, per aggiungere un periodo di attesa per la riduzione del modello, aggiungi un valore, in secondi, per `ScaleInCooldown`. Per ulteriori informazioni su `ScaleInCooldown` e `ScaleOutCooldown`, consulta `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)` in *Application Auto Scaling API Reference*.
Di seguito è riportato un esempio di una configurazione di monitoraggio dei target per una policy di dimensionamento. In questa configurazione, il parametro predefinito `SageMakerVariantInvocationsPerInstance` viene utilizzato per regolare il dimensionamento in base a una media di `70` in tutte le istanze di tale variante. La configurazione fornisce un tempo di raffreddamento di riduzione di 10 minuti e un tempo di raffreddamento di aumento di 5 minuti.
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
# Endpoint multi-container
SageMaker Gli endpoint multi-container AI consentono ai clienti di distribuire più container, che utilizzano modelli o framework diversi, su un singolo endpoint AI. SageMaker I container possono essere eseguiti in sequenza come pipeline di inferenza oppure è possibile accedere a ciascun container singolarmente utilizzando la chiamata diretta per migliorare l'utilizzo degli endpoint e ottimizzare i costi.
Per informazioni sull'invocazione dei container in un endpoint multi-container in sequenza, consulta [Pipeline di inferenza in Amazon AI SageMaker](inference-pipelines.md).
Per informazioni sull'invocazione di un container specifico in un endpoint multi-container, consulta [Richiamare un endpoint multi-container con invocazione diretta](multi-container-direct.md)
**Topics**
+ [Per creare un endpoint multi-container (Boto 3)](multi-container-create.md)
+ [Aggiornare un endpoint multi-container](multi-container-update.md)
+ [Richiamare un endpoint multi-container con invocazione diretta](multi-container-direct.md)
+ [Sicurezza con endpoint multi-container con invocazione diretta](multi-container-security.md)
+ [Parametri per endpoint multi-container con invocazione diretta](multi-container-metrics.md)
+ [Endpoint multi-container con scalabilità automatica](multi-container-auto-scaling.md)
+ [Risolvere i problemi relativi agli endpoint multi-container](multi-container-troubleshooting.md)
# Per creare un endpoint multi-container (Boto 3)
Crea un endpoint multi-contenitore [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)chiamando e [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) APIs come faresti per creare qualsiasi altro endpoint. [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) Puoi eseguire questi container in sequenza come pipeline di inferenza o eseguire ogni singolo container utilizzando la chiamata diretta. Gli endpoint multi-container presentano i seguenti requisiti per le chiamate `create_model`:
+ Utilizza il parametro `Containers` anziché `PrimaryContainer`e includi più di un container nel parametro `Containers`.
+ Il parametro `ContainerHostname` è obbligatorio per ogni container in un endpoint multi-container con invocazione diretta.
+ Imposta il parametro `Mode` del campo `InferenceExecutionConfig` per l'invocazione diretta `Direct` di ogni container o `Serial` per utilizzare i come pipeline di inferenza. La modalità predefinita è `Serial`.
**Nota**
Attualmente esiste un limite massimo di 15 container supportati su un endpoint multi-container.
L'esempio seguente crea un modello multi-container per l'invocazione diretta.
1. Crea elementi container e `InferenceExecutionConfig` con invocazione diretta.
```
container1 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage1:mytag',
'ContainerHostname': 'firstContainer'
}
container2 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage2:mytag',
'ContainerHostname': 'secondContainer'
}
inferenceExecutionConfig = {'Mode': 'Direct'}
```
1. Crea il modello con gli elementi del container e imposta il campo `InferenceExecutionConfig`.
```
import boto3
sm_client = boto3.Session().client('sagemaker')
response = sm_client.create_model(
ModelName = 'my-direct-mode-model-name',
InferenceExecutionConfig = inferenceExecutionConfig,
ExecutionRoleArn = role,
Containers = [container1, container2]
)
```
Per creare un endpoint, devi quindi chiamare [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) come faresti per creare qualsiasi altro endpoint.
# Aggiornare un endpoint multi-container
Per aggiornare un endpoint multi-container Amazon SageMaker AI, completa i seguenti passaggi.
1. Chiama [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) per creare un nuovo modello con un nuovo valore per il parametro `Mode` nel campo `InferenceExecutionConfig`.
1. Chiama [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) per creare una nuova configurazione di endpoint con un nome diverso utilizzando il nuovo modello creato nella fase precedente.
1. Chiama [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_endpoint) per aggiornare l'endpoint con la nuova configurazione dell'endpoint creata nella fase precedente.
# Richiamare un endpoint multi-container con invocazione diretta
SageMaker Gli endpoint multi-container AI consentono ai clienti di distribuire più container per distribuire modelli diversi su un endpoint AI. SageMaker È possibile ospitare fino a 15 container di inferenza diversi su un singolo endpoint. Utilizzando l'invocazione diretta, è possibile inviare una richiesta a un container di inferenza specifico ospitato su un endpoint multi-container.
Per richiamare un endpoint multi-container con chiamata diretta, chiama [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) come richiameresti qualsiasi altro endpoint e specifica quale container desideri richiamare utilizzando il parametro `TargetContainerHostname`.
L'esempio seguente richiama direttamente `secondContainer` di un endpoint multi-container per ottenere una previsione.
```
import boto3
runtime_sm_client = boto3.Session().client('sagemaker-runtime')
response = runtime_sm_client.invoke_endpoint(
EndpointName ='my-endpoint',
ContentType = 'text/csv',
TargetContainerHostname='secondContainer',
Body = body)
```
Per ogni richiesta di chiamata diretta a un endpoint multi-container, solo il container con `TargetContainerHostname` elabora la richiesta di chiamata. Se esegui una qualsiasi delle seguenti operazioni, otterrai degli errori di convalida:
+ Specificare un `TargetContainerHostname` che non esiste nell'endpoint
+ Non specificare un valore per `TargetContainerHostname` in una richiesta a un endpoint configurato per la chiamata diretta
+ Specificare un valore per `TargetContainerHostname` in una richiesta a un endpoint non configurato per la chiamata diretta.
# Sicurezza con endpoint multi-container con invocazione diretta
Per gli endpoint multi-container con invocazione diretta, sono disponibili più container ospitati in un'unica istanza condividendo memoria e un volume di archiviazione. È tua responsabilità utilizzare contenitori sicuri, mantenere la corretta mappatura delle richieste ai contenitori di destinazione e fornire agli utenti l'accesso corretto ai contenitori di destinazione. SageMaker L'intelligenza artificiale utilizza i ruoli IAM per fornire policy basate sull'identità IAM da utilizzare per specificare se l'accesso a una risorsa è consentito o negato a quel ruolo e in quali condizioni. Per ulteriori informazioni sui ruoli IAM, consulta [Ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) nella *AWS Identity and Access Management Guida per l'utente di IAM*. Per informazioni sulle policy basate sull’identità, consulta [Policy basate sulle identità e policy basate su risorse](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).
Per impostazione predefinita, un principale IAM con autorizzazioni `InvokeEndpoint` su un endpoint multi-container con invocazione diretta può richiamare qualsiasi container all'interno dell'endpoint con il nome dell'endpoint specificato al momento della chiamata a `invoke_endpoint`. Se devi limitare l'accesso `invoke_endpoint` a un set limitato di container all'interno di un endpoint multi-container, usa la chiave di condizione IAM `sagemaker:TargetContainerHostname`. Le seguenti policy mostrano come limitare le chiamate a container specifici all'interno di un endpoint.
Il criterio seguente consente le richieste `invoke_endpoint` solo quando il valore del campo `TargetContainerHostname` corrisponde a una delle espressioni regolari specificate.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"customIps*",
"common*"
]
}
}
}
]
}
```
------
La policy seguente nega le richieste `invoke_endpoint` quando il valore del campo `TargetContainerHostname` corrisponde a una delle espressioni regolari specificate nella dichiarazione `Deny`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"model_name*"
]
}
}
},
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Deny",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"special-model_name*"
]
}
}
}
]
}
```
------
*Per informazioni sulle chiavi di condizione SageMaker AI, consulta [Condition Keys for SageMaker AI nella Guida per](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys) l'AWS Identity and Access Management utente.*
# Parametri per endpoint multi-container con invocazione diretta
Oltre ai parametri degli endpoint elencati in[Metriche di Amazon SageMaker AI in Amazon CloudWatch](monitoring-cloudwatch.md), l' SageMaker IA fornisce anche parametri per contenitore.
Le metriche per contenitore per endpoint multi-contenitore con invocazione diretta si trovano e sono classificate in due namespace: e. CloudWatch `AWS/SageMaker` `aws/sagemaker/Endpoints` Lo spazio dei nomi `AWS/SageMaker` include parametri relativi alle chiamate e lo spazio dei nomi `aws/sagemaker/Endpoints` include parametri di utilizzo della memoria e della CPU.
La tabella seguente elenca i parametri di container per endpoint multi-container con invocazione diretta. Tutti i parametri utilizzano la dimensione [`EndpointName, VariantName, ContainerName`], che filtra i parametri su un endpoint specifico, per una variante specifica e corrispondente a un container specifico. Questi parametri condividono gli stessi nomi dei parametri utilizzati per le pipeline di inferenza, ma a livello di container [`EndpointName, VariantName, ContainerName`].
| | | | |
| --- |--- |--- |--- |
| Nome parametro | Description | Dimensione | NameSpace |
| Invocations | Il numero di richieste InvokeEndpoint inviate a un container all'interno di un endpoint. Per ottenere il numero totale di richieste inviate a quel container, utilizza la statistica Sum. Unità: nessuna statistica valida: Sum, Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation4XX Errors | Numero di richieste InvokeEndpoint per cui il modello ha restituito un codice di risposta HTTP 4xx per un container specifico. 4xxPer ogni SageMaker risposta1, AI invia un. Unità: nessuna statistica valida: Average, Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation5XX Errors | Numero di richieste InvokeEndpoint per cui il modello ha restituito un codice di risposta HTTP 5xx per un container specifico. Per ogni 5xx risposta, SageMaker AI invia un1. Unità: nessuna statistica valida: Average, Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| ContainerLatency | Il tempo impiegato dal contenitore di destinazione per rispondere come visualizzato dall' SageMaker IA. ContainerLatencyinclude il tempo impiegato per inviare la richiesta, recuperare la risposta dal contenitore del modello e completare l'inferenza nel contenitore. Unità: microsecondi statistiche valide: Average, Sum, Min, Max, Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| OverheadLatency | Il tempo aggiunto al tempo impiegato per rispondere a una richiesta del cliente da parte di SageMaker AI for overhead. OverheadLatencyviene misurato dal momento in cui l' SageMaker IA riceve la richiesta fino a quando non restituisce una risposta al client, meno il. ModelLatency La latenza di gestione può variare in base alle dimensioni di payload di richiesta e risposta, frequenza delle richieste e autenticazione o autorizzazione della richiesta, tra gli altri fattori. Unità: microsecondi statistiche valide: Average, Sum, Min, Max, `Conteggio di esempio ` | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| CPUUtilization | Percentuale di unità CPU utilizzate da ciascun container in esecuzione su un'istanza. Il valore varia dallo 0% al 100% e viene moltiplicato per il numero di. CPUs Ad esempio, se ce ne sono quattro CPUs, CPUUtilization può variare dallo 0% al 400%. Per gli endpoint con chiamata diretta, il numero di CPUUtilization metriche è uguale al numero di contenitori in quell'endpoint. Unità: percentuale | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
| MemoryUtilizaton | Percentuale di memoria utilizzata da ciascun container in esecuzione su un'istanza. Questo valore è compreso tra 0% e 100%. Analogamente agli endpoint con invocazione diretta CPUUtilization, il numero di metriche è uguale al numero di MemoryUtilization contenitori in quell'endpoint. Unità: percentuale | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
Tutti i parametri della tabella precedente sono specifici per gli endpoint multi-container con invocazione diretta. Oltre a questi parametro speciali per container, esistono anche parametri a livello di variante con dimensione `[EndpointName, VariantName]` per tutti i parametri previsti nella tabella `ContainerLatency`.
# Endpoint multi-container con scalabilità automatica
Se desideri configurare la scalabilità automatica per un endpoint multi-container utilizzando il parametro `InvocationsPerInstance`, ti consigliamo che il modello in ogni container mostri un utilizzo e una latenza della CPU simili su ogni richiesta di inferenza. Questa soluzione è consigliata perché se il traffico verso l'endpoint multi-container passa da un modello a basso utilizzo della CPU a un modello ad alto utilizzo della CPU, ma il volume complessivo delle chiamate rimane lo stesso, l'endpoint non si scalerà orizzontalmente e potrebbero non esserci abbastanza istanze per gestire tutte le richieste verso il modello ad alto utilizzo della CPU. Per informazioni sugli endpoint di scalabilità automatica, consulta [Ridimensionamento automatico dei modelli di SageMaker intelligenza artificiale di Amazon](endpoint-auto-scaling.md).
# Risolvere i problemi relativi agli endpoint multi-container
Le sezioni seguenti possono aiutarti a risolvere gli errori con endpoint multi-container.
## Errori di controllo dell'integrità
Con più container, la memoria degli endpoint e la CPU sono sottoposte a una maggiore pressione durante la creazione degli endpoint. In particolare, i parametri `MemoryUtilization` e `CPUUtilization` sono più elevati rispetto agli endpoint a container singolo, poiché la pressione di utilizzo è proporzionale al numero di container. Per questo motivo, ti consigliamo di scegliere tipi di istanza con memoria e CPU sufficienti per assicurarti che sull'istanza ci sia abbastanza memoria per caricare tutti i modelli (la stessa guida si applica alla distribuzione di una pipeline di inferenza). In caso contrario, la creazione dell'endpoint potrebbe fallire con un errore del tipo `XXX did not pass the ping health check`.
## Etichetta accept-bind-to-port =true Docker mancante
I container in endpoint multi-container restano in ascolto sulla porta specificata nella variabile di ambiente `SAGEMAKER_BIND_TO_PORT` anziché la porta 8080. Quando un contenitore viene eseguito in un endpoint con più container, l' SageMaker IA fornisce automaticamente questa variabile di ambiente al contenitore. Se questa variabile di ambiente non è presente, i container utilizzano la porta 8080 per impostazione predefinita. Per indicare che il container soddisfa questo requisito, utilizza il comando seguente per aggiungere un'etichetta al dockerfile:
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
Altrimenti, verrà visualizzato un messaggio di errore come `Your Ecr Image XXX does not contain required com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true Docker label(s).`
Se il container deve essere in ascolto su una seconda porta, scegli una porta nell'intervallo specificato dalla variabile di ambiente `SAGEMAKER_SAFE_PORT_RANGE`. Specificate il valore come intervallo inclusivo nel formato *XXXX* -*YYYY*, dove XXXX e YYYY sono numeri interi a più cifre. SageMaker L'intelligenza artificiale fornisce questo valore automaticamente quando esegui il contenitore in un endpoint multi-contenitore.
# Pipeline di inferenza in Amazon AI SageMaker
Una *pipeline di inferenza* è un modello di SageMaker intelligenza artificiale di Amazon composto da una sequenza lineare da due a quindici contenitori che elaborano le richieste di inferenze sui dati. Utilizzi una pipeline di inferenza per definire e distribuire qualsiasi combinazione di algoritmi integrati di SageMaker intelligenza artificiale preaddestrati e algoritmi personalizzati confezionati in contenitori Docker. Puoi utilizzare una pipeline di inferenza per combinare attività data science di pre-elaborazione, previsioni e post-elaborazione. Le pipeline di inferenza sono completamente gestite.
Puoi aggiungere contenitori SageMaker AI Spark ML Serving e scikit-learn che riutilizzano i trasformatori di dati sviluppati per i modelli di addestramento. L'intera pipeline di inferenza assemblata può essere considerata come un modello di SageMaker intelligenza artificiale da utilizzare per effettuare previsioni in tempo reale o per elaborare trasformazioni in batch direttamente senza alcuna preelaborazione esterna.
All'interno di un modello di pipeline di inferenza, l' SageMaker intelligenza artificiale gestisce le chiamate come una sequenza di richieste HTTP. Il primo contenitore della pipeline gestisce la richiesta iniziale, quindi la risposta intermedia viene inviata come richiesta al secondo contenitore e così via, per ogni contenitore della pipeline. SageMaker L'IA restituisce la risposta finale al client.
Quando distribuisci il modello di pipeline, l' SageMaker intelligenza artificiale installa ed esegue tutti i contenitori su ogni istanza Amazon Elastic Compute Cloud (Amazon EC2) nell'endpoint o nel processo di trasformazione. Elaborazione delle caratteristiche e inferenze vengono eseguite con bassa latenza perché i container si trovano nelle stesse istanze EC2. Definisci i container per un modello di pipeline utilizzando l'operazione [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) o dalla console. Invece di impostare un `PrimaryContainer`, utilizza il parametro `Containers` per impostare i container che compongono la pipeline. Specifica anche l’ordine di esecuzione dei container.
Un modello di pipeline è non modificabile, ma puoi aggiornare una pipeline di inferenza distribuendone una nuova utilizzando l'operazione [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html). Questa modularità supporta una maggiore flessibilità durante la sperimentazione.
Per informazioni su come creare una pipeline di inferenza con il Model Registry, consulta. SageMaker [Implementazione della registrazione del modello con il registro dei modelli](model-registry.md)
Questa caratteristica non comporta costi supplementari. Paghi solo per le istanze in esecuzione su un endpoint.
**Topics**
+ [Notebook di esempio per pipeline di inferenza](#inference-pipeline-sample-notebooks)
+ [Elaborazione delle caratteristiche con Spark ML e Scikit-learn](inference-pipeline-mleap-scikit-learn-containers.md)
+ [Creazione di un modello di pipeline](inference-pipeline-create-console.md)
+ [Esecuzione di previsioni in tempo reale con una pipeline di inferenza](inference-pipeline-real-time.md)
+ [Trasformazioni in batch con pipeline di inferenza](inference-pipeline-batch.md)
+ [Log e parametri della pipeline di inferenza](inference-pipeline-logs-metrics.md)
+ [Risoluzione dei problemi delle pipeline di inferenza](inference-pipeline-troubleshoot.md)
## Notebook di esempio per pipeline di inferenza
Per un esempio che mostra come creare e implementare pipeline di inferenza, consulta il notebook di esempio [Inference Pipeline with SciKit-Learn and Linear Learner](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/scikit_learn_inference_pipeline). Per istruzioni sulla creazione e l'accesso alle istanze di notebook Jupyter da utilizzare per eseguire l'esempio in AI, consulta. SageMaker [Istanze SageMaker per notebook Amazon](nbi.md)
**Per visualizzare un elenco di tutti gli esempi SageMaker AI, dopo aver creato e aperto un'istanza di notebook, scegli la SageMaker scheda Esempi AI.** Esistono tre notebook sulle pipeline di inferenza. I primi due notebook sulle pipeline di inferenza appena descritti si trovano nella cartella `advanced_functionality`, mentre il terzo si trova nella cartella `sagemaker-python-sdk`. Per aprire un notebook, seleziona la relativa scheda **Utilizza**, quindi scegli **Crea copia**.
# Elaborazione delle caratteristiche con Spark ML e Scikit-learn
Prima di addestrare un modello con algoritmi integrati di Amazon SageMaker AI o algoritmi personalizzati, puoi utilizzare i preprocessori Spark e scikit-learn per trasformare i tuoi dati e progettare le funzionalità.
## Elaborazione di caratteristiche con Spark ML
Puoi eseguire lavori Spark ML con [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html), un servizio ETL (estrazione, trasformazione, caricamento) senza server, dal tuo SageMaker notebook AI. Puoi inoltre eseguire la connessione a cluster EMR esistenti per eseguire processi Spark ML con [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html). Per fare ciò, hai bisogno di un ruolo AWS Identity and Access Management (IAM) che conceda l'autorizzazione a effettuare chiamate dal tuo SageMaker notebook AI a. AWS Glue
**Nota**
Per vedere quali versioni di Python e Spark sono AWS Glue supportate, consulta le note di rilascio di [AWS Glue](/glue/latest/dg/release-notes.html).
Dopo aver ingegnerizzato le funzionalità, puoi impacchettare e serializzare i lavori Spark ML MLeap in MLeap contenitori che puoi aggiungere a una pipeline di inferenza. Non è necessario utilizzare cluster Spark gestiti esternamente. Grazie a questo approccio, puoi ridimensionare senza problemi da un campione di righe a terabyte di dati. Gli stessi trasformatori funzionano per addestramento e inferenza, perciò non occorre duplicare la logica di pre-elaborazione e di progettazione caratteristiche né sviluppare una soluzione una tantum per rendere i modelli persistenti. Con pipeline di inferenza, non è necessario mantenere l'infrastruttura esterna e puoi effettuare previsioni direttamente da dati di input.
Quando esegui un job Spark ML su AWS Glue, una pipeline Spark ML viene serializzata in formato. [MLeap](https://github.com/combust/mleap) Quindi, puoi utilizzare il job con lo [SparkML Model Serving Container](https://github.com/aws/sagemaker-sparkml-serving-container) in una pipeline di inferenza SageMaker AI. *MLeap*è un formato di serializzazione e un motore di esecuzione per pipeline di apprendimento automatico. Supporta Spark, Scikit-learn e TensorFlow per addestrare le pipeline ed esportarle in una pipeline serializzata chiamata Bundle. MLeap Puoi deserializzare nuovamente i pacchetti in Spark per l'assegnazione del punteggio in modalità batch o in fase di esecuzione per alimentare i servizi API in tempo reale. MLeap
Per un esempio che mostra come implementare un processo con Spark ML, consulta [Train an ML model using Apache Spark in Amazon EMR e distribuiscilo in](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/sparkml_serving_emr_mleap_abalone) un notebook di esempio AI. SageMaker
## Elaborazione di caratteristiche con Scikit Learn
Puoi eseguire e impacchettare lavori scikit-learn in contenitori direttamente in Amazon AI. SageMaker Per un esempio di codice Python per la compilazione di un modello di caratterizzazione scikit-learn che esegue l’addestramento in base al [data set sui fiori della famiglia degli iris di Fisher](http://archive.ics.uci.edu/ml/datasets/Iris) e prevede la specie di iris in base alle misurazioni morfologiche, consulta [IRIS Training and Prediction with Sagemaker Scikit-learn](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit_learn_iris).
# Creazione di un modello di pipeline
Per creare un modello di pipeline che può essere distribuito su un endpoint o utilizzato per un processo di trasformazione in batch, utilizza la console Amazon SageMaker AI o l'operazione. `CreateModel`
**Per creare una pipeline di inferenza (console)**
1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Scegli **Modelli**, quindi seleziona **Crea modelli** dal gruppo **Inferenza**.
1. Nella pagina **Crea modello**, Nella pagina indica un nome per il modello, scegli un ruolo IAM e, se desideri utilizzare un VPC privato, specificane i valori.
![\[La pagina per la creazione di un modello per una pipeline di inferenza.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/create-pipeline-model.png)
1. Per aggiungere informazioni sui container nella pipeline di inferenza, scegli **Aggiungi container** e **Successivo**.
1. Completa i campi per ogni container nell'ordine di esecuzione scelto, fino a un massimo di quindici. Completa **Opzioni di input container**, **Posizione dell'immagine del codice di inferenza** e, facoltativamente, i campi **Posizione degli artefatti del modello**, **Nome host container** ed **Variabili di ambiente**.
![\[Creazione di un modello di pipeline con container.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/create-pipeline-model-containers.png)
La **MyInferencePipelineModel**pagina riassume le impostazioni per i contenitori che forniscono l'input per il modello. Se hai fornito le variabili di ambiente in una definizione di contenitore corrispondente, SageMaker AI le mostra nel campo **Variabili d'ambiente**.
![\[Il riepilogo delle impostazioni di container per il modello di pipeline.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/pipeline-MyInferencePipelinesModel-recap.png)
# Esecuzione di previsioni in tempo reale con una pipeline di inferenza
Puoi utilizzare modelli addestrati in una pipeline di inferenza per effettuare previsioni in tempo reale direttamente senza eseguire pre-elaborazione esterna. Quando configuri la pipeline, puoi scegliere di utilizzare i trasformatori di funzionalità integrati già disponibili in Amazon AI. SageMaker In alternativa, puoi implementare la tua logica di trasformazione utilizzando poche righe di codice scikit-learn o Spark.
[MLeap](https://combust.github.io/mleap-docs/), un formato di serializzazione e un motore di esecuzione per pipeline di apprendimento automatico, supporta Spark, scikit-learn e TensorFlow per addestrare le pipeline ed esportarle in una pipeline serializzata chiamata Bundle. MLeap Puoi deserializzare nuovamente i pacchetti in Spark per l'assegnazione del punteggio in modalità batch o in fase di esecuzione per alimentare i servizi API in tempo reale. MLeap
I container in una pipeline restano in ascolto sulla porta specificata nella variabile di ambiente `SAGEMAKER_BIND_TO_PORT` (anziché 8080). Quando viene eseguita in una pipeline di inferenza, l'intelligenza artificiale fornisce automaticamente questa variabile di ambiente ai contenitori SageMaker . Se questa variabile di ambiente non è presente, i container utilizzano la porta 8080 per impostazione predefinita. Per indicare che il container soddisfa questo requisito, utilizza il comando seguente per aggiungere un'etichetta al dockerfile:
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
Se il container deve essere in ascolto su una seconda porta, scegli una porta nell'intervallo specificato dalla variabile di ambiente `SAGEMAKER_SAFE_PORT_RANGE`. Specificate il valore come intervallo inclusivo nel formato**"XXXX-YYYY"**, dove `XXXX` e `YYYY` sono numeri interi a più cifre. SageMaker L'intelligenza artificiale fornisce questo valore automaticamente quando esegui il contenitore in una pipeline multicontainer.
**Nota**
Per utilizzare immagini Docker personalizzate in una pipeline che include [algoritmi integrati di SageMaker intelligenza artificiale](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html), è necessaria una policy di Amazon [Elastic Container Registry (Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)). Il tuo repository Amazon ECR deve concedere all' SageMaker IA l'autorizzazione per estrarre l'immagine. Per ulteriori informazioni, consulta [Risoluzione dei problemi relativi alle autorizzazioni Amazon ECR per le pipeline di inferenza](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions).
## Creazione e distribuzione un endpoint della pipeline di inferenza
Il codice seguente crea e implementa un modello di pipeline di inferenza in tempo reale con SparkML e XGBoost modelli in serie utilizzando AI SDK. SageMaker
```
from sagemaker.model import Model
from sagemaker.pipeline_model import PipelineModel
from sagemaker.sparkml.model import SparkMLModel
sparkml_data = 's3://{}/{}/{}'.format(s3_model_bucket, s3_model_key_prefix, 'model.tar.gz')
sparkml_model = SparkMLModel(model_data=sparkml_data)
xgb_model = Model(model_data=xgb_model.model_data, image=training_image)
model_name = 'serial-inference-' + timestamp_prefix
endpoint_name = 'serial-inference-ep-' + timestamp_prefix
sm_model = PipelineModel(name=model_name, role=role, models=[sparkml_model, xgb_model])
sm_model.deploy(initial_instance_count=1, instance_type='ml.c4.xlarge', endpoint_name=endpoint_name)
```
## Richiesta di inferenza in tempo reale da un endpoint della pipeline di inferenza
L'esempio seguente mostra come eseguire previsioni in tempo reale chiamando un endpoint di inferenza e passando un payload della richiesta in formato JSON:
```
import sagemaker
from sagemaker.predictor import json_serializer, json_deserializer, Predictor
payload = {
"input": [
{
"name": "Pclass",
"type": "float",
"val": "1.0"
},
{
"name": "Embarked",
"type": "string",
"val": "Q"
},
{
"name": "Age",
"type": "double",
"val": "48.0"
},
{
"name": "Fare",
"type": "double",
"val": "100.67"
},
{
"name": "SibSp",
"type": "double",
"val": "1.0"
},
{
"name": "Sex",
"type": "string",
"val": "male"
}
],
"output": {
"name": "features",
"type": "double",
"struct": "vector"
}
}
predictor = Predictor(endpoint=endpoint_name, sagemaker_session=sagemaker.Session(), serializer=json_serializer,
content_type='text/csv', accept='application/json')
print(predictor.predict(payload))
```
La risposta che si ottiene da `predictor.predict(payload)` è il risultato dell'inferenza del modello.
## Esempio di pipeline di inferenza in tempo reale
Puoi eseguire questo [notebook di esempio utilizzando il SKLearn predittore](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-python-sdk/scikit_learn_randomforest/Sklearn_on_SageMaker_end2end.ipynb) che mostra come implementare un endpoint, eseguire una richiesta di inferenza e quindi deserializzare la risposta. Trova questo taccuino e altri esempi nell'[ GitHub archivio di SageMaker esempi di Amazon](https://github.com/awslabs/amazon-sagemaker-examples).
# Trasformazioni in batch con pipeline di inferenza
Per ottenere inferenze su un intero set di dati esegui una trasformazione in batch su un modello addestrato. Lo stesso modello di pipeline di inferenza creato e distribuito in un endpoint per l'elaborazione in tempo reale può essere utilizzato in un processo di trasformazione in batch. Per eseguire un processo di trasformazione in batch in una pipeline, scarica i dati di input da Amazon S3 e inviali in una o più richieste HTTP al modello di pipeline di inferenza. Per un esempio che mostra come preparare i dati per una trasformazione in batch, consulta «Sezione 2 - Preelabora i dati grezzi sull'alloggiamento utilizzando Scikit Learn» degli [endpoint Amazon SageMaker Multi-Model utilizzando il notebook di esempio Linear Learner](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_linear_learner_home_value). Per informazioni sulle trasformazioni in batch di Amazon SageMaker AI, consulta[Trasformazione in batch per l'inferenza con Amazon SageMaker AI](batch-transform.md).
**Nota**
Per utilizzare immagini Docker personalizzate in una pipeline che include [algoritmi integrati di Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html), è necessaria una policy [Amazon Elastic Container Registry (ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)). Il tuo repository Amazon ECR deve concedere all' SageMaker IA l'autorizzazione per estrarre l'immagine. Per ulteriori informazioni, consulta [Risoluzione dei problemi relativi alle autorizzazioni Amazon ECR per le pipeline di inferenza](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions).
L'esempio seguente mostra come eseguire un processo di trasformazione utilizzando l'SDK [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). In questo esempio, `model_name` è la pipeline di inferenza che combina SparkML e XGBoost modelli (creati negli esempi precedenti). La posizione Amazon S3 specificata da `input_data_path` contiene i dati di input, in formato CSV, che devono essere scaricati e inviati al modello Spark ML. Al termine del processo di trasformazione, la posizione Amazon S3 specificata da `output_data_path` contiene i dati di output restituiti dal XGBoost modello in formato CSV.
```
import sagemaker
input_data_path = 's3://{}/{}/{}'.format(default_bucket, 'key', 'file_name')
output_data_path = 's3://{}/{}'.format(default_bucket, 'key')
transform_job = sagemaker.transformer.Transformer(
model_name = model_name,
instance_count = 1,
instance_type = 'ml.m4.xlarge',
strategy = 'SingleRecord',
assemble_with = 'Line',
output_path = output_data_path,
base_transform_job_name='inference-pipelines-batch',
sagemaker_session=sagemaker.Session(),
accept = CONTENT_TYPE_CSV)
transform_job.transform(data = input_data_path,
content_type = CONTENT_TYPE_CSV,
split_type = 'Line')
```
# Log e parametri della pipeline di inferenza
Il monitoraggio è importante per mantenere l'affidabilità, la disponibilità e le prestazioni delle risorse SageMaker AI di Amazon. Per monitorare e risolvere i problemi delle prestazioni della pipeline di inferenza, usa i CloudWatch log e i messaggi di errore di Amazon. Per informazioni sugli strumenti di monitoraggio forniti dall'intelligenza artificiale, consulta SageMaker . [Monitoraggio AWS delle risorse in Amazon SageMaker AI](monitoring-overview.md)
## Utilizzo di parametri per monitorare i modelli multicontainer
Per monitorare i modelli multi-container in Inference Pipelines, usa Amazon. CloudWatch CloudWatchraccoglie dati grezzi e li elabora in metriche leggibili e quasi in tempo reale. SageMaker I job e gli endpoint di formazione basati sull'intelligenza artificiale scrivono CloudWatch metriche e registri nel namespace. `AWS/SageMaker`
Le seguenti tabelle elencano i parametri e le dimensioni per gli elementi seguenti:
+ Invocazioni dell'endpoint
+ Processi di addestramento, processi di trasformazione in batch e istanze di endpoint
Una *dimensione* è una name/value coppia che identifica in modo univoco una metrica. Puoi assegnare a un parametro fino a 10 dimensioni. Per ulteriori informazioni sul monitoraggio con CloudWatch, vedere. [Metriche di Amazon SageMaker AI in Amazon CloudWatch](monitoring-cloudwatch.md)
**Parametri di invocazione dell'endpoint**
Lo spazio dei nomi `AWS/SageMaker` include i seguenti parametri di richiesta dalle chiamate a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html).
I parametri sono segnalati a intervalli di 1 minuto.
| Metrica | Description |
| --- | --- |
| Invocation4XXErrors | Numero di richieste `InvokeEndpoint` per cui il modello ha restituito un codice di risposta HTTP `4xx`. Per ogni `4xx` risposta, SageMaker AI invia un`1`. Unità: nessuna Statistiche valide: `Average`, `Sum` |
| Invocation5XXErrors | Numero di richieste `InvokeEndpoint` per cui il modello ha restituito un codice di risposta HTTP `5xx`. Per ogni `5xx` risposta, SageMaker AI invia un`1`. Unità: nessuna Statistiche valide: `Average`, `Sum` |
| Invocations | Richieste `number of InvokeEndpoint` inviate a un endpoint di un modello. Per ottenere il numero totale di richieste inviate a un endpoint di un modello, utilizza la statistica `Sum`. Unità: nessuna Statistiche valide: `Sum`, `Sample Count` |
| InvocationsPerInstance | Il numero di invocazioni degli endpoint inviate a un modello, normalizzato da in ciascuna. `InstanceCount` `ProductionVariant` SageMaker AI invia 1/ `numberOfInstances` come valore per ogni richiesta, dove `numberOfInstances` è il numero di istanze attive per l'endpoint al ProductionVariant momento della richiesta. Unità: nessuna Statistiche valide: `Sum` |
| ModelLatency | Il tempo richiesto dal modello o dai modelli per rispondere. Questo include il tempo richiesto per inviare la richiesta, recuperare la risposta dal container di modello e completare l'inferenza nel container. ModelLatency è il tempo totale impiegato da tutti i container in una pipeline di inferenza.Unità: microsecondiStatistiche valide: `Average`, `Sum`, `Min`, `Max`, conteggio di esempio |
| OverheadLatency | Il tempo aggiunto al tempo impiegato per rispondere a una richiesta del cliente da parte di SageMaker AI for overhead. `OverheadLatency`viene misurato dal momento in cui l' SageMaker IA riceve la richiesta fino a quando non restituisce una risposta al client, meno il. `ModelLatency` La latenza di gestione può variare in base alle dimensioni di payload di richiesta e risposta, frequenza delle richieste e autenticazione o autorizzazione della richiesta, tra gli altri fattori. Unità: microsecondi Statistiche valide: `Average`, `Sum`, `Min`, `Max`, `Sample Count` |
| ContainerLatency | Il tempo impiegato da un contenitore Inference Pipelines per rispondere come visualizzato dall'IA. SageMaker ContainerLatencyinclude il tempo impiegato per inviare la richiesta, recuperare la risposta dal contenitore del modello e completare l'inferenza nel contenitore.Unità: microsecondiStatistiche valide: `Average`, `Sum`, `Min`, `Max`, `Sample Count` |
**Dimensioni dei parametri di invocazione dell'endpoint**
| Dimensione | Description |
| --- | --- |
| EndpointName, VariantName, ContainerName | Filtra i parametri di invocazione dell'endpoint per un `ProductionVariant` presso l'endpoint specificato e la variante specificata. |
****Per un endpoint della pipeline di inferenza, CloudWatch elenca le metriche di latenza per contenitore nel tuo account come Endpoint Container Metrics e **Endpoint Variant Metrics nello spazio dei nomi** AI, come segue. SageMaker **** Il parametro `ContainerLatency` viene visualizzato solo per pipeline di inferenza.
![\[La dashboard per CloudWatch una pipeline di inferenza.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/pipeline-endpoint-metrics.png)
Per ogni endpoint e ogni container, i parametri di latenza visualizzano i nomi di container, endpoint, variante e metrica.
![\[I parametri di latenza per un endpoint.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/pipeline-endpoint-metrics-details.png)
**Parametri delle istanze endpoint, dei processi di addestramento e dei processi di trasformazione in batch**
Gli spazi dei nomi `/aws/sagemaker/TrainingJobs`, `/aws/sagemaker/TransformJobs` e `/aws/sagemaker/Endpoints` includono i seguenti parametri per i processi di addestramento e le istanze endpoint.
I parametri sono segnalati a intervalli di 1 minuto.
| Metrica | Description |
| --- | --- |
| CPUUtilization | Percentuale di unità CPU utilizzate dai container in esecuzione su un'istanza. Il valore varia dallo 0% al 100% e viene moltiplicato per il numero di. CPUs Ad esempio, se ce ne sono quattro CPUs, `CPUUtilization` può variare dallo 0% al 400%. Per i processi di addestramento, `CPUUtilization` corrisponde all'utilizzo della CPU del container di algoritmi in esecuzione sull'istanza. Per i processi di trasformazione in batch, `CPUUtilization` corrisponde all'utilizzo della CPU del container di trasformazione in esecuzione sull'istanza. Per modelli multi-container, `CPUUtilization` è la somma dell'utilizzo della CPU per tutti i container in esecuzione sull'istanza. Per le varianti di endpoint, `CPUUtilization` è la somma dell'utilizzo della CPU per tutti i container in esecuzione nell'istanza. Unità: percentuale |
| MemoryUtilization | Percentuale di memoria utilizzata dai container in esecuzione su un'istanza. Questo valore è compreso tra 0% e 100%.Per i processi di addestramento, `MemoryUtilization` è la memoria utilizzata dal container degli algoritmi in esecuzione sull'istanza.Per i processi di trasformazione in batch, `MemoryUtilization` è la memoria utilizzata dal container di trasformazione in esecuzione sull'istanza.Per i modelli multi-container, MemoryUtilization è la somma della memoria utilizzata da tutti i container in esecuzione sull'istanza.Per le varianti di endpoint, `MemoryUtilization` è la somma della memoria utilizzata da tutti i container in esecuzione sull'istanza.Unità: percentuale |
| GPUUtilization | La percentuale di unità GPU utilizzate dai contenitori in esecuzione su un'istanza. `GPUUtilization`varia dallo 0% al 100% e viene moltiplicata per il numero di. GPUs Ad esempio, se ce ne sono quattro GPUs, `GPUUtilization` può variare dallo 0% al 400%. Per i processi di addestramento, `GPUUtilization` è la GPU utilizzata dal container degli algoritmi in esecuzione sull'istanza. Per i processi di trasformazione in batch, `GPUUtilization` è la GPU utilizzata dal container di trasformazione in esecuzione sull'istanza. Per modelli multi-container, `GPUUtilization` è la somma della GPU utilizzata da tutti i container in esecuzione sull'istanza. Per le varianti di endpoint, `GPUUtilization` è la somma della GPU utilizzata da tutti i container in esecuzione sull'istanza. Unità: percentuale |
| GPUMemoryUtilization | La percentuale di memoria GPU utilizzata dai contenitori in esecuzione su un'istanza. GPUMemoryL'utilizzo varia dallo 0% al 100% e viene moltiplicato per il numero di. GPUs Ad esempio, se ce ne sono quattro GPUs, `GPUMemoryUtilization` può variare dallo 0% al 400%. Per i processi di addestramento, `GPUMemoryUtilization` è la memoria GPU utilizzata dal container degli algoritmi in esecuzione sull'istanza. Per i processi di trasformazione in batch, `GPUMemoryUtilization` è la memoria GPU utilizzata dal container di trasformazione in esecuzione sull'istanza. Per i modelli multi-container, `GPUMemoryUtilization` è la somma della GPU utilizzata da tutti i container in esecuzione sull'istanza. Per le versioni di endpoint, `GPUMemoryUtilization` è la somma della memoria GPU utilizzata da tutti i container in esecuzione nell'istanza. Unità: percentuale |
| DiskUtilization | La percentuale di spazio su disco utilizzata dai contenitori in esecuzione su un'istanza. DiskUtilization varia dallo 0% al 100%. Questo parametro non è supportato per i processi di trasformazione in batch. Per i processi di addestramento, `DiskUtilization` è lo spazio su disco utilizzato dal container degli algoritmi in esecuzione sull'istanza. Per le varianti di endpoint, `DiskUtilization` è la somma dello spazio su disco utilizzato da tutti i container forniti in esecuzione sull'istanza. Unità: percentuale |
**Dimensioni dei parametri delle istanze dell'endpoint, dei processi di addestramento e dei processi di trasformazione in batch**
| Dimensione | Description |
| --- | --- |
| Host | Per i processi di addestramento, `Host` ha il formato `[training-job-name]/algo-[instance-number-in-cluster]`. Utilizza questa dimensione per filtrare i parametri di istanza per i processi di addestramento e l'istanza specificati. Questo formato di dimensione è presente solo nello spazio dei nomi `/aws/sagemaker/TrainingJobs`. Per i processi di trasformazione in batch, `Host` ha il formato `[transform-job-name]/[instance-id]`. Utilizza questa dimensione per filtrare i parametri dell'istanza per il processo di trasformazione in batch e l'istanza specificati. Questo formato di dimensione è presente solo nello spazio dei nomi `/aws/sagemaker/TransformJobs`. Per gli endpoint, `Host` ha il formato `[endpoint-name]/[ production-variant-name ]/[instance-id]`. Utilizza questa dimensione per filtrare i parametri di istanza per l'endpoint, la variante e l'istanza specificati. Questo formato di dimensione è presente solo nello spazio dei nomi `/aws/sagemaker/Endpoints`. |
Per aiutarti a eseguire il debug dei processi di formazione, degli endpoint e delle configurazioni del ciclo di vita delle istanze notebook, l' SageMaker IA invia anche tutto ciò che un contenitore di algoritmi, un contenitore modello o una configurazione del ciclo di vita di un'istanza notebook invia ad Amazon Logs. `stdout` `stderr` CloudWatch Puoi utilizzare queste informazioni per il debug e l'analisi dell'avanzamento.
## Utilizzo di log per monitorare una pipeline di inferenza
La tabella seguente elenca i gruppi di log e i flussi di log che SageMaker AI. invia ad Amazon CloudWatch
Un *flusso di log* è una sequenza di eventi di log che condividono la stessa origine. Ogni fonte separata di log in CloudWatch costituisce un flusso di log separato. Un *gruppo di log* è un gruppo di flussi di log che condividono le stesse impostazioni di conservazione, monitoraggio e controllo degli accessi.
**Log**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
**Nota**
SageMaker L'IA crea il gruppo di `/aws/sagemaker/NotebookInstances` log quando si crea un'istanza di notebook con una configurazione del ciclo di vita. Per ulteriori informazioni, consulta [Personalizzazione di un'istanza di SageMaker notebook utilizzando uno script LCC](notebook-lifecycle-config.md).
Per ulteriori informazioni sulla registrazione SageMaker AI, consulta. [CloudWatch Registri per Amazon SageMaker AI](logging-cloudwatch.md)
# Risoluzione dei problemi delle pipeline di inferenza
Per risolvere i problemi relativi alla pipeline di inferenza, utilizza CloudWatch i log e i messaggi di errore. Se utilizzi immagini Docker personalizzate in una pipeline che include algoritmi integrati di Amazon SageMaker AI, potresti riscontrare anche problemi di autorizzazione. Per concedere le autorizzazioni richieste, crea una policy Amazon Elastic Container Registry (Amazon ECR).
**Topics**
+ [Risoluzione dei problemi relativi alle autorizzazioni Amazon ECR per le pipeline di inferenza](#inference-pipeline-troubleshoot-permissions)
+ [Usa i CloudWatch log per risolvere i problemi relativi alle pipeline di inferenza SageMaker AI](#inference-pipeline-troubleshoot-logs)
+ [Utilizzo dei messaggi di errore per la risoluzione dei problemi relativi alla pipeline di inferenza](#inference-pipeline-troubleshoot-errors)
## Risoluzione dei problemi relativi alle autorizzazioni Amazon ECR per le pipeline di inferenza
Quando utilizzi immagini Docker personalizzate in una pipeline che include [algoritmi integrati di SageMaker intelligenza artificiale](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html), hai bisogno di una policy [Amazon](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) ECR. La policy consente al tuo repository Amazon ECR di concedere l'autorizzazione all' SageMaker IA per estrarre l'immagine. La policy deve aggiungere le seguenti autorizzazioni:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "allowSageMakerToPull",
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "*"
}
]
}
```
------
## Usa i CloudWatch log per risolvere i problemi relativi alle pipeline di inferenza SageMaker AI
SageMaker L'intelligenza artificiale pubblica i log dei container per gli endpoint che distribuiscono una pipeline di inferenza su CloudWatch Amazon nel seguente percorso per ogni contenitore.
```
/aws/sagemaker/Endpoints/{EndpointName}/{Variant}/{InstanceId}/{ContainerHostname}
```
Ad esempio, i log per questo endpoint vengono pubblicati nei seguenti gruppi di log e flussi:
```
EndpointName: MyInferencePipelinesEndpoint
Variant: MyInferencePipelinesVariant
InstanceId: i-0179208609ff7e488
ContainerHostname: MyContainerName1 and MyContainerName2
```
```
logGroup: /aws/sagemaker/Endpoints/MyInferencePipelinesEndpoint
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName1
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName2
```
Un *flusso di log* è una sequenza di eventi di log che condividono la stessa origine. Ogni fonte di accesso separata costituisce un flusso di log separato CloudWatch . Un *gruppo di log* è un gruppo di flussi di log che condividono le stesse impostazioni di conservazione, monitoraggio e controllo degli accessi.
**Per vedere i gruppi di log e i flussi**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nella pagina di navigazione scegli **Log**.
1. In **Gruppi di log**, applicare il filtro **MyInferencePipelinesEndpoint**:
![\[I gruppi di CloudWatch log filtrati per l'endpoint della pipeline di inferenza.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/pipeline-log-group-filter.png)
1. **Per visualizzare i flussi di log, nella pagina CloudWatch **Log Groups**, scegliete**MyInferencePipelinesEndpoint**, quindi Search Log Group.**
![\[Il flusso di CloudWatch log per la pipeline di inferenza.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/pipeline-log-streams-2.png)
Per un elenco dei log pubblicati da SageMaker AI, vedi. [Log e parametri della pipeline di inferenza](inference-pipeline-logs-metrics.md)
## Utilizzo dei messaggi di errore per la risoluzione dei problemi relativi alla pipeline di inferenza
I messaggi di errore della pipeline di inferenza indicano quali container non sono riusciti.
Se si verifica un errore mentre l' SageMaker IA richiama un endpoint, il servizio restituisce un `ModelError` (codice di errore 424), che indica quale contenitore ha avuto esito negativo. Se il payload della richiesta (la risposta del contenitore precedente) supera il limite di 5 MB, SageMaker AI fornisce un messaggio di errore dettagliato, ad esempio:
Risposta ricevuta da MyContainerName 1 con codice di stato 200. Tuttavia, il payload della richiesta da MyContainerName 1 a MyContainerName 2 è di 6000000 byte, che ha superato il limite massimo di 5 MB.
``
Se un contenitore non supera il controllo dello stato del ping mentre l' SageMaker IA sta creando un endpoint, restituisce un `ClientError` e indica tutti i contenitori che non hanno superato il controllo ping nell'ultimo controllo di integrità.
# Elimina endpoint e risorse
Elimina gli endpoint per evitare di incorrere in addebiti.
## Eliminazione di un endpoint
Elimina l'endpoint a livello di codice utilizzando AWS SDK per Python (Boto3), con o utilizzando in modo interattivo la AWS CLI console AI. SageMaker
SageMaker L'intelligenza artificiale libera tutte le risorse che sono state distribuite al momento della creazione dell'endpoint. L'eliminazione di un endpoint non eliminerà la configurazione dell'endpoint o il modello AI. SageMaker Vedi [Eliminazione di una configurazione endpoint](#realtime-endpoints-delete-endpoint-config) e [Eliminazione di un modello](#realtime-endpoints-delete-model) per informazioni su come eliminare la configurazione dell'endpoint e il modello di intelligenza artificiale. SageMaker
------
#### [ AWS SDK per Python (Boto3) ]
Utilizza l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) per eliminare il tuo endpoint. Specifica l'endpoint per il campo `EndpointName`.
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint
sagemaker_client.delete_endpoint(EndpointName=endpoint_name)
```
------
#### [ AWS CLI ]
Per eliminare l’endpoint, usa il comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html). Specifica il nome dell'endpoint per il flag `endpoint-name`.
```
aws sagemaker delete-endpoint --endpoint-name
```
------
#### [ SageMaker AI Console ]
Elimina l'endpoint in modo interattivo con la SageMaker console AI.
1. **Nel menu di [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)navigazione della console SageMaker AI, scegli Inferenza.**
1. Seleziona **Endpoint** nel menu a discesa. Apparirà un elenco di endpoint creati nel tuo AWS account per nome, Amazon Resource Name (ARN), ora di creazione, stato e data e ora dell'ultimo aggiornamento dell'endpoint.
1. Seleziona l’endpoint da eliminare.
1. Seleziona il pulsante a discesa **Azioni** nell'angolo in alto a destra.
1. Scegli **Elimina**.
------
## Eliminazione di una configurazione endpoint
Elimina la configurazione dell'endpoint in modo programmatico utilizzando AWS SDK per Python (Boto3), con o in modo interattivo la AWS CLI console AI. SageMaker L'eliminazione di una configurazione endpoint non elimina gli endpoint creati utilizzando questa configurazione. Per informazioni su come eliminare l'endpoint, consulta [Eliminazione di un endpoint](#realtime-endpoints-delete-endpoint).
Non eliminare una configurazione endpoint utilizzata da un endpoint attivo o mentre l'endpoint viene aggiornato o creato. Se elimini la configurazione endpoint di un endpoint attivo o in fase di creazione o aggiornamento potresti perdere la visibilità del tipo di istanza utilizzato dall'endpoint.
------
#### [ AWS SDK per Python (Boto3) ]
Utilizza l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html) per eliminare il tuo endpoint. Specifica il nome della configurazione endpoint per il campo `EndpointConfigName`.
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
endpoint_config_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
Facoltativamente, puoi utilizzare l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) per restituire informazioni sul nome dei modelli distribuiti (varianti di produzione), come il nome del modello e il nome della configurazione dell'endpoint associata a quel modello distribuito. Specifica il nome dell'endpoint per il campo `EndpointConfigName`.
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
endpoint_config_name = response['ProductionVariants'][0]['EndpointConfigName']
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
[Per ulteriori informazioni sugli altri elementi di risposta restituiti da`DescribeEndpointConfig`, consulta [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)la guida di riferimento delle API. SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html)
------
#### [ AWS CLI ]
Usa il comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html) per eliminare la configurazione endpoint. Specifica il nome della configurazione endpoint per il flag `endpoint-config-name`.
```
aws sagemaker delete-endpoint-config \
--endpoint-config-name
```
Facoltativamente, puoi utilizzare il comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) per restituire informazioni sul nome dei modelli distribuiti (varianti di produzione), come il nome del modello e il nome della configurazione dell'endpoint associata a quel modello distribuito. Specifica il nome dell'endpoint per il flag `endpoint-config-name`.
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
Verrà restituita una risposta JSON. Puoi copiare e incollare, utilizzare un parser JSON o utilizzare uno strumento creato per l'analisi JSON per ottenere il nome della configurazione endpoint associato a quell'endpoint.
------
#### [ SageMaker AI Console ]
Elimina la configurazione dell'endpoint in modo interattivo con la console SageMaker AI.
1. **Nel menu di [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)navigazione della console SageMaker AI, scegli Inference.**
1. Dal menu a discesa, scegli **Configurazioni endpoint**. Apparirà un elenco di configurazioni endpoint create nel tuo account AWS per nome, nome della risorsa Amazon (ARN) e data creazione.
1. Seleziona la configurazione endpoint da eliminare.
1. Seleziona il pulsante a discesa **Azioni** nell'angolo in alto a destra.
1. Scegli **Elimina**.
------
## Eliminazione di un modello
Elimina il tuo modello di SageMaker intelligenza artificiale in modo programmatico utilizzando AWS SDK per Python (Boto3), con o utilizzando in modo interattivo la AWS CLI console AI. SageMaker L'eliminazione di un modello SageMaker AI elimina solo la voce del modello che è stata creata in AI. SageMaker L’eliminazione di un modello non elimina artefatti del modello, codici di inferenza o il ruolo IAM specificato durante la creazione del modello.
------
#### [ AWS SDK per Python (Boto3) ]
Utilizza l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html)API per eliminare il tuo modello di SageMaker intelligenza artificiale. Specifica il nome del modello per il campo `ModelName`.
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
model_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete model
sagemaker_client.delete_model(ModelName=model_name)
```
Facoltativamente, puoi utilizzare l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) per restituire informazioni sul nome dei modelli distribuiti (varianti di produzione), come il nome del modello e il nome della configurazione dell'endpoint associata a quel modello distribuito. Specifica il nome dell'endpoint per il campo `EndpointConfigName`.
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
model_name = response['ProductionVariants'][0]['ModelName']
sagemaker_client.delete_model(ModelName=model_name)
```
Per ulteriori informazioni sugli altri elementi di risposta restituiti da`DescribeEndpointConfig`, [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)consulta la [guida di riferimento dell'SageMaker API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html).
------
#### [ AWS CLI ]
Usa il [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html)comando per eliminare il tuo modello di SageMaker intelligenza artificiale. Specifica il nome del modello per il flag `model-name`.
```
aws sagemaker delete-model \
--model-name
```
Facoltativamente, puoi utilizzare il comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) per restituire informazioni sul nome dei modelli distribuiti (varianti di produzione), come il nome del modello e il nome della configurazione dell'endpoint associata a quel modello distribuito. Specifica il nome dell'endpoint per il flag `endpoint-config-name`.
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
Verrà restituita una risposta JSON. È possibile copiare e incollare, utilizzare un parser JSON o utilizzare uno strumento creato per l'analisi JSON per ottenere il nome del modello associato all'endpoint.
------
#### [ SageMaker AI Console ]
Elimina il tuo modello di SageMaker intelligenza artificiale in modo interattivo con la console SageMaker AI.
1. Nel menu di [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)navigazione della console SageMaker AI, scegli **Inference**.
1. Dal menu a discesa, scegli **Modelli**. Apparirà un elenco di modelli creati nel tuo AWS account per nome, Amazon Resource Name (ARN) e ora di creazione.
1. Seleziona il modello che intendi eliminare.
1. Seleziona il pulsante a discesa **Azioni** nell'angolo in alto a destra.
1. Scegli **Delete** (Elimina).
------