Implementazione di un modello preottimizzato

Come implementare un modello preottimizzato

1. In Studio, nel menu di navigazione a sinistra, scegli. 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 distribuzione, 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.

   Per ulteriori informazioni, consulta End-user contratti di licenza.

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

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

   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. 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 esempiometa-textgeneration-llama-3-70b.

Come recuperare le metriche di riferimento

1. Per determinare quale configurazione preottimizzata desideri implementare, consulta le opzioni fornite dall' SageMaker IA. 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 scelto JumpStart . Per ogni tipo di istanza, in Config Name sono elencati i nomi delle configurazioni preottimizzate. Le configurazioni fornite dall' SageMaker IA sono lmi-optimized denominate. 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 . . .'}