Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Inicio de un modelo de Etiquetas personalizadas de Amazon Rekognition
Puede empezar a ejecutar un modelo de Amazon Rekognition Custom Labels mediante la consola o mediante la operación. [StartProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartProjectVersion)
**importante**
Se le cobrará por el número de horas que el modelo esté en ejecución y por el número de unidades de inferencia que utilice mientras se ejecute. Para obtener más información, consulte [Ejecución de un modelo de Etiquetas personalizadas de Amazon Rekognition](running-model.md).
El proceso de inicio de un modelo puede tardar algunos minutos. Para comprobar el estado actual de preparación del modelo, consulte la página de detalles del proyecto o uso. [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)
Una vez iniciado el modelo [DetectCustomLabels](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectCustomLabels), utilice, para analizar las imágenes utilizando el modelo. Para obtener más información, consulte [Análisis de una imagen con un modelo entrenado](detecting-custom-labels.md). La consola también incluye un código de ejemplo para llamar a `DetectCustomLabels`.
**Topics**
+ [Inicio de un modelo de Etiquetas personalizadas de Amazon Rekognition (consola)](#rm-start-console)
+ [Inicio de un modelo de Etiquetas personalizadas de Amazon Rekognition (SDK)](#rm-start-sdk)
## Inicio de un modelo de Etiquetas personalizadas de Amazon Rekognition (consola)
Utilice el siguiente procedimiento para empezar a ejecutar un modelo de Etiquetas personalizadas de Amazon Rekognition con la consola. Puede iniciar el modelo directamente desde la consola o utilizar el código del AWS SDK proporcionado por la consola.
**Cómo iniciar un modelo (consola)**
1. Abra la consola Amazon Rekognition en. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Elija **Usar etiquetas personalizadas**.
1. Elija **Comenzar**.
1. En el panel de navegación izquierdo, elija **Proyectos**.
1. En la página **Proyectos**, elija el proyecto que contiene el modelo entrenado que quiera iniciar.
1. En la sección **Modelos**, elija el modelo que desee iniciar.
1. Seleccione la pestaña **Usar modelo**.
1. Realice una de las siguientes acciones:
------
#### [ Start model using the console ]
En la sección **Iniciar o detener modelo**, haga lo siguiente:
1. Seleccione el número de unidades de inferencia que desee utilizar. Para obtener más información, consulte [Ejecución de un modelo de Etiquetas personalizadas de Amazon Rekognition](running-model.md).
1. Elija **Iniciar**.
1. En el cuadro de diálogo **Iniciar modelo**, seleccione **Iniciar**.
------
#### [ Start model using the AWS SDK ]
En la sección **Usar su modelo**, realice lo siguiente:
1. Elija **Código de API**.
1. Elija **AWS CLI** o **Python**.
1. En **Iniciar modelo**, copie el código de ejemplo.
1. Utilice el código de ejemplo para iniciar el modelo. Para obtener más información, consulte [Inicio de un modelo de Etiquetas personalizadas de Amazon Rekognition (SDK)](#rm-start-sdk).
------
1. Para volver a la página de información general del proyecto, elija el nombre del proyecto en la parte superior de la página.
1. En la sección **Modelo**, compruebe el estado del modelo. Cuando el estado del modelo esté **EN EJECUCIÓN**, puede utilizar el modelo para analizar imágenes. Para obtener más información, consulte [Análisis de una imagen con un modelo entrenado](detecting-custom-labels.md).
## Inicio de un modelo de Etiquetas personalizadas de Amazon Rekognition (SDK)
Para iniciar un modelo, se llama a la [StartProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartProjectVersion)API y se pasa el nombre de recurso de Amazon (ARN) del modelo en el parámetro de `ProjectVersionArn` entrada. Indique también el número de unidades de inferencia que desee utilizar. Para obtener más información, consulte [Ejecución de un modelo de Etiquetas personalizadas de Amazon Rekognition](running-model.md).
Es posible que un modelo tarde un tiempo en iniciarse. En los ejemplos de Python y Java de este tema, se utilizan esperadores para que se inicie el modelo. Un esperador es un método de utilidad que sondean si se da un determinado estado. Como alternativa, puede comprobar el estado actual llamando [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions).
**Cómo iniciar un modelo (SDK)**
1. Si aún no lo ha hecho, instale y configure el AWS CLI y el AWS SDKs. Para obtener más información, consulte [Paso 4: Configure y AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Utilice el código de ejemplo para iniciar un modelo.
------
#### [ CLI ]
Cambie el valor de `project-version-arn` por el ARN del modelo que desee iniciar. Cambie el valor de `--min-inference-units` por el número de unidades de inferencia que desee utilizar. Si lo desea, cambie `--max-inference-units` por el número máximo de unidades de inferencia que Etiquetas personalizadas de Amazon Rekognition puede utilizar para escalar automáticamente el modelo.
```
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 ]
Indique los siguientes parámetros de línea de comandos:
+ `project_arn`: el ARN del proyecto que incluye el modelo que desea iniciar.
+ `model_arn`: el ARN del modelo que desea iniciar.
+ `min_inference_units`: el número de unidades de inferencia que desea utilizar.
+ (Opcional) `--max_inference_units`: el número máximo de unidades de inferencia que Etiquetas personalizadas de Amazon Rekognition puede utilizar para escalar automáticamente el modelo.
```
# 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 ]
Indique los siguientes parámetros de línea de comandos:
+ `project_arn`: el ARN del proyecto que incluye el modelo que desea iniciar.
+ `model_arn`: el ARN del modelo que desea iniciar.
+ `min_inference_units`: el número de unidades de inferencia que desea utilizar.
+ (Opcional)`max_inference_units`: el número máximo de unidades de inferencia que Etiquetas personalizadas de Amazon Rekognition puede utilizar para escalar automáticamente el modelo. Si no se indica ningún valor, no se aplicará el escalado automático.
```
/*
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);
}
}
}
```
------