Книга: «Промт-инжиниринг для GenAI»

В эпоху стремительного развития искусственного интеллекта (ИИ) каждый, кто профессионально использует эту технологию, сталкивается с вызовом: качество результатов напрямую зависит от качества входных данных. Именно поэтому сегодня невозможно обойтись без промт-инжиниринга — набора методов, которые повышают надежность, эффективность и точность работы моделей ИИ.

Книга «Промт-инжиниринг для GenAI. Паттерны надежных запросов для качественных результатов» Джеймса Феникса и Майка Тейлора станет практическим руководством для тех, кто хочет освоить эту дисциплину и эффективно внедрить генеративный ИИ в свои рабочие процессы.

О чем книга?

Книга, как бы ни было это очевидно, посвящена промт-инжинирингу — искусству составления инструкций и подсказок для ИИ, которые позволяют получать качественные и точные результаты. Авторы утверждают, что промтинг станет таким же необходимым навыком для профессионалов, как когда-то стало владение Microsoft Excel. Это не модное направление, а фундаментальный инструмент, который меняет представление о работе с компьютерами и автоматизацией.

Большие языковые модели (LLM) и диффузионные модели, такие как ChatGPT и DALL-E, обучаются на огромных объемах данных из интернета. Это делает их мощными инструментами для решения задач, которые раньше казались недоступными для автоматизации. Однако необдуманное использование этих моделей часто приводит к спорным результатам. Книга учит, как избежать таких ошибок и максимально эффективно интегрировать ИИ в рабочие процессы.

Весь код, представленный в книге, написан на Python и предназначен для запуска в Jupyter Notebook (https://jupyter.org) или Google Colab (https://colab.research.google.com). Изложенные здесь концепции можно при желании перенести в JavaScript или любой другой язык программирования, потому что основное внимание в книге уделено методам промтинга, составления подсказок и инструкций для ИИ, а не традиционным навыкам программирования.

Почему стоит прочитать «Промт-инжиниринг для GenAI»?

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

1. Пять принципов промтинга, которые останутся актуальными даже с развитием технологий. Эти принципы применимы к разным моделям ИИ и помогут вам оставаться в тренде.
2. Практические примеры использования генеративного ИИ с применением популярных библиотек и фреймворков, таких как LangChain.
3. Сравнение моделей ИИ, включая GPT-4, DALL-E 2 и их альтернативы с открытым исходным кодом. Авторы подробно разбирают сильные и слабые стороны каждой модели.
4. Примеры применения промт-инжиниринга в различных областях: обработка естественного языка, генерация текста, изображений и даже кода.
5. Реальные кейсы автоматизации рутинных задач, которые помогут вам эффективно интегрировать ИИ в свои рабочие процессы.

Почему промт-инжиниринг — это важно?

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

Книга «Промт-инжиниринг для GenAI» поможет вам овладеть навыками, которые будут полезны независимо от того, как будут развиваться технологии в ближайшие годы. Если вы хотите оставаться на передовой цифрового прогресса, переходите на сайт!

А если у вас остались сомнения, обратите внимание на отрывок ниже:

Агенты

Появление генеративных моделей ИИ привело к созданию архитектуры на основе агентов. Концептуально агент действует и принимает решения в некоторой среде, стремясь достигнуть заранее определенных целей.

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

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

next_action = agent.get_action(...)
while next_action != AgentFinish:
      observation = run(next_action)
      next_action = agent.get_action(..., next_action, observation)
return next_action

Поведение агента определяется тремя основными компонентами.

Входы
Это сенсорные стимулы или данные, которые агент получает из окружающей среды. Входы могут быть самыми разными: от визуальных (например, изображения) и слуховых (например, аудиофайлы) до тепловых сигналов и т. д.

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

Доступные действия
Пространство действий — это диапазон допустимых действий, которые агент может предпринять в любой момент (https://oreil.ly/5AVfM). Широта и характер этого пространства зависят от поставленной задачи.

Для более подробного объяснения этих концепций рассмотрим пример беспилотного автомобиля.

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

Целевая функция, или функция вознаграждения
Основная цель беспилотного автомобиля — безопасно и эффективно добраться из точки А в точку Б. При использовании системы, основанной на вознаграждении, автомобиль будет получать положительные вознаграждения, если будет стараться держаться на безопасном расстоянии от других объектов, соблюдать скоростной режим и правила дорожного движения. И наоборот, он будет получать штрафы за рискованное поведение, такое как резкое торможение или выезд за пределы полосы движения. Компания Tesla, в частности, использует в качестве функции вознаграждения мили, пройденные без вмешательства человека.

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

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

Вот как они отвечают нашим потребностям.

Входы
Взаимодействия с LLM в основном осуществляются посредством текстовых сообщений. Но это не ограничивает богатство информации, которую можно использовать. Любые имеющиеся у вас данные — показания температуры, нотную запись мелодий или сложные структуры данных — вы должны превратить в текстовые представления, которые сможет проанализировать LLM. Возьмем для примера видео: LLM не сможет проанализировать исходные кадры, но текстовое описание поможет ей извлечь ценную для вас информацию.

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

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

Существуют также различные компоненты, которые напрямую применимы к LLM.

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

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

Поиск
Модели LLM могут использовать различные типы поиска. Наиболее распространенным является поиск в векторных базах данных по семантическому сходству, но есть и другие виды поиска, например включение в запросы информации из базы данных SQL.

Рассмотрим подробнее наиболее типичные компоненты и изучим детали их реализации.

Рассуждения и действие (Reason and Act, ReAct)

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

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

Фреймворк ReAct (https://oreil.ly/ssdnL) использует сочетание декомпозиции задач, цикла размышлений и нескольких инструментов для разрешения вопросов. Давайте исследуем организацию цикла размышлений в ReAct.

1. Наблюдение за окружающей средой.
2. Интерпретация наблюдений путем размышлений.
3. Определение действия.
4. Выполнение действия в окружающей среде.
5. Повторять шаги 1–4, пока не будет найдено решение или пока не выполнится достаточное число итераций.

Вы можете без труда создать запрос в стиле ReAct, используя предыдущий цикл размышлений, а также предоставив LLM некоторые входные данные, такие как:

• {question}: вопрос, на который вы хотите получить ответ;
• {tools}: функции, которые можно использовать для выполнения очередного шага в процессе решения общей задачи. Обычной практикой является включение списка инструментов, каждый из которых представляет собой функцию на Python — имя функции и описание ее назначения.

Ниже приводится промт, реализующий паттерн ReAct с переменными, заключенными в фигурные скобки {}, например {question}:

Попытайся решить задачу поиска ответа на вопрос.
Для решения используй такую цепочку рассуждений:
1. Рассмотри исходный вопрос:
original_question: original_problem_text
2. Создай наблюдение по следующему шаблону:
observation: observation_text
3. Сделай логический вывод, исходя из наблюдения по следующему шаблону:
thought: thought_text
4. Используй инструменты для выполнения действий на основе рассуждений
по следующему шаблону:
action: tool_name
action_input: tool_input

Не надо придумывать или предполагать результаты инструмента, а предоставь
структурированный вывод, включающий action и action_input.

Тебе доступны следующие инструменты: {tools}.

original_problem: {question}

Основываясь на результате применения инструмента:

Представь следующее наблюдение, действие, входные данные для действия
или окончательный ответ, если доступен.

Возвращая окончательный ответ, верни его с применением следующего шаблона:
"Я нашел ответ: final_answer"

Рассмотрим поближе структуру запроса.

1. Вводная часть запроса четко определяет цель LLM: Попытайся решить задачу поиска ответа на вопрос.
2. Далее описывается подход к решению задачи: Для решения используй такую цепочку рассуждений:
3. Затем перечисляются этапы цепочки рассуждений:
   • сначала LLM должна рассмотреть исходный вопрос и сформулировать сделанное: original_question: original_problem_text, observation: observation_text;
   • основываясь на этом наблюдении, ИИ должен сформулировать логический вывод, обозначающий шаг в процессе рассуждений: thought: thought_text;
   • после формулировки логического вывода модель должна выбрать действие, используя один из доступных инструментов: action: tool_name, action_input: tool_input.
4. Затем модели LLM дается напоминание, что она не должна делать предположений о том, какие результаты может вернуть инструмент, и должна четко обозначить действие и соответствующие входные данные.
5. Текст Тебе доступны следующие инструменты: {tools} сообщает LLM, какие инструменты ей доступны для решения задачи.
6. Затем описывается сама задача, которую должна решить LLM: original_problem: {question}.
7. В заключение модели LLM даются инструкции о том, как реагировать на результаты действий. Она может либо продолжить делать новые наблюдения, выполнять действия и определять входные данные для этих действий, либо, если решение найдено, представить окончательный ответ.

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

Реализация паттерна ReAct

Теперь, познакомившись с паттерном ReAct, давайте напишем простую его реализацию на Python, которая повторяет то, что LangChain делает автоматически. Это позволит вам понять, что на самом деле происходит между ответами LLM.

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

Простая реализация ReAct должна делать следующее.

1. На каждом этапе любого рассуждения извлечь инструмент по желанию LLM для последующего использования. Поэтому мы должны извлечь последние элементы action и action_input. Действие action определяет имя инструмента, а action_input — его аргументы.
2. Проверить, считает ли LLM, что ей удалось найти окончательный ответ, и в этом случае цикл рассуждений завершается.

Для извлечения значений action и action_input из ответа LLM можно использовать регулярные выражения:

import re

# Образец текста:
text = """
action: search_on_google
action_input: Как зовут жену Тома Хэнкса

action: search_on_wikipedia
action_input: Сколько лет было Рите Уилсон в 2023

action: search_on_google
action_input: какой-то другой вопрос
"""

# Скомпилировать регулярные выражения:
action_pattern = re.compile(r"(?i)actions*:s*([^n]+)", re.MULTILINE)
action_input_pattern = re.compile(r"(?i)actions*_*inputs*:s*([^n]+)",
re.MULTILINE)

# Найти все вхождения action и action_input:
actions = action_pattern.findall(text)
action_inputs = action_input_pattern.findall(text)

# Извлечь последнее вхождение action и action_input:
last_action = actions[-1] if actions else None
last_action_input = action_inputs[-1] if action_inputs else None
print("Last Action:", last_action)
print("Last Action Input:", last_action_input)
# Last Action: search_on_google
# Last Action Input: какой-то другой вопрос

Разберем подробно, как работает регулярное выражение, извлекающее действие action:

• action_pattern = re.compile(r"(?i)actions*:s*([^n]+)", re.MULTILINE);
• (?i) — это так называемый встроенный флаг, который включает нечувствительность регулярного выражения к регистру символов. Это означает, что шаблон будет соответствовать последовательностям символом action, Action, ACTION и любой другой комбинации из прописных и строчных букв;
• action — эта часть шаблона буквально соответствует слову «action». Благодаря флагу, включающему нечувствительность к регистру символов, эта часть шаблона будет соответствовать любому написанию слова «action» c применением прописных и строчных букв;
• s* — эта часть шаблона соответствует произвольному количеству (ноль и более) пробельных символов (пробелов, табуляций и т. д.). Символ * означает «ноль или более», а s — это сокращенная запись шаблона, соответствующего пробельным символам;
• : — эта часть шаблона буквально соответствует символу двоеточия;
• s* — как и предыдущая часть s*, соответствует произвольному количеству (ноль и более) пробельных символов, следующих за двоеточием;
• +([^n]++) — это сохраняющая группа, соответствующая одному или нескольким символам, которые не являются символом перевода строки. Символ ^ внутри квадратных скобок [] означает отрицание, а n — символ перевода строки. + означает «один и более». Текст, соответствующий этой группе, можно будет извлечь с помощью функции findall();
• re.MULTILINE — это флаг, передаваемый в вызов функции re.compile(). Он сообщает механизму регулярных выражений, что входной текст может состоять из нескольких строк, поэтому шаблон следует применять построчно;
• в регулярных выражениях квадратные скобки [] используются для определения класса символов — набора символов, которым он должен соответствовать. Например, [abc] будет соответствовать любому одиночному символу «a», «b» или «c»;
• символ крышки ^ в начале класса символов отрицает класс символов, то есть такой класс будет соответствовать любым символам, не перечисленным в классе, а значит, шаблон [^abc] будет соответствовать любому отдельному символу, кроме «a», «b» или «c». В шаблоне +([^n]++) указан класс символов — [^n], то есть этот шаблон будет соответствовать любому символу, который не является символом перевода строки (n). Знак + после класса означает, что шаблон должен соответствовать одному или нескольким символам, которые не являются символом перевода строки;
• используя класс символов с отрицанием [^n] в сохраняющей группе, мы гарантируем, что механизм регулярных выражений сохранит текст до конца строки, не включая символ перевода строки. Это может пригодиться для извлечения текста после слова action или action_input до конца строки.

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

Единственная разница между этими двумя шаблонами регулярных выражений — буквальный текст, который они ищут в начале.

1. action_pattern ищет слово action.
2. action_input_pattern ищет слово action_input.

Теперь можно абстрагировать регулярное выражение за фасадом функции Python, которая отыскивает и возвращает последние найденные элементы action и action_input:

def extract_last_action_and_input(text):
   # Скомпилировать регулярные выражения
   action_pattern = re.compile(r"(?i)actions*:s*([^n]+)", re.MULTILINE)
   action_input_pattern = re.compile(
      r"(?i)actions*_*inputs*:s*([^n]+)", re.MULTILINE
   )

   # Найти все вхождения элементов action и action_input
   actions = action_pattern.findall(text)
   action_inputs = action_input_pattern.findall(text)

   # извлечь последнее вхождение action и action_input
   last_action = actions[-1] if actions else None
   last_action_input = action_inputs[-1] if action_inputs else None

   return {"action": last_action, "action_input": last_action_input}

extract_last_action_and_input(text)
# {'action': 'search_on_google', 'action_input': 'какой-то другой вопрос'}

Чтобы определить, нашла ли LLM окончательный ответ, и извлечь его, тоже можно использовать регулярные выражения:

def extract_final_answer(text):
   final_answer_pattern = re.compile(
      r"(?i)Я нашел ответ:s*([^n]+)", re.MULTILINE
   )
   final_answers = final_answer_pattern.findall(text)
   if final_answers:
      return final_answers[0]
   else:
      return None

final_answer_text = "Я нашел ответ: final_answer"
print(extract_final_answer(final_answer_text))
# final_answer

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

Теперь объединим все компоненты, действуя шаг за шагом:

from langchain_openai.chat_models import ChatOpenAI
from langchain.prompts.chat import SystemMessagePromptTemplate

Инициализируем экземпляр ChatOpenAI:

chat = ChatOpenAI(model_kwargs={"stop": ["tool_result:"],})

Добавление последовательности stop заставляет LLM прекратить генерировать новые токены после обнаружения фразы "tool_result:". Это помогает остановить галлюцинации по поводу использования инструментов.

Определим доступные инструменты:

tools = {}

def search_on_google(query: str):
   return f"У Джейсона Деруло нет жены или партнера."

tools["search_on_google"] = {
   "function": search_on_google,
   "description": "Ищет ответ на вопрос в Google",
}

Определим базовый шаблон запроса:

base_prompt = """
Попытайся решить задачу поиска ответа на вопрос.
Для решения используй такую цепочку рассуждений:

1. Рассмотри исходный вопрос:
original_question: original_problem_text
2. Создай наблюдение по следующему шаблону:
observation: observation_text
3. Сделай логический вывод, исходя из наблюдения, по следующему шаблону:
thought: thought_text
4. Используй инструменты для выполнения действий на основе рассуждений
по следующему шаблону:
action: tool_name
action_input: tool_input

Не надо придумывать или предполагать результаты инструмента, а предоставь
структурированный вывод, включающий action и action_input.

Тебе доступны следующие инструменты: {tools}.

original_problem: {question}
"""

Сгенерируем вывод модели:

output = chat.invoke(SystemMessagePromptTemplate 
.from_template(template=base_prompt) 
.format_messages(tools=tools, question="У Джейсона Деруло есть партнер?"))
print(output)

Извлечем последние элементы action и action_input и вызовем соответствующую функцию:

tool_name = extract_last_action_and_input(output.content)["action"]
tool_input = extract_last_action_and_input(output.content)["action_input"]
tool_result = tools[tool_name]["function"](tool_input)

Выведем информацию об инструменте:

print(f"""Агент решил использовать следующий инструмент:
tool_name: {tool_name}
tool_input: {tool_input}
tool_result: {tool_result}"""
)

Определить текущий запрос с результатом, полученным от инструмента:

current_prompt = """
Ты ответил на вопрос: У Джейсона Деруло есть партнер?

Основываясь на результате применения инструмента:
tool_result: {tool_result}

Представь следующее наблюдение, действие, входные данные для действия
или окончательный ответ, если доступен. Возвращая окончательный ответ,
верни его с применением следующего шаблона: "Я нашел ответ: final_answer"
"""

Сгенерируем вывод модели для текущего запроса:

output = chat.invoke(SystemMessagePromptTemplate. 
from_template(template=current_prompt) 
.format_messages(tool_result=tool_result))

Выведем ответ модели на текущий запрос:

print("----------nnВывод модели:", output.content)
final_answer = extract_final_answer(output.content)
if final_answer:
   print(f"Ответ: {final_answer}")
else:
   print("Окончательный ответ не найден.")

Вывод:

'''content='1. Рассмотри исходный вопрос:nУ Джейсона Деруло есть
партнер?nn2. Создай наблюдение:nУ нас нет никакой информации
об отношениях Джейсона Деруло с кем-либо.nn3. Сделай логический вывод,
исходя из наблюдения:nМы можем поискать последние новости или интервью,
чтобы узнать, связан ли Джейсон Деруло отношениями с кем-нибудь в настоящее
время.nn4. Используй инструменты для выполнения действий на основе
рассуждений:n action: search_on_googlenaction_input: "текущие отношения
Джейсона Деруло"' additional_kwargs={} example=False

----------
Агент решил использовать следующий инструмент:
tool_name: search_on_google

tool_input: "текущие отношения Джейсона Деруло"
tool_result: У Джейсона Деруло нет жены или партнера.
----------

Второй запрос показывает
Основываясь на результате применения инструмента:
tool_result: {tool_result}

Представь следующее наблюдение, действие, входные данные для действия
или окончательный ответ, если доступен. Возвращая окончательный ответ,
верни его с применением следующего шаблона: "Я нашел ответ: final_answer"

Вывод модели: Я нашел ответ: У Джейсона Деруло нет жены или партнера.
Ответ: у Джейсона Деруло нет жены или партнера'''.

Предыдущие шаги представляют очень простую реализацию паттерна ReAct. В данном случае LLM решил использовать инструмент search_on_google с текстом "текущие отношения Джейсона Деруло" в качестве action_input.

Агенты LangChain автоматически выполнят все предыдущие шаги, а также обеспечат использование нескольких инструментов (в цикле) и обработку их сбоев, когда у агента не получится проанализировать action или action_input.

Использование инструментов

Большие языковые модели, такие как GPT-4, могут генерировать только текст, поэтому предоставление им инструментов, помогающих выполнять другие действия, такие как взаимодействие с базой данных или чтение/запись файлов, позволяет эффективно расширить возможности LLM. Инструмент — это всего лишь предопределенная функция, помогающая агенту выполнить определенное действие.

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

Твоя цель: {goal}
Тебе доступны следующие инструменты: {tools}

Большинство инструментов реализуются как функции на том или ином языке программирования. Изучая фреймворк LangChain, вы обнаружите, что он предлагает три подхода к созданию/использованию инструментов:

• создание собственных инструментов;
• использование существующих инструментов;
• использование AgentToolkits — набора инструментов, предназначенных для выполнения конкретной задачи.

Начнем с создания своего инструмента, который проверяет длину строки с помощью LangChain:

# Импортировать необходимые классы и функции:
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_openai import ChatOpenAI
from langchain.tools import Tool

# Определить используемую LLM:
model = ChatOpenAI()

# Функция для подсчета числа символов в строке:
def count_characters_in_string(string):
   return len(string)

# Создать список инструментов:
# Сейчас имеется только один инструмент, подсчитывающий символы в строке.
tools = [
   Tool.from_function(
      func=count_characters_in_string,
      name="Count Characters in a text string",
      description="Count the number of characters in a text string",
   )
]

# Загрузить запрос react!
prompt = hub.pull("hwchase17/react")

# Сконструировать агента ReAct:
agent = create_react_agent(model, tools, prompt)

# Создать механизм выполнения и передать ему агента и набор инструментов:
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# вызвать агента с запросом, требующим подсчитать символы в заданном слове:
agent_executor.invoke({"input": '''How many characters are in the word
"supercalifragilisticexpialidocious"?'''})

# 'There are 34 characters in the word "supercalifragilisticexpialidocious".'

После импорта необходимых модулей инициализируется модель чата ChatOpenAI. Затем создается функция count_characters_in_string, которая определяет длину любой заданной строки. Эта функция инкапсулируется в объект Tool с описательным именем и пояснением ее роли.

Далее с помощью create_react_agent создается агент на основе набора инструментов Tools, модели ChatOpenAI и запроса react, полученного из хаба LangChain. В результате получается комплексный интерактивный агент.

Применением AgentExecutor агент оснащается инструментами и для него включается режим подробного журналирования.

В заключение вызывается agent_executor.invoke(...) с запросом, требующим подсчитать количество символов в слове 'supercalifragilisticexpialidocious'. Агент использует определенный инструмент и возвращает точный результат.

В примере 6.1 можно видеть, что агент решил использовать действие Action: Count Characters in a text string с входными данными Action Input: 'supercalifragilisticexpialidocious'. Этот шаблон очень похож на упрощенную реализацию ReAct, созданную нами выше.

Пример 6.1. Вывод агента с единственным инструментом

Entering new AgentExecutor change...
I should count the number of characters in the word
"supercalifragilisticexpiladocious".
Action: Count Characters in a text string
Action Input: "supercalifragilisticexpiladocious"
Observation: 34
Thought: I now know the final answer
Final Answer: There are 34 characters in the word
"supercalifragilisticexpiladocious".

Задайте направление

Выразительные названия для ваших функций Python и описания инструментов повысят способность LLM эффективно выбирать правильные инструменты

Об авторах

Джеймс Феникс — эксперт в области разработки конвейеров данных и автоматизации рутинных задач. Он провел более 60 учебных курсов по data science и активно сотрудничает с Майком Тейлором на платформах Udemy и Vexpower. С момента появления бета-версии GPT-3 в 2020 году Джеймс занимается промт-инжинирингом, автоматизируя свои рабочие процессы и помогая другим проектам в этой области.

Майк Тейлор — сооснователь маркетингового агентства Ladder, которое насчитывает 50 сотрудников и имеет офисы в США, Великобритании и ЕС. Более 400 000 человек прошли его курсы по маркетингу и ИИ на платформах LinkedIn Learning, Udemy и Vexpower. Майк также начал заниматься промт-инжинирингом с появлением GPT-3 и теперь активно применяет эти навыки в своих проектах.

Чтобы ознакомиться с книгой «Промт-инжиниринг для GenAI», переходите на сайт издательства.

» Оглавление
» Отрывок

По факту оплаты бумажной версии книги на e-mail высылается электронная книга.
Для Хаброжителей скидка 25% по купону — Промт-инжиниринг