Préparer des données d'entraînement vidéo pour la reconnaissance des actions

Cette page explique comment préparer des données d'entraînement vidéo à utiliser dans un ensemble de données Vertex AI pour entraîner un modèle de reconnaissance d'actions dans des vidéos.

Les sections suivantes fournissent des informations sur les exigences de données, les fichiers de schéma et le format des fichiers d'importation de données (JSONL et CSV) définis par le schéma.

Vous pouvez également importer des vidéos non annotées et les annoter ultérieurement à l'aide de la console Google Cloud (consultez la section Ajouter des étiquettes à l'aide de la console Google Cloud).

Exigences en matière de données

Les exigences suivantes s'appliquent aux ensembles de données utilisés pour entraîner des modèles AutoML ou des modèles personnalisés.

  • Vertex AI accepte les formats vidéo suivants pour entraîner votre modèle ou demander une prédiction (annotation d'une vidéo).

    • .MOV
    • .MPEG4
    • .MP4
    • .AVI

  • Pour afficher le contenu vidéo dans la console Web ou annoter une vidéo, vous devez utiliser un format compatible avec le navigateur. Étant donné que tous les navigateurs ne gèrent pas le contenu .MOV ou .AVI en mode natif, nous vous recommandons d'utiliser le format vidéo .MPEG4 ou .MP4.

  • La taille maximale du fichier est de 50 Go (durée maximale de 3 heures). Tous les fichiers vidéo dont les horodatages sont incorrects ou vides dans le conteneur ne sont pas acceptés.

  • Le nombre maximal d'étiquettes dans chaque ensemble de données est limité à 1 000.

  • Vous pouvez attribuer des étiquettes "ML_USE" aux vidéos des fichiers d'importation. Au moment de l'entraînement, vous pouvez choisir d'utiliser ces étiquettes pour scinder les vidéos et leurs annotations correspondantes en ensembles d'entraînement ou de test. Pour la reconnaissance des actions, l'utilisation de la console d'étiquetage VAR est limitée. Si vous souhaitez utiliser l'outil d'étiquetage pour attribuer des étiquettes aux actions, vous devez étiqueter toutes les actions dans cette vidéo.

Bonnes pratiques en termes de données vidéo utilisées afin d'entraîner des modèles AutoML

Les pratiques suivantes s'appliquent aux ensembles de données utilisés pour entraîner les modèles AutoML.

  • Les données d'entraînement doivent être aussi proches que possible des données sur lesquelles les prédictions sont fondées. Par exemple, si votre cas pratique implique des vidéos floues en basse résolution (comme celles d'une caméra de sécurité), vos données d'entraînement doivent être composées de vidéos floues à basse résolution. En général, il est également recommandé de fournir différents types d'angles, de résolutions et d'arrière-plans pour les vidéos d'entraînement.

  • Les modèles Vertex AI ne sont généralement pas capables de prédire les étiquettes qu'un humain ne serait pas en mesure d'attribuer. Ainsi, si un humain ne peut pas apprendre à attribuer des étiquettes en regardant la vidéo pendant 1 à 2 secondes, le modèle ne pourra probablement pas être entraîné à le faire non plus.

  • Le modèle fonctionne mieux lorsqu'il existe au maximum 100 fois plus de vidéos pour l'étiquette la plus courante que pour la plus rare. Nous vous recommandons de supprimer les libellés les moins fréquents. Pour la reconnaissance des actions, tenez compte des points suivants :

    • Il est recommandé d'utiliser au moins 100 images vidéo d'entraînement par étiquette.
    • Les images vidéo dont la résolution est supérieure à 1 024 pixels par 1 024 pixels peuvent perdre en qualité lors du processus de normalisation des images utilisé par Vertex AI.

Fichiers de schéma

  • Lors de la création du fichier jsonl pour l'importation d'annotations, utilisez le fichier de schéma accessible au public suivant. Ce fichier de schéma détermine le format des fichiers de données d'entrée. La structure du fichier suit le test du schéma OpenAPI.

    Fichier de schéma de reconnaissance d'actions :

    gs://google-cloud-aiplatform/schema/dataset/ioformat/video_action_recognition_io_format_1.0.0.yaml

    Fichier de schéma complet

    
title: VideoActionRecognition
description: >
  Import and export format for importing/exporting videos together with
  action recognition annotations with time segment. Can be used in
  Dataset.import_schema_uri field.
type: object
required:
- videoGcsUri
properties:
  videoGcsUri:
    type: string
    description: >
      A Cloud Storage URI pointing to a video. Up to 50 GB in size and
      up to 3 hours in duration. Supported file mime types: `video/mp4`,
      `video/avi`, `video/quicktime`.
  timeSegments:
    type: array
    description: Multiple fully-labeled segments.
    items:
      type: object
      description: A time period inside the video.
      properties:
        startTime:
          type: string
          description: >
            The start of the time segment. Expressed as a number of seconds as
            measured from the start of the video, with "s" appended at the end.
            Fractions are allowed, up to a microsecond precision.
          default: 0s
        endTime:
          type: string
          description: >
            The end of the time segment. Expressed as a number of seconds as
            measured from the start of the video, with "s" appended at the end.
            Fractions are allowed, up to a microsecond precision, and "Infinity"
            is allowed, which corresponds to the end of the video.
          default: Infinity
  timeSegmentAnnotations:
    type: array
    description: >
      Multiple action recognition annotations. Each on a time segment of the video.
    items:
      type: object
      description: Annotation with a time segment on media (e.g., video).
      properties:
        displayName:
          type: string
          description: >
            It will be imported as/exported from AnnotationSpec's display name.
        startTime:
          type: string
          description: >
            The start of the time segment. Expressed as a number of seconds as
            measured from the start of the video, with "s" appended at the end.
            Fractions are allowed, up to a microsecond precision.
          default: 0s
        endTime:
          type: string
          description: >
            The end of the time segment. Expressed as a number of seconds as
            measured from the start of the video, with "s" appended at the end.
            Fractions are allowed, up to a microsecond precision, and "Infinity"
            is allowed, which means the end of the video.
          default: Infinity
        annotationResourceLabels:
          description: Resource labels on the Annotation.
          type: object
          additionalProperties:
            type: string
  dataItemResourceLabels:
    description: Resource labels on the DataItem. Overrides values set in
      ImportDataConfig at import time. Can set a user-defined label
      or the predefined `aiplatform.googleapis.com/ml_use` label, which is
      used to determine the data split and can be set to `training` and `test`.
    type: object
    additionalProperties:
      type: string

Fichiers d'entrée

Vos données d'entraînement pour la reconnaissance d'action vidéo doivent respecter les formats ci-après.

Pour importer vos données, créez un fichier JSONL ou CSV.

JSONL

JSON sur chaque ligne :
Pour en savoir plus, consultez le fichier YAML de reconnaissance d'actions.
Remarque : Les segments de temps sont utilisés pour calculer l'horodatage des actions. Les valeurs startTime et endTime de timeSegmentAnnotations peuvent être égales et correspondent à l'image clé de l'action. 



{
  "videoGcsUri': "gs://bucket/filename.ext",
  "timeSegments": [{
    "startTime": "start_time_of_fully_annotated_segment",
    "endTime": "end_time_of_segment"}],
  "timeSegmentAnnotations": [{
    "displayName": "LABEL",
    "startTime": "start_time_of_segment",
    "endTime": "end_time_of_segment"
  }],
  "dataItemResourceLabels": {
    "ml_use": "train|test"
  }
}

Exemple JSONL : reconnaissance des actions sur les vidéos :



{"videoGcsUri": "gs://demo/video1.mp4", "timeSegmentAnnotations": [{"displayName": "cartwheel", "startTime": "1.0s", "endTime": "12.0s"}], "dataItemResourceLabels": {"ml_use": "training"}}
{"videoGcsUri": "gs://demo/video2.mp4", "timeSegmentAnnotations": [{"displayName": "swing", "startTime": "4.0s", "endTime": "9.0s"}], "dataItemResourceLabels": {"ml_use": "test"}}
...

CSV

Liste des colonnes
  1. Données de validation. (Facultatif) spécification TRAINING, TEST.
  2. Le contenu à classifier ou annoter. Ce champ contient l'URI Google Cloud Storage pour la vidéo. Les URI Cloud Storage sont sensibles à la casse.
  3. Une étiquette qui identifie le mode de classification de la vidéo. Les étiquettes doivent commencer par une lettre et ne contenir que des lettres, des chiffres et des traits de soulignement. Vous pouvez spécifier plusieurs étiquettes pour une vidéo en ajoutant plusieurs lignes dans le fichier CSV, chacune identifiant la même séquence vidéo, avec une étiquette différente pour chaque ligne.
  4. Heure de début et de fin de la séquence vidéo. Ces deux champs, séparés par une virgule, identifient les heures de début et de fin de la séquence vidéo à analyser, en secondes. L'heure de début doit être inférieure à l'heure de fin. Les deux valeurs doivent être positives et comprises dans la plage de temps de la vidéo. Par exemple, 0.09845,1.3600555, où la première valeur (0,09845) est l'heure de début et la seconde valeur (1,3600555) correspond à l'heure de fin du segment vidéo que vous souhaitez étiqueter. Pour utiliser l'intégralité du contenu de la vidéo, spécifiez une heure de début de 0 et une heure de fin égale à la durée totale de la vidéo ou "inf". Exemple : 0,inf.
  5. annotation L'annotation est une étiquette avec un horodatage d'image ou un segment de temps.

Chaque ligne doit correspondre à l'un des éléments suivants :

VIDEO_URI, TIME_SEGMENT_START, TIME_SEGMENT_END, LABEL, ANNOTATION_FRAME_TIMESTAMP
 
VIDEO_URI, , , LABEL, ANNOTATION_FRAME_TIMESTAMP
 
VIDEO_URI, TIME_SEGMENT_START, TIME_SEGMENT_END, LABEL, ANNOTATION_SEGMENT_START, ANNOTATION_SEGMENT_END
 
VIDEO_URI, , , LABEL, ANNOTATION_SEGMENT_START, ANNOTATION_SEGMENT_END

Quelques exemples

Attribuez une étiquette à deux actions à des moments différents :

gs://folder/video1.avi,kick,12.90,,

gs://folder/video1.avi,catch,19.65,,

Il n'y a aucune action d'intérêt dans les deux périodes. Remarque : La dernière ligne signifie que le segment entièrement étiqueté ne peut pas contenir d'action.

gs://folder/video1.avi,,,10.0,20.0

gs://folder/video1.avi,,,25.0,40.0

Vos données d'entraînement doivent comporter au moins une étiquette et une séquence entièrement étiquetée.


Encore une fois, il n'est pas nécessaire de spécifier des données de validation pour valider les résultats du modèle entraîné. Vertex AI divise automatiquement les lignes identifiées pour l'entraînement en données d'entraînement et de validation. 80 % sont réservées à l'entraînement et 20 % à la validation.

Enregistrez le contenu sous forme de fichier CSV dans votre bucket Cloud Storage.

Suivant
Créer un ensemble de données