Partager via

Extraire du texte et des informations d’images en utilisant l’enrichissement par IA

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 l’enrichissement et les ensembles de compétences IA pour créer et extraire du texte pouvant faire l’objet d’une recherche à partir d’images, notamment :

  • OCR pour la reconnaissance optique de caractères du texte et des chiffres
  • Analyse d’image qui décrit des images par le biais de fonctionnalités visuelles
  • Compétences personnalisées pour appeler tout traitement d’image externe que vous souhaitez fournir

En utilisant OCR, vous pouvez extraire du texte et des photos ou des images, telles que le mot STOP dans un signe d’arrêt. Grâce à l’analyse de l’image, vous pouvez générer une représentation textuelle d’une image, telle que le pissenlit pour une photo d’un pidelion, ou la couleur jaune. Vous pouvez également extraire des métadonnées de l’image, telles que sa taille.

Cet article décrit les principes fondamentaux de l’utilisation d’images dans des ensembles de compétences et décrit également plusieurs scénarios courants, tels que l’utilisation d’images incorporées, de compétences personnalisées et la superposition de visualisations sur des images d’origine.

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

  • Les fichiers sources qui incluent des images
  • Un indexeur de recherche, configuré pour les actions d’image
  • Un ensemble de compétences avec des compétences intégrées ou personnalisées qui appellent la reconnaissance optique de caractères ou l’analyse d’image
  • Un index de recherche avec des champs pour recevoir la sortie texte analysée, ainsi que des mappages de champs de sortie dans l’indexeur qui établissent l’association

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 les fichiers sources

Le traitement d’images est piloté par l’indexeur, ce qui signifie que les entrées brutes doivent se trouver dans une source de données prise en charge.

  • Analyse d’image prend en charge JPEG, PNG, GIF et BMP
  • OCR prend en charge JPEG, PNG, BMP et TIF

Les images peuvent être des fichiers binaires autonomes ou incorporées dans des documents tels que des fichiers PDF, RTF ou d’application Microsoft. Un maximum de 1 000 images peuvent être extraites d’un document donné. Si un document contient plus de 1 000 images, les 1 000 premières sont extraites, puis un avertissement est généré.

Azure Blob Storage est le stockage le plus fréquemment utilisé pour le traitement d’images dans Azure AI Search. Trois tâches principales sont liées à la récupération d’images à partir d’un conteneur d’objets blob :

Configurer des indexeurs pour le traitement d’image

Une fois les fichiers sources configurés, activez la normalisation des images en définissant le paramètre imageAction 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 imageAction (définition de ce paramètre à autre que none) entraîne des frais supplémentaires pour l’extraction d’images en fonction de la tarification Azure AI Search.

Les ajustements de métadonnées sont capturés dans un type complexe créé pour chaque image. Vous ne pouvez pas refuser l’exigence de normalisation de l’image. Les compétences qui effectuent des itérations sur les images, comme la reconnaissance optique de caractères et l’analyse des images, attendent des images normalisées.

  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 en pixels. La valeur par défaut est de 2 000. La valeur maximale est de 10 000.

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

    La valeur par défaut de 2 000 pixels pour la largeur et la hauteur maximale des images normalisées est basée sur les tailles maximales prises en charge par la compétence OCR et la compétence d’analyse d’image. La compétence OCR prend en charge une largeur maximale et une hauteur de 4 200 pour les langues non anglaises, et 10 000 pour l’anglais. Si vous augmentez les limites maximales, le traitement des images plus volumineuses peut échouer en fonction de la définition de vos compétences et de la langue des documents.

  6. Si vous le souhaitez, définissez des critères de type de fichier si la charge de travail cible un type de fichier spécifique. La configuration de l’indexeur d’objets blob comprend des paramètres d’inclusion et d’exclusion de fichiers. Vous pouvez filtrer les fichiers dont vous ne voulez pas.

{
  "parameters" : { 
      "configuration" : { 
          "indexedFileNameExtensions" : ".pdf, .docx",
          "excludedFileNameExtensions" : ".png, .jpeg" 
      } 
  }
}

À 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 Descriptif
données Chaîne codée en Base64 de l’image normalisée au format JPEG.
largeur Largeur de l’image normalisée en pixels.
hauteur 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 un appareil photo 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. Le contentOffset pour les images extraites de documents PDF est toujours à la fin du texte de la page à partir de laquelle il a été extrait 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 dans la page.
numéro de page 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.
boundingPolygon Si l’image a été extraite ou rendue à partir d’un fichier PDF, ce champ contient les coordonnées du polygone englobant qui entoure l’image sur la page. Le polygone est représenté sous la forme d’un tableau imbriqué de points, où chaque point a des coordonnées x et y normalisées aux dimensions de la page. Cela s’applique uniquement aux images extraites à l’aide imageAction: generateNormalizedImagesde .

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,
    "boundingPolygon": "[[{\"x\":0.0,\"y\":0.0},{\"x\":500.0,\"y\":0.0},{\"x\":0.0,\"y\":300.0},{\"x\":500.0,\"y\":300.0}]]"
  }
]

Remarque

Les données de polygones englobantes sont représentées sous forme de chaîne contenant un tableau codé au format JSON double imbriqué. Chaque polygone est un tableau de points, où chaque point a des coordonnées x et y. Les coordonnées sont relatives à la page PDF, avec l’origine (0, 0) en haut à gauche. Actuellement, les images extraites à l’aide imageAction: generateNormalizedImages produisent toujours un polygone unique, mais la structure double imbriquée est maintenue pour assurer la cohérence avec la compétence Disposition du document, qui prend en charge plusieurs polygones.

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.

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

  2. Ajoutez des modèles pour OCR et Analyse des images à partir du portail Azure ou copiez les définitions de la documentation de référence sur les compétences . Insérez-les dans le tableau de compétences de votre définition d’ensemble de compétences.

  3. Si nécessaire, incluez une clé multiservices dans la propriété des services Azure AI de l’ensemble de compétences. Azure AI Search effectue des appels à une ressource Azure AI Services facturable pour l’OCR et l’analyse d’images pour les transactions qui dépassent la limite gratuite (20 par indexeur par jour). Les services Azure AI doivent se trouver dans la même région que votre service de recherche.

  4. Si les images d’origine sont incorporées dans des fichiers PDF ou d’application de type PPTX ou DOCX, vous devez ajouter une compétence Fusion de texte pour que la sortie contienne à la fois les images et le texte. L’utilisation d’images incorporées est abordée plus loin dans cet article.

Une fois que l’infrastructure de base de votre ensemble de compétences est créée et que les services Azure AI sont configurés, 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.

Remarque

Pour obtenir un exemple d’ensemble de compétences qui combine le traitement d’images avec le traitement en langage naturel en aval, consultez le didacticiel REST : Utiliser REST et l’IA pour générer du contenu pouvant faire l’objet d’une recherche à partir d’objets blob 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.

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.

  • /document/normalized_images/*/pages est pour les documents traités en segments (pages).

Que vous utilisiez l’OCR et l’analyse des images, les entrées ont pratiquement la même construction :

    {
      "@odata.type": "#Microsoft.Skills.Vision.OcrSkill",
      "context": "/document/normalized_images/*",
      "detectOrientation": true,
      "inputs": [
        {
          "name": "image",
          "source": "/document/normalized_images/*"
        }
      ],
      "outputs": [ ]
    },
    {
      "@odata.type": "#Microsoft.Skills.Vision.ImageAnalysisSkill",
      "context": "/document/normalized_images/*",
      "visualFeatures": [ "tags", "description" ],
      "inputs": [
        {
          "name": "image",
          "source": "/document/normalized_images/*"
        }
      ],
      "outputs": [ ]
    }

Mapper des sorties à des champs de recherche

Dans un ensemble de compétences, la sortie de la compétence OCR et Analyse d’image est toujours du texte. 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.

  1. Dans l’ensemble de compétences, passez en revue la section outputs de chaque compétence pour déterminer les nœuds qui existent dans le document enrichi :

    {
  "@odata.type": "#Microsoft.Skills.Vision.OcrSkill",
  "context": "/document/normalized_images/*",
  "detectOrientation": true,
  "inputs": [ ],
  "outputs": [
    {
      "name": "text",
      "targetName": "text"
    },
    {
      "name": "layoutText",
      "targetName": "layoutText"
    }
  ]
}

  2. Créez ou mettez à jour un index de recherche pour ajouter des champs pour accepter les sorties de compétence.

    Dans l’exemple de collection de champs suivant, le contenu est du 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).

    Texte et layoutText sont des sorties de compétence OCR et doivent être une collection de chaînes afin de capturer toutes les sorties générées par OCR pour l’ensemble du document.

      "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": "merged_content",
      "type": "Edm.String",
      "filterable": false,
      "retrievable": true,
      "searchable": true,
      "sortable": false
    },
    {
      "name": "text",
      "type": "Collection(Edm.String)",
      "filterable": false,
      "retrievable": true,
      "searchable": true
    },
    {
      "name": "layoutText",
      "type": "Collection(Edm.String)",
      "filterable": false,
      "retrievable": true,
      "searchable": true
    }
  ],

  3. Mettez à jour l’indexeur 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/*/text",
      "targetFieldName": "text"
    },
    {
      "sourceFieldName": "/document/normalized_images/*/layoutText",
      "targetFieldName": "layoutText"
    }
  ]

  4. Exécutez l’indexeur pour appeler la récupération des documents sources, le traitement d’image 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 comme 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": "*",
    "select": "metadata_storage_name, text, layoutText, imageCaption, imageTags"
}

L’OCR reconnaît le texte dans les fichiers image. Cela signifie que les champs OCR (texte et layoutText) sont vides si les documents sources sont du texte pur ou des images pures. De même, les champs d’analyse d’image (imageCaption et imageTags) sont vides si les entrées de document source sont strictement textuelles. L’exécution de l’indexeur émet des avertissements si les entrées d’imagerie sont vides. Ces avertissements sont attendus quand les nœuds ne sont pas remplis dans le document enrichi. Rappelez-vous que l’indexation d’objets blob vous permet d’inclure ou d’exclure des types de fichiers si vous voulez travailler avec des types de contenu spécifiques. Vous pouvez utiliser ces paramètres pour réduire le bruit pendant les exécutions de l’indexeur.

Une autre requête permettant de vérifier les résultats peut inclure le champ contenu et le champ contenu_fusionné. Notez que ces champs incluent du contenu pour n’importe quel fichier blob, même ceux où aucun traitement d’image n’a été effectué.

À propos des sorties des compétences

Les sorties de compétence incluent text (OCR), layoutText (OCR), merged_content, captions (analyse d’images), tags (analyse d’images) :

  • text stocke la sortie générée par OCR. Ce nœud doit être mappé à un champ de type Collection(Edm.String). Il y a un seul champ text par document de recherche, constitué de chaînes délimitées par des virgules pour les documents qui contiennent plusieurs images. L’illustration suivante montre la sortie OCR pour trois documents. Le premier est un document contenant un fichier sans images. Deuxièmement, un document (fichier image) contenant un mot, Microsoft. Le troisième est un document contenant plusieurs images, certaines sans aucun texte ("",).

    "value": [
    {
        "@search.score": 1,
        "metadata_storage_name": "facts-about-microsoft.html",
        "text": []
    },
    {
        "@search.score": 1,
        "metadata_storage_name": "guthrie.jpg",
        "text": [ "Microsoft" ]
    },
    {
        "@search.score": 1,
        "metadata_storage_name": "Azure AI services and Content Intelligence.pptx",
        "text": [
            "",
            "Microsoft",
            "",
            "",
            "",
            "Azure AI Search and Augmentation Combining Microsoft Azure AI services and Azure Search"
        ]
    }
]

  • layoutText stocke les informations générées par OCR sur l’emplacement du texte dans la page, décrites en termes de cadres englobants et de coordonnées de l’image normalisée. Ce nœud doit être mappé à un champ de type Collection(Edm.String). Il y a un seul champ layoutText par document de recherche, constitué de chaînes délimitées par des virgules.

  • merged_content stocke la sortie d’une compétence Fusion de texte. Ce doit être un grand champ de type Edm.String qui contient le texte brut du document source, avec le text incorporé à la place d’une image. Si les fichiers contiennent seulement du texte, l’OCR et l’analyse d’images n’ont rien à faire, et merged_content est identique à content (une propriété de blob qui contient le contenu du blob).

  • imageCaption capture une description d’une image sous forme d’étiquettes individuelles et une description texte plus longue.

  • imageTags stocke les étiquettes concernant une image sous la forme d’une collection de mots clés. Il y a une seule collection pour toutes les images du document source.

La capture d’écran suivante est une illustration d’un PDF qui inclut du texte et des images incorporées. Le craquage de document a détecté trois images incorporées : groupe de mouettes, carte, aigle. D’autres texte de l’exemple (y compris les titres, les titres et le texte du corps) ont été extraits en tant que texte et exclus du traitement d’images.

Capture d’écran de trois images dans un fichier PDF.

La sortie de l’analyse d’images est illustrée dans le JSON suivant (résultat de la recherche). La définition de compétence vous permet de spécifier les fonctionnalités visuelles intéressantes. Pour cet exemple, les balises et les descriptions ont été produites, mais il existe plus de sorties à choisir.

  • La sortie imageCaption est un tableau de descriptions, un par image, avec des tags composés de mots seuls et d’expressions plus longues qui décrivent l’image. Remarquez les étiquettes a flock of seagulls are swimming in the water ou a close up of a bird.

  • Une sortie imageTags est un tableau d’étiquettes seules, listées dans l’ordre de création. Notez que les étiquettes se répètent. Il n’y a pas d’agrégation ou de regroupement.

 "imageCaption": [
      "{\"tags\":[\"bird\",\"outdoor\",\"water\",\"flock\",\"many\",\"lot\",\"bunch\",\"group\",\"several\",\"gathered\",\"pond\",\"lake\",\"different\",\"family\",\"flying\",\"standing\",\"little\",\"air\",\"beach\",\"swimming\",\"large\",\"dog\",\"landing\",\"jumping\",\"playing\"],\"captions\":[{\"text\":\"a flock of seagulls are swimming in the water\",\"confidence\":0.70419257326275686}]}",
      "{\"tags\":[\"map\"],\"captions\":[{\"text\":\"map\",\"confidence\":0.99942880868911743}]}",
      "{\"tags\":[\"animal\",\"bird\",\"raptor\",\"eagle\",\"sitting\",\"table\"],\"captions\":[{\"text\":\"a close up of a bird\",\"confidence\":0.89643581933539462}]}",
    . . .

 "imageTags": [
    "bird",
    "outdoor",
    "water",
    "flock",
    "animal",
    "bunch",
    "group",
    "several",
    "drink",
    "gathered",
    "pond",
    "different",
    "family",
    "same",
    "map",
    "text",
    "animal",
    "bird",
    "bird of prey",
    "eagle"
    . . .

Scénario : Images incorporées dans des PDF

Quand les images que vous voulez traiter sont incorporées dans d’autres fichiers, comme des fichiers PDF ou DOCX, le pipeline d’enrichissement extrait seulement les images, puis les passe à l’OCR ou à l’analyse d’images pour traitement. L’extraction d’images se produit pendant la phase de craquage de document, et une fois que les images sont séparées, elles le restent, sauf si vous refusionnez explicitement la sortie traitée dans le texte source.

La fusion de texte est utilisée pour remettre la sortie de traitement d’image dans le document. Bien que Fusion de texte ne soit pas une exigence stricte, elle est souvent appelée pour que la sortie d’image (texte OCR, layoutText OCR, étiquettes d’image, légendes d’image) puisse être réintroduite dans le document. Selon la compétence, la sortie d’image remplace une image binaire incorporée par un équivalent de texte en place. La sortie de l’analyse d’image peut être fusionnée à l’emplacement de l’image. La sortie OCR apparaît toujours à la fin de chaque page.

Le workflow suivant décrit le processus d’extraction, d’analyse et de fusion des images, et comment étendre le pipeline pour envoyer la sortie traitée par image dans d’autres compétences texte, comme Reconnaissance d’entités ou Traduction de texte.

  1. Après la connexion à la source de données, l’indexeur charge et décompose les documents sources, en extrayant les images et le texte, et met en file d’attente chaque type de contenu pour traitement. Un document enrichi composé uniquement d’un nœud racine (document) est créé.

  2. Les images de la file d’attente sont normalisées et passées dans des documents enrichis en tant que nœud document/normalized_images .

  3. Les enrichissements d’image s’exécutent, en "/document/normalized_images" comme entrée.

  4. Les sorties d’image sont passées à l’arborescence de documents enrichie, chaque sortie étant un nœud distinct. Les sorties varient en fonction de la compétence (text et layoutText pour OCR, étiquettes et légendes pour Analyse d’images).

  5. Facultatif mais recommandé si vous souhaitez que les documents de recherche incluent du texte et du texte d’origine image ensemble, la fusion de texte s’exécute, combinant la représentation textuelle de ces images avec le texte brut extrait du fichier. Les blocs de texte sont consolidés dans une seule chaîne volumineuse, où le texte est inséré en premier dans la chaîne, puis les balises et légendes de texte OCR.

    La sortie de Fusion de texte est maintenant le texte définitif à analyser pour les compétences en aval qui vont effectuer le traitement du texte. Par exemple, si votre ensemble de compétences inclut à la fois OCR et Reconnaissance d’entités, l’entrée de Reconnaissance d’entités doit être "document/merged_text" (targetName dans la sortie de la compétence Fusion de texte).

  6. Une fois que toutes les compétences ont été exécutées, le document enrichi est terminé. Dans la dernière étape, les indexeurs font référence aux mappages de champs de sortie pour envoyer du contenu enrichi à des champs individuels dans l’index de recherche.

L’exemple de compétences suivant crée un champ merged_text contenant le texte d’origine de votre document avec du texte reconnu par OCR incorporé à la place des images incorporées. Il comprend également une compétence Reconnaissance d’entités qui utilise merged_text comme entrée.

Syntaxe du corps de la demande

{
  "description": "Extract text from images and merge with content text to produce merged_text",
  "skills":
  [
    {
        "description": "Extract text (plain and structured) from image.",
        "@odata.type": "#Microsoft.Skills.Vision.OcrSkill",
        "context": "/document/normalized_images/*",
        "defaultLanguageCode": "en",
        "detectOrientation": true,
        "inputs": [
          {
            "name": "image",
            "source": "/document/normalized_images/*"
          }
        ],
        "outputs": [
          {
            "name": "text"
          }
        ]
    },
    {
      "@odata.type": "#Microsoft.Skills.Text.MergeSkill",
      "description": "Create merged_text, which includes all the textual representation of each image inserted at the right location in the content field.",
      "context": "/document",
      "insertPreTag": " ",
      "insertPostTag": " ",
      "inputs": [
        {
          "name":"text", "source": "/document/content"
        },
        {
          "name": "itemsToInsert", "source": "/document/normalized_images/*/text"
        },
        {
          "name":"offsets", "source": "/document/normalized_images/*/contentOffset" 
        }
      ],
      "outputs": [
        {
          "name": "mergedText", "targetName" : "merged_text"
        }
      ]
    },
    {
      "@odata.type": "#Microsoft.Skills.Text.V3.EntityRecognitionSkill",
      "context": "/document",
      "categories": [ "Person"],
      "defaultLanguageCode": "en", 
      "minimumPrecision": 0.5, 
      "inputs": [
        {
            "name": "text", "source": "/document/merged_text"
        }
      ],
      "outputs": [
        {
            "name": "persons", "targetName": "people"
        }
      ]
    }
  ]
}

À présent que vous avez un champ merged_text, vous pouvez le mapper en tant que champ pouvant faire l’objet d’une recherche dans la définition de votre indexeur. Tout le contenu de vos fichiers, y compris le texte des images, sera disponible pour une recherche.

Scénario : Visualiser les cadres englobants

Un autre scénario courant est la visualisation des informations de disposition des résultats de recherche. Par exemple, dans le cadre de vos résultats de recherche, vous pouvez vouloir mettre en évidence l’endroit où un élément de texte a été trouvé dans une image.

Étant donné que l’étape OCR est effectuée sur les images normalisées, les coordonnées de disposition sont dans l’espace d’image normalisée. Si vous devez afficher l’image d’origine, convertissez les points de coordonnées dans la disposition vers le système de coordonnées d’image d’origine.

L’algorithme suivant illustre le modèle :

/// <summary>
///  Converts a point in the normalized coordinate space to the original coordinate space.
///  This method assumes the rotation angles are multiples of 90 degrees.
/// </summary>
public static Point GetOriginalCoordinates(Point normalized,
                            int originalWidth,
                            int originalHeight,
                            int width,
                            int height,
                            double rotationFromOriginal)
{
    Point original = new Point();
    double angle = rotationFromOriginal % 360;

    if (angle == 0 )
    {
        original.X = normalized.X;
        original.Y = normalized.Y;
    } else if (angle == 90)
    {
        original.X = normalized.Y;
        original.Y = (width - normalized.X);
    } else if (angle == 180)
    {
        original.X = (width -  normalized.X);
        original.Y = (height - normalized.Y);
    } else if (angle == 270)
    {
        original.X = height - normalized.Y;
        original.Y = normalized.X;
    }

    double scalingFactor = (angle % 180 == 0) ? originalHeight / height : originalHeight / width;
    original.X = (int) (original.X * scalingFactor);
    original.Y = (int)(original.Y * scalingFactor);

    return original;
}

Scénario : Ensemble de compétences d’images personnalisées

Des images peuvent également être transmises et retournées dans des compétences personnalisées. Un ensemble de compétences encode en base64 l’image transmise dans la compétence personnalisée. Pour utiliser l’image dans la compétence personnalisée, définissez "/document/normalized_images/*/data" comme entrée dans la compétence personnalisée. Dans votre code de compétence personnalisée, décodez en base64 la chaîne avant de la convertir en image. Pour retourner une image à l’ensemble de compétences, encodez-la en base64 au préalable.

L’image est retournée en tant qu’objet avec les propriétés suivantes.

 { 
  "$type": "file", 
  "data": "base64String" 
 }

Le dépôt Exemples Python pour Azure Search contient un exemple complet implémenté en Python d’une compétence personnalisée qui enrichit les images.

Passage d’images aux compétences personnalisées

Pour les scénarios où vous avez besoin d’une compétence personnalisée pour travailler sur les images, vous pouvez faire passer des images à la compétence personnalisée et faire en sorte qu’elle retourne du texte ou des images. L’ensemble de compétences suivant provient d’un exemple.

L’ensemble de compétences suivant prend l’image normalisée (obtenue lors du craquage de document) et génère des tranches de l’image.

Exemple d’ensemble de compétences

{
  "description": "Extract text from images and merge with content text to produce merged_text",
  "skills":
  [
    {
          "@odata.type": "#Microsoft.Skills.Custom.WebApiSkill",
          "name": "ImageSkill",
          "description": "Segment Images",
          "context": "/document/normalized_images/*",
          "uri": "https://your.custom.skill.url",
          "httpMethod": "POST",
          "timeout": "PT30S",
          "batchSize": 100,
          "degreeOfParallelism": 1,
          "inputs": [
            {
              "name": "image",
              "source": "/document/normalized_images/*"
            }
          ],
          "outputs": [
            {
              "name": "slices",
              "targetName": "slices"
            }
          ],
          "httpHeaders": {}
        }
  ]
}

Exemple de compétence personnalisée

La compétence personnalisée elle-même est externe à l’ensemble de compétences. Ici, il s’agit de code Python qui effectue une boucle sur le lot d’enregistrements de requêtes dans le format de la compétence personnalisée, puis convertit la chaîne encodée en Base64 en image.

# deserialize the request, for each item in the batch
for value in values:
  data = value['data']
  base64String = data["image"]["data"]
  base64Bytes = base64String.encode('utf-8')
  inputBytes = base64.b64decode(base64Bytes)
  # Use numpy to convert the string to an image
  jpg_as_np = np.frombuffer(inputBytes, dtype=np.uint8)
  # you now have an image to work with

Comme pour renvoyer une image, retournez une chaîne encodée en base64 dans un objet JSON avec une $type propriété de fichier.

def base64EncodeImage(image):
    is_success, im_buf_arr = cv2.imencode(".jpg", image)
    byte_im = im_buf_arr.tobytes()
    base64Bytes = base64.b64encode(byte_im)
    base64String = base64Bytes.decode('utf-8')
    return base64String

 base64String = base64EncodeImage(jpg_as_np)
 result = { 
  "$type": "file", 
  "data": base64String 
}

Contenu connexe