Update app.py

app.py

@@ -4,7 +4,9 @@ from transformers import AutoTokenizer, AutoModelForCausalLM
 from huggingface_hub import login
 import os
 import matplotlib.pyplot as plt
+import seaborn as sns
 import numpy as np
+import time
 
 # Authentification
 login(token=os.environ["HF_TOKEN"])
@@ -30,18 +32,22 @@ models = [
 model = None
 tokenizer = None
 
-def load_model(model_name):
+def load_model(model_name, progress=gr.Progress()):
     global model, tokenizer
     try:
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        model = AutoModelForCausalLM.from_pretrained(
-            model_name, 
-            torch_dtype=torch.bfloat16, 
-            device_map="auto", 
-            attn_implementation="eager"
-        )
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
+        for i in progress.tqdm(range(100)):
+            time.sleep(0.01)  # Simuler le chargement
+            if i == 25:
+                tokenizer = AutoTokenizer.from_pretrained(model_name)
+            elif i == 75:
+                model = AutoModelForCausalLM.from_pretrained(
+                    model_name, 
+                    torch_dtype=torch.bfloat16, 
+                    device_map="auto", 
+                    attn_implementation="eager"
+                )
+                if tokenizer.pad_token is None:
+                    tokenizer.pad_token = tokenizer.eos_token
         return f"Modèle {model_name} chargé avec succès."
     except Exception as e:
         return f"Erreur lors du chargement du modèle : {str(e)}"
@@ -68,12 +74,10 @@ def analyze_next_token(input_text, temperature, top_p, top_k):
         
         prob_text = "\n".join([f"{word}: {prob:.4f}" for word, prob in prob_data.items()])
         
-        # Simplification de l'affichage de l'attention
-        attention_text = "Attention non disponible pour ce modèle"
-        if hasattr(outputs, 'attentions') and outputs.attentions is not None:
-            attention_text = "Attention disponible"
+        # Alternative pour le mécanisme d'attention
+        attention_heatmap = plot_attention_alternative(inputs["input_ids"][0], last_token_logits)
         
-        return prob_text, attention_text, prob_plot
+        return prob_text, attention_heatmap, prob_plot
     except Exception as e:
         return f"Erreur lors de l'analyse : {str(e)}", None, None
 
@@ -89,16 +93,14 @@ def generate_text(input_text, temperature, top_p, top_k):
         with torch.no_grad():
             outputs = model.generate(
                 **inputs,
-                max_new_tokens=1,  # Génère seulement le prochain mot
+                max_new_tokens=1,
                 temperature=temperature,
                 top_p=top_p,
                 top_k=top_k
             )
         
         generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        # Ne retourne que le nouveau mot généré
-        new_word = generated_text[len(input_text):].strip()
-        return new_word
+        return generated_text  # Retourne l'input + le nouveau mot
     except Exception as e:
         return f"Erreur lors de la génération : {str(e)}"
 
@@ -107,7 +109,7 @@ def plot_probabilities(prob_data):
     probs = list(prob_data.values())
     
     fig, ax = plt.subplots(figsize=(10, 5))
-    ax.bar(words, probs)
+    sns.barplot(x=words, y=probs, ax=ax)
     ax.set_title("Probabilités des tokens suivants les plus probables")
     ax.set_xlabel("Tokens")
     ax.set_ylabel("Probabilité")
@@ -115,6 +117,20 @@ def plot_probabilities(prob_data):
     plt.tight_layout()
     return fig
 
+def plot_attention_alternative(input_ids, last_token_logits):
+    input_tokens = tokenizer.convert_ids_to_tokens(input_ids)
+    attention_scores = torch.nn.functional.softmax(last_token_logits, dim=-1)
+    top_k = min(len(input_tokens), 10)  # Limiter à 10 tokens pour la lisibilité
+    top_attention_scores, _ = torch.topk(attention_scores, top_k)
+    
+    fig, ax = plt.subplots(figsize=(12, 6))
+    sns.heatmap(top_attention_scores.unsqueeze(0), annot=True, cmap="YlOrRd", cbar=False, ax=ax)
+    ax.set_xticklabels(input_tokens[-top_k:], rotation=45, ha="right")
+    ax.set_yticklabels(["Attention"], rotation=0)
+    ax.set_title("Scores d'attention pour les derniers tokens")
+    plt.tight_layout()
+    return fig
+
 def reset():
     global model, tokenizer
     model = None
@@ -138,24 +154,25 @@ with gr.Blocks() as demo:
     analyze_button = gr.Button("Analyser le prochain token")
     
     next_token_probs = gr.Textbox(label="Probabilités du prochain token")
-    attention_info = gr.Textbox(label="Information sur l'attention")
     
-    prob_plot = gr.Plot(label="Probabilités des tokens suivants")
+    with gr.Row():
+        attention_plot = gr.Plot(label="Visualisation de l'attention")
+        prob_plot = gr.Plot(label="Probabilités des tokens suivants")
     
     generate_button = gr.Button("Générer le prochain mot")
-    generated_word = gr.Textbox(label="Mot généré")
+    generated_text = gr.Textbox(label="Texte généré")
     
     reset_button = gr.Button("Réinitialiser")
     
     load_button.click(load_model, inputs=[model_dropdown], outputs=[load_output])
     analyze_button.click(analyze_next_token, 
                          inputs=[input_text, temperature, top_p, top_k], 
-                         outputs=[next_token_probs, attention_info, prob_plot])
+                         outputs=[next_token_probs, attention_plot, prob_plot])
     generate_button.click(generate_text, 
                           inputs=[input_text, temperature, top_p, top_k], 
-                          outputs=[generated_word])
+                          outputs=[generated_text])
     reset_button.click(reset, 
-                       outputs=[input_text, temperature, top_p, top_k, next_token_probs, attention_info, prob_plot, generated_word])
+                       outputs=[input_text, temperature, top_p, top_k, next_token_probs, attention_plot, prob_plot, generated_text])
 
 if __name__ == "__main__":
     demo.launch()