Dela via

funktion ai_parse_document

gäller för:markerad med ja Databricks SQL markerad med ja Databricks Runtime

Viktigt!

Den här funktionen finns i Beta.

Funktionen ai_parse_document() anropar en toppmodern generativ AI-modell från Api:er för Databricks Foundation-modell för att extrahera strukturerat innehåll från ostrukturerade dokument.

Kravspecifikation

Viktigt!

Modellen som driver den här funktionen är en del av Llama-serien med modeller och görs tillgänglig med api:er för Mosaic AI Model Serving Foundation Model. Se Tillämpliga licenser och villkor för modellutvecklare för information om vilka Llama-modeller som är tillgängliga på Databricks och de licenser och principer som styr användningen av dessa modeller. Om modeller dyker upp i framtiden som presterar bättre enligt Databricks interna riktmärken kan Databricks ändra modellerna och uppdatera dokumentationen.

  • En arbetsyta i någon av de regioner som stöds: eastus, eastus2, westus, centraluseller northcentralus.
  • Mosaic AI Agent Bricks Beta aktiverat.
  • Databricks Runtime 16.4 LTS eller senare.
  • Om du använder serverlös beräkning krävs även följande:
    • Måste vara kompatibel med Databricks Runtime 16.4 eller senare.
    • Den serverlösa miljöversionen måste vara inställd på 2 eftersom detta aktiverar funktioner som VARIANT.
    • Måste använda antingen Python eller SQL. Ytterligare serverlösa funktioner och begränsningar finns i Begränsningar för serverlös beräkning.
  • Funktionen ai_parse_document är tillgänglig med Databricks notebook-filer, SQL-redigerare, Databricks-arbetsflöden, jobb eller Lakeflow Deklarativa pipelines.
  • Se prissidan för Beta-produkter för faktureringsinformation.

Datasäkerhet

Dina dokumentdata bearbetas inom Databricks säkerhetsperimeter. Databricks lagrar inte de parametrar som skickas till anropen ai_parse_document function , men behåller information om metadatakörning, till exempel den Databricks Runtime-version som används.

Indatafilformat som stöds

Dina indatafiler måste lagras som blobdata i byte, vilket innebär en binär typkolumn i en dataram eller Delta-tabell. Om källdokumenten lagras i en Unity Catalog-volym kan kolumnen för binär typ genereras med spark-formatläsaren binaryFile .

Följande filformat stöds:

  • PDF
  • JPG/JPEG
  • PNG

Syntax

ai_parse_document(content)

ai_parse_document(content, Map("version" -> "1.0"))

Argumentpunkter

  • content: Ett BINARY uttryck som representerar inputdata för bytearray.
  • version: Den version av utdataschemat som stöds: "1.0".

Retur

Funktionen ai_parse_document extraherar kontextuella layoutmetadata från dokumentet, till exempel page_number, header, footer. Det extraherar också innehållet i dokumentet, till exempel textstycken eller tabeller och representerar det i markdown. Utdata är av VARIANT typen .

Viktigt!

Funktionens utdataschema har versioner med ett major.minor-format, som "1.0". Databricks kan uppgradera den version som stöds eller standardversionen för att återspegla förbättrade representationer baserat på pågående forskning.

  • Delversionsuppgraderingar är bakåtkompatibla och kanske bara introducerar nya fält.
  • Större versionsuppgraderingar kan omfatta icke-bakåtkompatibla ändringar, till exempel fälttillägg, borttagningar eller namnbyten.

Följande är utdataschemat:

{
  "document": {
    "pages": [
      {
        "id": INT,                 // 0-based page index
        "page_number": STRING,     // Extracted page number (NULL if not found)
        "header": STRING,          // Extracted page header (NULL if not found)
        "footer": STRING,          // Extracted page footer (NULL if not found)
        "content": STRING          // Text content (markdown) of the entire page
      }
    ],
    "elements": [
      {
        "id": INT,                 // 0-based element index
        "type": STRING,            // Supported: text, table, figure
        "content": STRING,         // Text content (markdown) of the target element
        "page_id": INT             // 0-based page index where the element appears
      }
    ],
  },
  "corrupted_data": [
    {
      "malformed_response": STRING  // The response in malformed json format
      "page_id": INT                // 0-based page index
    }
  ],
  "error_status": [
    {
      "error_message": STRING       // The detailed error message
      "page_id": INT                // 0-based page index
    }
  ],
  "metadata": {
    "version": STRING,              // The version of the output schema
    "backend_id": STRING            // The backend id where the document is parsed
  }
}

Exempel

I följande exempel används ai_parse_document för att extrahera dokumentlayouter som VARIANT utdata.

SQL

SELECT
  path,
  ai_parse_document(content)
FROM READ_FILES('/Volumes/path/to/source/file.pdf', format => 'binaryFile');

python

from pyspark.sql.functions import *


df = spark.read.format("binaryFile") \
  .load("/Volumes/path/to/source/file.pdf") \
  .withColumn(
    "parsed",
    ai_parse_document("content"))
display(df)

Scala

import org.apache.spark.sql.functions._


val df = spark.read.format("binaryFile")
  .load("/Volumes/path/to/source/file.pdf")
  .withColumn(
    "parsed",
    ai_parse_document($"content"))
display(df)

I följande exempel används ai_parse_document för att avgränsa varje fält på den översta nivån i utdata, document.pagestill exempel , document.elements, corrupted_data, error_statusoch metadata i enskilda kolumner.

SQL

WITH corpus AS (
  SELECT
    path,
    ai_parse_document(content) AS parsed
  FROM
    READ_FILES('/Volumes/path/to/source/file.pdf', format => 'binaryFile')
)
SELECT
  path,
  parsed:document:pages,
  parsed:document:elements,
  parsed:corrupted_data,
  parsed:error_status,
  parsed:metadata
FROM corpus;

python

from pyspark.sql.functions import *


df = spark.read.format("binaryFile") \
 .load("/Volumes/path/to/source/file.pdf") \
 .withColumn(
   "parsed",
   ai_parse_document("content")) \
 .withColumn(
   "parsed_json",
   parse_json(col("parsed").cast("string"))) \
 .selectExpr(
   "path",
   "parsed_json:document:pages",
   "parsed_json:document:elements",
   "parsed_json:corrupted_data",
   "parsed_json:error_status",
   "parsed_json:metadata")
display(df)

Scala


import com.databricks.sql.catalyst.unstructured.DocumentParseResultV1_0
import org.apache.spark.sql.functions._


val df = spark.read.format("binaryFile")
 .load("/Volumes/path/to/source/file.pdf")
 .withColumn(
   "parsed",
   ai_parse_document($"content").cast(DocumentParseResultV1_0.SCHEMA))
 .select(
   $"path",
   $"parsed.*")
display(df)

Begränsningar

  • Databricks arbetar kontinuerligt för att förbättra alla dess funktioner, men LLM:er är en ny teknik och kan orsaka fel.
  • Funktionen ai_parse_document kan ta tid att extrahera dokumentinnehåll samtidigt som strukturell information bevaras, särskilt för dokument som innehåller mycket tätt innehåll eller innehåll med dålig upplösning. I vissa fall kan det ta en stund för funktionen att köra eller ignorera innehåll. Databricks arbetar kontinuerligt för att förbättra svarstiden.
  • Se Indatafilformat som stöds. Databricks välkomnar feedback om vilka ytterligare format som är viktigast för din organisation.
  • Det går inte att anpassa den modell som driver ai_parse_document eller använder en kundanpassad modell för ai_parse_document .
  • Den underliggande modellen kanske inte fungerar optimalt när du hanterar bilder med text i icke-latinska alfabet, till exempel japanska eller koreanska.
  • Dokument med digitala signaturer kanske inte bearbetas korrekt.