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.
# Erstellen von Trainings- und Testdatensätzen mit Bildern
Sie können mit einem Projekt beginnen, das einen einzelnen Datensatz enthält, oder mit einem Projekt, das separate Trainings- und Testdatensätze enthält. Wenn Sie mit einem einzelnen Datensatz beginnen, teilt Amazon Rekognition Custom Labels Ihren Datensatz während des Trainings auf, um einen Trainingsdatensatz (80 %) und einen Testdatensatz (20 %) für Ihr Projekt zu erstellen. Beginnen Sie mit einem einzigen Datensatz, wenn Amazon Rekognition Custom Labels entscheiden soll, wo Bilder zum Trainieren und Testen verwendet werden. Um die vollständige Kontrolle über Trainings, Tests und Leistungsoptimierungen zu haben, empfehlen wir, dass Sie Ihr Projekt mit separaten Trainings- und Testdatensätzen beginnen.
Sie können Trainings- und Testdatensätze für ein Projekt erstellen, indem Sie Bilder von einem der folgenden Speicherorte importieren:
+ [Bilder aus einem Amazon S3 S3-Bucket importieren](md-create-dataset-s3.md)
+ [Bilder von einem lokalen Computer importieren](md-create-dataset-computer.md)
+ [Verwenden einer Manifestdatei zum Importieren von Bildern](md-create-dataset-ground-truth.md)
+ [Inhalte aus einem vorhandenen Datensatz werden kopiert](md-create-dataset-existing-dataset.md)
Wenn Sie Ihr Projekt mit separaten Trainings- und Testdatensätzen beginnen, können Sie für jeden Datensatz unterschiedliche Quellverzeichnisse verwenden.
Je nachdem, von wo Sie Ihre Bilder importieren, haben Ihre Bilder möglicherweise keine Labels. Beispielsweise haben Bilder, die von einem lokalen Computer importiert wurden, keine Label. Bilder, die aus einer Amazon SageMaker AI Ground Truth Manifest-Datei importiert wurden, sind beschriftet. Sie können die Amazon Rekognition Custom Labels-Konsole verwenden, um Labels hinzuzufügen, zu ändern und zuzuweisen. Weitere Informationen finden Sie unter [Labeling von Bildern](md-labeling-images.md).
Wenn Bilder fehlerhaft hochgeladen werden, Bilder fehlen oder Labels in Bildern fehlen, lesen Sie [Debuggen eines fehlgeschlagenen Modelltrainings](tm-debugging.md).
Weitere Informationen zu Datensätzen finden Sie unter [Verwalten von Datensätzen](managing-dataset.md).
## Erstellen von Trainings- und Testdatensätzen (SDK)
Sie können das AWS SDK verwenden, um Trainings- und Testdatensätze zu erstellen.
Mit `CreateDataset` diesem Vorgang können Sie optional Tags angeben, wenn Sie einen neuen Datensatz erstellen, um Ihre Ressourcen zu kategorisieren und zu verwalten.
### Trainingsdatensatz
Sie können das AWS SDK auf folgende Weise verwenden, um einen Trainingsdatensatz zu erstellen.
+ Verwenden Sie es [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)mit einer von Ihnen bereitgestellten Manifestdatei im Amazon Sagemaker-Format. Weitere Informationen finden Sie unter [Erstellen einer Manifestdatei](md-create-manifest-file.md). Einen Beispielcode finden Sie unter [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
+ Verwenden Sie `CreateDataset`, um einen bestehenden Amazon Rekognition Custom Labels-Datensatz zu kopieren. Einen Beispielcode finden Sie unter [Erstellen eines Datensatzes mit einem vorhandenen Datensatz (SDK)](md-create-dataset-existing-dataset-sdk.md).
+ Erstellen Sie einen leeren Datensatz mit `CreateDataset` und fügen Sie zu einem späteren Zeitpunkt Datensatzeinträge mit [UpdateDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_UpdateDatasetEntries) hinzu. Informationen zum Erstellen eines leeren Datensatzes finden Sie unter [Einen Datensatz zu einem Projekt hinzufügen](md-add-dataset.md). Informationen zum Hinzufügen von Bildern zu einem Datensatz finden Sie unter [Weitere Bilder hinzufügen (SDK)](md-add-images.md#md-add-images-sdk). Sie müssen die Datensatzeinträge hinzufügen, bevor Sie ein Modell trainieren können.
### Testdatensatz
Sie können das AWS SDK auf folgende Weise verwenden, um einen Testdatensatz zu erstellen:
+ Verwenden Sie es [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)mit einer von Ihnen bereitgestellten Manifestdatei im Amazon Sagemaker-Format. Weitere Informationen finden Sie unter [Erstellen einer Manifestdatei](md-create-manifest-file.md). Einen Beispielcode finden Sie unter [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
+ Verwenden Sie `CreateDataset`, um einen bestehenden Amazon Rekognition Custom Labels-Datensatz zu kopieren. Einen Beispielcode finden Sie unter [Erstellen eines Datensatzes mit einem vorhandenen Datensatz (SDK)](md-create-dataset-existing-dataset-sdk.md).
+ Erstellen Sie einen leeren Datensatz mit `CreateDataset` und fügen Sie zu einem späteren Zeitpunkt Datensatzeinträge mit `UpdateDatasetEntries` hinzu. Informationen zum Erstellen eines leeren Datensatzes finden Sie unter [Einen Datensatz zu einem Projekt hinzufügen](md-add-dataset.md). Informationen zum Hinzufügen von Bildern zu einem Datensatz finden Sie unter [Weitere Bilder hinzufügen (SDK)](md-add-images.md#md-add-images-sdk). Sie müssen die Datensatzeinträge hinzufügen, bevor Sie ein Modell trainieren können.
+ Teilen Sie den Trainingsdatensatz in separate Trainings- und Testdatensätze auf. Erstellen Sie zunächst einen leeren Testdatensatz mit `CreateDataset`. Verschieben Sie dann 20% der Trainingsdatensatzeinträge in den Testdatensatz, indem Sie aufrufen. [DistributeDatasetEntries](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DistributeDatasetEntries) Informationen zum Erstellen eines leeren Datensatzes finden Sie unter [Hinzufügen eines Datensatzes zu einem Projekt (SDK)](md-add-dataset.md#md-add-dataset-sdk). Informationen zum Aufteilen des Trainingsdatensatzes finden Sie unter [Verteilen eines Trainingsdatensatzes (SDK)](md-distributing-datasets.md).
# Bilder aus einem Amazon S3 S3-Bucket importieren
Die Bilder werden von einem Amazon-S3-Bucket importiert. Sie können den Konsolen-Bucket oder einen anderen Amazon S3 S3-Bucket in Ihrem AWS Konto verwenden. Wenn Sie den Konsolen-Bucket verwenden, sind die erforderlichen Berechtigungen bereits eingerichtet. Wenn Sie den Konsolen-Bucket nicht verwenden, siehe [Zugreifen auf externe Amazon-S3-Buckets](su-console-policy.md#su-external-buckets).
**Anmerkung**
Sie können das AWS SDK nicht verwenden, um einen Datensatz direkt aus Bildern in einem Amazon S3 S3-Bucket zu erstellen. Erstellen Sie stattdessen eine Manifestdatei, die auf die Quellverzeichnisse der Bilder verweist. Weitere Informationen finden Sie unter [Verwenden einer Manifestdatei zum Importieren von Bildern](md-create-dataset-ground-truth.md).
Während der Datensatzerstellung können Sie festlegen, dass Bildern Labelnamen zugewiesen werden, die auf dem Namen des Ordners basieren, der die Bilder enthält. Der/Die Ordner müssen ein untergeordnetes Element des Amazon S3-Ordnerpfads sein, den Sie bei der Datensatzerstellung im **Ordner S3** angegeben haben. Informationen zum Erstellen eines Datensatzes finden Sie unter [Erstellen eines Datensatzes durch Importieren von Bildern aus einem S3-Bucket](#cd-procedure).
Angenommen, ein Amazon-S3-Bucket hat die folgende Ordnerstruktur. Wenn Sie den Speicherort des Amazon S3-Ordners als *S3-Bucket/Alexa-Geräte* angeben, wird den Bildern im Ordner *Echo* das Label *Echo* zugewiesen. In ähnlicher Weise wird Bildern im Ordner *Echo-Dot* das Label *Echo-Dot* zugewiesen. Die Namen untergeordneter Ordner werden nicht für Bilder-Labels verwendet. Stattdessen wird der entsprechende untergeordnete Ordner des Amazon S3-Ordnerspeicherorts verwendet. Bildern in dem Ordner *white-echo-dots*wird beispielsweise das Label *echo-dot* zugewiesen. Bildern auf der Ebene des Speicherorts des S3-Ordners (*Alexa-Geräte*) sind keine Labels zugewiesen.
Ordner, die sich weiter unten in der Ordnerstruktur befinden, können für Bilder-Label verwendet werden, indem ein untergeordneter Speicherort für den S3-Ordner angegeben wird. Wenn Sie beispielsweise *S3- bucket/alexa-devices/echo -Punkt* angeben, werden die Bilder im Ordner *white-echo-dot*beschriftet. *white-echo-dot* Bilder, die sich außerhalb des angegebenen Speicherorts des S3-Ordners befinden, wie z. B. *Echo*, werden nicht importiert.
```
S3-bucket
└── alexa-devices
├── echo
│ ├── echo-image-1.png
│ └── echo-image-2.png
│ ├── .
│ └── .
└── echo-dot
├── white-echo-dot
│ ├── white-echo-dot-image-1.png
│ ├── white-echo-dot-image-2.png
│
├── echo-dot-image-1.png
├── echo-dot-image-2.png
├── .
└── .
```
Wir empfehlen Ihnen, den Amazon S3 S3-Bucket (Konsolen-Bucket) zu verwenden, der von Amazon Rekognition für Sie erstellt wurde, als Sie die Konsole zum ersten Mal in der aktuellen AWS Region geöffnet haben. Wenn sich der Amazon-S3-Bucket, den Sie verwenden, vom Konsolen-Bucket unterscheidet (extern), werden Sie von der Konsole während der Datensatzerstellung aufgefordert, die entsprechenden Berechtigungen einzurichten. Weitere Informationen finden Sie unter [Schritt 2: Einrichten von Amazon Rekognition Custom Labels-Konsolenberechtigungen](su-console-policy.md).
## Erstellen eines Datensatzes durch Importieren von Bildern aus einem S3-Bucket
Im folgenden Verfahren wird gezeigt, wie Sie einen Datensatz mithilfe von Bildern erstellen, die im S3-Bucket der Konsole gespeichert sind. Die Bilder erhalten als Label automatisch den Namen des Ordners, in dem sie gespeichert sind.
Nachdem Sie Ihre Bilder importiert haben, können Sie auf der Galerie-Seite eines Datensatzes weitere Bilder hinzufügen, Labels zuweisen und Begrenzungsrahmen hinzufügen. Weitere Informationen finden Sie unter [Labeling von Bildern](md-labeling-images.md).
**Laden Sie Ihre Bilder in einen Amazon Simple Storage Service-Bucket hoch.**
1. Erstellen Sie auf Ihrem lokalen Computer einen Ordner. Verwenden Sie einen Ordnernamen wie *Alexa-Geräte*.
1. Erstellen Sie in dem Ordner, den Sie gerade erstellt haben, Ordner, die nach jedem Label benannt sind, das Sie verwenden möchten. Zum Beispiel *Echo* und *Echo-Dot*. Die Ordnerstruktur sollte in etwa folgendermaßen aussehen.
```
alexa-devices
├── echo
│ ├── echo-image-1.png
│ ├── echo-image-2.png
│ ├── .
│ └── .
└── echo-dot
├── echo-dot-image-1.png
├── echo-dot-image-2.png
├── .
└── .
```
1. Platzieren Sie die Bilder, die einem Label entsprechen, in den Ordner mit demselben Labelnamen.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. [Fügen Sie den Ordner](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html), den Sie in Schritt 1 erstellt haben, dem Amazon-S3-Bucket (Konsolen-Bucket) hinzu, den Amazon Rekognition Custom Labels bei der *ersten Einrichtung* für Sie erstellt hat. Weitere Informationen finden Sie unter [Verwalten eines Amazon Rekognition Custom Labels-Projekts](managing-project.md).
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 auf der Seite **Projekte** das Projekt aus, dem Sie den Datensatz hinzufügen möchten. Die Detailseite für Ihr Projekt wird angezeigt.
1. Wählen Sie **Datensatz erstellen**. Die Seite **Datensatz erstellen** wird angezeigt.
1. Wählen Sie in der **Startkonfiguration** entweder **Mit einem einzelnen Datensatz beginnen** oder **Mit einem Trainingsdatensatz beginnen** aus. Um ein qualitativ hochwertigeres Modell zu erstellen, empfehlen wir, mit separaten Trainings- und Testdatensätzen zu beginnen.
------
#### [ Single dataset ]
1. Wählen Sie im Abschnitt **Details zum Trainingsdatensatz** die Option **Bilder aus dem S3-Bucket importieren** aus.
1. Geben Sie im Abschnitt **Details zum Trainingsdatensatz** die Informationen für die Schritte 13-15 im Abschnitt **Konfiguration der Bildquelle** ein.
------
#### [ Separate training and test datasets ]
1. Wählen Sie im Abschnitt **Details zum Trainingsdatensatz** die Option **Bilder aus dem S3-Bucket importieren** aus.
1. Geben Sie im Abschnitt **Details zum Trainingsdatensatz** die Informationen für die Schritte 13-15 im Abschnitt **Konfiguration der Bildquelle** ein.
1. Wählen Sie im Abschnitt **Details zum Testdatensatz** die Option **Bilder aus dem S3-Bucket importieren** aus.
1. Geben Sie im Abschnitt **Details zum Testdatensatz** die Informationen für die Schritte 13-15 im Abschnitt **Konfiguration der Bildquelle** ein.
------
1. Wählen Sie **Bilder aus Amazon-S3-Bucket importieren** aus.
1. Geben Sie unter **S3-URI** den Speicherort und den Ordnerpfad des Amazon-S3-Buckets ein.
1. Wählen Sie **Je nach Ordner automatisch Labels an Bilder anhängen** aus.
1. Wählen Sie **Datensätze erstellen** aus. Die Datensatzseite für Ihr Projekt wird geöffnet.
1. Wenn Sie Labels hinzufügen oder ändern müssen, führen Sie [Labeling von Bildern](md-labeling-images.md) aus.
1. Folgen Sie den Anweisungen unter [Ein Modell trainieren (Konsole)](training-model.md#tm-console), um Ihr Modell zu trainieren.
# Bilder von einem lokalen Computer importieren
Die Bilder werden direkt von Ihrem Computer geladen. Sie können bis zu 30 Bilder gleichzeitig hochladen.
Den Bildern, die Sie hochladen, sind keine Labels zugeordnet. Weitere Informationen finden Sie unter [Labeling von Bildern](md-labeling-images.md). Wenn Sie viele Bilder hochladen möchten, sollten Sie einen Amazon-S3-Bucket verwenden. Weitere Informationen finden Sie unter [Bilder aus einem Amazon S3 S3-Bucket importieren](md-create-dataset-s3.md).
**Anmerkung**
Sie können das AWS SDK nicht verwenden, um einen Datensatz mit lokalen Bildern zu erstellen. Erstellen Sie stattdessen eine Manifestdatei und laden Sie die Bilder in einen Amazon-S3-Bucket hoch. Weitere Informationen finden Sie unter [Verwenden einer Manifestdatei zum Importieren von Bildern](md-create-dataset-ground-truth.md).
**So erstellen Sie einen Datensatz mit Bildern auf einem lokalen Computer (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 auf der Seite **Projekte** das Projekt aus, dem Sie den Datensatz hinzufügen möchten. Die Detailseite für Ihr Projekt wird angezeigt.
1. Wählen Sie **Datensatz erstellen**. Die Seite **Datensatz erstellen** wird angezeigt.
1. Wählen Sie in der **Startkonfiguration** entweder **Mit einem einzelnen Datensatz beginnen** oder **Mit einem Trainingsdatensatz beginnen** aus. Um ein qualitativ hochwertigeres Modell zu erstellen, empfehlen wir, mit separaten Trainings- und Testdatensätzen zu beginnen.
------
#### [ Single dataset ]
1. Wählen Sie im **Abschnitt Details zum Trainingsdatensatz** die Option **Bilder von Ihrem Computer hochladen** aus.
1. Wählen Sie **Datensatz erstellen**.
1. Wählen Sie auf der Datensatzseite des Projekts die Option **Bilder hinzufügen** aus.
1. Wählen Sie die Bilder aus Ihren Computerdateien aus, die Sie in den Datensatz hochladen möchten. Sie können die Bilder ziehen oder die Bilder auswählen, die Sie von Ihrem lokalen Computer hochladen möchten.
1. Wählen Sie **Bilder hochladen**.
------
#### [ Separate training and test datasets ]
1. Wählen Sie im Abschnitt **Details zum Trainingsdatensatz** die Option **Bilder von Ihrem Computer hochladen** aus.
1. Wählen Sie im Abschnitt **Details zum Testdatensatz** die Option **Bilder von Ihrem Computer hochladen** aus.
**Anmerkung**
Ihre Trainings- und Testdatensätze können unterschiedliche Bildquellen haben.
1. Wählen Sie **Datensätze erstellen** aus. Die Datensatzseite Ihres Projekts wird mit den Registerkarten **Training** und **Test** für die jeweiligen Datensätze angezeigt.
1. Wählen Sie **Aktionen** und anschließend **Bilder zum Trainingsdatensatz hinzufügen** aus.
1. Wählen Sie die Bilder aus, die Sie in den Datensatz hochladen möchten. Sie können die Bilder ziehen oder die Bilder auswählen, die Sie von Ihrem lokalen Computer hochladen möchten.
1. Wählen Sie **Bilder hochladen**.
1. Wiederholen Sie die Schritte 5e-5g. Wählen Sie für Schritt 5e **Aktionen** und dann **Bilder zum Testdatensatz hinzufügen** aus.
------
1. Folgen Sie den Schritten unter [Labeling von Bildern](md-labeling-images.md), um Ihre Bilder zu beschriften.
1. Folgen Sie den Anweisungen unter [Ein Modell trainieren (Konsole)](training-model.md#tm-console), um Ihr Modell zu trainieren.
# Verwenden einer Manifestdatei zum Importieren von Bildern
Sie können einen Datensatz mithilfe einer Manifestdatei im Amazon SageMaker AI Ground Truth Format erstellen. Sie können die Manifestdatei aus einem Amazon SageMaker AI Ground Truth Job verwenden. Wenn Ihre Bilder und Beschriftungen nicht das Format einer SageMaker AI Ground Truth-Manifestdatei haben, können Sie eine Manifestdatei im SageMaker AI-Format erstellen und damit Ihre beschrifteten Bilder importieren.
Der `CreateDataset` Vorgang wurde aktualisiert, sodass Sie beim Erstellen eines neuen Datensatzes optional Tags angeben können. Tags sind Schlüssel-Wert-Paare, die Sie verwenden können, um Ihre Ressourcen zu kategorisieren und zu verwalten.
**Topics**
+ [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (Konsole)](#md-create-dataset-ground-truth-console)
+ [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](#md-create-dataset-ground-truth-sdk)
+ [Datensatz-Anfrage erstellen](#create-dataset-ground-truth-request)
+ [Bilder mit einem Amazon SageMaker AI Ground Truth Job beschriften](md-create-dataset-ground-truth-job.md)
+ [Erstellen einer Manifestdatei](md-create-manifest-file.md)
+ [Labels auf Bildebene in Manifestdateien importieren](md-create-manifest-file-classification.md)
+ [Objektlokalisierung in Manifestdateien](md-create-manifest-file-object-detection.md)
+ [Validierungsregeln für Manifestdateien](md-create-manifest-file-validation-rules.md)
+ [Konvertierung anderer Datensatzformate in eine Manifestdatei](md-converting-to-sm-format.md)
## Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (Konsole)
Das folgende Verfahren zeigt Ihnen, wie Sie einen Datensatz mithilfe einer Manifestdatei im SageMaker AI Ground Truth Format erstellen.
1. Erstellen Sie eine Manifestdatei für Ihren Trainingsdatensatz, indem Sie einen der folgenden Schritte ausführen:
+ Erstellen Sie eine Manifestdatei mit einem SageMaker GroundTruth AI-Job, indem Sie den Anweisungen unter folgen[Bilder mit einem Amazon SageMaker AI Ground Truth Job beschriften](md-create-dataset-ground-truth-job.md).
+ Erstellen Sie Ihre eigene Manifestdatei, indem Sie den Anweisungen unter [Erstellen einer Manifestdatei](md-create-manifest-file.md) folgen.
Wenn Sie einen Testdatensatz erstellen möchten, wiederholen Sie Schritt 1, um den Testdatensatz zu erstellen.
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 auf der Seite **Projekte** das Projekt aus, dem Sie den Datensatz hinzufügen möchten. Die Detailseite für Ihr Projekt wird angezeigt.
1. Wählen Sie **Datensatz erstellen**. Die Seite **Datensatz erstellen** wird angezeigt.
1. Wählen Sie in der **Startkonfiguration** entweder **Mit einem einzelnen Datensatz beginnen** oder **Mit einem Trainingsdatensatz beginnen** aus. Um ein qualitativ hochwertigeres Modell zu erstellen, empfehlen wir, mit separaten Trainings- und Testdatensätzen zu beginnen.
------
#### [ Single dataset ]
1. Wählen Sie im Abschnitt **Details zum Trainingsdatensatz** die Option **Mit SageMaker Ground Truth beschriftete Bilder importieren** aus.
1. Geben Sie im Feld **Speicherort der Manifestdatei** den Speicherort der Manifestdatei ein, den Sie in Schritt 1 erstellt haben.
1. Wählen Sie **Datensatz erstellen**. Die Datensatzseite für Ihr Projekt wird geöffnet.
------
#### [ Separate training and test datasets ]
1. Wählen Sie im Abschnitt **Details zum Trainingsdatensatz** die Option **Mit SageMaker Ground Truth beschriftete Bilder importieren** aus.
1. Geben Sie im Feld **Speicherort der Manifestdatei** den Speicherort der Trainingsdatensatz-Manifestdatei ein, den Sie in Schritt 1 erstellt haben.
1. Wählen Sie im Abschnitt **Details zum Testdatensatz** die Option **Bilder importieren mit der Bezeichnung SageMaker Ground Truth** aus.
**Anmerkung**
Ihre Trainings- und Testdatensätze können unterschiedliche Bildquellen haben.
1. Geben Sie im Feld **Speicherort der Manifestdatei** den Speicherort der Testdatensatz-Manifestdatei ein, den Sie in Schritt 1 erstellt haben.
1. Wählen Sie **Datensätze erstellen** aus. Die Datensatzseite für Ihr Projekt wird geöffnet.
------
1. Wenn Sie Labels hinzufügen oder ändern müssen, führen Sie [Labeling von Bildern](md-labeling-images.md) aus.
1. Folgen Sie den Anweisungen unter [Ein Modell trainieren (Konsole)](training-model.md#tm-console), um Ihr Modell zu trainieren.
## Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)
Das folgende Verfahren zeigt Ihnen, wie Sie mithilfe der [CreateDataset](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateDataset)API Trainings- oder Testdatensätze aus einer Manifestdatei erstellen.
Sie können eine vorhandene Manifestdatei verwenden, z. B. die Ausgabe eines [SageMaker AI Ground Truth Jobs](md-create-dataset-ground-truth-job.md), oder Ihre eigene [Manifestdatei](md-create-manifest-file.md) erstellen.
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 eine Manifestdatei für Ihren Trainingsdatensatz, indem Sie einen der folgenden Schritte ausführen:
+ Erstellen Sie eine Manifestdatei mit einem SageMaker GroundTruth AI-Job, indem Sie den Anweisungen unter folgen[Bilder mit einem Amazon SageMaker AI Ground Truth Job beschriften](md-create-dataset-ground-truth-job.md).
+ Erstellen Sie Ihre eigene Manifestdatei, indem Sie den Anweisungen unter [Erstellen einer Manifestdatei](md-create-manifest-file.md) folgen.
Wenn Sie einen Testdatensatz erstellen möchten, wiederholen Sie Schritt 2, um den Testdatensatz zu erstellen.
1. Verwenden Sie den folgenden Beispielcode, um den Trainings- und Testdatensatz zu erstellen.
------
#### [ AWS CLI ]
Erstellen Sie einen Datensatz mit dem folgenden Code. Ersetzen Sie Folgendes:
+ `project_arn`— den ARN des Projekts, dem Sie den Testdatensatz hinzufügen möchten.
+ `type` — den Typ des Datensatzes, den Sie erstellen möchten (TRAINIEREN oder TESTEN)
+ `bucket` — den Bucket, der die Manifestdatei für den Datensatz enthält.
+ `manifest_file` — den Pfad und Namen der Manifestdatei
```
aws rekognition create-dataset --project-arn project_arn \
--dataset-type type \
--dataset-source '{ "GroundTruthManifest": { "S3Object": { "Bucket": "bucket", "Name": "manifest_file" } } }' \
--profile custom-labels-access
--tags '{"key1": "value1", "key2": "value2"}'
```
------
#### [ Python ]
Erstellen Sie einen Datensatz mit den folgenden Werten. Geben Sie die folgenden Befehlszeilenparameter an:
+ `project_arn` — den ARN des Projekts, dem Sie den Testdatensatz hinzufügen möchten.
+ `dataset_type` — den Typ des Datensatzes, den Sie erstellen möchten (`train` oder `test`).
+ `bucket` — den Bucket, der die Manifestdatei für den Datensatz enthält.
+ `manifest_file` — den Pfad und Namen der Manifestdatei
```
#Copyright 2023 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 argparse
import logging
import time
import json
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def create_dataset(rek_client, project_arn, dataset_type, bucket, manifest_file):
"""
Creates an Amazon Rekognition Custom Labels dataset.
:param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
:param project_arn: The ARN of the project in which you want to create a dataset.
:param dataset_type: The type of the dataset that you want to create (train or test).
:param bucket: The S3 bucket that contains the manifest file.
:param manifest_file: The path and filename of the manifest file.
"""
try:
#Create the project
logger.info("Creating %s dataset for project %s",dataset_type, project_arn)
dataset_type = dataset_type.upper()
dataset_source = json.loads(
'{ "GroundTruthManifest": { "S3Object": { "Bucket": "'
+ bucket
+ '", "Name": "'
+ manifest_file
+ '" } } }'
)
response = rek_client.create_dataset(
ProjectArn=project_arn, DatasetType=dataset_type, DatasetSource=dataset_source
)
dataset_arn=response['DatasetArn']
logger.info("dataset ARN: %s",dataset_arn)
finished=False
while finished is False:
dataset=rek_client.describe_dataset(DatasetArn=dataset_arn)
status=dataset['DatasetDescription']['Status']
if status == "CREATE_IN_PROGRESS":
logger.info("Creating dataset: %s ",dataset_arn)
time.sleep(5)
continue
if status == "CREATE_COMPLETE":
logger.info("Dataset created: %s", dataset_arn)
finished=True
continue
if status == "CREATE_FAILED":
error_message = f"Dataset creation failed: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception (error_message)
error_message = f"Failed. Unexpected state for dataset creation: {status} : {dataset_arn}"
logger.exception(error_message)
raise Exception(error_message)
return dataset_arn
except ClientError as err:
logger.exception("Couldn't create dataset: %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 you want to create the dataset."
)
parser.add_argument(
"dataset_type", help="The type of the dataset that you want to create (train or test)."
)
parser.add_argument(
"bucket", help="The S3 bucket that contains the manifest file."
)
parser.add_argument(
"manifest_file", help="The path and filename of the manifest file."
)
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"Creating {args.dataset_type} dataset for project {args.project_arn}")
#Create the dataset.
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
dataset_arn=create_dataset(rekognition_client,
args.project_arn,
args.dataset_type,
args.bucket,
args.manifest_file)
print(f"Finished creating dataset: {dataset_arn}")
except ClientError as err:
logger.exception("Problem creating dataset: %s", err)
print(f"Problem creating dataset: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
Erstellen Sie einen Datensatz mit den folgenden Werten. Geben Sie die folgenden Befehlszeilenparameter an:
+ `project_arn` — den ARN des Projekts, dem Sie den Testdatensatz hinzufügen möchten.
+ `dataset_type` — den Typ des Datensatzes, den Sie erstellen möchten (`train` oder `test`).
+ `bucket` — den Bucket, der die Manifestdatei für den Datensatz enthält.
+ `manifest_file` — den Pfad und Namen der Manifestdatei
```
/*
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.CreateDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.CreateDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.DatasetDescription;
import software.amazon.awssdk.services.rekognition.model.DatasetSource;
import software.amazon.awssdk.services.rekognition.model.DatasetStatus;
import software.amazon.awssdk.services.rekognition.model.DatasetType;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeDatasetResponse;
import software.amazon.awssdk.services.rekognition.model.GroundTruthManifest;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.S3Object;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CreateDatasetManifestFiles {
public static final Logger logger = Logger.getLogger(CreateDatasetManifestFiles.class.getName());
public static String createMyDataset(RekognitionClient rekClient, String projectArn, String datasetType,
String bucket, String name) throws Exception, RekognitionException {
try {
logger.log(Level.INFO, "Creating {0} dataset for project : {1} from s3://{2}/{3} ",
new Object[] { datasetType, projectArn, bucket, name });
DatasetType requestDatasetType = null;
switch (datasetType) {
case "train":
requestDatasetType = DatasetType.TRAIN;
break;
case "test":
requestDatasetType = DatasetType.TEST;
break;
default:
logger.log(Level.SEVERE, "Could not create dataset. Unrecognized dataset type: {0}", datasetType);
throw new Exception("Could not create dataset. Unrecognized dataset type: " + datasetType);
}
GroundTruthManifest groundTruthManifest = GroundTruthManifest.builder()
.s3Object(S3Object.builder().bucket(bucket).name(name).build()).build();
DatasetSource datasetSource = DatasetSource.builder().groundTruthManifest(groundTruthManifest).build();
CreateDatasetRequest createDatasetRequest = CreateDatasetRequest.builder().projectArn(projectArn)
.datasetType(requestDatasetType).datasetSource(datasetSource).build();
CreateDatasetResponse response = rekClient.createDataset(createDatasetRequest);
boolean created = false;
do {
DescribeDatasetRequest describeDatasetRequest = DescribeDatasetRequest.builder()
.datasetArn(response.datasetArn()).build();
DescribeDatasetResponse describeDatasetResponse = rekClient.describeDataset(describeDatasetRequest);
DatasetDescription datasetDescription = describeDatasetResponse.datasetDescription();
DatasetStatus status = datasetDescription.status();
logger.log(Level.INFO, "Creating dataset ARN: {0} ", response.datasetArn());
switch (status) {
case CREATE_COMPLETE:
logger.log(Level.INFO, "Dataset created");
created = true;
break;
case CREATE_IN_PROGRESS:
Thread.sleep(5000);
break;
case CREATE_FAILED:
String error = "Dataset creation failed: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, error);
throw new Exception(error);
default:
String unexpectedError = "Unexpected creation state: " + datasetDescription.statusAsString() + " "
+ datasetDescription.statusMessage() + " " + response.datasetArn();
logger.log(Level.SEVERE, unexpectedError);
throw new Exception(unexpectedError);
}
} while (created == false);
return response.datasetArn();
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not create dataset: {0}", e.getMessage());
throw e;
}
}
public static void main(String[] args) {
String datasetType = null;
String bucket = null;
String name = null;
String projectArn = null;
String datasetArn = null;
final String USAGE = "\n" + "Usage: " + " \n\n" + "Where:\n"
+ " project_arn - the ARN of the project that you want to add copy the datast to.\n\n"
+ " dataset_type - the type of the dataset that you want to create (train or test).\n\n"
+ " bucket - the S3 bucket that contains the manifest file.\n\n"
+ " name - the location and name of the manifest file within the bucket.\n\n";
if (args.length != 4) {
System.out.println(USAGE);
System.exit(1);
}
projectArn = args[0];
datasetType = args[1];
bucket = args[2];
name = args[3];
try {
// Get the Rekognition client
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Create the dataset
datasetArn = createMyDataset(rekClient, projectArn, datasetType, bucket, name);
System.out.println(String.format("Created dataset: %s", datasetArn));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (Exception rekError) {
logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
System.exit(1);
}
}
}
```
------
1. Informationen zum Hinzufügen oder Ändern von Labels finden Sie unter [Labels verwalten (SDK)](md-labels.md#md-labels-sdk).
1. Folgen Sie den Anweisungen unter [Ein Modell trainieren (SDK)](training-model.md#tm-sdk), um Ihr Modell zu trainieren.
## Datensatz-Anfrage erstellen
Das Folgende ist das Format der CreateDataset Operationsanforderung:
```
{
"DatasetSource": {
"DatasetArn": "string",
"GroundTruthManifest": {
"S3Object": {
"Bucket": "string",
"Name": "string",
"Version": "string"
}
}
},
"DatasetType": "string",
"ProjectArn": "string",
"Tags": {
"string": "string"
}
}
```
# Bilder mit einem Amazon SageMaker AI Ground Truth Job beschriften
Mit Amazon SageMaker AI Ground Truth können Sie Mitarbeiter von Amazon Mechanical Turk, einem von Ihnen ausgewählten Anbieter, oder interne, private Mitarbeiter zusammen mit maschinellem Lernen einsetzen, mit dem Sie einen beschrifteten Satz von Bildern erstellen können. Amazon Rekognition Custom Labels importiert SageMaker AI Ground Truth Truth-Manifestdateien aus einem Amazon S3 S3-Bucket, den Sie angeben.
Amazon Rekognition Custom Labels unterstützt die folgenden SageMaker AI Ground Truth Truth-Aufgaben.
+ [Bildklassifizierung](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification.html)
+ [Begrenzungsrahmen](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-bounding-box.html)
Bei den Dateien, die Sie importieren, handelt es sich um die Bilder und eine Manifestdatei. Die Manifestdatei enthält Label- und Begrenzungsrahmen-Informationen für die Bilder, die Sie importieren.
Amazon Rekognition benötigt Berechtigungen für den Zugriff auf den Amazon-S3-Bucket, in dem Ihre Bilder gespeichert sind. Wenn Sie den Konsolen-Bucket verwenden, der von Amazon Rekognition Custom Labels für Sie eingerichtet wurde, sind die erforderlichen Berechtigungen bereits eingerichtet. Wenn Sie den Konsolen-Bucket nicht verwenden, siehe [Zugreifen auf externe Amazon-S3-Buckets](su-console-policy.md#su-external-buckets).
## Erstellen einer Manifestdatei mit einem SageMaker AI Ground Truth Job (Konsole)
Das folgende Verfahren zeigt Ihnen, wie Sie einen Datensatz mithilfe von Bildern erstellen, die mit einem SageMaker AI Ground Truth Job beschriftet wurden. Die Job-Ausgabedateien werden in Ihrem Amazon Rekognition Custom Labels-Konsolen-Bucket gespeichert.
**Um einen Datensatz mit Bildern zu erstellen, die mit einem SageMaker AI Ground Truth Job beschriftet wurden (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. [Erstellen Sie im Konsolen-Bucket einen Ordner](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html) für Ihre Trainingsbilder.
**Anmerkung**
Der Konsolen-Bucket wird erstellt, wenn Sie die Amazon Rekognition Custom Labels-Konsole zum ersten Mal in einer AWS Region öffnen. Weitere Informationen finden Sie unter [Verwalten eines Amazon Rekognition Custom Labels-Projekts](managing-project.md).
1. [Laden Sie Ihre Bilder](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) in den Ordner hoch, den Sie gerade erstellt haben.
1. Erstellen Sie im Konsolen-Bucket einen Ordner für die Ausgabe des Ground Truth-Jobs.
1. Öffnen Sie die SageMaker AI-Konsole unter. [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)
1. Erstellen Sie einen Ground Truth Labeling-Job. Sie benötigen Amazon S3 URLs für die Ordner, die Sie in Schritt 2 und Schritt 4 erstellt haben. Weitere Informationen finden Sie unter [Verwenden von Amazon SageMaker Ground Truth für die Datenkennzeichnung](https://docs.aws.amazon.com/sagemaker/latest/dg/sms.html).
1. Notieren Sie sich den Speicherort der `output.manifest`-Datei in dem Ordner, den Sie in Schritt 4 erstellt haben. Sie sollte sich im Unterordner `Ground-Truth-Job-Name/manifests/output` befinden.
1. Folgen Sie den Anweisungen unter [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (Konsole)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console), um einen Datensatz mit der hochgeladenen Manifestdatei zu erstellen. Geben Sie für Schritt 8 unter **Speicherort der Manifestdatei** die Amazon S3-URL für den Speicherort ein, den Sie im vorherigen Schritt notiert haben. Wenn Sie das AWS SDK verwenden, tun Sie dies[Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
1. Wiederholen Sie die Schritte 1 bis 6, um einen SageMaker AI Ground Truth Job für Ihren Testdatensatz zu erstellen.
# Erstellen einer Manifestdatei
Sie können einen Test- oder Trainingsdatensatz erstellen, indem Sie eine Manifestdatei im SageMaker AI Ground Truth Format importieren. Wenn Ihre Bilder in einem Format beschriftet sind, das keine SageMaker AI Ground Truth-Manifestdatei ist, verwenden Sie die folgenden Informationen, um eine Manifestdatei im SageMaker AI Ground Truth Format zu erstellen.
Manifestdateien haben das [JSON-Zeilen](http://jsonlines.org)-Format, wobei jede Zeile ein vollständiges JSON-Objekt ist, das die Label-Informationen für ein Bild darstellt. Amazon Rekognition Custom Labels unterstützt SageMaker AI Ground Truth Manifeste mit JSON-Zeilen in den folgenden Formaten:
+ [Klassifizierungsjob-Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class) — Wird verwendet, um einem Bild Labels auf Bildebene hinzuzufügen. Ein Label auf Bildebene definiert die Klasse der Szene, des Konzepts oder des Objekts (falls keine Informationen für die Objektposition benötigt werden), die sich auf einem Bild befindet. Ein Bild kann mehr als eine Bezeichnung auf Bildebene haben. Weitere Informationen finden Sie unter [Labels auf Bildebene in Manifestdateien importieren](md-create-manifest-file-classification.md).
+ [Begrenzungsrahmenjob-Output](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box) — Wird verwendet, um ein Label für Klasse und Position eines oder mehrerer Objekte auf einem Bild zu erstellen. Weitere Informationen finden Sie unter [Objektlokalisierung in Manifestdateien](md-create-manifest-file-object-detection.md).
JSON-Zeilen auf Bildebene und Lokalisierungszeilen (Begrenzungsrahmen) können in derselben Manifestdatei miteinander verkettet werden.
**Anmerkung**
Die Beispiele für JSON-Zeilen in diesem Abschnitt sind aus Gründen der Lesbarkeit formatiert.
Wenn Sie eine Manifestdatei importieren, wendet Amazon Rekognition Custom Labels Validierungsregeln für Grenzwerte, Syntax und Semantik an. Weitere Informationen finden Sie unter [Validierungsregeln für Manifestdateien](md-create-manifest-file-validation-rules.md).
Die Bilder, auf die eine Manifestdatei verweist, müssen sich in demselben Amazon-S3-Bucket befinden. Die Manifestdatei kann sich in einem anderen Amazon-S3-Bucket befinden als der Amazon-S3-Bucket, in dem die Bilder gespeichert sind. Sie geben die Position eines Bildes im `source-ref`-Feld einer JSON-Zeile an.
Amazon Rekognition benötigt Berechtigungen für den Zugriff auf den Amazon-S3-Bucket, in dem Ihre Bilder gespeichert sind. Wenn Sie den Konsolen-Bucket verwenden, der von Amazon Rekognition Custom Labels für Sie eingerichtet wurde, sind die erforderlichen Berechtigungen bereits eingerichtet. Wenn Sie den Konsolen-Bucket nicht verwenden, siehe [Zugreifen auf externe Amazon-S3-Buckets](su-console-policy.md#su-external-buckets).
**Topics**
+ [Erstellen einer Manifestdatei](#md-create-manifest-file-console)
## Erstellen einer Manifestdatei
Mit dem folgenden Verfahren wird ein Projekt mit einem Trainings- und Testdatensatz erstellt. Die Datensätze werden aus den von Ihnen erstellten Trainings- und Testmanifestdateien erstellt.
**So erstellen Sie einen Datensatz mit einer Manifestdatei im SageMaker AI Ground Truth Format (Konsole)**
1. Erstellen Sie im Konsolen-Bucket einen [Ordner](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-folder.html) für Ihre Manifestdateien.
1. Erstellen Sie in dem Konsolen-Bucket einen Ordner, um Ihre Bilder zu speichern.
1. Laden Sie Ihre Bilder in den nun erstellten Ordner hoch.
1. Erstellen Sie eine Manifestdatei im SageMaker AI Ground Truth Format für Ihren Trainingsdatensatz. Weitere Informationen erhalten Sie unter [Labels auf Bildebene in Manifestdateien importieren](md-create-manifest-file-classification.md) und [Objektlokalisierung in Manifestdateien](md-create-manifest-file-object-detection.md).
**Wichtig**
Der `source-ref`-Feldwert in jeder JSON-Zeile muss einem Bild zugeordnet sein, das Sie hochgeladen haben.
1. Erstellen Sie eine Manifestdatei im SageMaker AI Ground Truth Format für Ihren Testdatensatz.
1. [Laden Sie Ihre Manifestdateien](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) in den Ordner hoch, den Sie gerade erstellt haben.
1. Notieren Sie sich den Namen der Manifestdatei.
1. Folgen Sie den Anweisungen unter [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (Konsole)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console), um einen Datensatz mit der hochgeladenen Manifestdatei zu erstellen. Geben Sie für Schritt 8 unter **Speicherort der Manifestdatei** die Amazon S3-URL für den Speicherort ein, den Sie im vorherigen Schritt notiert haben. Wenn Sie das AWS SDK verwenden, tun Sie dies[Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk).
# Labels auf Bildebene in Manifestdateien importieren
Um Labels auf Bildebene zu importieren (Bilder, die mit Szenen, Konzepten oder Objekten beschriftet sind, für die keine Lokalisierungsinformationen erforderlich sind), fügen Sie JSON-Zeilen im SageMaker AI Ground Truth [Classification Job Output-Format](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-class) zu einer Manifestdatei hinzu. Eine Manifestdatei besteht aus einer oder mehreren JSON-Zeilen, eine für jedes Bild, das Sie importieren möchten.
**Tipp**
Um die Erstellung einer Manifestdatei zu vereinfachen, stellen wir ein Python-Skript zur Verfügung, das eine Manifestdatei aus einer CSV-Datei erstellt. Weitere Informationen finden Sie unter [Erstellen einer Manifestdatei aus einer CSV-Datei](ex-csv-manifest.md).
**So erstellen Sie eine Manifestdatei für Labels auf Bildebene.**
1. Erstellen Sie eine leere Textdatei.
1. Fügen Sie eine JSON-Zeile für jedes Bild hinzu, das Sie importieren möchten. Jede JSON-Zeile sollte nun etwa folgendermaßen aussehen.
```
{"source-ref":"s3://custom-labels-console-us-east-1-nnnnnnnnnn/gt-job/manifest/IMG_1133.png","TestCLConsoleBucket":0,"TestCLConsoleBucket-metadata":{"confidence":0.95,"job-name":"labeling-job/testclconsolebucket","class-name":"Echo Dot","human-annotated":"yes","creation-date":"2020-04-15T20:17:23.433061","type":"groundtruth/image-classification"}}
```
1. Speichern Sie die Datei. Sie können die Erweiterung `.manifest` verwenden, sie ist jedoch nicht erforderlich.
1. Erstellen Sie einen Datensatz mit der von Ihnen erstellten Manifestdatei. Weitere Informationen finden Sie unter [So erstellen Sie einen Datensatz mit einer Manifestdatei im SageMaker AI Ground Truth Format (Konsole)](md-create-manifest-file.md#create-dataset-procedure-manifest-file).
## JSON-Zeilen auf Bildebene
In diesem Abschnitt zeigen wir Ihnen, wie Sie eine JSON-Zeile für ein einzelnes Bild erstellen. Betrachten Sie das folgende Bild: Eine Szene für das folgende Bild könnte *Sonnenaufgang* heißen.
![\[Sonnenuntergang über einem See mit Dock und kleinen Booten, umgeben von Bergen.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/customlabels-dg/images/sunrise.png)
Die JSON-Zeile für das vorherige Bild mit der Szene *Sonnenaufgang* könnte wie folgt aussehen.
```
{
"source-ref": "s3://bucket/images/sunrise.png",
"testdataset-classification_Sunrise": 1,
"testdataset-classification_Sunrise-metadata": {
"confidence": 1,
"job-name": "labeling-job/testdataset-classification_Sunrise",
"class-name": "Sunrise",
"human-annotated": "yes",
"creation-date": "2020-03-06T17:46:39.176",
"type": "groundtruth/image-classification"
}
}
```
Notieren Sie die folgenden Informationen:
### Quellennachweis
(Erforderlich) Der Amazon S3-Speicherort des Bildes. Das Format ist `"s3://BUCKET/OBJECT_PATH"`. Bilder in einem importierten Datensatz müssen im gleichen Amazon-S3-Bucket gespeichert werden.
### *testdataset-classification\$1Sunrise*
(Erforderlich) Das Label-Attribut. Sie wählen den Feldnamen. Der Feldwert (1 im vorherigen Beispiel) ist ein Bezeichner für ein Labelattribut. Er wird von Amazon Rekognition Custom Labels nicht verwendet und kann eine beliebige Ganzzahl sein. Es müssen entsprechende Metadaten vorhanden sein, die durch den Feldnamen mit angehängtem *-Metadaten* identifiziert werden. Beispiel, `"testdataset-classification_Sunrise-metadata"`.
### *testdataset-classification\$1Sunrise*-Metadaten
(Erforderlich) Metadaten zum Label-Attribut. Der Feldname muss mit dem Label-Attribut identisch sein, wobei *-Metadaten* angehängt ist.
*Konfidenz*
(Erforderlich) Wird derzeit nicht von Amazon Rekognition Custom Labels verwendet, aber es muss ein Wert zwischen 0 und 1 angegeben werden.
*Jobname*
(Optional) Ein Name, den Sie für den Job wählen, der das Bild verarbeitet.
*Klassenname*
(Erforderlich) Ein Klassenname, den Sie für die Szene oder das Konzept wählen, das auf das Bild zutrifft. Beispiel, `"Sunrise"`.
*mit menschlichen Anmerkungen versehen*
(Erforderlich) Geben Sie `"yes"` an, wenn die Anmerkung von einem Menschen ausgefüllt wurde. Andernfalls `"no"`.
*Erstellungsdatum*
(Erforderlich) Das Datum und die Uhrzeit in koordinierter Weltzeit (UTC), zu der das Label erstellt wurde.
*Typ*
(Erforderlich) Die Art der Verarbeitung, die auf das Bild angewendet werden soll. Für Labels auf Bildebene ist der Wert `"groundtruth/image-classification"`.
### Hinzufügen mehrerer Labels auf Bildebene zu einem Bild
Sie können einem Bild mehrere Labels hinzufügen. Mit dem folgenden JSON-Code werden beispielsweise zwei Labels, *Fußball* und *Ball*, zu einem einzigen Bild hinzugefügt.
```
{
"source-ref": "S3 bucket location",
"sport0":0, # FIRST label
"sport0-metadata": {
"class-name": "football",
"confidence": 0.8,
"type":"groundtruth/image-classification",
"job-name": "identify-sport",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256"
},
"sport1":1, # SECOND label
"sport1-metadata": {
"class-name": "ball",
"confidence": 0.8,
"type":"groundtruth/image-classification",
"job-name": "identify-sport",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256"
}
} # end of annotations for 1 image
```
# Objektlokalisierung in Manifestdateien
Sie können Bilder importieren, die mit Informationen zur Objektlokalisierung beschriftet sind, indem Sie JSON-Zeilen im SageMaker AI Ground Truth [Bounding Box Job Output-Format](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html#sms-output-box) zu einer Manifestdatei hinzufügen.
Lokalisierungsinformationen stellen die Position eines Objekts auf einem Bild dar. Die Position wird durch einen Begrenzungsrahmen dargestellt, der das Objekt umgibt. Die Begrenzungsrahmenstruktur enthält die oberen linken Koordinaten des Begrenzungsrahmens sowie die Breite und Höhe des Begrenzungsrahmens. Eine JSON-Zeile im Begrenzungsrahmen-Format enthält Begrenzungsrahmen für die Positionen eines oder mehrerer Objekte auf einem Bild und die Klasse jedes Objekts auf dem Bild.
Eine Manifestdatei besteht aus einer oder mehreren JSON-Zeilen, wobei jede Zeile die Informationen für ein einzelnes Bild enthält.
**So erstellen Sie eine Manifestdatei zur Objektlokalisierung**
1. Erstellen Sie eine leere Textdatei.
1. Fügen Sie eine JSON-Zeile für jedes Bild hinzu, das Sie importieren möchten. Jede JSON-Zeile sollte nun etwa folgendermaßen aussehen.
```
{"source-ref": "s3://bucket/images/IMG_1186.png", "bounding-box": {"image_size": [{"width": 640, "height": 480, "depth": 3}], "annotations": [{ "class_id": 1, "top": 251, "left": 399, "width": 155, "height": 101}, {"class_id": 0, "top": 65, "left": 86, "width": 220, "height": 334}]}, "bounding-box-metadata": {"objects": [{ "confidence": 1}, {"confidence": 1}], "class-map": {"0": "Echo", "1": "Echo Dot"}, "type": "groundtruth/object-detection", "human-annotated": "yes", "creation-date": "2013-11-18T02:53:27", "job-name": "my job"}}
```
1. Speichern Sie die Datei. Sie können die Erweiterung `.manifest` verwenden, sie ist jedoch nicht erforderlich.
1. Erstellen Sie mit der Datei, die Sie gerade erstellt haben, einen Datensatz. Weitere Informationen finden Sie unter [So erstellen Sie einen Datensatz mit einer Manifestdatei im SageMaker AI Ground Truth Format (Konsole)](md-create-manifest-file.md#create-dataset-procedure-manifest-file).
## JSON-Zeilen, die das Objekt begrenzen
In diesem Abschnitt zeigen wir Ihnen, wie Sie eine JSON-Zeile für ein einzelnes Bild erstellen. Das folgende Bild zeigt Begrenzungsrahmen rund um Amazon Echo- und Amazon Echo Dot-Geräte.
![\[Zwei Amazon Smart Speaker, einer mit grüner Begrenzungsbox und einer blauen Begrenzungsbox, auf einer Holzoberfläche.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/customlabels-dg/images/echos.png)
Das Folgende ist die JSON-Begrenzungsrahmen-Zeile für das vorherige Bild.
```
{
"source-ref": "s3://custom-labels-bucket/images/IMG_1186.png",
"bounding-box": {
"image_size": [{
"width": 640,
"height": 480,
"depth": 3
}],
"annotations": [{
"class_id": 1,
"top": 251,
"left": 399,
"width": 155,
"height": 101
}, {
"class_id": 0,
"top": 65,
"left": 86,
"width": 220,
"height": 334
}]
},
"bounding-box-metadata": {
"objects": [{
"confidence": 1
}, {
"confidence": 1
}],
"class-map": {
"0": "Echo",
"1": "Echo Dot"
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2013-11-18T02:53:27",
"job-name": "my job"
}
}
```
Notieren Sie die folgenden Informationen:
### Quellennachweis
(Erforderlich) Der Amazon S3-Speicherort des Bildes. Das Format ist `"s3://BUCKET/OBJECT_PATH"`. Bilder in einem importierten Datensatz müssen im gleichen Amazon-S3-Bucket gespeichert werden.
### *bounding-box*
(Erforderlich) Das Label-Attribut. Sie wählen den Feldnamen. Enthält die Bildgröße und die Begrenzungsrahmen für jedes Objekt, das im Bild erkannt wurde. Es müssen entsprechende Metadaten vorhanden sein, die durch den Feldnamen mit angehängtem *-Metadaten* identifiziert werden. Beispiel, `"bounding-box-metadata"`.
*Bildgröße*
(Erforderlich) Ein Array mit einem einzelnen Element, das die Größe des Bildes in Pixeln enthält.
+ *Höhe* - (Erforderlich) Die Höhe, in Pixeln, des Bildes.
+ *Breite* — (Erforderlich) Die Tiefe des Bildes in Pixeln.
+ *Tiefe* — (Erforderlich) Die Anzahl der Kanäle im Bild. Die Wert für RGB-Bilder ist 3. Wird derzeit nicht von Amazon Rekognition Custom Labels verwendet, aber ein Wert ist erforderlich.
*Anmerkungen*
(Erforderlich) Eine Reihe von Bounding-Box-Informationen für jedes Objekt, das im Bild erkannt wurde.
+ *Klassen\$1ID* — (Erforderlich) Ordnet dem Label in *Klassenzuordnung* zu. Im vorherigen Beispiel ist das Objekt mit der *Klassen\$1ID* von `1` der Echo Dot im Bild.
+ *oben* — (Erforderlich) Der Abstand zwischen dem oberen Bildrand und dem oberen Rand des Begrenzungsrahmens in Pixeln.
+ *links* — (Erforderlich) Der Abstand von der linken Seite des Bilds zur linken Seite des Begrenzungsrahmens in Pixeln.
+ *Breite* — (Erforderlich) Die Breite des Begrenzungsrahmens in Pixeln.
+ *Höhe* - (Erforderlich) Die Höhe des Begrenzungsrahmens in Pixeln.
### *bounding-box*-Metadaten
(Erforderlich) Metadaten zum Label-Attribut. Der Feldname muss mit dem Label-Attribut identisch sein, wobei *-Metadaten* angehängt ist. Eine Reihe von Begrenzungsrahmen-Informationen für jedes Objekt, das im Bild erkannt wurde.
*Objekte*
(Erforderlich) Ein Array von Objekten im Bild. Ordnet dem Array *Anmerkungen* nach Index zu. Das Vertrauensattribut wird von Amazon Rekognition Custom Labels nicht verwendet.
*Klassenzuordnung*
(Erforderlich) Eine Zuordnung der Klassen, die für die im Bild erkannten Objekte gelten.
*Typ*
(Erforderlich) Der Typ des Klassifizierungsauftrags. `"groundtruth/object-detection"` identifiziert den Job als Objekterkennung.
*Erstellungsdatum*
(Erforderlich) Das Datum und die Uhrzeit in koordinierter Weltzeit (UTC), zu der das Label erstellt wurde.
*Mit menschlichen Anmerkungen versehen*
(Erforderlich) Geben Sie `"yes"` an, wenn die Anmerkung von einem Menschen ausgefüllt wurde. Andernfalls `"no"`.
*Jobname*
(Optional) Der Name des Jobs, der das Bild verarbeitet.
# Validierungsregeln für Manifestdateien
Wenn Sie eine Manifestdatei importieren, wendet Amazon Rekognition Custom Labels Validierungsregeln für Grenzwerte, Syntax und Semantik an. Das SageMaker AI Ground Truth Schema erzwingt die Syntaxvalidierung. Weitere Informationen finden Sie unter [Ausgaben](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data-output.html): Im Folgenden finden Sie die Validierungsregeln für Grenzwerte und Semantik.
**Anmerkung**
Die Ungültigkeitsregeln von 20 % gelten kumulativ für alle Validierungsregeln. Wenn der Import die 20 % -Grenze aufgrund einer beliebigen Kombination überschreitet, z. B. aufgrund von 15 % ungültigem JSON und 15 % ungültigen Bildern, schlägt der Import fehl.
Jedes Datensatz-Objekt ist eine Zeile im Manifest. Leere/ungültige Zeilen werden ebenfalls als Datensatzobjekte gezählt.
Überlappungen sind (gemeinsame Labels zwischen Test und Training)/(Trainingslabels).
**Topics**
+ [Einschränkungen](#md-validation-rules-limits)
+ [Semantik](#md-validation-rules-semantics)
## Einschränkungen
| Validierung | Limit | Es wurde ein Fehler gemeldet |
| --- | --- | --- |
| Größe der Manifestdatei | Maximal 1 GB | Fehler |
| Maximale Zeilenanzahl für eine Manifestdatei | Maximal 250 000 Datensatz-Objekte als Zeilen in einem Manifest. | Fehler |
| Untere Grenze für die Gesamtzahl gültiger Datensatz-Objekte pro Label | >=1 | Fehler |
| Untere Grenze auf Labels | >=2 | Fehler |
| Obere Grenze auf Labels | <= 250 | Fehler |
| Minimale Anzahl von Begrenzungsrahmen pro Bild | 0 | Keine |
| Maximale Anzahl von Begrenzungsrahmen pro Bild | 50 | Keine |
## Semantik
| Validierung | Limit | Es wurde ein Fehler gemeldet |
| --- | --- | --- |
| Leeres Manifest | | Fehler |
| Fehlendes oder unzugängliches Quellennachweisobjekt | Anzahl der Objekte weniger als 20 % | Warnung |
| Fehlendes oder unzugängliches Quellennachweisobjekt | Anzahl der Objekte > 20 % | Fehler |
| Test-Labels sind im Trainingsdatensatz nicht vorhanden | Die Labels überlappen sich mindestens zu 50 % | Fehler |
| Mischung aus Label-Beispielen und Objektbeispielen für dasselbe Label in einem Datensatz. Klassifizierung und Erkennung für dieselbe Klasse in einem Datensatzobjekt. | | Kein Fehler oder keine Warnung |
| Überlappende Ressourcen zwischen Test und Training | Es sollte keine Überschneidung zwischen Test- und Trainingsdatensätzen geben. | |
| Die Bilder in einem Datensatz müssen aus demselben Bucket stammen | Fehler, wenn sich die Objekte in einem anderen Bucket befinden | Fehler |
# Konvertierung anderer Datensatzformate in eine Manifestdatei
Sie können die folgenden Informationen verwenden, um Manifestdateien im Amazon SageMaker AI-Format aus einer Vielzahl von Quelldatensatzformaten zu erstellen. Nachdem Sie die Manifestdatei erstellt haben, verwenden Sie sie, um einen Datensatz zu erstellen. Weitere Informationen finden Sie unter [Verwenden einer Manifestdatei zum Importieren von Bildern](md-create-dataset-ground-truth.md).
**Topics**
+ [Umwandlung eines COCO-Datensatzes in ein Manifest-Dateiformat](md-transform-coco.md)
+ [Transformation von SageMaker AI Ground Truth-Manifestdateien mit mehreren Labels](md-gt-cl-transform.md)
+ [Erstellen einer Manifestdatei aus einer CSV-Datei](ex-csv-manifest.md)
# Umwandlung eines COCO-Datensatzes in ein Manifest-Dateiformat
[COCO](http://cocodataset.org/#home) ist ein Format zur Spezifizierung umfangreicher Datensätze zur Objekterkennung, Segmentierung und Untertitelung. Dieses Python-[Beispiel](md-coco-transform-example.md) zeigt Ihnen, wie Sie einen Datensatz im COCO-Objekterkennungsformat in eine [Manifestdatei im Begrenzungsrahmen-Format](md-create-manifest-file-object-detection.md) Amazon Rekognition Custom Labels umwandeln. Dieser Abschnitt enthält auch Informationen, mit denen Sie Ihren eigenen Code schreiben können.
Eine JSON-Datei im COCO-Format besteht aus fünf Abschnitten, die Informationen für *einen gesamten Datensatz* enthalten. Weitere Informationen finden Sie unter [Das COCO-Datensatzformat](md-coco-overview.md).
+ `info` — allgemeine Informationen über den Datensatz.
+ `licenses ` — Lizenzinformationen für die Bilder im Datensatz.
+ [`images`](md-coco-overview.md#md-coco-images) — eine Liste der Bilder im Datensatz.
+ [`annotations`](md-coco-overview.md#md-coco-annotations) — eine Liste von Anmerkungen (einschließlich Begrenzungsrahmen), die in allen Bildern des Datensatzes vorhanden sind.
+ [`categories`](md-coco-overview.md#md-coco-categories) — eine Liste von Label-Kategorien.
Sie benötigen Informationen aus den Listen `images`, `annotations` und `categories`, um eine Amazon Rekognition Custom Labels-Manifestdatei zu erstellen.
Eine Amazon Rekognition Custom Labels-Manifestdatei hat das JSON-Zeilenformat, wobei jede Zeile den Begrenzungsrahmen und die Labelinformationen für ein oder mehrere Objekte *auf einem Bild* enthält. Weitere Informationen finden Sie unter [Objektlokalisierung in Manifestdateien](md-create-manifest-file-object-detection.md).
## Zuordnung von COCO-Objekten zu einer JSON-Zeile mit benutzerdefinierten Labels
Um einen Datensatz im COCO-Format zu transformieren, ordnen Sie den COCO-Datensatz einer Amazon Rekognition Custom Labels-Manifestdatei für die Objektlokalisierung zu. Weitere Informationen finden Sie unter [Objektlokalisierung in Manifestdateien](md-create-manifest-file-object-detection.md). Um für jedes Bild eine JSON-Zeile zu erstellen, muss die Manifestdatei den COCO-Datensatz `image` und `category` das Objektfeld zuordnen IDs. `annotation`
Folgendes ist ein Beispiel für den Inhalt einer COCO-Manifestdatei: Weitere Informationen finden Sie unter [Das COCO-Datensatzformat](md-coco-overview.md).
```
{
"info": {
"description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01"
},
"licenses": [
{"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"}
],
"images": [
{"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"},
{"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"}
],
"annotations": [
{"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]},
{"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]},
{"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]}
],
"categories": [
{"supercategory": "speaker","id": 0,"name": "echo"},
{"supercategory": "speaker","id": 1,"name": "echo dot"}
]
}
```
Das folgende Diagramm zeigt, wie die COCO-Datensatzlisten für einen *Datensatz* den JSON-Zeilen von Amazon Rekognition Custom Labels für ein *Bild* zugeordnet werden. Jede JSON-Zeile für ein Bild besitzt ein Quellverweis-, Job- und Job-Metadatenfeld. Übereinstimmende Farben geben Informationen für ein einzelnes Bild an. Beachten Sie, dass ein einzelnes Bild im Manifest mehrere Anmerkungen und Metadaten/Kategorien haben kann.
![\[Diagramm, das die Struktur von Coco Manifest mit Bildern, Anmerkungen und Kategorien zeigt.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/customlabels-dg/images/coco-transform.png)
**So rufen Sie die COCO-Objekte für eine einzelne JSON-Zeile ab**
1. Rufen Sie für jedes Bild in der Bilderliste die Anmerkung aus der Anmerkungsliste ab, bei der der Wert des Anmerkungsfeldes `image_id` mit dem `id`-Bildfeld übereinstimmt.
1. Lesen Sie für jede Anmerkung, die in Schritt 1 gefunden wurde, die `categories`-Liste durch und ermitteln Sie jede `category`, bei der der Wert des `category`-Feldes `id` mit dem `annotation` `category_id`-Objektfeld übereinstimmt.
1. Erstellen Sie mithilfe der übereinstimmenden Objekte `image`, `annotation` und `category` eine JSON-Zeile für das Bild. Informationen zur Zuordnung der Felder finden Sie unter [Zuordnen von COCO-Objektfeldern zu JSON-Zeilenobjektfeldern mit benutzerdefinierten Labels](#md-mapping-fields-coco).
1. Wiederholen Sie die Schritte 1-3, bis Sie für jedes `image`-Objekt in der `images`-Liste JSON-Zeilen erstellt haben.
Einen Beispielcode finden Sie unter [Transformieren eines COCO-Datensatzes](md-coco-transform-example.md).
## Zuordnen von COCO-Objektfeldern zu JSON-Zeilenobjektfeldern mit benutzerdefinierten Labels
Nachdem Sie die COCO-Objekte für eine Amazon Rekognition Custom Labels JSON-Zeile identifiziert haben, müssen Sie die COCO-Objektfelder den jeweiligen JSON-Zeilenobjektfeldern von Amazon Rekognition Custom Labels zuordnen. Die folgende JSON-Beispielzeile für Amazon Rekognition Custom Labels ordnet ein Bild (`id`=`000000245915`) dem vorherigen COCO-JSON-Beispiel zu. Notieren Sie die folgenden Informationen:
+ `source-ref` ist der Speicherort des Images in einem Amazon-S3-Bucket. Wenn Ihre COCO-Bilder nicht in einem Amazon-S3-Bucket gespeichert sind, müssen Sie sie in einen Amazon-S3-Bucket verschieben.
+ Die `annotations`-Liste enthält ein `annotation`-Objekt für jedes Objekt auf dem Bild. Ein `annotation`-Objekt enthält Informationen zum Begrenzungsrahmen (`top`,`left`,`width`,`height`) und eine Label-ID (`class_id`).
+ Die Label-ID (`class_id`) ist der `class-map`-Liste in den Metadaten zugeordnet. Sie listet die auf dem Bild verwendeten Labels auf.
```
{
"source-ref": "s3://custom-labels-bucket/images/000000245915.jpg",
"bounding-box": {
"image_size": {
"width": 640,
"height": 480,
"depth": 3
},
"annotations": [{
"class_id": 0,
"top": 251,
"left": 399,
"width": 155,
"height": 101
}, {
"class_id": 1,
"top": 65,
"left": 86,
"width": 220,
"height": 334
}]
},
"bounding-box-metadata": {
"objects": [{
"confidence": 1
}, {
"confidence": 1
}],
"class-map": {
"0": "Echo",
"1": "Echo Dot"
},
"type": "groundtruth/object-detection",
"human-annotated": "yes",
"creation-date": "2018-10-18T22:18:13.527256",
"job-name": "my job"
}
}
```
Verwenden Sie die folgenden Informationen, um die Felder der Amazon Rekognition Custom Labels-Manifestdatei den JSON-Feldern des COCO-Datensatzes zuzuordnen.
### Quellennachweis
Die URL im S3-Format für den Speicherort des Bildes. Das Video muss in einem S3-Bucket gespeichert sein. Weitere Informationen finden Sie unter [Quellennachweis](md-create-manifest-file-object-detection.md#cd-manifest-source-ref). Wenn das `coco_url`-COCO-Feld auf eine S3-Bucket-Position verweist, können Sie den Wert von `coco_url` für den Wert von `source-ref` verwenden. Alternativ können Sie das Feld `source-ref` dem Feld `file_name` (COCO) zuordnen und in Ihrem Transformationscode den erforderlichen S3-Pfad zu dem Speicherort des Bilds hinzufügen.
### *bounding-box*
Ein Label-Attributname Ihrer Wahl. Weitere Informationen finden Sie unter [*bounding-box*](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box).
#### Bildgröße
Die Größe des Bildes in MB Ordnet einem `image`-Objekt in der [Bilder](md-coco-overview.md#md-coco-images)-Liste zu.
+ `height`-> `image.height`
+ `width`-> `image.width`
+ `depth`-> Wird nicht von Amazon Rekognition Custom Labels verwendet, aber es muss ein Wert angegeben werden.
#### Anmerkungen
Eine Liste von `annotation`-Objekten. Für jedes Objekt auf dem Bild gibt es einen `annotation`.
#### Anmerkung
Enthält Begrenzungsrahmen für eine Instance eines Objekts auf dem Bild.
+ `class_id`-> Zuordnung einer numerischen ID zur `class-map`-Liste von Custom Label.
+ `top` -> `bbox[1]`
+ `left` -> `bbox[0]`
+ `width` -> `bbox[2]`
+ `height` -> `bbox[3]`
### *bounding-box*-Metadaten
Metadaten für das Label-Attribut. Beinhaltet die Labels und Label-IDs. Weitere Informationen finden Sie unter [*bounding-box*-Metadaten](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata).
#### Objekte
Ein Array von Objekten im Bild. Ordnet der `annotations`-Liste nach Index zu.
##### Objekt
+ `confidence`->Wird nicht von Amazon Rekognition Custom Labels verwendet, aber ein Wert (1) ist erforderlich.
#### Klassenzuordnung
Eine Übersicht der Labels (Klassen), die für die im Bild erkannten Objekte gelten. Ordnet Kategorieobjekten in der [Kategorien](md-coco-overview.md#md-coco-categories)-Liste zu.
+ `id` -> `category.id`
+ `id value` -> `category.name`
#### type
Muss `groundtruth/object-detection` sein.
#### mit menschlichen Anmerkungen versehen
Geben Sie `yes` oder `no` an. Weitere Informationen finden Sie unter [*bounding-box*-Metadaten](md-create-manifest-file-object-detection.md#md-manifest-source-bounding-box-metadata).
#### Erstellungsdatum -> [Bild](md-coco-overview.md#md-coco-images).Aufnahmedatum
Das Erstellungsdatum und der Erstellungszeitpunkt des Bildes. Ordnet dem Feld [Bild](md-coco-overview.md#md-coco-images).Aufnahmedatum eines Bildes in der COCO-Bilderliste zu. Amazon Rekognition Custom Labels erwartet, dass das Format von `creation-date` *Y-M-DTH:M:S* lautet.
#### Jobname
Ein Jobname Ihrer Wahl.
# Das COCO-Datensatzformat
Ein COCO-Datensatz besteht aus fünf Informationsabschnitten, die Informationen für den gesamten Datensatz enthalten. Das Format für einen Datensatz zur COCO-Objekterkennung ist im [COCO-Datenformat](http://cocodataset.org/#format-data) dokumentiert.
+ Info – allgemeine Informationen über den Datensatz.
+ licenses – Lizenzinformationen für die Bilder im Datensatz.
+ [images](#md-coco-images) – eine Liste der Bilder im Datensatz.
+ [annotations](#md-coco-annotations) – eine Liste von Anmerkungen (einschließlich Begrenzungsrahmen), die in allen Bildern im Datensatz vorhanden sind.
+ [categories](#md-coco-categories) – eine Liste von Label-Kategorien.
Um ein Manifest für benutzerdefinierte Labels zu erstellen, verwenden Sie die Listen `images`, `annotations` und `categories` aus der COCO-Manifestdatei. Die anderen Abschnitte (`info`,`licences`) sind nicht erforderlich. Folgendes ist ein Beispiel für den Inhalt einer COCO-Manifestdatei.
```
{
"info": {
"description": "COCO 2017 Dataset","url": "http://cocodataset.org","version": "1.0","year": 2017,"contributor": "COCO Consortium","date_created": "2017/09/01"
},
"licenses": [
{"url": "http://creativecommons.org/licenses/by/2.0/","id": 4,"name": "Attribution License"}
],
"images": [
{"id": 242287, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/xxxxxxxxxxxx.jpg", "flickr_url": "http://farm3.staticflickr.com/2626/xxxxxxxxxxxx.jpg", "width": 426, "height": 640, "file_name": "xxxxxxxxx.jpg", "date_captured": "2013-11-15 02:41:42"},
{"id": 245915, "license": 4, "coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg", "flickr_url": "http://farm1.staticflickr.com/88/xxxxxxxxxxxx.jpg", "width": 640, "height": 480, "file_name": "nnnnnnnnnn.jpg", "date_captured": "2013-11-18 02:53:27"}
],
"annotations": [
{"id": 125686, "category_id": 0, "iscrowd": 0, "segmentation": [[164.81, 417.51,......167.55, 410.64]], "image_id": 242287, "area": 42061.80340000001, "bbox": [19.23, 383.18, 314.5, 244.46]},
{"id": 1409619, "category_id": 0, "iscrowd": 0, "segmentation": [[376.81, 238.8,........382.74, 241.17]], "image_id": 245915, "area": 3556.2197000000015, "bbox": [399, 251, 155, 101]},
{"id": 1410165, "category_id": 1, "iscrowd": 0, "segmentation": [[486.34, 239.01,..........495.95, 244.39]], "image_id": 245915, "area": 1775.8932499999994, "bbox": [86, 65, 220, 334]}
],
"categories": [
{"supercategory": "speaker","id": 0,"name": "echo"},
{"supercategory": "speaker","id": 1,"name": "echo dot"}
]
}
```
## Liste der Bilder
Die Bilder, auf die in einem COCO-Datensatz verwiesen wird, sind im Bilderarray aufgeführt. Jedes Bildobjekt enthält Informationen über das Bild, z. B. den Namen der Bilddatei. Notieren Sie sich im folgenden Beispiel-Bildobjekt die folgenden Informationen und welche Felder erforderlich sind, um eine Amazon Rekognition Custom Labels-Manifestdatei zu erstellen.
+ `id` – (Erforderlich) Eine eindeutige Kennung für das Bild. Das `id`-Feld ist dem `id`-Feld im Annotationsarray zugeordnet (in dem Begrenzungsrahmen-Informationen gespeichert werden).
+ `license` – (Nicht erforderlich) Entspricht dem Lizenz-Array.
+ `coco_url` – (Optional) Den Speicherort des Bildes.
+ `flickr_url` – (Nicht erforderlich) Der Speicherort des Bildes auf Flickr.
+ `width` – (Erforderlich) Die Breite des Bildes.
+ `height` – (Erforderlich) Die Höhe des Bildes.
+ `file_name` – (Erforderlich) Der Name der Bilddatei. In diesem Beispiel stimmen `file_name` und `id` überein, aber das ist keine Voraussetzung für COCO-Datensätze.
+ `date_captured` – (Erforderlich) Datum und Uhrzeit der Aufnahme des Bildes.
```
{
"id": 245915,
"license": 4,
"coco_url": "http://images.cocodataset.org/val2017/nnnnnnnnnnnn.jpg",
"flickr_url": "http://farm1.staticflickr.com/88/nnnnnnnnnnnnnnnnnnn.jpg",
"width": 640,
"height": 480,
"file_name": "000000245915.jpg",
"date_captured": "2013-11-18 02:53:27"
}
```
## Liste der Anmerkungen (Begrenzungsfelder)
Die Begrenzungsrahmeninformationen für alle Objekte auf allen Bildern werden in der Liste der Anmerkungen gespeichert. Ein einzelnes Anmerkungsobjekt enthält Begrenzungsrahmeninformationen für ein einzelnes Objekt und die Bezeichnung des Objekts auf einem Bild. Für jede Instance eines Objekts auf einem Bild gibt es ein Anmerkungsobjekt.
Notieren Sie sich im folgenden Beispiel die folgenden Informationen und welche Felder erforderlich sind, um eine Amazon Rekognition Custom Labels-Manifestdatei zu erstellen.
+ `id` – (Nicht erforderlich) Die Kennung für die Anmerkung.
+ `image_id` – (Erforderlich) Entspricht dem Bild `id` im Bildarray.
+ `category_id` – (Erforderlich) Der Bezeichner für das Label, das das Objekt innerhalb eines Begrenzungsrahmens identifiziert. Er wird dem `id`-Feld des Kategorien-Arrays zugeordnet.
+ `iscrowd` – (Nicht erforderlich) Gibt an, ob das Bild eine Menge von Objekten enthält.
+ `segmentation` – (Nicht erforderlich) Segmentierungsinformationen für Objekte auf einem Bild. Amazon Rekognition Custom Labels unterstützt keine Segmentierung.
+ `area` – (Nicht erforderlich) Der Bereich der Anmerkung.
+ `bbox` – (Erforderlich) Enthält die Koordinaten eines Begrenzungsrahmens, der ein Objekt auf dem Bild umgibt, in Pixeln.
```
{
"id": 1409619,
"category_id": 1,
"iscrowd": 0,
"segmentation": [
[86.0, 238.8,..........382.74, 241.17]
],
"image_id": 245915,
"area": 3556.2197000000015,
"bbox": [86, 65, 220, 334]
}
```
## Liste der Kategorien
Labelinformationen werden im Kategorien-Array gespeichert. Notieren Sie sich im folgenden Beispiel für ein Kategorie-Objekt die folgenden Informationen und welche Felder erforderlich sind, um eine Amazon Rekognition Custom Labels-Manifestdatei zu erstellen.
+ `supercategory` – (Nicht erforderlich) Die übergeordnete Kategorie für ein Label.
+ `id` – (Erforderlich) Die Label-ID. Das `id`-Feld ist dem `category_id`-Feld in einem `annotation`-Objekt zugeordnet. Im folgenden Beispiel ist der Identifier für einen Echo Dot 2.
+ `name` – (Erforderlich) Der Labelname.
```
{"supercategory": "speaker","id": 2,"name": "echo dot"}
```
# Transformieren eines COCO-Datensatzes
Verwenden Sie das folgende Python-Beispiel, um Begrenzungsrahmen-Informationen aus einem Datensatz im COCO-Format in eine Amazon Rekognition Custom Labels-Manifestdatei umzuwandeln. Der Code lädt die erstellte Manifestdatei in Ihren Amazon-S3-Bucket hoch. Der Code stellt auch einen AWS CLI-Befehl bereit, mit dem Sie Ihre Bilder hochladen können.
**So transformieren Sie einen COCO-Datensatz (SDK)**
1. Wenn Sie dies noch nicht getan haben:
1. Stellen Sie sicher, dass Sie die folgenden `AmazonS3FullAccess`-Berechtigungen haben. Weitere Informationen finden Sie unter [Einrichten von SDK-Berechtigungen](su-sdk-permissions.md).
1. 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. Verwenden Sie den folgenden Python-Code, um einen COCO-Datensatz zu transformieren. Legen Sie die folgenden Werte fest.
+ `s3_bucket` – Der Name des S3-Buckets, in dem Sie die Bilder und die Amazon Rekognition Custom Labels-Manifestdatei speichern möchten.
+ `s3_key_path_images` – Der Pfad zu dem Ort, an dem Sie die Bilder innerhalb des S3-Buckets platzieren möchten (`s3_bucket`).
+ `s3_key_path_manifest_file` – Der Pfad zu der Stelle, an der Sie die Manifestdatei für benutzerdefinierte Labels im S3-Bucket platzieren möchten (`s3_bucket`).
+ `local_path` – Der lokale Pfad, in dem das Beispiel den COCO-Eingabedatensatz öffnet und auch die neue Custom Labels-Manifestdatei speichert.
+ `local_images_path` – Der lokale Pfad zu den Bildern, die Sie für das Training verwenden möchten.
+ `coco_manifest` – Der Dateiname des COCO-Eingabedatensatzes.
+ `cl_manifest_file` – Ein Name für die Manifestdatei, die durch das Beispiel erstellt wurde. Die Datei wird an dem von `local_path` angegebenen Speicherort gespeichert. Konventionell hat die Datei die Erweiterung `.manifest`, dies ist jedoch nicht erforderlich.
+ `job_name` – Ein Name für den Custom Labels-Job.
```
import json
import os
import random
import shutil
import datetime
import botocore
import boto3
import PIL.Image as Image
import io
#S3 location for images
s3_bucket = 'bucket'
s3_key_path_manifest_file = 'path to custom labels manifest file/'
s3_key_path_images = 'path to images/'
s3_path='s3://' + s3_bucket + '/' + s3_key_path_images
s3 = boto3.resource('s3')
#Local file information
local_path='path to input COCO dataset and output Custom Labels manifest/'
local_images_path='path to COCO images/'
coco_manifest = 'COCO dataset JSON file name'
coco_json_file = local_path + coco_manifest
job_name='Custom Labels job name'
cl_manifest_file = 'custom_labels.manifest'
label_attribute ='bounding-box'
open(local_path + cl_manifest_file, 'w').close()
# class representing a Custom Label JSON line for an image
class cl_json_line:
def __init__(self,job, img):
#Get image info. Annotations are dealt with seperately
sizes=[]
image_size={}
image_size["width"] = img["width"]
image_size["depth"] = 3
image_size["height"] = img["height"]
sizes.append(image_size)
bounding_box={}
bounding_box["annotations"] = []
bounding_box["image_size"] = sizes
self.__dict__["source-ref"] = s3_path + img['file_name']
self.__dict__[job] = bounding_box
#get metadata
metadata = {}
metadata['job-name'] = job_name
metadata['class-map'] = {}
metadata['human-annotated']='yes'
metadata['objects'] = []
date_time_obj = datetime.datetime.strptime(img['date_captured'], '%Y-%m-%d %H:%M:%S')
metadata['creation-date']= date_time_obj.strftime('%Y-%m-%dT%H:%M:%S')
metadata['type']='groundtruth/object-detection'
self.__dict__[job + '-metadata'] = metadata
print("Getting image, annotations, and categories from COCO file...")
with open(coco_json_file) as f:
#Get custom label compatible info
js = json.load(f)
images = js['images']
categories = js['categories']
annotations = js['annotations']
print('Images: ' + str(len(images)))
print('annotations: ' + str(len(annotations)))
print('categories: ' + str(len (categories)))
print("Creating CL JSON lines...")
images_dict = {image['id']: cl_json_line(label_attribute, image) for image in images}
print('Parsing annotations...')
for annotation in annotations:
image=images_dict[annotation['image_id']]
cl_annotation = {}
cl_class_map={}
# get bounding box information
cl_bounding_box={}
cl_bounding_box['left'] = annotation['bbox'][0]
cl_bounding_box['top'] = annotation['bbox'][1]
cl_bounding_box['width'] = annotation['bbox'][2]
cl_bounding_box['height'] = annotation['bbox'][3]
cl_bounding_box['class_id'] = annotation['category_id']
getattr(image, label_attribute)['annotations'].append(cl_bounding_box)
for category in categories:
if annotation['category_id'] == category['id']:
getattr(image, label_attribute + '-metadata')['class-map'][category['id']]=category['name']
cl_object={}
cl_object['confidence'] = int(1) #not currently used by Custom Labels
getattr(image, label_attribute + '-metadata')['objects'].append(cl_object)
print('Done parsing annotations')
# Create manifest file.
print('Writing Custom Labels manifest...')
for im in images_dict.values():
with open(local_path+cl_manifest_file, 'a+') as outfile:
json.dump(im.__dict__,outfile)
outfile.write('\n')
outfile.close()
# Upload manifest file to S3 bucket.
print ('Uploading Custom Labels manifest file to S3 bucket')
print('Uploading' + local_path + cl_manifest_file + ' to ' + s3_key_path_manifest_file)
print(s3_bucket)
s3 = boto3.resource('s3')
s3.Bucket(s3_bucket).upload_file(local_path + cl_manifest_file, s3_key_path_manifest_file + cl_manifest_file)
# Print S3 URL to manifest file,
print ('S3 URL Path to manifest file. ')
print('\033[1m s3://' + s3_bucket + '/' + s3_key_path_manifest_file + cl_manifest_file + '\033[0m')
# Display aws s3 sync command.
print ('\nAWS CLI s3 sync command to upload your images to S3 bucket. ')
print ('\033[1m aws s3 sync ' + local_images_path + ' ' + s3_path + '\033[0m')
```
1. Führen Sie den Code aus.
1. Notieren Sie den `s3 sync`-Befehl in der Programmausgabe. Sie benötigen ihn im nächsten Schritt.
1. Führen Sie über die Eingabeaufforderung den folgenden `s3 sync`-Befehl aus. Ihre Bilder werden zu dem S3-Bucket hochgeladen. Wenn der Befehl beim Hochladen fehlschlägt, führen Sie ihn erneut aus, bis Ihre lokalen Bilder mit dem S3-Bucket synchronisiert sind.
1. Notieren Sie sich in der Programmausgabe den S3-URL-Pfad zur Manifestdatei. Sie benötigen ihn im nächsten Schritt.
1. Folgen Sie den Anweisungen unter [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (Konsole)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console), um einen Datensatz mit der hochgeladenen Manifestdatei zu erstellen. Geben Sie für Schritt 8 im **Manifestdatei-Speicherort** die Amazon S3-URL ein, die Sie sich im vorherigen Schritt notiert haben. Wenn Sie AWS -SDK verwenden, führen Sie [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk) durch.
# Transformation von SageMaker AI Ground Truth-Manifestdateien mit mehreren Labels
In diesem Thema erfahren Sie, wie Sie eine Amazon SageMaker AI Ground Truth-Manifestdatei mit mehreren Labels in eine Manifestdatei im Amazon Rekognition Custom Labels-Format umwandeln.
SageMaker AI Ground Truth Truth-Manifestdateien für Aufträge mit mehreren Labels sind anders formatiert als Manifestdateien im Amazon Rekognition Custom Labels-Format. Bei der Klassifizierung mit mehreren Labels wird ein Bild in eine Gruppe von Klassen eingeteilt, kann aber gleichzeitig mehreren Klassen angehören. In diesem Fall kann das Bild möglicherweise mehrere Labels haben, z. B. *Fußball* und *Ball*.
Informationen zu SageMaker KI-Ground-Truth-Aufträgen mit mehreren Labels finden Sie unter [Bildklassifizierung (mehrere Labels](https://docs.aws.amazon.com/sagemaker/latest/dg/sms-image-classification-multilabel.html)). Informationen zu Amazon Rekognition Custom Labels-Manifestdateien im Format mit mehreren Labels finden Sie unter [Hinzufügen mehrerer Labels auf Bildebene zu einem Bild](md-create-manifest-file-classification.md#md-dataset-purpose-classification-multiple-labels).
## Die Manifestdatei für einen SageMaker AI Ground Truth Job abrufen
Das folgende Verfahren zeigt Ihnen, wie Sie die Ausgabe-Manifestdatei (`output.manifest`) für einen Amazon SageMaker AI Ground Truth Job abrufen. Sie verwenden `output.manifest` als Eingabe für das nächste Verfahren.
**So laden Sie eine SageMaker AI Ground Truth Job-Manifest-Datei herunter**
1. Öffnen Sie die [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Wählen Sie im Navigationsbereich **Ground Truth** und dann **Labeling-Jobs** aus.
1. Wählen Sie den Labeling-Job, der die Manifestdatei enthält, die Sie verwenden möchten.
1. Wählen Sie auf der Detailseite den Link unter **Speicherort des Ausgabe-Datensatzes** aus. Die Amazon S3-Konsole wird am Speicherort des Datensatzes geöffnet.
1. Wählen Sie `Manifests`, `output` und anschließend `output.manifest` aus.
1. Um die Manifestdatei herunterzuladen, wählen Sie **Objektanmerkungen** und dann **Herunterladen** aus.
## Transformation einer SageMaker AI-Manifestdatei mit mehreren Bezeichnungen
Das folgende Verfahren erstellt eine Amazon Rekognition Custom Labels-Manifestdatei im Multi-Label-Format aus einer vorhandenen AI-Manifestdatei im Multi-Label-Format SageMaker . GroundTruth
**Anmerkung**
Um den Code auszuführen, benötigen Sie Python Version 3 oder höher.
**Um eine AI-Manifestdatei mit mehreren Bezeichnungen zu transformieren SageMaker**
1. Führen Sie den folgenden Python-Code aus. Geben Sie den Namen der Manifestdatei, die Sie in [Die Manifestdatei für einen SageMaker AI Ground Truth Job abrufen](#md-get-gt-manifest) als Befehlszeilenargument erstellt haben, an.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Purpose
Shows how to create and Amazon Rekognition Custom Labels format
manifest file from an Amazon SageMaker Ground Truth Image
Classification (Multi-label) format manifest file.
"""
import json
import logging
import argparse
import os.path
logger = logging.getLogger(__name__)
def create_manifest_file(ground_truth_manifest_file):
"""
Creates an Amazon Rekognition Custom Labels format manifest file from
an Amazon SageMaker Ground Truth Image Classification (Multi-label) format
manifest file.
:param: ground_truth_manifest_file: The name of the Ground Truth manifest file,
including the relative path.
:return: The name of the new Custom Labels manifest file.
"""
logger.info('Creating manifest file from %s', ground_truth_manifest_file)
new_manifest_file = f'custom_labels_{os.path.basename(ground_truth_manifest_file)}'
# Read the SageMaker Ground Truth manifest file into memory.
with open(ground_truth_manifest_file) as gt_file:
lines = gt_file.readlines()
#Iterate through the lines one at a time to generate the
#new lines for the Custom Labels manifest file.
with open(new_manifest_file, 'w') as the_new_file:
for line in lines:
#job_name - The of the Amazon Sagemaker Ground Truth job.
job_name = ''
# Load in the old json item from the Ground Truth manifest file
old_json = json.loads(line)
# Get the job name
keys = old_json.keys()
for key in keys:
if 'source-ref' not in key and '-metadata' not in key:
job_name = key
new_json = {}
# Set the location of the image
new_json['source-ref'] = old_json['source-ref']
# Temporarily store the list of labels
labels = old_json[job_name]
# Iterate through the labels and reformat to Custom Labels format
for index, label in enumerate(labels):
new_json[f'{job_name}{index}'] = index
metadata = {}
metadata['class-name'] = old_json[f'{job_name}-metadata']['class-map'][str(label)]
metadata['confidence'] = old_json[f'{job_name}-metadata']['confidence-map'][str(label)]
metadata['type'] = 'groundtruth/image-classification'
metadata['job-name'] = old_json[f'{job_name}-metadata']['job-name']
metadata['human-annotated'] = old_json[f'{job_name}-metadata']['human-annotated']
metadata['creation-date'] = old_json[f'{job_name}-metadata']['creation-date']
# Add the metadata to new json line
new_json[f'{job_name}{index}-metadata'] = metadata
# Write the current line to the json file
the_new_file.write(json.dumps(new_json))
the_new_file.write('\n')
logger.info('Created %s', new_manifest_file)
return new_manifest_file
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"manifest_file", help="The Amazon SageMaker Ground Truth manifest file"
"that you want to use."
)
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()
# Create the manifest file
manifest_file = create_manifest_file(args.manifest_file)
print(f'Manifest file created: {manifest_file}')
except FileNotFoundError as err:
logger.exception('File not found: %s', err)
print(f'File not found: {err}. Check your manifest file.')
if __name__ == "__main__":
main()
```
1. Notieren Sie sich den Namen der neuen Manifestdatei, die das Skript anzeigt. Sie werden ihn im nächsten Schritt verwenden.
1. [Laden Sie Ihre Manifestdateien](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) in den Amazon-S3-Bucket hoch, den Sie zum Speichern der Manifestdatei verwenden möchten.
**Anmerkung**
Stellen Sie sicher, dass Amazon Rekognition Custom Labels Zugriff auf den Amazon-S3-Bucket hat, auf den im `source-ref`-Feld der JSON-Zeilen der Manifestdatei verwiesen wird. Weitere Informationen finden Sie unter [Zugreifen auf externe Amazon-S3-Buckets](su-console-policy.md#su-external-buckets). Wenn Ihr Ground Truth-Job Bilder im Amazon Rekognition Custom Labels-Konsolen-Bucket speichert, müssen Sie keine Berechtigungen hinzufügen.
1. Folgen Sie den Anweisungen unter [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (Konsole)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console), um einen Datensatz mit der hochgeladenen Manifestdatei zu erstellen. Geben Sie für Schritt 8 unter **Speicherort der Manifestdatei** die Amazon S3-URL für die Manifestdatei ein. Wenn Sie AWS -SDK verwenden, führen Sie [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk) durch.
# Erstellen einer Manifestdatei aus einer CSV-Datei
Dieses Python-Beispielskript vereinfacht die Erstellung einer Manifestdatei, indem es eine CSV-Datei (Comma Separated Values) verwendet, um Bilder zu beschriften. So erstellen Sie die CSV-Datei Die Manifestdatei eignet sich für die [Klassifizierung von Bildern mit mehreren Labels](getting-started.md#gs-multi-label-image-classification-example) oder [Bildklassifizierung (mehrere Label)](getting-started.md#gs-multi-label-image-classification-example). Weitere Informationen finden Sie unter [Objekte, Szenen und Konzepte finden](understanding-custom-labels.md#tm-classification).
**Anmerkung**
Dieses Skript erstellt keine Manifestdatei, die für die Suche nach [Objektpositionen](understanding-custom-labels.md#tm-object-localization) oder [Markenpositionen](understanding-custom-labels.md#tm-brand-detection-localization) geeignet ist.
Eine Manifestdatei beschreibt die Bilder, die zum Trainieren eines Modells verwendet werden. Zum Beispiel Bildpositionen und Labels, die Bildern zugewiesen wurden. Eine Manifestdatei besteht aus einer oder mehreren JSON-Zeilen. Jede JSON-Zeile beschreibt ein einzelnes Bild. Weitere Informationen finden Sie unter [Labels auf Bildebene in Manifestdateien importieren](md-create-manifest-file-classification.md).
Eine CSV-Datei stellt tabellarische Daten über mehrere Zeilen in einer Textdatei dar. Felder in einer Zeile werden durch ein Komma getrennt. Weitere Informationen finden Sie unter [Kommagetrennte Werte](https://en.wikipedia.org/wiki/Comma-separated_values). Bei diesem Skript steht jede Zeile in Ihrer CSV-Datei für ein einzelnes Bild und ist einer JSON-Zeile in der Manifestdatei zugeordnet. Um eine CSV-Datei für eine Manifestdatei zu erstellen, die die [Bildklassifizierung mit mehreren Labels](getting-started.md#gs-multi-label-image-classification-example) unterstützt, fügen Sie jeder Zeile ein oder mehrere Labels auf Bildebene hinzu. Um eine geeignete Manifestdatei für [Bildklassifizierung](getting-started.md#gs-image-classification-example) zu erstellen, fügen Sie jeder Zeile ein einzelnes Label auf Bildebene hinzu.
In der folgenden CSV-Datei werden beispielsweise die Bilder im Projekt [Bildklassifizierung (mehrere Label)](getting-started.md#gs-multi-label-image-classification-example) (Blumen) *Erste Schritte* beschrieben.
```
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
```
Das Skript generiert JSON-Zeilen für jede Zeile. Das Folgende ist beispielsweise die JSON-Zeile für die erste Zeile (`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"}}
```
In der Beispiel-CSV ist der Amazon S3-Pfad zum Bild nicht vorhanden. Wenn Ihre CSV-Datei den Amazon S3-Pfad für die Bilder nicht enthält, verwenden Sie das `--s3_path`-Befehlszeilenargument, um den Amazon S3-Pfad zu dem Bild anzugeben.
Das Skript zeichnet den ersten Eintrag für jedes Bild in einer deduplizierten Bild-CSV-Datei auf. Die CSV-Datei mit dedupliziertem Bild enthält eine einzelne Instance jedes Bildes, das in der CSV-Eingabedatei gefunden wurde. Weitere Vorkommen eines Bilds in der CSV-Eingabedatei werden in einer doppelten CSV-Bilddatei aufgezeichnet. Wenn das Skript doppelte Bilder findet, überprüfen Sie die CSV-Datei mit dem doppelten Bild und aktualisieren Sie die CSV-Datei mit dem deduplizierten Bild nach Bedarf. Führen Sie das Skript mit der deduplizierten Datei erneut aus. Wenn in der CSV-Eingabedatei keine Duplikate gefunden werden, löscht das Skript die deduplizierte CSV-Datei und das duplizierte Bild CSVfile, da sie leer sind.
In diesem Verfahren erstellen Sie die CSV-Datei und führen das Python-Skript aus, um die Manifestdatei zu erstellen.
**So erstellen Sie eine Manifestdatei aus einer CSV-Datei**
1. Erstellen Sie eine CSV-Datei mit den folgenden Feldern in jeder Zeile (eine Zeile pro Bild). Fügen Sie der CSV-Datei keine Kopfzeile hinzu.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/rekognition/latest/customlabels-dg/ex-csv-manifest.html)
Zum Beispiel `camellia1.jpg,camellia,with_leaves` oder `s3://my-bucket/flowers/train/camellia1.jpg,camellia,with_leaves`
1. Speichern Sie die CSV-Datei.
1. Führen Sie das folgende Python-Skript aus. Stellen Sie die folgenden Argumente bereit:
+ `csv_file` – Die CSV-Datei, die Sie in Schritt 1 erstellt haben.
+ `manifest_file` – Der Name der Manifestdatei, die Sie erstellen möchten.
+ (Optional) `--s3_path s3://path_to_folder/` – Der Amazon S3-Pfad, der den Bilddateinamen hinzugefügt werden soll (Feld 1). Verwenden Sie `--s3_path`, wenn die Bilder in Feld 1 noch keinen S3-Pfad enthalten.
```
# 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. Wenn Sie einen Testdatensatz verwenden möchten, wiederholen Sie die Schritte 1-3, um eine Manifestdatei für Ihren Testdatensatz zu erstellen.
1. Kopieren Sie die Bilder bei Bedarf in den Amazon-S3-Bucket-Pfad, den Sie in Spalte 1 der CSV-Datei (oder in der `--s3_path`-Befehlszeile) angegeben haben. Sie können folgenden AWS S3-Befehl verwenden.
```
aws s3 cp --recursive your-local-folder s3://your-target-S3-location
```
1. [Laden Sie Ihre Manifestdateien](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) in den Amazon-S3-Bucket hoch, den Sie zum Speichern der Manifestdatei verwenden möchten.
**Anmerkung**
Stellen Sie sicher, dass Amazon Rekognition Custom Labels Zugriff auf den Amazon-S3-Bucket hat, auf den im `source-ref`-Feld der JSON-Zeilen der Manifestdatei verwiesen wird. Weitere Informationen finden Sie unter [Zugreifen auf externe Amazon-S3-Buckets](su-console-policy.md#su-external-buckets). Wenn Ihr Ground Truth-Job Bilder im Amazon Rekognition Custom Labels-Konsolen-Bucket speichert, müssen Sie keine Berechtigungen hinzufügen.
1. Folgen Sie den Anweisungen unter [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (Konsole)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-console), um einen Datensatz mit der hochgeladenen Manifestdatei zu erstellen. Geben Sie für Schritt 8 unter **Speicherort der Manifestdatei** die Amazon S3-URL für die Manifestdatei ein. Wenn Sie AWS -SDK verwenden, führen Sie [Erstellen eines Datensatzes mit einer SageMaker AI Ground Truth Manifestdatei (SDK)](md-create-dataset-ground-truth.md#md-create-dataset-ground-truth-sdk) durch.
# Inhalte aus einem vorhandenen Datensatz werden kopiert
Wenn Sie zuvor einen Datensatz erstellt haben, können Sie seinen Inhalt in einen neuen Datensatz kopieren. Informationen zum Erstellen eines Datensatzes aus einem vorhandenen Datensatz mit dem AWS SDK finden Sie unter[Erstellen eines Datensatzes mit einem vorhandenen Datensatz (SDK)](md-create-dataset-existing-dataset-sdk.md).
**So erstellen Sie einen Datensatz mit einem bestehenden Amazon Rekognition Custom Labels-Datensatz (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 auf der Seite **Projekte** das Projekt aus, dem Sie den Datensatz hinzufügen möchten. Die Detailseite für Ihr Projekt wird angezeigt.
1. Wählen Sie **Datensatz erstellen**. Die Seite **Datensatz erstellen** wird angezeigt.
1. Wählen Sie in der **Startkonfiguration** entweder **Mit einem einzelnen Datensatz beginnen** oder **Mit einem Trainingsdatensatz beginnen** aus. Um ein qualitativ hochwertigeres Modell zu erstellen, empfehlen wir, mit separaten Trainings- und Testdatensätzen zu beginnen.
------
#### [ Single dataset ]
1. Wählen Sie im Abschnitt **Details zum Trainingsdatensatz** die Option **Einen vorhandenen Amazon Rekognition Custom Labels-Datensatz kopieren** aus.
1. Geben Sie im Abschnitt **Details zum Trainingsdatensatz** im Bearbeitungsfeld **Datensatz** den Namen des Datensatzes ein, den Sie kopieren möchten, oder wählen Sie ihn aus.
1. Wählen Sie **Datensatz erstellen**. Die Datensatzseite für Ihr Projekt wird geöffnet.
------
#### [ Separate training and test datasets ]
1. Wählen Sie im Abschnitt **Details zum Trainingsdatensatz** die Option **Einen vorhandenen Amazon Rekognition Custom Labels-Datensatz kopieren** aus.
1. Geben Sie im Abschnitt **Details zum Trainingsdatensatz** im Bearbeitungsfeld **Datensatz** den Namen des Datensatzes ein, den Sie kopieren möchten, oder wählen Sie ihn aus.
1. Wählen Sie im Abschnitt **Details zum Testdatensatz** die Option **Einen vorhandenen Amazon Rekognition Custom Labels-Datensatz kopieren** aus.
1. Geben Sie im Abschnitt **Testdatensatzdetails** im Bearbeitungsfeld **Datensatz** den Namen des Datensatzes ein, den Sie kopieren möchten, oder wählen Sie ihn aus.
**Anmerkung**
Ihre Trainings- und Testdatensätze können unterschiedliche Bildquellen haben.
1. Wählen Sie **Datensätze erstellen** aus. Die Datensatzseite für Ihr Projekt wird geöffnet.
------
1. Wenn Sie Labels hinzufügen oder ändern müssen, führen Sie [Labeling von Bildern](md-labeling-images.md) aus.
1. Folgen Sie den Anweisungen unter [Ein Modell trainieren (Konsole)](training-model.md#tm-console), um Ihr Modell zu trainieren.