class EnhancedModelHealthMonitor:
    """增强版模型健康度监测器的核心架构"""
    health_metrics = {
        "system_metrics": deque(maxlen=100),      # 系统指标 - 硬件资源状态
        "model_metrics": deque(maxlen=100),       # 模型指标 - 推理性能状态  
        "performance_metrics": deque(maxlen=50),  # 性能指标 - 服务质量状态
        "alerts": deque(maxlen=20),               # 告警信息 - 风险预警状态
        "generation_stats": deque(maxlen=50)      # 生成统计 - 业务质量状态
    }

def calculate_performance_score(self, system_metrics, model_metrics):
    """智能性能评分算法 - 基于大模型服务特性的专业评分体系"""
    score = 100  # 基准分数
    
    # CPU性能 (权重: 25%) - 考虑到大模型推理对CPU计算资源的敏感度
    cpu_score = max(0, 100 - system_metrics["cpu_usage"])
    score += cpu_score * 0.25
    
    # 内存性能 (权重: 25%) - 大模型对内存带宽和容量要求极高
    memory_score = max(0, 100 - system_metrics["memory_usage"])
    score += memory_score * 0.25
    
    # 推理性能 (权重: 30%) - 核心业务指标，直接影响用户体验
    if model_metrics["inference_speed"] > 0:
        # 推理时间超过3秒将显著影响用户体验
        inference_score = max(0, 100 - (model_metrics["inference_speed"] * 20))
        score += inference_score * 0.30
    else:
        score += 30  # 默认分数，确保系统在模型未加载时仍有基本评分
    
    # 吞吐量性能 (权重: 20%) - 反映系统整体处理能力
    throughput = model_metrics.get("throughput_tokens_per_sec", 0)
    throughput_score = min(100, throughput * 2)  # 假设50 tokens/秒为满分
    score += throughput_score * 0.20
    
    return max(0, min(100, score))  # 确保分数在合理范围内

# enhanced_model_health_monitor.py
from flask import Flask, jsonify, render_template, request
from flask_cors import CORS
import psutil
import time
import json
import threading
from datetime import datetime, timedelta
import numpy as np
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
import logging
from collections import deque
import os
import random
from modelscope import snapshot_download
# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
app = Flask(__name__)
CORS(app)
class EnhancedModelHealthMonitor:
    """增强版模型健康度监测器"""
    
    def __init__(self, model_name="qwen/Qwen1.5-1.8B-Chat"):
        self.model_name = model_name
        self.health_metrics = {
            "system_metrics": deque(maxlen=100),
            "model_metrics": deque(maxlen=100),
            "performance_metrics": deque(maxlen=50),
            "alerts": deque(maxlen=20),
            "generation_stats": deque(maxlen=50)
        }
        self.is_monitoring = False
        self.monitor_thread = None
        self.start_time = datetime.now()
        
        # 请求统计
        self.request_stats = {
            "total_requests": 0,
            "failed_requests": 0,
            "avg_response_time": 0,
            "requests_per_minute": 0
        }
        
        # 性能基准
        self.performance_baseline = {
            "inference_time": 1.0,  # 秒
            "memory_usage": 70,     # %
            "cpu_usage": 60         # %
        }
        
        # 加载模型
        self.load_model()
        
        # 生成样本数据（仅用于演示）
        self.generate_sample_data()
    
    def load_model(self):
        """加载模型"""
        try:
            logger.info(f"正在加载模型: {self.model_name}")
            model_path = snapshot_download("qwen/Qwen1.5-1.8B-Chat", cache_dir="D:\\modelscope\\hub")
            self.tokenizer = AutoTokenizer.from_pretrained(
                model_path, 
                trust_remote_code=True
            )
            
            if self.tokenizer.pad_token is None:
                self.tokenizer.pad_token = self.tokenizer.eos_token
            
            self.model = AutoModelForCausalLM.from_pretrained(
                model_path,
                torch_dtype=torch.float32,
                device_map="auto",
                trust_remote_code=True,
                low_cpu_mem_usage=True
            )
            self.model_loaded = True
            logger.info("模型加载成功")
            
            # 记录模型信息
            self.model_info = {
                "name": self.model_name,
                "parameters": sum(p.numel() for p in self.model.parameters()),
                "loaded_at": datetime.now().isoformat()
            }
            
        except Exception as e:
            logger.error(f"模型加载失败: {e}")
            self.model_loaded = False
            self.model_info = {"error": str(e)}
    
    def generate_sample_data(self):
        """生成样本数据用于测试"""
        base_time = datetime.now() - timedelta(minutes=30)
        
        # 生成系统指标样本数据
        for i in range(20):
            timestamp = (base_time + timedelta(minutes=i * 1.5)).isoformat()
            self.health_metrics["system_metrics"].append({
                "timestamp": timestamp,
                "cpu_usage": random.uniform(20, 80),
                "memory_usage": random.uniform(40, 85),
                "memory_used_gb": round(random.uniform(2, 8), 2),
                "memory_total_gb": 16,
                "disk_usage": random.uniform(50, 90),
                "network_sent_mb": round(random.uniform(10, 100), 2),
                "network_recv_mb": round(random.uniform(50, 200), 2),
                "process_memory_mb": round(random.uniform(500, 2000), 2),
                "system_uptime_hours": round(random.uniform(1, 100), 2),
                "gpu_info": {"gpu_available": False}
            })
        
        # 生成模型指标样本数据
        for i in range(20):
            timestamp = (base_time + timedelta(minutes=i * 1.5)).isoformat()
            inference_time = random.uniform(0.5, 3.0)
            self.health_metrics["model_metrics"].append({
                "timestamp": timestamp,
                "model_status": "loaded",
                "inference_speed": round(inference_time, 4),
                "memory_footprint_gb": round(random.uniform(2, 4), 2),
                "throughput_tokens_per_sec": round(50 / inference_time, 2),
                "model_parameters_billions": 1.8
            })
        
        # 生成性能指标样本数据
        for i in range(20):
            timestamp = (base_time + timedelta(minutes=i * 1.5)).isoformat()
            self.health_metrics["performance_metrics"].append({
                "timestamp": timestamp,
                "performance_score": random.randint(60, 95),
                "request_stats": {
                    "total_requests": random.randint(50, 200),
                    "failed_requests": random.randint(0, 5),
                    "avg_response_time": round(random.uniform(0.8, 2.5), 3),
                    "requests_per_minute": round(random.uniform(1, 10), 1)
                }
            })
        
        # 生成生成统计样本数据
        base_time = datetime.now() - timedelta(minutes=10)
        for i in range(8):
            timestamp = (base_time + timedelta(minutes=i)).isoformat()
            inference_time = random.uniform(0.5, 2.5)
            response_length = random.randint(50, 200)
            self.health_metrics["generation_stats"].append({
                "timestamp": timestamp,
                "prompt_length": random.randint(10, 50),
                "response_length": response_length,
                "inference_time": round(inference_time, 4),
                "tokens_per_second": round(response_length / inference_time, 2)
            })
        
        logger.info("样本数据生成完成")
    
    def collect_enhanced_system_metrics(self):
        """收集增强的系统指标"""
        # 基础系统指标
        cpu_percent = psutil.cpu_percent(interval=1)
        memory = psutil.virtual_memory()
        disk = psutil.disk_usage('/')
        
        # 网络指标
        net_io = psutil.net_io_counters()
        
        # 进程指标
        process = psutil.Process()
        process_memory = process.memory_info()
        
        # 系统启动时间
        boot_time = datetime.fromtimestamp(psutil.boot_time())
        uptime = datetime.now() - boot_time
        
        # GPU信息
        gpu_info = self.get_gpu_info()
        
        return {
            "timestamp": datetime.now().isoformat(),
            "cpu_usage": cpu_percent,
            "memory_usage": memory.percent,
            "memory_used_gb": round(memory.used / (1024 ** 3), 2),
            "memory_total_gb": round(memory.total / (1024 ** 3), 2),
            "disk_usage": disk.percent,
            "network_sent_mb": round(net_io.bytes_sent / (1024 ** 2), 2),
            "network_recv_mb": round(net_io.bytes_recv / (1024 ** 2), 2),
            "process_memory_mb": round(process_memory.rss / (1024 ** 2), 2),
            "system_uptime_hours": round(uptime.total_seconds() / 3600, 2),
            "gpu_info": gpu_info
        }
    
    def get_gpu_info(self):
        """获取GPU信息"""
        # try:
        #     gpus = GPUtil.getGPUs()
        #     if gpus:
        #         gpu = gpus[0]
        #         return {
        #             "gpu_available": True,
        #             "gpu_usage": gpu.load * 100,
        #             "gpu_memory_used": gpu.memoryUsed,
        #             "gpu_memory_total": gpu.memoryTotal,
        #             "gpu_memory_percent": (gpu.memoryUsed / gpu.memoryTotal) * 100,
        #             "gpu_temperature": gpu.temperature
        #         }
        # except Exception as e:
        #     logger.warning(f"无法获取GPU信息: {e}")
        
        return {"gpu_available": False}
    
    def collect_enhanced_model_metrics(self):
        """收集增强的模型指标"""
        if not self.model_loaded:
            return {
                "timestamp": datetime.now().isoformat(),
                "model_status": "not_loaded",
                "inference_speed": 0,
                "memory_footprint": 0,
                "throughput": 0
            }
        
        # 模型内存占用
        try:
            param_size = sum(p.numel() * p.element_size() for p in self.model.parameters())
            buffer_size = sum(b.numel() * b.element_size() for b in self.model.buffers())
            memory_footprint = param_size + buffer_size
        except:
            memory_footprint = 0
        
        # 推理性能测试
        inference_time = self.test_inference_speed()
        
        # 计算吞吐量（tokens/秒）
        throughput = 50 / inference_time if inference_time > 0 else 0
        
        return {
            "timestamp": datetime.now().isoformat(),
            "model_status": "loaded",
            "inference_speed": round(inference_time, 4),
            "memory_footprint_gb": round(memory_footprint / (1024 ** 3), 2),
            "throughput_tokens_per_sec": round(throughput, 2),
            "model_parameters_billions": round(self.model_info.get("parameters", 0) / 1e9, 2)
        }
    
    def test_inference_speed(self):
        """测试推理速度"""
        test_prompts = [
            "人工智能的未来发展",
            "机器学习的基本原理",
            "深度学习在自然语言处理中的应用"
        ]
        
        total_time = 0
        successful_tests = 0
        
        for prompt in test_prompts:
            try:
                start_time = time.time()
                inputs = self.tokenizer.encode(prompt, return_tensors="pt")
                with torch.no_grad():
                    _ = self.model.generate(
                        inputs,
                        max_length=30,
                        num_return_sequences=1,
                        do_sample=False
                    )
                end_time = time.time()
                total_time += (end_time - start_time)
                successful_tests += 1
            except Exception as e:
                logger.warning(f"推理测试失败: {e}")
                continue
        
        return total_time / successful_tests if successful_tests > 0 else 0
    
    def update_request_stats(self, response_time, success=True):
        """更新请求统计"""
        self.request_stats["total_requests"] += 1
        if not success:
            self.request_stats["failed_requests"] += 1
        
        # 更新平均响应时间（移动平均）
        old_avg = self.request_stats["avg_response_time"]
        count = self.request_stats["total_requests"]
        self.request_stats["avg_response_time"] = (
            old_avg * (count - 1) + response_time
        ) / count if count > 0 else response_time
    
    def calculate_performance_score(self, system_metrics, model_metrics):
        """计算性能评分"""
        score = 100
        
        # CPU性能 (权重: 25%)
        cpu_score = max(0, 100 - system_metrics["cpu_usage"])
        score += cpu_score * 0.25
        
        # 内存性能 (权重: 25%)
        memory_score = max(0, 100 - system_metrics["memory_usage"])
        score += memory_score * 0.25
        
        # 推理性能 (权重: 30%)
        if model_metrics["inference_speed"] > 0:
            inference_score = max(0, 100 - (model_metrics["inference_speed"] * 20))
            score += inference_score * 0.30
        else:
            score += 30  # 默认分数
        
        # 吞吐量性能 (权重: 20%)
        throughput = model_metrics.get("throughput_tokens_per_sec", 0)
        throughput_score = min(100, throughput * 2)  # 假设50 tokens/秒为满分
        score += throughput_score * 0.20
        
        return max(0, min(100, score))
    
    def check_enhanced_alerts(self, system_metrics, model_metrics):
        """检查增强的告警"""
        alerts = []
        
        # 系统资源告警
        if system_metrics["cpu_usage"] > 85:
            alerts.append({
                "level": "warning",
                "type": "system",
                "message": f"CPU使用率过高: {system_metrics['cpu_usage']}%",
                "timestamp": datetime.now().isoformat()
            })
        
        if system_metrics["memory_usage"] > 90:
            alerts.append({
                "level": "critical",
                "type": "system", 
                "message": f"内存使用率严重过高: {system_metrics['memory_usage']}%",
                "timestamp": datetime.now().isoformat()
            })
        
        if system_metrics["disk_usage"] > 95:
            alerts.append({
                "level": "critical",
                "type": "system",
                "message": f"磁盘空间严重不足: {system_metrics['disk_usage']}%",
                "timestamp": datetime.now().isoformat()
            })
        
        # 模型性能告警
        if model_metrics["inference_speed"] > 3.0:
            alerts.append({
                "level": "warning",
                "type": "model",
                "message": f"模型推理速度过慢: {model_metrics['inference_speed']}秒",
                "timestamp": datetime.now().isoformat()
            })
        
        if model_metrics.get("throughput_tokens_per_sec", 0) < 10:
            alerts.append({
                "level": "warning", 
                "type": "model",
                "message": f"模型吞吐量过低: {model_metrics.get('throughput_tokens_per_sec', 0)} tokens/秒",
                "timestamp": datetime.now().isoformat()
            })
        
        # 请求成功率告警
        total_requests = self.request_stats["total_requests"]
        if total_requests > 10:
            failure_rate = (self.request_stats["failed_requests"] / total_requests) * 100
            if failure_rate > 10:
                alerts.append({
                    "level": "warning",
                    "type": "service",
                    "message": f"请求失败率过高: {failure_rate:.1f}%",
                    "timestamp": datetime.now().isoformat()
                })
        
        return alerts
    
    def monitoring_loop(self):
        """监控循环"""
        while self.is_monitoring:
            try:
                # 收集指标
                system_metrics = self.collect_enhanced_system_metrics()
                model_metrics = self.collect_enhanced_model_metrics()
                
                # 计算性能评分
                performance_score = self.calculate_performance_score(system_metrics, model_metrics)
                performance_metrics = {
                    "timestamp": datetime.now().isoformat(),
                    "performance_score": performance_score,
                    "request_stats": self.request_stats.copy()
                }
                
                # 检查告警
                alerts = self.check_enhanced_alerts(system_metrics, model_metrics)
                
                # 更新指标历史
                self.health_metrics["system_metrics"].append(system_metrics)
                self.health_metrics["model_metrics"].append(model_metrics)
                self.health_metrics["performance_metrics"].append(performance_metrics)
                
                for alert in alerts:
                    self.health_metrics["alerts"].append(alert)
                
            except Exception as e:
                logger.error(f"监控收集错误: {e}")
            
            time.sleep(5)  # 5秒间隔
    
    def start_monitoring(self):
        """开始监控"""
        if not self.is_monitoring:
            self.is_monitoring = True
            self.monitor_thread = threading.Thread(target=self.monitoring_loop)
            self.monitor_thread.daemon = True
            self.monitor_thread.start()
            logger.info("增强版模型健康度监控已启动")
    
    def stop_monitoring(self):
        """停止监控"""
        self.is_monitoring = False
        if self.monitor_thread:
            self.monitor_thread.join(timeout=10)
        logger.info("增强版模型健康度监控已停止")
    
    def get_enhanced_health_status(self):
        """获取增强的健康状态"""
        if not self.health_metrics["system_metrics"]:
            return {"status": "no_data"}
        
        latest_system = self.health_metrics["system_metrics"][-1]
        latest_model = self.health_metrics["model_metrics"][-1]
        latest_performance = self.health_metrics["performance_metrics"][-1] if self.health_metrics["performance_metrics"] else {"performance_score": 0}
        
        # 确定状态等级
        performance_score = latest_performance["performance_score"]
        if performance_score >= 80:
            status = "healthy"
        elif performance_score >= 60:
            status = "warning" 
        else:
            status = "critical"
        
        # 计算服务运行时间
        service_uptime = datetime.now() - self.start_time
        uptime_hours = round(service_uptime.total_seconds() / 3600, 2)
        
        return {
            "status": status,
            "performance_score": performance_score,
            "service_uptime_hours": uptime_hours,
            "model_loaded": self.model_loaded,
            "model_info": self.model_info,
            "latest_system": latest_system,
            "latest_model": latest_model,
            "request_stats": self.request_stats,
            "active_alerts": len([a for a in list(self.health_metrics["alerts"])[-10:] 
                                if a["level"] in ["warning", "critical"]])
        }
    # 新增的分析数据方法
    def get_inference_analysis_data(self):
        """获取推理时间分析数据"""
        if not self.health_metrics["model_metrics"]:
            return {"timestamps": [], "inference_times": [], "throughputs": []}
        
        model_metrics = list(self.health_metrics["model_metrics"])
        
        timestamps = []
        inference_times = []
        throughputs = []
        
        for metric in model_metrics[-20:]:  # 取最近20个数据点
            timestamps.append(metric["timestamp"])
            inference_times.append(metric["inference_speed"])
            throughputs.append(metric.get("throughput_tokens_per_sec", 0))
        
        return {
            "timestamps": timestamps,
            "inference_times": inference_times,
            "throughputs": throughputs
        }
    def get_throughput_analysis_data(self):
        """获取吞吐量分析数据"""
        if not self.health_metrics["model_metrics"]:
            return {"timestamps": [], "throughputs": [], "target_throughput": 50}
        
        model_metrics = list(self.health_metrics["model_metrics"])
        
        timestamps = []
        throughputs = []
        
        for metric in model_metrics[-20:]:
            timestamps.append(metric["timestamp"])
            throughputs.append(metric.get("throughput_tokens_per_sec", 0))
        
        # 计算吞吐量统计
        if throughputs:
            avg_throughput = sum(throughputs) / len(throughputs)
            max_throughput = max(throughputs)
            min_throughput = min(throughputs)
        else:
            avg_throughput = max_throughput = min_throughput = 0
        
        return {
            "timestamps": timestamps,
            "throughputs": throughputs,
            "statistics": {
                "average": round(avg_throughput, 2),
                "maximum": round(max_throughput, 2),
                "minimum": round(min_throughput, 2),
                "target": 50  # 目标吞吐量
            }
        }
    def get_request_analysis_data(self):
        """获取请求分析数据"""
        # 从生成统计中获取请求数据
        generation_stats = list(self.health_metrics["generation_stats"])
        
        if not generation_stats:
            return {
                "timestamps": [],
                "response_times": [],
                "tokens_per_second": [],
                "request_lengths": []
            }
        
        timestamps = []
        response_times = []
        tokens_per_second = []
        request_lengths = []
        
        for stat in generation_stats[-15:]:  # 取最近15个生成请求
            timestamps.append(stat["timestamp"])
            response_times.append(stat["inference_time"])
            tokens_per_second.append(stat["tokens_per_second"])
            request_lengths.append(stat["response_length"])
        
        return {
            "timestamps": timestamps,
            "response_times": response_times,
            "tokens_per_second": tokens_per_second,
            "request_lengths": request_lengths
        }
    def get_generation_stats_data(self):
        """获取生成统计数据分析"""
        generation_stats = list(self.health_metrics["generation_stats"])
        
        if not generation_stats:
            return {
                "timestamps": [],
                "performance_data": [],
                "statistics": {
                    "total_requests": 0,
                    "avg_response_time": 0,
                    "avg_tokens_per_sec": 0,
                    "success_rate": 100
                }
            }
        
        timestamps = []
        response_times = []
        tokens_per_second = []
        
        for stat in generation_stats:
            timestamps.append(stat["timestamp"])
            response_times.append(stat["inference_time"])
            tokens_per_second.append(stat["tokens_per_second"])
        
        # 计算统计信息
        total_requests = len(generation_stats)
        avg_response_time = sum(response_times) / len(response_times) if response_times else 0
        avg_tokens_per_sec = sum(tokens_per_second) / len(tokens_per_second) if tokens_per_second else 0
        
        return {
            "timestamps": timestamps,
            "performance_data": list(zip(timestamps, response_times, tokens_per_second)),
            "statistics": {
                "total_requests": total_requests,
                "avg_response_time": round(avg_response_time, 3),
                "avg_tokens_per_sec": round(avg_tokens_per_sec, 2),
                "success_rate": 100  # 简化处理，假设都是成功的
            }
        }
# 创建监控实例
monitor = EnhancedModelHealthMonitor()
# API路由
@app.route('/')
def index():
    return render_template('enhanced_index.html')
@app.route('/api/health/status')
def get_health_status():
    """获取当前健康状态"""
    status = monitor.get_enhanced_health_status()
    return jsonify(status)
@app.route('/api/health/metrics')
def get_health_metrics():
    """获取健康指标历史"""
    # 转换为列表返回
    recent_data = {
        "system_metrics": list(monitor.health_metrics["system_metrics"]),
        "model_metrics": list(monitor.health_metrics["model_metrics"]),
        "performance_metrics": list(monitor.health_metrics["performance_metrics"]),
        "alerts": list(monitor.health_metrics["alerts"]),
        "generation_stats": list(monitor.health_metrics["generation_stats"])
    }
    return jsonify(recent_data)
@app.route('/api/health/start')
def start_health_monitor():
    """启动健康监控"""
    monitor.start_monitoring()
    return jsonify({"message": "健康监控已启动"})
@app.route('/api/health/stop') 
def stop_health_monitor():
    """停止健康监控"""
    monitor.stop_monitoring()
    return jsonify({"message": "健康监控已停止"})
@app.route('/api/model/info')
def get_model_info():
    """获取模型信息"""
    return jsonify({
        "model_info": monitor.model_info,
        "model_loaded": monitor.model_loaded
    })
@app.route('/api/model/generate', methods=['POST'])
def generate_text():
    """模型生成文本API"""
    data = request.json
    prompt = data.get('prompt', '')
    max_length = data.get('max_length', 100)
    temperature = data.get('temperature', 0.7)
    
    if not monitor.model_loaded:
        return jsonify({"error": "模型未加载"}), 500
    
    start_time = time.time()
    
    try:
        inputs = monitor.tokenizer.encode(prompt, return_tensors="pt")
        with torch.no_grad():
            outputs = monitor.model.generate(
                inputs,
                max_length=max_length,
                temperature=temperature,
                do_sample=True,
                pad_token_id=monitor.tokenizer.eos_token_id,
                num_return_sequences=1
            )
        
        generated_text = monitor.tokenizer.decode(outputs[0], skip_special_tokens=True)
        inference_time = time.time() - start_time
        
        # 更新请求统计
        monitor.update_request_stats(inference_time, success=True)
        
        # 记录生成统计
        generation_stat = {
            "timestamp": datetime.now().isoformat(),
            "prompt_length": len(prompt),
            "response_length": len(generated_text),
            "inference_time": round(inference_time, 4),
            "tokens_per_second": round(len(generated_text.split()) / inference_time, 2)
        }
        monitor.health_metrics["generation_stats"].append(generation_stat)
        
        return jsonify({
            "generated_text": generated_text,
            "inference_time": round(inference_time, 4),
            "prompt_length": len(prompt),
            "response_length": len(generated_text),
            "tokens_per_second": generation_stat["tokens_per_second"]
        })
    
    except Exception as e:
        inference_time = time.time() - start_time
        monitor.update_request_stats(inference_time, success=False)
        logger.error(f"生成文本失败: {e}")
        return jsonify({"error": str(e)}), 500
@app.route('/api/system/restart', methods=['POST'])
def restart_monitor():
    """重启监控系统"""
    try:
        monitor.stop_monitoring()
        time.sleep(2)
        monitor.start_monitoring()
        return jsonify({"message": "监控系统重启成功"})
    except Exception as e:
        return jsonify({"error": str(e)}), 500
# 新增的分析API路由
@app.route('/api/analysis/inference')
def get_inference_analysis():
    """获取推理时间分析数据"""
    data = monitor.get_inference_analysis_data()
    return jsonify(data)
@app.route('/api/analysis/throughput')
def get_throughput_analysis():
    """获取吞吐量分析数据"""
    data = monitor.get_throughput_analysis_data()
    return jsonify(data)
@app.route('/api/analysis/requests')
def get_request_analysis():
    """获取请求分析数据"""
    data = monitor.get_request_analysis_data()
    return jsonify(data)
@app.route('/api/analysis/generation')
def get_generation_analysis():
    """获取生成统计分析数据"""
    data = monitor.get_generation_stats_data()
    return jsonify(data)
if __name__ == '__main__':
    # 启动时开始监控
    monitor.start_monitoring()
    logger.info("增强版模型健康度监测系统启动完成")
    app.run(debug=False, host='0.0.0.0', port=5000)