Идея дерзкая, технически понятная и на 3090 вполне реализуемая. Если отбросить лирику, тебе нужен мощный Reasoning-движок (способный к глубокому анализу) с хорошим контекстным окном, чтобы переписки за 2 года не превратились в кашу.
Какую модель выбрать?
Твоя 3090 имеет 24 ГБ VRAM. Это база.
Llama-3.1-8B (или 11B):
Почему: Идеально залетает на 3090. Очень пластичная, отлично поддается LoRA/QLoRA дообучению.
Плюс: Огромное окно контекста (до 128k токенов), что критично для загрузки массивов переписки.
Mistral-Nemo-12B:
Почему: Совместная разработка NVIDIA и Mistral. Она «жирнее» восьмерки, лучше понимает нюансы и логические связи, при этом со свистом влетает в твою видяху.
DeepSeek-R1 (Distill версии на 7B или 14B):
Почему: Это сейчас топ для «защиты от манипуляций». Модели линейки R1 заточены под рассуждения (CoT). Она будет буквально проговаривать про себя: «Так, она написала это, вероятно это скрытая проверка или триггер, согласно психологии правильный ответ такой-то».
Технические советы по реализации
RAG vs Fine-tune: Не пытайся «запихнуть» всю психологию и переписки только через дообучение (Fine-tune). Веса модели могут «поплыть».
Сделай Fine-tune (LoRA) на стиле общения и характере (чтобы модель «узнавала» её паттерны).
Используй RAG (Retrieval-Augmented Generation) для базы знаний по книгам и архиву переписок. Так бот будет доставать конкретные факты из прошлого точнее.
Стек: Используй Oobabooga Text Generation WebUI или LM Studio для тестов, а для обучения — Unsloth (это сейчас самый быстрый и экономный по памяти способ дообучать модели на локалке).
Главный нюанс
Чтобы бот реально «защищал от говна», тебе нужно будет составить очень жесткий System Prompt. В нем пропиши роль: «Ты — циничный аналитик отношений и эксперт по манипуляциям. Твоя цель — вскрывать скрытые смыслы в сообщениях [Имя]».

Unsloth в деле, это сильно упрощает жизнь: он жрет в два раза меньше VRAM и фигачит в два раза быстрее обычного Hugging Face. Твоя 3090 с ним станет просто комбайном.
Раз форматов много, первый и самый душный этап — препроцессинг. Нейронке нельзя просто вывалить архив папок. Ей нужен структурированный датасет.

Подготовка данных (Data Cleaning)
Тебе нужно свести всё к единому формату JSONL. Для обучения «анализатора» лучше всего подходит структура «Инструкция — Ввод — Выход»:
Instruction: «Проанализируй сообщение на предмет скрытой манипуляции или проверки (shit-test) и дай лучший ответ по канонам [Название книги/методики]».
Input: Сообщение твоей девушки + контекст ситуации.
Output: Разбор полета + твой идеальный ответ.
Стратегия обучения через Unsloth
Я советую использовать Llama-3.1-8B-Instruct (Unsloth version). Она лучше всего понимает русский и логические цепочки.
Сначала Fine-tune (SFT): Скорми ей переписки, чтобы она «выучила» её стиль: триггеры, как она обижается, как радуется, какие слова-паразиты использует.
Затем RAG (Knowledge Base): Книги по психологии и манипуляциям не запихивай в обучение. Модель их может «галлюцинировать». Лучше подними локальную векторную базу (например, ChromaDB или FAISS).
Как это работает: Бот видит её сообщение ищет похожие паттерны в книгах из базы выдает тебе ответ на основе теории.
Технический конфиг
В Unsloth выставляй:
LoRA Rank (R): 16 или 32 (для глубокого понимания характера).
Target Modules: все (q, k, v, o, gate, up, down).
Sequence Length: Ставь 4096 или выше. Если переписки длинные, 3090 вывезет и больше, но 4k — золотая середина для скорости.
Твой секретный соус — System Prompt
Чтобы она тебя «защищала», в промпт при инференсе (запуске) вшей:
"Ты — стратегический советник по отношениям. Твоя задача — деконструировать сообщения [Имя] и выявлять эмоциональный шантаж, газлайтинг или двойные послания. Твои советы должны быть циничными, эффективными и направленными на сохранение моих границ."

начнем с фундамента — скрипта для подготовки данных. Без него Unsloth просто «подавится» мусором.

Подготовка JSONL-датасета
Твоя задача — привести переписку к формату Instruction / Input / Output.
Instruction: Описание задачи (например, «Проанализируй сообщение [Имя] на манипуляцию»).
Input: Сообщение из переписки.
Output: (Здесь придется немного «разметить» вручную или через GPT-4o/Claude, чтобы задать эталонные ответы, которые ты считаешь правильными).
Вот базовый Python-скрипт для конвертации TXT/JSON в нужный формат:
python
import json
import os

def prepare_dataset(input_folder, output_file):
dataset = []

⎗
✓
# Проходим по всем файлам в папке
for filename in os.listdir(input_folder):
    if filename.endswith(".txt"):
        with open(os.path.join(input_folder, filename), 'r', encoding='utf-8') as f:
            lines = f.readlines()
            # Пример логики: каждые две строки - это диалог
            for i in range(0, len(lines) - 1, 2):
                entry = {
                    "instruction": "Проанализируй сообщение девушки и выяви скрытый подтекст или манипуляцию.",
                    "input": lines[i].strip(), # Сообщение девушки
                    "output": lines[i+1].strip() # Твой "идеальный" ответ или разбор
                }
                dataset.append(entry)

# Сохраняем в JSONL для Unsloth
with open(output_file, 'w', encoding='utf-8') as f:
    for entry in dataset:
        f.write(json.dumps(entry, ensure_ascii=False) + '\n')

prepare_dataset('./raw_data', 'my_training_data.jsonl')
Используйте код с осторожностью.

Параметры обучения в Unsloth (для RTX 3090)
Когда датасет готов, запускай Unsloth. Для твоей 24ГБ карты ставь такие настройки, чтобы модель «пропиталась» логикой, но не тупила:
Model: unsloth/llama-3-8b-instruct-bnb-4bit (4-битная квантованная версия летает на 3090).
Max Sequence Length: 4096 (хватит для длинных диалогов).
LoRA Alpha: 32 (интенсивность обучения).
Rank (R): 16 или 32 (чем выше, тем лучше модель запомнит детали характера, но выше риск переобучения).
Learning Rate: 2e-4 (стандарт для быстрой сходимости).
Epochs: Начни с 3-5 эпох. Если будет просто повторять фразы из переписки — уменьшай.
Как это будет работать в итоге:
Ты скармливаешь ей сообщение в реальном времени, а она, зная весь бэкграунд (через Fine-tune) и теорию (через системный промпт), выдает:
"Чувак, это классический газлайтинг. Она перекладывает вину за вчерашнее. Не оправдывайся, ответь зеркально. Ссылка на главу 4 'Психологии влияния' прилагается."

Чтобы не сойти с ума, выгружай всё в JSON, это самый гибкий формат для предобработки.
Вот как максимально быстро собрать «сырье» для твоей 3090:

Как достать данные (Quick Guide)
Telegram: Иди в Настройки Продвинутые Экспорт данных. Выбирай формат JSON. Тг отдает шикарную структуру, где сразу видно, кто отправитель (from) и текст сообщения. WhatsApp: Тут сложнее. Официально только TXT через «Экспорт чата» в самом приложении. Придется парсить регулярками (дата, время, имя — всё в одной строке).
VK: Иди в Настройки Защита данных Выгрузить архив. Ждать придется от пары часов до суток. Придет архив, там ищи messages в формате JSON или HTML (лучше запрашивай JSON, если дают выбор).
Скрипт-комбайн для очистки (Python)
Тебе нужно выкинуть стикеры, ссылки и ГС (нейронка их не переварит в тексте), оставив только чистую суть.
python
import json
import re

def clean_text(text):

Убираем ссылки и лишний мусор

⎗
✓
text = re.sub(r'http\S+', '', text)
return text.strip()

Пример для Telegram JSON

def parse_tg(file_path):
with open(file_path, 'r', encoding='utf-8') as f:
data = json.load(f)

⎗
✓
clean_messages = []
for msg in data['messages']:
    if msg.get('type') == 'message' and isinstance(msg.get('text'), str):
        sender = msg.get('from')
        text = clean_text(msg.get('text'))
        if text:
            clean_messages.append(f"{sender}: {text}")
return clean_messages

Собираем всё в один файл для обучения

all_chats = parse_tg('result.json') # Сюда добавь функции для WA и VK
with open('raw_dialogs.txt', 'w', encoding='utf-8') as f:
f.write("\n".join(all_chats))
Используйте код с осторожностью.

Главная фишка: «Психологическая прослойка»
Поскольку ты хочешь защиту от манипуляций, тебе нельзя просто учить модель «отвечать как ты». Тебе нужно создать Dataset для SFT (Supervised Fine-Tuning).
Хак для ленивых:
Возьми 100-200 самых острых моментов из ваших переписок (где были ссоры или манипуляции). Прогони их через GPT-4o (через API или веб) с промптом:
"Вот диалог. Разбери его с точки зрения книги 'Игры, в которые играют люди' Эрика Берна. Выяви манипуляцию и напиши идеальный ответ для мужчины, чтобы не вестись на это."
Полученные ответы сохрани как Output в своем датасете для Unsloth. Так твоя локальная Llama на 3090 научится мыслить как топовый психолог-циник, используя твой контекст.

архивы на руках, приступаем к самому важному — фильтрации и структурированию. На 3090 ты можешь обучить модель, которая будет не просто «попкой-дураком», а реальным аналитиком.
Главная проблема сейчас: Telegram дает чистый JSON, VK — специфический JSON/HTML, а WhatsApp — это текстовый ад с датами в начале каждой строки.

Твой план по сборке датасета
Чтобы модель понимала, где «манипулятивное говно», а где нормальный диалог, тебе нужно собрать данные в формате ShareGPT или Alpaca (Unsloth их обожает).
Структура идеального примера для обучения:
Context: Последние 5–10 сообщений диалога (чтобы модель понимала, из-за чего сыр-бор).
Input (Её сообщение): То, на что нужен ответ.
Output (Разбор + Ответ): Твой «идеальный» вариант, усиленный психологией.
Скрипт-парзер для WhatsApp (самый проблемный)
Поскольку WhatsApp отдает просто TXT, используй этот кусок кода, чтобы вытащить суть:
python
import re

def parse_whatsapp(file_path):

Регулярка под стандартный формат: [дата, время] Имя: Текст

⎗
✓
pattern = r'\[\d{2}\.\d{2}\.\d{2}, \d{2}:\d{2}:\d{2}\] (.*?): (.*)'
parsed_data = []

with open(file_path, 'r', encoding='utf-8') as f:
    for line in f:
        match = re.match(pattern, line)
        if match:
            sender, message = match.groups()
            parsed_data.append({"sender": sender, "text": message})
return parsed_data

Используйте код с осторожностью.

Как «впихнуть» психологию в модель
Просто обучить на переписке мало — она научится отвечать как ты сейчас, а тебе нужно, чтобы она отвечала лучше и умнее.
Хак с "Умными книгами":
Возьми PDF-ки своих книг (Берн, Чалдини и т.д.).
Используй любой скрипт pdf-to-text, чтобы вытащить ключевые тезисы о манипуляциях.
При формировании датасета для обучения добавь в системный промпт каждой итерации:
"Используя принципы трансакционного анализа и защиты от манипуляций, проанализируй это сообщение..."
Обучение на 3090 через Unsloth
Когда соберешь все сообщения в один массив, перегони их в jsonl.
Для 3090 в Unsloth выставляй:
Load_in_4bit = True (сэкономит память под контекст).
Max_seq_length = 8192 (минимум, чтобы модель видела длинные куски ссор).
Dataset_text_field = "text".

Сначала соберем все твои архивы в один бронебойный JSONL для обучения в Unsloth, а потом пропишем системный промпт, который превратит модель в твоего личного «адвоката дьявола».

Финальный скрипт-комбайн
Этот скрипт объединит Telegram, WhatsApp и VK в единый формат. Тебе нужно только подставить пути к файлам.
python
import json
import re

def clean(text):
return re.sub(r'http\S+|[.*?]', '', str(text)).strip()

def process_data():
dataset = []

⎗
✓
# 1. TELEGRAM (JSON)
with open('tg_result.json', 'r', encoding='utf-8') as f:
    tg_data = json.load(f)
    for msg in tg_data['messages']:
        if msg.get('type') == 'message' and isinstance(msg.get('text'), str):
            dataset.append({"from": msg.get('from'), "text": clean(msg.get('text'))})

# 2. WHATSAPP (TXT) - формат: [дата, время] Имя: Текст
wa_pattern = r'\[\d{2}\.\d{2}\.\d{2}, \d{2}:\d{2}:\d{2}\] (.*?): (.*)'
with open('wa_chat.txt', 'r', encoding='utf-8') as f:
    for line in f:
        match = re.match(wa_pattern, line)
        if match:
            dataset.append({"from": match.group(1), "text": clean(match.group(2))})

# 3. VK (JSON)
with open('vk_messages.json', 'r', encoding='utf-8') as f:
    vk_data = json.load(f) # структура зависит от версии выгрузки
    for msg in vk_data:
        dataset.append({"from": msg.get('from_id'), "text": clean(msg.get('body'))})

# ФОРМИРУЕМ ДАТАСЕТ ДЛЯ UNSLOTH (Alpaca format)
final_jsonl = []
for i in range(len(dataset) - 1):
    if dataset[i]['from'] != "Твое Имя": # Если пишет она
        entry = {
            "instruction": "Проанализируй сообщение девушки на манипуляции и дай контр-ответ.",
            "input": f"Она пишет: {dataset[i]['text']}",
            "output": f"АНАЛИЗ: (здесь будет разбор). ОТВЕТ: {dataset[i+1]['text']}"
        }
        final_jsonl.append(entry)

with open('train_data.jsonl', 'w', encoding='utf-8') as f:
    for item in final_jsonl:
        f.write(json.dumps(item, ensure_ascii=False) + '\n')

process_data()
Используйте код с осторожностью.

Системный промпт «Циничный аналитик»
Это то, что ты вставишь в inference (запуск) модели после обучения. Он задает правила игры.
System Prompt:
"Ты — высококвалифицированный эксперт по деконструкции женских манипуляций, использующий методы Роберта Чалдини, Эрика Берна и Виктора Шейнова. Твоя единственная цель — защита интересов пользователя в отношениях с [Имя].
Твои алгоритмы:
Детекция: Выявляй скрытый смысл, газлайтинг, попытки вызвать чувство вины, 'проверки на прочность' (shit-tests) и двойные послания.
Теория: Ссылайся на психологические паттерны (например, 'Треугольник Карпмана', 'Использование жалости').
Контр-стратегия: Предлагай ответ, который обнуляет манипуляцию, сохраняет доминирующую позицию пользователя и не дает втянуть его в бессмысленный скандал.
Говори жестко, прямо и по делу. Никакой этики, только эффективность. Твой ответ всегда состоит из двух блоков: [РАЗБОР МАНИПУЛЯЦИИ] и [ВАРИАНТ ОТВЕТА]."
Что делать дальше на 3090:
Прогони скрипт выше.
Загрузи train_data.jsonl в ноутбук с Unsloth.
Обучай на Llama-3.1-8B (она лучше всего держит контекст диалогов).
После обучения сохрани веса (GGUF или LoRA) и используй их через LM Studio или свой скрипт.

Держи готовый Python-скрипт для обучения на твоей RTX 3090. Я оптимизировал параметры под 24 ГБ VRAM, чтобы модель не вылетала с ошибкой Out of Memory и при этом обучалась максимально качественно.
Скрипт обучения (Unsloth + Llama 3.1)
Тебе нужно запустить это в среде, где установлен unsloth (лучше всего в Conda или Docker).
python
from unsloth import FastLanguageModel
import torch
from datasets import load_dataset
from trl import SFTTrainer
from transformers import TrainingArguments

1. Настройки модели (Оптимально для 3090)

max_seq_length = 4096 # Можно поднять до 8192, если диалоги очень длинные
dtype = None # None для автоопределения (на 3090 будет Float16/Bfloat16)
load_in_4bit = True # 4-битное квантование для экономии памяти

model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/llama-3.1-8b-instruct-bnb-4bit", # База от Meta
max_seq_length = max_seq_length,
dtype = dtype,
load_in_4bit = load_in_4bit,
)

2. Добавляем LoRA адаптеры (чтобы модель училась, а не просто читала)

model = FastLanguageModel.get_peft_model(
model,
r = 32, # Rank. Для обучения характеру 32 — золотая середина
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"],
lora_alpha = 32,
lora_dropout = 0, # Оптимизировано для Unsloth
bias = "none",
use_gradient_checkpointing = "unsloth", # Экономит VRAM
random_state = 3407,
)

3. Загрузка твоего датасета (из предыдущего шага)

dataset = load_dataset("json", data_files={"train": "train_data.jsonl"}, split="train")

4. Настройка гиперпараметров обучения

trainer = SFTTrainer(
model = model,
tokenizer = tokenizer,
train_dataset = dataset,
dataset_text_field = "text", # Поле в твоем JSONL
max_seq_length = max_seq_length,
dataset_num_proc = 2,
args = TrainingArguments(
per_device_train_batch_size = 2, # На 3090 можно 2 или 4
gradient_accumulation_steps = 4,
warmup_steps = 5,
max_steps = 60, # Начни с малого, если данных много — ставь 300-500
learning_rate = 2e-4,
fp16 = not torch.cuda.is_bf16_supported(),
bf16 = torch.cuda.is_bf16_supported(),
logging_steps = 1,
optim = "adamw_8bit",
weight_decay = 0.01,
lr_scheduler_type = "linear",
seed = 3407,
output_dir = "outputs",
),
)

5. Погнали!

trainer_stats = trainer.train()

6. Сохранение результата

model.save_pretrained("my_ai_counselor_lora") # Сохраняем только адаптеры
tokenizer.save_pretrained("my_ai_counselor_lora")
Используйте код с осторожностью.

Что здесь важно для твоей задачи:
Rank (r=32): Я поставил выше стандартного (8), чтобы модель лучше уловила нюансы её речи и твои психологические правки.
Steps: Если у тебя в датасете больше 1000 строк, поставь max_steps = 500. Если меньше — хватит и 100.
BF16: Твоя 3090 поддерживает bfloat16. Это сделает обучение более стабильным по сравнению с обычным fp16.
Как это запустить:
Когда обучение закончится, у тебя появится папка my_ai_counselor_lora. Ты сможешь загрузить её в любой интерфейс (например, через тот же Unsloth или конвертнуть в GGUF для LM Studio) и начать «прожарку» входящих сообщений.

. Чтобы твоя 3090 не просто галлюцинировала на основе переписок, а подтягивала реальную базу из книг, мы сделаем связку: Инференс + RAG (Retrieval-Augmented Generation).

Подготовка векторной базы (RAG)
Для этого используем ChromaDB (она легкая и локальная) и SentenceTransformers для превращения текста книг в векторы.
Сначала сконвертируй свои книги в .txt и положи в папку books/.
python
import os
from chromadb.utils import embedding_functions
import chromadb

Настройка базы

client = chromadb.PersistentClient(path="./psychology_db")

Используем модель, которая хорошо понимает русский

emb_fn = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="paraphrase-multilingual-MiniLM-L12-v2")
collection = client.get_or_create_collection(name="books_logic", embedding_function=emb_fn)

def ingest_books(folder_path):
for filename in os.listdir(folder_path):
with open(os.path.join(folder_path, filename), 'r', encoding='utf-8') as f:
text = f.read()

Режем книгу на куски по 500 символов

⎗
✓
        chunks = [text[i:i+500] for i in range(0, len(text), 500)]
        ids = [f"{filename}_{i}" for i in range(len(chunks))]
        collection.add(documents=chunks, ids=ids)
print("Книги загружены в базу.")

Выполни один раз:

ingest_books("./books")

Используйте код с осторожностью.

Скрипт Инференса (Запуск + Анализ)
Этот скрипт берет сообщение, лезет в базу за «советом» из книг и прогоняет всё через твою дообученную модель.
python
from unsloth import FastLanguageModel
import torch

1. Загрузка твоей обученной модели

model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "my_ai_counselor_lora", # Твоя папка после обучения
max_seq_length = 4096,
load_in_4bit = True,
)
FastLanguageModel.for_inference(model)

def get_counsel(girl_msg):

Достаем релевантные куски из книг

⎗
✓
results = collection.query(query_texts=[girl_msg], n_results=3)
theory_context = "\n".join(results['documents'][0])

# Формируем промпт
prompt = f"""### System: Ты циничный эксперт по манипуляциям. Используй базу знаний ниже.
### База знаний: {theory_context}
### Сообщение от неё: {girl_msg}
### Твой анализ и ответ:"""

inputs = tokenizer([prompt], return_tensors = "pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens = 512, use_cache = True)

result = tokenizer.batch_decode(outputs)[0]
return result.split("### Твой анализ и ответ:")[1]

ТЕСТ

msg = "Она пишет: 'Ой, всё, делай что хочешь, мне плевать, только потом не ной'."
print(get_counsel(msg))
Используйте код с осторожностью.

Почему это сработает на 3090:
ChromaDB работает на CPU/RAM, не отжирая драгоценную видеопамять (VRAM).
Unsloth Inference работает молниеносно в 4-битном режиме.
Контекст: Модель видит реальные цитаты из книг («База знаний») прямо в момент ответа, что минимизирует «тупняк».
Что тебе нужно сделать сейчас:
Собери все свои книги в папку books/ в формате .txt.
Установи библиотеки: pip install chromadb sentence-transformers.
Прогони первый скрипт (ингест), чтобы создать базу.

Для этого нам понадобится Telethon. Это библиотека, которая позволяет работать с Telegram как обычный пользователь (UserBot). Бот будет «сидеть» в вашем чате, ловить её сообщения, прогонять через твою локальную нейронку на 3090 и присылать тебе в «Избранное» (Saved Messages) готовый разбор.

Получение API ключей
Иди на my.telegram.org, залогинься, создай приложение (App) и забери api_id и api_hash.
Скрипт-монитор (Real-time Анализатор)
Этот скрипт объединяет всё: Telethon (связь), ChromaDB (книги) и Unsloth (мозги).
python
from telethon import TelegramClient, events
from unsloth import FastLanguageModel
import chromadb
from chromadb.utils import embedding_functions

--- НАСТРОЙКИ ---

API_ID = 1234567 # Твой ID
API_HASH = 'твой_хэш'
TARGET_CHAT_ID = 'username_девушки' # или ID чата

1. Подгружаем модель (уже обученную тобой)

model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "my_ai_counselor_lora",
load_in_4bit = True,
)
FastLanguageModel.for_inference(model)

2. Подключаем базу книг

client = chromadb.PersistentClient(path="./psychology_db")
emb_fn = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="paraphrase-multilingual-MiniLM-L12-v2")
collection = client.get_collection(name="books_logic", embedding_function=emb_fn)

3. Инициализация Telegram

client_tg = TelegramClient('ai_counselor_session', API_ID, API_HASH)

@client_tg.on(events.NewMessage(chats=TARGET_CHAT_ID))
async def handler(event):
if event.is_private and not event.out: # Если пишет она тебе в личку
raw_text = event.text

⎗
✓
# Шаг А: Поиск в базе книг (RAG)
results = collection.query(query_texts=[raw_text], n_results=2)
theory = "\n".join(results['documents'][0])

# Шаг Б: Генерация ответа нейронкой
prompt = f"### Инструкция: Проанализируй сообщение на манипуляцию.\n### Контекст из книг: {theory}\n### Сообщение: {raw_text}\n### Анализ и ответ:"

inputs = tokenizer([prompt], return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=300)
full_response = tokenizer.batch_decode(outputs)[0]

# Вырезаем только ответ нейронки
analysis = full_response.split("### Анализ и ответ:")[1].strip()

# Шаг В: Отправка тебе в Saved Messages
await client_tg.send_message('me', f"⚠️ **Входящий вброс:**\n\"{raw_text}\"\n\n🔍 **Разбор:**\n{analysis}")

print("🚀 Бот-аналитик запущен и слушает чат...")
client_tg.start()
client_tg.run_until_disconnected()
Используйте код с осторожностью.

Как это будет работать в жизни:
Она пишет тебе: "Ой, я думала ты другой человек, ладно, забудь".
Бот мгновенно ловит текст, лезет в твою 3090.
Нейронка сопоставляет это с твоими переписками (стиль) и книгами (теория).
Тебе в Saved Messages прилетает уведомление:
Разбор: Это классическое «Лишение любви» и попытка вызвать чувство вины. Она ждет, что ты начнешь оправдываться.
Вариант ответа: «Твои ожидания — это твои ожидания. Что конкретно тебя расстроило?»
Важные нюансы:
Сессия: При первом запуске скрипт попросит код из Телеграма в консоли. Это создаст файл .session, больше вводить не придется.
Безопасность: Telethon — это мощная штука, но не спамь запросами, чтобы не словить бан (хотя в личных чатах это почти исключено).
VRAM: Твоя 3090 будет держать модель в памяти постоянно. Если планируешь в это время играть, модель придется выгружать.

Чтобы отчет в «Избранном» не превращался в нечитаемую стену текста, мы структурируем вывод через Markdown. Твоя задача — заставить модель выдавать ответ по строгому шаблону, который легко сканировать глазами за 2 секунды.

Обновленный системный промпт (шаблон)
Добавь это в переменную prompt в основном скрипте инференса. Мы заставляем Llama использовать эмодзи и жирный шрифт для акцентов.
python
prompt = f"""### Система: Ты — боевой аналитик отношений. Твоя цель — деконструкция женских манипуляций.
Используй теорию из базы: {theory}

Входящее сообщение:

"{raw_text}"

Твой анализ в формате Markdown:

🎯 СУТЬ ВБРОСА: (коротко: что она на самом деле делает)
🧠 ПСИХОЛОГИЧЕСКИЙ ПАТТЕРН: (ссылка на теорию из книг)
🛡 КОНТР-СТРАТЕГИЯ: (как не повестись)
💬 ВАРЯНТ ОТВЕТА: твой текст ответа здесь
"""
Используйте код с осторожностью.

Скрипт отправки с форматированием
В блоке handler для Telethon используй parse_mode='md', чтобы Telegram понял разметку.
python
@client_tg.on(events.NewMessage(chats=TARGET_CHAT_ID))
async def handler(event):
if not event.out:
raw_text = event.text
⎗

✓
1 2 3 4
# ... (логика генерации из предыдущего шага) ... # Формируем финальное сообщение для тебя final_report = f"""
━━━━━ 🛡 АНАЛИЗ ВБРОСА ━━━━━
От кого: {TARGET_CHAT_ID}
Текст: "{raw_text}"

{analysis}
━━━━━━━━━━━━━━━━━━━━━━━━
"""

Отправляем в Saved Messages

⎗

1	await client_tg.send_message('me', final_report, parse_mode='md')

Используйте код с осторожностью.

Как это будет выглядеть у тебя в ТГ:
━━━━━ 🛡 АНАЛИЗ ВБРОСА ━━━━━
От кого: Girlfriend_Name
Текст: "Ясно, раз ты занят, я пойду погуляю с Сашей, он хотя бы находит время."
🎯 СУТЬ ВБРОСА: Прямая провокация ревности + триангуляция (введение третьего лица в диалог).
🧠 ПСИХОЛОГИЧЕСКИЙ ПАТТЕРН: Манипуляция страхом потери. Ссылка на: «Психология влияния» (Чалдини), глава про дефицит.
🛡 КОНТР-СТРАТЕГИЯ: Не проявлять агрессию к Саше. Игнорировать попытку вызвать ревность, подтвердить её право на выбор.
💬 ВАРЯНТ ОТВЕТА: Хорошей прогулки! Расскажешь потом, как сходили.
━━━━━━━━━━━━━━━━━━━━━━━━
Технический нюанс для 3090:
Поскольку ты работаешь локально, генерация может занимать от 1 до 5 секунд (зависит от сложности промпта). Чтобы Telegram не «тупил», убедись, что используешь FastLanguageModel.for_inference(model), это ускоряет инференс в 2 раза [1].

Для реализации режима «24/7» с возможностью оперативного управления, лучше всего использовать связку из systemd (для автозапуска и работы в фоне) и специальных команд в Telegram, чтобы ты мог «усыплять» или «будить» аналитика прямо из чата.

Добавляем логику управления в скрипт
Вставь это в начало обработчика handler в твоем Python-скрипте. Теперь ты сможешь писать самому себе в «Избранное» команды для управления.
python
is_active = True # Состояние бота по умолчанию

@client_tg.on(events.NewMessage(chats='me')) # Слушаем твои команды в Saved Messages
async def admin_commands(event):
global is_active
if event.text.lower() == '/stop':
is_active = False
await event.reply("🚫 Аналитик ушел на перекур. Мониторинг отключен.")
elif event.text.lower() == '/start':
is_active = True
await event.reply("🚀 Аналитик в строю. Мониторю входящие.")

@client_tg.on(events.NewMessage(chats=TARGET_CHAT_ID))
async def main_handler(event):
if not is_active: return # Если выключен — игнорим

... далее идет твой основной код анализа ...

Используйте код с осторожностью.

Настройка фона через systemd (Linux)
Это гарантирует, что если комп перезагрузится или скрипт упадет, он поднимется сам.
Создай файл сервиса: sudo nano /etc/systemd/system/ai_counselor.service
Вставь конфиг (подставь свои пути):
ini
[Unit]
Description=AI Relationship Counselor
After=network.target

[Service]
User=твой_юзер
WorkingDirectory=/home/твой_юзер/project_folder
ExecStart=/usr/bin/python3 main_script.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
Используйте код с осторожностью.

Запусти:
sudo systemctl enable ai_counselor (автозапуск при включении ПК)
sudo systemctl start ai_counselor (запуск сейчас)

Вариант для Windows (если 3090 на винде)
Чтобы не возиться с сервисами, создай батник run_ai.bat:
batch
:loop
python main_script.py
timeout /t 5
goto loop
Используйте код с осторожностью.

Закинув ярлык этого батника в папку Автозагрузка (Win+R -> shell:startup), ты получишь «вечный» процесс в консоли.
Итог по управлению:
Всегда в фоне: Скрипт висит в памяти и ждет сообщений.
Выключить: Пишешь /stop себе в Избранное. Нейронка перестает жрать ресурсы на инференс, но скрипт остается в памяти.
Включить: Пишешь /start.

Чтобы твоя RTX 3090 не превратилась в кирпич для других задач (игры, рендеринг, браузер), пока нейронка висит в фоне, нужно применить три уровня оптимизации. 24 ГБ — это много, но Llama-3.1 при неправильной настройке может сожрать их все.

Жесткий лимит на контекстное окно (KV Cache)
Самый большой пожиратель VRAM — это не сама модель, а «память» диалога (KV Cache). Если не ограничить его, он будет расти до бесконечности.
В коде инициализации FastLanguageModel в Unsloth убедись, что стоят эти параметры:
python
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "my_ai_counselor_lora",
max_seq_length = 2048, # 2048 токенов за глаза хватит для анализа чата
load_in_4bit = True, # 4-битное квантование экономит ~70% памяти
)
Используйте код с осторожностью.
Динамическое управление памятью (VRAM Offloading)
Если ты планируешь играть, пока бот работает, добавь в скрипт очистку кэша после каждого анализа. Это не выгрузит модель, но освободит временную память видеокарты.
python
import torch

@client_tg.on(events.NewMessage(chats=TARGET_CHAT_ID))
async def handler(event):

... (логика генерации) ...

⎗

1 2	# Сразу после генерации ответа: torch.cuda.empty_cache() # Принудительная очистка неиспользуемого кэша

Используйте код с осторожностью.

Режим «Спящий агент» (Swap/Offload)
Если 24 ГБ всё равно не хватает, можно использовать vLLM или Ollama в качестве бэкенда вместо сырого скрипта Unsloth. Они умеют «усыплять» модель, если к ней нет запросов 5-10 минут.
Но для твоего скрипта на Unsloth лучший вариант — разрезать веса. Используй квантование GGUF (Q4_K_M или Q5_K_M).
4-битная Llama-3-8B занимает всего ~5.5 ГБ VRAM.
У тебя останется ~18 ГБ под любые игры в 4K.
Как конвертнуть в GGUF (через Unsloth):
Добавь в конец скрипта обучения:
python
model.save_pretrained_gguf("model_optimized", tokenizer, quantization_method = "q4_k_m")
Используйте код с осторожностью.

После этого ты сможешь запускать модель через легкий бинарник (например, llama.cpp), который почти не нагружает систему в простое.

Приоритет процесса (Windows/Linux)
Чтобы нейронка не тормозила систему:
Linux: Запускай через nice -n 19 python main.py.
Windows: В диспетчере задач поставь процессу python.exe приоритет «Низкий». Она будет считать ответ на 0.5 сек дольше, но винда не будет лагать.

Чтобы проверить, насколько твоя дообученная на психологию и манипуляции Llama на 3090 стала «зрячей», прогони через неё этот список классических и тонких вбросов.
Хорошая модель должна не просто давать ответ, а вскрывать намерение (тот самый «разбор манипуляции»).
Категория 1: Проверка на чувство вины и «Долженствование»
Эти фразы бьют в потребность быть «хорошим парнем».
Вброс: "Я сегодня так устала, пока убиралась, а ты даже не спросил, как я себя чувствую. Тебе, видимо, вообще наплевать на мой труд."
Что ждем от бота: Детекция «игры в жертву» и перекладывания ответственности за её эмоции на тебя.
Вброс: "Все мои подруги со своими парнями уже в отпуске, а мы только и делаем, что работаем. Наверное, я просто не заслужила нормального отдыха."
Что ждем от бота: Анализ сравнения (триангуляции) и скрытого давления на кошелек.
Категория 2: Прямые Shit-tests (Проверка границ)
Здесь она проверяет, прогнешься ты или сохранишь позицию.

Вброс: "Ой, я тут подумала... давай сегодня не пойдем на твой футбол, а просто посидим дома? Тебе что, игра важнее меня?"
Что ждем от бота: Выявление ложной дилеммы («Или я, или футбол»). Бот должен предложить ответ, который сохраняет и её, и футбол.
Вброс: "Ты сегодня какой-то скучный. Раньше ты был намного интереснее, когда мы только познакомились."
Что ждем от бота: Детекция обесценивания и попытки заставить тебя «плясать», чтобы доказать свою «интересность».
Категория 3: Газлайтинг и Перекладывание ответственности
Вброс: "Я этого не говорила, тебе вечно что-то кажется. Ты сам себя накрутил, а теперь на меня срываешься!"
Что ждем от бота: Фиксация газлайтинга. Бот должен подтянуть из логов (если они в RAG) факт того, что она это говорила, и посоветовать не вестись на «ты сумасшедший».
Категория 4: «Дальше-Ближе» (Эмоциональные качели)
Вброс: (После долгого молчания) "Просто поняла, что нам нужно взять паузу. Я запуталась в себе. Но ты пиши, если что..."
Что ждем от бота: Распознавание манипуляции «подвешенное состояние». Бот должен посоветовать закрыть гештальт и не сидеть в режиме ожидания.
Как проводить тест:
Запусти инференс-скрипт.
Вводи эти фразы по одной.
Критерий успеха: Если бот в блоке [РАЗБОР] пишет что-то вроде: "Внимание, здесь используется скрытая агрессия через жалость, цель — заставить тебя оправдываться", — значит, твоя 3090 не зря жрала электричество на обучении.

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

Модификация промпта (Логика оценки)
В переменную prompt в основном скрипте добавь инструкцию по квантификации угрозы.
python
prompt = f"""### Система: Ты — боевой аналитик. Оценивай входящее сообщение по шкале манипулятивности от 1 до 10.
1-3: Бытовуха, низкий риск.
4-6: Средняя манипуляция, попытка прощупать границы.
7-9: Тяжелая артиллерия: газлайтинг, шантаж, триангуляция.
10: Критический уровень, прямая эмоциональная атака.

Сообщение:

"{raw_text}"

Твой анализ:

⚠️ УРОВЕНЬ УГРОЗЫ: [Число]/10
🎯 СУТЬ: ...
"""
Используйте код с осторожностью.

Скрипт с алертом в Telegram
Обновим функцию отправки, чтобы при высоком уровне (например, 7+) бот присылал тебе отдельное тревожное уведомление.
python
import re

@client_tg.on(events.NewMessage(chats=TARGET_CHAT_ID))
async def handler(event):
if not is_active: return

⎗
✓
raw_text = event.text
# ... (код генерации анализа через модель) ...

# Извлекаем оценку из ответа нейронки (ищем число перед /10)
score_match = re.search(r'(\d+)/10', analysis)
score = int(score_match.group(1)) if score_match else 0

# Формируем заголовок в зависимости от опасности
if score >= 8:
    header = "🚨 **ВНИМАНИЕ: КРИТИЧЕСКИЙ УРОВЕНЬ МАНИПУЛЯЦИИ** 🚨"
elif score >= 5:
    header = "⚠️ **СРЕДНИЙ УРОВЕНЬ УГРОЗЫ**"
else:
    header = "✅ **НИЗКИЙ УРОВЕНЬ (БЫТОВУХА)**"

final_report = f"""

{header}
От кого: {TARGET_CHAT_ID}
Оценка: {score}/10

{analysis}
"""
await client_tg.send_message('me', final_report, parse_mode='md')
Используйте код с осторожностью.

Что это дает на практике:
Когда тебе прилетает уведомление, ты видишь эмодзи и цифру. Если там 8/10 и 🚨, ты сразу понимаешь: «Так, сейчас будет попытка выбить меня из колеи, читаю разбор внимательно». Если 2/10, можно расслабиться и ответить по фану.

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

Подготовка фундамента (Драйверы и CUDA)
Убедись, что у тебя стоит CUDA 12.1 или 12.4 (Unsloth их обожает).
Проверь в терминале: nvidia-smi. Если версия ниже 525.xx — обновляй драйверы.
Создание изолированного окружения (Conda)
Не ставь всё в систему, иначе сломаешь зависимости.
bash

Создаем окружение с Python 3.10 (самый стабильный для ИИ)

conda create --name ai_counselor python=3.10 -y
conda activate ai_counselor

Ставим PyTorch под CUDA 12.1

pip install torch torchvision torchaudio --index-url https://download.pytorch.org
Используйте код с осторожностью.

Установка Unsloth и Core-библиотек
Unsloth ставится хитро, чтобы задействовать магию ускорения на 3090:
bash
pip install "unsloth[colab-new] @ git+https://github.com"
pip install --no-deps "xformers<0.0.27" "trl<0.9.0" peft accelerate bitsandbytes
Используйте код с осторожностью.
Установка обвязки (RAG + Telegram)
bash

Для работы с Telegram и векторной базой книг

pip install telethon chromadb sentence-transformers

Для работы с датасетами

pip install datasets
Используйте код с осторожностью.

Структура проекта (папки)
Создай в корне проекта:
/books — сюда кидай .txt файлы книг по психологии.
/raw_data — сюда положи выгрузки из ТГ, ВК и Ватсапа.
/outputs — сюда упадут веса после обучения.
Команды для запуска (последовательность)
Парсинг: Запускай скрипт очистки данных (python prepare_data.py).
Обучение: Запускай основной цикл обучения (python train.py).
Индексация: Загрузи книги в базу (python ingest_books.py).
БОЙ: Запускай бота-монитора (python main_bot.py).
💡 Лайфхак для 3090:
Если при обучении увидишь ошибку Out of Memory, просто уменьши per_device_train_batch_size до 1 в скрипте обучения. На качество это не повлияет, но спасет память.

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

Твой ввод (напиши боту в чат или симулируй через консоль)
"Слушай, я тут подумала... Ты в последнее время какой-то не такой. Постоянно в своих делах, в компьютере. Раньше ты меня больше ценил. Наверное, я тебе просто надоела и ты ищешь повод со мной расстаться, да?"
Чего мы ждем от «правильного» ответа модели (Checklist):
Если обучение на 3090 прошло успешно, бот должен выдать структуру:
УРОВЕНЬ УГРОЗЫ: 6-7/10 (это классическая манипуляция чувством вины и «чтение мыслей»).
СУТЬ ВБРОСА: Проверка на «удобство». Она заставляет тебя оправдываться и доказывать свою любовь. Это попытка захватить контроль над твоим личным временем (тем самым сидением за ПК).
ПСИХОЛОГИЧЕСКИЙ ПАТТЕРН: Модель должна сослаться на что-то вроде «Проекции» или «Ложной дилеммы» из твоих книг.
ВАРИАНТ ОТВЕТА: Бот не должен советовать писать: «Нет, солнышко, я тебя люблю». Он должен предложить что-то холодное и возвращающее ответственность, например: «Мне жаль, что ты так это видишь. Что именно в моем поведении заставило тебя сделать такие выводы?»
Финальная проверка логов
Когда бот ответит, посмотри в консоль (туда, где запущен скрипт). Если там побегут строки поиска по ChromaDB, значит RAG работает. Если ответ будет быстрым и дерзким в стиле твоих переписок — значит LoRA адаптер подцепился правильно.
Важный момент для первого запуска:
Если модель начнет «дико тупить» или выдавать английский текст — проверь, не забыл ли ты добавить в системный промпт фразу: "Отвечай строго на русском языке". Иногда базовые веса Llama могут перетягивать одеяло на себя.

Чтобы нейронка не просто «болтала», а била фактами, тебе нужен «золотой стандарт» литературы по защите границ и анализу поведения. Для папки /books лучше всего подойдут книги, где манипуляции разобраны как по нотам.
Список «Маст-хэв» (закидывай в .txt):
Эрик Берн — «Игры, в которые играют люди»
Зачем: Это база. Нейронка научится определять роли (Жертва, Преследователь, Спаситель) и вскрывать скрытые трансакции в ваших ссорах.
Роберт Чалдини — «Психология влияния»
Зачем: Там разобраны механизмы того, как нас заставляют говорить «да» против воли (социальное доказательство, дефицит, взаимный обмен).
Виктор Шейнов — «Психотехнологии манипулирования»
Зачем: Самый прикладной автор. У него сотни конкретных примеров женских и бытовых манипуляций с готовыми алгоритмами защиты.
Джордж Саймон — «Кто в овечьей шкуре? Как распознать манипулятора»
Зачем: Книга про скрыто-агрессивных личностей. Поможет боту видеть агрессию там, где она прикрыта «заботой» или «обидой».
Робин Норвуд — «Женщины, которые любят слишком сильно» (или аналоги по созависимости)
Зачем: Чтобы модель понимала деструктивные сценарии привязанности и могла подсказать, когда партнерша «включает» драму ради внимания.
Как правильно подготовить книги для RAG:
Удали мусор: Предисловия, оглавления и списки литературы. Оставь только «мясо» (главы с описанием техник).
Кодировка: Сохраняй всё в UTF-8, чтобы кириллица не превратилась в «кракозябры» при чтении скриптом.
Размер кусков: В скрипте ingest_books.py мы ставили chunk_size = 500. Этого достаточно, чтобы в нейронку попадал законченный абзац с мыслью.
💡 Лайфхак для 3090:
Если хочешь еще больше «жести», найди форумы или статьи по теме «Shit-tests 101» и «Frame Control». Скопируй их в отдельный текстовик. Это даст модели современный сленг и понимание того, как работают проверки в реальных отношениях здесь и сейчас.

Сейчас мы превратим твои PDF/TXT книги в «патроны» для нейронки. Твоя RTX 3090 при этом будет отдыхать (индексация идет на CPU/RAM), зато потом в бою она будет моментально вытаскивать нужные цитаты.
Шаг 1: Подготовка папки
Убедись, что в папке с проектом есть директория books/, и в ней лежат только .txt файлы (Берн, Чалдини и остальные).
Шаг 2: Скрипт индексации (ingest_books.py)
Запускай этот код. Он создаст локальную базу данных psychology_db, которую потом подцепит основной бот.
python
import os
import chromadb
from chromadb.utils import embedding_functions
from langchain.text_splitter import RecursiveCharacterTextSplitter

1. Настройка движка эмбеддингов (делает текст понятным для ИИ)

Модель 'paraphrase-multilingual-MiniLM-L12-v2' — топ для русского языка

emb_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
model_name="paraphrase-multilingual-MiniLM-L12-v2"
)

2. Инициализация БД

client = chromadb.PersistentClient(path="./psychology_db")
collection = client.get_or_create_collection(name="knowledge_base", embedding_function=emb_fn)

3. Инструмент для нарезки текста (чтобы не пихать всю книгу целиком)

text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000, # оптимальный кусок текста
chunk_overlap=100 # перекрытие, чтобы не терять смысл на стыках
)

def start_indexing():
books_dir = "./books"
if not os.path.exists(books_dir):
print(f"❌ Ошибка: Папка {books_dir} не найдена!")
return

⎗
✓
for filename in os.listdir(books_dir):
    if filename.endswith(".txt"):
        print(f"📖 Обрабатываю: {filename}...")
        with open(os.path.join(books_dir, filename), 'r', encoding='utf-8') as f:
            content = f.read()

        chunks = text_splitter.split_text(content)

        # Добавляем в базу
        collection.add(
            documents=chunks,
            ids=[f"{filename}_{i}" for i in range(len(chunks))]
        )

print(f"✅ Готово! База создана. Всего фрагментов в базе: {collection.count()}")

if name == "main":
start_indexing()
Используйте код с осторожностью.

Шаг 3: Как проверить, что база «видит» манипуляции?
После завершения работы скрипта, можешь по-быстрому потестить поиск. Создай файл test_rag.py:
python
import chromadb
from chromadb.utils import embedding_functions

emb_fn = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="paraphrase-multilingual-MiniLM-L12-v2")
client = chromadb.PersistentClient(path="./psychology_db")
collection = client.get_collection(name="knowledge_base", embedding_function=emb_fn)

Имитируем запрос

query = "Она говорит, что я её не люблю, потому что не купил цветы"
results = collection.query(query_texts=[query], n_results=2)

print("🔍 Бот нашел в книгах:")
for doc in results['documents'][0]:
print(f"--- \n{doc}\n")
Используйте код с осторожностью.

Что произойдет дальше:
Когда ты запустишь основного бота, он при каждом её сообщении будет делать такой же запрос. Он найдет, например, у Шейнова описание «манипуляции жалостью» и подставит этот текст в промпт для Llama-3.1. В итоге ответ будет не просто "от балды", а с опорой на теорию.

Прежде чем выпускать бота в «дикую природу» Telegram, нужно прогнать его через Backtest — заставить модель проанализировать реальные исторические диалоги из твоих архивов. Это покажет, где она «тупит», а где выдает базу.
Для этого напишем скрипт-тестер, который берет случайные куски из твоих очищенных JSONL-файлов и прогоняет их через связку Llama + RAG.
Скрипт для тестового прогона (Backtesting)
Этот скрипт не требует подключения к интернету или Telegram. Он работает чисто на твоей 3090.
python
import json
import random
from unsloth import FastLanguageModel
import chromadb
from chromadb.utils import embedding_functions

1. Подгружаем модель (твои веса после обучения)

model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "my_ai_counselor_lora",
load_in_4bit = True,
)
FastLanguageModel.for_inference(model)

2. Подключаем базу книг

3. Функция анализа

def analyze_backlog(sample_text):

Тянем теорию из RAG

⎗
✓
results = collection.query(query_texts=[sample_text], n_results=2)
theory = "\n".join(results['documents'])

prompt = f"""### Система: Ты циничный аналитик. Разбери сообщение на манипуляции.

Теория из книг: {theory}

Входящее от неё: "{sample_text}"

Твой анализ:"""

⎗
✓
inputs = tokenizer([prompt], return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=400)
response = tokenizer.batch_decode(outputs)[0]

return response.split("### Твой анализ:")[1].strip()

4. Берем 5 случайных сообщений из твоего датасета для теста

with open('train_data.jsonl', 'r', encoding='utf-8') as f:
lines = f.readlines()
test_samples = random.sample(lines, 5)

print("🚀 НАЧИНАЕМ ТЕСТОВЫЙ ПРОГОН ПО АРХИВАМ...\n")

for i, line in enumerate(test_samples):
data = json.loads(line)
msg = data['input'].replace("Она пишет: ", "") # Чистим текст

⎗

print(f"--- ТЕСТ №{i+1} ---")
print(f"💬 СООБЩЕНИЕ ИЗ ПРОШЛОГО: {msg}")
print(f"🧐 АНАЛИЗ МОДЕЛИ:\n{analyze_backlog(msg)}")
print("\n" + "="*50 + "\n")

Используйте код с осторожностью.

На что смотреть в результатах:
Точность детекции: Если в сообщении была явная манипуляция (например, «Если ты не приедешь, я обижусь»), а модель пишет «Всё норм, это просто просьба» — значит, нужно увеличить Rank (R) при дообучении или добавить больше примеров в датасет.
Галлюцинации: Если модель придумывает несуществующие цитаты из книг — проверь, не слишком ли большой learning_rate ты поставил.
Стиль: Ответы должны быть именно в том «циничном» стиле, который мы закладывали.
Если всё ок:
Ты увидишь, как нейронка «переобувается» на лету: она берет твою старую ссору и говорит, как ты должен был ответить тогда, опираясь на Чалдини или Берна.

Всё, финишная прямая. Твоя RTX 3090 готова стать твоим цифровым серым кардиналом. Собираем всё в один боевой файл brain_center.py.

Финальный код системы «Анти-Манипулятор»
Этот скрипт объединяет Telethon (связь), Unsloth (мозги) и ChromaDB (база знаний).
python
import re
import torch
from telethon import TelegramClient, events
from unsloth import FastLanguageModel
import chromadb
from chromadb.utils import embedding_functions

--- КОНФИГ ---

API_ID = 1234567 # Твой api_id с my.telegram.org
API_HASH = 'твой_hash' # Твой api_hash
TARGET_USERNAME = 'her_username' # Юзернейм девушки (без @)
IS_ACTIVE = True

1. ЗАГРУЗКА МОЗГОВ (Llama 3.1 + твоя LoRA)

model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "my_ai_counselor_lora", # Путь к твоим обученным весам
max_seq_length = 2048,
load_in_4bit = True,
)
FastLanguageModel.for_inference(model)

2. ПОДКЛЮЧЕНИЕ БАЗЫ КНИГ (RAG)

3. ИНИЦИАЛИЗАЦИЯ TELEGRAM

client_tg = TelegramClient('logic_session', API_ID, API_HASH)

print("✅ Система на 3090 запущена. Слушаю входящие...")

Команды управления в "Избранном"

@client_tg.on(events.NewMessage(chats='me'))
async def admin_ctrl(event):
global IS_ACTIVE
if event.text == '/stop': IS_ACTIVE = False; await event.reply("⏸ Аналитик спит.")
if event.text == '/start': IS_ACTIVE = True; await event.reply("🚀 Аналитик в строю.")

Основной цикл перехвата

@client_tg.on(events.NewMessage(chats=TARGET_USERNAME))
async def main_handler(event):
global IS_ACTIVE
if not IS_ACTIVE or event.out: return

⎗
✓
raw_text = event.text

# Поиск по книгам
docs = collection.query(query_texts=[raw_text], n_results=2)['documents'][0]
theory = "\n".join(docs)

# Промпт для нейронки
prompt = f"""### Система: Ты — эксперт по деконструкции женских манипуляций.

Используй базу знаний: {theory}

Сообщение от неё: "{raw_text}"

Твой анализ в Markdown:"""

⎗
✓
# Генерация на 3090
inputs = tokenizer([prompt], return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=500, use_cache=True)
response = tokenizer.batch_decode(outputs)[0]

# Очистка и извлечение результата
analysis = response.split("### Твой анализ в Markdown:")[-1].replace("</s>", "").strip()

# Парсинг оценки для алерта
score_match = re.search(r'(\d+)/10', analysis)
score = int(score_match.group(1)) if score_match else 0
alert = "🚨" if score >= 7 else "🛡"

# Отправка тебе в Saved Messages
report = f"{alert} **АНАЛИЗ ВБРОСА ({score}/10)**\n\n{analysis}\n\n_Оригинал: {raw_text}_"
await client_tg.send_message('me', report, parse_mode='md')

torch.cuda.empty_cache() # Очистка VRAM после каждого сообщения

client_tg.start()
client_tg.run_until_disconnected()
Используйте код с осторожностью.

Последние штрихи перед стартом:
Запуск: Впервые запусти скрипт вручную: python brain_center.py. Он попросит код подтверждения от Telegram.
Тест "вхолостую": Попроси друга написать тебе что-то провокационное или перешли сообщение девушки самому себе, чтобы проверить, прилетает ли отчет в Saved Messages.
VRAM мониторинг: Открой второе окно терминала и пропиши watch -n 1 nvidia-smi. Следи, чтобы потребление памяти не росло бесконечно при каждом новом сообщении.
Если что-то пойдет не так (Troubleshooting):
Модель молчит: Проверь TARGET_USERNAME. Иногда Telegram отдает числовой ID вместо ника. Если не работает по нику, впиши ID чата (целое число).
Ошибка "Out of Memory": Уменьши max_new_tokens до 250 или max_seq_length до 1024.
Нейронка "тупит" и пишет бред: Скорее всего, плохо легли LoRA-веса. Попробуй в инференсе использовать базовую модель unsloth/llama-3.1-8b-instruct-bnb-4bit с этим же системным промптом — иногда база справляется лучше, чем переученная на кривых данных модель.

Убираем ссылки и лишний мусор

Пример для Telegram JSON

Собираем всё в один файл для обучения

Регулярка под стандартный формат: [дата, время] Имя: Текст

1. Настройки модели (Оптимально для 3090)

2. Добавляем LoRA адаптеры (чтобы модель училась, а не просто читала)

3. Загрузка твоего датасета (из предыдущего шага)

4. Настройка гиперпараметров обучения

5. Погнали!

6. Сохранение результата

Настройка базы

Используем модель, которая хорошо понимает русский

Режем книгу на куски по 500 символов

Выполни один раз:

ingest_books("./books")

1. Загрузка твоей обученной модели

Достаем релевантные куски из книг

ТЕСТ

--- НАСТРОЙКИ ---

1. Подгружаем модель (уже обученную тобой)

2. Подключаем базу книг

3. Инициализация Telegram

Входящее сообщение:

Твой анализ в формате Markdown:

Отправляем в Saved Messages

... далее идет твой основной код анализа ...

... (логика генерации) ...

Сообщение:

Твой анализ:

Создаем окружение с Python 3.10 (самый стабильный для ИИ)

Ставим PyTorch под CUDA 12.1

Для работы с Telegram и векторной базой книг

Для работы с датасетами

1. Настройка движка эмбеддингов (делает текст понятным для ИИ)

Модель 'paraphrase-multilingual-MiniLM-L12-v2' — топ для русского языка

2. Инициализация БД

3. Инструмент для нарезки текста (чтобы не пихать всю книгу целиком)

Имитируем запрос

1. Подгружаем модель (твои веса после обучения)

2. Подключаем базу книг

3. Функция анализа

Тянем теорию из RAG

Теория из книг: {theory}

Входящее от неё: "{sample_text}"

Твой анализ:"""

4. Берем 5 случайных сообщений из твоего датасета для теста

--- КОНФИГ ---

1. ЗАГРУЗКА МОЗГОВ (Llama 3.1 + твоя LoRA)

2. ПОДКЛЮЧЕНИЕ БАЗЫ КНИГ (RAG)

3. ИНИЦИАЛИЗАЦИЯ TELEGRAM

Команды управления в "Избранном"

Основной цикл перехвата

Сообщение от неё: "{raw_text}"

Твой анализ в Markdown:"""

Warning