Buch lesen: «ИИ-агент в когнитивном программировании сознания – объединяем RAG и LLM»
Работа из серии по внедрению концепции когнитивного программирования корпоративного сознания (КПКС), рассматривающая все циклы разработки когнитивного тренажера в рамках объединения генеративных ответов на запросы по принципу Prompt-Engineer -> RAG -> LLM.
Вступление
Современные технологии искусственного интеллекта открывают новые горизонты для изучения и трансформации корпоративного сознания. Концепция когнитивного программирования, направленная на оптимизацию коллективного мышления и повышения эффективности взаимодействия внутри организаций, приобретает особую значимость в условиях динамично изменяющегося мира.
Эта книга посвящена созданию когнитивного тренажера – интеллектуального инструмента, способного обучать, поддерживать принятие решений и адаптироваться под запросы пользователей в режиме реального времени. Мы объединим Retrieval-Augmented Generation (RAG) и языковые модели (LLM), чтобы построить систему, которая станет не только источником знаний, но и проводником для формирования новых когнитивных навыков.
Целью данного руководства является пошаговое описание процесса разработки веб-интерфейса когнитивного тренажера. Мы разберем все ключевые этапы: от подготовки и структурирования данных до интеграции технологий и тестирования системы. Читатели узнают, как собрать и очистить данные, настроить RAG для эффективного поиска, оптимизировать языковую модель и интегрировать эти элементы в функциональный интерфейс.
Книга ориентирована на специалистов, занимающихся когнитивным программированием, разработчиков систем искусственного интеллекта, а также исследователей, работающих с корпоративными структурами. Здесь представлены не только теоретические подходы, но и готовые технические решения, что позволяет сразу перейти к практике.
Вместе мы создадим тренажер, способный не просто обучать, но и преобразовывать мышление – шаг к построению интеллектуального будущего, где коллективное сознание станет инструментом стратегического роста.
Этап 1: Подготовка данных
1.1 Сбор данных: Соберите десятки текстовых файлов, содержащих информацию о концепции когнитивного программирования. Убедитесь, что данные релевантны, актуальны и не содержат дубликатов.
1.2 Очистка данных: Удалите стоп-слова, HTML-теги, лишние символы. Проведите нормализацию текста (например, приведение к нижнему регистру).
1.3 Анализ структуры: Если файлы имеют разную структуру, унифицируйте формат (например, JSON, CSV или текст).
1.4 Создание базы знаний: Структурируйте данные в виде таблиц, онтологий или графа знаний для более точного поиска.
1.5 Векторизация данных: Преобразуйте текст в числовые векторы с использованием методов, таких как BERT, Sentence Transformers, или Word2Vec.
1.1 Сбор данных
Источники данных:
Внутренние источники: Архивные документы компании. Внутренние обучающие материалы, связанные с когнитивным программированием. Методические пособия, инструкции и презентации.
Внешние источники: Открытые статьи, научные публикации и книги по теме когнитивного программирования. Форумы, блоги или веб-сайты специалистов.
Необходимые лицензии: Проверьте, что собранные внешние данные не нарушают авторские права.
Критерии релевантности:
Тематика: Данные должны касаться когнитивного программирования сознания, его методов и применения.
Актуальность: Убедитесь, что данные не устарели (например, материалы, опубликованные не более 3–5 лет назад).
Полнота: Информация должна содержать ответы на основные вопросы, чтобы минимизировать пробелы.
Организация файлов:
Разделите данные по категориям: Теоретические основы (определения, термины). Практические кейсы. Часто задаваемые вопросы (FAQ). Примеры когнитивных моделей.
Практические примеры для сбора данных
1.1.1 Использование внутренних источников
Пример: Обработка архивных документов компании
1. Автоматическое извлечение информации из PDF-файлов:
```python
import PyPDF2
def extract_text_from_pdf(file_path):
with open(file_path, "rb") as file:
reader = PyPDF2.PdfReader(file)
text = ""
for page in reader.pages:
text += page.extract_text()
return text
pdf_text = extract_text_from_pdf("internal_documents.pdf")
print("Извлечённый текст:", pdf_text[:500])
```
2. Классификация данных:
Разделите извлечённый текст на категории:
```python
theoretical = []
practical = []
for line in pdf_text.split("\n"):
if "определение" in line.lower() or "термин" in line.lower():
theoretical.append(line)
elif "пример" in line.lower():
practical.append(line)
print("Теория:", theoretical[:5])
print("Практика:", practical[:5])
```
Результат: Внутренние материалы классифицированы для дальнейшего использования.
1.1.2 Использование внешних источников
Пример: Сбор научных статей с использованием BeautifulSoup
1. Скрейпинг данных из открытых источников:
```python
import requests
from bs4 import BeautifulSoup
def fetch_articles(base_url, keyword):
response = requests.get(f"{base_url}/search?q={keyword}")
soup = BeautifulSoup(response.text, "html.parser")
articles = []
for result in soup.find_all("div", class_="result"):
title = result.find("h2").text
link = result.find("a")["href"]
summary = result.find("p", class_="summary").text
articles.append({"title": title, "link": link, "summary": summary})
return articles
articles = fetch_articles("https://example.com", "когнитивное программирование")
print("Найденные статьи:", articles[:3])
```
2. Проверка лицензий:
Убедитесь, что данные не нарушают авторских прав, проверяя метаданные статьи на открытые лицензии (например, Creative Commons).
Результат: Собраны релевантные статьи из научных источников.
1.1.3 Проверка данных на актуальность и релевантность
Пример: Фильтрация данных по дате и ключевым словам
1. Отфильтруйте устаревшие материалы:
```python
from datetime import datetime
def filter_recent_articles(articles, years=5):
threshold_date = datetime.now().year – years
return [article for article in articles if int(article.get("date", 0)) >= threshold_date]
filtered_articles = filter_recent_articles([
{"title": "Статья 1", "date": "2019"},
{"title": "Статья 2", "date": "2010"}
])
print("Актуальные статьи:", filtered_articles)
```
2. Проверка релевантности по ключевым словам:
```python
keywords = ["когнитивное программирование", "модель", "примеры"]
def filter_by_keywords(articles, keywords):
return [article for article in articles if any(keyword in article["summary"] for keyword in keywords)]
relevant_articles = filter_by_keywords(articles, keywords)
print("Релевантные статьи:", relevant_articles)
```
Результат: Оставлены только актуальные и релевантные материалы.
1.1.4 Организация файлов
Пример: Разделение данных по категориям
1. Структурируйте данные по типам:
```python
def organize_files(data):
categories = {"Теория": [], "Практика": [], "FAQ": []}
for item in data:
if "определение" in item["summary"].lower():
categories["Теория"].append(item)
elif "пример" in item["summary"].lower():
categories["Практика"].append(item)
elif "вопрос" in item["summary"].lower():
categories["FAQ"].append(item)
return categories
structured_data = organize_files(relevant_articles)
print("Структурированные данные:", structured_data)
```
2. Создание файловой структуры:
```python
import os
base_path = "./knowledge_base"
for category in structured_data:
os.makedirs(f"{base_path}/{category}", exist_ok=True)
for i, item in enumerate(structured_data[category]):
with open(f"{base_path}/{category}/doc_{i+1}.txt", "w", encoding="utf-8") as file:
file.write(item["summary"])
```
Результат: Данные распределены по категориям с удобной файловой организацией.
1.1.5 Пример полного процесса сбора данных
Этап 1: Сбор внутренних данных
Извлечены обучающие материалы компании.
Классифицированы на теоретические основы и практические примеры.
Этап 2: Сбор внешних данных
Собраны научные статьи по ключевым словам.
Удалены устаревшие и нерелевантные статьи.
Этап 3: Интеграция в базу знаний
Все данные структурированы по категориям: Теория, Практика, FAQ.
Установлена файловая структура для удобной обработки.
Результат: Получен качественный набор данных для обучения модели и наполнения базы знаний.
Эти подходы обеспечивают системный подход к сбору, проверке и организации данных, что улучшает качество ответов когнитивного тренажера.
1.2 Очистка данных
Процесс очистки:
Удаление шумов: Уберите HTML-теги, ненужные ссылки, форматирование Markdown или LaTeX. Удалите таблицы, изображения и мета-данные, если они не несут ключевой информации.
Фильтрация информации: Исключите дублирующиеся тексты (например, одинаковые статьи, появившиеся в нескольких источниках). Удалите неинформативные фрагменты, такие как общие фразы, не относящиеся к теме.
Нормализация текста: Приведите текст к нижнему регистру для унификации обработки. Удалите специальные символы, такие как @, , или дополнительные пробелы.
Инструменты для очистки:
Python-библиотеки: `BeautifulSoup`: для удаления HTML-тегов. `re`: для удаления специфичных символов через регулярные выражения. `nltk` или `spaCy`: для удаления стоп-слов.
Автоматизация: Напишите скрипт для автоматической очистки всех файлов в заданной директории.
Практические примеры для этапа очистки данных
1.2.1 Удаление HTML-тегов и ненужных элементов
Пример: Очистка выгрузки с корпоративного сайта
Ваши данные включают статьи с HTML-тегами, ссылками и ненужными стилями. Используйте `BeautifulSoup` для автоматической очистки контента:
```python
from bs4 import BeautifulSoup
import os
def clean_html_file(filepath):
with open(filepath, "r", encoding="utf-8") as file:
html_content = file.read()
soup = BeautifulSoup(html_content, "html.parser")
clean_text = soup.get_text()
return clean_text.strip()
# Пример применения для директории
directory = "./data"
for filename in os.listdir(directory):
if filename.endswith(".html"):
cleaned_text = clean_html_file(os.path.join(directory, filename))
with open(f"./cleaned/{filename.replace('.html', '.txt')}", "w", encoding="utf-8") as clean_file:
clean_file.write(cleaned_text)
```
Этот скрипт обработает все HTML-файлы, извлекая только текстовый контент.
1.2.2 Фильтрация дублирующихся текстов
Пример: Исключение одинаковых статей из нескольких источников
Если в базе обнаруживаются дублирующие тексты, используйте хэширование для их удаления.
```python
import hashlib
def remove_duplicates(texts):
unique_texts = {}
for text in texts:
text_hash = hashlib.md5(text.encode()).hexdigest()
if text_hash not in unique_texts:
unique_texts[text_hash] = text
return list(unique_texts.values())
texts = ["Текст 1…", "Текст 2…", "Текст 1…"]
unique_texts = remove_duplicates(texts)
print(unique_texts)
```
Этот код сохранит только уникальные тексты, минимизируя объем данных.
1.2.3 Нормализация текста
Пример: Приведение текстов к единому формату
Для унификации данных выполните нормализацию текста: удаление стоп-слов, специальных символов и приведение к нижнему регистру.
```python
import re
import nltk
from nltk.corpus import stopwords
nltk.download('stopwords')
stop_words = set(stopwords.words('russian'))
def normalize_text(text):
text = text.lower()
# Приведение к нижнему регистру
text = re.sub(r'[^\w\s]', '', text)
# Удаление специальных символов
tokens = text.split()
filtered_tokens = [word for word in tokens if word not in stop_words]
# Удаление стоп-слов
return " ".join(filtered_tokens)
text = "Пример текста: как удалить лишние символы и нормализовать данные!"
normalized_text = normalize_text(text)
print(normalized_text)
```
Результат: `"пример текста удалить лишние символы нормализовать данные"`
1.2.4 Автоматизация процесса очистки
Пример: Скрипт для обработки всех файлов в папке
Создайте скрипт, который автоматически выполняет весь процесс очистки – удаляет шумы, фильтрует дубли и нормализует данные:
```python
import os
def process_files(input_dir, output_dir):
for filename in os.listdir(input_dir):
with open(os.path.join(input_dir, filename), "r", encoding="utf-8") as file:
raw_text = file.read()
# Очистка данных
clean_text = normalize_text(clean_html_file(raw_text))
# Сохранение результата
with open(os.path.join(output_dir, filename), "w", encoding="utf-8") as clean_file:
clean_file.write(clean_text)
process_files("./raw_data", "./cleaned_data")
```
Этот инструмент автоматизирует обработку данных для всех текстов в указанной директории.
1.2.5 Инструменты для ускорения обработки больших объемов данных
Пример: Использование `spaCy` для масштабных операций
Если объем данных велик, подключите `spaCy` для ускорения обработки:
```python
import spacy
nlp = spacy.load("ru_core_news_sm")
def process_with_spacy(text):
doc = nlp(text.lower())
return " ".join([token.text for token in doc if not token.is_stop and not token.is_punct])
text = "Когнитивное программирование – это подход, направленный на оптимизацию работы сознания."
processed_text = process_with_spacy(text)
print(processed_text)
```
Результат: `"когнитивное программирование подход направленный оптимизацию работы сознания"`
Эти примеры демонстрируют, как автоматизировать и оптимизировать процесс очистки данных для подготовки качественного материала, который станет основой для работы RAG и LLM.
1.3 Анализ структуры данных
Определение структуры:
Если данные в разных форматах (JSON, CSV, текст):
Приведите их к единому формату.
Например:
JSON: для работы с иерархически организованными данными.
CSV: для табличных данных (краткие справки, термины).
Текст: для длинных описательных данных (статьи, кейсы).
Шаги унификации:
1. Структурирование:
Определите ключевые поля:
Название текста.
Категория (теория, практика, примеры).
Ключевые слова.
Создайте единый формат для всех данных.
2. Конвертация:
Используйте Python-библиотеки, такие как `pandas` или `json`, для преобразования файлов.
Пример структуры JSON:
```json
{
"title": "Основы когнитивного программирования",
"category": "Теория",
"content": "Когнитивное программирование – это…",
"keywords": ["когнитивное программирование", "теория", "сознание"]
}
```
Практические примеры для этапа анализа структуры данных
1.3.1 Приведение данных к единому формату
Пример: Унификация форматов JSON, CSV и текста
Предположим, вы имеете три типа данных:
1. Таблицы в формате CSV с краткими определениями терминов.
2. Тексты в формате TXT с описанием кейсов.
3. Неструктурированные данные в JSON.
Для унификации все данные преобразуются в JSON с фиксированной структурой.
```python
import pandas as pd
import json
import os
def csv_to_json(csv_file, output_file):
df = pd.read_csv(csv_file)
data = df.to_dict(orient="records")
with open(output_file, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=4)
def txt_to_json(txt_file, output_file, category):
with open(txt_file, "r", encoding="utf-8") as f:
content = f.read()
data = {
"title": os.path.basename(txt_file).replace(".txt", ""),
"category": category,
"content": content.strip()
}
with open(output_file, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=4)
# Пример вызова функций
csv_to_json("terms.csv", "terms.json")
txt_to_json("case_description.txt", "case.json", "Кейсы")
```
Результат – преобразованные данные в едином формате JSON.
1.3.2 Структурирование данных
Пример: Разделение данных по ключевым категориям
При обработке собранной информации важно выделить ключевые поля, такие как заголовок, категория и ключевые слова. Для этого создайте функцию, которая добавляет недостающие поля и унифицирует структуру.
```python
def structure_data(raw_data, category):
structured_data = []
for item in raw_data:
structured_data.append({
"title": item.get("title", "Без названия"),
"category": category,
"content": item.get("content", ""),
"keywords": item.get("keywords", [])
})
return structured_data
# Пример исходных данных
raw_data = [
{"title": "Модель командного мышления", "content": "Описание модели…"},
{"content": "Описание когнитивных процессов…"}
]
structured = structure_data(raw_data, "Теория")
print(json.dumps(structured, ensure_ascii=False, indent=4))
```
Результат: добавлены заголовки и категории, что упрощает дальнейшую обработку.
1.3.3 Конвертация данных
Пример: Автоматическая обработка всех файлов в директории
Напишите скрипт, который обрабатывает файлы разных форматов и сохраняет их в едином формате JSON.
```python
def process_directory(input_dir, output_dir):
for filename in os.listdir(input_dir):
file_path = os.path.join(input_dir, filename)
if filename.endswith(".csv"):
csv_to_json(file_path, os.path.join(output_dir, filename.replace(".csv", ".json")))
elif filename.endswith(".txt"):
txt_to_json(file_path, os.path.join(output_dir, filename.replace(".txt", ".json")), "Кейсы")
elif filename.endswith(".json"):
# Дополнительная обработка JSON (если требуется)
pass
process_directory("./raw_data", "./processed_data")
```
Этот подход обеспечивает унификацию данных на основе их типа.
1.3.4 Формирование структуры для работы с данными
Пример: Структура базы знаний для когнитивного тренажера
Создайте JSON-файл, который будет хранить данные по ключевым тематикам.
```json
[
{
"title": "Основы когнитивного программирования",
"category": "Теория",
"content": "Когнитивное программирование – это метод…",
"keywords": ["основы", "когнитивное программирование", "теория"]
},
{
"title": "Кейс: Внедрение когнитивных моделей",
"category": "Кейсы",
"content": "Этот кейс описывает, как компания…",
"keywords": ["кейсы", "внедрение", "когнитивные модели"]
}
]
```
Такая структура обеспечивает удобный доступ к информации для алгоритмов RAG.
1.3.5 Проверка данных после унификации
Пример: Тестирование корректности структуры
После конвертации проверьте, что все данные соответствуют заданному формату, используя Python:
```python
def validate_data(data):
required_keys = ["title", "category", "content", "keywords"]
for item in data:
for key in required_keys:
if key not in item:
print(f"Ошибка: отсутствует ключ '{key}' в элементе {item['title']}")
print("Все данные проверены.")
# Пример проверки
with open("processed_data.json", "r", encoding="utf-8") as f:
data = json.load(f)
validate_data(data)
```
Этот процесс гарантирует, что все данные готовы к интеграции в когнитивный тренажер.
Данные примеры позволяют систематизировать данные, обеспечивая их подготовленность для дальнейшего использования в системе RAG и языковой модели.
1.4 Создание базы знаний
Форматы базы знаний:
Таблицы: Используйте для хранения кратких фактов, терминов или определений.
Инструменты: SQLite, PostgreSQL.
Граф знаний: Постройте граф с узлами (понятия, события) и ребрами (отношения между ними).
Инструменты: Neo4j, NetworkX.
Онтологии: Формализуйте знания о концепциях и их взаимосвязях.
Инструменты: Protégé для OWL-онтологий.
Порядок действий:
Сегментация данных: Разбейте текст на логические блоки (например, заголовки и подзаголовки).
Категоризация: Создайте категорийный справочник, например: "Методологии", "Инструменты", "Примеры".
Верификация: Проверьте, что информация в базе знаний точна и не содержит противоречий.
Практические примеры для создания базы знаний
1.4.1 Таблицы для хранения кратких фактов и терминов
Пример: Использование SQLite для хранения определений
Создайте таблицу для терминов, связанных с когнитивным программированием.
```sql
CREATE TABLE terms (
id INTEGER PRIMARY KEY AUTOINCREMENT,
term TEXT NOT NULL,
definition TEXT NOT NULL,
category TEXT NOT NULL
);
INSERT INTO terms (term, definition, category) VALUES
("Когнитивное программирование", "Подход, направленный на оптимизацию корпоративного сознания.", "Теория"),
("Модель мышления команд", "Описание когнитивных процессов, влияющих на взаимодействие в команде.", "Методология");
```
Эти данные можно использовать для быстрого поиска определений в системе.
1.4.2 Граф знаний для представления связей
Пример: Построение графа знаний с NetworkX
Постройте граф знаний, где узлы представляют ключевые понятия, а ребра – их взаимосвязи.
```python
import networkx as nx
import matplotlib.pyplot as plt
# Создание графа
G = nx.Graph()
G.add_node("Когнитивное программирование", category="Теория")
G.add_node("Модель мышления команд", category="Методология")
G.add_node("Внедрение когнитивных моделей", category="Кейсы")
G.add_edge("Когнитивное программирование", "Модель мышления команд", relation="Определяет")
G.add_edge("Модель мышления команд", "Внедрение когнитивных моделей", relation="Применяется в")
# Визуализация графа
nx.draw(G, with_labels=True, node_color="lightblue", font_size=10, node_size=3000)
plt.show()
```
Этот граф помогает визуализировать взаимосвязи между концепциями и использовать их для навигации внутри базы знаний.
1.4.3 Формализация знаний с помощью онтологий
Пример: Создание онтологии в Protégé
В Protégé создайте онтологию, где классы представляют категории данных, такие как "Методологии" и "Примеры".
Создайте класс `Методологии` с подклассами, например, `Модель мышления команд`.
Определите свойства, связывающие классы, например, `применяется в` между `Методологиями` и `Кейсами`.
Эта структура помогает формализовать знания для их дальнейшего использования в RAG.
1.4.4 Сегментация данных
Пример: Разделение длинного текста на логические блоки*
Используйте Python для автоматической сегментации данных на основе заголовков и подзаголовков.
```python
def segment_text(text):
segments = []
lines = text.split("\n")
current_segment = {"title": None, "content": ""}
for line in lines:
if line.startswith("#"): # Заголовки
if current_segment["title"]:
segments.append(current_segment)
current_segment = {"title": line.strip("# "), "content": ""}
else:
current_segment["content"] += line + " "
if current_segment["title"]:
segments.append(current_segment)
return segments
text = """
# Основы когнитивного программирования
Когнитивное программирование – это подход…
# Модель мышления команд
Описание модели…
"""
segments = segment_text(text)
print(segments)
```
Результат: список сегментов, каждый из которых можно сохранить как отдельный элемент базы знаний.
1.4.5 Категоризация данных
Пример: Создание категорийного справочника
Организуйте данные по ключевым темам, чтобы упростить поиск и обработку.
```json
{
"categories": {
"Теория": ["Основы когнитивного программирования", "Принципы командного мышления"],
"Методологии": ["Модель мышления команд"],
"Кейсы": ["Внедрение когнитивных моделей"]
}
}
```
Этот справочник можно использовать для фильтрации данных в интерфейсе тренажера.
1.4.6 Верификация данных
Пример: Проверка на полноту и точность
После создания базы знаний проведите автоматизированную проверку данных, чтобы выявить ошибки и пропуски.
```python
def verify_data(data):
for item in data:
if not item.get("title") or not item.get("content"):
print(f"Ошибка: Не хватает данных в элементе {item}")
if "keywords" not in item or not item["keywords"]:
print(f"Предупреждение: Отсутствуют ключевые слова в {item['title']}")
# Пример проверки
data = [
{"title": "Основы когнитивного программирования", "content": "Описание…", "keywords": []},
{"title": "Модель мышления команд", "content": "Описание модели…"}
]
verify_data(data)
```
Этот скрипт позволяет находить неполные записи, чтобы устранить их до запуска системы.
Эти практические примеры помогут эффективно организовать, сегментировать и верифицировать данные для создания базы знаний, полностью готовой к интеграции с когнитивным тренажером.
