瀏覽代碼

modules principaux d'assistant ai sur le wiki

Nadine Elleuch 1 年之前
父節點
當前提交
91d562c5e3
共有 6 個文件被更改,包括 335 次插入 和 0 次删除
  1. 43 0
      auth.py
  2. 59 0
      chunking.py
  3. 32 0
      embedding_index.py
  4. 135 0
      main.py
  5. 30 0
      qa_chain.py
  6. 36 0
      scraping.py

+ 43 - 0
auth.py

@@ -0,0 +1,43 @@
+"""
+auth.py 
+
+Gestion de l’authentification sur le wiki Intersel
+
+Ce module permet de se connecter au wiki en utilisant une session HTTP persistante et il récupère tout seul un code spécial (le token CSRF) nécessaire pour se connecter en toute sécurité
+"""
+
+import requests
+from bs4 import BeautifulSoup
+
+session = requests.Session()
+
+def login_to_wiki(username, password):
+    login_url = "https://wiki.intersel.fr/doku.php?id=start&do=login"
+    resp = session.get(login_url)
+    soup = BeautifulSoup(resp.text, "html.parser")
+    sectok_input = soup.find("input", {"name": "sectok"})
+
+    if not sectok_input:
+        print("❌ Impossible de trouver le token CSRF.")
+        return False
+
+    login_data = {
+        "u": username,
+        "p": password,
+        "do": "login",
+        "sectok": sectok_input.get("value")
+    }
+
+    headers = {
+        "User-Agent": "Mozilla/5.0",
+        "Referer": login_url
+    }
+
+    login_resp = session.post(login_url, data=login_data, headers=headers)
+
+    if "logout" in login_resp.text.lower():
+        print("✅ Connexion réussie.")
+        return True
+    else:
+        print("❌ Échec de la connexion.")
+        return False

+ 59 - 0
chunking.py

@@ -0,0 +1,59 @@
+"""
+chunking.py 
+
+Ce module permet de regrouper des phrases qui parlent de la même chose
+Il utilise un modèle pour comprendre le sens des phrases et décide quelles phrases doivent être mises ensemble
+À la fin, il crée des blocs de texte (chunks) qui sont assez longs et qui parlent d’un seul sujet
+Ça aide à organiser le texte en morceaux faciles à lire et à analyser
+"""
+
+import nltk
+from sklearn.metrics.pairwise import cosine_similarity
+from sentence_transformers import SentenceTransformer
+
+# pour la tokenisation des phrases
+nltk.download('punkt')
+
+# model pour générer des embeddings
+model = SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
+
+MIN_WORDS_PER_CHUNK = 20
+
+"""
+Découpe une liste de phrases en "chunks" (groupes de phrases) basés sur la similarité sémantique.
+L'idée est de regrouper ensemble des phrases qui parlent d'un même sujet ou thème.
+"""
+def semantic_chunking(sentences, similarity_threshold=0.5):
+    chunks = []            # Liste finale des chunks
+    current_chunk = []     # Liste des phrases du chunk courant
+    current_embeddings = [] # Embeddings des phrases du chunk courant pour calculer la similarité
+
+    for sentence in sentences:
+        # Générer l'embedding de la phrase actuelle
+        embedding = model.encode(sentence)
+        if not current_embeddings:
+            current_chunk.append(sentence)
+            current_embeddings.append(embedding)
+        else:
+            # Calculer la similarité entre la phrase actuelle et toutes les phrases déjà dans le chunk courant
+            similarities = cosine_similarity([embedding], current_embeddings)[0]
+            # Si la similarité max est supérieure au seuil on considère que la phrase fait partie du même sujet
+            if max(similarities) > similarity_threshold:
+                current_chunk.append(sentence)
+                current_embeddings.append(embedding)
+            else:
+                # on finalise le chunk courant seulement si il est assez long
+                chunk_text = " ".join(current_chunk)
+                if len(chunk_text.split()) >= MIN_WORDS_PER_CHUNK:
+                    chunks.append(chunk_text)
+                # on démarre un nouveau chunk
+                current_chunk = [sentence]
+                current_embeddings = [embedding]
+
+    # Ajouter le dernier chunk à la fin, s'il est assez long
+    if current_chunk:
+        chunk_text = " ".join(current_chunk)
+        if len(chunk_text.split()) >= MIN_WORDS_PER_CHUNK:
+            chunks.append(chunk_text)
+
+    return chunks

+ 32 - 0
embedding_index.py

@@ -0,0 +1,32 @@
+"""
+Ce module permet de créer et utiliser un index FAISS pour rechercher rapidement des vecteurs similaires
+
+La fonction build_faiss_index construit un index à partir d’une liste de vecteurs (embeddings) en normalisant les vecteurs pour mesurer la similarité par cosinus
+
+La fonction search_faiss cherche les vecteurs les plus proches d’un vecteur donné (requête) et retourne les distances et positions des meilleurs résultats
+
+"""
+
+import numpy as np
+import faiss
+
+"""
+Construire un index FAISS à partir d'une matrice d'embeddings pour pouvoir faire des recherches rapides par similarité
+"""
+def build_faiss_index(embeddings):
+    # Récupère la dimension des vecteurs
+    dimension = embeddings.shape[1]
+    # Crée un index FAISS pour recherche par produit scalaire
+    index = faiss.IndexFlatIP(dimension)
+    # Normalise les vecteurs pour utiliser la similarité cosinus (norme L2 = 1)
+    faiss.normalize_L2(embeddings)
+    index.add(embeddings)
+    return index
+
+"""
+Trouver les top_k vecteurs les plus similaires à un vecteur de requête en utilisant la similarité cosinus
+"""
+def search_faiss(index, query_embedding, top_k=10):
+    faiss.normalize_L2(query_embedding)
+    distances, indices = index.search(query_embedding, top_k)
+    return distances[0], indices[0]

+ 135 - 0
main.py

@@ -0,0 +1,135 @@
+"""
+Programme principal
+"""
+
+import nltk
+import numpy as np
+import pandas as pd
+from sentence_transformers import SentenceTransformer, CrossEncoder
+from auth import login_to_wiki
+from scraping import fetch_all_pages_content
+from chunking import semantic_chunking, model
+from embedding_index import build_faiss_index, search_faiss
+from qa_chain import get_qa_chain
+import getpass
+import warnings 
+warnings.filterwarnings("ignore")
+
+def get_relevance_label(score):
+    if score >= 2.5:
+        return "✅ bon"
+    elif score >= 0:
+        return "⚠️ moyen"
+    else:
+        return "❌ faible"
+
+
+def ask_question_with_reranking(question, model, cross_encoder, index, chunks, chunk_urls, qa_chain, faiss_top_k=30, rerank_top_k=10):
+    question_embedding = model.encode([question], convert_to_tensor=False)
+    question_embedding = np.array(question_embedding).astype('float32')
+    if question_embedding.ndim == 1:
+        question_embedding = np.expand_dims(question_embedding, axis=0)
+
+    distances, indices = search_faiss(index, question_embedding, top_k=faiss_top_k)
+
+    candidates = []
+    for idx, dist in zip(indices, distances):
+        candidates.append({
+            "chunk": chunks[idx],
+            "url": chunk_urls[idx],
+            "index": idx,
+            "faiss_score": float(dist)
+        })
+
+    # Reranking
+    pairs = [[question, c["chunk"]] for c in candidates]
+    rerank_scores = cross_encoder.predict(pairs)
+    for i in range(len(candidates)):
+        candidates[i]["rerank_score"] = float(rerank_scores[i])
+
+    reranked = sorted(candidates, key=lambda x: x["rerank_score"], reverse=True)[:rerank_top_k]
+
+    print("\n🔍 Résultats re-rankés :")
+    df = pd.DataFrame([{
+        "Index": r["index"],
+        "URL": r["url"],
+        "Score CrossEncoder": round(r["rerank_score"], 4),
+        "Chunk": r["chunk"][:100] + "..." if len(r["chunk"]) > 100 else r["chunk"]
+    } for r in reranked])
+    df["Pertinence"] = df["Score CrossEncoder"].apply(get_relevance_label)
+    pd.set_option('display.max_colwidth', None)
+
+    df_reranked = df.copy()  
+
+    # Tableau propre
+    colonnes_a_afficher = ['Index', 'URL', 'Score CrossEncoder', 'Pertinence', 'Chunk']
+    df_affichage = df_reranked[colonnes_a_afficher].copy()
+    df_affichage.reset_index(drop=True, inplace=True)
+
+    print("\n🎯 Résultats re-rankés (top 10) :")
+    print(df_affichage.head(10).to_string(index=True))
+
+    # Si tous les top chunks viennent d'une seule page
+    top_urls = [r["url"] for r in reranked]
+    unique_top_urls = list(set(top_urls))
+
+    if len(unique_top_urls) == 1:
+        print("ℹ️ Tous les meilleurs chunks viennent de la même page. Utilisation de l'ensemble de la page.")
+        full_context = "\n\n".join([
+            chunks[i] for i in range(len(chunks)) if chunk_urls[i] == unique_top_urls[0]
+        ])
+    else:
+        full_context = "\n\n".join([r["chunk"] for r in reranked])
+
+    result = qa_chain.run(context=full_context, question=question)
+    print(f"\n🤖 Réponse :\n{result}\n")
+
+
+
+if __name__ == "__main__":
+    nltk.download('punkt')
+    user = input("Entrez votre nom d'utilisateur : ")
+    pwd = getpass.getpass("Entrez votre mot de passe (entrée masquée) : ")
+    success = login_to_wiki(user, pwd)
+    if success:
+        wiki_urls = [
+            "https://wiki.intersel.fr/doku.php?id=intersel:presentation_equipe",
+            "https://wiki.intersel.fr/doku.php?id=intersel:presentation",
+            "https://wiki.intersel.fr/doku.php?id=intersel:guides:entretiens:stagiaires",
+            "https://wiki.intersel.fr/doku.php?id=projets:samsic:anticipia:start"
+        ]
+
+        url_texts = fetch_all_pages_content(wiki_urls)
+
+        all_chunks = []
+        chunk_urls = []
+
+        for url, text in url_texts.items():
+            print(f"\n--- Traitement de la page {url} ---")
+            sentences = nltk.sent_tokenize(text, language='french')
+            chunks = semantic_chunking(sentences)
+            print(f"Nombre de chunks : {len(chunks)}")
+            for i, chunk in enumerate(chunks):
+                print(f"Chunk {i+1} ({len(chunk.split())} mots): {chunk[:100]}{'...' if len(chunk) > 100 else ''}")
+                all_chunks.append(chunk)
+                chunk_urls.append(url)
+
+        print("\n✅ Génération des embeddings des chunks...")
+        chunk_embeddings = model.encode(all_chunks, convert_to_tensor=False, show_progress_bar=True)
+        chunk_embeddings = np.array(chunk_embeddings).astype('float32')
+
+        print("\n✅ Construction de l'index FAISS...")
+        index = build_faiss_index(chunk_embeddings)
+        print("✅ Index FAISS construit avec succès.")
+
+        cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+        qa_chain = get_qa_chain()
+
+        while True:
+            question = input("❓ Posez votre question sur le Wiki ('exit' pour quitter) :\n> ")
+            if question.lower() in ["exit", "quit"]:
+                break
+            ask_question_with_reranking(
+                question, model, cross_encoder, index,
+                all_chunks, chunk_urls, qa_chain
+            )

+ 30 - 0
qa_chain.py

@@ -0,0 +1,30 @@
+"""
+Ce module crée une chaîne de questions-réponses (Q&A) basée sur un modèle d'IA (llama3)
+Il définit un modèle de question (prompt) que le modèle doit suivre :
+→ Il doit répondre uniquement avec les informations fournies dans le contexte
+→ S’il ne sait pas, il doit dire "Je ne sais pas." et ne rien inventer
+"""
+
+from langchain_community.llms import Ollama
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+prompt_template = PromptTemplate(
+    input_variables=["context", "question"],
+    template="""
+Tu es un assistant expert du wiki interne d'Intersel. Réponds uniquement à partir du CONTEXTE donné. 
+Si aucune information pertinente n'est disponible, dis "Je ne sais pas." sans inventer.
+
+CONTEXTE :
+{context}
+
+QUESTION :
+{question}
+
+RÉPONSE :
+"""
+)
+
+def get_qa_chain():
+    llm = Ollama(model="llama3")
+    return LLMChain(llm=llm, prompt=prompt_template)

+ 36 - 0
scraping.py

@@ -0,0 +1,36 @@
+"""
+scraping.py
+
+Récupération du contenu de plusieurs pages web en accédant à leur mode édition
+
+"""
+
+from bs4 import BeautifulSoup
+from auth import session
+
+"""
+Récupère le contenu de plusieurs pages web en accédant à leur mode édition
+"""
+def fetch_all_pages_content(urls):
+    url_texts = {}
+    for url in urls:
+        try:
+            # modifier l'url pour accéder à la version édition de la page 
+            edit_url = url + "&do=edit" if "?" in url else url + "?do=edit"
+            response = session.get(edit_url)
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.text, "html.parser")
+                # Trouver la balise <textarea name="wikitext">
+                textarea = soup.find("textarea", {"name": "wikitext"})
+                if textarea:
+                    raw_text = textarea.text  # Extraire le contenu texte brut
+                    url_texts[url] = raw_text  # Enregistrer dans le dictionnaire
+                else:
+                    print(f"⚠️ Pas de balise <textarea> trouvée pour {edit_url}.")
+            else:
+                print(f"⚠️ Erreur d'accès à {edit_url} : code {response.status_code}")
+        except Exception as e:
+            print(f"❌ Exception pour {url}: {e}")
+    return url_texts
+
+