Update app.py

app.py

@@ -2,19 +2,13 @@ import re
 import requests
 import pandas as pd
 import torch
-import gradio as gr
-from tqdm import tqdm
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
-from typing import List, Dict, Any, Tuple, Optional
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 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')
@@ -22,267 +16,192 @@ logger = logging.getLogger("GAIA-Mastermind")
 
 # Конфигурация
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-MODEL_NAME = "google/flan-t5-large"  # Оптимизировано для CPU
+MODEL_NAME = "google/flan-t5-small"  # Используем меньшую модель для быстрой загрузки
 API_RETRIES = 3
-API_TIMEOUT = 45
+API_TIMEOUT = 30
 
-# === ЯДРО СИСТЕМЫ ===
-class GAIAThoughtProcessor:
+# Настройка кэширования моделей
+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
+    
     def __init__(self):
-        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 = 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()
+        # Инициализируем только один раз
+        if not GAIAExpert._is_initialized:
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+            logger.info(f"Инициализация модели на {self.device.upper()}")
             
-            # Создаем пайплайн для генерации текста
-            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)}")
+            # Отложенная инициализация - токенизатор загружаем сразу, модель - по требованию
+            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)}")
 
-    def process_question(self, question: str, task_id: str) -> str:
-        """Упрощенная обработка вопроса"""
+    @lru_cache(maxsize=100)  # Кэширование ответов для повторяющихся вопросов
+    def process_question(self, question: str) -> str:
+        """Обработка вопроса с оптимизацией и кэшированием"""
         try:
-            prompt = f"Реши задачу шаг за шагом: {question}\n\nФинальный ответ:"
+            # Загружаем модель только при первом вызове
+            self._ensure_model_loaded()
             
-            result = self.text_generator(
-                prompt,
-                max_new_tokens=128,
-                num_beams=2,
-                early_stopping=True,
-                temperature=0.1
+            # Оптимизированная обработка токенов
+            inputs = self.tokenizer(
+                f"Вопрос: {question}\nОтвет:",
+                return_tensors="pt",
+                max_length=256,
+                truncation=True,
+                padding="max_length"
             )
             
-            response = result[0]['generated_text'].strip()
+            # Перемещаем тензоры на нужное устройство
+            if self.device == "cuda":
+                inputs = {k: v.to(self.device) for k, v in inputs.items()}
             
-            # Создаем JSON ответ
-            return json.dumps({"final_answer": response})
-                
+            # Оптимизированная генерация
+            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()})
         except Exception as e:
-            logger.error(f"Ошибка обработки вопроса: {str(e)}")
-            return json.dumps({
-                "task_id": task_id,
-                "error": str(e),
-                "final_answer": f"ERROR: {str(e)}"
-            })
+            return json.dumps({"final_answer": f"ERROR: {str(e)}"})
 
-# === СИСТЕМА ОЦЕНКИ ===
-class GAIAEvaluationRunner:
+class GAIAEvaluator:
     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({
-            "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
+        self.session.headers.update({"Content-Type": "application/json"})
+        # Настройка повторных попыток и таймаутов
+        self.session.mount('https://', requests.adapters.HTTPAdapter(max_retries=API_RETRIES))
 
-    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()
+    def run_evaluation(self, username: str, agent_code: str):
+        """Консольный процесс оценки без интерфейса"""
+        # Создаем агента только при необходимости
+        agent = GAIAExpert()
         
-        total_questions = len(questions)
-        if total_questions == 0:
-            return "Получено 0 вопросов", 0, 0, pd.DataFrame()
+        # Получение вопросов с повторными попытками
+        questions = self._fetch_questions_with_retry()
+        if not isinstance(questions, list):
+            logger.error(f"Ошибка получения вопросов: {questions}")
+            return 0, 0
         
         # Обработка вопросов
-        results = []
         answers = []
         
         for i, q in enumerate(questions):
-            progress(i / total_questions, desc=f"Обработка задачи {i+1}/{total_questions}")
+            task_id = q.get("task_id", f"task_{i}")
+            logger.info(f"Обработка задачи {i+1}/{len(questions)}: {q['question'][:50]}...")
+            
             try:
-                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
+                json_response = agent.process_question(q["question"])
+                response_obj = json.loads(json_response)
+                answer = response_obj.get("final_answer", "")
                 
                 answers.append({
                     "task_id": task_id,
-                    "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"
+                    "answer": str(answer)[:300]
                 })
             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"
-                })
         
-        # Отправка ответов
-        progress(0.9, desc="Отправка результатов")
-        submission_result, score = self._submit_answers(username, agent_code, answers)
-        return submission_result, score, total_questions, pd.DataFrame(results)
+        # Отправка ответов с повторными попытками
+        return self._submit_answers_with_retry(username, agent_code, 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
+    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"
 
-# Создание интерфейса
-with gr.Blocks(title="GAIA Mastermind") as demo:
-    gr.Markdown("# GAIA Mastermind")
-    gr.Markdown("Многошаговое решение задач с декомпозицией")
+    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)
+
+if __name__ == "__main__":
+    # Параметры запуска
+    USERNAME = "yoshizen"
+    AGENT_CODE = "https://huggingface.co/spaces/yoshizen/FinalTest"
     
-    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
-            )
+    logger.info(f"Запуск оценки для {USERNAME}")
     
-    # Системная информация
-    def get_system_info():
-        device = "GPU" if torch.cuda.is_available() else "CPU"
-        return f"Device: {device} | Model: {MODEL_NAME} | API: {DEFAULT_API_URL}"
+    start_time = time.time()
+    evaluator = GAIAEvaluator()
+    score, total = evaluator.run_evaluation(USERNAME, AGENT_CODE)
     
-    demo.load(get_system_info, inputs=None, outputs=sys_info)
+    elapsed = time.time() - start_time
+    logger.info(f"Оценка завершена за {elapsed:.1f} сек")
+    logger.info(f"Результат: {score}/{total} правильных ответов")
     
-    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
-    )
+    if total > 0:
+        logger.info(f"Точность: {score/total*100:.1f}%")
+    else:
+        logger.error("Не удалось обработать ни одного вопроса")