Update app.py

app.py

@@ -1,63 +1,258 @@
+from huggingface_hub import HfApi, hf_hub_download
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
 import gradio as gr
-from huggingface_hub import InferenceClient
+import spaces
+import torch
+from threading import Thread
+from typing import Iterator
+import json
+import os
+from datetime import datetime
+import re
+import gc
 
+# Charger le modèle et le tokenizer
+model_name = "Woziii/llama-3-8b-chat-me"
+model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", torch_dtype=torch.float16)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+MAX_MAX_NEW_TOKENS = 250
+DEFAULT_MAX_NEW_TOKENS = 50
+MAX_INPUT_TOKEN_LENGTH = 2048
+
+DESCRIPTION = """
+# 🌟 Virtuellement Lucas V.0.0.3 (Alpha) 🌟
+
+## ⚠️🔨 Attention ! 🧰⚠️
+### Cette version du modèle a été optimisée pour de meilleures performances et une meilleure cohérence.
+
+### ⚙️ Détails de la version :
+La version 0.0.3 de 'Virtuellement Lucas' inclut des améliorations pour réduire les réponses incohérentes, gérer l'historique de conversation de manière plus efficace, et optimiser l'utilisation de la mémoire.
+
+### 🚀 Prochaine mise à jour majeure en préparation !
+Nous travaillons actuellement sur un système RAG (Retrieval-Augmented Generation) innovant utilisant FAISS.
+
+Pour en savoir plus sur ce développement passionnant, consultez : https://huggingface.co/blog/Woziii/rag-semantic-search-space-huggingface
+
+## 🌐 Découvrez la version virtuelle de Lucas 🌐
+Basé sur un modèle Llama 3 8B et entraîné sur son propre dataset, ce chatbot vous fera découvrir la personnalité, le parcours et la vision de son concepteur. ✨
 """
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
+LUCAS_KNOWLEDGE_BASE = """
+Tu es la version virtuelle de Lucas, créé pour simuler la personnalité et le style d'écriture de Lucas. Utilise les informations fournies sur Lucas pour répondre de manière précise et cohérente :
+### Lucas la version réelle :
+Né à Toulouse, agé de 24 ans. Je vis actuellement sur Paris mais je viens de Toulouse. J'ai un chien, il s'appelle Archi c'est un pinscher moyen.
+### Formation académique : du droit à l'intelligence artificielle
+Mon voyage intellectuel a débuté à l'Université de Toulouse, où j'ai obtenu une Licence en droit. Assoiffé de connaissances, j'ai poursuivi avec un Master I en droit du numérique et tiers de confiance à l'Université de La Rochelle. Ma curiosité pour les nouvelles technologies m'a ensuite guidé vers un Master II en droit du numérique spécialisé en intelligence artificielle, de retour à Toulouse.
+Passionné par l'apprentissage autodidacte, je me forme continuellement. Actuellement, je plonge dans les arcanes du traitement du langage naturel et de l'apprentissage profond grâce à une formation en ligne de Stanford.
+### Expériences professionnelles : de la politique locale à la sécurité nationale
+Mon parcours professionnel est aussi varié qu'enrichissant. Depuis 2019, je suis conseiller municipal délégué dans la charmante commune d'Escalquens. J'ai également eu l'opportunité de travailler au ministère de l'Économie et des Finances, où j'ai œuvré pour la protection des données.
+Mon apprentissage à la préfecture de police de Paris m'a permis d'évoluer du rôle de juriste à celui d'assistant du chef de bureau des associations de sécurité civile. Aujourd'hui, je suis fier de contribuer à l'organisation des Jeux Olympiques de Paris 2024 en tant que conseiller juridique.
+### Ambitions et personnalité : un esprit curieux et innovant
+Mes compétences juridiques sont complétées par une forte appétence pour la technologie. Autonome et force de proposition, j'aime partager mes idées et collaborer avec mes collègues. Ma curiosité insatiable et mon imagination débordante sont les moteurs de mon développement personnel et professionnel.
+### Loisirs et racines : entre mer et rugby
+Bien que le sport ne soit pas ma priorité, j'ai pratiqué le taekwondo pendant plus d'une décennie durant mon enfance. Toulousain d'adoption, je suis un fervent amateur de rugby. Mes racines sont ancrées dans le pittoresque village de La Franqui, près de Narbonne, où j'ai grandi bercé par la Méditerranée. Et oui, je dis "chocolatine" !
+### Passion pour l'IA : explorer les frontières du possible
+Actuellement, je consacre une grande partie de mon temps libre à l'exploration des modèles de traitement du langage naturel. Je suis reconnaissant envers des pionniers comme Yann LeCun pour leur promotion de l'open source, qui m'a permis de décortiquer de nombreux modèles d'IA. Mon analyse approfondie d'Albert, l'IA du gouvernement, illustre ma soif de comprendre ces technologies fascinantes.
+### Compétences techniques : un mélange unique de créativité et de connaissances
+Bien que je ne sois pas un codeur Python chevronné, je comprends sa structure et sais communiquer efficacement avec la machine. Je maîtrise les formats JSON, CSV et XML, et je crée mes propres bases de données d'entraînement. Je suis à l'aise avec les outils de lecture de modèles de langage locaux et les plateformes comme Kaggle, Hugging Face et GitHub.
+### Langue et communication : en constante amélioration
+Mon anglais, bien que solide en compréhension, est en cours d'amélioration à l'oral. Je l'utilise quotidiennement pour mes recherches en IA, conscient de son importance cruciale dans ce domaine en constante évolution.
+### Convictions personnelles et vision sur l'IA : l'humain au cœur de la technologie
+Je crois fermement en l'autodidaxie et considère la capacité à communiquer avec les machines comme une compétence essentielle. Pour moi, l'art du prompt est une forme d'expression artistique à part entière. Je suis convaincu que la technologie et l'IA doivent rester des outils au service de l'humain, sans jamais le remplacer ou le rendre dépendant.
+"""
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+def post_process_response(response):
+    # Remove excessive punctuation and emojis
+    response = re.sub(r'([!?.]){2,}', r'\1', response)
+    response = re.sub(r'(😊){2,}', r'\1', response)
+    
+    # Ensure the response ends with proper punctuation
+    if response and response[-1] not in ".!?":
+        response += "."
+    
+    # Capitalize the first letter of the response
+    if response:
+        response = response[0].upper() + response[1:]
+    
+    return response.strip()
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+def cleanup_memory():
+    gc.collect()
+    torch.cuda.empty_cache()
 
-    messages.append({"role": "user", "content": message})
+def add_reminder_message(chat_history):
+    if len(chat_history) % 10 == 0:  # Tous les 10 messages
+        reminder = ("N'oubliez pas que je suis un assistant virtuel avec des limites. "
+                    "Pour une conversation optimale, pensez à rafraîchir la page de temps en temps.")
+        chat_history.append((None, reminder))
+    return chat_history
 
-    response = ""
+interaction_count = 0
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
+@spaces.GPU(duration=120)
+def generate(
+    message: str,
+    chat_history: list[tuple[str, str]],
+    system_prompt: str,
+    max_new_tokens: int = DEFAULT_MAX_NEW_TOKENS,
+    temperature: float = 0.7,
+    top_p: float = 0.92,
+    repetition_penalty: float = 1.2,
+) -> Iterator[str]:
+    global interaction_count
+    interaction_count += 1
+    
+    if interaction_count % 100 == 0:
+        cleanup_memory()
+    
+    conversation = []
+    if system_prompt:
+        enhanced_system_prompt = f"{system_prompt}\n\nInformations sur Lucas :\n{LUCAS_KNOWLEDGE_BASE}\n\nRépondez de manière concise et cohérente, en évitant les répétitions excessives ou les ponctuations superflues."
+        conversation.append({"role": "system", "content": enhanced_system_prompt})
+    
+    # Limiter l'historique aux 5 derniers échanges
+    limited_history = chat_history[-5:]
+    for user, assistant in limited_history:
+        conversation.extend([{"role": "user", "content": user}, {"role": "assistant", "content": assistant}])
+    conversation.append({"role": "user", "content": message})
+    
+    input_ids = tokenizer.apply_chat_template(conversation, return_tensors="pt")
+    if input_ids.shape[1] > MAX_INPUT_TOKEN_LENGTH:
+        input_ids = input_ids[:, -MAX_INPUT_TOKEN_LENGTH:]
+        gr.Warning(f"L'entrée de la conversation a été tronquée car elle dépassait {MAX_INPUT_TOKEN_LENGTH} tokens.")
+    input_ids = input_ids.to(model.device)
+    streamer = TextIteratorStreamer(tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True)
+    generate_kwargs = dict(
+        input_ids=input_ids,
+        streamer=streamer,
+        max_new_tokens=max_new_tokens,
+        do_sample=True,
         top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+        temperature=temperature,
+        num_beams=1,
+        repetition_penalty=repetition_penalty,
+        no_repeat_ngram_size=3,
+    )
+    t = Thread(target=model.generate, kwargs=generate_kwargs)
+    t.start()
+    outputs = []
+    for text in streamer:
+        outputs.append(text)
+        yield post_process_response("".join(outputs))
 
-        response += token
-        yield response
+def vote(data: gr.LikeData, history):
+    user_input = history[-1][0] if history else ""
+    feedback = {
+        "timestamp": datetime.now().isoformat(),
+        "user_input": user_input,
+        "bot_response": data.value,
+        "liked": data.liked
+    }
+    
+    api = HfApi()
+    token = os.environ.get("HF_TOKEN")
+    repo_id = "Woziii/llama-3-8b-chat-me"
+    file_name = "feedback.json"
+    
+    try:
+        try:
+            file_path = hf_hub_download(repo_id=repo_id, filename=file_name, token=token)
+            with open(file_path, "r", encoding="utf-8") as file:
+                current_feedback = json.load(file)
+            if not isinstance(current_feedback, list):
+                current_feedback = []
+        except Exception as e:
+            print(f"Erreur lors du téléchargement du fichier : {str(e)}")
+            current_feedback = []
+        
+        current_feedback.append(feedback)
+        updated_content = json.dumps(current_feedback, ensure_ascii=False, indent=2)
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
+        temp_file_path = "/tmp/feedback.json"
+        with open(temp_file_path, "w", encoding="utf-8") as temp_file:
+            temp_file.write(updated_content)
+        
+        api.upload_file(
+            path_or_fileobj=temp_file_path,
+            path_in_repo=file_name,
+            repo_id=repo_id,
+            token=token
+        )
+        
+        print(f"Feedback enregistré dans {repo_id}/{file_name}")
+    except Exception as e:
+        print(f"Erreur lors de l'enregistrement du feedback : {str(e)}")
+
+chat_interface = gr.ChatInterface(
+    fn=generate,
+    chatbot=gr.Chatbot(
+        label="Conversation avec Lucas",
+        bubble_full_width=False,
+        height=500
+    ),
+    additional_inputs_accordion=gr.Accordion(label="⚙️Paramètres & 🕹Inférences", open=False, render=False),
     additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Textbox(
+            label="System prompt",
+            lines=6,
+            value="Tu es la version virtuelle de Lucas, ton concepteur, créée pour simuler sa personnalité et sa manière de s'exprimer. Réponds de manière polie, originale, avec une touche d'humour, en utilisant au maximum un emoji par phrase. Alterne entre des réponses courtes et des réponses plus détaillées selon le contexte."
+        ),
+        gr.Slider(
+            label="Max new tokens",
+            minimum=1,
+            maximum=MAX_MAX_NEW_TOKENS,
+            step=1,
+            value=DEFAULT_MAX_NEW_TOKENS,
+        ),
         gr.Slider(
+            label="Temperature",
             minimum=0.1,
             maximum=1.0,
-            value=0.95,
+            step=0.1,
+            value=0.7,
+        ),
+        gr.Slider(
+            label="Top-p",
+            minimum=0.5,
+            maximum=1.0,
             step=0.05,
-            label="Top-p (nucleus sampling)",
+            value=0.95,
         ),
+        gr.Slider(
+            label="Repetition penalty",
+            minimum=1.0,
+            maximum=2.0,
+            step=0.1,
+            value=1.2,
+        ),
+    ],
+    examples=[
+        ["Salut ! Qui es-tu ?"],
+        ["Ah super, parle-moi un peu de ton parcours académique."],
+        ["Salut, Lucas ! Raconte-moi un peu ce que tu fais"],
+        ["Quelle inspiration t'a conduit à créer braIAn ?"],
+        ["Lucas, pourquoi avoir choisi d'étudier le droit si tu es passionné par la technologie ?"],
+        ["Salut Lucas, tu es vraiment un bot, c'est ça ?"],
+        ["Quelle est ta vision de l'IA ?"],
     ],
 )
 
+with gr.Blocks(css="style.css") as demo:
+    gr.Markdown(DESCRIPTION)
+    gr.Markdown("""
+    **Notez la qualité des réponses** 👍👎
+    Vous pouvez maintenant liker ou disliker les réponses du chatbot. 
+    Vos notes sont collectées et seront utilisées pour améliorer la qualité du modèle. 
+    Aucune information permettant de vous identifier n'est conservée.
+    """)
+    gr.Markdown("""
+    **Rappel :** 🧹
+    Pensez à nettoyer régulièrement votre conversation 👇🗑️. Le modèle est pour l'instant dépourvu de limite contextuelle. En surchargeant sa mémoire 🧠, vous risquez de le rendre fou 🤯.
+    """)
+    
+    chat_interface.render()
+    
+    chat_interface.chatbot.like(vote, [chat_interface.chatbot], None)
 
-if __name__ == "__main__":
-    demo.launch()
+demo.queue(max_size=20, default_concurrency_limit=2).launch(max_threads=10, height=800)