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à.
# Copia di un modello Amazon Rekognition Custom Labels (SDK)
Puoi utilizzare l'[CopyProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CopyProjectVersion)operazione per copiare una versione del modello Amazon Rekognition Custom Labels da un progetto Amazon Rekognition Custom Labels di origine a un progetto di destinazione. Il progetto di destinazione può trovarsi in un AWS account diverso o nello stesso account. AWS Uno scenario tipico consiste nel copiare un modello testato da un account di sviluppo a un AWS AWS account di produzione.
In alternativa, puoi addestrare il modello nell'account di destinazione con il set di dati di origine. L'utilizzo dell'operazione `CopyProjectVersion` ha i vantaggi seguenti.
+ Il comportamento del modello è coerente. L'addestramento dei modelli non è deterministico e non è garantito che due modelli addestrati con lo stesso set di dati effettuino le stesse previsioni. La copia del modello con `CopyProjectVersion` aiuta a garantire che il comportamento del modello copiato sia coerente con il modello di origine e non sia necessario ripetere il test del modello.
+ Non è richiesto addestramento del modello. In questo modo puoi risparmiare denaro poiché ti viene addebitato un costo per ogni addestramento con esito positivo di un modello.
Per copiare un modello su un altro AWS account, devi avere un progetto Amazon Rekognition Custom Labels nell'account di destinazione. AWS Per informazioni sulla creazione di un progetto, consultare [Creare un progetto](mp-create-project.md). Assicurati di creare il progetto nell'account di destinazione. AWS
Una [policy di progetto](md-create-project-policy-document.md) è una policy basata su risorse che imposta le autorizzazioni di copia per la versione del modello che desideri copiare. È necessario utilizzare una [politica di progetto](md-create-project-policy-document.md) quando il progetto di destinazione si trova in un AWS account diverso dal progetto di origine.
Non è necessario utilizzare una [policy di progetto](md-create-project-policy-document.md) quando si copiano le versioni del modello all'interno dello stesso account. Tuttavia, puoi scegliere di utilizzare una [policy di progetto](md-create-project-policy-document.md) sui progetti inter-account se desideri un maggiore controllo su queste risorse.
È possibile allegare la politica del progetto al progetto di origine richiamando l'[PutProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_PutProjectPolicy)operazione.
Non è possibile utilizzare `CopyProjectVersion` per copiare un modello in un progetto in una AWS regione diversa. Inoltre, non puoi copiare un modello con la console di Amazon Rekognition Custom Labels. In questi casi, puoi addestrare il modello nel progetto di destinazione con i set di dati utilizzati per addestrare il modello sorgente. Per ulteriori informazioni, consulta [Addestramento di un modello Amazon Rekognition Custom Labels](training-model.md).
Per copiare un modello da un progetto di origine a un progetto di destinazione, procedi come segue:
**Per copiare un modello**
1. [Crea un documento sulla policy del progetto](md-create-project-policy-document.md).
1. [Collega la policy del progetto al progetto di origine](md-attach-project-policy.md).
1. [Copia il modello con l'operazione `CopyProjectVersion`](md-copy-model-sdk.md).
Per rimuovere una politica di progetto da un progetto, chiama [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy). Per ottenere un elenco delle politiche di progetto allegate a un progetto, chiama [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies).
**Topics**
+ [Creazione di un documento di policy](md-create-project-policy-document.md)
+ [Collegare una policy di progetto (SDK)](md-attach-project-policy.md)
+ [Copia di un modello (SDK)](md-copy-model-sdk.md)
+ [Elenco delle policy del progetto (SDK)](md-list-project-policies.md)
+ [Eliminazione di una policy di progetto (SDK)](md-delete-project-policy.title.md)
# Creazione di un documento di policy
Rekognition Custom Labels utilizza una policy basata su risorse, nota come *policy di progetto*, per gestire le autorizzazioni di copia per una versione del modello. Una policy di progetto è un documento in formato JSON.
Una policy di progetto consente o nega un'autorizzazione [principale](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html#intro-structure-principal) a copiare una versione del modello da un progetto di origine a un progetto di destinazione. È necessaria una politica di progetto se il progetto di destinazione si trova in un AWS account diverso. Ciò vale anche se il progetto di destinazione si trova nello stesso account AWS del progetto di origine e desideri limitare l'accesso a versioni specifiche del modello. Ad esempio, potresti voler negare le autorizzazioni di copia a uno specifico ruolo IAM all'interno di un AWS account.
L'esempio seguente consente al principale `arn:aws:iam::111111111111:role/Admin` di copiare la versione del modello `arn:aws:rekognition:us-east-1:123456789012:project/my_project/version/test_1/1627045542080`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"AWS":"arn:aws:iam::111111111111:role/Admin"
},
"Action":"rekognition:CopyProjectVersion",
"Resource":"arn:aws:rekognition:us-east-1:111111111111:project/my_project/version/test_1/1627045542080"
}
]
}
```
------
**Nota**
`Action`, `Resource`, `Principal` e `Effect` sono campi obbligatori in un documento sulla policy del progetto.
L’unico `action` supportato è `rekognition:CopyProjectVersion`.
`NotAction`, `NotResource`, e `NotPrincipal` sono campi proibiti e non devono essere presenti nel documento sulla policy del progetto.
Se non specifichi una politica di progetto, un responsabile dello stesso AWS account del progetto di origine può comunque copiare un modello, se il responsabile ha una politica basata sull'identità, ad esempio che autorizza la ` AmazonRekognitionCustomLabelsFullAccess` chiamata. `CopyProjectVersion`
La procedura seguente crea un file di documento sulle policy di progetto che è possibile utilizzare con l'esempio Python in [Collegare una policy di progetto (SDK)](md-attach-project-policy.md). Se si utilizza il `put-project-policy` AWS CLI comando, si fornisce la politica del progetto come stringa JSON.
**Creazione di un documento sulla policy di progetto**
1. In un editor di testo, crea il seguente documento. Imposta i valori seguenti:
+ Effetto – Specifica `ALLOW` per concedere l'autorizzazione alla copia. Specifica `DENY` per negare l'autorizzazione alla copia.
+ Principale – Per il principale al quale intendi consentire o negare l'accesso alle versioni del modello specificate in `Resource`. Ad esempio, puoi specificare l'[account principal AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#principal-accounts) per un AWS account diverso. Non limitiamo i principali che puoi utilizzare. Per ulteriori informazioni, consulta [Specifica di un principale](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#Principal_specifying).
+ Risorsa – L’Amazon Resource Name (ARN) della versione del modello per la quale intendi specificare le autorizzazioni di copia. Se desideri concedere le autorizzazioni a tutte le versioni del modello all'interno del progetto di origine, utilizza il seguente formato `arn:aws:rekognition:region:account:project/source project/version/* `
1. Salva la policy del progetto nel computer.
1. Collega la policy del progetto al progetto sorgente seguendo le istruzioni in [Collegare una policy di progetto (SDK)](md-attach-project-policy.md).
# Collegare una policy di progetto (SDK)
Alleghi una policy di progetto a un progetto Amazon Rekognition Custom Labels chiamando l'operazione. [PutProjectpolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_PutProjectPolicy)
Collega più policy di progetto a un progetto chiamando `PutProjectPolicy` per ogni policy di progetto che desideri aggiungere. Puoi collegare fino a cinque policy di progetto a un progetto. Se hai bisogno di collegare più policy di progetto, puoi richiedere un aumento del [limite](limits.md).
Quando alleghi per la prima volta una policy di progetto specifica a un progetto, non specificare un ID di revisione nel parametro di input `PolicyRevisionId`. Il modulo di risposta `PutProjectPolicy` è un ID di revisione per la policy di progetto che Amazon Rekognition Custom Labels crea per te. Puoi utilizzare l'ID di revisione per aggiornare o eliminare l'ultima revisione di una policy di progetto. Amazon Rekognition Custom Labels conserva solo l'ultima revisione delle policy di progetto. Se tenti di aggiornare o eliminare una revisione precedente di una policy di progetto, ricevi un errore `InvalidPolicyRevisionIdException`.
Per aggiornare una policy di progetto esistente, specifica l'ID di revisione della policy di progetto nel parametro di input `PolicyRevisionId`. Puoi ottenere la revisione IDs delle politiche di progetto in un progetto chiamando. [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)
Dopo aver associato una policy di progetto a un progetto di origine, è possibile copiare il modello dal progetto di origine al progetto di destinazione. Per ulteriori informazioni, consulta [Copia di un modello (SDK)](md-copy-model-sdk.md).
Per rimuovere una politica di progetto da un progetto, chiama [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy). Per ottenere un elenco delle politiche di progetto allegate a un progetto, chiama [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies).
**Per collegare una policy di progetto a un progetto (SDK)**
1. Se non l'hai già 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. [Crea un documento sulla policy del progetto](md-create-project-policy-document.md).
1. Usa il codice seguente per allegare la politica del progetto al progetto, nell' AWS account di fiducia, che contiene la versione del modello che desideri copiare. Per ottenere l'ARN del progetto, chiama. [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-describing-project-sdk.html) Per ottenere la versione del modello, chiamate ARN. [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-describing-model-sdk.html)
------
#### [ AWS CLI ]
Imposta i valori seguenti:
+ `project-arn`all'ARN del progetto di origine nell' AWS account di fiducia che contiene la versione del modello che si desidera copiare.
+ `policy-name` a un nome di policy a tua scelta.
+ `principal` al principale a cui desiderate consentire o negare l'accesso alle versioni del modello specificate in `Model version ARN`.
+ `project-version-arn` all'ARN della versione del modello che desideri copiare.
Se desideri aggiornare una policy di progetto esistente, specifica il parametro `policy-revision-id` e fornisci l'ID di revisione della policy di progetto desiderata.
```
aws rekognition put-project-policy \
--project-arn project-arn \
--policy-name policy-name \
--policy-document '{ "Version": "2012-10-17", "Statement":[{ "Effect":"ALLOW or DENY", "Principal":{ "AWS":"principal" }, "Action":"rekognition:CopyProjectVersion", "Resource":"project-version-arn" }]}' \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `project_arn` — L'ARN del progetto di origine a cui desideri collegare la policy del progetto.
+ `policy_name` — Un nome di policy a tua scelta.
+ `project_policy` — Il file che contiene il documento sulla policy del progetto.
+ `policy_revision_id` — (facoltativo). Se desideri aggiornare una revisione esistente di una policy di progetto, specifica l'ID di revisione della policy di progetto.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Amazon Rekognition Custom Labels model example used in the service documentation:
https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-copy-model-sdk.html
Shows how to attach a project policy to an Amazon Rekognition Custom Labels project.
"""
import boto3
import argparse
import logging
import json
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def put_project_policy(rek_client, project_arn, policy_name, policy_document_file, policy_revision_id=None):
"""
Attaches a project policy to an Amazon Rekognition Custom Labels project.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param policy_name: A name for the project policy.
:param project_arn: The Amazon Resource Name (ARN) of the source project
that you want to attach the project policy to.
:param policy_document_file: The JSON project policy document to
attach to the source project.
:param policy_revision_id: (Optional) The revision of an existing policy to update.
Pass None to attach new policy.
:return The revision ID for the project policy.
"""
try:
policy_document_json = ""
response = None
with open(policy_document_file, 'r') as policy_document:
policy_document_json = json.dumps(json.load(policy_document))
logger.info(
"Attaching %s project_policy to project %s.",
policy_name, project_arn)
if policy_revision_id is None:
response = rek_client.put_project_policy(ProjectArn=project_arn,
PolicyName=policy_name,
PolicyDocument=policy_document_json)
else:
response = rek_client.put_project_policy(ProjectArn=project_arn,
PolicyName=policy_name,
PolicyDocument=policy_document_json,
PolicyRevisionId=policy_revision_id)
new_revision_id = response['PolicyRevisionId']
logger.info(
"Finished creating project policy %s. Revision ID: %s",
policy_name, new_revision_id)
return new_revision_id
except ClientError as err:
logger.exception(
"Couldn't attach %s project policy to project %s: %s }",
policy_name, project_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 Amazon Resource Name (ARN) of the project "
"that you want to attach the project policy to."
)
parser.add_argument(
"policy_name", help="A name for the project policy."
)
parser.add_argument(
"project_policy", help="The file containing the project policy JSON"
)
parser.add_argument(
"--policy_revision_id", help="The revision of an existing policy to update. "
"If you don't supply a value, a new project policy is created.",
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()
print(f"Attaching policy to {args.project_arn}")
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
# Attach a new policy or update an existing policy.
response = put_project_policy(rekognition_client,
args.project_arn,
args.policy_name,
args.project_policy,
args.policy_revision_id)
print(
f"project policy {args.policy_name} attached to project {args.project_arn}")
print(f"Revision ID: {response}")
except ClientError as err:
print("Problem attaching project policy: %s", err)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `project_arn` — L'ARN del progetto di origine a cui desideri collegare la policy del progetto.
+ `project_policy_name` — Un nome di policy a tua scelta.
+ `project_policy_document` — Il file che contiene il documento sulla policy del progetto.
+ `project_policy_revision_id` — (facoltativo). Se desideri aggiornare una revisione esistente di una policy di progetto, specifica l'ID di revisione della policy di progetto.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.logging.Level;
import java.util.logging.Logger;
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.PutProjectPolicyRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class PutProjectPolicy {
public static final Logger logger = Logger.getLogger(PutProjectPolicy.class.getName());
public static void putMyProjectPolicy(RekognitionClient rekClient, String projectArn, String projectPolicyName,
String projectPolicyFileName, String projectPolicyRevisionId) throws IOException {
try {
Path filePath = Path.of(projectPolicyFileName);
String policyDocument = Files.readString(filePath);
String[] logArguments = new String[] { projectPolicyFileName, projectPolicyName };
PutProjectPolicyRequest putProjectPolicyRequest = null;
logger.log(Level.INFO, "Attaching Project policy: {0} to project: {1}", logArguments);
// Attach the project policy.
if (projectPolicyRevisionId == null) {
putProjectPolicyRequest = PutProjectPolicyRequest.builder().projectArn(projectArn)
.policyName(projectPolicyName).policyDocument(policyDocument).build();
} else {
putProjectPolicyRequest = PutProjectPolicyRequest.builder().projectArn(projectArn)
.policyName(projectPolicyName).policyRevisionId(projectPolicyRevisionId)
.policyDocument(policyDocument)
.build();
}
rekClient.putProjectPolicy(putProjectPolicyRequest);
logger.log(Level.INFO, "Attached Project policy: {0} to project: {1}", logArguments);
} catch (
RekognitionException e) {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
final String USAGE = "\n" + "Usage: "
+ " \n\n" + "Where:\n"
+ " project_arn - The ARN of the project that you want to attach the project policy to.\n\n"
+ " project_policy_name - A name for the project policy.\n\n"
+ " project_policy_document - The file name of the project policy.\n\n"
+ " project_policy_revision_id - (Optional) The revision ID of the project policy that you want to update.\n\n";
if (args.length < 3 || args.length > 4) {
System.out.println(USAGE);
System.exit(1);
}
String projectArn = args[0];
String projectPolicyName = args[1];
String projectPolicyDocument = args[2];
String projectPolicyRevisionId = null;
if (args.length == 4) {
projectPolicyRevisionId = args[3];
}
try {
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Attach the project policy.
putMyProjectPolicy(rekClient, projectArn, projectPolicyName, projectPolicyDocument,
projectPolicyRevisionId);
System.out.println(
String.format("project policy %s: attached to project: %s", projectPolicyName, projectArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
catch (IOException intError) {
logger.log(Level.SEVERE, "Exception while reading policy document: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------
1. Copia la versione del modello seguendo le istruzioni riportate in [Copia di un modello (SDK)](md-copy-model-sdk.md).
# Copia di un modello (SDK)
È possibile utilizzare l'API `CopyProjectVersion` per copiare una versione del modello da un progetto di origine a un progetto di destinazione. Il progetto di destinazione può trovarsi in un AWS account diverso ma deve appartenere alla stessa AWS regione. Se il progetto di destinazione si trova in un AWS account diverso (o se si desidera concedere autorizzazioni specifiche per una versione del modello copiata all'interno di un AWS account), è necessario allegare una politica di progetto al progetto di origine. Per ulteriori informazioni, consulta [Creazione di un documento di policy](md-create-project-policy-document.md). L'API `CopyProjectVersion` richiede l'accesso al bucket Amazon S3.
Il modello copiato include i risultati dell’addestramento per il modello sorgente, ma non include i set di dati di origine.
L' AWS account di origine non ha alcuna proprietà sul modello copiato in un account di destinazione, a meno che non si configurino le autorizzazioni appropriate.
**Per copiare 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. Collega una policy di progetto al progetto sorgente seguendo le istruzioni riportate in [Collegare una policy di progetto (SDK)](md-attach-project-policy.md).
1. Se stai copiando il modello su un altro AWS account, assicurati di avere un progetto nell' AWS account di destinazione.
1. Utilizza il codice seguente per copiare la versione del modello in un progetto di destinazione.
------
#### [ AWS CLI ]
Imposta i valori seguenti:
+ `source-project-arn` per l'ARN del progetto di origine che contiene la versione del modello da copiare.
+ `source-project-version-arn` per l'ARN della versione del modello che desideri copiare.
+ `destination-project-arn` per l'ARN del progetto di destinazione in cui desideri copiare il modello.
+ `version-name` per un nome della versione per il modello nel progetto di destinazione.
+ `bucket` per il bucket S3 in cui desideri copiare i risultati dell'addestramento per il modello di origine.
+ `folder` per la cartella in `bucket` cui desideri copiare i risultati dell'addestramento per il modello sorgente.
+ (Facoltativo) `kms-key-id` per l'ID chiave di AWS Key Management Service per il modello.
+ (Facoltativo) `key` per una chiave di tag a tua scelta.
+ (Facoltativo) `value` per un valore di tag a tua scelta.
```
aws rekognition copy-project-version \
--source-project-arn source-project-arn \
--source-project-version-arn source-project-version-arn \
--destination-project-arn destination-project-arn \
--version-name version-name \
--output-config '{"S3Bucket":"bucket","S3KeyPrefix":"folder"}' \
--kms-key-id arn:myKey \
--tags '{"key":"key"}' \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `source_project_arn`— l'ARN del progetto di origine nell' AWS account di origine che contiene la versione del modello che si desidera copiare.
+ `source_project_version-arn`— l'ARN della versione del modello nell' AWS account di origine che si desidera copiare.
+ `destination_project_arn` — l'ARN del progetto di destinazione in cui desideri copiare il modello.
+ `destination_version_name` — un nome di versione per il modello nel progetto di destinazione.
+ `training_results` — la posizione S3 in cui si desidera copiare i risultati dell’addestramento per la versione del modello di origine.
+ (Facoltativo) `kms_key_id` per l'ID chiave di AWS Key Management Service per il modello.
+ (Facoltativo) `tag_name` per una chiave di tag a tua scelta.
+ (Facoltativo) `tag_value` per un valore di tag a tua scelta.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def copy_model(
rekognition_client, source_project_arn, source_project_version_arn,
destination_project_arn, training_results, destination_version_name):
"""
Copies a version of a Amazon Rekognition Custom Labels model.
:param rekognition_client: A Boto3 Amazon Rekognition Custom Labels client.
:param source_project_arn: The ARN of the source project that contains the
model that you want to copy.
:param source_project_version_arn: The ARN of the model version that you want
to copy.
:param destination_project_Arn: The ARN of the project that you want to copy the model
to.
:param training_results: The Amazon S3 location where training results for the model
should be stored.
return: The model status and version.
"""
try:
logger.info("Copying model...%s from %s to %s ", source_project_version_arn,
source_project_arn,
destination_project_arn)
output_bucket, output_folder = training_results.replace(
"s3://", "").split("/", 1)
output_config = {"S3Bucket": output_bucket,
"S3KeyPrefix": output_folder}
response = rekognition_client.copy_project_version(
DestinationProjectArn=destination_project_arn,
OutputConfig=output_config,
SourceProjectArn=source_project_arn,
SourceProjectVersionArn=source_project_version_arn,
VersionName=destination_version_name
)
destination_model_arn = response["ProjectVersionArn"]
logger.info("Destination model ARN: %s", destination_model_arn)
# Wait until training completes.
finished = False
status = "UNKNOWN"
while finished is False:
model_description = rekognition_client.describe_project_versions(ProjectArn=destination_project_arn,
VersionNames=[destination_version_name])
status = model_description["ProjectVersionDescriptions"][0]["Status"]
if status == "COPYING_IN_PROGRESS":
logger.info("Model copying in progress...")
time.sleep(60)
continue
if status == "COPYING_COMPLETED":
logger.info("Model was successfully copied.")
if status == "COPYING_FAILED":
logger.info(
"Model copy failed: %s ",
model_description["ProjectVersionDescriptions"][0]["StatusMessage"])
finished = True
except ClientError:
logger.exception("Couldn't copy model.")
raise
else:
return destination_model_arn, status
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"source_project_arn",
help="The ARN of the project that contains the model that you want to copy."
)
parser.add_argument(
"source_project_version_arn",
help="The ARN of the model version that you want to copy."
)
parser.add_argument(
"destination_project_arn",
help="The ARN of the project which receives the copied model."
)
parser.add_argument(
"destination_version_name",
help="The version name for the model in the destination project."
)
parser.add_argument(
"training_results",
help="The S3 location in the destination account that receives the training results for the copied model."
)
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()
print(
f"Copying model version {args.source_project_version_arn} to project {args.destination_project_arn}")
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
# Copy the model.
model_arn, status = copy_model(rekognition_client,
args.source_project_arn,
args.source_project_version_arn,
args.destination_project_arn,
args.training_results,
args.destination_version_name,
)
print(f"Finished copying model: {model_arn}")
print(f"Status: {status}")
except ClientError as err:
print(f"Problem copying model: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `source_project_arn`— l'ARN del progetto di origine nell' AWS account di origine che contiene la versione del modello che si desidera copiare.
+ `source_project_version-arn`— l'ARN della versione del modello nell' AWS account di origine che si desidera copiare.
+ `destination_project_arn` — l'ARN del progetto di destinazione in cui desideri copiare il modello.
+ `destination_version_name` — un nome di versione per il modello nel progetto di destinazione.
+ `output_bucket` — il bucket S3 in cui desideri copiare i risultati dell’addestramento per la versione del modello di origine.
+ `output_folder` — la cartella di S3 in cui desideri copiare i risultati dell'addestramento per la versione del modello sorgente.
```
/*
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.CopyProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.CopyProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.OutputConfig;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CopyModel {
public static final Logger logger = Logger.getLogger(CopyModel.class.getName());
public static ProjectVersionDescription copyMyModel(RekognitionClient rekClient,
String sourceProjectArn,
String sourceProjectVersionArn,
String destinationProjectArn,
String versionName,
String outputBucket,
String outputFolder) throws InterruptedException {
try {
OutputConfig outputConfig = OutputConfig.builder().s3Bucket(outputBucket).s3KeyPrefix(outputFolder).build();
String[] logArguments = new String[] { versionName, sourceProjectArn, destinationProjectArn };
logger.log(Level.INFO, "Copying model {0} for from project {1} to project {2}", logArguments);
CopyProjectVersionRequest copyProjectVersionRequest = CopyProjectVersionRequest.builder()
.sourceProjectArn(sourceProjectArn)
.sourceProjectVersionArn(sourceProjectVersionArn)
.versionName(versionName)
.destinationProjectArn(destinationProjectArn)
.outputConfig(outputConfig)
.build();
CopyProjectVersionResponse response = rekClient.copyProjectVersion(copyProjectVersionRequest);
logger.log(Level.INFO, "Destination model ARN: {0}", response.projectVersionArn());
logger.log(Level.INFO, "Copying model...");
// wait until copying completes.
boolean finished = false;
ProjectVersionDescription copiedModel = null;
while (Boolean.FALSE.equals(finished)) {
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.versionNames(versionName)
.projectArn(destinationProjectArn)
.build();
DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
.describeProjectVersions(describeProjectVersionsRequest);
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
copiedModel = projectVersionDescription;
switch (projectVersionDescription.status()) {
case COPYING_IN_PROGRESS:
logger.log(Level.INFO, "Copying model...");
Thread.sleep(5000);
continue;
case COPYING_COMPLETED:
finished = true;
logger.log(Level.INFO, "Copying completed");
break;
case COPYING_FAILED:
finished = true;
logger.log(Level.INFO, "Copying failed...");
break;
default:
finished = true;
logger.log(Level.INFO, "Unexpected copy status %s",
projectVersionDescription.statusAsString());
break;
}
}
}
logger.log(Level.INFO, "Finished copying model {0} for from project {1} to project {2}", logArguments);
return copiedModel;
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not train model: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String sourceProjectArn = null;
String sourceProjectVersionArn = null;
String destinationProjectArn = null;
String versionName = null;
String bucket = null;
String location = null;
final String USAGE = "\n" + "Usage: "
+ " \n\n"
+ "Where:\n"
+ " source_project_arn - The ARN of the project that contains the model that you want to copy. \n\n"
+ " source_project_version_arn - The ARN of the project that contains the model that you want to copy. \n\n"
+ " destination_project_arn - The ARN of the destination project that you want to copy the model to. \n\n"
+ " version_name - A version name for the copied model.\n\n"
+ " output_bucket - The S3 bucket in which to place the training output. \n\n"
+ " output_folder - The folder within the bucket that the training output is stored in. \n\n";
if (args.length != 6) {
System.out.println(USAGE);
System.exit(1);
}
sourceProjectArn = args[0];
sourceProjectVersionArn = args[1];
destinationProjectArn = args[2];
versionName = args[3];
bucket = args[4];
location = args[5];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Copy the model.
ProjectVersionDescription copiedModel = copyMyModel(rekClient,
sourceProjectArn,
sourceProjectVersionArn,
destinationProjectArn,
versionName,
bucket,
location);
System.out.println(String.format("Model copied: %s Status: %s",
copiedModel.projectVersionArn(),
copiedModel.statusMessage()));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (InterruptedException intError) {
logger.log(Level.SEVERE, "Exception while sleeping: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------
# Elenco delle policy del progetto (SDK)
Puoi utilizzare l'[ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)operazione per elencare le politiche di progetto allegate a un progetto Amazon Rekognition Custom Labels.
**Per elencare le policy di progetto collegate a un progetto (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. Usa il codice seguente per elencare le policy del progetto.
------
#### [ AWS CLI ]
Modifica `project-arn` con il nome Amazon Resource del progetto per il quale desideri elencare le policy di progetto collegate.
```
aws rekognition list-project-policies \
--project-arn project-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ project\$1arn — il nome della risorsa Amazon del progetto per il quale desideri elencare le policy di progetto collegate.
Ad esempio: `python list_project_policies.py project_arn `
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Amazon Rekognition Custom Labels model example used in the service documentation:
https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-copy-model-sdk.html
Shows how to list the project policies in an Amazon Rekogntion Custom Labels project.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def display_project_policy(project_policy):
"""
Displays information about a Custom Labels project policy.
:param project_policy: The project policy (ProjectPolicy)
that you want to display information about.
"""
print(f"Policy name: {(project_policy['PolicyName'])}")
print(f"Project Arn: {project_policy['ProjectArn']}")
print(f"Document: {(project_policy['PolicyDocument'])}")
print(f"Revision ID: {(project_policy['PolicyRevisionId'])}")
print()
def list_project_policies(rek_client, project_arn):
"""
Describes an Amazon Rekognition Custom Labels project, or all projects.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The Amazon Resource Name of the project you want to use.
"""
try:
max_results = 5
pagination_token = ''
finished = False
logger.info("Listing project policies in: %s.", project_arn)
print('Projects\n--------')
while not finished:
response = rek_client.list_project_policies(
ProjectArn=project_arn, MaxResults=max_results, NextToken=pagination_token)
for project in response['ProjectPolicies']:
display_project_policy(project)
if 'NextToken' in response:
pagination_token = response['NextToken']
else:
finished = True
logger.info("Finished listing project policies.")
except ClientError as err:
logger.exception(
"Couldn't list policies for - %s: %s",
project_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 Amazon Resource Name of the project for which you want to list project policies."
)
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()
print(f"Listing project policies in: {args.project_arn}")
# List the project policies.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
list_project_policies(rekognition_client,
args.project_arn)
except ClientError as err:
print(f"Problem list project_policies: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ project\$1arn — L'ARN del progetto che contiene le policy di progetto che desideri elencare.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import java.util.logging.Level;
import java.util.logging.Logger;
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.ListProjectPoliciesRequest;
import software.amazon.awssdk.services.rekognition.model.ListProjectPoliciesResponse;
import software.amazon.awssdk.services.rekognition.model.ProjectPolicy;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class ListProjectPolicies {
public static final Logger logger = Logger.getLogger(ListProjectPolicies.class.getName());
public static void listMyProjectPolicies(RekognitionClient rekClient, String projectArn) {
try {
logger.log(Level.INFO, "Listing project policies for project: {0}", projectArn);
// List the project policies.
Boolean finished = false;
String nextToken = null;
while (Boolean.FALSE.equals(finished)) {
ListProjectPoliciesRequest listProjectPoliciesRequest = ListProjectPoliciesRequest.builder()
.maxResults(5)
.projectArn(projectArn)
.nextToken(nextToken)
.build();
ListProjectPoliciesResponse response = rekClient.listProjectPolicies(listProjectPoliciesRequest);
for (ProjectPolicy projectPolicy : response.projectPolicies()) {
System.out.println(String.format("Name: %s", projectPolicy.policyName()));
System.out.println(String.format("Revision ID: %s\n", projectPolicy.policyRevisionId()));
}
nextToken = response.nextToken();
if (nextToken == null) {
finished = true;
}
}
logger.log(Level.INFO, "Finished listing project policies for project: {0}", projectArn);
} catch (
RekognitionException e) {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - The ARN of the project with the project policies that you want to list.\n\n";
;
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String projectArn = args[0];
try {
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// List the project policies.
listMyProjectPolicies(rekClient, projectArn);
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Eliminazione di una policy di progetto (SDK)
Puoi utilizzare l'[DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy)operazione per eliminare una revisione di una politica di progetto esistente da un progetto Amazon Rekognition Custom Labels. Se desideri eliminare tutte le revisioni di una politica di progetto allegate a un progetto, utilizza questa opzione per [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)allegare la revisione IDs di ogni politica di progetto al progetto. Quindi chiama `DeletePolicy` per ogni nome di policy.
**Per eliminare una revisione di una policy di progetto (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 seguente per eliminare una policy di progetto.
DeletePolicy prende `ProjectARN` `PolicyName` e`PolicyRevisionId`. `ProjectARN`e `PolicyName` sono necessari per questa API. `PolicyRevisionId`è facoltativo, ma può essere incluso ai fini degli aggiornamenti atomici.
------
#### [ AWS CLI ]
Imposta i valori seguenti:
+ `policy-name` per il nome della policy di progetto che desideri eliminare.
+ `policy-revision-id` per l'ID di revisione della policy di progetto che desideri eliminare.
+ `project-arn` per l'Amazon Resource Name del progetto che contiene la revisione della policy del progetto che desideri eliminare.
```
aws rekognition delete-project-policy \
--policy-name policy-name \
--policy-revision-id policy-revision-id \
--project-arn project-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `policy-name` — Il nome della policy di progetto che desideri eliminare.
+ `project-arn` — Il nome della risorsa Amazon del progetto che contiene la policy del progetto che desideri eliminare.
+ `policy-revision-id` — L'ID di revisione della policy di progetto che desideri eliminare.
Ad esempio: `python delete_project_policy.py policy_name project_arn` *policy\$1revision\$1id*
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Amazon Rekognition Custom Labels model example used in the service documentation:
https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-copy-model-sdk.html
Shows how to delete a revision of a project policy.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def delete_project_policy(rekognition_client, policy_name, project_arn, policy_revision_id=None):
"""
Deletes a project policy.
:param rekognition_client: A Boto3 Amazon Rekognition client.
:param policy_name: The name of the project policy that you want to delete.
:param policy_revision_id: The revsion ID for the project policy that you want to delete.
:param project_arn: The Amazon Resource Name of the project that contains the project policy
that you want to delete.
"""
try:
logger.info("Deleting project policy: %s", policy_name)
if policy_revision_id is None:
rekognition_client.delete_project_policy(
PolicyName=policy_name,
ProjectArn=project_arn)
else:
rekognition_client.delete_project_policy(
PolicyName=policy_name,
PolicyRevisionId=policy_revision_id,
ProjectArn=project_arn)
logger.info("Deleted project policy: %s", policy_name)
except ClientError:
logger.exception("Couldn't delete project policy.")
raise
def confirm_project_policy_deletion(policy_name):
"""
Confirms deletion of the project policy. Returns True if delete entered.
:param model_arn: The ARN of the model that you want to delete.
"""
print(
f"Are you sure you wany to delete project policy {policy_name} ?\n", policy_name)
delete = input("Enter delete to delete your project policy: ")
if delete == "delete":
return True
else:
return False
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"policy_name", help="The ARN of the project that contains the project policy that you want to delete."
)
parser.add_argument(
"project_arn", help="The ARN of the project project policy you want to delete."
)
parser.add_argument(
"--policy_revision_id", help="(Optional) The revision ID of the project policy that you want to delete.",
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()
if confirm_project_policy_deletion(args.policy_name) is True:
print(f"Deleting project_policy: {args.policy_name}")
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
# Delete the project policy.
delete_project_policy(rekognition_client,
args.policy_name,
args.project_arn,
args.policy_revision_id)
print(f"Finished deleting project policy: {args.policy_name}")
else:
print(f"Not deleting project policy {args.policy_name}")
except ClientError as err:
print(f"Couldn't delete project policy in {args.policy_name}: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Usa il seguente codice. Fornisci i seguenti parametri di riga di comando:
+ `policy-name` — Il nome della policy di progetto che desideri eliminare.
+ `project-arn` — Il nome della risorsa Amazon del progetto che contiene la policy del progetto che desideri eliminare.
+ `policy-revision-id` — L'ID di revisione della policy di progetto che desideri eliminare.
```
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;
import java.util.logging.Level;
import java.util.logging.Logger;
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.DeleteProjectPolicyRequest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class DeleteProjectPolicy {
public static final Logger logger = Logger.getLogger(DeleteProjectPolicy.class.getName());
public static void deleteMyProjectPolicy(RekognitionClient rekClient, String projectArn,
String projectPolicyName,
String projectPolicyRevisionId)
throws InterruptedException {
try {
String[] logArguments = new String[] { projectPolicyName, projectPolicyRevisionId };
logger.log(Level.INFO, "Deleting: Project policy: {0} revision: {1}", logArguments);
// Delete the project policy.
DeleteProjectPolicyRequest deleteProjectPolicyRequest = DeleteProjectPolicyRequest.builder()
.policyName(projectPolicyName)
.policyRevisionId(projectPolicyRevisionId)
.projectArn(projectArn).build();
rekClient.deleteProjectPolicy(deleteProjectPolicyRequest);
logger.log(Level.INFO, "Deleted: Project policy: {0} revision: {1}", logArguments);
} catch (
RekognitionException e) {
logger.log(Level.SEVERE, "Client error occurred: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
final String USAGE = "\n" + "Usage: " + " \n\n"
+ "Where:\n"
+ " project_arn - The ARN of the project that has the project policy that you want to delete.\n\n"
+ " project_policy_name - The name of the project policy that you want to delete.\n\n"
+ " project_policy_revision_id - The revision of the project policy that you want to delete.\n\n";
if (args.length != 3) {
System.out.println(USAGE);
System.exit(1);
}
String projectArn = args[0];
String projectPolicyName = args[1];
String projectPolicyRevisionId = args[2];
try {
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Delete the project policy.
deleteMyProjectPolicy(rekClient, projectArn, projectPolicyName, projectPolicyRevisionId);
System.out.println(String.format("project policy deleted: %s revision: %s", projectPolicyName,
projectPolicyRevisionId));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
catch (InterruptedException intError) {
logger.log(Level.SEVERE, "Exception while sleeping: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------