....

.gitignore

@@ -0,0 +1,3 @@
+# DotEnv configuration
+.env
+

requirements.txt

@@ -1,4 +1,4 @@
-streamlit==1.26.0
+streamlit==1.34.0
 pandas==2.2.1
 matplotlib==3.8.2
 ipython==8.21.0
@@ -7,7 +7,6 @@ seaborn==0.13.2
 nltk==3.8.1
 scikit-learn==1.1.3
 scipy==1.9.3
-gensim==4.3.2
 sacrebleu==2.4.0
 pillow==9.5.0
 wordcloud==1.9.3
@@ -37,3 +36,7 @@ langchain_mistralai==0.2.0
 langgraph==0.2.34
 langsmith==0.1.131
 typing_extensions==4.12.2
+python-dotenv==1.0.1
+soundfile==0.12.1
+SpeechRecognition==3.10.4
+sounddevice==0.5.0

tabs/chatbot_tab.py

@@ -1,6 +1,16 @@
 import streamlit as st # type: ignore
 import os
 from datetime import datetime
+from extra_streamlit_components import tab_bar, TabBarItemData
+import io
+import base64
+from gtts import gTTS
+import soundfile as sf
+import sounddevice as sd
+import numpy as np
+import scipy.io.wavfile as wav
+import speech_recognition as sr
+import time
 from sentence_transformers import SentenceTransformer
 from translate_app import tr
 import getpass
@@ -12,6 +22,7 @@ from typing import Sequence
 from langchain_core.messages import BaseMessage, SystemMessage, HumanMessage, AIMessage, trim_messages
 from langgraph.graph.message import add_messages
 from typing_extensions import Annotated, TypedDict
+from dotenv import load_dotenv
 
 import warnings
 warnings.filterwarnings('ignore')
@@ -24,27 +35,23 @@ os.environ["LANGCHAIN_TRACING_V2"] = "true"
 os.environ["LANGCHAIN_ENDPOINT"]="https://api.smith.langchain.com"
 os.environ["LANGCHAIN_HUB_API_URL"]="https://api.smith.langchain.com"
 os.environ["LANGCHAIN_PROJECT"] = "Sales Coaching Chatbot" 
+if st.session_state.Cloud != 0:
+    load_dotenv()
 os.getenv("LANGCHAIN_API_KEY")
 os.getenv("MISTRAL_API_KEY")
+    
+    
+    
+    
 model = ChatMistralAI(model="mistral-large-latest")
-thread_id = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-dataPath = st.session_state.DataPath
 
-trimmer = trim_messages(
-    max_tokens=10000,
-    strategy="last",
-    token_counter=model,
-    include_system=True,
-    allow_partial=False,
-    start_on="human",
-)
 
+language = "French"
 prompt = ChatPromptTemplate.from_messages(
     [
         (
             "system",
-            "You are a helpful assistant. Answer all questions to the best of your ability in {language}.",
+            "Répond à toutes les questions du mieux possible en {language}.",
         ),
         MessagesPlaceholder(variable_name="messages"),
     ]
@@ -56,10 +63,7 @@ class State(TypedDict):
 
 def call_model(state: State):
     chain = prompt | model
-    trimmed_messages = trimmer.invoke(state["messages"])
-    response = chain.invoke(
-        {"messages": trimmed_messages, "language": state["language"]}
-    )
+    response = chain.invoke(state)
     return {"messages": [response]}
 
 # Define a new graph
@@ -74,14 +78,15 @@ workflow.add_edge("model", END)
 memory = MemorySaver()
 app = workflow.compile(checkpointer=memory)
 
-@st.cache_data
+# @st.cache_data
 def init():
-    global config,context,human_message1,ai_message1,trimmer,language
+    global config,thread_id, context,human_message1,ai_message1,language, app
     
+    thread_id = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     config = {"configurable": {"thread_id": thread_id}}
     
-    context = """Tu es un Directeur Commercial, mal organisé, d'une entreprise qui commercialise une solution technologique B2B"""
-    human_message1 = """Je souhaites que tu simule une conversation entre un commercial, Marc, de mon entreprise et toi, je prospecte.
+    context = """Tu es un Directeur Commercial, mal organisé, d'une entreprise qui commercialise une solution technologique B2B. """    
+    human_message1 = """Je souhaites que nous ayons une conversation verbale entre un commercial de mon entreprise, Marc (moi),  et toi que je prospecte.
 Mon entreprise propose une solution logicielle pour gérer la proposition de valeur d’entreprises B2B qui commercialises des solutions technologiques.   
     
 Les problématiques adressées par ma solution sont:  
@@ -114,56 +119,177 @@ et mon équipe de vente n'est pas performante.
  
 Attention: Ce n'est pas toi qui m'aide, c'est moi qui t'aide avec ma solution.
 """
-    ai_message1 = "J'ai bien compris, je suis un Directeur Commercial prospecté et je réponds à tes questions"   
+    ai_message1 = "J'ai bien compris, je suis un Directeur Commercial prospecté et je réponds seulement à mes questions"   
 
+    context = st.text_area(label=tr("Contexte:"), value=context)
+    human_message1 = st.text_area(label=tr("Consigne"), value=human_message1,height=300)
     messages = [
         SystemMessage(content=context),
         HumanMessage(content=human_message1),
         AIMessage(content=ai_message1),
+        HumanMessage(content="")
         ]
     
     
-    trimmer.invoke(messages)
-    language = "French"
-    st.write("Contexte: "+context+"\n")
-    st.write("Human Message: "+human_message1+"\n")
-    st.write("AI Message: "+ai_message1+"\n")
-
-init()
-
-def run():
 
-    st.write("")
-    st.write("")
-    st.title(tr(title))
-        
-    st.write("thread_id: "+thread_id)
-    query = st.text_area(label=tr("Vendeur:"), value="")
-    st.button(label=tr("Validez"), type="primary")
-    
-    input_messages = [HumanMessage(query)]
-    if query != "":
-        output = app.invoke(
-            {"messages": input_messages, "language": language},
+    app.invoke(
+            {"messages": messages, "language": language},
             config,
         )
-        st.write(output["messages"][-1].content)
-
-    
     '''
-    # Créer un espace réservé pour afficher les tokens
-    placeholder = st.empty()
-    
-    for chunk, metadata in app.stream(
-        {"messages": input_messages, "language": language},
-        config,
-        stream_mode="messages",
-        ):
-        if isinstance(chunk, AIMessage):  # Filter to just model responses
-            # st.markdown("<span style='white-space: nowrap;'>"+"/"+chunk.content+"/"+"</span>", unsafe_allow_html=True)
-            placeholder.markdown(f"<p style='display: inline;'>{chunk.content}</p>", unsafe_allow_html=True)
+    st.write("**Contexte:** "+context)
+    st.write("")
+    st.write("**Human Message:** "+human_message1)
+    st.write("")
+    st.write("**AI Message:** "+ai_message1)
     '''
     st.write("")
+    return config, thread_id
+
+# Fonction pour générer et jouer le texte en speech
+def play_audio(custom_sentence, Lang_target, speed=1.0):
+    # Générer le speech avec gTTS
+    audio_stream_bytesio_src = io.BytesIO()
+    tts = gTTS(custom_sentence, lang=Lang_target)
+    
+    # Revenir au début du flux audio
+    audio_stream_bytesio_src.seek(0)
+    audio_stream_bytesio_src.truncate(0)
+    
+    tts.write_to_fp(audio_stream_bytesio_src)
+
+    audio_stream_bytesio_src.seek(0)
+    
+    # Charger l'audio dans un tableau numpy
+    data, samplerate = sf.read(audio_stream_bytesio_src)
+
+    # Modifier la vitesse de lecture en ajustant le taux d'échantillonnage
+    new_samplerate = int(samplerate * speed)
+    new_audio_stream_bytesio = io.BytesIO()
+
+    # Enregistrer l'audio avec la nouvelle fréquence d'échantillonnage
+    sf.write(new_audio_stream_bytesio, data, new_samplerate, format='wav')
+    new_audio_stream_bytesio.seek(0)
+
+    # Lire l'audio dans Streamlit
+    st.audio(new_audio_stream_bytesio, autoplay=True)
+
+def is_silent(data, threshold=0.01):
+    """Vérifie si le niveau audio est inférieur à un certain seuil (silence)"""
+    return np.abs(data).mean() < threshold
+
+def record_audio_until_silence(fs=44100, silence_duration=2):
+    # st.write("Enregistrement en cours... Parlez maintenant.")
+    audio_data = []
+    silence_start = None
+
+    while True:
+        # Enregistre un petit bout de son
+        data = sd.rec(int(fs * 2), samplerate=fs, channels=1, dtype='float32')
+        sd.wait()
+
+        # Ajoute le morceau au tableau d'audio
+        audio_data.append(data)
+
+        # Vérifie si le morceau est en silence
+        if is_silent(data):
+            if silence_start is None:
+                silence_start = time.time()  # Démarre le chronomètre du silence
+            elif time.time() - silence_start > silence_duration:
+                print("Silence détecté. Fin de l'enregistrement.")
+                break  # Arrête l'enregistrement si le silence dure suffisamment longtemps
+        else:
+            silence_start = None  # Réinitialise le chronomètre si le son est détecté
+
+    # Convertit la liste de tableaux en un seul tableau NumPy
+    audio_data = np.concatenate(audio_data)
+    audio_data = np.int16(audio_data * 32767)
+
+    # Sauvegarde le fichier audio en format WAV
+    wav.write("enregistrement.wav", fs, audio_data)
+    st.write("Enregistrement sauvegardé")
+
+def convert_audio_to_text(filename):
+    recognizer = sr.Recognizer()
+    with sr.AudioFile(filename) as source:
+        audio = recognizer.record(source)  # Lit le fichier audio
+
+    try:
+        # Utilise l'API Google pour la reconnaissance vocale
+        text = recognizer.recognize_google(audio, language='fr-FR')
+        return text
+    except sr.UnknownValueError:
+        st.write("Google Speech Recognition n'a pas pu comprendre l'audio.")
+        return ""
+    except sr.RequestError as e:
+        st.write(f"Erreur avec le service Google Speech Recognition; {e}")
+        return ""
+
+
+def run():
+    global thread_id, config
+   
     st.write("")
     st.write("")
-    st.write("")
+    st.title(tr(title))
+    
+    chosen_id = tab_bar(data=[
+        TabBarItemData(id="tab1", title=tr("Initialisation"), description=tr("d'une nouvelle conversation")),
+        TabBarItemData(id="tab2", title=tr("Conversation"), description=tr("avec le prospect"))],
+        default="tab1")
+                        
+                        
+    if (chosen_id == "tab1"):
+        config,thread_id = init()
+        query = ""
+        st.button(label=tr("Validez"), type="primary")
+    else:
+        try:
+            config
+            # On ne fait rien
+        except NameError:
+            config,thread_id = init()
+        
+        st.write("**thread_id:** "+thread_id)
+        # query = st.text_area(label=tr("Vendeur:"), value="")
+        query = ""
+        if st.button(label=tr("Cliquer pour enregistrer"), type="primary"):
+            record_audio_until_silence()  # Enregistre jusqu'à ce qu'il y ait 2 secondes de silence
+            query = convert_audio_to_text("enregistrement.wav") # Convertit l'audio en texte   
+            st.write("**Vendeur :** "+query)
+            # st.button(label=tr("Validez"), type="primary")
+            input_messages = [HumanMessage(query)]
+            
+        if query != "":
+            output = app.invoke(
+                {"messages": input_messages, "language": language},
+                config,
+            )
+            st.write("**Prospect :** "+output["messages"][-1].content)
+            # Fonction pour générer et jouer le texte en speech
+
+
+            # Prononciation de la réponse
+            custom_sentence = output["messages"][-1].content
+            Lang_target = "fr"  # Exemple de langue détectée
+            # Joue l'audio
+            play_audio(custom_sentence, Lang_target, 1)
+
+        
+        '''
+            # Créer un espace réservé pour afficher les tokens
+            placeholder = st.empty()
+            
+            for chunk, metadata in app.stream(
+                {"messages": input_messages, "language": language},
+                config,
+                stream_mode="messages",
+                ):
+                if isinstance(chunk, AIMessage):  # Filter to just model responses
+                    # st.markdown("<span style='white-space: nowrap;'>"+"/"+chunk.content+"/"+"</span>", unsafe_allow_html=True)
+                    placeholder.markdown(f"<p style='display: inline;'>{chunk.content}</p>", unsafe_allow_html=True)
+        '''
+        st.write("")
+        st.write("")
+        st.write("")
+        st.write("")

tabs/intro.py

@@ -7,6 +7,7 @@ sidebar_name = "Introduction"
 
 def run():
 
+    st.write("")
     st.write("")
     # TODO: choose between one of these GIFs
     # st.image("https://dst-studio-template.s3.eu-west-3.amazonaws.com/1.gif")

tabs/sentence_similarity_tab.py

@@ -6,7 +6,6 @@ import contextlib
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
-from nltk.corpus import stopwords
 from sklearn.manifold import TSNE
 from sentence_transformers import SentenceTransformer
 from sklearn.metrics.pairwise import cosine_similarity
@@ -18,6 +17,7 @@ dataPath = st.session_state.DataPath
 
 
 def run():
+    st.write("")
     st.write("")
     st.title(tr(title))
     sentences = ["This is an example sentence", "Each sentence is converted"]

tabs/speech2text_tab.py

@@ -2,15 +2,10 @@ import streamlit as st # type: ignore
 import os
 import pandas as pd
 import collections
-from nltk.tokenize import word_tokenize
-from nltk import download
 from ast import literal_eval
 from translate_app import tr
 if st.session_state.Cloud == 0:
-    # import nltk
     import contextlib
-    import re
-    from nltk.corpus import stopwords
     import warnings
     warnings.filterwarnings('ignore')
 # from PIL import Image
@@ -20,308 +15,7 @@ if st.session_state.Cloud == 0:
 title = "Speech 2 Text"
 sidebar_name = "Speech 2 Text"
 dataPath = st.session_state.DataPath
-'''
-# Indiquer si l'on veut enlever les stop words. C'est un processus long
-stopwords_to_do = True
-# Indiquer si l'on veut lemmatiser les phrases, un fois les stop words enlevés. C'est un processus long (approximativement 8 minutes)
-lemmatize_to_do = True
-# Indiquer si l'on veut calculer le score Bleu pour tout le corpus. C'est un processus très long long (approximativement 10 minutes pour les 10 dictionnaires)
-bleu_score_to_do = True
-# Première ligne à charger
-first_line = 0
-# Nombre maximum de lignes à charger
-max_lines = 140000
-if ((first_line+max_lines)>137860):
-    max_lines = max(137860-first_line ,0)
-# Nombre maximum de ligne à afficher pour les DataFrame
-max_lines_to_display = 50
 
-download('punkt')
-
-if st.session_state.Cloud == 0:
-    download('averaged_perceptron_tagger')
-    with contextlib.redirect_stdout(open(os.devnull, "w")):
-        download('stopwords')
-
-@st.cache_data
-def load_data(path):
-    
-    input_file = os.path.join(path)
-    with open(input_file, "r",  encoding="utf-8") as f:
-        data = f.read()
-        
-    # On convertit les majuscules en minulcule
-    data = data.lower()
-    data = data.split('\n')
-    return data[first_line:min(len(data),first_line+max_lines)]
-
-@st.cache_data
-def load_preprocessed_data(path,data_type):
-    
-    input_file = os.path.join(path)
-    if data_type == 1:
-        return pd.read_csv(input_file, encoding="utf-8", index_col=0)
-    else:
-        with open(input_file, "r",  encoding="utf-8") as f:
-            data = f.read()
-            data = data.split('\n')
-        if data_type==0:
-            data=data[:-1]
-        elif data_type == 2:
-            data=[eval(i) for i in data[:-1]]
-        elif data_type ==3:
-            data2 = []
-            for d in data[:-1]:
-                data2.append(literal_eval(d))
-            data=data2
-        return data
-
-@st.cache_data
-def load_all_preprocessed_data(lang):
-    txt             =load_preprocessed_data(dataPath+'/preprocess_txt_'+lang,0)
-    txt_split       = load_preprocessed_data(dataPath+'/preprocess_txt_split_'+lang,3)
-    txt_lem         = load_preprocessed_data(dataPath+'/preprocess_txt_lem_'+lang,0)
-    txt_wo_stopword = load_preprocessed_data(dataPath+'/preprocess_txt_wo_stopword_'+lang,0)
-    df_count_word   = pd.concat([load_preprocessed_data(dataPath+'/preprocess_df_count_word1_'+lang,1), load_preprocessed_data(dataPath+'/preprocess_df_count_word2_'+lang,1)]) 
-    return txt, txt_split, txt_lem, txt_wo_stopword, df_count_word
-
-#Chargement des textes complet dans les 2 langues
-full_txt_en = load_data(dataPath+'/small_vocab_en')
-full_txt_fr = load_data(dataPath+'/small_vocab_fr')
-
-# Chargement du résultat du préprocessing, si st.session_state.reCalcule == False
-if not st.session_state.reCalcule:
-    full_txt_en, full_txt_split_en, full_txt_lem_en, full_txt_wo_stopword_en, full_df_count_word_en = load_all_preprocessed_data('en')
-    full_txt_fr, full_txt_split_fr, full_txt_lem_fr, full_txt_wo_stopword_fr, full_df_count_word_fr = load_all_preprocessed_data('fr')
-else:
-
-    def remove_stopwords(text, lang): 
-        stop_words = set(stopwords.words(lang))
-        # stop_words will contain  set all english stopwords
-        filtered_sentence = []   
-        for word in text.split(): 
-            if word not in stop_words: 
-                filtered_sentence.append(word) 
-        return " ".join(filtered_sentence)
-
-    def clean_undesirable_from_text(sentence, lang):
-
-        # Removing URLs 
-        sentence  = re.sub(r"https?://\S+|www\.\S+", "", sentence )
-    
-        # Removing Punctuations (we keep the . character)
-        REPLACEMENTS = [("..", "."),
-                        (",", ""),
-                        (";", ""),
-                        (":", ""),
-                        ("?", ""),
-                        ('"', ""),
-                        ("-", " "),
-                        ("it's", "it is"),
-                        ("isn't","is not"),
-                        ("'", " ")
-                        ]
-        for old, new in REPLACEMENTS:
-            sentence = sentence.replace(old, new)
-    
-        # Removing Digits
-        sentence= re.sub(r'[0-9]','',sentence)
-    
-        # Removing Additional Spaces
-        sentence = re.sub(' +', ' ', sentence)
-
-        return sentence
-
-    def clean_untranslated_sentence(data1, data2):
-        i=0
-        while i<len(data1):
-            if data1[i]==data2[i]:
-                data1.pop(i)
-                data2.pop(i)
-            else: i+=1
-        return data1,data2
-
-    import spacy
-
-    nlp_en = spacy.load('en_core_web_sm')
-    nlp_fr = spacy.load('fr_core_news_sm')
-
-
-    def lemmatize(sentence,lang):
-        # Create a Doc object
-        if lang=='en':
-            nlp=nlp_en
-        elif lang=='fr':
-            nlp=nlp_fr
-        else: return
-        doc = nlp(sentence)
-
-        # Create list of tokens from given string
-        tokens = [] 
-        for token in doc:
-            tokens.append(token)
-
-        lemmatized_sentence = " ".join([token.lemma_ for token in doc])
- 
-        return lemmatized_sentence
-
-
-    def preprocess_txt (data, lang): 
-  
-        word_count = collections.Counter()
-        word_lem_count = collections.Counter()
-        word_wosw_count = collections.Counter()
-        corpus = []
-        data_split = []
-        sentence_length = []
-        data_split_wo_stopwords = []
-        data_length_wo_stopwords = []
-        data_lem = []
-        data_lem_length = []
-    
-        txt_en_one_string= ". ".join([s for s in data])
-        txt_en_one_string = txt_en_one_string.replace('..', '.')
-        txt_en_one_string = " "+clean_undesirable_from_text(txt_en_one_string, 'lang')
-        data = txt_en_one_string.split('.')
-        if data[-1]=="":
-            data.pop(-1)
-        for i in range(len(data)): # On enleve les ' ' qui commencent et finissent les phrases 
-            if data[i][0] == ' ':
-                data[i]=data[i][1:]
-            if data[i][-1] == ' ':
-                data[i]=data[i][:-1]
-        nb_phrases = len(data)
-    
-        # Création d'un tableau de mots (sentence_split)
-        for i,sentence in enumerate(data):
-            sentence_split = word_tokenize(sentence)
-            word_count.update(sentence_split)
-            data_split.append(sentence_split)
-            sentence_length.append(len(sentence_split))
-
-        # La lemmatisation et le nettoyage des stopword va se faire en batch pour des raisons de vitesse
-        # (au lieu de le faire phrase par phrase)
-        # Ces 2 processus nécéssitent de connaitre la langue du corpus
-        if lang == 'en': l='english'
-        elif lang=='fr': l='french'
-        else: l="unknown"
-
-        if l!="unknown":
-            # Lemmatisation en 12 lots (On ne peut lemmatiser + de 1 M de caractères à la fois)
-            data_lemmatized=""
-            if lemmatize_to_do:
-                n_batch = 12
-                batch_size = round((nb_phrases/ n_batch)+0.5)
-                for i in range(n_batch):
-                    to_lem = ".".join([s for s in data[i*batch_size:(i+1)*batch_size]])
-                    data_lemmatized = data_lemmatized+"."+lemmatize(to_lem,lang).lower()
-
-                data_lem_for_sw = data_lemmatized[1:]  
-                data_lemmatized = data_lem_for_sw.split('.')
-                for i in range(nb_phrases):
-                    data_lem.append(data_lemmatized[i].split())
-                    data_lem_length.append(len(data_lemmatized[i].split()))
-                    word_lem_count.update(data_lem[-1])
-                               
-            # Elimination des StopWords en un lot
-            # On élimine les Stopwords des phrases lémmatisés, si cette phase a eu lieu
-            # (wosw signifie "WithOut Stop Words")
-            if stopwords_to_do:
-                if lemmatize_to_do:
-                    data_wosw = remove_stopwords(data_lem_for_sw,l)
-                else:
-                    data_wosw = remove_stopwords(txt_en_one_string,l)
-                               
-                data_wosw = data_wosw.split('.')
-                for i in range(nb_phrases):
-                    data_split_wo_stopwords.append(data_wosw[i].split())
-                    data_length_wo_stopwords.append(len(data_wosw[i].split()))
-                    word_wosw_count.update(data_split_wo_stopwords[-1])
-
-        corpus = list(word_count.keys())
-   
-        # Création d'un DataFrame txt_n_unique_val :
-        #      colonnes = mots
-        #      lignes = phases
-        #      valeur de la cellule = nombre d'occurence du mot dans la phrase
-    
-        ## BOW
-        from sklearn.feature_extraction.text import CountVectorizer
-        count_vectorizer = CountVectorizer(analyzer="word", ngram_range=(1, 1), token_pattern=r"[^' ']+" )
-    
-        # Calcul du nombre d'apparition de chaque mot dans la phrases
-        countvectors = count_vectorizer.fit_transform(data)
-        corpus = count_vectorizer.get_feature_names_out()
-
-        txt_n_unique_val=  pd.DataFrame(columns=corpus,index=range(nb_phrases), data=countvectors.todense()).astype(float)     
-    
-        return data, corpus, data_split, data_lemmatized, data_wosw, txt_n_unique_val, sentence_length, data_length_wo_stopwords, data_lem_length      
- 
-
-def count_world(data):
-    word_count = collections.Counter()
-    for sentence in data:
-        word_count.update(word_tokenize(sentence))
-    corpus = list(word_count.keys())
-    nb_mots = sum(word_count.values())
-    nb_mots_uniques = len(corpus)
-    return corpus, nb_mots, nb_mots_uniques
-                          
-def display_preprocess_results(lang, data, data_split, data_lem, data_wosw, txt_n_unique_val):
-
-    global max_lines, first_line, last_line, lemmatize_to_do, stopwords_to_do
-    corpus = []
-    nb_phrases = len(data)
-    corpus, nb_mots, nb_mots_uniques = count_world(data)
-    mots_lem, _ , nb_mots_lem = count_world(data_lem)
-    mots_wo_sw, _ , nb_mots_wo_stopword = count_world(data_wosw)
-    # Identifiez les colonnes contenant uniquement des zéros et les supprimer
-    columns_with_only_zeros = txt_n_unique_val.columns[txt_n_unique_val.eq(0).all()]
-    txt_n_unique_val = txt_n_unique_val.drop(columns=columns_with_only_zeros)
-
-    # Affichage du nombre de mot en fonction du pré-processing réalisé
-    tab1, tab2, tab3, tab4 = st.tabs([tr("Résumé"), tr("Tokenisation"),tr("Lemmatisation"), tr("Sans Stopword")])
-    with tab1:
-        st.subheader(tr("Résumé du pré-processing"))
-        st.write("**"+tr("Nombre de phrases")+"                     : "+str(nb_phrases)+"**")
-        st.write("**"+tr("Nombre de mots")+"                        : "+str(nb_mots)+"**")
-        st.write("**"+tr("Nombre de mots uniques")+"                : "+str(nb_mots_uniques)+"**") 
-        st.write("") 
-        st.write("\n**"+tr("Nombre d'apparitions de chaque mot dans chaque phrase (:red[Bag Of Words]):")+"**")
-        st.dataframe(txt_n_unique_val.head(max_lines_to_display), width=800) 
-    with tab2:
-        st.subheader(tr("Tokenisation"))
-        st.write(tr('Texte "splited":'))
-        st.dataframe(pd.DataFrame(data=data_split, index=range(first_line,last_line)).head(max_lines_to_display).fillna(''), width=800)
-        st.write("**"+tr("Nombre de mots uniques")+"                : "+str(nb_mots_uniques)+"**") 
-        st.write("")
-        st.write("\n**"+tr("Mots uniques")+":**")
-        st.markdown(corpus[:500])
-        st.write("\n**"+tr("Nombre d'apparitions de chaque mot dans chaque phrase (:red[Bag Of Words]):")+"**")
-        st.dataframe(txt_n_unique_val.head(max_lines_to_display), width=800) 
-    with tab3:
-        st.subheader(tr("Lemmatisation"))
-        if lemmatize_to_do:  
-            st.dataframe(pd.DataFrame(data=data_lem,columns=[tr('Texte lemmatisé')],index=range(first_line,last_line)).head(max_lines_to_display), width=800)
-            # Si langue anglaise, affichage du taggage des mots
-            # if lang == 'en':
-            #     for i in range(min(5,len(data))):
-            #         s = str(nltk.pos_tag(data_split[i]))
-            #         st.markdown("**Texte avec Tags     "+str(i)+"** : "+s)
-            st.write("**"+tr("Nombre de mots uniques lemmatisés")+"     : "+str(nb_mots_lem)+"**")
-            st.write("")
-            st.write("\n**"+tr("Mots uniques lemmatisés:")+"**")
-            st.markdown(mots_lem[:500])  
-    with tab4:
-        st.subheader(tr("Sans Stopword"))
-        if stopwords_to_do:
-            st.dataframe(pd.DataFrame(data=data_wosw,columns=['Texte sans stopwords'],index=range(first_line,last_line)).head(max_lines_to_display), width=800)
-            st.write("**"+tr("Nombre de mots uniques sans stop words")+": "+str(nb_mots_wo_stopword)+"**")
-            st.write("")  
-            st.write("\n**"+tr("Mots uniques sans stop words")+":**")
-            st.markdown(mots_wo_sw[:500])
-
-'''
 def run():
     global max_lines, first_line, last_line, lemmatize_to_do, stopwords_to_do
     global full_txt_en, full_txt_split_en, full_txt_lem_en, full_txt_wo_stopword_en, full_df_count_word_en
@@ -329,89 +23,6 @@ def run():
     
     st.write("")
     st.title(tr(title))
-    '''
-    st.write("## **"+tr("Explications")+" :**\n")
-    st.markdown(tr(
-        """
-        Le traitement du langage naturel permet à l'ordinateur de comprendre et de traiter les langues humaines.
-        Lors de notre projet, nous avons étudié le dataset small_vocab, proposés par Suzan Li, Chief Data Scientist chez Campaign Research à Toronto.
-        Celui-ci représente un corpus de phrases simples en anglais, et sa traduction (approximative) en français. 
-        :red[**Small_vocab**] contient 137 860 phrases en anglais et français.  
-        """)
-    , unsafe_allow_html=True)
-    st.markdown(tr(
-        """
-        Afin de découvrir ce corpus et de préparer la traduction, nous allons effectuer un certain nombre de tâches de pré-traitement (preprocessing).
-        Ces taches sont, par exemple:  
-        """)
-    , unsafe_allow_html=True)
-    st.markdown(
-        "* "+tr("le :red[**nettoyage**] du texte (enlever les majuscules et la ponctuation)")+"\n"+ \
-        "* "+tr("la :red[**tokenisation**] (découpage du texte en mots)")+"\n"+ \
-        "* "+tr("la :red[**lemmatisation**] (traitement lexical qui permet de donner une forme unique à toutes les \"variations\" d'un même mot)")+"\n"+ \
-        "* "+tr("l'élimination des :red[**mots \"transparents\"**] (sans utilité pour la compréhension, tels que les articles).")+"  \n"+ \
-        tr("Ce prétraintement se conclut avec la contruction d'un :red[**Bag Of Worlds**], c'est à dire une matrice qui compte le nombre d'apparition de chaque mots (colonne) dans chaque phrase (ligne)")
-    , unsafe_allow_html=True)
-    # 
-    st.write("## **"+tr("Paramètres")+" :**\n")
-    Langue = st.radio(tr('Langue:'),('Anglais','Français'), horizontal=True)
-    first_line = st.slider(tr('No de la premiere ligne à analyser:'),0,137859)
-    max_lines = st.select_slider(tr('Nombre de lignes à analyser:'),
-                              options=[1,5,10,15,100, 500, 1000,'Max'])
-    if max_lines=='Max':
-        max_lines=137860
-    if ((first_line+max_lines)>137860):
-        max_lines = max(137860-first_line,0)
-        
-    last_line = first_line+max_lines
-    if (Langue=='Anglais'):
-        st.dataframe(pd.DataFrame(data=full_txt_en,columns=['Texte']).loc[first_line:last_line-1].head(max_lines_to_display), width=800)
-    else:
-        st.dataframe(pd.DataFrame(data=full_txt_fr,columns=['Texte']).loc[first_line:last_line-1].head(max_lines_to_display), width=800)
-    st.write("")
-
-    # Chargement des textes sélectionnés dans les 2 langues (max lignes = max_lines)
-    txt_en = full_txt_en[first_line:last_line]
-    txt_fr = full_txt_fr[first_line:last_line]
-    
-    # Elimination des phrases non traduites
-    # txt_en, txt_fr = clean_untranslated_sentence(txt_en, txt_fr)
-
-    if not st.session_state.reCalcule:
-        txt_split_en = full_txt_split_en[first_line:last_line]
-        txt_lem_en = full_txt_lem_en[first_line:last_line]
-        txt_wo_stopword_en = full_txt_wo_stopword_en[first_line:last_line]
-        df_count_word_en = full_df_count_word_en.loc[first_line:last_line-1]
-        txt_split_fr = full_txt_split_fr[first_line:last_line]
-        txt_lem_fr = full_txt_lem_fr[first_line:last_line]
-        txt_wo_stopword_fr = full_txt_wo_stopword_fr[first_line:last_line]
-        df_count_word_fr = full_df_count_word_fr.loc[first_line:last_line-1]
-
-    # Lancement du préprocessing du texte qui va spliter nettoyer les phrases et les spliter en mots 
-    # et calculer nombre d'occurences des mots dans chaque phrase
-    if (Langue == 'Anglais'):
-        st.write("## **"+tr("Préprocessing de small_vocab_en")+" :**\n")
-        if max_lines>10000:
-            with st.status(":sunglasses:", expanded=True):
-                if st.session_state.reCalcule:
-                    txt_en, corpus_en, txt_split_en, txt_lem_en, txt_wo_stopword_en, df_count_word_en,sent_len_en, sent_wo_sw_len_en, sent_lem_len_en  = preprocess_txt (txt_en,'en')
-                display_preprocess_results('en',txt_en, txt_split_en, txt_lem_en, txt_wo_stopword_en, df_count_word_en)
-        else:
-            if st.session_state.reCalcule:
-                txt_en, corpus_en, txt_split_en, txt_lem_en, txt_wo_stopword_en, df_count_word_en,sent_len_en, sent_wo_sw_len_en, sent_lem_len_en  = preprocess_txt (txt_en,'en')
-            display_preprocess_results('en',txt_en, txt_split_en, txt_lem_en, txt_wo_stopword_en, df_count_word_en)
-    else:
-        st.write("## **"+tr("Préprocessing de small_vocab_fr")+" :**\n")
-        if max_lines>10000:
-            with st.status(":sunglasses:", expanded=True):
-                if st.session_state.reCalcule:
-                    txt_fr, corpus_fr, txt_split_fr, txt_lem_fr, txt_wo_stopword_fr, df_count_word_fr,sent_len_fr, sent_wo_sw_len_fr, sent_lem_len_fr  = preprocess_txt (txt_fr,'fr')
-                display_preprocess_results('fr', txt_fr, txt_split_fr, txt_lem_fr, txt_wo_stopword_fr, df_count_word_fr)
-        else:
-            if st.session_state.reCalcule:
-                txt_fr, corpus_fr, txt_split_fr, txt_lem_fr, txt_wo_stopword_fr, df_count_word_fr,sent_len_fr, sent_wo_sw_len_fr, sent_lem_len_fr  = preprocess_txt (txt_fr,'fr')
-            display_preprocess_results('fr', txt_fr, txt_split_fr, txt_lem_fr, txt_wo_stopword_fr, df_count_word_fr)
-    '''