Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Traitement par lot des images

En plus du traitement par flux, vous pouvez choisir le traitement par lot pour obtenir des informations à partir des données. Ce mode de traitement non en flux continu vous permet de créer des applications compatibles avec d'autres types de contenus multimédias.

Vous pouvez traiter par lot des fichiers image stockés dans Cloud Storage avec certains modèles. La sortie est stockée dans Cloud Storage.

Modèles compatibles

Les modèles suivants sont compatibles avec le traitement par lot :

Outil de reconnaissance de tags
Reconnaissance de produits

Types de données acceptés

Cette page explique comment traiter par lot les types de données suivants :

Données d'image

Avant de commencer

Consultez les modèles acceptés et les types de données acceptés pour le traitement par lot décrit sur cette page.
- Si vous utilisez un modèle Reconnaissance de produits, créez un Catalog et un ProductRecognitionIndex à utiliser lorsque vous créez un modèle de reconnaissance de produits pour le traitement par lot. Vous pouvez également identifier un index ou un modèle de reconnaissance de produits existant à utiliser.
- Si vous utilisez un modèle de reconnaissance de tags, créez-en un à l'aide du guide des modèles de reconnaissance de tags.
Créez un ou plusieurs buckets Cloud Storage pour les entrées et sorties du traitement par lot.
Recherchez les fichiers compatibles et importez-les dans votre bucket d'entrée Cloud Storage pour qu'ils soient traités.

Parcours utilisateur

Pour traiter par lot des données d'image, procédez comme suit :

Activez l'API Gemini Enterprise Agent Platform Vision.
Créez un processeur compatible (outil de reconnaissance de produits ou de tags).
Créez une application.
1. Entrée : ajoutez un nœud d'entrée universel qui spécifie les fichiers à traiter dans Cloud Storage.
2. Traitement : ajoutez le nœud de votre modèle.
3. Sortie : ajoutez le nœud de stockage de sortie en indiquant où les données traitées sont stockées dans Cloud Storage.
Créez des instances par lot de votre application, chacune correspondant à un emplacement d'entrée de bucket Cloud Storage.
Déployez l'application et ses instances.
Une fois l'instance de traitement par lot terminée, examinez la sortie stockée dans Cloud Storage.

Traiter des images par lot

La procédure d'envoi d'une requête de traitement par lot varie d'un modèle à l'autre. Suivez les instructions de votre modèle cible pour traiter les images par lot.

Modèle de reconnaissance de produits

Utilisez ces exemples pour traiter par lot des images avec un modèle de reconnaissance de produits.

Console

Créez une requête de traitement par lot d'images dans la console Google Cloud .

Créer une application

Ouvrez l'onglet Applications du tableau de bord Vision de Gemini Enterprise Agent Platform.

Accéder à l'onglet "Applications"
Cliquez sur le bouton Créer.
Saisissez le nom d'une application et choisissez votre région.
Cliquez sur Continuer.
Choisissez votre mode de facturation. Pour en savoir plus sur la facturation à l'utilisation et la facturation mensuelle, consultez la page des tarifs.
Cliquez sur Créer.

Spécifier les entrées de traitement par lot

Sur la page de l'éditeur d'applications graphiques, cliquez sur le nœud Universal input (Entrée universelle).
Dans le volet latéral Saisie universelle, cliquez sur Sélectionner les sources de saisie.
Sur la page Sélectionner des sources d'entrée, sélectionnez Prédiction par lot.
Cliquez sur Continuer.
Dans le volet Sources, cliquez sur Parcourir dans le champ du sélecteur d'emplacement pour indiquer où se trouvent vos fichiers dans Cloud Storage.
Facultatif. Pour spécifier d'autres sources, cliquez sur Ajouter un élément et répétez l'étape précédente.
Cliquez sur Envoyer.

Ajouter le modèle

Sur la page de l'éditeur d'applications graphiques, cliquez sur le nœud du modèle Reconnaissance de produits dans la section Modèles spécialisés.
Dans le volet Reconnaissance de produits, cliquez sur Sélectionner un modèle.
Sélectionnez Sélectionner un modèle de reconnaissance de produits existant.

Si vous devez créer un modèle ou un index, sélectionnez l'option correspondante pour créer les ressources.
Choisissez le modèle dans la liste.
Cliquez sur Sélectionner.
Facultatif. Modifiez le seuil de confiance.
Cliquez sur Appliquer les paramètres.

Ajouter une destination de sortie

Sur la page du générateur d'applications graphiques, cliquez sur le nœud de modèle Cloud Storage dans la section Sortie.
Dans le volet Cloud Storage, cliquez sur Parcourir pour sélectionner la destination de sortie de vos prédictions par lot dans Cloud Storage.

Déployer l'application

Sur la page du générateur d'applications graphiques, cliquez sur Déployer.

API REST et ligne de commande

Pour envoyer votre demande de traitement par lot d'images, procédez comme suit.

Créez un modèle de reconnaissance de produits à l'aide de la méthode projects.locations.processors.create.

Cette requête inclut une référence aux ressources Catalog et ProductRecognitionIndex. Pour savoir comment créer des ressources Catalog et ProductRecognitionIndex, consultez le guide du modèle de reconnaissance de produits.

curl -X POST \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
 -H "Content-Type: application/json" \
 https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/processors?processor_id=product-recognition-model1 \
 -d '{
   "display_name": "DISPLAY_NAME",
   "model_type": PRODUCT_RECOGNIZER,
   "custom_processor_source_info": {
     "source_type": PRODUCT_RECOGNIZER,
     "product_recognizer_artifact": {
       "retail_product_recognition_index":"projects/PROJECT_ID/locations/LOCATION_ID/retailCatalogs/CATALOG_ID/retailProductRecognitionIndexes/INDEX_ID",
     }
   }
 }'

Créez une application avec le modèle de reconnaissance de produits que vous venez de créer. Cette requête utilise la méthode projects.locations.applications.create.

Corps de la requête (app.json) :

{
  "applicationConfigs": {
    "nodes": [
      {
        "displayName": "Universal Input",
        "name": "universal-input-0",
        "processor": "builtin:universal-input"
      },
      {
        "displayName": "Product Recognition",
        "name": "product-recognition",
        "nodeConfig": {
          "product_recognizer_config": {
            "recognition_confidence_threshold": 0.75
          }
        },
        "parents": [
          {
            "parentNode": "universal-input-0"
          }
        ],
        "processor": "projects/PROJECT_ID/locations/LOCATION_ID/processors/product-recognition-model1"
      },
      {
        "displayName": "Storage output",
        "name": "gcs-output",
        "nodeConfig": {
          "gcs_output_config": {
            "gcs_path":"gs://product_recognizer_app_output"
          }
        },
        "parents": [
          {
            "parentNode": "product-recognition"
          }
        ],
        "processor": "builtin:gcs-output"
      }
    ]
  }
}

Requête :

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -d @app.json  \
  'https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/applications?application_id=product-recognition-app'

Créez des instances de votre application à l'aide de la méthode projects.locations.applications.createApplicationInstances.

Corps de la requête (instances.json) :

 {
   "applicationInstances": [
     {
       "instance": { 
         "instanceType": "BATCH_PREDICTION",
         "inputResources": [
           {
             "consumerNode": "universal-input-0",
             "dataType": "IMAGE",
             "inputResource": "gs://product_recognition_input"
           }
         ]
       },
       "instanceId": "instance1"
     },
     {
       "instance": { 
         "instanceType":"BATCH_PREDICTION",
         "inputResources": [
           {
             "consumerNode": "universal-input-0",
             "dataType": "IMAGE",
             "inputResource": "gs://product_recognition_input2"
           }
         ]
       },
       "instanceId": "instance2"
     }
   ]
 }

Requête :

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -d @instances.json \
  'https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/applications/product-recognition-app:createApplicationInstances'

Déployez l'application.

 curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -d '{}' \
   'https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/applications/product-recognition-app:deploy'

Obtenez les instances d'application. Ces informations vous indiquent quand le traitement par lot est terminé.

Plus précisément, le champ state indique quand le traitement est terminé : "state": "FINISHED". Une fois l'instance terminée, vous ne pouvez plus la modifier.

Vous pouvez utiliser la méthode projects.locations.applications.instances.list pour suivre les instances. De même, pour supprimer des instances de cette liste, utilisez la méthode projects.locations.applications.deleteApplicationInstances.

Requête :

 curl -X GET \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json"  \
   'https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/applications/product-recognition-app/instances'

Exemple de réponse :

 {
   "instances": [
     {
       "name": "projects/PROJECT_ID/locations/LOCATION_ID/applications/product-recognition-app/instances/instance1",
       "createTime": "2023-03-30T18:30:51.991004265Z",
       "inputResources": [
         {
           "inputResource": "gs://product_recognition_input",
           "consumerNode": "universal-input-0",
           "dataType": "IMAGE"
         }
       ],
       "outputResources": [
         {
           "outputResource": "gs://product_recognition_output/instance1",
           "producerNode": "product-recognition",
           "autogen": true
         }
       ],
       "updateTime": "2023-04-18T04:58:18.592092259Z",
       "state": "FINISHED",
       "instanceType": "BATCH_PREDICTION"
     }
 }

Modèle de reconnaissance de tags

Utilisez ces exemples pour traiter par lot des images avec un modèle de reconnaissance de tags.

API REST et ligne de commande

Pour envoyer votre demande de traitement par lot d'images, procédez comme suit.

Créez un modèle de reconnaissance de tags à l'aide de la méthode projects.locations.processors.create.

Pour cela, vous devez spécifier le nom de ressource du modèle d'origine hébergé sur la plate-forme Vertex AI (vertex_model).

curl -X POST \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
 -H "Content-Type: application/json" \
 https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/processors?processor_id=tag-recognition-model1 \
 -d '{
   "display_name": "DISPLAY_NAME",
   "model_type": TAG_RECOGNIZER,
   "custom_processor_source_info": {
     "source_type": VERTEX_AUTOML,
     "vertex_model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID"
   }
 }'

Créez une application avec le modèle de reconnaissance de tags que vous venez de créer. Cette requête utilise la méthode projects.locations.applications.create.

Corps de la requête (app.json) :

 {
   "applicationConfigs": {
     "nodes": [
       {
         "displayName": "Universal Input",
         "name": "universal-input-0",
         "processor": "builtin:universal-input"
       },
       {
         "displayName": "Tag Recognition",
         "name": "tag-recognition",
         "nodeConfig": {
           "tag_recognizer_config": {
             "tag_parsing_config": {
               "entity_parsing_configs": [
                 {
                   "entity_class": "price",
                   "regex": "\\$\\d+\\.\\d{2}",
                   "entity_matching_strategy": "MAX_OVERLAP_AREA"
                 }
               ]
             },
             "entity_detection_confidence_threshold": 0.0
           }
         },
         "parents": [
           {
             "parentNode": "universal-input-0"
           }
         ],
         "processor": "projects/PROJECT_ID/locations/LOCATION_ID/processors/tag-recognition-model1"
       },
       {
         "displayName": "Storage output",
         "name": "gcs-output",
         "nodeConfig": {
           "gcs_output_config": {
             "gcs_path": "gs://tag_recognizer_app_output"
           }
         },
         "parents": [
           {
             "parentNode": "tag-recognition"
           }
         ],
         "processor": "builtin:gcs-output"
       }
     ]
   }
 }

Requête :

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -d @app.json  \
  'https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/applications?application_id=tag-recognition-app'

Créez des instances de votre application à l'aide de la méthode projects.locations.applications.createApplicationInstances.

Corps de la requête (instances.json) :

 {
   "applicationInstances": [
     {
       "instance": { 
         "instanceType": "BATCH_PREDICTION",
         "inputResources": [
           {
             "consumerNode": "universal-input-0",
             "dataType": "IMAGE",
             "inputResource": "gs://tag_recognition_input"
           }
         ]
       },
       "instanceId": "instance1"
     },
     {
       "instance": { 
         "instanceType":"BATCH_PREDICTION",
         "inputResources": [
           {
             "consumerNode": "universal-input-0",
             "dataType": "IMAGE",
             "inputResource": "gs://tag_recognition_input2"
           }
         ]
       },
       "instanceId": "instance2"
     }
   ]
 }

Requête :

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -d @instances.json \
  'https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/applications/tag-recognition-app:createApplicationInstances'

Déployez l'application.

 curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   -d '{}' \
   'https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/applications/tag-recognition-app:deploy'

Obtenez les instances d'application. Ces informations vous indiquent quand le traitement par lot est terminé.

Plus précisément, le champ state indique quand le traitement est terminé : "state": "FINISHED". Une fois l'instance terminée, vous ne pouvez plus la modifier.

Requête :

 curl -X GET \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json"  \
   'https://visionai.googleapis.com/v1alpha1/projects/PROJECT_ID/locations/LOCATION_ID/applications/tag-recognition-app/instances'

Exemple de réponse :

 {
   "instances": [
     {
       "name": "projects/PROJECT_ID/locations/LOCATION_ID/applications/tag-recognition-app/instances/instance1",
       "createTime": "2023-03-30T18:30:51.991004265Z",
       "inputResources": [
         {
           "inputResource": "gs://tag_recognition_input",
           "consumerNode": "universal-input-0",
           "dataType": "IMAGE"
         }
       ],
       "outputResources": [
         {
           "outputResource": "gs://tag_recognition_output/instance1",
           "producerNode": "tag-recognition",
           "autogen": true
         }
       ],
       "updateTime": "2023-04-18T04:58:18.592092259Z",
       "state": "FINISHED",
       "instanceType": "BATCH_PREDICTION"
     }
 }

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

Modèles compatibles

Types de données acceptés

Avant de commencer

Parcours utilisateur

Traiter des images par lot

Modèle de reconnaissance de produits

Console

API REST et ligne de commande

Modèle de reconnaissance de tags

API REST et ligne de commande

Traitement par lot des images