Nozioni di base

Questa guida mostra come distribuire modelli Amazon Nova personalizzati su endpoint SageMaker in tempo reale, configurare i parametri di inferenza e richiamare i modelli per i test.

Prerequisiti

Di seguito sono riportati i prerequisiti per distribuire i modelli Amazon Nova sull' SageMaker inferenza:

• Crea un account Account AWS : se non ne hai già uno, consulta Creazione di un account. AWS

• Autorizzazioni IAM richieste: assicurati che il tuo utente o ruolo IAM abbia le seguenti politiche gestite allegate:

  • AmazonSageMakerFullAccess

  • AmazonS3FullAccess

• SDKs/CLI Versioni richieste: le seguenti versioni dell'SDK sono state testate e convalidate con modelli Amazon Nova sull' SageMaker inferenza:

  • SageMaker Python SDK v3.0.0+ () per un approccio API basato sulle risorse sagemaker>=3.0.0

  • Boto3 versione 1.35.0+ () per chiamate API dirette. boto3>=1.35.0 Gli esempi di questa guida utilizzano questo approccio.

• Aumento della quota di servizio: richiedi un aumento della quota di SageMaker servizio Amazon per il tipo di istanza ML che intendi utilizzare per il tuo endpoint SageMaker Inference (ad esempio,ml.p5.48xlarge for endpoint usage). Per una lista di tipi di istanze supportate, consulta Modelli e istanze supportati. Per richiedere un aumento, consulta Richiedere un aumento della quota. Per informazioni sulle quote delle SageMaker istanze, consulta SageMaker endpoint e quote.

Passaggio 1: configurare le credenziali AWS

Configura AWS le tue credenziali utilizzando uno dei seguenti metodi:

Opzione 1: AWS CLI (consigliata)

aws configure

Inserisci la chiave di AWS accesso, la chiave segreta e la regione predefinita quando richiesto.

Opzione 2: file di AWS credenziali

Crea o modifica~/.aws/credentials:

[default]
aws_access_key_id = YOUR_ACCESS_KEY
aws_secret_access_key = YOUR_SECRET_KEY

Opzione 3: variabili di ambiente

export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key

Nota

Per ulteriori informazioni sulle AWS credenziali, consulta Configurazione e impostazioni dei file di credenziali.

Inizializza i client AWS

Crea uno script o un notebook Python con il seguente codice per inizializzare l' AWS SDK e verificare le tue credenziali:

import boto3

# AWS Configuration - Update these for your environment
REGION = "us-east-1"  # Supported regions: us-east-1, us-west-2
AWS_ACCOUNT_ID = "YOUR_ACCOUNT_ID"  # Replace with your AWS account ID

# Initialize AWS clients using default credential chain
sagemaker = boto3.client('sagemaker', region_name=REGION)
sts = boto3.client('sts')

# Verify credentials
try:
    identity = sts.get_caller_identity()
    print(f"Successfully authenticated to AWS Account: {identity['Account']}")
    
    if identity['Account'] != AWS_ACCOUNT_ID:
        print(f"Warning: Connected to account {identity['Account']}, expected {AWS_ACCOUNT_ID}")

except Exception as e:
    print(f"Failed to authenticate: {e}")
    print("Please verify your credentials are configured correctly.")

Se l'autenticazione ha esito positivo, dovresti vedere un output che conferma l'ID del tuo account. AWS

Fase 2: Creare un ruolo di SageMaker esecuzione

Un ruolo di SageMaker esecuzione è un ruolo IAM che concede SageMaker le autorizzazioni per accedere a AWS risorse per tuo conto, come i bucket Amazon S3 per gli artefatti del modello e per la registrazione. CloudWatch

Creazione del ruolo di esecuzione

Nota

La creazione di ruoli IAM richiede iam:CreateRole e iam:AttachRolePolicy autorizzazioni. Assicurati che il tuo utente o ruolo IAM disponga di queste autorizzazioni prima di procedere.

Il codice seguente crea un ruolo IAM con le autorizzazioni necessarie per la distribuzione di modelli personalizzati Amazon Nova:

import json

# Create SageMaker Execution Role
role_name = f"SageMakerInference-ExecutionRole-{AWS_ACCOUNT_ID}"

trust_policy = {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {"Service": "sagemaker.amazonaws.com"},
            "Action": "sts:AssumeRole"
        }
    ]
}

iam = boto3.client('iam', region_name=REGION)

# Create the role
role_response = iam.create_role(
    RoleName=role_name,
    AssumeRolePolicyDocument=json.dumps(trust_policy),
    Description='SageMaker execution role with S3 and SageMaker access'
)

# Attach required policies
iam.attach_role_policy(
    RoleName=role_name,
    PolicyArn='arn:aws:iam::aws:policy/AmazonSageMakerFullAccess'
)

iam.attach_role_policy(
    RoleName=role_name,
    PolicyArn='arn:aws:iam::aws:policy/AmazonS3FullAccess'
)

SAGEMAKER_EXECUTION_ROLE_ARN = role_response['Role']['Arn']
print(f"Created SageMaker execution role: {SAGEMAKER_EXECUTION_ROLE_ARN}")

Utilizzo di un ruolo di esecuzione esistente (facoltativo)

Se disponi già di un ruolo di SageMaker esecuzione, puoi utilizzarlo al suo posto:

# Replace with your existing role ARN
SAGEMAKER_EXECUTION_ROLE_ARN = "arn:aws:iam::YOUR_ACCOUNT_ID:role/YOUR_EXISTING_ROLE_NAME"

Per trovare SageMaker i ruoli esistenti nel tuo account:

iam = boto3.client('iam', region_name=REGION)
response = iam.list_roles()
sagemaker_roles = [role for role in response['Roles'] if 'SageMaker' in role['RoleName']]
for role in sagemaker_roles:
    print(f"{role['RoleName']}: {role['Arn']}")

Importante

Il ruolo di esecuzione deve avere rapporti di fiducia sagemaker.amazonaws.com e autorizzazioni per accedere ad Amazon S3 SageMaker e alle risorse.

Per ulteriori informazioni sui ruoli di SageMaker esecuzione, consulta SageMaker Ruoli.

Fase 3: Configurazione dei parametri del modello

Configura i parametri di distribuzione per il tuo modello Amazon Nova. Queste impostazioni controllano il comportamento del modello, l'allocazione delle risorse e le caratteristiche di inferenza. Per un elenco dei tipi di istanza supportati e dei valori CONTEXT_LENGTH e MAX_CONCURRENCY supportati per ciascuno, consulta. Modelli e istanze supportati

Parametri obbligatori

• IMAGE: l'URI dell'immagine del contenitore Docker per il contenitore di inferenza Amazon Nova. Questo verrà fornito da. AWS

• CONTEXT_LENGTH: lunghezza del contesto del modello.

• MAX_CONCURRENCY: numero massimo di sequenze per iterazione; imposta il limite del numero di richieste utente individuali (prompt) che possono essere elaborate contemporaneamente all'interno di un singolo batch sulla GPU. Intervallo: numero intero maggiore di 0.

Parametri di generazione opzionali

• DEFAULT_TEMPERATURE: controlla la casualità durante la generazione. Intervallo: da 0,0 a 2,0 (0,0 = deterministico, più alto = più casuale).

• DEFAULT_TOP_P: soglia di campionamento del nucleo per la selezione dei token. Intervallo: da 1e-10 a 1,0.

• DEFAULT_TOP_K: Limita la selezione dei token ai primi K token più probabili. Intervallo: intero -1 o superiore (-1 = nessun limite).

• DEFAULT_MAX_NEW_TOKENS: numero massimo di token da generare in risposta (ovvero numero massimo di token di output). Intervallo: numero intero 1 o superiore.

• DEFAULT_LOGPROBS: numero di probabilità di log da restituire per token. Intervallo: numero intero compreso tra 1 e 20.

Configura la tua implementazione

# AWS Configuration
REGION = "us-east-1"  # Must match region from Step 1

# ECR Account mapping by region
ECR_ACCOUNT_MAP = {
    "us-east-1": "708977205387",
    "us-west-2": "176779409107"
}

# Container Image
IMAGE = f"{ECR_ACCOUNT_MAP[REGION]}.dkr.ecr.{REGION}.amazonaws.com/nova-inference-repo:SM-Inference-latest"
print(f"IMAGE = {IMAGE}")

# Model Parameters
CONTEXT_LENGTH = "8000"        # Maximum total context length
MAX_CONCURRENCY = "16"         # Maximum concurrent sequences

# Optional: Default generation parameters (uncomment to use)
DEFAULT_TEMPERATURE = "0.0"   # Deterministic output
DEFAULT_TOP_P = "1.0"         # Consider all tokens
# DEFAULT_TOP_K = "50"        # Uncomment to limit to top 50 tokens
# DEFAULT_MAX_NEW_TOKENS = "2048"  # Uncomment to set max output tokens
# DEFAULT_LOGPROBS = "1"      # Uncomment to enable log probabilities

# Build environment variables for the container
environment = {
    'CONTEXT_LENGTH': CONTEXT_LENGTH,
    'MAX_CONCURRENCY': MAX_CONCURRENCY,
}

# Add optional parameters if defined
if 'DEFAULT_TEMPERATURE' in globals():
    environment['DEFAULT_TEMPERATURE'] = DEFAULT_TEMPERATURE
if 'DEFAULT_TOP_P' in globals():
    environment['DEFAULT_TOP_P'] = DEFAULT_TOP_P
if 'DEFAULT_TOP_K' in globals():
    environment['DEFAULT_TOP_K'] = DEFAULT_TOP_K
if 'DEFAULT_MAX_NEW_TOKENS' in globals():
    environment['DEFAULT_MAX_NEW_TOKENS'] = DEFAULT_MAX_NEW_TOKENS
if 'DEFAULT_LOGPROBS' in globals():
    environment['DEFAULT_LOGPROBS'] = DEFAULT_LOGPROBS

print("Environment configuration:")
for key, value in environment.items():
    print(f"  {key}: {value}")

Configura i parametri specifici della distribuzione

Ora configura i parametri specifici per la distribuzione del tuo modello Amazon Nova, inclusa la posizione degli artefatti del modello e la selezione del tipo di istanza.

Imposta l'identificatore di distribuzione

# Deployment identifier - use a descriptive name for your use case
JOB_NAME = "my-nova-deployment"

Specificare la posizione degli artefatti del modello

Fornisci l'URI Amazon S3 in cui sono archiviati gli artefatti del modello Amazon Nova addestrati. Questo dovrebbe essere il luogo di output del processo di formazione o messa a punto del modello.

# S3 location of your trained Nova model artifacts
# Replace with your model's S3 URI - must end with /
MODEL_S3_LOCATION = "s3://your-bucket-name/path/to/model/artifacts/"

Seleziona la variante del modello e il tipo di istanza

# Configure model variant and instance type
TESTCASE = {
    "model": "micro",              # Options: micro, lite, lite2
    "instance": "ml.g5.12xlarge"   # Refer to "Supported models and instances" section
}

# Generate resource names
INSTANCE_TYPE = TESTCASE["instance"]
MODEL_NAME = JOB_NAME + "-" + TESTCASE["model"] + "-" + INSTANCE_TYPE.replace(".", "-")
ENDPOINT_CONFIG_NAME = MODEL_NAME + "-Config"
ENDPOINT_NAME = MODEL_NAME + "-Endpoint"

print(f"Model Name: {MODEL_NAME}")
print(f"Endpoint Config: {ENDPOINT_CONFIG_NAME}")
print(f"Endpoint Name: {ENDPOINT_NAME}")

Convenzioni di denominazione

Il codice genera automaticamente nomi coerenti per le AWS risorse:

• Nome del modello: {JOB_NAME}-{model}-{instance-type}

• Config dell'endpoint: {MODEL_NAME}-Config

• Nome dell'endpoint: {MODEL_NAME}-Endpoint

Fase 4: Creare la configurazione SageMaker del modello e dell'endpoint

In questa fase, creerai due risorse essenziali: un oggetto SageMaker modello che fa riferimento agli artefatti del modello Amazon Nova e una configurazione dell'endpoint che definisce come verrà distribuito il modello.

SageMaker Modello: un oggetto modello che racchiude l'immagine del contenitore di inferenza, la posizione degli artefatti del modello e la configurazione dell'ambiente. Si tratta di una risorsa riutilizzabile che può essere distribuita su più endpoint.

Configurazione degli endpoint: definisce le impostazioni dell'infrastruttura per la distribuzione, inclusi il tipo di istanza, il numero di istanze e le varianti del modello. Ciò consente di gestire le impostazioni di distribuzione separatamente dal modello stesso.

Crea il SageMaker modello

Il codice seguente crea un SageMaker modello che fa riferimento agli artefatti del modello Amazon Nova:

try:
    model_response = sagemaker.create_model(
        ModelName=MODEL_NAME,
        PrimaryContainer={
            'Image': IMAGE,
            'ModelDataSource': {
                'S3DataSource': {
                    'S3Uri': MODEL_S3_LOCATION,
                    'S3DataType': 'S3Prefix',
                    'CompressionType': 'None'
                }
            },
            'Environment': environment
        },
        ExecutionRoleArn=SAGEMAKER_EXECUTION_ROLE_ARN,
        EnableNetworkIsolation=True
    )
    print("Model created successfully!")
    print(f"Model ARN: {model_response['ModelArn']}")
    
except sagemaker.exceptions.ClientError as e:
    print(f"Error creating model: {e}")

Parametri chiave:

• ModelName: identificatore univoco per il tuo modello

• Image: URI dell'immagine del contenitore Docker per l'inferenza di Amazon Nova

• ModelDataSource: posizione in Amazon S3 degli artefatti del modello

• Environment: variabili di ambiente configurate nella fase 3

• ExecutionRoleArn: ruolo IAM dalla Fase 2

• EnableNetworkIsolation: Impostato su True per una maggiore sicurezza (impedisce al container di effettuare chiamate di rete in uscita)

Crea la configurazione dell'endpoint

Quindi, crea una configurazione dell'endpoint che definisca la tua infrastruttura di distribuzione:

# Create Endpoint Configuration
try:
    production_variant = {
        'VariantName': 'primary',
        'ModelName': MODEL_NAME,
        'InitialInstanceCount': 1,
        'InstanceType': INSTANCE_TYPE,
    }
    
    config_response = sagemaker.create_endpoint_config(
        EndpointConfigName=ENDPOINT_CONFIG_NAME,
        ProductionVariants=[production_variant]
    )
    print("Endpoint configuration created successfully!")
    print(f"Config ARN: {config_response['EndpointConfigArn']}")
    
except sagemaker.exceptions.ClientError as e:
    print(f"Error creating endpoint configuration: {e}")

Parametri chiave:

• VariantName: identificatore per questa variante del modello (usa «primario» per le implementazioni a modello singolo)

• ModelName: fa riferimento al modello creato sopra

• InitialInstanceCount: Numero di istanze da implementare (inizia con 1, scala in seguito se necessario)

• InstanceType: tipo di istanza ML selezionato nel passaggio 3

Verifica la creazione delle risorse

Puoi verificare che le tue risorse siano state create correttamente:

# Describe the model
model_info = sagemaker.describe_model(ModelName=MODEL_NAME)
print(f"Model Status: {model_info['ModelName']} created")

# Describe the endpoint configuration
config_info = sagemaker.describe_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
print(f"Endpoint Config Status: {config_info['EndpointConfigName']} created")

Fase 5: Implementazione dell'endpoint

Il passaggio successivo consiste nell'implementare il modello Amazon Nova creando un endpoint SageMaker in tempo reale. Questo endpoint ospiterà il tuo modello e fornirà un endpoint HTTPS sicuro per effettuare richieste di inferenza.

La creazione degli endpoint richiede in genere 15-30 minuti per il AWS provisioning dell'infrastruttura, il download degli artefatti del modello e l'inizializzazione del contenitore di inferenza.

Creare l'endpoint

import time

try:
    endpoint_response = sagemaker.create_endpoint(
        EndpointName=ENDPOINT_NAME,
        EndpointConfigName=ENDPOINT_CONFIG_NAME
    )
    print("Endpoint creation initiated successfully!")
    print(f"Endpoint ARN: {endpoint_response['EndpointArn']}")
except Exception as e:
    print(f"Error creating endpoint: {e}")

Monitora la creazione degli endpoint

Il codice seguente controlla lo stato dell'endpoint fino al completamento della distribuzione:

# Monitor endpoint creation progress
print("Waiting for endpoint creation to complete...")
print("This typically takes 15-30 minutes...\n")

while True:
    try:
        response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
        status = response['EndpointStatus']
        
        if status == 'Creating':
            print(f"⏳ Status: {status} - Provisioning infrastructure and loading model...")
        elif status == 'InService':
            print(f"✅ Status: {status}")
            print("\nEndpoint creation completed successfully!")
            print(f"Endpoint Name: {ENDPOINT_NAME}")
            print(f"Endpoint ARN: {response['EndpointArn']}")
            break
        elif status == 'Failed':
            print(f"❌ Status: {status}")
            print(f"Failure Reason: {response.get('FailureReason', 'Unknown')}")
            print("\nFull response:")
            print(response)
            break
        else:
            print(f"Status: {status}")
        
    except Exception as e:
        print(f"Error checking endpoint status: {e}")
        break
    
    time.sleep(30)  # Check every 30 seconds

Verifica che l'endpoint sia pronto

Una volta che l'endpoint è pronto InService, puoi verificarne la configurazione:

# Get detailed endpoint information
endpoint_info = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)

print("\n=== Endpoint Details ===")
print(f"Endpoint Name: {endpoint_info['EndpointName']}")
print(f"Endpoint ARN: {endpoint_info['EndpointArn']}")
print(f"Status: {endpoint_info['EndpointStatus']}")
print(f"Creation Time: {endpoint_info['CreationTime']}")
print(f"Last Modified: {endpoint_info['LastModifiedTime']}")

# Get endpoint config for instance type details
endpoint_config_name = endpoint_info['EndpointConfigName']
endpoint_config = sagemaker.describe_endpoint_config(EndpointConfigName=endpoint_config_name)

# Display production variant details
for variant in endpoint_info['ProductionVariants']:
    print(f"\nProduction Variant: {variant['VariantName']}")
    print(f"  Current Instance Count: {variant['CurrentInstanceCount']}")
    print(f"  Desired Instance Count: {variant['DesiredInstanceCount']}")
    # Get instance type from endpoint config
    for config_variant in endpoint_config['ProductionVariants']:
        if config_variant['VariantName'] == variant['VariantName']:
            print(f"  Instance Type: {config_variant['InstanceType']}")
            break

Risoluzione degli errori di creazione degli endpoint

Motivi di errore comuni:

• Capacità insufficiente: il tipo di istanza richiesto non è disponibile nella tua regione

  • Soluzione: prova un tipo di istanza diverso o richiedi un aumento della quota

• Autorizzazioni IAM: il ruolo di esecuzione non dispone delle autorizzazioni necessarie

  • Soluzione: verifica che il ruolo abbia accesso agli artefatti del modello Amazon S3 e alle autorizzazioni necessarie SageMaker

• Elementi del modello non trovati: l'URI di Amazon S3 è errato o inaccessibile

  • Soluzione: verifica l'URI di Amazon S3 e controlla le autorizzazioni del bucket, assicurati di trovarti nella regione corretta

• Limiti di risorse: limiti di account superati per endpoint o istanze

  • Soluzione: richiedere un aumento della quota di servizio tramite Service Quotas o Support AWS

Nota

Se è necessario eliminare un endpoint guasto e ricominciare da capo:

sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)

Passaggio 6: richiamare l'endpoint

Una volta creato l'endpoint InService, puoi inviare richieste di inferenza per generare previsioni dal tuo modello Amazon Nova. SageMaker supporta endpoint sincroni (in tempo reale con modalità streaming/non streaming) ed endpoint asincroni (basati su Amazon S3 per l'elaborazione in batch).

Configura il runtime client

Crea un client SageMaker Runtime con le impostazioni di timeout appropriate:

import json
import boto3
import botocore
from botocore.exceptions import ClientError

# Configure client with appropriate timeouts
config = botocore.config.Config(
    read_timeout=120,      # Maximum time to wait for response
    connect_timeout=10,    # Maximum time to establish connection
    retries={'max_attempts': 3}  # Number of retry attempts
)

# Create SageMaker Runtime client
runtime_client = boto3.client('sagemaker-runtime', config=config, region_name=REGION)

Crea una funzione di inferenza universale

La seguente funzione gestisce sia le richieste in streaming che quelle non in streaming:

def invoke_nova_endpoint(request_body):
    """
    Invoke Nova endpoint with automatic streaming detection.
    
    Args:
        request_body (dict): Request payload containing prompt and parameters
    
    Returns:
        dict: Response from the model (for non-streaming requests)
        None: For streaming requests (prints output directly)
    """
    body = json.dumps(request_body)
    is_streaming = request_body.get("stream", False)
    
    try:
        print(f"Invoking endpoint ({'streaming' if is_streaming else 'non-streaming'})...")
        
        if is_streaming:
            response = runtime_client.invoke_endpoint_with_response_stream(
                EndpointName=ENDPOINT_NAME,
                ContentType='application/json',
                Body=body
            )
            
            event_stream = response['Body']
            for event in event_stream:
                if 'PayloadPart' in event:
                    chunk = event['PayloadPart']
                    if 'Bytes' in chunk:
                        data = chunk['Bytes'].decode()
                        print("Chunk:", data)
        else:
            # Non-streaming inference
            response = runtime_client.invoke_endpoint(
                EndpointName=ENDPOINT_NAME,
                ContentType='application/json',
                Accept='application/json',
                Body=body
            )
            
            response_body = response['Body'].read().decode('utf-8')
            result = json.loads(response_body)
            print("✅ Response received successfully")
            return result
    
    except ClientError as e:
        error_code = e.response['Error']['Code']
        error_message = e.response['Error']['Message']
        print(f"❌ AWS Error: {error_code} - {error_message}")
    except Exception as e:
        print(f"❌ Unexpected error: {str(e)}")

Esempio 1: completamento della chat senza streaming

Usa il formato di chat per le interazioni conversazionali:

# Non-streaming chat request
chat_request = {
    "messages": [
        {"role": "user", "content": "Hello! How are you?"}
    ],
    "max_tokens": 100,
    "max_completion_tokens": 100,  # Alternative to max_tokens
    "stream": False,
    "temperature": 0.7,
    "top_p": 0.9,
    "top_k": 50,
    "logprobs": True,
    "top_logprobs": 3,
    "allowed_token_ids": None,  # List of allowed token IDs
    "truncate_prompt_tokens": None,  # Truncate prompt to this many tokens
    "stream_options": None
}

response = invoke_nova_endpoint(chat_request)

Esempio di risposta:

{
    "id": "chatcmpl-123456",
    "object": "chat.completion",
    "created": 1234567890,
    "model": "default",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "Hello! I'm doing well, thank you for asking. I'm here and ready to help you with any questions or tasks you might have. How can I assist you today?"
            },
            "logprobs": {
                "content": [
                    {
                        "token": "Hello",
                        "logprob": -0.123,
                        "top_logprobs": [
                            {"token": "Hello", "logprob": -0.123},
                            {"token": "Hi", "logprob": -2.456},
                            {"token": "Hey", "logprob": -3.789}
                        ]
                    }
                    # Additional tokens...
                ]
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 12,
        "completion_tokens": 28,
        "total_tokens": 40
    }
}

Esempio 2: semplice completamento del testo

Usa il formato di completamento per una semplice generazione di testo:

# Simple completion request
completion_request = {
    "prompt": "The capital of France is",
    "max_tokens": 50,
    "stream": False,
    "temperature": 0.0,
    "top_p": 1.0,
    "top_k": -1,  # -1 means no limit
    "logprobs": 3,  # Number of log probabilities to return
    "allowed_token_ids": None,  # List of allowed token IDs
    "truncate_prompt_tokens": None,  # Truncate prompt to this many tokens
    "stream_options": None
}

response = invoke_nova_endpoint(completion_request)

Esempio di risposta:

{
    "id": "cmpl-789012",
    "object": "text_completion",
    "created": 1234567890,
    "model": "default",
    "choices": [
        {
            "text": " Paris.",
            "index": 0,
            "logprobs": {
                "tokens": [" Paris", "."],
                "token_logprobs": [-0.001, -0.002],
                "top_logprobs": [
                    {" Paris": -0.001, " London": -5.234, " Rome": -6.789},
                    {".": -0.002, ",": -4.567, "!": -7.890}
                ]
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 6,
        "completion_tokens": 2,
        "total_tokens": 8
    }
}

Esempio 3: completamento della chat in streaming

# Streaming chat request
streaming_request = {
    "messages": [
        {"role": "user", "content": "Tell me a short story about a robot"}
    ],
    "max_tokens": 200,
    "stream": True,
    "temperature": 0.7,
    "top_p": 0.95,
    "top_k": 40,
    "logprobs": True,
    "top_logprobs": 2,
    "stream_options": {"include_usage": True}
}

invoke_nova_endpoint(streaming_request)

Esempio di output in streaming:

Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}],"prompt_token_ids":null}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" Once"},"logprobs":{"content":[{"token":"\u2581Once","logprob":-0.6078429222106934,"bytes":[226,150,129,79,110,99,101],"top_logprobs":[{"token":"\u2581Once","logprob":-0.6078429222106934,"bytes":[226,150,129,79,110,99,101]},{"token":"\u2581In","logprob":-0.7864127159118652,"bytes":[226,150,129,73,110]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" upon"},"logprobs":{"content":[{"token":"\u2581upon","logprob":-0.0012345,"bytes":[226,150,129,117,112,111,110],"top_logprobs":[{"token":"\u2581upon","logprob":-0.0012345,"bytes":[226,150,129,117,112,111,110]},{"token":"\u2581a","logprob":-6.789,"bytes":[226,150,129,97]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" a"},"logprobs":{"content":[{"token":"\u2581a","logprob":-0.0001234,"bytes":[226,150,129,97],"top_logprobs":[{"token":"\u2581a","logprob":-0.0001234,"bytes":[226,150,129,97]},{"token":"\u2581time","logprob":-9.123,"bytes":[226,150,129,116,105,109,101]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" time"},"logprobs":{"content":[{"token":"\u2581time","logprob":-0.0023456,"bytes":[226,150,129,116,105,109,101],"top_logprobs":[{"token":"\u2581time","logprob":-0.0023456,"bytes":[226,150,129,116,105,109,101]},{"token":",","logprob":-6.012,"bytes":[44]}]}]},"finish_reason":null,"token_ids":null}]}

# Additional chunks...

Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}],"usage":{"prompt_tokens":15,"completion_tokens":87,"total_tokens":102}}
Chunk: data: [DONE]

Esempio 4: completamento della chat multimodale

Usa il formato multimodale per l'immissione di immagini e testo:

# Multimodal chat request (if supported by your model)
multimodal_request = {
    "messages": [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}}
            ]
        }
    ],
    "max_tokens": 150,
    "temperature": 0.3,
    "top_p": 0.8,
    "stream": False
}

response = invoke_nova_endpoint(multimodal_request)

Esempio di risposta:

{
    "id": "chatcmpl-345678",
    "object": "chat.completion",
    "created": 1234567890,
    "model": "default",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "The image shows..."
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 1250,
        "completion_tokens": 45,
        "total_tokens": 1295
    }
}

Fase 7: Pulizia delle risorse (opzionale)

Per evitare di incorrere in addebiti inutili, elimina le AWS risorse che hai creato durante questo tutorial. SageMaker Gli endpoint sono soggetti a costi durante il loro funzionamento, anche se non state effettuando attivamente richieste di inferenza.

Importante

L'eliminazione delle risorse è permanente e non può essere annullata. Assicurati di non aver più bisogno di queste risorse prima di procedere.

Eliminare l'endpoint

import boto3

# Initialize SageMaker client
sagemaker = boto3.client('sagemaker', region_name=REGION)

try:
    print("Deleting endpoint...")
    sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
    print(f"✅ Endpoint '{ENDPOINT_NAME}' deletion initiated")
    print("Charges will stop once deletion completes (typically 2-5 minutes)")
except Exception as e:
    print(f"❌ Error deleting endpoint: {e}")

Nota

L'eliminazione dell'endpoint è asincrona. È possibile monitorare lo stato di eliminazione:

import time

print("Monitoring endpoint deletion...")
while True:
    try:
        response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
        status = response['EndpointStatus']
        print(f"Status: {status}")
        time.sleep(10)
    except sagemaker.exceptions.ClientError as e:
        if e.response['Error']['Code'] == 'ValidationException':
            print("✅ Endpoint successfully deleted")
            break
        else:
            print(f"Error: {e}")
            break

Eliminare la configurazione dell'endpoint

Dopo l'eliminazione dell'endpoint, rimuovi la configurazione dell'endpoint:

try:
    print("Deleting endpoint configuration...")
    sagemaker.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
    print(f"✅ Endpoint configuration '{ENDPOINT_CONFIG_NAME}' deleted")
except Exception as e:
    print(f"❌ Error deleting endpoint configuration: {e}")

Eliminare il modello

Rimuovi l'oggetto SageMaker del modello:

try:
    print("Deleting model...")
    sagemaker.delete_model(ModelName=MODEL_NAME)
    print(f"✅ Model '{MODEL_NAME}' deleted")
except Exception as e:
    print(f"❌ Error deleting model: {e}")