Annoter des vidéos

Une fois un modèle créé (entraîné), vous pouvez lui demander d'effectuer une prédiction pour une ou plusieurs vidéos à l'aide de la méthode batchPredict. Vous devez fournir un fichier CSV avec une liste de vidéos à la méthode batchPredict. La méthode batchPredict applique des libellés aux vidéos en fonction des objets principaux des vidéos que prédit le modèle.

La durée de vie maximale d'un modèle personnalisé est de deux ans. Vous devez créer un modèle et l'entraîner pour continuer à classifier le contenu au-delà de cette période.

À l'aide de curl

Pour faciliter l'exécution des exemples curl décrits dans ce sujet, définissez la variable d'environnement suivante, en remplaçant project-id par le nom de votre projet GCP.

export PROJECT_ID="project-id"

Exemple de prédiction

Pour demander un lot de prédictions à AutoML Video, créez un fichier CSV répertoriant les chemins d'accès Google Cloud Storage des vidéos que vous souhaitez annoter. Vous pouvez également spécifier une heure de début et une heure de fin pour indiquer à AutoML Video d'annoter seulement une séquence de la vidéo. L'heure de début doit être égale ou supérieure à zéro, et doit être antérieure à l'heure de fin. L'heure de fin doit être supérieure à l'heure de début et inférieure ou égale à la durée de la vidéo. Vous pouvez également utiliser inf pour indiquer la fin d'une vidéo.

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

Vous devez également spécifier le chemin du fichier de sortie dans lequel AutoML Video écrira les résultats des prédictions de votre modèle. Ce chemin doit être un bucket et un objet Google Cloud Storage pour lesquels vous disposez d'autorisations en écriture.

Chaque vidéo peut avoir une durée maximale de 3 heures et une taille de fichier maximale de 50 Go. AutoML Video peut générer des prédictions pour environ 100 heures de vidéo en 12 heures de temps de traitement.

Vous pouvez également définir les options suivantes dans la section params lorsque vous effectuez une requête de prédiction sur des vidéos. Si vous ne spécifiez aucune de ces options, la valeur par défaut du seuil de score est appliquée, et le paramètre segment-classification est utilisé.

  • score_threshold : Valeur comprise entre 0,0 et 1,0. Lorsque le modèle effectue des prédictions pour une vidéo, il génère seulement des résultats présentant au moins ce score de confiance. La valeur par défaut est 0,5.

  • segment-classification : Définissez cette option sur "true" (actif) pour activer la classification au niveau de la séquence. AutoML Video renvoie les étiquettes et leurs scores de confiance pour l'intégralité de la séquence vidéo que vous avez spécifiée dans la configuration de la requête. La valeur par défaut est "true" (actif).

  • shot-classification : Définissez cette option sur "true" (actif) pour activer la classification au niveau des plans. AutoML Video détermine les limites de chaque plan de caméra dans l'intégralité de la séquence vidéo que vous avez spécifiée dans la configuration de la requête. AutoML Video Intelligence renvoie ensuite les étiquettes et leurs scores de confiance pour chaque plan détecté, ainsi que l'heure de début et de fin du plan. La valeur par défaut est "false" (inactif).

  • 1s_interval : Définissez cette option sur "true" (actif) pour activer la classification d'une vidéo à intervalles d'une seconde. AutoML Video renvoie les étiquettes et leurs scores de confiance pour chaque seconde de l'intégralité de la séquence vidéo que vous avez spécifiée dans la configuration de la requête. La valeur par défaut est "false" (inactif).

UI Web

  1. Ouvrez la console Google Cloud Platform.
  2. Dans la liste affichée, cliquez sur le modèle personnalisé que vous souhaitez utiliser. Liste des modèles AutoML Video Intelligence personnalisés dans la console Cloud
  3. Cliquez sur l'onglet Prédiction du modèle, puis procédez comme suit :
    • Sous Tester votre modèle sur de nouvelles vidéos, sélectionnez un fichier CSV à utiliser pour la prédiction. Ce fichier doit fournir la liste des vidéos que vous souhaitez annoter.
    • Toujours sous Tester votre modèle sur de nouvelles vidéos, sélectionnez un répertoire de votre bucket Cloud Storage où recevoir les résultats des annotations.

      Vous voudrez peut-être créer un dossier "résultats" spécifique dans votre bucket Cloud Storage pour stocker les résultats des annotations. Ce faisant, vous pourrez accéder plus facilement aux prévisions plus anciennes en chargeant le fichier video_classification.csv contenu dans le répertoire des résultats.

    • Cliquez sur Obtenir les prédictions.
    Configurer une requête de prédiction pour AutoML Video Intelligence

L'obtention de prédictions peut prendre un certain temps, selon le nombre de vidéos que vous souhaitez annoter.

Une fois le processus terminé, les résultats apparaissent sur la page du modèle sous Prédictions récentes. Pour afficher les résultats, procédez comme suit :

  1. Sous Prédictions récentes, dans la colonne Prédictions, cliquez sur Afficher pour la prédiction que vous souhaitez consulter.
  2. Sous Vidéo, sélectionnez le nom de la vidéo pour laquelle vous souhaitez afficher les résultats.

Résultats de la prédiction AutoML Video Intelligence

Ligne de commande

L'exemple suivant montre comment effectuer une requête de prédiction pour une vidéo.

  • Remplacez model-id par l'ID de votre modèle. L'ID est le dernier élément du nom du modèle. Par exemple, si le nom du modèle est projects/434039606874/locations/us-central1/models/3745331181667467569, son ID est 3745331181667467569.

  • Remplacez your-bucket-name par le nom de votre bucket Google Cloud Storage. Par exemple : my-project-vcm.

  • Remplacez your-input-file par le nom du fichier CSV qui identifie les vidéos à annoter.

  • Remplacez your-output-storage-path par un chemin d'accès Google Cloud Storage, dans lequel le résultat des prédictions doit être stocké. AutoML Video créera dans ce chemin un sous-dossier nommé au format suivant : prediction-model_name-timestamp Le sous-dossier contiendra un fichier de prédiction pour chaque vidéo de la requête de traitement par lots. Vous devez avoir des autorisations d'écriture sur ce chemin.

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"
    }
  }
}'

Vous devez recevoir un identifiant d'opération pour votre requête de prédiction par lot. Exemple : 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": {}
  }
}

Vous pouvez interroger l'état de votre opération de prédiction par lot à l'aide de la commande curl suivante.

  • Remplacez your-operation-id par l'identifiant d'opération de votre opération de prédiction par lot.
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

Selon le nombre de vidéos que vous avez spécifiées dans le fichier CSV, la tâche de prédiction par lot peut prendre un certain temps. Lorsque la tâche est terminée, l'état done: true de l'opération sans erreur répertoriée s'affiche, comme illustré dans l'exemple suivant.

{
  "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"
  }
}

Une fois la tâche de prédiction par lot terminée, le résultat de la prédiction est stocké dans le bucket Google Cloud Storage spécifié dans la commande. Chaque séquence vidéo est répertoriée dans un fichier JSON. Exemple :

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))