Implementazione di un modello preottimizzato

Come implementare un modello preottimizzato

1. In Studio, nel menu di navigazione a sinistra, seleziona JumpStart.

2. Nella pagina Tutti i modelli pubblici, scegli uno dei modelli preottimizzati.

3. Nella pagina dei dettagli del modello, scegli Implementa.

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

5. In Nome endpoint e Conteggio istanze iniziale, accetta i valori predefiniti o imposta quelli personalizzati.

6. In Tipo di istanza, mantieni il valore predefinito. In caso contrario, non sarà possibile implementare una configurazione preottimizzata.

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

8. Seleziona Deploy (Implementa).

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

2. 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 Creare un modello in Amazon SageMaker AI con ModelBuilder.

   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)

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

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

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

3. 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 . . .'}