Catégories :

Fonctions de chaîne et fonctions binaires (Fonctions AI)

AI_EXTRACT

Extrait les informations d’une chaîne ou d’un fichier d’entrée.

Syntaxe

Extraire des informations d’une chaîne d’entrée :

AI_EXTRACT( <text>, <responseFormat> )
AI_EXTRACT( text => <text>,
            responseFormat => <responseFormat> )

Extraire des informations d’un fichier :

AI_EXTRACT( <file>, <responseFormat> )
AI_EXTRACT( file => <file>,
            responseFormat => <responseFormat>,
            [ config => <config_object> ]

Arguments

text

Une chaîne d’entrée pour l’extraction.

file

Un FILE pour l’extraction.

Formats de fichiers pris en charge :

  • PDF

  • PNG

  • PPTX, PPT

  • EML

  • DOC, DOCX

  • JPEG, JPG

  • HTM, HTML

  • TEXT, TXT

  • TIF, TIFF

  • BMP, GIF, WEBP

  • MD

La taille des fichiers ne doit pas dépasser 100 MB.

responseFormat

Informations à extraire. Le format dépend du type d’extraction.

Formats d’extraction d’entités

Extrayez des valeurs uniques en fournissant l’un des formats suivants :

  • Schéma d’objet simple qui mappe l’étiquette et les informations à extraire :

    {'name': 'What is the last name of the employee?', 'address': 'What is the address of the employee?'}
    
  • Tableau de chaînes contenant les informations à extraire :

    ['What is the last name of the employee?', 'What is the address of the employee?']
    
  • Un tableau de tableaux contenant deux chaînes (l’étiquette et les informations à extraire) :

    [['name', 'What is the last name of the employee?'], ['address', 'What is the address of the employee?']]
    
  • Un schéma JSON avec 'type': 'string' sur le sous-objet :

    {
      'schema': {
        'type': 'object',
        'properties': {
          'title': {
            'description': 'What is the title of the document?',
            'type': 'string'
          }
        }
      }
    }
    

Format d’extraction de liste

Extraire des tableaux de valeurs à l’aide d’un schéma JSON avec``”type”: “array”`` sur le sous-objet :

{
  'schema': {
    'type': 'object',
    'properties': {
      'employees': {
        'description': 'What are the names of employees?',
        'type': 'array'
      }
    }
  }
}

Format d’extraction de table

Extraire des données tabulaires à l’aide d’un schéma JSON avec 'type': 'object' et``column_ordering``. Chaque colonne est définie comme une propriété imbriquée avec``”type”: “array”`` et une description qui correspond au nom de colonne dans le fichier :

{
  'schema': {
    'type': 'object',
    'properties': {
      'income_table': {
        'description': 'Income for FY2026Q2',
        'type': 'object',
        'column_ordering': ['month', 'income'],
        'properties': {
          'month': {
            'description': 'Month',
            'type': 'array'
          },
          'income': {
            'description': 'Income',
            'type': 'array'
          }
        }
      }
    }
  }
}

Note

  • Vous ne pouvez pas combiner le format de schéma JSON avec d’autres formats de réponse. Si responseFormat contient la clé schema, vous devez définir toutes les questions à l’intérieur du schéma JSON. Les clés supplémentaires ne sont pas prises en charge.

  • Le modèle n’accepte que certaines formes de schéma JSON. Le type de niveau supérieur doit toujours être un objet, qui contient des sous-objets extraits indépendamment. Les sous-objets peuvent être une table (objet de listes de chaînes représentant des colonnes), une liste de chaînes ou une chaîne.

    Chaîne est actuellement le seul type scalaire pris en charge.

  • Utilisez le champ description pour fournir un contexte au modèle ; par exemple, pour aider le modèle à localiser la table droite dans un document. Vous pouvez saisir le nom de l’en-tête de colonne ou décrire la colonne d’une autre manière.

  • Utilisez le champ column_ordering pour spécifier l’ordre de toutes les colonnes de la table extraite. Le champ column_ordering est sensible à la casse et doit correspondre aux noms de colonnes définis dans le champ properties. L’ordre doit refléter l’ordre des colonnes du document.

config => config_object

Une valeur OBJECT qui spécifie les paramètres de configuration. Vous pouvez utiliser une constante OBJECT pour spécifier cet objet.

Vous pouvez spécifier les paires clé-valeur suivantes dans cet objet :

Clé

Description

scale_factor

Une valeur numérique de 1.0 à 4.0. Met à l’échelle les pages d’un fichier d’entrée avant qu’elles ne soient traitées par le modèle sous-jacent, qui peut améliorer la qualité OCR et les résultats d’extraction.

Utilisez scale_factor si vous recevez des réponses inattendues ou peu claires dans les scénarios suivants :

  • Documents dont la taille des pages est supérieure à A4

  • Documents contenant de petits textes, des éléments visuels détaillés ou des mises en page denses

  • Le texte extrait contient des fautes de frappe ou des erreurs OCR au niveau des caractères

Si omis,AI_EXTRACT utilise la valeur par défaut ('scale_factor': 1.0').

Renvoie

Un objet JSON contenant les informations extraites. La structure de la réponse dépend du type d’extraction.

Extraction d’entités

Renvoie un objet JSON avec des paires clé-valeur pour chaque entité extraite :

{
  "error": null,
  "response": {
    "title": "Financial report"
  }
}

Extraction de listes

Renvoie un objet JSON avec des tableaux de valeurs extraites :

{
  "error": null,
  "response": {
    "employees": [
      "Smith",
      "Johnson",
      "Doe"
    ]
  }
}

Extraction de table

Renvoie un objet JSON avec des tableaux de colonnes représentant la table extraite :

{
  "error": null,
  "response": {
    "income_table": {
      "income": ["$120 678","$130 123","$150 998"],
      "month": ["February", "March", "April"]
    }
  }
}

Extraction combinée

Lors de l’extraction d’entités, de listes et de tables dans un seul appel, la réponse contient tous les types d’extraction :

{
  "error": null,
  "response": {
    "employees": [
      "Smith",
      "Johnson",
      "Doe"
    ],
    "income_table": {
      "income": ["$120 678","$130 123","$150 998"],
      "month": ["February", "March", "April"]
    },
    "title": "Financial report"
  }
}

Exigences en matière de contrôle d’accès

Les utilisateurs doivent utiliser un rôle auquel le rôle de base de données SNOWFLAKE.CORTEX_USER a été accordé. Pour plus d’informations sur l’octroi de ce privilège, voir Privilèges LLM Cortex.

Notes sur l’utilisation

  • AI_EXTRACT est optimisé pour les documents numériques et numérisés.

  • Vous ne pouvez pas utiliser les deux paramètres text et file simultanément dans le même appel de fonction.

  • Vous pouvez soit poser des questions en langage naturel, soit décrire les informations à extraire (comme la ville, la route, le code ZIP) ; par exemple :

    ['address': 'City, street, ZIP', 'name': 'First and last name']
    
  • Les langues suivantes sont prises en charge :

    • Arabe

    • Bengali

    • Birman

    • Cebuano

    • Chinois

    • Tchèque

    • Néerlandais

    • Anglais

    • Français

    • Allemand

    • Hébreu

    • Hindi

    • Indonésien

    • Italien

    • Japonais

    • Khmer

    • Coréen

    • Lao

    • Malais

    • Persan

    • Polonais

    • Portugais

    • Russe

    • Espagnol

    • Tagalog

    • Thaïlandais

    • Turc

    • Ourdou

    • Vietnamien

  • Les documents ne doivent pas dépasser 125 pages.

  • Dans un seul appel AI_EXTRACT, vous pouvez poser un maximum de 100 questions pour l’extraction d’entités, et un maximum de 10 questions pour l’extraction de tables.

    Une question d’extraction de table est égale à 10 questions d’extraction d’entité. Par exemple, vous pouvez poser 4 questions sur l’extraction de tables et 60 questions sur l’extraction d’entités dans un seul appel AI_EXTRACT.

  • La longueur de sortie maximale pour l’extraction d’entités est de 512 jetons par question. Pour l’extraction de table, le modèle renvoie des réponses comportant un maximum de 4 096 jetons.

  • Les zones de préparation chiffrées côté client ne sont pas prises en charge.

  • Les scores de confiance ne sont pas pris en charge.

Considérations relatives aux clients

  • La fonction Cortex AI_EXTRACT entraîne des coûts de calcul basés sur le nombre de pages par document, de jetons d’invite d’entrée et de jetons de sortie traités.

    • Pour les formats de fichiers paginés (PDF, DOCX, TIF, TIFF), chaque page est comptée comme 970 jetons.

    • Pour les formats de fichier image (JPEG, JPG, PNG), chaque fichier image individuel est facturé comme une page et compté comme 970 jetons.

  • L’utilisation du paramètre scale_factor modifie le nombre de jetons consommés et le nombre de pages pouvant être traitées par appel :

    • Le nombre de jetons d’entrée consommés augmente proportionnellement avec``scale_factor``.

    • Le nombre maximum de pages par document pouvant être traitées par AI_EXTRACT diminue de``scale_factor``.

    Relation entre le facteur d’échelle (scale_factor) et le nombre de jetons et de pages

    Valeur scale_factor

    Nombre de jetons par page

    Nombre de pages par document

    2

    970 * 2 = 1 940 jetons

    1 25/2 = 62,5 (arrondi à 62)

    2.5

    970 * 2,5 = 2 425 jetons

    125/2,5 +50

    4

    970 * 4 = 3 880 jetons

    125/4 = 31,25 (arrondi à 31)

  • Snowflake recommande d’exécuter les requêtes qui font appel à la fonction Cortex AI_EXTRACT dans un entrepôt plus petit (pas plus grand que MEDIUM). Des entrepôts plus grands n’augmentent pas les performances.

Disponibilité régionale

AI_EXTRACT est disponible pour les comptes dans les régions suivantes :

Plateforme Cloud

Nom de la région

Amazon Web Services (AWS)

  • US Est (Virginie du Nord)

  • US Ouest (Oregon)

  • Canada (Centre)

  • Amérique du Sud (Sao Paulo)

  • EU (Irlande)

  • EU (Francfort)

  • Asie-Pacifique (Tokyo)

  • Asie-Pacifique (Sydney)

Microsoft Azure

  • Est US 2 (Virginie)

  • Ouest US 2 (Washington)

  • Sud-Central US (Texas)

  • Europe du Nord (Irlande)

  • Europe de l’Ouest (Pays-Bas)

  • Asie du Sud-Est (Singapour)

  • Australie Est (Nouvelle-Galles du Sud)

  • Inde centrale (Pune)

  • Japon Est (Tokyo)

AI_EXTRACT dispose d’une prise en charge interrégionale. pour plus d’informations sur l’activation de la prose en charge interrégionale de cortex AI, consultez Inférence interrégionale.

Conditions d’erreur

AI_EXTRACT peut produire les messages d’erreur suivants :

Message

Explication

Internal error.

Une erreur système s’est produite. Attendez et réessayez. Si le problème persiste, contactez le service d’assistance de Snowflake.

Not found.

Le fichier n’a pas été trouvé.

Provided file cannot be found.

Le fichier n’a pas été trouvé.

Provided file cannot be accessed.

L’utilisateur actuel ne dispose pas de privilèges suffisants pour accéder au fichier.

The provided file format {file_extension} isn't supported.

Le document n’est pas dans un format pris en charge.

The provided file isn't in the expected format or is client-side encrypted or is corrupted.

Le document n’est pas stocké dans une zone de préparation avec chiffrement côté serveur.

Empty request.

Aucun paramètre n’a été fourni.

Missing or empty response format.

Aucun format de réponse n’a été fourni.

Invalid response format.

Le format de réponse n’est pas un JSON valide.

Duplicate feature name found: {feature_name}.

Le format de réponse contient un ou plusieurs noms de fonctionnalités en double.

Too many questions: {number} complex and {number} simple = {number} total, complex question weight {number}.

Le nombre de questions dépasse la limite autorisée.

Maximum number of 125 pages exceeded. The document has {actual_pages} pages.

Le document dépasse la limite de 125 pages.

Page size in pixels exceeds 10000x10000. The page size is {actual_px} pixels.

L’image saisie ou la page du document converti dépasse les dimensions prises en charge.

Page size in inches exceeds 50x50 (3600x3600 pt). The page size is {actual_in} inches ({actual_pt} pt).

La page dépasse les dimensions prises en charge.

Maximum file size of 104857600 bytes exceeded. The file size is {actual_size} bytes.

Le document dépasse 100 MB.

Exemples

Extraction d’entités

  • L’exemple suivant extrait des entités du texte d’entrée à l’aide d’un schéma d’objet simple :

    SELECT AI_EXTRACT(
      text => 'John Smith lives in San Francisco and works for Snowflake',
      responseFormat => {'name': 'What is the first name of the employee?', 'city': 'What is the address of the employee?'}
    );
    
  • L’exemple suivant extrait et analyse les informations contenues dans le texte d’entrée :

    SELECT AI_EXTRACT(
      text => 'John Smith lives in San Francisco and works for Snowflake',
      responseFormat => PARSE_JSON('{"name": "What is the first name of the employee?", "address": "What is the address of the employee?"}')
    );
    
  • L’exemple suivant extrait les entités du fichier document.pdf :

    SELECT AI_EXTRACT(
      file => TO_FILE('@db.schema.files','document.pdf'),
      responseFormat => [['name', 'What is the first name of the employee?'], ['city', 'Where does the employee live?']]
    );
    
  • L’exemple suivant extrait des entités de tous les fichiers d’un répertoire sur une zone de préparation :

    Note

    Assurez-vous que la table de répertoire est activée. Pour plus d’informations, voir Manage directory tables.

    SELECT AI_EXTRACT(
      file => TO_FILE('@db.schema.files', relative_path),
      responseFormat => [
        'What is the document ID?',
        'What is the address of the company?'
      ]
    ) FROM DIRECTORY (@db.schema.files);
    
  • L’exemple suivant extrait l’entité title du fichier report.pdf en utilisant un schéma JSON :

    SELECT AI_EXTRACT(
      file => TO_FILE('@db.schema.files', 'report.pdf'),
      responseFormat => {
        'schema': {
          'type': 'object',
          'properties': {
            'title': {
              'description': 'What is the title of document?',
              'type': 'string'
            }
          }
        }
      }
    );
    

Extraction de listes

L’exemple suivant extrait la liste employees du fichier report.pdf :

SELECT AI_EXTRACT(
  file => TO_FILE('@db.schema.files', 'report.pdf'),
  responseFormat => {
    'schema': {
      'type': 'object',
      'properties': {
        'employees': {
          'description': 'What are the surnames of employees?',
          'type': 'array'
        }
      }
    }
  }
);

Extraction de table

L’exemple suivant extrait la table income_table du fichier report.pdf :

SELECT AI_EXTRACT(
  file => TO_FILE('@db.schema.files', 'report.pdf'),
  responseFormat => {
    'schema': {
      'type': 'object',
      'properties': {
        'income_table': {
          'description': 'Income for FY2026Q2',
          'type': 'object',
          'column_ordering': ['month', 'income'],
          'properties': {
            'month': {
              'description': 'Month',
              'type': 'array'
            },
            'income': {
              'description': 'Income',
              'type': 'array'
            }
          }
        }
      }
    }
  }
);

Extraction combinée

L’exemple suivant extrait une table (income_table), une entité (title) et une liste (employees) du fichier report.pdf en un seul appel :

SELECT AI_EXTRACT(
  file => TO_FILE('@db.schema.files', 'report.pdf'),
  responseFormat => {
    'schema': {
      'type': 'object',
      'properties': {
        'income_table': {
          'description': 'Income for FY2026Q2',
          'type': 'object',
          'column_ordering': ['month', 'income'],
          'properties': {
            'month': {
              'description': 'Month',
              'type': 'array'
            },
            'income': {
              'description': 'Income',
              'type': 'array'
            }
          }
        },
        'title': {
          'description': 'What is the title of document?',
          'type': 'string'
        },
        'employees': {
          'description': 'What are the surnames of employees?',
          'type': 'array'
        }
      }
    }
  }
);

Extraction avec un facteur d’échelle personnalisé

L’exemple suivant extrait le tableau employees du fichier report.pdf en utilisant un facteur d’échelle de 2.0 :

SELECT AI_EXTRACT(
  file => TO_FILE('@db.schema.files', 'report.pdf'),
  responseFormat => {
    'schema': {
      'type': 'object',
      'properties': {
        'employees': {
          'description': 'What are the surnames of employees?',
          'type': 'array'
        }
      }
    }
  },
  config => {'scale_factor': 2.0}
);

Extraction à l’aide d’un modèle arctic-extract affiné

Pour utiliser le modèle arctic-extract mis au point pour l’inférence avec la fonction AI_EXTRACT, spécifiez le modèle à l’aide du paramètre model, comme indiqué dans l’exemple suivant :

SELECT AI_EXTRACT(
  model => 'db.schema.my_tuned_model',
  file => TO_FILE('@db.schema.files','document.pdf')
);

Vous pouvez écraser les questions utilisées pour la mise au point en utilisant le paramètre responseFormat comme indiqué dans l’exemple suivant :

SELECT AI_EXTRACT(
  model => 'db.schema.my_tuned_model',
  file => TO_FILE('@db.schema.files','document.pdf'),
  responseFormat => [['name', 'What is the first name of the employee?'], ['city', 'Where does the employee live?']]
);

L’exemple suivant extrait les données du fichier invoice.pdf, en utilisant un modèle arctic-extract affiné et un facteur d’échelle de 2,0 :

SELECT AI_EXTRACT(
  model => 'db.schema.my_tuned_model',
  file => TO_FILE('@db.schema.files', 'invoice.pdf'),
  config => {'scale_factor': 2.0}
);

Pour plus d’informations, voir Mise au point des modèles arctic-extract.