Mengintegrasikan Milvus dengan DSPy

Apa itu DSPy

DSPy, yang diperkenalkan oleh Stanford NLP Group, merupakan kerangka kerja terobosan yang dirancang untuk mengoptimalkan permintaan dan bobot dalam model bahasa, terutama yang sangat berguna dalam skenario di mana model bahasa besar (LLM) diintegrasikan di berbagai tahap pipeline. Tidak seperti teknik rekayasa prompting konvensional yang bergantung pada pembuatan dan penyesuaian manual, DSPy mengadopsi pendekatan berbasis pembelajaran. Dengan mengasimilasi contoh-contoh pertanyaan-jawaban, DSPy menghasilkan prompt yang dioptimalkan secara dinamis, disesuaikan dengan tugas-tugas tertentu. Metodologi inovatif ini memungkinkan pemasangan kembali seluruh pipeline tanpa hambatan, sehingga tidak perlu lagi melakukan penyesuaian prompt secara manual. Sintaks Python DSPy menawarkan berbagai modul yang dapat dikomposisikan dan deklaratif, menyederhanakan instruksi LLM.

Manfaat menggunakan DSPy

• Pendekatan Pemrograman: DSPy menyediakan pendekatan pemrograman sistematis untuk pengembangan pipeline LM dengan mengabstraksikan pipeline sebagai grafik transformasi teks, bukan hanya memerintahkan LLM. Modul deklaratifnya memungkinkan desain dan pengoptimalan terstruktur, menggantikan metode coba-coba pada templat prompt tradisional.
• Peningkatan Kinerja: DSPy menunjukkan peningkatan kinerja yang signifikan dibandingkan metode yang ada. Melalui studi kasus, DSPy mengungguli prompt standar dan demonstrasi yang dibuat oleh para ahli, menunjukkan keserbagunaan dan keefektifannya bahkan ketika dikompilasi ke model LM yang lebih kecil.
• Abstraksi termodulasi: DSPy secara efektif mengabstraksikan aspek-aspek rumit dari pengembangan pipeline LM, seperti dekomposisi, fine-tuning, dan pemilihan model. Dengan DSPy, program yang ringkas dapat diterjemahkan dengan mulus ke dalam instruksi untuk berbagai model, seperti GPT-4, Llama2-13b, atau T5-base, sehingga merampingkan pengembangan dan meningkatkan kinerja.

Modul

Ada banyak komponen yang berkontribusi dalam membangun pipeline LLM. Di sini, kami akan menjelaskan beberapa komponen utama untuk memberikan pemahaman tingkat tinggi tentang cara kerja DSPy.

Modul DSPy

Tanda tangan: Signature dalam DSPy berfungsi sebagai spesifikasi deklaratif, yang menguraikan perilaku input/output modul, memandu model bahasa dalam eksekusi tugas. Modul: Modul DSPy berfungsi sebagai komponen fundamental untuk program yang memanfaatkan model bahasa (LM). Modul ini mengabstraksikan berbagai teknik prompt, seperti rantai pemikiran atau ReAct, dan dapat beradaptasi untuk menangani DSPy Signature apa pun. Dengan parameter yang dapat dipelajari dan kemampuan untuk memproses input dan menghasilkan output, modul-modul ini dapat dikombinasikan untuk membentuk program yang lebih besar, mengambil inspirasi dari modul NN di PyTorch tetapi disesuaikan untuk aplikasi LM. Pengoptimal: Pengoptimal dalam DSPy menyempurnakan parameter program DSPy, seperti petunjuk dan bobot LLM, untuk memaksimalkan metrik yang ditentukan seperti akurasi, meningkatkan efisiensi program.

Mengapa Milvus di DSPy

DSPy adalah kerangka kerja pemrograman yang kuat yang meningkatkan aplikasi RAG. Aplikasi tersebut perlu mengambil informasi yang berguna untuk meningkatkan kualitas jawaban, yang membutuhkan basis data vektor. Milvus adalah basis data vektor sumber terbuka yang terkenal untuk meningkatkan kinerja dan skalabilitas. Dengan MilvusRM, sebuah modul retriever di DSPy, mengintegrasikan Milvus menjadi sangat mudah. Sekarang, pengembang dapat dengan mudah mendefinisikan dan mengoptimalkan program RAG menggunakan DSPy, dengan memanfaatkan kemampuan pencarian vektor yang kuat dari Milvus. Kolaborasi ini membuat aplikasi RAG menjadi lebih efisien dan terukur, menggabungkan kemampuan pemrograman DSPy dengan fitur pencarian Milvus.

Contoh

Sekarang, mari kita lihat contoh singkat untuk mendemonstrasikan cara memanfaatkan Milvus dalam DSPy untuk mengoptimalkan aplikasi RAG.

Prasyarat

Sebelum membuat aplikasi RAG, instal DSPy dan PyMilvus.

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

Memuat dataset

Dalam contoh ini, kita menggunakan HotPotQA, sebuah kumpulan pasangan pertanyaan-jawaban yang kompleks, sebagai kumpulan data latihan. Kita dapat memuatnya melalui kelas HotPotQA.

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]

Memasukkan data ke dalam basis data vektor Milvus

Masukkan informasi konteks ke dalam koleksi Milvus untuk pengambilan vektor. Koleksi ini harus memiliki bidang embedding dan bidang text. Kami menggunakan model text-embedding-3-small dari OpenAI sebagai fungsi penyematan kueri default dalam kasus ini.

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,
            }
        ],
    )

Mendefinisikan MilvusRM.

Sekarang, Anda perlu mendefinisikan MilvusRM.

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)

Membangun tanda tangan

Setelah kita memuat data, mari kita mulai mendefinisikan tanda tangan untuk sub-tugas pipeline kita. Kita dapat mengidentifikasi masukan sederhana kita question dan keluaran answer, tetapi karena kita sedang membangun pipeline RAG, kita akan mengambil informasi kontekstual dari Milvus. Jadi mari kita definisikan tanda tangan kita sebagai context, question --> answer.

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")

Kami menyertakan deskripsi singkat untuk bidang context dan answer untuk mendefinisikan panduan yang lebih jelas tentang apa yang akan diterima dan dihasilkan oleh model.

Membangun pipeline

Sekarang, mari kita mendefinisikan pipeline RAG.

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

        # This signature indicates the task imposed on the COT module.
        self.generate_answer = dspy.ChainOfThought(GenerateAnswer)

    def forward(self, question):
        # Use milvus_rm to retrieve context for the question.
        context = self.retrieve(question).passages
        # COT module takes "context, query" and output "answer".
        prediction = self.generate_answer(context=context, question=question)
        return dspy.Prediction(
            context=[item.long_text for item in context], answer=prediction.answer
        )

Menjalankan pipeline dan mendapatkan hasilnya

Sekarang, kita telah membuat pipeline RAG ini. Mari kita coba dan dapatkan hasilnya.

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

Townes Van Zandt

Kita dapat mengevaluasi hasil kuantitatif pada dataset.

from dspy.evaluate.evaluate import Evaluate
from dspy.datasets import HotPotQA

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)

Mengoptimalkan pipeline

Setelah mendefinisikan program ini, langkah selanjutnya adalah kompilasi. Proses ini memperbarui parameter dalam setiap modul untuk meningkatkan kinerja. Proses kompilasi bergantung pada tiga faktor penting:

• Training Set: Kami akan menggunakan 20 contoh pertanyaan-jawaban dari kumpulan data pelatihan kami untuk demonstrasi ini.
• Metrik Validasi: Kami akan membuat metrik sederhana validate_context_and_answer. Metrik ini memverifikasi keakuratan jawaban yang diprediksi dan memastikan bahwa konteks yang diambil mencakup jawabannya.
• Pengoptimal Khusus (Teleprompter): Kompiler DSPy menggabungkan beberapa teleprompter yang dirancang untuk mengoptimalkan program Anda secara efektif.

from dspy.teleprompt import BootstrapFewShot

# Validation logic: check that the predicted answer is correct.# Also check that the retrieved context does contain that answer.


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


# Set up a basic teleprompter, which will compile our RAG program.
teleprompter = BootstrapFewShot(metric=validate_context_and_answer)

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

# Now compiled_rag is optimized and ready to answer your new question!
# Now, let’s evaluate the compiled RAG program.
score = evaluate_on_hotpotqa(compiled_rag, metric=metric)
print(score)
print("compile_rag:", score)

Skor Ragas telah meningkat dari nilai sebelumnya 50.0 menjadi 52.0, yang menunjukkan peningkatan kualitas jawaban.

Ringkasan

DSPy menandai lompatan dalam interaksi model bahasa melalui antarmuka yang dapat diprogram, yang memfasilitasi pengoptimalan algoritmik dan otomatis dari permintaan dan bobot model. Dengan memanfaatkan DSPy untuk implementasi RAG, kemampuan beradaptasi terhadap berbagai model bahasa atau kumpulan data menjadi mudah, secara drastis mengurangi kebutuhan akan intervensi manual yang membosankan.