01 - NLP Fondamenti: Tokenizzazione, Embeddings

import re
import unicodedata

def normalize_text(text: str) -> str:
    """Normalizzazione base del testo."""
    # Lowercasing
    text = text.lower()

    # Rimozione accenti (opzionale, NON consigliato per italiano)
    # text = unicodedata.normalize('NFKD', text)

    # Rimozione punteggiatura
    text = re.sub(r'[^\w\s]', '', text)

    # Rimozione spazi multipli
    text = re.sub(r'\s+', ' ', text).strip()

    return text

testo = "L'NLP e FANTASTICO! Analizza testi in 50+ lingue."
print(normalize_text(testo))
# Output: "lnlp e fantastico analizza testi in 50 lingue"

# Approccio 1: NLTK
from nltk.corpus import stopwords
import nltk
nltk.download('stopwords')

stop_it = set(stopwords.words('italian'))
print(f"Stopwords italiane NLTK: {len(stop_it)}")
# Output: Stopwords italiane NLTK: 279

testo = "il gatto mangia il pesce sul tavolo della cucina"
tokens = testo.split()
filtrato = [t for t in tokens if t not in stop_it]
print(filtrato)
# Output: ['gatto', 'mangia', 'pesce', 'tavolo', 'cucina']

# Approccio 2: spaCy (più completo)
import spacy
nlp = spacy.load("it_core_news_lg")

doc = nlp("il gatto mangia il pesce sul tavolo della cucina")
filtrato_spacy = [token.text for token in doc if not token.is_stop]
print(filtrato_spacy)
# Output: ['gatto', 'mangia', 'pesce', 'tavolo', 'cucina']

from nltk.stem.snowball import SnowballStemmer
import spacy

# Stemming con Snowball
stemmer = SnowballStemmer("italian")
parole = ["mangiando", "mangiare", "mangiato", "correre", "correndo", "bellissimo"]
stems = [stemmer.stem(p) for p in parole]
print(dict(zip(parole, stems)))
# {'mangiando': 'mang', 'mangiare': 'mang', 'mangiato': 'mang',
#  'correre': 'corr', 'correndo': 'corr', 'bellissimo': 'bellissim'}

# Lemmatization con spaCy
nlp = spacy.load("it_core_news_lg")
doc = nlp("Le ragazze stavano mangiando le mele più belle")
lemmi = [(token.text, token.lemma_, token.pos_) for token in doc]
for testo, lemma, pos in lemmi:
    print(f"  {testo:15s} -> {lemma:15s} ({pos})")
# le              -> il              (DET)
# ragazze         -> ragazza         (NOUN)
# stavano         -> stare           (AUX)
# mangiando       -> mangiare        (VERB)
# le              -> il              (DET)
# mele            -> mela            (NOUN)
# più             -> più             (ADV)
# belle           -> bello           (ADJ)

# Approccio naive: split per spazio
testo = "L'intelligenza artificiale cambia il mondo"
tokens_naive = testo.split()
print(tokens_naive)
# ["L'intelligenza", 'artificiale', 'cambia', 'il', 'mondo']
# Problema: "L'intelligenza" e un singolo token!

# Approccio migliore: spaCy
import spacy
nlp = spacy.load("it_core_news_lg")
doc = nlp(testo)
tokens_spacy = [token.text for token in doc]
print(tokens_spacy)
# ["L'", 'intelligenza', 'artificiale', 'cambia', 'il', 'mondo']
# spaCy gestisce correttamente le elisioni italiane

from transformers import AutoTokenizer

# Testo di esempio in italiano
testo = "L'intelligenza artificiale sta rivoluzionando il mondo"

# --- BERT (WordPiece) ---
bert_tok = AutoTokenizer.from_pretrained("dbmdz/bert-base-italian-cased")
bert_tokens = bert_tok.tokenize(testo)
bert_ids = bert_tok.encode(testo)
print("BERT tokens:", bert_tokens)
print("BERT IDs:   ", bert_ids)
# BERT tokens: ['L', "'", 'intelligenza', 'artificiale', 'sta',
#               'rivoluzionando', 'il', 'mondo']
# BERT IDs:    [102, 55, 7, 5765, 6892, 379, 28648, 42, 1601, 103]

# --- GPT-2 (BPE) ---
gpt2_tok = AutoTokenizer.from_pretrained("gpt2")
gpt2_tokens = gpt2_tok.tokenize(testo)
gpt2_ids = gpt2_tok.encode(testo)
print("\nGPT-2 tokens:", gpt2_tokens)
print("GPT-2 IDs:   ", gpt2_ids)
# GPT-2 tokens: ['L', "'", 'int', 'ell', 'ig', 'enza', ' art',
#                'ific', 'iale', ' sta', ' riv', 'oluz', 'ion',
#                'ando', ' il', ' mondo']

# --- Confronto ---
print(f"\nBERT:  {len(bert_tokens)} token")
print(f"GPT-2: {len(gpt2_tokens)} token")

from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("dbmdz/bert-base-italian-cased")

# Dimensione vocabolario
print(f"Vocabolario BERT italiano: {tok.vocab_size} token")
# Output: Vocabolario BERT italiano: 31102 token

# Token speciali
print(f"[CLS] = {tok.cls_token} (ID: {tok.cls_token_id})")
print(f"[SEP] = {tok.sep_token} (ID: {tok.sep_token_id})")
print(f"[PAD] = {tok.pad_token} (ID: {tok.pad_token_id})")
print(f"[UNK] = {tok.unk_token} (ID: {tok.unk_token_id})")
print(f"[MASK] = {tok.mask_token} (ID: {tok.mask_token_id})")

# Decodifica: da token IDs -> testo
ids = tok.encode("NLP e fantastico")
print(f"\nEncode: {ids}")
print(f"Decode: {tok.decode(ids)}")
# Decode: [CLS] NLP e fantastico [SEP]

from sklearn.feature_extraction.text import CountVectorizer

documenti = [
    "il gatto mangia il pesce",
    "il cane mangia la carne",
    "il gatto insegue il cane"
]

vectorizer = CountVectorizer()
bow_matrix = vectorizer.fit_transform(documenti)

print("Vocabolario:", vectorizer.get_feature_names_out())
# ['cane', 'carne', 'gatto', 'il', 'insegue', 'la', 'mangia', 'pesce']

print("\nMatrice BoW:")
print(bow_matrix.toarray())
# [[0, 0, 1, 2, 0, 0, 1, 1],   # doc 1
#  [1, 1, 0, 1, 0, 1, 1, 0],   # doc 2
#  [1, 0, 1, 2, 1, 0, 0, 0]]   # doc 3

from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np

documenti = [
    "il gatto mangia il pesce",
    "il cane mangia la carne",
    "il gatto insegue il cane"
]

tfidf = TfidfVectorizer()
tfidf_matrix = tfidf.fit_transform(documenti)

print("Feature:", tfidf.get_feature_names_out())
print("\nMatrice TF-IDF (arrotondata):")
print(np.round(tfidf_matrix.toarray(), 3))
# "pesce" e "carne" hanno pesi più alti perchè appaiono
# in un solo documento (più discriminanti)

import gensim.downloader as api

# Carica word embeddings pre-addestrati
model = api.load("word2vec-google-news-300")

# Analogia: re - uomo + donna = ?
result = model.most_similar(
    positive=["king", "woman"],
    negative=["man"],
    topn=3
)
print("king - man + woman =")
for word, score in result:
    print(f"  {word}: {score:.4f}")
# king - man + woman =
#   queen: 0.7118
#   monarch: 0.6189
#   princess: 0.5902

# Similarità tra parole
print(f"\ncat ~ dog: {model.similarity('cat', 'dog'):.4f}")
print(f"cat ~ car: {model.similarity('cat', 'car'):.4f}")
# cat ~ dog: 0.7609
# cat ~ car: 0.2004

from transformers import AutoTokenizer, AutoModel
import torch
import torch.nn.functional as F

# Carica BERT italiano
tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-italian-cased")
model = AutoModel.from_pretrained("dbmdz/bert-base-italian-cased")

def get_word_embedding(sentence: str, word: str):
    """Ottieni l'embedding contestuale di una parola nella frase."""
    inputs = tokenizer(sentence, return_tensors="pt")
    tokens = tokenizer.tokenize(sentence)

    with torch.no_grad():
        outputs = model(**inputs)

    # outputs.last_hidden_state: [batch, seq_len, hidden_dim]
    embeddings = outputs.last_hidden_state[0]  # [seq_len, 768]

    # Trova l'indice del token target
    word_idx = tokens.index(word) + 1  # +1 per [CLS]
    return embeddings[word_idx]

# "banco" in contesti diversi
emb_scuola = get_word_embedding("Il banco di scuola e rotto", "banco")
emb_banca = get_word_embedding("Il banco di Napoli e storico", "banco")
emb_pesce = get_word_embedding("Il banco del pesce e fresco", "banco")

# Calcola similarità coseno
sim_12 = F.cosine_similarity(emb_scuola.unsqueeze(0), emb_banca.unsqueeze(0))
sim_13 = F.cosine_similarity(emb_scuola.unsqueeze(0), emb_pesce.unsqueeze(0))
sim_23 = F.cosine_similarity(emb_banca.unsqueeze(0), emb_pesce.unsqueeze(0))

print(f"banco(scuola) ~ banco(banca): {sim_12.item():.4f}")
print(f"banco(scuola) ~ banco(pesce): {sim_13.item():.4f}")
print(f"banco(banca)  ~ banco(pesce): {sim_23.item():.4f}")
# I vettori saranno DIVERSI perchè BERT capisce il contesto!

from sentence_transformers import SentenceTransformer, util

# Modello multilingue (supporta italiano)
model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")

# Frasi in italiano
frasi = [
    "Il gatto dorme sul divano",
    "Il felino riposa sul sofa",
    "La borsa e salita oggi",
    "I mercati finanziari sono in crescita",
    "Ho comprato un nuovo computer portatile"
]

# Genera embeddings (1 vettore per frase, 384 dimensioni)
embeddings = model.encode(frasi, convert_to_tensor=True)
print(f"Shape: {embeddings.shape}")  # [5, 384]

# Calcola matrice di similarità
cosine_scores = util.cos_sim(embeddings, embeddings)

print("\nMatrice di Similarità:")
for i in range(len(frasi)):
    for j in range(i + 1, len(frasi)):
        print(f"  {frasi[i][:40]:40s} <-> {frasi[j][:40]:40s}")
        print(f"    Similarità: {cosine_scores[i][j]:.4f}")

# Risultati attesi:
# "gatto dorme"   <-> "felino riposa"  : ~0.85 (molto simili)
# "borsa salita"  <-> "mercati crescita": ~0.70 (correlati)
# "gatto dorme"   <-> "borsa salita"   : ~0.10 (non correlati)

import spacy
import re

class ItalianPreprocessor:
    """Pipeline di preprocessing specifica per l'italiano."""

    def __init__(self):
        self.nlp = spacy.load("it_core_news_lg")
        # Stopwords aggiuntive regionali/informali
        self.custom_stops = {
            "cioe", "quindi", "comunque", "praticamente",
            "allora", "insomma", "magari", "ecco", "tipo",
            "boh", "mah", "vabbe", "ok", "okay"
        }

    def preprocess(self, text: str, remove_stops: bool = True,
                   lemmatize: bool = True) -> list[str]:
        """Preprocessing completo per testo italiano."""
        # 1. Normalizzazione base
        text = text.lower()
        text = re.sub(r'http\S+|www\.\S+', '', text)  # rimuovi URL
        text = re.sub(r'[^\w\s\']', '', text)  # mantieni apostrofi
        text = re.sub(r'\d+', '', text)  # rimuovi numeri
        text = re.sub(r'\s+', ' ', text).strip()

        # 2. Analisi con spaCy
        doc = self.nlp(text)

        # 3. Filtraggio e lemmatizzazione
        tokens = []
        for token in doc:
            # Salta punteggiatura e spazi
            if token.is_punct or token.is_space:
                continue
            # Salta stopwords se richiesto
            if remove_stops and (token.is_stop or
                                  token.text in self.custom_stops):
                continue
            # Lemmatizza o usa la forma originale
            word = token.lemma_ if lemmatize else token.text
            if len(word) > 1:  # salta caratteri singoli
                tokens.append(word)

        return tokens


# Esempio d'uso
prep = ItalianPreprocessor()

testo = """L'intelligenza artificiale sta rivoluzionando
il modo in cui le aziende italiane gestiscono i loro
processi, cioe praticamente tutto sta cambiando."""

risultato = prep.preprocess(testo)
print("Token processati:", risultato)
# ['intelligenza', 'artificiale', 'rivoluzionare', 'modo',
#  'azienda', 'italiano', 'gestire', 'processo', 'cambiare']

from sentence_transformers import SentenceTransformer, util
import torch

class SemanticSearchIT:
    """Motore di ricerca semantica per testi italiani."""

    def __init__(self, model_name: str =
                 "paraphrase-multilingual-MiniLM-L12-v2"):
        self.model = SentenceTransformer(model_name)
        self.documents: list[str] = []
        self.embeddings = None

    def index_documents(self, documents: list[str]) -> None:
        """Indicizza i documenti calcolando gli embeddings."""
        self.documents = documents
        self.embeddings = self.model.encode(
            documents,
            convert_to_tensor=True,
            show_progress_bar=True
        )
        print(f"Indicizzati {len(documents)} documenti")
        print(f"Shape embeddings: {self.embeddings.shape}")

    def search(self, query: str, top_k: int = 3) -> list[dict]:
        """Cerca i documenti più rilevanti per la query."""
        query_embedding = self.model.encode(
            query, convert_to_tensor=True
        )
        scores = util.cos_sim(query_embedding, self.embeddings)[0]
        top_results = torch.topk(scores, k=min(top_k, len(self.documents)))

        results = []
        for score, idx in zip(top_results.values, top_results.indices):
            results.append({
                "documento": self.documents[idx],
                "score": round(score.item(), 4),
                "indice": idx.item()
            })
        return results


# --- Esempio d'uso ---
corpus = [
    "Python e un linguaggio di programmazione versatile e facile da imparare",
    "Il machine learning permette ai computer di imparare dai dati",
    "Angular e un framework per costruire applicazioni web moderne",
    "La pasta alla carbonara e un piatto tipico della cucina romana",
    "I database relazionali usano SQL per interrogare i dati",
    "Il deep learning utilizza reti neurali con molti strati nascosti",
    "Roma e la capitale d'Italia e ha una storia millenaria",
    "Le API REST permettono la comunicazione tra servizi web",
    "Il Natural Language Processing analizza e comprende il testo",
    "La pizza napoletana e patrimonio UNESCO dal 2017"
]

# Crea il motore di ricerca e indicizza
search_engine = SemanticSearchIT()
search_engine.index_documents(corpus)

# Esegui alcune ricerche
queries = [
    "come analizzare il linguaggio naturale",
    "framework per sviluppo frontend",
    "cucina tradizionale italiana"
]

for query in queries:
    print(f"\nQuery: '{query}'")
    print("-" * 60)
    results = search_engine.search(query, top_k=3)
    for i, r in enumerate(results, 1):
        print(f"  {i}. [{r['score']:.4f}] {r['documento']}")