Videos annotieren

Nachdem Sie ein Modell trainiert haben, können Sie eine Vorhersage anfordern, indem Sie eine CSV-Datei für die Methode batchPredict angeben, in der Ihre Videos aufgeführt sind. Die Methode batchPredict wendet Labels auf der Grundlage von Vorhersagen an, die Ihr Modell stellt.

Ein benutzerdefiniertes Modell hat eine Lebensdauer von höchstens zwei Jahren. Anschließend müssen Sie ein neues Modell trainieren.

Beispiele zu Vorhersagen

Um eine Reihe von Vorhersagen von AutoML Video Classification 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 Classification nur ein Segment (Segmentebene) 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. Mit inf können Sie auch das Ende eines Videos angeben.

gs://my-videos-vcm/short_video_1.avi,0.0,5.566667
gs://my-videos-vcm/car_chase.avi,0.0,3.933333
gs://my-videos-vcm/northwest_wildlife_01.avi,0.0,3.7
gs://my-videos-vcm/northwest_wildlife_02.avi,0.0,1.666667
gs://my-videos-vcm/motorcycles_and_cars.avi,0.0,2.633333
gs://my-videos-vcm/drying_paint.avi,0.0,inf

Sie müssen außerdem einen Ausgabedateipfad angeben, in den AutoML Video Classification die Ergebnisse der Vorhersagen aus Ihrem Modell schreibt. 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 und darf maximal 50 GB groß sein. AutoML Video Classification kann Vorhersagen für ungefähr 100 Stunden Videomaterial in 12 Stunden Verarbeitungszeit generieren.

Wenn Sie eine Vorhersage für Ihre Videos anfordern, können Sie die folgenden Optionen im Abschnitt params festlegen. Wenn Sie keine dieser Optionen festlegen, wird der Standard-Schwellenwert angewendet und die segment_classification verwendet.

  • score_threshold (Schwellenwert) – Ein Wert von 0,0 (keine Konfidenz) bis 1,0 (sehr hohe Konfidenz). Wenn das Modell Vorhersagen für ein Video trifft, werden nur Ergebnisse erzeugt, die mindestens den von Ihnen angegebenen Konfidenzwert aufweisen. Der Standardwert für die API ist 0,5.

  • segment_classification – Setzen Sie den Wert auf "true", um die Klassifizierung auf Segmentebene zu aktivieren. AutoML Video Classification gibt dann Labels und deren Konfidenzwerte für das gesamte Segment des Videos zurück, das Sie in der Anfragekonfiguration angegeben haben. Die Standardeinstellung ist "true".

  • shot_classification – Setzen Sie den Wert auf "true", um die Klassifizierung auf Aufnahmeebene zu aktivieren. AutoML Video Classification bestimmt die Grenzen für jede Kameraaufnahme im gesamten Segment des Videos, das Sie in der Anfragekonfiguration angegeben haben. AutoML Video Intelligence gibt dann für jede erkannte Aufnahme Labels und deren Konfidenzwerte sowie die Start- und Endzeit der Aufnahme zurück. Der Standardwert ist "false".

  • 1s_interval_classification – Setzen Sie den Wert auf "true", um für ein Video die Klassifizierung im Sekundentakt zu aktivieren. AutoML Video Classification gibt dann für jede Sekunde des Videos, das Sie in der Anfragekonfiguration angegeben haben, Labels und zugehörige Konfidenzwerte zurück. Der Standardwert ist "false".

Web-UI

  1. Öffnen Sie die AutoML Video Classification-UI.
  2. Klicken Sie in der angezeigten Liste auf das benutzerdefinierte Modell, das Sie verwenden möchten. Liste der benutzerdefinierten AutoML Video Intelligence-Modelle in der Cloud Console
  3. Führen Sie auf dem Tab Test und Nutzung des Modells folgende 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 ebenfalls unter 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. Sie können dann leichter auf ältere Vorhersagen zugreifen. Laden Sie hierzu die im Ergebnisverzeichnis enthaltene Datei video_classification.csv.

    • Klicken Sie auf Vorhersagen abrufen.
    Vorhersageanfrage für AutoML Video Intelligence konfigurieren

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:

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

Ergebnisse der AutoML Video Intelligence-Vorhersage

REST UND BEFEHLSZEILE

Bevor Sie die unten aufgeführten Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

  • input-uri: Ein Cloud Storage-Bucket, der die Datei enthält, die Sie annotieren möchten, einschließlich des Dateinamens. Muss mit gs:// beginnen. Beispiel:
    "inputUris": ["gs://automl-video-demo-data/hmdb_split1_test_gs_predict.csv"]
  • Ersetzen Sie output-bucket durch den Namen des Cloud Storage-Buckets. Beispiel: my-project-vcm
  • object-id: Ersetzen Sie diesen Wert durch die Vorgangs-ID für den Importvorgang.
  • 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:

{
  "inputConfig": {
    "gcsSource": {
      "inputUris": [input-uri]
    }
  },
  "outputConfig": {
    "gcsDestination": {
      "outputUriPrefix": "gs://output-bucket/object-id"
    }
  }
}

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

curl

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 application-default print-access-token) \
-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 application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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 Ihre Batch-Vorhersageanfrage erhalten. Beispiel: VCN926615623331479552.

Abhängig von der Anzahl der Videos, die Sie in Ihrer CSV-Datei angegeben haben, kann die Batchvorhersage einige Zeit in Anspruch nehmen. Wenn die Aufgabe abgeschlossen ist, wird im Status des Vorgangs done: true angezeigt und es sollten keine Fehler aufgelistet sein, wie im folgenden Beispiel zu sehen.

{
  "name": "projects/project-number/locations/location-id/operations/VCN926615623331479552",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2020-02-11T21:39:19.832131Z",
    "updateTime": "2020-02-11T21:43:43.908318Z",
    "done": true,
    "batchPredictDetails": {
      "inputConfig": {
        "gcsSource": {
          "inputUris": [
            "gs://bucket-name/input-file.csv"
          ]
        }
      },
      "outputInfo": {
        "gcsOutputDirectory": "output-storage-path/prediction-test_model_01-2019-01-11T21:39:19.684Z"
      }
    }
  }
}

Wenn die Batchvorhersage abgeschlossen ist, wird die Ausgabe der Vorhersage in dem Cloud Storage-Bucket gespeichert, den Sie in Ihrem Befehl angegeben haben. Für jedes Videosegment gibt es eine JSON-Datei. Beispiel:

my-video-01.avi.json

{
  "input_uri": "automl-video-sample/sample_video.avi",
  "segment_classification_annotations": [ {
    "annotation_spec": {
      "display_name": "ApplyLipstick",
      "description": "ApplyLipstick"
    },
    "segments": [ {
      "segment": {
        "start_time_offset": {
        },
        "end_time_offset": {
          "seconds": 4,
          "nanos": 960000000
        }
      },
      "confidence": 0.43253016
    }, {
      "segment": {
        "start_time_offset": {
        },
        "end_time_offset": {
          "seconds": 4,
          "nanos": 960000000
        }
      },
      "confidence": 0.56746984
    } ],
    "frames": [ ]
  } ],
  "shot_classification_annotations": [ {
    "annotation_spec": {
      "display_name": "ApplyLipstick",
      "description": "ApplyLipstick"
    },
    "segments": [ {
      "segment": {
        "start_time_offset": {
        },
        "end_time_offset": {
          "seconds": 5
        }
      },
      "confidence": 0.43253016
    }, {
      "segment": {
        "start_time_offset": {
        },
        "end_time_offset": {
          "seconds": 5
        }
      },
      "confidence": 0.56746984
    } ],
    "frames": [ ]
  } ],
  "one_second_sliding_window_classification_annotations": [ {
    "annotation_spec": {
      "display_name": "ApplyLipstick",
      "description": "ApplyLipstick"
    },
    "segments": [ ],
    "frames": [ {
      "time_offset": {
        "nanos": 800000000
      },
      "confidence": 0.54533803
    }, {
      "time_offset": {
        "nanos": 800000000
      },
      ...
      "confidence": 0.57945728
    }, {
      "time_offset": {
        "seconds": 4,
        "nanos": 300000000
      },
      "confidence": 0.42054281
    } ]
  } ],
  "object_annotations": [ ],
  "error": {
    "details": [ ]
  }
}

Java

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;

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...");
      BatchPredictResult response = 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()
        )
    )