Зажигание революции ИИ — путешествие с RAG и LangChain

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

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

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

Большие языковые модели и генеративный ИИ: двигатели инноваций

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

Большие языковые модели (LLM)

LLM, такие как QwenGPT и другие, являются титанами текста, способными понимать и генерировать человекоподобный язык в массовом масштабе. Эти модели были обучены на обширных корпусах текстовых данных, что позволяет им прогнозировать и создавать последовательные и контекстуально релевантные строки текста. Они являются основой многих задач обработки естественного языка, от перевода до создания контента.

Генеративный ИИ (GenAI)

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

LangChain: оркестровка вашей симфонией ИИ

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

Hugging Face: мегаполис модели ИИ

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

RAG: использование векторных баз данных для ускоренного интеллекта

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

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

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

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

Вооружившись обогащенным пониманием LangChain, Hugging Face, LLM, GenAI и RAG с расширенной векторной базой данных, мы стоим на пороге приключения в области кодирования, которое воплотит эти технологии в жизнь. Сценарий Python, в который мы углубимся, представляет собой синергию этих элементов, демонстрируя систему ИИ, способную реагировать не только творчеством и контекстом, но и глубиной понимания, когда-то считавшимся областью научной фантастики. Подготовьтесь к работе с кодом и испытайте преобразующую силу RAG с векторными базами данных.

Начать путешествие по кодированию

Прежде чем вы начнете: основы

Прежде чем мы отправимся в эту техническую одиссею, давайте убедимся, что у вас есть все необходимое:

Сервер Linux лучше с графическим процессором — потому что давайте посмотрим правде в глаза, скорость имеет решающее значение.
Python 3.6 или выше — волшебная палочка программирования.
pip или Anaconda — ваши удобные менеджеры пакетов dandy.
Если это с графическим процессором, то драйверы NVIDIA, CUDA Toolkit и cuDNN — святая троица для ускорения графического процессора.

Все готово? Прекрасно! Давайте испачкаем руки (в переносном смысле, конечно).

Запуск кода

Тщательно управляя зависимостями Python, Вы гарантируете, что ваш проект ИИ построен на стабильной и надежной основе. С зависимостями на месте и средой, настроенной правильно, вы все готовы запустить сценарий и увидеть силу RAG и LangChain в действии.

Теперь вы можете выполнить сценарий Python, чтобы увидеть RAG в действии.

Настройка сцены: импорт библиотек и нагрузка переменных

Прежде чем мы сможем приступить к исследованию ИИ с помощью фреймворка LangChain и библиотеки Transformers Hugging Face, крайне важно создать безопасную и хорошо настроенную среду. Эта подготовка включает импорт необходимых библиотек и управление конфиденциальной информацией, такой как ключи API, с помощью переменных среды.

from torch import cuda
from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings
from transformers import AutoModelForCausalLM, AutoTokenizer
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
from transformers import pipeline
from dotenv import load_dotenv

load_dotenv()

При работе с моделями ИИ из Hugging Face часто требуется доступ к API Hugging Face, для которого требуется ключ API. Этот ключ является вашим уникальным идентификатором при оформлении запросов к сервисам Hugging Face, позволяя загружать модели и использовать их в своих приложениях.

Вот что вам нужно сделать, чтобы надежно настроить свою среду:

Получите ваш ключ API Hugging Face: после того, как вы создали свою учетную запись Hugging Face, вы можете найти свой ключ API в настройках своей учетной записи в разделе «Токены доступа».
Защитите свой ключ API: ваш ключ API является конфиденциальной информацией и должен храниться в тайне. Вместо того, чтобы жестко кодировать его в свои скрипты, вы должны использовать переменные среды.
Создайте файл .env: создайте файл с именем .env. В этом файле будут храниться ваши переменные среды.
Добавьте свой ключ API в файл .env: откройте файл .env с помощью текстового редактора и добавьте ключ API Hugging Face в следующем формате:

HUGGINGFACE_API_KEY=your_api_key_here

Замените your_api_key_here фактическим ключом API, который вы получили из Hugging Face.

Определение пути модели и конфигурации

modelPath = "sentence-transformers/all-mpnet-base-v2"
device = 'cuda' if cuda.is_available() else 'cpu'
model_kwargs = {'device': device}

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

Инициализация вложений Hugging Face и векторного хранилища FAISS

embeddings = HuggingFaceEmbeddings(
    model_name=modelPath,
    model_kwargs=model_kwargs,
)

# Made up data, just for fun, but who knows in a future
vectorstore = FAISS.from_texts(
    ["Harrison worked at Alibaba Cloud"], embedding=embeddings
)

retriever = vectorstore.as_retriever()

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

Настройка шаблона подсказки чата

template = """Answer the question based only on the following context:
{context}
Question: {question}
"""

prompt = ChatPromptTemplate.from_template(template)

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

Подготовка токенизатора и языковой модели

В мире ИИ и обработки естественного языка токенизатор и языковая модель — это динамичный дуэт, который превращает текст в осмысленное действие. Токенизатор разбивает язык на части, которые модель может понять, в то время как языковая модель предсказывает и генерирует язык на основе этих входных данных. В нашем путешествии мы используем классы AutoTokenizer и AutoModelForCausalLM от Hugging Face, чтобы использовать эти возможности. Но важно помнить, что один размер не подходит всем, когда дело доходит до выбора языковой модели.

Размер модели и вычислительные ресурсы

Размер модели является критическим фактором для рассмотрения. Большие модели, такие как Qwen-72B, имеют больше параметров, что обычно означает, что они могут понимать и генерировать более тонкий текст. Однако, они также требуют больше вычислительной мощности. Если вы оснащены графическими процессорами высокого класса и достаточным объемом памяти, вы можете выбрать эти большие модели, чтобы максимально использовать их возможности.

С другой стороны, меньшие модели, такие как Qwen-1.8B, гораздо более управляемы для стандартных вычислительных сред. Даже эта крошечная модель должна быть способна работать на IoT и мобильных устройствах. Хотя они не могут охватить тонкости языка, а также их более крупные аналоги, они по-прежнему обеспечивают отличную производительность и более доступны для тех, у кого нет специализированного оборудования.

Модели для конкретных задач

Еще один момент, который следует учитывать, — это характер вашей задачи. Если вы создаете разговорный ИИ, использование модели, специфической для чата, такой как Qwen-7B-Chat, может дать лучшие результаты, поскольку эти модели точно настроены для диалогов и могут обрабатывать нюансы разговора лучше, чем базовые модели.

Стоимость вывода

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

Серия Qwen

Qwen-1.8B: модель меньшего размера подходит для задач, требующих меньшей вычислительной мощности. Подходит для прототипирования и работы на машинах без мощных графических процессоров.
Qwen-7B: модель среднего размера, которая уравновешивает производительность с вычислительными требованиями. Подходит для целого ряда задач, включая генерацию текста и ответы на вопросы.
Qwen-14B: большая модель, которая может обрабатывать более сложные задачи с большим нюансом в понимании и генерации языка.
Qwen-72B: самая большая модель в серии, предлагающая самые современные характеристики для продвинутых приложений ИИ, требующих глубокого понимания языка.
Qwen-1.8B-Chat: диалоговая модель, разработанная специально для создания чат-ботов и других диалоговых систем.
Qwen-7B-Chat: аналогично Qwen-1.8B-Chat, но с повышенной способностью обрабатывать более сложные диалоги.
Qwen-14B-Chat: высококлассная диалоговая модель, способная к сложным диалоговым взаимодействиям.
Qwen-72B-Chat: самая передовая диалоговая модель в серии Qwen, обеспечивающая исключительную производительность для требовательных приложений чата.

Сделать выбор

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

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

# This can be changed to any of the Qwen models based on your needs and resources
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen-7B", trust_remote_code=True)
model_name_or_path = "Qwen/Qwen-7B"
model = AutoModelForCausalLM.from_pretrained(model_name_or_path,
                                             device_map="auto",
                                             trust_remote_code=True)

Мы загружаем токенизатор и причинная модель языка из Hugging Face с классами AutoTokenizer и AutoModelForCausalLM соответственно. Эти компоненты имеют решающее значение для обработки входных данных естественного языка и генерации выходных данных.

Создание конвейера генерации текста

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

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=8192,
    do_sample=True,
    temperature=0.7,
    top_p=0.95,
    top_k=40,
    repetition_penalty=1.1
)

hf = HuggingFacePipeline(pipeline=pipe)

Объяснение параметров в конвейере генерации текста:

max_new_tokens (8192): этот параметр определяет максимальное количество токенов, которые могут быть сгенерированы в выходных данных. Токены могут быть словами, символами или подсловами, в зависимости от токенизера.
do_sample (True): если установлено значение True, этот параметр позволяет осуществлять вероятностную выборку из распределения возможных следующих токенов, сгенерированных моделью. Это вводит случайность и разнообразие в сгенерированный текст. Если установлено значение False, модель всегда будет выбирать наиболее вероятный следующий токен, что приведет к детерминированным и менее разнообразным выходным данным.
temperature (0.7): температурный параметр контролирует, сколько случайности вводится в процесс отбора проб. Более низкое значение температуры (ближе к 0) делает модель более уверенной в своем выборе, что приводит к меньшему количеству случайных выходов, в то время как более высокое значение температуры (ближе к 1) способствует большей случайности и разнообразию.
top_p (0.95): этот параметр управляет ядром выборки, метод, который рассматривает только наиболее вероятные токены с кумулятивной вероятностью выше порога top_p. Это помогает в создании текста, который является одновременно разнообразным и последовательным, избегая включения токенов с очень низкой вероятностью, которые могут сделать текст бессмысленным.
top_k (40): выборка top_k ограничивает пул выборки k наиболее вероятными следующими токенами. Это дополнительно уточняет набор токенов, которые модель будет рассматривать для генерации следующего фрагмента текста, гарантируя, что выходные данны остаются актуальными и последовательными.
repetition_penalty (1.1): этот параметр не позволяет модели повторять одни и те же токены или фразы, продвигая более интересный и разнообразный текст. Значение, превышающее 1, приводит к наказанию и, таким образом, снижает вероятность появления токенов, которые уже появились.

После настройки конвейера с нужными параметрами, следующая строка кода:

hf = HuggingFacePipeline(pipeline=pipe)

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

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

Создание и запуск цепочки RAG

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

1.& nbsp;Конструкция цепочки:

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | hf
    | StrOutputParser()
)

Вот что происходит в этой части кода:

Для получения соответствующей информации на основе запроса используется ретривер. Роль ретривера заключается в том, чтобы прочесывать набор данных или коллекцию документов, чтобы найти фрагменты информации, которые наиболее актуальны для заданного вопроса. Вероятно, для повышения эффективности используется векторная база данных.
RunnablePassthrough() — это компонент, который просто передает вопрос без каких-либо изменений. Это говорит о том, что цепочка предназначена для обработки вопроса напрямую, вероятно, так, как она была введена пользователем.
_prompt_здесь подробно не показано, но он, вероятно, служит шаблоном или набором инструкций, который форматирует входной вопрос и полученный контекст таким образом, который подходит для следующего этапа конвейера, что представляет собой модель Hugging Face.
_hf_переменная представляет собой конвейер Hugging Face, который, предположительно, является предварительно обученной языковой моделью, способной генерировать ответы. Этот конвейер будет принимать отформатированные входные данные предыдущего шага и использовать свои генеративные возможности для получения ответа.
_StrOutputParser()_является выходным парсером, и его задача состоит в том, чтобы взять необработанные выходные данные из конвейера Hugging Face и разобрать их в более удобный для пользователя формат, предположительно в строку.

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

2. Вызов цепочки:

results = chain.invoke("Where did Harrison work?")

В этой строке цепочка вызывается с конкретным вопросом: «Где работал Харрисон?» Этот вызов запускает всю последовательность операций, определенных в цепочке. Ретривер ищет соответствующую информацию, которая затем передается вместе с вопросом через подсказку в модель Hugging Face. Модель генерирует ответ на основе полученных входных данных.

3. Распечатка результата:

print(results)

Сгенерированный ответ затем анализируется с помощью StrOutputParser() и возвращается в качестве конечного результата, который затем выводится на консоль или другой вывод.

Наконец, мы строим цепочку RAG, связывая ретривер, шаблон подсказки, конвейер Hugging Face и выходной парсер. Мы вызываем цепочку с нашим вопросом, и результаты печатаются.

Заключение: ваш шлюз к мастерству ИИ

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

Эта статья изначально была написана на английском языке. Смотреть оригинал статьи здесь.

Community