Obtenir des prédictions à partir d'un modèle de suivi d'objets vidéo

Cette page explique comment obtenir des prédictions par lot à partir de vos modèles de suivi d'objets vidéo à 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_ID : 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 : l'ID de votre projet.
  • BATCH_JOB_NAME : nom à afficher du job par lot.
  • MODEL_ID : ID du modèle à utiliser pour effectuer des prédictions.
  • THRESHOLD_VALUE (facultatif) : Vertex AI ne renvoie que des prédictions ayant au moins cette valeur de score de confiance. La valeur par défaut est 0.0.
  • URI : URI Cloud Storage où se trouve le fichier JSON Lines d'entrée.
  • BUCKET : votre bucket Cloud Storage.
  • PROJECT_NUMBER : numéro de projet généré automatiquement pour votre projet

Méthode HTTP et URL :

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs

Corps JSON de la requête :

{
    "displayName": "BATCH_JOB_NAME",
    "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/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",
  "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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.BatchDedicatedResources;
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.BatchPredictionJob.InputConfig;
import com.google.cloud.aiplatform.v1.BatchPredictionJob.OutputConfig;
import com.google.cloud.aiplatform.v1.BatchPredictionJob.OutputInfo;
import com.google.cloud.aiplatform.v1.BigQueryDestination;
import com.google.cloud.aiplatform.v1.BigQuerySource;
import com.google.cloud.aiplatform.v1.CompletionStats;
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.MachineSpec;
import com.google.cloud.aiplatform.v1.ManualBatchTuningParameters;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.ResourcesConsumed;
import com.google.cloud.aiplatform.v1.schema.predict.params.VideoObjectTrackingPredictionParams;
import com.google.protobuf.Any;
import com.google.protobuf.Value;
import com.google.rpc.Status;
import java.io.IOException;
import java.util.List;

public class CreateBatchPredictionJobVideoObjectTrackingSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String batchPredictionDisplayName = YOUR_VIDEO_OBJECT_TRACKING_DISP"LAY_NAME;
    String modelId = YOUR_MOD"EL_ID;
    String gcsSou"rceUri =
    "    gs://YOUR_GCS_SOURCE_BUCKET/path_t"o_your_video_source/[file.csv/file.jsonl];
    String gcsDestinationOutputU"riPrefix =
        gs://YOUR_GCS_SOURCE_BUCKET/destinat"ion_output_uri_prefix/;
    String project = YOUR_PROJECT_"ID;
    batchPredictionJ"obVideoObjectTr"acking(
        batchPredictionDisplayName, modelId, gcsSourceUri, gcsDestinationOutputUriPrefix, project);
  }

  static void batchPredictionJobVideoObjectTracking(
      String batchPredictionDisplayName,
      String modelId,
      String gcsSourceUri,
      String gcsDestinationOutputUriPrefix,
      String project)
      throws IOException {
    JobServiceSettings jobServiceSettings =
        JobServiceSettings.newBuilder()
            .setEndpoint(us-central1-aiplatform.googleapis.com:443)
        "    .build();

    // Initialize client t"hat 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 remain"ing b"ackground resources.
    try (JobServiceClient jobServiceClient = JobServiceClient.create(jobServiceSettings)) {
      String location = us-central1;
      LocationName locationName = LocationNam"e.of(projec"t, location);
      ModelName modelName = ModelName.of(project, location, modelId);

      VideoObjectTrackingPredictionParams modelParamsObj =
          VideoObjectTrackingPredictionParams.newBuilder()
              .setConfidenceThreshold(((float) 0.5))
              .build();

      Value modelParameters = ValueConverter.toValue(modelParamsObj);

      GcsSource.Builder gcsSource = GcsSource.newBuilder();
      gcsSource.addUris(gcsSourceUri);
      InputConfig inputConfig =
          InputConfig.newBuilder().setInstancesFormat(jsonl).setGcsSource(gcsSource).build();

      GcsDestination gcsDestina"tion "=
          GcsDestination.newBuilder().setOutputUriPrefix(gcsDestinationOutputUriPrefix).build();
      OutputConfig outputConfig =
          OutputConfig.newBuilder()
              .setPredictionsFormat(jsonl)
              .setGcsDestination(gcsDestination)
              .build()";

  "    BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(batchPredictionDisplayName)
              .setModel(modelName.toString())
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();
      BatchPredictionJob batchPredictionJobResponse =
          jobServiceClient.createBatchPredictionJob(locationName, batchPredictionJob);

      System.out.println(Create Batch Prediction Job Video Object Tracking Response);
      System.out.format(\tName: "%s\n, batchPredictionJobResponse.getName());
      System."out.format(\tDisplay Name: %"s\n, batchPr"edictionJobResponse.getDisplayName());
      System.out.format(\tM"odel %s\n, batchPred"ictionJobResponse.getModel());
      System.out.format(
          \tModel" Parameters:" %s\n, batchPredictionJobResponse.getModelParameters());

      System.out.form"at(\tState: %s\n, batchP"redictionJobResponse.getState());
      System.out.format(\tCreate Time: %s\n, "batchPredicti"onJobResponse.getCreateTime());
      System.out.format(\tStart Tim"e: %s\n, batchPredi"ctionJobResponse.getStartTime());
      System.out.format(\tEnd Time: %s"\n, batchPredictio"nJobResponse.getEndTime());
      System.out.format(\tUpdate Time: %s\n", batchPredictio"nJobResponse.getUpdateTime());
      System.out.format(\tLabels: %s\n", batchPredictionJo"bResponse.getLabelsMap());

      InputConfig inputConfigResponse = batc"hPredictionJob"Response.getInputConfig();
      System.out.println(\tInput Config);
      System.out.format(\t\tInstances Format: %s\n, inputConfigResponse.getInstancesFormat("));

      Gcs"Source gcsSourceResponse = i"nputConfigResponse.getGcsS"ource();
      System.out.println(\t\tGcs Source);
      System.out.format(\t\t\tUris %s\n, gcsSourceResponse.getUrisList());

      BigQuerySourc"e bigQuerySour"ce = inputConfigResponse.get"BigquerySource(");
      System.out.println(\t\tBigquery Source);
      System.out.format(\t\t\tInput_uri: %s\n, bigQuerySource.getInputUri());

      OutputCon"fig outputConfigRes"ponse = batchPredictionJobRe"sponse.getOutputConfi"g();
      System.out.println(\tOutput Config);
      System.out.format(
          \t\tPredictions Format: %s\n, outputConfigResponse.getPredictionsFo"rmat());

     " GcsDestination gcsDestinationResponse =" outputConfigResponse.getGcs"Destination();
      System.out.println(\t\tGcs Destination);
      System.out.format(
          \t\t\tOutput Uri Prefix: %s\n, gcsDestinationResponse.getOutputUriPr"efix());

      Big"QueryDestination bigQueryDestination = o"utputConfigResponse.getBigque"ryDestination();
      System.out.println(\t\tBig Query Destination);
      System.out.format(\t\t\tOutput Uri: %s\n, bigQueryDestination.getOutputUri());

      BatchDedic"atedResources batchDedica"tedResources =
          bat"chPredictionJobRespons"e.getDedicatedResources();
      System.out.println(\tBatch Dedicated Resources);
      System.out.format(
          \t\tStarting Replica Count: %s\n, batchDedicatedResources.getStartingR"eplicaCount());
      Syste"m.out.format(
          \t\tMax Replica "Count: %s\n, batchDedicatedResou"rces.getMaxReplicaCount());

      MachineSpec machineSpec = batchDedicatedResources.getMac"hineSpec();
      System.ou"t.println(\t\tMachine Spec);
      System.out.format(\t\t\tMachine Type: %s\n, machineSpec.getMachineType());
      System.out.format(\t\t\tAccelerator "Type: %s\n, mach"ineSpec.getAcceleratorType()");
      System.out.form"at(\t\t\tAccelerator Count: %s\n, machineSpec.getAccelerat"orCount());

      ManualBat"chTuningParameters manualBatchTuningParameters =
          bat"chPredictionJobResponse.getMa"nualBatchTuningParameters();
      System.out.println(\tManual Batch Tuning Parameters);
      System.out.format(\t\tBatch Size: %s\n, manualBatchTuningParameters.getBatchSize());

      OutputInfo outpu"tInfo = batchPredictionJobRespon"se.getOutputInfo();
      Sy"stem.out.println(\tO"utput Info);
      System.out.format(\t\tGcs Output Directory: %s\n, outputInfo.getGcsOutputDirectory());
      System.out.format(\t\tBigquery Output "Dataset: %s\n", outputInfo.getBigqueryOutp"utDataset());

      Status st"atus = batchPredictionJobResponse.getError();
      System.out.p"rintln(\tError);
      System.out".format(\t\tCode: %s\n, status.getCode());
      System.out.format(\t\tMessage: %s\n, status.getMessage());
      ListAny details = "status."getDetailsList();

      for" (Status parti"alFailure : batchPredictionJobResponse.getPart"ialFailuresList()") {
        System.out.println(\tPa<rti>al Failure);
        System.out.format(\t\tCode: %s\n, partialFailure.getCode());
        System.out.format(\t\tMessage: %s\n, partialFailure.getMessage());
"        ListAny p"artialFailureDetailsList = par"tialFailure.ge"tDetailsList();
      }

      ResourcesConsumed resourc"esConsumed = batc"hPredictionJobResponse.getResourcesConsumed()<;
 >     System.out.println(\tResources Consumed);
      System.out.format(\t\tReplica Hours: %s\n, resourcesConsumed.getReplicaHours());

      CompletionStats completionStats = batchPredictionJobRe"sponse.getCompletion"Stats();
      System.out.pr"intln(\tCompletion Stat"s);
      System.out.format(\t\tSuccessful Count: %s\n, completionStats.getSuccessfulCount());
      System.out.format(\t\tFailed Count: %s\n, completionStats".getFailedCount())";
      System.out.format(\t"\tIncomplete Count: %s\n, "completionStats.getIncompleteCount());
    }
  }
}""""

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const batchPredictionDisplayName = 'YOUR_BATCH_PREDICTION_DISPLAY_NAME';
// const modelId = 'YOUR_MODEL_ID';
// const gcsSourceUri = 'YOUR_GCS_SOURCE_URI';
// const gcsDestinationOutputUriPrefix = 'YOUR_GCS_DEST_OUTPUT_URI_PREFIX';
//    eg. "gs://<your-gcs-bucket>/destination_path"
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {params} = aiplatform.protos.google.cloud.aiplatform.v1.schema.predict;

// Imports the Google Cloud Job Service Client library
const {JobServiceClient} = require('@google-cloud/aiplatform').v1;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const jobServiceClient = new JobServiceClient(clientOptions);

async function createBatchPredictionJobVideoObjectTracking() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const modelName = `projects/${project}/locations/${location}/models/${modelId}`;

  // For more information on how to configure the model parameters object, see
  // https://cloud.google.com/ai-platform-unified/docs/predictions/batch-predictions
  const modelParamsObj = new params.VideoObjectTrackingPredictionParams({
    confidenceThreshold: 0.5,
  });

  const modelParameters = modelParamsObj.toValue();

  const inputConfig = {
    instancesFormat: 'jsonl',
    gcsSource: {uris: [gcsSourceUri]},
  };
  const outputConfig = {
    predictionsFormat: 'jsonl',
    gcsDestination: {outputUriPrefix: gcsDestinationOutputUriPrefix},
  };
  const batchPredictionJob = {
    displayName: batchPredictionDisplayName,
    model: modelName,
    modelParameters,
    inputConfig,
    outputConfig,
  };
  const request = {
    parent,
    batchPredictionJob,
  };

  // Create batch prediction job request
  const [response] = await jobServiceClient.createBatchPredictionJob(request);

  console.log('Create batch prediction job video object tracking response');
  console.log(`Name : ${response.name}`);
  console.log('Raw response:');
  console.log(JSON.stringify(response, null, 2));
}
createBatchPredictionJobVideoObjectTracking();

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API 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 résultant d'un modèle de suivi d'objets vidéo.

{
  "instance": {
   "content": "gs://bucket/video.mp4",
    "mimeType": "video/mp4",
    "timeSegmentStart": "1s",
    "timeSegmentEnd": "5s"
  }
  "prediction": [{
    "id": "1",
    "displayName": "cat",
    "timeSegmentStart": "1.2s",
    "timeSegmentEnd": "3.4s",
    "frames": [{
      "timeOffset": "1.2s",
      "xMin": 0.1,
      "xMax": 0.2,
      "yMin": 0.3,
      "yMax": 0.4
    }, {
      "timeOffset": "3.4s",
      "xMin": 0.2,
      "xMax": 0.3,
      "yMin": 0.4,
      "yMax": 0.5,
    }],
    "confidence": 0.7
  }, {
    "id": "1",
    "displayName": "cat",
    "timeSegmentStart": "4.8s",
    "timeSegmentEnd": "4.8s",
    "frames": [{
      "timeOffset": "4.8s",
      "xMin": 0.2,
      "xMax": 0.3,
      "yMin": 0.4,
      "yMax": 0.5,
    }],
    "confidence": 0.6
  }, {
    "id": "2",
    "displayName": "dog",
    "timeSegmentStart": "1.2s",
    "timeSegmentEnd": "3.4s",
    "frames": [{
      "timeOffset": "1.2s",
      "xMin": 0.1,
      "xMax": 0.2,
      "yMin": 0.3,
      "yMax": 0.4
    }, {
      "timeOffset": "3.4s",
      "xMin": 0.2,
      "xMax": 0.3,
      "yMin": 0.4,
      "yMax": 0.5,
    }],
    "confidence": 0.5
  }]
}