Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Implemente modelos JumpStart utilizando kubectl

Los siguientes pasos muestran cómo implementar un JumpStart modelo en un HyperPod clúster mediante kubectl.

Las siguientes instrucciones contienen celdas de código y comandos diseñados para ejecutarse en un entorno de Jupyter Notebook, como Amazon SageMaker Studio o SageMaker Notebook Instances. Cada bloque de código representa una celda de bloc de notas que debe ejecutarse secuencialmente. Los elementos interactivos, incluidas las tablas de descubrimiento de modelos y los comandos de supervisión del estado, están optimizados para la interfaz del portátil y es posible que no funcionen correctamente en otros entornos. Asegúrese de tener acceso a un entorno de portátil con los AWS permisos necesarios antes de continuar.

Requisitos previos

Asegúrese de haber configurado las capacidades de inferencia en sus SageMaker HyperPod clústeres de Amazon. Para obtener más información, consulte Configuración de los clústeres para la implementación de modelos HyperPod .

Ajustes y configuración

Seleccione su región

Elija la región en la que desea implementar el HyperPod clúster y dónde desea ejecutar las cargas de trabajo de inferencia. También puede añadir otras personalizaciones 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)        

Elija su modelo y clúster

Configure el nombre del bucket de S3

Configure los nombres de los buckets de S3 para los certificados. Este depósito debe tener una carpeta llamada «certificados» en la que se cargarán los certificados. El depósito también debe estar en la misma región definida anteriormente.

# 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       

Implementar el modelo

Actualice la configuración de Kubernetes e implemente su modelo

Supervise el estado de la implementación de su modelo

Invoque el punto final de su modelo

Puede recuperar mediante programación cargas útiles de ejemplo del objeto. 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())      

Gestione su despliegue

Eliminar recursos

Elimine la implementación de su JumpStart modelo cuando ya no la necesite.

!kubectl delete JumpStartModel $model_id -n $cluster_namespace      

Solución de problemas

Utilice estos comandos de depuración si su implementación no funciona según lo esperado.