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