Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # SageMaker Folgerung Benutzerdefinierte Amazon Nova-Modelle sind jetzt auf SageMaker Inference verfügbar. Wenn Amazon Nova aktiviert ist SageMaker, können Sie damit beginnen, Prognosen oder Schlussfolgerungen aus Ihren trainierten benutzerdefinierten Amazon Nova-Modellen zu ziehen. SageMaker bietet eine breite Auswahl an Optionen zur ML-Infrastruktur und Modellbereitstellung, um all Ihren Anforderungen an ML-Inferenz gerecht zu werden. Mit SageMaker Inferenz können Sie Ihre Modellbereitstellung skalieren, Modelle in der Produktion effektiver verwalten und den betrieblichen Aufwand reduzieren. SageMaker bietet Ihnen verschiedene Inferenzoptionen, z. B. Echtzeit-Endpunkte für Inferenzen mit geringer Latenz und asynchrone Endpunkte für Batches von Anfragen. Indem Sie die für Ihren Anwendungsfall geeignete Inferenzoption nutzen, können Sie eine effiziente Modellbereitstellung und Inferenz sicherstellen. [Weitere Informationen zur Inferenz finden Sie unter Bereitstellen von Modellen für SageMaker Inferenz.](https://docs.aws.amazon.com//sagemaker/latest/dg/deploy-model.html) **Wichtig** Bei der Inferenz werden nur benutzerdefinierte Modelle mit vollem Rang und mit LoRa zusammengeführte Modelle unterstützt. SageMaker Verwenden Sie Amazon Bedrock für LoRa-Modelle und Basismodelle, die nicht zusammengeführt wurden. ## Features Die folgenden Funktionen sind für Amazon Nova-Modelle auf SageMaker Inferenz verfügbar: **Funktionen des Modells** + Textgenerierung **Bereitstellung und Skalierung** + Echtzeit-Endpunkte mit benutzerdefinierter Instanzauswahl + Auto Scaling — Passen Sie die Kapazität automatisch an die Verkehrsmuster an, um Kosten und GPU-Auslastung zu optimieren. Weitere Informationen finden Sie unter [Automatisches Skalieren von SageMaker Amazon-Modellen](https://docs.aws.amazon.com//sagemaker/latest/dg/endpoint-auto-scaling.html). + Streaming-API-Unterstützung für die Token-Generierung in Echtzeit **Überwachung und Optimierung** + CloudWatch Amazon-Integration für Überwachung und Benachrichtigungen + Latenzoptimierung unter Berücksichtigung der Availability Zone durch VPC-Konfiguration **Entwicklungstools** + AWS CLI support — Weitere Informationen finden Sie in der [AWS CLI-Befehlsreferenz für SageMaker](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/). + Notebook-Integration über SDK-Unterstützung ## Unterstützte Modelle und Instanzen Bei der Erstellung Ihrer SageMaker Inferenzendpunkte können Sie zwei Umgebungsvariablen festlegen, um Ihre Bereitstellung zu konfigurieren: `CONTEXT_LENGTH` und. `MAX_CONCURRENCY` + `CONTEXT_LENGTH`— Maximale Gesamtlänge des Tokens (Eingabe \$1 Ausgabe) pro Anfrage + `MAX_CONCURRENCY`— Maximale Anzahl gleichzeitiger Anfragen, die der Endpunkt bearbeiten wird In der folgenden Tabelle sind die unterstützten Amazon Nova-Modelle, Instance-Typen und unterstützten Konfigurationen aufgeführt. Die MAX\$1CONCURRENCY-Werte stellen die maximale unterstützte Parallelität für jede CONTEXT\$1LENGTH-Einstellung dar: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/nova/latest/nova2-userguide/nova-model-sagemaker-inference.html) **Anmerkung** Die angezeigten MAX\$1CONCURRENCY-Werte sind Obergrenzen für jede CONTEXT\$1LENGTH-Einstellung. Sie können niedrigere Kontextlängen bei derselben Parallelität verwenden, aber eine Überschreitung dieser Werte führt dazu, dass die Endpunkterstellung fehlschlägt. SageMaker Zum Beispiel auf Amazon Nova Micro mit einem ml.g5.12xlarge: `CONTEXT_LENGTH=2000``MAX_CONCURRENCY=32`, → Gültig `CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=32` → Abgelehnt (Parallelitätslimit liegt bei 16 bei einer Kontextlänge von 8000) `CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=4` → Gültig `CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=16` → Gültig `CONTEXT_LENGTH=10000`→ Abgelehnt (die maximale Kontextlänge beträgt 8000 auf dieser Instanz) ## Unterstützte AWS Regionen In der folgenden Tabelle sind die AWS Regionen aufgeführt, in denen Amazon Nova-Modelle auf SageMaker Inferenz verfügbar sind: **** | Name der Region | Regionscode | Verfügbarkeit | | --- | --- | --- | | USA Ost (Nord-Virginia) | us-east-1 | Available (Verfügbar) | | USA West (Oregon) | us-west-2 | Available (Verfügbar) | ## Unterstützte Container-Images In der folgenden Tabelle ist das Container-Image URIs für Amazon Nova-Modelle nach SageMaker Inferenz nach Regionen aufgeführt. Für jede Region sind zwei Bild-Tags verfügbar: ein versioniertes Tag (`v1.0.0`) und ein neuestes Tag (`SM-Inference-latest`). Für Produktionsbereitstellungen empfehlen wir die Verwendung des versionierten Tags. **** | Region | Container-Image 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 | ## Bewährte Methoden Bewährte Methoden für die Bereitstellung und Verwaltung von Modellen auf SageMaker finden Sie unter [Bewährte Methoden für SageMaker](https://docs.aws.amazon.com//sagemaker/latest/dg/best-practices.html). ## Support Bei Problemen und Support mit Amazon Nova-Modellen auf SageMaker Inferenz wenden Sie sich über die Konsole oder Ihren AWS Kundenbetreuer an den AWS Support. **Topics** + [ ## Features ](#nova-sagemaker-inference-features) + [ ## Unterstützte Modelle und Instanzen ](#nova-sagemaker-inference-supported) + [ ## Unterstützte AWS Regionen ](#nova-sagemaker-inference-regions) + [ ## Unterstützte Container-Images ](#nova-sagemaker-inference-container-images) + [ ## Bewährte Methoden ](#nova-sagemaker-inference-best-practices) + [ ## Support ](#nova-sagemaker-inference-support) + [ # Erste Schritte ](nova-sagemaker-inference-getting-started.md) + [ # API-Referenz ](nova-sagemaker-inference-api-reference.md) + [ # Evaluieren Sie auf SageMaker Inference gehostete Modelle ](nova-eval-on-sagemaker-inference.md) + [ # Einsatz von Amazon Nova Forge-Modellen bei der Missbrauchserkennung von Amazon SageMaker Inference ](nova-sagemaker-inference-abuse-detection.md) # Erste Schritte In diesem Handbuch erfahren Sie, wie Sie maßgeschneiderte Amazon Nova-Modelle auf SageMaker Echtzeit-Endpunkten bereitstellen, Inferenzparameter konfigurieren und Ihre Modelle zu Testzwecken aufrufen. ## Voraussetzungen Die folgenden Voraussetzungen müssen erfüllt sein, um Amazon Nova-Modelle auf Basis von SageMaker Inferenz bereitzustellen: + Erstellen Sie ein AWS-Konto — Falls Sie noch keines haben, finden Sie weitere Informationen unter [AWS Konto erstellen](https://docs.aws.amazon.com//sagemaker/latest/dg/gs-set-up.html#sign-up-for-aws). + Erforderliche IAM-Berechtigungen — Stellen Sie sicher, dass Ihrem IAM-Benutzer oder Ihrer IAM-Rolle die folgenden verwalteten Richtlinien zugeordnet sind: + `AmazonSageMakerFullAccess` + `AmazonS3FullAccess` + Erforderliche SDKs/CLI Versionen — Die folgenden SDK-Versionen wurden mit Amazon Nova-Modellen auf SageMaker Inferenz getestet und validiert: + SageMaker Python SDK v3.0.0\$1 (`sagemaker>=3.0.0`) für ressourcenbasierten API-Ansatz + Boto3 Version 1.35.0\$1 () für direkte API-Aufrufe. `boto3>=1.35.0` Die Beispiele in diesem Handbuch verwenden diesen Ansatz. + Erhöhung des Servicekontingents — Fordern Sie eine Erhöhung des Amazon SageMaker Service-Kontingents für den ML-Instance-Typ an, den Sie für Ihren SageMaker Inference-Endpunkt verwenden möchten (z. B.`ml.p5.48xlarge for endpoint usage`). Eine Liste mit unterstützten Instance-Typen finden Sie unter [Unterstützte Modelle und Instanzen](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported). Informationen zur Beantragung einer Erhöhung finden Sie unter [Eine Erhöhung des Kontingents beantragen](https://docs.aws.amazon.com//servicequotas/latest/userguide/request-quota-increase.html). Informationen zu SageMaker Instanzkontingenten finden Sie unter [SageMaker Endpunkte und Kontingente](https://docs.aws.amazon.com//general/latest/gr/sagemaker.html). ## Schritt 1: Anmeldeinformationen konfigurieren AWS Konfigurieren Sie Ihre AWS Anmeldeinformationen mit einer der folgenden Methoden: **Option 1: AWS CLI (Empfohlen)** ``` aws configure ``` Geben Sie Ihren AWS Zugriffsschlüssel, Ihren geheimen Schlüssel und Ihre Standardregion ein, wenn Sie dazu aufgefordert werden. **Option 2: Datei mit den AWS Anmeldeinformationen** Erstellen oder bearbeiten`~/.aws/credentials`: ``` [default] aws_access_key_id = YOUR_ACCESS_KEY aws_secret_access_key = YOUR_SECRET_KEY ``` **Option 3: Umgebungsvariablen** ``` export AWS_ACCESS_KEY_ID=your_access_key export AWS_SECRET_ACCESS_KEY=your_secret_key ``` **Anmerkung** Weitere Informationen zu AWS Anmeldeinformationen finden Sie unter [Konfiguration und Einstellungen für Anmeldeinformationsdateien](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-files.html). **Clients initialisieren AWS ** Erstellen Sie ein Python-Skript oder ein Notizbuch mit dem folgenden Code, um das AWS SDK zu initialisieren und Ihre Anmeldeinformationen zu überprüfen: ``` 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.") ``` Wenn die Authentifizierung erfolgreich ist, sollten Sie eine Ausgabe sehen, die Ihre AWS Konto-ID bestätigt. ## Schritt 2: Erstellen Sie eine SageMaker Ausführungsrolle Eine SageMaker Ausführungsrolle ist eine IAM-Rolle, die SageMaker Berechtigungen für den Zugriff auf AWS Ressourcen in Ihrem Namen gewährt, z. B. Amazon S3 S3-Buckets für Modellartefakte und CloudWatch für die Protokollierung. **Die Ausführungsrolle erstellen** **Anmerkung** Für die Erstellung von IAM-Rollen sind `iam:AttachRolePolicy` Berechtigungen `iam:CreateRole` und Voraussetzungen erforderlich. Stellen Sie sicher, dass Ihr IAM-Benutzer oder Ihre IAM-Rolle über diese Berechtigungen verfügt, bevor Sie fortfahren. Der folgende Code erstellt eine IAM-Rolle mit den erforderlichen Berechtigungen für die Bereitstellung benutzerdefinierter Amazon Nova-Modelle: ``` 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}") ``` **Verwenden einer vorhandenen Ausführungsrolle (optional)** Wenn Sie bereits über eine SageMaker Ausführungsrolle verfügen, können Sie diese stattdessen verwenden: ``` # Replace with your existing role ARN SAGEMAKER_EXECUTION_ROLE_ARN = "arn:aws:iam::YOUR_ACCOUNT_ID:role/YOUR_EXISTING_ROLE_NAME" ``` So finden Sie bestehende SageMaker Rollen in Ihrem Konto: ``` 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']}") ``` **Wichtig** Die Ausführungsrolle muss über eine Vertrauensbeziehung zu Amazon S3 `sagemaker.amazonaws.com` und SageMaker Ressourcen verfügen und über Zugriffsberechtigungen verfügen. Weitere Informationen zu SageMaker Ausführungsrollen finden Sie unter [SageMaker Rollen](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html). ## Schritt 3: Modellparameter konfigurieren Konfigurieren Sie die Bereitstellungsparameter für Ihr Amazon Nova-Modell. Diese Einstellungen steuern das Modellverhalten, die Ressourcenzuweisung und die Inferenzmerkmale. Eine Liste der unterstützten Instanztypen und der jeweils unterstützten Werte für CONTEXT\$1LENGTH und MAX\$1CONCURRENCY finden Sie unter. [Unterstützte Modelle und Instanzen](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported) **Erforderliche Parameter** + `IMAGE`: Die Docker-Container-Image-URI für den Amazon Nova-Inferenzcontainer. Dies wird bereitgestellt von. AWS + `CONTEXT_LENGTH`: Länge des Modellkontextes. + `MAX_CONCURRENCY`: Maximale Anzahl von Sequenzen pro Iteration; legt die Grenze fest, wie viele einzelne Benutzeranfragen (Eingabeaufforderungen) gleichzeitig innerhalb eines einzelnen Batches auf der GPU verarbeitet werden können. Bereich: Ganzzahl größer als 0. **Optionale Generierungsparameter** + `DEFAULT_TEMPERATURE`: Steuert die Zufälligkeit bei der Generierung. Bereich: 0,0 bis 2,0 (0,0 = deterministisch, höher = eher zufällig). + `DEFAULT_TOP_P`: Nucleus-Sampling-Schwellenwert für die Token-Auswahl. Bereich: 1e-10 bis 1,0. + `DEFAULT_TOP_K`: Beschränkt die Token-Auswahl auf die Top K der wahrscheinlichsten Tokens. Bereich: Ganzzahl -1 oder größer (-1 = kein Limit). + `DEFAULT_MAX_NEW_TOKENS`: Maximale Anzahl von Token, die als Antwort generiert werden sollen (d. h. maximale Anzahl von Ausgabetoken). Bereich: Ganzzahl 1 oder größer. + `DEFAULT_LOGPROBS`: Anzahl der Log-Wahrscheinlichkeiten, die pro Token zurückgegeben werden sollen. Bereich: Ganzzahl 1 bis 20. **Konfigurieren Sie Ihre Bereitstellung** ``` # 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}") ``` **Konfigurieren Sie bereitstellungsspezifische Parameter** Konfigurieren Sie jetzt die spezifischen Parameter für Ihre Amazon Nova-Modellbereitstellung, einschließlich des Standorts der Modellartefakte und der Auswahl des Instance-Typs. **Legen Sie die Bereitstellungs-ID fest** ``` # Deployment identifier - use a descriptive name for your use case JOB_NAME = "my-nova-deployment" ``` **Geben Sie den Speicherort der Modellartefakte** Geben Sie die Amazon S3 S3-URI an, in der Ihre trainierten Amazon Nova-Modellartefakte gespeichert sind. Dies sollte der Ausgabeort für Ihr Modelltraining oder Ihre Feinabstimmung sein. ``` # 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/" ``` **Wählen Sie die Modellvariante und den Instanztyp** ``` # 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}") ``` **Benennungskonventionen** Der Code generiert automatisch konsistente Namen für AWS Ressourcen: + Modellname: `{JOB_NAME}-{model}-{instance-type}` + Endpunktkonfiguration: `{MODEL_NAME}-Config` + Name des Endpunkts: `{MODEL_NAME}-Endpoint` ## Schritt 4: SageMaker Modell und Endpunktkonfiguration erstellen In diesem Schritt erstellen Sie zwei wichtige Ressourcen: ein SageMaker Modellobjekt, das auf Ihre Amazon Nova-Modellartefakte verweist, und eine Endpunktkonfiguration, die definiert, wie das Modell bereitgestellt wird. **SageMaker Modell**: Ein Modellobjekt, das das Inferenzcontainer-Image, den Speicherort der Modellartefakte und die Umgebungskonfiguration verpackt. Dies ist eine wiederverwendbare Ressource, die auf mehreren Endpunkten bereitgestellt werden kann. **Endpunktkonfiguration**: Definiert die Infrastruktureinstellungen für die Bereitstellung, einschließlich Instanztyp, Anzahl der Instanzen und Modellvarianten. Auf diese Weise können Sie die Bereitstellungseinstellungen getrennt vom Modell selbst verwalten. **Erstellen Sie das SageMaker Modell** Der folgende Code erstellt ein SageMaker Modell, das auf Ihre Amazon Nova-Modellartefakte verweist: ``` 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}") ``` Hauptparameter: + `ModelName`: Eindeutiger Bezeichner für Ihr Modell + `Image`: Docker-Container-Image-URI für Amazon Nova-Inferenz + `ModelDataSource`: Amazon S3 S3-Standort Ihrer Modellartefakte + `Environment`: In Schritt 3 konfigurierte Umgebungsvariablen + `ExecutionRoleArn`: IAM-Rolle aus Schritt 2 + `EnableNetworkIsolation`: Aus Sicherheitsgründen auf True setzen (verhindert, dass der Container ausgehende Netzwerkanrufe tätigt) **Erstellen Sie die Endpunktkonfiguration** Erstellen Sie als Nächstes eine Endpunktkonfiguration, die Ihre Bereitstellungsinfrastruktur definiert: ``` # 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}") ``` Hauptparameter: + `VariantName`: Identifier für diese Modellvariante (verwenden Sie „primary“ für Implementierungen mit nur einem Modell) + `ModelName`: Verweist auf das oben erstellte Modell + `InitialInstanceCount`: Anzahl der bereitzustellenden Instanzen (beginnen Sie mit 1, skalieren Sie bei Bedarf später) + `InstanceType`: In Schritt 3 ausgewählter ML-Instanztyp **Überprüfen Sie die Ressourcenerstellung** Sie können überprüfen, ob Ihre Ressourcen erfolgreich erstellt wurden: ``` # 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") ``` ## Schritt 5: Stellen Sie den Endpunkt bereit Der nächste Schritt besteht darin, Ihr Amazon Nova-Modell bereitzustellen, indem Sie einen SageMaker Echtzeit-Endpunkt erstellen. Dieser Endpunkt hostet Ihr Modell und bietet einen sicheren HTTPS-Endpunkt für Inferenzanfragen. Die Erstellung von Endpunkten dauert in der Regel 15 bis 30 Minuten, AWS da die Infrastruktur bereitgestellt, Ihre Modellartefakte heruntergeladen und der Inferenzcontainer initialisiert wird. **Endpunkt erstellen** ``` 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}") ``` **Überwachung der Endpunkterstellung** Der folgende Code fragt den Endpunktstatus ab, bis die Bereitstellung abgeschlossen ist: ``` # 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 ``` **Überprüfen Sie, ob der Endpunkt bereit ist** Sobald der Endpunkt fertig ist InService, können Sie seine Konfiguration überprüfen: ``` # 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 ``` **Behebung von Fehlern bei der Endpunkterstellung** Häufige Fehlerursachen: + **Unzureichende Kapazität**: Der angeforderte Instance-Typ ist in Ihrer Region nicht verfügbar + Lösung: Probieren Sie einen anderen Instance-Typ aus oder fordern Sie eine Erhöhung des Kontingents an + **IAM-Berechtigungen**: Der Ausführungsrolle fehlen die erforderlichen Berechtigungen + Lösung: Stellen Sie sicher, dass die Rolle Zugriff auf Amazon S3 S3-Modellartefakte und die erforderlichen SageMaker Berechtigungen hat + **Modellartefakte wurden nicht gefunden**: Die Amazon S3 S3-URI ist falsch oder es kann nicht darauf zugegriffen werden + Lösung: Überprüfen Sie die Amazon S3 S3-URI und überprüfen Sie die Bucket-Berechtigungen. Stellen Sie sicher, dass Sie sich in der richtigen Region befinden + **Ressourcenlimits**: Die Kontolimits für Endpunkte oder Instances wurden überschritten + Lösung: Beantragen Sie eine Erhöhung des Servicekontingents über Service Quotas oder AWS Support **Anmerkung** Wenn Sie einen ausgefallenen Endpunkt löschen und von vorne beginnen müssen: ``` sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME) ``` ## Schritt 6: Rufen Sie den Endpunkt auf Sobald Ihr Endpunkt da ist InService, können Sie Inferenzanfragen senden, um Prognosen aus Ihrem Amazon Nova-Modell zu generieren. SageMaker unterstützt synchrone Endpunkte (Echtzeit mit Streaming-/Nicht-Streaming-Modi) und asynchrone Endpunkte (Amazon S3-basiert für Batch-Verarbeitung). **Richten Sie den Runtime-Client ein** Erstellen Sie einen SageMaker Runtime-Client mit den entsprechenden Timeout-Einstellungen: ``` 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) ``` **Erstellen Sie eine universelle Inferenzfunktion** Die folgende Funktion verarbeitet sowohl Streaming- als auch Nicht-Streaming-Anfragen: ``` 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)}") ``` **Beispiel 1: Abschluss eines Chats ohne Streaming** Verwenden Sie das Chat-Format für Konversationsinteraktionen: ``` # 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) ``` **Beispielantwort**: ``` { "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 } } ``` **Beispiel 2: Einfache Textvervollständigung** Verwenden Sie das Vervollständigungsformat für die einfache Textgenerierung: ``` # 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) ``` **Beispielantwort**: ``` { "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 } } ``` **Beispiel 3: Abschluss des Streaming-Chats** ``` # 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) ``` **Beispiel für eine Streaming-Ausgabe:** ``` 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] ``` **Beispiel 4: Abschluss eines multimodalen Chats** Verwenden Sie das multimodale Format für Bild- und Texteingaben: ``` # 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) ``` **Beispielantwort**: ``` { "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 } } ``` ## Schritt 7: Ressourcen bereinigen (optional) Um unnötige Kosten zu vermeiden, löschen Sie die AWS Ressourcen, die Sie in diesem Tutorial erstellt haben. SageMaker Bei Endpunkten fallen Gebühren an, während sie laufen, auch wenn Sie nicht aktiv Inferenzanfragen stellen. **Wichtig** Das Löschen von Ressourcen ist dauerhaft und kann nicht rückgängig gemacht werden. Stellen Sie sicher, dass Sie diese Ressourcen nicht mehr benötigen, bevor Sie fortfahren. **Löschen Sie den Endpunkt** ``` 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}") ``` **Anmerkung** Das Löschen des Endpunkts erfolgt asynchron. Sie können den Löschstatus überwachen: ``` 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 ``` **Löschen Sie die Endpunktkonfiguration** Nachdem der Endpunkt gelöscht wurde, entfernen Sie die Endpunktkonfiguration: ``` 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}") ``` **Löschen Sie das Modell** Entfernen Sie das SageMaker Modellobjekt: ``` 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}") ``` # API-Referenz Amazon Nova-Modelle SageMaker verwenden die SageMaker Standard-Runtime-API für Inferenz. Eine vollständige API-Dokumentation finden Sie unter [Testen eines bereitgestellten Modells.](https://docs.aws.amazon.com//sagemaker/latest/dg/realtime-endpoints-test-endpoints.html) ## Aufruf von Endpunkten Amazon Nova-Modelle auf SageMaker unterstützen zwei Aufrufmethoden: + **Synchroner Aufruf**: Verwenden Sie die [InvokeEndpoint](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)API für Inferenzanfragen in Echtzeit, die kein Streaming erfordern. + **Streaming-Aufruf**: Verwenden Sie die [InvokeEndpointWithResponseStream](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html)API für Streaming-Inferenzanfragen in Echtzeit. ## Anforderungsformat Amazon Nova-Modelle unterstützen zwei Anforderungsformate: **Format für den Abschluss des Chats** Verwenden Sie dieses Format für Konversationsinteraktionen: ``` { "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 } } ``` **Format für die Textvervollständigung** Verwenden Sie dieses Format für die einfache Textgenerierung: ``` { "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 } } ``` **Format für die Fertigstellung eines multimodalen Chats** Verwenden Sie dieses Format für Bild- und Texteingaben: ``` { "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 } ``` **Anfrageparameter** + `messages`(Array): Für das Format zum Abschluss eines Chats. Array von Nachrichtenobjekten mit `content` Feldern `role` und. Inhalt kann eine Zeichenfolge für reine Texteingaben oder ein Array für multimodale Eingaben sein. + `prompt`(Zeichenfolge): Für das Textvervollständigungsformat. Der Eingabetext, aus dem generiert werden soll. + `max_tokens`(Ganzzahl): Maximale Anzahl von Token, die in der Antwort generiert werden sollen. Bereich: 1 oder größer. + `max_completion_tokens`(Ganzzahl): Alternative zu max\$1tokens für Chat-Abschlüsse. Maximale Anzahl der zu generierenden Abschluss-Token. + `temperature`(float): Steuert die Zufälligkeit bei der Generierung. Bereich: 0,0 bis 2,0 (0,0 = deterministisch, 2,0 = maximale Zufälligkeit). + `top_p`(Float): Schwellenwert für die Nukleus-Probenahme. Bereich: 1e-10 bis 1,0. + `top_k`(Ganzzahl): Beschränkt die Token-Auswahl auf die Top K der wahrscheinlichsten Tokens. Bereich: -1 oder größer (-1 = kein Limit). + `stream`(boolean): Ob die Antwort gestreamt werden soll. Auf für Streaming, `true` für Nicht-Streaming eingestellt. `false` + `logprobs`(boolesch/Ganzzahl): Verwenden Sie für Chat-Abschlüsse den booleschen Wert. Verwenden Sie für Textvervollständigungen eine Ganzzahl für die Anzahl der zurückzugebenden Log-Wahrscheinlichkeiten. Bereich: 1 bis 20. + `top_logprobs`(Ganzzahl): Anzahl der Token, für die die Wahrscheinlichkeit am wahrscheinlichsten ist, dass Log-Wahrscheinlichkeiten zurückgegeben werden (nur Chat-Abschlüsse). + `reasoning_effort`(Zeichenfolge): Umfang des Argumentationsaufwands. Optionen: „niedrig“, „hoch“ (Chat-Abschlüsse nur für benutzerdefinierte Nova 2 Lite-Modelle). + `allowed_token_ids`(Array): Liste der Token IDs , die generiert werden dürfen. Beschränkt die Ausgabe auf bestimmte Token. + `truncate_prompt_tokens`(Ganzzahl): Kürzt die Eingabeaufforderung auf diese Anzahl von Token, wenn sie das Limit überschreitet. + `stream_options`(Objekt): Optionen für das Streamen von Antworten. Enthält einen `include_usage` booleschen Wert, um die Token-Verwendung in Streaming-Antworten einzubeziehen. ## Reaktionsformat Das Antwortformat hängt von der Aufrufmethode und dem Anforderungstyp ab: **Antwort auf den Abschluss des Chats (kein Streaming)** Für Anfragen zum synchronen Abschluss eines Chats: ``` { "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] } ``` **Antwort auf die Textvervollständigung (kein Streaming)** Für Anfragen zur synchronen Textvervollständigung: ``` { "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 } } } ``` **Streaming-Antwort auf Abschluss des Chats** Bei Anfragen zur Beendigung des Streaming-Chats werden Antworten als vom Server gesendete Ereignisse (SSE) gesendet: ``` 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] ``` **Streaming-Antwort zur Textvervollständigung** Für Streaming-Anfragen zur Textvervollständigung: ``` 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] ``` **Erklärung der Antwortfelder** + `id`: Eindeutiger Bezeichner für den Abschluss + `object`: Typ des zurückgegebenen Objekts („chat.completion“, „text\$1completion“, „chat.completion.chunk“) + `created`: Unix-Zeitstempel, wann die Vervollständigung erstellt wurde + `model`: Für die Fertigstellung verwendetes Modell + `choices`: Eine Reihe von Optionen für die Fertigstellung + `usage`: Informationen zur Token-Nutzung, einschließlich Eingabeaufforderung, Fertigstellung und Gesamtzahl der Tokens + `logprobs`: Informationen zur Wahrscheinlichkeit von Tokens protokollieren (falls angefordert) + `finish_reason`: Grund, warum das Modell die Generierung eingestellt hat („stop“, „length“, „content\$1filter“) + `delta`: Inkrementeller Inhalt in Streaming-Antworten + `reasoning`: Inhalt zur Argumentation, wenn reasoning\$1effort verwendet wird + `token_ids`: Token-Array für den generierten Text IDs Eine vollständige API-Dokumentation finden Sie unter [InvokeEndpoint API-Referenz](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) und [InvokeEndpointWithResponseStream API-Referenz](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html). # Evaluieren Sie auf SageMaker Inference gehostete Modelle In diesem Leitfaden wird erklärt, wie Sie Ihre maßgeschneiderten Amazon Nova-Modelle, die auf SageMaker Inferenzendpunkten bereitgestellt werden, mithilfe von [Inspect AI](https://github.com/UKGovernmentBEIS/inspect_ai), einem Open-Source-Evaluierungsframework, bewerten können. **Anmerkung** [Eine praktische Anleitung finden Sie im Schnellstart-Notizbuch von Inspect AI. SageMaker ](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/sagemaker-inference/sagemaker_inspect_quickstart.ipynb) ## -Übersicht Sie können Ihre maßgeschneiderten Amazon Nova-Modelle, die auf SageMaker Endgeräten bereitgestellt werden, anhand standardisierter Benchmarks der KI-Forschungsgemeinschaft bewerten. Dieser Ansatz ermöglicht Ihnen: + Evaluieren Sie maßgeschneiderte Amazon Nova-Modelle (fein abgestimmt, destilliert oder anderweitig angepasst) in großem Maßstab + Führen Sie Evaluierungen mit parallel Inferenz über mehrere Endpunktinstanzen hinweg durch + Vergleichen Sie die Modellleistung anhand von Benchmarks wie MMLU, TruthfulQA und HumanEval + Integrieren Sie es in Ihre bestehende Infrastruktur SageMaker ## Unterstützte Modelle Der SageMaker Inferenzanbieter arbeitet mit: + Amazon Nova-Modelle (Nova Micro, Nova Lite, Nova Lite 2) + Modelle, die über VllM- oder OpenAI-kompatible Inferenzserver bereitgestellt werden + Jeder Endpunkt, der das OpenAI Chat Completions API-Format unterstützt ## Voraussetzungen Stellen Sie vor Beginn sicher, dass Sie über Folgendes verfügen: + Und AWS-Konto mit Berechtigungen zum Erstellen und Aufrufen von Endpunkten SageMaker + AWS Anmeldeinformationen AWS CLI, die über Umgebungsvariablen oder die IAM-Rolle konfiguriert wurden + Python 3.9 oder höher **Erforderliche IAM-Berechtigungen** Ihr IAM-Benutzer oder Ihre IAM-Rolle benötigt die folgenden Berechtigungen: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "sagemaker:InvokeEndpoint", "sagemaker:DescribeEndpoint" ], "Resource": "arn:aws:sagemaker:*:*:endpoint/*" } ] } ``` ## Schritt 1: Stellen Sie einen SageMaker Endpunkt bereit Bevor Sie Evaluierungen durchführen, benötigen Sie einen SageMaker Inferenzendpunkt, auf dem Ihr Modell ausgeführt wird. Anweisungen zum Erstellen eines SageMaker Inferenzendpunkts mit Amazon Nova-Modellen finden Sie unter[Erste Schritte](nova-sagemaker-inference-getting-started.md). Sobald sich Ihr Endpunkt im `InService` Status befindet, notieren Sie sich den Endpunktnamen, der in den Evaluierungsbefehlen verwendet werden soll. ## Schritt 2: Installieren Sie die Evaluierungsabhängigkeiten Erstellen Sie eine virtuelle Python-Umgebung und installieren Sie die erforderlichen Pakete. ``` # 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 ``` ## Schritt 3: AWS Anmeldeinformationen konfigurieren Wählen Sie eine der folgenden Authentifizierungsmethoden: **Option 1: AWS CLI (Empfohlen)** ``` aws configure ``` Geben Sie Ihre AWS Zugangsschlüssel-ID, Ihren geheimen Zugriffsschlüssel und Ihre Standardregion ein, wenn Sie dazu aufgefordert werden. **Option 2: Umgebungsvariablen** ``` export AWS_ACCESS_KEY_ID=your_access_key export AWS_SECRET_ACCESS_KEY=your_secret_key export AWS_DEFAULT_REGION=us-west-2 ``` **Option 3: IAM-Rolle** Bei Ausführung auf Amazon EC2 oder SageMaker Notebooks wird die IAM-Rolle der Instance automatisch verwendet. **Überprüfen Sie die Anmeldeinformationen** ``` import boto3 sts = boto3.client('sts') identity = sts.get_caller_identity() print(f"Account: {identity['Account']}") print(f"User/Role: {identity['Arn']}") ``` ## Schritt 4: Installieren Sie den SageMaker Anbieter Der SageMaker Anbieter ermöglicht Inspect AI die Kommunikation mit Ihren SageMaker Endpunkten. Der Installationsprozess des Anbieters wird im [Schnellstart-Notizbuch](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/sagemaker-inference/sagemaker_inspect_quickstart.ipynb) optimiert. ## Schritt 5: Laden Sie die Evaluierungs-Benchmarks herunter Klonen Sie das Inspect Evals-Repository, um auf Standard-Benchmarks zuzugreifen: ``` git clone https://github.com/UKGovernmentBEIS/inspect_evals.git ``` Dieses Repository enthält Benchmarks wie: + MMLU und MMLU-Pro (Wissen und Argumentation) + TruthfulQA (Wahrhaftigkeit) + HumanEval (Codegenerierung) + GSM8K (mathematisches Denken) ## Schritt 6: Evaluierungen durchführen Führen Sie eine Evaluierung mit Ihrem SageMaker Endpunkt durch: ``` 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 ``` **Die wichtigsten Parameter** | Parameter | Standard | Description | | --- | --- | --- | | --max-connections | 10 | Anzahl der parallel Anfragen an den Endpunkt. Skalieren Sie mit der Anzahl der Instanzen (z. B. 10 Instanzen × 25 = 250). | | --max-retries | 3 | Versuchen Sie es erneut mit fehlgeschlagenen Anfragen. Verwenden Sie 50-100 für umfangreiche Auswertungen. | | -M region\$1name | us-east-1 | AWS Region, in der Ihr Endpunkt bereitgestellt wird. | | -M read\$1timeout | 600 | Timeout in Sekunden anfordern. | | -M connect\$1timeout | 60 | Verbindungs-Timeout in Sekunden. | **Empfehlungen zur Optimierung** Für einen Endpunkt mit mehreren Instanzen: ``` # 10-instance endpoint example --max-connections 250 # ~25 connections per instance --max-retries 100 # Handle transient errors ``` Eine `--max-connections` zu hohe Einstellung kann den Endpunkt überfordern und zu Drosselung führen. Wenn er zu niedrig eingestellt ist, wird die Kapazität nicht ausreichend genutzt. ## Schritt 7: Ergebnisse anzeigen Starten Sie den Inspect AI Viewer, um die Bewertungsergebnisse zu analysieren: ``` inspect view ``` Der Viewer zeigt: + Allgemeine Punktzahlen und Kennzahlen + Ergebnisse pro Stichprobe mit Modellantworten + Fehleranalyse und Fehlermuster ## Verwaltung von Endpunkten **Aktualisieren Sie einen Endpunkt** So aktualisieren Sie einen vorhandenen Endpunkt mit einem neuen Modell oder einer neuen Konfiguration: ``` 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 ) ``` **Löschen Sie einen Endpunkt** ``` sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME) ``` ## Einführung benutzerdefinierter Benchmarks Mithilfe des folgenden Workflows können Sie Inspect AI neue Benchmarks hinzufügen: 1. Studieren Sie das Datensatzformat und die Bewertungskennzahlen des Benchmarks 1. Überprüfen Sie ähnliche Implementierungen in `inspect_evals/` 1. Erstellen Sie eine Aufgabendatei, die Datensatzdatensätze in Inspect AI-Beispiele konvertiert 1. Implementieren Sie geeignete Solver und Scorer 1. Validieren Sie mit einem kleinen Testlauf Beispiel für eine Aufgabenstruktur: ``` 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() ) ``` ## Fehlerbehebung **Häufig auftretende Probleme** **Drosselung oder Timeouts an Endpunkten** + Reduzieren `--max-connections` + Erhöhen `--max-retries` + Überprüfen Sie die CloudWatch Endpunktmetriken auf Kapazitätsprobleme **Fehler bei der Authentifizierung** + Stellen Sie sicher, dass die AWS Anmeldeinformationen korrekt konfiguriert sind + Überprüfen Sie, ob die IAM-Berechtigungen Folgendes beinhalten `sagemaker:InvokeEndpoint` **Fehler im Modell** + Stellen Sie sicher, dass sich der Endpunkt im `InService` Status befindet + Stellen Sie sicher, dass das Modell das OpenAI Chat Completions API-Format unterstützt ## Zugehörige Ressourcen + [Untersuchen Sie die KI-Dokumentation](https://inspect.ai-safety-institute.org.uk/) + [Untersuchen Sie das Evals Repository](https://github.com/UKGovernmentBEIS/inspect_evals) + [SageMaker Entwicklerhandbuch](https://docs.aws.amazon.com//sagemaker/latest/dg/whatis.html) + [Stellen Sie Modelle für Inferenz bereit](https://docs.aws.amazon.com//sagemaker/latest/dg/deploy-model.html) + [Konfiguration des AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-configure.html) # Einsatz von Amazon Nova Forge-Modellen bei der Missbrauchserkennung von Amazon SageMaker Inference AWS setzt sich für den verantwortungsvollen Umgang mit KI ein. Um potenziellen Missbrauch zu verhindern, implementiert Inference bei der Bereitstellung von Amazon Nova Forge-Modellen in Amazon SageMaker Inference automatisierte Mechanismen zur Missbrauchserkennung, SageMaker um potenzielle Verstöße gegen die [Acceptable Use Policy](https://aws.amazon.com/aup/) (AUP) und die Servicebedingungen, einschließlich der [Responsible](https://aws.amazon.com/ai/responsible-ai/policy/) AI Policy, zu identifizieren. AWS Unsere Mechanismen zur Missbrauchserkennung sind vollständig automatisiert, sodass es keine menschliche Überprüfung von oder menschlichen Zugriff auf Benutzereingaben oder Modellausgaben gibt. Die automatische Missbrauchserkennung umfasst: + **Inhalte kategorisieren** — Wir verwenden Klassifikatoren, um schädliche Inhalte (z. B. Inhalte, die zu Gewalt aufrufen) in Benutzereingaben und Modellausgaben zu erkennen. Ein Klassifizierer ist ein Algorithmus, der Modellein- und -ausgaben verarbeitet und die Art des Schadens und das Maß der Zuverlässigkeit zuweist. Wir können diese Klassifikatoren bei Verwendung des Amazon Nova Forge-Modells ausführen. Der Klassifizierungsprozess ist automatisiert und umfasst keine menschliche Überprüfung von Benutzereingaben oder Modellausgaben. + **Identifizieren Sie Muster** — Wir verwenden Klassifikator-Metriken, um potenzielle Verstöße und wiederkehrendes Verhalten zu identifizieren. Wir können anonymisierte Klassifikator-Metriken zusammenstellen und weitergeben. Amazon SageMaker Inference speichert keine Benutzereingaben oder Modellausgaben. + **Erkennen und Blockieren von Material über sexuellen Missbrauch von Kindern (CSAM)** — Sie sind für die Inhalte verantwortlich, die Sie (und Ihre Endbenutzer) auf Amazon SageMaker Inference hochladen, und müssen sicherstellen, dass diese Inhalte frei von illegalen Bildern sind. Um die Verbreitung von CSAM zu verhindern, kann Inference bei der Bereitstellung eines Amazon Nova Forge-Modells in Amazon SageMaker Inference automatisierte Mechanismen zur Missbrauchserkennung (wie Hash-Matching-Technologie oder Klassifikatoren) einsetzen, um offensichtliche CSAMs zu erkennen. SageMaker Wenn Amazon SageMaker Inference offensichtliches CSAM in Ihren Bildeingaben erkennt, blockiert Amazon SageMaker Inference die Anfrage und Sie erhalten eine automatische Fehlermeldung. Amazon SageMaker Inference kann auch einen Bericht beim National Center for Missing and Exploited Children (NCMEC) oder einer zuständigen Behörde einreichen. Wir nehmen CSAM sehr ernst und werden unsere Erkennungs-, Blockier- und Meldemechanismen weiterhin aktualisieren. Möglicherweise sind Sie nach geltendem Recht verpflichtet, zusätzliche Maßnahmen zu ergreifen, und Sie sind für diese Maßnahmen verantwortlich. Sobald unsere automatisierten Mechanismen zur Missbrauchserkennung potenzielle Verstöße erkennen, können wir Informationen über Ihre Nutzung von Amazon SageMaker Inference und die Einhaltung unserer Nutzungsbedingungen anfordern. Falls Sie nicht antworten, nicht bereit oder nicht in der Lage sind, diese Bedingungen oder Richtlinien einzuhalten, AWS können Sie Ihren Zugriff auf Amazon SageMaker Inference sperren. Möglicherweise wird Ihnen auch der fehlgeschlagene Inferenzauftrag in Rechnung gestellt, wenn unsere automatisierten Tests feststellen, dass Modellantworten nicht mit unseren Bedingungen und Richtlinien vereinbar sind. Falls Sie weitere Fragen haben, wenden Sie sich an den AWS Support. Weitere Informationen finden Sie auf [Amazon SageMaker FAQs](https://aws.amazon.com/sagemaker/ai/faqs/).