Added a web interface for managing models and launching additional training

training/model_manager.py

@@ -106,4 +106,426 @@ class ModelManager:
                     # Обновляем существующую запись
                     self.registry["models"][i] = model_entry
                     self.save_registry()
-                    return True, f"Мод
+                    return True, f"Модель {model_id} версии {version} обновлена в реестре"
+            
+            # Если модель новая, добавляем ее в реестр
+            self.registry["models"].append(model_entry)
+            
+            # Если модель отмечена как активная, деактивируем все другие модели с тем же model_id
+            if is_active:
+                for i, model in enumerate(self.registry["models"]):
+                    if model["model_id"] == model_id and model["version"] != version:
+                        self.registry["models"][i]["is_active"] = False
+            
+            self.save_registry()
+            return True, f"Модель {model_id} версии {version} добавлена в реестр"
+        except Exception as e:
+            return False, f"Ошибка при регистрации модели: {str(e)}"
+    
+    def download_model(
+        self, 
+        model_id: str,
+        version: str,
+        token: Optional[str] = None
+    ) -> Tuple[bool, str]:
+        """
+        Загрузка модели из Hugging Face Hub
+        
+        Args:
+            model_id: Идентификатор модели
+            version: Версия модели
+            token: Токен доступа к Hugging Face Hub
+            
+        Returns:
+            (успех, сообщение)
+        """
+        try:
+            # Находим модель в реестре
+            model_entry = None
+            for model in self.registry["models"]:
+                if model["model_id"] == model_id and model["version"] == version:
+                    model_entry = model
+                    break
+            
+            if model_entry is None:
+                return False, f"Модель {model_id} версии {version} не найдена в реестре"
+            
+            # Проверяем, что источник - это репозиторий Hugging Face
+            if not model_entry["source"].startswith("hf://"):
+                return False, "Источник модели не является репозиторием Hugging Face"
+            
+            # Извлекаем имя репозитория
+            repo_id = model_entry["source"][5:]
+            
+            # Путь для сохранения модели
+            local_path = model_entry["local_path"]
+            
+            # Проверяем, существует ли уже директория с моделью
+            if os.path.exists(local_path):
+                # Если директория существует, проверяем наличие файлов модели
+                if os.path.exists(os.path.join(local_path, "pytorch_model.bin")) or \
+                   os.path.exists(os.path.join(local_path, "adapter_model.bin")):
+                    return True, f"Модель {model_id} версии {version} уже загружена"
+            else:
+                # Создаем директорию для модели
+                os.makedirs(local_path, exist_ok=True)
+            
+            # Загружаем модель
+            logger.info(f"Загрузка модели {repo_id} в {local_path}...")
+            snapshot_download(
+                repo_id=repo_id,
+                local_dir=local_path,
+                token=token
+            )
+            
+            return True, f"Модель {model_id} версии {version} успешно загружена"
+        except Exception as e:
+            return False, f"Ошибка при загрузке модели: {str(e)}"
+    
+    def get_active_model(self, model_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Получение активной версии модели
+        
+        Args:
+            model_id: Идентификатор модели
+            
+        Returns:
+            Словарь с информацией о модели или None, если модель не найдена
+        """
+        for model in self.registry["models"]:
+            if model["model_id"] == model_id and model.get("is_active", False):
+                return model
+        return None
+    
+    def set_active_model(self, model_id: str, version: str) -> Tuple[bool, str]:
+        """
+        Установка активной версии модели
+        
+        Args:
+            model_id: Идентификатор модели
+            version: Версия модели
+            
+        Returns:
+            (успех, сообщение)
+        """
+        try:
+            # Проверяем, есть ли модель в реестре
+            model_found = False
+            for i, model in enumerate(self.registry["models"]):
+                if model["model_id"] == model_id:
+                    if model["version"] == version:
+                        model_found = True
+                        self.registry["models"][i]["is_active"] = True
+                    else:
+                        self.registry["models"][i]["is_active"] = False
+            
+            if not model_found:
+                return False, f"Модель {model_id} версии {version} не найдена в реестре"
+            
+            self.save_registry()
+            return True, f"Модель {model_id} версии {version} установлена как активная"
+        except Exception as e:
+            return False, f"Ошибка при установке активной модели: {str(e)}"
+    
+    def load_model(
+        self, 
+        model_id: str,
+        version: Optional[str] = None,
+        device: str = "cuda" if os.environ.get("CUDA_VISIBLE_DEVICES") else "cpu"
+    ) -> Tuple[bool, Any, Any, str]:
+        """
+        Загрузка модели и токенизатора
+        
+        Args:
+            model_id: Идентификатор модели
+            version: Версия модели (если None, загружается активная версия)
+            device: Устройство для загрузки модели
+            
+        Returns:
+            (успех, модель, токенизатор, сообщение)
+        """
+        try:
+            # Определяем версию модели
+            if version is None:
+                model_entry = self.get_active_model(model_id)
+                if model_entry is None:
+                    return False, None, None, f"Активная версия модели {model_id} не найдена"
+            else:
+                model_entry = None
+                for model in self.registry["models"]:
+                    if model["model_id"] == model_id and model["version"] == version:
+                        model_entry = model
+                        break
+                
+                if model_entry is None:
+                    return False, None, None, f"Модель {model_id} версии {version} не найдена в реестре"
+            
+            # Проверяем, загружена ли модель локально
+            local_path = model_entry["local_path"]
+            if not os.path.exists(local_path) or \
+               (not os.path.exists(os.path.join(local_path, "pytorch_model.bin")) and \
+                not os.path.exists(os.path.join(local_path, "adapter_model.bin"))):
+                # Если модель не загружена, пытаемся загрузить её
+                success, message = self.download_model(model_id, model_entry["version"])
+                if not success:
+                    return False, None, None, message
+            
+            # Загружаем токенизатор
+            logger.info(f"Загрузка токенизатора из {local_path}...")
+            tokenizer = AutoTokenizer.from_pretrained(
+                local_path,
+                trust_remote_code=True
+            )
+            
+            # Загружаем модель
+            logger.info(f"Загрузка модели из {local_path}...")
+            model = AutoModelForCausalLM.from_pretrained(
+                local_path,
+                trust_remote_code=True,
+                device_map="auto" if device == "cuda" else None
+            )
+            
+            return True, model, tokenizer, f"Модель {model_id} версии {model_entry['version']} успешно загружена"
+        except Exception as e:
+            return False, None, None, f"Ошибка при загрузке модели: {str(e)}"
+    
+    def delete_model(self, model_id: str, version: str) -> Tuple[bool, str]:
+        """
+        Удаление модели из реестра и локального хранилища
+        
+        Args:
+            model_id: Идентификатор модели
+            version: Версия модели
+            
+        Returns:
+            (успех, сообщение)
+        """
+        try:
+            # Ищем модель в реестре
+            model_entry = None
+            model_index = -1
+            for i, model in enumerate(self.registry["models"]):
+                if model["model_id"] == model_id and model["version"] == version:
+                    model_entry = model
+                    model_index = i
+                    break
+            
+            if model_entry is None:
+                return False, f"Модель {model_id} версии {version} не найдена в реестре"
+            
+            # Проверяем, активна ли модель
+            if model_entry.get("is_active", False):
+                return False, "Нельзя удалить активную модель. Сначала установите другую модель как активную."
+            
+            # Удаляем директорию с моделью, если она существует
+            local_path = model_entry["local_path"]
+            if os.path.exists(local_path):
+                shutil.rmtree(local_path)
+            
+            # Удаляем модель из реестра
+            self.registry["models"].pop(model_index)
+            self.save_registry()
+            
+            return True, f"Модель {model_id} версии {version} успешно удалена"
+        except Exception as e:
+            return False, f"Ошибка при удалении модели: {str(e)}"
+    
+    def list_models(self, model_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Получение списка моделей в реестре
+        
+        Args:
+            model_id: Идентификатор модели для фильтрации (если None, возвращаются все модели)
+            
+        Returns:
+            Список словарей с информацией о моделях
+        """
+        if model_id is None:
+            return self.registry["models"]
+        else:
+            return [model for model in self.registry["models"] if model["model_id"] == model_id]
+    
+    def import_local_model(
+        self,
+        source_path: str,
+        model_id: str,
+        version: str,
+        description: str = "",
+        is_active: bool = False
+    ) -> Tuple[bool, str]:
+        """
+        Импорт локальной модели в реестр
+        
+        Args:
+            source_path: Путь к директории с моделью
+            model_id: Идентификатор модели
+            version: Версия модели
+            description: Описание модели
+            is_active: Флаг активности модели
+            
+        Returns:
+            (успех, сообщение)
+        """
+        try:
+            # Проверяем существование исходной директории
+            if not os.path.exists(source_path):
+                return False, f"Директория {source_path} не существует"
+            
+            # Проверяем, что это директория с моделью
+            if not os.path.exists(os.path.join(source_path, "config.json")):
+                return False, f"Директория {source_path} не содержит модель трансформера"
+            
+            # Создаем путь для модели в нашем хранилище
+            target_path = os.path.join(self.models_dir, f"{model_id}_{version}")
+            
+            # Если директория уже существует, удаляем ее
+            if os.path.exists(target_path):
+                shutil.rmtree(target_path)
+            
+            # Копируем файлы модели
+            shutil.copytree(source_path, target_path)
+            
+            # Регистрируем модель в реестре
+            success, message = self.register_model(
+                model_id=model_id,
+                version=version,
+                source=f"local://{source_path}",
+                description=description,
+                is_active=is_active
+            )
+            
+            if not success:
+                # Если регистрация не удалась, удаляем скопированные файлы
+                shutil.rmtree(target_path)
+                return False, message
+            
+            return True, f"Модель успешно импортирована: {model_id} версии {version}"
+        except Exception as e:
+            return False, f"Ошибка при импорте модели: {str(e)}"
+    
+    def export_model_metrics(self, output_file: str) -> Tuple[bool, str]:
+        """
+        Экспорт метрик всех моделей в JSON файл
+        
+        Args:
+            output_file: Путь к выходному файлу
+            
+        Returns:
+            (успех, сообщение)
+        """
+        try:
+            # Создаем словарь с метриками для каждой модели
+            metrics_data = {}
+            
+            for model in self.registry["models"]:
+                model_key = f"{model['model_id']}_{model['version']}"
+                metrics_data[model_key] = {
+                    "model_id": model["model_id"],
+                    "version": model["version"],
+                    "is_active": model.get("is_active", False),
+                    "registration_date": model.get("registration_date", ""),
+                    "metrics": model.get("metrics", {})
+                }
+            
+            # Сохраняем в файл
+            with open(output_file, "w", encoding="utf-8") as f:
+                json.dump(metrics_data, f, ensure_ascii=False, indent=2)
+            
+            return True, f"Метрики моделей успешно экспортированы в {output_file}"
+        except Exception as e:
+            return False, f"Ошибка при экспорте метрик: {str(e)}"
+    
+    def update_model_metrics(
+        self,
+        model_id: str,
+        version: str,
+        metrics: Dict[str, Any]
+    ) -> Tuple[bool, str]:
+        """
+        Обновление метрик модели
+        
+        Args:
+            model_id: Идентификатор модели
+            version: Версия модели
+            metrics: Словарь с метриками
+            
+        Returns:
+            (успех, сообщение)
+        """
+        try:
+            # Ищем модель в реестре
+            model_found = False
+            for i, model in enumerate(self.registry["models"]):
+                if model["model_id"] == model_id and model["version"] == version:
+                    # Обновляем метрики
+                    self.registry["models"][i]["metrics"] = metrics
+                    model_found = True
+                    break
+            
+            if not model_found:
+                return False, f"Модель {model_id} версии {version} не найдена в реестре"
+            
+            self.save_registry()
+            return True, f"Метрики модели {model_id} версии {version} успешно обновлены"
+        except Exception as e:
+            return False, f"Ошибка при обновлении метрик: {str(e)}"
+
+def get_model(
+    model_id: str = "saiga",
+    version: Optional[str] = None,
+    device: str = "cuda" if os.environ.get("CUDA_VISIBLE_DEVICES") else "cpu"
+) -> Tuple[Any, Any, Dict[str, Any]]:
+    """
+    Удобная функция для получения модели и токенизатора
+    
+    Args:
+        model_id: Идентификатор модели
+        version: Версия модели (если None, загружается активная версия)
+        device: Устройство для загрузки модели
+        
+    Returns:
+        (модель, токенизатор, информация о модели)
+    """
+    manager = ModelManager()
+    success, model, tokenizer, message = manager.load_model(
+        model_id=model_id,
+        version=version,
+        device=device
+    )
+    
+    if not success:
+        logger.error(message)
+        raise ValueError(message)
+    
+    # Получаем информацию о загруженной модели
+    if version is None:
+        model_info = manager.get_active_model(model_id)
+    else:
+        for m in manager.list_models(model_id):
+            if m["version"] == version:
+                model_info = m
+                break
+        else:
+            model_info = {}
+    
+    return model, tokenizer, model_info
+
+if __name__ == "__main__":
+    # Пример использования
+    manager = ModelManager()
+    
+    # Регистрация базовой модели
+    success, message = manager.register_model(
+        model_id="saiga",
+        version="7b",
+        source="hf://IlyaGusev/saiga_7b_lora",
+        description="Базовая модель Saiga 7B с LoRA адаптерами",
+        is_active=True
+    )
+    print(message)
+    
+    # Вывод списка моделей
+    models = manager.list_models()
+    print(f"В реестре {len(models)} моделей:")
+    for model in models:
+        print(f" - {model['model_id']} v{model['version']}: {model['description']}")

web/training_interface.py

@@ -0,0 +1,223 @@
+"""
+Веб-интерфейс для управления моделями и запуска дообучения
+"""
+
+import os
+import json
+import gradio as gr
+import pandas as pd
+from datetime import datetime
+from typing import List, Dict, Any, Tuple, Optional
+
+from src.analytics.chat_analyzer import ChatAnalyzer
+from src.training.fine_tuner import FineTuner, finetune_from_chat_history
+from src.training.model_manager import ModelManager
+from config.settings import MODEL_PATH, TRAINING_OUTPUT_DIR
+
+# Инициализация менеджеров
+model_manager = ModelManager()
+chat_analyzer = ChatAnalyzer()
+
+def get_models_df():
+    """
+    Получение датафрейма с моделями из реестра
+    
+    Returns:
+        pandas.DataFrame: Датафрейм с моделями
+    """
+    models = model_manager.list_models()
+    
+    if not models:
+        return pd.DataFrame(columns=["model_id", "version", "description", "is_active", "registration_date"])
+    
+    # Создаем датафрейм
+    df = pd.DataFrame(models)
+    
+    # Выбираем нужные колонки
+    columns = ["model_id", "version", "description", "is_active", "registration_date"]
+    df = df[columns]
+    
+    # Сортируем по model_id и registration_date
+    df = df.sort_values(by=["model_id", "registration_date"], ascending=[True, False])
+    
+    return df
+
+def generate_chat_analysis():
+    """
+    Генерация аналитического отчета по истории чатов
+    
+    Returns:
+        str: HTML-отчет
+    """
+    report = chat_analyzer.generate_analytics_report()
+    
+    if not report or report.get("total_conversations", 0) == 0:
+        return "### Нет данных для анализа\nИстория чатов пуста или не может быть загружена."
+    
+    # Формируем HTML-отчет
+    html = f"""
+    ### Аналитический отчет по истории чатов
+    
+    #### Основные метрики
+    - **Всего диалогов:** {report['total_conversations']}
+    - **Пар вопрос-ответ для обучения:** {report['qa_pairs_count']}
+    - **Вопросы без ответов:** {report['failed_questions_count']}
+    
+    #### Метрики удовлетворенности
+    - **Среднее число сообщений в диалоге:** {report['satisfaction_metrics']['avg_messages_per_conversation']:.2f}
+    - **Процент диалогов с дополнительными вопросами:** {report['satisfaction_metrics']['follow_up_questions_rate']:.2f}%
+    """
+    
+    # Популярные вопросы
+    if report.get('common_questions'):
+        html += "\n\n#### Популярные вопросы\n"
+        for i, (question, count) in enumerate(report['common_questions'][:10], 1):
+            html += f"{i}. \"{question}\" ({count} раз)\n"
+    
+    # Вопросы без ответов
+    if report.get('failed_questions'):
+        html += "\n\n#### Примеры вопросов без ответов\n"
+        for i, question in enumerate(report['failed_questions'][:5], 1):
+            html += f"{i}. \"{question}\"\n"
+    
+    return html
+
+def register_model_action(model_id, version, source, description, set_active):
+    """
+    Действие регистрации модели
+    
+    Args:
+        model_id: Идентификатор модели
+        version: Версия модели
+        source: Источник модели
+        description: Описание модели
+        set_active: Установить как активную
+        
+    Returns:
+        str: Результат операции
+    """
+    # Проверка входных данных
+    if not model_id or not version or not source:
+        return "Ошибка: все поля обязательны для заполнения"
+    
+    # Регистрация модели
+    success, message = model_manager.register_model(
+        model_id=model_id,
+        version=version,
+        source=source,
+        description=description,
+        is_active=set_active
+    )
+    
+    if not success:
+        return f"Ошибка: {message}"
+    
+    # Если установлена опция загрузки модели, загружаем её
+    if source.startswith("hf://"):
+        success, download_message = model_manager.download_model(model_id, version)
+        if not success:
+            return f"Модель зарегистрирована, но не загружена: {download_message}"
+        message += f"\n{download_message}"
+    
+    return message
+
+def import_local_model_action(source_path, model_id, version, description, set_active):
+    """
+    Действие импорта локальной модели
+    
+    Args:
+        source_path: Путь к директории с моделью
+        model_id: Идентификатор модели
+        version: Версия модели
+        description: Описание модели
+        set_active: Установить как активную
+        
+    Returns:
+        str: Результат операции
+    """
+    # Проверка входных данных
+    if not source_path or not model_id or not version:
+        return "Ошибка: все поля обязательны для заполнения"
+    
+    # Проверка существования директории
+    if not os.path.exists(source_path):
+        return f"Ошибка: директория {source_path} не существует"
+    
+    # Импорт модели
+    success, message = model_manager.import_local_model(
+        source_path=source_path,
+        model_id=model_id,
+        version=version,
+        description=description,
+        is_active=set_active
+    )
+    
+    return message
+
+def set_active_model_action(model_row_index, models_df):
+    """
+    Действие установки активной модели
+    
+    Args:
+        model_row_index: Индекс строки модели в датафрейме
+        models_df: Датафрейм с моделями
+        
+    Returns:
+        str: Результат операции
+    """
+    try:
+        # Получаем информацию о выбранной модели
+        model_row = models_df.iloc[model_row_index]
+        model_id = model_row["model_id"]
+        version = model_row["version"]
+        
+        # Устанавливаем как активную
+        success, message = model_manager.set_active_model(model_id, version)
+        
+        return message
+    except Exception as e:
+        return f"Ошибка: {str(e)}"
+
+def delete_model_action(model_row_index, models_df):
+    """
+    Действие удаления модели
+    
+    Args:
+        model_row_index: Индекс строки модели в датафрейме
+        models_df: Датафрейм с моделями
+        
+    Returns:
+        str: Результат операции
+    """
+    try:
+        # Получаем информацию о выбранной модели
+        model_row = models_df.iloc[model_row_index]
+        model_id = model_row["model_id"]
+        version = model_row["version"]
+        
+        # Удаляем модель
+        success, message = model_manager.delete_model(model_id, version)
+        
+        return message
+    except Exception as e:
+        return f"Ошибка: {str(e)}"
+
+def start_finetune_action(
+    epochs, 
+    batch_size, 
+    learning_rate, 
+    base_model_id,
+    new_model_id,
+    new_version,
+    description,
+    set_active
+):
+    """
+    Действие запуска дообучения модели
+    
+    Args:
+        epochs: Количество эпох обучения
+        batch_size: Размер батча
+        learning_rate: Скорость обучения
+        base_model_id: Ид
+        """