Ce plugin s'intègre à Docling pour apporter un traitement structuré des PDF , des documents Word et d'autres formats d'entrée à votre pipeline spaCy. Il génère des données propres et structurées dans un format textuel et crée les objets Doc
familiers de spaCy qui vous permettent d'accéder à des étendues de texte étiquetées comme des sections ou des titres, et des tableaux avec leurs données converties en pandas.DataFrame
.
Ce flux de travail facilite l'application de puissantes techniques de PNL à vos documents, notamment l'analyse linguistique, la reconnaissance d'entités nommées, la classification de texte, etc. C'est également idéal pour implémenter le chunking pour les pipelines RAG .
️ Ce package nécessite Python 3.10 ou supérieur.
pip install spacy-layout
Après avoir initialisé le préprocesseur spaCyLayout
avec un objet nlp
pour la tokenisation, vous pouvez l'appeler sur un chemin de document pour le convertir en données structurées. L'objet Doc
résultant comprend des étendues de mise en page qui correspondent au texte brut d'origine et exposent divers attributs, notamment le type de contenu et les fonctionnalités de mise en page.
import spacy
from spacy_layout import spaCyLayout
nlp = spacy . blank ( "en" )
layout = spaCyLayout ( nlp )
# Process a document and create a spaCy Doc object
doc = layout ( "./starcraft.pdf" )
# The text-based contents of the document
print ( doc . text )
# Document layout including pages and page sizes
print ( doc . _ . layout )
# Tables in the document and their extracted data
print ( doc . _ . tables )
# Layout spans for different sections
for span in doc . spans [ "layout" ]:
# Document section and token and character offsets into the text
print ( span . text , span . start , span . end , span . start_char , span . end_char )
# Section type, e.g. "text", "title", "section_header" etc.
print ( span . label_ )
# Layout features of the section, including bounding box
print ( span . _ . layout )
# Closest heading to the span (accuracy depends on document structure)
print ( span . _ . heading )
Si vous devez traiter de plus grands volumes de documents à grande échelle, vous pouvez utiliser la méthode spaCyLayout.pipe
, qui prend à la place un itérable de chemins ou d'octets et génère des objets Doc
:
paths = [ "one.pdf" , "two.pdf" , "three.pdf" , ...]
for doc in layout . pipe ( paths ):
print ( doc . _ . layout )
Après avoir traité les documents, vous pouvez sérialiser les objets Doc
structurés dans le format binaire efficace de spaCy, afin de ne pas avoir à réexécuter la conversion gourmande en ressources.
spaCy vous permet également d'appeler l'objet nlp
sur un Doc
déjà créé, afin que vous puissiez facilement appliquer un pipeline de composants pour l'analyse linguistique ou la reconnaissance d'entités nommées, utiliser la correspondance basée sur des règles ou tout ce que vous pouvez faire avec spaCy.
# Load the transformer-based English pipeline
# Installation: python -m spacy download en_core_web_trf
nlp = spacy . load ( "en_core_web_trf" )
layout = spaCyLayout ( nlp )
doc = layout ( "./starcraft.pdf" )
# Apply the pipeline to access POS tags, dependencies, entities etc.
doc = nlp ( doc )
Les tableaux sont inclus dans les étendues de mise en page avec l'étiquette "table"
et sous le raccourci Doc._.tables
. Ils exposent un attribut d'extension layout
, ainsi qu'un attribut data
, qui inclut les données tabulaires converties en pandas.DataFrame
.
for table in doc . _ . tables :
# Token position and bounding box
print ( table . start , table . end , table . _ . layout )
# pandas.DataFrame of contents
print ( table . _ . data )
Par défaut, le texte span est un espace réservé TABLE
, mais vous pouvez personnaliser la façon dont un tableau est rendu en fournissant un rappel display_table
à spaCyLayout
, qui reçoit le pandas.DataFrame
des données. Cela vous permet d'inclure les figures du tableau dans le texte du document et de les utiliser ultérieurement, par exemple lors de l'extraction d'informations avec un outil de reconnaissance d'entités nommées ou un classificateur de texte formé.
def display_table ( df : pd . DataFrame ) -> str :
return f"Table with columns: { ', ' . join ( df . columns . tolist ()) } "
layout = spaCyLayout ( nlp , display_table = display_table )
layout = spaCyLayout ( nlp )
doc = layout ( "./starcraft.pdf" )
print ( doc . _ . layout )
for span in doc . spans [ "layout" ]:
print ( span . label_ , span . _ . layout )
Attribut | Taper | Description |
---|---|---|
Doc._.layout | DocLayout | Caractéristiques de mise en page du document. |
Doc._.pages | list[tuple[PageLayout, list[Span]]] | Pages du document et étendues qu'elles contiennent. |
Doc._.tables | list[Span] | Tous les tableaux du document. |
Doc.spans["layout"] | spacy.tokens.SpanGroup | La mise en page s'étend sur le document. |
Span.label_ | str | Le type de l'étendue de mise en page extraite, par exemple "text" ou "section_header" . Voir ici pour les options. |
Span.label | int | L’ID entier de l’étiquette span. |
Span.id | int | Index en cours d'exécution de l'étendue de la mise en page. |
Span._.layout | SpanLayout | None | Caractéristiques de mise en page d'une étendue de mise en page. |
Span._.heading | Span | None | Cap le plus proche d'un travée, si disponible. |
Span._.data | pandas.DataFrame | None | Les données extraites pour les étendues de table. |
Attribut | Taper | Description |
---|---|---|
page_no | int | Le numéro de page (indexé 1). |
width | float | Page en pixels. |
height | float | Hauteur de la page en pixels. |
Attribut | Taper | Description |
---|---|---|
pages | list[PageLayout] | Les pages du document. |
Attribut | Taper | Description |
---|---|---|
x | float | Décalage horizontal du cadre de délimitation en pixels. |
y | float | Décalage vertical du cadre de délimitation en pixels. |
width | float | Largeur du cadre de délimitation en pixels. |
height | float | Hauteur du cadre de délimitation en pixels. |
page_no | int | Nombre de pages sur lesquelles se trouve l'étendue. |
spaCyLayout
spaCyLayout.__init__
Initialisez le processeur de documents.
nlp = spacy . blank ( "en" )
layout = spaCyLayout ( nlp )
Argument | Taper | Description |
---|---|---|
nlp | spacy.language.Language | L'objet nlp initialisé à utiliser pour la tokenisation. |
separator | str | Jeton utilisé pour séparer les sections dans l'objet Doc créé. Le séparateur ne fera pas partie de la durée de mise en page. Si None , aucun séparateur ne sera ajouté. La valeur par défaut est "nn" . |
attrs | dict[str, str] | Remplacez les attributs spaCy personnalisés. Peut inclure "doc_layout" , "doc_pages" , "doc_tables" , "span_layout" , "span_data" , "span_heading" et "span_group" . |
headings | list[str] | Étiquettes des titres à prendre en compte pour la détection Span._.heading . La valeur par défaut est ["section_header", "page_header", "title"] . |
display_table | Callable[[pandas.DataFrame], str] | str | Fonction pour générer la représentation textuelle du tableau dans le Doc.text ou le texte d'espace réservé. La valeur par défaut est "TABLE" . |
docling_options | dict[InputFormat, FormatOption] | Options de format transmises au DocumentConverter de Docling. |
RETOURS | spaCyLayout | L'objet initialisé. |
spaCyLayout.__call__
Traitez un document et créez un objet spaCy Doc
contenant le contenu du texte et les étendues de mise en page, disponibles via Doc.spans["layout"]
par défaut.
layout = spaCyLayout ( nlp )
doc = layout ( "./starcraft.pdf" )
Argument | Taper | Description |
---|---|---|
source | str | Path | bytes | Chemin du document à traiter ou octets. |
RETOURS | Doc | L'objet spaCy Doc traité. |
spaCyLayout.pipe
Traitez plusieurs documents et créez des objets spaCy Doc
. Vous devez utiliser cette méthode si vous traitez de plus gros volumes de documents à grande échelle.
layout = spaCyLayout ( nlp )
paths = [ "one.pdf" , "two.pdf" , "three.pdf" , ...]
docs = layout . pipe ( paths )
Argument | Taper | Description |
---|---|---|
sources | Iterable[str | Path | bytes] | Chemins des documents à traiter ou octets. |
RENDEMENTS | Doc | L'objet spaCy Doc traité. |