Initial commit - Mini chatbot RAG

.gitignore

@@ -0,0 +1,5 @@
+venv/
+__pycache__/
+*.pyc
+.env
+.cache/

README.md

@@ -0,0 +1,63 @@
+# Mini Chatbot RAG — IA Générative
+
+## Présentation du projet
+
+Ce projet consiste en la création d’un mini système **RAG (Retrieval-Augmented Generation)** capable de répondre à des questions sur l’intelligence artificielle générative à partir d’un corpus documentaire personnalisé.
+
+L’objectif pédagogique est de :
+
+- comprendre le fonctionnement d’un système RAG ;
+- comparer différents modèles génératifs ;
+- analyser les limites des modèles de langage ;
+- réduire les hallucinations grâce à un corpus documentaire.
+
+Le projet utilise :
+
+- un corpus thématique de 15 fichiers ;
+- TF-IDF pour la recherche documentaire ;
+- plusieurs modèles génératifs (FLAN-T5 et GPT-2) ;
+- une interface interactive Gradio.
+
+---
+
+## Fonctionnement général du système
+
+Le système fonctionne en plusieurs étapes :
+
+1. L’utilisateur pose une question.
+2. Le moteur RAG recherche les passages les plus pertinents dans le corpus.
+3. Les documents récupérés sont classés selon leur pertinence.
+4. Une réponse est générée ou extraite à partir du contexte trouvé.
+5. Les sources utilisées sont affichées.
+
+---
+
+## Structure du projet
+
+```bash
+
+Mini_chatbot_RAG/
+│
+├── corpus/
+│   ├── diffusion_models.txt
+│   ├── ethique_ia.txt
+│   ├── gan.txt
+│   ├── ia_act.txt
+│   ├── ia_art.txt
+│   ├── ia_cybersecurite.txt
+│   ├── ia_education.txt
+│   ├── ia_finance.txt
+│   ├── ia_medecine.txt
+│   ├── ia_rh.txt
+│   ├── llm.txt
+│   ├── rag.txt
+│   ├── rgpd_ia.txt
+│   ├── transformers.txt
+│   └── vae.txt
+│
+├── app.py
+├── rag.py
+├── app_gpt2.py
+├── rag_gpt2.py
+├── README.md
+└── venv/

app.py

@@ -0,0 +1,309 @@
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
+from rag import RAGEngine
+
+
+# ───────── INITIALISATION RAG ─────────
+rag = RAGEngine("corpus/")
+
+
+# ───────── MODÈLE FLAN-T5 ─────────
+model_name = "google/flan-t5-base"
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
+
+
+def generate_answer(prompt, temperature=0.0, max_new_tokens=160):
+    inputs = tokenizer(
+        prompt,
+        return_tensors="pt",
+        truncation=True,
+        max_length=768
+    )
+
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=max_new_tokens,
+        do_sample=False,
+        repetition_penalty=1.5,
+        no_repeat_ngram_size=3,
+        early_stopping=True
+    )
+
+    return tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+
+# ───────── RÉPONSE CONTRÔLÉE POUR LE CHATBOT RAG ─────────
+def controlled_answer(question, sources_found):
+    best = sources_found[0]
+
+    text = rag._clean_for_prompt(best.text)
+
+    sentences = [
+        s.strip()
+        for s in text.split(".")
+        if len(s.strip()) > 40
+    ]
+
+    question_lower = question.lower()
+
+    if "risque" in question_lower:
+        keywords = [
+            "risque", "biais", "erreur",
+            "confidentialité", "sécurité",
+            "RGPD", "discrimination"
+        ]
+
+    elif "application" in question_lower or "utilisation" in question_lower:
+        keywords = [
+            "utilisé", "applications",
+            "diagnostic", "analyse",
+            "détection"
+        ]
+
+    elif "avantage" in question_lower or "importance" in question_lower:
+        keywords = [
+            "améliorer", "optimiser",
+            "aider", "utile"
+        ]
+
+    else:
+        keywords = []
+
+    selected = [
+        s for s in sentences
+        if any(k.lower() in s.lower() for k in keywords)
+    ]
+
+    if not selected:
+        selected = sentences[:4]
+
+    final_answer = ". ".join(selected[:4]).strip()
+
+    if not final_answer.endswith("."):
+        final_answer += "."
+
+    return (
+        final_answer
+        + f"\n\nSource utilisée : {best.filename}"
+    )
+# ───────── SENTIMENT ─────────
+sentiment = pipeline(
+    "sentiment-analysis",
+    model="nlptown/bert-base-multilingual-uncased-sentiment"
+)
+
+
+# ───────── CHATBOT RAG ─────────
+def chatbot_response(message, history, temperature, top_k):
+    if history is None:
+        history = []
+
+    if not message or not message.strip():
+        return history, "", "Veuillez poser une question."
+
+    # Pour stabiliser la démo, on force le meilleur passage uniquement
+    sources_found = rag.search(message, top_k=1)
+
+    if not sources_found:
+        answer = (
+            "Je ne dispose pas d’assez d’informations dans le corpus "
+            "pour répondre correctement à cette question."
+        )
+
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": answer})
+
+        return history, "", "Aucune source suffisamment pertinente trouvée."
+
+    answer = controlled_answer(message, sources_found)
+
+    source_text = ""
+    for src in sources_found:
+        source_text += f"### {src.filename} — score : {src.score:.3f}\n"
+        source_text += f"{src.text[:400]}...\n\n"
+
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": answer})
+
+    return history, "", source_text
+
+
+# ───────── EXPLORATION CORPUS ─────────
+def search_corpus(query, top_k):
+    if not query or not query.strip():
+        return "Entrez une requête de recherche."
+
+    results = rag.search(query, top_k=top_k)
+
+    if not results:
+        return "Aucun passage pertinent trouvé dans le corpus."
+
+    output = ""
+
+    for result in results:
+        output += f"## {result.filename} — score : {result.score:.3f}\n"
+        output += f"{result.text[:900]}...\n\n"
+
+    return output
+
+
+# ───────── ANALYSE DE SENTIMENT ─────────
+def analyse_sentiment(text):
+    if not text or not text.strip():
+        return "Entrez un texte à analyser."
+
+    result = sentiment(text)[0]
+
+    return f"""
+Résultat : **{result['label']}**
+
+Score de confiance : **{result['score']:.2f}**
+"""
+
+
+# ───────── GÉNÉRATION SANS RAG ─────────
+def free_generation(prompt, temperature):
+    if not prompt or not prompt.strip():
+        return "Entrez un prompt."
+
+    return generate_answer(
+        prompt,
+        temperature=temperature,
+        max_new_tokens=220
+    )
+
+
+# ───────── INTERFACE GRADIO ─────────
+with gr.Blocks(title="Assistant RAG IA Générative") as app:
+
+    gr.Markdown("# Assistant RAG — IA Générative")
+    gr.Markdown(
+        """
+        Cette application répond aux questions sur l’intelligence artificielle générative,
+        ses modèles, ses usages métier et ses enjeux éthiques à partir d’un corpus documentaire.
+        """
+    )
+
+    with gr.Tab("Chatbot RAG"):
+        chatbot = gr.Chatbot(label="Conversation")
+
+        question = gr.Textbox(
+            label="Votre question",
+            placeholder="Exemple : Quels sont les risques de l'IA dans la médecine ?",
+            lines=2
+        )
+
+        with gr.Row():
+            temperature = gr.Slider(
+                minimum=0.0,
+                maximum=1.0,
+                value=0.0,
+                step=0.1,
+                label="Température"
+            )
+
+            top_k = gr.Slider(
+                minimum=1,
+                maximum=5,
+                value=1,
+                step=1,
+                label="Nombre de passages utilisés"
+            )
+
+        send_btn = gr.Button("Envoyer", variant="primary")
+        reset_btn = gr.Button("Réinitialiser la conversation")
+
+        sources = gr.Markdown(label="Sources utilisées")
+
+        send_btn.click(
+            chatbot_response,
+            inputs=[question, chatbot, temperature, top_k],
+            outputs=[chatbot, question, sources]
+        )
+
+        reset_btn.click(
+            lambda: ([], "", ""),
+            outputs=[chatbot, question, sources]
+        )
+
+    with gr.Tab("Explorer le corpus"):
+        gr.Markdown(
+            f"""
+            **Nombre de fichiers chargés :** {len(set(rag.chunk_sources))}  
+            **Nombre de passages indexés :** {len(rag.chunks)}
+            """
+        )
+
+        search_query = gr.Textbox(
+            label="Recherche dans la base de connaissances",
+            placeholder="Exemple : IA et finance"
+        )
+
+        search_top_k = gr.Slider(
+            minimum=1,
+            maximum=5,
+            value=3,
+            step=1,
+            label="Nombre de résultats"
+        )
+
+        search_btn = gr.Button("Rechercher")
+        search_output = gr.Markdown()
+
+        search_btn.click(
+            search_corpus,
+            inputs=[search_query, search_top_k],
+            outputs=search_output
+        )
+
+    with gr.Tab("Analyse de sentiment"):
+        sent_text = gr.Textbox(
+            label="Texte à analyser",
+            placeholder="Exemple : Ce projet est très intéressant et utile.",
+            lines=4
+        )
+
+        sent_btn = gr.Button("Analyser")
+        sent_output = gr.Markdown()
+
+        sent_btn.click(
+            analyse_sentiment,
+            inputs=sent_text,
+            outputs=sent_output
+        )
+
+    with gr.Tab("Génération sans RAG"):
+        gr.Markdown(
+            """
+            Cet onglet permet de comparer une réponse générée sans contexte documentaire
+            avec une réponse enrichie par le RAG.
+            """
+        )
+
+        free_prompt = gr.Textbox(
+            label="Prompt libre",
+            placeholder="Exemple : Explique les modèles de diffusion.",
+            lines=4
+        )
+
+        free_temp = gr.Slider(
+            minimum=0.0,
+            maximum=1.0,
+            value=0.0,
+            step=0.1,
+            label="Température"
+        )
+
+        free_btn = gr.Button("Générer")
+        free_output = gr.Textbox(label="Réponse sans RAG", lines=8)
+
+        free_btn.click(
+            free_generation,
+            inputs=[free_prompt, free_temp],
+            outputs=free_output
+        )
+
+
+app.launch()

app_gpt2.py

@@ -0,0 +1,396 @@
+import re
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+
+from rag_gpt2 import RAGEngineGPT2
+
+
+# ───────── INITIALISATION RAG ─────────
+rag = RAGEngineGPT2("corpus/")
+
+
+# ───────── MODÈLE GPT-2 ─────────
+# Critique : GPT-2 standard est surtout anglophone et moins bon en instruction.
+# On l'utilise ici pour comparer avec FLAN-T5, pas comme meilleur modèle.
+model_name = "dbddv01/gpt2-french-small"
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name)
+
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+
+def generate_gpt2(prompt, max_new_tokens=120, temperature=0.7):
+    inputs = tokenizer(
+        prompt,
+        return_tensors="pt",
+        truncation=True,
+        max_length=768
+    )
+
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=max_new_tokens,
+        do_sample=True,
+        temperature=temperature,
+        top_p=0.9,
+        repetition_penalty=1.25,
+        no_repeat_ngram_size=3,
+        pad_token_id=tokenizer.eos_token_id
+    )
+
+    decoded = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    # On enlève le prompt recopié par GPT-2
+    if decoded.startswith(prompt):
+        decoded = decoded[len(prompt):]
+
+    return decoded.strip()
+
+
+def is_bad_generation(text: str) -> bool:
+    if not text or len(text.strip()) < 20:
+        return True
+
+    bad_patterns = [
+        "Question:",
+        "Questions:",
+        "Réponse en français",
+        "Contexte:",
+        "http",
+    ]
+
+    if any(p.lower() in text.lower() for p in bad_patterns):
+        return True
+
+    words = text.split()
+    if len(words) > 10:
+        unique_ratio = len(set(words)) / len(words)
+        if unique_ratio < 0.45:
+            return True
+
+    return False
+
+
+# ───────── RÉPONSE EXTRACTIVE CONTRÔLÉE ─────────
+def extractive_answer(question, sources_found):
+    best = sources_found[0]
+    text = rag._clean_for_prompt(best.text)
+
+    sentences = [
+        s.strip()
+        for s in text.split(".")
+        if len(s.strip()) > 35
+    ]
+
+    question_lower = question.lower()
+
+    if "risque" in question_lower:
+        keywords = [
+            "risque", "biais", "erreur", "erreurs",
+            "confidentialité", "données", "sécurité",
+            "RGPD", "discrimination", "supervision"
+        ]
+
+    elif "application" in question_lower or "utilisation" in question_lower:
+        keywords = [
+            "utilisé", "utilisée", "applications",
+            "diagnostic", "analyse", "détection",
+            "générer", "prédire"
+        ]
+
+    elif "avantage" in question_lower or "importance" in question_lower:
+        keywords = [
+            "améliorer", "optimiser", "aider",
+            "utile", "rapidité", "permet"
+        ]
+
+    elif "définition" in question_lower or "c'est quoi" in question_lower or "qu'est-ce" in question_lower:
+        keywords = [
+            "désigne", "définition", "est", "sont"
+        ]
+
+    else:
+        keywords = []
+
+    if keywords:
+        selected = [
+            s for s in sentences
+            if any(k.lower() in s.lower() for k in keywords)
+        ]
+    else:
+        selected = sentences[:4]
+
+    if not selected:
+        selected = sentences[:4]
+
+    answer = ". ".join(selected[:4]).strip()
+
+    if not answer.endswith("."):
+        answer += "."
+
+    return answer
+
+
+# ───────── RÉPONSE RAG + GPT-2 AVEC SÉCURITÉ ─────────
+def gpt2_rag_answer(question, sources_found, temperature):
+    base_answer = extractive_answer(question, sources_found)
+    best = sources_found[0]
+
+    rewrite_prompt = f"""
+Réécris ce texte en français clair et naturel sans ajouter d'information.
+
+Texte :
+{base_answer}
+
+Réponse :
+"""
+
+    generated = generate_gpt2(
+        rewrite_prompt,
+        max_new_tokens=100,
+        temperature=temperature
+    )
+
+    # GPT-2 est instable : si la génération est mauvaise, on garde la réponse extractive.
+    if is_bad_generation(generated):
+        final_answer = base_answer
+    else:
+        final_answer = generated
+
+    return final_answer + f"\n\nSource utilisée : {best.filename}"
+
+
+# ───────── SENTIMENT ─────────
+sentiment = pipeline(
+    "sentiment-analysis",
+    model="nlptown/bert-base-multilingual-uncased-sentiment"
+)
+
+
+# ───────── CHATBOT RAG GPT-2 ─────────
+def chatbot_response(message, history, temperature, top_k, use_gpt2_rewrite):
+    if history is None:
+        history = []
+
+    if not message or not message.strip():
+        return history, "", "Veuillez poser une question."
+
+    # Pour stabiliser la réponse RAG, on utilise le meilleur passage.
+    sources_found = rag.search(message, top_k=1)
+
+    if not sources_found:
+        answer = (
+            "Je ne dispose pas d’assez d’informations dans le corpus "
+            "pour répondre correctement à cette question."
+        )
+
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": answer})
+
+        return history, "", "Aucune source suffisamment pertinente trouvée."
+
+    if use_gpt2_rewrite:
+        answer = gpt2_rag_answer(message, sources_found, temperature)
+    else:
+        answer = extractive_answer(message, sources_found)
+        answer += f"\n\nSource utilisée : {sources_found[0].filename}"
+
+    source_text = ""
+    for src in sources_found:
+        source_text += f"### {src.filename} — score : {src.score:.3f}\n"
+        source_text += f"{src.text[:450]}...\n\n"
+
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": answer})
+
+    return history, "", source_text
+
+
+# ───────── EXPLORATION CORPUS ─────────
+def search_corpus(query, top_k):
+    if not query or not query.strip():
+        return "Entrez une requête de recherche."
+
+    results = rag.search(query, top_k=top_k)
+
+    if not results:
+        return "Aucun passage pertinent trouvé dans le corpus."
+
+    output = ""
+
+    for result in results:
+        output += f"## {result.filename} — score : {result.score:.3f}\n"
+        output += f"{result.text[:900]}...\n\n"
+
+    return output
+
+
+# ───────── SENTIMENT ─────────
+def analyse_sentiment(text):
+    if not text or not text.strip():
+        return "Entrez un texte à analyser."
+
+    result = sentiment(text)[0]
+
+    return f"""
+Résultat : **{result['label']}**
+
+Score de confiance : **{result['score']:.2f}**
+"""
+
+
+# ───────── GÉNÉRATION LIBRE GPT-2 ─────────
+def free_generation(prompt, temperature):
+    if not prompt or not prompt.strip():
+        return "Entrez un prompt."
+
+    generated = generate_gpt2(
+        prompt,
+        max_new_tokens=180,
+        temperature=temperature
+    )
+
+    return generated if generated else "GPT-2 n'a pas généré de réponse exploitable."
+
+
+# ───────── INTERFACE GRADIO ─────────
+with gr.Blocks(title="Assistant RAG GPT-2 — IA Générative") as app:
+
+    gr.Markdown("# Assistant RAG GPT-2 — IA Générative")
+    gr.Markdown(
+        """
+        Cette version teste GPT-2 avec le même corpus documentaire.
+        
+        **Critique importante :** GPT-2 est moins fiable que FLAN-T5 pour suivre des consignes.
+        Le mode RAG utilise donc une réponse extractive contrôlée, avec une option de reformulation par GPT-2.
+        """
+    )
+
+    with gr.Tab("Chatbot RAG GPT-2"):
+        chatbot = gr.Chatbot(label="Conversation")
+
+        question = gr.Textbox(
+            label="Votre question",
+            placeholder="Exemple : Quels sont les risques de l'IA dans la médecine ?",
+            lines=2
+        )
+
+        with gr.Row():
+            temperature = gr.Slider(
+                minimum=0.1,
+                maximum=1.0,
+                value=0.5,
+                step=0.1,
+                label="Température GPT-2"
+            )
+
+            top_k = gr.Slider(
+                minimum=1,
+                maximum=5,
+                value=1,
+                step=1,
+                label="Nombre de passages utilisés"
+            )
+
+        use_gpt2_rewrite = gr.Checkbox(
+            label="Utiliser GPT-2 pour reformuler la réponse",
+            value=False
+        )
+
+        send_btn = gr.Button("Envoyer", variant="primary")
+        reset_btn = gr.Button("Réinitialiser la conversation")
+
+        sources = gr.Markdown(label="Sources utilisées")
+
+        send_btn.click(
+            chatbot_response,
+            inputs=[question, chatbot, temperature, top_k, use_gpt2_rewrite],
+            outputs=[chatbot, question, sources]
+        )
+
+        reset_btn.click(
+            lambda: ([], "", ""),
+            outputs=[chatbot, question, sources]
+        )
+
+    with gr.Tab("Explorer le corpus"):
+        gr.Markdown(
+            f"""
+            **Nombre de fichiers chargés :** {len(set(rag.chunk_sources))}  
+            **Nombre de passages indexés :** {len(rag.chunks)}
+            """
+        )
+
+        search_query = gr.Textbox(
+            label="Recherche dans la base de connaissances",
+            placeholder="Exemple : IA et finance"
+        )
+
+        search_top_k = gr.Slider(
+            minimum=1,
+            maximum=5,
+            value=3,
+            step=1,
+            label="Nombre de résultats"
+        )
+
+        search_btn = gr.Button("Rechercher")
+        search_output = gr.Markdown()
+
+        search_btn.click(
+            search_corpus,
+            inputs=[search_query, search_top_k],
+            outputs=search_output
+        )
+
+    with gr.Tab("Analyse de sentiment"):
+        sent_text = gr.Textbox(
+            label="Texte à analyser",
+            placeholder="Exemple : Ce projet est très intéressant et utile.",
+            lines=4
+        )
+
+        sent_btn = gr.Button("Analyser")
+        sent_output = gr.Markdown()
+
+        sent_btn.click(
+            analyse_sentiment,
+            inputs=sent_text,
+            outputs=sent_output
+        )
+
+    with gr.Tab("Génération libre GPT-2"):
+        gr.Markdown(
+            """
+            Cet onglet montre GPT-2 sans RAG.  
+            Il permet de comparer une génération libre avec une réponse appuyée sur le corpus.
+            """
+        )
+
+        free_prompt = gr.Textbox(
+            label="Prompt libre",
+            placeholder="Exemple : Artificial intelligence in medicine is",
+            lines=4
+        )
+
+        free_temp = gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.7,
+            step=0.1,
+            label="Température"
+        )
+
+        free_btn = gr.Button("Générer")
+        free_output = gr.Textbox(label="Réponse GPT-2", lines=8)
+
+        free_btn.click(
+            free_generation,
+            inputs=[free_prompt, free_temp],
+            outputs=free_output
+        )
+
+
+app.launch()

corpus/diffusion_models.txt

@@ -0,0 +1,39 @@
+[TITRE]
+Modèles de diffusion
+
+[DEFINITION]
+Les modèles de diffusion sont des modèles génératifs capables de créer des images, du son ou d’autres données à partir de bruit aléatoire. Ils sont notamment utilisés dans des outils comme Stable Diffusion, DALL-E ou Midjourney.
+
+[FONCTIONNEMENT]
+Le principe consiste à ajouter progressivement du bruit à une image pendant l’entraînement, puis à apprendre le processus inverse : retirer le bruit étape par étape pour reconstruire une image cohérente.
+
+[APPLICATIONS]
+Les modèles de diffusion sont utilisés pour :
+- générer des images à partir de texte ;
+- créer des illustrations artistiques ;
+- améliorer la qualité d’images ;
+- générer des images médicales synthétiques ;
+- produire des contenus pour le design, la publicité ou les jeux vidéo.
+
+[EXEMPLES]
+Stable Diffusion permet de produire une image à partir d’un prompt textuel. DALL-E peut générer des scènes réalistes ou imaginaires en fonction d’une description écrite.
+
+[AVANTAGES]
+Les modèles de diffusion produisent souvent des images très détaillées et réalistes. Ils sont plus stables à entraîner que certains GAN et permettent un contrôle créatif important grâce aux prompts.
+
+[RISQUES]
+Les risques principaux sont :
+- création de deepfakes ;
+- génération de fausses images ;
+- désinformation visuelle ;
+- atteinte au droit d’auteur ;
+- utilisation non autorisée du style d’artistes.
+
+[LIMITES]
+Ces modèles demandent beaucoup de puissance de calcul. Ils peuvent aussi générer des erreurs visuelles, comme des mains mal formées, des textes illisibles ou des incohérences dans les détails.
+
+[ETHIQUE]
+L’usage des modèles de diffusion doit être encadré pour éviter les contenus trompeurs, protéger les artistes et signaler clairement les images générées par IA.
+
+[CONCLUSION]
+Les modèles de diffusion représentent une avancée majeure de l’IA générative, surtout dans la création d’images, mais ils nécessitent une utilisation responsable.

corpus/ethique_ia.txt

@@ -0,0 +1,49 @@
+[TITRE]
+Éthique de l’intelligence artificielle
+
+[DEFINITION]
+L’éthique de l’intelligence artificielle désigne l’ensemble des principes qui permettent de concevoir, utiliser et contrôler des systèmes IA de manière responsable, équitable et respectueuse des droits humains.
+
+[OBJECTIF]
+L’objectif principal de l’éthique IA est d’éviter que les systèmes automatisés produisent des décisions injustes, discriminatoires, opaques ou dangereuses pour les individus.
+
+[PRINCIPES]
+Les grands principes de l’éthique IA sont :
+- équité ;
+- transparence ;
+- explicabilité ;
+- responsabilité ;
+- sécurité ;
+- respect de la vie privée ;
+- supervision humaine ;
+- inclusion.
+
+[BIAIS]
+Les biais algorithmiques apparaissent lorsqu’un modèle reproduit ou amplifie des inégalités présentes dans les données. Un système de recrutement entraîné sur des données historiques biaisées peut par exemple défavoriser certains candidats.
+
+[TRANSPARENCE]
+Les utilisateurs doivent être informés lorsqu’ils interagissent avec une IA. Dans les domaines sensibles, ils doivent aussi comprendre les critères utilisés par le système.
+
+[EXPLICABILITE]
+L’explicabilité consiste à rendre les décisions du modèle compréhensibles. Elle est importante dans la santé, la finance, le recrutement, la justice ou l’éducation.
+
+[RISQUES]
+Les principaux risques éthiques sont :
+- discrimination ;
+- surveillance excessive ;
+- perte de contrôle humain ;
+- atteinte à la vie privée ;
+- décisions automatisées injustes ;
+- diffusion de fausses informations.
+
+[MESURES]
+Pour réduire ces risques, il faut :
+- auditer les données ;
+- tester les biais ;
+- documenter les modèles ;
+- mettre en place une supervision humaine ;
+- prévoir des mécanismes de contestation ;
+- former les équipes.
+
+[CONCLUSION]
+L’éthique IA est indispensable pour construire des systèmes fiables, utiles et dignes de confiance.

corpus/gan.txt

@@ -0,0 +1,44 @@
+[TITRE]
+GAN — Generative Adversarial Networks
+
+[DEFINITION]
+Les GAN, ou réseaux antagonistes génératifs, sont des modèles d’intelligence artificielle générative introduits par Ian Goodfellow en 2014. Ils permettent de générer de nouvelles données ressemblant à des données réelles.
+
+[FONCTIONNEMENT]
+Un GAN fonctionne avec deux réseaux de neurones :
+- le générateur ;
+- le discriminateur.
+
+Le générateur crée de fausses données. Le discriminateur essaie de distinguer les vraies données des données générées. Les deux réseaux s’améliorent en compétition.
+
+[APPLICATIONS]
+Les GAN sont utilisés pour :
+- générer des visages artificiels ;
+- créer des images réalistes ;
+- améliorer la résolution d’images ;
+- coloriser des images anciennes ;
+- générer des données synthétiques ;
+- produire des images médicales artificielles.
+
+[EXEMPLES]
+Un GAN peut créer un visage humain qui n’existe pas réellement. Il peut aussi transformer une image basse résolution en image plus nette.
+
+[AVANTAGES]
+Les GAN peuvent produire des résultats très réalistes. Ils sont utiles lorsque les données réelles sont rares ou difficiles à obtenir.
+
+[RISQUES]
+Les principaux risques sont :
+- création de deepfakes ;
+- usurpation d’identité ;
+- désinformation ;
+- génération d’images trompeuses ;
+- exploitation malveillante des contenus synthétiques.
+
+[LIMITES]
+L’entraînement des GAN est instable. Il peut être difficile d’équilibrer le générateur et le discriminateur. Les GAN peuvent aussi produire des images incohérentes ou manquer de diversité.
+
+[ETHIQUE]
+L’utilisation des GAN doit être transparente. Les contenus générés artificiellement devraient être signalés pour éviter la manipulation des utilisateurs.
+
+[CONCLUSION]
+Les GAN sont une technologie importante de l’IA générative, mais leur puissance impose un encadrement éthique fort.

corpus/ia_act.txt

@@ -0,0 +1,50 @@
+[TITRE]
+AI Act européen
+
+[DEFINITION]
+Le AI Act est le règlement européen destiné à encadrer les systèmes d’intelligence artificielle. Il vise à protéger les citoyens tout en permettant l’innovation.
+
+[OBJECTIF]
+L’objectif du AI Act est de garantir que les systèmes IA utilisés en Europe soient sûrs, transparents, contrôlables et respectueux des droits fondamentaux.
+
+[NIVEAUX DE RISQUE]
+Le AI Act classe les systèmes IA selon quatre niveaux :
+- risque minimal ;
+- risque limité ;
+- haut risque ;
+- risque inacceptable.
+
+[RISQUE MINIMAL]
+Les systèmes à risque minimal, comme les filtres anti-spam ou certaines recommandations simples, ont peu d’obligations spécifiques.
+
+[RISQUE LIMITE]
+Les systèmes à risque limité, comme les chatbots, doivent respecter des obligations de transparence. L’utilisateur doit savoir qu’il interagit avec une IA.
+
+[HAUT RISQUE]
+Les systèmes à haut risque concernent des domaines sensibles comme :
+- santé ;
+- recrutement ;
+- finance ;
+- éducation ;
+- justice ;
+- sécurité ;
+- infrastructures critiques.
+
+[OBLIGATIONS]
+Les systèmes à haut risque doivent prévoir :
+- documentation technique ;
+- gestion des risques ;
+- qualité des données ;
+- supervision humaine ;
+- traçabilité ;
+- tests de robustesse ;
+- contrôle des biais.
+
+[RISQUE INACCEPTABLE]
+Certains usages sont interdits, comme la notation sociale, la manipulation comportementale ou certaines formes de surveillance biométrique abusive.
+
+[IA GENERATIVE]
+Les modèles d’IA générative doivent respecter des exigences de transparence, notamment sur les contenus générés, les données d’entraînement et le respect du droit d’auteur.
+
+[CONCLUSION]
+Le AI Act cherche à construire une IA fiable, responsable et compatible avec les valeurs européennes.

corpus/ia_art.txt

@@ -0,0 +1,45 @@
+[TITRE]
+IA et art
+
+[DEFINITION]
+L’intelligence artificielle dans l’art désigne l’utilisation de modèles génératifs pour créer ou assister la création d’images, de musiques, de textes, de vidéos ou d’œuvres numériques.
+
+[APPLICATIONS]
+L’IA est utilisée pour :
+- générer des images artistiques ;
+- composer de la musique ;
+- créer des vidéos ;
+- produire des illustrations ;
+- assister le design graphique ;
+- générer des textes créatifs.
+
+[EXEMPLES]
+Des outils comme Midjourney, DALL-E ou Stable Diffusion peuvent produire une image à partir d’une description textuelle. Des modèles audio peuvent composer une mélodie ou générer une voix synthétique.
+
+[IMPORTANCE]
+L’IA permet aux artistes d’explorer rapidement plusieurs idées, styles et variations. Elle peut accélérer le processus créatif et ouvrir de nouvelles formes d’expression.
+
+[AVANTAGES]
+Les avantages sont :
+- créativité augmentée ;
+- production rapide ;
+- exploration de styles variés ;
+- accessibilité à des outils créatifs avancés ;
+- aide à l’inspiration.
+
+[RISQUES]
+Les principaux risques sont :
+- violation du droit d’auteur ;
+- imitation du style d’artistes sans autorisation ;
+- perte de valeur du travail humain ;
+- production massive de contenus artificiels ;
+- confusion entre création humaine et création IA.
+
+[LIMITES]
+L’IA ne possède pas d’intention artistique propre. Elle génère à partir de données apprises et peut produire des œuvres sans profondeur émotionnelle ou sans contexte culturel réel.
+
+[ETHIQUE]
+Il est important de signaler les œuvres générées par IA, de respecter les droits des artistes et de clarifier la propriété intellectuelle des créations.
+
+[CONCLUSION]
+L’IA transforme fortement l’art, mais son usage doit préserver la place de la créativité humaine et le respect des créateurs.

corpus/ia_cybersecurite.txt

@@ -0,0 +1,45 @@
+[TITRE]
+IA et cybersécurité
+
+[DEFINITION]
+L’intelligence artificielle en cybersécurité désigne l’utilisation de modèles IA pour détecter, prévenir et analyser les menaces informatiques.
+
+[APPLICATIONS]
+L’IA est utilisée pour :
+- détecter les intrusions ;
+- analyser les comportements suspects ;
+- identifier les logiciels malveillants ;
+- détecter les fraudes ;
+- surveiller les réseaux ;
+- automatiser la réponse aux incidents.
+
+[EXEMPLES]
+Un système IA peut repérer une connexion inhabituelle, détecter une activité anormale sur un serveur ou identifier une tentative de phishing.
+
+[IMPORTANCE]
+Les cyberattaques produisent de grandes quantités de signaux. L’IA permet d’analyser rapidement ces données et d’aider les équipes sécurité à réagir plus vite.
+
+[AVANTAGES]
+Les avantages sont :
+- détection rapide ;
+- analyse en temps réel ;
+- réduction du temps de réaction ;
+- amélioration de la surveillance ;
+- automatisation de tâches répétitives.
+
+[RISQUES]
+Les risques sont :
+- faux positifs ;
+- surveillance excessive ;
+- collecte massive de données ;
+- dépendance aux systèmes automatisés ;
+- utilisation de l’IA par les cybercriminels.
+
+[IA MALVEILLANTE]
+Les attaquants peuvent utiliser l’IA pour générer des emails de phishing crédibles, automatiser des attaques ou créer des deepfakes.
+
+[RGPD]
+Les systèmes de cybersécurité doivent respecter le RGPD lorsqu’ils traitent des données personnelles, comme les logs de connexion ou les informations utilisateurs.
+
+[CONCLUSION]
+L’IA est un outil puissant pour renforcer la cybersécurité, mais elle doit être encadrée pour éviter la surveillance abusive et les usages malveillants.

corpus/ia_education.txt

@@ -0,0 +1,46 @@
+[TITRE]
+IA et éducation
+
+[DEFINITION]
+L’intelligence artificielle dans l’éducation désigne l’utilisation de systèmes IA pour personnaliser l’apprentissage, accompagner les élèves et aider les enseignants.
+
+[APPLICATIONS]
+L’IA est utilisée pour :
+- adapter les exercices au niveau de l’élève ;
+- générer des quiz ;
+- corriger automatiquement certains travaux ;
+- détecter les risques de décrochage ;
+- proposer des recommandations pédagogiques ;
+- assister les enseignants.
+
+[EXEMPLES]
+Une plateforme éducative peut analyser les erreurs d’un étudiant et lui proposer des exercices plus adaptés. Un chatbot peut répondre à des questions de cours.
+
+[IMPORTANCE]
+L’IA peut rendre l’apprentissage plus personnalisé et aider les enseignants à mieux suivre les difficultés des élèves.
+
+[AVANTAGES]
+Les avantages sont :
+- personnalisation des parcours ;
+- feedback rapide ;
+- meilleure identification des difficultés ;
+- gain de temps pour les enseignants ;
+- accès à une aide pédagogique continue.
+
+[RISQUES]
+Les principaux risques sont :
+- profilage excessif des élèves ;
+- atteinte à la vie privée ;
+- biais socio-économiques ;
+- orientation injuste ;
+- dépendance aux outils numériques ;
+- réduction du rôle humain de l’enseignant.
+
+[MINEURS]
+Les élèves sont souvent mineurs. Les données scolaires et comportementales doivent donc être protégées avec une attention particulière.
+
+[SUPERVISION HUMAINE]
+L’IA ne doit pas décider seule de l’avenir scolaire d’un élève. Les enseignants doivent garder la responsabilité des décisions pédagogiques.
+
+[CONCLUSION]
+L’IA peut améliorer l’éducation, mais elle doit être utilisée avec prudence pour éviter les discriminations et protéger les élèves.

corpus/ia_finance.txt

@@ -0,0 +1,46 @@
+[TITRE]
+IA et finance
+
+[DEFINITION]
+L’intelligence artificielle en finance désigne l’utilisation de modèles IA pour analyser des données financières, automatiser des décisions et améliorer la gestion des risques.
+
+[APPLICATIONS]
+L’IA est utilisée pour :
+- détecter les fraudes bancaires ;
+- évaluer le risque de crédit ;
+- analyser les marchés financiers ;
+- automatiser le support client ;
+- prédire des comportements financiers ;
+- détecter des transactions suspectes.
+
+[EXEMPLES]
+Une banque peut utiliser l’IA pour repérer une transaction inhabituelle. Un système de scoring peut estimer la probabilité qu’un client rembourse un prêt.
+
+[IMPORTANCE]
+La finance produit de nombreuses données. L’IA permet d’analyser rapidement ces informations et d’améliorer la prise de décision.
+
+[AVANTAGES]
+Les avantages sont :
+- détection rapide des fraudes ;
+- meilleure analyse du risque ;
+- automatisation des tâches ;
+- amélioration du service client ;
+- réduction des pertes financières.
+
+[RISQUES]
+Les principaux risques sont :
+- discrimination dans l’accès au crédit ;
+- manque de transparence ;
+- décisions automatisées injustes ;
+- utilisation de données sensibles ;
+- dépendance aux algorithmes ;
+- erreurs dans les prédictions financières.
+
+[REGLEMENTATION]
+Les décisions financières automatisées doivent être explicables. Un client doit pouvoir comprendre pourquoi un prêt est refusé ou pourquoi une transaction est bloquée.
+
+[CYBERSECURITE]
+Les données financières sont très sensibles. Elles doivent être protégées contre les cyberattaques, les fuites et les accès non autorisés.
+
+[CONCLUSION]
+L’IA améliore la finance, mais elle doit être encadrée pour garantir l’équité, la transparence et la sécurité des données.

corpus/ia_medecine.txt

@@ -0,0 +1,45 @@
+[TITRE]
+IA en médecine
+
+[DEFINITION]
+L’intelligence artificielle en médecine désigne l’utilisation de modèles IA pour assister les professionnels de santé dans le diagnostic, l’analyse de données médicales et la gestion hospitalière.
+
+[APPLICATIONS]
+Les systèmes IA sont utilisés pour :
+- l’analyse de scanners et IRM ;
+- la détection de tumeurs ;
+- la prédiction de maladies ;
+- l’aide au diagnostic ;
+- la gestion hospitalière.
+
+[EXEMPLES]
+Des modèles de deep learning peuvent détecter :
+- des cancers ;
+- des fractures ;
+- des maladies pulmonaires.
+
+[IMPORTANCE]
+L’IA permet :
+- d’améliorer la rapidité des diagnostics ;
+- de réduire certaines erreurs médicales ;
+- d’optimiser les ressources hospitalières.
+
+[RISQUES]
+Les principaux risques sont :
+- les biais algorithmiques ;
+- les erreurs de diagnostic ;
+- les discriminations médicales ;
+- les problèmes de confidentialité des données ;
+- la dépendance excessive à l’IA.
+
+[RGPD]
+Les données médicales sont considérées comme sensibles par le RGPD. Les systèmes IA doivent garantir :
+- la sécurité ;
+- la confidentialité ;
+- la traçabilité des données patients.
+
+[SUPERVISION HUMAINE]
+L’IA ne doit pas remplacer les médecins. La supervision humaine reste essentielle pour garantir la sécurité des patients.
+
+[CONCLUSION]
+L’IA en médecine représente une avancée importante mais nécessite un encadrement éthique et réglementaire strict.

corpus/ia_rh.txt

@@ -0,0 +1,49 @@
+[TITRE]
+IA et ressources humaines
+
+[DEFINITION]
+L’intelligence artificielle dans les ressources humaines désigne l’utilisation de systèmes IA pour assister le recrutement, la gestion des talents, la formation et l’analyse des performances.
+
+[APPLICATIONS]
+L’IA est utilisée pour :
+- trier automatiquement des CV ;
+- classer des candidatures ;
+- répondre aux candidats via chatbot ;
+- analyser les compétences ;
+- prédire les risques de départ ;
+- recommander des formations.
+
+[EXEMPLES]
+Un outil de recrutement peut analyser des CV et proposer une liste de candidats correspondant à une offre d’emploi.
+
+[IMPORTANCE]
+L’IA peut faire gagner du temps aux équipes RH et améliorer la gestion des candidatures lorsque les volumes sont importants.
+
+[AVANTAGES]
+Les avantages sont :
+- automatisation du tri ;
+- traitement rapide des candidatures ;
+- aide à la décision ;
+- amélioration du suivi des employés ;
+- personnalisation des parcours de formation.
+
+[RISQUES]
+Les principaux risques sont :
+- discrimination ;
+- reproduction de biais historiques ;
+- manque de transparence ;
+- exclusion injuste de candidats ;
+- surveillance excessive des employés ;
+- décisions automatisées sans contrôle humain.
+
+[BIAIS]
+Un modèle entraîné sur des recrutements passés peut reproduire des inégalités. Si une entreprise a historiquement recruté plus d’hommes, le modèle peut favoriser les candidatures masculines.
+
+[AI ACT]
+Les systèmes IA de recrutement sont considérés comme des systèmes à haut risque. Ils doivent respecter des obligations strictes de transparence, documentation, supervision humaine et contrôle des biais.
+
+[SUPERVISION HUMAINE]
+L’IA doit assister les recruteurs mais ne doit pas décider seule du recrutement ou du rejet d’un candidat.
+
+[CONCLUSION]
+L’IA peut améliorer les ressources humaines, mais elle doit être contrôlée pour garantir l’équité et protéger les candidats.

corpus/llm.txt

@@ -0,0 +1,50 @@
+[TITRE]
+Large Language Models
+
+[DEFINITION]
+Les Large Language Models, ou LLM, sont des modèles d’intelligence artificielle capables de comprendre, produire, résumer, traduire et analyser du texte.
+
+[FONCTIONNEMENT]
+Les LLM sont généralement basés sur l’architecture Transformer. Ils sont entraînés sur de grands volumes de textes et apprennent à prédire le mot suivant dans une phrase.
+
+[APPLICATIONS]
+Les LLM sont utilisés pour :
+- créer des chatbots ;
+- résumer des documents ;
+- générer du texte ;
+- traduire automatiquement ;
+- écrire du code ;
+- répondre à des questions ;
+- assister la recherche documentaire.
+
+[EXEMPLES]
+GPT, Claude, Gemini, Llama et Mistral sont des exemples de LLM modernes. Ils peuvent servir d’assistants conversationnels ou d’outils d’aide à la rédaction.
+
+[IMPORTANCE]
+Les LLM ont transformé l’accès à l’information et l’automatisation des tâches textuelles. Ils permettent de créer des assistants capables d’interagir en langage naturel.
+
+[AVANTAGES]
+Les avantages sont :
+- compréhension du langage naturel ;
+- génération rapide de texte ;
+- polyvalence ;
+- aide à la productivité ;
+- capacité à traiter de nombreux domaines.
+
+[RISQUES]
+Les principaux risques sont :
+- hallucinations ;
+- réponses fausses mais convaincantes ;
+- biais ;
+- désinformation ;
+- fuite de données sensibles ;
+- dépendance excessive à l’IA.
+
+[LIMITES]
+Un LLM ne comprend pas le monde comme un humain. Il prédit du texte à partir de probabilités. Il peut inventer des informations lorsqu’il ne dispose pas de contexte fiable.
+
+[RAG]
+Le RAG permet de réduire certaines limites des LLM en leur fournissant des documents pertinents avant la génération de la réponse.
+
+[CONCLUSION]
+Les LLM sont au cœur de l’IA générative moderne, mais ils doivent être utilisés avec vérification, prudence et transparence.

corpus/rag.txt

@@ -0,0 +1,52 @@
+[TITRE]
+Retrieval Augmented Generation
+
+[DEFINITION]
+Le RAG, ou Retrieval Augmented Generation, est une méthode qui combine recherche documentaire et génération de texte par un modèle de langage.
+
+[OBJECTIF]
+L’objectif du RAG est d’améliorer la fiabilité des réponses d’un chatbot en lui fournissant des documents pertinents au moment de répondre.
+
+[FONCTIONNEMENT]
+Un système RAG suit généralement trois étapes :
+- indexer les documents ;
+- rechercher les passages les plus pertinents ;
+- envoyer le contexte trouvé au modèle génératif.
+
+[RECHERCHE]
+La recherche peut être réalisée avec TF-IDF, similarité cosinus ou embeddings sémantiques. Le système compare la question de l’utilisateur avec les documents du corpus.
+
+[GENERATION]
+Après la recherche, le modèle reçoit un prompt contenant le contexte et la question. Il génère ensuite une réponse basée sur les informations récupérées.
+
+[APPLICATIONS]
+Le RAG est utilisé pour :
+- assistants de cours ;
+- support client ;
+- recherche documentaire ;
+- chatbots d’entreprise ;
+- assistants juridiques ;
+- assistants médicaux ;
+- documentation technique.
+
+[AVANTAGES]
+Les avantages sont :
+- réduction des hallucinations ;
+- réponses plus précises ;
+- possibilité de citer les sources ;
+- mise à jour facile du corpus ;
+- meilleure transparence.
+
+[RISQUES]
+Les risques sont :
+- mauvais documents récupérés ;
+- contexte incomplet ;
+- corpus de mauvaise qualité ;
+- réponse générée hors contexte ;
+- dépendance à la qualité du retrieval.
+
+[CORPUS]
+La qualité du corpus est centrale. Un bon corpus doit être clair, structuré, précis et adapté aux questions attendues.
+
+[CONCLUSION]
+Le RAG rend les chatbots plus fiables, mais sa qualité dépend fortement du corpus, du découpage des documents et de la méthode de recherche.

corpus/rgpd_ia.txt

@@ -0,0 +1,51 @@
+[TITRE]
+RGPD et intelligence artificielle
+
+[DEFINITION]
+Le RGPD, ou Règlement Général sur la Protection des Données, encadre le traitement des données personnelles dans l’Union européenne. Il s’applique aux projets d’intelligence artificielle lorsqu’ils utilisent des données liées à des individus.
+
+[OBJECTIF]
+L’objectif du RGPD est de protéger la vie privée, les droits et les libertés des personnes dont les données sont collectées ou utilisées.
+
+[PRINCIPES]
+Les principes clés du RGPD sont :
+- licéité ;
+- transparence ;
+- minimisation des données ;
+- limitation des finalités ;
+- exactitude ;
+- sécurité ;
+- limitation de conservation.
+
+[APPLICATIONS IA]
+Dans un projet IA, le RGPD s’applique lorsque les données utilisées concernent des utilisateurs, patients, clients, candidats, employés ou élèves.
+
+[DONNEES SENSIBLES]
+Les données de santé, données biométriques, données financières ou informations liées à l’origine, aux opinions ou à la vie privée sont particulièrement protégées.
+
+[RISQUES]
+Les risques sont :
+- collecte excessive ;
+- absence de consentement ;
+- usage non prévu des données ;
+- fuite de données ;
+- réidentification ;
+- décisions automatisées non expliquées.
+
+[DROITS DES PERSONNES]
+Les utilisateurs disposent de plusieurs droits :
+- accès aux données ;
+- rectification ;
+- effacement ;
+- opposition ;
+- portabilité ;
+- contestation de certaines décisions automatisées.
+
+[PRIVACY BY DESIGN]
+La protection des données doit être intégrée dès la conception du système IA. Il faut limiter les données collectées et sécuriser les traitements.
+
+[SUPERVISION HUMAINE]
+Lorsqu’une IA influence une décision importante, une intervention humaine doit être prévue pour éviter une décision automatique injuste.
+
+[CONCLUSION]
+Le RGPD impose aux systèmes IA de respecter la vie privée, la sécurité, la transparence et les droits des personnes.

corpus/transformers.txt

@@ -0,0 +1,43 @@
+[TITRE]
+Architecture Transformer
+
+[DEFINITION]
+Les Transformers sont une architecture de réseau de neurones introduite en 2017 dans l’article “Attention Is All You Need”. Ils sont aujourd’hui au cœur des modèles modernes de langage comme GPT, BERT, T5 ou Llama.
+
+[OBJECTIF]
+Les Transformers servent à traiter des séquences de données, notamment du texte, en comprenant les relations entre les mots et leur contexte.
+
+[FONCTIONNEMENT]
+Le principe central des Transformers est le mécanisme d’attention. Ce mécanisme permet au modèle d’identifier quels mots sont importants les uns par rapport aux autres.
+
+[SELF-ATTENTION]
+La self-attention permet à chaque mot d’une phrase de tenir compte des autres mots. Cela aide le modèle à comprendre les dépendances longues et le sens global d’une phrase.
+
+[ENCODEUR]
+L’encodeur analyse le texte d’entrée et produit une représentation du contexte. Il est utilisé dans des modèles comme BERT.
+
+[DECODEUR]
+Le décodeur génère du texte à partir d’un contexte. Il est utilisé dans des modèles comme GPT.
+
+[APPLICATIONS]
+Les Transformers sont utilisés pour :
+- traduction automatique ;
+- résumé de texte ;
+- génération de texte ;
+- classification ;
+- question-réponse ;
+- chatbots ;
+- génération de code.
+
+[AVANTAGES]
+Les avantages sont :
+- traitement parallèle ;
+- meilleure gestion du contexte ;
+- très bonnes performances en langage naturel ;
+- adaptation à de nombreuses tâches.
+
+[LIMITES]
+Les Transformers demandent beaucoup de données et de puissance de calcul. Ils peuvent aussi produire des réponses biaisées ou incorrectes s’ils sont mal entraînés.
+
+[CONCLUSION]
+Les Transformers sont l’une des architectures les plus importantes de l’IA moderne et constituent la base de nombreux systèmes génératifs.

corpus/vae.txt

@@ -0,0 +1,45 @@
+[TITRE]
+VAE — Variational Autoencoder
+
+[DEFINITION]
+Les VAE, ou Variational Autoencoders, sont des modèles génératifs qui apprennent à représenter des données dans un espace latent probabiliste.
+
+[FONCTIONNEMENT]
+Un VAE est composé de deux parties :
+- un encodeur ;
+- un décodeur.
+
+L’encodeur compresse les données dans un espace latent. Le décodeur reconstruit les données à partir de cet espace.
+
+[ESPACE LATENT]
+L’espace latent est une représentation compacte des données. Dans un VAE, cette représentation est probabiliste, ce qui permet de générer de nouvelles données.
+
+[APPLICATIONS]
+Les VAE sont utilisés pour :
+- générer des images ;
+- réduire la dimension des données ;
+- détecter des anomalies ;
+- créer des données synthétiques ;
+- apprendre des représentations utiles.
+
+[EXEMPLES]
+Un VAE peut apprendre la structure d’images de chiffres manuscrits puis générer de nouveaux chiffres ressemblant aux originaux.
+
+[AVANTAGES]
+Les avantages sont :
+- entraînement plus stable que les GAN ;
+- cadre mathématique solide ;
+- capacité à apprendre une représentation organisée ;
+- génération de données nouvelles.
+
+[RISQUES]
+Les risques concernent surtout l’utilisation de données synthétiques trompeuses ou la génération de données sensibles si le modèle apprend trop précisément les exemples d’entraînement.
+
+[LIMITES]
+Les images générées par les VAE sont souvent moins nettes que celles produites par les GAN ou les modèles de diffusion.
+
+[MEDECINE]
+En médecine, les VAE peuvent aider à détecter des anomalies ou générer des images synthétiques pour augmenter un jeu de données.
+
+[CONCLUSION]
+Les VAE sont des modèles génératifs importants, utiles pour la représentation des données, la génération et la détection d’anomalies.

rag.py

@@ -0,0 +1,199 @@
+from pathlib import Path
+from dataclasses import dataclass
+from typing import List
+import re
+import numpy as np
+
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+
+@dataclass
+class RetrievedChunk:
+    text: str
+    filename: str
+    score: float
+
+
+class RAGEngine:
+    def __init__(
+        self,
+        corpus_dir: str = "corpus/",
+        chunk_size: int = 450,
+        chunk_overlap: int = 80,
+        min_score: float = 0.05
+    ):
+        self.corpus_dir = Path(corpus_dir)
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.min_score = min_score
+
+        self.chunks: List[str] = []
+        self.chunk_sources: List[str] = []
+
+        self.vectorizer = TfidfVectorizer(
+            lowercase=True,
+            strip_accents="unicode",
+            ngram_range=(1, 2),
+            max_features=10000
+        )
+
+        self._load_and_chunk_corpus()
+        self._index()
+
+    def _clean_text(self, text: str) -> str:
+        text = re.sub(r"\s+", " ", text)
+        return text.strip()
+
+    def _split_into_chunks(self, text: str) -> List[str]:
+        text = self._clean_text(text)
+
+        if len(text) <= self.chunk_size:
+            return [text]
+
+        chunks = []
+        start = 0
+
+        while start < len(text):
+            end = start + self.chunk_size
+            chunk = text[start:end].strip()
+
+            if chunk:
+                chunks.append(chunk)
+
+            start += self.chunk_size - self.chunk_overlap
+
+        return chunks
+
+    def _load_and_chunk_corpus(self):
+        if not self.corpus_dir.exists():
+            raise FileNotFoundError(f"Dossier corpus introuvable : {self.corpus_dir}")
+
+        files = sorted(
+            list(self.corpus_dir.glob("*.txt")) +
+            list(self.corpus_dir.glob("*.md"))
+        )
+
+        if not files:
+            raise ValueError("Aucun fichier .txt ou .md trouvé dans le dossier corpus.")
+
+        for file_path in files:
+            try:
+                text = file_path.read_text(encoding="utf-8")
+                chunks = self._split_into_chunks(text)
+
+                for chunk in chunks:
+                    self.chunks.append(chunk)
+                    self.chunk_sources.append(file_path.name)
+
+            except Exception as e:
+                print(f"Fichier ignoré : {file_path.name} | Erreur : {e}")
+
+        if not self.chunks:
+            raise ValueError("Aucun passage exploitable trouvé dans le corpus.")
+
+        print(f"{len(files)} fichiers chargés.")
+        print(f"{len(self.chunks)} passages indexés.")
+
+    def _index(self):
+        self.tfidf_matrix = self.vectorizer.fit_transform(self.chunks)
+
+    def search(self, query: str, top_k: int = 2) -> List[RetrievedChunk]:
+        query = self._clean_text(query)
+
+        if not query:
+            return []
+
+        q_vec = self.vectorizer.transform([query])
+        scores = cosine_similarity(q_vec, self.tfidf_matrix)[0]
+
+        query_lower = query.lower()
+
+        for i in range(len(scores)):
+            filename = self.chunk_sources[i].lower()
+
+            if "médecine" in query_lower or "medecine" in query_lower or "santé" in query_lower:
+                if "ia_medecine" in filename:
+                    scores[i] += 0.08
+
+            if "finance" in query_lower or "banque" in query_lower or "crédit" in query_lower or "credit" in query_lower:
+                if "ia_finance" in filename:
+                    scores[i] += 0.08
+
+            if "recrutement" in query_lower or "rh" in query_lower:
+                if "ia_rh" in filename:
+                    scores[i] += 0.08
+
+            if "éducation" in query_lower or "education" in query_lower or "école" in query_lower or "ecole" in query_lower or "élève" in query_lower or "eleve" in query_lower:
+                if "ia_education" in filename:
+                    scores[i] += 0.08
+
+            if "cybersécurité" in query_lower or "cybersecurite" in query_lower or "cyber" in query_lower:
+                if "ia_cybersecurite" in filename:
+                    scores[i] += 0.08
+
+            if "art" in query_lower or "image" in query_lower or "création" in query_lower or "creation" in query_lower:
+                if "ia_art" in filename:
+                    scores[i] += 0.08
+
+        top_idx = np.argsort(scores)[::-1][:top_k]
+
+        results = []
+
+        for i in top_idx:
+            score = float(scores[i])
+
+            if score >= self.min_score:
+                results.append(
+                    RetrievedChunk(
+                        text=self.chunks[i],
+                        filename=self.chunk_sources[i],
+                        score=score
+                    )
+                )
+
+        return results
+    
+    def _clean_for_prompt(self, text: str) -> str:
+        text = re.sub(r"\[[A-ZÉÈÊÀÙÎÏÇ _-]+\]", "", text)
+        text = re.sub(r"\s+", " ", text)
+        return text.strip()
+
+    def build_prompt(self, query: str, top_k: int = 2) -> str:
+        results = self.search(query, top_k=top_k)
+        
+        if not results:
+            return f"""
+Réponds uniquement en français.
+
+La réponse n'existe pas dans le contexte fourni.
+
+Question :
+{query}
+
+Réponse :
+Je ne dispose pas d'assez d'informations dans le corpus pour répondre correctement.
+"""
+
+        context = "\n\n".join(
+            [
+                f"{self._clean_for_prompt(result.text)}"
+                for result in results
+            ]
+    )
+
+        return f"""
+Réponds uniquement en français.
+Utilise uniquement le contexte.
+Ne recopie pas le contexte.
+Réponds en 4 à 6 phrases claires.
+Si le contexte ne répond pas à la question, dis que l'information est insuffisante.
+
+Contexte :
+{context}
+
+Question :
+{query}
+
+Réponse :
+"""

rag_gpt2.py

@@ -0,0 +1,178 @@
+from pathlib import Path
+from dataclasses import dataclass
+from typing import List
+import re
+import numpy as np
+
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+
+@dataclass
+class RetrievedChunk:
+    text: str
+    filename: str
+    score: float
+
+
+class RAGEngineGPT2:
+    def __init__(
+        self,
+        corpus_dir: str = "corpus/",
+        chunk_size: int = 450,
+        chunk_overlap: int = 80,
+        min_score: float = 0.05
+    ):
+        self.corpus_dir = Path(corpus_dir)
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.min_score = min_score
+
+        self.chunks: List[str] = []
+        self.chunk_sources: List[str] = []
+
+        self.vectorizer = TfidfVectorizer(
+            lowercase=True,
+            strip_accents="unicode",
+            ngram_range=(1, 2),
+            max_features=10000
+        )
+
+        self._load_and_chunk_corpus()
+        self._index()
+
+    def _clean_text(self, text: str) -> str:
+        text = re.sub(r"\s+", " ", text)
+        return text.strip()
+
+    def _clean_for_prompt(self, text: str) -> str:
+        text = re.sub(r"\[[A-ZÉÈÊÀÙÎÏÇ _-]+\]", "", text)
+        text = re.sub(r"\s+", " ", text)
+        return text.strip()
+
+    def _split_into_chunks(self, text: str) -> List[str]:
+        text = self._clean_text(text)
+
+        if len(text) <= self.chunk_size:
+            return [text]
+
+        chunks = []
+        start = 0
+
+        while start < len(text):
+            end = start + self.chunk_size
+            chunk = text[start:end].strip()
+
+            if chunk:
+                chunks.append(chunk)
+
+            start += self.chunk_size - self.chunk_overlap
+
+        return chunks
+
+    def _load_and_chunk_corpus(self):
+        if not self.corpus_dir.exists():
+            raise FileNotFoundError(f"Dossier corpus introuvable : {self.corpus_dir}")
+
+        files = sorted(
+            list(self.corpus_dir.glob("*.txt")) +
+            list(self.corpus_dir.glob("*.md"))
+        )
+
+        if not files:
+            raise ValueError("Aucun fichier .txt ou .md trouvé dans le dossier corpus.")
+
+        for file_path in files:
+            try:
+                text = file_path.read_text(encoding="utf-8")
+                chunks = self._split_into_chunks(text)
+
+                for chunk in chunks:
+                    self.chunks.append(chunk)
+                    self.chunk_sources.append(file_path.name)
+
+            except Exception as e:
+                print(f"Fichier ignoré : {file_path.name} | Erreur : {e}")
+
+        if not self.chunks:
+            raise ValueError("Aucun passage exploitable trouvé dans le corpus.")
+
+        print(f"{len(files)} fichiers chargés.")
+        print(f"{len(self.chunks)} passages indexés.")
+
+    def _index(self):
+        self.tfidf_matrix = self.vectorizer.fit_transform(self.chunks)
+
+    def _apply_domain_boost(self, query: str, scores):
+        query_lower = query.lower()
+
+        for i in range(len(scores)):
+            filename = self.chunk_sources[i].lower()
+
+            if ("médecine" in query_lower or "medecine" in query_lower or "santé" in query_lower) and "ia_medecine" in filename:
+                scores[i] += 0.08
+
+            if ("finance" in query_lower or "banque" in query_lower or "crédit" in query_lower or "credit" in query_lower) and "ia_finance" in filename:
+                scores[i] += 0.08
+
+            if ("recrutement" in query_lower or "rh" in query_lower) and "ia_rh" in filename:
+                scores[i] += 0.08
+
+            if ("éducation" in query_lower or "education" in query_lower or "école" in query_lower or "ecole" in query_lower or "élève" in query_lower or "eleve" in query_lower) and "ia_education" in filename:
+                scores[i] += 0.08
+
+            if ("cybersécurité" in query_lower or "cybersecurite" in query_lower or "cyber" in query_lower) and "ia_cybersecurite" in filename:
+                scores[i] += 0.08
+
+            if ("art" in query_lower or "image" in query_lower or "création" in query_lower or "creation" in query_lower) and "ia_art" in filename:
+                scores[i] += 0.08
+
+        return scores
+
+    def search(self, query: str, top_k: int = 1) -> List[RetrievedChunk]:
+        query = self._clean_text(query)
+
+        if not query:
+            return []
+
+        q_vec = self.vectorizer.transform([query])
+        scores = cosine_similarity(q_vec, self.tfidf_matrix)[0]
+        scores = self._apply_domain_boost(query, scores)
+
+        top_idx = np.argsort(scores)[::-1][:top_k]
+
+        results = []
+
+        for i in top_idx:
+            score = float(scores[i])
+
+            if score >= self.min_score:
+                results.append(
+                    RetrievedChunk(
+                        text=self.chunks[i],
+                        filename=self.chunk_sources[i],
+                        score=score
+                    )
+                )
+
+        return results
+
+    def build_prompt(self, query: str, top_k: int = 1) -> str:
+        results = self.search(query, top_k=top_k)
+
+        if not results:
+            return ""
+
+        context = "\n\n".join(
+            [self._clean_for_prompt(result.text) for result in results]
+        )
+
+        return f"""
+Contexte :
+{context}
+
+Question :
+{query}
+
+Réponse en français :
+"""

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+transformers
+scikit-learn
+numpy
+sentencepiece
+torch