AI 应用开发中的任务管理与性能优化-优快云博客

摘要

在 AI 应用开发中，任务管理与性能优化是确保系统高效运行的关键环节。本文通过分析实际场景，探讨了任务取消的原因、性能监控的方法以及优化策略。文章分为多个章节，详细讲解了任务管理、资源监控、性能优化等核心内容，并提供了实践示例和代码。通过本文，读者将能够掌握如何在 AI 应用中有效管理任务并优化系统性能，从而提升用户体验和系统稳定性。

引言

在 AI 应用开发中，任务管理与性能优化是确保系统高效运行的关键环节。随着 AI 技术的快速发展，应用复杂度不断增加，对系统的性能要求也越来越高。AI 应用通常涉及大量计算任务，如模型训练、推理、数据处理等，这些任务对系统资源消耗较大，如果管理不当，很容易导致系统性能下降甚至崩溃。

任务管理涉及任务的调度、执行和监控，而性能优化则关注系统的响应速度、资源利用率和稳定性。良好的任务管理能够确保系统资源得到合理分配，避免任务冲突和资源竞争；有效的性能优化则能够提升系统整体运行效率，改善用户体验。

本文将通过分析实际场景，探讨任务取消的原因、性能监控的方法以及优化策略，帮助开发者构建高效稳定的 AI 应用系统。

任务管理

任务管理是 AI 应用中的一个重要环节，它涉及任务的调度、执行和监控。在 AI 应用中，任务可能包括模型训练、数据预处理、推理计算、结果分析等。这些任务通常具有计算密集、耗时较长的特点，如果管理不当，容易导致系统资源耗尽或任务执行失败。

任务取消的原因

任务取消可能是由于以下原因之一：

任务超时：任务在执行过程中耗时过长，超过了系统设定的超时阈值。
资源不足：服务器资源（CPU、内存、GPU等）不足，导致任务被取消。
用户操作：用户手动取消了任务。
系统错误：任务依赖的外部服务不可用，或者任务的输入数据不正确。

实践示例：任务管理器实现

以下是一个简单的 Python 任务管理器实现，用于管理 AI 应用中的计算任务：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
AI 应用任务管理器
用于管理 AI 应用中的计算任务，包括任务调度、执行和取消
"""

import asyncio
import time
import logging
from typing import Dict, Callable, Any, Optional
from dataclasses import dataclass
from enum import Enum

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class TaskStatus(Enum):
    """任务状态枚举"""
    PENDING = "pending"      # 等待中
    RUNNING = "running"      # 运行中
    COMPLETED = "completed"  # 已完成
    CANCELLED = "cancelled"  # 已取消
    FAILED = "failed"        # 已失败

@dataclass
class TaskInfo:
    """任务信息"""
    task_id: str
    name: str
    status: TaskStatus
    created_at: float
    started_at: Optional[float] = None
    completed_at: Optional[float] = None
    result: Any = None
    error: Optional[str] = None

class TaskManager:
    """任务管理器"""
    
    def __init__(self, max_concurrent_tasks: int = 5):
        """
        初始化任务管理器
        
        Args:
            max_concurrent_tasks (int): 最大并发任务数
        """
        self.max_concurrent_tasks = max_concurrent_tasks
        self.tasks: Dict[str, TaskInfo] = {}
        self.running_tasks: Dict[str, asyncio.Task] = {}
        self.task_queue = asyncio.Queue()
        self.semaphore = asyncio.Semaphore(max_concurrent_tasks)
        
    async def add_task(self, task_id: str, name: str, task_func: Callable, *args, **kwargs) -> None:
        """
        添加任务到队列
        
        Args:
            task_id (str): 任务ID
            name (str): 任务名称
            task_func (Callable): 任务函数
            *args: 任务函数参数
            **kwargs: 任务函数关键字参数
        """
        # 创建任务信息
        task_info = TaskInfo(
            task_id=task_id,
            name=name,
            status=TaskStatus.PENDING,
            created_at=time.time()
        )
        
        # 保存任务信息
        self.tasks[task_id] = task_info
        
        # 添加到任务队列
        await self.task_queue.put((task_id, task_func, args, kwargs))
        logger.info(f"任务已添加到队列: {task_id} - {name}")
    
    async def _execute_task(self, task_id: str, task_func: Callable, args: tuple, kwargs: dict) -> None:
        """
        执行任务
        
        Args:
            task_id (str): 任务ID
            task_func (Callable): 任务函数
            args (tuple): 任务函数参数
            kwargs (dict): 任务函数关键字参数
        """
        try:
            # 更新任务状态
            self.tasks[task_id].status = TaskStatus.RUNNING
            self.tasks[task_id].started_at = time.time()
            logger.info(f"任务开始执行: {task_id}")
            
            # 执行任务
            result = await task_func(*args, **kwargs)
            
            # 更新任务状态
            self.tasks[task_id].status = TaskStatus.COMPLETED
            self.tasks[task_id].completed_at = time.time()
            self.tasks[task_id].result = result
            logger.info(f"任务执行完成: {task_id}")
            
        except asyncio.CancelledError:
            # 任务被取消
            self.tasks[task_id].status = TaskStatus.CANCELLED
            self.tasks[task_id].completed_at = time.time()
            logger.warning(f"任务被取消: {task_id}")
            raise
        except Exception as e:
            # 任务执行失败
            self.tasks[task_id].status = TaskStatus.FAILED
            self.tasks[task_id].completed_at = time.time()
            self.tasks[task_id].error = str(e)
            logger.error(f"任务执行失败: {task_id}, 错误: {str(e)}")
    
    async def _worker(self) -> None:
        """工作协程，从队列中获取任务并执行"""
        while True:
            try:
                # 从队列中获取任务
                task_id, task_func, args, kwargs = await self.task_queue.get()
                
                # 使用信号量控制并发数
                async with self.semaphore:
                    # 创建异步任务
                    task = asyncio.create_task(
                        self._execute_task(task_id, task_func, args, kwargs)
                    )
                    
                    # 保存任务引用
                    self.running_tasks[task_id] = task
                    
                    try:
                        # 等待任务完成
                        await task
                    finally:
                        # 清理任务引用
                        self.running_tasks.pop(task_id, None)
                        self.task_queue.task_done()
                        
            except Exception as e:
                logger.error(f"工作协程发生错误: {str(e)}")
    
    async def start(self, worker_count: int = 3) -> None:
        """
        启动任务管理器
        
        Args:
            worker_count (int): 工作协程数量
        """
        # 启动工作协程
        for i in range(worker_count):
            asyncio.create_task(self._worker())
        logger.info(f"任务管理器已启动，工作协程数量: {worker_count}")
    
    async def cancel_task(self, task_id: str) -> bool:
        """
        取消任务
        
        Args:
            task_id (str): 任务ID
            
        Returns:
            bool: 取消是否成功
        """
        if task_id in self.running_tasks:
            # 取消异步任务
            task = self.running_tasks[task_id]
            task.cancel()
            
            # 等待任务取消完成
            try:
                await task
            except asyncio.CancelledError:
                pass
            
            logger.info(f"任务已取消: {task_id}")
            return True
        else:
            logger.warning(f"任务不存在或已完成: {task_id}")
            return False
    
    def get_task_info(self, task_id: str) -> Optional[TaskInfo]:
        """
        获取任务信息
        
        Args:
            task_id (str): 任务ID
            
        Returns:
            Optional[TaskInfo]: 任务信息
        """
        return self.tasks.get(task_id)
    
    def list_tasks(self) -> Dict[str, TaskInfo]:
        """
        列出所有任务
        
        Returns:
            Dict[str, TaskInfo]: 所有任务信息
        """
        return self.tasks.copy()

# 模拟 AI 计算任务
async def ai_computation_task(task_name: str, duration: int) -> str:
    """
    模拟 AI 计算任务
    
    Args:
        task_name (str): 任务名称
        duration (int): 任务持续时间（秒）
        
    Returns:
        str: 任务结果
    """
    logger.info(f"开始执行 AI 计算任务: {task_name}")
    
    # 模拟计算过程
    for i in range(duration):
        await asyncio.sleep(1)
        logger.info(f"任务 {task_name} 进度: {i+1}/{duration}")
    
    result = f"AI 计算任务 {task_name} 完成，耗时 {duration} 秒"
    logger.info(result)
    return result

# 使用示例
async def main():
    """主函数"""
    # 创建任务管理器
    task_manager = TaskManager(max_concurrent_tasks=3)
    
    # 启动任务管理器
    await task_manager.start(worker_count=2)
    
    # 添加任务
    await task_manager.add_task(
        "task_1", 
        "模型训练任务", 
        ai_computation_task, 
        "模型训练", 
        5
    )
    
    await task_manager.add_task(
        "task_2", 
        "数据预处理任务", 
        ai_computation_task, 
        "数据预处理", 
        3
    )
    
    await task_manager.add_task(
        "task_3", 
        "推理计算任务", 
        ai_computation_task, 
        "推理计算", 
        7
    )
    
    # 等待一段时间
    await asyncio.sleep(2)
    
    # 取消一个任务
    await task_manager.cancel_task("task_3")
    
    # 等待所有任务完成
    await asyncio.sleep(10)
    
    # 查看任务状态
    tasks = task_manager.list_tasks()
    for task_id, task_info in tasks.items():
        logger.info(f"任务 {task_id}: {task_info.status.value}")

if __name__ == "__main__":
    asyncio.run(main())

资源监控

资源监控是性能优化的基础，通过监控服务器的 CPU、内存、磁盘 I/O 和 GPU 使用情况，可以及时发现潜在问题。在 AI 应用中，资源监控尤为重要，因为 AI 计算通常对硬件资源要求较高。

监控工具

常用的资源监控工具包括：

psutil：Python 库，用于获取系统和进程的详细信息
Prometheus：用于监控系统和应用程序的性能指标
Grafana：用于可视化 Prometheus 收集的指标
nvidia-ml-py：用于监控 NVIDIA GPU 的使用情况
top/htop：Linux 系统自带的实时监控工具

实践示例：系统资源监控器

以下是一个简单的系统资源监控器实现，用于监控 CPU、内存和 GPU 使用情况：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
系统资源监控器
用于监控 AI 应用的系统资源使用情况
"""

import psutil
import time
import logging
from typing import Dict, Optional
try:
    import pynvml
    NVIDIA_GPU_AVAILABLE = True
except ImportError:
    NVIDIA_GPU_AVAILABLE = False

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class SystemResourceMonitor:
    """系统资源监控器"""
    
    def __init__(self):
        """初始化系统资源监控器"""
        self.cpu_usage_history = []
        self.memory_usage_history = []
        self.disk_usage_history = []
        
        # 初始化 NVIDIA GPU 监控
        if NVIDIA_GPU_AVAILABLE:
            try:
                pynvml.nvmlInit()
                self.gpu_count = pynvml.nvmlDeviceGetCount()
                logger.info(f"检测到 {self.gpu_count} 个 NVIDIA GPU")
            except Exception as e:
                logger.warning(f"初始化 NVIDIA GPU 监控失败: {e}")
                NVIDIA_GPU_AVAILABLE = False
                self.gpu_count = 0
        else:
            self.gpu_count = 0
            logger.info("未检测到 NVIDIA GPU 或未安装 pynvml 库")
    
    def get_cpu_usage(self) -> float:
        """
        获取 CPU 使用率
        
        Returns:
            float: CPU 使用率（百分比）
        """
        cpu_percent = psutil.cpu_percent(interval=1)
        self.cpu_usage_history.append(cpu_percent)
        # 保持最近 60 个数据点
        if len(self.cpu_usage_history) > 60:
            self.cpu_usage_history.pop(0)
        return cpu_percent
    
    def get_memory_usage(self) -> Dict[str, float]:
        """
        获取内存使用情况
        
        Returns:
            Dict[str, float]: 内存使用情况字典
        """
        memory = psutil.virtual_memory()
        memory_info = {
            'total': memory.total / (1024**3),  # GB
            'available': memory.available / (1024**3),  # GB
            'used': memory.used / (1024**3),  # GB
            'percent': memory.percent  # 百分比
        }
        
        self.memory_usage_history.append(memory_info['percent'])
        # 保持最近 60 个数据点
        if len(self.memory_usage_history) > 60:
            self.memory_usage_history.pop(0)
            
        return memory_info
    
    def get_disk_usage(self) -> Dict[str, float]:
        """
        获取磁盘使用情况
        
        Returns:
            Dict[str, float]: 磁盘使用情况字典
        """
        disk = psutil.disk_usage('/')
        disk_info = {
            'total': disk.total / (1024**3),  # GB
            'used': disk.used / (1024**3),  # GB
            'free': disk.free / (1024**3),  # GB
            'percent': disk.percent  # 百分比
        }
        
        self.disk_usage_history.append(disk_info['percent'])
        # 保持最近 60 个数据点
        if len(self.disk_usage_history) > 60:
            self.disk_usage_history.pop(0)
            
        return disk_info
    
    def get_gpu_usage(self) -> Optional[Dict[str, Dict[str, float]]]:
        """
        获取 GPU 使用情况
        
        Returns:
            Optional[Dict[str, Dict[str, float]]]: GPU 使用情况字典
        """
        if not NVIDIA_GPU_AVAILABLE or self.gpu_count == 0:
            return None
        
        gpu_info = {}
        try:
            for i in range(self.gpu_count):
                handle = pynvml.nvmlDeviceGetHandleByIndex(i)
                gpu_name = pynvml.nvmlDeviceGetName(handle).decode('utf-8')
                
                # 获取 GPU 使用率
                utilization = pynvml.nvmlDeviceGetUtilizationRates(handle)
                
                # 获取显存信息
                memory_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
                
                gpu_info[f'GPU-{i}'] = {
                    'name': gpu_name,
                    'utilization': utilization.gpu,  # GPU 使用率（百分比）
                    'memory_total': memory_info.total / (1024**3),  # GB
                    'memory_used': memory_info.used / (1024**3),  # GB
                    'memory_free': memory_info.free / (1024**3),  # GB
                    'memory_percent': (memory_info.used / memory_info.total) * 100  # 百分比
                }
        except Exception as e:
            logger.error(f"获取 GPU 信息时发生错误: {e}")
            return None
            
        return gpu_info
    
    def get_system_load(self) -> Dict[str, float]:
        """
        获取系统负载
        
        Returns:
            Dict[str, float]: 系统负载信息
        """
        load_avg = psutil.getloadavg()
        return {
            'load_1min': load_avg[0],
            'load_5min': load_avg[1],
            'load_15min': load_avg[2]
        }
    
    def get_network_io(self) -> Dict[str, float]:
        """
        获取网络 I/O 统计信息
        
        Returns:
            Dict[str, float]: 网络 I/O 信息
        """
        net_io = psutil.net_io_counters()
        return {
            'bytes_sent': net_io.bytes_sent / (1024**2),  # MB
            'bytes_recv': net_io.bytes_recv / (1024**2),  # MB
            'packets_sent': net_io.packets_sent,
            'packets_recv': net_io.packets_recv
        }
    
    def get_resource_report(self) -> Dict[str, any]:
        """
        获取完整的资源使用报告
        
        Returns:
            Dict[str, any]: 资源使用报告
        """
        report = {
            'timestamp': time.time(),
            'cpu': {
                'usage': self.get_cpu_usage(),
                'load': self.get_system_load()
            },
            'memory': self.get_memory_usage(),
            'disk': self.get_disk_usage(),
            'network': self.get_network_io()
        }
        
        # 添加 GPU 信息（如果有）
        if NVIDIA_GPU_AVAILABLE and self.gpu_count > 0:
            report['gpu'] = self.get_gpu_usage()
            
        return report
    
    def print_resource_report(self) -> None:
        """打印资源使用报告"""
        report = self.get_resource_report()
        
        # 打印 CPU 信息
        cpu_usage = report['cpu']['usage']
        load_avg = report['cpu']['load']
        logger.info(f"CPU 使用率: {cpu_usage:.1f}%")
        logger.info(f"系统负载 (1min/5min/15min): {load_avg['load_1min']:.2f}/{load_avg['load_5min']:.2f}/{load_avg['load_15min']:.2f}")
        
        # 打印内存信息
        memory = report['memory']
        logger.info(f"内存使用: {memory['used']:.1f}GB/{memory['total']:.1f}GB ({memory['percent']:.1f}%)")
        
        # 打印磁盘信息
        disk = report['disk']
        logger.info(f"磁盘使用: {disk['used']:.1f}GB/{disk['total']:.1f}GB ({disk['percent']:.1f}%)")
        
        # 打印网络信息
        network = report['network']
        logger.info(f"网络传输: 发送 {network['bytes_sent']:.1f}MB, 接收 {network['bytes_recv']:.1f}MB")
        
        # 打印 GPU 信息（如果有）
        if 'gpu' in report and report['gpu']:
            for gpu_id, gpu_info in report['gpu'].items():
                logger.info(f"{gpu_id} ({gpu_info['name']}):")
                logger.info(f"  GPU 使用率: {gpu_info['utilization']:.1f}%")
                logger.info(f"  显存使用: {gpu_info['memory_used']:.1f}GB/{gpu_info['memory_total']:.1f}GB ({gpu_info['memory_percent']:.1f}%)")

# 使用示例
def main():
    """主函数"""
    # 创建资源监控器
    monitor = SystemResourceMonitor()
    
    # 持续监控资源使用情况
    try:
        for i in range(10):
            logger.info(f"=== 资源监控报告 #{i+1} ===")
            monitor.print_resource_report()
            time.sleep(5)  # 每5秒监控一次
    except KeyboardInterrupt:
        logger.info("监控已停止")

if __name__ == "__main__":
    main()

性能优化

性能优化是确保 AI 应用高效运行的关键。通过优化任务执行逻辑、减少资源占用和提高系统响应速度，可以显著提升用户体验。AI 应用的性能优化涉及多个方面，包括算法优化、并行处理、缓存机制、资源调度等。

优化任务执行

任务执行优化是性能优化的核心内容，主要包括以下几个方面：

任务分解：将大型任务分解为多个子任务并行处理
算法优化：优化算法以提高计算效率
资源分配：合理分配系统资源，避免资源竞争
缓存机制：使用缓存减少重复计算
异步处理：使用异步编程提高并发能力

实践示例：AI 任务性能优化

以下是一个优化后的 AI 任务执行示例，展示了如何通过并行处理和缓存机制提高性能：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
AI 任务性能优化示例
展示如何通过并行处理和缓存机制优化 AI 任务执行
"""

import asyncio
import time
import logging
import hashlib
import pickle
from typing import List, Dict, Any, Optional
from functools import wraps

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class SimpleCache:
    """简单缓存实现"""
    
    def __init__(self, max_size: int = 100):
        """
        初始化缓存
        
        Args:
            max_size (int): 最大缓存条目数
        """
        self.max_size = max_size
        self.cache: Dict[str, Any] = {}
        self.access_times: Dict[str, float] = {}
    
    def _get_cache_key(self, func_name: str, args: tuple, kwargs: dict) -> str:
        """
        生成缓存键
        
        Args:
            func_name (str): 函数名称
            args (tuple): 函数参数
            kwargs (dict): 函数关键字参数
            
        Returns:
            str: 缓存键
        """
        # 创建参数的哈希值作为缓存键
        key_data = f"{func_name}:{str(args)}:{str(sorted(kwargs.items()))}"
        return hashlib.md5(key_data.encode()).hexdigest()
    
    def get(self, func_name: str, args: tuple, kwargs: dict) -> Optional[Any]:
        """
        从缓存中获取数据
        
        Args:
            func_name (str): 函数名称
            args (tuple): 函数参数
            kwargs (dict): 函数关键字参数
            
        Returns:
            Optional[Any]: 缓存数据，如果不存在则返回 None
        """
        key = self._get_cache_key(func_name, args, kwargs)
        if key in self.cache:
            self.access_times[key] = time.time()
            logger.info(f"缓存命中: {func_name}")
            return self.cache[key]
        return None
    
    def set(self, func_name: str, args: tuple, kwargs: dict, value: Any) -> None:
        """
        将数据存入缓存
        
        Args:
            func_name (str): 函数名称
            args (tuple): 函数参数
            kwargs (dict): 函数关键字参数
            value (Any): 要缓存的数据
        """
        # 如果缓存已满，删除最久未访问的条目
        if len(self.cache) >= self.max_size:
            oldest_key = min(self.access_times.keys(), key=lambda k: self.access_times[k])
            del self.cache[oldest_key]
            del self.access_times[oldest_key]
            logger.info(f"缓存已满，删除最旧条目: {oldest_key}")
        
        key = self._get_cache_key(func_name, args, kwargs)
        self.cache[key] = value
        self.access_times[key] = time.time()
        logger.info(f"数据已缓存: {func_name}")

def cached(cache_instance: SimpleCache):
    """
    缓存装饰器
    
    Args:
        cache_instance (SimpleCache): 缓存实例
    """
    def decorator(func):
        @wraps(func)
        async def async_wrapper(*args, **kwargs):
            # 检查缓存
            cached_result = cache_instance.get(func.__name__, args, kwargs)
            if cached_result is not None:
                return cached_result
            
            # 执行函数
            result = await func(*args, **kwargs)
            
            # 缓存结果
            cache_instance.set(func.__name__, args, kwargs, result)
            return result
        
        @wraps(func)
        def sync_wrapper(*args, **kwargs):
            # 检查缓存
            cached_result = cache_instance.get(func.__name__, args, kwargs)
            if cached_result is not None:
                return cached_result
            
            # 执行函数
            result = func(*args, **kwargs)
            
            # 缓存结果
            cache_instance.set(func.__name__, args, kwargs, result)
            return result
        
        # 根据函数是否为异步函数返回相应的包装器
        return async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper
    
    return decorator

class AITaskOptimizer:
    """AI 任务优化器"""
    
    def __init__(self):
        """初始化 AI 任务优化器"""
        self.cache = SimpleCache(max_size=50)
    
    @cached(cache_instance=None)  # 这里会在运行时替换为实际的缓存实例
    async def data_preprocessing(self, data_id: int, data: List[float]) -> List[float]:
        """
        数据预处理任务（带缓存）
        
        Args:
            data_id (int): 数据 ID
            data (List[float]): 原始数据
            
        Returns:
            List[float]: 预处理后的数据
        """
        logger.info(f"开始预处理数据 {data_id}")
        
        # 模拟数据预处理过程
        processed_data = []
        for i, value in enumerate(data):
            # 模拟复杂的预处理计算
            await asyncio.sleep(0.01)  # 模拟计算耗时
            processed_value = value * 1.1 + 0.5  # 简单的预处理操作
            processed_data.append(processed_value)
        
        logger.info(f"数据 {data_id} 预处理完成")
        return processed_data
    
    # 替换装饰器中的缓存实例
    data_preprocessing = cached(cache)(data_preprocessing)
    
    async def model_inference(self, model_id: str, input_data: List[float]) -> Dict[str, float]:
        """
        模型推理任务
        
        Args:
            model_id (str): 模型 ID
            input_data (List[float]): 输入数据
            
        Returns:
            Dict[str, float]: 推理结果
        """
        logger.info(f"开始使用模型 {model_id} 进行推理")
        
        # 模拟模型推理过程
        await asyncio.sleep(0.1)  # 模拟推理耗时
        
        # 简单的推理逻辑（实际应用中会调用真实的模型）
        result = {
            'prediction': sum(input_data) / len(input_data),  # 平均值作为预测结果
            'confidence': 0.95  # 置信度
        }
        
        logger.info(f"模型 {model_id} 推理完成")
        return result
    
    async def batch_process_data(self, data_batches: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        批量处理数据（并行处理）
        
        Args:
            data_batches (List[Dict[str, Any]]): 数据批次列表
            
        Returns:
            List[Dict[str, Any]]: 处理结果列表
        """
        logger.info(f"开始批量处理 {len(data_batches)} 个数据批次")
        
        # 创建任务列表
        tasks = []
        for batch in data_batches:
            task = self._process_single_batch(batch)
            tasks.append(task)
        
        # 并行执行所有任务
        results = await asyncio.gather(*tasks, return_exceptions=True)
        
        # 处理结果
        processed_results = []
        for i, result in enumerate(results):
            if isinstance(result, Exception):
                logger.error(f"处理批次 {i} 时发生错误: {result}")
                processed_results.append({
                    'batch_id': data_batches[i]['batch_id'],
                    'status': 'failed',
                    'error': str(result)
                })
            else:
                processed_results.append(result)
        
        logger.info(f"批量处理完成，成功处理 {len([r for r in processed_results if r.get('status') != 'failed'])} 个批次")
        return processed_results
    
    async def _process_single_batch(self, batch: Dict[str, Any]) -> Dict[str, Any]:
        """
        处理单个数据批次
        
        Args:
            batch (Dict[str, Any]): 数据批次
            
        Returns:
            Dict[str, Any]: 处理结果
        """
        batch_id = batch['batch_id']
        data = batch['data']
        model_id = batch.get('model_id', 'default_model')
        
        try:
            logger.info(f"开始处理批次 {batch_id}")
            
            # 数据预处理（带缓存）
            processed_data = await self.data_preprocessing(batch_id, data)
            
            # 模型推理
            inference_result = await self.model_inference(model_id, processed_data)
            
            result = {
                'batch_id': batch_id,
                'status': 'success',
                'processed_data': processed_data,
                'inference_result': inference_result,
                'processed_at': time.time()
            }
            
            logger.info(f"批次 {batch_id} 处理完成")
            return result
            
        except Exception as e:
            logger.error(f"处理批次 {batch_id} 时发生错误: {e}")
            return {
                'batch_id': batch_id,
                'status': 'failed',
                'error': str(e),
                'processed_at': time.time()
            }

# 模拟大量数据处理
def generate_test_data(batch_count: int = 10) -> List[Dict[str, Any]]:
    """
    生成测试数据
    
    Args:
        batch_count (int): 批次数量
        
    Returns:
        List[Dict[str, Any]]: 测试数据
    """
    import random
    
    data_batches = []
    for i in range(batch_count):
        batch = {
            'batch_id': f'batch_{i}',
            'model_id': f'model_{i % 3}',  # 循环使用 3 个模型
            'data': [random.uniform(0, 100) for _ in range(50)]  # 50 个随机数据点
        }
        data_batches.append(batch)
    
    return data_batches

# 使用示例
async def main():
    """主函数"""
    # 创建 AI 任务优化器
    optimizer = AITaskOptimizer()
    
    # 生成测试数据
    test_data = generate_test_data(batch_count=20)
    logger.info(f"生成 {len(test_data)} 个测试数据批次")
    
    # 记录开始时间
    start_time = time.time()
    
    # 批量处理数据
    results = await optimizer.batch_process_data(test_data)
    
    # 记录结束时间
    end_time = time.time()
    
    # 统计结果
    successful_batches = len([r for r in results if r.get('status') == 'success'])
    failed_batches = len([r for r in results if r.get('status') == 'failed'])
    
    logger.info(f"=== 处理结果统计 ===")
    logger.info(f"总批次数量: {len(results)}")
    logger.info(f"成功处理: {successful_batches}")
    logger.info(f"处理失败: {failed_batches}")
    logger.info(f"总耗时: {end_time - start_time:.2f} 秒")
    
    # 展示部分结果
    logger.info(f"=== 部分处理结果 ===")
    for i, result in enumerate(results[:3]):  # 显示前 3 个结果
        if result.get('status') == 'success':
            logger.info(f"批次 {result['batch_id']}:")
            logger.info(f"  预测结果: {result['inference_result']['prediction']:.2f}")
            logger.info(f"  置信度: {result['inference_result']['confidence']:.2f}")
        else:
            logger.info(f"批次 {result['batch_id']}: 处理失败 - {result.get('error', '未知错误')}")

if __name__ == "__main__":
    asyncio.run(main())