Annoter des vidéos

Bêta

Ce produit est soumis aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les produits pré-DG sont disponibles "en l'état" et peuvent bénéficier d'une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

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 est de deux ans. Vous devez ensuite entraîner un nouveau modèle.

Remarque :Dans cette version, seul l'emplacement us-central1 est compatible.

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 (annotation au niveau d'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 é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 durer jusqu'à trois heures, avec 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.

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.

  Remarque : Lorsque vous annotez des vidéos via l'interface utilisateur de la console, la valeur par défaut est 0. Par conséquent, l'utilisateur peut obtenir plus d'étiquettes qu'en utilisant directement l'API.

• segment_classification : définissez cette option sur "true" pour activer la classification au niveau des séquences. 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" 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 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 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.
2. Dans la liste affichée, cliquez sur le modèle que vous souhaitez utiliser.
3. Dans l'onglet 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 Test your model (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.
   

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.

REST

Avant d'utiliser les données de requête, 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

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

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

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: project-number" \
    -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

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

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

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-number" }

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 devriez recevoir un ID d'opération pour votre requête de prédiction par lot. Par exemple, VCN926615623331479552.

Réponse

{
  "name": "projects/project-number/locations/location-id/operations/VCN926615623331479552",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2020-02-19T21:22:27.003694Z",
    "updateTime": "2020-02-19T21:22:27.003694Z",
    "batchPredictDetails": {}
  }
}

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

Pour vous authentifier auprès d'AutoML Video, configurez les 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.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;

abstract 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...");
      future.get();
      System.out.println("Batch Prediction results saved to specified Cloud Storage bucket.");
    }
  }
}

Node.js

Pour vous authentifier auprès d'AutoML Video, configurez les 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.
 */
// 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

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

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

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

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

    request = automl.BatchPredictRequest(
        name=model_full_id,
        input_config=input_config,
        output_config=output_config,
        params=params,
    )
    response = prediction_client.batch_predict(request=request)

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

Important : Le message d'erreur "Le modèle est en cours de mise en route. Veuillez réessayer ultérieurement." indique que vous devez attendre quelques minutes avant de réessayer d'interroger le modèle. Ce délai de mise en route peut survenir lorsque vous interrogez votre modèle pour la première fois ou lorsque vous effectuez une requête auprès d'un modèle qui n'a pas été interrogé récemment.