Datasets erstellen

Ein Dataset ist eine Sammlung von Datenelementen, die menschliche Labelersteller mit Labels versehen sollen. Es enthält repräsentative Stichproben, die Sie klassifizieren oder analysieren möchten. Ein Dataset mit aussagekräftigen Labels kann zum Trainieren eines benutzerdefinierten Modells verwendet werden.

Die wesentlichen Schritte zum Erstellen eines Datasets sind:

  1. Datenelemente in einen Cloud Storage-Bucket hochladen
  2. Eine CSV-Datei (Comma-Separated Values = kommagetrennte Werte) zur Katalogisierung der Datenelemente erstellen und in denselben Cloud Storage-Bucket hochladen
  3. Dataset-Ressource erstellen
  4. Importieren Sie die Datenelemente in die Dataset-Ressource.

Ein Projekt kann aus mehreren Datasets bestehen, von denen jedes für eine andere Anfrage des AI Platform Data Labelling Service verwendet wird. Sie können eine Liste der verfügbaren Datasets abrufen und Datasets löschen, die Sie nicht mehr benötigen. Weitere Informationen finden Sie auf der Seite zu Dataset-Ressourcen.

Daten ohne Label bereitstellen

Der erste Schritt beim Erstellen eines Datasets besteht darin, die Datenelemente in einen Cloud Storage-Bucket hochzuladen, um sie Labels hinzuzufügen. Informationen zum Erstellen eines Buckets finden Sie unter Vorbereitung.

Der Data Labeling Service unterstützt das Hinzufügen von Labels zu drei Datentypen. Sie können die folgenden Abschnitte maximieren, um sich die Details zum Bereitstellen von hochwertigen Datenelementen für jeden Typ anzeigen zu lassen. Für das Labeling werden derzeit nur Datasets in englischer Sprache unterstützt.

Bilder

Für Bilder muss ein unterstützter Dateityp verwendet werden.

  • JPEG
  • PNG

Die maximale Dateigröße beim Labeling von Bildern beträgt 30 MB, außer der Bildsegmentierung. Beim Labeling für die Bildsegmentierung beträgt die maximale Dateigröße 10 MB.

Die maximale Bildgröße beträgt 1920 x 1080.

Die Trainingsdaten sollten den Daten, für die Vorhersagen getroffen werden sollen, möglichst ähnlich sein. Wenn Ihr Anwendungsfall beispielsweise verschwommene Bilder mit niedriger Auflösung (etwa von einer Überwachungskamera) beinhaltet, sollten Ihre Trainingsdaten aus verschwommenen Bildern mit niedriger Auflösung bestehen. Sie sollten außerdem mehrere Blickwinkel, Auflösungen und Hintergründe für Ihre Trainingsbilder bereitstellen.

Das Trainieren eines Modells funktioniert am besten, wenn für das am häufigsten verwendete Label höchstens 100-mal mehr Bilder vorhanden sind als für das am wenigsten verwendete Label. Es wird empfohlen, Labels mit sehr geringer Häufigkeit zu entfernen.

Video

Videos müssen im MP4-Format mit H.264-, H.265- und MPEG4-Codec vorliegen. Die maximale Videogröße beträgt 2 GB.

Die Trainingsdaten sollten den Daten, für die Vorhersagen getroffen werden sollen, möglichst ähnlich sein. Wenn Ihr Anwendungsfall beispielsweise verschwommene Videos mit niedriger Auflösung (zum Beispiel von einer Überwachungskamera) beinhaltet, sollten Ihre Trainingsdaten aus verschwommenen Videos mit niedriger Auflösung bestehen. Sie sollten außerdem mehrere Blickwinkel, Auflösungen und Hintergründe für Ihre Trainingsvideos bereitstellen.

Wir empfehlen ca. 1.000 Trainingsvideos pro Label. Die Mindestanzahl pro Label ist 10, für fortgeschrittene Modelle liegt sie bei 50. Im Allgemeinen sind mehr Beispiele pro Label nötig, um Modelle mit mehreren Labels pro Video zu trainieren. Die Auswertung der Konfidenzwerte ist dann schwieriger.

Das Modell funktioniert am besten, wenn für das am häufigsten verwendete Label höchstens 100-mal mehr Videos vorhanden sind als für das am wenigsten verwendete Label. Es wird empfohlen, Labels mit sehr geringer Häufigkeit zu entfernen.

SMS

Textdateien müssen das UTF-8-Codierungsformat für Textdateien verwenden.

Jedes Dokument muss einer separaten Textdatei entsprechen. Mehrere Dokumente können nicht in einer Textdatei bereitgestellt werden. Sie können beispielsweise nicht die einzelnen Zeilen einer Textdatei als eigene Dokumente behandeln.

Die maximale Zeichenanzahl pro Textdatei ist 100.000.

Versuchen Sie, Ihre Trainingsdaten so verschiedenartig wie die Daten zu gestalten, für die Vorhersagen getroffen werden. Datasets müssen Dokumente unterschiedlicher Länge, Dokumente, die von verschiedenen Personen verfasst wurden, Dokumente mit unterschiedlichen Formulierungen oder unterschiedlichem Stil und so weiter enthalten.

Wir empfehlen mindestens 1.000 Trainingsdokumente pro Label. Die Mindestanzahl von Dokumenten pro Label ist 10. Sie können jedoch die Konfidenzwerte des Modells verbessern, wenn Sie mehr Beispiele pro Label verwenden. Bessere Konfidenzwerte sind besonders hilfreich, wenn das Modell mehrere Labels zurückgibt, um ein Dokument zu klassifizieren.

Das Modell funktioniert am besten, wenn für das am häufigsten verwendete Label höchstens 100-mal mehr Dokumente vorhanden sind als für das am wenigsten verwendete Label. Es wird empfohlen, Labels mit sehr geringer Häufigkeit zu entfernen.

Eingabe-CSV-Datei erstellen

Zusätzlich zu den Beispieldatenelementen müssen Sie auch eine CSV-Datei (Comma-Separated Values, kommagetrennte Werte) erstellen, in der alle Daten katalogisiert werden. Die CSV-Datei kann beliebig benannt werden, muss aber UTF-8-codiert sein und die Dateiendung .csv haben.

Bei Bild- und Videodaten gibt jede Zeile in der CSV-Datei den Speicherort eines Bildes bzw. Videos im Google Cloud Storage-Bucket Ihres Projekts an. Beispiel:

gs://my_project_bucket/image1.png
gs://my_project_bucket/image2.png
gs://my_project_bucket/image3.png
gs://my_project_bucket/image4.png

Bei Textdaten gibt jede Zeile in der CSV-Datei den Speicherort einer Textdatei an. Beispiel:

gs://my_project_bucket/file1.txt
gs://my_project_bucket/file2.txt
gs://my_project_bucket/file3.txt
gs://my_project_bucket/file4.txt

Jede Datendatei sollte die Daten enthalten, die Sie mit einem Label versehen möchten. Der Inhalt jeder Datendatei wird Labelerstellern als eine Labelfrage angezeigt.

Nachdem Sie die CSV-Datei erstellt haben, die die Datenelemente katalogisiert, laden Sie sie in denselben Cloud Storage-Bucket hoch wie die Datenelemente.

Dataset-Ressource erstellen

Im nächsten Schritt wird eine Dataset-Ressource erstellt, die die Datenelemente enthalten soll. Das neu erstellte Dataset bleibt leer, bis Sie im nächsten Schritt Datenelemente darin importieren.

Web-UI

In der Benutzeroberfläche des Data Labeling Service erstellen Sie ein Dataset und importieren Elemente von derselben Seite in dieses Dataset.

  1. Rufen Sie die Data Labeling Service-UI auf.

    Auf der Seite Datasets wird der Status zuvor erstellter Datasets für das aktuelle Projekt angezeigt.

    Wenn Sie ein Dataset für ein anderes Projekt hinzufügen möchten, wählen Sie das betreffende Projekt in der Drop-down-Liste rechts oben in der Titelleiste aus.

  2. Klicken Sie in der Titelleiste auf die Schaltfläche Create (Erstellen).

  3. Geben Sie auf der Seite Add dataset (Dataset hinzufügen) einen Namen und eine Beschreibung für das Dataset ein.

  4. Wählen Sie in der Drop-down-Liste Dataset type (Dataset-Typ) den Typ der Datenelemente aus, die Sie in dieses Dataset hochladen möchten: Images (Bilder), Video oder Text.

  5. Geben Sie im Feld CSV file location (Speicherort der CSV-Datei) den vollständigen Pfad zur CSV-Eingabedatei ein.

    Die CSV-Datei muss sich in demselben Google Cloud Storage-Bucket wie die darin aufgelisteten Datenelemente befinden.

  6. Klicken Sie auf Erstellen.

    Es wird wieder die Seite Datasets angezeigt. Der Status Ihres Datasets lautet "In progress", während Ihre Dokumente importiert werden. Dieser Vorgang dauert ungefähr 10 Minuten pro 1.000 Dokumente, kann aber auch mehr oder weniger Zeit in Anspruch nehmen.

    Wenn der Dienst einen 405-Fehler zurückgibt, reduzieren Sie die Anzahl der Dokumente, die Sie gleichzeitig hochladen. Sie müssen die Seite aktualisieren, bevor Sie es noch einmal versuchen.

Befehlszeile

Im folgenden Beispiel wird ein Dataset mit dem Namen test_dataset erstellt. Das neu erstellte Dataset enthält keine Daten, bis Sie Elemente importiert haben.

Speichern Sie den "name" des neuen Datasets (aus der Antwort), um es für weitere Vorgänge zu verwenden, beispielsweise zum Importieren von Elementen in das Dataset.

curl -X POST \
   -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
   -H "Content-Type: application/json" \
   https://datalabeling.googleapis.com/v1beta1/projects/${PROJECT_ID}/datasets \
   -d '{
     "dataset": {
     "displayName": "test_dataset",
     "description": "dataset for curl commands testing",
     },
   }'

Die Ausgabe sollte in etwa so aussehen:

{
  "name": "projects/data-labeling-codelab/datasets/5c897e1e_0000_2ab5_9159_94eb2c0b4daa",
  "displayName": "test_dataset",
  "description": "dataset for curl commands testing",
  "createTime": "2019-03-14T03:11:50.926475415Z"
}

Python

Für dieses Codebeispiel müssen die Python-Clientbibliotheken installiert sein.

def create_dataset(project_id):
    """Creates a dataset for the given Google Cloud project."""
    from google.cloud import datalabeling_v1beta1 as datalabeling

    client = datalabeling.DataLabelingServiceClient()

    formatted_project_name = f"projects/{project_id}"

    dataset = datalabeling.Dataset(
        display_name="YOUR_DATASET_SET_DISPLAY_NAME", description="YOUR_DESCRIPTION"
    )

    response = client.create_dataset(
        request={"parent": formatted_project_name, "dataset": dataset}
    )

    # The format of resource name:
    # project_id/{project_id}/datasets/{dataset_id}
    print("The dataset resource name: {}".format(response.name))
    print("Display name: {}".format(response.display_name))
    print("Description: {}".format(response.description))
    print("Create time:")
    print("\tseconds: {}".format(response.create_time.timestamp_pb().seconds))
    print("\tnanos: {}\n".format(response.create_time.timestamp_pb().nanos))

    return response

Java

Für dieses Codebeispiel müssen die Java-Clientbibliotheken installiert sein.
import com.google.cloud.datalabeling.v1beta1.CreateDatasetRequest;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceClient;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceSettings;
import com.google.cloud.datalabeling.v1beta1.Dataset;
import com.google.cloud.datalabeling.v1beta1.ProjectName;
import java.io.IOException;

class CreateDataset {

  // Create a dataset that is initially empty.
  static void createDataset(String projectId, String datasetName) throws IOException {
    // String projectId = "YOUR_PROJECT_ID";
    // String datasetName = "YOUR_DATASET_DISPLAY_NAME";

    DataLabelingServiceSettings settings =
        DataLabelingServiceSettings.newBuilder()
            .build();
    try (DataLabelingServiceClient dataLabelingServiceClient =
        DataLabelingServiceClient.create(settings)) {
      ProjectName projectName = ProjectName.of(projectId);

      Dataset dataset =
          Dataset.newBuilder()
              .setDisplayName(datasetName)
              .setDescription("YOUR_DESCRIPTION")
              .build();

      CreateDatasetRequest createDatasetRequest =
          CreateDatasetRequest.newBuilder()
              .setParent(projectName.toString())
              .setDataset(dataset)
              .build();

      Dataset createdDataset = dataLabelingServiceClient.createDataset(createDatasetRequest);

      System.out.format("Name: %s\n", createdDataset.getName());
      System.out.format("DisplayName: %s\n", createdDataset.getDisplayName());
      System.out.format("Description: %s\n", createdDataset.getDescription());
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Datenelemente in das Dataset importieren

Nachdem Sie ein Dataset erstellt haben, können Sie die Datenelemente mithilfe der CSV-Datei in dieses Dataset importieren.

Web-UI

In der Benutzeroberfläche des Data Labeling Service können Sie diesen Schritt überspringen, da der Import bereits im vorherigen Schritt erledigt wurde ist.

Befehlszeile

  • Ersetzen Sie DATASET_ID durch die ID Ihres Datasets aus der Antwort, die Sie beim Erstellen des Datasets erhalten haben. Die ID wird am Ende des vollständigen Dataset-Namens angezeigt: projects/{project-id}/locations/us-central1/datasets/{dataset-id}

  • Ersetzen Sie CSV_FILE durch den vollständigen Pfad zur eingegebenen CSV-Datei.

    curl -X POST \
       -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
       -H "Content-Type: application/json" \
       https://datalabeling.googleapis.com/v1beta1/projects/${PROJECT_ID}/datasets/${DATASET_ID}:importData \
       -d '{
         "inputConfig": {
           "dataType": "IMAGE",
           "gcsSource": {
              "inputUri": "${CSV_FILE}",
              "mimeType": "text/csv",
            }
           },
       }'
    

    Die Ausgabe sieht in etwa so aus: Sie können den Status der Aufgabe anhand der Vorgangs-ID abrufen. Hier finden Sie ein Beispiel dafür, wie Sie den Status eines Vorgangs abrufen.

    {
      "name": "projects/data-labeling-codelab/operations/5c73dd6b_0000_2b34_a920_883d24fa2064",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.data-labeling.v1beta1.ImportDataOperationMetadata",
        "dataset": "projects/data-labeling-codelab/datasets/5c73db3d_0000_23e0_a25b_94eb2c119c4c"
      }
    }
    

Python

Für dieses Codebeispiel müssen die Python-Clientbibliotheken installiert sein.

def import_data(dataset_resource_name, data_type, input_gcs_uri):
    """Imports data to the given Google Cloud project and dataset."""
    from google.cloud import datalabeling_v1beta1 as datalabeling

    client = datalabeling.DataLabelingServiceClient()

    gcs_source = datalabeling.GcsSource(input_uri=input_gcs_uri, mime_type="text/csv")

    csv_input_config = datalabeling.InputConfig(
        data_type=data_type, gcs_source=gcs_source
    )

    response = client.import_data(
        request={"name": dataset_resource_name, "input_config": csv_input_config}
    )

    result = response.result()

    # The format of resource name:
    # project_id/{project_id}/datasets/{dataset_id}
    print("Dataset resource name: {}\n".format(result.dataset))

    return result

Java

Für dieses Codebeispiel müssen die Java-Clientbibliotheken installiert sein.
import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceClient;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceSettings;
import com.google.cloud.datalabeling.v1beta1.DataType;
import com.google.cloud.datalabeling.v1beta1.GcsSource;
import com.google.cloud.datalabeling.v1beta1.ImportDataOperationMetadata;
import com.google.cloud.datalabeling.v1beta1.ImportDataOperationResponse;
import com.google.cloud.datalabeling.v1beta1.ImportDataRequest;
import com.google.cloud.datalabeling.v1beta1.InputConfig;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class ImportData {

  // Import data to an existing dataset.
  static void importData(String datasetName, String gcsSourceUri) throws IOException {
    // String datasetName = DataLabelingServiceClient.formatDatasetName(
    //     "YOUR_PROJECT_ID", "YOUR_DATASETS_UUID");
    // String gcsSourceUri = "gs://YOUR_BUCKET_ID/path_to_data";

    DataLabelingServiceSettings settings =
        DataLabelingServiceSettings.newBuilder()
            .build();
    try (DataLabelingServiceClient dataLabelingServiceClient =
        DataLabelingServiceClient.create(settings)) {
      GcsSource gcsSource =
          GcsSource.newBuilder().setInputUri(gcsSourceUri).setMimeType("text/csv").build();

      InputConfig inputConfig =
          InputConfig.newBuilder()
              .setDataType(DataType.IMAGE) // DataTypes: AUDIO, IMAGE, VIDEO, TEXT
              .setGcsSource(gcsSource)
              .build();

      ImportDataRequest importDataRequest =
          ImportDataRequest.newBuilder().setName(datasetName).setInputConfig(inputConfig).build();

      OperationFuture<ImportDataOperationResponse, ImportDataOperationMetadata> operation =
          dataLabelingServiceClient.importDataAsync(importDataRequest);

      ImportDataOperationResponse response = operation.get();

      System.out.format("Imported items: %d\n", response.getImportCount());
    } catch (IOException | InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
  }
}

Datenelemente im Dataset anzeigen lassen

So lassen Sie sich die Datenelemente in einem importierten Dataset anzeigen:

  1. Rufen Sie die Data Labeling Service-UI auf.

    Auf der Seite Datasets werden Data Labeling Service-Datasets für das aktuelle Projekt angezeigt.

  2. Klicken Sie in der Liste der Datasets auf den Namen des Datasets, dessen Elemente Sie anzeigen lassen möchten.

  3. Über den Tab Details der Seite Dataset-Details können Sie sich die einzelnen Datenelemente anzeigen lassen, die im Dataset enthalten sind.