Come Simula un LLM la Lettura dei File? Costruisci la tua Utility Python
Spesso immaginiamo i modelli di linguaggio come entità capaci di comprendere ogni sfumatura di un documento, come farebbe una persona leggendo.
Ma cosa accade realmente quando un’intelligenza artificiale si confronta con un file PDF, un documento Word o un semplice testo?
La loro ‘percezione’ non è una lettura diretta, ma un viaggio articolato: prima il contenuto deve essere estratto, poi liberato da ogni elemento superfluo, trasformato in un flusso di parole pure, e infine suddiviso in frammenti più piccoli che l’algoritmo può analizzare. Questo articolo ti invita a scoprire passo dopo passo come si svolge questo processo, guidandoti nella creazione di un piccolo strumento Python che ti permetterà di toccare con mano le fasi che precedono la vera ‘comprensione’ da parte di un modello di linguaggio.
Un tutorial pratico per sviluppare uno strumento che ti mostra come un modello di linguaggio legge davvero un PDF, un DOCX, un Markdown o un TXT.
Obiettivo del progetto
Il comportamento di un LLM non è semplicemente “leggere un file” come farebbe un umano: la sua comprensione inizia solo dopo che il contenuto è stato:
Estratto dal file (parsing);
Ripulito da elementi superflui (normalizzazione);
Convertito in testo semplice;
Suddiviso in token (opzionalmente, token LLM-style).
La scelta del formato del file non incide solo sulla facilità di parsing, ma anche sulla qualità dell’informazione che un modello NLP può estrarre. Un’analisi comparativa dettagliata dei diversi formati e del loro impatto sulla performance dei modelli di AI è disponibile in questo approfondimento.
Questa utility Python simula proprio questo processo, passo per passo.
import os
import sys
import docx
import markdown
from bs4 import BeautifulSoup
from PyPDF2 import PdfReader
import nltk
from nltk.tokenize import word_tokenize
def parse_pdf(file_path):
try:
reader = PdfReader(file_path)
text = "\n".join(page.extract_text() or '' for page in reader.pages)
return text.strip()
except Exception as e:
return f"Errore nella lettura PDF: {e}"
def parse_docx(file_path):
try:
doc = docx.Document(file_path)
return "\n".join(p.text for p in doc.paragraphs if p.text.strip())
except Exception as e:
return f"Errore nella lettura DOCX: {e}"
def parse_txt(file_path):
try:
with open(file_path, 'r', encoding='utf-8') as f:
return f.read()
except Exception as e:
return f"Errore nella lettura TXT: {e}"
def parse_markdown(file_path):
try:
with open(file_path, 'r', encoding='utf-8') as f:
raw_md = f.read()
html = markdown.markdown(raw_md)
soup = BeautifulSoup(html, 'html.parser')
return soup.get_text(separator="\n").strip()
except Exception as e:
return f"Errore nella lettura MD: {e}"
def simulate_llm_parsing(file_path, tokenize=False):
ext = os.path.splitext(file_path)[1].lower()
if not os.path.exists(file_path):
return f"File non trovato: {file_path}"
if ext == '.pdf':
content = parse_pdf(file_path)
elif ext == '.docx':
content = parse_docx(file_path)
elif ext == '.md':
content = parse_markdown(file_path)
elif ext == '.txt':
content = parse_txt(file_path)
else:
return f"Formato non supportato: {ext}"
if tokenize:
tokens = word_tokenize(content)
return f"Testo estratto ({len(content)} caratteri):\n\n{content[:300]}...\n\n---\n\nToken ({len(tokens)}):\n{tokens[:50]}..."
else:
return f"Testo estratto ({len(content)} caratteri):\n\n{content}"
if __name__ == '__main__':
if len(sys.argv) < 2:
print("Usa: python llm_parser.py <file_path> [--tokenize]")
else:
path = sys.argv[1]
tokenize = '--tokenize' in sys.argv
output = simulate_llm_parsing(path, tokenize=tokenize)
print(output)
Esempi pronti da testare
1. Crea file di prova in locale
with open("testo.txt", "w") as f:
f.write("Ciao! Questo è un semplice file di testo.")
with open("readme.md", "w") as f:
f.write("""
# Titolo
Questa è una descrizione **formattata** con Markdown.
""")
import docx
doc = docx.Document()
doc.add_paragraph("Questo è un file .docx di test.")
doc.save("prova.docx")
Il Valore Pratico degli Esempi: Oltre la Semplice Funzionalità
Gli esempi forniti non sono solo un modo per verificare che il codice funzioni; sono un vero e proprio laboratorio per capire come i modelli di linguaggio interagiscono con i dati digitali. Ti mostrano, passo dopo passo, il viaggio di un file dal suo formato originale a un testo che un’intelligenza artificiale può effettivamente elaborare.
Ecco perché sono particolarmente importanti per chiunque lavori con l’AI:
Il Percorso del Dato Diventa Tangibile: Quando lanci lo script su un file .txt, .md o .docx, non stai solo “leggendo” il contenuto. Stai assistendo alla trasformazione del dato. L’utility ti mostra il testo estratto e, se lo scegli, i token. Questo processo di preparazione è cruciale: la qualità dell’input determina direttamente la qualità di ciò che il modello di linguaggio è in grado di produrre.
Gestione della Diversità dei Formati: Il set di esempi evidenzia subito una realtà importante: non tutti i file sono uguali. Un semplice .txt è diretto, ma un .md richiede un lavoro di pulizia della formattazione, e un .docx o un .pdf necessitano di strumenti specifici per estrarre il testo. Questi esempi dimostrano che non esiste un’unica soluzione magica per tutti i documenti, ma serve un approccio modulare e adattivo che replichi la complessità del mondo reale.
La “Normalizzazione” in Azione: L’esempio con il file Markdown (readme.md) è particolarmente illuminante. Vedrai come la formattazione (come il grassetto o i titoli) viene completamente rimossa per lasciare solo il testo puro. Questa normalizzazione è vitale. Se il modello dovesse processare il Markdown grezzo, potrebbe confondere i simboli di formattazione con informazioni significative. L’esercizio ti fa toccare con mano come il contenuto informativo pulito sia più importante della sua veste estetica per il modello.
Comprendere la Tokenizzazione: Usando l’opzione --tokenize con, ad esempio, il file prova.docx, farai un passo avanti nella comprensione di come i modelli “vedono” realmente il testo. I token non sono solo parole, ma le unità elementari di significato che il modello elabora. Vedere i primi 50 token ti offre un’idea concreta di come le frasi vengono spezzettate e preparate per l’analisi interna dell’LLM. È un’introduzione semplice, ma efficace, al concetto che sta alla base della comprensione del linguaggio artificiale.
Una Solida Base per Sviluppi Futuri: La semplicità e chiarezza di questi esempi li rendono un punto di partenza ideale. Verificare che il parsing funzioni e che il testo venga estratto correttamente è il primo passo. Da qui, puoi facilmente espandere l’utility per includere funzionalità più avanzate, come la segmentazione in blocchi di testo (chunks), la gestione di tabelle o immagini, o l’integrazione di tokenizer più sofisticati, come quelli usati dagli LLM reali. Questi esercizi non chiudono il discorso, ma ti forniscono le basi per esplorare un mondo di possibilità.
In sintesi, gli esercizi vanno oltre il semplice collaudo del codice. Sono una lente d’ingrandimento sul processo di pre-elaborazione che rende i documenti comprensibili ai modelli di linguaggio, offrendoti un’intuizione pratica su come si prepara il terreno per l’intelligenza artificiale.
Cosa potresti aggiungere
Confronto con tokenizer reali
Tokenizer OpenAI (tiktoken) o Hugging Face (AutoTokenizer) spezzano il testo in modo diverso rispetto a nltk.
Un LLM “vede” i token, non il testo: potresti integrare tiktoken per simulazioni più fedeli.
Test automatici
Crea un file test_llm_parser.py con pytest e verifica che ogni parser restituisca contenuto non vuoto per file validi.
Conclusione
Questa utility ti permette di visualizzare, passo per passo, come un LLM riceve il contenuto di un file. Non basta passargli un PDF: bisogna convertirlo, pulirlo, interpretarlo, e solo allora entra in gioco il modello.
È uno strumento utile per chi sviluppa prompt, agenti AI o applicazioni NLP.
