Оптимизация LLM с помощью DSPy: пошаговое руководство по созданию, оптимизации и оценке систем искусственного интеллекта

Поскольку возможности больших языковых моделей (LLM) продолжают расширяться, разработка надежных систем искусственного интеллекта, использующих их потенциал, становится все более сложной. Традиционные подходы часто включают в себя сложные методы подсказок, генерацию данных для точной настройки и ручное руководство для обеспечения соблюдения ограничений, специфичных для конкретной предметной области. Однако этот процесс может быть утомительным, подверженным ошибкам и в значительной степени зависеть от вмешательства человека.

Enter DSPy, революционная платформа, предназначенная для оптимизации разработки систем искусственного интеллекта на базе LLM. DSPy представляет систематический подход к оптимизации подсказок и весов LM, что позволяет разработчикам создавать сложные приложения с минимальными ручными усилиями.

В этом подробном руководстве мы рассмотрим основные принципы DSPy, его модульную архитектуру и набор мощных функций. Мы также рассмотрим практические примеры, демонстрирующие, как DSPy может преобразить ваш подход к разработке систем ИИ с участием LLM.

Что такое DSPy и зачем он вам нужен?

DSPy — это платформа, которая разделяет поток вашей программы (modules) из параметров (подсказок LM и весов) каждого шага. Такое разделение позволяет систематически оптимизировать подсказки и веса LM, позволяя создавать сложные системы искусственного интеллекта с большей надежностью, предсказуемостью и соблюдением ограничений, специфичных для предметной области.

Традиционно разработка систем искусственного интеллекта с помощью LLM включала в себя трудоемкий процесс разбиения проблемы на этапы, создания сложных подсказок для каждого шага, создания синтетических примеров для точной настройки и ручного управления LM для соблюдения конкретных ограничений. Этот подход не только отнимал много времени, но и был подвержен ошибкам, поскольку даже незначительные изменения в конвейере, LM или данных могли потребовать обширной переработки подсказок и шагов точной настройки.

DSPy решает эти проблемы, вводя новую парадигму: оптимизаторы. Эти алгоритмы на основе LM могут настраивать подсказки и веса ваших вызовов LM с учетом показателя, который вы хотите максимизировать. Автоматизируя процесс оптимизации, DSPy дает разработчикам возможность создавать надежные системы искусственного интеллекта с минимальным ручным вмешательством, повышая надежность и предсказуемость результатов LM.

Модульная архитектура DSPy

В основе DSPy лежит модульная архитектура, которая упрощает компоновку сложных систем искусственного интеллекта. Платформа предоставляет набор встроенных модулей, которые абстрагируют различные методы подсказок, такие как dspy.ChainOfThought и dspy.ReAct. Эти модули можно комбинировать и объединять в более крупные программы, что позволяет разработчикам создавать сложные конвейеры, адаптированные к их конкретным требованиям.

Каждый модуль инкапсулирует обучаемые параметры, включая инструкции, примеры с несколькими ударами и веса LM. При вызове модуля оптимизаторы DSPy могут точно настроить эти параметры для максимизации желаемой метрики, гарантируя, что выходные данные LM соответствуют заданным ограничениям и требованиям.

Оптимизация с помощью DSPy

DSPy представляет ряд мощных оптимизаторов, предназначенных для повышения производительности и надежности ваших систем искусственного интеллекта. Эти оптимизаторы используют алгоритмы на основе LM для настройки подсказок и весов ваших вызовов LM, максимизируя заданную метрику, соблюдая при этом ограничения, специфичные для предметной области.

Некоторые из ключевых оптимизаторов, доступных в DSPy, включают:

1. BootstrapFewShot: этот оптимизатор расширяет сигнатуру, автоматически генерируя и включая оптимизированные примеры в приглашение, отправленное в модель, реализуя обучение за несколько шагов.
2. BootstrapFewShotWithRandomSearch: Применяется BootstrapFewShot несколько раз случайным перебором по сгенерированным демонстрациям, выбор лучшей программы по оптимизации.
3. MIPRO: генерирует инструкции и примеры из нескольких кадров на каждом этапе, при этом генерация инструкций учитывает данные и демонстрацию. Он использует байесовскую оптимизацию для эффективного поиска в пространстве инструкций генерации и демонстраций ваших модулей.
4. BootstrapFinetune: превращает программу DSPy на основе подсказок в обновления веса для небольших LM, что позволяет вам точно настроить базовые LLM для повышения эффективности.

Используя эти оптимизаторы, разработчики могут систематически оптимизировать свои системы искусственного интеллекта, обеспечивая высокое качество результатов, соблюдая при этом ограничения и требования, специфичные для конкретной предметной области.

Начало работы с DSPy

Чтобы проиллюстрировать возможности DSPy, давайте рассмотрим практический пример создания системы генерации дополненной поисковой информации (RAG) для вопросно-ответных задач.

Шаг 1. Настройка языковой модели и модели поиска

Первый шаг включает настройку языковой модели (LM) и модели поиска (RM) в DSPy.

Чтобы установить DSPy, выполните:

pip install dspy-ai

DSPy поддерживает несколько API-интерфейсов LM и RM, а также локальный хостинг моделей, что упрощает интеграцию предпочитаемых вами моделей.

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. Загрузка набора данных

Далее мы загрузим набор данных 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)

# 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. Создание подписей

DSPy использует сигнатуры для определения поведения модулей. В этом примере мы определим сигнатуру для задачи генерации ответа, указав входные поля (контекст и вопрос) и выходное поле (ответ).

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

Шаг 4: Создание конвейера

Мы построим наш конвейер RAG как модуль DSPy, который состоит из метода инициализации (__init__) для объявления подмодулей (dspy.Retrieve и dspy.ChainOfThought) и метода пересылки (forward) для описания потока управления ответом на вопрос с использованием этих модулей.

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)

Шаг 5: Оптимизация конвейера

Определив конвейер, мы можем оптимизировать его с помощью оптимизаторов DSPy. В этом примере мы будем использовать оптимизатор BootstrapFewShot, который генерирует и выбирает эффективные подсказки для наших модулей на основе обучающего набора и метрики для проверки.

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)

Шаг 6: Оценка конвейера

После компиляции программы важно оценить ее производительность на тестовом наборе, чтобы убедиться, что она соответствует желаемой точности и надежности.

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

Шаг 7: Проверка истории модели

Для более глубокого понимания взаимодействий модели вы можете просмотреть самые последние поколения, изучив историю модели.

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

Шаг 8: Делаем прогнозы

Теперь, когда конвейер оптимизирован и оценен, вы можете использовать его для прогнозирования новых вопросов.

# 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

Теперь давайте рассмотрим еще один минимальный рабочий пример с использованием Набор данных GSM8K и модель OpenAI GPT-3.5-turbo для моделирования задач подсказок в DSPy.

Установка

Сначала убедитесь, что ваша среда настроена правильно:

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)

Команда gsm8k_trainset и gsm8k_devset наборы данных содержат список примеров, каждый из которых имеет поле вопросов и ответов.

Определите модуль

Затем определите собственную программу, используя модуль ChainOfThought для пошагового рассуждения:

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

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

Скомпилируйте и оцените модель

Теперь скомпилируйте его с помощью BootstrapFewShot телесуфлер:

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)

В этом примере показано, как настроить среду, определить собственный модуль, скомпилировать модель и тщательно оценить ее производительность, используя предоставленный набор данных и конфигурации телесуфлера.

Управление данными в DSPy

DSPy работает с наборами для обучения, разработки и тестирования. Для каждого примера в ваших данных обычно есть три типа значений: входные, промежуточные метки и конечные метки. Хотя промежуточные или конечные метки не являются обязательными, важно иметь несколько примеров входных данных.

Создание примеров объектов

Примеры объектов в DSPy похожи на словари Python, но имеют полезные утилиты:

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)

Вывод:

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

Указание клавиш ввода

В DSPy объекты примера имеют метод with_inputs() для пометки определенных полей как входных:

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

Доступ к значениям можно получить с помощью оператора точки, а такие методы, как inputs() и labels(), возвращают новые объекты примера, содержащие только входные или невходящие ключи соответственно.

Оптимизаторы в DSPy

Оптимизатор DSPy настраивает параметры программы DSPy (т. е. подсказки и/или веса LM) для максимизации заданных показателей. DSPy предлагает различные встроенные оптимизаторы, каждый из которых использует разные стратегии.

Доступные оптимизаторы

• BootstrapFewShot: генерирует примеры из нескольких снимков, используя предоставленные помеченные точки входных и выходных данных.
• BootstrapFewShotWithRandomSearch: применяет BootstrapFewShot несколько раз со случайным поиском по сгенерированным демонстрациям.
• Copro: генерирует и уточняет новые инструкции для каждого шага, оптимизируя их с увеличением координат.
• MIPRO: оптимизирует инструкции и примеры с несколькими кадрами с использованием байесовской оптимизации.

Выбор оптимизатора

Если вы не знаете, с чего начать, используйте BootstrapFewShotWithRandomSearch:

Для очень небольшого количества данных (10 примеров) используйте BootstrapFewShot.
Чтобы получить немного больше данных (50 примеров), используйте BootstrapFewShotWithRandomSearch.
Для больших наборов данных (более 300 примеров) используйте MIPRO.

Вот как использовать BootstrapFewShotWithRandomSearch:

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)

Сохранение и загрузка оптимизированных программ

После запуска программы через оптимизатор сохраните ее для дальнейшего использования:

оптимизированная_программа.save(ВАШ_ПУТЬ_СОХРАНЕНИЯ)

Загрузите сохраненную программу:

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

Расширенные функции: утверждения DSPy

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

Использование утверждений

Определите функции проверки и объявите утверждения после соответствующей генерации модели. Например:

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

Преобразование программ с помощью утверждений

from dspy.primitives.assertions import assert_transform_module, backtrack_handler

baleen_with_assertions = assert_transform_module(SimplifiedBaleenAssertions(), backtrack_handler)

Альтернативно активируйте утверждения непосредственно в программе:

baleen_with_assertions = SimplifiedBaleenAssertions().activate_assertions()

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

Утверждения DSPy работают с оптимизацией DSPy, особенно с BootstrapFewShotWithRandomSearch, включая такие настройки, как:

• Компиляция с утверждениями
• Компиляция + вывод с утверждениями

Заключение

DSPy предлагает мощный и систематический подход к оптимизации языковых моделей и их подсказок. Следуя инструкциям, описанным в этих примерах, вы сможете легко создавать, оптимизировать и оценивать сложные системы искусственного интеллекта. Модульная структура DSPy и передовые оптимизаторы обеспечивают эффективную интеграцию различных языковых моделей, что делает его ценным инструментом для всех, кто работает в области обработки естественного языка и искусственного интеллекта.

Независимо от того, создаете ли вы простую вопросно-ответную систему или более сложный конвейер, DSPy обеспечивает гибкость и надежность, необходимые для достижения высокой производительности и надежности.