Data Labeling anfordern

Die Qualität der Trainingsdaten beeinflusst stark die Effizienz des von Ihnen erstellten Modells und folglich die Qualität der damit generierten Vorhersagen. Um hochwertige Trainingsdaten zu erhalten, benötigen Sie Trainingselemente, die die Domain korrekt darstellen, zu der Sie Vorhersagen treffen möchten. Außerdem müssen die Trainingselemente mit den richtigen Labels versehen werden.

Es gibt drei Möglichkeiten, Ihren Trainingsdatenelementen Labels zuzuweisen:

  • Fügen Sie Ihrem Dataset die Datenelemente mit bereits zugewiesenen Labels hinzu, beispielsweise mit einem kommerziell verfügbaren Dataset.
  • Weisen Sie den Datenelementen mithilfe der Console Labels zu.
  • Labels werden von menschlichen Labelerstellern zu den Datenelementen hinzugefügt.

Daten-Labeling-Aufgaben von Vertex AI ermöglichen die Zusammenarbeit mit menschlichen Labelerstellern, um hochpräzise Labels für eine Sammlung von Daten zu generieren, mit denen Sie Ihre Modelle für maschinelles Lernen trainieren können.

Um das Daten-Labeling durch menschliche Labelersteller anzufordern, müssen Sie einen Daten-Labeling-Job erstellen, der den menschlichen Labelerstellern folgende Informationen zur Verfügung stellt:

  • Das Dataset mit den repräsentativen Datenelementen, die mit Labels versehen werden sollen
  • Eine Liste aller möglichen Labels, die auf die Datenelemente angewendet werden
  • Eine PDF-Datei mit Anleitung, die menschliche Labelersteller durch die Labeling-Aufgaben führt

Mit diesen Ressourcen annotieren die menschlichen Labelersteller die Elemente im Dataset gemäß Ihrer Anleitung. Wenn diese abgeschlossen sind, können Sie das Anmerkungssatz verwenden, um ein Vertex-KI-Modell zu trainieren oder die mit Labels versehenen Datenelemente zur Verwendung in einer anderen ML-Umgebung zu exportieren.

Dataset erstellen

Sie geben den menschlichen Labelerstellern die Datenelemente, die mit Labels versehen werden sollen, durch Erstellen eines Datasets und Importieren von Datenelementen. Die Datenelemente dürfen nicht mit einem Label versehen sein. Der Datentyp (Bild, Video oder Text) und das Ziel (z. B. Klassifizierung oder Objekt-Tracking) bestimmen die Art der Annotationen, die von menschlichen Labelerstellern auf die Datenelemente angewendet werden.

Labels angeben

Wenn Sie eine Daten-Labeling-Aufgabe erstellen, listen Sie die Gruppe von Labels auf, die von den menschlichen Labelerstellern mit den Labels versehen werden sollen. Wenn Sie Bilder beispielsweise anhand der Kriterien Hund oder Katze klassifizieren möchten, erstellen Sie einen Labelsatz mit zwei Labels: "Hund" und "Katze". Wie unten erwähnt, können Sie auch Labels für "Keine" und "Beide" verwenden.

Hier finden Sie einige Richtlinien zur Erstellung eines hochwertigen Labelsatzes.

  • Benennen Sie jedes Label mit einem aussagekräftigen Begriff, z. B. "Hund", "Katze" oder "Gebäude". Verwenden Sie keine abstrakten Namen wie "label1" und "label2" oder unbekannte Akronyme. Je aussagekräftiger die Labelnamen sind, desto einfacher ist es für menschliche Labelersteller, sie exakt und konsistent anzuwenden.
  • Achten Sie darauf, dass die Labels leicht voneinander zu unterscheiden sind. Für Klassifizierungsaufgaben, bei denen auf jedes Datenelement immer ein Label abgewendet wird, sollte die Bedeutung der Labels klar voneinander abgegrenzt sein. Sie können beispielsweise keine Labels für "Sport" und "Baseball" haben.
  • Bei Klassifizierungsaufgaben ist es in der Regel sinnvoll, ein Label mit dem Namen "Sonstiges" oder "Keines" einzufügen. Dieses Label kann dann für Daten verwendet werden, für die kein anderes Label zutrifft. Wenn die einzigen verfügbaren Labels beispielsweise "Hund" und "Katze" sind, müssen Labelersteller jedes Bild mit einem dieser Labels kennzeichnen. Ihr benutzerdefiniertes Modell wird in der Regel robuster, wenn Sie in einem solchen Fall Bilder mit anderen Inhalten als nur Hunde oder Katzen in die Trainingsdaten aufnehmen.
  • Beachten Sie, dass für eine effiziente und präzise Labelerstellung nicht mehr als 20 Labels im Labelsatz enthalten sein sollten. Sie können bis zu 100 Labels einfügen

Anleitung erstellen

Eine Anleitung stellt dem menschlichen Labelersteller Informationen darüber zur Verfügung, wie er Ihre Daten mit Labels kennzeichnen soll. Die Anleitung sollte Beispiele für Daten mit Labels und andere explizite Hinweise enthalten.

Eine Anleitung ist eine PDF-Datei. PDF-Anleitungen können komplexe Hinweise wie positive und negative Beispiele oder Beschreibungen für jeden Fall enthalten. PDF ist auch ein praktisches Format, um Anleitungen für komplizierte Aufgaben wie Bildbegrenzungsrahmen oder Videoobjekt-Tracking bereitzustellen.

Schreiben Sie die Anleitung, erstellen Sie eine PDF-Datei und speichern Sie die PDF-Datei in Ihrem Google Cloud Storage-Bucket.

Effektive Anleitungen bereitstellen

Eine effektive Anleitung ist der wichtigste Faktor für zufriedenstellende Ergebnisse bei der menschlichen Labelerstellung. Da Sie Ihren Anwendungsfall am besten kennen, müssen Sie den menschlichen Labelerstellern mitteilen, was sie tun sollen. Hier finden Sie einige Richtlinien für die Erstellung einer effektiven Anleitung:

  • Die menschlichen Labelersteller haben nicht Ihre Kenntnisse in Ihrem Fachgebiet. Die Unterscheidungen, die Labelersteller treffen sollen, müssen deshalb auch für Personen verständlich sein, die nicht mit Ihrem Anwendungsfall vertraut sind.

  • Vermeiden Sie zu lange Anleitungen. Am besten ist es, wenn ein Labelersteller sie innerhalb von 20 Minuten lesen und verstehen kann.

  • In der Anleitung sollte das Konzept der Aufgabe beschrieben und im Detail angegeben werden, wie die Daten mit Labels versehen werden sollen. Beispiel: Bei einer Aufgabe für Begrenzungsrahmen müssen Sie beschreiben, wie der Labelersteller einen Begrenzungsrahmen zeichnen soll. Soll es sich um einen engen oder um einen mit Abstand gezogenen Rahmen handeln? Wenn es mehrere Exemplare des Objekts gibt, sollte derjenige einen großen Begrenzungsrahmen oder mehrere kleinere Rahmen zeichnen?

  • Wenn Ihre Anleitungen einen entsprechenden Labelsatz enthalten, sollten alle Labels in diesem Satz behandelt werden. Der Labelname in der Anleitung sollte mit dem Namen im Labelsatz übereinstimmen.

  • Oft sind mehrere Wiederholungen für das Erstellen einer effektiven Anleitung erforderlich. Wir empfehlen, menschlichen Labelerstellern zuerst ein kleines Dataset zur Verfügung zu stellen und die Anleitung dann basierend darauf anzupassen, wie gut die Arbeit der Labelersteller Ihre Erwartungen erfüllt.

Eine effektive Anleitung sollte die folgenden Abschnitte enthalten:

  • Labelliste und -beschreibung: Listen Sie alle Labels auf, die Sie verwenden möchten, und beschreiben Sie die Bedeutung der einzelnen Labels.
  • Beispiele: Geben Sie für jedes Label mindestens drei positive Beispiele und ein negatives Beispiel an. Die Beispiele sollten verschiedene Fälle abdecken.
  • Beziehen Sie Grenzfälle ein. Klären Sie möglichst viele Randfälle, sodass der Labelersteller die Labels nicht mehr interpretieren muss. Wenn beispielsweise ein Begrenzungsrahmen um eine Person gezeichnet werden soll, ist es besser, vorab Folgendes zu klären:
    • Benötigen Sie, wenn es mehrere Personen gibt, für jede Person einen eigenen Rahmen?
    • Benötigen Sie einen Rahmen, wenn eine Person verdeckt ist?
    • Benötigen Sie einen Rahmen für eine Person, die nur teilweise im Bild zu sehen ist?
    • Benötigen Sie einen Rahmen für eine Person auf einer Abbildung oder auf einem Gemälde?
  • Beschreiben Sie, wie Annotationen hinzugefügt werden sollen. Beispiel:
    • Benötigen Sie einen eng oder einen mit Abstand gezogenen Begrenzungsrahmen?
    • Wo beginnt bei der Extraktion von Textentitäten die jeweilige Entität und wo endet sie?
  • Klarstellung zu Labels: Wenn zwei Labels ähnlich oder leicht zu verwechseln sind, geben Sie Beispiele an, die den Unterschied verdeutlichen.

Die folgenden Beispiele zeigen, was in PDF-Anleitungen enthalten sein kann. Labelersteller prüfen die Anleitung, bevor sie mit der Aufgabe beginnen.

PDF-Anleitung 1

PDF-Anleitung 2

Daten-Labeling-Aufgabe erstellen

Web-UI

Sie können Datenlabels in der Google Cloud Console an zwei Stellen anfordern:

  • Klicken Sie im Bildschirm "Dataset-Detail" auf Labeling-Aufgabe erstellen.
  • Klicken Sie in der Liste Labeling-Aufgaben auf Erstellen.

Der Bereich Neue Labeling-Aufgabe wird geöffnet.

  1. Geben Sie einen Namen für die Labeling-Aufgabe ein.

  2. Wählen Sie das Dataset aus, dessen Elemente Sie mit einem Label versehen möchten.

    Wenn Sie den Bereich Neue Labeling-Aufgabe im Bildschirm mit den Dataset-Details geöffnet haben, können Sie kein anderes Dataset auswählen.

  3. Prüfen Sie, ob das Ziel korrekt ist.

    Das Feld Ziel zeigt das Ziel für das ausgewählte Dataset, wie es durch den zugehörigen Standardannotationssatz festgelegt ist. Wählen Sie einen anderen Annotationssatz aus, um das Ziel zu ändern.

  4. Wählen Sie den Annotationssatz aus, der für die mit Labels versehenen Daten verwendet werden soll.

    Die von menschlichen Labelerstellern angewendeten Labels werden im ausgewählten Annotationssatz gespeichert. Sie können einen vorhandenen Annotationsssatz auswählen oder einen neuen erstellen. Wenn Sie ein neues Konto erstellen, müssen Sie einen Namen dafür angeben.

  5. Geben Sie an, ob Sie aktives Lernen verwenden möchten.

    Aktives Lernen beschleunigt den Labeling-Prozess, da Daten teilweise von menschlichen Labelerstellern gekennzeichnet werden und dann maschinelles Lernen angewendet wird, um den Rest automatisch mit Labeln zu versehen.

    HINWEIS: Aktives Lernen ist nur für die Ziele Bildklassifizierung (einzelnes Label) und Image-Begrenzungsrahmen verfügbar.

  6. Klicken Sie auf Weiter.

  7. Geben Sie die Labels ein, die von menschlichen Labelerstellern angewendet werden sollen, und klicken Sie auf Weiter.

    Unter Labelsatz entwerfen finden Sie Richtlinien zum Erstellen eines hochwertigen Satz Labels.

  8. Geben Sie den Pfad zur Anleitung für die menschlichen Labelersteller ein und klicken Sie auf Weiter.

    Die Anleitung muss eine PDF-Datei sein, die in einem Google Cloud Storage-Bucket gespeichert ist. Anleitungen zum Erstellen hochwertiger Anweisungen finden Sie unter Anleitungen für menschliche Labelersteller erstellen.

  9. Wählen Sie aus, ob Sie von Google verwaltete Labelersteller verwenden oder Ihre eigenen Labelersteller bereitstellen möchten.

    Wenn Sie eigene Labelersteller bereitstellen möchten, müssen Sie Labelerstellergruppen erstellen und ihre Aktivitäten mit der DataCompute Console verwalten.

  10. Geben Sie an, wie viele Labelersteller die einzelnen Elemente prüfen sollen.

    Standardmäßig annotiert ein menschlicher Labelersteller jedes Datenelement. Sie können auch festlegen, dass mehrere Labelersteller die einzelnen Elemente mit Anmerkungen versehen und überprüfen sollen. Wählen Sie aus dem Feld Spezialisten pro Datenelement die Anzahl der Labelersteller aus.

  11. Wenn Sie von Google verwaltete Labelersteller verwenden, klicken Sie auf das Kästchen, um zu bestätigen, dass Sie die Preisanleitung mit den Kosten für die Labelerstellung gelesen haben.

  12. Wenn Sie eigene Labelersteller bereitstellen möchten, wählen Sie die für diese Labelaufgabe zu verwendende Labelerstellergruppe aus.

    Wählen Sie eine vorhandene Labelerstellergruppe aus der Drop-down-Liste aus oder wählen Sie Neue Labelerstellergruppe aus und geben Sie einen Gruppennamen und eine durch Kommas getrennte Liste von E-Mail-Adressen für die Manager der Gruppe in die Textfelder unterhalb der Drop-down-Liste ein. Klicken Sie auf das Kästchen, um den angegebenen Managern die Berechtigung zum Ansehen der Daten-Labeling-Informationen zu gewähren.

  13. Klicken Sie auf Aufgabe starten.

    Wenn Aufgabe starten nicht verfügbar ist, prüfen Sie auf den Seiten im Bereich Neue Labeling-Aufgabe, ob Sie alle erforderlichen Informationen eingegeben haben.

Sie können den Fortschritt der Aufgabe zur Labelerstellung für Daten prüfen, indem Sie in der Console Labeling-Aufgaben auswählen. Auf der Seite wird der Status jeder angeforderten Labeling-Aufgabe angezeigt. Wenn in der Spalte Fortschritt 100 % angezeigt wird, erhält das entsprechende Dataset ein Label und kann zum Trainieren eines Modells verwendet werden.

REST UND BEFEHLSZEILE

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • PROJECT_ID: Ihre Projekt-ID
  • DISPLAY_NAME: Name für den Daten-Labeling-Job
  • DATASET_ID: ID des Datasets, das die Elemente für das Label enthält
  • LABELERS: Die Anzahl der menschlichen Labelersteller, die jedes Datenelement prüfen sollen. Gültige Werte sind 1, 3 und 5.
  • INSTRUCTIONS: Der Pfad zur PDF-Datei, die die Anleitung für die menschlichen Labelersteller enthält. Die Datei muss sich in einem Google Cloud Storage-Bucket befinden, auf den von Ihrem Projekt aus zugegriffen werden kann.
  • INPUT_SCHEMA_URI: Pfad zur Schemadatei für den Datenelementtyp:
    • Bildklassifizierung (ein Label):
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_classification_single_label_io_format_1.0.0.yaml
    • Bildklassifizierung (mehrere Labels):
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_classification_multi_label_io_format_1.0.0.yaml
    • Objekterkennung in Bildern:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_bounding_box_io_format_1.0.0.yaml
    • Textklassifizierung (ein Label):
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_classification_single_label_io_format_1.0.0.yaml
    • Textklassifizierung (mehrere Labels):
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_classification_multi_label_io_format_1.0.0.yaml
    • Extraktion der Textentität:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_extraction_io_format_1.0.0.yaml
    • Textsentimentanalyse:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_sentiment_io_format_1.0.0.yaml
    • Videoklassifizierung:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/video_classification_io_format_1.0.0.yaml
    • Videoobjekt-Tracking:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/video_object_tracking_io_format_1.0.0.yaml
  • LABEL_LIST: Eine durch Kommas getrennte Liste von Strings, in der die verfügbaren Labels zur Anwendung auf ein Datenelement aufgezählt werden
  • ANNOTATION_SET: Der Name des Annotationssatzes für die mit Labels versehenen Daten

HTTP-Methode und URL:

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/dataLabelingJobs

JSON-Text anfordern:

{
   "displayName":"DISPLAY_NAME",
   "datasets":"DATASET_ID",
   "labelerCount":LABELERS,
   "instructionUri":"INSTRUCTIONS",
   "inputsSchemaUri":"INPUT_SCHEMA_URI",
   "inputs": {
     "annotation_specs": [LABEL_LIST]
   },
   "annotationLabels": {
     "aiplatform.googleapis.com/annotation_set_name": "ANNOTATION_SET"
   }
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie müssten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/us-central1/dataLabelingJobs/JOB_ID",
  "displayName": "DISPLAY_NAME",
  "datasets": [
    "DATASET_ID"
  ],
  "labelerCount": LABELERS,
  "instructionUri": "INSTRUCTIONS",
  "inputsSchemaUri": "INPUT_SCHEMA_URI",
  "inputs": {
    "annotationSpecs": [
      LABEL_LIST
    ]
  },
  "state": "JOB_STATE_PENDING",
  "labelingProgress": "0",
  "createTime": "2020-05-30T23:13:49.121133Z",
  "updateTime": "2020-05-30T23:13:49.121133Z",
  "savedQuery": {
    "name": "projects/PROJECT_ID/locations/us-central1/datasets/DATASET_ID/savedQueries/ANNOTATION_SET_ID"
  },
  "annotationSpecCount": 2
}
Die Antwort ist ein DataLabelingJob. Sie können den Fortschritt des Jobs prüfen. Überwachen Sie dazu das Element "labelingProgress", dessen Wert der abgeschlossene Prozentsatz ist.

Java

Zusätzliche Codebeispiele:


import com.google.cloud.aiplatform.v1.DataLabelingJob;
import com.google.cloud.aiplatform.v1.DatasetName;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import com.google.type.Money;
import java.io.IOException;
import java.util.Map;

public class CreateDataLabelingJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String displayName = "YOUR_DATA_LABELING_DISPLAY_NAME";
    String datasetId = "YOUR_DATASET_ID";
    String instructionUri =
        "gs://YOUR_GCS_SOURCE_BUCKET/path_to_your_data_labeling_source/file.pdf";
    String inputsSchemaUri = "YOUR_INPUT_SCHEMA_URI";
    String annotationSpec = "YOUR_ANNOTATION_SPEC";
    createDataLabelingJob(
        project, displayName, datasetId, instructionUri, inputsSchemaUri, annotationSpec);
  }

  static void createDataLabelingJob(
      String project,
      String displayName,
      String datasetId,
      String instructionUri,
      String inputsSchemaUri,
      String annotationSpec)
      throws IOException {
    JobServiceSettings jobServiceSettings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient jobServiceClient = JobServiceClient.create(jobServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);

      String jsonString = "{\"annotation_specs\": [ " + annotationSpec + "]}";
      Value.Builder annotationSpecValue = Value.newBuilder();
      JsonFormat.parser().merge(jsonString, annotationSpecValue);

      DatasetName datasetName = DatasetName.of(project, location, datasetId);
      DataLabelingJob dataLabelingJob =
          DataLabelingJob.newBuilder()
              .setDisplayName(displayName)
              .setLabelerCount(1)
              .setInstructionUri(instructionUri)
              .setInputsSchemaUri(inputsSchemaUri)
              .addDatasets(datasetName.toString())
              .setInputs(annotationSpecValue)
              .putAnnotationLabels(
                  "aiplatform.googleapis.com/annotation_set_name", "my_test_saved_query")
              .build();

      DataLabelingJob dataLabelingJobResponse =
          jobServiceClient.createDataLabelingJob(locationName, dataLabelingJob);

      System.out.println("Create Data Labeling Job Response");
      System.out.format("\tName: %s\n", dataLabelingJobResponse.getName());
      System.out.format("\tDisplay Name: %s\n", dataLabelingJobResponse.getDisplayName());
      System.out.format("\tDatasets: %s\n", dataLabelingJobResponse.getDatasetsList());
      System.out.format("\tLabeler Count: %s\n", dataLabelingJobResponse.getLabelerCount());
      System.out.format("\tInstruction Uri: %s\n", dataLabelingJobResponse.getInstructionUri());
      System.out.format("\tInputs Schema Uri: %s\n", dataLabelingJobResponse.getInputsSchemaUri());
      System.out.format("\tInputs: %s\n", dataLabelingJobResponse.getInputs());
      System.out.format("\tState: %s\n", dataLabelingJobResponse.getState());
      System.out.format("\tLabeling Progress: %s\n", dataLabelingJobResponse.getLabelingProgress());
      System.out.format("\tCreate Time: %s\n", dataLabelingJobResponse.getCreateTime());
      System.out.format("\tUpdate Time: %s\n", dataLabelingJobResponse.getUpdateTime());
      System.out.format("\tLabels: %s\n", dataLabelingJobResponse.getLabelsMap());
      System.out.format(
          "\tSpecialist Pools: %s\n", dataLabelingJobResponse.getSpecialistPoolsList());
      for (Map.Entry<String, String> annotationLabelMap :
          dataLabelingJobResponse.getAnnotationLabelsMap().entrySet()) {
        System.out.println("\tAnnotation Level");
        System.out.format("\t\tkey: %s\n", annotationLabelMap.getKey());
        System.out.format("\t\tvalue: %s\n", annotationLabelMap.getValue());
      }
      Money money = dataLabelingJobResponse.getCurrentSpend();

      System.out.println("\tCurrent Spend");
      System.out.format("\t\tCurrency Code: %s\n", money.getCurrencyCode());
      System.out.format("\t\tUnits: %s\n", money.getUnits());
      System.out.format("\t\tNanos: %s\n", money.getNanos());
    }
  }
}

Python

Zusätzliche Codebeispiele:

from google.cloud import aiplatform
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value

def create_data_labeling_job_sample(
    project: str,
    display_name: str,
    dataset_name: str,
    instruction_uri: str,
    inputs_schema_uri: str,
    annotation_spec: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.JobServiceClient(client_options=client_options)
    inputs_dict = {"annotation_specs": [annotation_spec]}
    inputs = json_format.ParseDict(inputs_dict, Value())

    data_labeling_job = {
        "display_name": display_name,
        # Full resource name: projects/{project_id}/locations/{location}/datasets/{dataset_id}
        "datasets": [dataset_name],
        # labeler_count must be 1, 3, or 5
        "labeler_count": 1,
        "instruction_uri": instruction_uri,
        "inputs_schema_uri": inputs_schema_uri,
        "inputs": inputs,
        "annotation_labels": {
            "aiplatform.googleapis.com/annotation_set_name": "my_test_saved_query"
        },
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_data_labeling_job(
        parent=parent, data_labeling_job=data_labeling_job
    )
    print("response:", response)

HINWEIS: Die maximale Bearbeitungszeit für einen Daten-Labeling-Job beträgt 63 Tage. Wenn er nicht innerhalb dieser Zeit abgeschlossen wird, läuft der Job ab und wird zusammen mit den Aufgaben gelöscht, die Labelersteller zugewiesen sind.

Nächste Schritte