Diese Legacy-Version von AutoML Video Intelligence wurde eingestellt und ist nach dem 23. Januar 2024 nicht mehr in Google Cloud verfügbar. Alle Funktionen des alten AutoML Video Intelligence sowie neue Funktionen sind auf der Vertex AI-Plattform verfügbar. Informationen zum Migrieren Ihrer Ressourcen finden Sie unter Zu Vertex AI migrieren.

Objekte in Videos verfolgen

Nachdem Sie ein Modell erstellt (trainiert) haben, können Sie mit der Methode batchPredict eine Vorhersageanfrage für ein oder mehrere Videos senden. Stellen Sie für die Methode batchPredict eine CSV-Datei mit einer Liste von Videos bereit. Die Methode batchPredict annotiert Videos, indem sie Objekte erkennt und beobachtet, die Ihr Modell vorhersagt.

Ein Modell hat eine Lebensdauer von höchstens zwei Jahren. Nach zwei Jahren müssen Sie ein neues Modell erstellen und trainieren, um Ihre Videos weiterhin annotieren zu können.

Beispiele zu Vorhersagen

Um einen Satz von Vorhersagen von AutoML Video Object Tracking anzufordern, erstellen Sie eine CSV-Datei mit den Cloud Storage-Pfaden zu den Videos, die Sie annotieren möchten. Sie können auch eine Start- und Endzeit angeben, damit AutoML Video Object Tracking nur ein Segment des Videos annotiert. Die Startzeit muss null oder größer sein und vor der Endzeit liegen. Die Endzeit muss größer als die Startzeit und kleiner oder gleich der Dauer des Videos sein.

Im folgenden Beispiel wird gezeigt, wie Sie ein vollständiges Video annotieren. Dazu geben Sie eine Start- und Endzeit als 0,inf an.

gs://my-videos-vcm/cow_video.mp4,0,inf
gs://my-videos-vcm/bird_video.mp4,10.00000,15.50000

Sie müssen außerdem einen Ausgabedateipfad angeben, in den das AutoML Video-Objekt-Tracking die Ergebnisse der Vorhersagen aus Ihrem Modell schreiben soll. Dieser Pfad muss ein Cloud Storage-Bucket und ein Objekt sein, für das Sie Schreibberechtigungen haben.

Jedes Video kann eine Dauer von bis zu 3 Stunden haben. Die maximale Dateigröße beträgt 50 GB. Das AutoML Video-Objekt-Tracking kann Vorhersagen für etwa 100 Stunden Videomaterial in 12 Stunden Verarbeitungszeit generieren.

Web-UI

Öffnen Sie die AutoML Video Object Tracking-UI.
Klicken Sie in der angezeigten Liste auf das Modell, das Sie verwenden möchten.
Führen Sie auf dem Tab Test & Use (Test und Nutzung) des Modells die folgenden Schritte aus:
- Wählen Sie unter Modell testen eine CSV-Datei aus, die für die Vorhersage verwendet werden soll. Die CSV-Datei muss eine Liste mit Videos enthalten, die Sie annotieren möchten.
- Wählen Sie außerdem unter Test your model (Modell testen) ein Verzeichnis in Ihrem Cloud Storage-Bucket aus, in dem die Anmerkungsergebnisse gespeichert werden sollen.
  
  Sie können in Ihrem Cloud Storage-Bucket einen Ordner "Ergebnisse" erstellen, in dem die Anmerkungsergebnisse gespeichert werden.
- Klicken Sie auf Vorhersagen abrufen.

Der Vorgang zum Abrufen von Vorhersagen kann je nach Anzahl der Videos, die Sie mit Anmerkungen versehen möchten, einige Zeit in Anspruch nehmen.

Wenn der Vorgang abgeschlossen ist, werden die Ergebnisse auf der Seite für das Modell unter Aktuelle Vorhersagen angezeigt. Führen Sie folgende Schritte aus, um die Ergebnisse aufzurufen:

Klicken Sie unter Aktuelle Vorhersagen in der Spalte Vorhersagen auf Ansehen für die Vorhersage, die Sie ansehen möchten.
Wählen Sie unter Video den Namen des Videos aus, für das Sie die Ergebnisse aufrufen möchten.

REST

Bevor Sie die Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

model-id: Ersetzen Sie diesen Wert durch die ID Ihres Modells. Die ID ist das letzte Element des Modellnamens. Wenn das Modell beispielsweise den Namen projects/project-number/locations/location-id/models/VOT6312181905852727296 hat, lautet die Modell-ID VOT6312181905852727296.
request-id: Weisen Sie diesem Feld einen beliebigen digitalen Wert zu.
Ersetzen Sie bucket-name durch den Namen des Cloud Storage-Buckets. Beispiel: my-project-vcm
input-file: Ersetzen Sie diesen Wert durch den Namen der CSV-Datei, in der die zu annotierenden Videos angegeben sind.
output-storage-path: Ersetzen Sie den Pfad zum Cloud Storage-Bucket, in dem die Ausgabe der Vorhersagen gespeichert werden soll. AutoML Video Object Tracking erstellt einen Unterordner für die Ergebnisse in diesem Pfad mit dem folgenden Format: prediction-model_name-timestamp. In dem Unterordner wird für jedes Video in der Batchanfrage jeweils eine Vorhersagedatei erstellt. Sie benötigen Schreibberechtigungen für diesen Pfad.
Hinweis:
- project-number: Nummer Ihres Projekts
- location-id: Die Cloud-Region, in der die Annotation erfolgen soll. Unterstützte Cloud-Regionen sind: us-east1, us-west1, europe-west1, asia-east1. Wenn keine Region angegeben ist, wird eine Region basierend auf dem Speicherort der Videodatei festgelegt.

HTTP-Methode und URL:

POST https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/models/model-id:batchPredict

JSON-Text der Anfrage:

{
  "request_id": "request-id",
  "inputConfig": {
    "gcsSource": {
      "inputUris": ["gs://bucket-name/input-file.csv"]
    }
  },
  "outputConfig": {
    "gcsDestination": {
      "outputUriPrefix": "gs://output-storage-path"
    }
  },
  "params": {
    "score_threshold": "0.0"
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud CLI angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch in der gcloud CLI anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: project-number" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/models/model-id:batchPredict"

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-number" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/models/model-id:batchPredict" | Select-Object -Expand Content

Sie sollten eine Vorgangs-ID für das Modelltraining erhalten. Das folgende Beispiel zeigt eine Antwort, die die Vorgangs-ID des Modelltrainings VOT1741767155885539328 enthält.

Antwort

{
  "name": "projects/project-number/locations/location-id/operations/VOT1741767155885539328",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2020-02-18T21:32:06.730258Z",
    "updateTime": "2020-02-18T21:32:06.730258Z",
    "createModelDetails": {}
  }
}

Java

Zur Authentifizierung bei AutoML Video Object Tracking richten Sie Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1beta1.BatchPredictInputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictOutputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictRequest;
import com.google.cloud.automl.v1beta1.BatchPredictResult;
import com.google.cloud.automl.v1beta1.GcsDestination;
import com.google.cloud.automl.v1beta1.GcsSource;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.OperationMetadata;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

abstract class BatchPredict {

  static void batchPredict() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String inputUri = "gs://YOUR_BUCKET_ID/path_to_your_input_csv_or_jsonl";
    String outputUri = "gs://YOUR_BUCKET_ID/path_to_save_results/";
    batchPredict(projectId, modelId, inputUri, outputUri);
  }

  static void batchPredict(String projectId, String modelId, String inputUri, String outputUri)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      // Configure the source of the file from a GCS bucket
      GcsSource gcsSource = GcsSource.newBuilder().addInputUris(inputUri).build();
      BatchPredictInputConfig inputConfig =
          BatchPredictInputConfig.newBuilder().setGcsSource(gcsSource).build();

      // Configure where to store the output in a GCS bucket
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(outputUri).build();
      BatchPredictOutputConfig outputConfig =
          BatchPredictOutputConfig.newBuilder().setGcsDestination(gcsDestination).build();

      // Build the request that will be sent to the API
      BatchPredictRequest request =
          BatchPredictRequest.newBuilder()
              .setName(name.toString())
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();

      // Start an asynchronous request
      OperationFuture<BatchPredictResult, OperationMetadata> future =
          client.batchPredictAsync(request);

      System.out.println("Waiting for operation to complete...");
      future.get();
      System.out.println("Batch Prediction results saved to specified Cloud Storage bucket.");
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';
// const inputUri = 'gs://YOUR_BUCKET_ID/path_to_your_input_csv_or_jsonl';
// const outputUri = 'gs://YOUR_BUCKET_ID/path_to_save_results/';

// Imports the Google Cloud AutoML library
const {PredictionServiceClient} = require('@google-cloud/automl').v1beta1;

// Instantiates a client
const client = new PredictionServiceClient();

async function batchPredict() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
    inputConfig: {
      gcsSource: {
        inputUris: [inputUri],
      },
    },
    outputConfig: {
      gcsDestination: {
        outputUriPrefix: outputUri,
      },
    },
  };

  const [operation] = await client.batchPredict(request);

  console.log('Waiting for operation to complete...');
  // Wait for operation to complete.
  const [response] = await operation.promise();
  console.log(
    `Batch Prediction results saved to Cloud Storage bucket. ${response}`
  );
}

batchPredict();

Python

from google.cloud import automl_v1beta1 as automl

def batch_predict(
    project_id="YOUR_PROJECT_ID",
    model_id="YOUR_MODEL_ID",
    input_uri="gs://YOUR_BUCKET_ID/path/to/your/input/csv_or_jsonl",
    output_uri="gs://YOUR_BUCKET_ID/path/to/save/results/",
):
    """Batch predict"""
    prediction_client = automl.PredictionServiceClient()

    # Get the full path of the model.
    model_full_id = automl.AutoMlClient.model_path(project_id, "us-central1", model_id)

    gcs_source = automl.GcsSource(input_uris=[input_uri])

    input_config = automl.BatchPredictInputConfig(gcs_source=gcs_source)
    gcs_destination = automl.GcsDestination(output_uri_prefix=output_uri)
    output_config = automl.BatchPredictOutputConfig(gcs_destination=gcs_destination)
    params = {}

    request = automl.BatchPredictRequest(
        name=model_full_id,
        input_config=input_config,
        output_config=output_config,
        params=params,
    )
    response = prediction_client.batch_predict(request=request)

    print("Waiting for operation to complete...")
    print(
        "Batch Prediction results saved to Cloud Storage bucket. {}".format(
            response.result()
        )
    )

Status des Vorhersagevorgangs abfragen

Sie können den Status Ihres Batchvorhersagevorgangs mit den folgenden curl- oder PowerShell-Befehlen abfragen.

REST

Bevor Sie die Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

project-number: Die Nummer Ihres Projekts
location-id: Die Cloud-Region, in der die Annotation stattfinden soll. Unterstützte Cloud-Regionen sind: us-east1, us-west1, europe-west1, asia-east1. Wenn keine Region angegeben ist, wird eine Region basierend auf dem Speicherort der Videodatei festgelegt.
operation-id: Die ID des lang andauernden Vorgangs, der für die Anfrage erstellt und in der Antwort beim Start des Vorgangs angegeben wurde, z. B. VOT12345....

HTTP-Methode und URL:

GET https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/operations/operation-id

Senden Sie die Anfrage mithilfe einer der folgenden Optionen:

curl

Führen Sie folgenden Befehl aus:

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: project-number" \
    "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/operations/operation-id"

PowerShell

Führen Sie folgenden Befehl aus:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-number" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/operations/operation-id" | Select-Object -Expand Content

operation-name ist der Name des Vorgangs, der von der AutoML Video Intelligence Object Tracking API zurückgegeben wird. Der Vorgangsname hat das Format projects/project-number/locations/location-id/operations/operation-id

Antwort

{
  "name": "operation-name",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2020-02-18T21:23:15.181451Z",
    "updateTime": "2020-02-18T21:26:10.354502Z",
    "importDataDetails": {}
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.protobuf.Empty"
  }
}

Wenn die Batchvorhersage abgeschlossen ist, wird die Ausgabe der Vorhersage in dem Cloud Storage-Speicherort gespeichert, den Sie in Ihrem Befehl angegeben haben. Für jedes Videosegment gibt es eine JSON-Datei. Die JSON-Dateien haben ein ähnliches Format wie my-video-01.avi.json, wobei die Dateiendung der Erweiterung .json an den ursprünglichen Dateinamen angehängt wird.

{
  "inputUris": ["automl-video-demo-data/sample_video.avi"],
  "object_annotations": [ {
    "annotation_spec": {
      "display_name": "Cat",
      "description": "Cat"
    },
    "confidence": 0.43253016
    "frames": [ {
      "frame": {
        "time_offset": {
          "seconds": 4,
          "nanos": 960000000
        },
        "normalized_bounding_box": {
          "x_min": 0.1,
          "y_min": 0.1,
          "x_max": 0.8,
          "y_max": 0.8
        }
      }
    }, {
      "frame": {
        "time_offset": {
          "seconds": 5,
          "nanos": 960000000
        },
        "normalized_bounding_box": {
          "x_min": 0.2,
          "y_min": 0.2,
          "x_max": 0.9,
          "y_max": 0.9
        }
      }
    } ],
    "segment": {
      "start_time_offset": {
          "seconds": 4,
          "nanos": 960000000
      },
      "end_time_offset": {
          "seconds": 5,
          "nanos": 960000000
      }
    }
  } ],
  "error": {
    "details": [ ]
  }
}