

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 criar um arquivo de manifesto de um arquivo CSV
<a name="ex-csv-manifest"></a>

Este exemplo de script em Python simplifica a criação de um arquivo de manifesto usando um arquivo de valores separados por vírgulas (CSV) para rotular imagens. Crie o arquivo CSV. O arquivo de manifesto é adequado para a [classificação de imagens com vários rótulos](getting-started.md#gs-multi-label-image-classification-example) ou [Classificação de imagens com vários rótulos](getting-started.md#gs-multi-label-image-classification-example). Para obter mais informações, consulte [Encontre objetos, cenas e conceitos](understanding-custom-labels.md#tm-classification). 

**nota**  
Este script não cria um arquivo de manifesto adequado para descobrir [localizações de objetos](understanding-custom-labels.md#tm-object-localization) ou para encontrar [localizações de marcas](understanding-custom-labels.md#tm-brand-detection-localization).

Um arquivo de manifesto descreve as imagens usadas para treinar um modelo. Por exemplo, localizações de imagens e rótulos atribuídos às imagens. Um arquivo de manifesto é composto por uma ou mais linhas JSON. Cada linha JSON descreve uma única imagem. Para obter mais informações, consulte [Importar rótulos ao nível da imagem em arquivos de manifesto](md-create-manifest-file-classification.md).

Um arquivo CSV representa dados tabulares em várias linhas em um arquivo de texto. Os campos em uma linha são separados por vírgulas. Para obter mais informações, consulte [valores separados por vírgula](https://en.wikipedia.org/wiki/Comma-separated_values). Para esse script, cada linha em seu arquivo CSV representa uma única imagem e mapeia para uma linha JSON no arquivo de manifesto. Para criar um arquivo CSV para um arquivo de manifesto que seja compatível com a [classificação de imagens com vários rótulos](getting-started.md#gs-multi-label-image-classification-example), adicione um ou mais rótulos em nível de imagem a cada linha. Para criar um arquivo de manifesto adequado para [Classificação de imagens](getting-started.md#gs-image-classification-example), adicione um único rótulo em nível de imagem a cada linha.

Por exemplo, o arquivo CSV a seguir descreve as imagens no projeto [Classificação de imagens com vários rótulos](getting-started.md#gs-multi-label-image-classification-example) (Flores) *Conceitos básicos*. 

```
camellia1.jpg,camellia,with_leaves
camellia2.jpg,camellia,with_leaves
camellia3.jpg,camellia,without_leaves
helleborus1.jpg,helleborus,without_leaves,not_fully_grown
helleborus2.jpg,helleborus,with_leaves,fully_grown
helleborus3.jpg,helleborus,with_leaves,fully_grown
jonquil1.jpg,jonquil,with_leaves
jonquil2.jpg,jonquil,with_leaves
jonquil3.jpg,jonquil,with_leaves
jonquil4.jpg,jonquil,without_leaves
mauve_honey_myrtle1.jpg,mauve_honey_myrtle,without_leaves
mauve_honey_myrtle2.jpg,mauve_honey_myrtle,with_leaves
mauve_honey_myrtle3.jpg,mauve_honey_myrtle,with_leaves
mediterranean_spurge1.jpg,mediterranean_spurge,with_leaves
mediterranean_spurge2.jpg,mediterranean_spurge,without_leaves
```

O script gera linhas JSON para cada linha. Por exemplo, a seguir está a linha JSON para a primeira linha (`camellia1.jpg,camellia,with_leaves`).

```
{"source-ref": "s3://bucket/flowers/train/camellia1.jpg","camellia": 1,"camellia-metadata":{"confidence": 1,"job-name": "labeling-job/camellia","class-name": "camellia","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"},"with_leaves": 1,"with_leaves-metadata":{"confidence": 1,"job-name": "labeling-job/with_leaves","class-name": "with_leaves","human-annotated": "yes","creation-date": "2022-01-21T14:21:05","type": "groundtruth/image-classification"}}
```

No exemplo CSV, o caminho do Amazon S3 para a imagem não está presente. Se seu arquivo CSV não incluir o caminho do Amazon S3 para as imagens, use o argumento da linha de comando `--s3_path` para especificar o caminho do Amazon S3 para a imagem. 

O script registra a primeira entrada de cada imagem em um arquivo CSV de imagem desduplicada. O arquivo CSV de imagem desduplicada contém uma única instância de cada imagem encontrada no arquivo CSV de entrada. Outras ocorrências de uma imagem no arquivo CSV de entrada são registradas em um arquivo CSV de imagem duplicado. Se o script encontrar imagens duplicadas, revise o arquivo CSV de imagem duplicada e atualize o arquivo CSV de imagem desduplicada conforme necessário. Execute novamente o script com o arquivo desduplicado. Se nenhuma duplicata for encontrada no arquivo CSV de entrada, o script excluirá o arquivo CSV de imagem desduplicada e a imagem duplicada, pois eles estão vazios. CSVfile 

 Neste procedimento, o arquivo CSV é criado e o script em Python é executado para criar o arquivo de manifesto. 

**Para criar um arquivo de manifesto de um arquivo CSV**

1. Crie um arquivo CSV com os seguintes campos em cada linha (uma linha por imagem). Não adicione uma linha de cabeçalho ao arquivo CSV.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/customlabels-dg/ex-csv-manifest.html)

   Por exemplo, `camellia1.jpg,camellia,with_leaves` ou `s3://my-bucket/flowers/train/camellia1.jpg,camellia,with_leaves` 

1. Salve o arquivo CSV.

1. Execute o seguinte script em Python. Forneça os seguintes argumentos:
   + `csv_file`: o arquivo CSV que você criou na etapa 1. 
   + `manifest_file`: o nome do arquivo de manifesto que você deseja criar.
   + (Opcional) `--s3_path s3://path_to_folder/`: o caminho do Amazon S3 a ser adicionado aos nomes dos arquivos de imagem (campo 1). Use `--s3_path` se as imagens no campo 1 ainda não contiverem um caminho do S3.

   ```
   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier:  Apache-2.0
   
   from datetime import datetime, timezone
   import argparse
   import logging
   import csv
   import os
   import json
   
   """
   Purpose
   Amazon Rekognition Custom Labels model example used in the service documentation.
   Shows how to create an image-level (classification) manifest file from a CSV file.
   You can specify multiple image level labels per image.
   CSV file format is
   image,label,label,..
   If necessary, use the bucket argument to specify the S3 bucket folder for the images.
   https://docs.aws.amazon.com/rekognition/latest/customlabels-dg/md-gt-cl-transform.html
   """
   
   logger = logging.getLogger(__name__)
   
   
   def check_duplicates(csv_file, deduplicated_file, duplicates_file):
       """
       Checks for duplicate images in a CSV file. If duplicate images
       are found, deduplicated_file is the deduplicated CSV file - only the first
       occurence of a duplicate is recorded. Other duplicates are recorded in duplicates_file.
       :param csv_file: The source CSV file.
       :param deduplicated_file: The deduplicated CSV file to create. If no duplicates are found
       this file is removed.
       :param duplicates_file: The duplicate images CSV file to create. If no duplicates are found
       this file is removed.
       :return: True if duplicates are found, otherwise false.
       """
   
       logger.info("Deduplicating %s", csv_file)
   
       duplicates_found = False
   
       # Find duplicates.
       with open(csv_file, 'r', newline='', encoding="UTF-8") as f,\
               open(deduplicated_file, 'w', encoding="UTF-8") as dedup,\
               open(duplicates_file, 'w', encoding="UTF-8") as duplicates:
   
           reader = csv.reader(f, delimiter=',')
           dedup_writer = csv.writer(dedup)
           duplicates_writer = csv.writer(duplicates)
   
           entries = set()
           for row in reader:
               # Skip empty lines.
               if not ''.join(row).strip():
                   continue
   
               key = row[0]
               if key not in entries:
                   dedup_writer.writerow(row)
                   entries.add(key)
               else:
                   duplicates_writer.writerow(row)
                   duplicates_found = True
   
       if duplicates_found:
           logger.info("Duplicates found check %s", duplicates_file)
   
       else:
           os.remove(duplicates_file)
           os.remove(deduplicated_file)
   
       return duplicates_found
   
   
   def create_manifest_file(csv_file, manifest_file, s3_path):
       """
       Reads a CSV file and creates a Custom Labels classification manifest file.
       :param csv_file: The source CSV file.
       :param manifest_file: The name of the manifest file to create.
       :param s3_path: The S3 path to the folder that contains the images.
       """
       logger.info("Processing CSV file %s", csv_file)
   
       image_count = 0
       label_count = 0
   
       with open(csv_file, newline='', encoding="UTF-8") as csvfile,\
               open(manifest_file, "w", encoding="UTF-8") as output_file:
   
           image_classifications = csv.reader(
               csvfile, delimiter=',', quotechar='|')
   
           # Process each row (image) in CSV file.
           for row in image_classifications:
               source_ref = str(s3_path)+row[0]
   
               image_count += 1
   
               # Create JSON for image source ref.
               json_line = {}
               json_line['source-ref'] = source_ref
   
               # Process each image level label.
               for index in range(1, len(row)):
                   image_level_label = row[index]
   
                   # Skip empty columns.
                   if image_level_label == '':
                       continue
                   label_count += 1
   
                  # Create the JSON line metadata.
                   json_line[image_level_label] = 1
                   metadata = {}
                   metadata['confidence'] = 1
                   metadata['job-name'] = 'labeling-job/' + image_level_label
                   metadata['class-name'] = image_level_label
                   metadata['human-annotated'] = "yes"
                   metadata['creation-date'] = \
                       datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')
                   metadata['type'] = "groundtruth/image-classification"
   
                   json_line[f'{image_level_label}-metadata'] = metadata
   
                   # Write the image JSON Line.
               output_file.write(json.dumps(json_line))
               output_file.write('\n')
   
       output_file.close()
       logger.info("Finished creating manifest file %s\nImages: %s\nLabels: %s",
                   manifest_file, image_count, label_count)
   
       return image_count, label_count
   
   
   def add_arguments(parser):
       """
       Adds command line arguments to the parser.
       :param parser: The command line parser.
       """
   
       parser.add_argument(
           "csv_file", help="The CSV file that you want to process."
       )
   
       parser.add_argument(
           "--s3_path", help="The S3 bucket and folder path for the images."
           " If not supplied, column 1 is assumed to include the S3 path.", 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()
   
           s3_path = args.s3_path
           if s3_path is None:
               s3_path = ''
   
           # Create file names.
           csv_file = args.csv_file
           file_name = os.path.splitext(csv_file)[0]
           manifest_file = f'{file_name}.manifest'
           duplicates_file = f'{file_name}-duplicates.csv'
           deduplicated_file = f'{file_name}-deduplicated.csv'
   
           # Create manifest file, if there are no duplicate images.
           if check_duplicates(csv_file, deduplicated_file, duplicates_file):
               print(f"Duplicates found. Use {duplicates_file} to view duplicates "
                     f"and then update {deduplicated_file}. ")
               print(f"{deduplicated_file} contains the first occurence of a duplicate. "
                     "Update as necessary with the correct label information.")
               print(f"Re-run the script with {deduplicated_file}")
           else:
               print("No duplicates found. Creating manifest file.")
   
               image_count, label_count = create_manifest_file(csv_file,
                                                               manifest_file,
                                                               s3_path)
   
               print(f"Finished creating manifest file: {manifest_file} \n"
                     f"Images: {image_count}\nLabels: {label_count}")
   
       except FileNotFoundError as err:
           logger.exception("File not found: %s", err)
           print(f"File not found: {err}. Check your input CSV file.")
   
   
   if __name__ == "__main__":
       main()
   ```

1. Se planeja usar um conjunto de dados de teste, repita as etapas de 1 a 3 para criar um arquivo de manifesto para seu conjunto de dados de teste.

1. Se necessário, copie as imagens para o caminho do bucket do Amazon S3 que você especificou na coluna 1 do arquivo CSV (ou especificado na linha de comando `--s3_path`). É possível usar o seguinte comando AWS do S3.

   ```
   aws s3 cp --recursive your-local-folder s3://your-target-S3-location
   ```

1. [Faça upload dos arquivos de manifesto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) para o bucket do Amazon S3 que você deseja usar para armazenar o arquivo de manifesto.
**nota**  
Certifique-se de que o Amazon Rekognition Custom Labels tenha acesso ao bucket do Amazon S3 referenciado no campo `source-ref` das linhas JSON do arquivo de manifesto. Para obter mais informações, consulte [Como acessar os buckets externos do Amazon S3](su-console-policy.md#su-external-buckets). Se seu trabalho do Ground Truth armazena imagens no bucket do console do Amazon Rekognition Custom Labels, você não precisa adicionar permissões.

1. Siga as instruções em [Criação de um conjunto de dados com um arquivo de manifesto do SageMaker AI Ground Truth (console)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console) para criar um conjunto de dados com o arquivo de manifesto carregado. Para a etapa 8, na **localização do arquivo .manifest**, insira a URL do Amazon S3 para a localização do arquivo de manifesto. Se estiver usando o AWS SDK, use [Criação de um conjunto de dados com um arquivo de manifesto (SDK) do SageMaker AI Ground Truth](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).