Update app.py

app.py

@@ -4,11 +4,7 @@ import pandas as pd
 import torch
 import gradio as gr
 from tqdm import tqdm
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-from llama_index.core import Settings
-from llama_index.core.tools import FunctionTool
-from llama_index.core.agent import ReActAgent
-from llama_index.llms.huggingface import HuggingFaceLLM
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
 from typing import List, Dict, Any, Tuple, Optional
 import json
 import ast
@@ -18,6 +14,7 @@ import io
 import base64
 import logging
 import time
+import sys
 
 # Настройка логирования
 logging.basicConfig(level=logging.INFO)
@@ -29,64 +26,38 @@ MODEL_NAME = "google/flan-t5-xxl"
 API_RETRIES = 3
 API_TIMEOUT = 45
 
-# === ИСПРАВЛЕННОЕ ЯДРО СИСТЕМЫ ===
+# === ЯДРО СИСТЕМЫ (без зависимостей от llama_index) ===
 class GAIAThoughtProcessor:
     def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info(f"⚡ Инициализация GAIAThoughtProcessor на {self.device.upper()}")
+        
         # Оптимизированная загрузка модели
-        self.llm = HuggingFaceLLM(
-            model_name=MODEL_NAME,
-            tokenizer_name=MODEL_NAME,
-            context_window=2048,
-            max_new_tokens=512,
+        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        self.model = AutoModelForSeq2SeqLM.from_pretrained(
+            MODEL_NAME,
             device_map="auto",
-            model_kwargs={
-                "torch_dtype": torch.float16,
-                "load_in_4bit": True,
-                "device_map": "auto"
-            },
-            generate_kwargs={"temperature": 0.01, "do_sample": False}
-        )
-        self.tools = self._create_gaia_tools()
-        self.agent = ReActAgent.from_tools(
-            self.tools, 
-            llm=self.llm, 
-            verbose=True,
-            max_iterations=10,
-            react_mode="plan_and_solve"
+            torch_dtype=torch.float16 if "cuda" in self.device else torch.float32,
+            low_cpu_mem_usage=True
+        ).eval()
+        
+        # Создаем пайплайн для генерации текста
+        self.text_generator = pipeline(
+            "text2text-generation",
+            model=self.model,
+            tokenizer=self.tokenizer,
+            device=self.device,
+            max_new_tokens=512
         )
-        logger.info("⚙️ Инициализирован GAIAThoughtProcessor с %d инструментами", len(self.tools))
-
-    def _create_gaia_tools(self) -> List[FunctionTool]:
-        """Создает инструменты, соответствующие спецификации GAIA"""
-        return [
-            FunctionTool.from_defaults(
-                fn=self._math_solver,
-                name="math_solver",
-                description="Вычисляет математические выражения. Ввод: строка с выражением (например, '2+2*3')"
-            ),
-            FunctionTool.from_defaults(
-                fn=self._table_analyzer,
-                name="table_analyzer",
-                description="Анализирует табличные данные. Ввод: (table_data:str, query:str)"
-            ),
-            FunctionTool.from_defaults(
-                fn=self._text_processor,
-                name="text_processor",
-                description="Операции с текстом: reverse, count_words, extract_numbers. Ввод: (text:str, operation:str)"
-            ),
-            FunctionTool.from_defaults(
-                fn=self._image_processor,
-                name="image_processor",
-                description="Анализирует изображения. Ввод: base64 изображения или URL"
-            )
-        ]
+        
+        logger.info("✅ GAIAThoughtProcessor готов")
 
     def _math_solver(self, expression: str) -> str:
         """Безопасное вычисление математических выражений"""
         try:
             # Очистка выражения
             clean_expr = re.sub(r"[^0-9+\-*/().^√π]", "", expression)
-            # Поддержка математических констант и функций
+            # Поддержка математических функций
             context = {
                 "sqrt": np.sqrt,
                 "log": np.log,
@@ -99,13 +70,13 @@ class GAIAThoughtProcessor:
             }
             return str(eval(clean_expr, {"__builtins__": None}, context))
         except Exception as e:
-            logger.error("Math error: %s", e)
+            logger.error(f"Math error: {e}")
             return f"Math Error: {str(e)}"
 
     def _table_analyzer(self, table_data: str, query: str) -> str:
-        """Анализ табличных данных с поддержкой сложных запросов"""
+        """Анализ табличных данных"""
         try:
-            # Определение формата таблицы
+            # Автоопределение формата таблицы
             if "\t" in table_data:
                 df = pd.read_csv(io.StringIO(table_data), sep="\t")
             elif "," in table_data:
@@ -113,30 +84,26 @@ class GAIAThoughtProcessor:
             else:
                 df = pd.read_fwf(io.StringIO(table_data))
             
-            # Выполнение pandas-запроса
-            if "sum" in query.lower():
+            # Выполнение запросов
+            query = query.lower()
+            if "sum" in query:
                 return str(df.sum(numeric_only=True).to_dict())
-            elif "mean" in query.lower():
+            elif "mean" in query:
                 return str(df.mean(numeric_only=True).to_dict())
-            elif "max" in query.lower():
+            elif "max" in query:
                 return str(df.max(numeric_only=True).to_dict())
-            elif "min" in query.lower():
+            elif "min" in query:
                 return str(df.min(numeric_only=True).to_dict())
-            elif "count" in query.lower():
+            elif "count" in query:
                 return str(df.count().to_dict())
             else:
-                # Обработка пользовательских запросов
-                try:
-                    result = df.query(query)
-                    return result.to_string()
-                except:
-                    return df.describe().to_string()
+                return df.describe().to_string()
         except Exception as e:
-            logger.error("Table error: %s", e)
+            logger.error(f"Table error: {e}")
             return f"Table Error: {str(e)}"
 
     def _text_processor(self, text: str, operation: str) -> str:
-        """Операции с текстом с поддержкой GAIA спецификации"""
+        """Операции с текстом"""
         operation = operation.lower()
         if operation == "reverse":
             return text[::-1]
@@ -152,7 +119,7 @@ class GAIAThoughtProcessor:
             return f"Unsupported operation: {operation}"
 
     def _image_processor(self, image_input: str) -> str:
-        """Обработка изображений с поддержкой URL и base64"""
+        """Обработка изображений"""
         try:
             # Обработка URL
             if image_input.startswith("http"):
@@ -168,58 +135,107 @@ class GAIAThoughtProcessor:
             else:
                 return "Invalid image format"
             
-            # Анализ изображения
+            # Базовый анализ изображения
             description = (
                 f"Format: {img.format}, Size: {img.size}, "
                 f"Mode: {img.mode}, Colors: {len(set(img.getdata()))}"
             )
             return description
         except (UnidentifiedImageError, requests.exceptions.RequestException) as e:
-            logger.error("Image processing error: %s", e)
+            logger.error(f"Image processing error: {e}")
             return f"Image Error: {str(e)}"
         except Exception as e:
             logger.exception("Unexpected image error")
             return f"Unexpected Error: {str(e)}"
 
+    def _call_tool(self, tool_name: str, arguments: str) -> str:
+        """Вызов инструмента по имени"""
+        try:
+            # Парсинг аргументов
+            args = [a.strip() for a in arguments.split(",")]
+            
+            if tool_name == "math_solver":
+                return self._math_solver(args[0])
+            elif tool_name == "table_analyzer":
+                return self._table_analyzer(args[0], args[1])
+            elif tool_name == "text_processor":
+                return self._text_processor(args[0], args[1])
+            elif tool_name == "image_processor":
+                return self._image_processor(args[0])
+            else:
+                return f"Unknown tool: {tool_name}"
+        except Exception as e:
+            return f"Tool Error: {str(e)}"
+
+    def _generate_response(self, prompt: str) -> str:
+        """Генерация ответа с помощью модели"""
+        try:
+            result = self.text_generator(
+                prompt,
+                max_new_tokens=256,
+                num_beams=3,
+                early_stopping=True,
+                temperature=0.01
+            )
+            return result[0]['generated_text']
+        except Exception as e:
+            logger.error(f"Generation error: {e}")
+            return f"Generation Error: {str(e)}"
+        finally:
+            # Очистка памяти GPU
+            if "cuda" in self.device:
+                torch.cuda.empty_cache()
+
     def process_question(self, question: str, task_id: str) -> str:
-        """Обработка вопроса с учетом спецификации GAIA"""
+        """Обработка вопроса с декомпозицией на шаги"""
         try:
-            # Декомпозиция задачи
+            # Шаг 1: Декомпозиция задачи
             decomposition_prompt = (
-                f"Декомпозируй задачу GAIA ({task_id}) на шаги:\n{question}\n\n"
-                "Шаги (разделены точкой с запятой):"
+                f"Декомпозируй задачу GAIA ({task_id}) на шаги. "
+                f"Используй инструменты: math_solver, table_analyzer, text_processor, image_processor.\n\n"
+                f"Задача: {question}\n\n"
+                "Шаги (формат: [tool_name] arguments):"
             )
-            steps_response = self.llm.complete(decomposition_prompt)
-            steps = [s.strip() for s in steps_response.text.split(";") if s.strip()]
             
-            # Выполнение шагов
+            steps_response = self._generate_response(decomposition_prompt)
+            steps = [s.strip() for s in steps_response.split("\n") if s.strip()]
+            
+            # Шаг 2: Выполнение шагов
             results = []
             for step in steps:
                 if step:
                     try:
-                        result = self.agent.chat(step)
-                        results.append(f"{step}: {result}")
+                        # Извлечение инструмента и аргументов
+                        match = re.match(r"\[(\w+)\]\s*(.+)", step)
+                        if match:
+                            tool_name = match.group(1)
+                            arguments = match.group(2)
+                            result = self._call_tool(tool_name, arguments)
+                            results.append(f"{step} -> {result}")
+                        else:
+                            results.append(f"{step} -> ERROR: Invalid format")
                     except Exception as e:
-                        results.append(f"{step}: ERROR - {str(e)}")
+                        results.append(f"{step} -> ERROR: {str(e)}")
             
-            # Синтез финального ответа
+            # Шаг 3: Синтез финального ответа
             synthesis_prompt = (
                 f"Задача GAIA {task_id}:\n{question}\n\n"
                 "Выполненные шаги:\n" + "\n".join(results) + 
-                "\n\nФинальный ответ в формате JSON:"
+                "\n\nФинальный ответ в формате JSON (только поле final_answer):"
             )
-            final_response = self.llm.complete(synthesis_prompt)
+            
+            final_response = self._generate_response(synthesis_prompt)
             
             # Извлечение чистого ответа
-            answer_match = re.search(r'\{.*\}', final_response.text, re.DOTALL)
-            if answer_match:
-                return answer_match.group(0)
+            if "final_answer" in final_response:
+                return json.dumps({"final_answer": final_response})
             else:
-                return json.dumps({
-                    "final_answer": final_response.text.strip(),
-                    "task_id": task_id,
-                    "reasoning_steps": results
-                })
+                # Попробуем извлечь ответ из текста
+                answer_match = re.search(r'\{.*\}', final_response, re.DOTALL)
+                if answer_match:
+                    return answer_match.group(0)
+                else:
+                    return json.dumps({"final_answer": final_response.strip()})
         except Exception as e:
             logger.exception("Processing failed")
             return json.dumps({
@@ -228,7 +244,7 @@ class GAIAThoughtProcessor:
                 "final_answer": f"SYSTEM ERROR: {str(e)}"
             })
 
-# === ИСПРАВЛЕННАЯ СИСТЕМА ОЦЕНКИ ===
+# === СИСТЕМА ОЦЕНКИ ===
 class GAIAEvaluationRunner:
     def __init__(self, api_url: str = DEFAULT_API_URL):
         self.api_url = api_url
@@ -240,7 +256,7 @@ class GAIAEvaluationRunner:
             "User-Agent": "GAIA-Mastermind/1.0",
             "Content-Type": "application/json"
         })
-        logger.info("🌐 Инициализирован GAIAEvaluationRunner для %s", api_url)
+        logger.info(f"🌐 Инициализирован GAIAEvaluationRunner для {api_url}")
 
     def run_evaluation(self, agent, username: str, agent_code: str, progress=tqdm):
         # Получение вопросов
@@ -253,27 +269,22 @@ class GAIAEvaluationRunner:
         answers = []
         for i, q in enumerate(progress(questions, desc="🧠 Processing GAIA")):
             try:
-                # GAIA-specific: task_id обязателен
                 task_id = q.get("task_id", f"unknown_{i}")
-                
-                # Обработка вопроса
                 json_response = agent.process_question(q["question"], task_id)
                 
-                # Парсинг и валидация ответа
+                # Парсинг ответа
                 try:
                     response_obj = json.loads(json_response)
                     final_answer = response_obj.get("final_answer", "")
-                    
-                    # GAIA-требование: ответ должен быть строкой
                     if not isinstance(final_answer, str):
                         final_answer = str(final_answer)
                 except json.JSONDecodeError:
                     final_answer = json_response
                 
-                # Формирование ответа согласно GAIA API
+                # Формирование ответа для GAIA API
                 answers.append({
                     "task_id": task_id,
-                    "answer": final_answer[:500]  # GAIA limitation
+                    "answer": final_answer[:500]  # Ограничение длины
                 })
                 
                 # Запись результатов
@@ -284,7 +295,7 @@ class GAIAEvaluationRunner:
                     "Status": "Processed"
                 })
             except Exception as e:
-                logger.error("Task %s failed: %s", task_id, e)
+                logger.error(f"Task {task_id} failed: {e}")
                 answers.append({
                     "task_id": task_id,
                     "answer": f"ERROR: {str(e)}"
@@ -301,7 +312,7 @@ class GAIAEvaluationRunner:
         return submission_result, score, len(questions), pd.DataFrame(results)
 
     def _fetch_questions(self) -> Tuple[list, str]:
-        """Получение вопросов с обработкой GAIA спецификации"""
+        """Получение вопросов с API"""
         for _ in range(API_RETRIES):
             try:
                 response = self.session.get(
@@ -309,17 +320,14 @@ class GAIAEvaluationRunner:
                     timeout=API_TIMEOUT
                 )
                 
-                # Обработка GAIA статусов
                 if response.status_code == 200:
                     questions = response.json()
                     if not isinstance(questions, list):
                         return [], "Invalid response format: expected list"
                     
-                    # Обогащение данных для мультимодальных задач
+                    # Добавление task_id если отсутствует
                     for q in questions:
                         q.setdefault("task_id", f"id_{hash(q['question']) % 100000}")
-                        if "image" in q:
-                            q["question"] = f"[IMAGE] {q['question']}"
                     return questions, "success"
                 
                 elif response.status_code == 429:
@@ -327,20 +335,17 @@ class GAIAEvaluationRunner:
                     time.sleep(5)
                     continue
                     
-                elif response.status_code == 404:
-                    return [], "API endpoint not found"
-                    
                 else:
                     return [], f"API error: HTTP {response.status_code}"
                     
             except Exception as e:
-                logger.error("Fetch error: %s", e)
+                logger.error(f"Fetch error: {e}")
                 return [], f"Connection error: {str(e)}"
         
         return [], "API unavailable after retries"
 
     def _submit_answers(self, username: str, agent_code: str, answers: list) -> Tuple[str, int]:
-        """Отправка ответов согласно GAIA API спецификации"""
+        """Отправка ответов на сервер"""
         payload = {
             "username": username.strip(),
             "agent_code": agent_code.strip(),
@@ -355,7 +360,6 @@ class GAIAEvaluationRunner:
                     timeout=API_TIMEOUT * 2
                 )
                 
-                # Обработка GAIA статусов
                 if response.status_code == 200:
                     result = response.json()
                     score = result.get("score", 0)
@@ -363,7 +367,7 @@ class GAIAEvaluationRunner:
                     
                 elif response.status_code == 400:
                     error = response.json().get("error", "Invalid request")
-                    logger.error("Validation error: %s", error)
+                    logger.error(f"Validation error: {error}")
                     return f"Validation Error: {error}", 0
                     
                 elif response.status_code == 429:
@@ -375,12 +379,12 @@ class GAIAEvaluationRunner:
                     return f"HTTP Error {response.status_code}", 0
                     
             except Exception as e:
-                logger.error("Submit error: %s", e)
+                logger.error(f"Submit error: {e}")
                 return f"Connection Error: {str(e)}", 0
         
         return "Submission failed after retries", 0
 
-# === ОПТИМИЗИРОВАННЫЙ ИНТЕРФЕЙС ===
+# === ИНТЕРФЕЙС GRADIO ===
 def run_evaluation(username: str, agent_code: str, progress=gr.Progress()):
     progress(0, desc="⚡ Инициализация GAIA Mastermind...")
     try:
@@ -392,33 +396,58 @@ def run_evaluation(username: str, agent_code: str, progress=gr.Progress()):
     progress(0.1, desc="🌐 Подключение к GAIA API...")
     runner = GAIAEvaluationRunner()
     
-    # Обертка tqdm для Gradio
-    class ProgressWrapper:
-        def __init__(self, total, progress):
-            self.total = total
-            self.progress = progress
-            self.current = 0
+    # Получение вопросов
+    questions, status = runner._fetch_questions()
+    if status != "success":
+        return status, 0, 0, pd.DataFrame()
+    
+    # Обработка вопросов с прогрессом
+    results = []
+    answers = []
+    total = len(questions)
+    
+    for i, q in enumerate(questions):
+        progress(i / total, desc=f"🧠 Обработка задач ({i+1}/{total})")
+        try:
+            task_id = q.get("task_id", f"unknown_{i}")
+            json_response = agent.process_question(q["question"], task_id)
             
-        def update(self, n=1):
-            self.current += n
-            self.progress(self.current / self.total, desc=f"🧠 Обработка задач ({self.current}/{self.total})")
+            # Парсинг ответа
+            try:
+                response_obj = json.loads(json_response)
+                final_answer = response_obj.get("final_answer", "")
+            except:
+                final_answer = json_response
             
-        def __iter__(self):
-            return self
+            answers.append({
+                "task_id": task_id,
+                "answer": str(final_answer)[:500]
+            })
             
-        def __next__(self):
-            if self.current >= self.total:
-                raise StopIteration
-            return self.current
+            results.append({
+                "Task ID": task_id,
+                "Question": q["question"][:150] + "..." if len(q["question"]) > 150 else q["question"],
+                "Answer": str(final_answer)[:200],
+                "Status": "Processed"
+            })
+        except Exception as e:
+            logger.error(f"Task {task_id} failed: {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 runner.run_evaluation(
-        agent, 
-        username, 
-        agent_code, 
-        progress=ProgressWrapper
-    )
+    # Отправка ответов
+    submission_result, score = runner._submit_answers(username, agent_code, answers)
+    return submission_result, score, total, pd.DataFrame(results)
 
-# === ИНТЕЛЛЕКТУАЛЬНЫЙ ИНТЕРФЕЙС ===
+# Создание интерфейса
 with gr.Blocks(
     title="🧠 GAIA Mastermind", 
     theme=gr.themes.Soft(),
@@ -431,8 +460,8 @@ with gr.Blocks(
     <div style="text-align:center; background: linear-gradient(135deg, #0f2027, #203a43); 
                 padding: 20px; border-radius: 15px; color: white; box-shadow: 0 10px 20px rgba(0,0,0,0.3);">
         <h1>🧠 GAIA Mastermind</h1>
-        <h3>Многошаговое решение задач с Tree-of-Thought</h3>
-        <p>Соответствует спецификации GAIA API v1.2</p>
+        <h3>Многошаговое решение задач с декомпозицией</h3>
+        <p>Соответствует спецификации GAIA API</p>
     </div>
     """)
     
@@ -452,7 +481,7 @@ with gr.Blocks(
             run_btn = gr.Button("🚀 Запустить оценку", variant="primary", scale=1)
             
             gr.Markdown("### ⚙️ Статус системы")
-            sys_info = gr.Textbox(label="Системная информация", interactive=False)
+            sys_info = gr.Textbox(label="Системная информация", interactive=False, value="")
             
         with gr.Column(scale=2):
             gr.Markdown("### 📊 Результаты GAIA")
@@ -484,11 +513,8 @@ with gr.Blocks(
     
     # Системная информация
     def get_system_info():
-        return (
-            f"Device: {'GPU ✅' if torch.cuda.is_available() else 'CPU ⚠️'}, "
-            f"Model: {MODEL_NAME}, "
-            f"API: {DEFAULT_API_URL}"
-        )
+        device = "GPU ✅" if torch.cuda.is_available() else "CPU ⚠️"
+        return f"Device: {device} | Model: {MODEL_NAME} | API: {DEFAULT_API_URL}"
     
     demo.load(get_system_info, inputs=None, outputs=sys_info)
     
@@ -497,15 +523,11 @@ with gr.Blocks(
         inputs=[username, agent_code],
         outputs=[result_output, correct_output, total_output, results_table],
         concurrency_limit=1,
-        show_progress="minimal",
-        api_name="run_evaluation"
+        show_progress="minimal"
     )
 
 if __name__ == "__main__":
-    demo.queue(
-        max_size=5, 
-        api_open=False
-    ).launch(
+    demo.queue(max_size=5).launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,