DSPy and Zilliz Cloud Integration

DSPy, introduit par le Stanford NLP Group, est un framework programmatique révolutionnaire conçu pour optimiser les prompts et les poids au sein des modèles de langage, particulièrement précieux dans les scénarios où de grands modèles de langage (LLM) sont intégrés à plusieurs étapes d’un pipeline. Contrairement aux techniques conventionnelles d’ingénierie des prompts qui reposent sur une élaboration et des ajustements manuels, DSPy adopte une approche fondée sur l’apprentissage. En assimilant des exemples de questions-réponses, DSPy génère dynamiquement des prompts optimisés, adaptés à des tâches spécifiques. Cette méthodologie innovante permet le réassemblage fluide de pipelines entiers, éliminant la nécessité d’ajustements manuels continus des prompts. La syntaxe Pythonic de DSPy offre divers modules composables et déclaratifs, simplifiant l’instruction des LLMs.

En s’intégrant à Zilliz Cloud (Milvus entièrement géré), DSPy accède à une base de données vectorielle entièrement gérée via le module de récupération MilvusRM, permettant aux développeurs de définir et d’optimiser facilement des programmes RAG tout en tirant parti des solides capacités de recherche vectorielle de Milvus pour une récupération efficace et évolutive.

• Implémentation et configuration RAG simplifiées : L’intégration rationalise la mise en place du pipeline RAG en automatisant programmatiquement l’optimisation de la récupération vectorielle, la conception des prompts et l’affinage des LLM, réduisant ainsi les besoins d’ajustements manuels.
• Performances et évolutivité RAG améliorées : Zilliz Cloud fournit Milvus managé haute performance, garantissant une gestion efficace des opérations de récupération de données à grande échelle et rendant les applications plus robustes et capables de gérer des ensembles de données volumineux.
• Optimisation programmatique des prompts : L’approche basée sur l’apprentissage de DSPy génère dynamiquement des prompts optimisés adaptés à des tâches spécifiques, éliminant la méthode par tâtonnements des modèles de prompts traditionnels et améliorant considérablement la qualité des réponses.
• Abstraction modularisée : DSPy abstrait efficacement les aspects complexes du développement de pipelines LM tels que la décomposition, l’affinage et la sélection de modèles, tandis que Zilliz Cloud gère de manière transparente la couche de stockage et de récupération vectoriels.

DSPy fournit un framework programmatique pour créer des pipelines LLM à l’aide de modules composables et déclaratifs. Il offre des Signatures pour définir le comportement d’entrée/sortie, des Modules pour abstraire des techniques de prompting comme la chaîne de pensée ou ReAct, et des Optimizers pour affiner des paramètres tels que les prompts et les poids LLM afin de maximiser des métriques spécifiées comme la précision.

Zilliz Cloud sert de couche de base de données vectorielle via le module de récupération MilvusRM dans DSPy, en stockant et en indexant les embeddings de documents pour une recherche rapide par similarité. Il permet au pipeline RAG de récupérer efficacement le contexte le plus pertinent à partir de vastes bases de connaissances.

Ensemble, DSPy et Zilliz Cloud créent une solution RAG optimisée automatiquement : les données sont ingérées et intégrées dans Zilliz Cloud, MilvusRM de DSPy récupère le contexte pertinent grâce à la recherche par similarité vectorielle, et les optimiseurs du framework affinent itérativement les prompts et les paramètres pour améliorer la qualité des réponses — le tout avec une intervention manuelle minimale.

1. Installer les dépendances

Installez DSPy avec la prise en charge de Milvus et PyMilvus :

$ pip install "dspy-ai[milvus]"
$ pip install -U pymilvus

2. Charger le jeu de données

Utilisez le jeu de données HotPotQA, une collection de paires question-réponse complexes, comme jeu de données d’entraînement :

from dspy.datasets import HotPotQA

# Load the dataset.
dataset = HotPotQA(
    train_seed=1, train_size=20, eval_seed=2023, dev_size=50, test_size=0
)

# Tell DSPy that the 'question' field is the input. Any other fields are labels and/or metadata.
trainset = [x.with_inputs("question") for x in dataset.train]
devset = [x.with_inputs("question") for x in dataset.dev]

3. Ingérer les données dans la base de données vectorielle Milvus

Ingérez les informations de contexte dans la collection Milvus pour la récupération vectorielle. Cette collection doit avoir un champ embedding et un champ text. Nous utilisons le modèle text-embedding-3-small d’OpenAI comme fonction d’embedding de requête par défaut dans ce cas.

import requests
import os

os.environ["OPENAI_API_KEY"] = "<YOUR_OPENAI_API_KEY>"
MILVUS_URI = "example.db"
MILVUS_TOKEN = ""

from pymilvus import MilvusClient, DataType, Collection
from dspy.retrieve.milvus_rm import openai_embedding_function

client = MilvusClient(uri=MILVUS_URI, token=MILVUS_TOKEN)

if "dspy_example" not in client.list_collections():
    client.create_collection(
        collection_name="dspy_example",
        overwrite=True,
        dimension=1536,
        primary_field_name="id",
        vector_field_name="embedding",
        id_type="int",
        metric_type="IP",
        max_length=65535,
        enable_dynamic=True,
    )
text = requests.get(
    "https://raw.githubusercontent.com/wxywb/dspy_dataset_sample/master/sample_data.txt"
).text

for idx, passage in enumerate(text.split("\n")):
    if len(passage) == 0:
        continue
    client.insert(
        collection_name="dspy_example",
        data=[
            {
                "id": idx,
                "embedding": openai_embedding_function(passage)[0],
                "text": passage,
            }
        ],
    )

4. Définir MilvusRM et configurer DSPy

Définissez le module de récupération MilvusRM et configurez DSPy avec le modèle de langage :

from dspy.retrieve.milvus_rm import MilvusRM
import dspy

retriever_model = MilvusRM(
    collection_name="dspy_example",
    uri=MILVUS_URI,
    token=MILVUS_TOKEN,  # ignore this if no token is required for Milvus connection
    embedding_function=openai_embedding_function,
)
turbo = dspy.OpenAI(model="gpt-3.5-turbo")
dspy.settings.configure(lm=turbo)

5. Créer les signatures et le pipeline RAG

Définissez la signature pour la tâche et créez le module de pipeline RAG :

class GenerateAnswer(dspy.Signature):
    """Answer questions with short factoid answers."""

    context = dspy.InputField(desc="may contain relevant facts")
    question = dspy.InputField()
    answer = dspy.OutputField(desc="often between 1 and 5 words")

class RAG(dspy.Module):
    def __init__(self, rm):
        super().__init__()
        self.retrieve = rm
        self.generate_answer = dspy.ChainOfThought(GenerateAnswer)

    def forward(self, question):
        context = self.retrieve(question).passages
        prediction = self.generate_answer(context=context, question=question)
        return dspy.Prediction(
            context=[item.long_text for item in context], answer=prediction.answer
        )

6. Exécuter le pipeline et obtenir les résultats

Essayez le pipeline RAG et évaluez les résultats :

rag = RAG(retriever_model)
print(rag("who write At My Window").answer)

Évaluez les résultats quantitatifs sur le jeu de données :

from dspy.evaluate.evaluate import Evaluate

evaluate_on_hotpotqa = Evaluate(
    devset=devset, num_threads=1, display_progress=False, display_table=5
)

metric = dspy.evaluate.answer_exact_match
score = evaluate_on_hotpotqa(rag, metric=metric)
print("rag:", score)

7. Optimiser le pipeline

Compilez le programme pour mettre à jour les paramètres au sein de chaque module et améliorer les performances :

from dspy.teleprompt import BootstrapFewShot

def validate_context_and_answer(example, pred, trace=None):
    answer_EM = dspy.evaluate.answer_exact_match(example, pred)
    answer_PM = dspy.evaluate.answer_passage_match(example, pred)
    return answer_EM and answer_PM

teleprompter = BootstrapFewShot(metric=validate_context_and_answer)

# Compile!
compiled_rag = teleprompter.compile(rag, trainset=trainset)

# Evaluate the compiled RAG program.
score = evaluate_on_hotpotqa(compiled_rag, metric=metric)
print("compile_rag:", score)

Le score Ragas est passé de sa valeur précédente de 50,0 à 52,0, indiquant une amélioration de la qualité des réponses.

• Intégrer Milvus avec DSPy — Tutoriel officiel de Milvus pour l’intégration avec DSPy
• Explorer DSPy et son intégration avec Milvus pour créer des pipelines RAG hautement efficaces — Blog de Zilliz sur l’intégration de DSPy et Milvus
• Créer un RAG avec Llama3, Ollama, DSPy et Milvus — Tutoriel Zilliz sur la création d’un RAG avec DSPy
• Dépôt GitHub de DSPy — Code source officiel de DSPy
• Dépôt GitHub de Milvus — Code source officiel de Milvus