Partager via

Générer des légendes pour les images dans une autre langue

Dans cet article, découvrez comment générer des légendes à l’aide de l’enrichissement par IA et d’un ensemble de compétences. Les images contiennent souvent des informations utiles pertinentes dans les scénarios de recherche. Vous pouvez vectoriser des images pour représenter du contenu visuel dans votre index de recherche. Vous pouvez également utiliser des ensembles d’enrichissement et de compétences IA pour créer et extraire du texte pouvant faire l’objet d’une recherche à partir d’images.

La fonctionnalité d'achèvement de conversation (aperçu) peut générer une description de chaque image de votre source de données, tandis que l'indexeur intègre cette description dans un index de recherche. Pour afficher les descriptions, exécutez une requête qui les inclut dans la réponse.

Prerequisites

Pour travailler avec du contenu d’image dans un ensemble de compétences, vous avez besoin des éléments suivants :

  • Source de données prise en charge. Nous vous recommandons de Azure Storage.
  • Fichiers ou objets blob contenant des images.
  • Accès en lecture à la source de données prise en charge. Cet article utilise l’authentification basée sur des clés, mais les indexeurs peuvent également se connecter à l’aide de l’identité search service et de l’authentification Microsoft Entra ID. Pour le contrôle d'accès en fonction du rôle, attribuez des rôles sur la source de données pour autoriser l'accès en lecture par l’identité de service. Si vous effectuez des tests sur un ordinateur de développement local, vérifiez que vous avez également accès en lecture sur la source de données supportée.
  • Indexeur de recherche, configuré pour les actions d’image.
  • Un ensemble de compétences intégrant la compétence Chat Completion.
  • Un index de recherche comportant des champs destinés à recevoir le texte généré, ainsi que des mappages de champs de sortie définis dans l’indexeur pour établir les correspondances.

Si vous le souhaitez, vous pouvez définir des projections pour accepter la sortie analysée par image dans une base de connaissances pour les scénarios d’exploration de données.

Configurer des indexeurs pour le traitement d’image

Une fois les fichiers sources configurés, activez la normalisation des images en définissant le imageAction paramètre dans la configuration de l’indexeur. La normalisation des images permet de rendre les images plus uniformes pour le traitement en aval. La normalisation des images comprend les opérations suivantes :

  • Les images de grande taille sont redimensionnées à une hauteur et une largeur maximales afin de les rendre uniformes.
  • Pour les images qui ont des métadonnées qui spécifient l’orientation, la rotation est ajustée pour un chargement vertical.

Notez que l’activation de imageAction (définition de ce paramètre sur autre que none) entraîne des frais supplémentaires pour l’extraction d’images en fonction de la tarification Azure AI Search.

  1. Créez ou mettez à jour un indexeur pour définir les propriétés de configuration :

    {
  "parameters": {
    "configuration": {
      "dataToExtract": "contentAndMetadata",
      "parsingMode": "default",
      "imageAction": "generateNormalizedImages"
    }
  }
}

  2. Définissez dataToExtract sur contentAndMetadata (obligatoire).

  3. Vérifiez que la parsingMode valeur par défaut est définie (obligatoire).

    Ce paramètre détermine la précision des documents de recherche créés dans l’index. Le mode par défaut configure une correspondance un-à-un, de façon à ce qu’un objet blob génère un seul document de recherche. Si les documents sont grands ou si les compétences nécessitent des segments de texte plus petits, vous pouvez ajouter une compétence Découpage du texte, qui subdivise un document en pages pour le traitement. Cependant, pour les scénarios de recherche, un seul objet blob par document est obligatoire si l’enrichissement comprend le traitement de l’image.

  4. Définissez imageAction de façon à activer le nœud normalized_images dans une arborescence d’enrichissement (obligatoire) :

    • generateNormalizedImages pour générer un tableau d’images normalisées dans le cadre de la décomposition des documents.

    • generateNormalizedImagePerPage (s’applique aux PDF uniquement) pour générer un tableau d’images normalisées où chaque page du document PDF est rendue dans une image de sortie. Pour les fichiers non-PDF, le comportement de ce paramètre est le même que si vous définissez generateNormalizedImages. Toutefois, notez que la définition de generateNormalizedImagePerPage peut rendre l’opération d’indexation moins performante par défaut (en particulier pour les grands documents), car plusieurs images doivent être générées.

  5. Si vous le souhaitez, ajustez la largeur ou la hauteur des images normalisées générées :

normalizedImageMaxWidth est mesuré en pixels. La valeur par défaut est 2 000. La valeur maximale est de 10 000.

normalizedImageMaxHeight est mesuré en pixels. La valeur par défaut est 2 000. La valeur maximale est de 10 000.

À propos des images normalisées

Lorsque imageAction a une valeur autre que none, le nouveau champ normalized_images contient un tableau d’images. Chaque image est un type complexe qui a les membres suivants :

Membre de l’image Description
data Chaîne codée en Base64 de l’image normalisée au format JPEG.
width Largeur de l’image normalisée en pixels.
height Hauteur de l’image normalisée en pixels.
originalWidth Largeur d’origine de l’image avant la normalisation.
originalHeight Hauteur d’origine de l’image avant la normalisation.
rotationFromOriginal Rotation dans le sens inverse des aiguilles d’une montre exprimée en degrés pour créer l’image normalisée. Valeur comprise entre 0 et 360 degrés. Cette étape lit les métadonnées de l’image générée par une caméra ou un scanneur. La valeur est généralement un multiple de 90 degrés.
contentOffset Offset de caractère à l’intérieur du champ de contenu dont l’image a été extraite. Ce champ est applicable uniquement aux fichiers contenant des images incorporées. Les contentOffset images extraites de documents PDF sont toujours à la fin du texte de la page où elles ont été extraites dans le document. Cela signifie que les images apparaissent après tout le texte de cette page, quel que soit l’emplacement d’origine de l’image sur la page.
pageNumber Si l'image a été extraite ou rendue à partir d'un PDF, ce champ contient le numéro de page du PDF à partir de laquelle elle a été extraite ou rendue, à partir de 1. Si l’image ne provient pas d’un fichier PDF, ce champ est 0.

Exemple de valeur de normalized_images :

[
  {
    "data": "BASE64 ENCODED STRING OF A JPEG IMAGE",
    "width": 500,
    "height": 300,
    "originalWidth": 5000,  
    "originalHeight": 3000,
    "rotationFromOriginal": 90,
    "contentOffset": 500,
    "pageNumber": 2
  }
]

Définir des ensembles de compétences pour le traitement d’image

Cette section complète les articles de référence sur les compétences en fournissant un contexte permettant d’utiliser des entrées, des sorties et des modèles de compétences, en ce qui concerne le traitement d’images.

  • Créez ou mettez à jour un ensemble de compétences pour ajouter des compétences.

Une fois que l’infrastructure de base de votre ensemble de compétences est créée et que Foundry Tools est configuré, vous pouvez vous concentrer sur chaque compétence d’image individuelle, définir les entrées et le contexte source et mapper les sorties aux champs d’un index ou d’une base de connaissances.

Note

Pour obtenir un exemple d’ensemble de compétences techniques qui combine le traitement d’images avec le traitement en langage naturel en aval, consultez Tutoriel REST : utilisez REST et l'IA pour générer du contenu consultable à partir des blobs Azure. Il montre comment alimenter la sortie d’image d’une compétence en reconnaissance d’entités et en extraction d’expressions clés.

Exemples d’entrées pour le traitement d’images

Comme nous l’avons vu, les images sont extraites lors de la décomposition des documents, puis elles sont normalisées à titre d’étape préliminaire. Les images normalisées sont les entrées de n’importe quelle compétence de traitement d’image et elles sont toujours représentées dans une arborescence de documents enrichie de l’une des deux façons suivantes :

  • /document/normalized_images/* est pour les documents traités comme un tout.
{
  "@odata.type": "#Microsoft.Skills.Custom.ChatCompletionSkill",
  "context": "/document/normalized_images/*",
  "uri": "https://contoso.openai.azure.com/openai/deployments/contoso-gpt-4o/chat/completions?api-version=2025-01-01-preview",
  "timeout": "PT1M",
  "apiKey": "<YOUR-API-KEY here>",
  "inputs": [
    {
      "name": "image",
      "source": "/document/normalized_images/*/data"
    },
    {
      "name": "systemMessage",
      "source": "='You are a useful artificial intelligence assistant that helps people.'"
    },
    {
      "name": "userMessage",
      "source": "='Describe what you see in this image in 20 words or less in Spanish.'"
    }
  ],
  "outputs": [
    {
      "name": "response",
      "targetName": "captionedImage"
    }
  ]
}

Exemple utilisant des réponses de schéma JSON avec des entrées de texte

Cet exemple montre comment utiliser des sorties structurées pour les modèles de langage. Cette fonctionnalité est actuellement prise en charge principalement par les modèles de langage OpenAI, bien que cela puisse changer à l’avenir.

{
  "@odata.type": "#Microsoft.Skills.Custom.ChatCompletionSkill",
  "context": "/document/content",
  "uri": "https://contoso.openai.azure.com/openai/deployments/contoso-gpt-4o/chat/completions?api-version=2025-01-01-preview",
  "timeout": "PT1M",
  "apiKey": "<YOUR-API-KEY here>",
  "inputs": [
    {
      "name": "systemMessage",
      "source": "='You are a useful artificial intelligence assistant that helps people.'"
    },
    {
      "name": "userMessage",
      "source": "='How many languages are there in the world and what are they?'"
    }
  ],
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "structured_output",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "total": {
            "type": "number"
          },
          "languages": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "required": [
          "total",
          "languages"
        ],
        "additionalProperties": false
      }
    }
  },
  "outputs": [
    {
      "name": "response",
      "targetName": "responseJsonForLanguages"
    }
  ]
}

Mapper des sorties à des champs de recherche

Le texte en sortie est représenté sous forme de nœuds dans une arborescence interne de documents enrichis, et chaque nœud doit être mappé à des champs dans un index de recherche, ou à des projections dans une base de connaissances, afin de rendre le contenu disponible dans votre application.

Tout d’abord, utilisez Create ou Update - Index pour ajouter des champs pour recevoir les résultats des compétences.

Dans l’exemple de collection de champs suivant :

  • content correspond à un contenu blob.
  • metadata_storage_name contient le nom du fichier (défini retrievable sur true).
  • metadata_storage_path est le chemin unique de l’objet blob et est la clé de document par défaut.
  • merged_content est généré à partir de la fusion de texte (utile lorsque les images sont incorporées).
  • captioned_image est une sortie de compétence et doit être un champ de chaîne pour capturer toutes les sorties du modèle de langage dans l’index de recherche.
"fields": [
  {
    "name": "content",
    "type": "Edm.String",
    "filterable": false,
    "retrievable": true,
    "searchable": true,
    "sortable": false
  },
  {
    "name": "metadata_storage_name",
    "type": "Edm.String",
    "filterable": true,
    "retrievable": true,
    "searchable": true,
    "sortable": false
  },
  {
    "name": "metadata_storage_path",
    "type": "Edm.String",
    "filterable": false,
    "key": true,
    "retrievable": true,
    "searchable": false,
    "sortable": false
  },
  {
    "name": "captioned_image",
    "type": "Edm.String",
    "filterable": false,
    "retrievable": true,
    "searchable": true,
    "sortable": false
  }
]

Ensuite, utilisez Update - Indexer pour mapper la sortie de l’ensemble de compétences (nœuds dans une arborescence d’enrichissement) aux champs d’index.

Les documents enrichis sont internes. Pour externaliser les nœuds dans une arborescence de documents enrichie, configurez un mappage de champs de sortie qui spécifie le champ d’index qui reçoit le contenu du nœud. Les données enrichies sont accessibles par votre application via un champ d’index. L’exemple suivant montre un nœud de texte (sortie OCR) dans un document enrichi mappé à un champ de texte dans un index de recherche.

"outputFieldMappings": [
  {
    "sourceFieldName": "/document/normalized_images/*/captionedImage",
    "targetFieldName": "captioned_image"
  }
]

Exécutez l’indexeur pour appeler la récupération de documents source, le traitement des images via des légendes de modèle de langage et l’indexation.

Vérifier les résultats

Exécutez une requête sur l’index pour vérifier les résultats du traitement d’image. Utilisez l’Explorateur de recherche en tant que client de recherche, ou tout outil qui envoie des requêtes HTTP. La requête suivante sélectionne les champs qui contiennent la sortie du traitement d’image.

POST /indexes/[index name]/docs/search?api-version=[api-version]
{
  "search": "A cat in a picture",
  "select": "metadata_storage_name, captioned_image"
}

Contenu connexe

  • Last updated on