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.
# Verwalten eines Amazon Rekognition Custom Labels-Modells
Ein Amazon Rekognition Custom Labels-Modell ist ein mathematisches Modell, das das Vorhandensein von Objekten, Szenen und Konzepten in neuen Bildern vorhersagt. Dazu sucht es nach Mustern in Bildern, die zum Trainieren des Modells verwendet wurden. In diesem Abschnitt erfahren Sie, wie Sie ein Modell trainieren, seine Leistung bewerten und Verbesserungen vornehmen. Außerdem erfahren Sie, wie Sie ein Modell für die Verwendung verfügbar machen und wie Sie ein Modell löschen, wenn Sie es nicht mehr benötigen.
**Topics**
+ [Löschen eines Amazon Rekognition Custom Labels-Modells](tm-delete-model.md)
+ [Einem Modell Tags hinzufügen](tm-tagging-model.md)
+ [Beschreibung eines Modells (SDK)](md-describing-model-sdk.md)
+ [Kopieren eines Amazon Rekognition Custom Labels-Modells (SDK)](md-copy-model-overview.md)
# Löschen eines Amazon Rekognition Custom Labels-Modells
Sie können ein Modell mithilfe der Amazon Rekognition Custom Labels-Konsole oder mithilfe der [DeleteProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectVersion)API löschen. Sie können ein Modell nicht löschen, wenn es läuft oder trainiert wird. Verwenden Sie die API, um ein laufendes Modell zu beenden. [StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion) Weitere Informationen finden Sie unter [Stoppen eines Amazon Rekognition Custom Labels-Modells (SDK)](rm-stop.md#rm-stop-sdk). Wenn ein Modell trainiert wird, warten Sie, bis es fertig ist, bevor Sie das Modell löschen.
Ein gelöschtes Modell kann nicht wiederhergestellt werden.
**Topics**
+ [Löschen eines Amazon Rekognition Custom Labels-Modells (Konsole)](#tm-delete-model-console)
+ [Löschen eines Amazon Rekognition Custom Labels-Modells (SDK)](#tm-delete-model-sdk)
## Löschen eines Amazon Rekognition Custom Labels-Modells (Konsole)
Das folgende Verfahren zeigt, wie Sie ein Modell von einer Projektdetailseite löschen. Sie können ein Modell auch von der Detailseite eines Modells löschen.
**So löschen 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 das Projekt aus, das das Modell enthält, das Sie löschen möchten. Die Seite mit Projektdetails wird geöffnet.
1. Wählen Sie im Abschnitt **Modelle** die Modelle aus, die Sie löschen möchten.
**Anmerkung**
Wenn das Modell nicht ausgewählt werden kann, läuft das Modell entweder gerade oder wird trainiert und kann nicht gelöscht werden. Überprüfen Sie das Feld **Status** und versuchen Sie es erneut, nachdem Sie das laufende Modell gestoppt haben, oder warten Sie, bis das Training beendet ist.
1. Wählen Sie **Modell löschen**. Daraufhin wird das Dialogfeld **Modell löschen** angezeigt.
1. Geben Sie **Löschen** ein, um den Löschvorgang zu bestätigen.
1. Wählen Sie **Löschen**, um das Modell zu löschen. Das Löschen des Modells kann eine Weile dauern.
**Anmerkung**
Wenn Sie das Dialogfeld während des Löschens des Modells **schließen**, werden die Modelle trotzdem gelöscht.
## Löschen eines Amazon Rekognition Custom Labels-Modells (SDK)
Sie löschen ein Amazon Rekognition Custom Labels-Modell, indem Sie den Amazon-Ressourcennamen (ARN) des Modells, das Sie löschen möchten, aufrufen [DeleteProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectVersion)und angeben. Sie können den Modell-ARN im Abschnitt **Ihr Modell verwenden** auf der Seite mit den Modelldetails in der Amazon Rekognition Custom Labels-Konsole abrufen. Rufen Sie alternativ an [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)und geben Sie Folgendes an.
+ Der ARN des Projekts (`ProjectArn`), dem das Modell zugeordnet ist.
+ Der Versionsname (`VersionNames`) des Modells.
Das Modell ARN ist das `ProjectVersionArn` Feld im [ProjectVersionDescription](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProjectVersionDescription)Objekt aus der `DescribeProjectVersions` Antwort.
Sie können ein Modell nicht löschen, wenn es ausgeführt oder trainiert wird. Um festzustellen, ob das Modell läuft oder trainiert, rufen Sie das `Status` Feld des [ProjectVersionDescription](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ProjectVersionDescription)Modellobjekts auf [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DescribeProjectVersions)und überprüfen Sie es. Verwenden Sie die [StopProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StopProjectVersion)API, um ein laufendes Modell zu beenden. Weitere Informationen finden Sie unter [Stoppen eines Amazon Rekognition Custom Labels-Modells (SDK)](rm-stop.md#rm-stop-sdk). Sie müssen warten, bis ein Modell das Training abgeschlossen hat, bevor Sie es löschen können.
**So löschen 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 Code, um ein Modell zu löschen.
------
#### [ AWS CLI ]
Ändern Sie den Wert von `project-version-arn` in den Namen des Projekts, das Sie löschen möchten.
```
aws rekognition delete-project-version --project-version-arn model_arn \
--profile custom-labels-access
```
------
#### [ Python ]
Geben Sie die folgenden Befehlszeilenparameter an
+ `project_arn` — den ARN des Projekts mit dem Modell, das Sie löschen möchten.
+ `model_arn` — den ARN der Modellversion, die Sie löschen möchten.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to delete an existing Amazon Rekognition Custom Labels model.
"""
import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def find_forward_slash(input_string, n):
"""
Returns the location of '/' after n number of occurences.
:param input_string: The string you want to search
: n: the occurence that you want to find.
"""
position = input_string.find('/')
while position >= 0 and n > 1:
position = input_string.find('/', position + 1)
n -= 1
return position
def delete_model(rek_client, project_arn, model_arn):
"""
Deletes an Amazon Rekognition Custom Labels model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param model_arn: The ARN of the model version that you want to delete.
"""
try:
# Delete the model
logger.info("Deleting dataset: {%s}", model_arn)
rek_client.delete_project_version(ProjectVersionArn=model_arn)
# Get the model version name
start = find_forward_slash(model_arn, 3) + 1
end = find_forward_slash(model_arn, 4)
version_name = model_arn[start:end]
deleted = False
# model might not be deleted yet, so wait deletion finishes.
while deleted is False:
describe_response = rek_client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
if len(describe_response['ProjectVersionDescriptions']) == 0:
deleted = True
else:
logger.info("Waiting for model deletion %s", model_arn)
time.sleep(5)
logger.info("model deleted: %s", model_arn)
return True
except ClientError as err:
logger.exception("Couldn't delete 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 delete."
)
parser.add_argument(
"model_arn", help="The ARN of the model version that you want to delete."
)
def confirm_model_deletion(model_arn):
"""
Confirms deletion of the model. 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 model {model_arn} ?\n", model_arn)
start = input("Enter delete to delete your model: ")
if start == "delete":
return True
else:
return 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_model_deletion(args.model_arn) is True:
print(f"Deleting model: {args.model_arn}")
# Delete the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
delete_model(rekognition_client,
args.project_arn,
args.model_arn)
print(f"Finished deleting model: {args.model_arn}")
else:
print(f"Not deleting model {args.model_arn}")
except ClientError as err:
print(f"Problem deleting model: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
+ `project_arn` — den ARN des Projekts mit dem Modell, das Sie löschen möchten.
+ `model_arn` — den ARN der Modellversion, die Sie löschen möchten.
```
//Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-custom-labels-developer-guide/blob/master/LICENSE-SAMPLECODE.)
import java.net.URI;
import java.util.logging.Level;
import java.util.logging.Logger;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DeleteProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.DeleteProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
public class DeleteModel {
public static final Logger logger = Logger.getLogger(DeleteModel.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 deleteMyModel(RekognitionClient rekClient, String projectArn, String modelArn)
throws InterruptedException {
try {
logger.log(Level.INFO, "Deleting model: {0}", projectArn);
// Delete the model
DeleteProjectVersionRequest deleteProjectVersionRequest = DeleteProjectVersionRequest.builder()
.projectVersionArn(modelArn).build();
DeleteProjectVersionResponse response =
rekClient.deleteProjectVersion(deleteProjectVersionRequest);
logger.log(Level.INFO, "Status: {0}", response.status());
// Get the model version
int start = findForwardSlash(modelArn, 3) + 1;
int end = findForwardSlash(modelArn, 4);
String versionName = modelArn.substring(start, end);
Boolean deleted = false;
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.projectArn(projectArn).versionNames(versionName).build();
// Wait until model is deleted.
do {
DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
.describeProjectVersions(describeProjectVersionsRequest);
if (describeProjectVersionsResponse.projectVersionDescriptions().size()==0) {
logger.log(Level.INFO, "Waiting for model deletion: {0}", modelArn);
Thread.sleep(5000);
} else {
deleted = true;
logger.log(Level.INFO, "Model deleted: {0}", modelArn);
}
} while (Boolean.FALSE.equals(deleted));
logger.log(Level.INFO, "Model deleted: {0}", modelArn);
} 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 contains the model that you want to delete.\n\n"
+ " model_version - The ARN of the model that you want to delete.\n\n";
if (args.length != 2) {
System.out.println(USAGE);
System.exit(1);
}
String projectArn = args[0];
String modelVersion = args[1];
try {
RekognitionClient rekClient = RekognitionClient.builder().build();
// Delete the model
deleteMyModel(rekClient, projectArn, modelVersion);
System.out.println(String.format("model deleted: %s", modelVersion));
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);
}
}
}
```
------
# Einem Modell Tags hinzufügen
Sie können Ihre Amazon Rekognition-Modelle mithilfe von Tags identifizieren, organisieren, suchen und filtern. Jedes Tag ist eine Bezeichnung, die aus einem benutzerdefinierten Schlüssel und Wert besteht. Um beispielsweise die Abrechnung für Ihre Modelle zu bestimmen, taggen Sie Ihre Modelle mit einem `Cost center`-Schlüssel und fügen Sie die entsprechende Kostenstellennummer als Wert hinzu. Weitere Informationen finden Sie unter [Taggen von AWS-Ressourcen](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Verwenden Sie Tags, um:
+ Verfolgen Sie die Abrechnung für ein Modell mithilfe von Kostenzuweisungs-Tags. Weitere Informationen finden Sie unter [Verwendung von Kostenzuordnungs-Tags](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html).
+ Den Zugriff auf ein Modell kontrollieren mit Identity and Access Management (IAM). Weitere Informationen finden Sie unter [Steuern des Zugriffs auf AWS -Ressourcen mithilfe von Ressourcen-Tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html).
+ Die Modellverwaltung automatisieren. Sie können zum Beispiel automatische Start- oder Stoppskripte ausführen, die Entwicklungsmodelle außerhalb der Geschäftszeiten abschalten, um Kosten zu sparen. Weitere Informationen finden Sie unter [Ausführen eines trainierten Amazon Rekognition Custom Labels-Modells](running-model.md).
Sie können Modelle mit der Amazon Rekognition Rekognition-Konsole oder mit der kennzeichnen. AWS SDKs
**Topics**
+ [Taggen von Modellen (Konsole)](#tm-tagging-model-console)
+ [Anzeigen von Modell-Tags](#tm-tagging-model-viewing-console)
+ [Modelle kennzeichnen (SDK)](#tm-tagging-model-sdk)
## Taggen von Modellen (Konsole)
Sie können die Rekognition-Konsole verwenden, um Tags zu Modellen hinzuzufügen, die an ein Modell angehängten Tags anzuzeigen und Tags zu entfernen.
### Hinzufügen und Entfernen von Tags
In diesem Verfahren wird erklärt, wie Sie einem vorhandenen Modell Tags hinzufügen oder Tags daraus entfernen. Sie können einem neuen Modell auch Tags hinzufügen, wenn es trainiert wird. Weitere Informationen finden Sie unter [Trainieren eines Amazon Rekognition Custom Labels-Modells](training-model.md).
**So fügen Sie einem vorhandenen Modell mithilfe der Konsole Tags hinzu oder entfernen sie**
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 **Erste Schritte**.
1. Klicken Sie im Navigationsbereich auf **Projekte**.
1. Wählen Sie auf der Ressourcenseite **Projekte** das Projekt aus, das das Modell enthält, dem Sie Tags hinzufügen möchten.
1. Wählen Sie im Navigationsbereich unter dem Projekt, das Sie zuvor ausgewählt haben, **Modelle** aus.
1. Wählen Sie im Abschnitt **Modelle** das Modell aus, dem Sie ein Tag hinzufügen möchten.
1. Wählen Sie auf der Seite mit den Modelldetails die Registerkarte **Tags** aus.
1. Wählen Sie im Abschnitt **Tags (Markierungen)** die Option **Manage tags (Tags (Markierungen) verwalten)**.
1. Wählen Sie auf der Seite **Tags verwalten** **Neuen Tag hinzufügen** aus.
1. Geben Sie einen Key Schlüssel und einen Wert ein.
1. Geben Sie für **Schlüssel** einen Schlüsselnamen ein.
1. Geben Sie unter **Value (Wert)** einen Wert ein.
1. Wiederholen Sie die Schritte 9 und 10, um weitere Tags hinzuzufügen.
1. (Optional) Wählen Sie zum Entfernen eines Tags neben dem Tag, den Sie entfernen möchten, **Entfernen.** Wenn Sie ein zuvor gespeichertes Tag entfernen, wird es entfernt, wenn Sie Ihre Änderungen speichern.
1. Wählen Sie **Änderungen speichern** aus, um Ihre Änderungen zu speichern.
## Anzeigen von Modell-Tags
Sie können mit der Amazon Rekognition-Konsole die Tags anzeigen, die einem Modell angefügt sind.
Um die Tags anzuzeigen, die *allen Modellen innerhalb eines Projekts* zugeordnet sind, müssen Sie das AWS-SDK verwenden. Weitere Informationen finden Sie unter [Auflisten von Modell-Tags](#listing-model-tags-sdk).
**So zeigen Sie die einem Modell angefügten Tags an**
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 **Erste Schritte**.
1. Klicken Sie im Navigationsbereich auf **Projekte**.
1. Wählen Sie auf der Seite **Projektressourcen** das Projekt aus, das das Modell enthält, dessen Tag Sie anzeigen möchten.
1. Wählen Sie im Navigationsbereich unter dem Projekt, das Sie zuvor ausgewählt haben, **Modelle** aus.
1. Wählen Sie im Abschnitt **Modelle** das Modell aus, dessen Tag Sie anzeigen möchten.
1. Wählen Sie auf der Seite mit den Modelldetails die Registerkarte **Tags** aus. Die Tags werden im Abschnitt **Tags** angezeigt.
## Modelle kennzeichnen (SDK)
Sie können das AWS SDK verwenden, um:
+ Hinzufügen von Tags zu einem neuen Modell
+ Hinzufügen von Tags zu einem vorhandenen Modell
+ Auflisten der einem Modell angefügten Tags
+ Entfernen von Tags von einem Modell
Die Tags in den folgenden AWS CLI Beispielen haben das folgende Format.
```
--tags '{"key1":"value1","key2":"value2"}'
```
Alternativ können Sie auch dieses Format verwenden.
```
--tags key1=value1,key2=value2
```
Falls Sie das nicht installiert haben AWS CLI, finden Sie weitere Informationen unter[Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
### Hinzufügen von Tags zu einem neuen Modell
Sie können einem Modell Beschriftungen hinzufügen, wenn Sie es mithilfe dieser [CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion.html)Operation erstellen. Geben Sie ein oder mehrere Tags im `Tags`-Array-Eingabeparameter an.
```
aws rekognition create-project-version --project-arn project arn \
--version-name version_name \
--output-config '{ "S3Location": { "Bucket": "output bucket", "Prefix": "output folder" } }' \
--tags '{"key1":"value1","key2":"value2"}' \
--profile custom-labels-access
```
Informationen zum Erstellen und Trainieren eines Modells finden Sie unter [Ein Modell trainieren (SDK)](training-model.md#tm-sdk).
### Hinzufügen von Tags zu einem vorhandenen Modell
Verwenden Sie die [TagResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TagResource)Operation, um einem vorhandenen Modell ein oder mehrere Tags hinzuzufügen. Geben Sie den Amazon-Ressourcennamen (ARN) (`ResourceArn`) des Modells und die Tags (`Tags`) an, die Sie hinzufügen möchten. Das folgende Beispiel zeigt, wie zwei Tags hinzugefügt werden.
```
aws rekognition tag-resource --resource-arn resource-arn \
--tags '{"key1":"value1","key2":"value2"}' \
--profile custom-labels-access
```
Sie können den ARN für ein Modell telefonisch abrufen [CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion).
### Auflisten von Modell-Tags
Um die an ein Modell angehängten Tags aufzulisten, verwenden Sie die [ListTagsForResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListTagsForResource)Operation und geben Sie den ARN des Modells an (`ResourceArn`). Die Antwort ist eine Zuordnung von Tag-Schlüsseln und -Werten, die an das angegebene Modell angefügt sind.
```
aws rekognition list-tags-for-resource --resource-arn resource-arn \
--profile custom-labels-access
```
In der Ausgabe wird eine Liste der Tags angezeigt, die an das Modell angefügt sind.
```
{
"Tags": {
"Dept": "Engineering",
"Name": "Ana Silva Carolina",
"Role": "Developer"
}
}
```
Um zu sehen, welche Modelle in einem Projekt über ein bestimmtes Tag verfügen, rufen Sie `DescribeProjectVersions` auf, um eine Liste der Modelle abzurufen. Rufen Sie dann in der Antwort von `DescribeProjectVersions` für jedes Modell `ListTagsForResource` auf. Überprüfen Sie die Antwort von `ListTagsForResource`, um festzustellen, ob das erforderliche Tag vorhanden ist.
Das folgende Python 3-Beispiel zeigt Ihnen, wie Sie alle Ihre Projekte nach einem bestimmten Tag-Schlüssel und -Wert durchsuchen. Die Ausgabe umfasst den Projekt-ARN und den Modell-ARN, in dem ein passender Schlüssel gefunden wurde.
**So suchen Sie nach einem Tag-Wert**
1. Speichern Sie den folgenden Code in eine Datei mit dem Namen `find_tag.py`.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to find a tag value that's associated with models within
your Amazon Rekognition Custom Labels projects.
"""
import logging
import argparse
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def find_tag_in_projects(rekognition_client, key, value):
"""
Finds Amazon Rekognition Custom Label models tagged with the supplied key and key value.
:param rekognition_client: An Amazon Rekognition boto3 client.
:param key: The tag key to find.
:param value: The value of the tag that you want to find.
return: A list of matching model versions (and model projects) that were found.
"""
try:
found_tags = []
found = False
projects = rekognition_client.describe_projects()
# Iterate through each project and models within a project.
for project in projects["ProjectDescriptions"]:
logger.info("Searching project: %s ...", project["ProjectArn"])
models = rekognition_client.describe_project_versions(
ProjectArn=(project["ProjectArn"])
)
for model in models["ProjectVersionDescriptions"]:
logger.info("Searching model %s", model["ProjectVersionArn"])
tags = rekognition_client.list_tags_for_resource(
ResourceArn=model["ProjectVersionArn"]
)
logger.info(
"\tSearching model: %s for tag: %s value: %s.",
model["ProjectVersionArn"],
key,
value,
)
# Check if tag exists.
if key in tags["Tags"]:
if tags["Tags"][key] == value:
found = True
logger.info(
"\t\tMATCH: Project: %s: model version %s",
project["ProjectArn"],
model["ProjectVersionArn"],
)
found_tags.append(
{
"Project": project["ProjectArn"],
"ModelVersion": model["ProjectVersionArn"],
}
)
if found is False:
logger.info("No match for Tag %s with value %s.", key, value)
return found_tags
except ClientError as err:
logger.info("Problem finding tags: %s. ", format(err))
raise
def main():
"""
Entry point for example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
# Set up command line arguments.
parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
parser.add_argument("tag", help="The tag that you want to find.")
parser.add_argument("value", help="The tag value that you want to find.")
args = parser.parse_args()
key = args.tag
value = args.value
print(f"Searching your models for tag: {key} with value: {value}.")
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
# Get tagged models for all projects.
tagged_models = find_tag_in_projects(rekognition_client, key, value)
print("Matched models\n--------------")
if len(tagged_models) > 0:
for model in tagged_models:
print(
"Project: {project}\nModel version: {version}\n".format(
project=model["Project"], version=model["ModelVersion"]
)
)
else:
print("No matches found.")
print("Done.")
if __name__ == "__main__":
main()
```
1. Geben Sie in der Eingabeaufforderung Folgendes ein. Ersetzen Sie *key* und *value* durch den Schlüsselnamen und den Schlüsselwert, nach dem Sie suchen möchten.
```
python find_tag.py key value
```
### Löschen von Tags aus einem Modell
Verwenden Sie die [UntagResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UntagResource)Operation, um ein oder mehrere Tags aus einem Modell zu entfernen. Geben Sie den ARN des Modells (`ResourceArn`) und die Tag-Schlüssel (`Tag-Keys`) an, die Sie entfernen möchten.
```
aws rekognition untag-resource --resource-arn resource-arn \
--tag-keys '["key1","key2"]' \
--profile custom-labels-access
```
Alternativ können Sie `tag-keys` in diesem Format angeben.
```
--tag-keys key1,key2
```
# Beschreibung eines Modells (SDK)
Sie können die `DescribeProjectVersions`-API verwenden, um Informationen über eine Version eines Modells abzurufen. Wenn Sie `VersionName` nicht angeben, gibt `DescribeProjectVersions` Beschreibungen für alle Modellversionen im Projekt zurück.
**So beschreiben 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 eine Version eines Modells zu beschreiben.
------
#### [ AWS CLI ]
Ändern Sie den Wert von `project-arn` in den ARN des Projekts, das Sie beschreiben möchten. Ändern Sie den Wert von `version-name` in die Version des Modells, das Sie beschreiben möchten.
```
aws rekognition describe-project-versions --project-arn project_arn \
--version-names version_name \
--profile custom-labels-access
```
------
#### [ Python ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ project\$1arn — der ARN des Modells, das Sie beschreiben möchten.
+ model\$1version — die Version des Modells, das Sie beschreiben möchten.
Beispiel: `python describe_model.py project_arn model_version `
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to describe an Amazon Rekognition Custom Labels model.
"""
import argparse
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def describe_model(rek_client, project_arn, version_name):
"""
Describes an Amazon Rekognition Custom Labels model.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the prject that contains the model.
:param version_name: The version name of the model that you want to describe.
"""
try:
# Describe the model
logger.info("Describing model: %s for project %s",
version_name, project_arn)
describe_response = rek_client.describe_project_versions(ProjectArn=project_arn,
VersionNames=[version_name])
for model in describe_response['ProjectVersionDescriptions']:
print(f"Created: {str(model['CreationTimestamp'])} ")
print(f"ARN: {str(model['ProjectVersionArn'])} ")
if 'BillableTrainingTimeInSeconds' in model:
print(
f"Billing training time (minutes): {str(model['BillableTrainingTimeInSeconds']/60)} ")
print("Evaluation results: ")
if 'EvaluationResult' in model:
evaluation_results = model['EvaluationResult']
print(f"\tF1 score: {str(evaluation_results['F1Score'])}")
print(
f"\tSummary location: s3://{evaluation_results['Summary']['S3Object']['Bucket']}/{evaluation_results['Summary']['S3Object']['Name']}")
if 'ManifestSummary' in model:
print(
f"Manifest summary location: s3://{model['ManifestSummary']['S3Object']['Bucket']}/{model['ManifestSummary']['S3Object']['Name']}")
if 'OutputConfig' in model:
print(
f"Training output location: s3://{model['OutputConfig']['S3Bucket']}/{model['OutputConfig']['S3KeyPrefix']}")
if 'MinInferenceUnits' in model:
print(
f"Minimum inference units: {str(model['MinInferenceUnits'])}")
if 'MaxInferenceUnits' in model:
print(
f"Maximum Inference units: {str(model['MaxInferenceUnits'])}")
print("Status: " + model['Status'])
print("Message: " + model['StatusMessage'])
except ClientError as err:
logger.exception(
"Couldn't describe model: %s", 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 in which the model resides."
)
parser.add_argument(
"version_name", help="The version of the model that you want to describe."
)
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"Describing model: {args.version_name} for project {args.project_arn}.")
# Describe the model.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
describe_model(rekognition_client, args.project_arn,
args.version_name)
print(
f"Finished describing model: {args.version_name} for project {args.project_arn}.")
except ClientError as err:
error_message = f"Problem describing model: {err}"
logger.exception(error_message)
print(error_message)
except Exception as err:
error_message = f"Problem describing model: {err}"
logger.exception(error_message)
print(error_message)
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ project\$1arn — der ARN des Modells, das Sie beschreiben möchten.
+ model\$1version — die Version des Modells, das Sie beschreiben möchten.
```
/*
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.EvaluationResult;
import software.amazon.awssdk.services.rekognition.model.GroundTruthManifest;
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 DescribeModel {
public static final Logger logger = Logger.getLogger(DescribeModel.class.getName());
public static void describeMyModel(RekognitionClient rekClient, String projectArn, String versionName) {
try {
// If a single version name is supplied, build request argument
DescribeProjectVersionsRequest describeProjectVersionsRequest = null;
if (versionName == null) {
describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder().projectArn(projectArn)
.build();
} else {
describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder().projectArn(projectArn)
.versionNames(versionName).build();
}
DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
.describeProjectVersions(describeProjectVersionsRequest);
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
System.out.println("ARN: " + projectVersionDescription.projectVersionArn());
System.out.println("Status: " + projectVersionDescription.statusAsString());
System.out.println("Message: " + projectVersionDescription.statusMessage());
if (projectVersionDescription.billableTrainingTimeInSeconds() != null) {
System.out.println(
"Billable minutes: " + (projectVersionDescription.billableTrainingTimeInSeconds() / 60));
}
if (projectVersionDescription.evaluationResult() != null) {
EvaluationResult evaluationResult = projectVersionDescription.evaluationResult();
System.out.println("F1 Score: " + evaluationResult.f1Score());
System.out.println("Summary location: s3://" + evaluationResult.summary().s3Object().bucket() + "/"
+ evaluationResult.summary().s3Object().name());
}
if (projectVersionDescription.manifestSummary() != null) {
GroundTruthManifest manifestSummary = projectVersionDescription.manifestSummary();
System.out.println("Manifest summary location: s3://" + manifestSummary.s3Object().bucket() + "/"
+ manifestSummary.s3Object().name());
}
if (projectVersionDescription.outputConfig() != null) {
OutputConfig outputConfig = projectVersionDescription.outputConfig();
System.out.println(
"Training output: s3://" + outputConfig.s3Bucket() + "/" + outputConfig.s3KeyPrefix());
}
if (projectVersionDescription.minInferenceUnits() != null) {
System.out.println("Min inference units: " + projectVersionDescription.minInferenceUnits());
}
System.out.println();
}
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
throw rekError;
}
}
public static void main(String args[]) {
String projectArn = null;
String versionName = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - The ARN of the project that contains the models you want to describe.\n\n"
+ " version_name - (optional) The version name of the model that you want to describe. \n\n"
+ " If you don't specify a value, all model versions are described.\n\n";
if (args.length > 2 || args.length == 0) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
if (args.length == 2) {
versionName = args[1];
}
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Describe the model
describeMyModel(rekClient, projectArn, versionName);
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
# Kopieren eines Amazon Rekognition Custom Labels-Modells (SDK)
Sie können den [CopyProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CopyProjectVersion)Vorgang verwenden, um eine Amazon Rekognition Custom Labels-Modellversion von einem Amazon Rekognition Custom Labels-Quellprojekt in ein Zielprojekt zu kopieren. Das Zielprojekt kann sich in einem anderen AWS Konto oder im selben Konto befinden. AWS Ein typisches Szenario ist das Kopieren eines getesteten Modells von einem AWS Entwicklungskonto auf ein AWS Produktionskonto.
Alternativ können Sie das Modell im Zielkonto mit dem Quelldatensatz trainieren. Die Verwendung des `CopyProjectVersion`-Vorgangs hat die folgenden Vorteile.
+ Das Modellverhalten ist konsistent. Das Modelltraining ist nicht deterministisch, und es ist nicht garantiert, dass zwei Modelle, die mit demselben Datensatz trainiert wurden, dieselben Vorhersagen treffen. Durch Kopieren des Modells mit wird `CopyProjectVersion` sichergestellt, dass das Verhalten des kopierten Modells mit dem des Quellmodells übereinstimmt, sodass Sie das Modell nicht erneut testen müssen.
+ Ein Modelltraining ist nicht erforderlich. Dadurch sparen Sie Geld, da Ihnen jedes erfolgreiche Training eines Modells in Rechnung gestellt wird.
Um ein Modell auf ein anderes AWS Konto zu kopieren, muss das AWS Zielkonto über ein Amazon Rekognition Custom Labels-Projekt verfügen. Informationen über das Erstellen eines Projekts finden Sie unter [Erstellen eines Projekts](mp-create-project.md). Stellen Sie sicher, dass Sie das Projekt im AWS Zielkonto erstellen.
Eine [Projektrichtlinie](md-create-project-policy-document.md) ist eine ressourcenbasierte Richtlinie, die Kopierberechtigungen für die Modellversion festlegt, die Sie kopieren möchten. Sie müssen eine [Projektrichtlinie](md-create-project-policy-document.md) verwenden, wenn sich das Zielprojekt in einem anderen AWS Konto befindet als das Quellprojekt.
Sie müssen keine [Projektrichtlinie](md-create-project-policy-document.md) verwenden, wenn Sie Modellversionen innerhalb desselben Kontos kopieren. Sie können sich jedoch dafür entscheiden, eine [Projektrichtlinie für](md-create-project-policy-document.md) Projekte mit mehreren Konten zu verwenden, wenn Sie mehr Kontrolle über diese Ressourcen haben möchten.
Sie fügen die Projektrichtlinie dem Quellprojekt hinzu, indem Sie den [PutProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_PutProjectPolicy)Vorgang aufrufen.
Sie können es nicht verwenden`CopyProjectVersion`, um ein Modell in ein Projekt in einer anderen AWS Region zu kopieren. Außerdem können Sie ein Modell nicht mit der Amazon Rekognition Custom Labels-Konsole kopieren. In diesen Fällen können Sie das Modell im Zielprojekt mit den Datensätzen trainieren, die zum Trainieren des Quellmodells verwendet wurden. Weitere Informationen finden Sie unter [Trainieren eines Amazon Rekognition Custom Labels-Modells](training-model.md).
Gehen Sie wie folgt vor, um ein Modell aus einem Quellprojekt in ein Zielprojekt zu kopieren:
**So kopieren Sie ein Modell**
1. [Erstellen Sie ein Dokument mit Projektrichtlinien](md-create-project-policy-document.md).
1. [Hängen Sie die Projektrichtlinie an das Quellprojekt an](md-attach-project-policy.md).
1. [Kopieren Sie das Modell mit dem `CopyProjectVersion`-Vorgang](md-copy-model-sdk.md).
Rufen Sie an, um eine Projektrichtlinie aus einem Projekt zu entfernen [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy). Rufen Sie an, um eine Liste der mit einem Projekt verknüpften Projektrichtlinien zu erhalten [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies).
**Topics**
+ [Erstellen eines Richtliniendokuments für das Projekt](md-create-project-policy-document.md)
+ [Eine Projektrichtlinie (SDK) anhängen](md-attach-project-policy.md)
+ [Kopieren eines Modells (SDK)](md-copy-model-sdk.md)
+ [Auflistung der Projektrichtlinien (SDK)](md-list-project-policies.md)
+ [Löschen einer Projektrichtlinie (SDK)](md-delete-project-policy.title.md)
# Erstellen eines Richtliniendokuments für das Projekt
Rekognition Custom Labels verwendet eine ressourcenbasierte Richtlinie, die als *Projektrichtlinie* bezeichnet wird, um Kopierberechtigungen für eine Modellversion zu verwalten. Eine Projektrichtlinie ist ein Dokument im JSON-Format.
Eine Projektrichtlinie erteilt oder verweigert einem [Prinzipal](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html#intro-structure-principal) die Erlaubnis, eine Modellversion von einem Quellprojekt in ein Zielprojekt zu kopieren. Sie benötigen eine Projektrichtlinie, wenn sich das Zielprojekt in einem anderen AWS Konto befindet. Das gilt auch, wenn sich das Zielprojekt in demselben AWS -Konto wie das Quellprojekt befindet und Sie den Zugriff auf bestimmte Modellversionen einschränken möchten. Beispielsweise möchten Sie möglicherweise Kopierberechtigungen für eine bestimmte IAM-Rolle innerhalb eines AWS Kontos verweigern.
Im folgenden Beispiel kann der Prinzipal `arn:aws:iam::111111111111:role/Admin` die Modellversion `arn:aws:rekognition:us-east-1:123456789012:project/my_project/version/test_1/1627045542080` kopieren.
------
#### [ 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"
}
]
}
```
------
**Anmerkung**
`Action`, `Resource`, `Principal` und `Effect` sind Pflichtfelder in einem Projektrichtliniendokument.
Der einzige unterstützte `action` ist `rekognition:CopyProjectVersion`.
`NotAction`, `NotResource` und `NotPrincipal` sind unzulässige Felder und dürfen nicht im Projektrichtliniendokument vorkommen.
Wenn Sie keine Projektrichtlinie angeben, kann ein Principal, der sich im gleichen AWS Konto wie das Quellprojekt befindet, trotzdem ein Modell kopieren, sofern der Prinzipal über eine identitätsbasierte Richtlinie verfügt, z. B. ` AmazonRekognitionCustomLabelsFullAccess` die Erlaubnis zum Aufrufen. `CopyProjectVersion`
Mit dem folgenden Verfahren wird eine Projektrichtlinien-Dokumentdatei erstellt, die Sie zusammen mit dem Python-Beispiel in [Eine Projektrichtlinie (SDK) anhängen](md-attach-project-policy.md) verwenden können. Wenn Sie den `put-project-policy` AWS CLI Befehl verwenden, geben Sie die Projektrichtlinie als JSON-Zeichenfolge an.
**So erstellen Sie ein Projektrichtliniendokument**
1. Erstellen Sie in einem Texteditor das folgende Dokument. Ändern Sie die folgenden Werte:
+ Effekt — Geben Sie `ALLOW` an, um die Kopierberechtigung zu erteilen. Geben Sie `DENY` an, um die Kopierberechtigung zu verweigern.
+ Prinzipal – Für den Prinzipal, dem Sie den Zugriff auf die von Ihnen in `Resource` angegebenen Modellversionen erlauben oder verweigern möchten. Sie können beispielsweise den [AWS-Kontoprinzipal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#principal-accounts) für ein anderes AWS Konto angeben. Wir schränken die Prinzipale, die Sie verwenden können, nicht ein. Weitere Informationen finden Sie unter [Angeben eines Auftraggebers](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html#Principal_specifying).
+ Ressource – Der Amazon-Ressourcenname (ARN) der Modellversion, für die Sie Kopierberechtigungen angeben möchten. Wenn Sie allen Modellversionen innerhalb des Quellprojekts Berechtigungen gewähren möchten, verwenden Sie das folgende Format `arn:aws:rekognition:region:account:project/source project/version/* `
1. Speichern Sie die Projektrichtlinie auf Ihrem Computer.
1. Hängen Sie die Projektrichtlinie an das Quellprojekt an, indem Sie den Anweisungen unter [Eine Projektrichtlinie (SDK) anhängen](md-attach-project-policy.md) folgen.
# Eine Projektrichtlinie (SDK) anhängen
Sie fügen einem Amazon Rekognition Custom Labels-Projekt eine Projektrichtlinie hinzu, indem Sie den [PutProjectpolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_PutProjectPolicy)Vorgang aufrufen.
Hängen Sie mehrere Projektrichtlinien an ein Projekt an, indem Sie `PutProjectPolicy` für jede Projektrichtlinie aufrufen, die Sie hinzufügen möchten. Sie können einem Projekt bis zu fünf Projektrichtlinien hinzufügen. Wenn Sie mehr Projektrichtlinien hinzufügen müssen, können Sie eine Erhöhung des [Limits](limits.md) beantragen.
Wenn Sie einem Projekt zum ersten Mal eine eindeutige Projektrichtlinie zuordnen, geben Sie im `PolicyRevisionId`-Eingabeparameter keine Revisions-ID an. Die Antwort von `PutProjectPolicy` ist eine Revisions-ID für die Projektrichtlinie, die Amazon Rekognition Custom Labels für Sie erstellt. Sie können die Revisions-ID verwenden, um die neueste Version einer Projektrichtlinie zu aktualisieren oder zu löschen. Amazon Rekognition Custom Labels speichert nur die neueste Version einer Projektrichtlinie. Wenn Sie versuchen, eine frühere Version einer Projektrichtlinie zu aktualisieren oder zu löschen, wird ein `InvalidPolicyRevisionIdException`-Fehler angezeigt.
Um eine bestehende Projektrichtlinie zu aktualisieren, geben Sie die Revisions-ID der Projektrichtlinie im `PolicyRevisionId`-Eingabeparameter an. Die Revision der IDs Projektrichtlinien in einem Projekt erhalten Sie telefonisch. [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)
Nachdem Sie einem Quellprojekt eine Projektrichtlinie angehängt haben, können Sie das Modell aus dem Quellprojekt in das Zielprojekt kopieren. Weitere Informationen finden Sie unter [Kopieren eines Modells (SDK)](md-copy-model-sdk.md).
Rufen Sie an, um eine Projektrichtlinie aus einem Projekt zu entfernen [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy). Rufen Sie an, um eine Liste der mit einem Projekt verknüpften Projektrichtlinien zu erhalten [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies).
**So hängen Sie eine Projektrichtlinie an ein Projekt an (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. [Erstellen Sie ein Dokument mit Projektrichtlinien](md-create-project-policy-document.md).
1. Verwenden Sie den folgenden Code, um die Projektrichtlinie an das Projekt im vertrauenswürdigen AWS Konto anzuhängen, das die Modellversion enthält, die Sie kopieren möchten. Rufen Sie an, um den Projekt-ARN zu erhalten [DescribeProjects](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-describing-project-sdk.html). Rufen Sie ARN auf, um die Modellversion abzurufen [DescribeProjectVersions](https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-describing-model-sdk.html).
------
#### [ AWS CLI ]
Ändern Sie die folgenden Werte:
+ `project-arn`an den ARN des Quellprojekts in dem vertrauenswürdigen AWS Konto, das die Modellversion enthält, die Sie kopieren möchten.
+ `policy-name` in einen von Ihnen gewählten Richtliniennamen.
+ `principal` in den Prinzipal, dem Sie den Zugriff auf die von Ihnen in `Model version ARN` angegebenen Modellversionen gewähren oder verweigern möchten.
+ `project-version-arn` in den ARN der Modellversion, die Sie kopieren möchten.
Wenn Sie eine bestehende Projektrichtlinie aktualisieren möchten, geben Sie den `policy-revision-id`-Parameter an und geben Sie die Revisions-ID der gewünschten Projektrichtlinie an.
```
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 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ `project_arn` – Der ARN des Quellprojekts, an das Sie die Projektrichtlinie anfügen möchten.
+ `policy_name` – Ein Richtlinienname, den Sie wählen.
+ `project_policy` – Die Datei, die das Dokument mit den Projektrichtlinien enthält.
+ `policy_revision_id` – (Optional). Wenn Sie eine bestehende Version einer Projektrichtlinie aktualisieren möchten, geben Sie die Revisions-ID der Projektrichtlinie an.
```
# 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 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ `project_arn` – Der ARN des Quellprojekts, an das Sie die Projektrichtlinie anfügen möchten.
+ `project_policy_name` – Ein Richtlinienname, den Sie wählen.
+ `project_policy_document` – Die Datei, die das Dokument mit den Projektrichtlinien enthält.
+ `project_policy_revision_id` – (Optional). Wenn Sie eine bestehende Version einer Projektrichtlinie aktualisieren möchten, geben Sie die Revisions-ID der Projektrichtlinie an.
```
/*
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. Kopieren Sie die Modellversion, indem Sie den Anweisungen unter [Kopieren eines Modells (SDK)](md-copy-model-sdk.md) folgen.
# Kopieren eines Modells (SDK)
Sie können die `CopyProjectVersion`-API verwenden, um eine Modellversion von einem Quellprojekt in ein Zielprojekt zu kopieren. Das Zielprojekt kann sich in einem anderen AWS Konto befinden, muss sich aber in derselben AWS Region befinden. Wenn sich das Zielprojekt in einem anderen AWS Konto befindet (oder wenn Sie bestimmte Berechtigungen für eine innerhalb eines AWS Kontos kopierte Modellversion gewähren möchten), müssen Sie dem Quellprojekt eine Projektrichtlinie hinzufügen. Weitere Informationen finden Sie unter [Erstellen eines Richtliniendokuments für das Projekt](md-create-project-policy-document.md). Für die `CopyProjectVersion`-API ist Zugriff auf Ihren Amazon-S3-Bucket erforderlich.
Das kopierte Modell enthält die Trainingsergebnisse für das Quellmodell, jedoch nicht die Quelldatensätze.
Das AWS Quellkonto ist nicht Eigentümer des Modells, das in ein Zielkonto kopiert wurde, es sei denn, Sie richten die entsprechenden Berechtigungen ein.
**So kopieren Sie ein Modell (SDK)**
1. Falls Sie dies noch nicht getan haben, installieren und konfigurieren Sie das AWS CLI und das AWS SDKs. Weitere Informationen finden Sie unter [Schritt 4: Richten Sie das und ein AWS CLI AWS SDKs](su-awscli-sdk.md).
1. Fügen Sie dem Quellprojekt eine Projektrichtlinie hinzu, indem Sie den Anweisungen unter [Eine Projektrichtlinie (SDK) anhängen](md-attach-project-policy.md) folgen.
1. Wenn Sie das Modell in ein anderes AWS Konto kopieren, stellen Sie sicher, dass das AWS Zielkonto über ein Projekt verfügt.
1. Verwenden Sie den folgenden Code, um die Modellversion in ein Zielprojekt zu kopieren.
------
#### [ AWS CLI ]
Ändern Sie die folgenden Werte:
+ `source-project-arn` in den ARN des Quellprojekts mit der Modellversion, die Sie kopieren möchten.
+ `source-project-version-arn` in den ARN der Modellversion, die Sie kopieren möchten.
+ `destination-project-arn` in den ARN des Zielprojekts, in das Sie das Modell kopieren möchten.
+ `version-name` in einen Versionsnamen für das Modell im Zielprojekt.
+ `bucket` in den S3-Bucket, in den Sie die Trainingsergebnisse für das Quellmodell kopieren möchten.
+ `folder` in den Ordner in `bucket`, in den Sie die Trainingsergebnisse für das Quellmodell kopieren möchten.
+ (Optional) `kms-key-id` in den Schlüssel-ID des AWS Key Management Service für das Modell.
+ (Optional) `key` in einen Tag-Schlüssel Ihrer Wahl.
+ (Optional) `value` in einen Tag-Wert Ihrer Wahl.
```
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 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ `source_project_arn`— der ARN des Quellprojekts im AWS Quellkonto, das die Modellversion enthält, die Sie kopieren möchten.
+ `source_project_version-arn`— der ARN der Modellversion im AWS Quellkonto, das Sie kopieren möchten.
+ `destination_project_arn` — der ARN des Zielprojekts, in das Sie das Modell kopieren möchten.
+ `destination_version_name` — ein Versionsname für das Modell im Zielprojekt.
+ `training_results` — der S3-Speicherort, an den Sie die Trainingsergebnisse für die Quellmodellversion kopieren möchten.
+ (Optional) `kms_key_id` in den Schlüssel-ID des AWS Key Management Service für das Modell.
+ (Optional) `tag_name` in einen Tag-Schlüssel Ihrer Wahl.
+ (Optional) `tag_value` in einen Tag-Wert Ihrer Wahl.
```
# 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 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ `source_project_arn`— der ARN des Quellprojekts im AWS Quellkonto, das die Modellversion enthält, die Sie kopieren möchten.
+ `source_project_version-arn`— der ARN der Modellversion im AWS Quellkonto, das Sie kopieren möchten.
+ `destination_project_arn` — der ARN des Zielprojekts, in das Sie das Modell kopieren möchten.
+ `destination_version_name` — ein Versionsname für das Modell im Zielprojekt.
+ `output_bucket` — der S3-Bucket, in den Sie die Trainingsergebnisse für die Quellmodellversion kopieren möchten.
+ `output_folder` — der Ordner im S3, in den Sie die Trainingsergebnisse für die Quellmodellversion kopieren möchten.
```
/*
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);
}
}
}
```
------
# Auflistung der Projektrichtlinien (SDK)
Sie können den [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)Vorgang verwenden, um die Projektrichtlinien aufzulisten, die an ein Amazon Rekognition Custom Labels-Projekt angehängt sind.
**So listen Sie die Projektrichtlinien auf, die an ein Projekt angefügt sind (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 Code, um die Projektrichtlinien aufzulisten.
------
#### [ AWS CLI ]
Ändern Sie `project-arn` in den Amazon-Ressourcennamen des Projekts, für das Sie die angehängten Projektrichtlinien auflisten möchten.
```
aws rekognition list-project-policies \
--project-arn project-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ project\$1arn — der Amazon-Ressourcenname des Projekts, für das Sie die angehängten Projektrichtlinien auflisten möchten.
Beispiel: `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 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ project\$1arn — Der ARN des Projekts, das die Projektrichtlinien enthält, die Sie auflisten möchten.
```
/*
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);
}
}
}
```
------
# Löschen einer Projektrichtlinie (SDK)
Sie können den [DeleteProjectPolicy](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DeleteProjectPolicy)Vorgang verwenden, um eine Version einer vorhandenen Projektrichtlinie aus einem Amazon Rekognition Custom Labels-Projekt zu löschen. Wenn Sie alle Revisionen einer Projektrichtlinie löschen möchten, die einem Projekt zugeordnet sind, verwenden Sie, [ListProjectPolicies](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListProjectPolicies)um die Revision IDs jeder Projektrichtlinie an das Projekt anzuhängen. Rufen Sie dann `DeletePolicy` für jeden Richtliniennamen auf.
**Um eine Revision einer Projektrichtlinie (SDK) zu löschen**
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. Gehen Sie wie folgt vor, um eine Projektrichtlinie zu löschen.
DeletePolicy dauert`ProjectARN`, `PolicyName` und`PolicyRevisionId`. `ProjectARN`und `PolicyName` sind für diese API erforderlich. `PolicyRevisionId`ist optional, kann aber für atomare Updates hinzugefügt werden.
------
#### [ AWS CLI ]
Ändern Sie die folgenden Werte:
+ `policy-name` in den Namen der Projektrichtlinie, die Sie löschen möchten.
+ `policy-revision-id` in die Revisions-ID der Projektrichtlinie, die Sie löschen möchten.
+ `project-arn` in den Amazon-Ressourcennamen des Projekts, das die Version der Projektrichtlinie enthält, die Sie löschen möchten.
```
aws rekognition delete-project-policy \
--policy-name policy-name \
--policy-revision-id policy-revision-id \
--project-arn project-arn \
--profile custom-labels-access
```
------
#### [ Python ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ `policy-name` — Der Name der Projektrichtlinie, die Sie löschen möchten.
+ `project-arn` — Der Amazon-Ressourcenname des Projekts, das die Projektrichtlinie enthält, die Sie löschen möchten.
+ `policy-revision-id` — Die Revisions-ID der Projektrichtlinie, die Sie löschen möchten.
Zum Beispiel: `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 ]
Verwenden Sie folgenden Code. Geben Sie die folgenden Befehlszeilenparameter an:
+ `policy-name` — Der Name der Projektrichtlinie, die Sie löschen möchten.
+ `project-arn` — Der Amazon-Ressourcenname des Projekts, das die Projektrichtlinie enthält, die Sie löschen möchten.
+ `policy-revision-id` — Die Revisions-ID der Projektrichtlinie, die Sie löschen möchten.
```
/*
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);
}
}
}
```
------