refactor: обновление системы ML-скоринга и переход на RAG API
- Обновлен Dockerfile для использования Alpine вместо Slim, улучшая размер образа. - Удален устаревший RAGService и добавлен RagApiClient для работы с внешним RAG API. - Обновлены переменные окружения в env.example для настройки нового RAG API. - Обновлен ScoringManager для интеграции с RagApiClient. - Упрощена структура проекта, удалены ненужные файлы и зависимости, связанные с векторным хранилищем. - Обновлены обработчики и функции для работы с новым API, включая получение статистики и обработку ошибок.
This commit is contained in:
@@ -2,10 +2,9 @@
|
||||
Сервисы для ML-скоринга постов.
|
||||
|
||||
Включает:
|
||||
- RAGService - локальное векторное сравнение с ruBERT
|
||||
- RagApiClient - HTTP клиент для внешнего RAG API сервиса
|
||||
- DeepSeekService - интеграция с DeepSeek API
|
||||
- ScoringManager - объединение всех сервисов скоринга
|
||||
- VectorStore - in-memory хранилище векторов
|
||||
"""
|
||||
|
||||
from .base import ScoringResult, ScoringServiceProtocol, CombinedScore
|
||||
@@ -17,8 +16,7 @@ from .exceptions import (
|
||||
InsufficientExamplesError,
|
||||
TextTooShortError,
|
||||
)
|
||||
from .vector_store import VectorStore
|
||||
from .rag_service import RAGService
|
||||
from .rag_client import RagApiClient
|
||||
from .deepseek_service import DeepSeekService
|
||||
from .scoring_manager import ScoringManager
|
||||
|
||||
@@ -35,8 +33,7 @@ __all__ = [
|
||||
"InsufficientExamplesError",
|
||||
"TextTooShortError",
|
||||
# Сервисы
|
||||
"VectorStore",
|
||||
"RAGService",
|
||||
"RagApiClient",
|
||||
"DeepSeekService",
|
||||
"ScoringManager",
|
||||
]
|
||||
|
||||
311
helper_bot/services/scoring/rag_client.py
Normal file
311
helper_bot/services/scoring/rag_client.py
Normal file
@@ -0,0 +1,311 @@
|
||||
"""
|
||||
HTTP клиент для взаимодействия с внешним RAG сервисом.
|
||||
|
||||
Использует REST API для получения скоров и отправки примеров.
|
||||
"""
|
||||
|
||||
from typing import Optional, Dict, Any
|
||||
import httpx
|
||||
from logs.custom_logger import logger
|
||||
from helper_bot.utils.metrics import track_time, track_errors
|
||||
|
||||
from .base import ScoringResult
|
||||
from .exceptions import ScoringError, InsufficientExamplesError, TextTooShortError
|
||||
|
||||
|
||||
class RagApiClient:
|
||||
"""
|
||||
HTTP клиент для взаимодействия с внешним RAG сервисом.
|
||||
|
||||
Использует REST API для:
|
||||
- Получения скоров постов (POST /api/v1/score)
|
||||
- Отправки положительных примеров (POST /api/v1/examples/positive)
|
||||
- Отправки отрицательных примеров (POST /api/v1/examples/negative)
|
||||
- Получения статистики (GET /api/v1/stats)
|
||||
|
||||
Attributes:
|
||||
api_url: Базовый URL API сервиса
|
||||
api_key: API ключ для аутентификации
|
||||
timeout: Таймаут запросов в секундах
|
||||
test_mode: Включен ли тестовый режим (добавляет заголовок X-Test-Mode: true)
|
||||
enabled: Включен ли клиент
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
api_url: str,
|
||||
api_key: str,
|
||||
timeout: int = 30,
|
||||
test_mode: bool = False,
|
||||
enabled: bool = True,
|
||||
):
|
||||
"""
|
||||
Инициализация клиента.
|
||||
|
||||
Args:
|
||||
api_url: Базовый URL API (например, http://хх.ххх.ххх.хх/api/v1)
|
||||
api_key: API ключ для аутентификации
|
||||
timeout: Таймаут запросов в секундах
|
||||
test_mode: Включен ли тестовый режим (добавляет заголовок X-Test-Mode: true к запросам examples)
|
||||
enabled: Включен ли клиент
|
||||
"""
|
||||
# Убираем trailing slash если есть
|
||||
self.api_url = api_url.rstrip('/')
|
||||
self.api_key = api_key
|
||||
self.timeout = timeout
|
||||
self.test_mode = test_mode
|
||||
self._enabled = enabled
|
||||
|
||||
# Создаем HTTP клиент
|
||||
self._client = httpx.AsyncClient(
|
||||
timeout=httpx.Timeout(timeout),
|
||||
headers={
|
||||
"X-API-Key": api_key,
|
||||
"Content-Type": "application/json",
|
||||
}
|
||||
)
|
||||
|
||||
logger.info(f"RagApiClient инициализирован (url={self.api_url}, enabled={enabled})")
|
||||
|
||||
@property
|
||||
def source_name(self) -> str:
|
||||
"""Имя источника для результатов."""
|
||||
return "rag"
|
||||
|
||||
@property
|
||||
def is_enabled(self) -> bool:
|
||||
"""Проверяет, включен ли клиент."""
|
||||
return self._enabled
|
||||
|
||||
async def close(self) -> None:
|
||||
"""Закрывает HTTP клиент."""
|
||||
await self._client.aclose()
|
||||
|
||||
@track_time("calculate_score", "rag_client")
|
||||
@track_errors("rag_client", "calculate_score")
|
||||
async def calculate_score(self, text: str) -> ScoringResult:
|
||||
"""
|
||||
Рассчитывает скор для текста поста через API.
|
||||
|
||||
Args:
|
||||
text: Текст поста для оценки
|
||||
|
||||
Returns:
|
||||
ScoringResult с оценкой
|
||||
|
||||
Raises:
|
||||
ScoringError: При ошибке расчета
|
||||
InsufficientExamplesError: Если недостаточно примеров
|
||||
TextTooShortError: Если текст слишком короткий
|
||||
"""
|
||||
if not self._enabled:
|
||||
raise ScoringError("RAG API клиент отключен")
|
||||
|
||||
if not text or not text.strip():
|
||||
raise TextTooShortError("Текст пустой")
|
||||
|
||||
try:
|
||||
response = await self._client.post(
|
||||
f"{self.api_url}/score",
|
||||
json={"text": text.strip()}
|
||||
)
|
||||
|
||||
# Обрабатываем различные статусы
|
||||
if response.status_code == 400:
|
||||
try:
|
||||
error_data = response.json()
|
||||
error_msg = error_data.get("detail", "Неизвестная ошибка")
|
||||
except Exception:
|
||||
error_msg = response.text or "Неизвестная ошибка"
|
||||
|
||||
logger.warning(f"RagApiClient: Ошибка валидации запроса: {error_msg}")
|
||||
|
||||
if "недостаточно" in error_msg.lower() or "insufficient" in error_msg.lower():
|
||||
raise InsufficientExamplesError(error_msg)
|
||||
if "коротк" in error_msg.lower() or "short" in error_msg.lower():
|
||||
raise TextTooShortError(error_msg)
|
||||
raise ScoringError(f"Ошибка валидации: {error_msg}")
|
||||
|
||||
if response.status_code == 401:
|
||||
logger.error("RagApiClient: Ошибка аутентификации: неверный API ключ")
|
||||
raise ScoringError("Ошибка аутентификации: неверный API ключ")
|
||||
|
||||
if response.status_code == 404:
|
||||
logger.error("RagApiClient: RAG API endpoint не найден")
|
||||
raise ScoringError("RAG API endpoint не найден")
|
||||
|
||||
if response.status_code >= 500:
|
||||
logger.error(f"RagApiClient: Ошибка сервера RAG API: {response.status_code}")
|
||||
raise ScoringError(f"Ошибка сервера RAG API: {response.status_code}")
|
||||
|
||||
# Проверяем успешный статус
|
||||
if response.status_code != 200:
|
||||
response.raise_for_status()
|
||||
|
||||
data = response.json()
|
||||
|
||||
# Парсим ответ
|
||||
score = float(data.get("rag_score", 0.0))
|
||||
confidence = float(data.get("rag_confidence", 0.0)) if data.get("rag_confidence") is not None else None
|
||||
|
||||
# Форматируем confidence для логирования
|
||||
confidence_str = f"{confidence:.4f}" if confidence is not None else "None"
|
||||
|
||||
logger.info(
|
||||
f"RagApiClient: Скор успешно получен "
|
||||
f"(score={score:.4f}, confidence={confidence_str})"
|
||||
)
|
||||
|
||||
return ScoringResult(
|
||||
score=score,
|
||||
source=self.source_name,
|
||||
model=data.get("meta", {}).get("model", "rag-service"),
|
||||
confidence=confidence,
|
||||
metadata={
|
||||
"rag_score_pos_only": float(data.get("rag_score_pos_only", 0.0)) if data.get("rag_score_pos_only") is not None else None,
|
||||
"positive_examples": data.get("meta", {}).get("positive_examples"),
|
||||
"negative_examples": data.get("meta", {}).get("negative_examples"),
|
||||
}
|
||||
)
|
||||
|
||||
except httpx.TimeoutException:
|
||||
logger.error(f"RagApiClient: Таймаут запроса к RAG API (>{self.timeout}с)")
|
||||
raise ScoringError(f"Таймаут запроса к RAG API (>{self.timeout}с)")
|
||||
except httpx.RequestError as e:
|
||||
logger.error(f"RagApiClient: Ошибка подключения к RAG API: {e}")
|
||||
raise ScoringError(f"Ошибка подключения к RAG API: {e}")
|
||||
except (KeyError, ValueError, TypeError) as e:
|
||||
logger.error(f"RagApiClient: Ошибка парсинга ответа: {e}, response: {response.text if 'response' in locals() else 'N/A'}")
|
||||
raise ScoringError(f"Ошибка парсинга ответа от RAG API: {e}")
|
||||
except InsufficientExamplesError:
|
||||
raise
|
||||
except TextTooShortError:
|
||||
raise
|
||||
except ScoringError:
|
||||
# Уже залогированные ошибки (401, 404, 500, таймауты и т.д.) - просто пробрасываем
|
||||
raise
|
||||
except Exception as e:
|
||||
# Только действительно неожиданные ошибки логируем здесь
|
||||
logger.error(f"RagApiClient: Неожиданная ошибка при расчете скора: {e}", exc_info=True)
|
||||
raise ScoringError(f"Неожиданная ошибка: {e}")
|
||||
|
||||
@track_time("add_positive_example", "rag_client")
|
||||
async def add_positive_example(self, text: str) -> None:
|
||||
"""
|
||||
Добавляет текст как положительный пример (опубликованный пост).
|
||||
|
||||
Args:
|
||||
text: Текст опубликованного поста
|
||||
"""
|
||||
if not self._enabled:
|
||||
return
|
||||
|
||||
if not text or not text.strip():
|
||||
return
|
||||
|
||||
try:
|
||||
# Формируем заголовки (добавляем X-Test-Mode если включен тестовый режим)
|
||||
headers = {}
|
||||
if self.test_mode:
|
||||
headers["X-Test-Mode"] = "true"
|
||||
|
||||
response = await self._client.post(
|
||||
f"{self.api_url}/examples/positive",
|
||||
json={"text": text.strip()},
|
||||
headers=headers
|
||||
)
|
||||
|
||||
if response.status_code == 200 or response.status_code == 201:
|
||||
logger.info("RagApiClient: Положительный пример успешно добавлен")
|
||||
elif response.status_code == 400:
|
||||
logger.warning(f"RagApiClient: Ошибка валидации при добавлении положительного примера: {response.text}")
|
||||
else:
|
||||
logger.warning(f"RagApiClient: Неожиданный статус при добавлении положительного примера: {response.status_code}")
|
||||
|
||||
except httpx.TimeoutException:
|
||||
logger.warning(f"RagApiClient: Таймаут при добавлении положительного примера")
|
||||
except httpx.RequestError as e:
|
||||
logger.warning(f"RagApiClient: Ошибка подключения при добавлении положительного примера: {e}")
|
||||
except Exception as e:
|
||||
logger.error(f"RagApiClient: Ошибка добавления положительного примера: {e}")
|
||||
|
||||
@track_time("add_negative_example", "rag_client")
|
||||
async def add_negative_example(self, text: str) -> None:
|
||||
"""
|
||||
Добавляет текст как отрицательный пример (отклоненный пост).
|
||||
|
||||
Args:
|
||||
text: Текст отклоненного поста
|
||||
"""
|
||||
if not self._enabled:
|
||||
return
|
||||
|
||||
if not text or not text.strip():
|
||||
return
|
||||
|
||||
try:
|
||||
# Формируем заголовки (добавляем X-Test-Mode если включен тестовый режим)
|
||||
headers = {}
|
||||
if self.test_mode:
|
||||
headers["X-Test-Mode"] = "true"
|
||||
|
||||
response = await self._client.post(
|
||||
f"{self.api_url}/examples/negative",
|
||||
json={"text": text.strip()},
|
||||
headers=headers
|
||||
)
|
||||
|
||||
if response.status_code == 200 or response.status_code == 201:
|
||||
logger.info("RagApiClient: Отрицательный пример успешно добавлен")
|
||||
elif response.status_code == 400:
|
||||
logger.warning(f"RagApiClient: Ошибка валидации при добавлении отрицательного примера: {response.text}")
|
||||
else:
|
||||
logger.warning(f"RagApiClient: Неожиданный статус при добавлении отрицательного примера: {response.status_code}")
|
||||
|
||||
except httpx.TimeoutException:
|
||||
logger.warning(f"RagApiClient: Таймаут при добавлении отрицательного примера")
|
||||
except httpx.RequestError as e:
|
||||
logger.warning(f"RagApiClient: Ошибка подключения при добавлении отрицательного примера: {e}")
|
||||
except Exception as e:
|
||||
logger.error(f"RagApiClient: Ошибка добавления отрицательного примера: {e}")
|
||||
|
||||
async def get_stats(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Получает статистику от RAG API.
|
||||
|
||||
Returns:
|
||||
Словарь со статистикой или пустой словарь при ошибке
|
||||
"""
|
||||
if not self._enabled:
|
||||
return {}
|
||||
|
||||
try:
|
||||
response = await self._client.get(f"{self.api_url}/stats")
|
||||
|
||||
if response.status_code == 200:
|
||||
return response.json()
|
||||
else:
|
||||
logger.warning(f"RagApiClient: Неожиданный статус при получении статистики: {response.status_code}")
|
||||
return {}
|
||||
|
||||
except httpx.TimeoutException:
|
||||
logger.warning(f"RagApiClient: Таймаут при получении статистики")
|
||||
return {}
|
||||
except httpx.RequestError as e:
|
||||
logger.warning(f"RagApiClient: Ошибка подключения при получении статистики: {e}")
|
||||
return {}
|
||||
except Exception as e:
|
||||
logger.error(f"RagApiClient: Ошибка получения статистики: {e}")
|
||||
return {}
|
||||
|
||||
def get_stats_sync(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Синхронная версия get_stats для использования в get_stats() ScoringManager.
|
||||
|
||||
Внимание: Это заглушка, реальная статистика будет получена асинхронно.
|
||||
"""
|
||||
return {
|
||||
"enabled": self._enabled,
|
||||
"api_url": self.api_url,
|
||||
"timeout": self.timeout,
|
||||
}
|
||||
@@ -1,507 +0,0 @@
|
||||
"""
|
||||
RAG сервис для скоринга постов с использованием ruBERT.
|
||||
|
||||
Использует модель DeepPavlov/rubert-base-cased для создания эмбеддингов
|
||||
и сравнивает их с эталонными примерами через VectorStore.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
from typing import Optional, List
|
||||
|
||||
import numpy as np
|
||||
|
||||
from logs.custom_logger import logger
|
||||
from helper_bot.utils.metrics import track_time, track_errors
|
||||
|
||||
from .base import ScoringResult
|
||||
from .vector_store import VectorStore
|
||||
from .exceptions import (
|
||||
ModelNotLoadedError,
|
||||
ScoringError,
|
||||
InsufficientExamplesError,
|
||||
TextTooShortError,
|
||||
)
|
||||
|
||||
|
||||
class RAGService:
|
||||
"""
|
||||
RAG сервис для оценки постов на основе векторного сходства.
|
||||
|
||||
Использует ruBERT для создания эмбеддингов текста и сравнивает
|
||||
их с эталонными примерами (опубликованные vs отклоненные посты).
|
||||
|
||||
Attributes:
|
||||
model_name: Название модели HuggingFace
|
||||
vector_store: Хранилище векторов
|
||||
min_text_length: Минимальная длина текста для обработки
|
||||
"""
|
||||
|
||||
# Название модели по умолчанию
|
||||
DEFAULT_MODEL = "DeepPavlov/rubert-base-cased"
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
model_name: Optional[str] = None,
|
||||
vector_store: Optional[VectorStore] = None,
|
||||
cache_dir: Optional[str] = None,
|
||||
enabled: bool = True,
|
||||
min_text_length: int = 3,
|
||||
):
|
||||
"""
|
||||
Инициализация RAG сервиса.
|
||||
|
||||
Args:
|
||||
model_name: Название модели HuggingFace (по умолчанию ruBERT)
|
||||
vector_store: Хранилище векторов (создается автоматически если не передано)
|
||||
cache_dir: Директория для кеширования модели
|
||||
enabled: Включен ли сервис
|
||||
min_text_length: Минимальная длина текста для обработки
|
||||
"""
|
||||
self.model_name = model_name or self.DEFAULT_MODEL
|
||||
self.cache_dir = cache_dir
|
||||
self._enabled = enabled
|
||||
self.min_text_length = min_text_length
|
||||
|
||||
# Модель и токенизатор загружаются лениво
|
||||
self._model = None
|
||||
self._tokenizer = None
|
||||
self._model_loaded = False
|
||||
|
||||
# Хранилище векторов
|
||||
self.vector_store = vector_store or VectorStore()
|
||||
|
||||
logger.info(f"RAGService инициализирован (model={self.model_name}, enabled={enabled})")
|
||||
|
||||
@property
|
||||
def source_name(self) -> str:
|
||||
"""Имя источника для результатов."""
|
||||
return "rag"
|
||||
|
||||
@property
|
||||
def is_enabled(self) -> bool:
|
||||
"""Проверяет, включен ли сервис."""
|
||||
return self._enabled
|
||||
|
||||
@property
|
||||
def is_model_loaded(self) -> bool:
|
||||
"""Проверяет, загружена ли модель."""
|
||||
return self._model_loaded
|
||||
|
||||
async def load_model(self) -> None:
|
||||
"""
|
||||
Загружает модель и токенизатор.
|
||||
|
||||
Выполняется асинхронно в отдельном потоке чтобы не блокировать event loop.
|
||||
"""
|
||||
if self._model_loaded:
|
||||
return
|
||||
|
||||
if not self._enabled:
|
||||
logger.warning("RAGService: Сервис отключен, модель не загружается")
|
||||
return
|
||||
|
||||
logger.info(f"RAGService: Загрузка модели {self.model_name}...")
|
||||
|
||||
try:
|
||||
# Загрузка в отдельном потоке
|
||||
loop = asyncio.get_event_loop()
|
||||
await loop.run_in_executor(None, self._load_model_sync)
|
||||
|
||||
self._model_loaded = True
|
||||
logger.info(f"RAGService: Модель {self.model_name} успешно загружена")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"RAGService: Ошибка загрузки модели: {e}")
|
||||
raise ModelNotLoadedError(f"Не удалось загрузить модель {self.model_name}: {e}")
|
||||
|
||||
def _load_model_sync(self) -> None:
|
||||
"""Синхронная загрузка модели (вызывается в executor)."""
|
||||
logger.info("RAGService: Начало _load_model_sync, импорт transformers...")
|
||||
from transformers import AutoTokenizer, AutoModel
|
||||
import torch
|
||||
|
||||
# Определяем устройство
|
||||
self._device = "cuda" if torch.cuda.is_available() else "cpu"
|
||||
logger.info(f"RAGService: Устройство определено: {self._device}")
|
||||
|
||||
# Загружаем токенизатор
|
||||
logger.info(f"RAGService: Загрузка токенизатора из {self.model_name}...")
|
||||
self._tokenizer = AutoTokenizer.from_pretrained(
|
||||
self.model_name,
|
||||
cache_dir=self.cache_dir,
|
||||
)
|
||||
logger.info("RAGService: Токенизатор загружен")
|
||||
|
||||
# Загружаем модель
|
||||
logger.info(f"RAGService: Загрузка модели из {self.model_name} (это может занять несколько минут)...")
|
||||
self._model = AutoModel.from_pretrained(
|
||||
self.model_name,
|
||||
cache_dir=self.cache_dir,
|
||||
)
|
||||
logger.info("RAGService: Модель загружена, перенос на устройство...")
|
||||
self._model.to(self._device)
|
||||
self._model.eval() # Режим инференса
|
||||
|
||||
logger.info(f"RAGService: Модель готова на устройстве: {self._device}")
|
||||
|
||||
def _get_embedding_sync(self, text: str) -> np.ndarray:
|
||||
"""
|
||||
Получает эмбеддинг текста (синхронно).
|
||||
|
||||
Использует [CLS] токен как представление всего текста.
|
||||
|
||||
Args:
|
||||
text: Текст для векторизации
|
||||
|
||||
Returns:
|
||||
Numpy массив с эмбеддингом (768 измерений для ruBERT)
|
||||
"""
|
||||
import torch
|
||||
|
||||
# Токенизация с ограничением длины
|
||||
inputs = self._tokenizer(
|
||||
text,
|
||||
return_tensors="pt",
|
||||
truncation=True,
|
||||
max_length=512,
|
||||
padding=True,
|
||||
)
|
||||
inputs = {k: v.to(self._device) for k, v in inputs.items()}
|
||||
|
||||
# Получаем эмбеддинг
|
||||
with torch.no_grad():
|
||||
outputs = self._model(**inputs)
|
||||
# Используем [CLS] токен (первый токен)
|
||||
embedding = outputs.last_hidden_state[:, 0, :].cpu().numpy()
|
||||
|
||||
return embedding.flatten()
|
||||
|
||||
def _get_embeddings_batch_sync(self, texts: List[str], batch_size: int = 16) -> List[np.ndarray]:
|
||||
"""
|
||||
Получает эмбеддинги для батча текстов (синхронно).
|
||||
|
||||
Обрабатывает тексты пачками для эффективного использования GPU/CPU.
|
||||
|
||||
Args:
|
||||
texts: Список текстов для векторизации
|
||||
batch_size: Размер батча (по умолчанию 16)
|
||||
|
||||
Returns:
|
||||
Список numpy массивов с эмбеддингами
|
||||
"""
|
||||
import torch
|
||||
|
||||
all_embeddings = []
|
||||
|
||||
for i in range(0, len(texts), batch_size):
|
||||
batch_texts = texts[i:i + batch_size]
|
||||
|
||||
# Токенизация батча
|
||||
inputs = self._tokenizer(
|
||||
batch_texts,
|
||||
return_tensors="pt",
|
||||
truncation=True,
|
||||
max_length=512,
|
||||
padding=True,
|
||||
)
|
||||
inputs = {k: v.to(self._device) for k, v in inputs.items()}
|
||||
|
||||
# Получаем эмбеддинги
|
||||
with torch.no_grad():
|
||||
outputs = self._model(**inputs)
|
||||
# [CLS] токен для каждого текста в батче
|
||||
batch_embeddings = outputs.last_hidden_state[:, 0, :].cpu().numpy()
|
||||
|
||||
# Разбиваем на отдельные эмбеддинги
|
||||
for j in range(len(batch_texts)):
|
||||
all_embeddings.append(batch_embeddings[j])
|
||||
|
||||
if i > 0 and i % (batch_size * 10) == 0:
|
||||
logger.info(f"RAGService: Обработано {i}/{len(texts)} текстов")
|
||||
|
||||
return all_embeddings
|
||||
|
||||
async def get_embeddings_batch(self, texts: List[str], batch_size: int = 16) -> List[np.ndarray]:
|
||||
"""
|
||||
Получает эмбеддинги для батча текстов (асинхронно).
|
||||
|
||||
Args:
|
||||
texts: Список текстов для векторизации
|
||||
batch_size: Размер батча
|
||||
|
||||
Returns:
|
||||
Список numpy массивов с эмбеддингами
|
||||
"""
|
||||
if not self._model_loaded:
|
||||
await self.load_model()
|
||||
|
||||
if not self._model_loaded:
|
||||
raise ModelNotLoadedError("Модель не загружена")
|
||||
|
||||
# Очищаем тексты
|
||||
clean_texts = [self._clean_text(text) for text in texts]
|
||||
|
||||
# Выполняем батч-обработку в thread pool
|
||||
loop = asyncio.get_event_loop()
|
||||
embeddings = await loop.run_in_executor(
|
||||
None,
|
||||
self._get_embeddings_batch_sync,
|
||||
clean_texts,
|
||||
batch_size,
|
||||
)
|
||||
|
||||
return embeddings
|
||||
|
||||
async def get_embedding(self, text: str) -> np.ndarray:
|
||||
"""
|
||||
Получает эмбеддинг текста (асинхронно).
|
||||
|
||||
Args:
|
||||
text: Текст для векторизации
|
||||
|
||||
Returns:
|
||||
Numpy массив с эмбеддингом
|
||||
|
||||
Raises:
|
||||
ModelNotLoadedError: Если модель не загружена
|
||||
TextTooShortError: Если текст слишком короткий
|
||||
"""
|
||||
if not self._model_loaded:
|
||||
await self.load_model()
|
||||
|
||||
if not self._model_loaded:
|
||||
raise ModelNotLoadedError("Модель не загружена")
|
||||
|
||||
# Очищаем текст
|
||||
clean_text = self._clean_text(text)
|
||||
|
||||
if len(clean_text) < self.min_text_length:
|
||||
raise TextTooShortError(
|
||||
f"Текст слишком короткий (минимум {self.min_text_length} символов)"
|
||||
)
|
||||
|
||||
# Выполняем в отдельном потоке
|
||||
loop = asyncio.get_event_loop()
|
||||
embedding = await loop.run_in_executor(
|
||||
None,
|
||||
self._get_embedding_sync,
|
||||
clean_text
|
||||
)
|
||||
|
||||
return embedding
|
||||
|
||||
def _clean_text(self, text: str) -> str:
|
||||
"""Очищает текст от лишних символов."""
|
||||
if not text:
|
||||
return ""
|
||||
|
||||
# Удаляем лишние пробелы и переносы строк
|
||||
clean = " ".join(text.split())
|
||||
|
||||
# Удаляем служебные символы (например "^" для helper сообщений)
|
||||
if clean == "^":
|
||||
return ""
|
||||
|
||||
return clean.strip()
|
||||
|
||||
@track_time("calculate_score", "rag_service")
|
||||
@track_errors("rag_service", "calculate_score")
|
||||
async def calculate_score(self, text: str) -> ScoringResult:
|
||||
"""
|
||||
Рассчитывает скор для текста поста.
|
||||
|
||||
Args:
|
||||
text: Текст поста для оценки
|
||||
|
||||
Returns:
|
||||
ScoringResult с оценкой
|
||||
|
||||
Raises:
|
||||
ScoringError: При ошибке расчета
|
||||
"""
|
||||
if not self._enabled:
|
||||
raise ScoringError("RAG сервис отключен")
|
||||
|
||||
try:
|
||||
# Получаем эмбеддинг текста
|
||||
embedding = await self.get_embedding(text)
|
||||
|
||||
# Логируем первые элементы вектора для отладки
|
||||
logger.info(
|
||||
f"RAGService: embedding[:3]={embedding[:3].tolist()}, "
|
||||
f"text_preview='{text[:30]}'"
|
||||
)
|
||||
|
||||
# Рассчитываем скор через VectorStore
|
||||
score, confidence, score_pos_only = self.vector_store.calculate_similarity_score(embedding)
|
||||
|
||||
return ScoringResult(
|
||||
score=score,
|
||||
source=self.source_name,
|
||||
model=self.model_name,
|
||||
confidence=confidence,
|
||||
metadata={
|
||||
"positive_examples": self.vector_store.positive_count,
|
||||
"negative_examples": self.vector_store.negative_count,
|
||||
"score_pos_only": score_pos_only, # Для сравнения
|
||||
},
|
||||
)
|
||||
|
||||
except InsufficientExamplesError:
|
||||
# Не достаточно примеров - возвращаем нейтральный скор
|
||||
logger.warning("RAGService: Недостаточно примеров для расчета скора")
|
||||
raise
|
||||
|
||||
except TextTooShortError:
|
||||
logger.warning(f"RAGService: Текст слишком короткий для оценки")
|
||||
raise
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"RAGService: Ошибка расчета скора: {e}")
|
||||
raise ScoringError(f"Ошибка расчета скора: {e}")
|
||||
|
||||
@track_time("add_positive_example", "rag_service")
|
||||
async def add_positive_example(self, text: str) -> None:
|
||||
"""
|
||||
Добавляет текст как положительный пример (опубликованный пост).
|
||||
|
||||
Args:
|
||||
text: Текст опубликованного поста
|
||||
"""
|
||||
if not self._enabled:
|
||||
return
|
||||
|
||||
try:
|
||||
clean_text = self._clean_text(text)
|
||||
if len(clean_text) < self.min_text_length:
|
||||
logger.debug("RAGService: Текст слишком короткий для примера, пропускаем")
|
||||
return
|
||||
|
||||
# Получаем эмбеддинг
|
||||
embedding = await self.get_embedding(clean_text)
|
||||
|
||||
# Вычисляем хеш для дедупликации
|
||||
text_hash = VectorStore.compute_text_hash(clean_text)
|
||||
|
||||
# Добавляем в хранилище
|
||||
added = self.vector_store.add_positive(embedding, text_hash)
|
||||
|
||||
if added:
|
||||
logger.info(f"RAGService: Добавлен положительный пример")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"RAGService: Ошибка добавления положительного примера: {e}")
|
||||
|
||||
@track_time("add_negative_example", "rag_service")
|
||||
async def add_negative_example(self, text: str) -> None:
|
||||
"""
|
||||
Добавляет текст как отрицательный пример (отклоненный пост).
|
||||
|
||||
Args:
|
||||
text: Текст отклоненного поста
|
||||
"""
|
||||
if not self._enabled:
|
||||
return
|
||||
|
||||
try:
|
||||
clean_text = self._clean_text(text)
|
||||
if len(clean_text) < self.min_text_length:
|
||||
logger.debug("RAGService: Текст слишком короткий для примера, пропускаем")
|
||||
return
|
||||
|
||||
# Получаем эмбеддинг
|
||||
embedding = await self.get_embedding(clean_text)
|
||||
|
||||
# Вычисляем хеш для дедупликации
|
||||
text_hash = VectorStore.compute_text_hash(clean_text)
|
||||
|
||||
# Добавляем в хранилище
|
||||
added = self.vector_store.add_negative(embedding, text_hash)
|
||||
|
||||
if added:
|
||||
logger.info(f"RAGService: Добавлен отрицательный пример")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"RAGService: Ошибка добавления отрицательного примера: {e}")
|
||||
|
||||
async def load_examples_from_db(
|
||||
self,
|
||||
positive_texts: list[str],
|
||||
negative_texts: list[str],
|
||||
batch_size: int = 16,
|
||||
) -> None:
|
||||
"""
|
||||
Загружает примеры из базы данных с батч-обработкой.
|
||||
|
||||
Используется при запуске бота для восстановления VectorStore.
|
||||
Батч-обработка ускоряет загрузку в 10-20 раз.
|
||||
|
||||
Args:
|
||||
positive_texts: Список текстов опубликованных постов
|
||||
negative_texts: Список текстов отклоненных постов
|
||||
batch_size: Размер батча для обработки (по умолчанию 16)
|
||||
"""
|
||||
if not self._enabled:
|
||||
return
|
||||
|
||||
logger.info(
|
||||
f"RAGService: Загрузка примеров из БД с батч-обработкой "
|
||||
f"(positive: {len(positive_texts)}, negative: {len(negative_texts)}, batch_size: {batch_size})"
|
||||
)
|
||||
|
||||
# Убеждаемся что модель загружена
|
||||
await self.load_model()
|
||||
|
||||
import time
|
||||
start_time = time.time()
|
||||
|
||||
# Фильтруем и очищаем положительные тексты
|
||||
if positive_texts:
|
||||
clean_positive = []
|
||||
positive_hashes = []
|
||||
for text in positive_texts:
|
||||
clean_text = self._clean_text(text)
|
||||
if len(clean_text) >= self.min_text_length:
|
||||
clean_positive.append(clean_text)
|
||||
positive_hashes.append(VectorStore.compute_text_hash(clean_text))
|
||||
|
||||
if clean_positive:
|
||||
logger.info(f"RAGService: Обработка {len(clean_positive)} положительных примеров батчами...")
|
||||
positive_embeddings = await self.get_embeddings_batch(clean_positive, batch_size)
|
||||
self.vector_store.add_positive_batch(positive_embeddings, positive_hashes)
|
||||
|
||||
# Фильтруем и очищаем отрицательные тексты
|
||||
if negative_texts:
|
||||
clean_negative = []
|
||||
negative_hashes = []
|
||||
for text in negative_texts:
|
||||
clean_text = self._clean_text(text)
|
||||
if len(clean_text) >= self.min_text_length:
|
||||
clean_negative.append(clean_text)
|
||||
negative_hashes.append(VectorStore.compute_text_hash(clean_text))
|
||||
|
||||
if clean_negative:
|
||||
logger.info(f"RAGService: Обработка {len(clean_negative)} отрицательных примеров батчами...")
|
||||
negative_embeddings = await self.get_embeddings_batch(clean_negative, batch_size)
|
||||
self.vector_store.add_negative_batch(negative_embeddings, negative_hashes)
|
||||
|
||||
elapsed = time.time() - start_time
|
||||
logger.info(
|
||||
f"RAGService: Загрузка завершена за {elapsed:.1f} сек "
|
||||
f"(positive: {self.vector_store.positive_count}, "
|
||||
f"negative: {self.vector_store.negative_count})"
|
||||
)
|
||||
|
||||
def save_vectors(self) -> None:
|
||||
"""Сохраняет векторы на диск."""
|
||||
if self.vector_store.storage_path:
|
||||
self.vector_store.save_to_disk()
|
||||
|
||||
def get_stats(self) -> dict:
|
||||
"""Возвращает статистику сервиса."""
|
||||
return {
|
||||
"enabled": self._enabled,
|
||||
"model_name": self.model_name,
|
||||
"model_loaded": self._model_loaded,
|
||||
"vector_store": self.vector_store.get_stats(),
|
||||
}
|
||||
@@ -1,20 +1,19 @@
|
||||
"""
|
||||
Менеджер для объединения всех сервисов скоринга.
|
||||
|
||||
Координирует работу RAGService и DeepSeekService,
|
||||
Координирует работу RagApiClient и DeepSeekService,
|
||||
выполняет параллельные запросы и агрегирует результаты.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
from typing import Optional, List
|
||||
from typing import Optional
|
||||
|
||||
from logs.custom_logger import logger
|
||||
from helper_bot.utils.metrics import track_time, track_errors
|
||||
|
||||
from .base import CombinedScore, ScoringResult
|
||||
from .rag_service import RAGService
|
||||
from .rag_client import RagApiClient
|
||||
from .deepseek_service import DeepSeekService
|
||||
from .vector_store import VectorStore
|
||||
from .exceptions import ScoringError, InsufficientExamplesError, TextTooShortError
|
||||
|
||||
|
||||
@@ -22,39 +21,39 @@ class ScoringManager:
|
||||
"""
|
||||
Менеджер для управления всеми сервисами скоринга.
|
||||
|
||||
Объединяет RAGService и DeepSeekService, выполняет параллельные
|
||||
Объединяет RagApiClient и DeepSeekService, выполняет параллельные
|
||||
запросы и агрегирует результаты в единый CombinedScore.
|
||||
|
||||
Attributes:
|
||||
rag_service: Сервис RAG с ruBERT
|
||||
rag_client: HTTP клиент для RAG API
|
||||
deepseek_service: Сервис DeepSeek API
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
rag_service: Optional[RAGService] = None,
|
||||
rag_client: Optional[RagApiClient] = None,
|
||||
deepseek_service: Optional[DeepSeekService] = None,
|
||||
):
|
||||
"""
|
||||
Инициализация менеджера.
|
||||
|
||||
Args:
|
||||
rag_service: Сервис RAG (создается автоматически если не передан)
|
||||
rag_client: HTTP клиент для RAG API (создается автоматически если не передан)
|
||||
deepseek_service: Сервис DeepSeek (создается автоматически если не передан)
|
||||
"""
|
||||
self.rag_service = rag_service
|
||||
self.rag_client = rag_client
|
||||
self.deepseek_service = deepseek_service
|
||||
|
||||
logger.info(
|
||||
f"ScoringManager инициализирован "
|
||||
f"(rag={rag_service is not None and rag_service.is_enabled}, "
|
||||
f"(rag={rag_client is not None and rag_client.is_enabled}, "
|
||||
f"deepseek={deepseek_service is not None and deepseek_service.is_enabled})"
|
||||
)
|
||||
|
||||
@property
|
||||
def is_any_enabled(self) -> bool:
|
||||
"""Проверяет, включен ли хотя бы один сервис."""
|
||||
rag_enabled = self.rag_service is not None and self.rag_service.is_enabled
|
||||
rag_enabled = self.rag_client is not None and self.rag_client.is_enabled
|
||||
deepseek_enabled = self.deepseek_service is not None and self.deepseek_service.is_enabled
|
||||
return rag_enabled or deepseek_enabled
|
||||
|
||||
@@ -82,8 +81,8 @@ class ScoringManager:
|
||||
tasks = []
|
||||
task_names = []
|
||||
|
||||
# RAG сервис
|
||||
if self.rag_service and self.rag_service.is_enabled:
|
||||
# RAG API клиент
|
||||
if self.rag_client and self.rag_client.is_enabled:
|
||||
tasks.append(self._get_rag_score(text))
|
||||
task_names.append("rag")
|
||||
|
||||
@@ -104,6 +103,7 @@ class ScoringManager:
|
||||
if isinstance(res, Exception):
|
||||
error_msg = str(res)
|
||||
result.errors[name] = error_msg
|
||||
# Ошибки уже залогированы в сервисах, здесь только предупреждение
|
||||
logger.warning(f"ScoringManager: Ошибка от {name}: {error_msg}")
|
||||
elif res is not None:
|
||||
if name == "rag":
|
||||
@@ -119,9 +119,9 @@ class ScoringManager:
|
||||
return result
|
||||
|
||||
async def _get_rag_score(self, text: str) -> Optional[ScoringResult]:
|
||||
"""Получает скор от RAG сервиса."""
|
||||
"""Получает скор от RAG API."""
|
||||
try:
|
||||
return await self.rag_service.calculate_score(text)
|
||||
return await self.rag_client.calculate_score(text)
|
||||
except InsufficientExamplesError:
|
||||
# Недостаточно примеров - это не ошибка, просто нет данных
|
||||
logger.info("ScoringManager: RAG - недостаточно примеров")
|
||||
@@ -131,7 +131,7 @@ class ScoringManager:
|
||||
logger.debug("ScoringManager: RAG - текст слишком короткий")
|
||||
return None
|
||||
except Exception as e:
|
||||
logger.error(f"ScoringManager: RAG ошибка: {e}")
|
||||
# Ошибки уже залогированы в RagApiClient, здесь только пробрасываем
|
||||
raise
|
||||
|
||||
async def _get_deepseek_score(self, text: str) -> Optional[ScoringResult]:
|
||||
@@ -143,7 +143,7 @@ class ScoringManager:
|
||||
logger.debug("ScoringManager: DeepSeek - текст слишком короткий")
|
||||
return None
|
||||
except Exception as e:
|
||||
logger.error(f"ScoringManager: DeepSeek ошибка: {e}")
|
||||
# Ошибки уже залогированы в DeepSeekService, здесь только пробрасываем
|
||||
raise
|
||||
|
||||
@track_time("on_post_published", "scoring_manager")
|
||||
@@ -161,8 +161,8 @@ class ScoringManager:
|
||||
|
||||
tasks = []
|
||||
|
||||
if self.rag_service and self.rag_service.is_enabled:
|
||||
tasks.append(self.rag_service.add_positive_example(text))
|
||||
if self.rag_client and self.rag_client.is_enabled:
|
||||
tasks.append(self.rag_client.add_positive_example(text))
|
||||
|
||||
if self.deepseek_service and self.deepseek_service.is_enabled:
|
||||
tasks.append(self.deepseek_service.add_positive_example(text))
|
||||
@@ -186,8 +186,8 @@ class ScoringManager:
|
||||
|
||||
tasks = []
|
||||
|
||||
if self.rag_service and self.rag_service.is_enabled:
|
||||
tasks.append(self.rag_service.add_negative_example(text))
|
||||
if self.rag_client and self.rag_client.is_enabled:
|
||||
tasks.append(self.rag_client.add_negative_example(text))
|
||||
|
||||
if self.deepseek_service and self.deepseek_service.is_enabled:
|
||||
tasks.append(self.deepseek_service.add_negative_example(text))
|
||||
@@ -196,45 +196,25 @@ class ScoringManager:
|
||||
await asyncio.gather(*tasks, return_exceptions=True)
|
||||
logger.info("ScoringManager: Добавлен отрицательный пример")
|
||||
|
||||
async def load_examples_from_db(
|
||||
self,
|
||||
positive_texts: List[str],
|
||||
negative_texts: List[str],
|
||||
) -> None:
|
||||
"""
|
||||
Загружает примеры из базы данных при запуске бота.
|
||||
|
||||
Args:
|
||||
positive_texts: Список текстов опубликованных постов
|
||||
negative_texts: Список текстов отклоненных постов
|
||||
"""
|
||||
if self.rag_service and self.rag_service.is_enabled:
|
||||
await self.rag_service.load_examples_from_db(
|
||||
positive_texts,
|
||||
negative_texts
|
||||
)
|
||||
|
||||
def save_vectors(self) -> None:
|
||||
"""Сохраняет векторы RAG на диск."""
|
||||
if self.rag_service:
|
||||
self.rag_service.save_vectors()
|
||||
|
||||
async def close(self) -> None:
|
||||
"""Закрывает ресурсы всех сервисов."""
|
||||
if self.deepseek_service:
|
||||
await self.deepseek_service.close()
|
||||
|
||||
# Сохраняем векторы перед закрытием
|
||||
self.save_vectors()
|
||||
if self.rag_client:
|
||||
await self.rag_client.close()
|
||||
|
||||
def get_stats(self) -> dict:
|
||||
async def get_stats(self) -> dict:
|
||||
"""Возвращает статистику всех сервисов."""
|
||||
stats = {
|
||||
"any_enabled": self.is_any_enabled,
|
||||
}
|
||||
|
||||
if self.rag_service:
|
||||
stats["rag"] = self.rag_service.get_stats()
|
||||
if self.rag_client:
|
||||
# Получаем статистику асинхронно от API
|
||||
rag_stats = await self.rag_client.get_stats()
|
||||
stats["rag"] = rag_stats if rag_stats else self.rag_client.get_stats_sync()
|
||||
|
||||
if self.deepseek_service:
|
||||
stats["deepseek"] = self.deepseek_service.get_stats()
|
||||
|
||||
@@ -1,399 +0,0 @@
|
||||
"""
|
||||
In-memory хранилище векторов на numpy.
|
||||
|
||||
Хранит векторные представления постов для быстрого сравнения.
|
||||
Поддерживает персистентность через сохранение/загрузку с диска.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
from pathlib import Path
|
||||
from typing import Optional, Tuple, List
|
||||
import threading
|
||||
|
||||
import numpy as np
|
||||
|
||||
from logs.custom_logger import logger
|
||||
from .exceptions import VectorStoreError, InsufficientExamplesError
|
||||
|
||||
|
||||
class VectorStore:
|
||||
"""
|
||||
In-memory хранилище векторов для RAG.
|
||||
|
||||
Хранит отдельно положительные (опубликованные) и отрицательные (отклоненные)
|
||||
примеры. Использует косинусное сходство для расчета скора.
|
||||
|
||||
Attributes:
|
||||
vector_dim: Размерность векторов (768 для ruBERT)
|
||||
max_examples: Максимальное количество примеров каждого типа
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
vector_dim: int = 768,
|
||||
max_examples: int = 10000,
|
||||
storage_path: Optional[str] = None,
|
||||
score_multiplier: float = 5.0,
|
||||
):
|
||||
"""
|
||||
Инициализация хранилища.
|
||||
|
||||
Args:
|
||||
vector_dim: Размерность векторов
|
||||
max_examples: Максимальное количество примеров каждого типа
|
||||
storage_path: Путь для сохранения/загрузки векторов (опционально)
|
||||
score_multiplier: Множитель для усиления разницы в скорах
|
||||
"""
|
||||
self.vector_dim = vector_dim
|
||||
self.max_examples = max_examples
|
||||
self.storage_path = storage_path
|
||||
self.score_multiplier = score_multiplier
|
||||
|
||||
# Инициализируем пустые массивы
|
||||
# Используем список для динамического добавления, потом конвертируем в numpy
|
||||
self._positive_vectors: list = []
|
||||
self._negative_vectors: list = []
|
||||
self._positive_hashes: list = [] # Хеши текстов для дедупликации
|
||||
self._negative_hashes: list = []
|
||||
|
||||
# Lock для потокобезопасности
|
||||
self._lock = threading.Lock()
|
||||
|
||||
# Пытаемся загрузить сохраненные векторы
|
||||
if storage_path and os.path.exists(storage_path):
|
||||
self._load_from_disk()
|
||||
|
||||
@property
|
||||
def positive_count(self) -> int:
|
||||
"""Количество положительных примеров."""
|
||||
return len(self._positive_vectors)
|
||||
|
||||
@property
|
||||
def negative_count(self) -> int:
|
||||
"""Количество отрицательных примеров."""
|
||||
return len(self._negative_vectors)
|
||||
|
||||
@property
|
||||
def total_count(self) -> int:
|
||||
"""Общее количество примеров."""
|
||||
return self.positive_count + self.negative_count
|
||||
|
||||
@staticmethod
|
||||
def compute_text_hash(text: str) -> str:
|
||||
"""Вычисляет хеш текста для дедупликации."""
|
||||
return hashlib.md5(text.encode('utf-8')).hexdigest()
|
||||
|
||||
def _normalize_vector(self, vector: np.ndarray) -> np.ndarray:
|
||||
"""Нормализует вектор для косинусного сходства."""
|
||||
norm = np.linalg.norm(vector)
|
||||
if norm == 0:
|
||||
return vector
|
||||
return vector / norm
|
||||
|
||||
def add_positive(self, vector: np.ndarray, text_hash: Optional[str] = None) -> bool:
|
||||
"""
|
||||
Добавляет положительный пример (опубликованный пост).
|
||||
|
||||
Args:
|
||||
vector: Векторное представление текста
|
||||
text_hash: Хеш текста для дедупликации (опционально)
|
||||
|
||||
Returns:
|
||||
True если добавлен, False если дубликат или превышен лимит
|
||||
"""
|
||||
with self._lock:
|
||||
# Проверяем дубликат по хешу
|
||||
if text_hash and text_hash in self._positive_hashes:
|
||||
logger.debug(f"VectorStore: Пропуск дубликата положительного примера")
|
||||
return False
|
||||
|
||||
# Проверяем лимит
|
||||
if len(self._positive_vectors) >= self.max_examples:
|
||||
# Удаляем самый старый пример (FIFO)
|
||||
self._positive_vectors.pop(0)
|
||||
self._positive_hashes.pop(0)
|
||||
logger.debug("VectorStore: Удален старый положительный пример (лимит)")
|
||||
|
||||
# Нормализуем и добавляем
|
||||
normalized = self._normalize_vector(vector)
|
||||
self._positive_vectors.append(normalized)
|
||||
if text_hash:
|
||||
self._positive_hashes.append(text_hash)
|
||||
|
||||
logger.info(f"VectorStore: Добавлен положительный пример (всего: {self.positive_count})")
|
||||
return True
|
||||
|
||||
def add_positive_batch(
|
||||
self,
|
||||
vectors: List[np.ndarray],
|
||||
text_hashes: Optional[List[str]] = None
|
||||
) -> int:
|
||||
"""
|
||||
Добавляет батч положительных примеров.
|
||||
|
||||
Args:
|
||||
vectors: Список векторов
|
||||
text_hashes: Список хешей текстов для дедупликации
|
||||
|
||||
Returns:
|
||||
Количество добавленных примеров
|
||||
"""
|
||||
if text_hashes is None:
|
||||
text_hashes = [None] * len(vectors)
|
||||
|
||||
added = 0
|
||||
with self._lock:
|
||||
for vector, text_hash in zip(vectors, text_hashes):
|
||||
# Проверяем дубликат по хешу
|
||||
if text_hash and text_hash in self._positive_hashes:
|
||||
continue
|
||||
|
||||
# Проверяем лимит
|
||||
if len(self._positive_vectors) >= self.max_examples:
|
||||
self._positive_vectors.pop(0)
|
||||
self._positive_hashes.pop(0)
|
||||
|
||||
# Нормализуем и добавляем
|
||||
normalized = self._normalize_vector(vector)
|
||||
self._positive_vectors.append(normalized)
|
||||
if text_hash:
|
||||
self._positive_hashes.append(text_hash)
|
||||
added += 1
|
||||
|
||||
logger.info(f"VectorStore: Добавлено {added} положительных примеров батчем (всего: {self.positive_count})")
|
||||
return added
|
||||
|
||||
def add_negative(self, vector: np.ndarray, text_hash: Optional[str] = None) -> bool:
|
||||
"""
|
||||
Добавляет отрицательный пример (отклоненный пост).
|
||||
|
||||
Args:
|
||||
vector: Векторное представление текста
|
||||
text_hash: Хеш текста для дедупликации (опционально)
|
||||
|
||||
Returns:
|
||||
True если добавлен, False если дубликат или превышен лимит
|
||||
"""
|
||||
with self._lock:
|
||||
# Проверяем дубликат по хешу
|
||||
if text_hash and text_hash in self._negative_hashes:
|
||||
logger.debug(f"VectorStore: Пропуск дубликата отрицательного примера")
|
||||
return False
|
||||
|
||||
# Проверяем лимит
|
||||
if len(self._negative_vectors) >= self.max_examples:
|
||||
# Удаляем самый старый пример (FIFO)
|
||||
self._negative_vectors.pop(0)
|
||||
self._negative_hashes.pop(0)
|
||||
logger.debug("VectorStore: Удален старый отрицательный пример (лимит)")
|
||||
|
||||
# Нормализуем и добавляем
|
||||
normalized = self._normalize_vector(vector)
|
||||
self._negative_vectors.append(normalized)
|
||||
if text_hash:
|
||||
self._negative_hashes.append(text_hash)
|
||||
|
||||
logger.info(f"VectorStore: Добавлен отрицательный пример (всего: {self.negative_count})")
|
||||
return True
|
||||
|
||||
def add_negative_batch(
|
||||
self,
|
||||
vectors: List[np.ndarray],
|
||||
text_hashes: Optional[List[str]] = None
|
||||
) -> int:
|
||||
"""
|
||||
Добавляет батч отрицательных примеров.
|
||||
|
||||
Args:
|
||||
vectors: Список векторов
|
||||
text_hashes: Список хешей текстов для дедупликации
|
||||
|
||||
Returns:
|
||||
Количество добавленных примеров
|
||||
"""
|
||||
if text_hashes is None:
|
||||
text_hashes = [None] * len(vectors)
|
||||
|
||||
added = 0
|
||||
with self._lock:
|
||||
for vector, text_hash in zip(vectors, text_hashes):
|
||||
# Проверяем дубликат по хешу
|
||||
if text_hash and text_hash in self._negative_hashes:
|
||||
continue
|
||||
|
||||
# Проверяем лимит
|
||||
if len(self._negative_vectors) >= self.max_examples:
|
||||
self._negative_vectors.pop(0)
|
||||
self._negative_hashes.pop(0)
|
||||
|
||||
# Нормализуем и добавляем
|
||||
normalized = self._normalize_vector(vector)
|
||||
self._negative_vectors.append(normalized)
|
||||
if text_hash:
|
||||
self._negative_hashes.append(text_hash)
|
||||
added += 1
|
||||
|
||||
logger.info(f"VectorStore: Добавлено {added} отрицательных примеров батчем (всего: {self.negative_count})")
|
||||
return added
|
||||
|
||||
def calculate_similarity_score(self, vector: np.ndarray) -> Tuple[float, float]:
|
||||
"""
|
||||
Рассчитывает скор на основе сходства с примерами.
|
||||
|
||||
Алгоритм:
|
||||
1. Вычисляем среднее косинусное сходство с положительными примерами
|
||||
2. Вычисляем среднее косинусное сходство с отрицательными примерами
|
||||
3. Финальный скор = pos_sim / (pos_sim + neg_sim + eps)
|
||||
|
||||
Args:
|
||||
vector: Векторное представление нового поста
|
||||
|
||||
Returns:
|
||||
Tuple (score, confidence):
|
||||
- score: Оценка от 0.0 до 1.0
|
||||
- confidence: Уверенность (зависит от количества примеров)
|
||||
|
||||
Raises:
|
||||
InsufficientExamplesError: Если недостаточно примеров
|
||||
"""
|
||||
with self._lock:
|
||||
if self.positive_count == 0:
|
||||
raise InsufficientExamplesError(
|
||||
"Нет положительных примеров для сравнения"
|
||||
)
|
||||
|
||||
# Нормализуем входной вектор
|
||||
normalized = self._normalize_vector(vector)
|
||||
|
||||
# Конвертируем в numpy массивы для быстрых вычислений
|
||||
pos_matrix = np.array(self._positive_vectors)
|
||||
|
||||
# Косинусное сходство с положительными примерами
|
||||
# Для нормализованных векторов это просто скалярное произведение
|
||||
pos_similarities = np.dot(pos_matrix, normalized)
|
||||
pos_sim = float(np.mean(pos_similarities))
|
||||
|
||||
# Косинусное сходство с отрицательными примерами
|
||||
if self.negative_count > 0:
|
||||
neg_matrix = np.array(self._negative_vectors)
|
||||
neg_similarities = np.dot(neg_matrix, normalized)
|
||||
neg_sim = float(np.mean(neg_similarities))
|
||||
else:
|
||||
# Если нет отрицательных примеров, используем нейтральное значение
|
||||
neg_sim = pos_sim # Нейтральный скор = 0.5
|
||||
|
||||
# === Вариант 1: neg/pos (разница между положительными и отрицательными) ===
|
||||
diff = pos_sim - neg_sim
|
||||
score_neg_pos = 0.5 + (diff * self.score_multiplier)
|
||||
score_neg_pos = max(0.0, min(1.0, score_neg_pos))
|
||||
|
||||
# === Вариант 2: pos only (только положительные, топ-k ближайших) ===
|
||||
# Берём топ-5 ближайших положительных примеров
|
||||
top_k = min(5, len(pos_similarities))
|
||||
top_k_sim = float(np.mean(np.sort(pos_similarities)[-top_k:]))
|
||||
# Нормализуем: 0.85 -> 0.0, 0.95 -> 1.0 (типичный диапазон для BERT)
|
||||
score_pos_only = (top_k_sim - 0.85) / 0.10
|
||||
score_pos_only = max(0.0, min(1.0, score_pos_only))
|
||||
|
||||
# Основной скор — neg/pos (можно будет переключить позже)
|
||||
score = score_neg_pos
|
||||
|
||||
# Confidence зависит от количества примеров (100% при 1000 примерах)
|
||||
total_examples = self.positive_count + self.negative_count
|
||||
confidence = min(1.0, total_examples / 1000)
|
||||
|
||||
logger.info(
|
||||
f"VectorStore: pos_sim={pos_sim:.4f}, neg_sim={neg_sim:.4f}, "
|
||||
f"top_k_sim={top_k_sim:.4f}, score_neg_pos={score_neg_pos:.4f}, "
|
||||
f"score_pos_only={score_pos_only:.4f}"
|
||||
)
|
||||
|
||||
return score, confidence, score_pos_only
|
||||
|
||||
def save_to_disk(self, path: Optional[str] = None) -> None:
|
||||
"""
|
||||
Сохраняет векторы на диск.
|
||||
|
||||
Args:
|
||||
path: Путь для сохранения (если не указан, используется storage_path)
|
||||
"""
|
||||
save_path = path or self.storage_path
|
||||
if not save_path:
|
||||
raise VectorStoreError("Путь для сохранения не указан")
|
||||
|
||||
with self._lock:
|
||||
# Создаем директорию если нужно
|
||||
Path(save_path).parent.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Сохраняем в npz формате
|
||||
np.savez_compressed(
|
||||
save_path,
|
||||
positive_vectors=np.array(self._positive_vectors) if self._positive_vectors else np.array([]),
|
||||
negative_vectors=np.array(self._negative_vectors) if self._negative_vectors else np.array([]),
|
||||
positive_hashes=np.array(self._positive_hashes, dtype=object),
|
||||
negative_hashes=np.array(self._negative_hashes, dtype=object),
|
||||
vector_dim=self.vector_dim,
|
||||
max_examples=self.max_examples,
|
||||
)
|
||||
|
||||
logger.info(
|
||||
f"VectorStore: Сохранено на диск ({self.positive_count} pos, "
|
||||
f"{self.negative_count} neg): {save_path}"
|
||||
)
|
||||
|
||||
def _load_from_disk(self) -> None:
|
||||
"""Загружает векторы с диска."""
|
||||
if not self.storage_path or not os.path.exists(self.storage_path):
|
||||
return
|
||||
|
||||
try:
|
||||
with self._lock:
|
||||
data = np.load(self.storage_path, allow_pickle=True)
|
||||
|
||||
# Загружаем векторы
|
||||
pos_vectors = data.get('positive_vectors', np.array([]))
|
||||
neg_vectors = data.get('negative_vectors', np.array([]))
|
||||
|
||||
if pos_vectors.size > 0:
|
||||
self._positive_vectors = list(pos_vectors)
|
||||
if neg_vectors.size > 0:
|
||||
self._negative_vectors = list(neg_vectors)
|
||||
|
||||
# Загружаем хеши
|
||||
pos_hashes = data.get('positive_hashes', np.array([]))
|
||||
neg_hashes = data.get('negative_hashes', np.array([]))
|
||||
|
||||
if pos_hashes.size > 0:
|
||||
self._positive_hashes = list(pos_hashes)
|
||||
if neg_hashes.size > 0:
|
||||
self._negative_hashes = list(neg_hashes)
|
||||
|
||||
logger.info(
|
||||
f"VectorStore: Загружено с диска ({self.positive_count} pos, "
|
||||
f"{self.negative_count} neg): {self.storage_path}"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"VectorStore: Ошибка загрузки с диска: {e}")
|
||||
# Продолжаем с пустым хранилищем
|
||||
|
||||
def clear(self) -> None:
|
||||
"""Очищает все векторы."""
|
||||
with self._lock:
|
||||
self._positive_vectors.clear()
|
||||
self._negative_vectors.clear()
|
||||
self._positive_hashes.clear()
|
||||
self._negative_hashes.clear()
|
||||
logger.info("VectorStore: Хранилище очищено")
|
||||
|
||||
def get_stats(self) -> dict:
|
||||
"""Возвращает статистику хранилища."""
|
||||
return {
|
||||
"positive_count": self.positive_count,
|
||||
"negative_count": self.negative_count,
|
||||
"total_count": self.total_count,
|
||||
"vector_dim": self.vector_dim,
|
||||
"max_examples": self.max_examples,
|
||||
"storage_path": self.storage_path,
|
||||
}
|
||||
Reference in New Issue
Block a user