LLM'yi DSPy ile Optimize Edin: Yapay Zeka sistemlerini oluşturmak, optimize etmek ve değerlendirmek için Adım Adım Kılavuz

Büyük dil modellerinin (LLM'ler) yetenekleri genişlemeye devam ettikçe, potansiyellerinden yararlanan sağlam yapay zeka sistemleri geliştirmek giderek daha karmaşık hale geldi. Geleneksel yaklaşımlar genellikle karmaşık yönlendirme tekniklerini, ince ayar için veri oluşturmayı ve alana özgü kısıtlamalara uyumu sağlamak için manuel yönlendirmeyi içerir. Ancak bu süreç sıkıcı, hataya açık ve büyük ölçüde insan müdahalesine bağlı olabilir.

Keşfet DSPyLLM'ler tarafından desteklenen yapay zeka sistemlerinin geliştirilmesini kolaylaştırmak için tasarlanmış devrim niteliğinde bir çerçeve. DSPy, LM istemlerini ve ağırlıklarını optimize etmeye yönelik sistematik bir yaklaşım sunarak geliştiricilerin minimum manuel çabayla karmaşık uygulamalar oluşturmasına olanak tanır.

Bu kapsamlı rehberde, DSPy'nin temel prensiplerini, modüler mimarisini ve sunduğu güçlü özellikleri inceleyeceğiz. Ayrıca, DSPy'nin LLM dereceleriyle yapay zeka sistemleri geliştirme şeklinizi nasıl dönüştürebileceğini gösteren pratik örneklere de değineceğiz.

DSPy Nedir ve Neden İhtiyacınız Var?

DSPy programınızın akışını ayıran bir çerçevedir (modules) her adımın parametrelerinden (LM istemleri ve ağırlıklar). Bu ayırma, LM istemlerinin ve ağırlıklarının sistematik optimizasyonuna olanak tanıyarak, daha fazla güvenilirliğe, öngörülebilirliğe ve alana özgü kısıtlamalara uyum sağlayan karmaşık yapay zeka sistemleri oluşturmanıza olanak tanır.

Geleneksel olarak, Yüksek Lisans'larla yapay zeka sistemleri geliştirmek, sorunu adımlara bölmek, her adım için karmaşık istemler oluşturmak, ince ayar için sentetik örnekler oluşturmak ve LM'leri belirli kısıtlamalara uymaları için manuel olarak yönlendirmek gibi zahmetli bir süreci içeriyordu. Bu yaklaşım yalnızca zaman alıcı olmakla kalmıyordu, aynı zamanda hatalara da açıktı; çünkü ardışık düzende, LM'de veya verilerde yapılan küçük değişiklikler bile istemlerin kapsamlı bir şekilde yeniden işlenmesini ve ince ayar adımlarını gerektirebilirdi.

DSPy yeni bir paradigma sunarak bu zorlukların üstesinden gelir: optimize. Bu LM odaklı algoritmalar, maksimuma çıkarmak istediğiniz bir ölçüm göz önüne alındığında, LM çağrılarınızın istemlerini ve ağırlıklarını ayarlayabilir. DSPy, optimizasyon sürecini otomatikleştirerek geliştiricilere minimum manuel müdahaleyle sağlam yapay zeka sistemleri oluşturma olanağı vererek LM çıktılarının güvenilirliğini ve öngörülebilirliğini artırır.

DSPy'nin Modüler Mimarisi

DSPy'ın kalbinde karmaşık yapay zeka sistemlerinin oluşturulmasını kolaylaştıran modüler bir mimari yatıyor. Çerçeve, çeşitli yönlendirme tekniklerini soyutlayan bir dizi yerleşik modül sağlar; dspy.ChainOfThought ve dspy.ReAct. Bu modüller birleştirilebilir ve daha büyük programlarda birleştirilebilir; bu da geliştiricilerin kendi özel gereksinimlerine göre uyarlanmış karmaşık işlem hatları oluşturmasına olanak tanır.

Her modül, talimatlar, birkaç örnek ve LM ağırlıkları dahil olmak üzere öğrenilebilir parametreleri kapsar. Bir modül çağrıldığında, DSPy'nin optimize edicileri, istenen metriği en üst düzeye çıkarmak için bu parametreleri hassas bir şekilde ayarlayabilir ve LM çıktılarının belirtilen kısıtlamalara ve gereksinimlere uymasını sağlayabilir.

DSPy ile optimizasyon

DSPy, yapay zeka sistemlerinizin performansını ve güvenilirliğini artırmak için tasarlanmış bir dizi güçlü optimizasyon aracı sunar. Bu optimize ediciler, LM çağrılarınızın istemlerini ve ağırlıklarını ayarlamak için LM odaklı algoritmalardan yararlanır ve alana özgü kısıtlamalara bağlı kalarak belirtilen ölçümü en üst düzeye çıkarır.

DSPy'de bulunan temel optimize edicilerden bazıları şunlardır:

1. BootstrapFewShot: Bu optimize edici, modele gönderilen istem içerisine optimize edilmiş örnekleri otomatik olarak oluşturarak ve dahil ederek imzayı genişletir ve birkaç adımlı öğrenmeyi uygular.
2. BootstrapFewShotWithRandomSearch: Geçerlidir BootstrapFewShot optimizasyon üzerinden en iyi programı seçerek, oluşturulan gösteriler üzerinde rastgele arama yaparak birkaç kez.
3. Mipro: Talimat oluşturmanın verilere ve gösterime duyarlı olmasıyla, her adımda talimatlar ve birkaç örnek oluşturur. Modülleriniz genelinde talimat oluşturma ve gösterim alanını etkili bir şekilde aramak için Bayesian Optimizasyonunu kullanır.
4. BootstrapFinetune: İstem tabanlı bir DSPy programını daha küçük LM'ler için ağırlık güncellemelerine dönüştürerek, gelişmiş verimlilik için temel LLM'lere ince ayar yapmanıza olanak tanır.

Geliştiriciler, bu optimize edicilerden yararlanarak yapay zeka sistemlerini sistematik olarak optimize edebilir, böylece alana özgü kısıtlamalara ve gereksinimlere bağlı kalarak yüksek kaliteli çıktılar elde edebilirler.

DSPy'a Başlarken

DSPy'nin gücünü göstermek için, soru-cevaplama için bir geri çağırma-artırılmış üretim (RAG) sisteminin oluşturulmasına ilişkin pratik bir örneği inceleyelim.

Adım 1: Dil Modelini ve Geri Alma Modelini Kurma

İlk adım, DSPy içerisinde dil modelinin (LM) ve erişim modelinin (RM) yapılandırılmasını içerir.

DSPy çalıştırmasını yüklemek için:

pip install dspy-ai

DSPy, birden fazla LM ve RM API'sinin yanı sıra yerel model barındırmayı da destekleyerek tercih ettiğiniz modellerin entegrasyonunu kolaylaştırır.

import dspy

# Configure the LM and 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)

2. Adım: Veri Kümesini Yükleme

Daha sonra, genellikle çoklu atlamalı bir şekilde cevaplanan karmaşık soru-cevap çiftlerinin bir koleksiyonunu içeren HotPotQA veri setini yükleyeceğiz.

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)

# Specify the 'question' field as the input
trainset = [x.with_inputs('question') for x in dataset.train]
devset = [x.with_inputs('question') for x in dataset.dev]

3. Adım: İmza Oluşturma

DSPy, modüllerin davranışını tanımlamak için imzaları kullanır. Bu örnekte, yanıt oluşturma görevi için giriş alanlarını (bağlam ve soru) ve çıktı alanını (yanıt) belirten bir imza tanımlayacağız.

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

Adım 4: Boru Hattının İnşası

RAG boru hattımızı, alt modülleri (dspy.Retrieve ve dspy.ChainOfThought) bildirmek için bir başlatma yöntemi (__init__) ve bu modülleri kullanarak soruyu yanıtlamanın kontrol akışını tanımlamak için bir iletme yöntemi (forward) içeren bir DSPy modülü olarak oluşturacağız.

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, question):
        context = self.retrieve(question).passages
        prediction = self.generate_answer(context=context, question=question)
        return dspy.Prediction(context=context, answer=prediction.answer)

Adım 5: Boru Hattını Optimize Etme

Boru hattı tanımlandığına göre, artık DSPy'nin optimize edicilerini kullanarak optimize edebiliriz. Bu örnekte, bir eğitim kümesi ve doğrulama metriğine dayanarak modüllerimiz için etkili komut istemleri oluşturup seçen BootstrapFewShot optimize edicisini kullanacağız.

from dspy.teleprompt import BootstrapFewShot

# Validation metric
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 the optimizer
teleprompter = BootstrapFewShot(metric=validate_context_and_answer)

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

Adım 6: Boru Hattının Değerlendirilmesi

Programı derledikten sonra, istenen doğruluk ve güvenilirliği karşıladığından emin olmak için bir geliştirme seti üzerindeki performansını değerlendirmek önemlidir.

from dspy.evaluate import Evaluate

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

# Evaluate the compiled RAG program
evaluation_result = evaluate(compiled_rag)

print(f"Evaluation Result: {evaluation_result}")

Adım 7: Model Geçmişini İnceleme

Modelin etkileşimlerini daha derinlemesine anlamak için modelin geçmişini inceleyerek en son nesilleri inceleyebilirsiniz.

# Inspect the model's history
turbo.inspect_history(n=1)

8. Adım: Tahmin Yapmak

İşlem hattının optimize edilmesi ve değerlendirilmesi sayesinde artık bunu yeni sorularla ilgili tahminlerde bulunmak için kullanabilirsiniz.

# Example question
question = "Which award did Gary Zukav's first book receive?"

# Make a prediction using the compiled RAG program
prediction = compiled_rag(question)

print(f"Question: {question}")
print(f"Answer: {prediction.answer}")
print(f"Retrieved Contexts: {prediction.context}")

DSPy ile Minimal Çalışma Örneği

Şimdi, şunu kullanarak başka bir minimal çalışma örneğini inceleyelim: GSM8K veri kümesi ve DSPy içindeki yönlendirme görevlerini simüle etmek için OpenAI GPT-3.5-turbo modeli.

Kurmak

Öncelikle ortamınızın doğru şekilde yapılandırıldığından emin olun:

import dspy
from dspy.datasets.gsm8k import GSM8K, gsm8k_metric

# Set up the LM
turbo = dspy.OpenAI(model='gpt-3.5-turbo-instruct', max_tokens=250)
dspy.settings.configure(lm=turbo)

# Load math questions from the GSM8K dataset
gsm8k = GSM8K()
gsm8k_trainset, gsm8k_devset = gsm8k.train[:10], gsm8k.dev[:10]

print(gsm8k_trainset)

The gsm8k_trainset ve gsm8k_devset veri kümeleri, her örneğin bir soru ve cevap alanına sahip olduğu bir örnek listesi içerir.

Modülü Tanımlayın

Daha sonra, adım adım akıl yürütme için ChainOfThought modülünü kullanan özel bir program tanımlayın:

class CoT(dspy.Module):
def __init__(self):
super().__init__()
self.prog = dspy.ChainOfThought("question -> answer")

def forward(self, question):
return self.prog(question=question)

Modeli Derleyin ve Değerlendirin

Şimdi bunu şununla derleyin: BootstrapFewShot akıl defteri:

from dspy.teleprompt import BootstrapFewShot

# Set up the optimizer
config = dict(max_bootstrapped_demos=4, max_labeled_demos=4)

# Optimize using the gsm8k_metric
teleprompter = BootstrapFewShot(metric=gsm8k_metric, **config)
optimized_cot = teleprompter.compile(CoT(), trainset=gsm8k_trainset)

# Set up the evaluator
from dspy.evaluate import Evaluate

evaluate = Evaluate(devset=gsm8k_devset, metric=gsm8k_metric, num_threads=4, display_progress=True, display_table=0)
evaluate(optimized_cot)

# Inspect the model's history
turbo.inspect_history(n=1)

Bu örnek, ortamınızı nasıl kuracağınızı, özel bir modülü nasıl tanımlayacağınızı, bir modeli nasıl derleyeceğinizi ve sağlanan veri kümesi ve teleprompter yapılandırmalarını kullanarak performansının titizlikle nasıl değerlendirileceğini gösterir.

DSPy'da Veri Yönetimi

DSPy eğitim, geliştirme ve test setleriyle çalışır. Verilerinizdeki her örnek için genellikle üç tür değeriniz vardır: girişler, ara etiketler ve son etiketler. Ara veya son etiketler isteğe bağlı olsa da, birkaç örnek girişin olması önemlidir.

Örnek Nesneler Oluşturma

DSPy'daki örnek nesneler Python sözlüklerine benzer ancak yararlı yardımcı programlarla birlikte gelir:

qa_pair = dspy.Example(question="This is a question?", answer="This is an answer.")

print(qa_pair)
print(qa_pair.question)
print(qa_pair.answer)

Çıktı:

Example({'question': 'This is a question?', 'answer': 'This is an answer.'}) (input_keys=None)
This is a question?
This is an answer.

Giriş Tuşlarını Belirleme

DSPy'da, Örnek nesnelerin belirli alanları giriş olarak işaretlemek için bir with_inputs() yöntemi vardır:

print(qa_pair.with_inputs("question"))
print(qa_pair.with_inputs("question", "answer"))

Değerlere nokta operatörü kullanılarak erişilebilir ve inputs() ve labels() gibi yöntemler, sırasıyla yalnızca giriş anahtarları veya giriş olmayan anahtarlar içeren yeni Örnek nesneleri döndürür.

DSPy'daki optimize ediciler

Bir DSPy iyileştirici, belirtilen ölçümleri en üst düzeye çıkarmak için bir DSPy programının parametrelerini (yani istemler ve/veya LM ağırlıkları) ayarlar. DSPy, her biri farklı stratejiler kullanan çeşitli yerleşik optimize ediciler sunar.

Mevcut Optimize Ediciler

• BootstrapFewShot: Sağlanan etiketli giriş ve çıkış veri noktalarını kullanarak birkaç çekimlik örnekler oluşturur.
• BootstrapFewShotWithRandomSearch: Oluşturulan gösteriler üzerinde rastgele aramayla BootstrapFewShot'ı birden çok kez uygular.
• Copro: Her adım için yeni talimatlar oluşturur ve geliştirir, bunları koordinat yükselişiyle optimize eder.
• Mipro: Bayesian Optimizasyonunu kullanarak talimatları ve birkaç çekimli örnekleri optimize eder.

Bir Optimize Edici Seçmek

Nereden başlayacağınızdan emin değilseniz BootstrapFewShotWithRandomSearch'ü kullanın:

Çok az veri için (10 örnek) BootstrapFewShot'ı kullanın.
Biraz daha fazla veri için (50 örnek), BootstrapFewShotWithRandomSearch'ü kullanın.
Daha büyük veri kümeleri için (300'den fazla örnek) MIPRO'yu kullanın.

BootstrapFewShotWithRandomSearch'ün nasıl kullanılacağı aşağıda açıklanmıştır:

from dspy.teleprompt import BootstrapFewShotWithRandomSearch

config = dict(max_bootstrapped_demos=4, max_labeled_demos=4, num_candidate_programs=10, num_threads=4)
teleprompter = BootstrapFewShotWithRandomSearch(metric=YOUR_METRIC_HERE, **config)
optimized_program = teleprompter.compile(YOUR_PROGRAM_HERE, trainset=YOUR_TRAINSET_HERE)

Optimize Edilmiş Programları Kaydetme ve Yükleme

Bir programı optimize edici aracılığıyla çalıştırdıktan sonra, ileride kullanmak üzere kaydedin:

optimize_program.save(YOUR_SAVE_PATH)

Kaydedilmiş bir programı yükleyin:

loaded_program = YOUR_PROGRAM_CLASS()
loaded_program.load(path=YOUR_SAVE_PATH)

Gelişmiş Özellikler: DSPy İddiaları

DSPy Onayları, LM'ler üzerindeki hesaplama kısıtlamalarının uygulanmasını otomatikleştirerek LM çıktılarının güvenilirliğini, öngörülebilirliğini ve doğruluğunu artırır.

İddiaları Kullanma

Doğrulama işlevlerini tanımlayın ve ilgili model oluşturmanın ardından iddiaları bildirin. Örneğin:

dspy.Suggest(
len(query) <= 100,
"Query should be short and less than 100 characters",
)

dspy.Suggest(
validate_query_distinction_local(prev_queries, query),
"Query should be distinct from: " + "; ".join(f"{i+1}) {q}" for i, q in enumerate(prev_queries)),
)

Programları İddialarla Dönüştürmek

from dspy.primitives.assertions import assert_transform_module, backtrack_handler

baleen_with_assertions = assert_transform_module(SimplifiedBaleenAssertions(), backtrack_handler)

Alternatif olarak iddiaları doğrudan program üzerinden etkinleştirin:

baleen_with_assertions = SimplifiedBaleenAssertions().activate_assertions()

İddia Odaklı Optimizasyonlar

DSPy Assertions, DSPy optimizasyonlarıyla, özellikle BootstrapFewShotWithRandomSearch ile birlikte çalışır ve aşağıdaki gibi ayarlar içerir:

• İddialarla Derleme
• Derleme + İddialarla Çıkarım

Sonuç

DSPy, dil modellerini ve komut istemlerini optimize etmek için güçlü ve sistematik bir yaklaşım sunar. Bu örneklerde özetlenen adımları izleyerek karmaşık yapay zeka sistemlerini kolayca oluşturabilir, optimize edebilir ve değerlendirebilirsiniz. DSPy'nin modüler tasarımı ve gelişmiş optimizasyon araçları, çeşitli dil modellerinin verimli ve etkili bir şekilde entegre edilmesini sağlayarak, onu NLP ve yapay zeka alanında çalışan herkes için değerli bir araç haline getirir.

İster basit bir soru-cevap sistemi, ister daha karmaşık bir işlem hattı oluşturuyor olun, DSPy yüksek performans ve güvenilirlik elde etmek için gereken esnekliği ve sağlamlığı sağlar.