🏠 Главная › user guide › mlops research dspy

{/ Эта страница автоматически передается из навыков SKILL.md с помощью сайта/scripts/generate-skill-docs.py. Редактируйте исходный SKILL.md, а не эту страницу. /}

Дшпион

DSPy: декларативные LM-программы, автооптимизация промптов, RAG.

Метаданные навыки
Источник Встроенный (устанавливается по умолчанию)
Путь навыки/млопс/исследования/dspy
Версия 1.0.0
Автор Исследование оркестра
Лицензия Массачусетский технологический институт
Зависимости dspy, openai, антропный
Платформы Linux, MacOS, Windows
Теги Быстрое проектирование, DSPy, Декларативное программирование, RAG, Агенты, Быстрая оптимизация, LM-программирование, Стэнфордский НЛП, Автоматическая оптимизация, Модульный искусственный интеллект

Справочник: полный SKILL.md:::информация

Ниже приведено полное описание навыков, которые Hermes загружает при его активации. Агент увидит эту инструкцию, когда навыки активны.

DSPy: Декларативное программирование языковых моделей

Когда использовать этот навык

Используйте DSPy, когда необходимо: - Строить сложные AI-системы с несколькими компонентами и некоторыми процессами. - Программировать LM декларативно вместо ручного инжиниринга - Автоматическая оптимизация промптов с помощью методов, основанных на данных. - Создавать модульные AI-конвейеры, которые влияют и переносятся. - Систематически улучшать выходные модели с помощью оптимизаторов. - Строить RAG-системы, агенты или классификаторы с лучшей надежностью

Вёзды GitHub: 22 000+ | Создано: Стэнфордское НЛП.

Установка

# Стабильный релиз
pip install dspy

# Последняя версия для разработки
pip install git+https://github.com/stanfordnlp/dspy.git

# С конкретными провайдерами LM
pip install dspy[openai]        # OpenAI
pip install dspy[anthropic]     # Anthropic Claude
pip install dspy[all]           # Все провайдеры

Быстрый старт

Базовый пример: Ответы на вопросы

import dspy

# Настройка языковой модели
lm = dspy.Claude(model="claude-sonnet-4-5-20250929")
dspy.settings.configure(lm=lm)

# Определение сигнатуры (вход → выход)
class QA(dspy.Signature):
    """Отвечайте на вопросы короткими фактическими ответами."""
    question = dspy.InputField()
    answer = dspy.OutputField(desc="обычно от 1 до 5 слов")

# Создание модуля
qa = dspy.Predict(QA)

# Использование
response = qa(question="What is the capital of France?")
print(response.answer)  # "Paris"

Рассуждение цепочкой мыслей

import dspy

lm = dspy.Claude(model="claude-sonnet-4-5-20250929")
dspy.settings.configure(lm=lm)

# Используйте ChainOfThought для лучшего рассуждения
class MathProblem(dspy.Signature):
    """Решайте текстовые математические задачи."""
    problem = dspy.InputField()
    answer = dspy.OutputField(desc="числовой ответ")

# ChainOfThought автоматически генерирует шаги рассуждения
cot = dspy.ChainOfThought(MathProblem)

response = cot(problem="If John has 5 apples and gives 2 to Mary, how many does he have?")
print(response.rationale)  # Показывает шаги рассуждения
print(response.answer)     # "3"

Основные концепции

1. Подписи

Сигнатуры определяют структуру ваших AI-задач (входы → выходы):

# Встроенная сигнатура (простая)
qa = dspy.Predict("question -> answer")

# Сигнатура класса (подробная)
class Summarize(dspy.Signature):
    """Суммируйте текст в ключевые пункты."""
    text = dspy.InputField()
    summary = dspy.OutputField(desc="маркированный список, 3-5 пунктов")

summarizer = dspy.ChainOfThought(Summarize)

Когда что использовать: - Встроенная: Быстрое прототипирование, простые задачи - Класс: Сложные задачи, подсказки типа, лучшая документация

2. Модули

Модули — это переиспользуемые компоненты, преобразующие входы в выходы:

dspy.Predict

Базовый модуль предсказания:

predictor = dspy.Predict("context, question -> answer")
result = predictor(context="Paris is the capital of France",
                   question="What is the capital?")

dspy.ChainOfThought

Генерирует шаги распределения перед ответом:

cot = dspy.ChainOfThought("question -> answer")
result = cot(question="Why is the sky blue?")
print(result.rationale)  # Шаги рассуждения
print(result.answer)     # Финальный ответ

dspy.ReAct

Агентоподобное рассуждение с инструментами:

from dspy.predict import ReAct

class SearchQA(dspy.Signature):
    """Отвечайте на вопросы, используя поиск."""
    question = dspy.InputField()
    answer = dspy.OutputField()

def search_tool(query: str) -> str:
    """Поиск в Википедии."""
    # Ваша реализация поиска
    return results

react = ReAct(SearchQA, tools=[search_tool])
result = react(question="When was Python created?")

dspy.ProgramOfThought

Генерирует и выполняет код для обсуждения:

pot = dspy.ProgramOfThought("question -> answer")
result = pot(question="What is 15% of 240?")
# Генерирует: answer = 240 * 0.15

3. Оптимизаторы

Оптимизаторы автоматически улучшают ваши модули, используя обучающие данные:

BootstrapFewShot

Учится на примерах:

from dspy.teleprompt import BootstrapFewShot

# Обучающие данные
trainset = [
    dspy.Example(question="What is 2+2?", answer="4").with_inputs("question"),
    dspy.Example(question="What is 3+5?", answer="8").with_inputs("question"),
]

# Определение метрики
def validate_answer(example, pred, trace=None):
    return example.answer == pred.answer

# Оптимизация
optimizer = BootstrapFewShot(metric=validate_answer, max_bootstrapped_demos=3)
optimized_qa = optimizer.compile(qa, trainset=trainset)

# Теперь optimized_qa работает лучше!

MIPRO (самая важная оптимизация подсказок)

Итеративно улучшайте предложения:

from dspy.teleprompt import MIPRO

optimizer = MIPRO(
    metric=validate_answer,
    num_candidates=10,
    init_temperature=1.0
)

optimized_cot = optimizer.compile(
    cot,
    trainset=trainset,
    num_trials=100
)

BootstrapFinetune

Создаёт наборы данных для дообучения моделей:

from dspy.teleprompt import BootstrapFinetune

optimizer = BootstrapFinetune(metric=validate_answer)
optimized_module = optimizer.compile(qa, trainset=trainset)

# Экспортирует обучающие данные для дообучения

4. Построение сложных систем

Многоступенчатый конвейер

import dspy

class MultiHopQA(dspy.Module):
    def __init__(self):
        super().__init__()
        self.retrieve = dspy.Retrieve(k=3)
        self.generate_query = dspy.ChainOfThought("question -> search_query")
        self.generate_answer = dspy.ChainOfThought("context, question -> answer")

    def forward(self, question):
        # Этап 1: Генерация поискового запроса
        search_query = self.generate_query(question=question).search_query

        # Этап 2: Извлечение контекста
        passages = self.retrieve(search_query).passages
        context = "\n".join(passages)

        # Этап 3: Генерация ответа
        answer = self.generate_answer(context=context, question=question).answer
        return dspy.Prediction(answer=answer, context=context)

# Использование конвейера
qa_system = MultiHopQA()
result = qa_system(question="Who wrote the book that inspired the movie Blade Runner?")

RAG-система с оптимизацией

import dspy
from dspy.retrieve.chromadb_rm import ChromadbRM

# Настройка ретривера
retriever = ChromadbRM(
    collection_name="documents",
    persist_directory="./chroma_db"
)

class RAG(dspy.Module):
    def __init__(self, num_passages=3):
        super().__init__()
        self.retrieve = dspy.Retrieve(k=num_passages)
        self.generate = dspy.ChainOfThought("context, question -> answer")

    def forward(self, question):
        context = self.retrieve(question).passages
        return self.generate(context=context, question=question)

# Создание и оптимизация
rag = RAG()

# Оптимизация с обучающими данными
from dspy.teleprompt import BootstrapFewShot

optimizer = BootstrapFewShot(metric=validate_answer)
optimized_rag = optimizer.compile(rag, trainset=trainset)

Конфигурация провайдера LM

Антропный Клод

import dspy

lm = dspy.Claude(
    model="claude-sonnet-4-5-20250929",
    api_key="your-api-key",  # Или установите переменную окружения ANTHROPIC_API_KEY
    max_tokens=1000,
    temperature=0.7
)
dspy.settings.configure(lm=lm)

OpenAI

lm = dspy.OpenAI(
    model="gpt-4",
    api_key="your-api-key",
    max_tokens=1000
)
dspy.settings.configure(lm=lm)

Локальные модели (Оллама)

lm = dspy.OllamaLocal(
    model="llama3.1",
    base_url="http://localhost:11434"
)
dspy.settings.configure(lm=lm)

Несколько моделей

# Разные модели для разных задач
cheap_lm = dspy.OpenAI(model="gpt-3.5-turbo")
strong_lm = dspy.Claude(model="claude-sonnet-4-5-20250929")

# Используйте дешёвую модель для извлечения, сильную для рассуждения
with dspy.settings.context(lm=cheap_lm):
    context = retriever(question)

with dspy.settings.context(lm=strong_lm):
    answer = generator(context=context, question=question)

Типовые узоры

Шаблон 1: Структурированный вывод

from pydantic import BaseModel, Field

class PersonInfo(BaseModel):
    name: str = Field(description="Полное имя")
    age: int = Field(description="Возраст в годах")
    occupation: str = Field(description="Текущая работа")

class ExtractPerson(dspy.Signature):
    """Извлеките информацию о человеке из текста."""
    text = dspy.InputField()
    person: PersonInfo = dspy.OutputField()

extractor = dspy.TypedPredictor(ExtractPerson)
result = extractor(text="John Doe is a 35-year-old software engineer.")
print(result.person.name)  # "John Doe"
print(result.person.age)   # 35

Схема 2: Оптимизация на основе утверждений

import dspy
from dspy.primitives.assertions import assert_transform_module, backtrack_handler

class MathQA(dspy.Module):
    def __init__(self):
        super().__init__()
        self.solve = dspy.ChainOfThought("problem -> solution: float")

    def forward(self, problem):
        solution = self.solve(problem=problem).solution

        # Утверждение, что решение числовое
        dspy.Assert(
            isinstance(float(solution), float),
            "Решение должно быть числом",
            backtrack=backtrack_handler
        )

        return dspy.Prediction(solution=solution)

Схема 3: Самосогласованность

import dspy
from collections import Counter

class ConsistentQA(dspy.Module):
    def __init__(self, num_samples=5):
        super().__init__()
        self.qa = dspy.ChainOfThought("question -> answer")
        self.num_samples = num_samples

    def forward(self, question):
        # Генерация нескольких ответов
        answers = []
        for _ in range(self.num_samples):
            result = self.qa(question=question)
            answers.append(result.answer)

        # Возврат самого частого ответа
        most_common = Counter(answers).most_common(1)[0][0]
        return dspy.Prediction(answer=most_common)

Схема 4: Извлечение с переранжированием

class RerankedRAG(dspy.Module):
    def __init__(self):
        super().__init__()
        self.retrieve = dspy.Retrieve(k=10)
        self.rerank = dspy.Predict("question, passage -> relevance_score: float")
        self.answer = dspy.ChainOfThought("context, question -> answer")

    def forward(self, question):
        # Извлечение кандидатов
        passages = self.retrieve(question).passages

        # Переранжирование отрывков
        scored = []
        for passage in passages:
            score = float(self.rerank(question=question, passage=passage).relevance_score)
            scored.append((score, passage))

        # Взять топ-3
        top_passages = [p for _, p in sorted(scored, reverse=True)[:3]]
        context = "\n\n".join(top_passages)

        # Генерация ответа
        return self.answer(context=context, question=question)

Оценка и метрики

Пользовательские метрики

def exact_match(example, pred, trace=None):
    """Метрика точного совпадения."""
    return example.answer.lower() == pred.answer.lower()

def f1_score(example, pred, trace=None):
    """F1-мера для перекрытия текста."""
    pred_tokens = set(pred.answer.lower().split())
    gold_tokens = set(example.answer.lower().split())

    if not pred_tokens:
        return 0.0

    precision = len(pred_tokens & gold_tokens) / len(pred_tokens)
    recall = len(pred_tokens & gold_tokens) / len(gold_tokens)

    if precision + recall == 0:
        return 0.0

    return 2 * (precision * recall) / (precision + recall)

Оценка

from dspy.evaluate import Evaluate

# Создание оценщика
evaluator = Evaluate(
    devset=testset,
    metric=exact_match,
    num_threads=4,
    display_progress=True
)

# Оценка модели
score = evaluator(qa_system)
print(f"Точность: {score}")

# Сравнение оптимизированной и неоптимизированной
score_before = evaluator(qa)
score_after = evaluator(optimized_qa)
print(f"Улучшение: {score_after - score_before:.2%}")

Лучшая практика

1. Начинайте с простого, итерируйте

# Начните с Predict
qa = dspy.Predict("question -> answer")

# Добавьте рассуждение, если нужно
qa = dspy.ChainOfThought("question -> answer")

# Добавьте оптимизацию, когда есть данные
optimized_qa = optimizer.compile(qa, trainset=data)

2. Используйте описательные подписи

# ❌ Плохо: Расплывчато
class Task(dspy.Signature):
    input = dspy.InputField()
    output = dspy.OutputField()

# ✅ Хорошо: Описательно
class SummarizeArticle(dspy.Signature):
    """Суммируйте новостные статьи в 3-5 ключевых пунктов."""
    article = dspy.InputField(desc="полный текст статьи")
    summary = dspy.OutputField(desc="маркированный список, 3-5 пунктов")

3. Оптимизируйте репрезентативные данные

# Создайте разнообразные обучающие примеры
trainset = [
    dspy.Example(question="фактический", answer="...").with_inputs("question"),
    dspy.Example(question="рассуждение", answer="...").with_inputs("question"),
    dspy.Example(question="вычисление", answer="...").with_inputs("question"),
]

# Используйте валидационный набор для метрики
def metric(example, pred, trace=None):
    return example.answer in pred.answer

4. Сохраняйте и загружайте надежные модели.

# Сохранение
optimized_qa.save("models/qa_v1.json")

# Загрузка
loaded_qa = dspy.ChainOfThought("question -> answer")
loaded_qa.load("models/qa_v1.json")

5. Мониторинг и отладка

# Включение трассировки
dspy.settings.configure(lm=lm, trace=[])

# Запуск предсказания
result = qa(question="...")

# Просмотр трассировки
for call in dspy.settings.trace:
    print(f"Промпт: {call['prompt']}")
    print(f"Ответ: {call['response']}")

Сравнение с другими подходами

Особенность Ручное описание предложений Лангчейн ДСПи
Инжиниринг промптов Вручную Вручную Автоматически
Оптимизация Метод проб и ошибок Нет На основе данных
Модульность Низкая Средняя Высокий
Тип безопасности Нет Ограниченная Да (Сигнатуры)
Переносимость Низкая Средняя Высокий
Кривая обучение Низкая Средняя Средне-высокая

При выборе DSPy: - У вас есть обучающие данные или вы можете их сгенерировать. - Вам необходимо систематическое улучшение промптов. - Вы строите сложные многоступенчатые системы. - Вы хотите адаптировать LM для разных версий

При выборе альтернатив: - Быстрые прототипы (ручное описание подсказок) - Простые цепочки с существующими инструментами (LangChain) - Нужна пользовательская оптимизация логики

Ресурсы

См. также