Obtenir des prédictions à partir d'un modèle de reconnaissance d'actions dans des vidéos

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Cette page vous explique comment obtenir des prédictions par lot à partir de vos modèles de reconnaissance d'actions dans des vidéos à l'aide de la console Google Cloud ou de l'API Vertex AI. Les prédictions par lot sont des requêtes asynchrones. Vous demandez des prédictions par lot directement à partir de la ressource de modèle sans avoir à le déployer sur un point de terminaison.

Les modèles vidéo AutoML ne sont pas compatibles avec les prédictions en ligne.

Obtenir des prédictions par lot

Pour effectuer une requête de prédiction par lot, vous devez spécifier une source d'entrée et un format de sortie dans lesquels Vertex AI stocke les résultats des prédictions.

Exigences concernant les données d'entrée

L'entrée des requêtes par lot spécifie les éléments à envoyer à votre modèle pour la prédiction. Les prédictions par lot pour le type de modèle vidéo AutoML utilisent un fichier JSON Lines pour spécifier une liste des vidéos pour lesquelles réaliser des prédictions, puis stockent le fichier JSON Lines dans un bucket Cloud Storage. Vous pouvez spécifier Infinity pour le champ timeSegmentEnd afin d'indiquer la fin de la vidéo. L'exemple suivant montre l'une des lignes figurant dans un fichier JSON Lines d'entrée.

{'content': 'gs://sourcebucket/datasets/videos/source_video.mp4', 'mimeType': 'video/mp4', 'timeSegmentStart': '0.0s', 'timeSegmentEnd': '2.366667s'}

Demander une prédiction par lots

Pour les requêtes de prédiction par lot, vous pouvez utiliser la console Google Cloud ou l'API Vertex AI. Selon le nombre d'éléments d'entrée envoyés, la tâche de prédiction par lot peut prendre un certain temps.

console Google Cloud

Utilisez la console Google Cloud pour demander une prédiction par lot.

  1. Dans la console Google Cloud, dans la section Vertex AI, accédez à la page Prédictions par lot.

    Accéder à la page "Prédictions par lot"

  2. Cliquez sur Créer pour ouvrir la fenêtre Nouvelle prédiction par lot et procédez comme suit :

    1. Saisissez un nom pour la prédiction par lot.
    2. Dans Nom du modèle, sélectionnez le nom du modèle à utiliser pour cette prédiction par lot.
    3. Dans le champ Chemin source, spécifiez l'emplacement Cloud Storage où se trouve votre fichier d'entrée JSON Lines.
    4. Pour le chemin d'accès de la destination, spécifiez un emplacement Cloud Storage où les résultats de la prédiction par lot sont stockés. Le format de sortie est déterminé par l'objectif de votre modèle. Les modèles AutoML pour les objectifs d'images génèrent des fichiers JSON Lines.

API

Envoyez des requêtes de prédiction par lot à l'aide de l'API Vertex AI.

REST

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

  • LOCATION : région où le modèle est stocké et la tâche de prédiction par lot est exécutée. Exemple : us-central1.
  • PROJECT : ID de votre projet
  • BATCH_JOB_NAME : nom à afficher de la tâche de prédiction par lot.
  • MODEL_ID : ID du modèle à utiliser pour effectuer des prédictions.
  • THRESHOLD_VALUE (facultatif) : le modèle ne renvoie que les prédictions dont le score de confiance est au moins égal à cette valeur.
  • URI : URI Cloud Storage où se trouve le fichier JSON Lines d'entrée.
  • BUCKET : votre bucket Cloud Storage.
  • PROJECT_NUMBER: numéro de votre projet

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/batchPredictionJobs

Corps JSON de la requête :

{
    "displayName": "BATCH_JOB_NAME",
    "model": "projects/PROJECT/locations/us-central1/MODEL_ID",
    "modelParameters": {
      "confidenceThreshold": THRESHOLD_VALUE,
    },
    "inputConfig": {
        "instancesFormat": "jsonl",
        "gcsSource": {
            "uris": ["URI"],
        },
    },
    "outputConfig": {
        "predictionsFormat": "jsonl",
        "gcsDestination": {
            "outputUriPrefix": "OUTPUT_BUCKET",
        },
    },
}

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 print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/batchPredictionJobs"

PowerShell

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

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/batchPredictionJobs" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_NUMBER/locations/us-central1/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT_NUMBER/locations/us-central1/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "CONTENT"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "BUCKET"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
  "modelDisplayName": "MODEL_NAME",
  "modelObjective": "MODEL_OBJECTIVE"
}

Vous pouvez interroger l'état de la tâche par lot à l'aide de BATCH_JOB_ID jusqu'à ce que le paramètre state soit défini sur JOB_STATE_SUCCEEDED.

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour Vertex AI, consultez Bibliothèques clientes Vertex AI. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.GcsSource;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.protobuf.Value;
import java.io.IOException;

public class CreateBatchPredictionJobVideoActionRecognitionSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String model = "MODEL";
    String gcsSourceUri = "GCS_SOURCE_URI";
    String gcsDestinationOutputUriPrefix = "GCS_DESTINATION_OUTPUT_URI_PREFIX";
    createBatchPredictionJobVideoActionRecognitionSample(
        project, displayName, model, gcsSourceUri, gcsDestinationOutputUriPrefix);
  }

  static void createBatchPredictionJobVideoActionRecognitionSample(
      String project,
      String displayName,
      String model,
      String gcsSourceUri,
      String gcsDestinationOutputUriPrefix)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // 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 (JobServiceClient client = JobServiceClient.create(settings)) {
      Value modelParameters = ValueConverter.EMPTY_VALUE;
      GcsSource gcsSource = GcsSource.newBuilder().addUris(gcsSourceUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat("jsonl")
              .setGcsSource(gcsSource)
              .build();
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(gcsDestinationOutputUriPrefix).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat("jsonl")
              .setGcsDestination(gcsDestination)
              .build();

      String modelName = ModelName.of(project, location, model).toString();

      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();
      LocationName parent = LocationName.of(project, location);
      BatchPredictionJob response = client.createBatchPredictionJob(parent, batchPredictionJob);
      System.out.format("response: %s\n", response);
      System.out.format("\tName: %s\n", response.getName());
    }
  }
}

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Vertex AI, consultez la page Bibliothèques clientes Vertex AI. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Python.

def create_batch_prediction_job_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

Récupérer des résultats de prédiction par lot

Vertex AI envoie une sortie de prédiction par lot à la destination spécifiée.

Lorsqu'une tâche de prédiction par lot est terminée, le résultat de la prédiction est stocké dans le bucket Cloud Storage que vous avez spécifié dans votre requête.

Exemples de résultats de prédictions par lot

Voici un exemple de prédiction par lot issu d'un modèle de reconnaissance d'actions dans une vidéo.

{
  "instance": {
   "content": "gs://bucket/video.mp4",
    "mimeType": "video/mp4",
    "timeSegmentStart": "1s",
    "timeSegmentEnd": "5s"
  }
  "prediction": [{
    "id": "1",
    "displayName": "swing",
    "timeSegmentStart": "1.2s",
    "timeSegmentEnd": "1.2s",
    "confidence": 0.7
  }, {
    "id": "2",
    "displayName": "jump",
    "timeSegmentStart": "3.4s",
    "timeSegmentEnd": "3.4s",
    "confidence": 0.5
  }]
}