La tokenizzazione accurata rappresenta la pietra angolare di ogni pipeline NLP, ma nel contesto della lingua italiana, ricca di morfologia flessa, composizioni e omografi, presenta sfide uniche. Mentre strumenti generici spesso frammentano in modo errato aggettivi composti, termini tecnici o nomi propri, l’adozione di metodologie avanzate basate su regole morfologiche, modelli subword personalizzati e validazione semantica consente di ridurre drasticamente gli errori di segmentazione. Questo articolo approfondisce, con esempi pratici e codifiche operative in Python, come costruire un processo stratificato per eliminare i token errors nel preprocessing testuale italiano, partendo dalle basi linguistiche fino a tecniche di ottimizzazione avanzate.

1. Fondamenti linguistici e specificità della tokenizzazione italiana

La tokenizzazione nel NLP italiano deve tenere conto della morfologia estremamente flessa: aggettivi composti, verbi pronominali e nomi propri con variazioni lessicali generano frequenti errori con approcci basati su regex o modelli multilingue. A differenza dell’inglese, dove la separazione è spesso basata su confini lessicali chiari, in italiano la segmentazione si complica da particelle grammaticali (es. “va bene”), contrazioni (“non è” → “nesti”), e aggregati semantici (“studi-in-corso” → “studi-in-corso” anziché “studi”, “in”, “correnti”). Metodi tradizionali come spaCy o NLTK, pur utili, spesso non riconoscono queste strutture complesse, producendo token frammentati o unità frammentarie.

2. Analisi degli errori comuni nel preprocessing italiano

Gli errori più ricorrenti includono:
– Frammentazione errata di aggettivi composti: “studi-in-corso” diventa “studi-in”, “romano” non segmentato in “Romanello”
– Trattamento inconsistente di contrazioni (“non è” → “nesti”, “va va’” → “va’”)
– Segmentazione frammentaria di termini tecnici: “Codice-Di-Perfetto” → “Codice”, “Di”, “Perfetto”
– Errori di gestione di interiezioni e particelle grammaticali (“va”, “va bene”, “è”)
– Caso studio: analisi con spaCy evidenzia un tasso di falsi positivi del 42% nei token di frasi legali italiane, dovuti a frasi ellissi e contrazioni non riconosciute.

3. Metodologia avanzata per la correzione degli errori di tokenizzazione

Per eliminare sistematicamente i token errors, si propone un processo stratificato in five fasi chiave:

1. Fase 1: Normalizzazione iniziale
   Codifica UTF-8 (es. `df.apply(lambda x: x.encode(‘utf-8’).decode(‘utf-8′), axis=1)`), rimozione di caratteri di controllo e HTML (con `re.sub(r'<.*?>’, ”, text)`), correzione ortografica base tramite PyEnchant (`en_it`).

   Questa fase riduce il rumore iniziale che alimenta errori successivi.

   • Esempio:
     “`python
     import re
     def normalizzare(text):
     text = text.encode(‘utf-8’).decode(‘utf-8’).replace(‘©’, ”).replace(‘<.*?>’, ”)
     text = re.sub(r’\s+’, ‘ ‘, text).strip()
     return text
     “`
2. Fase 2: Tokenizzazione contestuale con regole morfologiche
   Impiego di pattern regex e morfologia italiana per preservare unità semantiche: separare aggettivi composti con spazi o congiunzioni (es. “studi-in-corso” → “studi” + “in” + “correnti”), riconoscere verbi pronominali (“va bene” → “va_bene”) tramite N-gram.

   Implementazione:
   “`python
   import re
   def separa_aggettivi_composti(text):
   pattern = r'(\w+-\w+)|\b(va\s+bene|va\s+male)\b’
   return re.sub(pattern, r’\1′, text)
   “`

3. Fase 3: Modello BPE personalizzato su corpus italiano
   Addestramento di un modello Byte Pair Encoding (BPE) su un corpus italiano (es. Tito Corpus) per ridurre frammentazione.

   Parametri chiave:
   – vocab size: 30.000
   – epochs: 30
   – vocab size stagnante: < 3.000
   
   Esempio pseudo-codice:
   “`python
   import tokenizers
   model = tokenizers.Tokenizer()
   model.train(train_texts, vocab_size=30000, min_frequency=2)
   “`

4. Fase 4: Post-processing con dizionario tecnico
   Creazione di un dizionario locale per nomi propri e termini tecnici (es. “Romanello”, “Codice-Di-Perfetto”) da inserire in un dizionario PyEnchant o integrare in un parser NLTK con regole di inclusione.

   Esempio:
   “`python
   custom_words = {“Romanello”, “Codice-Di-Perfetto”}
   tokens = [w if w in custom_words else w for w in token_list]
   “`

5. Fase 5: Validazione e metriche quantitative
   Confronto con annotazioni manuali per calcolare precision, recall e F1-score su un corpus standard (es. Tito Corpus). Monitoraggio errore di lunghezza token e fidelità semantica.

   Tabella esemplificativa di performance post-correzione:

   Metrica	Baseline	Post-correzione	Miglioramento (%)
   Precisione	78%	96%	+18%
   Recall	72%	89%	+17%
   F1-score	84%	92%	+8%
   Errore di lunghezza token (token totali)	1.8	1.2	-33%

4. Implementazione pratica in ambiente Python: pipeline completa

Un flusso operativo efficace integra normalizzazione, tokenizzazione contestuale, correzione guidata e validazione. Di seguito un esempio completo con dataset di testi legali italiani, considerando peculiarità lessicali e regionali.

1. Passo 1: Caricamento e pulizia del dataset

  
  df = pd.read_csv("testi_legali_italiani.csv", encoding='utf-8')  
  df["clean_text"] = df["testo"].apply(normalizzare)  
  

2. Passo 2: Segmentazione contestuale con regole morfologiche

  
  def separa_composti(text):  
      return re.sub(r'(\w+-\w+)', r'\1', text)  
  df["segmented"] = df["clean_text"].apply(separa_composti)  
  

3. Passo 3: Integrazione modello BPE personalizzato

  
  model = tokenizers.Tokenizer(vocab_size=30000, min_frequency=2)  
  model.train(df["segmented"].tolist(), vocab_size=30000)  
  tokenizer = tokenizers.Tokenizer(model=model)  
  df["tokens"] = df["segmented"].apply(tokenizer.encode)  
  

4. Passo 4: Correzione ortografica con PyEnchant su token specifici

  
  from pyenchant import EnSpell  
  spell = EnSpell('it')  
  df["corrected_t