Update app.py

app.py

@@ -2,13 +2,19 @@ import re
 import requests
 import pandas as pd
 import torch
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+import gradio as gr
+from tqdm import tqdm
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
+from typing import List, Dict, Any, Tuple, Optional
 import json
+import ast
+import numpy as np
+from PIL import Image, UnidentifiedImageError
+import io
+import base64
 import logging
 import time
 import sys
-import os
-from functools import lru_cache
 
 # Настройка логирования
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -16,192 +22,267 @@ logger = logging.getLogger("GAIA-Mastermind")
 
 # Конфигурация
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-MODEL_NAME = "google/flan-t5-base"  # Используем меньшую модель для быстрой загрузки
+MODEL_NAME = "google/flan-t5-large"  # Оптимизировано для CPU
 API_RETRIES = 3
-API_TIMEOUT = 30
+API_TIMEOUT = 45
 
-# Настройка кэширования моделей
-os.environ["TRANSFORMERS_CACHE"] = "/tmp/transformers_cache"
-os.environ["HF_HOME"] = "/tmp/hf_home"
-
-class GAIAExpert:
-    _instance = None
-    _is_initialized = False
-    
-    def __new__(cls):
-        # Паттерн Singleton для предотвращения повторной загрузки модели
-        if cls._instance is None:
-            cls._instance = super(GAIAExpert, cls).__new__(cls)
-        return cls._instance
-    
+# === ЯДРО СИСТЕМЫ ===
+class GAIAThoughtProcessor:
     def __init__(self):
-        # Инициализируем только один раз
-        if not GAIAExpert._is_initialized:
-            self.device = "cuda" if torch.cuda.is_available() else "cpu"
-            logger.info(f"Инициализация модели на {self.device.upper()}")
-            
-            # Отложенная инициализация - токенизатор загружаем сразу, модель - по требованию
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info(f"⚡ Инициализация GAIAThoughtProcessor на {self.device.upper()}")
+        
+        try:
+            # Оптимизированная загрузка модели для CPU
             self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-            self.model = None
-            GAIAExpert._is_initialized = True
-    
-    def _ensure_model_loaded(self):
-        """Ленивая загрузка модели только при необходимости"""
-        if self.model is None:
-            try:
-                logger.info("Загрузка модели...")
-                # Оптимизированная загрузка модели
-                self.model = AutoModelForSeq2SeqLM.from_pretrained(
-                    MODEL_NAME,
-                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
-                    low_cpu_mem_usage=True,
-                    device_map="auto"  # Автоматическое распределение на доступные устройства
-                ).eval()
-                logger.info("Модель успешно загружена")
-            except Exception as e:
-                logger.exception("Ошибка загрузки модели")
-                raise RuntimeError(f"Ошибка инициализации: {str(e)}")
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(
+                MODEL_NAME,
+                device_map="auto" if torch.cuda.is_available() else None,
+                torch_dtype=torch.float32,
+                low_cpu_mem_usage=True
+            ).eval()
+            
+            # Создаем пайплайн для генерации текста
+            self.text_generator = pipeline(
+                "text2text-generation",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=-1 if self.device == "cpu" else 0,
+                max_new_tokens=128
+            )
+            
+            logger.info("✅ GAIAThoughtProcessor готов")
+        except Exception as e:
+            logger.exception("Ошибка инициализации модели")
+            raise RuntimeError(f"Ошибка инициализации: {str(e)}")
 
-    @lru_cache(maxsize=100)  # Кэширование ответов для повторяющихся вопросов
-    def process_question(self, question: str) -> str:
-        """Обработка вопроса с оптимизацией и кэшированием"""
+    def process_question(self, question: str, task_id: str) -> str:
+        """Упрощенная обработка вопроса"""
         try:
-            # Загружаем модель только при первом вызове
-            self._ensure_model_loaded()
+            prompt = f"Реши задачу шаг за шагом: {question}\n\nФинальный ответ:"
             
-            # Оптимизированная обработка токенов
-            inputs = self.tokenizer(
-                f"Вопрос: {question}\nОтвет:",
-                return_tensors="pt",
-                max_length=256,
-                truncation=True,
-                padding="max_length"
+            result = self.text_generator(
+                prompt,
+                max_new_tokens=128,
+                num_beams=2,
+                early_stopping=True,
+                temperature=0.1
             )
             
-            # Перемещаем тензоры на нужное устройство
-            if self.device == "cuda":
-                inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            response = result[0]['generated_text'].strip()
             
-            # Оптимизированная генерация
-            with torch.no_grad():  # Отключаем вычисление градиентов для экономии памяти
-                outputs = self.model.generate(
-                    **inputs,
-                    max_new_tokens=50,
-                    num_beams=1,  # Ускорение генерации
-                    early_stopping=True,
-                    do_sample=False  # Детерминированная генерация для скорости
-                )
-            
-            answer = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-            return json.dumps({"final_answer": answer.strip()})
+            # Создаем JSON ответ
+            return json.dumps({"final_answer": response})
+                
         except Exception as e:
-            return json.dumps({"final_answer": f"ERROR: {str(e)}"})
+            logger.error(f"Ошибка обработки вопроса: {str(e)}")
+            return json.dumps({
+                "task_id": task_id,
+                "error": str(e),
+                "final_answer": f"ERROR: {str(e)}"
+            })
 
-class GAIAEvaluator:
+# === СИСТЕМА ОЦЕНКИ ===
+class GAIAEvaluationRunner:
     def __init__(self, api_url: str = DEFAULT_API_URL):
         self.api_url = api_url
         self.questions_url = f"{api_url}/questions"
         self.submit_url = f"{api_url}/submit"
         self.session = requests.Session()
-        self.session.headers.update({"Content-Type": "application/json"})
-        # Настройка повторных попыток и таймаутов
-        self.session.mount('https://', requests.adapters.HTTPAdapter(max_retries=API_RETRIES))
+        self.session.headers.update({
+            "Accept": "application/json",
+            "User-Agent": "GAIA-Mastermind/1.0",
+            "Content-Type": "application/json"
+        })
+        logger.info(f"🌐 Инициализирован GAIAEvaluationRunner для {api_url}")
+
+    def _fetch_questions(self) -> Tuple[list, str]:
+        """Получение вопросов с API"""
+        logger.info(f"🔍 Запрос вопросов с {self.questions_url}")
+        try:
+            response = self.session.get(
+                self.questions_url,
+                timeout=API_TIMEOUT
+            )
+            
+            logger.info(f"Статус ответа: {response.status_code}")
+            
+            if response.status_code == 200:
+                questions = response.json()
+                logger.info(f"Получено {len(questions)} вопросов")
+                return questions, "success"
+            else:
+                error_msg = f"Ошибка API: HTTP {response.status_code}"
+                logger.error(error_msg)
+                return [], error_msg
+                    
+        except Exception as e:
+            error_msg = f"Ошибка соединения: {str(e)}"
+            logger.exception(error_msg)
+            return [], error_msg
+
+    def _submit_answers(self, username: str, agent_code: str, answers: list) -> Tuple[str, int]:
+        """Отправка ответов на сервер"""
+        logger.info(f"📤 Отправка ответов для пользователя {username}")
+        try:
+            payload = {
+                "username": username.strip(),
+                "agent_code": agent_code.strip(),
+                "answers": answers
+            }
+            
+            response = self.session.post(
+                self.submit_url,
+                json=payload,
+                timeout=API_TIMEOUT * 2
+            )
+            
+            logger.info(f"Статус отправки: {response.status_code}")
+            
+            if response.status_code == 200:
+                result = response.json()
+                score = result.get("score", 0)
+                return result.get("message", "Ответы успешно отправлены"), score
+            else:
+                error = f"HTTP Ошибка {response.status_code}"
+                if response.text:
+                    error += f": {response.text[:200]}"
+                logger.error(error)
+                return error, 0
+                    
+        except Exception as e:
+            error = f"Ошибка отправки: {str(e)}"
+            logger.exception(error)
+            return error, 0
 
-    def run_evaluation(self, username: str, agent_code: str):
-        """Консольный процесс оценки без интерфейса"""
-        # Создаем агента только при необходимости
-        agent = GAIAExpert()
+    def run_evaluation(self, agent, username: str, agent_code: str, progress=gr.Progress()):
+        """Основной процесс оценки"""
+        # Получение вопросов
+        progress(0.1, desc="Получение вопросов")
+        questions, status = self._fetch_questions()
+        if status != "success":
+            return status, 0, 0, pd.DataFrame()
         
-        # Получение вопросов с повторными попытками
-        questions = self._fetch_questions_with_retry()
-        if not isinstance(questions, list):
-            logger.error(f"Ошибка получения вопросов: {questions}")
-            return 0, 0
+        total_questions = len(questions)
+        if total_questions == 0:
+            return "Получено 0 вопросов", 0, 0, pd.DataFrame()
         
         # Обработка вопросов
+        results = []
         answers = []
         
         for i, q in enumerate(questions):
-            task_id = q.get("task_id", f"task_{i}")
-            logger.info(f"Обработка задачи {i+1}/{len(questions)}: {q['question'][:50]}...")
-            
+            progress(i / total_questions, desc=f"Обработка задачи {i+1}/{total_questions}")
             try:
-                json_response = agent.process_question(q["question"])
-                response_obj = json.loads(json_response)
-                answer = response_obj.get("final_answer", "")
+                task_id = q.get("task_id", f"task_{i}")
+                logger.info(f"🔧 Обработка задачи {task_id}")
+                
+                json_response = agent.process_question(q["question"], task_id)
+                
+                # Парсинг ответа
+                try:
+                    response_obj = json.loads(json_response)
+                    final_answer = response_obj.get("final_answer", "")
+                except:
+                    final_answer = json_response
                 
                 answers.append({
                     "task_id": task_id,
-                    "answer": str(answer)[:300]
+                    "answer": str(final_answer)[:500]
+                })
+                
+                results.append({
+                    "Task ID": task_id,
+                    "Question": q["question"][:50] + "..." if len(q["question"]) > 50 else q["question"],
+                    "Answer": str(final_answer)[:50] + "..." if len(str(final_answer)) > 50 else str(final_answer),
+                    "Status": "Processed"
                 })
             except Exception as e:
-                logger.error(f"Ошибка обработки: {str(e)}")
+                logger.error(f"Ошибка обработки задачи: {str(e)}")
                 answers.append({
                     "task_id": task_id,
                     "answer": f"ERROR: {str(e)}"
                 })
+                results.append({
+                    "Task ID": task_id,
+                    "Question": "Error",
+                    "Answer": f"ERROR: {str(e)}",
+                    "Status": "Failed"
+                })
         
-        # Отправка ответов с повторными попытками
-        return self._submit_answers_with_retry(username, agent_code, answers)
-
-    def _fetch_questions_with_retry(self, max_retries=3):
-        """Получение вопросов с API с повторными попытками"""
-        for attempt in range(max_retries):
-            try:
-                response = self.session.get(self.questions_url, timeout=API_TIMEOUT)
-                if response.status_code == 200:
-                    return response.json()
-                logger.warning(f"HTTP error {response.status_code}, попытка {attempt+1}/{max_retries}")
-                time.sleep(2 ** attempt)  # Экспоненциальная задержка между попытками
-            except Exception as e:
-                logger.warning(f"Connection error: {str(e)}, попытка {attempt+1}/{max_retries}")
-                time.sleep(2 ** attempt)
-        return f"Failed after {max_retries} attempts"
+        # Отправка ответов
+        progress(0.9, desc="Отправка результатов")
+        submission_result, score = self._submit_answers(username, agent_code, answers)
+        return submission_result, score, total_questions, pd.DataFrame(results)
 
-    def _submit_answers_with_retry(self, username: str, agent_code: str, answers: list, max_retries=3):
-        """Отправка ответов на сервер с повторными попытками"""
-        for attempt in range(max_retries):
-            try:
-                payload = {
-                    "username": username.strip(),
-                    "agent_code": agent_code.strip(),
-                    "answers": answers
-                }
-                
-                response = self.session.post(
-                    self.submit_url,
-                    json=payload,
-                    timeout=API_TIMEOUT * 2
-                )
-                
-                if response.status_code == 200:
-                    result = response.json()
-                    score = result.get("score", 0)
-                    return score, len(answers)
-                
-                logger.warning(f"HTTP error {response.status_code}, попытка {attempt+1}/{max_retries}")
-                time.sleep(2 ** attempt)
-            except Exception as e:
-                logger.error(f"Ошибка отправки: {str(e)}, попытка {attempt+1}/{max_retries}")
-                time.sleep(2 ** attempt)
-        return 0, len(answers)
+# === ИНТЕРФЕЙС GRADIO ===
+def run_evaluation(username: str, agent_code: str, progress=gr.Progress()):
+    try:
+        progress(0, desc="Инициализация агента")
+        agent = GAIAThoughtProcessor()
+        
+        progress(0.1, desc="Подключение к API")
+        runner = GAIAEvaluationRunner()
+        
+        # Запуск оценки
+        return runner.run_evaluation(agent, username, agent_code, progress)
+    
+    except Exception as e:
+        logger.exception("Критическая ошибка в run_evaluation")
+        error_df = pd.DataFrame([{
+            "Task ID": "ERROR",
+            "Question": f"Критическая ошибка: {str(e)}",
+            "Answer": "См. логи",
+            "Status": "Failed"
+        }])
+        return f"Ошибка: {str(e)}", 0, 0, error_df
 
-if __name__ == "__main__":
-    # Параметры запуска
-    USERNAME = "yoshizen"
-    AGENT_CODE = "https://huggingface.co/spaces/yoshizen/FinalTest"
+# Создание интерфейса
+with gr.Blocks(title="GAIA Mastermind") as demo:
+    gr.Markdown("# GAIA Mastermind")
+    gr.Markdown("Многошаговое решение задач с декомпозицией")
     
-    logger.info(f"Запуск оценки для {USERNAME}")
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("## 🔐 Авторизация")
+            username = gr.Textbox(label="HF Username", value="yoshizen")
+            agent_code = gr.Textbox(label="Agent Code", value="https://huggingface.co/spaces/yoshizen/FinalTest")
+            run_btn = gr.Button("Запустить оценку")
+            
+            gr.Markdown("## ⚙️ Статус системы")
+            sys_info = gr.Textbox(label="Системная информация", interactive=False)
+            
+        with gr.Column():
+            gr.Markdown("## 📊 Результаты GAIA")
+            with gr.Row():
+                result_output = gr.Textbox(label="Статус отправки", interactive=False)
+                correct_output = gr.Number(label="Правильные ответы", interactive=False)
+                total_output = gr.Number(label="Всего вопросов", interactive=False)
+            
+            results_table = gr.Dataframe(
+                label="Детализация ответов",
+                headers=["Task ID", "Question", "Answer", "Status"],
+                interactive=False
+            )
     
-    start_time = time.time()
-    evaluator = GAIAEvaluator()
-    score, total = evaluator.run_evaluation(USERNAME, AGENT_CODE)
+    # Системная информация
+    def get_system_info():
+        device = "GPU" if torch.cuda.is_available() else "CPU"
+        return f"Device: {device} | Model: {MODEL_NAME} | API: {DEFAULT_API_URL}"
     
-    elapsed = time.time() - start_time
-    logger.info(f"Оценка завершена за {elapsed:.1f} сек")
-    logger.info(f"Результат: {score}/{total} правильных ответов")
+    demo.load(get_system_info, inputs=None, outputs=sys_info)
     
-    if total > 0:
-        logger.info(f"Точность: {score/total*100:.1f}%")
-    else:
-        logger.error("Не удалось обработать ни одного вопроса")
+    run_btn.click(
+        fn=run_evaluation,
+        inputs=[username, agent_code],
+        outputs=[result_output, correct_output, total_output, results_table],
+        concurrency_limit=1
+    )
+
+if __name__ == "__main__":
+    demo.queue(max_size=1).launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )