Amélioration du chiffon: au-delà des approches de vanille

La génération (RAG) de la récupération (RAG) stimule considérablement les modèles de langage en intégrant la récupération des informations externes. Le chiffon standard, tout en améliorant la pertinence de la réponse, vacille souvent dans des situations de récupération complexes. Cet article examine les lacunes du chiffon de base et présente des méthodes avancées pour améliorer la précision et l'efficacité.

Limites du chiffon de base

Considérez un scénario simple: récupérer les informations pertinentes à partir de plusieurs documents. Notre ensemble de données comprend:

• un document principal détaillant les pratiques de style de vie saines et productives.
• Deux documents non liés contenant des mots clés qui se chevauchent, mais dans des contextes différents.

<code>main_document_text = """
Morning Routine (5:30 AM - 9:00 AM)
✅ Wake Up Early - Aim for 6-8 hours of sleep to feel well-rested.
✅ Hydrate First - Drink a glass of water to rehydrate your body.
✅ Morning Stretch or Light Exercise - Do 5-10 minutes of stretching or a short workout to activate your body.
✅ Mindfulness or Meditation - Spend 5-10 minutes practicing mindfulness or deep breathing.
✅ Healthy Breakfast - Eat a balanced meal with protein, healthy fats, and fiber.
✅ Plan Your Day - Set goals, review your schedule, and prioritize tasks.
...
"""</code>

un système de chiffon de base, lorsqu'il est interrogé avec:

1. Comment puis-je améliorer ma santé et ma productivité?
2. Quelles sont les meilleures stratégies pour un mode de vie sain et productif?

peut avoir du mal à récupérer systématiquement le document principal en raison de la présence de mots similaires dans des documents non liés.

Fonctions d'assistance: rationalisation du pipeline de chiffon

Pour améliorer la précision de la récupération et simplifier le traitement des requêtes, nous introduisons les fonctions d'assistance. Ces fonctions gèrent les tâches telles que l'interrogation de l'API ChatGPT, le calcul des intégres de documents et la détermination des scores de similitude. Cela crée un pipeline de chiffon plus efficace.

Voici les fonctions d'assistance:

<code># **Imports**
import os
import json
import openai
import numpy as np
from scipy.spatial.distance import cosine
from google.colab import userdata

# Set up OpenAI API key
os.environ["OPENAI_API_KEY"] = userdata.get('AiTeam')</code>

<code>def query_chatgpt(prompt, model="gpt-4o", response_format=openai.NOT_GIVEN):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": prompt}],
            temperature=0.0 , # Adjust for more or less creativity
            response_format=response_format
        )
        return response.choices[0].message.content.strip()
    except Exception as e:
        return f"Error: {e}"</code>

<code>def get_embedding(text, model="text-embedding-3-large"): #"text-embedding-ada-002"
    """Fetches the embedding for a given text using OpenAI's API."""
    response = client.embeddings.create(
        input=[text],
        model=model
    )
    return response.data[0].embedding</code>

<code>def compute_similarity_metrics(embed1, embed2):
    """Computes different similarity/distance metrics between two embeddings."""
    cosine_sim = 1- cosine(embed1, embed2)  # Cosine similarity

    return cosine_sim</code>

<code>def fetch_similar_docs(query, docs, threshold = .55, top=1):
  query_em = get_embedding(query)
  data = []
  for d in docs:
    # Compute and print similarity metrics
    similarity_results = compute_similarity_metrics(d["embedding"], query_em)
    if(similarity_results >= threshold):
      data.append({"id":d["id"], "ref_doc":d.get("ref_doc", ""), "score":similarity_results})

  # Sorting by value (second element in each tuple)
  sorted_data = sorted(data, key=lambda x: x["score"], reverse=True)  # Ascending order
  sorted_data = sorted_data[:min(top, len(sorted_data))]
  return sorted_data</code>

Évaluation de Rag de base

Nous testons le chiffon de base en utilisant des requêtes prédéfinies pour évaluer sa capacité à récupérer le document le plus pertinent en fonction de la similitude sémantique. Cela met en évidence ses limites.

<code>"""# **Testing Vanilla RAG**"""

query = "what should I do to stay healthy and productive?"
r = fetch_similar_docs(query, docs)
print("query = ", query)
print("documents = ", r)

query = "what are the best practices to stay healthy and productive ?"
r = fetch_similar_docs(query, docs)
print("query = ", query)
print("documents = ", r)</code>

Techniques avancées pour un chiffon amélioré

Pour améliorer le processus de récupération, nous introduisons des fonctions qui génèrent des informations structurées pour améliorer la récupération des documents et le traitement des requêtes.

Trois améliorations de clés sont implémentées:

1. Génération de FAQ

La création de FAQ à partir du document étend les possibilités de correspondance de requête. Ces FAQ sont générées une fois et stockées, enrichissant l'espace de recherche sans coûts récurrents.

<code>def generate_faq(text):
  prompt = f'''
  given the following text: """{text}"""
  Ask relevant simple atomic questions ONLY (don't answer them) to cover all subjects covered by the text. Return the result as a json list example [q1, q2, q3...]
  '''
  return query_chatgpt(prompt, response_format={ "type": "json_object" })</code>

2. Création d'un aperçu

Un résumé concis capture les idées de base du document, améliorant l'efficacité de la récupération. L'intégration de la vue d'ensemble est ajoutée à la collection de documents.

<code>def generate_overview(text):
  prompt = f'''
  given the following text: """{text}"""
  Generate an abstract for it that tells in maximum 3 lines what is it about and use high level terms that will capture the main points,
  Use terms and words that will be most likely used by average person.
  '''
  return query_chatgpt(prompt)</code>

3. Décomposition de requête

Les requêtes larges sont décomposées en sous-questions plus petites et plus précises. Ces sous-requêtes sont comparées à la collection de documents améliorée (document d'origine, FAQ et aperçu). Les résultats sont fusionnés pour une pertinence améliorée.

<code>main_document_text = """
Morning Routine (5:30 AM - 9:00 AM)
✅ Wake Up Early - Aim for 6-8 hours of sleep to feel well-rested.
✅ Hydrate First - Drink a glass of water to rehydrate your body.
✅ Morning Stretch or Light Exercise - Do 5-10 minutes of stretching or a short workout to activate your body.
✅ Mindfulness or Meditation - Spend 5-10 minutes practicing mindfulness or deep breathing.
✅ Healthy Breakfast - Eat a balanced meal with protein, healthy fats, and fiber.
✅ Plan Your Day - Set goals, review your schedule, and prioritize tasks.
...
"""</code>

Évaluation du chiffon amélioré

La réévaluation des requêtes initiales avec ces améliorations montre une amélioration significative. La décomposition des requêtes génère plusieurs sous-questions, conduisant à une récupération réussie à la fois des FAQ et du document d'origine.

<code># **Imports**
import os
import json
import openai
import numpy as np
from scipy.spatial.distance import cosine
from google.colab import userdata

# Set up OpenAI API key
os.environ["OPENAI_API_KEY"] = userdata.get('AiTeam')</code>

Exemple de sortie FAQ:

<code>def query_chatgpt(prompt, model="gpt-4o", response_format=openai.NOT_GIVEN):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": prompt}],
            temperature=0.0 , # Adjust for more or less creativity
            response_format=response_format
        )
        return response.choices[0].message.content.strip()
    except Exception as e:
        return f"Error: {e}"</code>

Analyse coûts-avantages

Alors que le prétraitement (génération de FAQ, des aperçus et des intégres) ajoute un coût initial, c'est un coût unique par document. Cela compense les inefficacités d'un système de chiffon mal optimisé: les utilisateurs frustrés et l'augmentation des coûts de requête en récupérant des informations non pertinentes. Pour les systèmes à volume élevé, le prétraitement est un investissement valable.

Conclusion

La combinaison du prétraitement des documents (FAQ et aperçus) avec décomposition des requêtes crée un système de chiffon plus intelligent qui équilibre la précision et la rentabilité. Cela améliore la qualité de récupération, réduit les résultats non pertinents et améliore l'expérience utilisateur. Les recherches futures peuvent explorer d'autres optimisations telles que le seuil dynamique et l'apprentissage du renforcement pour le raffinement des requêtes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!