import streamlit as st
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tiktoken
import joblib
import json
from transformers import pipeline
from extra_streamlit_components import tab_bar, TabBarItemData
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import naive_bayes
from translate_app import tr
import requests
title = "Identification de langue"
sidebar_name = "Identification de langue"
dataPath = st.session_state.DataPath
# CountVectorizer a une liste de phrase en entrée.
# Cette fonction met les données d'entrée dans le bon format
def format_to_vectorize(data):
X_tok = []
if "DataFrame" in str(type(data)):sentences = data.tolist()
elif "str" in str(type(data)):
sentences =[data]
else: sentences = data
for sentence in sentences:
X_tok.append(sentence)
return X_tok
def create_BOW(data):
global vectorizer
X_tok = format_to_vectorize(data)
X = vectorizer.transform(X_tok)
return X
def load_vectorizer(tokenizer):
global dict_token, dict_ids, nb_token
path = dataPath+'/vectorizer_tiktoken_big.pkl'
vectorizer = joblib.load(path)
dict_token = {tokenizer.decode([cle]): cle for cle, valeur in vectorizer.vocabulary_.items()}
dict_ids = {cle: tokenizer.decode([cle]) for cle, valeur in vectorizer.vocabulary_.items()} #dict_ids.items()}
nb_token = len(vectorizer.vocabulary_)
return vectorizer
def lang_id_nb(sentences):
global lan_to_language
if "str" in str(type(sentences)):
return lan_to_language[clf_nb.predict(create_BOW(sentences))[0]]
else: return [lan_to_language[l] for l in clf_nb.predict(create_BOW(sentences))]
@st.cache_resource
def init_nb_identifier():
tokenizer = tiktoken.get_encoding("cl100k_base")
# Chargement du classificateur sauvegardé
clf_nb = joblib.load(dataPath+"/id_lang_tiktoken_nb_sparse_big.pkl")
vectorizer = load_vectorizer(tokenizer)
# Lisez le contenu du fichier JSON
with open(dataPath+'/multilingue/lan_to_language.json', 'r') as fichier:
lan_to_language = json.load(fichier)
return tokenizer, dict_token, dict_ids, nb_token, lan_to_language, clf_nb, vectorizer
@st.cache_resource
def init_lang_id_external():
lang_id_model_ext = pipeline('text-classification',model="papluca/xlm-roberta-base-language-detection")
dict_xlmr = {"ar":"ara", "bg":"bul", "de":"deu", "el": "ell", "en":"eng", "es":"spa", "fr":"fra", "hi": "hin","it":"ita","ja":"jpn", \
"nl":"nld", "pl":"pol", "pt":"por", "ru":"rus", "sw":"swh", "th":"tha", "tr":"tur", "ur": "urd", "vi":"vie", "zh":"cmn"}
sentence_test = pd.read_csv(dataPath+'//multilingue/sentence_test_extract.csv')
sentence_test = sentence_test[:4750]
# Instanciation d'un exemple
exemples = ["Er weiß überhaupt nichts über dieses Buch", # Phrase 0
"Umbrellas sell well", # Phrase 1
"elle adore les voitures très luxueuses, et toi ?", # Phrase 2
"she loves very luxurious cars, don't you?", # Phrase 3
"Vogliamo visitare il Colosseo e nuotare nel Tevere", # Phrase 4
"vamos a la playa", # Phrase 5
"Te propongo un trato", # Phrase 6
"she loves you much, mais elle te hait aussi and das ist traurig", # Phrase 7 # Attention à cette phrase trilingue
"Elle a de belles loches" # Phrase 8
]
lang_exemples = ['deu','eng','fra','eng','ita','spa','spa','fra','fra']
return lang_id_model_ext, dict_xlmr, sentence_test, lang_exemples, exemples
@st.cache_data
def display_acp(title, comment):
data = np.load(dataPath+'/data_lang_id_acp.npz')
X_train_scaled = data['X_train_scaled']
y_train_pred = data['y_train_pred']
label_arrow = ['.', ',', '?', ' a', ' de', ' la', ' que', 'Tom', ' un', ' the', ' in', \
' to', 'I', "'", 'i', ' le', ' en', ' es', 'é', ' l', '!', 'o', ' ist', \
' pas', ' Tom', ' me', ' di', 'Ich', ' is', 'Je', ' nicht', ' you', \
' die', ' à', ' el', ' est', 'a', 'en', ' d', ' è', ' ne', ' se', ' no', \
' una', ' zu', 'Il', '¿', ' of', ' du', "'t", 'ato', ' der', ' il', \
' n', 'El', ' non', ' che', 'are', ' con', 'ó', ' was', 'La', 'No', \
' ?', 'es', 'le', 'L', ' and', ' des', ' s', ' ich', 'as', 'S', ' per', \
' das', ' und', ' ein', 'e', "'s", 'u', ' y', 'He', 'z', 'er', ' m', \
'st', ' les', 'Le', ' I', 'ar', 'te', 'Non', 'The', ' er', 'ie', ' v', \
' c', "'est", ' ha', ' den']
pca = PCA(n_components=2)
X_new = pca.fit_transform(X_train_scaled)
coeff = pca.components_.transpose()
xs = X_new[:, 0]
ys = X_new[:, 1]
scalex = 1.0/(xs.max() - xs.min())
scaley = 1.0/(ys.max() - ys.min())
principalDf = pd.DataFrame({'PC1': xs*scalex, 'PC2': ys * scaley})
finalDF = pd.concat([principalDf, pd.Series(y_train_pred, name='Langue')], axis=1)
sns.set_context("poster") # Valeur possible:"notebook", "talk", "poster", ou "paper"
plt.rc("axes", titlesize=32,titleweight='bold') # Taille du titre de l'axe
plt.rc("axes", labelsize=18,labelweight='bold') # Taille des étiquettes de l'axe
plt.rc("xtick", labelsize=14) # Taille des étiquettes de l'axe des x
plt.rc("ytick", labelsize=14) # Taille des étiquettes de l'axe des y
st.write(comment)
st.write("")
fig = plt.figure(figsize=(20, 15))
sns.scatterplot(x='PC1', y='PC2', hue='Langue', data=finalDF, alpha=0.5)
for i in range(50):
plt.arrow(0, 0, coeff[i, 0]*1.5, coeff[i, 1]*0.8,color='k', alpha=0.08, head_width=0.01, )
plt.text(coeff[i, 0]*1.5, coeff[i, 1] * 0.8, label_arrow[i], color='k', weight='bold')
plt.title(title)
plt.xlim(-0.4, 0.45)
plt.ylim(-0.15, 0.28);
st.pyplot(fig)
return
@st.cache_data
def read_BOW_examples():
return pd.read_csv(dataPath+'/lang_id_small_BOW.csv')
def analyse_nb(sel_phrase):
global lang_exemples,exemples
def create_small_BOW(s):
encodage = tokenizer.encode(s)
sb = [0] * (df_BOW.shape[1]-1)
nb_unique_token = 0
for i in range(df_BOW.shape[1]-1):
for t in encodage:
if df_BOW.columns[i]==str(t):
sb[i] += 1
if sb[i] > 0: nb_unique_token +=1
return sb, nb_unique_token
st.write("#### **"+tr("Probabilité d'appartenance de la phrase à une langue")+" :**")
st.image("./assets/formule_proba_naive_bayes.png")
st.write(tr("où **C** est la classe (lan_code), **Fi** est la caractéristique i du BOW, **Z** est l'\"evidence\" servant à regulariser la probabilité"))
st.write("")
nb_lang = 5
lan_code = ['deu','eng','fra','spa','ita']
lan_color = {'deu':'violet','eng':'green','fra':'red','spa':'blue','ita':'orange'}
df_BOW = read_BOW_examples()
clf_nb2 = naive_bayes.MultinomialNB()
clf_nb2.fit(df_BOW.drop(columns='lan_code').values.tolist(), df_BOW['lan_code'].values.tolist())
nb_phrases_lang =[]
for l in lan_code:
nb_phrases_lang.append(sum(df_BOW['lan_code']==l))
st.write(tr("Phrase à analyser")+" :",'**:'+lan_color[lang_exemples[sel_phrase]]+'['+lang_exemples[sel_phrase],']** - **"'+exemples[sel_phrase]+'"**')
# Tokenisation et encodage de la phrase
encodage = tokenizer.encode(exemples[sel_phrase])
# Création du vecteur BOW de la phrase
bow_exemple, nb_unique_token = create_small_BOW(exemples[sel_phrase])
st.write(tr("Nombre de tokens retenus dans le BOW")+": "+ str(nb_unique_token))
masque_tokens_retenus = [(1 if token in list(dict_ids.keys()) else 0) for token in encodage]
str_token = " "
for i in range(len(encodage)):
if masque_tokens_retenus[i]==1:
if (i%2) ==0:
str_token += "**:red["+tokenizer.decode([encodage[i]])+"]** "
else:
str_token += "**:violet["+tokenizer.decode([encodage[i]])+"]** "
else: str_token += ":green["+tokenizer.decode([encodage[i]])+"] "
st.write(tr("Tokens se trouvant dans le modèle (en")+" :red["+tr("rouge")+"] "+tr("ou")+" :violet["+tr("violet")+"]) :"+str_token+" ")
st.write("")
# Afin de continuer l'analyse on ne garde que les token de la phrase disponibles dans le BOW
token_used = [str(encodage[i]) for i in range(len(encodage)) if (masque_tokens_retenus[i]==1)]
# Calcul du nombre d'apparition de ces tokens dans le BOW pour chaque langue, et stockage dans un DataFrame df_count
def compter_non_zero(colonne):
return (colonne != 0).sum()
votes = []
for i in range(nb_lang):
#votes.append(list(df_BOW[token_used].loc[df_BOW['lan_code']==lan_code[i]].sum(axis=0)))
votes.append(list(df_BOW[token_used].loc[df_BOW['lan_code']==lan_code[i]].apply(compter_non_zero)))
col_name = [str(i+1)+'-'+tokenizer.decode([int(token_used[i])]) for i in range(len(token_used))]
df_count = pd.DataFrame(data=votes,columns=token_used, index=lan_code)
df_count.columns = col_name
st.write("\n**"+tr("Nombre d'apparitions des tokens, dans chaque langue")+"**")
# Lissage de Laplace n°1 (Laplace smoothing )
# df_count = df_count+1
st.dataframe(df_count)
#########
######### 3. Calcul de la probabilité d'apparition de chaque token dans chaque langue
df_proba = df_count.div(nb_phrases_lang, axis = 0)
# Lissage de Laplace n°2 (Laplace smoothing )
df_proba = df_proba.replace(0.0,0.0010)
# Initialisation de df_proba: Calcul de la probabilité conditionnelle d'appartenance de la phrase à une langue
df_proba['Proba'] = 1
# Itérer sur les colonnes et effectuez la multiplication pour chaque ligne
for col in df_count.columns:
df_proba['Proba'] *= df_proba[col]
#########
######### 4. Calcul (par multiplication) de la probabilité d'appartenance de la phrase à une langue
# Multiplication par la probabilité de la classe
p_classe = [(nb_phrases_lang[i]/df_BOW.shape[0]) for i in range(len(nb_phrases_lang))]
df_proba['Proba'] *= p_classe
# Diviser par l'evidence
evidence = df_proba['Proba'].sum(axis=0)
df_proba['Proba'] *= 1/evidence
df_proba['Proba'] = df_proba['Proba'].round(3)
# Affichage de la matrice des probabilités
st.write("**"+tr("Probabilités conditionnelles d'apparition des tokens retenus, dans chaque langue")+":**")
st.dataframe(df_proba)
str_token = "Lang proba max: "# "*20
for i,token in enumerate(df_proba.columns[:-1]):
str_token += '*'+token+'*:**:'+lan_color[df_proba[token].idxmax()]+'['+df_proba[token].idxmax()+']**'+" "*2 #8
st.write(str_token)
st.write("")
st.write(tr("Langue réelle de la phrase")+" "*35+": **:"+lan_color[lang_exemples[sel_phrase]]+'['+lang_exemples[sel_phrase]+']**')
st.write(tr("Langue dont la probabilité est la plus forte ")+": **:"+lan_color[df_proba['Proba'].idxmax()]+'['+df_proba['Proba'].idxmax(),"]** (proba={:.2f}".format(max(df_proba['Proba']))+")")
prediction = clf_nb2.predict([bow_exemple])
st.write(tr("Langue prédite par Naiva Bayes")+" "*23+": **:"+lan_color[prediction[0]]+'['+prediction[0]+"]** (proba={:.2f}".format(max(clf_nb2.predict_proba([bow_exemple])[0]))+")")
st.write("")
fig, axs = plt.subplots(1, 2, figsize=(10, 6))
df_proba_sorted =df_proba.sort_index(ascending=True)
axs[0].set_title(tr("Probabilités calculée manuellement"), fontsize=12)
axs[0].barh(df_proba_sorted.index, df_proba_sorted['Proba'])
axs[1].set_title(tr("Probabilités du classifieur Naive Bayes"), fontsize=12)
axs[1].barh(df_proba_sorted.index, clf_nb2.predict_proba([bow_exemple])[0]);
st.pyplot(fig)
return
#@st.cache_data
def find_exemple(lang_sel):
global exemples
return exemples[lang_sel]
def display_shapley(lang_sel):
st.write("**"+tr("Analyse de l'importance de chaque token dans l'identification de la langue")+"**")
st.image('assets/fig_schapley'+str(lang_sel)+'.png')
st.write("**"+tr("Recapitulatif de l'influence des tokens sur la selection de la langue")+"**")
st.image('assets/fig_schapley_recap'+str(lang_sel)+'.png')
return
def run():
global tokenizer, vectorizer, dict_token, dict_ids, nb_token, lan_to_language, clf_nb
global toggle_val, custom_sentence, lan_identified
global lang_exemples, exemples
tokenizer, dict_token, dict_ids, nb_token, lan_to_language, clf_nb, vectorizer = init_nb_identifier()
lan_identified = requests.get( "https://demosthene-or-api-avr23-cds-translation.hf.space/lan_identified").json()
lang_id_model_ext, dict_xlmr, sentence_test, lang_exemples, exemples= init_lang_id_external()
st.write("")
st.title(tr(title))
st.write("## **"+tr("Explications")+" :**\n")
st.markdown(tr(
"""
Afin de mettre en oeuvre cette fonctionnalité nous avons utilisé un jeu d'entrainement multilinge de 9.757.778 phrases dans 95 langues.
Les 95 langues identifiées sont:
""")
, unsafe_allow_html=True)
st.selectbox(label="Lang",options=sorted(lan_identified),label_visibility="hidden")
st.markdown(tr(
"""
Nous avons utilisé 2 méthodes pour identifier la langue d'un texte:
1. un classificateur **Naïve Bayes**
2. un modèle de **Deep Learning**
""")
, unsafe_allow_html=True)
st.markdown(tr(
"""
Les 2 modèles ont un accuracy similaire sur le jeu de test: **:red[96% pour NB et 97,5% pour DL]**
""")
, unsafe_allow_html=True)
chosen_id = tab_bar(data=[
TabBarItemData(id="tab1", title=tr("Id. Naïve Bayes"), description=tr("avec le Bag Of Words")),
TabBarItemData(id="tab2", title=tr("Id. Deep Learning"), description=tr(" avec Keras")),
TabBarItemData(id="tab3", title=tr("Interpretabilité"), description=tr("du modèle Naïve Bayes "))],
default="tab1")
if (chosen_id == "tab1") or (chosen_id == "tab2"):
st.write("## **"+tr("Paramètres")+" :**\n")
toggle_val = st.toggle(tr('Phrase à saisir/Phrase test'), value=True, help=tr("Off = phrase à saisir, On = selection d'une phrase test parmi 9500 phrases"))
if toggle_val:
custom_sentence= st.selectbox(tr("Selectionnez une phrases test à identifier")+":", sentence_test['sentence'] )
else:
custom_sentence = st.text_area(label=tr("Saisir le texte dont vous souhaitez identifier la langue:"))
st.button(label=tr("Validez"), type="primary")
if custom_sentence!='':
url = "https://demosthene-or-api-avr23-cds-translation.hf.space/lang_id_dl"
params = {"sentence": custom_sentence}
response = requests.get(url, params=params)
st.write("## **"+tr("Résultats")+" :**\n")
md = """
|"""+tr("Identifieur")+""" |"""+tr("Langue identifiée")+"""|
|-------------------------------------|---------------|"""
md1 = ""
if toggle_val:
lan_reelle = sentence_test['lan_code'].loc[sentence_test['sentence']==custom_sentence].tolist()[0]
md1 = """
|"""+tr("Langue réelle")+""" |**:blue["""+lan_to_language[lan_reelle]+"""]**|"""
md2 = """
|"""+tr("Classificateur Naïve Bayes")+""" |**:red["""+lang_id_nb(custom_sentence)+"""]**|
|"""+tr("Modèle de Deep Learning")+""" |**:red["""+str(response.json())+"""]**|"""
md3 = """
|XLM-RoBERTa (Hugging Face) |**:red["""+lan_to_language[dict_xlmr[lang_id_model_ext(custom_sentence)[0]['label']]]+"""]**|"""
if toggle_val:
if not (lan_reelle in list(dict_xlmr.values())):
md3=""
st.markdown(md+md1+md2+md3, unsafe_allow_html=True)
st.write("## **"+tr("Details sur la méthode")+" :**\n")
if (chosen_id == "tab1"):
st.markdown(tr(
"""
Afin d'utiliser le classificateur Naïve Bayes, il nous a fallu:""")+"\n"+
"* "+tr("Créer un Bag of Words de token..")+"\n"+
"* "+tr("..Tokeniser le texte d'entrainement avec CountVectorizer et un tokenizer 'custom', **Tiktoken** d'OpenAI. ")+"\n"+
"* "+tr("Utiliser des matrices creuses (Sparse Matrix), car notre BOW contenait 10 Millions de lignes x 59122 tokens. ")+"\n"+
"* "+tr("Sauvegarder le vectorizer (non serialisable) et le classificateur entrainé. ")
, unsafe_allow_html=True)
st.markdown(tr(
"""
L'execution de toutes ces étapes est assez rapide: une dizaine de minutes
Le résultat est très bon: L'Accuracy sur le jeu de test est =
**:red[96%]** sur les 95 langues, et **:red[99,1%]** sur les 5 langues d'Europe de l'Ouest (en,fr,de,it,sp)
""")
, unsafe_allow_html=True)
st.markdown(tr(
"""
**Note 1:** Les 2 modèles ont un accuracy similaire sur le jeu de test: **:red[96% pour NB et 97,5% pour DL]**
**Note 2:** Le modèle *XLM-RoBERTa* de Hugging Face (qui identifie 20 langues seulement) a une accuracy, sur notre jeu de test = **97,8%**,
versus **99,3% pour NB** et **99,2% pour DL** sur ces 20 langues.
""")
, unsafe_allow_html=True)
else:
st.markdown(tr(
"""
Nous avons mis en oeuvre un modèle Keras avec une couche d'embedding et 4 couches denses (*Voir architecture ci-dessous*).
Nous avons utilisé le tokeniser Tiktoken d'OpenAI.
La couche d'embedding accepte 250 tokens, ce qui signifie que la détection de langue s'effectue sur approximativement les 200 premiers mots.
""")
, unsafe_allow_html=True)
st.markdown(tr(
"""
L'entrainement a duré plus de 10 heures..
Finalement, le résultat est très bon: L'Accuracy sur le jeu de test est =
**:red[97,5%]** sur les 95 langues, et **:red[99,1%]** sur les 5 langues d'Europe de l'Ouest (en,fr,de,it,sp).
Néanmoins, la durée pour une prédiction est relativement longue: approximativement 5/100 de seconde
""")
, unsafe_allow_html=True)
st.markdown(tr(
"""
**Note 1:** Les 2 modèles ont un accuracy similaire sur le jeu de test: **:red[96% pour NB et 97,5% pour DL]**""")+"
"+
tr("""
**Note 2:** Le modèle *XLM-RoBERTa* de Hugging Face (qui identifie 20 langues seulement) a une accuracy, sur notre jeu de test = 97,8%,
versus **99,3% pour NB** et **99,2% pour DL** sur ces 20 langues.
""")
, unsafe_allow_html=True)
st.write(""+tr("Architecture du modèle utilisé")+":
", unsafe_allow_html=True)
col1, col2, col3 = st.columns([0.15,0.7,0.15])
with col2:
st.image("https://demosthene-or-api-avr23-cds-translation.hf.space/small_vocab/plot_model?&model_type=lang_id",use_column_width="auto")
elif (chosen_id == "tab3"):
st.write("### **"+tr("Interpretabilité du classifieur Naïve Bayes sur 5 langues")+"**")
st.write("##### "+tr("..et un Training set réduit (15000 phrases et 94 tokens)"))
st.write("")
chosen_id2 = tab_bar(data=[
TabBarItemData(id="tab1", title=tr("Analyse en Compos. Princ."), description=""),
TabBarItemData(id="tab2", title=tr("Simul. calcul NB"), description=""),
TabBarItemData(id="tab3", title=tr("Shapley"), description="")],
default="tab1")
if (chosen_id2 == "tab1"):
display_acp(tr("Importance des principaux tokens dans \n l'identification de langue par l'algorithme Naive Bayes"),tr("Affichage de 10 000 phrases (points) et des 50 tokens les + utilisés (flèches)"))
if (chosen_id2 == "tab2") or (chosen_id2 == "tab3"):
sel_phrase = st.selectbox(tr('Selectionnez une phrase à "interpréter"')+':', range(9), format_func=find_exemple)
if (chosen_id2 == "tab2"):
analyse_nb(sel_phrase)
if (chosen_id2 == "tab3"):
display_shapley(sel_phrase)