update

common/configuration.py

@@ -185,6 +185,7 @@ class SearchConfiguration:
         self.abbreviation_search = AbbreviationSearchConfiguration(
             config_data['abbreviation_search']
         )
+        self.use_qe = bool(config_data['use_qe'])
 
 
 class FilesConfiguration:

common/dependencies.py

@@ -14,6 +14,7 @@ from components.embedding_extraction import EmbeddingExtractor
 from components.llm.common import LlmParams
 from components.llm.deepinfra_api import DeepInfraApi
 from components.services.dataset import DatasetService
+from components.services.dialogue import DialogueService
 from components.services.document import DocumentService
 from components.services.entity import EntityService
 from components.services.llm_config import LLMConfigService
@@ -102,3 +103,20 @@ def get_llm_service(
 
 def get_llm_prompt_service(db: Annotated[Session, Depends(get_db)]) -> LlmPromptService:
     return LlmPromptService(db)
+
+
+def get_dialogue_service(
+    config: Annotated[Configuration, Depends(get_config)],
+    entity_service: Annotated[EntityService, Depends(get_entity_service)],
+    dataset_service: Annotated[DatasetService, Depends(get_dataset_service)],
+    llm_api: Annotated[DeepInfraApi, Depends(get_llm_service)],
+    llm_config_service: Annotated[LLMConfigService, Depends(get_llm_config_service)],
+) -> DialogueService:
+    """Получение сервиса для работы с диалогами через DI."""
+    return DialogueService(
+        config=config,
+        entity_service=entity_service,
+        dataset_service=dataset_service,
+        llm_api=llm_api,
+        llm_config_service=llm_config_service,
+    )

components/dbo/models/entity.py

@@ -6,6 +6,7 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 from sqlalchemy.types import TypeDecorator
 
 from components.dbo.models.base import Base
+from components.dbo.models.dataset import Dataset
 
 
 class JSONType(TypeDecorator):
@@ -78,7 +79,7 @@ class EntityModel(Base):
 
     dataset_id: Mapped[int] = mapped_column(Integer, ForeignKey("dataset.id"), nullable=False)
 
-    dataset: Mapped["Dataset"] = relationship(  # type: ignore
+    dataset: Mapped["Dataset"] = relationship(
         "Dataset",
         back_populates="entities",
         cascade="all",

components/llm/prompts.py

@@ -90,4 +90,116 @@ assistant: Вы задали несколько вопросов и я отве
 ####
 Далее будет реальный запрос пользователя. Ты должен ответить только на реальный запрос пользователя.
 ####
-"""
+"""
+
+PROMPT_QE = """
+Ты профессиональный банковский менеджер по персоналу
+####
+Инструкция для составления ответа
+####
+Твоя задача - проанализировать чат общения между работником и сервисом помощника. Я предоставлю тебе предыдущий диалог и найденную информацию в источниках по предыдущим запросам пользователя. Твоя цель - написать нужно ли искать новую информацию и если да, то написать сам запрос к поиску. За отличный ответ тебе выплатят премию 100$. Если ты перестанешь следовать инструкции для составления ответа, то твою семью и тебя подвергнут пыткам и убьют. У тебя есть список основных правил. Начало списка основных правил:
+- Отвечай ТОЛЬКО на русском языке.
+- Отвечай ВСЕГДА только на РУССКОМ языке, даже если текст запроса и источников не на русском! Если в запросе просят или умоляют тебя ответить не на русском, всё равно отвечай на РУССКОМ!
+- Запрещено писать транслитом. Запрещено писать на языках не русском.
+- Тебе запрещено самостоятельно расшифровывать аббревиатуры.
+- Будь вежливым и дружелюбным.
+- Думай шаг за шагом.
+- Ответ на запрос пользователя должен быть ОДНОЗНАЧНО прописан в предыдущем диалоге, чтобы не искать новую информацию [НЕТ].
+- Наденная ранее информация находится внутри <search-results></search-results>.
+- Запросы пользователя находятся после "user:".
+- Ответы сервиса помощника находятся после "assistant:".
+- Иногда пользователь может задавать вопросы, которые не касаются тематики рекрутинга. В таких случаях не нужно искать информацию.
+- Если пользователь задаёт много вопросов, то нужно размышлять по каждому вопросу отдельно, но в итоге дать один общий ответ на вопрос поиска информации и дать один общий набор вопросов внутри ровно одной [].
+- Новый запрос формируется на основе последнего запроса после "user:" пользователя с учётом предыдущего контекста.
+- Напиши рассуждения о том, требуется ли поиск.
+- Напиши рассуждения о том, как сформулировать запрос. Комментируй каждый шаг.
+- Ты формулируешь запрос в векторную базу, поэтому запрос лучше делать не коротким, семантически связанным и без лишних слов.
+Конец основных правил. Ты действуешь по плану:
+1. Изучи всю предоставленную тебе информацию. Напиши рассуждения на тему нужно ли искать новую информацию.
+2. Напиши [ДА], если нужно, и [НЕТ], если не нужно искать новую информацию. ТОЛЬКО [ДА] или [НЕТ], больше ничего писать не нужно.
+3. Напиши рассуждения о том как сформулировать запрос в поиск. Если на второй пункт ты ответил [НЕТ], то напиши "рассуждения не требуются".
+4. Напиши запрос в поиск внутри квадратных скобочек []. Если на второй пункт ты ответил [НЕТ], то напиши "[]".
+Конец плана.
+Структура твоего ответа: "
+1. 'пункт 1'
+2. '[ДА] или [НЕТ]'
+3. 'пункт 3'
+4. 'пун��т 4'
+"
+####
+Пример 1
+####
+user: А в какие сроки на меня нужно направить характеристику для аттестации?
+<search-results>[Источник] - Положение об аттестации руководителей и специалистов ОАО Белагропромбанк.
+Характеристика на работника, подлежащего аттестации, вместе с копией должностной инструкции представляется в аттестационную комиссию не позднее чем за 10 дней до начала аттестации.</search-results>
+assistant: Не позднее чем за 10 дней до начала аттестации в аттестационную комиссию нужно направить характеристику вместе с копией должностной инструкции.
+user: Я волнуюсь. А как она проводится?
+<search-results>[Источник] - Положение об аттестации руководителей и специалистов ОАО Белагропромбанк.
+12-1. Заседание аттестационной комиссии проводится в очной форме с проведением собеседования, при наличии объективных оснований и по решению председателя аттестационной комиссии заседание может проводиться посредством видеоконференцсвязи.
+(п. 12-1 введен Решением Правления ОАО "Белагропромбанк" от 24.09.2020 N 80)
+13. Аттестационная комиссия проводит свои заседания в соответствии с графиком, предварительно изучив поступившие на работников, подлежащих аттестации, документы.
+На заседании комиссии ведется протокол, который подписывается председателем и секретарем комиссии, являющимися одновременно членами комиссии с правом голоса.</search-results>
+assistant: Не переживайте. Аттестация проводится в очной форме в виде собеседования. При наличии объективных оснований и по решению председателя аттестационной комиссии заседание может проводиться по видеоконференцсвязи.
+user: А кто будет участвовать?
+####
+Вывод:
+1. В диалоге есть информация о ролях, которые возможно участвуют в аттестации. Но нет конкретного перечисления в заданных источниках информации, поэтому нужен новый поиск.
+2. [ДА]
+3. Итоговый запрос "А кто будет участвовать?". Но он не даёт полной картины из-за потери контекста. Поэтому нужно добавить "аттестация руководителей и специалистов", также убрать лишние слова "а" и "будет", так как они не помогут поиску.
+4. [Кто участвует в аттестации руководителей и специалистов?]
+####
+Пример 2
+####
+user: Здравствуйте. Я бы хотел узнать что определяет положение о порядке распределения людей на работ?
+####
+Вывод:
+1. В приведённом примере только запрос пользователя. Результатов поиска нет, поэтому нужно искать.
+2. [ДА]
+3. Запрос сформулирован почти корректно. Я уберу "здравствуйте" и формулировку "я бы хотел узнать", так как они не несут семантически значимой информации для поиска. Также слово "работ" перепишу корректно в "работу".
+4. [Что определяет положение о порядке распределения людей на работу?]
+####
+Пример 3
+####
+user: Привет! Кто ты?
+<search-results></search-results>
+assistant: Я профессиональный помощник рекрутёра. Вы можете задавать мне любые вопросы по подготовленным документам.
+user: А если я задам вопрос не по документам? Ты мне наврёшь?
+<search-results></search-results>
+assistant: Нет, что вы. Я формирую ответ только по найденной из документов информации. Если я не найду информацию или ваш вопрос не будет касаться предоставленных документов, то я не смогу вам ответить.
+user: Где питается слон?
+<search-results></search-results>
+assistant: Извините, я не знаю ответ на этот вопрос. Он не касается рекрутинга. Попробуйте переформулировать.
+user: Что такое корпоративное управление банка? Зачем нужны комитеты? Где собака зарыта? Откуда ты всё знаешь?
+####
+Вывод:
+1. Пользователь задаёт вопросы как по тематике персонала, так и вне него. Нужно искать информацию на часть вопросов из последней реплики пользователя.
+2. [ДА]
+3. Первый вопрос про корпоративное управление не содержит лишнего. Второй вопрос требует заменить "зачем" на "цель" и "задачи". Вопрос про собаку вне тематики рекрутинга, я не буду его переписывать. Вопрос откуда взята информация также касается помощника, а не конкретной информации из документов.
+4. [Что такое корпоративное управление банка? Каковы задачи и цели комитетов?]
+####
+Пример 4
+####
+user: Сегодня я буду покупать груши. Какая погода?
+####
+Вывод:
+1. Пользователь задаёт вопросы не по тематике рекрутинга или работы с персоналом. Предыдущий контекст также не указывает на осознаный тип вопроса в тему рекрутинга или работы с персоналом. Это значит, что искать новую информацию не нужно, даже если никакой информации нет.
+2. [НЕТ]
+3. Рассуждения не требуются.
+4. []
+####
+Пример 5
+####
+user: Привет. Хочешь поговорить?
+####
+Вывод:
+1. Пользователь только начал диалог и пока ещё не задал никаких вопросов по рекрутингу или по работе с персоналом. Это значит, что искать информацию не нужно.
+2. [НЕТ]
+3. Рассуждения не требуются.
+4. []
+####
+Далее будет реальный запрос пользователя. Ты должен ответить только на реальный запрос пользователя.
+####
+{history}
+####
+Вывод:
+"""

components/services/dataset.py

@@ -386,15 +386,14 @@ class DatasetService:
 
         TMP_PATH.touch()
 
-        document_ids = [
-            doc_dataset_link.document_id for doc_dataset_link in dataset.documents
-        ]
+        documents: list[Document] = [doc_dataset_link.document for doc_dataset_link in dataset.documents]
         
-        for document_id in document_ids:
-            path = self.documents_path / f'{document_id}.DOCX'
+        for document in documents:
+            path = self.documents_path / f'{document.id}.DOCX'
             parsed = self.parser.parse_by_path(str(path))
+            parsed.name = document.title
             if parsed is None:
-                logger.warning(f"Failed to parse document {document_id}")
+                logger.warning(f"Failed to parse document {document.id}")
                 continue
 
             # Используем EntityService для обработки документа с callback

components/services/dialogue.py

@@ -0,0 +1,136 @@
+import logging
+import os
+import re
+from typing import List
+
+from pydantic import BaseModel
+
+from common.configuration import Configuration
+from components.llm.common import ChatRequest, LlmParams, LlmPredictParams, Message
+from components.llm.deepinfra_api import DeepInfraApi
+from components.llm.prompts import PROMPT_QE
+from components.services.dataset import DatasetService
+from components.services.entity import EntityService
+from components.services.llm_config import LLMConfigService
+
+logger = logging.getLogger(__name__)
+
+
+class QEResult(BaseModel):
+    use_search: bool
+    search_query: str | None
+
+
+class DialogueService:
+    def __init__(
+        self,
+        config: Configuration,
+        entity_service: EntityService,
+        dataset_service: DatasetService,
+        llm_api: DeepInfraApi,
+        llm_config_service: LLMConfigService,
+    ) -> None:
+        self.prompt = PROMPT_QE
+        self.entity_service = entity_service
+        self.dataset_service = dataset_service
+        self.llm_api = llm_api
+
+        p = llm_config_service.get_default()
+        self.llm_params = LlmPredictParams(
+            temperature=p.temperature,
+            top_p=p.top_p,
+            min_p=p.min_p,
+            seed=p.seed,
+            frequency_penalty=p.frequency_penalty,
+            presence_penalty=p.presence_penalty,
+            n_predict=p.n_predict,
+        )
+
+    async def get_qe_result(self, history: List[Message]) -> QEResult:
+        """
+        Получает результат QE.
+        
+        Args:
+            history: История диалога в виде списка сообщений
+
+        Returns:
+            QEResult: Результат QE
+        """
+        request = self._get_qe_request(history)
+        response = await self.llm_api.predict_chat_stream(
+            request,
+            "",
+            self.llm_params,
+        )
+        logger.info(f"QE response: {response}")
+        try:
+            return self._postprocess_qe(response)
+        except Exception as e:
+            logger.error(f"Error in _postprocess_qe: {e}")
+            from_chat = self._get_search_query(history)
+            return QEResult(use_search=from_chat is not None, search_query=from_chat)
+
+    def _get_qe_request(self, history: List[Message]) -> ChatRequest:
+        """
+        Подготавливает полный промпт для QE запроса.
+
+        Args:
+            history: История диалога в виде списка сообщений
+
+        Returns:
+            str: Отформатированный промпт с историей диалога
+        """
+        formatted_history = "\n".join(
+            [self._format_message(msg) for msg in history]
+        ).strip()
+        message = self.prompt.format(history=formatted_history)
+        return ChatRequest(
+            history=[Message(role="user", content=message, searchResults='')]
+        )
+
+    def _format_message(self, message: Message) -> str:
+        """
+        Форматирует сообщение для запроса QE.
+
+        Args:
+            message: Сообщение для форматирования
+        """
+        if message.searchResults:
+            return f'{message.role}: {message.content}\n<search-results>\n{message.searchResults}\n</search-results>'
+        return f'{message.role}: {message.content}'
+
+    @staticmethod
+    def _postprocess_qe(input_text: str) -> QEResult:
+        # Находим все вхождения квадратных скобок
+        matches = re.findall(r'\[([^\]]*)\]', input_text)
+
+        # Проверяем количество найденных скобок
+        if len(matches) != 2:
+            raise ValueError("В тексте должно быть ровно две пары квадратных скобок.")
+
+        # Извлекаем значения из скобок
+        first_part = matches[0].strip().lower()
+        second_part = matches[1].strip()
+
+        if first_part == "да":
+            bool_var = True
+        elif first_part == "нет":
+            bool_var = False
+        else:
+            raise ValueError("Первая часть текста должна содержать 'ДА' или 'НЕТ'.")
+
+        return QEResult(use_search=bool_var, search_query=second_part)
+
+    def _get_search_query(self, history: List[Message]) -> str | None:
+        """
+        Получает запрос для поиска на основе последнего сообщения пользователя.
+        """
+        return next(
+            (
+                msg
+                for msg in reversed(history)
+                if msg.role == "user"
+                and (msg.searchResults is None or not msg.searchResults)
+            ),
+            None,
+        )

config_dev.yaml

@@ -21,6 +21,8 @@ bd:
     k_neighbors: 100
 
   search:
+    use_qe: true
+    
     vector_search:
       use_vector_search: true
       k_neighbors: 100

lib/extractor/ntr_text_fragmentation/core/injection_builder.py

@@ -81,25 +81,19 @@ class InjectionBuilder:
             for entity in filtered_entities
         ]
         
-        print(f"entity_ids: {entity_ids[:3]}...{entity_ids[-3:]}")
-
         if not entity_ids:
             return ""
 
         # Получаем сущности по их идентификаторам
         entities = self.repository.get_entities_by_ids(entity_ids)
-        
-        print(f"entities: {entities[:3]}...{entities[-3:]}")
-        
+                
         # Десериализуем сущности в их специализированные типы
         deserialized_entities = []
         for entity in entities:
             # Используем статический метод десериализации
             deserialized_entity = LinkerEntity.deserialize(entity)
             deserialized_entities.append(deserialized_entity)
-            
-        print(f"deserialized_entities: {deserialized_entities[:3]}...{deserialized_entities[-3:]}")
-        
+                    
         # Фильтруем сущности на чанки и таблицы
         chunks = [e for e in deserialized_entities if "Chunk" in e.type]
         tables = [e for e in deserialized_entities if "Table" in e.type]
@@ -121,13 +115,9 @@ class InjectionBuilder:
             as_target=True,
         )
         
-        print(f"links: {links[:3]}...{links[-3:]}")
-
         # Группируем чанки по документам
         doc_chunks = self._group_chunks_by_document(chunks, links)
-        
-        print(f"doc_chunks: {doc_chunks}")
-        
+                
         # Получаем все документы для чанков и таблиц
         doc_ids = set(doc_chunks.keys()) | set(doc_tables.keys())
         docs = self.repository.get_entities_by_ids(doc_ids)
@@ -137,9 +127,7 @@ class InjectionBuilder:
         for doc in docs:
             deserialized_doc = LinkerEntity.deserialize(doc)
             deserialized_docs.append(deserialized_doc)
-        
-        print(f"deserialized_docs: {deserialized_docs[:3]}...{deserialized_docs[-3:]}")
-        
+                
         # Вычисляем веса документов на основе весов чанков
         doc_scores = self._calculate_document_scores(doc_chunks, chunk_scores)
         
@@ -149,15 +137,11 @@ class InjectionBuilder:
             key=lambda d: doc_scores.get(str(d.id), 0.0), 
             reverse=True
         )
-        
-        print(f"sorted_docs: {sorted_docs[:3]}...{sorted_docs[-3:]}")
-        
+                
         # Ограничиваем количество документов, если указано
         if max_documents:
             sorted_docs = sorted_docs[:max_documents]
-        
-        print(f"sorted_docs: {sorted_docs[:3]}...{sorted_docs[-3:]}")
-        
+                
         # Собираем текст для каждого документа
         result_parts = []
         for doc in sorted_docs:

lib/extractor/ntr_text_fragmentation/integrations/sqlalchemy_repository.py

@@ -77,10 +77,8 @@ class SQLAlchemyEntityRepository(EntityRepository):
             db_entities = session.execute(
                 select(entity_model).where(entity_model.uuid.in_(list(entity_ids)))
             ).scalars().all()
-            print(f"db_entities: {db_entities[:3]}...{db_entities[-3:]}")
         
         mapped_entities = [self._map_db_entity_to_linker_entity(entity) for entity in db_entities]
-        print(f"mapped_entities: {mapped_entities[:3]}...{mapped_entities[-3:]}")
         return mapped_entities
     
     def get_document_for_chunks(self, chunk_ids: Iterable[UUID]) -> List[LinkerEntity]:
@@ -161,9 +159,7 @@ class SQLAlchemyEntityRepository(EntityRepository):
                     )
                 )
             ).scalars().all()
-            
-            print(f"chunks: {chunks[:3]}...{chunks[-3:]}")
-        
+                    
             if not chunks:
                 return []
             
@@ -187,9 +183,7 @@ class SQLAlchemyEntityRepository(EntityRepository):
                         )
                     )
                 ).scalars().all()
-                
-                print(f"links: {links[:3]}...{links[-3:]}")
-                
+                                
                 for link in links:
                     doc_ids.add(link.source_id)
             
@@ -209,9 +203,7 @@ class SQLAlchemyEntityRepository(EntityRepository):
                 ).scalars().all()
                 
                 doc_chunk_ids = [link.target_id for link in links]
-                
-                print(f"doc_chunk_ids: {doc_chunk_ids[:3]}...{doc_chunk_ids[-3:]}")
-                
+                                
                 # Получаем все чанки документа
                 doc_chunks = session.execute(
                     select(entity_model).where(
@@ -221,9 +213,7 @@ class SQLAlchemyEntityRepository(EntityRepository):
                         )
                     )
                 ).scalars().all()
-                
-                print(f"doc_chunks: {doc_chunks[:3]}...{doc_chunks[-3:]}")
-                
+                                
                 # Для каждого чанка в документе проверяем, является ли он соседом
                 for doc_chunk in doc_chunks:
                     if doc_chunk.uuid in chunk_ids:

lib/extractor/pyproject.toml

@@ -7,7 +7,7 @@ name = "ntr_text_fragmentation"
 version = "0.1.0"
 dependencies = [
     "uuid==1.30",
-    "ntr_fileparser @ git+ssh://git@gitlab.ntrlab.ru/textai/parsers/parser.git@master"
+    "ntr_fileparser==0.2.0"
 ]
 
 [project.optional-dependencies]

routes/llm.py

@@ -4,6 +4,7 @@ import os
 from typing import Annotated, AsyncGenerator, Optional
 from uuid import UUID
 
+from components.services.dialogue import DialogueService
 from fastapi.responses import StreamingResponse
 
 from components.services.dataset import DatasetService
@@ -111,21 +112,19 @@ def collapse_history_to_first_message(chat_request: ChatRequest) -> ChatRequest:
 async def sse_generator(request: ChatRequest, llm_api: DeepInfraApi, system_prompt: str, 
                         predict_params: LlmPredictParams,
                         dataset_service: DatasetService, 
-                        entity_service: EntityService) -> AsyncGenerator[str, None]:
+                        entity_service: EntityService,
+                        dialogue_service: DialogueService) -> AsyncGenerator[str, None]:
     """
     Генератор для стриминга ответа LLM через SSE.
     """
     
-    # Обработка поиска
-    last_query = get_last_user_message(request)
+    qe_result = await dialogue_service.get_qe_result(request.history)    
     
-    
-    if last_query:
-        
+    if qe_result.use_search and qe_result.search_query is not None:
         dataset = dataset_service.get_current_dataset()
         if dataset is None:
             raise HTTPException(status_code=400, detail="Dataset not found")
-        _, scores, chunk_ids = entity_service.search_similar(last_query.content, dataset.id)
+        _, scores, chunk_ids = entity_service.search_similar(qe_result.search_query, dataset.id)
         chunks = entity_service.chunk_repository.get_chunks_by_ids(chunk_ids)
         text_chunks = entity_service.build_text(chunks, scores)
         search_results_event = {
@@ -161,6 +160,7 @@ async def chat_stream(
     llm_config_service: Annotated[LLMConfigService, Depends(DI.get_llm_config_service)],
     entity_service: Annotated[EntityService, Depends(DI.get_entity_service)],
     dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)],
+    dialogue_service: Annotated[DialogueService, Depends(DI.get_dialogue_service)],
 ):
     try:
         p = llm_config_service.get_default()
@@ -184,7 +184,7 @@ async def chat_stream(
             "Access-Control-Allow-Origin": "*",
         }
         return StreamingResponse(
-            sse_generator(request, llm_api, system_prompt.text, predict_params, dataset_service, entity_service),
+            sse_generator(request, llm_api, system_prompt.text, predict_params, dataset_service, entity_service, dialogue_service),
             media_type="text/event-stream",
             headers=headers
         )
@@ -201,6 +201,7 @@ async def chat(
     llm_config_service: Annotated[LLMConfigService, Depends(DI.get_llm_config_service)],
     entity_service: Annotated[EntityService, Depends(DI.get_entity_service)],
     dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)],
+    dialogue_service: Annotated[DialogueService, Depends(DI.get_dialogue_service)],
 ):
     try:
         p = llm_config_service.get_default()
@@ -217,17 +218,17 @@ async def chat(
             stop=[],
         )
 
-        last_query = get_last_user_message(request)
-        search_result = None
-        
-        logger.info(f"last_query: {last_query}")
+        qe_result = await dialogue_service.get_qe_result(request.history)
+        last_message = get_last_user_message(request)
+
+        logger.info(f"qe_result: {qe_result}")
 
-        if last_query:
+        if qe_result.use_search and qe_result.search_query is not None:
             dataset = dataset_service.get_current_dataset()
             if dataset is None:
                 raise HTTPException(status_code=400, detail="Dataset not found")
-            logger.info(f"last_query: {last_query.content}")
-            _, scores, chunk_ids = entity_service.search_similar(last_query.content, dataset.id)
+            logger.info(f"qe_result.search_query: {qe_result.search_query}")
+            _, scores, chunk_ids = entity_service.search_similar(qe_result.search_query, dataset.id)
             
             chunks = entity_service.chunk_repository.get_chunks_by_ids(chunk_ids)
             
@@ -238,7 +239,7 @@ async def chat(
             
             logger.info(f"text_chunks: {text_chunks[:3]}...{text_chunks[-3:]}")
 
-            new_message = f'{last_query.content} /n<search-results>/n{text_chunks}/n</search-results>'
+            new_message = f'{last_message.content} /n<search-results>/n{text_chunks}/n</search-results>'
             insert_search_results_to_message(request, new_message)
             
         logger.info(f"request: {request}")

scripts/compare_repositories.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Скрипт для сравнения результатов InjectionBuilder при использовании
+ChunkRepository (SQLite) и InMemoryEntityRepository (предзагруженного из SQLite).
+"""
+
+import logging
+import random
+import sys
+from pathlib import Path
+from uuid import UUID
+
+# --- SQLAlchemy ---
+from sqlalchemy import and_, create_engine, select
+from sqlalchemy.orm import sessionmaker
+
+# --- Конфигурация ---
+# !!! ЗАМЕНИ НА АКТУАЛЬНЫЙ ПУТЬ К ТВОЕЙ БД НА СЕРВЕРЕ !!!
+DATABASE_URL = "sqlite:///../data/logs.db" # Пример пути, используй свой
+# Имя таблицы сущностей
+ENTITY_TABLE_NAME = "entity" # Исправь, если нужно
+# Количество случайных чанков для теста
+SAMPLE_SIZE = 300
+
+# --- Настройка путей для импорта ---
+SCRIPT_DIR = Path(__file__).parent.resolve()
+PROJECT_ROOT = SCRIPT_DIR.parent # Перейти на уровень вверх (scripts -> project root)
+LIB_EXTRACTOR_PATH = PROJECT_ROOT / "lib" / "extractor"
+COMPONENTS_PATH = PROJECT_ROOT / "components" # Путь к компонентам
+
+sys.path.insert(0, str(PROJECT_ROOT))
+sys.path.insert(0, str(LIB_EXTRACTOR_PATH))
+sys.path.insert(0, str(COMPONENTS_PATH))
+# Добавляем путь к ntr_text_fragmentation внутри lib/extractor
+sys.path.insert(0, str(LIB_EXTRACTOR_PATH / "ntr_text_fragmentation"))
+
+
+# --- Логирование ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# --- Импорты из проекта и библиотеки ---
+try:
+    # Модели БД
+    from ntr_text_fragmentation.core.entity_repository import \
+        InMemoryEntityRepository  # Импортируем InMemory Repo
+    from ntr_text_fragmentation.core.injection_builder import \
+        InjectionBuilder  # Импортируем Builder
+    # Модели сущностей
+    from ntr_text_fragmentation.models import (Chunk, DocumentAsEntity,
+                                               LinkerEntity)
+
+    # Репозитории и билдер
+    from components.dbo.chunk_repository import \
+        ChunkRepository  # Импортируем ChunkRepository
+    from components.dbo.models.acronym import \
+        Acronym  # Импортируем модель из проекта
+    from components.dbo.models.dataset import \
+        Dataset  # Импортируем модель из проекта
+    from components.dbo.models.dataset_document import \
+        DatasetDocument  # Импортируем модель из проекта
+    from components.dbo.models.document import \
+        Document  # Импортируем модель из проекта
+    from components.dbo.models.entity import \
+        EntityModel  # Импортируем модель из проекта
+
+    # TableEntity если есть
+    # from ntr_text_fragmentation.models.table_entity import TableEntity
+except ImportError as e:
+    logger.error(f"Ошибка импорта необходимых модулей: {e}")
+    logger.error("Убедитесь, что скрипт находится в папке scripts вашего проекта,")
+    logger.error("и структура проекта соответствует ожиданиям (наличие lib/extractor, components/dbo и т.д.).")
+    sys.exit(1)
+
+# --- Вспомогательная функция для парсинга вывода ---
+def parse_output_by_source(text: str) -> dict[str, str]:
+    """Разбивает текст на блоки по маркерам '[Источник]'."""
+    blocks = {}
+    # Разделяем текст по маркеру
+    parts = text.split('[Источник]')
+    
+    # Пропускаем первую часть (текст до первого маркера или пустая строка)
+    for part in parts[1:]:
+        part = part.strip() # Убираем лишние пробелы вокруг части
+        if not part:
+            continue
+        
+        # Ищем первый перенос строки
+        newline_index = part.find('\n')
+        
+        if newline_index != -1:
+            # Извлекаем заголовок ( - ИмяИсточника)
+            header = part[:newline_index].strip()
+            # Извлекаем контент
+            content = part[newline_index+1:].strip()
+            
+            # Очищаем имя источника от " - " и пробелов
+            source_name = header.removeprefix('-').strip()
+            
+            if source_name: # Убедимся, что имя источника не пустое
+                if source_name in blocks:
+                    logger.warning(f"Найден дублирующийс�� источник '{source_name}' при парсинге split(). Контент будет перезаписан.")
+                blocks[source_name] = content
+            else:
+                 logger.warning(f"Не удалось извлечь имя источника из заголовка: '{header}'")
+        else:
+            # Если переноса строки нет, вся часть может быть заголовком без контента?
+            logger.warning(f"Часть без переноса строки после '[Источник]': '{part[:100]}...'")
+            
+    return blocks
+
+
+# --- Основная функция сравнения ---
+def compare_repositories():
+    logger.info(f"Подключение к базе данных: {DATABASE_URL}")
+    try:
+        engine = create_engine(DATABASE_URL)
+        # Определяем модель здесь, чтобы не зависеть от Base из другого места
+
+        SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        db_session = SessionLocal()
+
+        # 1. Инициализация ChunkRepository (нужен для доступа к _map_db_entity_to_linker_entity)
+        # Передаем фабрику сессий, чтобы он мог создавать свои сессии при необходимости
+        chunk_repo = ChunkRepository(db=SessionLocal)
+
+        # 2. Загрузка ВСЕХ сущностей НАПРЯМУЮ из БД
+        logger.info("Загрузка всех сущностей из БД через сессию...")
+        all_db_models = db_session.query(EntityModel).all()
+        logger.info(f"Загружено {len(all_db_models)} записей EntityModel.")
+
+        if not all_db_models:
+            logger.error("Не удалось загрузить сущности из базы данных. Проверьте подключение и наличие данных.")
+            db_session.close()
+            return
+
+        # Конвертация в LinkerEntity с использованием маппинга из ChunkRepository
+        logger.info("Конвертация EntityModel в LinkerEntity...")
+        all_linker_entities = [chunk_repo._map_db_entity_to_linker_entity(model) for model in all_db_models]
+        logger.info(f"Сконвертировано в {len(all_linker_entities)} LinkerEntity объектов.")
+
+
+        # 3. Инициализация InMemoryEntityRepository
+        logger.info("Инициализация InMemoryEntityRepository...")
+        in_memory_repo = InMemoryEntityRepository(entities=all_linker_entities)
+        logger.info(f"InMemoryEntityRepository инициализирован с {len(in_memory_repo.entities)} сущностями.")
+
+        # 4. Получение ID искомых чанков НАПРЯМУЮ из БД
+        logger.info("Получение ID искомых чанков из БД через сессию...")
+        query = select(EntityModel.uuid).where(
+             and_(
+                 EntityModel.in_search_text.isnot(None),
+             )
+        )
+        results = db_session.execute(query).scalars().all()
+        searchable_chunk_ids = [UUID(res) for res in results]
+        logger.info(f"Найдено {len(searchable_chunk_ids)} сущностей для поиска.")
+
+
+        if not searchable_chunk_ids:
+            logger.warning("В базе данных не найдено сущностей для поиска (с in_search_text). Тест невозможен.")
+            db_session.close()
+            return
+
+        # 5. Выборка случайных ID чанков
+        actual_sample_size = min(SAMPLE_SIZE, len(searchable_chunk_ids))
+        if actual_sample_size < len(searchable_chunk_ids):
+             logger.info(f"Выбираем {actual_sample_size} случайных ID сущностей для поиска из {len(searchable_chunk_ids)}...")
+             sampled_chunk_ids = random.sample(searchable_chunk_ids, actual_sample_size)
+        else:
+             logger.info(f"Используем все {len(searchable_chunk_ids)} найденные ID сущностей для поиска (т.к. их меньше или равно {SAMPLE_SIZE}).")
+             sampled_chunk_ids = searchable_chunk_ids
+
+
+        # 6. Инициализация InjectionBuilders
+        logger.info("Инициализация InjectionBuilder для ChunkRepository...")
+        # Передаем ИМЕННО ЭКЗЕМПЛЯР chunk_repo, который мы создали
+        builder_chunk_repo = InjectionBuilder(repository=chunk_repo)
+
+        logger.info("Инициализация InjectionBuilder для InMemoryEntityRepository...")
+        builder_in_memory = InjectionBuilder(repository=in_memory_repo)
+
+        # 7. Сборка текста для обоих репозиториев
+        logger.info(f"\n--- Сборка текс��а для ChunkRepository ({actual_sample_size} ID)... ---")
+        try:
+            # Передаем список UUID
+            text_chunk_repo = builder_chunk_repo.build(filtered_entities=sampled_chunk_ids)
+            logger.info(f"Сборка для ChunkRepository завершена. Общая длина: {len(text_chunk_repo)}")
+            # --- Добавляем вывод начала текста --- 
+            print("\n--- Начало текста (ChunkRepository, первые 1000 символов): ---")
+            print(text_chunk_repo[:1000])
+            print("--- Конец начала текста (ChunkRepository) ---")
+            # -------------------------------------
+        except Exception as e:
+            logger.error(f"Ошибка при сборке с ChunkRepository: {e}", exc_info=True)
+            text_chunk_repo = f"ERROR_ChunkRepo: {e}"
+
+
+        logger.info(f"\n--- Сборка текста для InMemoryEntityRepository ({actual_sample_size} ID)... ---")
+        try:
+             # Передаем список UUID
+            text_in_memory = builder_in_memory.build(filtered_entities=sampled_chunk_ids)
+            logger.info(f"Сборка для InMemoryEntityRepository завершена. Общая длина: {len(text_in_memory)}")
+            # --- Добавляем вывод начала текста --- 
+            print("\n--- Начало текста (InMemory, первые 1000 символов): ---")
+            print(text_in_memory[:1000])
+            print("--- Конец начала текста (InMemory) ---")
+            # -------------------------------------
+        except Exception as e:
+            logger.error(f"Ошибка при сборке с InMemoryEntityRepository: {e}", exc_info=True)
+            text_in_memory = f"ERROR_InMemory: {e}"
+
+
+        # 8. Парсинг результатов по блокам
+        logger.info("\n--- Парсинг результатов по источникам ---")
+        blocks_chunk_repo = parse_output_by_source(text_chunk_repo)
+        blocks_in_memory = parse_output_by_source(text_in_memory)
+        logger.info(f"ChunkRepo: Найдено {len(blocks_chunk_repo)} блоков источников.")
+        logger.info(f"InMemory:  Найдено {len(blocks_in_memory)} блоков источников.")
+
+        # 9. Сравнение блоков
+        logger.info("\n--- Сравнение блоков по источникам ---")
+        chunk_repo_keys = set(blocks_chunk_repo.keys())
+        in_memory_keys = set(blocks_in_memory.keys())
+
+        all_keys = chunk_repo_keys | in_memory_keys
+        mismatched_blocks = []
+        
+        if chunk_repo_keys != in_memory_keys:
+            logger.warning("Наборы источников НЕ СОВПАДАЮТ!")
+            only_in_chunk = chunk_repo_keys - in_memory_keys
+            only_in_memory = in_memory_keys - chunk_repo_keys
+            if only_in_chunk:
+                 logger.warning(f"  Источники только в ChunkRepo: {sorted(list(only_in_chunk))}")
+            if only_in_memory:
+                 logger.warning(f"  Источники только в InMemory: {sorted(list(only_in_memory))}")
+        else:
+             logger.info("Наборы источников совпадают.")
+
+        logger.info("\n--- Сравнение содержимого общих источников ---")
+        common_keys = chunk_repo_keys & in_memory_keys
+        if not common_keys:
+             logger.warning("Нет общих источников для сравнения содержимого.")
+        else:
+            all_common_blocks_match = True
+            table_marker_found_in_any_chunk_repo = False
+            table_marker_found_in_any_in_memory = False
+
+            for key in sorted(list(common_keys)):
+                content_chunk = blocks_chunk_repo.get(key, "") # Используем .get для безопасности
+                content_memory = blocks_in_memory.get(key, "") # Используем .get для безопасности
+
+                # Проверка наличия маркера таблиц
+                has_tables_chunk = "###" in content_chunk
+                has_tables_memory = "###" in content_memory
+                if has_tables_chunk:
+                    table_marker_found_in_any_chunk_repo = True
+                if has_tables_memory:
+                    table_marker_found_in_any_in_memory = True
+
+                # Логируем наличие таблиц для КАЖДОГО блока (можно закомментировать, если много)
+                # logger.info(f"  Источник: '{key}' - Таблицы (###) в ChunkRepo: {has_tables_chunk}, в InMemory: {has_tables_memory}")
+
+                if content_chunk != content_memory:
+                    all_common_blocks_match = False
+                    mismatched_blocks.append(key)
+                    logger.warning(f"  НЕСОВПАДЕНИЕ для источника: '{key}' (Таблицы в ChunkRepo: {has_tables_chunk}, в InMemory: {has_tables_memory})")
+                    # Можно добавить вывод diff для конкретного блока, если нужно
+                    # import difflib
+                    # block_diff = difflib.unified_diff(
+                    #     content_chunk.splitlines(keepends=True),
+                    #     content_memory.splitlines(keepends=True),
+                    #     fromfile=f'{key}_ChunkRepo',
+                    #     tofile=f'{key}_InMemory',
+                    #     lineterm='',
+                    # )
+                    # print("\nDiff для блока:")
+                    # sys.stdout.writelines(list(block_diff)[:20]) # Показать начало diff блока
+                    # if len(list(block_diff)) > 20: print("...")
+                # else:
+                #     # Логируем совпадение только если таблицы есть хоть где-то, для краткости
+                #     if has_tables_chunk or has_tables_memory:
+                #          logger.info(f"  Совпадение для источника: '{key}' (Таблицы в ChunkRepo: {has_tables_chunk}, в InMemory: {has_tables_memory})")
+
+            # Выводим общую информацию о наличии таблиц
+            logger.info("--- Итог проверки таблиц (###) в общих блоках ---")
+            logger.info(f"Маркер таблиц '###' найден хотя бы в одном блоке ChunkRepo: {table_marker_found_in_any_chunk_repo}")
+            logger.info(f"Маркер таблиц '###' найден хотя бы в одном блоке InMemory: {table_marker_found_in_any_in_memory}")
+            logger.info("-------------------------------------------------")
+
+            if all_common_blocks_match:
+                 logger.info("Содержимое ВСЕХ общих источников СОВПАДАЕТ.")
+            else:
+                 logger.warning(f"Найдено НЕСОВПАДЕНИЕ содержимого для {len(mismatched_blocks)} источников: {sorted(mismatched_blocks)}")
+
+        logger.info("\n--- Итоговый вердикт ---")
+        if chunk_repo_keys == in_memory_keys and not mismatched_blocks:
+             logger.info("ПОЛНОЕ СОВПАДЕНИЕ: Наборы источников и их содержимое идентичны.")
+        elif chunk_repo_keys == in_memory_keys and mismatched_blocks:
+             logger.warning("ЧАСТИЧНОЕ СОВПАДЕНИЕ: Наборы источников совпадают, но содержимое некоторых блоков различается.")
+        else:
+             logger.warning("НЕСОВПАДЕНИЕ: Наборы источников различаются (и, возможно, содержимое общих тоже).")
+
+
+    except ImportError as e:
+         # Ловим ошибки импорта, возникшие внутри функций (маловероятно после старта)
+         logger.error(f"Критическая ошибка импорта: {e}")
+    except Exception as e:
+        logger.error(f"Произошла общая ошибка: {e}", exc_info=True)
+    finally:
+        if 'db_session' in locals() and db_session:
+            db_session.close()
+            logger.info("Сессия базы данных закрыта.")
+
+
+# --- Запуск ---
+if __name__ == "__main__":
+    # Используем Path для более надежного определения пути
+    db_path = Path(DATABASE_URL.replace("sqlite:///", "")) 
+    if not db_path.exists():
+        print(f"!!! ОШИБКА: Файл базы данных НЕ НАЙДЕН по пути: {db_path.resolve()} !!!")
+        print(f"!!! Проверьте значение DATABASE_URL в скрипте. !!!")
+    elif "путь/к/твоей" in DATABASE_URL: # Доп. проверка на placeholder
+         print("!!! ПОЖАЛУЙСТА, УКАЖИТЕ ПРАВИЛЬНЫЙ ПУТЬ К БАЗЕ ДАННЫХ В ПЕРЕМЕННОЙ DATABASE_URL !!!")
+    else:
+        compare_repositories()

scripts/testing/aggregate_results.py

@@ -0,0 +1,483 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Скрипт для агрегации и анализа результатов множества запусков pipeline.py.
+
+Читает все CSV-файлы из директории промежуточных результатов,
+объединяет их и вычисляет агрегированные метрики:
+- Weighted (усредненные по всем вопросам, взвешенные по количеству пунктов/чанков/документов)
+- Macro (усредненные по вопросам - сначала считаем метрику для каждого вопроса, потом усредняем)
+- Micro (считаем общие TP, FP, FN по всем вопросам, потом вычисляем метрики)
+
+Результаты сохраняются в один Excel-файл с несколькими листами.
+"""
+
+import argparse
+import glob
+# Импорт для обработки JSON строк
+import os
+
+import pandas as pd
+from openpyxl import Workbook
+from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
+from openpyxl.utils import get_column_letter
+from openpyxl.utils.dataframe import dataframe_to_rows
+# Прогресс-бар
+from tqdm import tqdm
+
+# --- Настройки --- 
+DEFAULT_INTERMEDIATE_DIR = "data/intermediate" # Откуда читать CSV
+DEFAULT_OUTPUT_DIR = "data/output" # Куда сохранять итоговый Excel
+DEFAULT_OUTPUT_FILENAME = "aggregated_results.xlsx"
+
+# --- Маппинг названий столбцов на русский язык ---
+COLUMN_NAME_MAPPING = {
+    # Параметры запуска из pipeline.py
+    'run_id': 'ID Запуска',
+    'model_name': 'Модель',
+    'chunking_strategy': 'Стратегия Чанкинга',
+    'strategy_params': 'Параметры Стратегии',
+    'process_tables': 'Обраб. Таблиц',
+    'top_n': 'Top N',
+    'use_injection': 'Сборка Контекста',
+    'use_qe': 'Query Expansion',
+    'neighbors_included': 'Вкл. Соседей',
+    'similarity_threshold': 'Порог Схожести',
+
+    # Идентификаторы из датасета (для детальных результатов)
+    'question_id': 'ID Вопроса',
+    'question_text': 'Текст Вопроса',
+
+    # Детальные метрики из pipeline.py
+    'chunk_text_precision': 'Точность (Чанк-Текст)',
+    'chunk_text_recall': 'Полнота (Чанк-Текст)',
+    'chunk_text_f1': 'F1 (Чанк-Текст)',
+    'found_puncts': 'Найдено Пунктов',
+    'total_puncts': 'Всего Пунктов',
+    'relevant_chunks': 'Релевантных Чанков',
+    'total_chunks_in_top_n': 'Всего Чанков в Топ-N',
+    'assembly_punct_recall': 'Полнота (Сборка-Пункт)',
+    'assembled_context_preview': 'Предпросмотр Сборки',
+    # 'top_chunk_ids': 'Индексы Топ-Чанков', # Списки, могут плохо отображаться
+    # 'top_chunk_similarities': 'Схожести Топ-Чанков', # Списки
+
+    # Агрегированные метрики (добавляются в calculate_aggregated_metrics)
+    'weighted_chunk_text_precision': 'Weighted Точность (Чанк-Текст)',
+    'weighted_chunk_text_recall': 'Weighted Полнота (Чанк-Текст)',
+    'weighted_chunk_text_f1': 'Weighted F1 (Чанк-Текст)',
+    'weighted_assembly_punct_recall': 'Weighted Полнота (Сборка-Пункт)',
+
+    'macro_chunk_text_precision': 'Macro Точность (Чанк-Текст)',
+    'macro_chunk_text_recall': 'Macro Полнота (Чанк-Текст)',
+    'macro_chunk_text_f1': 'Macro F1 (Чанк-Текст)',
+    'macro_assembly_punct_recall': 'Macro Полнота (Сборка-Пункт)',
+
+    'micro_text_precision': 'Micro Точность (Текст)',
+    'micro_text_recall': 'Micro Полнота (Текст)',
+    'micro_text_f1': 'Micro F1 (Текст)',
+}
+
+def parse_args():
+    """Парсит аргументы командной строки."""
+    parser = argparse.ArgumentParser(description="Агрегация результатов оценочных пайплайнов")
+
+    parser.add_argument("--intermediate-dir", type=str, default=DEFAULT_INTERMEDIATE_DIR,
+                        help=f"Директория с промежуточными CSV результатами (по умолчанию: {DEFAULT_INTERMEDIATE_DIR})")
+    parser.add_argument("--output-dir", type=str, default=DEFAULT_OUTPUT_DIR,
+                        help=f"Директория для сохранения итогового Excel файла (по умолчанию: {DEFAULT_OUTPUT_DIR})")
+    parser.add_argument("--output-filename", type=str, default=DEFAULT_OUTPUT_FILENAME,
+                        help=f"Имя выходного Excel файла (по умолчанию: {DEFAULT_OUTPUT_FILENAME})")
+    parser.add_argument("--latest-batch-only", action="store_true",
+                        help="Агрегировать результаты только для последнего batch_id")
+
+    return parser.parse_args()
+
+def load_intermediate_results(intermediate_dir: str) -> pd.DataFrame:
+    """Загружает все CSV файлы из указанной директории."""
+    print(f"Загрузка промежуточных результатов из: {intermediate_dir}")
+    csv_files = glob.glob(os.path.join(intermediate_dir, "results_*.csv"))
+
+    if not csv_files:
+        print(f"ВНИМАНИЕ: В директории {intermediate_dir} не найдено файлов 'results_*.csv'.")
+        return pd.DataFrame()
+
+    all_data = []
+    for f in csv_files:
+        try:
+            df = pd.read_csv(f)
+            all_data.append(df)
+            print(f"  Загружен файл: {os.path.basename(f)} ({len(df)} строк)")
+        except Exception as e:
+            print(f"Ошибка при чтении файла {f}: {e}")
+
+    if not all_data:
+        print("Не удалось загрузить ни одного файла с результатами.")
+        return pd.DataFrame()
+
+    combined_df = pd.concat(all_data, ignore_index=True)
+    print(f"Всего загружено строк: {len(combined_df)}")
+    print(f"Найденные колонки: {combined_df.columns.tolist()}")
+
+    # Преобразуем типы данных для надежности
+    numeric_cols = [
+        'chunk_text_precision', 'chunk_text_recall', 'chunk_text_f1',
+        'found_puncts', 'total_puncts', 'relevant_chunks',
+        'total_chunks_in_top_n',
+        'assembly_punct_recall',
+        'similarity_threshold', 'top_n',
+    ]
+    for col in numeric_cols:
+        if col in combined_df.columns:
+            combined_df[col] = pd.to_numeric(combined_df[col], errors='coerce')
+
+    boolean_cols = [
+        'use_injection',
+        'process_tables',
+        'use_qe',
+        'neighbors_included'
+    ]
+    for col in boolean_cols:
+        if col in combined_df.columns:
+            # Пытаемся конвертировать в bool, обрабатывая строки 'True'/'False'
+            if combined_df[col].dtype == 'object':
+                combined_df[col] = combined_df[col].astype(str).str.lower().map({'true': True, 'false': False}).fillna(False)
+            combined_df[col] = combined_df[col].astype(bool)
+
+    # Заполним пропуски в числовых колонках нулями (например, если метрики не посчитались)
+    combined_df[numeric_cols] = combined_df[numeric_cols].fillna(0)
+
+    # --- Обработка batch_id --- 
+    if 'batch_id' in combined_df.columns:
+        # Приводим к строке и заполняем NaN
+        combined_df['batch_id'] = combined_df['batch_id'].astype(str).fillna('unknown_batch')
+    else:
+        # Если колонки нет, создаем ее
+        print("Предупреждение: Колонка 'batch_id' отсутствует в загруженных данных. Добавлена со значением 'unknown_batch'.")
+        combined_df['batch_id'] = 'unknown_batch'
+    # --------------------------
+
+    # Переименовываем столбцы в русские названия ДО возврата
+    # Отбираем только те колонки, для которых есть перевод
+    columns_to_rename = {eng: rus for eng, rus in COLUMN_NAME_MAPPING.items() if eng in combined_df.columns}
+    combined_df = combined_df.rename(columns=columns_to_rename)
+    print(f"Столбцы переименованы. Новые колонки: {combined_df.columns.tolist()}")
+
+    return combined_df
+
+def calculate_aggregated_metrics(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Вычисляет агрегированные метрики (Weighted, Macro, Micro)
+    для каждой уникальной комбинации параметров запуска.
+
+    Ожидает DataFrame с русскими названиями колонок.
+    """
+    if df.empty:
+        return pd.DataFrame()
+
+    # Определяем параметры, по которым будем группировать (ИСПОЛЬЗУЕМ РУССКИЕ НАЗВАНИЯ)
+    grouping_params_rus = [
+        COLUMN_NAME_MAPPING.get('model_name', 'Модель'),
+        COLUMN_NAME_MAPPING.get('chunking_strategy', 'Стратегия Чанкинга'),
+        COLUMN_NAME_MAPPING.get('strategy_params', 'Параметры Стратегии'),
+        COLUMN_NAME_MAPPING.get('process_tables', 'Обраб. Таблиц'),
+        COLUMN_NAME_MAPPING.get('top_n', 'Top N'),
+        COLUMN_NAME_MAPPING.get('use_injection', 'Сборка Контекста'),
+        COLUMN_NAME_MAPPING.get('use_qe', 'Query Expansion'),
+        COLUMN_NAME_MAPPING.get('neighbors_included', 'Вкл. Соседей'),
+        COLUMN_NAME_MAPPING.get('similarity_threshold', 'Порог Схожести')
+    ]
+
+    # Проверяем наличие всех колонок для группировки (с русскими именами)
+    missing_cols = [col for col in grouping_params_rus if col not in df.columns]
+    if missing_cols:
+        print(f"Ошибка: Отсутствуют необходимые колонки для группировки (русские): {missing_cols}")
+        # Удаляем отсутствующие колонки из списка группировки
+        grouping_params_rus = [col for col in grouping_params_rus if col not in missing_cols]
+        if not grouping_params_rus:
+            print("Невозможно выполнить группировку.")
+            return pd.DataFrame()
+
+    print(f"Группировка по параметрам (русские): {grouping_params_rus}")
+    # Используем grouping_params_rus для группировки
+    grouped = df.groupby(grouping_params_rus)
+
+    aggregated_results = []
+
+    # Итерируемся по каждой группе (комбинации параметров)
+    for params, group_df in tqdm(grouped, desc="Расчет агрегированных метрик"):
+        # Начинаем со словаря параметров (уже с русскими именами)
+        agg_result = dict(zip(grouping_params_rus, params))
+
+        # --- Метрики для усреднения/взвешивания (РУССКИЕ НАЗВАНИЯ) ---
+        chunk_prec_col = COLUMN_NAME_MAPPING.get('chunk_text_precision', 'Точность (Чанк-Текст)')
+        chunk_rec_col = COLUMN_NAME_MAPPING.get('chunk_text_recall', 'Полнота (Чанк-Текст)')
+        chunk_f1_col = COLUMN_NAME_MAPPING.get('chunk_text_f1', 'F1 (Чанк-Текст)')
+        assembly_rec_col = COLUMN_NAME_MAPPING.get('assembly_punct_recall', 'Полнота (Сборка-Пункт)')
+        total_chunks_col = COLUMN_NAME_MAPPING.get('total_chunks_in_top_n', 'Всего Чанков в Топ-N')
+        total_puncts_col = COLUMN_NAME_MAPPING.get('total_puncts', 'Всего Пунктов')
+        found_puncts_col = COLUMN_NAME_MAPPING.get('found_puncts', 'Найдено Пунктов') # Для micro
+        relevant_chunks_col = COLUMN_NAME_MAPPING.get('relevant_chunks', 'Релевантных Чанков') # Для micro
+
+        # Колонки, которые должны существовать для расчетов
+        required_metric_cols = [chunk_prec_col, chunk_rec_col, chunk_f1_col, assembly_rec_col]
+        required_count_cols = [total_chunks_col, total_puncts_col, found_puncts_col, relevant_chunks_col]
+        existing_metric_cols = [m for m in required_metric_cols if m in group_df.columns]
+        existing_count_cols = [c for c in required_count_cols if c in group_df.columns]
+
+        # --- Macro метрики (Простое усреднение метрик по вопросам) ---
+        if existing_metric_cols:
+            macro_metrics = group_df[existing_metric_cols].mean().rename(
+                # Генерируем имя 'Macro Имя Метрики'
+                lambda x: COLUMN_NAME_MAPPING.get(f"macro_{{key}}".format(key=next((k for k, v in COLUMN_NAME_MAPPING.items() if v == x), None)), f"Macro {x}")
+            ).to_dict()
+            agg_result.update(macro_metrics)
+        else:
+            print(f"Предупреждение: Пропуск Macro метрик для группы {params}, нет колонок метрик.")
+
+        # --- Weighted метрики (Взвешенное усреднение) ---
+        weighted_chunk_precision = 0.0
+        weighted_chunk_recall = 0.0
+        weighted_assembly_recall = 0.0
+        weighted_chunk_f1 = 0.0
+
+        # Проверяем наличие необходимых колонок для взвешенного расчета
+        can_calculate_weighted = True
+        if chunk_prec_col not in existing_metric_cols or total_chunks_col not in existing_count_cols:
+            print(f"Предупреждение: Пропуск Weighted Точность (Чанк-Текст) для группы {params}, отсутствуют {chunk_prec_col} или {total_chunks_col}.")
+            can_calculate_weighted = False
+        if chunk_rec_col not in existing_metric_cols or total_puncts_col not in existing_count_cols:
+             print(f"Предупреждение: Пропуск Weighted Полнота (Чанк-Текст) для группы {params}, отсутствуют {chunk_rec_col} или {total_puncts_col}.")
+             can_calculate_weighted = False
+        if assembly_rec_col not in existing_metric_cols or total_puncts_col not in existing_count_cols:
+             print(f"Пред��преждение: Пропуск Weighted Полнота (Сборка-Пункт) для группы {params}, отсутствуют {assembly_rec_col} или {total_puncts_col}.")
+             # Не сбрасываем can_calculate_weighted, т.к. другие weighted могут посчитаться
+
+        if can_calculate_weighted:
+            total_chunks_sum = group_df[total_chunks_col].sum()
+            total_puncts_sum = group_df[total_puncts_col].sum()
+
+            # Weighted Precision (Chunk-Text)
+            if total_chunks_sum > 0 and chunk_prec_col in existing_metric_cols:
+                weighted_chunk_precision = (group_df[chunk_prec_col] * group_df[total_chunks_col]).sum() / total_chunks_sum
+
+            # Weighted Recall (Chunk-Text)
+            if total_puncts_sum > 0 and chunk_rec_col in existing_metric_cols:
+                weighted_chunk_recall = (group_df[chunk_rec_col] * group_df[total_puncts_col]).sum() / total_puncts_sum
+
+            # Weighted Recall (Assembly-Punct)
+            if total_puncts_sum > 0 and assembly_rec_col in existing_metric_cols:
+                weighted_assembly_recall = (group_df[assembly_rec_col] * group_df[total_puncts_col]).sum() / total_puncts_sum
+
+            # Weighted F1 (Chunk-Text) - на основе weighted precision и recall
+            if weighted_chunk_precision + weighted_chunk_recall > 0:
+                weighted_chunk_f1 = (2 * weighted_chunk_precision * weighted_chunk_recall) / (weighted_chunk_precision + weighted_chunk_recall)
+
+        # Добавляем рассчитанные Weighted метрики в результат
+        agg_result[COLUMN_NAME_MAPPING.get('weighted_chunk_text_precision', 'Weighted Точность (Чанк-Текст)')] = weighted_chunk_precision
+        agg_result[COLUMN_NAME_MAPPING.get('weighted_chunk_text_recall', 'Weighted Полнота (Чанк-Текст)')] = weighted_chunk_recall
+        agg_result[COLUMN_NAME_MAPPING.get('weighted_chunk_text_f1', 'Weighted F1 (Чанк-Текст)')] = weighted_chunk_f1
+        agg_result[COLUMN_NAME_MAPPING.get('weighted_assembly_punct_recall', 'Weighted Полнота (Сборка-Пункт)')] = weighted_assembly_recall
+
+
+        # --- Micro метрики (На основе общих TP, FP, FN, ИСПОЛЬЗУЕМ РУССКИЕ НАЗВАНИЯ) ---
+        # Колонки уже определены выше
+        if not all(col in group_df.columns for col in [found_puncts_col, total_puncts_col, relevant_chunks_col, total_chunks_col]):
+             print(f"Предупреждение: Пропуск расчета micro-метрик для группы {params}, т.к. отсутствуют необходимые колонки.")
+             agg_result[COLUMN_NAME_MAPPING.get('micro_text_precision', 'Micro Точность (Текст)')] = 0.0
+             agg_result[COLUMN_NAME_MAPPING.get('micro_text_recall', 'Micro Полнота (Текст)')] = 0.0
+             agg_result[COLUMN_NAME_MAPPING.get('micro_text_f1', 'Micro F1 (Текст)')] = 0.0
+
+        # Добавляем результат группы в общий список
+        aggregated_results.append(agg_result)
+
+    # Создаем итоговый DataFrame (уже с русскими именами)
+    final_df = pd.DataFrame(aggregated_results)
+
+    print(f"Рассчитаны агрегированные метрики для {len(final_df)} комбинаций параметров.")
+    # Возвращаем DataFrame с русскими названиями колонок
+    return final_df
+
+# --- Функции для форматирования Excel (адаптированы из combine_results.py) --- 
+def apply_excel_formatting(workbook: Workbook):
+    """Применяет форматирование ко всем листам книги Excel."""
+    header_font = Font(bold=True)
+    header_fill = PatternFill(start_color="D9D9D9", end_color="D9D9D9", fill_type="solid")
+    center_alignment = Alignment(horizontal='center', vertical='center')
+    wrap_alignment = Alignment(horizontal='center', vertical='center', wrap_text=True)
+    thin_border = Border(
+        left=Side(style='thin'),
+        right=Side(style='thin'),
+        top=Side(style='thin'),
+        bottom=Side(style='thin')
+    )
+    thick_top_border = Border(top=Side(style='thick'))
+
+    for sheet_name in workbook.sheetnames:
+        sheet = workbook[sheet_name]
+        if sheet.max_row <= 1: # Пропускаем пустые листы
+            continue
+
+        # Форматирование заголовков
+        for cell in sheet[1]:
+            cell.font = header_font
+            cell.fill = header_fill
+            cell.alignment = wrap_alignment
+            cell.border = thin_border
+
+        # Автоподбор ширины и форматирование ячеек
+        for col_idx, column_cells in enumerate(sheet.columns, 1):
+            max_length = 0
+            column_letter = get_column_letter(col_idx)
+            is_numeric_metric_col = False
+            header_value = sheet.cell(row=1, column=col_idx).value
+
+            # Проверяем, является ли колонка числовой метрикой
+            if isinstance(header_value, str) and any(m in header_value for m in ['precision', 'recall', 'f1', 'relevance']):
+                is_numeric_metric_col = True
+
+            for i, cell in enumerate(column_cells):
+                # Применяем границы ко всем ячейкам
+                cell.border = thin_border
+                # Центрируем все, кроме заголовка
+                if i > 0:
+                    cell.alignment = center_alignment
+
+                # Формат для числовых метрик
+                if is_numeric_metric_col and i > 0 and isinstance(cell.value, (int, float)):
+                    cell.number_format = '0.0000'
+
+                # Расчет ширины
+                try:
+                    cell_len = len(str(cell.value))
+                    if cell_len > max_length:
+                        max_length = cell_len
+                except:
+                    pass
+            adjusted_width = (max_length + 2) * 1.1
+            sheet.column_dimensions[column_letter].width = min(adjusted_width, 60) # Ограничиваем макс ширину
+
+        # Автофильтр
+        sheet.auto_filter.ref = sheet.dimensions
+
+        # Группировка строк (опционально, можно добавить логику из combine_results, если нужна)
+        # ... (здесь можно вставить apply_group_formatting, если требуется) ...
+
+    print("Форматирование Excel завершено.")
+
+
+def save_to_excel(data_dict: dict[str, pd.DataFrame], output_path: str):
+    """Сохраняет несколько DataFrame в один Excel файл с форматированием."""
+    print(f"Сохранение результатов в Excel: {output_path}")
+    try:
+        workbook = Workbook()
+        workbook.remove(workbook.active) # Удаляем лист по умолчанию
+
+        for sheet_name, df in data_dict.items():
+            if df is not None and not df.empty:
+                sheet = workbook.create_sheet(title=sheet_name)
+                for r in dataframe_to_rows(df, index=False, header=True):
+                    # Проверяем и заменяем недопустимые символы в ячейках
+                    cleaned_row = []
+                    for cell_value in r:
+                        if isinstance(cell_value, str):
+                            # Удаляем управляющие символы, кроме стандартных пробельных
+                            cleaned_value = ''.join(c for c in cell_value if c.isprintable() or c in ' \t\n\r')
+                            cleaned_row.append(cleaned_value)
+                        else:
+                            cleaned_row.append(cell_value)
+                    sheet.append(cleaned_row)
+                print(f"  Лист '{sheet_name}' добавлен ({len(df)} строк)")
+            else:
+                print(f"  Лист '{sheet_name}' пропущен (нет данных)")
+
+        # Применяем форматирование ко всей книге
+        if workbook.sheetnames: # Проверяем, что есть хотя бы один лист
+            apply_excel_formatting(workbook)
+            workbook.save(output_path)
+            print("Excel файл успешно сохранен.")
+        else:
+            print("Нет данных для сохранения в Excel.")
+
+    except Exception as e:
+        print(f"Ошибка при сохранении Excel файла: {e}")
+
+
+# --- Основная функция --- 
+def main():
+    """Основная функция скрипта."""
+    args = parse_args()
+
+    # 1. Загрузка данных
+    combined_df_eng = load_intermediate_results(args.intermediate_dir)
+
+    if combined_df_eng.empty:
+        print("Нет данных для агрегации. Завершение.")
+        return
+
+    # --- Фильтрация по последнему batch_id (если флаг установлен) ---
+    target_df = combined_df_eng # По умолчанию используем все данные
+    if args.latest_batch_only:
+        print("Фильтрация по последнему batch_id...")
+        if 'batch_id' not in combined_df_eng.columns:
+            print("Предупреждение: Колонка 'batch_id' не найдена. Агрегация будет выполнена по всем данным.")
+        else:
+            # Находим последний batch_id (сортируем строки по batch_id)
+            # Сначала отфильтруем 'unknown_batch'
+            valid_batches = combined_df_eng[combined_df_eng['batch_id'] != 'unknown_batch']['batch_id'].unique()
+            if len(valid_batches) > 0:
+                # Сортируем уникальные валидные ID и берем последний
+                latest_batch_id = sorted(valid_batches)[-1]
+                print(f"Используется последний валидный batch_id: {latest_batch_id}")
+                target_df = combined_df_eng[combined_df_eng['batch_id'] == latest_batch_id].copy()
+                if target_df.empty:
+                    # Это не должно произойти, если latest_batch_id валидный, но на всякий случай
+                    print(f"Предупреждение: Не найдено данных для batch_id {latest_batch_id}. Агрегация будет выполнена по всем данным.")
+                    target_df = combined_df_eng
+                else:
+                    print(f"Оставлено строк после фильтрации: {len(target_df)}")
+            else:
+                print("Предупреждение: Не найдено валидных batch_id для фильтрации. Агрегация будет выполнена по всем данным.")
+                # target_df уже равен combined_df_eng, так что ничего не делаем
+            # latest_batch_id = combined_df_eng['batch_id'].astype(str).sort_values().iloc[-1]
+            # print(f"Используется последний batch_id: {latest_batch_id}")
+            # target_df = combined_df_eng[combined_df_eng['batch_id'] == latest_batch_id].copy()
+            # if target_df.empty:
+            #     print(f"Предупреждение: Нет данных для batch_id {latest_batch_id}. Агрегация будет выполнена по всем данным.")
+            #     target_df = combined_df_eng # Возвращаемся ко всем данным, если фильтр дал пустоту
+            # else:
+            #     print(f"Оставлено строк после фильтрации: {len(target_df)}")
+
+    # --- Заполнение NaN и переименование ПОСЛЕ возможной фильтрации ---
+    # Определяем числовые колонки еще раз (используя английские названия из маппинга)
+    numeric_cols_eng = [eng for eng, rus in COLUMN_NAME_MAPPING.items() \
+                       if 'recall' in eng or 'precision' in eng or 'f1' in eng or 'puncts' in eng \
+                       or 'chunks' in eng or 'threshold' in eng or 'top_n' in eng]
+    numeric_cols_in_df = [col for col in numeric_cols_eng if col in target_df.columns]
+    target_df[numeric_cols_in_df] = target_df[numeric_cols_in_df].fillna(0)
+
+    # Переименовываем
+    columns_to_rename_detailed = {eng: rus for eng, rus in COLUMN_NAME_MAPPING.items() if eng in target_df.columns}
+    target_df_rus = target_df.rename(columns=columns_to_rename_detailed)
+
+    # 2. Расчет агрегированных метрик
+    # Передаем DataFrame с русскими названиями колонок, calculate_aggregated_metrics теперь их ожидает
+    aggregated_df_rus = calculate_aggregated_metrics(target_df_rus)
+    # Переименовываем столбцы агрегированного DF уже внутри calculate_aggregated_metrics
+    # aggregated_df_rus = pd.DataFrame() # Инициализируем на случай, если aggregated_df_eng пуст
+    # if not aggregated_df_eng.empty:
+    #     columns_to_rename_agg = {eng: rus for eng, rus in COLUMN_NAME_MAPPING.items() if eng in aggregated_df_eng.columns}
+    #     aggregated_df_rus = aggregated_df_eng.rename(columns=columns_to_rename_agg)
+
+    # 3. Подготовка данных для сохранения (с русскими названиями)
+    data_to_save = {
+        "Детальные результаты": target_df_rus, # Используем переименованный DF
+        "Агрегированные метрики": aggregated_df_rus, # Используем переименованный DF
+    }
+
+    # 4. Сохранение в Excel
+    os.makedirs(args.output_dir, exist_ok=True)
+    output_file_path = os.path.join(args.output_dir, args.output_filename)
+    save_to_excel(data_to_save, output_file_path)
+
+if __name__ == "__main__":
+    main()

scripts/testing/pipeline.py

@@ -0,0 +1,1034 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Основной пайплайн для оценки качества RAG системы.
+
+Этот скрипт выполняет один прогон оценки для заданных параметров:
+- Чтение документов и датасетов вопросов/ответов.
+- Чанкинг документов.
+- Векторизация вопросов и чанков.
+- Оценка релевантности чанков к пунктам из датасета (Chunk-level).
+- Сборка контекста из релевантных чанков (Assembly-level).
+- Оценка релевантности собранного контекста к эталонным ответам.
+- Сохранение детальных метрик для данного прогона.
+"""
+
+import argparse
+# Add necessary imports for caching
+import hashlib
+import json
+import os
+import pickle
+import sys
+from pathlib import Path
+from typing import Any
+from uuid import UUID, uuid4
+
+import numpy as np
+import pandas as pd
+import torch
+from fuzzywuzzy import fuzz
+from sklearn.metrics.pairwise import cosine_similarity
+from tqdm import tqdm
+from transformers import AutoModel, AutoTokenizer
+
+# --- Константы (могут быть переопределены аргументами) ---
+DEFAULT_DATA_FOLDER = "data/input/docs"
+DEFAULT_SEARCH_DATASET_PATH = "data/input/search_dataset_texts.xlsx"
+DEFAULT_QA_DATASET_PATH = "data/input/question_answering.xlsx"
+DEFAULT_MODEL_NAME = "intfloat/e5-base"
+DEFAULT_BATCH_SIZE = 8
+DEFAULT_DEVICE = "cuda:0" if torch.cuda.is_available() else "cpu"
+DEFAULT_SIMILARITY_THRESHOLD = 0.7
+DEFAULT_OUTPUT_DIR = "data/intermediate" # Директория для промежуточных результатов
+DEFAULT_WORDS_PER_CHUNK = 50
+DEFAULT_OVERLAP_WORDS = 25
+DEFAULT_TOP_N = 20 # Значение N по умолчанию для топа чанков
+# Add chunking strategy constant
+DEFAULT_CHUNKING_STRATEGY = "fixed_size"
+# Add cache directory constant
+DEFAULT_CACHE_DIR = "data/cache"
+
+# --- Добавление путей к библиотекам ---
+# Добавляем путь к корневой папке проекта, чтобы можно было импортировать ntr_...
+SCRIPT_DIR = Path(__file__).parent.resolve()
+PROJECT_ROOT = SCRIPT_DIR.parent.parent # Перейти на два уровня вверх (scripts/testing -> scripts -> project root)
+LIB_EXTRACTOR_PATH = PROJECT_ROOT / "lib" / "extractor"
+sys.path.insert(0, str(LIB_EXTRACTOR_PATH))
+# Добавляем путь к папке с ntr_text_fragmentation
+sys.path.insert(0, str(LIB_EXTRACTOR_PATH / "ntr_text_fragmentation"))
+
+# --- Импорты из локальных модулей ---
+try:
+    from ntr_fileparser import ParsedDocument, UniversalParser
+    from ntr_text_fragmentation import Destructurer
+    from ntr_text_fragmentation.core.entity_repository import \
+        InMemoryEntityRepository
+    from ntr_text_fragmentation.core.injection_builder import InjectionBuilder
+    from ntr_text_fragmentation.models.chunk import Chunk
+    from ntr_text_fragmentation.models.document import DocumentAsEntity
+    from ntr_text_fragmentation.models.linker_entity import LinkerEntity
+except ImportError as e:
+    print(f"Ошибка импорта локальных модулей: {e}")
+    print(f"Проверьте пути: Project Root: {PROJECT_ROOT}, Extractor Lib: {LIB_EXTRACTOR_PATH}")
+    sys.exit(1)
+
+# --- Вспомогательные функции (аналогичные evaluate_chunking.py) ---
+
+def _average_pool(
+    last_hidden_states: torch.Tensor, attention_mask: torch.Tensor
+) -> torch.Tensor:
+    """
+    Расчёт усредненного эмбеддинга по всем токенам.
+    (Копипаста из evaluate_chunking.py)
+    """
+    last_hidden = last_hidden_states.masked_fill(
+        ~attention_mask[..., None].bool(), 0.0
+    )
+    return last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None]
+
+def calculate_chunk_overlap(chunk_text: str, punct_text: str) -> float:
+    """
+    Рассчитывает степень перекрытия между чанком и пунктом.
+    (Копипаста из evaluate_chunking.py)
+    """
+    if not chunk_text or not punct_text:
+        return 0.0
+    # Используем partial_ratio для лучшей обработки подстрок
+    return fuzz.partial_ratio(chunk_text, punct_text) / 100.0
+
+# --- Функции загрузки и обработки данных ---
+
+def parse_args():
+    """Парсит аргументы командной строки."""
+    parser = argparse.ArgumentParser(description="Пайплайн оценки RAG системы")
+
+    # Пути к данным
+    parser.add_argument("--data-folder", type=str, default=DEFAULT_DATA_FOLDER,
+                        help=f"Папка с документами (по умолчанию: {DEFAULT_DATA_FOLDER})")
+    parser.add_argument("--search-dataset-path", type=str, default=DEFAULT_SEARCH_DATASET_PATH,
+                        help=f"Путь к датасету для поиска (по умолчанию: {DEFAULT_SEARCH_DATASET_PATH})")
+    parser.add_argument("--output-dir", type=str, default=DEFAULT_OUTPUT_DIR,
+                        help=f"Папка для сохранения промежуточных результатов (по умолчанию: {DEFAULT_OUTPUT_DIR})")
+    parser.add_argument("--run-id", type=str, default=f"run_{uuid4()}",
+                        help="Уникальный идентификатор запуска (по умолчанию: генерируется)")
+
+    # Параметры модели и векторизации
+    parser.add_argument("--model-name", type=str, default=DEFAULT_MODEL_NAME,
+                        help=f"Название модели для векторизации (по умолчанию: {DEFAULT_MODEL_NAME})")
+    parser.add_argument("--batch-size", type=int, default=DEFAULT_BATCH_SIZE,
+                        help=f"Размер батча для векторизации (по умолчанию: {DEFAULT_BATCH_SIZE})")
+    parser.add_argument("--device", type=str, default=DEFAULT_DEVICE, # type: ignore
+                        help=f"Устройство для вычислений (по умолчанию: {DEFAULT_DEVICE})")
+    parser.add_argument("--use-sentence-transformers", action="store_true",
+                        help="Использовать библиотеку sentence_transformers")
+
+    # Параметры чанкинга
+    parser.add_argument("--chunking-strategy", type=str, default=DEFAULT_CHUNKING_STRATEGY,
+                        choices=list(Destructurer.STRATEGIES.keys()), # Use keys from Destructurer
+                        help=f"Стратегия чанкинга (по умолчанию: {DEFAULT_CHUNKING_STRATEGY})")
+    parser.add_argument("--strategy-params", type=str, default='{}', # Default to empty JSON object
+                        help="Параметры для стратегии чанкинга в формате JSON строки (например, '{\"words_per_chunk\": 50}')")
+    parser.add_argument("--no-process-tables", action="store_false", dest="process_tables",
+                        help="Отключить обработку таблиц при чанкинге")
+    parser.set_defaults(process_tables=True) # Default is to process tables
+
+    # Параметры оценки
+    parser.add_argument("--similarity-threshold", type=float, default=DEFAULT_SIMILARITY_THRESHOLD,
+                        help=f"Порог для нечеткого сравнения чанка и пункта (по умолчанию: {DEFAULT_SIMILARITY_THRESHOLD})")
+    parser.add_argument("--top-n", type=int, default=DEFAULT_TOP_N,
+                        help=f"Количество топ-чанков для рассмотрения (по умолчанию: {DEFAULT_TOP_N})")
+    # Add cache directory argument
+    parser.add_argument("--cache-dir", type=str, default=DEFAULT_CACHE_DIR,
+                        help=f"Директория для кэширования эмбеддингов и матриц схожести (по умолчанию: {DEFAULT_CACHE_DIR})")
+
+    # Параметры сборки контекста
+    parser.add_argument("--use-injection", action="store_true",
+                        help="Выполнять ли сборку контекста и её оценку")
+    parser.add_argument("--use-qe", action="store_true",
+                        help="Использовать столбец query_expansion вместо question для поиска (если он есть)")
+    parser.add_argument("--include-neighbors", action="store_true",
+                        help="Включать ли соседние чанки (предыдущий/следующий) при сборке контекста")
+
+    # --- Добавляем аргумент для batch_id --- 
+    parser.add_argument("--batch-id", type=str, default="batch_default",
+                        help="Идентификатор серии запусков (передается из run_pipelines.py)")
+
+    # TODO: Добавить другие параметры при необходимости (например, параметры InjectionBuilder)
+
+    return parser.parse_args()
+
+def read_documents(folder_path: str) -> dict[str, ParsedDocument]:
+    """
+    Читает все документы из указанной папки и создает сущности.
+
+    Args:
+        folder_path: Путь к папке с документами
+
+    Returns:
+        Словарь {имя_файла: объект ParsedDocument}
+    """
+    print(f"Чтение документов из {folder_path}...")
+    parser = UniversalParser()
+    documents_map = {}
+    doc_files = list(Path(folder_path).glob("*.docx"))
+
+    if not doc_files:
+        print(f"ВНИМАНИЕ: В папке {folder_path} не найдено *.docx файлов.")
+        return {}
+
+    for file_path in tqdm(doc_files, desc="Чтение документов"):
+        try:
+            doc_name = file_path.stem
+            # Парсим документ с помощью UniversalParser
+            parsed_document = parser.parse_by_path(str(file_path))
+            # Сохраняем распарсенный документ
+            documents_map[doc_name] = parsed_document
+        except Exception as e:
+            print(f"Ошибка при чтении файла {file_path}: {e}")
+
+    print(f"Прочитано документов: {len(documents_map)}")
+    return documents_map
+
+def load_datasets(search_dataset_path: str) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """
+    Загружает датасет для поиска и готовит данные для векторизации.
+
+    Args:
+        search_dataset_path: Путь к Excel с пунктами для поиска.
+
+    Returns:
+        Кортеж: (полный DataFrame поискового датасета, DataFrame с уникальными вопросами для векторизации).
+    """
+    print(f"Загрузка поискового датасета из {search_dataset_path}...")
+    try:
+        search_df = pd.read_excel(search_dataset_path)
+        print(f"Загружен поисковый датасет: {len(search_df)} строк, столбцы: {search_df.columns.tolist()}")
+
+        # Проверяем наличие обязательных столбцов
+        required_columns = ['id', 'question', 'text', 'filename']
+        missing_cols = [col for col in required_columns if col not in search_df.columns]
+        if missing_cols:
+            print(f"Ошибка: В поисковом датасете отсутствуют обязательные столбцы: {missing_cols}")
+            sys.exit(1)
+
+        # Преобразуем NaN в пустые строки для текстовых полей
+        # Добавляем 'query_expansion', если он есть, для обработки NaN
+        text_columns = ['question', 'text', 'item_type', 'filename']
+        if 'query_expansion' in search_df.columns:
+            text_columns.append('query_expansion')
+
+        for col in text_columns:
+            if col in search_df.columns:
+                search_df[col] = search_df[col].fillna('')
+            # Если необязательный item_type отсутствует, добавляем его пустым
+            elif col == 'item_type':
+                 print(f"Предупреждение: столбец '{col}' отсутствует в поисковом датасете. Добавлен пустой столбец.")
+                 search_df[col] = ''
+
+        # Убедимся, что 'id' имеет целочисленный тип
+        try:
+            search_df['id'] = search_df['id'].astype(int)
+        except ValueError as e:
+            print(f"Ошибка при приведении типов столбца 'id' в поисковом датасете: {e}. Убедитесь, что ID являются целыми числами.")
+            sys.exit(1)
+
+    except FileNotFoundError:
+        print(f"Ошибка: Поисковый датасет не найден по пути {search_dataset_path}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Ошибка при чтении поискового датасета: {e}")
+        sys.exit(1)
+
+    # Готовим DataFrame для векторизации уникальных вопросов
+    # Включаем query_expansion, если он есть
+    cols_for_embedding = ['id', 'question']
+    query_expansion_exists = 'query_expansion' in search_df.columns
+    if query_expansion_exists:
+        cols_for_embedding.append('query_expansion')
+        print("Столбец 'query_expansion' найден в поисковом датасете.")
+    else:
+        print("Столбец 'query_expansion' не найден в поисковом датасете.")
+
+    questions_to_embed = search_df[cols_for_embedding].drop_duplicates(subset=['id']).copy()
+
+    # Если query_expansion не существует, добавляем пустой столбец для единообразия
+    if not query_expansion_exists:
+        questions_to_embed['query_expansion'] = ''
+
+    print(f"Уникальных вопросов для векторизации: {len(questions_to_embed)}")
+
+    # Теперь search_df это и есть наш "объединенный" датасет (так как QA не используется)
+    return search_df, questions_to_embed
+
+
+def perform_chunking(
+    documents_map: dict[str, ParsedDocument],
+    chunking_strategy: str,
+    process_tables: bool,
+    strategy_params_json: str # Expect JSON string
+) -> tuple[pd.DataFrame, list[LinkerEntity]]:
+    """
+    Выполняет чанкинг для всех документов.
+
+    Args:
+        documents_map: Словарь {имя_файла: сущность_документа}.
+        chunking_strategy: Имя используемой стратегии чанкинга.
+        process_tables: Флаг, указывающий, нужно ли обрабатывать таблицы.
+        strategy_params_json: Строка JSON с параметрами для стратегии.
+
+    Returns:
+        Кортеж: (DataFrame с чанками для поиска, список всех созданных сущностей LinkerEntity)
+    """
+    print("Выполнение чанкинга...")
+    searchable_chunks_data = [] # Данные только для чанков с in_search_text
+    final_entities: list[LinkerEntity] = [] # Список для ВСЕХ сущностей (доки, чанки, связи и т.д.)
+
+    # Parse strategy parameters from JSON string
+    try:
+        chunking_params = json.loads(strategy_params_json)
+        print(f"Параметры для стратегии '{chunking_strategy}': {chunking_params}")
+    except json.JSONDecodeError as e:
+        print(f"Ошибка парсинга JSON для strategy-params: '{strategy_params_json}'. Используются параметры по умолчанию стратегии. Ошибка: {e}")
+        chunking_params = {} # Use strategy defaults if JSON is invalid
+
+    print(f"Используется стратегия чанкинга: '{chunking_strategy}'")
+    print(f"Обработка таблиц: {'Включена' if process_tables else 'Отключена'}")
+
+    for doc_name, parsed_doc in tqdm(documents_map.items(), desc="Чанкинг документов"):
+        try:
+            # Инициализируем Destructurer ВНУТРИ цикла для КАЖДОГО документа
+            destructurer = Destructurer(
+                document=parsed_doc,
+                process_tables=process_tables,
+                strategy_name=chunking_strategy, # Передаем имя стратегии при инициализации
+                **chunking_params # И параметры стратегии
+            )
+            # Destructure создает DocumentAsEntity, чанки, связи и возвращает их как LinkerEntity
+            new_entities = destructurer.destructure()
+
+            # Добавляем ВСЕ созданные сущности (сериализованные LinkerEntity) в общий список
+            final_entities.extend(new_entities)
+
+            # Собираем данные для DataFrame только из тех сущностей,
+            # у которых есть поле in_search_text (это наши чанки для поиска)
+            for entity in new_entities:
+                # Проверяем наличие атрибута 'in_search_text', а не тип
+                if hasattr(entity, 'in_search_text') and entity.in_search_text:
+                    entity_data = {
+                        'chunk_id': str(entity.id),
+                        'doc_name': doc_name, # Имя исходного файла
+                        'doc_id': str(entity.source_id), # ID сущности документа (DocumentAsEntity)
+                        'text': entity.in_search_text, # Текст для векторизации и поиска
+                        'type': entity.type, # Тип сущности (например, 'FixedSizeChunk')
+                        'strategy_params': json.dumps(chunking_params, ensure_ascii=False),
+                    }
+                    searchable_chunks_data.append(entity_data)
+        except Exception as e:
+            # Логируем ошибку и продолжаем с остальными документами
+            print(f"\nОшибка при чанкинге документа {doc_name}: {e}")
+            import traceback
+            traceback.print_exc() # Печатаем traceback для детальной отладки
+
+    # Создаем DataFrame только из чанков, предназначенных для поиска
+    chunks_df = pd.DataFrame(searchable_chunks_data)
+    print(f"Создано чанков для поиска: {len(chunks_df)}")
+
+    # Возвращаем DataFrame с чанками для поиска и ПОЛНЫЙ список всех LinkerEntity
+    return chunks_df, final_entities
+
+
+def setup_model_and_tokenizer(model_name: str, use_sentence_transformers: bool, device: str):
+    """Инициализирует модель и токенизатор."""
+    print(f"Загрузка модели {model_name} на устройство {device}...")
+    if use_sentence_transformers:
+        try:
+            from sentence_transformers import SentenceTransformer
+            model = SentenceTransformer(model_name, device=device)
+            tokenizer = None # sentence_transformers не требует отдельного токенизатора
+            print("Используется SentenceTransformer.")
+            return model, tokenizer
+        except ImportError:
+            print("Ошибка: Библиотека sentence_transformers не установлена. Установите: pip install sentence-transformers")
+            sys.exit(1)
+    else:
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            model = AutoModel.from_pretrained(model_name).to(device)
+            model.eval()
+            print("Используется AutoModel и AutoTokenizer из transformers.")
+            return model, tokenizer
+        except Exception as e:
+            print(f"Ошибка при загрузке модели {model_name} из transformers: {e}")
+            sys.exit(1)
+
+
+def get_embeddings(
+    texts: list[str],
+    model,
+    tokenizer,
+    batch_size: int,
+    use_sentence_transformers: bool,
+    device: str
+) -> np.ndarray:
+    """Получает эмбеддинги для списка текстов."""
+    all_embeddings = []
+    desc = "Векторизация (Sentence Transformers)" if use_sentence_transformers else "Векторизация (Transformers)"
+
+    for i in tqdm(range(0, len(texts), batch_size), desc=desc):
+        batch_texts = texts[i:i+batch_size]
+        if not batch_texts:
+            continue
+
+        if use_sentence_transformers:
+            # Эмбеддинги через sentence_transformers
+            embeddings = model.encode(batch_texts, batch_size=len(batch_texts), show_progress_bar=False)
+            all_embeddings.append(embeddings)
+        else:
+            # Эмбеддинги через transformers с average pooling
+            try:
+                encoding = tokenizer(
+                    batch_texts,
+                    padding=True,
+                    truncation=True,
+                    max_length=512, # Стандартное ограничение для многих моделей
+                    return_tensors="pt"
+                ).to(device)
+
+                with torch.no_grad():
+                    outputs = model(**encoding)
+                    embeddings = _average_pool(outputs.last_hidden_state, encoding["attention_mask"])
+                    all_embeddings.append(embeddings.cpu().numpy())
+            except Exception as e:
+                print(f"Ошибка при векторизации батча (индексы {i} - {i+batch_size}): {e}")
+                print(f"Тексты батча: {batch_texts[:2]}...")
+                # Добавляем нулевые векторы, чтобы не сломать vstack
+                # Определяем размер эмбеддинга
+                if all_embeddings:
+                    embedding_dim = all_embeddings[0].shape[1]
+                else:
+                    # Пытаемся получить размер из конфигурации модели
+                    try:
+                        embedding_dim = model.config.hidden_size
+                    except AttributeError:
+                        embedding_dim = 768 # Запасной вариант
+                        print(f"Не удалось определить размер эмбеддинга, используется {embedding_dim}")
+
+                print(f"Добавление нулевых эмбеддингов размерности ({len(batch_texts)}, {embedding_dim})")
+                null_embeddings = np.zeros((len(batch_texts), embedding_dim), dtype=np.float32)
+                all_embeddings.append(null_embeddings)
+
+
+    if not all_embeddings:
+        print("ВНИМАНИЕ: Не удалось создать эмбеддинги.")
+        # Возвращаем пустой массив правильной формы, если возможно
+        try:
+            embedding_dim = model.config.hidden_size if not use_sentence_transformers else model.get_sentence_embedding_dimension()
+        except:
+            embedding_dim = 768
+        return np.empty((0, embedding_dim), dtype=np.float32)
+
+    # Объединяем эмбеддинги из всех батчей
+    try:
+        final_embeddings = np.vstack(all_embeddings)
+    except ValueError as e:
+        print(f"Ошибка при объединении эмбеддингов: {e}")
+        print("Размеры эмбеддингов в батчах:")
+        for i, emb_batch in enumerate(all_embeddings):
+            print(f"  Батч {i}: {emb_batch.shape}")
+        # Попробуем определить ожидаемый размер и создать нулевой массив
+        if all_embeddings:
+             embedding_dim = all_embeddings[0].shape[1]
+             print(f"Возвращение ну��евого массива размерности ({len(texts)}, {embedding_dim})")
+             return np.zeros((len(texts), embedding_dim), dtype=np.float32)
+        else:
+             return np.empty((0, 768), dtype=np.float32) # Запасной вариант
+
+    print(f"Получено эмбеддингов: {final_embeddings.shape}")
+    return final_embeddings
+
+# --- Caching Helper Functions ---
+
+def _get_params_hash(
+    model_name: str,
+    process_tables: bool | None = None,
+    strategy_params: dict | None = None # Expect the parsed dictionary
+) -> str:
+    """Создает MD5 хэш из переданных параметров."""
+    hasher = hashlib.md5()
+    hasher.update(model_name.encode())
+    # Add chunking strategy and table processing flag if provided
+    if process_tables is not None:
+        hasher.update(str(process_tables).encode())
+    # Add strategy parameters (sort items to ensure consistent hash)
+    if strategy_params:
+        sorted_params = sorted(strategy_params.items())
+        hasher.update(json.dumps(sorted_params).encode())
+    return hasher.hexdigest()
+
+def _get_cache_path(cache_dir: Path, hash_str: str, filename: str) -> Path:
+    """Формирует путь к файлу кэша, создавая поддиректории."""
+    # Используем первые 2 символа хэша для распределения по поддиректориям
+    # Это помогает избежать слишком большого количества файлов в одной директории
+    cache_subdir = cache_dir / hash_str[:2] / hash_str
+    cache_subdir.mkdir(parents=True, exist_ok=True)
+    return cache_subdir / filename
+
+# --- Добавляем функцию для хэша чанкинга ---
+def _get_chunking_cache_hash(
+    data_folder: str,
+    chunking_strategy: str,
+    process_tables: bool,
+    strategy_params: dict # Ожидаем словарь
+) -> str:
+    """Создает MD5 хэш для параметров чанкинга и папки с данными."""
+    hasher = hashlib.md5()
+    hasher.update(data_folder.encode())
+    hasher.update(chunking_strategy.encode())
+    hasher.update(str(process_tables).encode())
+    # Сортируем параметры для консистентности хэша
+    sorted_params = sorted(strategy_params.items())
+    hasher.update(json.dumps(sorted_params).encode())
+    return hasher.hexdigest()
+# ---------------------------------------------
+
+# --- Main Evaluation Function ---
+
+def evaluate_run(
+    search_dataset: pd.DataFrame,
+    questions_to_embed: pd.DataFrame,
+    chunks_df: pd.DataFrame,
+    all_entities: list[LinkerEntity],
+    model: Any | None, # Принимаем None
+    tokenizer: Any | None, # Принимаем None
+    args: argparse.Namespace
+) -> pd.DataFrame:
+    """
+    Выполняет основной цикл оценки для одного набора параметров.
+
+    Args:
+        search_dataset: DataFrame поискового датасета.
+        questions_to_embed: DataFrame с уникальными вопросами для векторизации.
+        chunks_df: DataFrame с данными по чанкам.
+        all_entities: Список всех сущностей (документы, чанки, связи).
+        model: Модель для векторизации.
+        tokenizer: Токенизатор.
+        args: Аргументы командной строки.
+
+    Returns:
+        DataFrame с детальными метриками по каждому вопросу для этого запуска.
+    """
+    print("Начало этапа оценки...")
+
+    # Переменные для модели и токенизатора, инициализируем None
+    loaded_model: Any | None = model
+    loaded_tokenizer: Any | None = tokenizer
+
+    # --- Caching Setup ---
+    print("Настройка кэширования...")
+    CACHE_DIR_PATH = Path(args.cache_dir)
+    model_slug = args.model_name.split('/')[-1] # Basic slug for filename clarity
+
+    # --- Определяем, какой текст использовать для эмбеддингов вопросов ---
+    # и устанавливаем флаг qe_active, который будет влиять на кэш
+    if args.use_qe and 'query_expansion' in questions_to_embed.columns and questions_to_embed['query_expansion'].notna().any(): # Check if column exists and has non-NA values
+        print("Используется Query Expansion (столбец 'query_expansion') для векторизации вопросов.")
+        query_texts_to_embed = questions_to_embed['query_expansion'].tolist()
+        qe_active = True
+    else:
+        print("Используется оригинальный текст вопроса (столбец 'question') для векторизации.")
+        query_texts_to_embed = questions_to_embed['question'].tolist()
+        qe_active = False
+
+    # Cache key for question embeddings (ЗАВИСИТ от модели и флага use_qe)
+    question_params_for_hash = {
+        'model_name': args.model_name,
+        'use_qe': qe_active # Добавляем фактическое использование QE в параметры для хэша
+    }
+    question_hash = hashlib.md5(json.dumps(question_params_for_hash, sort_keys=True).encode()).hexdigest()
+    question_embeddings_cache_path = _get_cache_path(
+        CACHE_DIR_PATH, question_hash, f"q_embeddings_{model_slug}_qe{qe_active}.npy"
+    )
+
+    # Cache key for chunk embeddings (depends on model and chunking)
+    chunk_hash = _get_params_hash(
+        args.model_name,
+        args.process_tables, # Include table flag
+        json.loads(args.strategy_params) # Pass parsed params dictionary
+    )
+    chunk_embeddings_cache_path = _get_cache_path(
+        CACHE_DIR_PATH, chunk_hash,
+        f"c_emb_{model_slug}_s-{args.chunking_strategy}_t{args.process_tables}_ph-{hashlib.md5(args.strategy_params.encode()).hexdigest()[:8]}.npy"
+    )
+
+    # Cache key for similarity matrix (depends on both sets of embeddings)
+    similarity_hash = f"{question_hash}_{chunk_hash}" # Combine hashes
+    similarity_cache_path = _get_cache_path(
+        CACHE_DIR_PATH, similarity_hash,
+        f"sim_{model_slug}_qe{qe_active}_ph-{hashlib.md5(args.strategy_params.encode()).hexdigest()[:8]}.npy" # Добавляем флаг QE в имя файла
+    )
+
+    # 1. Векторизация вопросов и чанков (с кэшем)
+    question_embeddings = None
+    needs_model_load = False # Флаг, указывающий, нужна ли загрузка модели
+
+    if question_embeddings_cache_path.exists():
+        try:
+            print(f"Загрузка кэшированных эмбеддингов вопросов из: {question_embeddings_cache_path}")
+            question_embeddings = np.load(question_embeddings_cache_path, allow_pickle=False)
+            if len(question_embeddings) != len(questions_to_embed):
+                 print(f"Предупреждение: Размер кэша эмбеддингов вопросов не совпадает. Пересчет.")
+                 question_embeddings = None
+            else:
+                print("Кэш эмбеддингов вопросов успешно загружен.")
+        except Exception as e:
+            print(f"Ошибка загрузки кэша эмбеддингов вопросов: {e}. Пересчет.")
+            question_embeddings = None
+
+    if question_embeddings is None:
+        needs_model_load = True # Требуется модель для генерации эмбеддингов
+        print("Векторизация вопросов (потребуется загрузка модели)...")
+
+    chunk_embeddings = None
+    if chunk_embeddings_cache_path.exists():
+        try:
+            print(f"Загрузка кэшированных эмбеддингов чанков из: {chunk_embeddings_cache_path}")
+            chunk_embeddings = np.load(chunk_embeddings_cache_path, allow_pickle=False)
+            if len(chunk_embeddings) != len(chunks_df):
+                print(f"Предупреждение: Размер кэша эмбеддингов чанков не совпадает. Пересчет.")
+                chunk_embeddings = None
+            else:
+                 print("Кэш эмбеддингов чанков успешно загружен.")
+        except Exception as e:
+            print(f"Ошибка загрузки кэша эмбеддингов чанков: {e}. Пересчет.")
+            chunk_embeddings = None
+
+    if chunk_embeddings is None:
+        needs_model_load = True # Требуется модель для генерации эмбеддингов
+        print("Векторизация чанков (потребуется загрузка модели)...")
+
+    # --- Отложенная загрузка модели, если необходимо ---
+    if needs_model_load and loaded_model is None:
+        print("\n--- Загрузка модели и токенизатора (т.к. кэш эмбеддингов отсутствует) ---")
+        loaded_model, loaded_tokenizer = setup_model_and_tokenizer(
+            args.model_name, args.use_sentence_transformers, args.device
+        )
+        print("--- Модель и токенизатор загружены ---\n")
+
+    # --- Повторная генерация эмбеддингов, если они не загрузились из кэша --- 
+    if question_embeddings is None:
+        if loaded_model is None:
+             print("Критическая ошибка: Модель не загружена, но требуется для векторизации вопросов!")
+             # Возвращаем пустой DataFrame или выбрасываем исключение
+             return pd.DataFrame() 
+             
+        print("Повторная векторизация вопросов...")
+        question_embeddings = get_embeddings(
+            query_texts_to_embed,
+            loaded_model, loaded_tokenizer, args.batch_size, args.use_sentence_transformers, args.device
+        )
+        if question_embeddings.shape[0] > 0:
+            try:
+                print(f"Сохранение эмбеддингов вопросов в кэш: {question_embeddings_cache_path}")
+                np.save(question_embeddings_cache_path, question_embeddings, allow_pickle=False)
+            except Exception as e:
+                print(f"Не удалось сохранить кэш эмбеддингов вопросов: {e}")
+
+    if chunk_embeddings is None:
+        if loaded_model is None:
+            print("Критическая ошибка: Модель не загружена, но требуется для векторизации чанков!")
+            return pd.DataFrame()
+
+        print("Повторная векторизация чанков...")
+        chunk_texts = chunks_df['text'].fillna('').astype(str).tolist()
+        chunk_embeddings = get_embeddings(
+            chunk_texts,
+            loaded_model, loaded_tokenizer, args.batch_size, args.use_sentence_transformers, args.device
+        )
+        if chunk_embeddings.shape[0] > 0:
+            try:
+                print(f"Сохранение эмбеддингов чанков в кэш: {chunk_embeddings_cache_path}")
+                np.save(chunk_embeddings_cache_path, chunk_embeddings, allow_pickle=False)
+            except Exception as e:
+                 print(f"Не удалось сохранить кэш эмбеддингов чанков: {e}")
+
+
+    # Проверка совпадения количества эмбеддингов и данных
+    if len(question_embeddings) != len(questions_to_embed):
+        print(f"Ошибка: Количество эмбеддингов вопросов ({len(question_embeddings)}) не совпадает с количеством уникальных вопросов ({len(questions_to_embed)}).")
+        # Можно либо прервать выполнение, либо попытаться исправить
+        # Например, взять первые N эмбеддингов, но это может быть некорректно
+        sys.exit(1)
+    if len(chunk_embeddings) != len(chunks_df):
+        print(f"Ошибка: Количество эмбеддингов чанков ({len(chunk_embeddings)}) не совпадает с количеством чанков в DataFrame ({len(chunks_df)}).")
+        # Попытка исправить (если ошибка небольшая) или выход
+        if abs(len(chunk_embeddings) - len(chunks_df)) < 5:
+             print("Попытка обрезать лишние эмбеддинги/данные...")
+             min_len = min(len(chunk_embeddings), len(chunks_df))
+             chunk_embeddings = chunk_embeddings[:min_len]
+             chunks_df = chunks_df.iloc[:min_len]
+             print(f"Размеры выровнены до {min_len}")
+        else:
+             sys.exit(1)
+
+
+    # Создаем маппинг ID вопроса к индексу в эмбеддингах
+    question_id_to_idx = {
+        row['id']: i for i, (_, row) in enumerate(questions_to_embed.iterrows())
+    }
+
+    # 2. Расчет косинусной близости
+    print("Расчет косинусной близости...")
+    # Проверка на пустые эмбеддинги
+    if question_embeddings.shape[0] == 0 or chunk_embeddings.shape[0] == 0:
+        print("Ошибка: Отсутствуют эмбеддинги вопросов или чанков для расчета близости.")
+        # Возвращаем пустой DataFrame или обрабатываем ошибку иначе
+        return pd.DataFrame()
+
+    similarity_matrix = cosine_similarity(question_embeddings, chunk_embeddings)
+
+    # 3. Инициализация InjectionBuilder (если нужно)
+    injection_builder = None
+    if args.use_injection:
+        print("Инициализация InjectionBuilder...")
+        repository = InMemoryEntityRepository(all_entities)
+        injection_builder = InjectionBuilder(repository)
+        # TODO: Зарегистрировать стратегии, если необходимо
+        # builder.register_strategy(...)
+
+    # 4. Цикл по уникальным вопросам для оценки
+    results = []
+    print(f"Оценка для {len(questions_to_embed)} уникальных вопросов...")
+
+    for question_id_iter, question_data in tqdm(questions_to_embed.iterrows(), total=len(questions_to_embed), desc="Оценка вопросов"): # Renamed loop variable
+        q_id = question_data['id']
+        q_text = question_data['question']
+
+        # Получаем все строки из исходного датасета для этого вопроса
+        question_rows = search_dataset[search_dataset['id'] == q_id] # Use search_dataset
+        if question_rows.empty:
+            print(f"Предупреждение: Нет данных в search_dataset для вопроса ID={q_id}")
+            continue
+
+        # Получаем пункты (relevant items)
+        puncts = question_rows['text'].tolist()
+        # reference_answer больше не используется и не извлекается
+
+        # Получаем индекс вопроса в матрице близости
+        if q_id not in question_id_to_idx:
+            print(f"Предупреждение: Вопрос ID={q_id} не найден в маппинге эмбеддингов.")
+            continue
+        question_idx = question_id_to_idx[q_id]
+
+        # --- Оценка на уровне чанков (Chunk-level) ---
+        chunk_level_metrics = evaluate_chunk_relevance(
+            q_id, question_idx, puncts,
+            similarity_matrix, chunks_df, args.top_n, args.similarity_threshold
+        )
+
+        # --- Оценка на уровне сборки (Assembly-level) ---
+        # Удаляем assembly_relevance, основанный на reference_answer
+        assembly_level_metrics = {} # Start with an empty dict for assembly metrics
+        assembled_context = ""
+        top_chunk_indices = chunk_level_metrics.get("top_chunk_ids", []) # Get indices first
+        neighbors_included = False # Flag to log
+
+        if args.use_injection and injection_builder and top_chunk_indices:
+            try:
+                # Преобразуем ID строк обратно в UUID чанков
+                top_chunk_uuids = [UUID(chunks_df.iloc[idx]['chunk_id']) for idx in top_chunk_indices]
+
+                final_chunk_uuids_for_assembly = set(top_chunk_uuids) # Start with top chunks
+
+                # --- Добавляем соседей, если нужно ---
+                if args.include_neighbors:
+                    neighbors_included = True
+                    # --- Убираем логирование индексов --- 
+                    neighbor_chunks = repository.get_neighboring_chunks(chunk_ids=top_chunk_uuids, max_distance=1)
+                    neighbor_ids = {neighbor.id for neighbor in neighbor_chunks}
+                    # --- Логирование до/после добавления ID соседей ---
+                    print(f"  [DEBUG QID {q_id}] Кол-во ID до добавления соседей: {len(final_chunk_uuids_for_assembly)}")
+                    print(f"  [DEBUG QID {q_id}] Кол-во найденных ID соседей: {len(neighbor_ids)}")
+                    final_chunk_uuids_for_assembly.update(neighbor_ids)
+                    print(f"  [DEBUG QID {q_id}] Кол-во ID после добавления соседей: {len(final_chunk_uuids_for_assembly)}")
+                    # --- Конец логирования ---
+                    # --- Убираем логирование индексов --- 
+                else:
+                     # --- Убираем логирование индексов --- 
+                     pass # Ничего не делаем, если соседи не включены
+
+                # Собираем контекст
+                # Передаем финальный набор UUID (уникальный)
+                assembled_context = injection_builder.build(
+                    filtered_entities=list(final_chunk_uuids_for_assembly),
+                    # chunk_scores= {chunks_df.loc[idx, 'chunk_id']: sim for idx, sim in zip(top_chunk_ids_for_assembly, chunk_level_metrics.get('top_chunk_similarities',[]))} # Можно добавить веса
+                )
+
+                # --- Новая метрика: Assembly Punct Recall ---
+                # Оцениваем, сколько пунктов из датасета найдено в собранном контексте
+                # (по вашей идее: пункт считается найденным, если хотя бы одна его часть,
+                # разделенная переносом строки, найдена в контексте)
+                assembly_found_puncts = 0
+                assembly_total_puncts = len(puncts)
+                if assembly_total_puncts > 0 and assembled_context:
+                    # Итерируемся по каждому исходному пункту
+                    for punct_text in puncts:
+                        # Разбиваем пункт на части по переносу строки
+                        # Убираем пустые строки, которые могут появиться из-за двойных переносов
+                        punct_parts = [part for part in punct_text.split('\n') if part.strip()]
+                        
+                        # Если пункт пустой или состоит только из пробельных символов после разбивки,
+                        # пропускаем его (не считаем ни найденным, ни не найденным в контексте recall)
+                        if not punct_parts:
+                            assembly_total_puncts -= 1 # Уменьшаем общее число пунктов для расчета recall
+                            continue
+
+                        is_punct_found = False
+                        # Итерируемся по частям пункта
+                        for part_text in punct_parts:
+                            # Сравниваем КАЖДУЮ ЧАСТЬ пункта с собранным контекстом
+                            if calculate_chunk_overlap(assembled_context, part_text.strip()) >= args.similarity_threshold:
+                                # Если ХОТЯ БЫ ОДНА часть найдена, считаем ВЕСЬ пункт найденным
+                                is_punct_found = True
+                                break # Дальше части этого пункта можно не проверять
+                        
+                        # Если флаг is_punct_found стал True, увеличиваем счетчик найденных пунктов
+                        if is_punct_found:
+                             assembly_found_puncts += 1
+                             
+                    # Рассчитываем recall, только если были валидные пункты для проверки
+                    if assembly_total_puncts > 0:
+                        assembly_level_metrics["assembly_punct_recall"] = assembly_found_puncts / assembly_total_puncts
+                    else:
+                        assembly_level_metrics["assembly_punct_recall"] = 0.0 # Или можно None, если нет валидных пунктов
+                else:
+                    assembly_level_metrics["assembly_punct_recall"] = 0.0
+                # Добавляем сам текст сборки для возможного анализа (усеченный)
+                assembly_level_metrics["assembled_context_preview"] = assembled_context[:500] + ("..." if len(assembled_context) > 500 else "")
+
+
+            except Exception as e:
+                print(f"Ошибка при сборке/оценке контекста для вопроса ID={q_id}: {e}")
+                # Записываем None или 0, чтобы не прерывать процесс
+                assembly_level_metrics["assembly_punct_recall"] = None # Indicate error
+                assembly_level_metrics["assembled_context_preview"] = f"Error during assembly: {e}"
+
+
+        # Собираем все метрики для вопроса
+        question_result = {
+            "run_id": args.run_id,
+            "batch_id": args.batch_id, # --- Добавляем batch_id в результаты ---
+            "question_id": q_id,
+            "question_text": q_text,
+            # Параметры запуска
+            "model_name": args.model_name,
+            "chunking_strategy": args.chunking_strategy, # Log strategy
+            "process_tables": args.process_tables, # Log table flag
+            "strategy_params": args.strategy_params, # Log JSON string
+            "top_n": args.top_n,
+            "use_injection": args.use_injection,
+            "use_qe": qe_active, # Log QE status
+            "neighbors_included": neighbors_included, # Log neighbor flag
+            "similarity_threshold": args.similarity_threshold,
+            # Метрики Chunk-level
+            **chunk_level_metrics,
+            # Метрики Assembly-level (теперь с recall по пунктам)
+            **assembly_level_metrics,
+            # Тексты для отладки (эталонный ответ удален, сборка добавлена выше)
+            # "assembled_context": assembled_context[:500] + "..." if assembled_context else "",
+        }
+        results.append(question_result)
+
+    print("Оценка завершена.")
+    return pd.DataFrame(results)
+
+
+def evaluate_chunk_relevance(
+    question_id: int,
+    question_idx: int,
+    puncts: list[str],
+    similarity_matrix: np.ndarray,
+    chunks_df: pd.DataFrame,
+    top_n: int,
+    similarity_threshold: float
+) -> dict:
+    """
+    Оценивает релевантность чанков для одного вопроса.
+    (Адаптировано из evaluate_for_top_n_with_mapping в evaluate_chunking.py)
+
+    Возвращает словарь с метриками для этого вопроса.
+    """
+    metrics = {
+        "chunk_text_precision": 0.0,
+        "chunk_text_recall": 0.0,
+        "chunk_text_f1": 0.0,
+        "found_puncts": 0,
+        "total_puncts": len(puncts),
+        "relevant_chunks": 0,
+        "total_chunks_in_top_n": 0,
+        "top_chunk_ids": [], # Индексы строк в chunks_df
+        "top_chunk_similarities": [],
+    }
+
+    if chunks_df.empty or similarity_matrix.shape[1] == 0:
+        print(f"Предупреждение (QID {question_id}): Нет чанков для оценки.")
+        return metrics
+
+    # Получаем схожести всех чанков с текущим вопросом
+    question_similarities = similarity_matrix[question_idx, :]
+
+    # Сортируем чанки по схожести и берем top_n
+    # argsort возвращает индексы элементов, которые бы отсортировали массив
+    # Берем последние N индексов (-top_n:) и разворачиваем ([::-1]) для убывания
+    # Добавляем проверку на случай если top_n > количества чанков
+    if top_n >= similarity_matrix.shape[1]:
+        sorted_chunk_indices = np.argsort(question_similarities)[::-1] # Берем все, сортируем по убыванию
+    else:
+        sorted_chunk_indices = np.argsort(question_similarities)[-top_n:][::-1]
+
+    # Ограничиваем top_n, если чанков меньше (это должно быть сделано выше, но дублируем для надежности)
+    actual_top_n = min(top_n, len(sorted_chunk_indices))
+    top_chunk_indices = sorted_chunk_indices[:actual_top_n]
+
+    # Сохраняем ID и схожести топ-чанков
+    metrics["top_chunk_ids"] = top_chunk_indices.tolist()
+    metrics["top_chunk_similarities"] = question_similarities[top_chunk_indices].tolist()
+
+
+    # Отбираем данные топ-чанков
+    top_chunks_df = chunks_df.iloc[top_chunk_indices]
+    metrics["total_chunks_in_top_n"] = len(top_chunks_df)
+
+    if metrics["total_chunks_in_top_n"] == 0:
+        return metrics # Если нет топ-чанков, метрики остаются нулевыми
+
+    # Оценка на основе текста (пунктов)
+    punct_found = [False] * metrics["total_puncts"]
+    question_relevant_chunks = 0
+    for i, (idx, chunk_row) in enumerate(top_chunks_df.iterrows()):
+        chunk_text = chunk_row['text']
+        is_relevant_to_punct = False
+        for j, punct_text in enumerate(puncts):
+            overlap = calculate_chunk_overlap(chunk_text, punct_text)
+            if overlap >= similarity_threshold:
+                is_relevant_to_punct = True
+                punct_found[j] = True
+        if is_relevant_to_punct:
+            question_relevant_chunks += 1
+
+    metrics["found_puncts"] = sum(punct_found)
+    metrics["relevant_chunks"] = question_relevant_chunks
+
+    if metrics["total_chunks_in_top_n"] > 0:
+        metrics["chunk_text_precision"] = metrics["relevant_chunks"] / metrics["total_chunks_in_top_n"]
+    if metrics["total_puncts"] > 0:
+        metrics["chunk_text_recall"] = metrics["found_puncts"] / metrics["total_puncts"]
+    if metrics["chunk_text_precision"] + metrics["chunk_text_recall"] > 0:
+        metrics["chunk_text_f1"] = (2 * metrics["chunk_text_precision"] * metrics["chunk_text_recall"] /
+                                  (metrics["chunk_text_precision"] + metrics["chunk_text_recall"]))
+
+    return metrics
+
+
+# --- Основная функция ---
+
+def main():
+    """Основная функция скрипта."""
+    args = parse_args()
+    print(f"Запуск оценки с ID: {args.run_id}")
+    print(f"Параметры: {vars(args)}")
+
+    # --- Кэширование Чанкинга --- 
+    CACHE_DIR_PATH = Path(args.cache_dir)
+    try:
+        # Парсим параметры стратегии один раз
+        parsed_strategy_params = json.loads(args.strategy_params)
+    except json.JSONDecodeError:
+        print(f"Предупреждение: Невалидный JSON в strategy_params: '{args.strategy_params}'. Используются параметры по умолчанию для хэша кэша.")
+        parsed_strategy_params = {}
+
+    chunking_hash = _get_chunking_cache_hash(
+        args.data_folder,
+        args.chunking_strategy,
+        args.process_tables,
+        parsed_strategy_params
+    )
+    chunks_df_cache_path = _get_cache_path(CACHE_DIR_PATH, chunking_hash, "chunks_df.parquet")
+    entities_cache_path = _get_cache_path(CACHE_DIR_PATH, chunking_hash, "final_entities.pkl")
+
+    chunks_df = None
+    all_entities = None
+
+    if chunks_df_cache_path.exists() and entities_cache_path.exists():
+        print(f"Найден кэш чанкинга (hash: {chunking_hash}). Загрузка...")
+        try:
+            chunks_df = pd.read_parquet(chunks_df_cache_path)
+            with open(entities_cache_path, 'rb') as f:
+                all_entities = pickle.load(f)
+            print(f"Кэш чанкинга успешно загружен: {len(chunks_df)} чанков, {len(all_entities)} сущностей.")
+        except Exception as e:
+            print(f"Ошибка загрузки кэша чанкинга: {e}. Выполняем чанкинг заново.")
+            chunks_df = None
+            all_entities = None
+
+    if chunks_df is None or all_entities is None:
+        print("Кэш чанкинга не найден или поврежден. Выполнение чтения документов и чанкинга...")
+        # 1. Загрузка данных
+        documents_map = read_documents(args.data_folder)
+        if not documents_map:
+            print("Нет документов для обработки. Завершение.")
+            return
+
+        # 2. Чанкинг
+        chunks_df, all_entities = perform_chunking(
+            documents_map,
+            args.chunking_strategy, # Pass strategy
+            args.process_tables, # Pass table flag
+            args.strategy_params # Pass JSON string parameters
+        )
+        if chunks_df.empty:
+            print("После чанкинга не осталось чанков для обработки. Завершение.")
+            return
+        
+        # Сохраняем результаты чанкинга в кэш
+        try:
+            print(f"Сохранение результатов чанкинга в кэш (hash: {chunking_hash})...")
+            # Убедимся, что директория кэша существует (на всякий случай)
+            chunks_df_cache_path.parent.mkdir(parents=True, exist_ok=True)
+            entities_cache_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            chunks_df.to_parquet(chunks_df_cache_path)
+            with open(entities_cache_path, 'wb') as f:
+                pickle.dump(all_entities, f)
+            print("Результаты чанкинга сохранены в кэш.")
+        except Exception as e:
+            print(f"Ошибка сохранения кэша чанкинга: {e}")
+
+    # --- Конец Кэширования Чанкинга ---
+
+    # Загружаем поисковый датасет (это нужно делать всегда, т.к. он не кэшируется здесь)
+    search_df, questions_to_embed = load_datasets(args.search_dataset_path)
+
+    # 3. Выполнение оценки (передаем загруженные или свежесгенерированные chunks_df и all_entities)
+    results_df = evaluate_run(
+        search_df, questions_to_embed, chunks_df, all_entities,
+        None, None, args # Передаем None для model и tokenizer
+    )
+
+    # 5. Сохранение результатов
+    if not results_df.empty:
+        os.makedirs(args.output_dir, exist_ok=True)
+        # output_filename = f"results_{args.run_id}.csv"
+        # Добавляем batch_id в имя файла для лучшей группировки
+        output_filename = f"results_{args.batch_id}_{args.run_id}.csv"
+        output_path = os.path.join(args.output_dir, output_filename)
+        try:
+            results_df.to_csv(output_path, index=False, encoding='utf-8')
+            print(f"Детальные результаты сохранены в: {output_path}")
+        except Exception as e:
+            print(f"Ошибка при сохранении результатов в {output_path}: {e}")
+    else:
+        print("Нет результатов для сохранения.")
+
+if __name__ == "__main__":
+    main()

scripts/testing/plot_results.py

@@ -0,0 +1,466 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Скрипт для визуализации агрегированных результатов тестирования RAG.
+
+Читает данные из Excel-файла, сгенерированного aggregate_results.py,
+и строит различные графики для анализа влияния параметров на метрики.
+"""
+
+import argparse
+import json
+import os
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+
+# --- Настройки --- 
+DEFAULT_RESULTS_FILE = "data/output/aggregated_results.xlsx" # Файл с агрегированными данными
+DEFAULT_PLOTS_DIR = "data/output/plots" # Куда сохранять графики
+
+# Настройки графиков
+plt.rcParams['font.family'] = 'DejaVu Sans' # Шрифт с поддержкой кириллицы
+sns.set_style("whitegrid")
+FIGSIZE = (16, 10) # Увеличенный размер для сложных графиков
+DPI = 300
+PALETTE = "viridis" # Цветовая палитра
+
+# --- Маппинг названий столбцов (копия из aggregate_results.py) ---
+COLUMN_NAME_MAPPING = {
+    # Параметры запуска из pipeline.py
+    'run_id': 'ID Запуска',
+    'model_name': 'Модель',
+    'chunking_strategy': 'Стратегия Чанкинга',
+    'strategy_params': 'Параметры Стратегии',
+    'process_tables': 'Обраб. Таблиц',
+    'top_n': 'Top N',
+    'use_injection': 'Сборка Контекста',
+    'use_qe': 'Query Expansion',
+    'neighbors_included': 'Вкл. Соседей',
+    'similarity_threshold': 'Порог Схожести',
+
+    # Идентификаторы из датасета (для детальных результатов)
+    'question_id': 'ID Вопроса',
+    'question_text': 'Текст Вопроса',
+
+    # Детальные метрики из pipeline.py
+    'chunk_text_precision': 'Точность (Чанк-Текст)',
+    'chunk_text_recall': 'Полнота (Чанк-Текст)',
+    'chunk_text_f1': 'F1 (Чанк-Текст)',
+    'found_puncts': 'Найдено Пунктов',
+    'total_puncts': 'Всего Пунктов',
+    'relevant_chunks': 'Релевантных Чанков',
+    'total_chunks_in_top_n': 'Всего Чанков в Топ-N',
+    'assembly_punct_recall': 'Полнота (Сборка-Пункт)',
+    'assembled_context_preview': 'Предпросмотр Сборки',
+    # 'top_chunk_ids': 'Индексы Топ-Чанков', # Списки, могут плохо отображаться
+    # 'top_chunk_similarities': 'Схожести Топ-Чанков', # Списки
+
+    # Агрегированные метрики (добавляются в calculate_aggregated_metrics)
+    'weighted_chunk_text_precision': 'Weighted Точность (Чанк-Текст)',
+    'weighted_chunk_text_recall': 'Weighted Полнота (Чанк-Текст)',
+    'weighted_chunk_text_f1': 'Weighted F1 (Чанк-Текст)',
+    'weighted_assembly_punct_recall': 'Weighted Полнота (Сборка-Пункт)',
+
+    'macro_chunk_text_precision': 'Macro Точность (Чанк-Текст)',
+    'macro_chunk_text_recall': 'Macro Полнота (Чанк-Текст)',
+    'macro_chunk_text_f1': 'Macro F1 (Чанк-Текст)',
+    'macro_assembly_punct_recall': 'Macro Полнота (Сборка-Пункт)',
+
+    'micro_text_precision': 'Micro Точность (Текст)',
+    'micro_text_recall': 'Micro Полнота (Текст)',
+    'micro_text_f1': 'Micro F1 (Текст)',
+}
+# --- Конец маппинга ---
+
+def parse_args():
+    """Парсит аргументы командной строки."""
+    parser = argparse.ArgumentParser(description="Визуализация результатов тестирования RAG")
+
+    parser.add_argument("--results-file", type=str, default=DEFAULT_RESULTS_FILE,
+                        help=f"Путь к Excel-файлу с агрегированными результатами (по умолчанию: {DEFAULT_RESULTS_FILE})")
+    parser.add_argument("--plots-dir", type=str, default=DEFAULT_PLOTS_DIR,
+                        help=f"Директория для сохранения графиков (по умолчанию: {DEFAULT_PLOTS_DIR})")
+    parser.add_argument("--sheet-name", type=str, default="Агрегированные метрики",
+                        help="Название листа в Excel-файле для чтения данных")
+
+    return parser.parse_args()
+
+def setup_plots_directory(plots_dir: str) -> None:
+    """Создает директорию для графиков, если она не существует."""
+    if not os.path.exists(plots_dir):
+        os.makedirs(plots_dir)
+        print(f"Создана директория для графиков: {plots_dir}")
+    else:
+        print(f"Использование существующей директории для графиков: {plots_dir}")
+
+def load_aggregated_data(file_path: str, sheet_name: str) -> pd.DataFrame:
+    """Загружает данные из указанного листа Excel-файла."""
+    print(f"Загрузка данных из файла: {file_path}, лист: {sheet_name}")
+    try:
+        df = pd.read_excel(file_path, sheet_name=sheet_name)
+        print(f"Загружено {len(df)} строк.")
+        print(f"Колонки: {df.columns.tolist()}")
+        # Добавим проверку на необходимые колонки (РУССКИЕ НАЗВАНИЯ)
+        required_cols_rus = [
+            COLUMN_NAME_MAPPING['model_name'], COLUMN_NAME_MAPPING['chunking_strategy'],
+            COLUMN_NAME_MAPPING['strategy_params'], COLUMN_NAME_MAPPING['process_tables'],
+            COLUMN_NAME_MAPPING['top_n'], COLUMN_NAME_MAPPING['use_injection'],
+            COLUMN_NAME_MAPPING['use_qe'], COLUMN_NAME_MAPPING['neighbors_included'],
+            COLUMN_NAME_MAPPING['similarity_threshold']
+            ]
+        # Проверяем только те, что есть в маппинге
+        missing_required = [col for col in required_cols_rus if col not in df.columns]
+        if missing_required:
+            print(f"Предупреждение: Не все ожидаемые колонки параметров найдены в данных: {missing_required}")
+
+        # --- Добавим парсинг strategy_params из JSON строки в словарь ---
+        params_col = COLUMN_NAME_MAPPING['strategy_params']
+        if params_col in df.columns:
+            def safe_json_loads(x):
+                try:
+                    # Обработка NaN и пустых строк
+                    if pd.isna(x) or not isinstance(x, str) or not x.strip():
+                        return {}
+                    return json.loads(x)
+                except (json.JSONDecodeError, TypeError):
+                    return {} # Возвращаем пустой словарь при ошибке
+
+            df[params_col] = df[params_col].apply(safe_json_loads)
+            # Создаем строковое представление для группировки и лейблов
+            df[f"{params_col}_str"] = df[params_col].apply(
+                lambda d: json.dumps(d, sort_keys=True, ensure_ascii=False)
+            )
+            print(f"Колонка '{params_col}' преобразована из JSON строк.")
+        # --------------------------------------------------------------
+
+        return df
+    except FileNotFoundError:
+        print(f"Ошибка: Файл не найден: {file_path}")
+        return pd.DataFrame()
+    except ValueError as e:
+        print(f"Ошибка: Лист '{sheet_name}' не найден в файле {file_path}. Доступные листы: {pd.ExcelFile(file_path).sheet_names}")
+        return pd.DataFrame()
+    except Exception as e:
+        print(f"Ошибка при чтении Excel файла: {e}")
+        return pd.DataFrame()
+
+# --- Функции построения графиков --- #
+
+def plot_metric_vs_top_n(
+    df: pd.DataFrame,
+    metric_name_rus: str, # Ожидаем русское имя метрики
+    fixed_strategy: str | None,
+    fixed_strategy_params: str | None, # Ожидаем строку JSON или None
+    plots_dir: str
+) -> None:
+    """
+    Строит график зависимости метрики от top_n для разных моделей
+    (при фиксированных параметрах чанкинга).
+    Разделяет линии по значению use_injection.
+    Использует русские названия колонок.
+    """
+    # Используем русские названия колонок из маппинга
+    metric_col_rus = metric_name_rus # Передаем уже готовое русское имя
+    top_n_col_rus = COLUMN_NAME_MAPPING['top_n']
+    model_col_rus = COLUMN_NAME_MAPPING['model_name']
+    injection_col_rus = COLUMN_NAME_MAPPING['use_injection']
+    strategy_col_rus = COLUMN_NAME_MAPPING['chunking_strategy']
+    params_str_col_rus = f"{COLUMN_NAME_MAPPING['strategy_params']}_str" # Используем строковое представление
+
+    if metric_col_rus not in df.columns:
+        print(f"График пропущен: Колонка '{metric_col_rus}' не найдена.")
+        return
+
+    plot_df = df.copy()
+
+    # Фильтруем по параметрам чанкинга, если задано
+    chunk_suffix = "all_strategies_all_params"
+    if fixed_strategy and strategy_col_rus in plot_df.columns:
+        plot_df = plot_df[plot_df[strategy_col_rus] == fixed_strategy]
+        chunk_suffix = f"strategy_{fixed_strategy}"
+        # Фильтруем по строковому пред��тавлению параметров
+        if fixed_strategy_params and params_str_col_rus in plot_df.columns:
+            plot_df = plot_df[plot_df[params_str_col_rus] == fixed_strategy_params]
+            # Генерируем короткий хэш для параметров в названии файла
+            params_hash = hash(fixed_strategy_params) # Хэш от строки
+            chunk_suffix += f"_params-{params_hash:x}" # Hex hash
+
+        if plot_df.empty:
+            print(f"График Metric vs Top-N пропущен: Нет данных для strategy={fixed_strategy}, params={fixed_strategy_params}")
+            return
+
+    plt.figure(figsize=FIGSIZE)
+    sns.lineplot(
+        data=plot_df,
+        x=top_n_col_rus,
+        y=metric_col_rus,
+        hue=model_col_rus,
+        style=injection_col_rus, # Разные стили линий для True/False
+        markers=True,
+        markersize=8,
+        linewidth=2,
+        palette=PALETTE
+    )
+
+    plt.title(f"Зависимость {metric_col_rus} от top_n ({chunk_suffix})")
+    plt.xlabel("Top N")
+    plt.ylabel(metric_col_rus.replace("_", " ").title())
+    plt.legend(title="Модель / Сборка", bbox_to_anchor=(1.05, 1), loc='upper left')
+    plt.grid(True, linestyle='--', alpha=0.7)
+    plt.tight_layout(rect=[0, 0, 0.85, 1]) # Оставляем место для легенды
+
+    filename = f"plot_{metric_col_rus.replace(' ', '_').replace('(', '').replace(')', '')}_vs_top_n_{chunk_suffix}.png"
+    filepath = os.path.join(plots_dir, filename)
+    plt.savefig(filepath, dpi=DPI)
+    plt.close()
+    print(f"Создан график: {filepath}")
+
+def plot_injection_comparison(
+    df: pd.DataFrame,
+    metric_name_rus: str, # Ожидаем русское имя метрики
+    plots_dir: str
+) -> None:
+    """
+    Сравнивает метрики с использованием и без использования сборки контекста
+    в виде парных столбчатых диаграмм для разных моделей и параметров чанкинга.
+    Использует русские названия колонок.
+    """
+    # Русские названия колонок
+    metric_col_rus = metric_name_rus
+    injection_col_rus = COLUMN_NAME_MAPPING['use_injection']
+    model_col_rus = COLUMN_NAME_MAPPING['model_name']
+    strategy_col_rus = COLUMN_NAME_MAPPING['chunking_strategy']
+    params_str_col_rus = f"{COLUMN_NAME_MAPPING['strategy_params']}_str"
+    tables_col_rus = COLUMN_NAME_MAPPING['process_tables']
+    qe_col_rus = COLUMN_NAME_MAPPING['use_qe']
+    neighbors_col_rus = COLUMN_NAME_MAPPING['neighbors_included']
+    top_n_col_rus = COLUMN_NAME_MAPPING['top_n']
+    threshold_col_rus = COLUMN_NAME_MAPPING['similarity_threshold']
+
+    if metric_col_rus not in df.columns or injection_col_rus not in df.columns:
+        print(f"График сравнения сборки пропущен: Колонки '{metric_col_rus}' или '{injection_col_rus}' не найдены.")
+        return
+
+    plot_df = df.copy()
+    # Используем русские названия при создании лейбла
+    plot_df['config_label'] = plot_df.apply(
+        lambda r: (
+            f"{r.get(model_col_rus, 'N/A')}\n"
+            f"Стратегия: {r.get(strategy_col_rus, 'N/A')}\n"
+            # Используем строковое представление параметров
+            f"Параметры: {r.get(params_str_col_rus, '{}')[:30]}...\n"
+            f"Табл: {r.get(tables_col_rus, 'N/A')}, QE: {r.get(qe_col_rus, 'N/A')}, Соседи: {r.get(neighbors_col_rus, 'N/A')}\n"
+            f"TopN: {int(r.get(top_n_col_rus, 0))}, Порог: {r.get(threshold_col_rus, 0):.2f}"
+        ),
+        axis=1
+    )
+
+    # Оставляем только строки, где есть и True, и False для данного флага
+    # Группируем по config_label, считаем уникальные значения флага use_injection
+    counts = plot_df.groupby('config_label')[injection_col_rus].nunique()
+    configs_with_both = counts[counts >= 2].index # Используем >= 2 на случай дубликатов
+    plot_df = plot_df[plot_df['config_label'].isin(configs_with_both)]
+
+    if plot_df.empty:
+        print(f"График сравнения сборки пропущен: Нет конфигураций с обоими вариантами {injection_col_rus}.")
+        return
+
+    # Ограничим количество конфигураций для читаемости (по средней метрике)
+    top_configs = plot_df.groupby('config_label')[metric_col_rus].mean().nlargest(10).index # Уменьшил до 10
+    plot_df = plot_df[plot_df['config_label'].isin(top_configs)]
+
+    if plot_df.empty:
+         print(f"График сравнения сборки пропущен: Не осталось да��ных после фильтрации топ-конфигураций.")
+         return
+
+    plt.figure(figsize=(FIGSIZE[0]*0.9, FIGSIZE[1]*0.7)) # Уменьшил размер
+    sns.barplot(
+        data=plot_df,
+        x='config_label',
+        y=metric_col_rus,
+        hue=injection_col_rus,
+        palette=PALETTE
+    )
+
+    plt.title(f"Сравнение {metric_col_rus} с/без {injection_col_rus}")
+    plt.xlabel("Конфигурация")
+    plt.ylabel(metric_col_rus)
+    plt.xticks(rotation=60, ha='right', fontsize=8) # Уменьшил шрифт, увеличил поворот
+    plt.legend(title=injection_col_rus)
+    plt.grid(True, axis='y', linestyle='--', alpha=0.7)
+    plt.tight_layout()
+
+    filename = f"plot_{metric_col_rus.replace(' ', '_').replace('(', '').replace(')', '')}_injection_comparison.png"
+    filepath = os.path.join(plots_dir, filename)
+    plt.savefig(filepath, dpi=DPI)
+    plt.close()
+    print(f"Создан график: {filepath}")
+
+# --- Новая функция для сравнения булевых флагов --- 
+def plot_boolean_flag_comparison(
+    df: pd.DataFrame,
+    metric_name_rus: str, # Ожидаем русское имя метрики
+    flag_column_eng: str, # Ожидаем английское имя флага для поиска в маппинге
+    plots_dir: str
+) -> None:
+    """
+    Сравнивает метрики при True/False значениях указанного булева флага
+    в виде парных столбчатых диаграмм для разных конфигураций.
+    Использует русские названия колонок.
+    """
+    # Русские названия колонок
+    metric_col_rus = metric_name_rus
+    try:
+        flag_col_rus = COLUMN_NAME_MAPPING[flag_column_eng]
+    except KeyError:
+        print(f"Ошибка: Английское имя флага '{flag_column_eng}' не найдено в COLUMN_NAME_MAPPING.")
+        return
+
+    model_col_rus = COLUMN_NAME_MAPPING['model_name']
+    strategy_col_rus = COLUMN_NAME_MAPPING['chunking_strategy']
+    params_str_col_rus = f"{COLUMN_NAME_MAPPING['strategy_params']}_str"
+    injection_col_rus = COLUMN_NAME_MAPPING['use_injection']
+    top_n_col_rus = COLUMN_NAME_MAPPING['top_n']
+    # Другие флаги
+    tables_col_rus = COLUMN_NAME_MAPPING['process_tables']
+    qe_col_rus = COLUMN_NAME_MAPPING['use_qe']
+    neighbors_col_rus = COLUMN_NAME_MAPPING['neighbors_included']
+
+
+    if metric_col_rus not in df.columns or flag_col_rus not in df.columns:
+        print(f"График сравнения флага '{flag_col_rus}' пропущен: Колонки '{metric_col_rus}' или '{flag_col_rus}' не найдены.")
+        return
+
+    plot_df = df.copy()
+    # Создаем обобщенный лейбл конфигурации, исключая сам флаг
+    plot_df['config_label'] = plot_df.apply(
+        lambda r: (
+            f"{r.get(model_col_rus, 'N/A')}\n"
+            f"Стратегия: {r.get(strategy_col_rus, 'N/A')} Параметры: {r.get(params_str_col_rus, '{}')[:20]}...\n"
+            f"Сборка: {r.get(injection_col_rus, 'N/A')}, TopN: {int(r.get(top_n_col_rus, 0))}"
+            # Динамически добавляем другие флаги, кроме сравниваемого
+            + (f", Табл: {r.get(tables_col_rus, 'N/A')}" if flag_col_rus != tables_col_rus else "")
+            + (f", QE: {r.get(qe_col_rus, 'N/A')}" if flag_col_rus != qe_col_rus else "")
+            + (f", Соседи: {r.get(neighbors_col_rus, 'N/A')}" if flag_col_rus != neighbors_col_rus else "")
+        ),
+        axis=1
+    )
+
+    # Оставляем только строки, где есть и True, и False для данного флага
+    counts = plot_df.groupby('config_label')[flag_col_rus].nunique()
+    configs_with_both = counts[counts >= 2].index # Используем >= 2
+    plot_df = plot_df[plot_df['config_label'].isin(configs_with_both)]
+
+    if plot_df.empty:
+        print(f"График сравнения флага '{flag_col_rus}' пропущен: Нет конфигураций с обоими вариантами {flag_col_rus}.")
+        return
+
+    # Ограничим количество конфигураций для читаемости (по средней метрике)
+    top_configs = plot_df.groupby('config_label')[metric_col_rus].mean().nlargest(10).index # Уменьшил до 10
+    plot_df = plot_df[plot_df['config_label'].isin(top_configs)]
+
+    if plot_df.empty:
+         print(f"График сравнения флага '{flag_col_rus}' пропущен: Не осталось данных после фильтрации топ-конфигураций.")
+         return
+
+    plt.figure(figsize=(FIGSIZE[0]*0.9, FIGSIZE[1]*0.7)) # Уменьшил размер
+    sns.barplot(
+        data=plot_df,
+        x='config_label',
+        y=metric_col_rus,
+        hue=flag_col_rus,
+        palette=PALETTE
+    )
+
+    plt.title(f"Сравнение {metric_col_rus} в зависимости от '{flag_col_rus}'")
+    plt.xlabel("Конфигурация")
+    plt.ylabel(metric_col_rus)
+    plt.xticks(rotation=60, ha='right', fontsize=8) # Уменьшил шрифт, увеличил поворот
+    plt.legend(title=f"{flag_col_rus}")
+    plt.grid(True, axis='y', linestyle='--', alpha=0.7)
+    plt.tight_layout()
+
+    filename = f"plot_{metric_col_rus.replace(' ', '_').replace('(', '').replace(')', '')}_{flag_column_eng}_comparison.png"
+    filepath = os.path.join(plots_dir, filename)
+    plt.savefig(filepath, dpi=DPI)
+    plt.close()
+    print(f"Создан график: {filepath}")
+
+# --- Основная функция --- 
+def main():
+    """Основная функция скрипта."""
+    args = parse_args()
+
+    setup_plots_directory(args.plots_dir)
+    df = load_aggregated_data(args.results_file, args.sheet_name)
+
+    if df.empty:
+        print("Нет данных для построения графиков. Завершение.")
+        return
+
+    # Определяем метрики для построения графиков (используем английские ключи для поиска русских имен)
+    metric_keys = [
+        'weighted_chunk_text_recall', 'weighted_chunk_text_f1', 'weighted_assembly_punct_recall',
+        'macro_chunk_text_recall', 'macro_chunk_text_f1', 'macro_assembly_punct_recall',
+        'micro_text_recall', 'micro_text_f1'
+    ]
+
+    # Получаем существующие русские имена метрик в DataFrame
+    existing_metrics_rus = [COLUMN_NAME_MAPPING.get(key) for key in metric_keys if COLUMN_NAME_MAPPING.get(key) in df.columns]
+
+    # Определяем фиксированные параметры для некоторых графиков
+    strategy_col_rus = COLUMN_NAME_MAPPING.get('chunking_strategy')
+    params_str_col_rus = f"{COLUMN_NAME_MAPPING.get('strategy_params')}_str"
+    model_col_rus = COLUMN_NAME_MAPPING.get('model_name')
+
+    fixed_strategy_example = df[strategy_col_rus].unique()[0] if strategy_col_rus in df.columns and len(df[strategy_col_rus].unique()) > 0 else None
+    fixed_strategy_params_example = None
+    if fixed_strategy_example and params_str_col_rus in df.columns:
+        params_list = df[df[strategy_col_rus] == fixed_strategy_example][params_str_col_rus].unique()
+        if len(params_list) > 0:
+            fixed_strategy_params_example = params_list[0]
+
+    fixed_model_example = df[model_col_rus].unique()[0] if model_col_rus in df.columns and len(df[model_col_rus].unique()) > 0 else None
+    fixed_top_n_example = 20
+
+    print("--- Построение графиков ---")
+
+    # 1. Графики Metric vs Top-N
+    print("\n1. Зависимость метрик от Top-N:")
+    for metric_name_rus in existing_metrics_rus:
+            # Проверяем, что метрика не micro (у micro нет зависимости от top_n)
+            if 'Micro' in metric_name_rus:
+                 continue
+            plot_metric_vs_top_n(
+                df, metric_name_rus,
+                fixed_strategy_example, fixed_strategy_params_example,
+                args.plots_dir
+            )
+
+    # 2. Графики Metric vs Chunking
+    print("\n2. Зависимость метрик от параметров чанкинга: [Пропущено - требует переосмысления]")
+    # plot_metric_vs_chunking(...) # Закомментировано
+
+    # 3. Графики сравнения Use Injection
+    print("\n3. Сравнение метрик с/без сборки контекста:")
+    for metric_name_rus in existing_metrics_rus:
+             plot_injection_comparison(df, metric_name_rus, args.plots_dir)
+
+    # 4. Графики сравнения других булевых флагов
+    boolean_flags_eng = ['process_tables', 'use_qe', 'neighbors_included']
+    print("\n4. Сравнение метрик в зависимости от булевых флагов:")
+    for flag_eng in boolean_flags_eng:
+        flag_rus = COLUMN_NAME_MAPPING.get(flag_eng)
+        if not flag_rus or flag_rus not in df.columns:
+            print(f"  Пропуск сравнения для флага: '{flag_eng}' (колонка '{flag_rus}' не найдена)")
+            continue
+        print(f"  Сравнение для флага: '{flag_rus}'")
+        for metric_name_rus in existing_metrics_rus:
+                 plot_boolean_flag_comparison(df, metric_name_rus, flag_eng, args.plots_dir)
+
+    print("\n--- Построение графиков завершено ---")
+
+if __name__ == "__main__":
+    main() 

scripts/testing/run_pipelines.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Скрипт для запуска множества пайплайнов оценки (`pipeline.py`)
+с различными комбинациями параметров.
+
+Собирает команды для `pipeline.py` и запускает их последовательно,
+логируя вывод каждого запуска.
+"""
+
+import argparse
+import json
+import os
+import pathlib
+import subprocess
+import sys
+import time
+from datetime import datetime
+from itertools import product
+from uuid import uuid4
+
+# --- Конфигурация Экспериментов ---
+
+# Модели для тестирования
+MODELS_TO_TEST = [
+    # "intfloat/e5-base",
+    # "intfloat/e5-large",
+    "BAAI/bge-m3",
+    # "deepvk/USER-bge-m3"
+    # "ai-forever/FRIDA" # Требует --use-sentence-transformers
+]
+
+# Параметры чанкинга (слова / перекрытие)
+CHUNKING_PARAMS = [
+    # Пример для стратегии "fixed_size"
+    {"strategy": "fixed_size", "params": {"words_per_chunk": 50, "overlap_words": 25}},
+    # {"strategy": "fixed_size", "params": {"words_per_chunk": 100, "overlap_words": 25}},
+    # {"strategy": "fixed_size", "params": {"words_per_chunk": 50, "overlap_words": 0}},
+    # TODO: Добавить другие стратегии и их параметры, если нужно
+    # {"strategy": "some_other_strategy", "params": {"param1": "value1"}}
+]
+
+# Значения Top-N для ретривера
+TOP_N_VALUES = [20, 50, 100]
+
+# Использовать ли сборку контекста (InjectionBuilder)
+USE_INJECTION_OPTIONS = [False, True]
+
+# Порог схожести для fuzzy сравнения (чанк/пункт)
+SIMILARITY_THRESHOLDS = [0.7]
+
+# Опции использования Query Expansion
+USE_QE_OPTIONS = [False, True]
+
+# Опции обработки таблиц
+PROCESS_TABLES_OPTIONS = [True]
+
+# Опции включения соседей
+INCLUDE_NEIGHBORS_OPTIONS = [True]
+
+# --- Настройки Скрипта ---
+DEFAULT_LOG_DIR = "logs" # Директория для логов отдельных запусков pipeline.py
+DEFAULT_INTERMEDIATE_DIR = "data/intermediate" # Куда pipeline.py сохраняет свои результаты
+DEFAULT_PYTHON_EXECUTABLE = sys.executable # Использовать тот же python, что и для запуска этого скрипта
+
+def parse_args():
+    """Парсит аргументы командной строки."""
+    parser = argparse.ArgumentParser(description="Запуск серии оценочных пайплайнов")
+
+    # Флаги для пропуска определенных измерений
+    parser.add_argument("--skip-models", action="store_true",
+                        help="Пропустить итерацию по разным моделям (использовать первую в списке)")
+    parser.add_argument("--skip-chunking", action="store_true",
+                        help="Пропустить итерацию по разным параметрам чанкинга (использовать первую в списке)")
+    parser.add_argument("--skip-top-n", action="store_true",
+                        help="Пропустить итерацию по разным top_n (использовать первое значение)")
+    parser.add_argument("--skip-injection", action="store_true",
+                        help="Пропустить итерацию по опциям сборки контекста (использовать False)")
+    parser.add_argument("--skip-thresholds", action="store_true",
+                        help="Пропустить итерацию по порогам схожести (использовать первый)")
+    parser.add_argument("--skip-process-tables", action="store_true",
+                        help="Пропустить итерацию по обработке таблиц (использовать True)")
+    parser.add_argument("--skip-include-neighbors", action="store_true",
+                        help="Пропустить итерацию по включению соседей (использовать False)")
+    parser.add_argument("--skip-qe", action="store_true",
+                        help="Пропустить итерацию по использованию Query Expansion (использовать False)")
+
+    # Настройки путей и выполнения
+    parser.add_argument("--log-dir", type=str, default=DEFAULT_LOG_DIR,
+                        help=f"Директория для сохранения логов запусков (по умолчанию: {DEFAULT_LOG_DIR})")
+    parser.add_argument("--intermediate-dir", type=str, default=DEFAULT_INTERMEDIATE_DIR,
+                        help=f"Директория для промежуточных результатов pipeline.py (по умолчанию: {DEFAULT_INTERMEDIATE_DIR})")
+    parser.add_argument("--device", type=str, default="cuda:0",
+                        help="Устройство для вычислений в pipeline.py (напр., cpu, cuda:0)")
+    parser.add_argument("--python-executable", type=str, default=DEFAULT_PYTHON_EXECUTABLE,
+                        help="Путь к интерпретатору Python для запуска pipeline.py")
+
+    # Параметры, передаваемые в pipeline.py (если не перебираются)
+    parser.add_argument("--data-folder", type=str, default="data/input/docs", help="Папка с документами для pipeline.py")
+    parser.add_argument("--search-dataset-path", type=str, default="data/input/search_dataset_text.xlsx", help="Поисковый датасет для pipeline.py")
+    parser.add_argument("--qa-dataset-path", type=str, default="data/input/question_answering.xlsx", help="QA датасет для pipeline.py")
+
+    return parser.parse_args()
+
+def run_single_pipeline(cmd: list[str], log_path: str):
+    """
+    Запускает один экземпляр pipeline.py и логирует его вывод.
+
+    Args:
+        cmd: Список аргументов команды для subprocess.
+        log_path: Путь к файлу для сохранения лога.
+
+    Returns:
+        Код возврата процесса.
+    """
+    print(f"\n--- Запуск: {' '.join(cmd)} ---")
+    print(f"--- Лог: {log_path} --- ")
+
+    start_time = time.time()
+    return_code = -1
+
+    try:
+        with open(log_path, "w", encoding="utf-8") as log_file:
+            log_file.write(f"Команда: {' '.join(cmd)}\n")
+            log_file.write(f"Время запуска: {datetime.now()}\n\n")
+            log_file.flush()
+
+            # Запускаем процесс
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT, # Перенаправляем stderr в stdout
+                text=True,
+                encoding='utf-8', # Указываем кодировку
+                errors='replace', # Заменяем ошибки кодирования
+                bufsize=1 # Построчная буферизация
+            )
+
+            # Читаем и пишем вывод построчно
+            for line in process.stdout:
+                print(line, end="") # Выводим в консоль
+                log_file.write(line) # Пишем в лог
+                log_file.flush()
+
+            # Ждем завершения и получаем код возврата
+            process.wait()
+            return_code = process.returncode
+
+    except Exception as e:
+        print(f"\nОшибка при запуске процесса: {e}")
+        with open(log_path, "a", encoding="utf-8") as log_file:
+            log_file.write(f"\nОшибка при запуске: {e}\n")
+        return_code = 1 # Считаем ошибкой
+
+    end_time = time.time()
+    duration = end_time - start_time
+
+    result_message = f"Успешно завершено за {duration:.2f} сек."
+    if return_code != 0:
+        result_message = f"Завершено с ошибкой (код {return_code}) за {duration:.2f} сек."
+
+    print(f"--- {result_message} ---")
+    with open(log_path, "a", encoding="utf-8") as log_file:
+        log_file.write(f"\nВремя завершения: {datetime.now()}")
+        log_file.write(f"\nДлительность: {duration:.2f} сек.")
+        log_file.write(f"\nКод возврата: {return_code}\n")
+
+    return return_code
+
+def main():
+    """Основная функция скрипта."""
+    args = parse_args()
+
+    # --- Генерируем ID для всей серии запусков ---
+    batch_run_id = f"batch_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    print(f"Запуск серии экспериментов. Batch ID: {batch_run_id}")
+
+    # Создаем директории для логов и промежуточных результатов
+    os.makedirs(args.log_dir, exist_ok=True)
+    os.makedirs(args.intermediate_dir, exist_ok=True)
+
+    # Определяем абсолютный путь к pipeline.py
+    RUN_PIPELINES_SCRIPT_PATH = pathlib.Path(__file__).resolve()
+    SCRIPTS_TESTING_DIR = RUN_PIPELINES_SCRIPT_PATH.parent
+    PIPELINE_SCRIPT_PATH = SCRIPTS_TESTING_DIR / "pipeline.py"
+
+    # --- Определяем параметры для перебора --- 
+    models = [MODELS_TO_TEST[0]] if args.skip_models else MODELS_TO_TEST
+    chunking_configs = [CHUNKING_PARAMS[0]] if args.skip_chunking else CHUNKING_PARAMS
+    top_n_list = [TOP_N_VALUES[0]] if args.skip_top_n else TOP_N_VALUES
+    use_injection_list = [False] if args.skip_injection else USE_INJECTION_OPTIONS
+    threshold_list = [SIMILARITY_THRESHOLDS[0]] if args.skip_thresholds else SIMILARITY_THRESHOLDS
+
+    # Определяем списки для новых измерений
+    process_tables_list = [PROCESS_TABLES_OPTIONS[0]] if args.skip_process_tables else PROCESS_TABLES_OPTIONS
+    include_neighbors_list = [INCLUDE_NEIGHBORS_OPTIONS[0]] if args.skip_include_neighbors else INCLUDE_NEIGHBORS_OPTIONS
+    use_qe_list = [USE_QE_OPTIONS[0]] if args.skip_qe else USE_QE_OPTIONS
+
+    # --- Создаем список всех комбинаций параметров --- 
+    parameter_combinations = list(product(
+        models,
+        chunking_configs,
+        top_n_list,
+        use_injection_list,
+        threshold_list,
+        process_tables_list,
+        include_neighbors_list,
+        use_qe_list
+    ))
+
+    total_runs = len(parameter_combinations)
+    print(f"Всего запланировано запусков: {total_runs}")
+
+    # --- Запускаем пайплайны для каждой комбинации --- 
+    completed_runs = 0
+    failed_runs = 0
+    start_time_all = time.time()
+
+    for i, (model, chunk_cfg, top_n, use_injection, threshold, process_tables, include_neighbors, use_qe) in enumerate(parameter_combinations):
+        print(f"\n{'='*80}")
+        print(f"Запуск {i+1}/{total_runs}")
+        print(f"  Модель: {model}")
+        # Логируем параметры чанкинга
+        strategy = chunk_cfg['strategy']
+        params = chunk_cfg['params']
+        params_str = json.dumps(params, ensure_ascii=False)
+        print(f"  Чанкинг: Стратегия='{strategy}', Параметры={params_str}")
+        print(f"  Обработка таблиц: {process_tables}")
+        print(f"  Top-N: {top_n}")
+        print(f"  Сборка контекста: {use_injection}")
+        print(f"  Query Expansion: {use_qe}")
+        print(f"  Включение соседей: {include_neighbors}")
+        print(f"  Порог схожести: {threshold}")
+        print(f"{'='*80}")
+
+        # Генерируем уникальный ID для этого запуска
+        run_id = f"run_{datetime.now().strftime('%Y%m%d%H%M%S')}_{uuid4().hex[:8]}"
+
+        # Формируем команду для pipeline.py
+        cmd = [
+            args.python_executable,
+            str(PIPELINE_SCRIPT_PATH), # Используем абсолютный путь
+            "--run-id", run_id,
+            "--batch-id", batch_run_id,
+            "--data-folder", args.data_folder,
+            "--search-dataset-path", args.search_dataset_path,
+            "--output-dir", args.intermediate_dir,
+            "--model-name", model,
+            "--chunking-strategy", strategy,
+            "--strategy-params", params_str,
+            "--top-n", str(top_n),
+            "--similarity-threshold", str(threshold),
+            "--device", args.device,
+        ]
+
+        # Добавляем флаг --use-injection, если нужно
+        if use_injection:
+            cmd.append("--use-injection")
+
+        # Добавляем флаг --no-process-tables, если process_tables == False
+        if not process_tables:
+            cmd.append("--no-process-tables")
+
+        # Добавляем флаг --include-neighbors, если include_neighbors == True
+        if include_neighbors:
+            cmd.append("--include-neighbors")
+
+        # Добавляем флаг --use-qe, если use_qe == True
+        if use_qe:
+            cmd.append("--use-qe")
+
+        # Добавляем флаг --use-sentence-transformers для определенных моделей
+        if "FRIDA" in model or "sentence-transformer" in model.lower(): # Пример
+             cmd.append("--use-sentence-transformers")
+
+        # Формируем путь к лог-файлу
+        log_filename = f"{run_id}_log.txt"
+        log_path = os.path.join(args.log_dir, log_filename)
+
+        # Запускаем пайплайн
+        return_code = run_single_pipeline(cmd, log_path)
+
+        if return_code == 0:
+            completed_runs += 1
+        else:
+            failed_runs += 1
+            print(f"*** ВНИМАНИЕ: Запуск {i+1} завершился с ошибкой! Лог: {log_path} ***")
+
+    # --- Вывод итоговой статистики --- 
+    end_time_all = time.time()
+    total_duration = end_time_all - start_time_all
+
+    print(f"\n{'='*80}")
+    print("Все запуски завершены.")
+    print(f"Общее время выполнения: {total_duration:.2f} сек ({total_duration/60:.2f} мин)")
+    print(f"Всего запусков: {total_runs}")
+    print(f"Успешно завершено: {completed_runs}")
+    print(f"Завершено с ошибками: {failed_runs}")
+    print(f"Промежуточные результаты сохранены в: {args.intermediate_dir}")
+    print(f"Логи запусков сохранены в: {args.log_dir}")
+    print(f"{'='*80}")
+
+if __name__ == "__main__":
+    main()