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à.
# Ottimizzazione dell’inferenza per i modelli Amazon SageMaker AI
Con Amazon SageMaker AI, puoi migliorare le prestazioni dei tuoi modelli di IA generativa applicando tecniche di ottimizzazione dell’inferenza. Ottimizzare i modelli consente di ottenere un miglior rapporto costo-prestazioni per il tuo caso d’uso. Quando ottimizzi un modello, scegli quale delle tecniche di ottimizzazione supportate applicare, tra cui la quantizzazione, la decodifica speculativa e la compilazione. Dopo aver ottimizzato il modello, puoi eseguire una valutazione per visualizzare le metriche prestazionali relative a latenza, throughput e prezzo.
Per molti modelli, SageMaker AI fornisce anche varie versioni preottimizzate, ognuna delle quali soddisfa le diverse esigenze delle applicazioni in termini di latenza e throughput. Per tali modelli, è possibile implementare una delle versioni ottimizzate senza dover prima ottimizzare il modello autonomamente.
## Tecniche di ottimizzazione
Amazon SageMaker AI supporta le tecniche di ottimizzazione indicate di seguito.
### Compilazione
La *compilazione* ottimizza il modello per ottenere le migliori prestazioni disponibili sul tipo di hardware scelto senza compromettere la precisione. È possibile applicare la compilazione di modelli per ottimizzare gli LLM per hardware accelerato, come le istanze GPU, le istanze AWS Trainium o le istanze AWS Inferentia.
Quando ottimizzi un modello con la compilazione, usufruisci dei vantaggi offerti da una compilazione anticipata. I tempi di implementazione del modello e la latenza del dimensionamento automatico si riducono, perché i pesi del modello non richiedono la compilazione just-in-time quando il modello viene implementato su una nuova istanza.
Se scegli di compilare il modello per un’istanza GPU, SageMaker AI esegue la compilazione utilizzando la libreria TensorRT-LLM. Se scegli di compilare il modello per un’istanza AWS Trainium o AWS Inferentia, SageMaker AI esegue la compilazione utilizzando AWS Neuron SDK.
### Quantizzazione
La *quantizzazione* è una tecnica che consente di ridurre i requisiti hardware di un modello utilizzando un tipo di dati meno preciso per i pesi e le attivazioni. Dopo aver ottimizzato un modello con la quantizzazione, è possibile ospitarlo su GPU meno costose e più disponibili. Tuttavia, il modello quantizzato potrebbe essere meno preciso del modello di origine ottimizzato.
I formati di dati supportati da SageMaker AI per la quantizzazione variano da modello a modello. I formati supportati sono i seguenti:
+ INT4-AWQ: formato di dati a 4 bit. La quantizzazione del peso sensibile all’attivazione (AWQ) è una tecnica di quantizzazione per LLM efficiente, accurata, a basso numero di bit e basata solo sul peso.
+ FP8: Floating Point a 8 bit (FP8) è un formato a bassa precisione per numeri in virgola mobile. Bilancia l’efficienza della memoria e la precisione del modello rappresentando valori con un minor numero di bit rispetto al formato a virgola mobile FP16 standard.
+ INT8-SmoothQuant: formato di dati a 8 bit. SmoothQuant è un metodo di quantizzazione a precisione mista che scala congiuntamente le attivazioni e i pesi, bilanciando i rispettivi intervalli dinamici.
### Decodifica speculativa
La *decodifica speculativa* è una tecnica che consente di accelerare il processo di decodifica di LLM di grandi dimensioni. Ottimizza i modelli per la latenza senza compromettere la qualità del testo generato.
Questa tecnica utilizza un modello più piccolo ma più veloce, chiamato modello di *bozza*. Il modello di bozza genera token candidati, che vengono poi convalidati dal modello di *destinazione*, più grande ma più lento. A ogni iterazione, il modello di bozza genera più token candidati. Il modello di destinazione verifica i token e, se rileva che un determinato token non è accettabile, lo rifiuta e lo rigenera. Quindi, il modello di destinazione verifica i token e ne genera una piccola quantità.
Il modello di bozza è notevolmente più veloce del modello di destinazione. Genera rapidamente tutti i token e quindi li invia in batch al modello di destinazione per la verifica. Il modello di destinazione li valuta tutti in parallelo, accelerando così la risposta finale.
SageMaker AI offre una bozza di modello predefinita che puoi utilizzare, in modo da non dover crearne uno tuo. Se preferisci utilizzare il tuo modello di bozza personalizzato, SageMaker AI supporta anche questa opzione.
### Caricamento rapido dei modelli
La tecnica di *caricamento rapido dei modelli* prepara un LLM in modo che SageMaker AI possa caricarlo su un’istanza ML più rapidamente.
Per preparare il modello, SageMaker AI ne esegue lo sharding in anticipo, dividendolo in parti che possono risiedere ciascuna su una GPU separata per l’inferenza distribuita. Inoltre, SageMaker AI memorizza i pesi del modello in blocchi di dimensioni uguali che può caricare contemporaneamente sull’istanza.
Quando SageMaker AI carica sull’istanza il modello ottimizzato, ne trasmette i pesi direttamente da Amazon S3 alle GPU dell’istanza. Nella trasmissione dei pesi in streaming, SageMaker AI omette diverse fasi dispendiose in termini di tempo che di norma sono necessarie. Queste fasi includono il download su disco degli artefatti del modello da Amazon S3, il caricamento degli artefatti del modello nella memoria host e lo sharding del modello sull’host prima di caricare definitivamente gli shard sulle GPU.
Dopo aver ottimizzato il modello per un caricamento più rapido, puoi accelerarne l’implementazione su un endpoint di SageMaker AI. Inoltre, se configuri l’endpoint per utilizzare il dimensionamento automatico, questo aumenta orizzontalmente in modo più rapido per adattarsi all’aumento del traffico.
# Implementazione di un modello preottimizzato
Alcuni modelli in JumpStart sono preottimizzati da SageMaker AI. Questo significa che è possibile implementare versioni ottimizzate di tali modelli senza prima creare un processo di ottimizzazione dell’inferenza.
Per l’elenco dei modelli con opzioni preottimizzate, consulta [Modelli JumpStart preottimizzati](#pre-optimized-js).
## Amazon SageMaker Studio
Utilizza la seguente procedura per implementare un modello JumpStart preottimizzato utilizzando Amazon SageMaker Studio.
**Come implementare un modello preottimizzato**
1. In Studio, nel menu di navigazione a sinistra, seleziona **JumpStart**.
1. Nella pagina **Tutti i modelli pubblici**, scegli uno dei modelli preottimizzati.
1. Nella pagina dei dettagli del modello, scegli **Implementa**.
1. Nella pagina di implementazione, alcuni modelli di JumpStart richiedono la firma di un contratto di licenza con l’utente finale (End User License Agreement, EULA) prima di procedere. Se richiesto, consulta i termini di licenza nella sezione **Contratto di licenza**. Se i termini sono accettabili per il caso d’uso specifico, seleziona la casella di controllo **Accetto l’EULA e leggi i termini e le condizioni.**
Per ulteriori informazioni, consulta [Contratti di licenza con l'utente finale](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula).
1. In **Nome endpoint** e **Conteggio istanze iniziale**, accetta i valori predefiniti o imposta quelli personalizzati.
1. In **Tipo di istanza**, mantieni il valore predefinito. In caso contrario, non sarà possibile implementare una configurazione preottimizzata.
1. In **Modelli**, espandi la configurazione del modello. Studio mostra una tabella che fornisce configurazioni preottimizzate tra cui scegliere. Ogni opzione include metriche per la latenza e il throughput. Scegli l’opzione più indicata per le tue esigenze di applicazione.
1. Seleziona **Deploy (Implementa)**.
## SageMaker AI Python SDK
Puoi implementare un modello preottimizzato utilizzando SageMaker AI Python SDK nel tuo progetto. Innanzitutto, definisci un’istanza `Model` utilizzando la classe `ModelBuilder`. Quindi, utilizza il metodo `set_deployment_config()` per impostare la configurazione preottimizzata che desideri implementare. Quindi, utilizza il metodo `build()` per creare il modello. Infine, utilizza il metodo `deploy()` per implementarlo su un endpoint di inferenza.
Per ulteriori informazioni sulle classi e i metodi utilizzati negli esempi seguenti, consulta [API](https://sagemaker.readthedocs.io/en/stable/api/index.html) nella documentazione di SageMaker AI Python SDK.
**Come configurare il progetto**
1. Nel codice dell’applicazione, importa le librerie necessarie. L’esempio seguente importa l’SDK per Python (Boto3). Importa anche i moduli dal SageMaker AI Python SDK che utilizzi per definire e utilizzare i modelli:
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
```
1. Inizializza una sessione di SageMaker AI. L’esempio seguente utilizza la classe `Session()`:
```
sagemaker_session = Session()
```
**Come definire il tuo modello**
1. Crea un’istanza `SchemaBuilder` e fornisci esempi di input e output. Fornisci questa istanza alla classe `ModelBuilder` al momento della definizione di un modello. SageMaker AI può così generare automaticamente le funzioni di marshalling per serializzare e deserializzare l’input e l’output.
Per ulteriori informazioni sull’utilizzo delle classi `SchemaBuilder` e `ModelBuilder`, consulta [Crea un modello in Amazon SageMaker AI con ModelBuilder](how-it-works-modelbuilder-creation.md).
L’esempio seguente fornisce esempi di stringhe di input e output per la classe `SchemaBuilder`:
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Definisci il tuo modello in SageMaker AI. L’esempio seguente imposta i parametri per inizializzare un’istanza `ModelBuilder`:
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Questo esempio utilizza un modello JumpStart. Sostituisci `jumpstart-model-id` con l’ID di un modello JumpStart, ad esempio `meta-textgeneration-llama-3-70b`.
**Come recuperare le metriche di riferimento**
1. Per determinare quale configurazione preottimizzata desideri implementare, consulta le opzioni fornite da SageMaker AI. Sono visualizzate nell’esempio seguente:
```
model_builder.display_benchmark_metrics()
```
Questo metodo `display_benchmark_metrics()` stampa una tabella simile alla seguente:
```
| Instance Type | Config Name | Concurrent Users | Latency, TTFT (P50 in sec) | Throughput (P50 in tokens/sec/user) |
|:----------------|:--------------|-------------------:|-----------------------------:|--------------------------------------:|
| ml.g5.48xlarge | lmi-optimized | 1 | 2.25 | 49.70 |
| ml.g5.48xlarge | lmi-optimized | 2 | 2.28 | 21.10 |
| ml.g5.48xlarge | lmi-optimized | 4 | 2.37 | 14.10 |
. . .
| ml.p4d.24xlarge | lmi-optimized | 1 | 0.10 | 137.40 |
| ml.p4d.24xlarge | lmi-optimized | 2 | 0.11 | 109.20 |
| ml.p4d.24xlarge | lmi-optimized | 4 | 0.13 | 85.00 |
. . .
```
Nella prima colonna, la tabella elenca i potenziali tipi di istanza che è possibile utilizzare per ospitare il modello JumpStart scelto. Per ogni tipo di istanza, in `Config Name` sono elencati i nomi delle configurazioni preottimizzate. Le configurazioni fornite da SageMaker AI sono denominate `lmi-optimized`. Per ogni tipo di istanza e configurazione, la tabella fornisce metriche di riferimento. Queste metriche indicano il throughput e la latenza che il modello supporterà per un numero diverso di utenti simultanei.
1. In base alle metriche di riferimento, scegli il tipo di istanza e il nome di configurazione che meglio supportano le tue esigenze di prestazioni. Questi valori ti serviranno per creare una configurazione di implementazione.
**Come implementare un modello preottimizzato**
1. Crea una configurazione dell’implementazione. L’esempio seguente utilizza un’istanza `ModelBuilder`, che passa un tipo di istanza e un nome di configurazione al metodo `set_deployment_config()`:
```
model_builder.set_deployment_config(
config_name="config-name",
instance_type="instance-type",
)
```
Sostituisci *`config-name`* con un nome di configurazione contenuto nella tabella, ad esempio `lmi-optimized`. Sostituisci `instance-type` con un tipo di istanza presente nella tabella, ad esempio `ml.p4d.24xlarge`.
1. Crea il tuo modello. L’esempio seguente utilizza il metodo `.build()` dell’istanza `ModelBuilder`:
```
optimized_model = model_builder.build()
```
Il metodo `.build()` restituisce un’istanza `Model` implementabile.
1. Implementa il tuo modello su un endpoint di inferenza. L’esempio seguente utilizza il metodo `.deploy()` dell’istanza `Model`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
Il metodo `deploy()` restituisce un’istanza `Predictor`, che è possibile utilizzare per inviare richieste di inferenza al modello.
**Come testare il modello con una richiesta di inferenza**
+ Dopo aver implementato il modello su un endpoint di inferenza, verifica le previsioni tramite modello. L’esempio seguente invia una richiesta di inferenza utilizzando l’istanza `Predictor`:
```
predictor.predict(sample_input)
```
Il modello restituisce il testo generato con una risposta simile alla seguente:
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## Modelli JumpStart preottimizzati
Di seguito sono riportati i modelli JumpStart con configurazioni preottimizzate.
**Meta**
+ Llama 3.1 70B Instruct
+ Llama 3.1 70B
+ Llama 3.1 405B Instruct FP8
+ Llama 3.1 405B FP8
+ Llama 3 8B Instruct
+ Llama 3 8B
+ Llama 3 70B Instruct
+ Llama 3 70B
+ Llama 2 70B Chat
+ Llama 2 7B Chat
+ Llama 2 13B Chat
**HuggingFace**
+ Mixtral 8x7B Instruct
+ Mixtral 8x7B
+ Mistral 7B Instruct
+ Mistral 7B
### Modelli JumpStart precompilati
Per alcuni modelli e configurazioni, SageMaker AI fornisce modelli precompilati per istanze AWS Inferentia e AWS Trainium specifiche. In questi casi, se si crea un processo di ottimizzazione della compilazione e si sceglie ml.inf2.48xlarge o ml.trn1.32xlarge come tipo di istanza di implementazione, SageMaker AI recupera gli artefatti compilati. Poiché il processo utilizza un modello già compilato, il completamento è rapido e non richiede di eseguire la compilazione da zero.
I seguenti sono i modelli JumpStart per i quali SageMaker AI dispone di modelli precompilati:
**Meta**
+ Llama3 8B
+ Llama3 70B
+ Llama2 7B
+ Llama2 70B
+ Llama2 13B
+ Code Llama 7B
+ Code Llama 70B
**HuggingFace**
+ Mistral 7B
# Creazione di un processo di ottimizzazione dell’inferenza
Puoi creare un lavoro di ottimizzazione dell'inferenza utilizzando Studio o l'SDK SageMaker AI Python. Il processo ottimizza il modello applicando le tecniche scelte dall’utente. Per ulteriori informazioni, consulta [Tecniche di ottimizzazione](model-optimize.md#optimization-techniques).
**Prezzi delle istanze per i processi di ottimizzazione dell’inferenza**
Quando crei un lavoro di ottimizzazione dell'inferenza che applica la quantizzazione o la compilazione, l' SageMaker intelligenza artificiale sceglie il tipo di istanza da utilizzare per eseguire il lavoro. L’addebito si basa sull’istanza utilizzata.
Per i possibili tipi di istanze e i relativi dettagli sui prezzi, consulta le informazioni sui prezzi di ottimizzazione dell'inferenza nella pagina [ SageMaker dei prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/).
Non sono previsti costi aggiuntivi per i processi che applicano la decodifica speculativa.
Per informazioni sui modelli supportati che è possibile ottimizzare, consulta [Riferimento sui modelli supportati](optimization-supported-models.md).
## Amazon SageMaker Studio
Completa la seguente procedura per creare un processo di ottimizzazione dell’inferenza in Studio.
**Come iniziare a creare un processo di ottimizzazione**
1. In SageMaker AI Studio, crea un lavoro di ottimizzazione attraverso uno dei seguenti percorsi:
+ Per creare un lavoro per un JumpStart modello, procedi come segue:
1. Nel menu di navigazione, scegliete **JumpStart**.
1. Nella pagina **Tutti i modelli pubblici**, scegli un provider di modelli, quindi scegli uno dei modelli che supporta l’ottimizzazione.
1. Nella pagina dei dettagli del modello, scegli **Ottimizza**. Questo pulsante è abilitato solo per i modelli che supportano l’ottimizzazione.
1. Nella pagina **Crea processo di ottimizzazione dell'inferenza**, alcuni JumpStart modelli richiedono la firma di un contratto di licenza con l'utente finale (EULA) prima di poter procedere. Se richiesto, consulta i termini di licenza nella sezione **Contratto di licenza**. Se i termini sono accettabili per il caso d’uso specifico, seleziona la casella di controllo **Accetto l’EULA e leggi i termini e le condizioni.**
+ Per creare un lavoro per un modello ottimizzato JumpStart , procedi come segue:
1. Nel menu di navigazione, in **Processi**, scegli **Addestramento**.
1. Nella pagina **Training Jobs**, scegliete il nome di un job che avete usato per mettere a punto un modello. JumpStart Questi lavori hanno il tipo di **JumpStartformazione** nella colonna **Tipo di lavoro**.
1. Nella pagina dei dettagli del job di addestramento, scegli **Ottimizza**.
+ Per creare un processo per un modello personalizzato, effettua le seguenti operazioni:
1. Nel menu di navigazione, in **Processi**, scegli **Ottimizzazione dell’inferenza**.
1. Scegli **Create new job** (Crea nuovo processo).
1. Nella pagina **Creazione di un processo di ottimizzazione dell’inferenza**, scegli **Aggiungi modello**.
1. Nella finestra **Aggiungi modello**, scegli **Modello personalizzato**.
1. Scegli una delle seguenti opzioni:
**Usa il tuo modello esistente**: seleziona questa opzione per ottimizzare un modello che hai già creato in SageMaker AI.
**Nome del modello esistente**: inserisci il nome del tuo modello di SageMaker intelligenza artificiale.
**Da S3**: seleziona questa opzione per fornire artefatti del modello da Amazon S3. In **URI S3**, inserisci l’URI per la posizione in Amazon S3 in cui hai archiviato gli artefatti del modello.
1. (Facoltativo) Per ****Output model name****, puoi inserire un nome personalizzato per il modello ottimizzato creato dal lavoro. Se non fornite un nome, Studio ne genera automaticamente uno in base alla selezione effettuata.
1. Nella pagina **Create inference optimization job**, per **Job name**, puoi accettare il nome predefinito assegnato da SageMaker AI. Oppure, per inserire un nome di processo personalizzato, seleziona il campo **Nome del processo** e scegli **Inserisci il nome del processo**.
**Come impostare le configurazioni di ottimizzazione**
1. Per **Tipo di istanza implementazione**, scegli il tipo di istanza per il quale desideri ottimizzare il modello.
Il tipo di istanza influisce sulle tecniche di ottimizzazione che puoi scegliere. Per la maggior parte dei tipi che utilizzano hardware GPU, le tecniche supportate sono la **Quantizzazione** e la **Decodifica speculativa**. Se scegli un'istanza che utilizza silicio personalizzato, come l'istanza AWS Inferentia ml.inf2.8xlarge, la tecnica supportata è la **compilazione**, che puoi usare per compilare il modello per quel tipo di hardware specifico.
1. Seleziona una o più tecniche di ottimizzazione fornite da Studio:
+ Se selezioni **Quantizzazione**, scegli un tipo di dati per **Tipo di dati di precisione**.
+ Se selezioni **Decodifica speculativa**, scegli una delle seguenti opzioni:
+ **Usa il modello di bozza SageMaker AI: scegli di utilizzare il modello bozza fornito** dall'intelligenza artificiale. SageMaker
**Nota**
Se scegli di utilizzare il modello di bozza SageMaker AI, devi anche abilitare l'isolamento della rete. Studio offre questa opzione in **Sicurezza**.
+ **Scegli il modello di JumpStart bozza**: scegli di selezionare un modello dal JumpStart catalogo da utilizzare come modello di bozza.
+ **Scegli il tuo modello di bozza**: scegli di utilizzare il tuo modello di bozza e fornisci l’URI S3 che lo individua.
+ Se scegli **Caricamento rapido del modello**, Studio mostra la variabile di ambiente `OPTION_TENSOR_PARALLEL_DEGREE`. Utilizza il campo **Valore** per impostare il grado di parallelizzazione tensoriale. Il valore deve dividere equamente il numero di GPUs nell'istanza scelta per il **tipo di istanza Deployment**. Ad esempio, per suddividere il modello utilizzando un'istanza con 8 GPUs, utilizzate i valori 2, 4 o 8.
+ Se imposti il **tipo di istanza Deployment** su un'istanza AWS Inferentia o AWS Trainium, Studio potrebbe mostrare che **Compilation è l'unica opzione supportata**. In tal caso, Studio seleziona questa opzione per te.
1. Per **Output**, inserisci l’URI di una posizione in Amazon S3. Qui, l' SageMaker intelligenza artificiale memorizza gli artefatti del modello ottimizzato creato dal tuo lavoro.
1. (Facoltativo) Espandi **Opzioni avanzate** per un controllo più preciso sulle impostazioni, come il ruolo IAM, il VPC e le variabili di ambiente. Per ulteriori informazioni, consulta *Opzioni avanzate*.
1. Al termine della configurazione del processo, scegli **Crea processo**.
Studio mostra la pagina dei dettagli del processo, su cui è indicato lo stato del processo con tutte le relative impostazioni.
### Opzioni avanzate
Quando si crea un processo di ottimizzazione dell’inferenza, è possibile impostare le opzioni avanzate indicate di seguito.
In **Configurazioni**, puoi impostare le seguenti opzioni:
**Grado di parallelizzazione tensoriale **
Un valore per il grado di *parallelizzazione tensoriale*. La parallelizzazione tensoriale è un tipo di parallelizzazione del modello in cui pesi, gradienti e stati dell’ottimizzatore specifici del modello vengono suddivisi tra i dispositivi. Il valore deve dividere equamente il numero di GPUs nel cluster.
**Lunghezza massima del token**
Il limite per il numero di token che il modello deve generare. Tieni presente che il modello potrebbe non generare sempre il numero massimo di token.
**Concurrency (Simultaneità)**
La capacità di eseguire più istanze di un modello sullo stesso hardware sottostante. Utilizza la simultaneità per fornire previsioni a più utenti e massimizzare l’utilizzo dell’hardware.
**Dimensione batch**
Se il modello esegue l’*inferenza in batch*, utilizza questa opzione per controllare la dimensione dei batch elaborati dal modello.
L’inferenza in batch genera previsioni tramite modelli su un batch di osservazioni. È una buona opzione per set di dati di grandi dimensioni o se non è necessaria una risposta immediata a una richiesta di inferenza.
In **Sicurezza**, puoi impostare le seguenti opzioni:
**Ruolo IAM**
Un ruolo IAM che consente all' SageMaker IA di eseguire attività per tuo conto. Durante l'ottimizzazione dei modelli, l' SageMaker intelligenza artificiale necessita del tuo permesso per:
+ Leggere i dati di input da un bucket S3
+ Scrivere artefatti dei modelli in un bucket S3
+ Scrivere log su Amazon CloudWatch Logs
+ Pubblica i parametri su Amazon CloudWatch
Concedi le autorizzazioni per tutte queste attività a un ruolo IAM.
Per ulteriori informazioni, consulta [Come utilizzare i ruoli di esecuzione dell' SageMaker IA](sagemaker-roles.md).
**Chiave KMS di crittografia**
Una chiave in AWS Key Management Service (AWS KMS). SageMaker L'intelligenza artificiale utilizza la loro chiave per crittografare gli artefatti del modello ottimizzato quando l' SageMaker IA carica il modello su Amazon S3.
**VPC**
SageMaker L'intelligenza artificiale utilizza queste informazioni per creare interfacce di rete e collegarle ai contenitori del modello. Le interfacce di rete forniscono ai container di modello una connessione di rete all'interno del tuo VPC che non è connesso a Internet. Consentono anche al tuo modello di connettersi alle risorse nel tuo VPC privato.
Per ulteriori informazioni, consulta [Offri agli endpoint ospitati dall' SageMaker intelligenza artificiale l'accesso alle risorse nel tuo Amazon VPC](host-vpc.md).
**Abilitazione dell’isolamento di rete**
Attiva questa opzione se desideri limitare l’accesso a Internet del container. I container che funzionano con isolamento di rete non possono effettuare chiamate di rete in uscita.
È necessario attivare questa opzione quando si ottimizza con la decodifica speculativa e si utilizza il SageMaker modello di bozza AI.
Per ulteriori informazioni sull’isolamento della rete, consulta [Isolamento di rete](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
In **Definizione avanzata del container**, è possibile impostare le seguenti opzioni:
**Condizione di arresto**
Specifica un limite per la durata dell’esecuzione di un processo. Quando il lavoro raggiunge il limite di tempo, l' SageMaker IA termina il lavoro. Utilizza questa opzione per limitare i costi.
**Tag**
Coppie chiave-valore associate al processo di ottimizzazione.
Per ulteriori informazioni sui tag, consulta [Tagging delle risorse AWS](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html) in *Riferimenti generali di AWS*.
**Variabili di ambiente**
Coppie chiave-valore che definiscono le variabili di ambiente da impostare nel container del modello.
## SageMaker SDK per AI per Python
Puoi creare un lavoro di ottimizzazione dell'inferenza utilizzando l'SDK SageMaker AI Python nel tuo progetto. Innanzitutto, definisci un’istanza `Model` utilizzando la classe `ModelBuilder`. Quindi, utilizza il metodo `optimize()` per eseguire un processo che ottimizza il modello con quantizzazione, decodifica speculativa o compilazione. Al termine del processo, implementa il modello su un endpoint di inferenza utilizzando il metodo `deploy()`.
Per ulteriori informazioni sulle classi e sui metodi utilizzati negli esempi seguenti, consulta la [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)documentazione di SageMaker AI Python SDK.
**Come configurare il progetto**
1. Nel codice dell’applicazione, importa le librerie necessarie. L’esempio seguente importa l’SDK per Python (Boto3). Importa anche le classi dall'SDK SageMaker AI Python che usi per definire e lavorare con i modelli:
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
from pathlib import Path
```
1. Inizializza una SageMaker sessione AI. L’esempio seguente utilizza la classe `Session()`:
```
sagemaker_session = Session()
```
**Come definire il tuo modello**
1. Crea un’istanza `SchemaBuilder` e fornisci esempi di input e output. Fornisci questa istanza alla classe `ModelBuilder` al momento della definizione di un modello. Con esso, l' SageMaker IA genera automaticamente le funzioni di marshalling per serializzare e deserializzare l'input e l'output.
Per ulteriori informazioni sull’utilizzo delle classi `SchemaBuilder` e `ModelBuilder`, consulta [Crea un modello in Amazon SageMaker AI con ModelBuilder](how-it-works-modelbuilder-creation.md).
L’esempio seguente fornisce esempi di stringhe di input e output per la classe `SchemaBuilder`:
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. SageMaker Definisci il tuo modello in base all'intelligenza artificiale. L’esempio seguente imposta i parametri per inizializzare un’istanza `ModelBuilder`:
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Questo esempio utilizza un JumpStart modello. Sostituisci `jumpstart-model-id` con l'ID di un JumpStart modello, ad esempio`meta-textgeneration-llama-3-70b`.
**Nota**
Se desideri ottimizzare con la decodifica speculativa e desideri utilizzare la bozza SageMaker AI, devi abilitare l'isolamento della rete. Per abilitarlo, includi il seguente argomento quando inizializzi un’istanza `ModelBuilder`:
```
enable_network_isolation=True,
```
Per ulteriori informazioni sull’isolamento della rete, consulta [Isolamento di rete](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
**Come eseguire l’ottimizzazione con la quantizzazione**
1. Per eseguire un processo di quantizzazione, utilizza il metodo `optimize()` e imposta l’argomento `quantization_config`. L’esempio seguente imposta `OPTION_QUANTIZE` come variabile di ambiente nel container di ottimizzazione:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
quantization_config={
"OverrideEnvironment": {
"OPTION_QUANTIZE": "awq",
},
},
output_path="s3://output-path",
)
```
In questo esempio, sostituisci *`instance-type`* con un’istanza ML, ad esempio `ml.p4d.24xlarge`. Sostituisci *`s3://output-path`* con il percorso della posizione S3 in cui archivi il modello ottimizzato creato dal processo.
Il metodo `optimize()` restituisce un oggetto `Model`, che è possibile utilizzare per implementare il modello in un endpoint.
1. Al termine del processo, implementa il modello. L’esempio seguente utilizza il metodo `deploy()`:
```
predictor = optimized_model.deploy(
instance_type="instance-type",
accept_eula=True,
)
```
In questo esempio, sostituisci *`instance-type`* con un’istanza ML, ad esempio `ml.p4d.24xlarge`.
Il metodo `deploy()` restituisce un oggetto predittore, che è possibile utilizzare per inviare richieste di inferenza all’endpoint che ospita il modello.
**Da ottimizzare con la decodifica speculativa utilizzando il modello AI Draft SageMaker**
Quando ottimizzi il modello con una decodifica speculativa, puoi scegliere di utilizzare una bozza di modello fornita dall' SageMaker intelligenza artificiale oppure puoi usare il tuo. I seguenti esempi utilizzano il modello di bozza SageMaker AI.
**Prerequisito**
Per ottimizzare con la decodifica speculativa e il modello di bozza SageMaker AI, è necessario abilitare l'isolamento della rete quando si definisce il modello.
1. Per eseguire un processo di decodifica speculativa, utilizza il metodo `optimize()` e imposta l’argomento `speculative_decoding_config`. L'esempio seguente imposta la `ModelProvider` chiave per utilizzare il modello `SAGEMAKER` di bozza fornito dall'IA. SageMaker
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelProvider": "SAGEMAKER",
},
)
```
In questo esempio, sostituisci *`instance-type`* con un’istanza ML, ad esempio `ml.p4d.24xlarge`.
Il metodo `optimize()` restituisce un oggetto `Model`, che è possibile utilizzare per implementare il modello in un endpoint.
1. Al termine del processo, implementa il modello. L’esempio seguente utilizza il metodo `deploy()`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
Il metodo `deploy()` restituisce un oggetto predittore, che è possibile utilizzare per inviare richieste di inferenza all’endpoint che ospita il modello.
**Come eseguire l’ottimizzazione con la decodifica speculativa utilizzando un modello di bozza personalizzato**
Prima di poter fornire la bozza del modello personalizzato all' SageMaker IA, devi prima caricare gli artefatti del modello su Amazon S3.
Gli esempi seguenti mostrano un modo possibile per fornire una bozza di modello personalizzata. Gli esempi scaricano la bozza del modello da Hugging Face Hub, la caricano in Amazon S3 e forniscono l’URI S3 per l’argomento `speculative_decoding_config`.
1. Se desideri scaricare un modello dall’Hugging Face Hub, aggiungi la libreria `huggingface_hub` al tuo progetto e scarica un modello con il metodo `snapshot_download()`. L’esempio seguente scarica un modello in una cartella locale:
```
import huggingface_hub
huggingface_hub.snapshot_download(
repo_id="model-id",
revision="main",
local_dir=download-dir,
token=hf-access-token,
)
```
In questo esempio, sostituisci *`model-id`* con l’ID di un modello dell’Hugging Face Hub, ad esempio `meta-llama/Meta-Llama-3-8B`. Sostituisci *`download-dir`* con una directory locale. Sostituisci *`hf-access-token`* con il tuo token di accesso utente. Per scoprire come ottenere il token di accesso, consulta [Token di accesso utente](https://huggingface.co/docs/hub/en/security-tokens) nella documentazione di Hugging Face.
Per ulteriori informazioni sulla libreria `huggingface_hub`, consulta [Libreria client dell’hub](https://huggingface.co/docs/huggingface_hub/en/index) nella documentazione di Hugging Face.
1. Per rendere disponibile all' SageMaker IA il modello scaricato, caricalo su Amazon S3. L’esempio seguente carica il modello con l’oggetto `sagemaker_session`.
```
custom_draft_model_uri = sagemaker_session.upload_data(
path=hf_local_download_dir.as_posix(),
bucket=sagemaker_session.default_bucket(),
key_prefix="prefix",
)
```
In questo esempio, sostituisci *`prefix`* con un qualificatore che ti aiuti a distinguere la bozza del modello in S3, ad esempio `spec-dec-custom-draft-model`.
Il metodo `upload_data()` restituisce l’URI S3 per gli artefatti del modello.
1. Per eseguire un processo di decodifica speculativa, utilizza il metodo `optimize()` e imposta l’argomento `speculative_decoding_config`. L’esempio seguente imposta la chiave `ModelSource` per l’URI S3 del modello di bozza personalizzato:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelSource": custom_draft_model_uri + "/",
},
)
```
In questo esempio, sostituisci *`instance-type`* con un’istanza ML, ad esempio `ml.p4d.24xlarge`.
Il metodo `optimize()` restituisce un oggetto `Model`, che è possibile utilizzare per implementare il modello in un endpoint.
1. Al termine del processo, implementa il modello. L’esempio seguente utilizza il metodo `deploy()`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
Il metodo `deploy()` restituisce un oggetto predittore, che è possibile utilizzare per inviare richieste di inferenza all’endpoint che ospita il modello.
**Come ottimizzare con la compilazione**
1. Per eseguire un processo di compilazione, utilizza il metodo `optimize()` e imposta l’argomento `compilation_config`. L’esempio seguente utilizza la chiave `OverrideEnvironment` per impostare le variabili di ambiente necessarie nel container di ottimizzazione:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
compilation_config={
"OverrideEnvironment": {
"OPTION_TENSOR_PARALLEL_DEGREE": "24",
"OPTION_N_POSITIONS": "8192",
"OPTION_DTYPE": "fp16",
"OPTION_ROLLING_BATCH": "auto",
"OPTION_MAX_ROLLING_BATCH_SIZE": "4",
"OPTION_NEURON_OPTIMIZE_LEVEL": "2",
}
},
output_path="s3://output-path",
)
```
In questo esempio, imposta *`instance-type`* su un tipo di istanza ML con hardware accelerato. Ad esempio, per un'inferenza accelerata con AWS Inferentia, puoi impostare il tipo su un'istanza Inf2, ad esempio. `ml.inf2.48xlarge` Sostituisci *`s3://output-path`* con il percorso della posizione S3 in cui archivi il modello ottimizzato creato dal processo.
1. Al termine del processo, implementa il modello. L’esempio seguente utilizza il metodo `deploy()`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
Il metodo `deploy()` restituisce un oggetto predittore, che è possibile utilizzare per inviare richieste di inferenza all’endpoint che ospita il modello.
**Come testare il modello con una richiesta di inferenza**
+ Per inviare una richiesta di inferenza di test al modello implementato, utilizza il metodo `predict()` di un oggetto predittore. L’esempio seguente passa la variabile `sample_input`, che è stata passata anche alla classe `SchemaBuilder` negli esempi per definire il modello:
```
predictor.predict(sample_input)
```
L’input di esempio presenta il prompt, `"What is the largest planet in the solar system?"`. Il metodo `predict()` restituisce la risposta generata dal modello, come illustrato nell’esempio seguente:
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## AWS SDK per Python (Boto3)
Puoi utilizzare l' AWS SDK for Python (Boto3) per creare e gestire a livello di codice lavori di ottimizzazione dell'inferenza. Questa sezione fornisce esempi per diverse tecniche di ottimizzazione.
**Prerequisiti**
Prima di creare un lavoro di ottimizzazione con Boto3, assicurati di avere:
+ AWS Credenziali configurate: imposta le tue AWS credenziali con le autorizzazioni appropriate
+ Hai creato un modello di SageMaker intelligenza artificiale (se utilizzi un modello esistente)
+ Dati di addestramento preparati in S3 (per l'ottimizzazione della decodifica speculativa, lunghezza del contesto supportata fino a 4096)
+ Ruolo IAM con le autorizzazioni necessarie: il ruolo di esecuzione deve disporre delle autorizzazioni per accedere a S3 e creare risorse SageMaker
**Esempio: creazione di un Job di ottimizzazione con EAGLE Speculative Decoding (Llama 3.3 70B)**
Questo esempio dimostra la creazione di un lavoro di ottimizzazione per un modello linguistico di grandi dimensioni utilizzando la tecnica di decodifica speculativa EAGLE:
```
import boto3
# Initialize SageMaker client
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Step 1: Create a SageMaker model (if not already created)
model_response = sagemaker_client.create_model(
ModelName='meta-llama-3-3-70b-instruct',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/Llama-3.3-70B-Instruct/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'SAGEMAKER_ENV': '1',
'SAGEMAKER_MODEL_SERVER_TIMEOUT': '3600'
}
}
)
# Step 2: Create optimization job with speculative decoding
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'meta-llama-3-3-70b-instruct'
}
},
DeploymentInstanceType='ml.p4d.24xlarge',
# MaxInstanceCount specifies the maximum number of instances for distributed training
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_8k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/llama-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Esempio: creazione di un Job di ottimizzazione da S3 Model Artifacts (Qwen3 32B)**
Questo esempio mostra come creare un lavoro di ottimizzazione utilizzando gli artefatti del modello direttamente da S3:
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Create model from S3 artifacts
model_response = sagemaker_client.create_model(
ModelName='qwen3-32b',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'Mode': 'SingleModel',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/qwen3-32b/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'AWS_REGION': 'us-west-2'
}
}
)
# Create optimization job with smaller training dataset
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='qwen3-optim-job-eagle',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'qwen3-32b'
}
},
DeploymentInstanceType='ml.g6.48xlarge',
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_1k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/qwen3-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Esempio: monitoraggio e gestione dei lavori di ottimizzazione**
Dopo aver creato un lavoro di ottimizzazione, è possibile monitorarne l'avanzamento e gestirlo utilizzando questi comandi:
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Describe optimization job to check status
describe_response = sagemaker_client.describe_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
)
print(f"Job Status: {describe_response['OptimizationJobStatus']}")
# List all optimization jobs (with pagination)
list_response = sagemaker_client.list_optimization_jobs(
MaxResults=10,
SortBy='CreationTime',
SortOrder='Descending'
)
print("\nRecent optimization jobs:")
for job in list_response['OptimizationJobSummaries']:
print(f"- {job['OptimizationJobName']}: {job['OptimizationJobStatus']}")
# Stop a running optimization job if needed
# sagemaker_client.stop_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
# Delete a completed or failed optimization job
# sagemaker_client.delete_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
```
La decodifica speculativa con Eagle Heads esegue quattro processi di addestramento sequenziali. Ogni processo produce un output che diventa l'input per il successivo. Solo l'output del lavoro finale viene inviato al tuo bucket S3. Gli output intermedi sono crittografati e archiviati in un bucket di servizi SageMaker AI interno per un massimo di 20 giorni. SageMaker L'IA non dispone delle autorizzazioni per decrittografarli. Se desideri che i dati intermedi vengano rimossi prima di tale periodo di tempo, assicurati che il processo sia stato completato o interrotto, quindi apri una richiesta di assistenza [[https://docs.aws.amazon.com/awssupport/latest/user/casecreating-a-support-case-management.html\$1](https://docs.aws.amazon.com/awssupport/latest/user/case-management.html#creating-a-support-case)] per eliminare questi dati. Includi nella richiesta l'ID del tuo AWS account e l'ARN del lavoro di ottimizzazione.
## Limitazioni del modello di bozza SageMaker AI
Per qualsiasi modello ottimizzato con il modello di bozza SageMaker AI, tieni presente i requisiti, le restrizioni e le variabili di ambiente supportate.
**Requisiti**
Completa le attività seguenti:
+ Usa un modello fornito da SageMaker JumpStart.
+ Abilita l’isolamento della rete per l’implementazione del modello.
+ Se distribuisci il modello in un contenitore Large Model Inference (LMI), utilizza un DJLServing contenitore con versione 0.28.0 o successiva.
Per i contenitori disponibili, consulta [Large Model Inference Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) nel GitHub repository Deep Learning Containers.
+ Se ottimizzi il JumpStart modello, usa il formato safetensors per i pesi del modello.
Per ulteriori informazioni su questo formato, consulta [Safetensors](https://huggingface.co/docs/safetensors/en/index) nella documentazione di Hugging Face.
**Restrizioni**
Non puoi eseguire le operazioni indicate di seguito:
+ Utilizza il modello in ambienti di test locali creati con la modalità locale.
Per ulteriori informazioni sulla modalità locale, consulta [Local Mode](https://sagemaker.readthedocs.io/en/stable/overview.html#local-mode) nella documentazione di SageMaker AI Python SDK.
+ Accedi al contenitore del modello tramite l' AWS Systems Manager agente (agente SSM). L'agente SSM fornisce l'accesso a livello di shell al contenitore modello in modo da poter eseguire il debug dei processi e registrare i comandi con Amazon. CloudWatch
Per ulteriori informazioni sull'utilizzo di questa caratteristica, consulta [Accedi ai container tramite SSM](ssm-access.md).
+ Configura il container del modello per un core dump che si verifica in caso di arresto anomalo del processo.
Per ulteriori informazioni sui core dump dei container modello, consulta. [ProductionVariantCoreDumpConfig](sagemaker/latest/APIReference/API_ProductionVariantCoreDumpConfig.html)
+ Implementa il modello su endpoint multi-modello, endpoint multi-container o endpoint che ospitano componenti di inferenza.
Per ulteriori informazioni su questi tipi di endpoint, consulta [Endpoint multi-modello](multi-model-endpoints.md), [Endpoint multi-container](multi-container-endpoints.md) e [Componenti di inferenza](realtime-endpoints-deploy-models.md#inference-components).
+ Crea un pacchetto di modelli per il modello. Utilizzate i pacchetti di modelli per creare modelli distribuibili su cui pubblicare. Marketplace AWS
Per ulteriori informazioni sull'utilizzo di questa caratteristica, consulta [Creazione di una risorsa pacchetto di modelli](sagemaker-mkt-create-model-package.md).
+ Utilizza il tuo codice di inferenza nel container del modello.
+ Utilizza un file `requirements.txt` nel container del modello. Questo tipo di file elenca le dipendenze dei pacchetti.
+ Abilita il parametro `trust_remote_code` di Hugging Face.
**Variabili di ambiente supportate**
Puoi configurare il container solo con le seguenti variabili di ambiente:
+ Variabili di ambiente comuni per container di inferenza di modelli di grandi dimensioni (LMI).
Per ulteriori informazioni su queste variabili, consulta [Configurazioni delle variabili di ambiente](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/deployment_guide/configurations.html#environment-variable-configurations) nella documentazione del container LMI.
+ Variabili di ambiente comuni per i pacchetti forniti da Hugging Face Hub nei suoi repository Git.
Per i repository, vedi [Hugging Face on](https://github.com/huggingface). GitHub
+ Variabili di ambiente comuni PyTorch e CUDA.
Per ulteriori informazioni su queste variabili, consulta [Torch Environment Variables](https://pytorch.org/docs/stable/torch_environment_variables.html) nella PyTorch documentazione.
# Visualizzazione dei risultati del processo di ottimizzazione
Dopo aver creato uno o più processi di ottimizzazione, puoi utilizzare Studio per visualizzare una tabella riassuntiva di tutti i tuoi processi e i relativi dettagli.
## Amazon SageMaker Studio
**Come visualizzare la tabella riassuntiva dei processi di ottimizzazione**
+ Nel menu di navigazione di Studio, in **Processi**, scegli **Ottimizzazione dell’inferenza**.
La pagina **Ottimizzazione dell’inferenza** contiene una tabella in cui sono riportati i processi che hai creato. Per ogni processo, mostra le configurazioni di ottimizzazione che hai applicato e lo stato del processo.
**Come visualizzare i dettagli per un processo**
+ Scegli il nome del processo nella tabella di riepilogo presente nella pagina **Ottimizzazione dell’inferenza**.
Studio mostra la pagina dei dettagli del processo, su cui è indicato lo stato del processo con tutte le impostazioni applicate al momento della sua creazione. Se il processo è stato completato correttamente, SageMaker AI ha archiviato gli artefatti del modello ottimizzato nella posizione Amazon S3 in **URI S3 del modello ottimizzato**.
# Valutazione delle prestazioni dei modelli ottimizzati
Dopo aver utilizzato un processo di ottimizzazione per creare un modello ottimizzato, è possibile eseguire una valutazione delle prestazioni del modello. Questa valutazione fornisce metriche relative a latenza, throughput e prezzo. Utilizza queste metriche per determinare se il modello ottimizzato soddisfa le esigenze del tuo caso d’uso o se richiede un’ulteriore ottimizzazione.
È possibile eseguire valutazioni delle prestazioni solo utilizzando Studio. Questa funzionalità non è fornita tramite l'API Amazon SageMaker AI o l'SDK Python.
## Prima di iniziare
Prima di poter creare una valutazione delle prestazioni, è necessario ottimizzare un modello creando un processo di ottimizzazione dell’inferenza. In Studio, è possibile valutare solo i modelli creati con questi processi.
## Creazione della valutazione delle prestazioni
Completa la seguente procedura in Studio per creare una valutazione delle prestazioni per un modello ottimizzato.
1. Nel menu di navigazione di Studio, in **Processi**, scegli **Ottimizzazione dell’inferenza**.
1. Scegli il nome del processo che ha creato il modello ottimizzato che desideri valutare.
1. Nella pagina dei dettagli del processo, scegli **Valuta le prestazioni**.
1. Nella pagina **Evaluate performance**, alcuni JumpStart modelli richiedono la firma di un contratto di licenza con l'utente finale (EULA) prima di procedere. Se richiesto, consulta i termini di licenza nella sezione **Contratto di licenza**. Se i termini sono accettabili per il caso d’uso specifico, seleziona la casella di controllo **Accetto l’EULA e leggi i termini e le condizioni.**
1. In **Seleziona un modello per il tokenizzatore**, accetta l’impostazione predefinita o scegli un modello specifico che funga da tokenizer per la tua valutazione.
1. Per **Set di dati di input**, scegli se:
+ Utilizza i set di dati di esempio predefiniti di AI. SageMaker
+ Fornisci un URI S3 che rimandi ai tuoi set di dati di esempio.
1. In **URI S3 per i risultati delle prestazioni**, fornisci un URI che rimandi alla posizione in Amazon S3 in cui desideri archiviare i risultati della valutazione.
1. Scegli **Valuta**.
Studio mostra la pagina **Valutazioni delle prestazioni**, in cui il processo di valutazione viene mostrato nella tabella. La colonna **Stato** mostra lo stato della valutazione.
1. Quando lo stato è **Completato**, scegli il nome del processo per visualizzare i risultati della valutazione.
La pagina dei dettagli della valutazione mostra le tabelle che forniscono le metriche delle prestazioni relative a latenza, throughput e prezzo. Per ulteriori informazioni sulle singole metriche, consulta [Riferimento alle metriche per le valutazioni delle prestazioni di inferenza](#performance-eval-metrics-reference).
## Riferimento alle metriche per le valutazioni delle prestazioni di inferenza
Una volta conclusa correttamente la valutazione delle prestazioni di un modello ottimizzato, la pagina dei dettagli della valutazione in Studio mostra le seguenti metriche.
### Metriche di latenza
La sezione **Latenza** mostra le metriche indicate di seguito.
**Concurrency (Simultaneità)**
Il numero di utenti simultanei simulati dalla valutazione per invocare l’endpoint contemporaneamente.
**Tempo per il primo token (ms)**
Il tempo trascorso tra l’invio della richiesta e la ricezione del primo token di una risposta in streaming.
**Latenza inter-token (ms)**
Il tempo necessario per generare un token di output per ogni richiesta.
**Latenza del client (ms)**
La latenza della richiesta dal momento in cui questa viene inviata al momento della ricezione dell’intera risposta.
**Input tokens/sec (conteggio)**
Il numero totale di token di input generati, in tutte le richieste, diviso per la durata totale in secondi della simultaneità.
**Uscita tokens/sec (conteggio)**
Il numero totale di token di output generati, in tutte le richieste, diviso per la durata totale in secondi della simultaneità.
**Invocazioni del client (numero)**
Il numero totale di richieste di inferenza inviate all’endpoint da tutti gli utenti contemporaneamente.
**Errori di invocazione client (numero)**
Il numero totale di richieste di inferenza inviate all’endpoint da tutti gli utenti in un determinato momento simultaneo con un conseguente errore di invocazione.
**Errore del tokenizzatore (numero)**
Il numero totale di richieste di inferenza in cui il tokenizzatore non è riuscito ad analizzare la richiesta o la risposta.
**Risposta di inferenza vuota (numero)**
Il numero totale di richieste di inferenza che hanno portato a zero token di output o alla mancata analisi della risposta da parte del tokenizzatore.
### Metriche di throughput
La sezione **Throughput** mostra le metriche indicate di seguito.
**Concurrency (Simultaneità)**
Il numero di utenti simultanei simulati dalla valutazione per invocare l’endpoint contemporaneamente.
**Ingresso tokens/sec/req (conteggio)**
Il numero totale di token di input generati al secondo per richiesta.
**Uscita tokens/sec/req (conteggio)**
Il numero totale di token di output generati al secondo per richiesta.
**Token di input (numero)**
Il numero totale di token di input generati per richiesta.
**Token di output (numero)**
Il numero totale di token di output generati per richiesta.
### Metriche di prezzo
La sezione **Prezzo** mostra le metriche indicate di seguito.
**Concurrency (Simultaneità)**
Il numero di utenti simultanei simulati dalla valutazione per invocare l’endpoint contemporaneamente.
**Prezzo per milione di token di input**
Costo di elaborazione di 1 milione di token di input.
**Prezzo per milione di token di output**
Costo della generazione di 1 milione di token di output.
# Riferimento sui modelli supportati
Le tabelle seguenti mostrano i modelli per i quali l' SageMaker IA supporta l'ottimizzazione dell'inferenza e le tecniche di ottimizzazione supportate.
**Modelli Llama supportati**
| Nome modello | Formati di dati supportati per la quantizzazione | Supporta la decodifica speculativa | Supporta il caricamento rapido dei modelli | Librerie utilizzate per la compilazione |
| --- | --- | --- | --- | --- |
| Meta Llama 2 13B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Llama 2 13B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Llama 2 70B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Llama 2 70B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Llama 2 7B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Llama 2 7B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Llama 3 70B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Llama 3 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Llama 3 8B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Llama 3 8B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Meta Code Llama 13B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 13B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 13B Python | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 34B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 34B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 34B Python | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 70B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 70B Python | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 7B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Code Llama 7B Python | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Meta Llama 2 13B Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 2 13B Chat Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 2 70B Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 2 70B Chat Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 2 7B Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 2 7B Chat Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 3 70B Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 3 70B Instruct Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 3 8B Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 3 8B Instruct Neuron | Nessuno | No | No | AWSNeurone |
| Meta Code Llama 70B Neuron | Nessuno | No | No | AWSNeurone |
| Meta Code Llama 7B Neuron | Nessuno | No | No | AWSNeurone |
| Meta Code Llama 7B Python Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 3.1 405B FP8 | Nessuno | Sì | Sì | Nessuno |
| Istruzioni per Meta Llama 3.1 405B FP8 | Nessuno | Sì | Sì | Nessuno |
| Meta Llama 3.1 70B | INT4-FAQ FP8 | Sì | Sì | Nessuno |
| Meta Llama 3.1 70B Instruct | INT4-AWQ FP8 | Sì | Sì | Nessuno |
| Meta Llama 3.1 8B | INT4-AWQ FP8 | Sì | Sì | Nessuno |
| Meta Llama 3.1 8B Instruct | INT4-AWQ FP8 | Sì | Sì | Nessuno |
| Meta Llama 3.1 70B Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 3.1 70B Instruct Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 3 1 8B Neuron | Nessuno | No | No | AWSNeurone |
| Meta Llama 3.1 8B Instruct Neuron | Nessuno | No | No | AWSNeurone |
**Modelli Mistral supportati**
| Nome modello | Formati di dati supportati per la quantizzazione | Supporta la decodifica speculativa | Supporta il caricamento rapido dei modelli | Librerie utilizzate per la compilazione |
| --- | --- | --- | --- | --- |
| Mistral 7B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Mistral 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | AWSNeurone TensorRT-LLM |
| Mistral 7B Neuron | Nessuno | No | No | AWSNeurone |
| Mistral 7B Instruct Neuron | Nessuno | No | No | AWSNeurone |
**Modelli Mixtral supportati**
| Nome modello | Formati di dati supportati per la quantizzazione | Supporta la decodifica speculativa | Supporta il caricamento rapido dei modelli | Librerie utilizzate per la compilazione |
| --- | --- | --- | --- | --- |
| Mixtral-8x22B-Instruct-v0.1 | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Mixtral-8x22B V1 | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Mixtral 8x7B | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
| Mixtral 8x7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sì | Sì | TensorRT-LLM |
**Architetture di modello supportate e tipo EAGLE**
| Nome dell'architettura del modello | Tipo EAGLE |
| --- | --- |
| LlamaForCausalLM | AQUILA 3 |
| ForCausalWen 3 KM | AQUILA 3 |
| NextForCausalWen 3 KM | AQUILA 2 |
| MoeForCausalWen 3 KM | AQUILA 3 |
| ForCausalWen 2 KM | AQUILA 3 |
| GptOssForCausalLM | AQUILA 3 |