Optimalkan LLM dengan DSPy : Panduan Langkah demi Langkah untuk Membangun, Mengoptimalkan, dan Mengevaluasi Sistem AI

Karena kemampuan model bahasa besar (LLM) terus berkembang, mengembangkan sistem AI yang kuat yang memanfaatkan potensinya telah menjadi semakin kompleks. Pendekatan konvensional sering melibatkan teknik prompting yang rumit, generasi data untuk fine-tuning, dan bimbingan manual untuk memastikan kepatuhan terhadap konstrain spesifik domain. Namun, proses ini dapat membosankan, rentan terhadap kesalahan, dan sangat bergantung pada intervensi manusia.

Masuklah DSPy, sebuah kerangka kerja revolusioner yang dirancang untuk mempermudah pengembangan sistem AI yang ditenagai oleh LLM. DSPy memperkenalkan pendekatan sistematis untuk mengoptimalkan prompt LM dan bobot, memungkinkan pengembang untuk membangun aplikasi canggih dengan upaya manual minimal.

Dalam panduan komprehensif ini, kita akan menjelajahi prinsip-prinsip inti DSPy, arsitektur modularnya, dan berbagai fitur kuat yang ditawarkannya. Kita juga akan mempelajari contoh praktis, menunjukkan bagaimana DSPy dapat mengubah cara Anda mengembangkan sistem AI dengan LLM.

Apa itu DSPy, dan Mengapa Anda Membutuhkannya?

DSPy adalah kerangka kerja yang memisahkan aliran program Anda (modul) dari parameter (prompt LM dan bobot) dari setiap langkah. Pemisahan ini memungkinkan optimasi sistematis dari prompt LM dan bobot, memungkinkan Anda untuk membangun sistem AI yang kompleks dengan keandalan, prediktabilitas, dan kepatuhan terhadap konstrain spesifik domain yang lebih baik.

Secara tradisional, mengembangkan sistem AI dengan LLM melibatkan proses yang melelahkan dari memecah masalah menjadi langkah-langkah, membuat prompt yang rumit untuk setiap langkah, menghasilkan contoh sintetis untuk fine-tuning, dan memandu LM secara manual untuk mematuhi konstrain tertentu. Pendekatan ini tidak hanya memakan waktu tetapi juga rentan terhadap kesalahan, karena bahkan perubahan kecil pada pipeline, LM, atau data dapat memerlukan perubahan ekstensif pada prompt dan langkah fine-tuning.

DSPy menangani tantangan ini dengan memperkenalkan paradigma baru: optimizer. Algoritma LM yang didorong ini dapat menyetel prompt dan bobot dari panggilan LM, diberikan metrik yang ingin dimaksimalkan. Dengan mengotomatisasi proses optimasi, DSPy memberdayakan pengembang untuk membangun sistem AI yang kuat dengan intervensi manual minimal, meningkatkan keandalan dan prediktabilitas output LM.

Arsitektur Modular DSPy

Di jantung DSPy terdapat arsitektur modular yang memfasilitasi komposisi sistem AI yang kompleks. Kerangka kerja ini menyediakan set modul bawaan yang mengabstraksi berbagai teknik prompting, seperti dspy.ChainOfThought dan dspy.ReAct. Modul-modul ini dapat dikombinasikan dan disusun menjadi program yang lebih besar, memungkinkan pengembang untuk membangun pipeline yang rumit yang disesuaikan dengan kebutuhan spesifik mereka.

Setiap modul mengenkapsulasi parameter yang dapat dipelajari, termasuk instruksi, contoh few-shot, dan bobot LM. Ketika modul diaktifkan, optimizer DSPy dapat menyetel parameter ini untuk memaksimalkan metrik yang diinginkan, memastikan bahwa output LM mematuhi konstrain dan kebutuhan yang ditentukan.

Mengoptimalkan dengan DSPy

DSPy memperkenalkan berbagai optimizer kuat yang dirancang untuk meningkatkan kinerja dan keandalan sistem AI Anda. Optimizer-optimizer ini menggunakan algoritma LM yang didorong untuk menyetel prompt dan bobot dari panggilan LM, memaksimalkan metrik yang ditentukan sambil mematuhi konstrain spesifik domain.

Beberapa optimizer kunci yang tersedia di DSPy termasuk:

1. BootstrapFewShot: Optimizer ini memperluas tanda tangan dengan secara otomatis menghasilkan dan memasukkan contoh yang dioptimalkan dalam prompt yang dikirim ke model, mengimplementasikan pembelajaran few-shot.
2. BootstrapFewShotWithRandomSearch: Menggunakan BootstrapFewShot beberapa kali dengan pencarian acak atas demonstrasi yang dihasilkan, memilih program terbaik selama optimasi.
3. MIPRO: Menghasilkan instruksi dan contoh few-shot pada setiap langkah, dengan instruksi yang dihasilkan menjadi sadar data dan demonstrasi. Ini menggunakan Optimasi Bayesian untuk secara efektif mencari ruang instruksi dan demonstrasi yang dihasilkan melalui modul Anda.
4. BootstrapFinetune: Mengolah program DSPy berbasis prompt menjadi pembaruan bobot untuk LM yang lebih kecil, memungkinkan Anda untuk fine-tuning LM yang mendasarinya untuk efisiensi yang ditingkatkan.

Dengan menggunakan optimizer-optimizer ini, pengembang dapat secara sistematis mengoptimalkan sistem AI mereka, memastikan output berkualitas tinggi sambil mematuhi konstrain dan kebutuhan spesifik domain.

Menggunakan DSPy

Untuk mengilustrasikan kekuatan DSPy, mari kita jalankan contoh praktis membangun sistem generasi yang ditingkatkan dengan pengambilan (RAG) untuk pertanyaan-jawaban.

Langkah 1: Mengatur Model Bahasa dan Model Pengambilan

Langkah pertama melibatkan konfigurasi model bahasa (LM) dan model pengambilan (RM) dalam DSPy.

Untuk menginstal DSPy, jalankan:

pip install dspy-ai

DSPy mendukung beberapa API LM dan RM, serta hosting model lokal, membuatnya mudah untuk mengintegrasikan model yang Anda sukai.

import dspy

# Konfigurasikan LM dan RM
turbo = dspy.OpenAI(model='gpt-3.5-turbo')
colbertv2_wiki17_abstracts = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts')

dspy.settings.configure(lm=turbo, rm=colbertv2_wiki17_abstracts)

Langkah 2: Memuat Dataset

Selanjutnya, kita akan memuat dataset HotPotQA, yang berisi koleksi pasangan pertanyaan-jawaban yang kompleks yang biasanya dijawab dalam cara multi-hop.

from dspy.datasets import HotPotQA

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

# Tentukan 'pertanyaan' sebagai input
trainset = [x.with_inputs('pertanyaan') for x in dataset.train]
devset = [x.with_inputs('pertanyaan') for x in dataset.dev]

Langkah 3: Membangun Tanda Tangan

DSPy menggunakan tanda tangan untuk mendefinisikan perilaku modul. Dalam contoh ini, kita akan mendefinisikan tanda tangan untuk tugas generasi jawaban, menentukan bidang input (konteks dan pertanyaan) dan bidang output (jawaban).

class GenerateAnswer(dspy.Signature):
"""Jawab pertanyaan dengan jawaban faktoid pendek."""

konteks = dspy.InputField(desc="mungkin berisi fakta relevan")
pertanyaan = dspy.InputField()
jawaban = dspy.OutputField(desc="seringkali antara 1 dan 5 kata")

Langkah 4: Membangun Pipeline

Kita akan membangun pipeline RAG kita sebagai modul DSPy, yang terdiri dari metode inisialisasi (__init__) untuk mendeklarasikan sub-modul (dspy.Retrieve dan dspy.ChainOfThought) dan metode maju (forward) untuk menggambarkan aliran kontrol menjawab pertanyaan menggunakan modul-modul ini.

class RAG(dspy.Module):
def __init__(self, num_passages=3):
super().__init__()

self.retrieve = dspy.Retrieve(k=num_passages)
self.generate_answer = dspy.ChainOfThought(GenerateAnswer)

def forward(self, pertanyaan):
konteks = self.retrieve(pertanyaan).passages
prediksi = self.generate_answer(konteks=konteks, pertanyaan=pertanyaan)
return dspy.Prediction(konteks=konteks, jawaban=prediksi.jawaban)

Langkah 5: Mengoptimalkan Pipeline

Dengan pipeline yang didefinisikan, kita sekarang dapat mengoptimalkannya menggunakan optimizer DSPy. Dalam contoh ini, kita akan menggunakan optimizer BootstrapFewShot, yang menghasilkan dan memilih prompt yang efektif untuk modul-modul kita berdasarkan set pelatihan dan metrik untuk validasi.

from dspy.teleprompt import BootstrapFewShot

# Metrik validasi
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

# Atur optimizer
teleprompter = BootstrapFewShot(metric=validate_context_and_answer)

# Kompilasi program
compiled_rag = teleprompter.compile(RAG(), trainset=trainset)

Langkah 6: Mengevaluasi Pipeline

Setelah mengompilasi program, penting untuk mengevaluasi kinerjanya pada set pengembangan untuk memastikan bahwa itu memenuhi akurasi dan keandalan yang diinginkan.

from dspy.evaluate import Evaluate

# Atur evaluator
evaluate = Evaluate(devset=devset, metric=validate_context_and_answer, num_threads=4, display_progress=True, display_table=0)

# Evaluasi program RAG yang dikompilasi
evaluation_result = evaluate(compiled_rag)

print(f"Evaluasi Hasil: {evaluation_result}")

Langkah 7: Mengeksplorasi Riwayat Model

Untuk pemahaman yang lebih dalam tentang interaksi model, Anda dapat meninjau generasi terbaru dengan mengeksplorasi riwayat model.

# Eksplorasi riwayat model
turbo.inspect_history(n=1)

Langkah 8: Membuat Prediksi

Dengan pipeline yang dioptimalkan dan dievaluasi, Anda sekarang dapat menggunakannya untuk membuat prediksi pada pertanyaan baru.

# Contoh pertanyaan
pertanyaan = "Apa penghargaan yang diterima buku pertama Gary Zukav?"

# Buat prediksi menggunakan program RAG yang dikompilasi
prediksi = compiled_rag(pertanyaan)

print(f"Pertanyaan: {pertanyaan}")
print(f"Jawaban: {prediksi.jawaban}")
print(f"Konteks yang Diambil: {prediksi.konteks}")

Contoh Minimal dengan DSPy

Sekarang, mari kita jalankan contoh minimal lain menggunakan dataset GSM8K dan model OpenAI GPT-3.5-turbo untuk mensimulasikan tugas prompting dalam DSPy.

Pengaturan

Example({'pertanyaan': 'Ini adalah pertanyaan?', 'jawaban': 'Ini adalah jawaban.'}) (input_keys=None)
Ini adalah pertanyaan?
Ini adalah jawaban.

Menentukan Kunci Input

Di DSPy, objek Contoh memiliki metode with_inputs() untuk menandai bidang tertentu sebagai input:

print(qa_pair.with_inputs("pertanyaan"))
print(qa_pair.with_inputs("pertanyaan", "jawaban"))

Nilai dapat diakses menggunakan operator titik, dan metode seperti inputs() dan labels() mengembalikan objek Contoh baru yang berisi hanya kunci input atau non-input.

Optimizer di DSPy

Optimizer DSPy menyetel parameter program DSPy (yaitu, prompt dan/atau bobot LM) untuk memaksimalkan metrik yang ditentukan. DSPy menawarkan berbagai optimizer bawaan, masing-masing menggunakan strategi yang berbeda.

Optimizer yang Tersedia

• BootstrapFewShot: Menghasilkan contoh few-shot menggunakan data input dan output yang dilabeli.
• BootstrapFewShotWithRandomSearch: Menggunakan BootstrapFewShot beberapa kali dengan pencarian acak atas demonstrasi yang dihasilkan.
• COPRO: Menghasilkan dan memperbarui instruksi baru untuk setiap langkah, mengoptimalkannya dengan koordinat naik.
• MIPRO: Mengoptimalkan instruksi dan contoh few-shot menggunakan Optimasi Bayesian.

Memilih Optimizer

Jika Anda tidak yakin dari mana memulai, gunakan BootstrapFewShotWithRandomSearch:

Untuk sangat sedikit data (10 contoh), gunakan BootstrapFewShot.
Untuk sedikit lebih banyak data (50 contoh), gunakan BootstrapFewShotWithRandomSearch.
Untuk dataset yang lebih besar (300+ contoh), gunakan MIPRO.