imit

.gitignore

@@ -0,0 +1,8 @@
+venv/
+.gradio/
+.idea/
+set_env.sh
+datasets/
+explo.ipynb
+*.pyc
+.DS_Store

README.md

@@ -1,12 +1,159 @@
+# Gossip Answering
+
+## Quick Start
+
+Cette application utilise **Gradio** pour créer une interface permettant de poser des questions sur des articles provenant de [VSD](https://vsd.fr/) et [Public](https://www.public.fr/) en utilisant des techniques de **Retrieval-Augmented Generation (RAG)**.
+
+  Ce projet utilise deux services API, et il vous sera nécessaire de générer des clés pour accéder à ces API. :
+   - **[Cohere](https://dashboard.cohere.com/api-keys)** pour générer des embeddings.
+   - **[Groq](https://console.groq.com/keys)** pour générer du contenu.
+
 ---
-title: Gossip Semantic Search Demo
-emoji: 🚀
-colorFrom: purple
-colorTo: gray
-sdk: gradio
-sdk_version: 5.1.0
-app_file: app.py
-pinned: false
+### colab ###
+
+Vous pouvez accéder au [notebook disponible sur Google Colab ici.](https://colab.research.google.com/drive/1pG4-s2Tg-9o7U0bRZrV1WELTy2k42qk5?usp=drive_link)
+
+
+Dans la première cellule, vous devrez entrer votre GitHub token pour cloner le repo ainsi que les clés des deux API utilisées par ce projet.
+
+Une fois cela fait, exécutez toutes les cellules du notebook, puis rendez-vous sur le lien généré `.gradio.live` à la fin de la dernière cellule pour accéder à l'application.
+
+---
+### Local ###
+#### Prérequis
+
+- **Python 3.12.3** (La version utilisée pour ce projet)
+
+#### Installation
+
+1. **Clonez le dépôt :**
+
+   Clonez le projet sur votre machine locale en utilisant la commande suivante :
+
+    ```
+   git clone https://github.com/PierreBdesG/gossip-semantic-search.git
+   ```
+
+2. **Récupérez les clés API :**
+
+   Définissez vos API keys comme variables d'environnement :
+
+   ``` 
+   export COHERE_API_KEY=your_cohere_api_key
+   export GROQ_API_KEY=your_groq_api_key 
+   ```
+
+3. **Installez les dépendances :**
+
+   Installez les bibliothèques nécessaires à l'aide du fichier `requirements.txt` :
+
+   ```
+   pip install -r requirements.txt
+   ```
+
+4. **Téléchargez le dataset :**
+
+   Téléchargez le dataset (mis à jour le 19 octobre 2024) :
+    ``` 
+   !curl -L -o dataset.pkl "https://drive.google.com/uc?export=download&id=1g4-pNY3CTRIW5_hinWBREMkTrsZ05GNd"
+   ```
+
+5. **Lancez l'application :**
+
+   Exécutez l'application avec la commande suivante, en fournissant le chemin vers le dataset téléchargé :
+
+   ```
+   python gossip_semantic_search/front --dataset_path dataset.pkl
+   ```
+    
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Création du Dataset
+
+Le dataset utilisé dans ce projet est une **`List[Article]`**, où chaque élément est un objet `Article` contenant les informations suivantes :
+
+```
+class Article:
+    author: str
+    title: str
+    link: str
+    description: str
+    published_date: datetime
+    content: str
+    embeded_content: NDArray
+    questions: list[str]
+ ```
+
+- Les attributs **`author`**, **`title`**, **`link`**, **`description`**, **`published_date`** et **`content`** sont extraits des flux RSS des sites [VSD](https://vsd.fr/feed) et [Public](https://www.public.fr/feed).
+- Le champ **`embeded_content`** correspond aux embeddings générés pour chaque article. Une description détaillée de l'embedding utilisé est disponible [ici](https://cohere.com/blog/introducing-embed-v3).
+- Le champ **`questions`** contient une liste de `n` questions associées à l'article. Ces questions ont été générées à l'aide de [`Llama-3-70B`](https://huggingface.co/meta-llama/Meta-Llama-3-70B), via l'API fournie par [Groq](https://groq.com/).
+
+---
+
+## Évaluation ##
+
+Pour ce dataset, nous avons choisi de générer 3 questions par article. Avec un total de 60 articles, cela constitue un dataset d'environ 180 questions.
+
+Une fois ce dataset créé, nous pouvons évaluer notre modèle de retrieval de la manière suivante :
+- Effectuer un produit scalaire (similaire a un cosine similarity vue que les normes des embedding=1) entre tous les embeddings des questions et tous les embeddings des contextes.
+- Pour chaque question, récupérer les `k` meilleurs contextes correspondant.
+
+ce qui nous donne les resultats suivant:
+![k_plot_graph.png](gossip_semantic_search/evaluator/k_plot_graph.png)
+
+/!\ regénerer le graph en décalant les absisse de 1
+
+#### Résultats du Graph
+
+Sur ce graphique, on observe les résultats suivants pour la récupération des contextes :
+
+- Si l'on se base uniquement sur le **dot product** le plus élevé pour chaque question, dans **91.5% des cas**, le contexte d'origine est retrouvé.
+- En élargissant la sélection aux **2 meilleurs contextes**, dans environ **99% des cas**, le contexte d'origine se trouve parmi les deux contextes sélectionnés.
+- En prenant les **3 meilleurs contextes**, on atteint une précision de **99.5%**, où le contexte d'origine se retrouve dans les trois contextes sélectionnés.
+
+
+#### Limitation ####
+
+Ce dataset est un dataset **synthétique**. Les questions ont été générées par le modèle **[Llama-3-70B](https://huggingface.co/meta-llama/Meta-Llama-3-70B)**, en prenant en compte un certain article spécifique pour chaque question. Les questions sont donc conçues pour correspondre directement au contenu des articles, créant ainsi un ensemble de données biaisé par apport au réel avec 
+des questions bien alignées avec les informations présentes dans le texte.
+Lors de l'inférence, les questions posées par les utilisateurs ne seront pas toujours aussi structurées ou spécifiques que celles générées pour ce dataset. Les questions réelles, posées par des utilisateurs humains, seront souvent plus organiques, plus variées, et moins directement liées à un contexte particulier
+En conséquence, les performances du modèle seront donc moins élevées lorsqu'il sera confronté à des questions plus naturelles 
+
+---
+
+## Inférence et génération de réponses ##
+
+1.Une question est entrée par un utilisateur.
+
+2.  La question est convertie en embedding.
+
+3.  On effectue un dot product entre l'embedding de la question et tous les articles embeddés, qui ont été chargés en RAM lors du lancement de l'application.
+
+4. On récupère les 3 articles les plus pertinents.
+
+5. On prend le premier article et on demande à **[Llama-3-70B](https://huggingface.co/meta-llama/Meta-Llama-3-70B)** si la réponse à la question se trouve dans le contexte de cet article.
+   - Si oui, on demande à **Llama-3-70B** de générer la réponse, puis on renvoie la réponse, le lien de l'article et le contexte correspondant.
+   - Si non, on passe au deuxième article et répète la même procédure.
+   - Si la réponse n'est trouvée dans aucun des 3 articles, on renvoie le message **"incapable de générer une réponse"** ainsi que le premier contexte.
+
+------
+
+## Exploration
+Si j'avais eu plus de temps, j'aurais :
+
+- Généré un jeu de données plus complexe.
+- Implémenté des KNN plutôt que d'utiliser le produit scalaire pour le retriever.
+- Mieux exploré et analysé les questions mal classifiées.
+- Mis en place un reformulateur de questions (multi-query, [hyde](https://arxiv.org/abs/2212.10496)).
+- Exploré davantage Cohere et d'autres embedders.
+- Mis en place ColBERT sur les K meilleurs contextes.
+
+---
+
+reste a faire: regler le pb de pickle
+
+replot le graph
+
+test
+
+linter

gossip_semantic_search/constant.py

@@ -0,0 +1,15 @@
+HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
+                  'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+}
+CHANNEL_KEY = "channel"
+ITEM_KEY = "item"
+AUTHOR_KEY = "{http://purl.org/dc/elements/1.1/}creator"
+TITLE_KEY = "title"
+LINK_KEY = "link"
+DESCRIPTION_KEY = "description"
+PUBLICATION_DATE_KEY = "pubDate"
+CONTENT_KEY = "{http://purl.org/rss/1.0/modules/content/}encoded"
+LLAMA_70B_MODEL = "llama3-groq-70b-8192-tool-use-preview"
+EMBEDING_MODEL = "embed-multilingual-v3.0"
+DATE_FORMAT = "%a, %d %b %Y %H:%M:%S %z"

gossip_semantic_search/dataset_creator/__main__.py

@@ -0,0 +1,32 @@
+import sys
+import os
+
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.append(project_root)
+
+import argparse
+
+import yaml
+
+from dataset_creator import DatasetCreator
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--config', type=str, help='Chemin vers le fichier YAML de configuration.', required=True
+    )
+
+    args = parser.parse_args()
+    with open(args.config, 'r') as file:
+        config = yaml.safe_load(file)
+
+    dataset_creator = DatasetCreator(urls=config.get('urls', []),
+                                     save_path=config.get('save_path'),
+                                     number_questions=config.get('number_questions'),
+                                     embed_articles=config.get('embed_articles'))
+    dataset_creator.run()
+
+if __name__ == '__main__':
+    main()
+
+

gossip_semantic_search/dataset_creator/config.yml

@@ -0,0 +1,6 @@
+urls:
+  - "https://www.public.fr/feed"
+  - "https://www.vsd.fr/feed"
+save_path: "datasets/dataset.pkl"
+number_questions: 3
+embed_articles: True

gossip_semantic_search/dataset_creator/dataset_creator.py

@@ -0,0 +1,62 @@
+import pickle
+from typing import List
+from xml.etree.ElementTree import fromstring
+
+import requests
+from tqdm import tqdm
+from groq import Groq
+from cohere import Client
+
+from gossip_semantic_search.constant import HEADERS, CHANNEL_KEY,  ITEM_KEY
+from gossip_semantic_search.utils import (xml_to_dict, article_raw_to_article,
+                                          generates_questions, embed_content)
+from gossip_semantic_search.models import Article
+
+class DatasetCreator:
+    def __init__(self,
+                 urls: List[str],
+                 save_path: str = None,
+                 number_questions:int = 0,
+                 embed_articles: bool = False):
+
+        self.urls = urls
+        self.save_path = save_path
+        self.number_questions = number_questions
+        self.embed_articles = embed_articles
+
+        self.articles: List[Article] = []
+
+    def extract_articles(self):
+        for url in self.urls:
+            response = requests.get(url, headers=HEADERS)
+            xml_string = response.text
+            root = fromstring(xml_string)
+            articles_raw = xml_to_dict(root)[CHANNEL_KEY][ITEM_KEY]
+            self.articles.extend([article_raw_to_article(article_raw)
+                                  for article_raw in articles_raw])
+
+    def save_articles(self):
+        with open(self.save_path, 'wb') as f:
+            pickle.dump(self.articles, f)
+
+    def generate_questions(self):
+        client = Groq()
+        for article in tqdm(self.articles, desc="Generating questions"):
+            article.questions = generates_questions(article.content, self.number_questions, client)
+
+    def embed_article(self):
+        client = Client()
+        for article in tqdm(self.articles, desc="Embedding content"):
+            article.embeded_content = embed_content([article.content], client)[0, :]
+
+    def run(self):
+        self.extract_articles()
+
+        if self.number_questions:
+            self.generate_questions()
+
+        if self.embed_articles:
+            self.embed_article()
+
+        if self.articles:
+            self.save_articles()

gossip_semantic_search/dataset_processor/__main__.py

@@ -0,0 +1,30 @@
+import sys
+import os
+
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.append(project_root)
+print(project_root)
+
+import argparse
+
+import yaml
+
+from dataset_processor import DatasetProcessor
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--config', type=str, help='Chemin vers le fichier YAML de configuration.', required=True
+    )
+
+    args = parser.parse_args()
+    with open(args.config, 'r') as file:
+        config = yaml.safe_load(file)
+
+    dataset_processor = DatasetProcessor(
+        dataset_path=config.get('dataset_path'),
+        saved_processed_dataset_path=config.get('saved_processed_dataset_path'))
+    dataset_processor.run()
+
+if __name__ == '__main__':
+    main()

gossip_semantic_search/dataset_processor/config.yml

@@ -0,0 +1,2 @@
+dataset_path: "datasets/dataset.pkl"
+saved_processed_dataset_path: "datasets/processed_dataset.pkl"

gossip_semantic_search/dataset_processor/dataset_processor.py

@@ -0,0 +1,51 @@
+from pickle import dump
+from typing import List
+
+from cohere import Client
+from numpy import array
+
+from gossip_semantic_search.models import Article, ProcessedDataset
+from gossip_semantic_search.utils import embed_content, CustomUnpickler
+
+
+class DatasetProcessor:
+    def __init__(self,
+                 dataset_path: str,
+                 saved_processed_dataset_path: str):
+        self.dataset_path = dataset_path
+        self.saved_processed_dataset_path = saved_processed_dataset_path
+
+        self.processed_dataset: ProcessedDataset = None
+
+    @staticmethod
+    def load_dataset(dataset_path: str) -> List[Article]:
+        with open(dataset_path, 'rb') as file:
+            unpickler = CustomUnpickler(file)
+            data = unpickler.load()
+        return data
+
+
+    def process_dataset(self,
+                        data: List[Article]):
+        client = Client()
+
+        y_true = []
+        questions = []
+        for i, sample in enumerate(data):
+            for question in sample.questions:
+                y_true.append(i)
+                questions.append(question)
+
+        self.processed_dataset = ProcessedDataset(
+            y_true = array(y_true),
+            embedded_queries=embed_content(questions, client),
+            embedded_context=array([sample.embeded_content for sample in data]))
+
+    def save_articles(self):
+        with open(self.saved_processed_dataset_path, 'wb') as f:
+            dump(self.processed_dataset, f)
+
+    def run(self):
+        data = self.load_dataset(self.dataset_path)
+        self.process_dataset(data)
+        self.save_articles()

gossip_semantic_search/evaluator/__main__.py

@@ -0,0 +1,30 @@
+import sys
+import os
+
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.append(project_root)
+
+import argparse
+
+import yaml
+
+from evaluator import Evaluator
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', type=str, help='Chemin vers le fichier YAML de configuration.', required=True)
+
+    args = parser.parse_args()
+    with open(args.config, 'r') as file:
+        config = yaml.safe_load(file)
+
+    evaluator = Evaluator(
+        processed_dataset_path=config.get('processed_dataset_path'),
+        k_max=config.get('k_max'),
+        path_k_plot=config.get('path_k_plot'),
+    )
+    evaluator.run()
+
+if __name__ == '__main__':
+    main()
+

gossip_semantic_search/evaluator/config.yml

@@ -0,0 +1,3 @@
+processed_dataset_path: "datasets/processed_dataset.pkl"
+k_max: 6
+path_k_plot: "gossip_semantic_search/evaluator/k_plot_graph.png"

gossip_semantic_search/evaluator/evaluator.py

@@ -0,0 +1,53 @@
+from pickle import dump, load
+
+from numpy import argsort, dot, array, any, isin
+from matplotlib import pyplot as plt
+from gossip_semantic_search.models import ProcessedDataset
+from gossip_semantic_search.utils import CustomUnpickler
+
+
+class Evaluator:
+    def __init__(self,
+                 processed_dataset_path: str,
+                 k_max:int = None,
+                 path_k_plot:str = None):
+
+        self.processed_dataset_path = processed_dataset_path
+        self.k_max = k_max
+        self.path_k_plot = path_k_plot
+
+        self.processed_dataset: ProcessedDataset = None
+
+    def load_dataset(self):
+        with open(self.processed_dataset_path, 'rb') as file:
+            unpickler = CustomUnpickler(file)
+            return unpickler.load()
+
+    def evaluate_k_context(self,
+                           k:int) -> float:
+        similarity_matrix = dot(self.processed_dataset.embedded_queries, self.processed_dataset.embedded_context.T)
+        k_best_context = argsort(similarity_matrix, axis=1)[:, -k:][:, ::-1]
+        result = array([1 if any(isin(row, val)) else 0
+                        for row, val in zip(self.processed_dataset.y_true, k_best_context)])
+        return result.mean()
+
+    def plot_top_k_graph(self):
+        accuracies = []
+        for k in range(1, self.k_max):
+            accuracies.append(self.evaluate_k_context(k))
+        plt.plot(accuracies, marker='o', color='b', linestyle='-', markersize=8, linewidth=2)
+
+        # Personnalisation du graphique
+        plt.title("Taux de contextes corrects parmi les k meilleurs contextes", fontsize=14, fontweight='bold')
+        plt.xlabel("k", fontsize=12)
+        plt.ylabel("Accuracy", fontsize=12)
+        plt.grid(True, which='both', linestyle='--', linewidth=0.5)
+        plt.xticks(fontsize=10)
+        plt.yticks(fontsize=10)
+        plt.legend()
+        plt.savefig(self.path_k_plot)
+
+    def run(self):
+        self.processed_dataset = self.load_dataset()
+        if self.k_max:
+            self.plot_top_k_graph()

gossip_semantic_search/front/app.py

@@ -0,0 +1,42 @@
+import sys
+import os
+
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.append(project_root)
+
+import gradio as gr
+from cohere import Client
+from groq import Groq
+from predictor import Predictor
+
+COHERE_API_KEY="8hr6huyTDgAnbbU3WU4mnXTovfa2dwIeV0kc5Uf5"
+GROQ_API_KEY="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"
+
+def main():
+    embeding_client = Client(api_key=COHERE_API_KEY)
+    gen_client = Groq(api_key=GROQ_API_KEY)
+
+    predictor = Predictor(dataset_path="datasets/dataset.pkl",
+                          embeding_client=embeding_client,
+                          QA_boosted=True,
+                          generative_client=gen_client,)
+    predictor.setup()
+
+    def make_prediction(query):
+        answer = predictor.make_prediction(query)
+        return answer.answer, answer.link, answer.content
+
+    iface = gr.Interface(
+        fn=make_prediction,
+        inputs=gr.Textbox(label="query", value="Alain Delon connait-il Anne-Elisabeth Lemoine?"),
+        outputs=[gr.Textbox(label="reponse"),
+                 gr.Textbox(label="link"),
+                 gr.Textbox(label="context")],
+        title="Gossip answering",
+        description="Poser une question Gossip, peut-etre y'aura t'il la reponse"
+    )
+
+    iface.launch()
+
+if __name__ == '__main__':
+    main()

gossip_semantic_search/front/predictor.py

@@ -0,0 +1,57 @@
+from typing import List
+
+from cohere import Client
+from groq import Groq
+from numpy import array, argsort, dot
+from numpy.typing import NDArray
+
+from gossip_semantic_search.models import Article, Answer
+from gossip_semantic_search.utils import (CustomUnpickler, embed_content,
+                                          choose_context_and_answer_questions)
+
+
+class Predictor:
+    def __init__(self,
+                 dataset_path:str,
+                 embeding_client: Client,
+                 QA_boosted: bool = False,
+                 generative_client: Groq = None):
+        self.dataset_path = dataset_path
+        self.embeding_client = embeding_client
+        self.generative_client = generative_client
+        self.QA_boosted = QA_boosted
+
+        self.dataset: List[Article] = []
+        self.embeded_contents: NDArray
+
+    @staticmethod
+    def load_dataset(dataset_path: str) -> List[Article]:
+        with open(dataset_path, 'rb') as file:
+            unpickler = CustomUnpickler(file)
+            data = unpickler.load()
+        return data
+
+    def setup(self):
+        self.dataset = self.load_dataset(self.dataset_path)
+        self.embeded_contents = array([sample.embeded_content for sample in self.dataset])
+
+    def make_prediction(self,
+                        query:str) -> Answer :
+        embeded_query = embed_content([query], self.embeding_client)
+        similarity_vector = dot(embeded_query, self.embeded_contents.T)
+        k_best_article_index = argsort(similarity_vector, axis=1)[:, -3:][:, ::-1]
+
+        if self.QA_boosted:
+            k_best_article = [self.dataset[k] for k in k_best_article_index[0]]
+            return choose_context_and_answer_questions(
+                k_best_article,
+                query,
+                self.generative_client
+            )
+
+        best_article = self.dataset[k_best_article_index[0][0]]
+        return Answer(
+            answer = "pas de reponse, activer QA_boosted pour générer des reponses",
+            link = f"{best_article.link}",
+            content = f"{best_article.content}"
+        )

gossip_semantic_search/models.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+
+from datetime import datetime
+from numpy.typing import NDArray
+
+@dataclass
+class Article:
+    author: str
+    title: str
+    link: str
+    description: str
+    published_date: datetime
+    content: str
+    embeded_content: NDArray = None
+    questions: list[str] = None
+
+@dataclass
+class Answer:
+    link: str
+    content: str
+    answer: str
+
+@dataclass
+class ProcessedDataset:
+    y_true: NDArray[int]
+    embedded_queries: NDArray[float]
+    embedded_context: NDArray[float]

gossip_semantic_search/prompts.py

@@ -0,0 +1,17 @@
+def generate_question_prompt(context, nb_questions):
+    return(f"À partir du contexte suivant : '{context}',"
+           f" \n générez {nb_questions} questions pertinentes en français qui pourraient "
+           f"être posées en lien avec ce contexte.\n"
+           f"Les questions devront avoir la forme :\n" +
+           "\n".join([f"{i + 1}. ceci est-il une question {i + 1}?" for i in range(nb_questions)]))
+
+
+def generate_context_retriver_prompt(query, context):
+    return(f"je vais te donner 1 texte et une question, tu devras me dire si la reponse est dans le texte "
+           f"et si elle y est, me générer une reponse. \n"
+           f"voici la question: {query} \n "
+           f"voici le texte: {context} \n "
+           f"si la reponse est dans le texte ta reponse doit avor la forme suivante: \n "
+           f" (answer_in_text=True, answer='La réponse généré')"
+           f"si la reponse n'est pas dans le texte ta reponse doit avor la forme suivante:"
+           f" (answer_in_text=False, answer=None)")

gossip_semantic_search/utils.py

@@ -0,0 +1,160 @@
+from datetime import datetime
+import warnings
+from typing import List
+from pickle import Unpickler
+import re
+
+from bs4 import BeautifulSoup
+from groq import Groq
+from cohere import Client
+from numpy.typing import NDArray
+from numpy import array
+
+from gossip_semantic_search.models import Article, Answer
+from gossip_semantic_search.constant import (AUTHOR_KEY, TITLE_KEY, LINK_KEY, DESCRIPTION_KEY,
+                                             PUBLICATION_DATE_KEY, CONTENT_KEY, LLAMA_70B_MODEL,
+                                             DATE_FORMAT, EMBEDING_MODEL)
+from gossip_semantic_search.prompts import (generate_question_prompt,
+                                            generate_context_retriver_prompt)
+
+
+def xml_to_dict(element):
+    result = {}
+
+    for child in element:
+        child_dict = xml_to_dict(child)
+        if child.tag in result:
+            if isinstance(result[child.tag], list):
+                result[child.tag].append(child_dict)
+            else:
+                result[child.tag] = [result[child.tag], child_dict]
+        else:
+            result[child.tag] = child_dict
+
+    if element.text and element.text.strip():
+        result = element.text.strip()
+
+    return result
+
+
+def sanitize_html_content(html_content):
+    soup = BeautifulSoup(html_content, 'html.parser')
+
+    for a in soup.find_all('a'):
+        a.unwrap()
+
+    for tag in soup.find_all(['em', 'strong']):
+        tag.unwrap()
+
+    for blockquote in soup.find_all('blockquote'):
+        blockquote.extract()
+
+    cleaned_text = re.sub(r'\s+', ' ', soup.get_text()).strip()
+    return cleaned_text
+
+def article_raw_to_article(raw_article) -> Article:
+    return Article(
+        author = raw_article[AUTHOR_KEY],
+        title = raw_article[TITLE_KEY],
+        link = raw_article[LINK_KEY],
+        description = raw_article[DESCRIPTION_KEY],
+        published_date = datetime.strptime(
+            raw_article[PUBLICATION_DATE_KEY],
+            DATE_FORMAT
+        ),
+        content = sanitize_html_content(raw_article[CONTENT_KEY])
+    )
+
+def generates_questions(context: str,
+                        nb_questions: int,
+                        client: Groq) -> List[str]:
+    completion = client.chat.completions.create(
+        model=LLAMA_70B_MODEL,
+        messages=[
+            {
+                "role": "user",
+                "content": generate_question_prompt(context, nb_questions)
+            },
+        ],
+        temperature=1,
+        max_tokens=1024,
+        top_p=1,
+        stream=True,
+        stop=None,
+    )
+    questions_str = "".join(chunk.choices[0].delta.content or "" for chunk in completion)
+
+    try:
+        questions = re.findall(r'([^?]*\?)', questions_str)
+        questions = [question.strip()[3:] for question in questions]
+
+    except IndexError:
+        warnings.warn(f"no question found. \n"
+                      f"string return: {questions_str}")
+        return []
+
+    if len(questions) != nb_questions:
+        warnings.warn(f"Expected {nb_questions} questions, but found "
+                      f"{len(questions)}. {', '.join(questions)}", UserWarning)
+
+    return questions
+
+def choose_context_and_answer_questions(articles: List[Article],
+                                        query:str,
+                                        generative_client) -> Answer:
+    for article in articles:
+        completion = generative_client.chat.completions.create(
+            model=LLAMA_70B_MODEL,
+            messages=[
+                {
+                    "role": "user",
+                    "content": generate_context_retriver_prompt(query, article.content)
+                },
+            ],
+            temperature=1,
+            max_tokens=1024,
+            top_p=1,
+            stream=True,
+            stop=None,
+        )
+        answer = "".join(chunk.choices[0].delta.content or "" for chunk in completion)
+        pattern = r"answer_in_text\s*=\s*(.*?),"
+
+        # Appliquer la regex
+        match = re.search(pattern, answer)
+        if match:
+            if match.group(1) == "True":
+                pattern = r"answer\s*=\s*(.*)"
+                match = re.search(pattern, answer)
+                if match:
+                    answer_value = match.group(1)[1:-2]
+                    return Answer(
+                            answer = answer_value,
+                            link = f"{article.link}",
+                            content = f"{article.content}"
+                        )
+
+    return Answer(
+        answer = "incapable de générer une reponse",
+        link = f"{articles[0].link}",
+        content = f"{articles[0].content}"
+    )
+
+
+def embed_content(contexts:List[str],
+                  client: Client) -> NDArray:
+    return array(client.embed(
+        model=EMBEDING_MODEL,
+        texts=contexts,
+        input_type='classification',
+        truncate='NONE'
+    ).embeddings)
+
+class CustomUnpickler(Unpickler):
+    def find_class(self, module, name):
+        if module == 'models':
+            return Article  # Renvoie une classe de remplacement
+        return super().find_class(module, name)
+
+
+

requirements.txt

@@ -0,0 +1,9 @@
+beautifulsoup4
+cohere
+gradio
+groq
+matplotlib
+numpy
+pylint
+requests
+tqdm