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.
# Starten eines Amazon Rekognition Custom Labels-Modells
Sie können mit der Ausführung eines Amazon Rekognition Custom Labels-Modells beginnen, indem Sie die Konsole oder den [StartProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartProjectVersion)Vorgang verwenden.
**Wichtig**
Ihnen werden die Anzahl der Stunden, die Ihr Modell läuft, und die Anzahl der Inferenzeinheiten, die Ihr Modell während des Betriebs verwendet, in Rechnung gestellt. Weitere Informationen finden Sie unter [Ausführen eines trainierten Amazon Rekognition Custom Labels-Modells](running-model.md).
Das Starten eines Modells kann einige Minuten dauern. Den aktuellen Status der Modellreife finden Sie auf der Detailseite für das Projekt oder die Nutzung. [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)
Nachdem das Modell gestartet wurde [DetectCustomLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectCustomLabels), verwenden Sie, um Bilder anhand des Modells zu analysieren. Weitere Informationen finden Sie unter [Analysieren eines Bildes mit einem trainierten Modell](detecting-custom-labels.md). Die Konsole bietet auch Beispielcode zum Aufrufen von `DetectCustomLabels`.
**Topics**
+ [Starten eines Amazon Rekognition Custom Labels-Modells (Konsole)](#rm-start-console)
+ [Starten eines Amazon Rekognition Custom Labels-Modells (SDK)](#rm-start-sdk)
## Starten eines Amazon Rekognition Custom Labels-Modells (Konsole)
Gehen Sie wie folgt vor, um ein Amazon Rekognition Custom Labels-Modell mit der Konsole auszuführen. Sie können das Modell direkt von der Konsole aus starten oder den von der Konsole bereitgestellten AWS SDK-Code verwenden.
**So starten Sie ein Modell (Konsole)**
1. Öffnen Sie die Amazon Rekognition Rekognition-Konsole unter. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Wählen Sie **Benutzerdefinierte Labels verwenden**.
1. Wählen Sie **Erste Schritte**.
1. Wählen Sie im linken Navigationsbereich die Option **Projekte** aus.
1. Wählen Sie auf der Ressourcenseite **Projekte** das Projekt aus, das das trainierte Modell enthält, das Sie starten möchten.
1. Wählen Sie im Abschnitt **Modelle** das Modell aus, das Sie starten möchten.
1. Wählen Sie die Registerkarte **Modell verwenden**.
1. Führen Sie eine der folgenden Aktionen aus:
------
#### [ Start model using the console ]
Gehen Sie im Abschnitt **Modell starten oder stoppen** wie folgt vor:
1. Wählen Sie die Anzahl der Inferenzeinheiten aus, die Sie verwenden möchten. Weitere Informationen finden Sie unter [Ausführen eines trainierten Amazon Rekognition Custom Labels-Modells](running-model.md).
1. Wählen Sie **Starten**.
1. Wählen Sie im Dialogfeld **Modell starten** die Option **Starten** aus.
------
#### [ Start model using the AWS SDK ]
Gehen Sie im Abschnitt **Modell verwenden** wie folgt vor:
1. Wählen Sie **API-Code.**
1. Wählen Sie entweder **AWS CLI** oder **Python**.
1. Kopieren Sie in **Modell starten** den Beispielcode.
1. Verwenden Sie den Beispielcode, um Ihr Modell zu starten. Weitere Informationen finden Sie unter [Starten eines Amazon Rekognition Custom Labels-Modells (SDK)](#rm-start-sdk).
------
1. Um zur Projektübersichtsseite zurückzukehren, wählen Sie oben auf der Seite Ihren Projektnamen aus.
1. Überprüfen Sie im Abschnitt **Modell** den Status des Modells. Wenn der Modellstatus **WIRD AUSGEFÜHRT** lautet, können Sie das Modell zur Analyse von Bildern verwenden. Weitere Informationen finden Sie unter [Analysieren eines Bildes mit einem trainierten Modell](detecting-custom-labels.md).
## Starten eines Amazon Rekognition Custom Labels-Modells (SDK)
Sie starten ein Modell, indem Sie die [StartProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartProjectVersion)API aufrufen und den Amazon-Ressourcennamen (ARN) des Modells im `ProjectVersionArn` Eingabeparameter übergeben. Sie geben auch die Anzahl der Inferenzeinheiten an, die Sie verwenden möchten. Weitere Informationen finden Sie unter [Ausführen eines trainierten Amazon Rekognition Custom Labels-Modells](running-model.md).
Es kann eine Weile dauern, bis ein Modell gestartet wird. Die Python- und Java-Beispiele in diesem Thema verwenden Waiter, um auf den Start des Modells zu warten. Waiter sind Hilfsprogrammmethoden, die einen bestimmten Status abfragen. Alternativ können Sie den aktuellen Status überprüfen, indem Sie anrufen [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions).
**So starten Sie ein Modell (SDK)**
1. Falls Sie dies noch nicht getan haben, installieren und konfigurieren Sie den AWS CLI und den AWS SDKs. Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Verwenden Sie den folgenden Beispielcode, um ein Modell zu starten.
------
#### [ CLI ]
Ändern Sie den Wert von `project-version-arn` in den ARN des Modells, das Sie starten möchten. Ändern Sie den Wert von `--min-inference-units` in die Anzahl der Inferenzeinheiten, die Sie verwenden möchten. Ändern Sie optional `--max-inference-units` in die maximale Anzahl von Inferenzeinheiten, die Amazon Rekognition Custom Labels verwenden kann, um das Modell automatisch zu skalieren.
```
aws rekognition start-project-version --project-version-arn {{model_arn}} \
--min-inference-units {{minimum number of units \}}
--max-inference-units {{maximum number of units \}}
--profile custom-labels-access
```
------
#### [ Python ]
Geben Sie die folgenden Befehlszeilenparameter an:
+ `project_arn` — der ARN des Projekts, das das Modell enthält, das Sie starten möchten.
+ `model_arn` — die ARN des Modells, das Sie starten möchten.
+ `min_inference_units` — die Anzahl der Inferenzeinheiten, die Sie verwenden möchten.
+ (Optional) `--max_inference_units` Die maximale Anzahl von Inferenzeinheiten, die Amazon Rekognition Custom Labels für die automatische Skalierung des Modells verwenden kann.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to start running an Amazon Lookout for Vision model.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def get_model_status(rek_client, project_arn, model_arn):
"""
Gets the current status of an Amazon Rekognition Custom Labels model
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_name: The name of the project that you want to use.
:param model_arn: The name of the model that you want the status for.
:return: The model status
"""
logger.info("Getting status for %s.", model_arn)
# Extract the model version from the model arn.
version_name = (model_arn.split("version/", 1)[1]).rpartition('/')[0]
models = rek_client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
for model in models['ProjectVersionDescriptions']:
logger.info("Status: %s", model['StatusMessage'])
return model["Status"]
error_message = f"Model {model_arn} not found."
logger.exception(error_message)
raise Exception(error_message)
def start_model(rek_client, project_arn, model_arn, min_inference_units, max_inference_units=None):
"""
Starts the hosting of an Amazon Rekognition Custom Labels model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_name: The name of the project that contains the
model that you want to start hosting.
:param min_inference_units: The number of inference units to use for hosting.
:param max_inference_units: The number of inference units to use for auto-scaling
the model. If not supplied, auto-scaling does not happen.
"""
try:
# Start the model
logger.info(f"Starting model: {model_arn}. Please wait....")
if max_inference_units is None:
rek_client.start_project_version(ProjectVersionArn=model_arn,
MinInferenceUnits=int(min_inference_units))
else:
rek_client.start_project_version(ProjectVersionArn=model_arn,
MinInferenceUnits=int(
min_inference_units),
MaxInferenceUnits=int(max_inference_units))
# Wait for the model to be in the running state
version_name = (model_arn.split("version/", 1)[1]).rpartition('/')[0]
project_version_running_waiter = rek_client.get_waiter(
'project_version_running')
project_version_running_waiter.wait(
ProjectArn=project_arn, VersionNames=[version_name])
# Get the running status
return get_model_status(rek_client, project_arn, model_arn)
except ClientError as err:
logger.exception("Client error: Problem starting model: %s", err)
raise
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"project_arn", help="The ARN of the project that contains that the model you want to start."
)
parser.add_argument(
"model_arn", help="The ARN of the model that you want to start."
)
parser.add_argument(
"min_inference_units", help="The minimum number of inference units to use."
)
parser.add_argument(
"--max_inference_units", help="The maximum number of inference units to use for auto-scaling the model.", required=False
)
def main():
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
# Get command line arguments.
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
add_arguments(parser)
args = parser.parse_args()
# Start the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
status = start_model(rekognition_client,
args.project_arn, args.model_arn,
args.min_inference_units,
args.max_inference_units)
print(f"Finished starting model: {args.model_arn}")
print(f"Status: {status}")
except ClientError as err:
error_message = f"Client error: Problem starting model: {err}"
logger.exception(error_message)
print(error_message)
except Exception as err:
error_message = f"Problem starting model:{err}"
logger.exception(error_message)
print(error_message)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Geben Sie die folgenden Befehlszeilenparameter an:
+ `project_arn` — der ARN des Projekts, das das Modell enthält, das Sie starten möchten.
+ `model_arn` — die ARN des Modells, das Sie starten möchten.
+ `min_inference_units` — die Anzahl der Inferenzeinheiten, die Sie verwenden möchten.
+ (Optional) `max_inference_units` — Die maximale Anzahl von Inferenzeinheiten, die Amazon Rekognition Custom Labels verwenden kann, um das Modell automatisch zu skalieren. Wenn Sie keinen Wert angeben, erfolgt keine automatische Skalierung.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionStatus;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.StartProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.StartProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.waiters.RekognitionWaiter;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;
public class StartModel {
public static final Logger logger = Logger.getLogger(StartModel.class.getName());
public static int findForwardSlash(String modelArn, int n) {
int start = modelArn.indexOf('/');
while (start >= 0 && n > 1) {
start = modelArn.indexOf('/', start + 1);
n -= 1;
}
return start;
}
public static void startMyModel(RekognitionClient rekClient, String projectArn, String modelArn,
Integer minInferenceUnits, Integer maxInferenceUnits
) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Starting model: {0}", modelArn);
StartProjectVersionRequest startProjectVersionRequest = null;
if (maxInferenceUnits == null) {
startProjectVersionRequest = StartProjectVersionRequest.builder()
.projectVersionArn(modelArn)
.minInferenceUnits(minInferenceUnits)
.build();
}
else {
startProjectVersionRequest = StartProjectVersionRequest.builder()
.projectVersionArn(modelArn)
.minInferenceUnits(minInferenceUnits)
.maxInferenceUnits(maxInferenceUnits)
.build();
}
StartProjectVersionResponse response = rekClient.startProjectVersion(startProjectVersionRequest);
logger.log(Level.INFO, "Status: {0}", response.statusAsString() );
// Get the model version
int start = findForwardSlash(modelArn, 3) + 1;
int end = findForwardSlash(modelArn, 4);
String versionName = modelArn.substring(start, end);
// wait until model starts
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.versionNames(versionName)
.projectArn(projectArn)
.build();
RekognitionWaiter waiter = rekClient.waiter();
WaiterResponse waiterResponse = waiter
.waitUntilProjectVersionRunning(describeProjectVersionsRequest);
Optional optionalResponse = waiterResponse.matched().response();
DescribeProjectVersionsResponse describeProjectVersionsResponse = optionalResponse.get();
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
if(projectVersionDescription.status() == ProjectVersionStatus.RUNNING) {
logger.log(Level.INFO, "Model is running" );
}
else {
String error = "Model training failed: " + projectVersionDescription.statusAsString() + " "
+ projectVersionDescription.statusMessage() + " " + modelArn;
logger.log(Level.SEVERE, error);
throw new Exception(error);
}
}
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not start model: {0}", e.getMessage());
throw e;
}
}
public static void main(String[] args) {
String modelArn = null;
String projectArn = null;
Integer minInferenceUnits = null;
Integer maxInferenceUnits = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - The ARN of the project that contains the model that you want to start. \n\n"
+ " model_arn - The ARN of the model version that you want to start.\n\n"
+ " min_inference_units - The number of inference units to start the model with.\n\n"
+ " max_inference_units - The maximum number of inference units that Custom Labels can use to "
+ " automatically scale the model. If the value is null, automatic scaling doesn't happen.\n\n";
if (args.length < 3 || args.length >4) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
modelArn = args[1];
minInferenceUnits=Integer.parseInt(args[2]);
if (args.length == 4) {
maxInferenceUnits = Integer.parseInt(args[3]);
}
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Start the model.
startMyModel(rekClient, projectArn, modelArn, minInferenceUnits, maxInferenceUnits);
System.out.println(String.format("Model started: %s", modelArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (Exception rekError) {
logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------