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

Distribuisci modelli utilizzando JumpStart kubectl

I passaggi seguenti mostrano come distribuire un JumpStart modello in un cluster usando kubectl. HyperPod

Le seguenti istruzioni contengono celle di codice e comandi progettati per essere eseguiti in un ambiente notebook Jupyter, come Amazon SageMaker Studio o SageMaker Notebook Instances. Ogni blocco di codice rappresenta una cella del notebook che deve essere eseguita in sequenza. Gli elementi interattivi, tra cui le tabelle di individuazione dei modelli e i comandi di monitoraggio dello stato, sono ottimizzati per l'interfaccia del notebook e potrebbero non funzionare correttamente in altri ambienti. Assicurati di avere accesso a un ambiente notebook con le AWS autorizzazioni necessarie prima di procedere.

Prerequisiti

Assicurati di aver configurato le funzionalità di inferenza sui tuoi SageMaker HyperPod cluster Amazon. Per ulteriori informazioni, consulta HyperPod Configurazione dei cluster per la distribuzione dei modelli.

Configurazione e configurazione

Seleziona la tua regione

Scegli la regione in cui distribuire il HyperPod cluster e dove desideri eseguire i carichi di lavoro di inferenza. Puoi anche aggiungere altre personalizzazioni a. sagemaker_client

region_name = <REGION>

import boto3
from botocore.config import Config
# Configure retry options
boto3_config = Config(
    retries={
        'max_attempts': 10,  # Maximum number of retry attempts
        'mode': 'adaptive'   # Use adaptive mode for exponential backoff
    }
)

sagemaker_client=boto3.client("sagemaker", region_name=region_name, config=boto3_config)        

Scegli il modello e il cluster

Configura il nome del bucket S3

Configura i nomi dei bucket S3 per i certificati. Questo bucket deve avere una cartella denominata «certificati» in cui verranno caricati i certificati. Inoltre, il bucket deve trovarsi nella stessa regione definita sopra.

# Set the S3 bucket name where TLS certificates will be stored for secure model communication
certificate_bucket = "<insert bucket name here>"      

import yaml
from datetime import datetime

# Get current time in format suitable for endpoint name
current_time = datetime.now().strftime("%Y%m%d-%H%M%S")
sagemaker_endpoint_name=f"{model_id}-{current_time}"


def generate_jumpstart_model_yaml(model_id, model_version, namespace, instance_type, output_file_path, certificate_bucket):
    """
    Generate a JumpStartModel YAML file with the provided parameters.

    Args:
        model_id (str): The model ID
        model_version (str): The model version
        namespace (str): The namespace
        instance_type (str): The instance type
        output_file_path (str): Path where the YAML file will be saved
    """

    # Create the YAML structure
    tlsCertificateOutputS3Uri = "s3://" + certificate_bucket + "/certificates/"
    model_config = {
        "apiVersion": "inference.sagemaker.aws.amazon.com/v1alpha1",
        "kind": "JumpStartModel",
        "metadata": {
            "name": model_id,
            "namespace": namespace
        },
        "spec": {
            "sageMakerEndpoint": {
                "name": sagemaker_endpoint_name
            },
            "model": {
                "modelHubName": "SageMakerPublicHub",
                "modelId": model_id,
                # modelVersion is optional
                "modelVersion": model_version
                # acceptEula is optional, set value to True when using a gated model
            },
            "server": {
                "instanceType": instance_type
            },
            "tlsConfig": {
                "tlsCertificateOutputS3Uri": tlsCertificateOutputS3Uri
            }
        }
    }

    # Write to YAML file
    with open(output_file_path, 'w') as file:
        yaml.dump(model_config, file, default_flow_style=False)

    print(f"YAML file created successfully at: {output_file_path}")       

# Import JumpStart utilities to retrieve model specifications and version information
from sagemaker.jumpstart import utilsfrom sagemaker.jumpstart.enums import JumpStartScriptScope

model_specs = utils.verify_model_region_and_return_specs(
        model_id, "*", JumpStartScriptScope.INFERENCE, region=region_name)     
model_version = model_specs.version       

# Generate the output filename for the Kubernetes YAML configuration
output_file_path=f"jumpstart-model-{model_id}.yaml"
generate_jumpstart_model_yaml(
    model_id=model_id,
    model_version=model_version,
    namespace=cluster_namespace,
    instance_type=instance_type,
    output_file_path=output_file_path,
    certificate_bucket=certificate_bucket
)

import os
os.environ["JUMPSTART_YAML_FILE_PATH"]=output_file_path
os.environ["MODEL_ID"]=model_id       

Distribuzione del modello

Aggiorna la configurazione di Kubernetes e distribuisci il tuo modello

Monitora lo stato dell'implementazione del modello

Invoca l'endpoint del tuo modello

È possibile recuperare a livello di codice payload di esempio dall'oggetto. JumpStartModel

import boto3

prompt = "{\"inputs\": \"What is AWS SageMaker?\"}}"

runtime_client = boto3.client('sagemaker-runtime', region_name=region_name)
response = runtime_client.invoke_endpoint(
    EndpointName=sagemaker_endpoint_name,
    ContentType="application/json",
    Body=prompt
)
print(response["Body"].read().decode())      

Gestisci la tua implementazione

Pulizia delle risorse

Elimina la distribuzione JumpStart del modello quando non è più necessaria.

!kubectl delete JumpStartModel $model_id -n $cluster_namespace      

Risoluzione dei problemi

Usa questi comandi di debug se la distribuzione non funziona come previsto.