Créer une application

Cette page explique comment créer une application et combiner des composants, tels que des flux d'entrée, des modèles pour l'analyse et des entrepôts pour le stockage, à l'aide de la plate-forme d'applications de Vertex AI Vision.

Pour créer une application, vous devez tenir compte de vos sources de données, de l'analyse que vous souhaitez effectuer et de la manière dont vous souhaitez stocker les résultats. Une application de bout en bout peut prendre différentes formes selon votre cas d'utilisation. Par conséquent, la façon dont vous créez une application dépendra de votre objectif.

Avant de commencer, évaluez votre cas d'utilisation et votre objectif du point de vue de l'IA responsable. Réfléchissez à l'impact que vos modèles et applications pourraient avoir sur vos utilisateurs finaux en cas de problème. Découvrez les premières étapes à suivre pour évaluer l'équité de votre cas d'utilisation. Assurez-vous également que votre utilisation de Vertex AI Vision est conforme aux Conditions d'utilisation de Google Cloudou à une variante hors connexion, ainsi qu'aux conditions d'utilisation des URL intégrées, comme le Règlement sur l'utilisation autorisée de Google Cloud.

Lorsque vous créez votre application, gardez à l'esprit que les technologies de vision par IA peuvent renforcer ou introduire des biais injustes et avoir un impact sur les droits humains fondamentaux. Le développement de votre application doit inclure une réflexion éthique basée sur les valeurs de votre entreprise, ainsi qu'une diligence raisonnable juridique pour votre cas d'utilisation spécifique, y compris les cas d'utilisation à haut risque. Comme pour toutes les technologies, vous devez tenir compte de toutes les lois et réglementations applicables régissant votre utilisation des technologies d'IA/ML dans la région où vous les implémentez. Il incombe aux clients de faire preuve de la diligence requise pour implémenter des cas d'utilisation considérés comme à risque élevé dans une région donnée.

Créer une application

Avant de pouvoir ajouter des composants tels qu'un flux ou des modèles à une application, vous devez créer l'application elle-même. Pour être déployées, toutes les applications doivent contenir les éléments suivants :

• Nœud d'entrée de flux (source de données).
• Au moins un autre nœud de composant, tel qu'un modèle ou un entrepôt.

Créer une application personnalisée

Créer une application à l'aide d'un modèle

Ajouter une entrée de flux

Une application doit contenir un nœud de flux vidéo. Vous ne pouvez pas déployer l'application si vous n'ajoutez pas de nœud Streams.

Si votre application n'est pas déployée, la modification de l'entrée de flux sera automatiquement appliquée à l'application. Si votre application est déjà déployée, vous devez la supprimer et la mettre à jour pour que les modifications soient appliquées. Pour en savoir plus, consultez la section Mettre à jour une application.

POST https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput

{
  "applicationStreamInputs": [
     {
       "streamWithAnnotation": {
         "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID"
       }
     },
     {
       "streamWithAnnotation": {
         "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID"
       }
     }
   ]
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput"

$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://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput" | Select-Object -Expand Content

Ajouter une entrée de flux avec des annotations de nœud

Lorsque vous créez un flux d'entrée d'application, vous pouvez ajouter des annotations au flux à l'aide de l'API Vertex AI Vision. Vous pouvez également ajouter des annotations à un nœud dans la consoleGoogle Cloud .

POST https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput

{
  "applicationStreamInputs": [
    {
      "streamWithAnnotation": {
        "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID",
        "nodeAnnotations": [
          {
            "node": "NODE_NAME",
            "annotations": [
              {
                "id": "ANNOTATION_ID",
                "displayName": "ANNOTATION_DISPLAYNAME",
                "sourceStream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID",
                "type": ANNOTATION_TYPE,
                "activeZone": {
                  "normalizedVertices": {
                    "x": 0.07434944,
                    "y": 0.18061674
                  },
                  "normalizedVertices": {
                    "x": 0.64684016,
                    "y": 0.16079295
                  },
                  "normalizedVertices": {
                    "x": 0.6047088,
                    "y": 0.92070484
                  },
                  "normalizedVertices": {
                    "x": 0.1251549,
                    "y": 0.76651984
                  }
                }
              }
            ]
          }
        ]
      }
    }
  ]
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput"

$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://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput" | Select-Object -Expand Content

Supprimer l'entrée du flux

POST https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:removeStreamInput

{
  "targetStreamInputs": [
     {
       "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID"
     },
     {
       "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID"
     }
   ]
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:removeStreamInput"

$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://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:removeStreamInput" | Select-Object -Expand Content

Ajouter un modèle Vertex AI Vision pré-entraîné

Une fois que vous avez créé une application, vous pouvez ajouter un modèle et le connecter à des flux, à d'autres modèles ou à un entrepôt de données multimédias.

Il existe deux types de modèles : les modèles pré-entraînés et les modèles entraînés par l'utilisateur. De même, les modèles entraînés par l'utilisateur peuvent également être de deux types : AutoML ou entraînés de manière personnalisée :

• Les modèles pré-entraînés remplissent un objectif spécifique, sont entraînés sur des données généralisées et sont prêts à l'emploi.
• Les modèles AutoML ou entraînés sur mesure par l'utilisateur vous obligent à identifier et à fournir des exemples de données, puis à entraîner des modèles mieux adaptés à votre cas d'utilisation spécifique. Vous entraînez ces modèles à l'aide de Vertex AI, un produit qui propose deux options d'entraînement : les modèles entraînés avec AutoML et les modèles entraînés personnalisés. Pour en savoir plus, consultez Choisir une méthode d'entraînement.

Suivez les instructions ci-dessous pour ajouter un modèle Vertex AI Vision pré-entraîné à votre graphique d'application.

Ajouter un modèle Vertex AI entraîné par l'utilisateur

Une fois que vous avez créé une application, vous pouvez ajouter un modèle et le connecter à des flux, à d'autres modèles ou à un entrepôt de données multimédias.

Il existe deux types de modèles : les modèles pré-entraînés et les modèles entraînés par l'utilisateur. De même, les modèles entraînés par l'utilisateur peuvent également être de deux types : AutoML ou entraînés de manière personnalisée :

• Les modèles pré-entraînés remplissent un objectif spécifique, sont entraînés sur des données généralisées et sont prêts à l'emploi.
• Les modèles AutoML ou entraînés sur mesure par l'utilisateur vous obligent à identifier et à fournir des exemples de données, puis à entraîner des modèles mieux adaptés à votre cas d'utilisation spécifique. Vous entraînez ces modèles à l'aide de Vertex AI, un produit qui propose deux options d'entraînement : les modèles entraînés avec AutoML et les modèles entraînés personnalisés. Pour en savoir plus, consultez Choisir une méthode d'entraînement.

Ajouter un modèle de traitement en flux continu pour la détection d'objets AutoML Vertex AI

Suivez les instructions ci-dessous pour ajouter un modèle de traitement en flux continu de détection d'objets AutoML Vertex AI que vous entraînez à votre graphique d'application.

Avant de pouvoir entraîner un modèle Vertex AI AutoML, vous devez préparer vos données de détection d'objets et créer un ensemble de données.

Entraîner un modèle à utiliser dans Vertex AI Vision

Une fois que vous avez créé un ensemble de données avec une collection représentative de données dans Vertex AI, vous pouvez entraîner un modèle à utiliser dans Vertex AI Vision.

Ajouter le modèle entraîné à votre application

Une fois l'entraînement de votre modèle terminé, vous pouvez l'ajouter à votre application Vertex AI Vision.

Ajouter un modèle personnalisé Vertex AI

Vous pouvez également importer des modèles entraînés personnalisés Vertex AI dans Vertex AI Vision pour les utiliser dans l'analyse de données. Ces modèles entraînés sur mesure doivent présenter les propriétés suivantes :

• Le modèle doit être sans état, car l'entrée du modèle correspond aux images provenant de différentes instances d'application (flux) et peut être dans le désordre. Si vous avez besoin d'un traitement de flux avec état, vous devrez peut-être conserver les états dans votre propre conteneur.
• La taille de l'entrée de votre modèle est limitée à 1,5 Mo. Par conséquent, Vertex AI Vision doit compresser l'image RVB d'origine dans un format avec pertes, tel que JPG.

Suivez les instructions ci-dessous pour ajouter à votre graphique d'application un modèle vidéo entraîné sur mesure Vertex AI que vous avez entraîné.

Pour savoir comment créer un modèle entraîné personnalisé Vertex AI avec un conteneur personnalisé, consultez Utiliser un conteneur personnalisé pour la prédiction.

Spécifier un fichier YAML d'instances

Lorsque vous ajoutez un modèle Vertex AI entraîné de manière personnalisée, vous devez spécifier un fichier YAML d'instances (instances.yaml) stocké dans Cloud Storage. Ce fichier spécifie l'entrée attendue pour le conteneur de votre modèle.

Vertex AI envoie la requête de prédiction dans un format :

{
  "instances": [
    <value>|<simple/nested list>|<object>,
    ...
  ]
}

Ici, instances.yaml définit le schéma de la charge utile. Pour en savoir plus, consultez Obtenir des prédictions en ligne avec des modèles personnalisés.

Vertex AI Vision n'est compatible qu'avec les modèles entraînés personnalisés comportant exactement une entrée de prédiction nommée. Ce type d'entrée doit être une chaîne JPEG encodée. Le schéma de l'entrée de prédiction doit être spécifié avec le fichier YAML du schéma des instances. Ce fichier YAML de schéma doit être au format d'un objet de schéma OpenAPI.

Par exemple, le schéma suivant recevra la requête avec l'image encodée dans un champ appelé image_bytes :

properties:
  image_bytes:
    type: string

Votre modèle personnalisé reçoit des entrées de prédiction au format suivant :

{
  "instances": [
    {
      "image_bytes" : {
        "b64": "BASE64_ENCODED_IMAGE_BYTES"
      }
    }
  ]
}

Avant d'importer le modèle dans Vertex AI Vision, vérifiez qu'il fonctionne correctement avec cette entrée.

Spécifier un fichier YAML de prédictions

Lorsque vous ajoutez un modèle Vertex AI entraîné sur mesure, vous pouvez spécifier un fichier YAML de prédictions (predictions.yaml) stocké dans Cloud Storage. Ce fichier spécifie la sortie du conteneur de votre modèle.

Ce fichier est facultatif, mais recommandé pour informer Vertex AI Vision de la structure de sortie de votre modèle. Par exemple, le fichier classification_1.0.0.yaml suivant décrit les informations de sortie du modèle pour un modèle de classification d'images :

title: Classification
type: object
description: >
  The predicted AnnotationSpecs.
properties:
  ids:
    type: array
    description: >
      The resource IDs of the AnnotationSpecs that had been identified.
    items:
      type: integer
      format: int64
      enum: [0]  # As values of this enum all AnnotationSpec IDs the Model
      # was trained on will be populated.
  displayNames:
    type: array
    description: >
      The display names of the AnnotationSpecs that had been identified,
      order matches the IDs.
    items:
      type: string
      enum: [""]  # As values of this enum all AnnotationSpec display_names
      # the Model was trained on will be populated.
  confidences:
    type: array
    description: >
      The Model's confidences in correctness of the predicted IDs, higher
      value means higher confidence. Order matches the Ids.
    items:
      type: number
      format: float
      minimum: 0.0
      maximum: 1.0

Ajouter le modèle entraîné personnalisé

Utilisez l'exemple suivant pour ajouter le modèle entraîné personnalisé Vertex AI à votre application.

Facultatif. Inclure des métadonnées d'application

En plus des octets d'image, vous pouvez définir attach_application_metadata pour demander à la plate-forme d'application Vertex AI Vision d'inclure les métadonnées de l'application à envoyer au conteneur personnalisé.

Les métadonnées présentent le schéma suivant :

'appPlatformMetadata': {
     'application': STRING;
     'instanceId': STRING;
     'node': STRING;
     'processor': STRING;
   }

Facultatif. Ajouter un sujet Pub/Sub de configuration dynamique

Pour contrôler de manière dynamique la fréquence d'images à laquelle l'opérateur personnalisé Vertex envoie des images vidéo aux conteneurs personnalisés Vertex, vous pouvez créer un sujet Pub/Sub. Ajoutez-le à la section Dynamic Configuration des paramètres du nœud.

Si le sujet Pub/Sub est configuré, la fréquence d'images initiale est définie sur 0. Pendant le traitement de la vidéo, vous pouvez envoyer des messages Pub/Sub au sujet Pub/Sub au format suivant en temps réel pour modifier la fréquence d'images :

{
  "stream_id": "input-stream-id",
  "fps": 5,
}

Le champ stream_id doit correspondre à l'ID du flux d'entrée de l'application.

Compte de service et autorisations

Les identifiants de service par défaut du conteneur personnalisé ont été configurés sur le compte de service appartenant à Google de la plate-forme d'application Vertex AI Vision. Pour accéder à d'autres services Google Cloudà partir du conteneur, accordez les autorisations appropriées à : service-<var>PROJECT_NUMBER</var>@gcp-sa-visionai.iam.gserviceaccount.com

Facultatif. Notification d'événements de modèle avec les fonctions Cloud Run et Pub/Sub

Dans Vertex AI Vision, les modèles reçoivent des données multimédias provenant d'appareils tels que des caméras, exécutent des prédictions d'IA sur les données et produisent des annotations en continu. Vous envoyez fréquemment ces données traitées vers une destination de données ("récepteur de données") telle qu'un entrepôt de données média ou BigQuery pour d'autres tâches d'analyse. Toutefois, il peut arriver que certaines annotations doivent être traitées différemment ou que les besoins en annotations soient urgents. Les intégrations avec les fonctions Cloud Run et Pub/Sub vous aident à répondre à ces besoins.

Modèles compatibles

Les modèles suivants proposent des intégrations pour la génération d'événements Cloud Run Functions et les notifications d'événements Pub/Sub :

• Modèle Analyse de l'occupation
• Modèles entraînés personnalisés Vertex AI

Configurer Cloud Run Functions pour traiter la sortie du modèle

Pour déclencher des notifications basées sur des événements, vous devez d'abord configurer des fonctions Cloud Run pour traiter les résultats du modèle et générer des événements.

Votre fonction Cloud Run se connecte au modèle et écoute sa sortie en tant qu'action de post-traitement. La fonction Cloud Run doit renvoyer un AppPlatformCloudFunctionResponse. Les événements (appplatformeventbody) sont envoyés au sujet Pub/Sub que vous configurerez à l'étape suivante.

Pour afficher un exemple de fonction Cloud Run, consultez Activer les notifications d'événements de modèle avec Cloud Functions et Pub/Sub.

Suivez les instructions ci-dessous pour envoyer le flux de sortie du modèle à votre fonction Cloud Run :

Activer les notifications d'événements de modèle avec Pub/Sub

Une fois que vous avez configuré les fonctions Cloud Run pour traiter les résultats du modèle et générer des événements, vous pouvez configurer les notifications d'événements avec Pub/Sub. Pour lire les messages d'un sujet, vous devez également choisir et créer un abonnement Pub/Sub.

Connecter la sortie du modèle à un nœud en aval

Après avoir créé un nœud de modèle, vous pouvez connecter sa sortie à un autre nœud.

Connecter la sortie à une destination de données

Après avoir créé le flux d'ingestion de données et ajouté les nœuds de traitement à votre application, vous devez choisir où envoyer les données traitées. Cette destination de données est le point de terminaison du graphique de votre application qui accepte les données de flux sans en produire. La destination que vous choisissez dépend de la façon dont vous utilisez les données de sortie de l'application.

Vous pouvez connecter les données de sortie de l'application aux destinations de données suivantes :

1. Vision Warehouse : stockez les données vidéo d'origine ou analysées que vous pouvez afficher et interroger.

   Pour en savoir plus sur l'envoi des données de sortie d'une application à un Vision Warehouse, consultez Connecter et stocker des données dans un entrepôt.

2. BigQuery : stockez des données dans BigQuery pour utiliser ses fonctionnalités d'analyse hors connexion.

   Pour en savoir plus sur l'envoi des données de sortie de l'application vers BigQuery, consultez Connecter et stocker des données dans BigQuery.

3. Données de diffusion en direct : si vous souhaitez un contrôle plus précis pour agir sur les données analytiques en temps réel, vous pouvez recevoir le flux en direct de votre application.

   Pour en savoir plus sur le streaming direct des données de sortie de l'application, consultez Activer la sortie de flux en direct.

Mettre à jour une application

Applications non déployées

Modifiez l'application (par exemple, en ajoutant ou en supprimant des nœuds de composants). Vertex AI Vision enregistre automatiquement les modifications.

Étapes suivantes

• Découvrez comment déployer votre application pour ingérer et analyser des données dans Déployer une application.
• Pour savoir comment commencer l'ingestion de données à partir du flux d'entrée d'une application, consultez Créer et gérer des flux.
• Découvrez comment lister les applications et afficher les instances d'une application déployée dans Gérer les applications.
• Découvrez comment lire les données d'entrée d'une application à partir d'un flux d'ingestion ou les données de sortie d'un modèle analysé dans Lire les données de flux.