Videos mit Anmerkungen versehen

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 der Methode batchPredict eine CSV-Datei mit einer Liste von Videos bereit. Die Methode batchPredict versieht Ihr Video mit Labels für die Hauptobjekte in den vom Modell vorhergesagten Videos.

Ein benutzerdefiniertes Modell hat eine Lebensdauer von höchstens zwei Jahren. Nach diesem Zeitraum müssen Sie ein neues Modell erstellen und trainieren, um den Inhalt weiterhin klassifizieren zu können.

cURL verwenden

Legen Sie die folgende Umgebungsvariable fest, um das Ausführen der curl-Beispiele in diesem Thema zu vereinfachen. Ersetzen Sie project-id durch den Namen Ihres GCP-Projekts.

export PROJECT_ID="project-id"

Beispiele zu Vorhersagen

Wenn Sie einen Satz von Vorhersagen von AutoML Video anfordern möchten, erstellen Sie eine CSV-Datei, in der die Google Cloud Storage-Pfade zu den Videos aufgeführt sind, die Sie mit Anmerkungen versehen möchten. Sie können auch eine Start- und Endzeit angeben, um AutoML Video mitzuteilen, dass nur ein Segment des Videos mit Anmerkungen versehen werden soll. 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. Sie können auch inf verwenden, um das Ende eines Videos anzuzeigen.

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 die Ergebnisse der Vorhersagen aus Ihrem Modell schreibt. Dieser Pfad muss ein Google 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 kann Vorhersagen für ungefähr 100 Stunden Videomaterial in 12 Stunden generieren.

Optional können Sie im Abschnitt params die folgenden Optionen für das Anfordern von Vorhersagen für Ihre Videos festlegen. Wenn Sie keine dieser Optionen festlegen, wird der Standard-Schwellenwert angewendet und die Segmentklassifizierung verwendet.

  • score_threshold (Schwellenwert) – Ein Wert von 0,0 bis 1,0. Wenn das Modell Vorhersagen für ein Video trifft, werden nur Ergebnisse erzeugt, die mindestens diesen Konfidenzwert haben. Der Standardwert ist 0,5.

  • segment-classification (Segmentklassifizierung) – Setzen Sie den Wert auf "true", um die Klassifizierung auf Segmentebene zu aktivieren. AutoML Video 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 (Aufnahmeklassifizierung) – Setzen Sie den Wert auf "true", um die Klassifizierung auf Aufnahmeebene zu aktivieren. AutoML Video 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 (1-Sekunden-Intervall) – Setzen Sie den Wert auf "true", um für ein Video die Klassifizierung im Sekundentakt zu aktivieren. AutoML Video 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 Google Cloud Platform Console.
  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 im Tab Vorhersage für das Modell die folgenden Aufgaben durch:
    • Wählen Sie unter Modell an neuen Videos testen eine CSV-Datei für die Vorhersage aus. Die CSV-Datei muss eine Liste mit Videos enthalten, die Sie annotieren möchten.
    • Wählen Sie ebenfalls unter Modell an neuen Videos testen ein Verzeichnis in Ihrem Cloud Storage-Bucket aus, in dem die Annotationsergebnisse abgelegt werden.

      Sie können in Ihrem Cloud Storage-Bucket einen Ordner "Ergebnisse" erstellen, in dem die Annotationsergebnisse gespeichert werden. Sie können dann leichter auf ältere Vorhersagen zugreifen, indem Sie die im Ergebnisverzeichnis enthaltene Datei video_classification.csv laden.

    • 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

Befehlszeile

Im folgenden Beispiel wird eine Vorhersage für ein Video angefordert.

  • Ersetzen Sie model-id durch die ID Ihres Modells. Die ID ist das letzte Element des Modellnamens. Wenn der Name Ihres Modells beispielsweise projects/434039606874/locations/us-central1/models/3745331181667467569 lautet, ist die ID des Modells 3745331181667467569.

  • Ersetzen Sie your-bucket-name durch den Namen Ihres Cloud Storage-Buckets. Beispiel: my-project-vcm.

  • Ersetzen Sie your-input-file durch den Namen der CSV-Datei, in der das zu annotierende Video angegeben ist.

  • Ersetzen Sie your-output-storage-path durch einen Pfad zu Google Cloud Storage, in dem die Ausgabe der Vorhersagen gespeichert werden soll. AutoML Video erstellt in diesem Pfad einen Unterordner, der nach dem folgenden Format benannt ist: prediction-model_name-timestamp. In dem Unterordner wird für jedes Video in der Batchanfrage jeweils eine Vorhersagedatei erstellt. Sie brauchen Schreibberechtigungen für diesen Pfad.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
https://automl.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/models/your-model-id:batchPredict -d '{
  "inputConfig": {
    "gcsSource": {
      "inputUris": ["gs://your-bucket-name/your-input-file.csv"]
    }
  },
  "outputConfig": {
    "gcsDestination": {
      "outputUriPrefix": "gs://your-storage-path"
    }
  }
}'

Sie sollten eine Vorgangs-ID für Ihre Batchvorhersageanfrage erhalten, beispielsweise VCN926615623331479552.

{
  "name": "projects/915378992997/locations/us-central1/operations/VCN926615623331479552",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2018-10-19T21:22:27.003694Z",
    "updateTime": "2018-10-19T21:22:27.003694Z",
    "batchPredictDetails": {}
  }
}

Sie können den Status Ihres Batchvorhersagevorgangs mit folgendem curl-Befehl abfragen.

  • Ersetzen Sie your-operation-id durch die ID des Vorgangs zur Batchvorhersage.
curl -X GET -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
https://${ENDPOINT}/v1beta1/projects/${PROJECT_ID}/locations/us-central1/operations/your-operation-id

Abhängig von der Anzahl der Videos, die Sie in Ihrer CSV-Datei angegeben haben, kann die Batchvorhersage einige Zeit in Anspruch nehmen. Wenn der Vorgang 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/915378992997/locations/us-central1/operations/VCN926615623331479552",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2018-10-18T21:23:15.181451Z",
    "updateTime": "2018-10-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 Google 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

/**
 * Demonstrates using the AutoML client to classify the video intelligence
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name. (e.g., "us-central1")
 * @param modelId the Id of the model which will be used for video intelligence classification.
 * @param inputUri the GCS bucket path of csv file which contains path of the video to be
 *     classified.
 * @param outputUriPrefix the output GCS bucket folder path which contains one csv file and json
 *     file for each video classification.
 * @throws IOException
 * @throws ExecutionException
 * @throws InterruptedException
 */
public static void predict(
    String projectId,
    String computeRegion,
    String modelId,
    String inputUri,
    String outputUriPrefix)
    throws IOException, InterruptedException, ExecutionException {

  // Create client for prediction service.
  PredictionServiceClient predictionClient = PredictionServiceClient.create();

  // Get full path of model
  ModelName modelName = ModelName.of(projectId, computeRegion, modelId);

  // Set the input URI
  GcsSource.Builder gcsSource = GcsSource.newBuilder();

  // Get multiple training data files to be imported
  String[] inputUris = inputUri.split(",");
  for (String inputFilePath : inputUris) {
    gcsSource.addInputUris(inputFilePath);
  }

  // Set the Batch Input Configuration
  BatchPredictInputConfig batchInputConfig =
      BatchPredictInputConfig.newBuilder().setGcsSource(gcsSource).build();

  // Set the output URI
  GcsDestination.Builder gcsDestination = GcsDestination.newBuilder();
  gcsDestination.setOutputUriPrefix(outputUriPrefix);

  // Set the Batch Input Configuration
  BatchPredictOutputConfig batchOutputConfig =
      BatchPredictOutputConfig.newBuilder().setGcsDestination(gcsDestination).build();

  // Set the modelName, input and output config in the batch prediction
  BatchPredictRequest batchRequest =
      BatchPredictRequest.newBuilder()
          .setInputConfig(batchInputConfig)
          .setOutputConfig(batchOutputConfig)
          .setName(modelName.toString())
          .build();

  // Get the latest state of a long-running operation.
  OperationFuture<BatchPredictResult, OperationMetadata> operation =
      predictionClient.batchPredictAsync(batchRequest);

  System.out.println(
      String.format("Operation Name: %s", operation.getInitialFuture().get().getName()));
}

Node.js

const automl = require(`@google-cloud/automl`);

// Create client for prediction service.
const client = new automl.v1beta1.PredictionServiceClient();

/**
 * Demonstrates using the AutoML client to classify the video intelligence
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const modelId = '[MODEL_ID]' e.g., "IOD2122286140026257408";
// const inputUri = '[GCS_PATH]' e.g., "gs://<bucket-name>/<csv file>",
// `the GCS bucket path of csv file which contains path of the video
// to be classified.`;
// const outputUriPrefix = '[GCS_DIRECTORY_PATH]'
// e.g., "gs://<bucket-name>/<folder>",
// `the output GCS bucket folder path which contains one csv file and
// json file for each video classification.`;

// Get the full path of the model.
const modelFullId = client.modelPath(projectId, computeRegion, modelId);

// Set the input URI
const inputConfig = {
  gcsSource: {
    inputUris: [inputUri],
  },
};

// Set the output URI
const outputUri = outputUriPrefix;
const outputConfig = {
  gcsDestination: {
    outputUriPrefix: outputUri,
  },
};

// Get the latest state of a long-running operation.
client
  .batchPredict({
    name: modelFullId,
    inputConfig: inputConfig,
    outputConfig: outputConfig,
  })
  .then(responses => {
    const response = responses[1];
    console.log(`Operation name: ${response.name}`);
  })
  .catch(err => {
    console.error(err);
  });

Python

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# input_uri = 'gs://path/to/file.csv'
# output_uri_prefix = 'gs://path'

from google.cloud import automl_v1beta1 as automl
import csv

automl_client = automl.AutoMlClient()

# Get the full path of the model.
model_full_id = automl_client.model_path(
    project_id, compute_region, model_id
)

# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()

# Input configuration.
input_config = dict(gcs_source={'input_uris': [input_uri]})

# Output configuration.
output_config = dict(
    gcs_destination={'output_uri_prefix': output_uri_prefix}
)

# Launch long-running batch prediction operation.
response = prediction_client.batch_predict(model_full_id, input_config,
                                            output_config)
print("Making batch prediction... ")
try:
    result = response.result()
except:
    # Hides Any to BatchPredictResult error.
    pass
print("Batch prediction complete.\n{}".format(response.metadata))