Update app.py

app.py

@@ -36,199 +36,201 @@ def setup_tensorflow():
 
 # Usage dans votre app Gradio
 tf = setup_tensorflow()
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import Embedding, GRU, Dense
-from tensorflow.keras.preprocessing.text import Tokenizer
-from tensorflow.keras.preprocessing.sequence import pad_sequences
-
-#creation du model
-model = Sequential()
-# analyse du texte
-tokenizer = Tokenizer()
-
-max_sequence_len=0
-
-textes = [
-    "la goutte d'eau qui fait déborder le vase", 
-    "Il n'y a pas de fumée sans feu", 
-    "Il faut battre le fer tant qu'il est chaud", 
-    "Il ne faut pas mettre tous ses oeufs dans le même panier", 
-    "Il faut tourner sept fois sa langue dans sa bouche avant de parler", 
-    "L'habit ne fait pas le moine", 
-    "Il ne faut pas réveiller le chat qui dort", 
-    "Il faut se méfier de l'eau qui dort", 
-    "C'est l'hôpital qui se moque de la charité", 
-    "Qui vole un oeuf vole un boeuf", 
-    "Chercher midi à quatorze heures", 
-    "Avoir un poil dans la main", 
-    "Être dans de beaux draps", 
-    "Avoir la tête dans les nuages", 
-    "Mettre les pieds dans le plat"]
-
-
-def afficher_liste(liste):
-    return "\n".join(liste)
-
-def ajouter_a_liste(liste_actuelle, nouveau_texte):
-    if nouveau_texte:
-        liste_actuelle.append(nouveau_texte)
-    return liste_actuelle, ""
-
-def supprimer_de_liste(liste_actuelle, index_a_supprimer):
-    if index_a_supprimer is not None and 0 <= index_a_supprimer < len(liste_actuelle):
-        ligne_supprimee = liste_actuelle.pop(index_a_supprimer)
-        message = f"Ligne supprimée : '{ligne_supprimee}'"
-    else:
-        message = "Aucune ligne sélectionnée pour suppression"    
-    return liste_actuelle, liste_actuelle, message  # Liste mise à jour, choix mis à jour, message
-
-def apprendre(liste_actuelle):
-    global max_sequence_len
-    # Traiter la liste finale
-    resultat = ", ".join(liste_actuelle)
-    print("Liste soumise:", liste_actuelle)  # Pour voir dans la console
-    # analyse du texte
-    tokenizer.fit_on_texts(liste_actuelle)
-    total_words = len(tokenizer.word_index) + 1
-    print("nb de mots différents rencontrés :", total_words)
-    type(tokenizer.word_index)
-    #from dict to list 
-    liste = list(tokenizer.word_index.keys())
-    print("voici les premiers mots trouvés : ")
-    for i in range(10): print(f"({i+1}:'{liste[i]}')", end= ", ")
-    print()
-    # transformation des textes en vecteurs 
-    input_sequences = []
-    for sentence in liste_actuelle:
-        token_list = tokenizer.texts_to_sequences([sentence])[0]
-        for i in range(1, len(token_list)):
-            n_gram_sequence = token_list[:i+1]
-            input_sequences.append(n_gram_sequence)
-    # calibrage des vecteurs pour qu'ils aient tous la même longueur
-    max_sequence_len = max([len(x) for x in input_sequences])
-    input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')
-    print("la phrase '", liste_actuelle[0], "' est traduite en plusieurs vecteurs :")
-    split = liste_actuelle[0].split()
-    for i in range(6):
-        print(input_sequences[i], end=" -> '")
-        for j in range(i+2):
-            print(split[j], end=" ")
-        print("'")
-    # creer les x (premieres valeurs de chaque vecteur)
-    X = input_sequences[:, :-1]
-    # creer les y (derniere valeur de chaque vecteur)
-    y = input_sequences[:, -1]
-    # chaque mot de sortie est représenté par un vecteur de 0, avec 1 correspondant à l'indice du mot
-    #donc le vecteur est aussi grand que le nb de mots trouvés
-    y = tf.keras.utils.to_categorical(y, num_classes=total_words)
+if tf is not None:
+    from tensorflow.keras.models import Sequential
+    from tensorflow.keras.layers import Embedding, GRU, Dense
+    from tensorflow.keras.preprocessing.text import Tokenizer
+    from tensorflow.keras.preprocessing.sequence import pad_sequences
+    
     #creation du model
-    model.add(Embedding(total_words, 50, input_length=max_sequence_len-1))
-    model.add(GRU(120, return_sequences=False))
-    model.add(Dense(total_words, activation='softmax'))
-    # Compile the model
-    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
-    # entrainer le modele
-    print("patienter 30s pendant l'entrainement...")
-    model.fit(X, y, epochs=300, verbose=0)
-    return f"Entrainement effectué, saisissez un début de phrase pour demander la suite"
-
-
-# fonction pour prédire le mot suivant
-def predict_next_word(start_text, nb_words):
-    print("===> start_text=",start_text)
-    print(f"prédictions de {nb_words} mots.")
-    for _ in range(nb_words):
-        token_list = tokenizer.texts_to_sequences([start_text])[0]
-        token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')
-        print("===> token_list=",token_list)
-        predicted = np.argmax(model.predict(token_list), axis=-1)        
-        print("===> predicted=",predicted)
-        for word, index in tokenizer.word_index.items():
-            if index == predicted:
-                start_text += " " + word
-                break
-    print(f"Prediction: {start_text}")
-    print("-" * 50)
-    return start_text
-
+    model = Sequential()
+    # analyse du texte
+    tokenizer = Tokenizer()
     
-with gr.Blocks() as demo:
-    #ENTETE
-    gr.Markdown("# Exemple de prévision de mots")
-    gr.Markdown("Exemple simple, utilisant un réseau de neurone de type **GRU**")
-    gr.Markdown("- Le réseau 'apprend' les phrases de la liste (vous pouvez en ajouter)")
-    gr.Markdown("- Cliquez sur apprendre si l'apprentissage n'a pas eu lieu")
-    gr.Markdown("- Donnez plus bas un début de phrase et laissez le réseau en déduire la suite")
+    max_sequence_len=0
     
-    #Liste de phrases
-    with gr.Row():
-        sortie = gr.Textbox(label="Phrases actuelles", lines=5)
-        liste = gr.State( textes)
-        # Ajouter et supprimer des lignes
-        with gr.Column():
-            texte = gr.Textbox(label="Nouvelle phrase courte")
-            btn_add = gr.Button("Ajouter")        
-            # Liste déroulante pour sélectionner une ligne à supprimer
-            choix_ligne = gr.Dropdown(
-                choices=textes,
-                label="Sélectionner une ligne à supprimer",
-                type="index"  # Retourne l'index et non la valeur
-            )
-            btn_supprimer = gr.Button("Supprimer de la liste")
-            feedback = gr.Textbox(label="Message", lines=1)    
-    # ajouter une ligne
-    btn_add.click(
-        fn=ajouter_a_liste, 
-        inputs=[liste, texte], 
-        outputs=[liste, texte]
-    ).then(
-        fn=lambda x: "\n".join(x), 
-        inputs=[liste], 
-        outputs=[sortie]
-    )
-    # Supprimer une ligne
-    btn_supprimer.click(
-        fn=supprimer_de_liste,
-        inputs=[liste, choix_ligne],
-        outputs=[liste, choix_ligne, feedback]
-    ).then(
-        fn=afficher_liste,
-        inputs=[liste],
-        outputs=[sortie]
-    )
+    textes = [
+        "la goutte d'eau qui fait déborder le vase", 
+        "Il n'y a pas de fumée sans feu", 
+        "Il faut battre le fer tant qu'il est chaud", 
+        "Il ne faut pas mettre tous ses oeufs dans le même panier", 
+        "Il faut tourner sept fois sa langue dans sa bouche avant de parler", 
+        "L'habit ne fait pas le moine", 
+        "Il ne faut pas réveiller le chat qui dort", 
+        "Il faut se méfier de l'eau qui dort", 
+        "C'est l'hôpital qui se moque de la charité", 
+        "Qui vole un oeuf vole un boeuf", 
+        "Chercher midi à quatorze heures", 
+        "Avoir un poil dans la main", 
+        "Être dans de beaux draps", 
+        "Avoir la tête dans les nuages", 
+        "Mettre les pieds dans le plat"]
     
-
-    #apprentissage
-    texte_app = "Apprentissage non réalisé. Cliquez et attendez > 30s"
-    if len(model.layers) > 0:
-        texte_app = "Apprentissage déjà réalisé"
-    with gr.Row():
-        message_apprentissage = gr.Textbox(label="Résultat de l'apprentissage", value=texte_app)
-        apprendre_btn = gr.Button("Apprendre")
-    apprendre_btn.click(
-        fn=apprendre,
-        inputs=[liste],
-        outputs=[message_apprentissage]
-    )
-
-    #prédiction
-    with gr.Row():
-        bout_texte = gr.Textbox(label="Début de phrase ")
-        with gr.Column():
-            nb_mots_pred = gr.Slider(
-            minimum=1, 
-            maximum=6, 
-            value=3, 
-            step=1, 
-            label="Nombre de mots à prédire",
-            interactive=True 
-            )
-            btn_suite = gr.Button("Poursuivre")
-    btn_suite.click(
-        fn=predict_next_word, 
-        inputs=[bout_texte, nb_mots_pred], 
-        outputs=[bout_texte])
-
+    
+    def afficher_liste(liste):
+        return "\n".join(liste)
+    
+    def ajouter_a_liste(liste_actuelle, nouveau_texte):
+        if nouveau_texte:
+            liste_actuelle.append(nouveau_texte)
+        return liste_actuelle, ""
+    
+    def supprimer_de_liste(liste_actuelle, index_a_supprimer):
+        if index_a_supprimer is not None and 0 <= index_a_supprimer < len(liste_actuelle):
+            ligne_supprimee = liste_actuelle.pop(index_a_supprimer)
+            message = f"Ligne supprimée : '{ligne_supprimee}'"
+        else:
+            message = "Aucune ligne sélectionnée pour suppression"    
+        return liste_actuelle, liste_actuelle, message  # Liste mise à jour, choix mis à jour, message
+    
+    def apprendre(liste_actuelle):
+        global max_sequence_len
+        # Traiter la liste finale
+        resultat = ", ".join(liste_actuelle)
+        print("Liste soumise:", liste_actuelle)  # Pour voir dans la console
+        # analyse du texte
+        tokenizer.fit_on_texts(liste_actuelle)
+        total_words = len(tokenizer.word_index) + 1
+        print("nb de mots différents rencontrés :", total_words)
+        type(tokenizer.word_index)
+        #from dict to list 
+        liste = list(tokenizer.word_index.keys())
+        print("voici les premiers mots trouvés : ")
+        for i in range(10): print(f"({i+1}:'{liste[i]}')", end= ", ")
+        print()
+        # transformation des textes en vecteurs 
+        input_sequences = []
+        for sentence in liste_actuelle:
+            token_list = tokenizer.texts_to_sequences([sentence])[0]
+            for i in range(1, len(token_list)):
+                n_gram_sequence = token_list[:i+1]
+                input_sequences.append(n_gram_sequence)
+        # calibrage des vecteurs pour qu'ils aient tous la même longueur
+        max_sequence_len = max([len(x) for x in input_sequences])
+        input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')
+        print("la phrase '", liste_actuelle[0], "' est traduite en plusieurs vecteurs :")
+        split = liste_actuelle[0].split()
+        for i in range(6):
+            print(input_sequences[i], end=" -> '")
+            for j in range(i+2):
+                print(split[j], end=" ")
+            print("'")
+        # creer les x (premieres valeurs de chaque vecteur)
+        X = input_sequences[:, :-1]
+        # creer les y (derniere valeur de chaque vecteur)
+        y = input_sequences[:, -1]
+        # chaque mot de sortie est représenté par un vecteur de 0, avec 1 correspondant à l'indice du mot
+        #donc le vecteur est aussi grand que le nb de mots trouvés
+        y = tf.keras.utils.to_categorical(y, num_classes=total_words)
+        #creation du model
+        model.add(Embedding(total_words, 50, input_length=max_sequence_len-1))
+        model.add(GRU(120, return_sequences=False))
+        model.add(Dense(total_words, activation='softmax'))
+        # Compile the model
+        model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+        # entrainer le modele
+        print("patienter 30s pendant l'entrainement...")
+        model.fit(X, y, epochs=300, verbose=0)
+        return f"Entrainement effectué, saisissez un début de phrase pour demander la suite"
+    
+    
+    # fonction pour prédire le mot suivant
+    def predict_next_word(start_text, nb_words):
+        print("===> start_text=",start_text)
+        print(f"prédictions de {nb_words} mots.")
+        for _ in range(nb_words):
+            token_list = tokenizer.texts_to_sequences([start_text])[0]
+            token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')
+            print("===> token_list=",token_list)
+            predicted = np.argmax(model.predict(token_list), axis=-1)        
+            print("===> predicted=",predicted)
+            for word, index in tokenizer.word_index.items():
+                if index == predicted:
+                    start_text += " " + word
+                    break
+        print(f"Prediction: {start_text}")
+        print("-" * 50)
+        return start_text
+    
+        
+    with gr.Blocks() as demo:
+        #ENTETE
+        gr.Markdown("# Exemple de prévision de mots")
+        gr.Markdown("Exemple simple, utilisant un réseau de neurone de type **GRU**")
+        gr.Markdown("- Le réseau 'apprend' les phrases de la liste (vous pouvez en ajouter)")
+        gr.Markdown("- Cliquez sur apprendre si l'apprentissage n'a pas eu lieu")
+        gr.Markdown("- Donnez plus bas un début de phrase et laissez le réseau en déduire la suite")
+        
+        #Liste de phrases
+        with gr.Row():
+            sortie = gr.Textbox(label="Phrases actuelles", lines=5)
+            liste = gr.State( textes)
+            # Ajouter et supprimer des lignes
+            with gr.Column():
+                texte = gr.Textbox(label="Nouvelle phrase courte")
+                btn_add = gr.Button("Ajouter")        
+                # Liste déroulante pour sélectionner une ligne à supprimer
+                choix_ligne = gr.Dropdown(
+                    choices=textes,
+                    label="Sélectionner une ligne à supprimer",
+                    type="index"  # Retourne l'index et non la valeur
+                )
+                btn_supprimer = gr.Button("Supprimer de la liste")
+                feedback = gr.Textbox(label="Message", lines=1)    
+        # ajouter une ligne
+        btn_add.click(
+            fn=ajouter_a_liste, 
+            inputs=[liste, texte], 
+            outputs=[liste, texte]
+        ).then(
+            fn=lambda x: "\n".join(x), 
+            inputs=[liste], 
+            outputs=[sortie]
+        )
+        # Supprimer une ligne
+        btn_supprimer.click(
+            fn=supprimer_de_liste,
+            inputs=[liste, choix_ligne],
+            outputs=[liste, choix_ligne, feedback]
+        ).then(
+            fn=afficher_liste,
+            inputs=[liste],
+            outputs=[sortie]
+        )
+        
+    
+        #apprentissage
+        texte_app = "Apprentissage non réalisé. Cliquez et attendez > 30s"
+        if len(model.layers) > 0:
+            texte_app = "Apprentissage déjà réalisé"
+        with gr.Row():
+            message_apprentissage = gr.Textbox(label="Résultat de l'apprentissage", value=texte_app)
+            apprendre_btn = gr.Button("Apprendre")
+        apprendre_btn.click(
+            fn=apprendre,
+            inputs=[liste],
+            outputs=[message_apprentissage]
+        )
+    
+        #prédiction
+        with gr.Row():
+            bout_texte = gr.Textbox(label="Début de phrase ")
+            with gr.Column():
+                nb_mots_pred = gr.Slider(
+                minimum=1, 
+                maximum=6, 
+                value=3, 
+                step=1, 
+                label="Nombre de mots à prédire",
+                interactive=True 
+                )
+                btn_suite = gr.Button("Poursuivre")
+        btn_suite.click(
+            fn=predict_next_word, 
+            inputs=[bout_texte, nb_mots_pred], 
+            outputs=[bout_texte])
+else:
+    gr.Textbox(label="Pas de tensorflow installé ")
     
     # Afficher la liste initiale au lancement
 #    demo.load(