# Inferencias de SageMaker
Los modelos personalizados de Amazon Nova ya están disponibles para Inferencias de SageMaker. Con Amazon Nova en SageMaker, puede empezar a obtener predicciones o inferencias a partir de sus modelos de Amazon Nova personalizados y entrenados. Sagemaker ofrece una amplia selección de opciones de implementación de modelos e infraestructuras de ML para ayudarle a satisfacer todas sus necesidades de inferencia de ML. Con Inferencias de SageMaker, puede escalar la implementación de modelos, administrar modelos de forma más eficaz en la fase de producción y reducir la carga operativa.
SageMaker le proporciona varias opciones de inferencia, como, por ejemplo, puntos de conexión en tiempo real para obtener inferencias de baja latencia y puntos de conexión asíncronos para lotes de solicitudes. Al utilizar la opción de inferencia adecuada para el caso de uso, puede garantizar una implementación e inferencia eficaces de los modelos. Para obtener más información sobre Inferencias de SageMaker, consulte [Deploy models for inference](https://docs.aws.amazon.com//sagemaker/latest/dg/deploy-model.html).
**importante**
Solo los modelos personalizados de rango completo y los modelos fusionados con LoRA son compatibles con Inferencias de SageMaker. En el caso de los modelos LoRA no fusionados y los modelos base, utilice Amazon Bedrock.
## Características
Las siguientes características están disponibles para los modelos de Amazon Nova en Inferencias de SageMaker:
**Capacidades del modelo**
+ Generación de texto
**Implementación y escalado**
+ Puntos de conexión en tiempo real con selección de instancias personalizada.
+ Escalado automático: ajuste automáticamente la capacidad en función de los patrones de tráfico para optimizar los costos y el uso de la GPU. Para obtener información, consulte [Automatically Scale Amazon SageMaker Models](https://docs.aws.amazon.com//sagemaker/latest/dg/endpoint-auto-scaling.html)
+ Compatibilidad con API de transmisión para la generación de tokens en tiempo real.
**Supervisión y optimización**
+ Integración de Amazon CloudWatch para supervisar y configurar alertas.
+ Optimización de la latencia con reconocimiento de zonas de disponibilidad mediante la configuración de VPC.
**Herramientas de desarrollo de**
+ Compatibilidad con AWS CLI: para obtener más información, consulte [AWS CLI Command Reference for SageMaker](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/).
+ Integración de cuadernos mediante la compatibilidad con el SDK.
## Modelos e instancias compatibles
Al crear los puntos de conexión de Inferencias de SageMaker, puede definir dos variables de entorno para configurar su implementación: `CONTEXT_LENGTH` y `MAX_CONCURRENCY`.
+ `CONTEXT_LENGTH`: longitud máxima total del token (entrada \$1 salida) por solicitud
+ `MAX_CONCURRENCY`: número máximo de solicitudes simultáneas que atenderá el punto de conexión
En la siguiente tabla se muestran los modelos de Amazon Nova admitidos, los tipos de instancias y las configuraciones admitidas. Los valores de MAX\$1CONCURRENCY representan la simultaneidad máxima admitida para cada configuración de CONTEXT\$1LENGTH:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/nova/latest/nova2-userguide/nova-model-sagemaker-inference.html)
**nota**
Los valores de MAX\$1CONCURRENCY que se muestran son los límites superiores de cada configuración de CONTEXT\$1LENGTH. Puede utilizar longitudes de contexto más bajas con la misma simultaneidad, pero si se superan estos valores, se producirá un error en la creación del punto de conexión de SageMaker.
Por ejemplo, en Amazon Nova Micro con una instancia ml.g5.12xlarge:
`CONTEXT_LENGTH=2000`, `MAX_CONCURRENCY=32` → válido
`CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=32` → rechazado (el límite de simultaneidad es 16 con una longitud de contexto de 8000)
`CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=4` → válido
`CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=16` → válido
`CONTEXT_LENGTH=10000` → rechazado (la longitud máxima del contexto es 8000 en esta instancia)
## Regiones de AWS compatibles
La siguiente tabla muestra las regiones de AWS en las que los modelos de Amazon Nova están disponibles para Inferencias de SageMaker:
****
| Nombre de la región | Código de región | Disponibilidad |
| --- | --- | --- |
| Este de EE. UU. (Norte de Virginia) | us-east-1 | Disponible |
| Oeste de EE. UU. (Oregón) | us-west-2 | Disponible |
## Imágenes de contenedor compatibles
La siguiente tabla muestra los URI de imágenes de contenedor para los modelos de Amazon Nova en Inferencias de SageMaker, organizados por región. Hay dos etiquetas de imagen disponibles para cada región: una etiqueta versionada (`v1.0.0`) y la etiqueta más reciente (`SM-Inference-latest`). En el caso de las implementaciones en producción, se recomienda usar la etiqueta versionada.
****
| Región | URI de imágenes de contenedor |
| --- | --- |
| 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 |
## Prácticas recomendadas
Para obtener información sobre las prácticas recomendadas sobre la implementación y administración de modelos en SageMaker, consulte [Best Practices for SageMaker](https://docs.aws.amazon.com//sagemaker/latest/dg/best-practices.html).
## Soporte
Si tiene problemas o necesita asistencia con los modelos de Amazon Nova en Inferencias de SageMaker, póngase en contacto con AWS Support a través de la consola o con su administrador de cuentas de AWS.
**Topics**
+ [Características](#nova-sagemaker-inference-features)
+ [Modelos e instancias compatibles](#nova-sagemaker-inference-supported)
+ [Regiones de AWS compatibles](#nova-sagemaker-inference-regions)
+ [Imágenes de contenedor compatibles](#nova-sagemaker-inference-container-images)
+ [Prácticas recomendadas](#nova-sagemaker-inference-best-practices)
+ [Soporte](#nova-sagemaker-inference-support)
+ [Introducción](nova-sagemaker-inference-getting-started.md)
+ [referencia de la API](nova-sagemaker-inference-api-reference.md)
+ [Evaluación de los modelos alojados en Inferencias de SageMaker](nova-eval-on-sagemaker-inference.md)
+ [Implementación de modelos de Amazon Nova Forge en la detección de abusos de Inferencia de Amazon SageMaker](nova-sagemaker-inference-abuse-detection.md)
# Introducción
Esta guía le muestra cómo implementar modelos personalizados de Amazon Nova en puntos de conexión en tiempo real de SageMaker, configurar los parámetros de inferencia e invocar sus modelos para realizar pruebas.
## Requisitos previos
Los siguientes son requisitos previos para implementar modelos de Amazon Nova en Inferencias de SageMaker:
+ Cree una Cuenta de AWS: si aún no tiene una, consulte [Creating an AWS account](https://docs.aws.amazon.com//sagemaker/latest/dg/gs-set-up.html#sign-up-for-aws).
+ Permisos de IAM necesarios: asegúrese de que su usuario o rol de IAM tenga adjuntas las políticas de administración siguientes:
+ `AmazonSageMakerFullAccess`
+ `AmazonS3FullAccess`
+ Versiones del SDK y de la CLI requeridas: las siguientes versiones de SDK se han probado y validado con modelos de Amazon Nova en Inferencias de SageMaker.
+ Versión 3.0.0 o superior del SDK de SageMaker para Python (`sagemaker>=3.0.0`) para un enfoque de API basado en recursos.
+ Versión 1.35.0 o superior de Boto3 (`boto3>=1.35.0`) para llamadas directas a la API. Los ejemplos de esta guía utilizan este enfoque.
+ Aumento de la cuota de servicio: solicite un aumento de la cuota de servicio de Amazon SageMaker para el tipo de instancia de ML que tiene previsto utilizar para el punto de conexión de Inferencia de SageMaker (por ejemplo, `ml.p5.48xlarge for endpoint usage`). Para ver una lista de los tipos de instancia admitidos, consulte [Modelos e instancias compatibles](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported). Para solicitar un aumento, consulte [Solicitud de aumento de cuota](https://docs.aws.amazon.com//servicequotas/latest/userguide/request-quota-increase.html). Para obtener más información sobre las cuotas de instancias de SageMaker, consulte [Puntos de conexión y cuotas de Amazon SageMaker](https://docs.aws.amazon.com//general/latest/gr/sagemaker.html).
## Paso 1: configure las credenciales de AWS
Configure las credenciales de AWS con uno de los siguientes métodos:
**Opción 1: AWS CLI (recomendado)**
```
aws configure
```
Ingrese la clave de acceso de AWS, la clave secreta y el nombre de la región predeterminada cuando se le solicite.
**Opción 2: archivo de credenciales AWS**
Cree o edite `~/.aws/credentials`:
```
[default]
aws_access_key_id = YOUR_ACCESS_KEY
aws_secret_access_key = YOUR_SECRET_KEY
```
**Opción 3: variables de entorno**
```
export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key
```
**nota**
Para obtener más información sobre las credenciales de AWS, consulte [Opciones de los archivos de configuración y credenciales en la AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-files.html).
**Initialización de clientes de AWS**
Cree un script o cuaderno de Python con el siguiente código para inicializar el SDK de AWS y verificar sus credenciales:
```
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.")
```
Si la autenticación se realiza correctamente, debería ver una salida que confirma el ID de su cuenta de AWS.
## Paso 2: cree un rol de puesta en marcha de SageMaker AI
Un rol de puesta en marcha de SageMaker es un rol de IAM que concede permisos a SageMaker para acceder a los recursos de AWS en su nombre, como los buckets de Amazon S3 para artefactos de modelos y CloudWatch para el registro.
**Creación del rol de puesta en marcha**
**nota**
La creación de roles de IAM requiere los permisos `iam:CreateRole` y `iam:AttachRolePolicy`. Asegúrese de que el usuario o el rol de IAM tenga estos permisos antes de continuar.
El código siguiente crea un rol de IAM con los permisos necesarios para implementar modelos personalizados de 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}")
```
**Uso de un rol de puesta en marcha existente (opcional)**
Si ya tiene un rol de puesta en marcha de SageMaker, puede usarlo en su lugar:
```
# Replace with your existing role ARN
SAGEMAKER_EXECUTION_ROLE_ARN = "arn:aws:iam::YOUR_ACCOUNT_ID:role/YOUR_EXISTING_ROLE_NAME"
```
Para buscar los roles de SageMaker existentes en su cuenta:
```
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**
El rol de puesta en marcha debe tener una relación de confianza con `sagemaker.amazonaws.com` y permisos para acceder a los recursos de Amazon S3 y SageMaker.
Para obtener más información sobre los roles de puesta en marcha de SageMaker, consulte [SageMaker Roles](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html).
## Paso 3: configure los parámetros del modelo
Configure los parámetros de implementación de su modelo de Amazon Nova. Estos ajustes controlan el comportamiento del modelo, la asignación de recursos y las características de inferencia. Para obtener una lista de los tipos de instancias compatibles y los valores de CONTEXT\$1LENGTH y MAX\$1CONCURRENCY admitidos para cada uno, consulte [Modelos e instancias compatibles](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported).
**Parámetros requeridos**
+ `IMAGE`: el URI de imagen del contenedor de Docker para el contenedor de inferencias de Amazon Nova. Lo proporcionará AWS.
+ `CONTEXT_LENGTH`: longitud del contexto del modelo.
+ `MAX_CONCURRENCY`: número máximo de secuencias por iteración; establece el límite de cuántas solicitudes de usuarios individuales (peticiones) se pueden procesar simultáneamente en un solo lote en la GPU. Rango: valor entero mayor que 0.
**Parámetros de generación opcionales**
+ `DEFAULT_TEMPERATURE`: controla la asignación al azar en la generación. Rango: de 0,0 a 2,0 (0.0 = determinista, más alto = asignación al azar mayor).
+ `DEFAULT_TOP_P`: umbral de muestreo del núcleo para la selección de tokens. Rango: del 1e-10 al 1,0.
+ `DEFAULT_TOP_K`: limita la selección de tokens a los K más probables. Rango: número entero -1 o mayor (-1 = sin límite).
+ `DEFAULT_MAX_NEW_TOKENS`: número máximo de tokens que se generarán en respuesta (es decir, número máximo de tokens de salida). Rango: número entero 1 o mayor.
+ `DEFAULT_LOGPROBS`: número de probabilidades logarítmicas que se devolverán por token. Rango: número entero del 1 al 20.
**Configurar su implementación**
```
# 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}")
```
**Configuración de los parámetros específicos de la implementación**
Ahora configure los parámetros específicos de la implementación de su modelo de Amazon Nova, como la ubicación de los artefactos del modelo y la selección del tipo de instancia.
**Definición del identificador de la implementación**
```
# Deployment identifier - use a descriptive name for your use case
JOB_NAME = "my-nova-deployment"
```
**Definición de la ubicación de los artefactos del modelo**
Proporcione el URI de Amazon S3 en el que se almacenan los artefactos de los modelos entrenados de Amazon Nova. Esta debe ser la ubicación de salida de su trabajo de entrenamiento o refinamiento del modelo.
```
# 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/"
```
**Selección de la variante del modelo y del tipo de instancia**
```
# 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}")
```
**Convenciones de nomenclatura**
El código genera automáticamente nombres consistentes para los recursos de AWS:
+ Nombre del modelo: `{JOB_NAME}-{model}-{instance-type}`
+ Configuración del punto de conexión: `{MODEL_NAME}-Config`
+ Nombre del punto de conexión: `{MODEL_NAME}-Endpoint`
## Paso 4: cree la configuración del modelo y del punto de conexión de SageMaker
En este paso, creará dos recursos esenciales: un objeto de modelo de SageMaker que haga referencia a los artefactos del modelo de Amazon Nova y una configuración de punto de conexión que defina cómo se implementará el modelo.
**Modelo de SageMaker**: objeto de modelo que empaqueta la imagen del contenedor de inferencia, la ubicación de los artefactos del modelo y la configuración del entorno. Se trata de un recurso reutilizable que se puede implementar en varios puntos de conexión.
**Configuración de punto de conexión**: define la configuración de la infraestructura de la implementación, como el tipo de instancia, el número de instancias y las variantes del modelo. Esto le permite administrar la configuración de implementación de forma independiente del propio modelo.
**Cree el modelo de SageMaker**
El siguiente código crea un modelo de SageMaker que hace referencia a los artefactos del modelo de 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}")
```
Parámetros clave:
+ `ModelName`: identificador único para su modelo
+ `Image`: URI de imagen del contenedor de Docker para las inferencias de Amazon Nova
+ `ModelDataSource`: ubicación en Amazon S3 de los artefactos de su modelo
+ `Environment`: variables de entorno configuradas en el paso 3
+ `ExecutionRoleArn`: rol de IAM del paso 2
+ `EnableNetworkIsolation`: establezca el valor en True para mejorar la seguridad (evita que el contenedor haga llamadas salientes a la red)
**Creación de la configuración de punto de conexión**
A continuación, cree una configuración de punto de conexión que defina la infraestructura de la implementación:
```
# 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}")
```
Parámetros clave:
+ `VariantName`: identificador de esta variante del modelo (utilice “principal” para las implementaciones de un solo modelo)
+ `ModelName`: hace referencia al modelo creado anteriormente
+ `InitialInstanceCount`: número de instancias que se van a implementar (comience con 1 y escale más adelante si es necesario)
+ `InstanceType`: tipo de instancia de ML seleccionado en el paso 3
**Verificación de la creación de recursos**
Puede verificar que los recursos se crearon correctamente:
```
# 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")
```
## Paso 5: implemente el punto de conexión
El siguiente paso consiste en implementar su modelo de Amazon Nova mediante la creación de un punto de conexión en tiempo real de SageMaker. Este punto de conexión alojará su modelo y proporcionará un punto de conexión HTTPS seguro para realizar solicitudes de inferencia.
La creación del punto de conexión suele tardar entre 15 y 30 minutos, ya que AWS aprovisiona la infraestructura, descarga los artefactos del modelo e inicializa el contenedor de inferencias.
**Cree el punto de conexión**
```
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}")
```
**Supervisión de la creación de puntos de conexión**
El siguiente código sondea el estado del punto de conexión hasta que se complete la implementación:
```
# 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
```
**Comprobación de que el punto de conexión esté listo**
Cuando el punto de conexión esté en funcionamiento, puede verificar su configuración:
```
# 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
```
**Solución de problemas de creación de puntos de conexión**
Motivos de error comunes:
+ **Capacidad insuficiente**: el tipo de instancia solicitado no está disponible en su región.
+ Solución: pruebe un tipo de instancia diferente o solicite un aumento de cuota
+ **Permisos de IAM**: el rol de puesta en marcha carece de los permisos necesarios.
+ Solución: compruebe que el rol tenga acceso a los artefactos del modelo de Amazon S3 y a los permisos de SageMaker necesarios
+ **No se encontraron los artefactos del modelo**: el URI de Amazon S3 es incorrecto o no se puede acceder a él.
+ Solución: compruebe el URI de Amazon S3 y los permisos del bucket, y asegúrese de que se encuentra en la región correcta.
+ **Límites de recursos**: se han superado los límites de las cuentas para los puntos de conexión o las instancias.
+ Solución: solicite un aumento de la cuota de servicio a través de Service Quotas o AWS Support.
**nota**
Si tiene que eliminar un punto de conexión defectuoso y empezar de nuevo, haga lo siguiente:
```
sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
```
## Paso 6: invoque el punto de conexión
Cuando el punto de conexión esté en funcionamiento, puede enviar solicitudes de inferencia para generar predicciones a partir de su modelo de Amazon Nova. SageMaker admite puntos de conexión síncronos (en tiempo real con modos de transmisión o sin transmisión) y puntos de conexión asíncronos (basados en Amazon S3 para el procesamiento por lotes).
**Configuración del cliente de tiempo de ejecución**
Cree un cliente de tiempo de ejecución de SageMaker con la configuración de tiempo de espera adecuada:
```
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)
```
**Creación de una función de inferencia universal**
La siguiente función gestiona las solicitudes de transmisión y de no transmisión:
```
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)}")
```
**Ejemplo 1: finalización de un chat sin transmisión**
Use el formato de chat para las interacciones conversacionales:
```
# 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)
```
**Respuesta de ejemplo:**
```
{
"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
}
}
```
**Ejemplo 2: finalización de texto simple**
Use el formato de finalización para generar texto simple:
```
# 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)
```
**Respuesta de ejemplo:**
```
{
"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
}
}
```
**Ejemplo 3: finalización de un chat con transmisión**
```
# 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)
```
**Ejemplo de salida de transmisión:**
```
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]
```
**Ejemplo 4: finalización de un chat multimodal**
Use el formato multimodal para la entrada de imágenes y texto:
```
# 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)
```
**Respuesta de ejemplo:**
```
{
"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
}
}
```
## Paso 7 (opcional): elimine recursos
Para evitar incurrir en gastos innecesarios, elimine los recursos de AWS que creó durante este tutorial. Los puntos de conexión de SageMaker incurren en cargos mientras están en funcionamiento, incluso si no realiza activamente solicitudes de inferencia.
**importante**
La eliminación de los recursos es permanente y no se puede deshacer. Asegúrese de que ya no necesite estos recursos antes de continuar.
**Eliminación del punto de conexión**
```
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**
La eliminación de puntos de conexión es asíncrona. Puede supervisar el estado de la eliminación:
```
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
```
**Eliminación de la configuración de punto de conexión**
Una vez eliminado el punto de conexión, elimine su configuración.
```
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}")
```
**Eliminación del modelo**
Elimine el objeto de modelo de SageMaker:
```
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}")
```
# referencia de la API
Los modelos de Amazon Nova en SageMaker utilizan la API estándar de Tiempo de ejecución de SageMaker Runtime para realizar inferencias. Para obtener la documentación completa de la API, consulte [Test a deployed model](https://docs.aws.amazon.com//sagemaker/latest/dg/realtime-endpoints-test-endpoints.html).
## Invocación del punto de conexión
Los modelos de Amazon Nova en SageMaker admiten dos métodos de invocación:
+ **Invocación sincrónica**: utilice la API [InvokeEndpoint](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) para solicitudes de inferencia en tiempo real sin transmisión.
+ **Invocación con transmisión**: utilice la API [InvokeEndpointWithResponseStream](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html) para las solicitudes de inferencia en tiempo real con transmisión.
## Formato de solicitudes
Los modelos de Amazon Nova admiten dos formatos de solicitud:
**Formato de finalización de chat**
Use este formato para las interacciones conversacionales:
```
{
"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 de finalización de texto**
Use este formato para generar texto simple:
```
{
"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 de finalización de chat multimodal**
Use este formato para la entrada de imágenes y texto:
```
{
"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
}
```
**Parámetros de solicitud**
+ `messages` (matriz): para el formato de finalización de chat. Matriz de objetos de mensaje con los campos `role` y `content`. El contenido puede ser una cadena de solo texto o una matriz de entradas multimodales.
+ `prompt` (cadena): para el formato de finalización de texto. El texto de entrada desde el que se generará.
+ `max_tokens` (entero): número máximo de tokens que se generarán en la respuesta. Rango: 1 o más.
+ `max_completion_tokens` (entero): alternativa a max\$1tokens para el formato de finalización de chat. Número máximo de tokens de finalización que se generarán.
+ `temperature` (float): controla la asignación al azar en la generación. Rango: de 0,0 a 2,0 (0,0 = determinista, 2,0 = asignación al azar máxima).
+ `top_p` (float): umbral de muestreo del núcleo Rango: del 1e-10 al 1,0.
+ `top_k` (entero): limita la selección de tokens a los K más probables. Rango: entero -1 o mayor (-1 = sin límite).
+ `stream` (booleano): indica si se debe transmitir la respuesta. Establezca el valor en `true` para transmitir o en `false` si no quiere transmisión.
+ `logprobs` (booleano/entero): para finalizaciones de chat, use un valor booleano. Para la finalización de texto, utilice un número entero como número de probabilidades logarítmicas que se deben devolver. Rango: del 1 al 20
+ `top_logprobs` (entero): número de tokens más probables para los cuales devolver probabilidades logarítmicas (solo para finalizaciones de chat).
+ `reasoning_effort` (cadena): nivel de esfuerzo de razonamiento. Opciones: “bajo”, “alto” (finalizaciones de chat solo para los modelos personalizados de Nova 2 Lite).
+ `allowed_token_ids` (matriz): lista de ID de token que se pueden generar. Restringe la salida a los tokens especificados.
+ `truncate_prompt_tokens` (entero): trunca la petición a este número de símbolos si supera el límite.
+ `stream_options` (objeto): opciones para transmitir las respuestas. Contiene el valor booleano de `include_usage` que indica si incluir el uso de tokens en las respuestas transmitidas.
## Formato de respuesta
El formato de respuesta depende del método de invocación y del tipo de solicitud:
**Respuesta de finalización de chat (sin transmisión)**
Para solicitudes de finalización de chat sincrónicas:
```
{
"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]
}
```
**Respuesta de finalización de texto (sin transmisión)**
Para solicitudes de finalización de texto sincrónicas:
```
{
"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
}
}
}
```
**Respuesta de finalización de chat con transmisión**
En el caso de las solicitudes de finalización de chat con transmisión, las respuestas se envían como eventos enviados por el servidor (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]
```
**Respuesta de finalización de texto con transmisión**
Para solicitudes de finalización de texto con transmisión:
```
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]
```
**Explicación de los campos de respuesta**
+ `id`: identificador único de la finalización
+ `object`: tipo de objeto devuelto (“chat.completion”, “text\$1completion”, “chat.completion.chunk”)
+ `created`: marca de tiempo Unix del momento en que se creó la finalización
+ `model`: modelo utilizado para la finalización
+ `choices`: matriz de opciones de finalización
+ `usage`: información sobre el uso de las tokens, lo que incluye la petición, la finalización y el número total de tokens
+ `logprobs`: información de probabilidades logarítmicas de los tokens (cuando se solicite)
+ `finish_reason`: motivo por el que el modelo dejó de generar (“stop”, “length”, “content\$1filter”)
+ `delta`: contenido incremental en las respuestas con transmisión
+ `reasoning`: contenido de razonamiento cuando se use reasoning\$1effort
+ `token_ids`: matriz de ID de tokens para el texto generado
Para obtener la documentación completa de la API, consulte [InvokeEndpoint API reference](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) y [InvokeEndpointWithResponseStream API reference](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html).
# Evaluación de los modelos alojados en Inferencias de SageMaker
Esta guía explica cómo evaluar los modelos personalizados de Amazon Nova implementados en los puntos de conexión de Inferencias de SageMaker mediante [Inspect AI](https://github.com/UKGovernmentBEIS/inspect_ai), un marco de evaluación de código abierto.
**nota**
Para ver un tutorial práctico, consulte [SageMaker Inspect AI quickstart notebook](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/sagemaker-inference/sagemaker_inspect_quickstart.ipynb).
## Descripción general
Puede evaluar los modelos personalizados de Amazon Nova implementados en los puntos de conexión de SageMaker utilizando pruebas comparativas estandarizadas de la comunidad de investigadores de IA. Este enfoque le permite lo siguiente:
+ Evaluar modelos personalizados de Amazon Nova (refinados, destilados o adaptados de alguna manera) a escala
+ Poner en marcha evaluaciones con inferencia paralela en varias instancias del punto de conexión
+ Comparar el rendimiento del modelo mediante pruebas comparativas como MMLU, TruthfulQA y HumanEval
+ Integrar con su infraestructura de SageMaker existente
## Modelos compatibles
El proveedor de Inferencias de SageMaker funciona con:
+ Modelos de Amazon Nova (Nova Micro, Nova Lite, Nova Lite 2)
+ Modelos implementados mediante servidores de inferencia compatibles con vLLM u OpenAI
+ Cualquier punto de conexión compatible con el formato de la API de finalizaciones de chat de OpenAI
## Requisitos previos
Antes de comenzar, asegúrese de que dispone de lo siguiente:
+ Una Cuenta de AWS con permisos para crear e invocar puntos de conexión de SageMaker
+ Credenciales de AWS configuradas mediante AWS CLI, variables de entorno o roles de IAM
+ Python 3.9 o superior
**Permisos de IAM necesarios**
El usuario o rol de IAM necesita los siguientes permisos:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:InvokeEndpoint",
"sagemaker:DescribeEndpoint"
],
"Resource": "arn:aws:sagemaker:*:*:endpoint/*"
}
]
}
```
## Paso 1: implemente un punto de conexión de SageMaker
Antes de poner en marcha las evaluaciones, necesita un punto de conexión de Inferencias de SageMaker que use el modelo.
Para obtener instrucciones sobre cómo crear un punto de conexión de Inferencias de SageMaker con modelos de Amazon Nova, consulte [Introducción](nova-sagemaker-inference-getting-started.md).
Cuando el punto de conexión esté en estado `InService`, anote el nombre del punto de conexión para usarlo en los comandos de evaluación.
## Paso 2: instale las dependencias de evaluación
Cree un entorno virtual de Python e instale los paquetes necesarios.
```
# 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
```
## Paso 3: configure las credenciales de AWS
Elija uno de los siguientes métodos de autenticación:
**Opción 1: AWS CLI (recomendado)**
```
aws configure
```
Ingrese el ID de su clave de acceso de AWS, la clave de acceso secreta y el nombre de la región predeterminada cuando se le solicite.
**Opción 2: variables de entorno**
```
export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key
export AWS_DEFAULT_REGION=us-west-2
```
**Opción 3: rol de IAM**
Si se usan Amazon EC2 o cuadernos de SageMaker, el rol de IAM de la instancia se utiliza automáticamente.
**Verificación de credenciales**
```
import boto3
sts = boto3.client('sts')
identity = sts.get_caller_identity()
print(f"Account: {identity['Account']}")
print(f"User/Role: {identity['Arn']}")
```
## Paso 4: instalación del proveedor de SageMaker
El proveedor de SageMaker permite que Inspect AI se comunique con sus puntos de conexión de SageMaker. El proceso de instalación del proveedor aparece simplificado en el [cuaderno de inicio rápido](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/sagemaker-inference/sagemaker_inspect_quickstart.ipynb).
## Paso 5: descargue las pruebas comparativas de evaluación
Clone el repositorio Inspect Evals para acceder a los pruebas comparativas estándar:
```
git clone https://github.com/UKGovernmentBEIS/inspect_evals.git
```
Este repositorio incluye pruebas comparativas como:
+ MMLU y MMLU-Pro (conocimiento y razonamiento)
+ TruthfulQA (veracidad)
+ HumanEval (generación de código)
+ GSM8K (razonamiento matemático)
## Paso 6: realice evaluaciones
Lleve a cabo una evaluación con su punto de conexión de SageMaker:
```
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
```
**Parámetros clave**
| Parámetro | Predeterminado | Descripción |
| --- | --- | --- |
| --max-connections | 10 | Número de solicitudes paralelas al punto de conexión. Escale con el número de instancias (por ejemplo, 10 instancias × 25 = 250). |
| --max-retries | 3 | Reintentos en caso de error. Utilice 50-100 para evaluaciones de gran tamaño. |
| -M region\$1name | us-east-1 | Región de AWS en la que se implementa el punto de conexión. |
| -M read\$1timeout | 600 | Tiempo de espera de la solicitud en segundos. |
| -M connect\$1timeout | 60 | Tiempo de espera de la conexión en segundos. |
**Recomendaciones de refinamiento**
Para un punto de conexión de varias instancias:
```
# 10-instance endpoint example
--max-connections 250 # ~25 connections per instance
--max-retries 100 # Handle transient errors
```
Si se establece un valor demasiado alto para `--max-connections`, es posible que el punto de conexión se sobrecargue y se produzcan limitaciones. Si se establece un valor demasiado bajo, se infrautiliza la capacidad.
## Paso 7: visualización de los resultados
Inicie el lector de Inspect AI para analizar los resultados de la evaluación:
```
inspect view
```
El lector muestra lo siguiente:
+ Puntuaciones y métricas generales
+ Resultados por muestra con las respuestas del modelo
+ Análisis de errores y patrones de error
## Administración de puntos de conexión
**Actualizar un punto de conexión**
Para actualizar un punto de conexión existente con un nuevo modelo o configuración:
```
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
)
```
**Eliminación de un punto de conexión**
```
sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
```
## Incorporación de pruebas comparativas personalizadas
Puede agregar nuevas pruebas comparativas a Inspect AI mediante el siguiente flujo de trabajo:
1. Estudie el formato del conjunto de datos de la prueba comparativa y las métricas de evaluación.
1. Revise implementaciones similares en `inspect_evals/`.
1. Cree un archivo de tareas que convierta los registros del conjunto de datos en muestras de Inspect AI.
1. Implemente los solucionadores y evaluadores adecuados.
1. Valide con una pequeña prueba.
Estructura de tarea de ejemplo:
```
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()
)
```
## Solución de problemas
**Problemas comunes**
**Limitación o tiempos de espera del punto de conexión**
+ Reduzca `--max-connections`
+ Aumente `--max-retries`
+ Compruebe las métricas de CloudWatch de los puntos de conexión para ver si hay problemas de capacidad
**Errores de autenticación**
+ Compruebe que las credenciales de AWS estén configuradas correctamente:
+ Compruebe que los permisos de IAM incluyan `sagemaker:InvokeEndpoint`
**Errores del modelo**
+ Compruebe que el punto de conexión esté en estado `InService`
+ Compruebe que el modelo sea compatible con el formato de la API de finalizaciones de chat de OpenAI
## Recursos relacionados
+ [Documentación de Inspect AI](https://inspect.ai-safety-institute.org.uk/)
+ [Repositorio Inspect Evals](https://github.com/UKGovernmentBEIS/inspect_evals)
+ [SageMaker Developer Guide](https://docs.aws.amazon.com//sagemaker/latest/dg/whatis.html)
+ [Deploy Models for Inference](https://docs.aws.amazon.com//sagemaker/latest/dg/deploy-model.html)
+ [Configuración de la AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-configure.html)
# Implementación de modelos de Amazon Nova Forge en la detección de abusos de Inferencia de Amazon SageMaker
AWS tiene el compromiso de usar responsablemente la IA. Para ayudar a prevenir un posible uso indebido, al implementar modelos de Amazon Nova Forge en Inferencia de Amazon SageMaker, Inferencia de SageMaker implementa mecanismos automatizados de detección de abusos para identificar las posibles infracciones de la [Política de uso aceptable](https://aws.amazon.com/aup/) (AUP) y las Condiciones del servicio de AWS, lo que incluye la [Política de IA responsable](https://aws.amazon.com/ai/responsible-ai/policy/).
Nuestros mecanismos de detección de abusos están totalmente automatizados, por lo que no se puede revisar ni acceder a las entradas de usuario ni a las salidas del modelo.
La detección automática de abusos incluye:
+ **Categorización de contenido**: utilizamos clasificadores para detectar contenido dañino (como el que incita a la violencia) en las entradas del usuario y en las salidas del modelo. Un clasificador es un algoritmo que procesa las entradas y salidas del modelo y asigna el tipo de daño y el nivel de confianza. Podemos utilizar estos clasificadores en el uso del modelo de Amazon Nova Forge. El proceso de clasificación está automatizado y no implica la revisión humana de entradas de usuario ni de salidas del modelo.
+ **Identificación de patrones**: utilizamos métricas de clasificadores para identificar posibles infracciones y comportamientos recurrentes. Podemos recopilar y compartir métricas de clasificadores anónimas. Inferencia de Amazon SageMaker no almacena las entradas del usuario ni las salidas del modelo.
+ **Detección y bloqueo de material de abuso sexual infantil**: usted es responsable del contenido que usted y sus usuarios finales suban a Inferencia de Amazon SageMaker y debe asegurarse de que no contenga imágenes ilegales. Para ayudar a detener la difusión de material de abuso sexual infantil, al implementar un modelo de Amazon Nova Forge en Inferencia de Amazon SageMaker, Inferencia de SageMaker puede utilizar mecanismos automatizados de detección de abusos (como la tecnología de coincidencia de hash o los clasificadores) para detectar posible material de abuso sexual infantil. Si Inferencia de Amazon SageMaker detecta posible material de abuso sexual infantil en las entradas de imágenes, bloqueará la solicitud y usted recibirá un mensaje de error automático. Inferencia de Amazon SageMaker también puede remitir una denuncia al Centro Nacional para Menores Desaparecidos y Explotados (NCMEC, por sus siglas en inglés) o a la autoridad pertinente. Nos tomamos muy en serio el CSAM y, por ello, no dejaremos de actualizar nuestros mecanismos de detección, bloqueo y notificación. Es posible que las leyes aplicables le exijan que tome medidas adicionales. Usted es responsable de tomar dichas medidas.
Cuando nuestros mecanismos automatizados de detección de abusos identifiquen posibles infracciones, podemos solicitar información sobre el uso que hace de Inferencia de Amazon SageMaker y sobre el cumplimiento de nuestras condiciones del servicio. En el caso de que no responda, se niegue o no pueda cumplir con estos términos o políticas, AWS podría suspender su acceso a Inferencia de Amazon SageMaker. También es posible que se le facturen los trabajos de inferencia que hayan fallado si nuestras pruebas automatizadas detectan que las respuestas de los modelos no cumplen con nuestros términos y políticas.
Si tiene alguna pregunta, póngase en contacto con AWS Support. Para obtener más información, consulte [Preguntas frecuentes sobre Amazon SageMaker](https://aws.amazon.com/sagemaker/ai/faqs/).