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à. # Nozioni di base 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](https://docs.aws.amazon.com//sagemaker/latest/dg/gs-set-up.html#sign-up-for-aws) 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\$1 () per un approccio API basato sulle risorse `sagemaker>=3.0.0` + Boto3 versione 1.35.0\$1 () 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](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported). Per richiedere un aumento, consulta [Richiedere un aumento della](https://docs.aws.amazon.com//servicequotas/latest/userguide/request-quota-increase.html) quota. Per informazioni sulle quote delle SageMaker istanze, consulta [SageMaker endpoint](https://docs.aws.amazon.com//general/latest/gr/sagemaker.html) 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](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-files.html). **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.](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html) ## 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\$1LENGTH e MAX\$1CONCURRENCY supportati per ciascuno, consulta. [Modelli e istanze supportati](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported) **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 = "16000" # Maximum total context length MAX_CONCURRENCY = "2" # 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": "lite2", # Options: micro, lite, lite2 "instance": "ml.p5.48xlarge" # 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, "reasoning_effort": "low", # Options: "low", "high" "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, "reasoning_effort": "high", # For more detailed reasoning "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":"","reasoning_content":null},"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","reasoning_content":null},"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","reasoning_content":null},"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","reasoning_content":null},"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","reasoning_content":null},"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}") ```