Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Amazon Rekognition Custom Labels
Puoi interrompere l'esecuzione di un modello Amazon Rekognition Custom Labels utilizzando la console o utilizzando l'operazione. [StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion)
**Topics**
+ [Interruzione di un modello Amazon Rekognition Custom Labels (console)](#rm-stop-console)
+ [Interruzione di un modello Amazon Rekognition Custom Labels (SDK)](#rm-stop-sdk)
## Interruzione di un modello Amazon Rekognition Custom Labels (console)
Utilizza la procedura seguente per interrompere l'esecuzione di un modello Amazon Rekognition Custom Labels con la console. Puoi interrompere il modello direttamente dalla console o utilizzare il codice AWS SDK fornito dalla console.
**Per interrompere un modello (console)**
1. Apri la console Amazon Rekognition all'indirizzo. [https://console.aws.amazon.com/rekognition/](https://console.aws.amazon.com/rekognition/)
1. Scegli **Usa etichette personalizzate**.
1. Scegli **Avvia**.
1. Nel pannello di navigazione a sinistra, scegli **Progetti**.
1. Nella pagina **Progetti**, scegli il progetto contenente il modello addestrato che desideri interrompere.
1. Nella sezione **Modelli**, scegli il modello che desideri interrompere.
1. Scegli la scheda **Usa modello**.
1.
------
#### [ Stop model using the console ]
1. Nella sezione **Avvia o interrompi il modello** scegli **Interrompi**.
1. Nella finestra di dialogo **Interrompi modello**, immetti **Interrompi** per confermare che desideri interrompere il modello.
1. Scegli **Interrompi** per interrompere il modello.
------
#### [ Stop model using the AWS SDK ]
Nella sezione **Usa il modello**, procedi come segue:
1. Scegli **Codice API**.
1. Scegli **AWS CLI** o **Python**.
1. In **Interrompi modello** copia il codice di esempio.
1. Usa il codice di esempio per interrompere il tuo modello. Per ulteriori informazioni, consulta [Interruzione di un modello Amazon Rekognition Custom Labels (SDK)](#rm-stop-sdk).
------
1. Scegliete il nome del progetto nella parte superiore della pagina per tornare alla pagina di panoramica del progetto.
1. Nella sezione **Modello**, controlla lo stato del modello. Il modello è interrotto quando lo stato del modello è **INTERROTTO**.
## Interruzione di un modello Amazon Rekognition Custom Labels (SDK)
Puoi interrompere un modello chiamando l'[StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion)API e passando l'Amazon Resource Name (ARN) del modello nel parametro di `ProjectVersionArn` input.
L'interruzione di un modello potrebbe richiedere alcuni istanti. Per verificare lo stato corrente, usa `DescribeProjectVersions`.
**Per interrompere un modello (SDK)**
1. Se non l'hai ancora fatto, installa e configura il AWS CLI AWS SDKs. Per ulteriori informazioni, consulta [Passaggio 4: configura e AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Utilizza il codice di esempio seguente per interrompere l'esecuzione di un modello.
------
#### [ CLI ]
Cambia il valore di `project-version-arn` nell'ARN della versione del modello che desideri interrompere.
```
aws rekognition stop-project-version --project-version-arn "model arn" \
--profile custom-labels-access
```
------
#### [ Python ]
L'esempio seguente interrompe un modello già in esecuzione.
Fornisci i seguenti parametri di riga di comando:
+ `project_arn` — l'ARN del progetto che contiene il modello che desideri interrompere.
+ `model_arn` — l'ARN del modello che desideri interrompere.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to stop a running Amazon Lookout for Vision model.
"""
import argparse
import logging
import time
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.
"""
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]
# Get the model status.
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"]
# No model found.
logger.exception("Model %s not found.", model_arn)
raise Exception("Model %s not found.", model_arn)
def stop_model(rek_client, project_arn, model_arn):
"""
Stops a running Amazon Rekognition Custom Labels Model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project that you want to stop running.
:param model_arn: The ARN of the model (ProjectVersion) that you want to stop running.
"""
logger.info("Stopping model: %s", model_arn)
try:
# Stop the model.
response=rek_client.stop_project_version(ProjectVersionArn=model_arn)
logger.info("Status: %s", response['Status'])
# stops when hosting has stopped or failure.
status = ""
finished = False
while finished is False:
status=get_model_status(rek_client, project_arn, model_arn)
if status == "STOPPING":
logger.info("Model stopping in progress...")
time.sleep(10)
continue
if status == "STOPPED":
logger.info("Model is not running.")
finished = True
continue
error_message = f"Error stopping model. Unexepected state: {status}"
logger.exception(error_message)
raise Exception(error_message)
logger.info("finished. Status %s", status)
return status
except ClientError as err:
logger.exception("Couldn't stop model - %s: %s",
model_arn,err.response['Error']['Message'])
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 the model that you want to stop."
)
parser.add_argument(
"model_arn", help="The ARN of the model that you want to stop."
)
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()
# Stop the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
status=stop_model(rekognition_client, args.project_arn, args.model_arn)
print(f"Finished stopping model: {args.model_arn}")
print(f"Status: {status}")
except ClientError as err:
logger.exception("Problem stopping model:%s",err)
print(f"Failed to stop model: {err}")
except Exception as err:
logger.exception("Problem stopping model:%s", err)
print(f"Failed to stop model: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Fornisci i seguenti parametri di riga di comando:
+ `project_arn` — l'ARN del progetto che contiene il modello che desideri interrompere.
+ `model_arn` — l'ARN del modello che desideri interrompere.
```
/*
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.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.StopProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.StopProjectVersionResponse;
import java.util.logging.Level;
import java.util.logging.Logger;
public class StopModel {
public static final Logger logger = Logger.getLogger(StopModel.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 stopMyModel(RekognitionClient rekClient, String projectArn, String modelArn)
throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Stopping {0}", modelArn);
StopProjectVersionRequest stopProjectVersionRequest = StopProjectVersionRequest.builder()
.projectVersionArn(modelArn).build();
StopProjectVersionResponse response = rekClient.stopProjectVersion(stopProjectVersionRequest);
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 stops
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.projectArn(projectArn).versionNames(versionName).build();
boolean stopped = false;
// Wait until create finishes
do {
DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
.describeProjectVersions(describeProjectVersionsRequest);
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
ProjectVersionStatus status = projectVersionDescription.status();
logger.log(Level.INFO, "stopping model: {0} ", modelArn);
switch (status) {
case STOPPED:
logger.log(Level.INFO, "Model stopped");
stopped = true;
break;
case STOPPING:
Thread.sleep(5000);
break;
case FAILED:
String error = "Model stopping failed: " + projectVersionDescription.statusAsString() + " "
+ projectVersionDescription.statusMessage() + " " + modelArn;
logger.log(Level.SEVERE, error);
throw new Exception(error);
default:
String unexpectedError = "Unexpected stopping state: "
+ projectVersionDescription.statusAsString() + " "
+ projectVersionDescription.statusMessage() + " " + modelArn;
logger.log(Level.SEVERE, unexpectedError);
throw new Exception(unexpectedError);
}
}
} while (stopped == false);
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not stop model: {0}", e.getMessage());
throw e;
}
}
public static void main(String[] args) {
String modelArn = null;
String projectArn = 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 stop. \n\n"
+ " model_arn - The ARN of the model version that you want to stop.\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
modelArn = args[1];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Stop model
stopMyModel(rekClient, projectArn, modelArn);
System.out.println(String.format("Model stopped: %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);
}
}
}
```
------