Annoter des vidéos

Une fois que vous avez entraîné un modèle, vous pouvez demander une prédiction en fournissant un fichier CSV à la méthode batchPredict qui répertorie vos vidéos. La méthode batchPredict applique des étiquettes en fonction des prédictions effectuées par votre modèle.

La durée de vie maximale d'un modèle personnalisé est de deux ans. Vous devez ensuite entraîner un nouveau modèle.

Exemple de prédiction

Pour demander un lot de prédictions à AutoML Video Classification, créez un fichier CSV répertoriant les chemins d'accès 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 Classification 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 ulté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 Classification écrira les résultats des prédictions de votre modèle. Ce chemin doit être un bucket et un objet 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 Classification peut générer des prédictions pour environ 100 heures de vidéo en 12 heures de temps de traitement.

Lorsque vous demandez une prédiction pour vos vidéos, vous pouvez définir les options suivantes dans la section params. Si vous ne spécifiez aucune de ces options, le seuil de score par défaut est appliqué, et segment_classification est utilisé.

  • score_threshold : valeur comprise entre 0.0 (niveau de confiance nul) et 1.0 (niveau de confiance très élevé). Lorsque le modèle effectue des prédictions pour une vidéo, il génère seulement des résultats présentant au moins le score de confiance spécifié. La valeur par défaut de l'API est 0.5.

  • segment_classification : définissez cette option sur "true" pour activer la classification au niveau des séquences. AutoML Video Classification 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" pour activer la classification au niveau des plans. AutoML Video Classification 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 Classification renvoie ensuite les étiquettes et leurs scores de confiance pour chaque plan détecté, ainsi que les heures de début et de fin du plan. La valeur par défaut est "false" (inactif).

  • 1s_interval_classification : définissez cette option sur "true" pour activer la classification d'une vidéo à intervalles d'une seconde. AutoML Video Classification 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 l'interface utilisateur d'AutoML Video Classification.
  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. Dans l'onglet Test & Use (Test et utilisation) du modèle, procédez comme suit :
    • Sous Test your model (Tester votre modèle), 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, 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édictions 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

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • input-uri : bucket Cloud Storage contenant le fichier que vous souhaitez annoter, y compris son nom. Doit commencer par gs://. Par exemple :
    "inputUris": ["gs://automl-video-demo-data/hmdb_split1_test_gs_predict.csv"]
  • output-bucket : remplacez cette valeur par le nom de votre bucket Cloud Storage. Par exemple : my-project-vcm
  • object-id : remplacez cette valeur par l'ID de l'opération d'importation de données.
  • Remarque :
    • project-number : numéro de votre projet.
    • location-id : région cloud dans laquelle l'annotation doit avoir lieu. Les régions cloud compatibles sont les suivantes : us-east1, us-west1, europe-west1 et asia-east1. Si aucune région n'est spécifiée, une région sera déterminée en fonction de l'emplacement du fichier vidéo.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devez recevoir un identifiant d'opération pour votre requête de prédiction par lot. Exemple : VCN926615623331479552

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. Une fois la tâche terminée, vous verrez s'afficher done: true dans l'état de l'opération, sans aucune erreur répertoriée, comme illustré dans l'exemple suivant.

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

Une fois la tâche de prédiction par lot terminée, le résultat de la prédiction est stocké dans le bucket 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

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 = prediction_client.model_path(
        project_id, "us-central1", model_id
    )

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

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

    response = prediction_client.batch_predict(
        model_full_id, input_config, output_config, params=params
    )

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