As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Como marcar um modelo
É possível identificar, organizar, pesquisar e filtrar seus modelos do Amazon Rekognition usando tags. Cada tag é um rótulo que consiste em um valor e uma chave definida pelo usuário. Por exemplo, para ajudar a determinar o faturamento de seus modelos, marque seus modelos com uma chave `Cost center` e adicione o número do centro de custo apropriado como valor. Para obter mais informações, consulte [Como rotular recursos da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Use tags para:
+ Acompanhe o faturamento de um modelo usando tags de alocação de custos. Para obter mais informações, consulte [Usar tags de alocação de custos](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html).
+ Controle o acesso a um modelo usando o AWS Identity and Access Management (IAM). Para obter mais informações, consulte [Controlar o acesso a recursos da AWS usando tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html).
+ Automatize o gerenciamento de modelos. Por exemplo, é possível executar scripts de inicialização ou interrupção automatizados que desativam modelos de desenvolvimento fora do horário comercial para reduzir os custos. Para obter mais informações, consulte [Como executar um modelo do Amazon Rekognition Custom Labels](running-model.md).
Você pode marcar modelos usando o console do Amazon Rekognition ou usando o. AWS SDKs
**Topics**
+ [Como marcar modelos (console)](#tm-tagging-model-console)
+ [Como visualizar tags de modelo](#tm-tagging-model-viewing-console)
+ [Como marcar modelos (SDK)](#tm-tagging-model-sdk)
## Como marcar modelos (console)
É possível usar o console do Rekognition para adicionar tags aos modelos, visualizar as tags anexadas a um modelo e remover tags.
### Adicionar e remover rótulos
Este procedimento explica como adicionar ou remover tags de um modelo existente. Também é possível adicionar tags a um modelo novo quando ele for treinado. Para obter mais informações, consulte [Como treinar um modelo do Amazon Rekognition Custom Labels](training-model.md).
**Para adicionar tags ou remover tags de um modelo existente usando o console**
1. Abra o console do Amazon Rekognition em. [ https://console.aws.amazon.com/rekognition/]( https://console.aws.amazon.com/rekognition/)
1. Escolha **Começar**.
1. No painel de navegação, selecione **Projetos**.
1. Na página de recursos **Projetos**, selecione o projeto que contém o modelo ao qual você deseja atribuir uma tag.
1. No painel de navegação, no projeto que você escolheu anteriormente, escolha **Modelos**.
1. Na seção **Modelos**, escolha o modelo ao qual deseja atribuir uma tag.
1. Na página de detalhes do modelo, escolha a guia **Tags**.
1. Na seção **Tags**, escolha **Gerenciar tags**.
1. Na página **Gerenciar tags**, escolha **Adicionar nova tag**.
1. Insira uma Chave e um Valor.
1. Em **Chave**, insira o nome da chave.
1. Em **Valor**, insira um valor.
1. Para adicionar mais tags, repita as etapas 9 e 10.
1. (Opcional) Para remover uma tag, selecione **Remover** ao lado da tag que você deseja remover. Se estiver removendo uma tag salva anteriormente, ela será removida quando você salvar suas alterações.
1. Escolha **Salvar alterações** para salvar suas alterações.
## Como visualizar tags de modelo
É possível usar o console do Amazon Rekognition para visualizar as tags anexadas a um modelo.
Para visualizar as tags anexadas a *todos os modelos em um projeto*, você deve usar o AWS SDK. Para obter mais informações, consulte [Como listar de tags de modelo](#listing-model-tags-sdk).
**Para visualizar as tags anexadas a um modelo**
1. Abra o console do Amazon Rekognition em. [ https://console.aws.amazon.com/rekognition/]( https://console.aws.amazon.com/rekognition/)
1. Escolha **Começar**.
1. No painel de navegação, selecione **Projetos**.
1. Na página de recursos **Projetos**, selecione o projeto que contém o modelo cuja tag você deseja visualizar.
1. No painel de navegação, no projeto que você escolheu anteriormente, escolha **Modelos**.
1. Na seção **Modelos**, escolha o modelo cujo rótulo você deseja exibir.
1. Na página de detalhes do modelo, escolha a guia **Tags**. As tags são mostradas na seção **Tags**.
## Como marcar modelos (SDK)
Você pode usar o AWS SDK para:
+ Adicionar tags a um novo modelo
+ Adicionar tags a um modelo existente
+ Liste as tags anexadas a um modelo
+ Remover tags de um modelo
As tags nos AWS CLI exemplos a seguir estão no formato a seguir.
```
--tags '{"key1":"value1","key2":"value2"}'
```
Como alternativa, é possível usar este formato.
```
--tags key1=value1,key2=value2
```
Se você não instalou o AWS CLI, consulte[Etapa 4: configurar o AWS CLI e AWS SDKs](su-awscli-sdk.md).
### Como adicionar tags a um novo modelo
Você pode adicionar tags a um modelo ao criá-lo usando a [CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion.html)operação. Especifique uma ou mais tags no parâmetro `Tags` de entrada da matriz.
```
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
```
Para obter informações sobre como criar e treinar um modelo, consulte [Treinando um modelo (SDK)](training-model.md#tm-sdk).
### Como adicionar tags a um modelo existente
Para adicionar uma ou mais tags a um modelo existente, use a [TagResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TagResource)operação. Especifique o nome do recurso da Amazon (ARN) (`ResourceArn`) do modelo e as tags (`Tags`) que deseja adicionar. O exemplo a seguir mostra como adicionar duas tags.
```
aws rekognition tag-resource --resource-arn resource-arn \
--tags '{"key1":"value1","key2":"value2"}' \
--profile custom-labels-access
```
Você pode obter o ARN de um modelo ligando para. [CreateProjectVersion](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateProjectVersion)
### Como listar de tags de modelo
Para listar as tags anexadas a um modelo, use a [ListTagsForResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ListTagsForResource)operação e especifique o ARN do modelo ()`ResourceArn`. A resposta é um mapa de tags e valores anexados ao modelo especificado.
```
aws rekognition list-tags-for-resource --resource-arn resource-arn \
--profile custom-labels-access
```
A saída exibe uma lista das tags anexadas ao modelo.
```
{
"Tags": {
"Dept": "Engineering",
"Name": "Ana Silva Carolina",
"Role": "Developer"
}
}
```
Para ver quais modelos em um projeto têm uma tag específica, chame `DescribeProjectVersions` para obter uma lista de modelos. Depois, chame `ListTagsForResource` para cada modelo na resposta de `DescribeProjectVersions`. Inspecione a resposta de `ListTagsForResource` para ver se a tag necessária está presente.
O exemplo a seguir do Python 3 mostra como pesquisar em todos os seus projetos uma chave e um valor de tag específicos. A saída inclui o ARN do projeto e o ARN do modelo em que uma chave correspondente é encontrada.
**Para pesquisar um valor de tag**
1. Salve o código a seguir em um arquivo chamado `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. No prompt de comando, digite o seguinte. *value*Substitua *key* e pelo nome e valor da chave que você deseja encontrar.
```
python find_tag.py key value
```
### Como excluir as tags de um modelo
Para remover uma ou mais tags de um modelo, use a [UntagResource](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UntagResource)operação. Especifique o ARN do modelo (`ResourceArn`) e as chaves de tag (`Tag-Keys`) que deseja remover.
```
aws rekognition untag-resource --resource-arn resource-arn \
--tag-keys '["key1","key2"]' \
--profile custom-labels-access
```
Como alternativa, é possível especificar `tag-keys` neste formato.
```
--tag-keys key1,key2
```