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à. # SageMaker Inferenza SageMaker Inferenza I modelli Amazon Nova personalizzati sono ora disponibili in SageMaker inferenza. Con Amazon Nova attivo SageMaker, puoi iniziare a ottenere previsioni o inferenze dai tuoi modelli Amazon Nova personalizzati addestrati. SageMaker offre un'ampia selezione di infrastrutture ML e opzioni di implementazione dei modelli per aiutarti a soddisfare tutte le tue esigenze di inferenza ML. Con SageMaker l'inferenza, è possibile scalare l'implementazione dei modelli, gestirli in modo più efficace in produzione e ridurre il carico operativo. SageMaker offre diverse opzioni di inferenza, come endpoint in tempo reale per ottenere inferenze a bassa latenza ed endpoint asincroni per batch di richieste. Sfruttando l’opzione di inferenza appropriata per il tuo caso d’uso, puoi garantire un’implementazione e un’inferenza efficienti del modello. [Per ulteriori informazioni sull'inferenza, consulta Implementare modelli per l'inferenza. SageMaker ](https://docs.aws.amazon.com//sagemaker/latest/dg/deploy-model.html) **Importante** Nell'inferenza sono supportati solo i modelli personalizzati completi e i modelli uniti con LoRA. SageMaker Per i modelli LoRa e i modelli base non uniti, usa Amazon Bedrock. ## Funzionalità Le seguenti funzionalità sono disponibili per i modelli Amazon Nova sull' SageMaker inferenza: **Funzionalità del modello** + Generazione di testo **Implementazione e scalabilità** + Endpoint in tempo reale con selezione personalizzata delle istanze + Auto Scaling: regola automaticamente la capacità in base ai modelli di traffico per ottimizzare i costi e l'utilizzo della GPU. Per ulteriori informazioni, consulta [Automately Scale Amazon SageMaker Models](https://docs.aws.amazon.com//sagemaker/latest/dg/endpoint-auto-scaling.html). + Supporto API di streaming per la generazione di token in tempo reale **Monitoraggio e ottimizzazione** + CloudWatch Integrazione con Amazon per il monitoraggio e gli avvisi + Disponibilità Ottimizzazione della latenza con riconoscimento della zona tramite configurazione VPC **Strumenti di sviluppo** + AWS CLI supporto: per ulteriori informazioni, consulta [AWS CLI Command Reference](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/) for. SageMaker + Integrazione con i notebook tramite supporto SDK ## Modelli e istanze supportati Quando crei gli endpoint di SageMaker inferenza, puoi impostare due variabili di ambiente per configurare la distribuzione: e. `CONTEXT_LENGTH` `MAX_CONCURRENCY` + `CONTEXT_LENGTH`— Lunghezza totale massima del token (ingresso\$1output) per richiesta + `MAX_CONCURRENCY`— Numero massimo di richieste simultanee che l'endpoint servirà La tabella seguente elenca i modelli, i tipi di istanza e le configurazioni supportate di Amazon Nova supportati. I valori MAX\$1CONCURRENCY rappresentano la concorrenza massima supportata per ogni impostazione CONTEXT\$1LENGTH: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/nova/latest/nova2-userguide/nova-model-sagemaker-inference.html) **Nota** I valori MAX\$1CONCURRENCY mostrati sono limiti superiori per ogni impostazione CONTEXT\$1LENGTH. È possibile utilizzare lunghezze di contesto inferiori con la stessa concorrenza, ma il superamento di questi valori impedirà la creazione dell'endpoint. SageMaker Ad esempio, su Amazon Nova Micro con un ml.g5.12xlarge: `CONTEXT_LENGTH=2000``MAX_CONCURRENCY=32`, → Valido `CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=32` → Rifiutato (il limite di concorrenza è 16 alla lunghezza del contesto 8000) `CONTEXT_LENGTH=8000`, → Valido `MAX_CONCURRENCY=4` `CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=16` → Valido `CONTEXT_LENGTH=10000`→ Rifiutato (la lunghezza massima del contesto è 8000 in questa istanza) ## Regioni supportate AWS La tabella seguente elenca le AWS regioni in cui i modelli Amazon Nova sono disponibili in SageMaker inferenza: **** | Nome della regione | Codice regione | Disponibilità | | --- | --- | --- | | Stati Uniti orientali (Virginia settentrionale) | us-east-1 | Disponibilità | | Stati Uniti occidentali (Oregon) | us-west-2 | Disponibilità | ## Immagini dei container supportate La tabella seguente elenca l'immagine del contenitore URIs per i modelli Amazon Nova sull' SageMaker inferenza per regione. Sono disponibili due tag di immagine per ogni regione: un tag con versione (`v1.0.0`) e un tag più recente (`SM-Inference-latest`). Per le implementazioni di produzione, consigliamo di utilizzare il tag versioned. **** | Region | Immagine del contenitore URIs | | --- | --- | | us-east-1 | 708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-inference-repo:SM-Inference-latest | | us-west-2 | 176779409107.dkr.ecr.us-west-2.amazonaws.com/nova-inference-repo:SM-Inference-latest | ## Best practice Per le migliori pratiche sulla distribuzione e la gestione dei modelli su SageMaker, consulta [Best Practices for SageMaker](https://docs.aws.amazon.com//sagemaker/latest/dg/best-practices.html). ## Supporto Per problemi e supporto con i modelli Amazon Nova sull' SageMaker inferenza, contatta l' AWS assistenza tramite la console o il tuo AWS account manager. **Topics** + [ ## Funzionalità ](#nova-sagemaker-inference-features) + [ ## Modelli e istanze supportati ](#nova-sagemaker-inference-supported) + [ ## Regioni supportate AWS ](#nova-sagemaker-inference-regions) + [ ## Immagini dei container supportate ](#nova-sagemaker-inference-container-images) + [ ## Best practice ](#nova-sagemaker-inference-best-practices) + [ ## Supporto ](#nova-sagemaker-inference-support) + [ # Nozioni di base ](nova-sagemaker-inference-getting-started.md) + [ # Documentazione di riferimento delle API ](nova-sagemaker-inference-api-reference.md) + [ # Valuta i modelli ospitati su SageMaker Inference ](nova-eval-on-sagemaker-inference.md) + [ # Implementazione di modelli Amazon Nova Forge nel rilevamento degli abusi di Amazon SageMaker Inference ](nova-sagemaker-inference-abuse-detection.md) # 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}") ``` # Documentazione di riferimento delle API Guida di riferimento alle API I modelli Amazon Nova SageMaker utilizzano l'API SageMaker Runtime standard per l'inferenza. Per la documentazione completa sull'API, consulta [Testare un modello distribuito](https://docs.aws.amazon.com//sagemaker/latest/dg/realtime-endpoints-test-endpoints.html). ## Richiamata degli endpoint I modelli Amazon Nova SageMaker supportano due metodi di invocazione: + **Richiamata sincrona: utilizza l'[InvokeEndpoint](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)**API per richieste di inferenza in tempo reale e non in streaming. + **Richiamata in streaming: utilizza l'API per le richieste di** inferenza in streaming in tempo reale [InvokeEndpointWithResponseStream](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html). ## Formato della richiesta I modelli Amazon Nova supportano due formati di richiesta: **Formato di completamento della chat** Usa questo formato per le interazioni conversazionali: ``` { "messages": [ {"role": "user", "content": "string"} ], "max_tokens": integer, "max_completion_tokens": integer, "stream": boolean, "temperature": float, "top_p": float, "top_k": integer, "logprobs": boolean, "top_logprobs": integer, "reasoning_effort": "low" | "high", "allowed_token_ids": [integer], "truncate_prompt_tokens": integer, "stream_options": { "include_usage": boolean } } ``` **Formato di completamento del testo** Utilizzate questo formato per una semplice generazione di testo: ``` { "prompt": "string", "max_tokens": integer, "stream": boolean, "temperature": float, "top_p": float, "top_k": integer, "logprobs": integer, "allowed_token_ids": [integer], "truncate_prompt_tokens": integer, "stream_options": { "include_usage": boolean } } ``` **Formato di completamento della chat multimodale** Usa questo formato per inserire immagini e testo: ``` { "messages": [ { "role": "user", "content": [ {"type": "text", "text": "What's in this image?"}, {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}} ] } ], "max_tokens": integer, "temperature": float, "top_p": float, "stream": boolean } ``` **Parametri della richiesta** + `messages`(array): Per il formato di completamento della chat. Matrice di oggetti di messaggio con `role` e `content` campi. Il contenuto può essere una stringa di solo testo o un array per input multimodali. + `prompt`(stringa): Per il formato di completamento del testo. Il testo di input da cui generare. + `max_tokens`(intero): numero massimo di token da generare nella risposta. Intervallo: 1 o superiore. + `max_completion_tokens`(intero): alternativa a max\$1tokens per il completamento della chat. Numero massimo di token di completamento da generare. + `temperature`(float): controlla la casualità nella generazione. Intervallo: da 0,0 a 2,0 (0,0 = deterministico, 2,0 = casualità massima). + `top_p`(float): soglia di campionamento del nucleo. Intervallo: da 1e-10 a 1,0. + `top_k`(numero intero): limita la selezione dei token ai primi K token più probabili. Intervallo: -1 o superiore (-1 = nessun limite). + `stream`(boolean): Indica se trasmettere la risposta in streaming. Impostato su per lo streaming, `true` `false` per il non streaming. + `logprobs`(booleano/intero): per il completamento della chat, usa booleano. Per i completamenti di testo, usa il numero intero per indicare il numero di probabilità di log da restituire. Intervallo: da 1 a 20. + `top_logprobs`(numero intero): numero di token per i quali è più probabile che vengano restituite le probabilità di log (solo per il completamento della chat). + `reasoning_effort`(stringa): Livello di sforzo di ragionamento. Opzioni: «basso», «alto» (completamenti della chat solo per i modelli personalizzati Nova 2 Lite). + `allowed_token_ids`(array): Elenco di token IDs che possono essere generati. Limita l'output ai token specificati. + `truncate_prompt_tokens`(numero intero): Tronca il prompt a questo numero di token se supera il limite. + `stream_options`(oggetto): opzioni per lo streaming delle risposte. Contiene un valore `include_usage` booleano per includere l'utilizzo del token nelle risposte in streaming. ## Formato della risposta Il formato della risposta dipende dal metodo di invocazione e dal tipo di richiesta: **Risposta al completamento della chat (non in streaming)** Per le richieste sincrone di completamento della chat: ``` { "id": "chatcmpl-123e4567-e89b-12d3-a456-426614174000", "object": "chat.completion", "created": 1677652288, "model": "nova-micro-custom", "choices": [ { "index": 0, "message": { "role": "assistant", "content": "Hello! I'm doing well, thank you for asking. How can I help you today?", "refusal": null, "reasoning": null, "reasoning_content": null }, "logprobs": { "content": [ { "token": "Hello", "logprob": -0.31725305, "bytes": [72, 101, 108, 108, 111], "top_logprobs": [ { "token": "Hello", "logprob": -0.31725305, "bytes": [72, 101, 108, 108, 111] }, { "token": "Hi", "logprob": -1.3190403, "bytes": [72, 105] } ] } ] }, "finish_reason": "stop", "stop_reason": null, "token_ids": [9906, 0, 358, 2157, 1049, 11, 1309, 345, 369, 6464, 13] } ], "usage": { "prompt_tokens": 9, "completion_tokens": 12, "total_tokens": 21, "prompt_tokens_details": { "cached_tokens": 0 } }, "prompt_token_ids": [9906, 0, 358] } ``` **Risposta di completamento del testo (non in streaming)** Per le richieste sincrone di completamento del testo: ``` { "id": "cmpl-123e4567-e89b-12d3-a456-426614174000", "object": "text_completion", "created": 1677652288, "model": "nova-micro-custom", "choices": [ { "index": 0, "text": "Paris, the capital and most populous city of France.", "logprobs": { "tokens": ["Paris", ",", " the", " capital"], "token_logprobs": [-0.31725305, -0.07918124, -0.12345678, -0.23456789], "top_logprobs": [ { "Paris": -0.31725305, "London": -1.3190403, "Rome": -2.1234567 }, { ",": -0.07918124, " is": -1.2345678 } ] }, "finish_reason": "stop", "stop_reason": null, "prompt_token_ids": [464, 6864, 315, 4881, 374], "token_ids": [3915, 11, 279, 6864, 323, 1455, 95551, 3363, 315, 4881, 13] } ], "usage": { "prompt_tokens": 5, "completion_tokens": 11, "total_tokens": 16, "prompt_tokens_details": { "cached_tokens": 0 } } } ``` **Completamento della chat, risposta in streaming** Per le richieste di completamento della chat in streaming, le risposte vengono inviate come Server-Sent Events (SSE): ``` data: { "id": "chatcmpl-123e4567-e89b-12d3-a456-426614174000", "object": "chat.completion.chunk", "created": 1677652288, "model": "nova-micro-custom", "choices": [ { "index": 0, "delta": { "role": "assistant", "content": "Hello", "refusal": null, "reasoning": null, "reasoning_content": null }, "logprobs": { "content": [ { "token": "Hello", "logprob": -0.31725305, "bytes": [72, 101, 108, 108, 111], "top_logprobs": [ { "token": "Hello", "logprob": -0.31725305, "bytes": [72, 101, 108, 108, 111] } ] } ] }, "finish_reason": null, "stop_reason": null } ], "usage": null, "prompt_token_ids": null } data: { "id": "chatcmpl-123e4567-e89b-12d3-a456-426614174000", "object": "chat.completion.chunk", "created": 1677652288, "model": "nova-micro-custom", "choices": [ { "index": 0, "delta": { "content": "! I'm" }, "logprobs": null, "finish_reason": null, "stop_reason": null } ], "usage": null } data: { "id": "chatcmpl-123e4567-e89b-12d3-a456-426614174000", "object": "chat.completion.chunk", "created": 1677652288, "model": "nova-micro-custom", "choices": [ { "index": 0, "delta": {}, "finish_reason": "stop", "stop_reason": null } ], "usage": { "prompt_tokens": 9, "completion_tokens": 12, "total_tokens": 21, "prompt_tokens_details": { "cached_tokens": 0 } } } data: [DONE] ``` **Completamento del testo, risposta in streaming** Per le richieste di completamento di testi in streaming: ``` data: { "id": "cmpl-123e4567-e89b-12d3-a456-426614174000", "object": "text_completion", "created": 1677652288, "model": "nova-micro-custom", "choices": [ { "index": 0, "text": "Paris", "logprobs": { "tokens": ["Paris"], "token_logprobs": [-0.31725305], "top_logprobs": [ { "Paris": -0.31725305, "London": -1.3190403 } ] }, "finish_reason": null, "stop_reason": null } ], "usage": null } data: { "id": "cmpl-123e4567-e89b-12d3-a456-426614174000", "object": "text_completion", "created": 1677652288, "model": "nova-micro-custom", "choices": [ { "index": 0, "text": ", the capital", "logprobs": null, "finish_reason": null, "stop_reason": null } ], "usage": null } data: { "id": "cmpl-123e4567-e89b-12d3-a456-426614174000", "object": "text_completion", "created": 1677652288, "model": "nova-micro-custom", "choices": [ { "index": 0, "text": "", "finish_reason": "stop", "stop_reason": null } ], "usage": { "prompt_tokens": 5, "completion_tokens": 11, "total_tokens": 16 } } data: [DONE] ``` **Spiegazione dei campi di risposta** + `id`: identificatore univoco per il completamento + `object`: Tipo di oggetto restituito («chat.completion», «text\$1completion», «chat.completion.chunk») + `created`: timestamp Unix di quando è stato creato il completamento + `model`: Modello utilizzato per il completamento + `choices`: Gamma di scelte di completamento + `usage`: informazioni sull'utilizzo dei token, tra cui richiesta, completamento e token totali + `logprobs`: Registra le informazioni sulla probabilità dei token (quando richiesto) + `finish_reason`: Motivo per cui il modello ha smesso di generare («stop», «length», «content\$1filter») + `delta`: Contenuto incrementale nelle risposte in streaming + `reasoning`: Contenuto di ragionamento quando viene utilizzato reasoning\$1effort + `token_ids`: Matrice di token IDs per il testo generato Per una documentazione completa sull'API, consulta [InvokeEndpoint API reference](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) e [InvokeEndpointWithResponseStream API reference](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html). # Valuta i modelli ospitati su SageMaker Inference Valuta i modelli Questa guida spiega come valutare i tuoi modelli Amazon Nova personalizzati distribuiti su endpoint di SageMaker inferenza utilizzando [Inspect AI](https://github.com/UKGovernmentBEIS/inspect_ai), un framework di valutazione open source. **Nota** [Per una guida pratica, consulta il notebook Quickstart di Inspect AI. SageMaker ](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/sagemaker-inference/sagemaker_inspect_quickstart.ipynb) ## Panoramica di Puoi valutare i tuoi modelli Amazon Nova personalizzati distribuiti sugli SageMaker endpoint utilizzando benchmark standardizzati della comunità di ricerca sull'intelligenza artificiale. Questo approccio ti consente di: + Valuta modelli Amazon Nova personalizzati (ottimizzati, distillati o adattati in altro modo) su larga scala + Esegui valutazioni con inferenza parallela su più istanze di endpoint + Confronta le prestazioni dei modelli utilizzando benchmark come MMLU, TruthfulQA e HumanEval + SageMaker Effettua l'integrazione con la tua infrastruttura esistente ## Modelli supportati Il provider di SageMaker inferenza funziona con: + Modelli Amazon Nova (Nova Micro, Nova Lite, Nova Lite 2) + Modelli distribuiti tramite server di inferenza compatibili con VLLM o OpenAI + Qualsiasi endpoint che supporti il formato API OpenAI Chat Completions ## Prerequisiti Prima di iniziare, assicurati di disporre dei seguenti elementi: + E Account AWS con le autorizzazioni per creare e richiamare endpoint SageMaker + AWS credenziali configurate tramite variabili di ambiente AWS CLI o ruolo IAM + Python 3.9 o versioni successive **Autorizzazioni IAM richieste** Il tuo utente o ruolo IAM necessita delle seguenti autorizzazioni: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "sagemaker:InvokeEndpoint", "sagemaker:DescribeEndpoint" ], "Resource": "arn:aws:sagemaker:*:*:endpoint/*" } ] } ``` ## Fase 1: Implementazione di un endpoint SageMaker Prima di eseguire le valutazioni, è necessario un endpoint di SageMaker inferenza che esegua il modello. Per istruzioni sulla creazione di un endpoint di SageMaker inferenza con i modelli Amazon Nova, consulta. [Nozioni di base](nova-sagemaker-inference-getting-started.md) Una volta che l'endpoint è in `InService` stato, annota il nome dell'endpoint da utilizzare nei comandi di valutazione. ## Fase 2: Installare le dipendenze di valutazione Crea un ambiente virtuale Python e installa i pacchetti richiesti. ``` # Create virtual environment python3.12 -m venv venv source venv/bin/activate # Install uv for faster package installation pip install uv # Install Inspect AI and evaluation benchmarks uv pip install inspect-ai inspect-evals # Install AWS dependencies uv pip install aioboto3 boto3 botocore openai ``` ## Fase 3: Configurare le credenziali AWS Scegli uno dei seguenti metodi di autenticazione: **Opzione 1: AWS CLI (consigliata)** ``` aws configure ``` Inserisci AWS l'ID della chiave di accesso, la chiave di accesso segreta e la regione predefinita quando richiesto. **Opzione 2: variabili di ambiente** ``` export AWS_ACCESS_KEY_ID=your_access_key export AWS_SECRET_ACCESS_KEY=your_secret_key export AWS_DEFAULT_REGION=us-west-2 ``` **Opzione 3: ruolo IAM** Se è in esecuzione su Amazon EC2 o SageMaker notebook, il ruolo IAM dell'istanza viene utilizzato automaticamente. **Verifica le credenziali** ``` import boto3 sts = boto3.client('sts') identity = sts.get_caller_identity() print(f"Account: {identity['Account']}") print(f"User/Role: {identity['Arn']}") ``` ## Fase 4: Installare il provider SageMaker Il SageMaker provider consente a Inspect AI di comunicare con gli SageMaker endpoint. [Il processo di installazione del provider è semplificato nel notebook quickstart.](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/sagemaker-inference/sagemaker_inspect_quickstart.ipynb) ## Fase 5: Scarica i benchmark di valutazione Clona il repository Inspect Evals per accedere ai benchmark standard: ``` git clone https://github.com/UKGovernmentBEIS/inspect_evals.git ``` Questo repository include benchmark come: + MMLU e MMLU-Pro (conoscenza e ragionamento) + TruthfulQA (veridicità) + HumanEval (generazione di codice) + GSM8K (ragionamento matematico) ## Fase 6: Eseguire le valutazioni Esegui una valutazione utilizzando il tuo SageMaker endpoint: ``` cd inspect_evals/src/inspect_evals/ inspect eval mmlu_pro/mmlu_pro.py \ --model sagemaker/my-nova-endpoint \ -M region_name=us-west-2 \ --max-connections 256 \ --max-retries 100 \ --display plain ``` **Parametri chiave** | Parametro | Predefinita | Description | | --- | --- | --- | | --max-connections | 10 | Numero di richieste parallele all'endpoint. Scala in base al numero di istanze (ad esempio, 10 istanze × 25 = 250). | | --max-retries | 3 | Riprova per richieste non riuscite. Usa 50-100 per valutazioni di grandi dimensioni. | | -M region\$1name | us-east-1 | AWS regione in cui è distribuito l'endpoint. | | -M read\$1timeout | 600 | Timeout della richiesta in secondi. | | -M connect\$1timeout | 60 | Timeout della connessione in secondi. | **Consigli di ottimizzazione** Per un endpoint a più istanze: ``` # 10-instance endpoint example --max-connections 250 # ~25 connections per instance --max-retries 100 # Handle transient errors ``` Un'impostazione `--max-connections` troppo alta potrebbe sovraccaricare l'endpoint e causare un rallentamento. Impostarlo su un valore troppo basso comporta un sottoutilizzo della capacità. ## Fase 7: Visualizza i risultati Avvia il visualizzatore Inspect AI per analizzare i risultati della valutazione: ``` inspect view ``` Il visualizzatore mostra: + Punteggi e metriche complessivi + Risultati per campione con risposte del modello + Analisi degli errori e modelli di guasto ## Gestione degli endpoint **Aggiornare un endpoint** Per aggiornare un endpoint esistente con un nuovo modello o configurazione: ``` import boto3 sagemaker = boto3.client('sagemaker', region_name=REGION) # Create new model and endpoint configuration # Then update the endpoint sagemaker.update_endpoint( EndpointName=EXISTING_ENDPOINT_NAME, EndpointConfigName=NEW_ENDPOINT_CONFIG_NAME ) ``` **Eliminare un endpoint** ``` sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME) ``` ## Introduzione di benchmark personalizzati Puoi aggiungere nuovi benchmark a Inspect AI utilizzando il seguente flusso di lavoro: 1. Studia il formato del set di dati e le metriche di valutazione del benchmark 1. Rivedi implementazioni simili in `inspect_evals/` 1. Crea un file di attività che converta i record del set di dati in esempi di Inspect AI 1. Implementa risolutori e punteggi appropriati 1. Esegui la convalida con una piccola esecuzione di test Esempio di struttura delle attività: ``` from inspect_ai import Task, task from inspect_ai.dataset import hf_dataset from inspect_ai.scorer import choice from inspect_ai.solver import multiple_choice @task def my_benchmark(): return Task( dataset=hf_dataset("dataset_name", split="test"), solver=multiple_choice(), scorer=choice() ) ``` ## Risoluzione dei problemi **Problemi comuni** **Limitazione o timeout degli endpoint** + Ridurre `--max-connections` + Aumentare `--max-retries` + Controlla le CloudWatch metriche degli endpoint per problemi di capacità **Errori di autenticazione** + Verifica che AWS le credenziali siano configurate correttamente + Verifica che le autorizzazioni IAM includano `sagemaker:InvokeEndpoint` **Errori del modello** + Verifica che l'endpoint sia in `InService` stato + Verifica che il modello supporti il formato API OpenAI Chat Completions ## Risorse correlate + [Ispeziona la documentazione AI](https://inspect.ai-safety-institute.org.uk/) + [Ispeziona il repository Evals](https://github.com/UKGovernmentBEIS/inspect_evals) + [SageMaker Guida per gli sviluppatori](https://docs.aws.amazon.com//sagemaker/latest/dg/whatis.html) + [Implementa modelli per l'inferenza](https://docs.aws.amazon.com//sagemaker/latest/dg/deploy-model.html) + [Configurazione di AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-configure.html) # Implementazione di modelli Amazon Nova Forge nel rilevamento degli abusi di Amazon SageMaker Inference Rilevamento degli abusi per Amazon Nova Forge AWS si impegna a utilizzare l'IA in modo responsabile. [Per aiutare a prevenire potenziali abusi, quando distribuisci modelli Amazon Nova Forge in Amazon SageMaker Inference, SageMaker Inference implementa meccanismi automatici di rilevamento degli abusi per identificare potenziali violazioni della Politica di [utilizzo accettabile (AUP) e dei Termini AWS di servizio di Amazon, inclusa la Politica sull'](https://aws.amazon.com/aup/)IA responsabile.](https://aws.amazon.com/ai/responsible-ai/policy/) I nostri meccanismi di rilevamento degli abusi sono completamente automatizzati, quindi non è prevista alcuna revisione umana o accesso agli input degli utenti o agli output dei modelli. Il rilevamento automatico degli abusi include: + **Categorizza i contenuti**: utilizziamo classificatori per rilevare contenuti dannosi (come contenuti che incitano alla violenza) negli input degli utenti e negli output dei modelli. Un classificatore è un algoritmo che elabora gli input e gli output del modello e che assegna il tipo di danno e il livello di confidenza. Possiamo eseguire questi classificatori sull'utilizzo del modello Amazon Nova Forge. Il processo di classificazione è automatizzato e non prevede la revisione umana degli input degli utenti o degli output del modello. + **Identifica i modelli**: utilizziamo le metriche dei classificatori per identificare potenziali violazioni e comportamenti ricorrenti. Possiamo compilare e condividere metriche di classificazione anonime. Amazon SageMaker Inference non memorizza l'input dell'utente o l'output del modello. + **Rilevamento e blocco di materiale pedopornografico (CSAM)**: sei responsabile dei contenuti che tu (e i tuoi utenti finali) caricate su Amazon SageMaker Inference e devi assicurarti che tali contenuti siano privi di immagini illegali. Per contribuire a fermare la diffusione di CSAM, durante la distribuzione di un modello Amazon Nova Forge in Amazon SageMaker Inference, SageMaker Inference può utilizzare meccanismi automatici di rilevamento degli abusi (come la tecnologia di hash matching o i classificatori) per rilevare CSAM apparente. Se Amazon SageMaker Inference rileva un CSAM apparente negli input delle tue immagini, SageMaker Amazon Inference bloccherà la richiesta e riceverai un messaggio di errore automatico. Amazon SageMaker Inference può anche presentare una segnalazione al National Center for Missing and Exploited Children (NCMEC) o a un'autorità competente. Prendiamo molto sul serio il problema dei materiali pedopornografici e continueremo ad aggiornare i nostri meccanismi di rilevamento, blocco e segnalazione. Le leggi applicabili potrebbero richiedere l’adozione di ulteriori misure, di cui l’utente è responsabile. Una volta che i nostri meccanismi automatici di rilevamento degli abusi identificano potenziali violazioni, possiamo richiedere informazioni sull'utilizzo di Amazon SageMaker Inference e sulla conformità ai nostri termini di servizio. Nel caso in cui tu non risponda, non voglia o non sia in grado di rispettare questi termini o politiche, puoi AWS sospendere il tuo accesso ad Amazon Inference. SageMaker Inoltre, se i nostri test automatici rilevano che le risposte del modello non sono coerenti con i nostri termini e politiche, potresti ricevere una fattura per il processo di inferenza non riuscito. Contatta AWS l'assistenza se hai altre domande. Per ulteriori informazioni, consulta [Amazon SageMaker FAQs](https://aws.amazon.com/sagemaker/ai/faqs/).