138_绿色计算：碳排放优化 - 估算部署的碳足迹与LLM环境友好型部署最佳实践

### 3.2 数据中心冷却优化

冷却系统是数据中心能源消耗的第二大来源，通常占总能耗的25-30%。针对LLM部署的高密度计算环境，优化冷却策略至关重要。以下是关键的冷却优化技术：

1. **冷热通道隔离优化**
   - **物理隔离实施**：使用挡板、门和天花板密封冷热通道
   - **气流组织设计**：优化机柜排列，确保冷空气直接进入设备进风口
   - **压力差控制**：维持冷通道正压、热通道负压，减少气流混合

2. **动态冷却控制**
   - **温度感知调节**：根据实时温度数据动态调整制冷设备输出
   - **CFD (计算流体动力学) 模拟**：预测气流模式，优化冷却布局
   - **AI驱动冷却**：使用机器学习算法预测负载变化，提前调整冷却

3. **高效制冷技术**
   - **间接蒸发冷却**：在适当气候条件下替代传统机械制冷
   - **液冷技术**：针对GPU集群的浸没式或冷板式液冷系统
   - **自然冷却利用**：充分利用外部冷空气，减少机械制冷需求

4. **温度设定点优化**
   - **提高冷通道温度**：ASHRAE建议的IT设备环境温度范围为18-27°C，适当提高设定点可显著降低能耗
   - **湿度控制优化**：保持适当湿度范围(40-60%)，避免过度除湿
   - **分层温度管理**：根据设备类型和发热特性设置不同区域的温度

以下是一个数据中心冷却优化系统的Python实现示例：

```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import time
from scipy.optimize import minimize
import random

# 确保中文显示正常
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

class CoolingOptimizer:
    def __init__(self):
        # 初始化系统参数
        self.room_dimensions = {"length": 50, "width": 30, "height": 4}  # 数据中心尺寸（米）
        self.rack_count = 30  # 机柜数量
        self.cooling_units = 8  # CRAC/ CRAH 数量
        self.ambient_temp_profile = None  # 环境温度曲线
        self.load_profile = None  # 负载曲线
        self.temperature_readings = None  # 温度读数
        self.cooling_efficiency = 0.75  # 初始冷却效率
        self.energy_consumption = []  # 能耗记录
    
    def generate_profiles(self, days=7, resolution="hourly"):
        """生成环境温度和负载曲线"""
        # 生成时间序列
        if resolution == "hourly":
            periods = days * 24
            freq = "H"
        elif resolution == "15min":
            periods = days * 24 * 4
            freq = "15min"
        else:
            periods = days * 24
            freq = "H"
        
        date_range = pd.date_range(end=datetime.now(), periods=periods, freq=freq)
        
        # 生成环境温度曲线（模拟昼夜和季节变化）
        ambient_temp = []
        for dt in date_range:
            hour = dt.hour
            weekday = dt.weekday()
            
            # 基础温度（白天高，夜晚低）
            base_temp = 20 + 5 * np.sin((hour - 6) * np.pi / 12)
            
            # 周末效应
            if weekday >= 5:
                base_temp -= 1
            
            # 添加随机波动
            temp = base_temp + 1.5 * np.random.random() - 0.75
            ambient_temp.append(temp)
        
        self.ambient_temp_profile = pd.DataFrame({
            "timestamp": date_range,
            "ambient_temp": ambient_temp
        })
        
        # 生成IT负载曲线（模拟工作负载变化）
        it_load = []
        for dt in date_range:
            hour = dt.hour
            weekday = dt.weekday()
            
            # 基础负载
            if weekday < 5:  # 工作日
                if 8 <= hour < 18:
                    # 工作时间 - 高峰负载
                    load = 80 + 15 * np.sin((hour - 8) * np.pi / 10) + 5 * np.random.random()
                else:
                    # 非工作时间 - 低负载
                    load = 40 + 10 * np.random.random()
            else:  # 周末
                # 周末负载较低
                load = 50 + 15 * np.random.random()
            
            # LLM特定负载模式 - 假设每天有2-3次推理高峰
            if weekday < 5:
                for peak_hour in [10, 14, 16]:
                    if abs(hour - peak_hour) < 1:
                        load += 20 * np.exp(-0.5 * ((hour - peak_hour) / 0.5) ** 2)
            
            it_load.append(min(load, 100))  # 上限为100%
        
        self.load_profile = pd.DataFrame({
            "timestamp": date_range,
            "it_load_percentage": it_load
        })
        
        return self.ambient_temp_profile, self.load_profile
    
    def simulate_temperature_distribution(self, hot_aisle_cold_aisle=True, cooling_setting=70):
        """模拟数据中心温度分布"""
        if self.load_profile is None:
            self.generate_profiles()
        
        # 创建模拟温度传感器网格
        grid_size = 5  # 每维传感器数量
        x_coords = np.linspace(0, self.room_dimensions["length"], grid_size)
        y_coords = np.linspace(0, self.room_dimensions["width"], grid_size)
        
        # 模拟机柜位置（假设均匀分布）
        rack_positions = []
        rack_spacing = self.room_dimensions["length"] / (self.rack_count/2)
        for i in range(self.rack_count):
            row = i % 2
            col = i // 2
            rack_positions.append((col * rack_spacing + rack_spacing/2, 
                                 self.room_dimensions["width"] * 0.3 if row == 0 else self.room_dimensions["width"] * 0.7))
        
        # 对每个时间点模拟温度分布
        temperature_data = []
        
        for idx, row in self.load_profile.iterrows():
            timestamp = row["timestamp"]
            load_percentage = row["it_load_percentage"]
            
            # 获取对应时间的环境温度
            ambient_temp = self.ambient_temp_profile.iloc[idx]["ambient_temp"]
            
            # 计算冷却效率影响
            cooling_factor = cooling_setting / 100.0  # 冷却设置 (0-100)
            
            # 模拟每个传感器点的温度
            for x in x_coords:
                for y in y_coords:
                    # 基础温度受环境和冷却设置影响
                    base_temp = ambient_temp - (ambient_temp - 20) * cooling_factor * self.cooling_efficiency
                    
                    # 机柜散热影响 - 计算到最近机柜的距离
                    min_distance = float('inf')
                    for (rack_x, rack_y) in rack_positions:
                        distance = np.sqrt((x - rack_x)**2 + (y - rack_y)**2)
                        min_distance = min(min_distance, distance)
                    
                    # 距离越近，温度越高
                    if min_distance < 3:  # 3米内受机柜影响
                        heat_contribution = (3 - min_distance) * 2 * (load_percentage / 100)
                        base_temp += heat_contribution
                    
                    # 冷热通道效应
                    if hot_aisle_cold_aisle:
                        # 简化模型：假设y=width/2附近为冷热通道分隔线
                        aisle_factor = 1.0
                        if y < self.room_dimensions["width"] * 0.45:
                            aisle_factor = 0.9  # 冷通道温度较低
                        elif y > self.room_dimensions["width"] * 0.55:
                            aisle_factor = 1.1  # 热通道温度较高
                        
                        base_temp *= aisle_factor
                    
                    # 添加随机波动
                    base_temp += np.random.normal(0, 0.5)
                    
                    temperature_data.append({
                        "timestamp": timestamp,
                        "x": x,
                        "y": y,
                        "temperature": base_temp,
                        "load_percentage": load_percentage,
                        "cooling_setting": cooling_setting
                    })
        
        self.temperature_readings = pd.DataFrame(temperature_data)
        return self.temperature_readings
    
    def calculate_energy_consumption(self, cooling_setting=70):
        """计算冷却系统能耗"""
        if self.temperature_readings is None:
            self.simulate_temperature_distribution(cooling_setting=cooling_setting)
        
        # 简化能耗模型
        # 假设基础能耗为100 kW，随冷却设置和环境温度变化
        energy_data = []
        
        # 按时间聚合温度数据
        temp_by_time = self.temperature_readings.groupby("timestamp").agg({
            "temperature": "mean",
            "load_percentage": "first",
            "cooling_setting": "first"
        }).reset_index()
        
        for idx, row in temp_by_time.iterrows():
            timestamp = row["timestamp"]
            avg_temp = row["temperature"]
            load_percentage = row["load_percentage"]
            cooling = row["cooling_setting"]
            
            # 获取对应时间的环境温度
            ambient_temp = self.ambient_temp_profile[self.ambient_temp_profile["timestamp"] == timestamp]["ambient_temp"].values[0]
            
            # 基础能耗 (kW)
            base_power = 100
            
            # 冷却设置影响 - 设置越高，能耗越大
            setting_factor = 1 + (cooling - 50) * 0.02
            
            # 环境温度影响 - 温度越高，冷却能耗越大
            temp_factor = 1 + (ambient_temp - 20) * 0.03
            
            # 负载影响 - 负载越高，需要的冷却越多
            load_factor = 1 + (load_percentage - 50) * 0.01
            
            # 计算实际能耗
            power_consumption = base_power * setting_factor * temp_factor * load_factor * (1 - self.cooling_efficiency)
            
            energy_data.append({
                "timestamp": timestamp,
                "power_consumption": power_consumption,
                "cooling_setting": cooling,
                "ambient_temp": ambient_temp,
                "load_percentage": load_percentage
            })
        
        energy_df = pd.DataFrame(energy_data)
        self.energy_consumption = energy_df
        
        # 计算总能耗
        total_energy = energy_df["power_consumption"].sum() / 1000  # 转换为MWh
        
        print(f"模拟期间总冷却能耗: {total_energy:.2f} MWh")
        print(f"平均功率消耗: {energy_df['power_consumption'].mean():.2f} kW")
        
        return energy_df, total_energy
    
    def optimize_cooling_settings(self):
        """优化冷却设置以平衡温度控制和能耗"""
        # 定义优化目标函数
        def objective(cooling_param):
            cooling_setting = cooling_param[0]
            
            # 模拟温度分布
            self.simulate_temperature_distribution(cooling_setting=cooling_setting)
            
            # 计算能耗
            energy_df, total_energy = self.calculate_energy_consumption(cooling_setting=cooling_setting)
            
            # 计算平均和最大温度
            avg_temp = self.temperature_readings["temperature"].mean()
            max_temp = self.temperature_readings["temperature"].max()
            
            # 目标函数：最小化能耗 + 温度违规惩罚
            # 温度目标：平均24°C，最大不超过27°C
            temp_penalty = 0
            if avg_temp > 24:
                temp_penalty += (avg_temp - 24) * 100  # 每度超额增加100的惩罚
            if max_temp > 27:
                temp_penalty += (max_temp - 27) * 500  # 高温惩罚更严厉
            
            # 如果温度过低也有小幅惩罚
            if avg_temp < 18:
                temp_penalty += (18 - avg_temp) * 50
            
            return total_energy + temp_penalty
        
        # 设置优化约束
        bounds = [(30, 100)]  # 冷却设置范围
        
        # 初始猜测
        initial_guess = [70]
        
        # 执行优化
        result = minimize(objective, initial_guess, bounds=bounds, method='L-BFGS-B')
        
        optimal_cooling = result.x[0]
        min_objective_value = result.fun
        
        # 运行优化后的冷却设置
        self.simulate_temperature_distribution(cooling_setting=optimal_cooling)
        optimized_energy, total_energy_opt = self.calculate_energy_consumption(cooling_setting=optimal_cooling)
        
        # 计算优化前后对比
        # 先计算默认设置下的能耗
        self.simulate_temperature_distribution(cooling_setting=70)
        default_energy, total_energy_default = self.calculate_energy_consumption(cooling_setting=70)
        
        savings_percentage = (total_energy_default - total_energy_opt) / total_energy_default * 100
        
        print(f"\n优化结果:")
        print(f"最佳冷却设置: {optimal_cooling:.1f}%")
        print(f"优化前总能耗: {total_energy_default:.2f} MWh")
        print(f"优化后总能耗: {total_energy_opt:.2f} MWh")
        print(f"节能百分比: {savings_percentage:.1f}%")
        
        # 验证优化后的温度
        avg_temp_opt = self.temperature_readings["temperature"].mean()
        max_temp_opt = self.temperature_readings["temperature"].max()
        
        print(f"优化后平均温度: {avg_temp_opt:.1f}°C")
        print(f"优化后最高温度: {max_temp_opt:.1f}°C")
        
        return {
            "optimal_cooling_setting": optimal_cooling,
            "energy_savings_percentage": savings_percentage,
            "optimized_energy_consumption": total_energy_opt,
            "temperature_stats": {
                "average": avg_temp_opt,
                "maximum": max_temp_opt
            }
        }
    
    def implement_hot_cold_aisle_optimization(self):
        """模拟冷热通道优化的效果"""
        # 模拟优化前（无冷热通道隔离）
        self.simulate_temperature_distribution(hot_aisle_cold_aisle=False)
        energy_no_isolation, total_energy_no = self.calculate_energy_consumption()
        
        # 模拟优化后（有冷热通道隔离）
        self.simulate_temperature_distribution(hot_aisle_cold_aisle=True)
        energy_with_isolation, total_energy_with = self.calculate_energy_consumption()
        
        # 计算改进
        improvement = (total_energy_no - total_energy_with) / total_energy_no * 100
        
        # 比较温度分布
        avg_temp_no = energy_no_isolation["power_consumption"].mean()
        avg_temp_with = energy_with_isolation["power_consumption"].mean()
        
        print(f"\n冷热通道隔离效果:")
        print(f"无隔离总能耗: {total_energy_no:.2f} MWh")
        print(f"有隔离总能耗: {total_energy_with:.2f} MWh")
        print(f"能耗降低: {improvement:.1f}%")
        
        # 计算温度标准差，衡量温度均匀性
        temp_std_no = self.temperature_readings["temperature"].std() if not hot_aisle_cold_aisle else 0
        temp_std_with = self.temperature_readings["temperature"].std() if hot_aisle_cold_aisle else 0
        
        if temp_std_no > 0:
            print(f"温度均匀性改善: {(temp_std_no - temp_std_with) / temp_std_no * 100:.1f}%")
        
        return {
            "energy_reduction_percentage": improvement,
            "energy_saved": total_energy_no - total_energy_with
        }
    
    def implement_dynamic_cooling_control(self):
        """实施动态冷却控制策略"""
        if self.load_profile is None:
            self.generate_profiles()
        
        # 动态调整冷却设置
        dynamic_settings = []
        
        for idx, row in self.load_profile.iterrows():
            timestamp = row["timestamp"]
            load_percentage = row["load_percentage"]
            
            # 获取环境温度
            ambient_temp = self.ambient_temp_profile.iloc[idx]["ambient_temp"]
            
            # 基础冷却设置
            base_setting = 60
            
            # 基于负载调整
            load_adjustment = (load_percentage - 50) * 0.3  # 负载每变化10%，冷却设置调整3%
            
            # 基于环境温度调整
            temp_adjustment = (ambient_temp - 20) * 2  # 环境温度每变化1°C，冷却设置调整2%
            
            # 计算最终冷却设置，限制在合理范围内
            cooling_setting = max(30, min(100, base_setting + load_adjustment + temp_adjustment))
            
            dynamic_settings.append({
                "timestamp": timestamp,
                "cooling_setting": cooling_setting,
                "load_percentage": load_percentage,
                "ambient_temp": ambient_temp
            })
        
        dynamic_df = pd.DataFrame(dynamic_settings)
        
        # 模拟动态冷却控制的能耗
        total_dynamic_energy = 0
        all_temp_readings = []
        
        # 对每个时间点单独模拟
        for idx, setting_row in dynamic_df.iterrows():
            # 模拟当前时间点的温度分布
            self.simulate_temperature_distribution(cooling_setting=setting_row["cooling_setting"])
            
            # 计算当前时间点的能耗
            energy_df, time_energy = self.calculate_energy_consumption(cooling_setting=setting_row["cooling_setting"])
            total_dynamic_energy += time_energy / len(dynamic_df)  # 分配到每个时间点
            
            # 收集温度数据
            temp_readings = self.temperature_readings.copy()
            all_temp_readings.append(temp_readings)
        
        # 合并所有温度数据
        if all_temp_readings:
            self.temperature_readings = pd.concat(all_temp_readings)
        
        # 计算静态控制下的能耗（对比）
        self.simulate_temperature_distribution(cooling_setting=70)
        _, static_energy = self.calculate_energy_consumption(cooling_setting=70)
        
        # 计算节能效果
        savings_percentage = (static_energy - total_dynamic_energy) / static_energy * 100
        
        print(f"\n动态冷却控制效果:")
        print(f"静态控制能耗: {static_energy:.2f} MWh")
        print(f"动态控制能耗: {total_dynamic_energy:.2f} MWh")
        print(f"节能百分比: {savings_percentage:.1f}%")
        
        # 分析冷却设置变化
        avg_setting = dynamic_df["cooling_setting"].mean()
        max_setting = dynamic_df["cooling_setting"].max()
        min_setting = dynamic_df["cooling_setting"].min()
        
        print(f"平均冷却设置: {avg_setting:.1f}%")
        print(f"冷却设置范围: {min_setting:.1f}% - {max_setting:.1f}%")
        
        return {
            "energy_savings_percentage": savings_percentage,
            "dynamic_cooling_settings": dynamic_df,
            "average_cooling_setting": avg_setting,
            "energy_consumption": total_dynamic_energy
        }
    
    def optimize_cold_aisle_temperature(self):
        """优化冷通道温度设定点"""
        # 测试不同的冷通道温度设定点
        temperature_settings = [18, 19, 20, 21, 22, 23, 24, 25, 26]
        results = []
        
        for target_temp in temperature_settings:
            print(f"\n测试冷通道温度设定点: {target_temp}°C")
            
            # 将温度设定点转换为冷却设置（简化关系）
            cooling_setting = 100 - (target_temp - 18) * 5  # 线性关系，18°C对应100%冷却，每升高1°C减少5%
            cooling_setting = max(30, min(100, cooling_setting))  # 限制范围
            
            # 模拟该设置下的性能
            self.simulate_temperature_distribution(cooling_setting=cooling_setting)
            _, total_energy = self.calculate_energy_consumption(cooling_setting=cooling_setting)
            
            # 分析温度
            avg_temp = self.temperature_readings["temperature"].mean()
            max_temp = self.temperature_readings["temperature"].max()
            
            # 检查是否有热点超过安全阈值
            hotspots = len(self.temperature_readings[self.temperature_readings["temperature"] > 27])
            hotspot_percentage = hotspots / len(self.temperature_readings) * 100
            
            # 记录结果
            results.append({
                "target_temperature": target_temp,
                "cooling_setting": cooling_setting,
                "actual_avg_temp": avg_temp,
                "actual_max_temp": max_temp,
                "energy_consumption": total_energy,
                "hotspot_percentage": hotspot_percentage
            })
            
            print(f"  能耗: {total_energy:.2f} MWh")
            print(f"  实际平均温度: {avg_temp:.1f}°C")
            print(f"  实际最高温度: {max_temp:.1f}°C")
            print(f"  热点百分比: {hotspot_percentage:.1f}%")
        
        # 转换为DataFrame便于分析
        results_df = pd.DataFrame(results)
        
        # 找到最佳平衡点 - 热点少于5%且能耗较低
        acceptable_results = results_df[results_df["hotspot_percentage"] < 5]
        
        if not acceptable_results.empty:
            best_result = acceptable_results.loc[acceptable_results["energy_consumption"].idxmin()]
            
            print(f"\n最佳冷通道温度设定点: {best_result['target_temperature']}°C")
            print(f"预计能耗: {best_result['energy_consumption']:.2f} MWh")
            print(f"热点百分比: {best_result['hotspot_percentage']:.1f}%")
            
            # 计算相对于最低温度的节能
            min_temp_energy = results_df[results_df["target_temperature"] == min(temperature_settings)]["energy_consumption"].values[0]
            savings = (min_temp_energy - best_result["energy_consumption"]) / min_temp_energy * 100
            print(f"相比18°C设定点节能: {savings:.1f}%")
        else:
            # 如果没有完全可接受的结果，找热点最少的
            best_result = results_df.loc[results_df["hotspot_percentage"].idxmin()]
            print(f"\n最佳折衷方案: {best_result['target_temperature']}°C")
            print(f"能耗: {best_result['energy_consumption']:.2f} MWh")
            print(f"热点百分比: {best_result['hotspot_percentage']:.1f}%")
        
        return results_df
    
    def generate_cooling_optimization_report(self, output_file=None):
        """生成冷却优化综合报告"""
        # 运行所有优化方案
        self.generate_profiles()  # 确保有基础数据
        
        # 1. 优化冷却设置
        optimal_settings = self.optimize_cooling_settings()
        
        # 2. 评估冷热通道隔离
        hot_cold_results = self.implement_hot_cold_aisle_optimization()
        
        # 3. 实施动态冷却控制
        dynamic_results = self.implement_dynamic_cooling_control()
        
        # 4. 优化冷通道温度
        temp_setpoint_results = self.optimize_cold_aisle_temperature()
        
        # 综合报告
        report = {
            "title": "数据中心冷却系统优化报告",
            "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "summary": {
                "optimal_cooling_setting": optimal_settings["optimal_cooling_setting"],
                "hot_cold_aisle_improvement": hot_cold_results["energy_reduction_percentage"],
                "dynamic_control_savings": dynamic_results["energy_savings_percentage"],
                "recommended_temp_setpoint": temp_setpoint_results.loc[temp_setpoint_results["hotspot_percentage"].idxmin()]["target_temperature"]
            },
            "detailed_results": {
                "optimization": optimal_settings,
                "hot_cold_aisle": hot_cold_results,
                "dynamic_control": dynamic_results,
                "temperature_setpoints": temp_setpoint_results.to_dict("records")
            },
            "recommendations": [
                f"将冷通道温度设定点优化至 {temp_setpoint_results.loc[temp_setpoint_results['hotspot_percentage'].idxmin()]['target_temperature']}°C",
                "实施严格的冷热通道物理隔离措施",
                "部署动态冷却控制系统，根据负载和环境温度自动调整",
                "定期清理通风口和过滤器，减少气流阻力",
                "考虑液冷技术用于高密度GPU服务器区域"
            ]
        }
        
        # 计算综合节能潜力
        base_cooling_energy = 100 * 24 * 7 / 1000  # 假设基础能耗 (100kW * 7天)
        total_savings_potential = optimal_settings["energy_savings_percentage"] + \
                                hot_cold_results["energy_reduction_percentage"]
        
        if total_savings_potential > 100:  # 避免重复计算导致超过100%
            total_savings_potential = 90  # 保守估计90%
        
        report["summary"]["total_savings_potential"] = total_savings_potential
        report["summary"]["estimated_annual_savings_mwh"] = base_cooling_energy * 52 * (total_savings_potential / 100)
        
        # 保存报告
        if output_file:
            try:
                import json
                with open(output_file, 'w', encoding='utf-8') as f:
                    json.dump(report, f, ensure_ascii=False, indent=2)
                print(f"\n报告已保存到: {output_file}")
            except Exception as e:
                print(f"\n保存报告失败: {e}")
        
        # 打印摘要
        print("\n========== 冷却系统优化报告摘要 ==========")
        print(f"最佳冷却设置: {optimal_settings['optimal_cooling_setting']:.1f}%")
        print(f"冷热通道隔离节能: {hot_cold_results['energy_reduction_percentage']:.1f}%")
        print(f"动态冷却控制节能: {dynamic_results['energy_savings_percentage']:.1f}%")
        print(f"推荐冷通道温度: {temp_setpoint_results.loc[temp_setpoint_results['hotspot_percentage'].idxmin()]['target_temperature']}°C")
        print(f"综合节能潜力: {total_savings_potential:.1f}%")
        print(f"预计年节能量: {report['summary']['estimated_annual_savings_mwh']:.0f} MWh")
        
        print("\n主要建议:")
        for i, rec in enumerate(report["recommendations"], 1):
            print(f"{i}. {rec}")
        
        return report

# 使用示例
if __name__ == "__main__":
    # 创建冷却优化器实例
    optimizer = CoolingOptimizer()
    
    # 1. 生成基础配置文件
    print("生成环境温度和负载曲线...")
    optimizer.generate_profiles(days=7)
    
    # 2. 模拟当前冷却状况
    print("\n模拟当前冷却系统性能...")
    optimizer.simulate_temperature_distribution()
    optimizer.calculate_energy_consumption()
    
    # 3. 运行综合优化报告
    print("\n运行冷却系统综合优化...")
    report = optimizer.generate_cooling_optimization_report("cooling_optimization_report.json")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import random
from scipy.optimize import minimize

# 确保中文显示正常
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

class GreenEnergyIntegration:
    def __init__(self):
        # 初始化系统参数
        self.energy_consumption_profile = None  # 能耗曲线
        self.grid_carbon_intensity = None  # 电网碳强度数据
        self.renewable_generation = None  # 可再生能源发电数据
        self.carbon_offset_options = None  # 碳抵消选项
        self.integration_strategy = None  # 整合策略
        self.savings_results = None  # 节能结果
    
    def generate_energy_profile(self, days=30, resolution="hourly", model_size="large"):
        """生成LLM部署的能耗曲线"""
        # 生成时间序列
        if resolution == "hourly":
            periods = days * 24
            freq = "H"
        elif resolution == "15min":
            periods = days * 24 * 4
            freq = "15min"
        else:
            periods = days * 24
            freq = "H"
        
        date_range = pd.date_range(end=datetime.now(), periods=periods, freq=freq)
        
        # 根据模型规模确定基础能耗
        base_consumption = {
            "small": 200,  # 小型模型：200 kWh/小时
            "medium": 500,  # 中型模型：500 kWh/小时
            "large": 1000,  # 大型模型：1000 kWh/小时
            "xlarge": 3000  # 超大型模型：3000 kWh/小时
        }
        
        # 确定实际基础能耗
        base_kwh = base_consumption.get(model_size, 1000)
        
        # 生成能耗曲线
        consumption = []
        for dt in date_range:
            hour = dt.hour
            weekday = dt.weekday()
            
            # 基础能耗
            base = base_kwh
            
            # 时间因素 - 工作时间需求更高
            if weekday < 5:  # 工作日
                if 8 <= hour < 20:
                    # 工作时间峰值
                    time_factor = 1.2 + 0.2 * np.sin((hour - 8) * np.pi / 12)
                else:
                    # 非工作时间
                    time_factor = 0.7
            else:  # 周末
                time_factor = 0.8
            
            # LLM特定模式 - 推理和训练需求
            if hour in [10, 14, 16]:  # 推理高峰期
                model_factor = 1.3
            elif hour in [2, 3, 4]:  # 训练作业通常在深夜
                model_factor = 1.5
            else:
                model_factor = 1.0
            
            # 添加随机波动
            random_factor = 1.0 + 0.1 * np.random.random() - 0.05
            
            # 计算最终能耗
            final_kwh = base * time_factor * model_factor * random_factor
            consumption.append(final_kwh)
        
        self.energy_consumption_profile = pd.DataFrame({
            "timestamp": date_range,
            "energy_consumption_kwh": consumption
        })
        
        # 计算总能耗和碳排放（假设初始碳强度）
        total_kwh = self.energy_consumption_profile["energy_consumption_kwh"].sum()
        print(f"生成的{model_size}模型能耗曲线:")
        print(f"总能耗: {total_kwh/1000:.2f} MWh")
        print(f"平均功率: {self.energy_consumption_profile['energy_consumption_kwh'].mean():.2f} kWh/小时")
        print(f"峰值功率: {self.energy_consumption_profile['energy_consumption_kwh'].max():.2f} kWh/小时")
        
        return self.energy_consumption_profile
    
    def generate_grid_carbon_intensity(self, days=30, resolution="hourly", region="us_west"):
        """生成电网碳强度数据（克CO2e/kWh）"""
        # 生成时间序列
        if resolution == "hourly":
            periods = days * 24
            freq = "H"
        elif resolution == "15min":
            periods = days * 24 * 4
            freq = "15min"
        else:
            periods = days * 24
            freq = "H"
        
        date_range = pd.date_range(end=datetime.now(), periods=periods, freq=freq)
        
        # 不同地区的碳强度基准值（克CO2e/kWh）
        region_baselines = {
            "us_west": 250,
            "us_east": 450,
            "us_midwest": 600,
            "europe": 200,
            "asia_pacific": 500,
            "renewable_rich": 100
        }
        
        baseline = region_baselines.get(region, 300)
        
        # 生成碳强度曲线
        carbon_intensity = []
        for dt in date_range:
            hour = dt.hour
            weekday = dt.weekday()
            
            # 基础碳强度
            base = baseline
            
            # 时间因素 - 白天可再生能源比例更高
            if 8 <= hour < 18:
                # 白天 - 太阳能可用性高
                time_factor = 0.8 - 0.2 * np.sin((hour - 8) * np.pi / 10)
            else:
                # 夜间 - 更多依赖化石燃料
                time_factor = 1.2
            
            # 周末因素 - 工业需求低，碳强度通常较低
            if weekday >= 5:
                weekday_factor = 0.9
            else:
                weekday_factor = 1.0
            
            # 季节/随机因素（模拟天气变化等）
            seasonal_factor = 1.0 + 0.15 * np.random.random() - 0.075
            
            # 计算最终碳强度
            final_intensity = base * time_factor * weekday_factor * seasonal_factor
            carbon_intensity.append(final_intensity)
        
        self.grid_carbon_intensity = pd.DataFrame({
            "timestamp": date_range,
            "carbon_intensity_gco2e_per_kwh": carbon_intensity
        })
        
        # 分析结果
        avg_intensity = self.grid_carbon_intensity["carbon_intensity_gco2e_per_kwh"].mean()
        max_intensity = self.grid_carbon_intensity["carbon_intensity_gco2e_per_kwh"].max()
        min_intensity = self.grid_carbon_intensity["carbon_intensity_gco2e_per_kwh"].min()
        
        print(f"生成的{region}地区碳强度曲线:")
        print(f"平均碳强度: {avg_intensity:.2f} gCO2e/kWh")
        print(f"碳强度范围: {min_intensity:.2f} - {max_intensity:.2f} gCO2e/kWh")
        
        return self.grid_carbon_intensity
    
    def simulate_renewable_generation(self, solar_capacity_kw=500, wind_capacity_kw=200, days=30):
        """模拟可再生能源发电"""
        # 生成时间序列
        date_range = pd.date_range(end=datetime.now(), periods=days*24, freq="H")
        
        # 模拟太阳能发电
        solar_generation = []
        # 模拟风能发电
        wind_generation = []
        
        for dt in date_range:
            hour = dt.hour
            month = dt.month
            day_of_year = dt.timetuple().tm_yday
            
            # 太阳能发电模型
            # 基于时间的太阳能可用性（正弦曲线）
            if 6 <= hour < 18:
                # 白天有阳光
                day_factor = np.sin((hour - 6) * np.pi / 12)  # 最大在中午
                
                # 季节性变化（北半球）
                season_factor = 0.5 + 0.5 * np.sin((day_of_year - 80) * 2 * np.pi / 365)
                
                # 随机天气因素
                weather_factor = 0.7 + 0.3 * np.random.random()
                
                # 计算太阳能发电
                solar_output = solar_capacity_kw * day_factor * season_factor * weather_factor
            else:
                # 夜间无阳光
                solar_output = 0
            
            solar_generation.append(solar_output)
            
            # 风能发电模型
            # 更随机的模式，但有一定的时段偏好
            base_wind = 0.4 + 0.2 * np.random.random()  # 基础风力
            
            # 某些时段风更大
            if hour in [2, 3, 4, 5, 13, 14, 15]:
                time_factor = 1.4
            else:
                time_factor = 0.9
            
            # 随机变化
            random_factor = 0.8 + 0.4 * np.random.random()
            
            # 计算风能发电
            wind_output = wind_capacity_kw * base_wind * time_factor * random_factor
            wind_generation.append(wind_output)
        
        # 合并数据
        self.renewable_generation = pd.DataFrame({
            "timestamp": date_range,
            "solar_generation_kwh": solar_generation,
            "wind_generation_kwh": wind_generation
        })
        
        # 计算总和
        self.renewable_generation["total_renewable_kwh"] = \
            self.renewable_generation["solar_generation_kwh"] + \
            self.renewable_generation["wind_generation_kwh"]
        
        # 分析结果
        total_solar = self.renewable_generation["solar_generation_kwh"].sum()
        total_wind = self.renewable_generation["wind_generation_kwh"].sum()
        total_renewable = self.renewable_generation["total_renewable_kwh"].sum()
        
        print(f"可再生能源模拟结果:")
        print(f"太阳能总发电: {total_solar/1000:.2f} MWh")
        print(f"风能总发电: {total_wind/1000:.2f} MWh")
        print(f"可再生能源总计: {total_renewable/1000:.2f} MWh")
        print(f"平均可再生电力: {self.renewable_generation['total_renewable_kwh'].mean():.2f} kWh/小时")
        
        return self.renewable_generation
    
    def calculate_carbon_footprint(self):
        """计算当前碳足迹"""
        if self.energy_consumption_profile is None:
            self.generate_energy_profile()
        
        if self.grid_carbon_intensity is None:
            self.generate_grid_carbon_intensity()
        
        # 合并能耗和碳强度数据
        # 假设时间戳匹配
        combined_df = pd.merge(
            self.energy_consumption_profile,
            self.grid_carbon_intensity,
            on="timestamp"
        )
        
        # 计算每小时碳排放量
        combined_df["carbon_emission_gco2e"] = \
            combined_df["energy_consumption_kwh"] * combined_df["carbon_intensity_gco2e_per_kwh"]
        
        # 转换为吨CO2e
        combined_df["carbon_emission_tco2e"] = combined_df["carbon_emission_gco2e"] / 1000000
        
        # 计算总量
        total_emission_tco2e = combined_df["carbon_emission_tco2e"].sum()
        avg_intensity = combined_df["carbon_intensity_gco2e_per_kwh"].mean()
        
        print(f"碳足迹计算结果:")
        print(f"总碳排放量: {total_emission_tco2e:.2f} tCO2e")
        print(f"平均碳强度: {avg_intensity:.2f} gCO2e/kWh")
        print(f"单位能耗碳排放: {total_emission_tco2e / (combined_df['energy_consumption_kwh'].sum()/1000):.2f} tCO2e/MWh")
        
        return combined_df, total_emission_tco2e
    
    def optimize_energy_usage(self, strategy="time_shifting"):
        """优化能源使用策略"""
        if self.energy_consumption_profile is None:
            self.generate_energy_profile()
        
        if self.grid_carbon_intensity is None:
            self.generate_grid_carbon_intensity()
        
        # 合并数据
        combined_df = pd.merge(
            self.energy_consumption_profile,
            self.grid_carbon_intensity,
            on="timestamp"
        )
        
        # 创建优化副本
        optimized_df = combined_df.copy()
        
        if strategy == "time_shifting":
            # 时间转移策略 - 将高碳时段的负载转移到低碳时段
            
            # 按日期分组
            daily_groups = optimized_df.groupby(optimized_df["timestamp"].dt.date)
            
            for date, daily_data in daily_groups:
                # 识别当天的碳强度分布
                carbon_intensity = daily_data["carbon_intensity_gco2e_per_kwh"].values
                
                # 找出碳强度最低的4个小时（可灵活调整）
                low_carbon_hours = carbon_intensity.argsort()[:4]
                
                # 找出碳强度最高的4个小时
                high_carbon_hours = carbon_intensity.argsort()[-4:]
                
                # 计算可转移的负载量（从高碳到低碳时段）
                total_high_load = daily_data.iloc[high_carbon_hours]["energy_consumption_kwh"].sum()
                transfer_amount = total_high_load * 0.3  # 假设30%的负载可以转移
                
                # 平均分配到低碳时段
                transfer_per_hour = transfer_amount / len(low_carbon_hours)
                
                # 调整负载
                for idx in high_carbon_hours:
                    # 减少高碳时段负载
                    original_load = daily_data.iloc[idx]["energy_consumption_kwh"]
                    reduction = min(original_load * 0.3, transfer_per_hour)
                    optimized_df.loc[daily_data.index[idx], "energy_consumption_kwh"] -= reduction
                
                for idx in low_carbon_hours:
                    # 增加低碳时段负载
                    optimized_df.loc[daily_data.index[idx], "energy_consumption_kwh"] += transfer_per_hour
        
        elif strategy == "renewable_matching":
            # 可再生能源匹配策略 - 优先在可再生能源丰富的时段运行
            if self.renewable_generation is None:
                self.simulate_renewable_generation()
            
            # 合并可再生能源数据
            optimized_df = pd.merge(
                optimized_df,
                self.renewable_generation[["timestamp", "total_renewable_kwh"]],
                on="timestamp",
                how="left"
            )
            
            # 填充缺失值
            optimized_df["total_renewable_kwh"] = optimized_df["total_renewable_kwh"].fillna(0)
            
            # 按日期分组
            daily_groups = optimized_df.groupby(optimized_df["timestamp"].dt.date)
            
            for date, daily_data in daily_groups:
                # 识别当天可再生能源最丰富的时段
                renewable_energy = daily_data["total_renewable_kwh"].values
                high_renewable_hours = renewable_energy.argsort()[-4:]
                
                # 识别可再生能源较少的时段
                low_renewable_hours = renewable_energy.argsort()[:4]
                
                # 计算可转移的负载量
                total_low_renewable_load = daily_data.iloc[low_renewable_hours]["energy_consumption_kwh"].sum()
                transfer_amount = total_low_renewable_load * 0.25  # 25%的负载可以转移
                
                # 平均分配到高可再生能源时段
                transfer_per_hour = transfer_amount / len(high_renewable_hours)
                
                # 调整负载
                for idx in low_renewable_hours:
                    # 减少低可再生能源时段负载
                    original_load = daily_data.iloc[idx]["energy_consumption_kwh"]
                    reduction = min(original_load * 0.25, transfer_per_hour)
                    optimized_df.loc[daily_data.index[idx], "energy_consumption_kwh"] -= reduction
                
                for idx in high_renewable_hours:
                    # 增加高可再生能源时段负载
                    optimized_df.loc[daily_data.index[idx], "energy_consumption_kwh"] += transfer_per_hour
        
        # 计算优化后的碳排放
        optimized_df["carbon_emission_gco2e"] = \
            optimized_df["energy_consumption_kwh"] * optimized_df["carbon_intensity_gco2e_per_kwh"]
        optimized_df["carbon_emission_tco2e"] = optimized_df["carbon_emission_gco2e"] / 1000000
        
        # 计算优化前后对比
        original_emission = combined_df["carbon_emission_tco2e"].sum()
        optimized_emission = optimized_df["carbon_emission_tco2e"].sum()
        emission_reduction = original_emission - optimized_emission
        reduction_percentage = (emission_reduction / original_emission) * 100
        
        print(f"\n{strategy}策略优化结果:")
        print(f"优化前碳排放: {original_emission:.2f} tCO2e")
        print(f"优化后碳排放: {optimized_emission:.2f} tCO2e")
        print(f"碳减排量: {emission_reduction:.2f} tCO2e")
        print(f"减排百分比: {reduction_percentage:.1f}%")
        
        self.integration_strategy = strategy
        self.savings_results = {
            "original_emission": original_emission,
            "optimized_emission": optimized_emission,
            "emission_reduction": emission_reduction,
            "reduction_percentage": reduction_percentage
        }
        
        return optimized_df, reduction_percentage
    
    def evaluate_ppa_options(self, options=None):
        """评估可再生能源电力采购协议(PPA)选项"""
        if options is None:
            # 预设几种PPA选项
            options = [
                {
                    "name": "100%太阳能PPA",
                    "renewable_percentage": 100,
                    "type": "solar",
                    "contract_years": 10,
                    "price_per_kwh": 0.05,
                    "carbon_offset_percentage": 95
                },
                {
                    "name": "75%混合可再生PPA",
                    "renewable_percentage": 75,
                    "type": "hybrid",
                    "contract_years": 7,
                    "price_per_kwh": 0.045,
                    "carbon_offset_percentage": 70
                },
                {
                    "name": "50%风能PPA",
                    "renewable_percentage": 50,
                    "type": "wind",
                    "contract_years": 5,
                    "price_per_kwh": 0.04,
                    "carbon_offset_percentage": 45
                }
            ]
        
        if self.energy_consumption_profile is None:
            self.generate_energy_profile()
        
        # 计算当前总能耗
        total_kwh = self.energy_consumption_profile["energy_consumption_kwh"].sum()
        annual_kwh = total_kwh * (365 / len(self.energy_consumption_profile) * 24)  # 估算年耗电量
        
        # 假设当前电价
        current_price_per_kwh = 0.07  # 假设当前电价为$0.07/kWh
        
        # 计算基础情况的年成本
        current_annual_cost = annual_kwh * current_price_per_kwh / 1000  # 转换为美元
        
        # 评估每个PPA选项
        ppa_results = []
        
        for option in options:
            # 计算PPA覆盖的电量
            covered_kwh = annual_kwh * (option["renewable_percentage"] / 100)
            
            # 计算PPA年成本
            ppa_annual_cost = covered_kwh * option["price_per_kwh"] / 1000
            
            # 计算剩余电量的成本（按当前价格）
            remaining_kwh = annual_kwh - covered_kwh
            remaining_cost = remaining_kwh * current_price_per_kwh / 1000
            
            # 总年度成本
            total_annual_cost = ppa_annual_cost + remaining_cost
            
            # 成本变化
            cost_change = total_annual_cost - current_annual_cost
            cost_change_percentage = (cost_change / current_annual_cost) * 100
            
            # 计算碳减排（假设当前碳强度）
            if self.grid_carbon_intensity is None:
                avg_carbon_intensity = 300  # 默认300 gCO2e/kWh
            else:
                avg_carbon_intensity = self.grid_carbon_intensity["carbon_intensity_gco2e_per_kwh"].mean()
            
            # PPA碳强度（假设95%的减排）
            ppa_carbon_intensity = avg_carbon_intensity * (1 - option["carbon_offset_percentage"] / 100)
            
            # 计算碳减排量
            carbon_reduction_tco2e = (avg_carbon_intensity - ppa_carbon_intensity) * covered_kwh / 1000000000  # 转换为吨
            
            # 记录结果
            result = {
                "name": option["name"],
                "renewable_percentage": option["renewable_percentage"],
                "contract_years": option["contract_years"],
                "price_per_kwh": option["price_per_kwh"],
                "annual_cost": total_annual_cost,
                "cost_change": cost_change,
                "cost_change_percentage": cost_change_percentage,
                "carbon_reduction_tco2e": carbon_reduction_tco2e,
                "carbon_offset_percentage": option["carbon_offset_percentage"]
            }
            
            ppa_results.append(result)
        
        # 转换为DataFrame
        results_df = pd.DataFrame(ppa_results)
        
        print(f"\nPPA选项评估结果（基于年耗电量 {annual_kwh/1000:.0f} MWh）:")
        print(f"当前电价: ${current_price_per_kwh}/kWh")
        print(f"当前年度电费: ${current_annual_cost:.2f}")
        
        for idx, row in results_df.iterrows():
            print(f"\n选项 {idx+1}: {row['name']}")
            print(f"  可再生能源比例: {row['renewable_percentage']}%")
            print(f"  合同年限: {row['contract_years']}年")
            print(f"  PPA电价: ${row['price_per_kwh']}/kWh")
            print(f"  年度总成本: ${row['annual_cost']:.2f}")
            if row['cost_change'] >= 0:
                print(f"  成本变化: +${row['cost_change']:.2f} ({row['cost_change_percentage']:.1f}%)")
            else:
                print(f"  成本变化: -${abs(row['cost_change']):.2f} ({row['cost_change_percentage']:.1f}%)")
            print(f"  年碳减排: {row['carbon_reduction_tco2e']:.2f} tCO2e")
            print(f"  碳抵消比例: {row['carbon_offset_percentage']}%")
        
        return results_df
    
    def evaluate_onsite_generation(self, solar_options=None, wind_options=None):
        """评估现场可再生能源发电选项"""
        if solar_options is None:
            solar_options = [
                {
                    "name": "小型太阳能系统",
                    "capacity_kw": 200,
                    "installation_cost": 400000,
                    "maintenance_cost_yearly": 10000,
                    "lifespan_years": 25,
                    "efficiency": 0.18
                },
                {
                    "name": "中型太阳能系统",
                    "capacity_kw": 500,
                    "installation_cost": 900000,
                    "maintenance_cost_yearly": 22500,
                    "lifespan_years": 25,
                    "efficiency": 0.18
                },
                {
                    "name": "大型太阳能系统",
                    "capacity_kw": 1000,
                    "installation_cost": 1700000,
                    "maintenance_cost_yearly": 42500,
                    "lifespan_years": 25,
                    "efficiency": 0.18
                }
            ]
        
        if wind_options is None:
            wind_options = [
                {
                    "name": "单台风力发电机",
                    "capacity_kw": 200,
                    "installation_cost": 500000,
                    "maintenance_cost_yearly": 25000,
                    "lifespan_years": 20,
                    "average_capacity_factor": 0.35
                },
                {
                    "name": "双台风力发电机",
                    "capacity_kw": 400,
                    "installation_cost": 950000,
                    "maintenance_cost_yearly": 47500,
                    "lifespan_years": 20,
                    "average_capacity_factor": 0.35
                }
            ]
        
        # 模拟发电数据以估算产能
        generation_results = []
        
        # 1. 评估太阳能选项
        for option in solar_options:
            # 模拟发电（使用简化模型）
            # 假设年平均日照小时数为2000小时
            annual_generation_kwh = option["capacity_kw"] * 2000 * option["efficiency"]
            
            # 计算经济性
            total_cost = option["installation_cost"] + (option["maintenance_cost_yearly"] * option["lifespan_years"])
            cost_per_kwh = total_cost / annual_generation_kwh / option["lifespan_years"]
            
            # 计算投资回报期（假设电价为$0.07/kWh）
            savings_per_year = annual_generation_kwh * 0.07
            payback_period = option["installation_cost"] / savings_per_year
            
            # 计算碳减排（假设避免的电网电力碳强度为300 gCO2e/kWh）
            carbon_reduction_tco2e = annual_generation_kwh * 300 / 1000000
            
            result = {
                "type": "solar",
                "name": option["name"],
                "capacity_kw": option["capacity_kw"],
                "annual_generation_mwh": annual_generation_kwh / 1000,
                "installation_cost": option["installation_cost"],
                "lifespan_years": option["lifespan_years"],
                "total_cost": total_cost,
                "cost_per_kwh": cost_per_kwh,
                "payback_period_years": payback_period,
                "annual_carbon_reduction_tco2e": carbon_reduction_tco2e
            }
            
            generation_results.append(result)
        
        # 2. 评估风能选项
        for option in wind_options:
            # 模拟发电
            # 年发电小时数 = 24小时 * 365天 * 容量因子
            annual_generation_kwh = option["capacity_kw"] * 24 * 365 * option["average_capacity_factor"]
            
            # 计算经济性
            total_cost = option["installation_cost"] + (option["maintenance_cost_yearly"] * option["lifespan_years"])
            cost_per_kwh = total_cost / annual_generation_kwh / option["lifespan_years"]
            
            # 计算投资回报期
            savings_per_year = annual_generation_kwh * 0.07
            payback_period = option["installation_cost"] / savings_per_year
            
            # 计算碳减排
            carbon_reduction_tco2e = annual_generation_kwh * 300 / 1000000
            
            result = {
                "type": "wind",
                "name": option["name"],
                "capacity_kw": option["capacity_kw"],
                "annual_generation_mwh": annual_generation_kwh / 1000,
                "installation_cost": option["installation_cost"],
                "lifespan_years": option["lifespan_years"],
                "total_cost": total_cost,
                "cost_per_kwh": cost_per_kwh,
                "payback_period_years": payback_period,
                "annual_carbon_reduction_tco2e": carbon_reduction_tco2e
            }
            
            generation_results.append(result)
        
        # 转换为DataFrame
        results_df = pd.DataFrame(generation_results)
        
        print(f"\n现场可再生能源评估结果:")
        
        # 分别打印太阳能和风能结果
        solar_results = results_df[results_df["type"] == "solar"]
        wind_results = results_df[results_df["type"] == "wind"]
        
        print("\n太阳能选项:")
        for idx, row in solar_results.iterrows():
            print(f"\n{row['name']}:")
            print(f"  装机容量: {row['capacity_kw']} kW")
            print(f"  年发电量: {row['annual_generation_mwh']:.2f} MWh")
            print(f"  初始投资: ${row['installation_cost']:,.0f}")
            print(f"  使用寿命: {row['lifespan_years']}年")
            print(f"  度电成本: ${row['cost_per_kwh']:.4f}/kWh")
            print(f"  投资回报期: {row['payback_period_years']:.1f}年")
            print(f"  年碳减排: {row['annual_carbon_reduction_tco2e']:.2f} tCO2e")
        
        print("\n风能选项:")
        for idx, row in wind_results.iterrows():
            print(f"\n{row['name']}:")
            print(f"  装机容量: {row['capacity_kw']} kW")
            print(f"  年发电量: {row['annual_generation_mwh']:.2f} MWh")
            print(f"  初始投资: ${row['installation_cost']:,.0f}")
            print(f"  使用寿命: {row['lifespan_years']}年")
            print(f"  度电成本: ${row['cost_per_kwh']:.4f}/kWh")
            print(f"  投资回报期: {row['payback_period_years']:.1f}年")
            print(f"  年碳减排: {row['annual_carbon_reduction_tco2e']:.2f} tCO2e")
        
        return results_df
    
    def recommend_renewable_strategy(self):
        """推荐综合可再生能源策略"""
        # 确保所有必要的数据都已生成
        if self.energy_consumption_profile is None:
            self.generate_energy_profile()
        
        if self.grid_carbon_intensity is None:
            self.generate_grid_carbon_intensity()
        
        # 计算当前碳足迹
        _, current_emission = self.calculate_carbon_footprint()
        
        # 评估各种策略
        # 1. 评估PPA选项
        ppa_results = self.evaluate_ppa_options()
        
        # 2. 评估现场发电选项
        onsite_results = self.evaluate_onsite_generation()
        
        # 3. 评估时间转移策略
        _, time_shift_savings = self.optimize_energy_usage(strategy="time_shifting")
        
        # 基于成本效益和减排潜力制定推荐
        recommendations = []
        
        # 1. 找出最优PPA选项（考虑成本和减排平衡）
        # 计算成本效益比（减排量/额外成本）
        ppa_results["cost_effectiveness"] = ppa_results["carbon_reduction_tco2e"] / ppa_results["cost_change"].abs()
        best_ppa = ppa_results.loc[ppa_results["cost_effectiveness"].idxmax()]
        
        recommendations.append({
            "type": "PPA",
            "name": best_ppa["name"],
            "description": f"签订{best_ppa['renewable_percentage']}%可再生能源比例的{best_ppa['contract_years']}年PPA",
            "annual_cost_change": best_ppa["cost_change"],
            "annual_carbon_reduction": best_ppa["carbon_reduction_tco2e"],
            "priority": "high" if best_ppa["cost_change_percentage"] <= 10 else "medium"
        })
        
        # 2. 找出最优现场发电选项（考虑投资回报期和发电量）
        onsite_results = onsite_results.sort_values(by="payback_period_years")
        best_onsite = onsite_results.iloc[0]
        
        recommendations.append({
            "type": "onsite",
            "name": best_onsite["name"],
            "description": f"安装{best_onsite['capacity_kw']}kW的{best_onsite['type']}系统，年发电{best_onsite['annual_generation_mwh']:.0f}MWh",
            "initial_investment": best_onsite["installation_cost"],
            "payback_period": best_onsite["payback_period_years"],
            "annual_carbon_reduction": best_onsite["annual_carbon_reduction_tco2e"],
            "priority": "high" if best_onsite["payback_period_years"] <= 7 else "medium"
        })
        
        # 3. 时间转移策略
        recommendations.append({
            "type": "optimization",
            "name": "时间转移策略",
            "description": "将高碳时段的训练和推理任务转移到低碳时段",
            "implementation_cost": "低",
            "estimated_reduction_percentage": time_shift_savings,
            "priority": "high"
        })
        
        # 4. 建议能源存储（如果合适）
        # 基于可再生能源波动性和峰谷电价差异评估
        if self.grid_carbon_intensity is not None:
            # 计算峰谷碳强度差异
            carbon_diff = self.grid_carbon_intensity["carbon_intensity_gco2e_per_kwh"].max() - \
                         self.grid_carbon_intensity["carbon_intensity_gco2e_per_kwh"].min()
            
            # 如果差异显著，建议添加储能
            if carbon_diff > 100:  # 超过100 gCO2e/kWh的差异
                recommendations.append({
                    "type": "storage",
                    "name": "电池储能系统",
                    "description": "安装电池储能系统，在可再生能源丰富时段充电，高峰时段放电",
                    "estimated_reduction_percentage": 5,
                    "priority": "medium"
                })
        
        # 5. 长期建议
        recommendations.append({
            "type": "long_term",
            "name": "碳抵消投资",
            "description": "投资碳抵消项目，抵消剩余碳排放",
            "estimated_offset_percentage": 100,
            "priority": "low"
        })
        
        # 生成综合报告
        print("\n========== 绿色能源整合策略推荐 ==========")
        
        # 按优先级排序
        priority_order = {"high": 0, "medium": 1, "low": 2}
        recommendations.sort(key=lambda x: priority_order.get(x.get("priority", "medium"), 1))
        
        for i, rec in enumerate(recommendations, 1):
            print(f"\n{i}. {rec['name']} (优先级: {rec.get('priority', 'medium')})")
            print(f"   描述: {rec['description']}")
            
            if rec["type"] == "PPA":
                cost_change_str = f"+${rec['annual_cost_change']:.2f}" if rec['annual_cost_change'] > 0 else f"-${abs(rec['annual_cost_change']):.2f}"
                print(f"   年度成本变化: {cost_change_str}")
                print(f"   年度碳减排: {rec['annual_carbon_reduction']:.2f} tCO2e")
            
            elif rec["type"] == "onsite":
                print(f"   初始投资: ${rec['initial_investment']:,.0f}")
                print(f"   投资回报期: {rec['payback_period']:.1f}年")
                print(f"   年度碳减排: {rec['annual_carbon_reduction']:.2f} tCO2e")
            
            elif rec["type"] == "optimization":
                print(f"   实施成本: {rec['implementation_cost']}")
                print(f"   预计减排: {rec['estimated_reduction_percentage']:.1f}%")
            
            elif rec["type"] == "storage":
                print(f"   预计减排: {rec['estimated_reduction_percentage']:.1f}%")
            
            elif rec["type"] == "long_term":
                print(f"   预计抵消: {rec['estimated_offset_percentage']}%")
        
        # 计算综合减排潜力
        total_reduction_potential = min(100, time_shift_savings + \
                                      (best_ppa['carbon_reduction_tco2e'] / current_emission * 100) + \
                                      (best_onsite['annual_carbon_reduction_tco2e'] / current_emission * 100) + \
                                      10)  # 额外储能和优化
        
        print(f"\n综合碳减排潜力: {total_reduction_potential:.1f}%")
        print(f"建议分阶段实施，优先采用高优先级措施，可在2-3年内实现显著减排。")
        
        return recommendations
    
    def generate_green_energy_report(self, output_file=None):
        """生成绿色能源整合综合报告"""
        # 确保所有数据都已生成
        if self.energy_consumption_profile is None:
            self.generate_energy_profile()
        
        if self.grid_carbon_intensity is None:
            self.generate_grid_carbon_intensity()
        
        # 计算当前碳足迹
        carbon_data, current_emission = self.calculate_carbon_footprint()
        
        # 获取能源优化结果
        optimized_data, optimization_savings = self.optimize_energy_usage(strategy="time_shifting")
        
        # 获取可再生能源策略建议
        recommendations = self.recommend_renewable_strategy()
        
        # 模拟可再生能源整合后的碳排放
        # 简化估算：假设高优先级措施实施后的效果
        high_priority_recs = [r for r in recommendations if r.get("priority") == "high"]
        estimated_reduction = 0
        
        for rec in high_priority_recs:
            if "estimated_reduction_percentage" in rec:
                estimated_reduction += rec["estimated_reduction_percentage"]
            elif "annual_carbon_reduction" in rec:
                reduction_percentage = (rec["annual_carbon_reduction"] / current_emission) * 100
                estimated_reduction += reduction_percentage
        
        # 确保不超过100%
        estimated_reduction = min(100, estimated_reduction)
        
        # 计算实施后的碳排放
        projected_emission = current_emission * (1 - estimated_reduction / 100)
        
        # 创建报告结构
        report = {
            "title": "LLM部署绿色能源整合报告",
            "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "current_state": {
                "annual_energy_consumption_mwh": self.energy_consumption_profile["energy_consumption_kwh"].sum() / 1000 * (365 / (len(self.energy_consumption_profile) / 24)),
                "current_carbon_emission_tco2e": current_emission,
                "average_carbon_intensity_gco2e_per_kwh": carbon_data["carbon_intensity_gco2e_per_kwh"].mean()
            },
            "optimization_potential": {
                "energy_optimization_savings_percentage": optimization_savings,
                "renewable_integration_potential_percentage": estimated_reduction,
                "projected_carbon_emission_tco2e": projected_emission,
                "absolute_reduction_potential_tco2e": current_emission - projected_emission
            },
            "recommendations": recommendations,
            "implementation_roadmap": [
                {
                    "phase": "第一阶段（0-6个月）",
                    "actions": [
                        "实施时间转移策略，优化负载调度",
                        "启动PPA供应商评估和谈判",
                        "进行现场可再生能源系统的详细可行性研究"
                    ],
                    "target_reduction_percentage": 10
                },
                {
                    "phase": "第二阶段（6-18个月）",
                    "actions": [
                        "签署并实施最佳PPA协议",
                        "开始安装现场可再生能源系统",
                        "评估并优化数据中心冷却效率"
                    ],
                    "target_reduction_percentage": 40
                },
                {
                    "phase": "第三阶段（18-36个月）",
                    "actions": [
                        "完成现场可再生能源系统安装",
                        "评估并考虑添加能源存储系统",
                        "探索额外的碳抵消机会"
                    ],
                    "target_reduction_percentage": 70
                }
            ]
        }
        
        # 保存报告
        if output_file:
            try:
                import json
                with open(output_file, 'w', encoding='utf-8') as f:
                    json.dump(report, f, ensure_ascii=False, indent=2)
                print(f"\n报告已保存到: {output_file}")
            except Exception as e:
                print(f"\n保存报告失败: {e}")
        
        # 打印报告摘要
        print("\n========== 绿色能源整合报告摘要 ==========")
        print(f"当前年碳排放量: {report['current_state']['current_carbon_emission_tco2e']:.2f} tCO2e")
        print(f"预计减排潜力: {estimated_reduction:.1f}%")
        print(f"项目碳排放量: {projected_emission:.2f} tCO2e")
        print(f"年减排量: {report['optimization_potential']['absolute_reduction_potential_tco2e']:.2f} tCO2e")
        
        print("\n实施路线图:")
        for phase in report["implementation_roadmap"]:
            print(f"\n{phase['phase']}:")
            print(f"  目标减排: {phase['target_reduction_percentage']}%")
            print("  行动项目:")
            for action in phase["actions"]:
                print(f"    - {action}")
        
        return report

# 使用示例
if __name__ == "__main__":
    # 创建绿色能源整合评估器
    green_energy = GreenEnergyIntegration()
    
    # 1. 生成能耗曲线
    print("生成LLM部署能耗曲线...")
    green_energy.generate_energy_profile(model_size="large", days=7)
    
    # 2. 生成电网碳强度数据
    print("\n生成电网碳强度数据...")
    green_energy.generate_grid_carbon_intensity(region="us_west", days=7)
    
    # 3. 模拟可再生能源发电
    print("\n模拟可再生能源发电...")
    green_energy.simulate_renewable_generation(solar_capacity_kw=500, wind_capacity_kw=200, days=7)
    
    # 4. 计算当前碳足迹
    print("\n计算当前碳足迹...")
    carbon_data, total_emission = green_energy.calculate_carbon_footprint()
    
    # 5. 运行优化策略
    print("\n评估能源使用优化...")
    optimized_data, savings = green_energy.optimize_energy_usage(strategy="time_shifting")
    
    # 6. 评估PPA选项
    print("\n评估PPA选项...")
    ppa_results = green_energy.evaluate_ppa_options()
    
    # 7. 评估现场可再生能源
    print("\n评估现场可再生能源选项...")
    onsite_results = green_energy.evaluate_onsite_generation()
    
    # 8. 生成综合报告
    print("\n生成绿色能源整合报告...")
    report = green_energy.generate_green_energy_report("green_energy_integration_report.json")

碳排放量(CO₂e) = 能源消耗(kWh) × 碳排放因子(kg CO₂e/kWh)

import numpy as np
import matplotlib.pyplot as plt
from ml_co2_impact import MLCarbonImpact

class LLMCarbonCalculator:
    def __init__(self, model_params):
        self.model_params = model_params
        self.calculator = MLCarbonImpact()
    
    def calculate_inference_emissions(self, inference_hours, gpu_count):
        # 估算推理阶段碳排放
        power_per_gpu = self.model_params.get('gpu_power_watts', 300)  # 每GPU功率(W)
        pue = self.model_params.get('pue', 1.5)  # 数据中心能效系数
        carbon_intensity = self.model_params.get('carbon_intensity', 400)  # 碳强度(g CO2e/kWh)
        
        # 计算总能耗(kWh)
        total_energy = (power_per_gpu * gpu_count * inference_hours * pue) / 1000
        
        # 计算碳排放(kg CO2e)
        emissions = (total_energy * carbon_intensity) / 1000
        
        return {
            'total_energy_kwh': total_energy,
            'emissions_kg_co2e': emissions,
            'emissions_tons_co2e': emissions / 1000
        }
    
    def calculate_training_emissions(self, training_hours, gpu_count):
        # 估算训练阶段碳排放
        # 训练通常比推理消耗更多能源
        power_per_gpu = self.model_params.get('training_gpu_power_watts', 350)  # 训练时每GPU功率(W)
        pue = self.model_params.get('pue', 1.5)  # 数据中心能效系数
        carbon_intensity = self.model_params.get('carbon_intensity', 400)  # 碳强度(g CO2e/kWh)
        
        # 计算总能耗(kWh)
        total_energy = (power_per_gpu * gpu_count * training_hours * pue) / 1000
        
        # 计算碳排放(kg CO2e)
        emissions = (total_energy * carbon_intensity) / 1000
        
        return {
            'total_energy_kwh': total_energy,
            'emissions_kg_co2e': emissions,
            'emissions_tons_co2e': emissions / 1000
        }
    
    def compare_deployment_options(self, options):
        # 比较不同部署选项的碳足迹
        results = []
        for option in options:
            if option['type'] == 'inference':
                result = self.calculate_inference_emissions(
                    option['hours'], option['gpu_count']
                )
            else:
                result = self.calculate_training_emissions(
                    option['hours'], option['gpu_count']
                )
            results.append({
                'option_name': option['name'],
                **result
            })
        
        return results
    
    def visualize_comparison(self, comparison_results):
        # 可视化比较结果
        names = [r['option_name'] for r in comparison_results]
        emissions = [r['emissions_tons_co2e'] for r in comparison_results]
        
        plt.figure(figsize=(10, 6))
        bars = plt.bar(names, emissions)
        plt.xlabel('部署选项')
        plt.ylabel('碳排放(吨 CO2e)')
        plt.title('不同LLM部署选项的碳足迹比较')
        plt.xticks(rotation=45, ha='right')
        
        # 添加数值标签
        for bar in bars:
            height = bar.get_height()
            plt.text(bar.get_x() + bar.get_width()/2., height + 0.05,
                    f'{height:.2f}吨', ha='center', va='bottom')
        
        plt.tight_layout()
        plt.savefig('llm_emissions_comparison.png', dpi=300)
        plt.show()
        
        return plt

# 使用示例
if __name__ == "__main__":
    # 定义模型参数
    model_params = {
        'gpu_power_watts': 250,  # A100 GPU功耗
        'training_gpu_power_watts': 300,  # 训练时功耗略高
        'pue': 1.2,  # 现代化数据中心PUE
        'carbon_intensity': 350  # 混合能源电网碳强度
    }
    
    # 创建计算器实例
    calculator = LLMCarbonCalculator(model_params)
    
    # 定义不同部署选项
    options = [
        {
            'name': '本地数据中心',
            'type': 'inference',
            'hours': 8760,  # 一年运行时间
            'gpu_count': 4
        },
        {
            'name': '绿色云服务',
            'type': 'inference',
            'hours': 8760,
            'gpu_count': 4
        },
        {
            'name': '模型量化后部署',
            'type': 'inference',
            'hours': 8760,
            'gpu_count': 2  # 量化后可减少GPU数量
        },
        {
            'name': '按需缩放部署',
            'type': 'inference',
            'hours': 4380,  # 仅高峰期运行
            'gpu_count': 4
        }
    ]
    
    # 比较不同选项
    comparison_results = calculator.compare_deployment_options(options)
    print("部署选项比较结果:")
    for result in comparison_results:
        print(f"{result['option_name']}: {result['emissions_tons_co2e']:.2f}吨 CO2e/年")
    
    # 可视化比较结果
    calculator.visualize_comparison(comparison_results)

import psutil
import subprocess
import time
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime

class HardwareEnergyOptimizer:
    def __init__(self, log_file="energy_usage.csv"):
        self.log_file = log_file
        self.monitoring_active = False
    
    def get_cpu_usage(self):
        # 获取CPU使用率
        return psutil.cpu_percent(interval=1, percpu=True)
    
    def get_memory_usage(self):
        # 获取内存使用率
        memory = psutil.virtual_memory()
        return {
            'total_gb': memory.total / (1024**3),
            'used_gb': memory.used / (1024**3),
            'percent': memory.percent
        }
    
    def get_gpu_stats(self):
        # 获取GPU信息（需要安装nvidia-smi）
        try:
            result = subprocess.check_output(
                ['nvidia-smi', '--query-gpu=index,name,utilization.gpu,utilization.memory,power.draw,energy.consumption', 
                 '--format=csv,noheader,nounits']
            ).decode('utf-8').strip()
            
            gpus = []
            for line in result.split('\n'):
                if line.strip():
                    parts = line.split(', ')
                    gpus.append({
                        'index': int(parts[0]),
                        'name': parts[1],
                        'gpu_utilization': float(parts[2]),
                        'memory_utilization': float(parts[3]),
                        'power_draw_watts': float(parts[4]),
                        'energy_consumption_j': float(parts[5]) if len(parts) > 5 else None
                    })
            return gpus
        except Exception as e:
            print(f"无法获取GPU信息: {e}")
            return []
    
    def monitor_resources(self, interval=60):
        # 持续监控资源使用情况
        self.monitoring_active = True
        
        # 创建日志文件头
        with open(self.log_file, 'w') as f:
            f.write("timestamp,cpu_avg_usage,memory_percent,gpu_count,gpu_avg_utilization,gpu_avg_power_watts,energy_estimate_kwh\n")
        
        print(f"开始监控资源使用情况，日志保存至 {self.log_file}")
        
        try:
            prev_energy = {}
            
            while self.monitoring_active:
                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                
                # 获取CPU和内存信息
                cpu_usage = self.get_cpu_usage()
                cpu_avg = sum(cpu_usage) / len(cpu_usage)
                memory = self.get_memory_usage()
                
                # 获取GPU信息
                gpus = self.get_gpu_stats()
                gpu_count = len(gpus)
                
                if gpu_count > 0:
                    gpu_avg_util = sum(g['gpu_utilization'] for g in gpus) / gpu_count
                    gpu_avg_power = sum(g['power_draw_watts'] for g in gpus) / gpu_count
                    
                    # 估算能耗增量
                    energy_increment_kwh = (gpu_avg_power * gpu_count * interval) / (1000 * 3600)
                    
                    # 记录日志
                    with open(self.log_file, 'a') as f:
                        f.write(f"{timestamp},{cpu_avg},{memory['percent']},{gpu_count},{gpu_avg_util},{gpu_avg_power},{energy_increment_kwh}\n")
                    
                    print(f"[{timestamp}] CPU: {cpu_avg:.1f}%, 内存: {memory['percent']:.1f}%, GPU: {gpu_avg_util:.1f}% @ {gpu_avg_power:.1f}W, 估算能耗增量: {energy_increment_kwh:.4f} kWh")
                else:
                    # 只有CPU和内存的情况
                    with open(self.log_file, 'a') as f:
                        f.write(f"{timestamp},{cpu_avg},{memory['percent']},0,0,0,0\n")
                    
                    print(f"[{timestamp}] CPU: {cpu_avg:.1f}%, 内存: {memory['percent']:.1f}%")
                
                time.sleep(interval)
        except KeyboardInterrupt:
            self.stop_monitoring()
    
    def stop_monitoring(self):
        # 停止监控
        self.monitoring_active = False
        print("停止资源监控")
    
    def analyze_usage_patterns(self):
        # 分析使用模式并提出优化建议
        try:
            # 读取日志文件
            df = pd.read_csv(self.log_file)
            
            # 转换时间戳
            df['timestamp'] = pd.to_datetime(df['timestamp'])
            
            # 按小时分组分析
            df['hour'] = df['timestamp'].dt.hour
            hourly_stats = df.groupby('hour').agg({
                'cpu_avg_usage': 'mean',
                'memory_percent': 'mean',
                'gpu_avg_utilization': 'mean',
                'gpu_avg_power_watts': 'mean',
                'energy_estimate_kwh': 'sum'
            }).reset_index()
            
            # 识别低使用率时段
            low_cpu_hours = hourly_stats[hourly_stats['cpu_avg_usage'] < 30]['hour'].tolist()
            low_gpu_hours = hourly_stats[hourly_stats['gpu_avg_utilization'] < 20]['hour'].tolist()
            
            # 计算总能耗
            total_energy = df['energy_estimate_kwh'].sum()
            
            # 提出优化建议
            recommendations = []
            
            if low_cpu_hours:
                recommendations.append(f"低CPU使用率时段: {', '.join(map(str, low_cpu_hours))}时，可考虑在这些时段降低CPU频率或关闭部分节点")
            
            if low_gpu_hours:
                recommendations.append(f"低GPU使用率时段: {', '.join(map(str, low_gpu_hours))}时，可考虑在这些时段关闭部分GPU或切换到低功耗模式")
            
            # 分析GPU利用率分布
            gpu_util = df['gpu_avg_utilization']
            if len(gpu_util) > 0:
                idle_gpu_percent = (gpu_util < 10).mean() * 100
                low_gpu_percent = ((gpu_util >= 10) & (gpu_util < 50)).mean() * 100
                high_gpu_percent = (gpu_util >= 80).mean() * 100
                
                if idle_gpu_percent > 20:
                    recommendations.append(f"GPU空闲时间占比达{idle_gpu_percent:.1f}%，可考虑实施动态GPU分配或在空闲时关闭")
                
                if low_gpu_percent > 40:
                    recommendations.append(f"GPU低负载运行时间占比达{low_gpu_percent:.1f}%，可考虑使用更小型GPU或优化批处理大小")
                
                if high_gpu_percent > 60:
                    recommendations.append(f"GPU高负载运行时间占比达{high_gpu_percent:.1f}%，可能需要增加GPU资源以避免性能瓶颈")
            
            # 生成报告
            report = {
                'analysis_period': f"{df['timestamp'].min()} 至 {df['timestamp'].max()}",
                'total_energy_consumption_kwh': total_energy,
                'estimated_daily_energy_kwh': total_energy / ((df['timestamp'].max() - df['timestamp'].min()).total_seconds() / 86400),
                'cpu_utilization_summary': {
                    'avg': df['cpu_avg_usage'].mean(),
                    'max': df['cpu_avg_usage'].max(),
                    'min': df['cpu_avg_usage'].min()
                },
                'gpu_utilization_summary': {
                    'avg': df['gpu_avg_utilization'].mean() if len(df) > 0 else 0,
                    'max': df['gpu_avg_utilization'].max() if len(df) > 0 else 0,
                    'min': df['gpu_avg_utilization'].min() if len(df) > 0 else 0
                },
                'recommendations': recommendations
            }
            
            # 生成可视化图表
            self._generate_visualizations(df, hourly_stats)
            
            return report
            
        except Exception as e:
            print(f"分析使用模式时出错: {e}")
            return None
    
    def _generate_visualizations(self, df, hourly_stats):
        # 生成使用情况可视化图表
        plt.figure(figsize=(15, 10))
        
        # CPU使用率趋势
        plt.subplot(3, 1, 1)
        plt.plot(df['timestamp'], df['cpu_avg_usage'], label='CPU使用率(%)')
        plt.axhline(y=30, color='r', linestyle='--', label='低负载阈值(30%)')
        plt.title('CPU使用率趋势')
        plt.ylabel('使用率(%)')
        plt.legend()
        plt.grid(True)
        
        # GPU使用率和功耗
        plt.subplot(3, 1, 2)
        if 'gpu_avg_utilization' in df.columns and len(df) > 0:
            ax1 = plt.gca()
            ax1.plot(df['timestamp'], df['gpu_avg_utilization'], 'b-', label='GPU使用率(%)')
            ax1.set_ylabel('GPU使用率(%)', color='b')
            ax1.tick_params(axis='y', labelcolor='b')
            
            ax2 = ax1.twinx()
            ax2.plot(df['timestamp'], df['gpu_avg_power_watts'], 'r-', label='GPU功耗(W)')
            ax2.set_ylabel('GPU功耗(W)', color='r')
            ax2.tick_params(axis='y', labelcolor='r')
            
            plt.title('GPU使用率和功耗趋势')
            
            lines1, labels1 = ax1.get_legend_handles_labels()
            lines2, labels2 = ax2.get_legend_handles_labels()
            ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper right')
        else:
            plt.text(0.5, 0.5, '无GPU数据可用', ha='center', va='center')
        plt.grid(True)
        
        # 每小时能耗
        plt.subplot(3, 1, 3)
        plt.bar(hourly_stats['hour'], hourly_stats['energy_estimate_kwh'])
        plt.title('每小时能耗分布')
        plt.xlabel('小时')
        plt.ylabel('能耗(kWh)')
        plt.grid(True)
        plt.xticks(range(24))
        
        plt.tight_layout()
        plt.savefig('energy_usage_analysis.png', dpi=300)
        print("已生成能源使用分析图表: energy_usage_analysis.png")
    
    def optimize_gpu_power_settings(self, target_utilization_threshold=30):
        # 优化GPU功耗设置
        try:
            gpus = self.get_gpu_stats()
            if not gpus:
                return "无法获取GPU信息，优化失败"
            
            actions = []
            for gpu in gpus:
                if gpu['gpu_utilization'] < target_utilization_threshold:
                    # 对于低利用率GPU，建议降低功耗限制
                    current_power = gpu['power_draw_watts']
                    suggested_limit = current_power * 0.7  # 建议将功耗限制降至当前的70%
                    actions.append(f"GPU {gpu['index']} ({gpu['name']}) 当前利用率 {gpu['gpu_utilization']:.1f}%，建议将功耗限制设置为 {suggested_limit:.1f}W")
                else:
                    actions.append(f"GPU {gpu['index']} ({gpu['name']}) 当前利用率 {gpu['gpu_utilization']:.1f}%，保持当前功耗设置")
            
            return actions
        except Exception as e:
            print(f"优化GPU功耗设置时出错: {e}")
            return None

# 使用示例
if __name__ == "__main__":
    optimizer = HardwareEnergyOptimizer()
    
    # 打印当前资源使用情况
    print("\n当前系统状态:")
    print(f"CPU使用率: {sum(optimizer.get_cpu_usage()) / len(optimizer.get_cpu_usage()):.1f}%")
    memory = optimizer.get_memory_usage()
    print(f"内存使用率: {memory['percent']:.1f}% ({memory['used_gb']:.1f}/{memory['total_gb']:.1f} GB)")
    
    gpus = optimizer.get_gpu_stats()
    if gpus:
        print(f"检测到 {len(gpus)} 个GPU:")
        for gpu in gpus:
            print(f"  GPU {gpu['index']}: {gpu['name']}, 利用率: {gpu['gpu_utilization']:.1f}%, 功耗: {gpu['power_draw_watts']:.1f}W")
    else:
        print("未检测到GPU")
    
    # 获取GPU优化建议
    gpu_optimizations = optimizer.optimize_gpu_power_settings()
    if gpu_optimizations:
        print("\nGPU优化建议:")
        for suggestion in gpu_optimizations:
            print(f"  {suggestion}")
    
    # 注意：要开始持续监控，请取消下面一行的注释
    # optimizer.monitor_resources(interval=60)  # 每分钟记录一次

### 2.2 软件层面的能源优化

软件层面的优化同样对降低LLM部署的能源消耗至关重要。以下是几种有效的软件优化策略：

1. **模型量化与剪枝**：减少模型大小和计算需求
   - 将FP32降至INT8/INT4精度，可减少50-75%的能源消耗
   - 剪枝不重要的权重和神经元，减少20-40%的模型大小
   - 结构化稀疏化对能源效率提升更为明显

2. **批处理优化**：提高GPU利用率
   - 动态批处理根据可用资源自动调整批大小
   - 分组批处理将相似请求合并，提高处理效率
   - 混合精度训练在保持性能的同时降低能耗

3. **知识蒸馏**：将大模型知识迁移到小模型
   - 训练小型"学生"模型模仿大型"教师"模型
   - 可以将模型缩小10倍以上，同时保留85-95%的性能
   - 特别适合边缘部署场景

4. **缓存策略优化**：减少重复计算
   - 实现智能提示缓存系统
   - 使用语义哈希快速检索相似查询
   - 多级缓存架构（内存、磁盘、分布式）

5. **并行化与流水线优化**：提高资源利用率
   - 模型并行与数据并行的最佳组合
   - 流水线并行减少通信开销
   - 自适应并行度调整根据负载动态变化

以下是一个模型量化与批处理优化的Python实现示例：

```python
import torch
import torch.nn as nn
from transformers import AutoModelForCausalLM, AutoTokenizer
import time
import psutil
import os
from concurrent.futures import ThreadPoolExecutor
import numpy as np

class ModelOptimization:
    def __init__(self):
        self.models = {}
        self.tokenizers = {}
        self.energy_metrics = []
    
    def load_model(self, model_name, device="cuda" if torch.cuda.is_available() else "cpu"):
        """加载原始模型和分词器"""
        print(f"加载模型: {model_name} 到 {device}")
        start_time = time.time()
        
        tokenizer = AutoTokenizer.from_pretrained(model_name)
        model = AutoModelForCausalLM.from_pretrained(model_name)
        model.to(device)
        model.eval()
        
        load_time = time.time() - start_time
        print(f"模型加载完成，耗时: {load_time:.2f}秒")
        
        # 存储模型和分词器
        self.models["original"] = model
        self.tokenizers["original"] = tokenizer
        
        # 获取模型信息
        param_count = sum(p.numel() for p in model.parameters()) / 1e9  # 转换为十亿参数
        print(f"模型参数量: {param_count:.2f}B")
        
        return model, tokenizer
    
    def quantize_model(self, model_name, quantization_bits=8, device="cuda" if torch.cuda.is_available() else "cpu"):
        """量化模型以减少内存占用和提高推理速度"""
        if "original" not in self.models:
            print("请先加载原始模型")
            return None
        
        print(f"对模型进行{quantization_bits}位量化")
        start_time = time.time()
        
        # 获取原始模型
        original_model = self.models["original"]
        
        # 进行量化
        if quantization_bits == 8:
            # 8位量化
            quantized_model = torch.quantization.quantize_dynamic(
                original_model,
                {nn.Linear},  # 只量化线性层
                dtype=torch.qint8
            )
        elif quantization_bits == 4:
            # 4位量化 - 使用更高级的量化技术
            # 注意：这里使用模拟的4位量化，实际应用中可能需要特定库支持
            quantized_model = self._simulate_4bit_quantization(original_model)
        else:
            print(f"不支持的量化位数: {quantization_bits}")
            return None
        
        quantized_model.to(device)
        quantized_model.eval()
        
        quant_time = time.time() - start_time
        print(f"模型量化完成，耗时: {quant_time:.2f}秒")
        
        # 存储量化模型
        self.models[f"quantized_{quantization_bits}bit"] = quantized_model
        
        # 估算量化后模型大小
        original_size = sum(p.numel() * p.element_size() for p in original_model.parameters())
        # 对于量化模型，线性层参数大小减少为原来的1/4(4bit)或1/2(8bit)
        reduction_factor = 8 / quantization_bits
        estimated_size = original_size / reduction_factor
        size_reduction = (1 - 1/reduction_factor) * 100
        
        print(f"估计模型大小减少: {size_reduction:.1f}%")
        print(f"原始大小估计: {original_size/1e9:.2f}GB")
        print(f"量化后大小估计: {estimated_size/1e9:.2f}GB")
        
        return quantized_model
    
    def _simulate_4bit_quantization(self, model):
        """模拟4位量化"""
        # 创建模型副本
        quantized_model = copy.deepcopy(model)
        
        # 模拟量化 - 在实际应用中使用专用的4位量化库
        # 这里只是示意性代码
        for name, module in quantized_model.named_modules():
            if isinstance(module, nn.Linear):
                # 获取权重
                weight = module.weight.data
                
                # 量化和反量化模拟
                scale = (weight.max() - weight.min()) / 15.0  # 4位有符号整数范围: -8到7
                zero_point = -8 - (weight.min() / scale)
                
                # 量化到4位
                quantized = torch.clamp(torch.round(weight / scale + zero_point), -8, 7)
                
                # 反量化 (在实际应用中，推理时可能会直接使用量化权重)
                dequantized = (quantized - zero_point) * scale
                
                # 更新权重
                module.weight.data = dequantized
        
        return quantized_model
    
    def prune_model(self, model_name, pruning_percentage=0.3, device="cuda" if torch.cuda.is_available() else "cpu"):
        """剪枝模型以减少参数量"""
        if "original" not in self.models:
            print("请先加载原始模型")
            return None
        
        print(f"对模型进行{pruning_percentage*100}%的权重剪枝")
        start_time = time.time()
        
        # 导入剪枝相关库
        import torch.nn.utils.prune as prune
        
        # 获取原始模型
        original_model = self.models["original"]
        
        # 创建模型副本
        pruned_model = copy.deepcopy(original_model)
        
        # 对所有线性层进行剪枝
        parameters_to_prune = []
        for name, module in pruned_model.named_modules():
            if isinstance(module, nn.Linear):
                parameters_to_prune.append((module, 'weight'))
        
        # 执行全局剪枝
        prune.global_unstructured(
            parameters_to_prune,
            pruning_method=prune.L1Unstructured,
            amount=pruning_percentage,
        )
        
        # 使剪枝永久化
        for module, _ in parameters_to_prune:
            prune.remove(module, 'weight')
        
        pruned_model.to(device)
        pruned_model.eval()
        
        prune_time = time.time() - start_time
        print(f"模型剪枝完成，耗时: {prune_time:.2f}秒")
        
        # 存储剪枝模型
        self.models[f"pruned_{int(pruning_percentage*100)}%"] = pruned_model
        
        # 计算实际剪枝率
        total_params = sum(p.numel() for p in original_model.parameters())
        pruned_params = sum(p.numel() for p in pruned_model.parameters())
        actual_pruning_rate = 1 - pruned_params / total_params
        
        print(f"实际参数减少: {actual_pruning_rate*100:.1f}%")
        print(f"剪枝前参数: {total_params/1e6:.2f}M")
        print(f"剪枝后参数: {pruned_params/1e6:.2f}M")
        
        return pruned_model
    
    def generate_text(self, model_key, prompt, max_length=100, batch_size=1):
        """使用指定模型生成文本"""
        if model_key not in self.models:
            print(f"未找到模型: {model_key}")
            return None
        
        if "original" not in self.tokenizers:
            print("未找到分词器")
            return None
        
        model = self.models[model_key]
        tokenizer = self.tokenizers["original"]
        
        # 创建批次
        prompts = [prompt] * batch_size
        
        # 编码
        inputs = tokenizer(prompts, return_tensors="pt", padding=True, truncation=True)
        inputs = {k: v.to(model.device) for k, v in inputs.items()}
        
        # 记录开始前的系统状态
        start_time = time.time()
        start_energy = self._get_system_energy_metrics()
        
        # 生成文本
        with torch.no_grad():
            outputs = model.generate(
                **inputs,
                max_length=max_length,
                num_return_sequences=1,
                do_sample=True,
                temperature=0.7,
                pad_token_id=tokenizer.eos_token_id
            )
        
        # 记录结束后的系统状态
        end_time = time.time()
        end_energy = self._get_system_energy_metrics()
        
        # 解码结果
        results = [tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
        
        # 计算性能指标
        generation_time = end_time - start_time
        tokens_per_second = (batch_size * (max_length - inputs['input_ids'].shape[1])) / generation_time
        
        # 计算能源指标
        energy_metrics = {
            "model": model_key,
            "batch_size": batch_size,
            "generation_time": generation_time,
            "tokens_per_second": tokens_per_second,
            "cpu_percent": end_energy["cpu_percent"] - start_energy["cpu_percent"] if end_energy and start_energy else 0,
            "memory_percent": end_energy["memory_percent"] - start_energy["memory_percent"] if end_energy and start_energy else 0
        }
        
        # 记录能源指标
        self.energy_metrics.append(energy_metrics)
        
        print(f"[{model_key}] 批大小: {batch_size}, 生成耗时: {generation_time:.2f}秒, 每秒生成token: {tokens_per_second:.2f}")
        
        return results, energy_metrics
    
    def _get_system_energy_metrics(self):
        """获取系统能源使用指标"""
        try:
            return {
                "cpu_percent": psutil.cpu_percent(interval=0.1),
                "memory_percent": psutil.virtual_memory().percent
            }
        except:
            return None
    
    def benchmark_models(self, prompt, max_length=100, batch_sizes=[1, 4, 8, 16]):
        """对所有加载的模型进行基准测试"""
        results = {}
        
        for model_key in self.models.keys():
            print(f"\n对模型 {model_key} 进行基准测试:")
            model_results = []
            
            for batch_size in batch_sizes:
                try:
                    _, metrics = self.generate_text(model_key, prompt, max_length, batch_size)
                    model_results.append(metrics)
                except Exception as e:
                    print(f"批大小 {batch_size} 测试失败: {e}")
                    continue
            
            results[model_key] = model_results
        
        # 生成比较报告
        self._generate_benchmark_report(results)
        
        return results
    
    def _generate_benchmark_report(self, results):
        """生成基准测试比较报告"""
        print("\n========== 基准测试比较报告 ==========")
        print(f"{'模型':<20} {'批大小':<10} {'生成时间(秒)':<15} {'每秒Token数':<15} {'CPU使用率':<15} {'内存使用率':<15}")
        print("-" * 95)
        
        for model_key, model_results in results.items():
            for result in model_results:
                print(f"{model_key:<20} {result['batch_size']:<10} {result['generation_time']:<15.4f} {result['tokens_per_second']:<15.2f} {result['cpu_percent']:<15.2f} {result['memory_percent']:<15.2f}")
        
        # 计算相对性能和效率
        print("\n========== 相对性能比较 ==========")
        if "original" in results and results["original"]:
            # 使用原始模型的单批次结果作为基准
            original_single_batch = next((r for r in results["original"] if r["batch_size"] == 1), None)
            if original_single_batch:
                original_time = original_single_batch["generation_time"]
                original_tokens_per_second = original_single_batch["tokens_per_second"]
                
                print(f"{'模型':<20} {'批大小':<10} {'速度提升':<15} {'效率提升':<15}")
                print("-" * 65)
                
                for model_key, model_results in results.items():
                    for result in model_results:
                        speedup = original_time / result["generation_time"] if result["generation_time"] > 0 else 0
                        efficiency_boost = result["tokens_per_second"] / original_tokens_per_second if original_tokens_per_second > 0 else 0
                        print(f"{model_key:<20} {result['batch_size']:<10} {speedup:<15.2f}x {efficiency_boost:<15.2f}x")
    
    def optimize_batch_processing(self, model_key, prompt, test_batch_sizes=[1, 2, 4, 8, 16, 32, 64], max_length=100):
        """优化批处理大小"""
        if model_key not in self.models:
            print(f"未找到模型: {model_key}")
            return None
        
        print(f"\n优化模型 {model_key} 的批处理大小:")
        batch_metrics = []
        
        for batch_size in test_batch_sizes:
            try:
                print(f"测试批大小 {batch_size}...")
                _, metrics = self.generate_text(model_key, prompt, max_length, batch_size)
                batch_metrics.append(metrics)
            except Exception as e:
                print(f"批大小 {batch_size} 测试失败: {e}")
                # 可能是内存不足，停止测试更大的批大小
                print("已达到硬件限制，停止测试更大的批大小")
                break
        
        # 找出最佳批处理大小
        if batch_metrics:
            # 按每token能耗效率排序 (假设tokens_per_second与能耗效率正相关)
            best_batch = max(batch_metrics, key=lambda x: x["tokens_per_second"] / max(x["cpu_percent"], 1))
            
            print("\n批处理优化结果:")
            print(f"{'批大小':<10} {'生成时间(秒)':<15} {'每秒Token数':<15} {'性能/CPU比':<15}")
            print("-" * 65)
            
            for metrics in batch_metrics:
                efficiency_ratio = metrics["tokens_per_second"] / max(metrics["cpu_percent"], 1)
                is_best = "<-- 最佳" if metrics == best_batch else ""
                print(f"{metrics['batch_size']:<10} {metrics['generation_time']:<15.4f} {metrics['tokens_per_second']:<15.2f} {efficiency_ratio:<15.4f} {is_best}")
            
            print(f"\n建议的最佳批处理大小: {best_batch['batch_size']}")
            print(f"在此批大小下，每秒可处理 {best_batch['tokens_per_second']:.2f} 个token")
            
            return best_batch
        
        return None
    
    def implement_caching_strategy(self, model_key, cache_size=100, similarity_threshold=0.8):
        """实现智能提示缓存策略"""
        print(f"\n为模型 {model_key} 实现智能提示缓存")
        
        # 缓存类实现
        class PromptCache:
            def __init__(self, capacity=100, similarity_threshold=0.8):
                self.cache = {}
                self.capacity = capacity
                self.similarity_threshold = similarity_threshold
                self.usage_count = {}
            
            def _calculate_similarity(self, prompt1, prompt2):
                """简单的基于字符的相似性计算，实际应用中可使用更复杂的语义相似性"""
                # 转换为小写并分词
                words1 = set(prompt1.lower().split())
                words2 = set(prompt2.lower().split())
                
                # 计算Jaccard相似度
                if not words1 and not words2:
                    return 1.0
                return len(words1.intersection(words2)) / len(words1.union(words2))
            
            def get(self, prompt):
                """获取缓存的结果，如果没有完全匹配则尝试查找相似的"""
                # 检查完全匹配
                if prompt in self.cache:
                    self.usage_count[prompt] += 1
                    return self.cache[prompt]
                
                # 查找相似的提示
                for cached_prompt, cached_result in self.cache.items():
                    similarity = self._calculate_similarity(prompt, cached_prompt)
                    if similarity >= self.similarity_threshold:
                        print(f"缓存命中相似提示 (相似度: {similarity:.2f}):\n  原提示: {prompt}\n  缓存提示: {cached_prompt}")
                        self.usage_count[cached_prompt] += 1
                        return cached_result
                
                return None
            
            def set(self, prompt, result):
                """将结果添加到缓存"""
                # 如果缓存已满，删除最不常用的项
                if len(self.cache) >= self.capacity:
                    # 找出使用次数最少的键
                    least_used = min(self.usage_count, key=self.usage_count.get)
                    del self.cache[least_used]
                    del self.usage_count[least_used]
                
                self.cache[prompt] = result
                self.usage_count[prompt] = 1
            
            def size(self):
                """返回缓存大小"""
                return len(self.cache)
            
            def stats(self):
                """返回缓存统计信息"""
                if not self.usage_count:
                    return {"hits": 0, "misses": 0, "hit_rate": 0}
                
                total_usage = sum(self.usage_count.values())
                # 简单估计，实际需要跟踪命中和未命中
                return {
                    "cache_size": len(self.cache),
                    "total_accesses": total_usage,
                    "avg_usage_per_item": total_usage / len(self.cache)
                }
        
        # 创建缓存实例
        cache = PromptCache(capacity=cache_size, similarity_threshold=similarity_threshold)
        
        # 添加缓存方法到模型优化类
        def cached_generate(self, prompt, max_length=100):
            """使用缓存生成文本"""
            # 尝试从缓存获取
            cached_result = cache.get(prompt)
            if cached_result:
                return cached_result, {"cached": True}
            
            # 缓存未命中，生成新结果
            result, metrics = self.generate_text(model_key, prompt, max_length)
            
            # 存储到缓存
            cache.set(prompt, result)
            
            return result, {"cached": False, "metrics": metrics}
        
        # 将缓存方法绑定到实例
        self.cached_generate = lambda prompt, max_length=100: cached_generate(self, prompt, max_length)
        self.cache = cache
        
        print(f"提示缓存已实现，容量: {cache_size}，相似性阈值: {similarity_threshold}")
        return cache
    
    def test_caching_performance(self, prompts, max_length=100):
        """测试缓存性能"""
        if not hasattr(self, 'cached_generate'):
            print("请先实现缓存策略")
            return None
        
        print("\n测试缓存性能:")
        
        # 第一次运行 - 缓存未填充
        print("\n=== 第一次运行 (冷缓存) ===")
        cold_start_time = time.time()
        cache_hits = 0
        cache_misses = 0
        
        for prompt in prompts:
            result, info = self.cached_generate(prompt, max_length)
            if info["cached"]:
                cache_hits += 1
            else:
                cache_misses += 1
        
        cold_total_time = time.time() - cold_start_time
        print(f"冷缓存运行时间: {cold_total_time:.2f}秒")
        print(f"缓存命中: {cache_hits}, 缓存未命中: {cache_misses}")
        
        # 第二次运行 - 缓存应已填充
        print("\n=== 第二次运行 (热缓存) ===")
        warm_start_time = time.time()
        cache_hits = 0
        cache_misses = 0
        
        for prompt in prompts:
            result, info = self.cached_generate(prompt, max_length)
            if info["cached"]:
                cache_hits += 1
            else:
                cache_misses += 1
        
        warm_total_time = time.time() - warm_start_time
        print(f"热缓存运行时间: {warm_total_time:.2f}秒")
        print(f"缓存命中: {cache_hits}, 缓存未命中: {cache_misses}")
        
        # 计算性能提升
        speedup = cold_total_time / warm_total_time if warm_total_time > 0 else 0
        hit_rate = cache_hits / len(prompts) if prompts else 0
        
        print("\n缓存性能总结:")
        print(f"速度提升: {speedup:.2f}x")
        print(f"缓存命中率: {hit_rate*100:.1f}%")
        print(f"缓存统计: {self.cache.stats()}")
        
        return {
            "cold_time": cold_total_time,
            "warm_time": warm_total_time,
            "speedup": speedup,
            "hit_rate": hit_rate,
            "cache_stats": self.cache.stats()
        }

# 使用示例
if __name__ == "__main__":
    # 导入必要的库
    import copy
    
    # 创建模型优化实例
    optimizer = ModelOptimization()
    
    # 加载模型 (使用较小的模型进行演示)
    # 注意：在实际使用中，您可能需要下载和使用更大的模型
    model_name = "gpt2"
    model, tokenizer = optimizer.load_model(model_name)
    
    # 量化模型
    quantized_model_8bit = optimizer.quantize_model(model_name, quantization_bits=8)
    
    # 剪枝模型
    pruned_model = optimizer.prune_model(model_name, pruning_percentage=0.2)
    
    # 准备测试提示
    test_prompt = "Explain how large language models can help reduce carbon emissions in data centers."
    
    # 生成文本 - 测试不同模型
    print("\n测试不同模型的文本生成:")
    
    # 原始模型
    original_results, original_metrics = optimizer.generate_text("original", test_prompt)
    print("\n原始模型生成结果:")
    print(original_results[0])
    
    # 量化模型
    if quantized_model_8bit:
        quantized_results, quantized_metrics = optimizer.generate_text("quantized_8bit", test_prompt)
        print("\n量化模型生成结果:")
        print(quantized_results[0])
    
    # 剪枝模型
    if pruned_model:
        pruned_results, pruned_metrics = optimizer.generate_text("pruned_20%", test_prompt)
        print("\n剪枝模型生成结果:")
        print(pruned_results[0])
    
    # 基准测试
    print("\n进行基准测试:")
    optimizer.benchmark_models(test_prompt, batch_sizes=[1, 2, 4])
    
    # 优化批处理大小
    print("\n优化批处理大小:")
    optimizer.optimize_batch_processing("original", test_prompt, test_batch_sizes=[1, 2, 4, 8])
    
    # 实现缓存策略
    print("\n实现缓存策略:")
    optimizer.implement_caching_strategy("original", cache_size=20)
    
    # 准备一组相似的提示进行缓存测试
    similar_prompts = [
        "Explain how large language models can help reduce carbon emissions in data centers.",
        "How can LLMs contribute to lowering carbon footprint in data centers?",
        "Ways large language models can reduce environmental impact of data centers.",
        "Explain LLM's role in reducing data center emissions.",
        "How do large language models help make data centers more eco-friendly?"
    ]
    
    # 测试缓存性能
    print("\n测试缓存性能:")
    optimizer.test_caching_performance(similar_prompts)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import scipy.stats as stats

class DataCenterEfficiencyAnalyzer:
    def __init__(self):
        self.energy_data = None
        self.cooling_data = None
        self.it_equipment_data = None
        self.carbon_intensity_data = None
        self.temperature_data = None
    
    def load_energy_data(self, file_path=None, sample_data=False, days=30):
        """加载或生成能源消耗数据"""
        if sample_data:
            # 生成示例数据
            date_range = pd.date_range(end=datetime.now(), periods=days*24, freq='H')
            
            # 创建基础能耗模式（考虑昼夜和周末模式）
            base_load = 100  # kWh
            hourly_pattern = []
            
            for i in range(len(date_range)):
                hour = date_range[i].hour
                weekday = date_range[i].weekday()
                
                # 工作日模式
                if weekday < 5:
                    if 8 <= hour < 18:
                        # 工作时间 - 高峰负载
                        load = base_load * (1 + 0.5 * np.sin((hour - 8) * np.pi / 10) + 0.1 * np.random.random())
                    else:
                        # 非工作时间 - 低负载
                        load = base_load * (0.4 + 0.1 * np.random.random())
                else:
                    # 周末 - 更低负载
                    load = base_load * (0.5 + 0.1 * np.random.random())
                
                hourly_pattern.append(load)
            
            # 创建DataFrame
            self.energy_data = pd.DataFrame({
                'timestamp': date_range,
                'total_energy': hourly_pattern,
                'it_energy': [x * (0.65 + 0.05 * np.random.random()) for x in hourly_pattern],  # IT负载占总负载的65-70%
                'cooling_energy': [x * (0.25 + 0.05 * np.random.random()) for x in hourly_pattern],  # 冷却负载占25-30%
                'other_energy': [hourly_pattern[i] - x[0] - x[1] for i, x in enumerate(zip(
                    [x * (0.65 + 0.05 * np.random.random()) for x in hourly_pattern],
                    [x * (0.25 + 0.05 * np.random.random()) for x in hourly_pattern]
                ))]  # 其他负载
            })
            
            print(f"已生成{days}天的示例能源消耗数据")
        elif file_path:
            # 从文件加载数据
            try:
                self.energy_data = pd.read_csv(file_path, parse_dates=['timestamp'])
                print(f"已从{file_path}加载能源消耗数据")
            except Exception as e:
                print(f"加载数据失败: {e}")
        
        return self.energy_data
    
    def load_temperature_data(self, file_path=None, sample_data=False, days=30, zones=5):
        """加载或生成温度数据"""
        if sample_data:
            # 生成示例温度数据
            date_range = pd.date_range(end=datetime.now(), periods=days*24, freq='H')
            
            # 创建每个区域的温度模式
            temperature_data = []
            
            for zone in range(1, zones + 1):
                for i in range(len(date_range)):
                    hour = date_range[i].hour
                    weekday = date_range[i].weekday()
                    
                    # 基础温度（考虑区域差异）
                    base_temp = 22 + (zone - 3) * 0.5  # 中心区域较冷，边缘区域较热
                    
                    # 温度变化模式
                    if weekday < 5:
                        # 工作日温度变化
                        if 8 <= hour < 18:
                            # 工作时间温度上升
                            temp = base_temp + 2 * np.sin((hour - 8) * np.pi / 10) + 0.5 * np.random.random()
                        else:
                            # 非工作时间温度下降
                            temp = base_temp - 1 + 0.5 * np.random.random()
                    else:
                        # 周末温度较低
                        temp = base_temp - 0.5 + 0.5 * np.random.random()
                    
                    temperature_data.append({
                        'timestamp': date_range[i],
                        'zone_id': zone,
                        'temperature': temp
                    })
            
            # 创建DataFrame
            self.temperature_data = pd.DataFrame(temperature_data)
            
            print(f"已生成{zones}个区域{days}天的示例温度数据")
        elif file_path:
            # 从文件加载数据
            try:
                self.temperature_data = pd.read_csv(file_path, parse_dates=['timestamp'])
                print(f"已从{file_path}加载温度数据")
            except Exception as e:
                print(f"加载数据失败: {e}")
        
        return self.temperature_data
    
    def load_carbon_intensity_data(self, file_path=None, sample_data=False, days=30, region="us-east"):
        """加载或生成碳强度数据"""
        if sample_data:
            # 生成示例碳强度数据（模拟不同时段的电网碳强度变化）
            date_range = pd.date_range(end=datetime.now(), periods=days*24, freq='H')
            
            # 碳强度模式（考虑昼夜和季节变化）
            carbon_intensity = []
            
            for i in range(len(date_range)):
                hour = date_range[i].hour
                weekday = date_range[i].weekday()
                month = date_range[i].month
                
                # 基础碳强度（kgCO₂e/kWh）
                base_ci = 300  # 以美国东部电网为例
                
                # 季节调整
                seasonal_factor = 1 + 0.2 * np.sin((month - 1) * np.pi / 6)  # 冬夏较高，春秋较低
                
                # 工作日模式
                if weekday < 5:
                    if 7 <= hour < 10 or 17 <= hour < 20:
                        # 早晚高峰 - 碳强度较高
                        ci = base_ci * seasonal_factor * (1.2 + 0.1 * np.random.random())
                    elif 10 <= hour < 17:
                        # 白天 - 碳强度中等
                        ci = base_ci * seasonal_factor * (1.0 + 0.1 * np.random.random())
                    else:
                        # 夜间 - 碳强度较低
                        ci = base_ci * seasonal_factor * (0.8 + 0.1 * np.random.random())
                else:
                    # 周末 - 碳强度较低
                    ci = base_ci * seasonal_factor * (0.9 + 0.1 * np.random.random())
                
                carbon_intensity.append(ci)
            
            # 创建DataFrame
            self.carbon_intensity_data = pd.DataFrame({
                'timestamp': date_range,
                'carbon_intensity': carbon_intensity,
                'region': region
            })
            
            print(f"已生成{days}天的示例碳强度数据")
        elif file_path:
            # 从文件加载数据
            try:
                self.carbon_intensity_data = pd.read_csv(file_path, parse_dates=['timestamp'])
                print(f"已从{file_path}加载碳强度数据")
            except Exception as e:
                print(f"加载数据失败: {e}")
        
        return self.carbon_intensity_data
    
    def calculate_pue(self):
        """计算PUE (Power Usage Effectiveness)"""
        if self.energy_data is None:
            print("请先加载能源数据")
            return None
        
        # 确保需要的列存在
        required_columns = ['total_energy', 'it_energy']
        if not all(col in self.energy_data.columns for col in required_columns):
            print(f"数据缺少必要的列: {required_columns}")
            return None
        
        # 计算总体PUE
        total_pue = self.energy_data['total_energy'].sum() / self.energy_data['it_energy'].sum()
        
        # 计算每日PUE
        daily_pue = self.energy_data.resample('D', on='timestamp').agg({
            'total_energy': 'sum',
            'it_energy': 'sum'
        }).eval('pue = total_energy / it_energy')['pue']
        
        # 计算每小时PUE
        hourly_pue = self.energy_data.eval('pue = total_energy / it_energy')
        
        results = {
            'overall_pue': total_pue,
            'daily_pue': daily_pue,
            'hourly_pue': hourly_pue[['timestamp', 'pue']]
        }
        
        print(f"总体PUE: {total_pue:.2f}")
        print(f"日平均PUE: {daily_pue.mean():.2f} (范围: {daily_pue.min():.2f} - {daily_pue.max():.2f})")
        
        return results
    
    def calculate_carbon_footprint(self):
        """计算数据中心的碳足迹"""
        if self.energy_data is None or self.carbon_intensity_data is None:
            print("请先加载能源数据和碳强度数据")
            return None
        
        # 确保两个数据集的时间戳可以对齐
        energy_df = self.energy_data.copy()
        carbon_df = self.carbon_intensity_data.copy()
        
        # 确保时间戳是索引
        energy_df.set_index('timestamp', inplace=True)
        carbon_df.set_index('timestamp', inplace=True)
        
        # 重采样到相同的频率（如果需要）
        if energy_df.index.freq != carbon_df.index.freq:
            # 假设我们重采样到小时级别
            energy_df = energy_df.resample('H').mean()
            carbon_df = carbon_df.resample('H').mean()
        
        # 合并数据集
        merged_df = pd.merge(energy_df, carbon_df[['carbon_intensity']], left_index=True, right_index=True, how='inner')
        
        # 计算碳足迹
        merged_df['carbon_footprint'] = merged_df['total_energy'] * merged_df['carbon_intensity']
        merged_df['it_carbon_footprint'] = merged_df['it_energy'] * merged_df['carbon_intensity']
        
        # 计算总体碳足迹
        total_carbon = merged_df['carbon_footprint'].sum()
        it_carbon = merged_df['it_carbon_footprint'].sum()
        
        # 计算每日碳足迹
        daily_carbon = merged_df.resample('D').agg({
            'carbon_footprint': 'sum',
            'it_carbon_footprint': 'sum',
            'carbon_intensity': 'mean'
        })
        
        results = {
            'total_carbon_footprint': total_carbon,
            'it_carbon_footprint': it_carbon,
            'daily_carbon_footprint': daily_carbon,
            'hourly_data': merged_df.reset_index()[['timestamp', 'carbon_footprint', 'it_carbon_footprint', 'carbon_intensity']]
        }
        
        print(f"总碳足迹: {total_carbon/1000:.2f} kgCO₂e")
        print(f"IT设备碳足迹: {it_carbon/1000:.2f} kgCO₂e ({it_carbon/total_carbon*100:.1f}%)")
        
        return results
    
    def analyze_temperature_patterns(self):
        """分析温度模式并识别热点"""
        if self.temperature_data is None:
            print("请先加载温度数据")
            return None
        
        # 确保需要的列存在
        required_columns = ['timestamp', 'zone_id', 'temperature']
        if not all(col in self.temperature_data.columns for col in required_columns):
            print(f"数据缺少必要的列: {required_columns}")
            return None
        
        # 按区域计算平均温度和温度变化
        zone_stats = self.temperature_data.groupby('zone_id')['temperature'].agg(
            mean='mean',
            std='std',
            min='min',
            max='max'
        ).reset_index()
        
        # 识别热点区域（温度高于平均值2个标准差）
        overall_mean = self.temperature_data['temperature'].mean()
        overall_std = self.temperature_data['temperature'].std()
        threshold = overall_mean + 2 * overall_std
        
        hot_zones = zone_stats[zone_stats['max'] > threshold]['zone_id'].tolist()
        
        # 分析时间模式
        self.temperature_data['hour'] = self.temperature_data['timestamp'].dt.hour
        self.temperature_data['weekday'] = self.temperature_data['timestamp'].dt.weekday
        
        hourly_pattern = self.temperature_data.groupby(['zone_id', 'hour'])['temperature'].mean().reset_index()
        weekday_pattern = self.temperature_data.groupby(['zone_id', 'weekday'])['temperature'].mean().reset_index()
        
        results = {
            'zone_statistics': zone_stats,
            'hot_zones': hot_zones,
            'temperature_threshold': threshold,
            'hourly_pattern': hourly_pattern,
            'weekday_pattern': weekday_pattern
        }
        
        print(f"已识别{len(hot_zones)}个热点区域: {hot_zones}")
        print(f"热点阈值温度: {threshold:.1f}°C")
        
        return results
    
    def identify_energy_efficiency_opportunities(self):
        """识别能源效率优化机会"""
        opportunities = []
        
        # 基于PUE分析
        if self.energy_data is not None:
            pue_results = self.calculate_pue()
            if pue_results:
                overall_pue = pue_results['overall_pue']
                
                if overall_pue > 1.5:
                    opportunities.append({
                        'category': 'cooling',
                        'description': '数据中心PUE过高，表明冷却系统效率低下',
                        'severity': 'high',
                        'potential_improvement': f"降低PUE至1.3可节省约{((overall_pue - 1.3) / (overall_pue - 1)) * 100:.1f}%的能源消耗",
                        'recommendations': [
                            "优化冷热通道隔离",
                            "更新冷却设备为更高效的型号",
                            "实施动态冷却控制",
                            "改善气流管理"
                        ]
                    })
                elif overall_pue > 1.3:
                    opportunities.append({
                        'category': 'cooling',
                        'description': '数据中心PUE略高，有改进空间',
                        'severity': 'medium',
                        'potential_improvement': f"降低PUE至1.2可节省约{((overall_pue - 1.2) / (overall_pue - 1)) * 100:.1f}%的能源消耗",
                        'recommendations': [
                            "优化现有冷却系统设置",
                            "提高机房温度设定点",
                            "修复气流泄漏"
                        ]
                    })
        
        # 基于温度分析
        if self.temperature_data is not None:
            temp_results = self.analyze_temperature_patterns()
            if temp_results and temp_results['hot_zones']:
                opportunities.append({
                    'category': 'hotspots',
                    'description': f"检测到{len(temp_results['hot_zones'])}个热点区域",
                    'severity': 'high',
                    'affected_zones': temp_results['hot_zones'],
                    'recommendations': [
                        "重新布置这些区域的IT设备",
                        "增加这些区域的冷却能力",
                        "改善机柜排列以优化气流",
                        "检查并清理这些区域的通风口"
                    ]
                })
        
        # 基于碳强度分析
        if self.carbon_intensity_data is not None:
            # 分析碳强度模式以识别最佳运行时间
            hourly_ci = self.carbon_intensity_data.groupby(self.carbon_intensity_data['timestamp'].dt.hour)['carbon_intensity'].mean()
            best_hours = hourly_ci.nsmallest(6).index.tolist()
            worst_hours = hourly_ci.nlargest(6).index.tolist()
            
            opportunities.append({
                'category': 'demand_management',
                'description': '优化计算任务调度以减少碳排放',
                'severity': 'medium',
                'details': {
                    'best_operating_hours': best_hours,
                    'worst_operating_hours': worst_hours,
                    'potential_reduction': f"将非关键任务从{worst_hours}转移到{best_hours}可减少约{((hourly_ci.loc[worst_hours].mean() - hourly_ci.loc[best_hours].mean()) / hourly_ci.loc[worst_hours].mean()) * 100:.1f}%的碳足迹"
                },
                'recommendations': [
                    "实施智能任务调度系统",
                    "将批处理任务安排在低碳时段",
                    "优化LLM推理请求队列管理",
                    "考虑在高碳时段降低非关键服务的资源分配"
                ]
            })
        
        # 基于能源使用模式分析
        if self.energy_data is not None:
            # 计算负载因子
            self.energy_data['hour'] = self.energy_data['timestamp'].dt.hour
            hourly_load = self.energy_data.groupby('hour')['it_energy'].mean()
            peak_to_average = hourly_load.max() / hourly_load.mean()
            
            if peak_to_average > 1.5:
                opportunities.append({
                    'category': 'load_balancing',
                    'description': 'IT负载峰谷差过大',
                    'severity': 'medium',
                    'peak_to_average_ratio': peak_to_average,
                    'recommendations': [
                        "实施工作负载均衡策略",
                        "优化虚拟机和容器部署",
                        "考虑使用动态资源分配",
                        "实施服务器整合和虚拟化"
                    ]
                })
        
        print(f"已识别{len(opportunities)}个能源效率优化机会")
        
        # 按严重性排序
        severity_order = {'high': 0, 'medium': 1, 'low': 2}
        opportunities.sort(key=lambda x: severity_order.get(x.get('severity', 'low'), 2))
        
        return opportunities
    
    def generate_efficiency_report(self, output_file=None):
        """生成综合效率报告"""
        # 确保有数据
        if self.energy_data is None:
            print("请至少加载能源数据")
            return None
        
        # 计算关键指标
        pue_results = self.calculate_pue()
        
        report = {
            'title': '数据中心能源效率评估报告',
            'generated_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            'period': {
                'start': self.energy_data['timestamp'].min().strftime('%Y-%m-%d'),
                'end': self.energy_data['timestamp'].max().strftime('%Y-%m-%d')
            },
            'key_metrics': {
                'pue': pue_results['overall_pue'] if pue_results else None,
                'total_energy_consumption': self.energy_data['total_energy'].sum() if 'total_energy' in self.energy_data.columns else None,
                'it_energy_consumption': self.energy_data['it_energy'].sum() if 'it_energy' in self.energy_data.columns else None,
            },
            'opportunities': self.identify_energy_efficiency_opportunities(),
            'recommendations': []
        }
        
        # 如果有碳足迹数据，添加到报告
        if self.carbon_intensity_data is not None:
            carbon_results = self.calculate_carbon_footprint()
            if carbon_results:
                report['key_metrics']['carbon_footprint'] = carbon_results['total_carbon_footprint']
                report['key_metrics']['it_carbon_footprint'] = carbon_results['it_carbon_footprint']
        
        # 生成具体建议
        for opportunity in report['opportunities']:
            report['recommendations'].extend(opportunity.get('recommendations', []))
        
        # 删除重复的建议
        report['recommendations'] = list(set(report['recommendations']))
        
        # 如果指定了输出文件，保存报告
        if output_file:
            try:
                import json
                with open(output_file, 'w', encoding='utf-8') as f:
                    json.dump(report, f, ensure_ascii=False, indent=2, default=str)
                print(f"报告已保存到: {output_file}")
            except Exception as e:
                print(f"保存报告失败: {e}")
        
        print("\n========== 数据中心效率报告摘要 ==========")
        print(f"评估期间: {report['period']['start']} 至 {report['period']['end']}")
        print(f"PUE: {report['key_metrics']['pue']:.2f}")
        print(f"总能源消耗: {report['key_metrics']['total_energy_consumption']/1000:.2f} MWh")
        print(f"IT能源消耗: {report['key_metrics']['it_energy_consumption']/1000:.2f} MWh")
        
        if 'carbon_footprint' in report['key_metrics']:
            print(f"总碳足迹: {report['key_metrics']['carbon_footprint']/1000:.2f} kgCO₂e")
        
        print(f"\n识别到的优化机会数量: {len(report['opportunities'])}")
        print("\n主要建议:")
        for i, rec in enumerate(report['recommendations'][:5], 1):  # 只显示前5条
            print(f"{i}. {rec}")
        
        if len(report['recommendations']) > 5:
            print(f"... 以及其他{len(report['recommendations']) - 5}条建议")
        
        return report
    
    def visualize_performance(self, output_dir=None):
        """可视化数据中心性能指标"""
        # 确保matplotlib正确显示中文
        plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
        plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
        
        figures = []
        
        # 1. 能源消耗趋势图
        if self.energy_data is not None:
            plt.figure(figsize=(12, 6))
            
            # 重采样为每日数据以减少数据点
            daily_data = self.energy_data.resample('D', on='timestamp').sum()
            
            plt.plot(daily_data.index, daily_data['total_energy'], label='总能耗', color='blue')
            plt.plot(daily_data.index, daily_data['it_energy'], label='IT能耗', color='green')
            plt.plot(daily_data.index, daily_data['cooling_energy'], label='冷却能耗', color='red')
            plt.plot(daily_data.index, daily_data['other_energy'], label='其他能耗', color='gray')
            
            plt.title('数据中心每日能源消耗趋势')
            plt.xlabel('日期')
            plt.ylabel('能耗 (kWh)')
            plt.legend()
            plt.grid(True)
            
            if output_dir:
                os.makedirs(output_dir, exist_ok=True)
                plt.savefig(os.path.join(output_dir, 'energy_consumption_trend.png'), dpi=300, bbox_inches='tight')
                print("能源消耗趋势图已保存")
            
            figures.append(plt.gcf())
            plt.close()
        
        # 2. PUE趋势图
        if self.energy_data is not None:
            pue_results = self.calculate_pue()
            if pue_results:
                plt.figure(figsize=(12, 6))
                plt.plot(pue_results['daily_pue'].index, pue_results['daily_pue'], marker='o', linestyle='-', color='purple')
                plt.axhline(y=1.5, color='r', linestyle='--', label='行业基准 (1.5)')
                plt.axhline(y=1.3, color='g', linestyle='--', label='高效目标 (1.3)')
                
                plt.title('每日PUE趋势')
                plt.xlabel('日期')
                plt.ylabel('PUE')
                plt.legend()
                plt.grid(True)
                
                if output_dir:
                    plt.savefig(os.path.join(output_dir, 'pue_trend.png'), dpi=300, bbox_inches='tight')
                    print("PUE趋势图已保存")
                
                figures.append(plt.gcf())
                plt.close()
        
        # 3. 温度分布热图
        if self.temperature_data is not None:
            # 准备热图数据
            pivot_data = self.temperature_data.pivot_table(
                index='zone_id', 
                columns=self.temperature_data['timestamp'].dt.hour, 
                values='temperature', 
                aggfunc='mean'
            )
            
            plt.figure(figsize=(14, 8))
            sns.heatmap(pivot_data, annot=False, cmap='RdYlBu_r', fmt='.1f', cbar_kws={'label': '温度 (°C)'})
            plt.title('各区域温度随时间变化热图')
            plt.xlabel('小时')
            plt.ylabel('区域ID')
            
            if output_dir:
                plt.savefig(os.path.join(output_dir, 'temperature_heatmap.png'), dpi=300, bbox_inches='tight')
                print("温度热图已保存")
            
            figures.append(plt.gcf())
            plt.close()
        
        # 4. 碳强度与能耗相关性
        if self.energy_data is not None and self.carbon_intensity_data is not None:
            # 合并数据
            energy_df = self.energy_data.copy()
            carbon_df = self.carbon_intensity_data.copy()
            
            energy_df.set_index('timestamp', inplace=True)
            carbon_df.set_index('timestamp', inplace=True)
            
            merged_df = pd.merge(energy_df, carbon_df[['carbon_intensity']], left_index=True, right_index=True, how='inner')
            
            plt.figure(figsize=(10, 8))
            
            # 创建散点图
            plt.scatter(merged_df['it_energy'], merged_df['carbon_intensity'], alpha=0.5, c=merged_df.index.hour, cmap='viridis')
            
            # 添加颜色条表示时间
            cbar = plt.colorbar()
            cbar.set_label('小时')
            
            plt.title('IT能耗与碳强度相关性')
            plt.xlabel('IT能耗 (kWh)')
            plt.ylabel('碳强度 (kgCO₂e/kWh)')
            plt.grid(True)
            
            if output_dir:
                plt.savefig(os.path.join(output_dir, 'carbon_intensity_correlation.png'), dpi=300, bbox_inches='tight')
                print("碳强度相关性图已保存")
            
            figures.append(plt.gcf())
            plt.close()
        
        print(f"已生成{len(figures)}个可视化图表")
        
        return figures

# 使用示例
if __name__ == "__main__":
    # 创建分析器实例
    analyzer = DataCenterEfficiencyAnalyzer()
    
    # 生成示例数据
    analyzer.load_energy_data(sample_data=True, days=30)
    analyzer.load_temperature_data(sample_data=True, days=30, zones=8)
    analyzer.load_carbon_intensity_data(sample_data=True, days=30)
    
    # 计算PUE
    print("\n计算PUE指标:")
    pue_results = analyzer.calculate_pue()
    
    # 计算碳足迹
    print("\n计算碳足迹:")
    carbon_results = analyzer.calculate_carbon_footprint()
    
    # 分析温度模式
    print("\n分析温度模式:")
    temp_results = analyzer.analyze_temperature_patterns()
    
    # 识别优化机会
    print("\n识别优化机会:")
    opportunities = analyzer.identify_energy_efficiency_opportunities()
    
    # 生成效率报告
    print("\n生成效率报告:")
    report = analyzer.generate_efficiency_report(output_file="data_center_efficiency_report.json")
    
    # 生成可视化
    print("\n生成可视化图表:")
    analyzer.visualize_performance(output_dir="./visualizations")