{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"authorship_tag":"ABX9TyP4NrZuC8QdX39fyHJeBmNG"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["#Modello per l'Identificazione della Lingua di Testi per un Museo\n","\n","Progetto di *Fabrizio Ferla*\n","\n","##Obiettivo del Progetto\n","\n","L'obiettivo è sviluppare un modello di machine learning basato su tecniche di Natural Language Processing (NLP) per identificare la lingua di testi forniti dal museo.\n","Questo modello dovrà:\n","\n","- Riconoscere automaticamente la lingua di un testo.\n","- Supportare almeno 3 lingue principali.\n","- Essere facile da integrare con il sistema esistente del museo.\n","\n","#Risultati attesi\n","\n","1. Automazione: Eliminare la necessità di identificazione manuale delle lingue.\n","2. Efficienza: Processare rapidamente grandi volumi di testi.\n","3. Accuratezza: Ridurre gli errori umani nell'identificazione delle lingue.\n","\n","##Tecnologie\n","\n","- Linguaggio di programmazione: Python\n","- Librerie richieste:\n","  - scikit-learn\n","  - nltk\n","  - numpy\n","  - pandas"],"metadata":{"id":"ZyMvpiX_kgH_"}},{"cell_type":"markdown","source":["Librerie"],"metadata":{"id":"fq-sN5ePTZwF"}},{"cell_type":"code","source":["# Librerie base\n","import re\n","import pandas as pd\n","import numpy as np\n","import math\n","\n","# Pipeline\n","from sklearn.pipeline import Pipeline\n","\n","# Divisione dataset\n","from sklearn.model_selection import train_test_split\n","\n","#Vettorizzazione\n","from sklearn.feature_extraction.text import TfidfVectorizer\n","\n","# Modelli\n","from sklearn.naive_bayes import MultinomialNB\n","from sklearn.linear_model import LogisticRegression\n","\n","# Valutazione\n","from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n","\n","# Cross validation\n","from sklearn.model_selection import cross_val_score, KFold, learning_curve\n","\n","# Grafici\n","import matplotlib.pyplot as plt\n"],"metadata":{"id":"8MJIHUAATL35"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["RANDOM_SEED = 42"],"metadata":{"id":"3oFzr7TUOOrc"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Funzioni"],"metadata":{"id":"HLaLGGUATxTf"}},{"cell_type":"code","source":["def info_dataset(dataset):\n","  \"\"\"\n","    Questa funzione stampa le informazioni del dataset.\n","  \"\"\"\n","  target = dataset['Codice Lingua']\n","  print(dataset.shape) # Dimensioni del dataset\n","  print(dataset.info()) # Informazioni sul dataset\n","  print(set(target)) # Le colonne del dataset sono 'Testo' e 'Codice Lingua'\n","  print(dataset.columns.values) # Le colonne del dataset sono 'Testo' e 'Codice Lingua'\n","  for l in set(target): # Per ogni lingua restituisce il numero di elementi appartenenti a quella lingua\n","    print(l + \" : \" + str(len(dataset[target == l])))\n","  print(dataset.isnull().sum()) # Numero di valori nulli"],"metadata":{"id":"xUiH0DCtTw5T"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["def data_cleaned(sentence):\n","  \"\"\"\n","    Questa funzione si occupa di pulire e normalizzare una string.\n","      - Converte la stringa in lettere minuscole\n","      - Rimuove la punteggiatura.\n","      - Rimuove i numeri.\n","      - Rimuove gli spazi duplicati.\n","  \"\"\"\n","  sentence = sentence.lower() # Converte la stringa in lettere minuscole\n","  sentence = re.sub(r'[^\\w\\s]|_|\\d', \" \", sentence) # Sostituisce tutte le cifre numeriche (da 0 a 9) con uno spazio\n","  sentence = re.sub(r' +', \" \", sentence) # Sostituisce gli spazi duplicati con un singolo spazio\n","\n","  return sentence # Restituisce la stringa pulita, formata da lettere minuscole e spazi singoli"],"metadata":{"id":"xmJVBCdfU5lA"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["def class_report(y_true, y_pred):\n","  \"\"\"\n","    Questa funzione stampa le metriche di valutazione del modello.\n","  \"\"\"\n","  acc = accuracy_score(y_true, y_pred)\n","  prec = precision_score(y_true, y_pred, average =\"macro\")\n","  rec = recall_score(y_true, y_pred, average =\"macro\")\n","  f1 = f1_score(y_true, y_pred, average =\"macro\")\n","\n","  print(f\"Accuracy: {np.round(acc, 4)*100}%\") # Indica la percentuale di osservazioni che il modello ha classificato correttamente\n","  print(f\"Precision:  {np.round(prec, 4)*100}%\") # Indica la percentuale di classificazioni positive che erano positive\n","  print(f\"Recall:  {np.round(rec, 4)*100}%\") # Indica la percentuale di osservazioni positive che sono state classificate come positive\n","  print(f\"F1:  {np.round(f1, 4)*100}%\") # Media armonica tra precision e recall\n","  print(\"\\n\")"],"metadata":{"id":"zn1PpnIkWqS7"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["def cross_validation(pipeline, X, y, cv=5):\n","  \"\"\"\n","    Questa funzione esegue la cross-validation su un modello di machine learning.\n","  \"\"\"\n","  kf = KFold(n_splits=cv, shuffle=True, random_state=RANDOM_SEED)\n","\n","  for nome, pip in pipeline.items():\n","    print(f\"############# Modello: {nome} #############\")\n","    scores = cross_val_score(pip, X, y, cv=kf, scoring='f1_macro') # Esegue la cross-validation su modello\n","    print(f\"F1 scores: {np.round(scores, 4)*100}\") # Stampa l'F1 score\n","    print(f\"Mean F1 score: {np.round(scores.mean())*100}\") # Stampa la media\n","    print(\"\\n\")"],"metadata":{"id":"qYPPf5--bBha"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["def plot_learning_curve(modello , X , y, cv=5):\n","  kf = KFold(n_splits=cv, shuffle=True, random_state=RANDOM_SEED)\n","\n","  train_sizes, train_scores, test_scores = learning_curve(modello, X, y, cv=kf, scoring='f1_macro',shuffle= True, random_state= RANDOM_SEED,  n_jobs=-1)\n","\n","  plt.plot(train_sizes, train_scores.mean(axis=1), label=\"Training score\")\n","  plt.plot(train_sizes, test_scores.mean(axis=1), label=\"Test score\")\n","  plt.ylim([-1,1])\n","  plt.legend(loc='lower right')\n","  plt.grid()\n","  plt.show()"],"metadata":{"id":"TxckndmRxxT_"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Download Dataset"],"metadata":{"id":"GmD5J9OCTb_4"}},{"cell_type":"code","source":["!wget \"https://raw.githubusercontent.com/Profession-AI/progetti-ml/refs/heads/main/Modello%20per%20l'identificazione%20della%20lingua%20dei%20testi%20di%20un%20museo/museo_descrizioni.csv\""],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"p2ZCnO98TL0r","executionInfo":{"status":"ok","timestamp":1782457356990,"user_tz":-120,"elapsed":359,"user":{"displayName":"Fabrizio Ferla","userId":"15328954300085185958"}},"outputId":"02adcdca-d080-4d10-925e-ce6c06d7ea6b"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["--2026-06-26 07:02:36--  https://raw.githubusercontent.com/Profession-AI/progetti-ml/refs/heads/main/Modello%20per%20l'identificazione%20della%20lingua%20dei%20testi%20di%20un%20museo/museo_descrizioni.csv\n","Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.111.133, 185.199.108.133, ...\n","Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n","HTTP request sent, awaiting response... 200 OK\n","Length: 14294 (14K) [text/plain]\n","Saving to: ‘museo_descrizioni.csv’\n","\n","\rmuseo_descrizioni.c   0%[                    ]       0  --.-KB/s               \rmuseo_descrizioni.c 100%[===================>]  13.96K  --.-KB/s    in 0s      \n","\n","2026-06-26 07:02:36 (34.9 MB/s) - ‘museo_descrizioni.csv’ saved [14294/14294]\n","\n"]}]},{"cell_type":"markdown","source":["Import Dataset"],"metadata":{"id":"-__51AMgThZx"}},{"cell_type":"code","source":["museum_dataset = pd.read_csv(\"./museo_descrizioni.csv\") # Recupero del dataset tramite Pandas"],"metadata":{"id":"aaoBYMWWTLyC"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["text = museum_dataset['Testo']\n","language_labels = museum_dataset['Codice Lingua']"],"metadata":{"id":"OlqqzYMoUejS"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Informazioni sul dataset"],"metadata":{"id":"8HZwNUfVTl6J"}},{"cell_type":"code","source":["info_dataset(museum_dataset)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"tZLOm4GITLtK","executionInfo":{"status":"ok","timestamp":1782457357094,"user_tz":-120,"elapsed":73,"user":{"displayName":"Fabrizio Ferla","userId":"15328954300085185958"}},"outputId":"fef66ae7-d65f-4fc6-bc5a-9c22ef796358"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["(294, 2)\n","<class 'pandas.core.frame.DataFrame'>\n","RangeIndex: 294 entries, 0 to 293\n","Data columns (total 2 columns):\n"," #   Column         Non-Null Count  Dtype \n","---  ------         --------------  ----- \n"," 0   Testo          294 non-null    object\n"," 1   Codice Lingua  294 non-null    object\n","dtypes: object(2)\n","memory usage: 4.7+ KB\n","None\n","{'it', 'de', 'en'}\n","['Testo' 'Codice Lingua']\n","it : 98\n","de : 98\n","en : 98\n","Testo            0\n","Codice Lingua    0\n","dtype: int64\n"]}]},{"cell_type":"markdown","source":["Il dataset del museo contiene 294 righe e 2 colonne denominate rispettivamente **Testo** e **Codice Lingua**. Nel dataset ci sono frasi in lingua **Inglese**, **Italiano** e **Tedesco**. Le frasi per ciascuno di essi sono 98 e non ci sono valori mancanti sia per il testo che per il codice della lingua"],"metadata":{"id":"Vhp-FjBIVE0r"}},{"cell_type":"markdown","source":["Pulizia dataset"],"metadata":{"id":"B_ELfJHnVO3k"}},{"cell_type":"code","source":["cleaned_dataset = [data_cleaned(sentence) for sentence in text] # Crea un dataset con testo minuscolo, privo di punteggiatura, numeri e con un singolo spazio"],"metadata":{"id":"cKK4WIb6VPWL"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Split dataset"],"metadata":{"id":"2XmtLIEDVES3"}},{"cell_type":"code","source":["X_train, X_test, y_train, y_test = train_test_split(cleaned_dataset, language_labels, test_size=0.2, random_state=RANDOM_SEED) # Divide il dataset in set di training e set di test"],"metadata":{"id":"xhwg3um0TLqP"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Addestramento Naive Bayes\n","Il modello multinomiale di **Naive Bayes** permette di calcolare per ogni istanza la probabilità di appartenenza a una classe.\n","\n","Il teorema di Bayes calcola la probabilità di un evento A condizionata a un evento B.\n","\n","$$ P(A|B) = P(A|B) . P(A) / P(B) $$\n","\n","**alpha=1.0** -> **Laplace smoothing** Permette di evitare la probabilità di un evento diventi zero. Lo zero smoothing aggiunge un valore fittizio al conteggio di ogni parola e una costante al denominatore."],"metadata":{"id":"M9ZHIeCXVnsx"}},{"cell_type":"code","source":["pipeline_nb = Pipeline([\n","    (\"tfidf\", TfidfVectorizer(analyzer=\"char\", ngram_range=(2,4))),\n","    (\"clf\", MultinomialNB(alpha=1.0))\n","])\n","\n","pipeline_nb.fit(X_train, y_train)\n","y_pred_nb = pipeline_nb.predict(X_test)"],"metadata":{"id":"PAc045IyVrCD"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Addestramento Regressione Logistica\n","\n","Il modello di **Regressione logistica permette di calcolare la probabilità  che un determinato evento si verifichi. La regressione logistica restituisce una probabilità compresa tra 0 e 1\n","\n","$$ P = 1/(1+(e^-z)) $$"],"metadata":{"id":"9g1Wl46oWKsy"}},{"cell_type":"code","source":["pipeline_lr = Pipeline([\n","    (\"tfidf\", TfidfVectorizer(analyzer=\"char\", ngram_range=(2,4))),\n","    (\"clf\", LogisticRegression(max_iter= 1000, random_state = RANDOM_SEED))\n","])\n","\n","pipeline_lr.fit(X_train, y_train)\n","y_pred_lr = pipeline_lr.predict(X_test)"],"metadata":{"id":"ADn60WlATLlJ"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Metriche modelli"],"metadata":{"id":"q7bcYNR-Wbl_"}},{"cell_type":"code","source":["modelli = {\"Multinomial Naive Bayes\" : pipeline_nb, \"Regressione logistica\" : pipeline_lr}"],"metadata":{"id":"r1lezaMwaTfI"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["print(\"############# Modello: Multinomial Naive Bayes #############\")\n","\n","class_report(y_test, y_pred_nb) # Stampa le metriche Accuracy, Precision, Recall, F1 per il modello Naive Bayes\n","\n","print(\"############# Modello: Regressione Logistica #############\")\n","\n","class_report(y_test, y_pred_lr) # Stampa le metriche Accuracy, Precision, Recall, F1 per il  modello di regressione logistica"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"NsI1qvBSTLiu","executionInfo":{"status":"ok","timestamp":1782457358881,"user_tz":-120,"elapsed":140,"user":{"displayName":"Fabrizio Ferla","userId":"15328954300085185958"}},"outputId":"be6b5e2c-1df0-46df-df8f-228aef91055f"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["############# Modello: Multinomial Naive Bayes #############\n","Accuracy: 96.61%\n","Precision:  97.22%\n","Recall:  96.08%\n","F1:  96.47%\n","\n","\n","############# Modello: Regressione Logistica #############\n","Accuracy: 100.0%\n","Precision:  100.0%\n","Recall:  100.0%\n","F1:  100.0%\n","\n","\n"]}]},{"cell_type":"markdown","source":["# Cross validation e valutazione delle metriche"],"metadata":{"id":"rRHX8SH5Yxdp"}},{"cell_type":"code","source":["cross_validation(modelli,X_train, y_train)\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"GUnqVONVh59a","executionInfo":{"status":"ok","timestamp":1782457362030,"user_tz":-120,"elapsed":3055,"user":{"displayName":"Fabrizio Ferla","userId":"15328954300085185958"}},"outputId":"e87d5837-9881-4253-c6a2-ded28a9d96a9"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["############# Modello: Multinomial Naive Bayes #############\n","F1 scores: [ 95.79 100.   100.   100.   100.  ]\n","Mean F1 score: 100.0\n","\n","\n","############# Modello: Regressione logistica #############\n","F1 scores: [ 97.7 100.  100.  100.  100. ]\n","Mean F1 score: 100.0\n","\n","\n"]}]},{"cell_type":"markdown","source":["La Cross-validation a 5 fold eseguita sui dati di training produce un F1 score medio del 99.5% per entrambi i modelli con varianza minima trascurabile. Tutti i folder raggiungono F1 score a 1 ad eccezione del 1° fold che è paria al 95,7%per modello Multinomial NaiveBayes e il 97,7% per il modello di Regressione Logistica, che rappresenta il sottoinsieme più difficile del dataset. I risultati scaturiti della Cross-validation dei modelli MultinomialNB e Regressione Logistica, indicano che entrambi i modelli apprendono in modo stabile  e senza **Overfitting**"],"metadata":{"id":"0mE5p-s4Zjds"}},{"cell_type":"markdown","source":["# Learning curve"],"metadata":{"id":"htYcFIpYoPwI"}},{"cell_type":"code","source":["plot_learning_curve(pipeline_nb, X_train, y_train)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":435},"id":"f0LCIaknrEG7","executionInfo":{"status":"ok","timestamp":1782457372973,"user_tz":-120,"elapsed":10936,"user":{"displayName":"Fabrizio Ferla","userId":"15328954300085185958"}},"outputId":"51b338c5-c3e8-4739-abfb-a876de76c1d2"},"execution_count":null,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":["Analizzando la curva di apprendimento del modello **MultinomialNB** si denota che sia la linea blu (training) si la linea arancione (test) sono praticamente sovrapposte e questo scaturisce che non c'è **Overfitting**. Entrambe le linee convergono verso 1.0 questo risultato permette di capire che non c'è **Underfitting** quindi il modello ha imparato bene"],"metadata":{"id":"I3tld0yUyVpx"}},{"cell_type":"code","source":["plot_learning_curve(pipeline_lr, X_train, y_train)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":435},"id":"ZHxdgjoGyU5b","executionInfo":{"status":"ok","timestamp":1782457378419,"user_tz":-120,"elapsed":5437,"user":{"displayName":"Fabrizio Ferla","userId":"15328954300085185958"}},"outputId":"f2a8cf5b-0117-489b-d2dd-3ea6f4cd0cb8"},"execution_count":null,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":["Analizzando la curva di apprendimento del modello **Regressione Logistica** si denota che  la linea blu (training) parte subito da 1 quindi memorizza i dati di training ma generalizza peggio sul test da qui si può evincere un  **Overfitting** iniziale ma da 100 esempi in poi le due linee convergono verso il 99% riducendo a 0 la distanza tra trainning e  test. Entrambe le linee convergono verso 1.0 questo risultato permette di capire che non c'è **Underfitting** quindi il modello ha imparato bene."],"metadata":{"id":"Sg7XGF_y5drt"}},{"cell_type":"markdown","source":["# Modelli a confronto\n","\n","Le curve di apprendiemento di entrmabi i modelli si comportano in modo diverso tra loro. Il modello di **MultinomialNB** stima la probabilità di ogni parola per ogni lingua, le parole sono indipendenti tra di loro e ha necessità di pochi dati per essere efficiente; Il modello di **Regressione Logistica** definisce un confine marcato tra una lingua e un'altra è molto lento ad apprendere e ha necessità di molti dati per avere la massima efficienza."],"metadata":{"id":"ZLOoya7_ZegX"}},{"cell_type":"markdown","source":["Test imput utente"],"metadata":{"id":"bgi41q8qY0FL"}},{"cell_type":"code","source":["sentence = input(\"Inserisci una frase: \") # Prende in input la frase dell'utente\n","\n","cleaned_sentence = data_cleaned(sentence) # Pulisce la frase dell'utente\n","\n","print(f\"Modello multinomi: {pipeline_nb.predict([cleaned_sentence])}\") # Utilizza il modello  Multinomiale Naive Bayes per predire la lingua\n","print(f\"Modello Regressione logistica: {pipeline_lr.predict([cleaned_sentence])}\") # Utilizza il modello di regressione logistica per predire la lingua"],"metadata":{"id":"G-A05-zXTLad","executionInfo":{"status":"ok","timestamp":1782458232864,"user_tz":-120,"elapsed":854442,"user":{"displayName":"Fabrizio Ferla","userId":"15328954300085185958"}},"colab":{"base_uri":"https://localhost:8080/"},"outputId":"36f87d84-0eaf-4d2e-a02f-3d3678b4f37c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Inserisci una frase: Egitto\n","Modello multinomi: ['it']\n","Modello Regressione logistica: ['it']\n"]}]},{"cell_type":"markdown","source":["Conclusioni"],"metadata":{"id":"h05yXeGDY69B"}},{"cell_type":"markdown","source":["A Parità di F1 medio (100%) in Cross validation, scelgo il modello di MultinomialNB come modello final. I fattori determinati sono: la semplictà nell'utilizzo, l'assenza di **Overfitting** evidenziata dalla curva di apprendimento, la poca quantità di dati utili per addestrare il modello cosa molto diversa dal modello di regressione logistica. Nel contesto di un dataset di dimensione moderate la semplicità e l'efficienza del MultinomialNB predilige questo modello."],"metadata":{"id":"tX5IY1YHGlAs"}}]}