Chapitre 3 : Gestion des différents types de fichiers

Introduction

Les documents du monde réel se présentent sous de nombreux formats, chacun avec des défis uniques. Ce chapitre couvre les stratégies pour gérer les PDF, les images, les tableaux et les données structurées.

Défis des PDF

Les PDF sont le format de document le plus courant, mais aussi le plus difficile :

Zones problématiques

Défi	Description	Solution
PDF scannés	Images, pas de texte	Traitement OCR
Tableaux	Structure perdue	Extracteurs spécialisés
Multi-colonnes	Ordre de lecture incorrect	Analyse de la mise en page
En-têtes/Pieds de page	Bruit répété	Filtrage

Options d'extraction de PDF

# Option 1 : Basique (PyPDF2/PyPDFLoader)
from langchain.document_loaders import PyPDFLoader
loader = PyPDFLoader("document.pdf")
# Avantages : Rapide, simple
# Inconvénients : Mauvais avec les mises en page complexes

# Option 2 : Meilleurs tableaux (PDFPlumber)
from langchain.document_loaders import PDFPlumberLoader
loader = PDFPlumberLoader("document.pdf")
# Avantages : Meilleure extraction de tableaux
# Inconvénients : Plus lent

# Option 3 : Meilleure qualité (Unstructured)
from langchain.document_loaders import UnstructuredPDFLoader
loader = UnstructuredPDFLoader(
    "document.pdf",
    mode="elements",  # Préserve la structure
    strategy="hi_res"  # Meilleure qualité
)
# Avantages : Meilleure qualité globale
# Inconvénients : Nécessite des dépendances supplémentaires

OCR pour les documents scannés

Pour les PDF scannés et les images :

# Utilisation de Tesseract OCR
from langchain.document_loaders import UnstructuredPDFLoader

loader = UnstructuredPDFLoader(
    "scanned_document.pdf",
    strategy="ocr_only",
    ocr_languages="eng"
)
documents = loader.load()

# Utilisation d'Amazon Textract
from langchain.document_loaders import AmazonTextractPDFLoader

loader = AmazonTextractPDFLoader(
    "scanned.pdf",
    client=textract_client
)

Bonnes pratiques OCR

1. Pré-traiter les images - Redresser, améliorer le contraste
2. Spécifier la langue - Améliore la précision
3. Post-traiter le texte - Corriger les erreurs OCR courantes
4. Scores de confiance - Signaler les extractions à faible confiance

Gestion des tableaux

Les tableaux nécessitent un traitement spécial pour préserver la structure :

# Méthode 1 : Convertir en Markdown
from langchain.document_loaders import UnstructuredPDFLoader

loader = UnstructuredPDFLoader(
    "report.pdf",
    mode="elements"
)
docs = loader.load()

# Les tableaux viennent comme des éléments structurés
for doc in docs:
    if doc.metadata.get("category") == "Table":
        # Traiter le tableau spécialement
        table_markdown = convert_table_to_markdown(doc)

# Méthode 2 : Utilisation de Camelot pour les PDF
import camelot

tables = camelot.read_pdf("document.pdf", pages="all")
for table in tables:
    df = table.df
    markdown = df.to_markdown()

Stratégie de découpage des tableaux

def chunk_with_tables(documents):
    chunks = []
    
    for doc in documents:
        if is_table(doc):
            # Garder les tableaux comme des morceaux uniques
            chunks.append(doc)
        else:
            # Découpage normal pour le texte
            text_chunks = splitter.split_documents([doc])
            chunks.extend(text_chunks)
    
    return chunks

Images dans les documents

Extraire et traiter les images :

# Extraire les images du PDF
import fitz  # PyMuPDF

doc = fitz.open("document.pdf")
for page_num, page in enumerate(doc):
    images = page.get_images()
    for img_index, img in enumerate(images):
        # Extraire l'image
        xref = img[0]
        base_image = doc.extract_image(xref)
        image_bytes = base_image["image"]
        
        # Traiter avec le modèle de vision
        description = vision_model.describe(image_bytes)
        
        # Ajouter la description au document

Intégration du modèle de vision

from langchain.chat_models import ChatOpenAI

# Utiliser GPT-4 Vision pour la compréhension des images
vision_llm = ChatOpenAI(model="gpt-4-vision-preview")

def describe_image(image_path):
    response = vision_llm.invoke([
        {
            "type": "image_url",
            "image_url": f"data:image/jpeg;base64,{base64_image}"
        },
        {
            "type": "text",
            "text": "Décrivez cette image en détail pour la recherche de documents."
        }
    ])
    return response.content

Données structurées

JSON/JSONL

from langchain.document_loaders import JSONLoader

loader = JSONLoader(
    file_path="data.json",
    jq_schema=".data[].content",
    text_content=False
)

CSV

from langchain.document_loaders import CSVLoader

loader = CSVLoader(
    file_path="data.csv",
    csv_args={"delimiter": ","},
    source_column="source"
)

# Pour les grands CSV, traiter par lots
import pandas as pd

def load_csv_in_batches(file_path, batch_size=1000):
    for chunk in pd.read_csv(file_path, chunksize=batch_size):
        yield from chunk.to_dict('records')

Bases de données SQL

from langchain.document_loaders import SQLDatabaseLoader
from langchain.utilities import SQLDatabase

db = SQLDatabase.from_uri("postgresql://user:pass@localhost/db")

loader = SQLDatabaseLoader(
    db=db,
    query="SELECT id, content, metadata FROM documents WHERE active = true"
)

Pipeline de traitement complet

from pathlib import Path

def process_document(file_path: str):
    """Processeur de document universel"""
    path = Path(file_path)
    extension = path.suffix.lower()
    
    loaders = {
        ".pdf": lambda p: UnstructuredPDFLoader(p, strategy="hi_res"),
        ".docx": lambda p: Docx2txtLoader(p),
        ".txt": lambda p: TextLoader(p, encoding="utf-8"),
        ".html": lambda p: UnstructuredHTMLLoader(p),
        ".md": lambda p: UnstructuredMarkdownLoader(p),
        ".csv": lambda p: CSVLoader(p),
        ".json": lambda p: JSONLoader(p, jq_schema=".[]")
    }
    
    if extension not in loaders:
        raise ValueError(f"Unsupported file type: {extension}")
    
    loader = loaders[extension](str(path))
    documents = loader.load()
    
    # Ajouter des métadonnées de fichier
    for doc in documents:
        doc.metadata["file_name"] = path.name
        doc.metadata["file_type"] = extension
        doc.metadata["file_size"] = path.stat().st_size
    
    return documents

Résumé

Type de fichier	Meilleur chargeur	Remarques
PDF (texte)	PDFPlumberLoader	Bon support des tableaux
PDF (scanné)	UnstructuredPDFLoader + OCR	Utiliser la stratégie hi_res
Word	Docx2txtLoader	Rapide et fiable
HTML	UnstructuredHTMLLoader	Supprime les balises
CSV	CSVLoader	Traiter par lots pour les grands fichiers
Images	Modèles de vision	Pour les images intégrées

Points clés à retenir

1. Les PDF sont complexes - Utilisez le bon chargeur pour vos besoins
2. OCR pour les documents scannés - Essentiel pour les PDF basés sur des images
3. Les tableaux nécessitent un traitement spécial - Ne pas découper à travers les lignes
4. Les images nécessitent une description - Utilisez des modèles de vision
5. Testez votre pipeline - Avec des échantillons représentatifs

---

Prochaines étapes

Testez vos connaissances avec le Quiz du Module 2 !