update15

app.py

@@ -10,7 +10,9 @@ import time
 import threading
 import queue
 import uuid
+import numpy as np
 from datetime import datetime
+from tqdm.auto import tqdm
 from src.containerized_eval import eval_string_script
 
 # 添加当前目录和src目录到模块搜索路径
@@ -25,7 +27,7 @@ if src_dir not in sys.path:
 task_queue = queue.Queue()
 # 存储任务状态的字典
 task_status = {}
-# 存储任务历史的列表，最多保存最近10个任务
+# 存储任务历史的列表，最多保存最近20个任务
 task_history = []
 # 用于保护共享资源的锁
 lock = threading.Lock()
@@ -33,6 +35,8 @@ lock = threading.Lock()
 worker_threads = multiprocessing.cpu_count()
 # 后台线程是否运行的标志
 running = True
+# 任务类型到处理时间的映射
+task_type_times = {}
 
 def queue_processor():
     """处理队列中的任务"""
@@ -44,6 +48,21 @@ def queue_processor():
                 task_status[task_id]['status'] = 'processing'
                 task_status[task_id]['start_time'] = time.time()
             
+            # 识别任务特征以估计完成时间
+            # 例如：语言类型、代码大小等
+            if isinstance(input_data, list) and len(input_data) > 0:
+                sample_task = input_data[0]
+                language = sample_task.get('language', 'unknown') if isinstance(sample_task, dict) else 'unknown'
+                task_size = len(input_data)
+                task_complexity = _estimate_task_complexity(input_data)
+                
+                with lock:
+                    task_status[task_id]['estimated_factors'] = {
+                        'language': language,
+                        'size': task_size,
+                        'complexity': task_complexity
+                    }
+            
             # 处理任务
             result = evaluate(input_data)
             
@@ -57,15 +76,30 @@ def queue_processor():
                 task_status[task_id]['end_time'] = end_time
                 task_status[task_id]['process_time'] = process_time
                 
+                # 更新任务类型到处理时间的映射
+                if 'estimated_factors' in task_status[task_id]:
+                    factors = task_status[task_id]['estimated_factors']
+                    key = f"{factors['language']}_{factors['complexity']}"
+                    
+                    if key not in task_type_times:
+                        task_type_times[key] = []
+                    
+                    # 记录此类型任务的处理时间
+                    task_type_times[key].append(process_time / factors['size'])
+                    # 只保留最近的10个记录
+                    if len(task_type_times[key]) > 10:
+                        task_type_times[key] = task_type_times[key][-10:]
+                
                 # 更新任务历史
                 task_history.append({
                     'task_id': task_id,
                     'request_time': request_time,
                     'process_time': process_time,
-                    'status': 'completed'
+                    'status': 'completed',
+                    'factors': task_status[task_id].get('estimated_factors', {})
                 })
-                # 只保留最近10个任务
-                while len(task_history) > 10:
+                # 只保留最近20个任务
+                while len(task_history) > 20:
                     task_history.pop(0)
                     
             # 标记任务完成
@@ -82,6 +116,44 @@ def queue_processor():
                     task_status[task_id]['end_time'] = time.time()
             task_queue.task_done()
 
+def _estimate_task_complexity(tasks):
+    """估计任务复杂度
+    
+    Args:
+        tasks: 任务列表
+        
+    Returns:
+        str: 复杂度评级 ('simple', 'medium', 'complex')
+    """
+    # 基于代码和测试的长度评估复杂度
+    total_code_length = 0
+    count = 0
+    
+    for task in tasks:
+        if isinstance(task, dict):
+            prompt = task.get('prompt', '')
+            tests = task.get('tests', '')
+            completions = task.get('processed_completions', [])
+            
+            code_length = len(prompt) + len(tests)
+            if completions:
+                code_length += sum(len(comp) for comp in completions)
+            
+            total_code_length += code_length
+            count += 1
+    
+    if count == 0:
+        return 'medium'  # 默认中等复杂度
+    
+    avg_length = total_code_length / count
+    
+    if avg_length < 1000:
+        return 'simple'
+    elif avg_length < 5000:
+        return 'medium'
+    else:
+        return 'complex'
+
 def evaluate(input_data):
     """评估代码的主函数
     
@@ -174,6 +246,21 @@ def synchronous_evaluate(input_data):
     Returns:
         dict: 评估结果
     """
+    # a) 估计此任务的特征
+    if isinstance(input_data, list) and len(input_data) > 0:
+        sample_task = input_data[0]
+        language = sample_task.get('language', 'unknown') if isinstance(sample_task, dict) else 'unknown'
+        task_size = len(input_data)
+        task_complexity = _estimate_task_complexity(input_data)
+    else:
+        language = 'unknown'
+        task_size = 1
+        task_complexity = 'medium'
+    
+    # b) 估计完成时间用于前端显示
+    estimated_time_per_task = _get_estimated_time_for_task(language, task_complexity)
+    estimated_total_time = estimated_time_per_task * task_size
+    
     # 获取队列当前状态
     queue_info = get_queue_status()
     waiting_tasks = queue_info['waiting_tasks']
@@ -188,7 +275,13 @@ def synchronous_evaluate(input_data):
             'status': 'queued',
             'queued_time': request_time,
             'queue_position': task_queue.qsize() + 1,
-            'synchronous': True  # 标记为同步任务
+            'synchronous': True,  # 标记为同步任务
+            'estimated_factors': {
+                'language': language,
+                'size': task_size,
+                'complexity': task_complexity
+            },
+            'estimated_time': estimated_total_time
         }
     
     # 将任务添加到队列
@@ -213,6 +306,30 @@ def synchronous_evaluate(input_data):
         # 短暂睡眠避免CPU占用过高
         time.sleep(0.1)
 
+def _get_estimated_time_for_task(language, complexity):
+    """获取特定类型任务的估计处理时间
+    
+    Args:
+        language: 编程语言
+        complexity: 任务复杂度
+        
+    Returns:
+        float: 估计的处理时间（秒）
+    """
+    key = f"{language}_{complexity}"
+    
+    # 如果有历史数据，使用中位数作为估计值
+    if key in task_type_times and len(task_type_times[key]) > 0:
+        return np.median(task_type_times[key])
+    
+    # 否则使用基于复杂度的默认估计值
+    if complexity == 'simple':
+        return 1.0
+    elif complexity == 'medium':
+        return 3.0
+    else:  # complex
+        return 8.0
+
 def enqueue_task(input_data):
     """将任务添加到队列
     
@@ -222,6 +339,20 @@ def enqueue_task(input_data):
     Returns:
         dict: 包含任务ID和状态的字典
     """
+    # 估计任务特征和处理时间
+    if isinstance(input_data, list) and len(input_data) > 0:
+        sample_task = input_data[0]
+        language = sample_task.get('language', 'unknown') if isinstance(sample_task, dict) else 'unknown'
+        task_size = len(input_data)
+        task_complexity = _estimate_task_complexity(input_data)
+    else:
+        language = 'unknown'
+        task_size = 1
+        task_complexity = 'medium'
+    
+    estimated_time_per_task = _get_estimated_time_for_task(language, task_complexity)
+    estimated_total_time = estimated_time_per_task * task_size
+    
     task_id = str(uuid.uuid4())
     request_time = time.time()
     
@@ -230,9 +361,19 @@ def enqueue_task(input_data):
         task_status[task_id] = {
             'status': 'queued',
             'queued_time': request_time,
-            'queue_position': task_queue.qsize() + 1
+            'queue_position': task_queue.qsize() + 1,
+            'estimated_factors': {
+                'language': language,
+                'size': task_size,
+                'complexity': task_complexity
+            },
+            'estimated_time': estimated_total_time
         }
     
+    # 获取队列状态以计算等待时间
+    queue_info = get_queue_status()
+    est_wait = queue_info['estimated_wait']
+    
     # 将任务添加到队列
     task_queue.put((task_id, input_data, request_time))
     
@@ -240,7 +381,8 @@ def enqueue_task(input_data):
         'task_id': task_id,
         'status': 'queued',
         'queue_position': task_status[task_id]['queue_position'],
-        'estimated_wait': task_status[task_id]['queue_position'] * 5  # 估计等待时间，假设每个任务平均5秒
+        'estimated_wait': est_wait,
+        'estimated_processing': estimated_total_time
     }
 
 def check_status(task_id):
@@ -271,32 +413,70 @@ def get_queue_status():
         dict: 包含队列状态的字典
     """
     with lock:
+        # 获取队列中的所有任务
+        queued_tasks = [t for t in task_status.values() if t['status'] == 'queued']
+        processing_tasks = [t for t in task_status.values() if t['status'] == 'processing']
+        
         queue_size = task_queue.qsize()
-        active_tasks = sum(1 for status in task_status.values() if status['status'] == 'processing')
-        waiting_tasks = sum(1 for status in task_status.values() if status['status'] == 'queued')
+        active_tasks = len(processing_tasks)
+        waiting_tasks = len(queued_tasks)
         
-        recent_tasks = task_history[-5:] if task_history else []
+        # 更准确地估计等待时间
+        # 1. 计算当前处理中任务的剩余时间
+        remaining_processing_time = 0
+        for task in processing_tasks:
+            # 如果任务有开始时间和估计总时间
+            if 'start_time' in task and 'estimated_time' in task:
+                elapsed = time.time() - task['start_time']
+                # 剩余时间 = 估计总时间 - 已经过去的时间
+                remaining = max(0, task['estimated_time'] - elapsed)
+                remaining_processing_time += remaining
+            else:
+                # 默认假设还需要2秒
+                remaining_processing_time += 2
+        
+        # 使用动态均衡：根据工作线程数量平衡负载
+        if active_tasks > 0:
+            remaining_processing_time = remaining_processing_time / min(active_tasks, worker_threads)
+        
+        # 2. 计算排队中任务的估计处理时间
+        queued_processing_time = 0
+        for task in queued_tasks:
+            if 'estimated_time' in task:
+                queued_processing_time += task['estimated_time']
+            else:
+                # 默认假设每个任务5秒
+                queued_processing_time += 5
         
-        # 计算平均处理时间，如果没有历史数据，使用默认值
-        if recent_tasks:
-            avg_time = sum(task['process_time'] for task in recent_tasks) / len(recent_tasks)
-            # 确保平均时间至少为1秒
-            avg_time = max(avg_time, 1.0)
-        else:
-            # 没有历史数据时的默认平均处理时间（秒）
-            avg_time = 5.0
+        # 考虑并行处理：分摊到可用工作线程
+        if worker_threads > 0 and queued_processing_time > 0:
+            queued_processing_time = queued_processing_time / worker_threads
         
-        # 估算等待时间
-        # 如果有活跃任务，假设它们还需要完成一半的平均时间
-        active_time = (active_tasks * avg_time) / 2 if active_tasks > 0 else 0
-        # 排队任务的总时间
-        queue_time = waiting_tasks * avg_time
-        # 总预计等待时间
-        estimated_wait = active_time + queue_time
+        # 总估计等待时间
+        estimated_wait = remaining_processing_time + queued_processing_time
         
-        # 确保即使没有任务也返回有效值
-        if estimated_wait == 0 and (waiting_tasks > 0 or active_tasks > 0):
-            estimated_wait = 1.0
+        # 应用统计校正：使用历史数据调整预测
+        if task_history:
+            # 计算历史预测与实际处理时间的比例
+            prediction_ratios = []
+            for task in task_history:
+                if 'factors' in task and 'estimated_time' in task:
+                    prediction_ratios.append(task['process_time'] / task['estimated_time'])
+            
+            # 如果有足够数据，使用中位数比例调整当前预测
+            if prediction_ratios:
+                correction_factor = np.median(prediction_ratios)
+                # 应用校正因子，但限制在合理范围内
+                correction_factor = max(0.5, min(2.0, correction_factor))
+                estimated_wait *= correction_factor
+        
+        # 确保等待时间有意义
+        estimated_wait = max(0.1, estimated_wait)
+        if waiting_tasks == 0 and active_tasks == 0:
+            estimated_wait = 0
+            
+        # 获取最近处理的任务
+        recent_tasks = task_history[-5:] if task_history else []
             
         return {
             'queue_size': queue_size,
@@ -304,7 +484,6 @@ def get_queue_status():
             'waiting_tasks': waiting_tasks,
             'worker_threads': worker_threads,
             'estimated_wait': estimated_wait,
-            'avg_process_time': avg_time,
             'recent_tasks': recent_tasks
         }
 
@@ -328,113 +507,6 @@ def format_time(seconds):
         minutes = int((seconds % 3600) / 60)
         return f"{hours}小时{minutes}分钟"
 
-def ui_submit(input_json):
-    """提交任务到队列的UI函数
-    
-    Args:
-        input_json: JSON格式的输入数据
-        
-    Returns:
-        tuple: 任务ID和初始状态信息
-    """
-    try:
-        input_data = json.loads(input_json) if isinstance(input_json, str) else input_json
-        response = enqueue_task(input_data)
-        task_id = response['task_id']
-        
-        status_html = f"""
-        <div class="status-card">
-            <h3>任务状态</h3>
-            <p><b>任务ID:</b> {task_id}</p>
-            <p><b>状态:</b> 已入队</p>
-            <p><b>队列位置:</b> {response['queue_position']}</p>
-            <p><b>预计等待时间:</b> {format_time(response['estimated_wait'])}</p>
-        </div>
-        """
-        
-        return task_id, status_html
-    except Exception as e:
-        return None, f"<div class='error-message'>提交失败: {str(e)}</div>"
-
-def ui_check_status(task_id):
-    """检查任务状态的UI函数
-    
-    Args:
-        task_id: 任务ID
-        
-    Returns:
-        str: 包含任务状态的HTML
-    """
-    if not task_id:
-        return "<div class='notice'>请提供任务ID</div>"
-    
-    status = check_status(task_id)
-    
-    if status['status'] == 'not_found':
-        return "<div class='error-message'>任务未找到</div>"
-    
-    if status['status'] == 'queued':
-        queue_info = get_queue_status()
-        
-        # 计算这个特定任务的等待时间
-        avg_time = queue_info.get('avg_process_time', 5.0)
-        active_time = (queue_info['active_tasks'] * avg_time) / 2 if queue_info['active_tasks'] > 0 else 0
-        
-        # 计算此任务前面的任务数
-        tasks_ahead = status['queue_position'] - 1
-        
-        # 此任务的估计等待时间 = 活跃任务完成时间 + 前面排队任务时间
-        est_wait = active_time + (tasks_ahead * avg_time)
-        
-        return f"""
-        <div class="status-card">
-            <h3>任务状态</h3>
-            <p><b>任务ID:</b> {task_id}</p>
-            <p><b>状态:</b> 等待中</p>
-            <p><b>队列位置:</b> {status['queue_position']}</p>
-            <p><b>入队时间:</b> {datetime.fromtimestamp(status['queued_time']).strftime('%H:%M:%S')}</p>
-            <p><b>预计等待时间:</b> {format_time(est_wait)}</p>
-        </div>
-        """
-    
-    if status['status'] == 'processing':
-        process_time = time.time() - status['start_time']
-        
-        return f"""
-        <div class="status-card">
-            <h3>任务状态</h3>
-            <p><b>任务ID:</b> {task_id}</p>
-            <p><b>状态:</b> 处理中</p>
-            <p><b>已处理时间:</b> {format_time(process_time)}</p>
-            <p><b>入队时间:</b> {datetime.fromtimestamp(status['queued_time']).strftime('%H:%M:%S')}</p>
-        </div>
-        """
-    
-    if status['status'] == 'completed':
-        result = status.get('result', {})
-        
-        return f"""
-        <div class="status-card success">
-            <h3>任务状态</h3>
-            <p><b>任务ID:</b> {task_id}</p>
-            <p><b>状态:</b> 已完成</p>
-            <p><b>处理时间:</b> {format_time(status['process_time'])}</p>
-            <p><b>完成时间:</b> {datetime.fromtimestamp(status['end_time']).strftime('%H:%M:%S')}</p>
-        </div>
-        """
-    
-    if status['status'] == 'error':
-        return f"""
-        <div class="status-card error">
-            <h3>任务状态</h3>
-            <p><b>任务ID:</b> {task_id}</p>
-            <p><b>状态:</b> 错误</p>
-            <p><b>错误信息:</b> {status.get('error', '未知错误')}</p>
-        </div>
-        """
-    
-    return "<div class='error-message'>未知状态</div>"
-
 def ui_get_queue_info():
     """获取队列信息的UI函数
     
@@ -461,9 +533,6 @@ def ui_get_queue_info():
         </tr>
         """
     
-    # 添加平均处理时间显示
-    avg_time_html = f"""<p><b>平均处理时间:</b> {format_time(queue_info.get('avg_process_time', 0))}</p>"""
-    
     return f"""
     <div class="dashboard">
         <div class="queue-info-card main-card">
@@ -484,7 +553,6 @@ def ui_get_queue_info():
             </div>
             
             <div class="wait-time">
-                {avg_time_html}
                 <p><b>当前预计等待时间:</b> {format_time(queue_info['estimated_wait'])}</p>
                 <p class="last-update"><small>最后更新: {datetime.now().strftime('%H:%M:%S')}</small></p>
             </div>
@@ -508,36 +576,6 @@ def ui_get_queue_info():
     </div>
     """
 
-def ui_get_result(task_id):
-    """获取任务结果的UI函数
-    
-    Args:
-        task_id: 任务ID
-        
-    Returns:
-        任务结果
-    """
-    if not task_id:
-        return None
-    
-    status = check_status(task_id)
-    
-    if status['status'] == 'completed':
-        return status.get('result', None)
-    
-    return None
-
-def launch_workers():
-    """启动工作线程"""
-    global running
-    running = True
-    
-    # 创建工作线程
-    for _ in range(worker_threads):
-        worker = threading.Thread(target=queue_processor)
-        worker.daemon = True
-        worker.start()
-
 # 自定义CSS
 custom_css = """
 .container {