<think>我们将构建一个整合蒙特卡洛仿真和整数规划的资源调度优化模型。该模型用于解决以下问题：
1. 通过蒙特卡洛仿真验证在考虑需求不确定性和板卡损耗的情况下，能否达到75%的板卡复用率目标。
2. 通过整数规划求解最优的板卡调拨方案，以最小化运输成本。
模型分为两部分：
第一部分：蒙特卡洛仿真
输入：各区域的需求分布（均值和标准差）、核心区拆除板卡数量的分布、板卡损耗的分布
过程：模拟未来24个月的需求和拆除情况，计算每次仿真的板卡复用率（可用回收板卡满足的需求量 / 总需求）
输出：复用率的概率分布（如95%置信区间）
第二部分：整数规划
输入：具体的一次需求场景和回收板卡数量（可以是蒙特卡洛中的一次采样，也可以是实际数据）
目标：最小化总运输成本
约束：满足每个乡镇的需求，每个仓库的发出量不超过库存，变量为整数
求解：得到最优的调拨方案
我们将设计一个类来封装整个模型，并实现以下功能：
- 加载数据（需求分布、运输成本、仓库库存等）
- 蒙特卡洛仿真
- 整数规划优化
- 结果分析和可视化
注意：板卡类型只有两种：10G PON和50G PON。升级过程中，10G PON板卡被拆除后，经过损耗后可用于其他地区。
假设：
- 需求为随机变量，服从正态分布（也可以使用其他分布，这里以正态分布为例）
- 拆除的板卡数量也是随机变量（与升级计划相关，这里简化为正态分布）
- 损耗：10G PON板卡在拆除后有一定比例的损耗，损耗率服从正态分布（均值为15%，标准差3%）
步骤：
1. 定义类 `ResourceOptimizationModel`
2. 初始化：设置参数，如仿真次数（n_simulations）、时间周期（months=24）等
3. 加载数据：从文件或直接输入，包括地区信息、需求分布参数、运输成本矩阵、仓库初始库存等
4. 蒙特卡洛仿真方法：`monte_carlo_simulation`
循环n_simulations次：
对于每个月（24个月）：
生成每个地区的需求（随机数）
生成核心区拆除的板卡数量（随机数）
计算当月的板卡流动（升级和回收）
累计总需求和总可用回收板卡数量
计算本次仿真的复用率 = 总可用回收板卡 / 总需求 （注意：总可用回收板卡不能超过总需求，因为多出的部分可能不会被使用）
记录复用率
分析复用率的分布，给出置信区间
5. 整数规划方法：`integer_programming_optimization`，针对给定的需求场景和回收板卡库存，求解最优运输方案
使用PuLP库建立整数规划模型
变量：从仓库i到乡镇j的板卡运输数量
目标：最小化总运输成本
约束：需求约束、供应约束、非负整数
求解并返回结果
6. 示例：使用一次蒙特卡洛仿真的结果作为输入，进行整数规划优化
7. 可视化：绘制复用率的分布直方图，展示优化后的调拨方案
注意：在仿真过程中，我们假设每个月回收的板卡可以用于下个月的需求，但为了简化，我们在24个月结束后统一计算。
更精细的模型可以逐月模拟库存变化，但这里我们关注的是整个周期的复用率。
由于板卡升级和回收是逐月发生的，我们假设：
- 升级操作在每月初进行，拆除的板卡经过损耗后进入仓库（可用库存）
- 每月需求在月末发生，由仓库库存和当月的回收板卡（如果有）来满足
- 如果当月库存不足，则记录短缺，但不会跨月调度（因为仿真只关注总复用率，不涉及跨月调度成本，调度优化在整数规划部分针对单次场景）
在仿真部分，我们只计算总复用率，不考虑运输成本。运输成本在整数规划部分考虑。
数据准备：
- regions: 地区列表，包括核心区（升级地区）和乡镇（安装地区）
- demand_params: 每个地区每月需求的分布参数（均值，标准差）
- upgrade_rates: 核心区每月拆除板卡数量的分布参数（均值，标准差）
- transport_cost: 一个字典，键为(from_region, to_region)，值为单位运输成本
- warehouse_initial: 仓库初始库存（这里仓库就是核心区，但回收的板卡会进入仓库）
注意：在仿真中，仓库的库存会随着回收的板卡增加，同时随着满足需求而减少。
由于问题规模，我们假设所有回收的板卡都存放在一个中央仓库，然后由中央仓库运往各个乡镇。
模型简化：
- 只有一个中央仓库（即所有核心区回收的板卡都集中到这里）
- 多个乡镇（安装地区）的需求由中央仓库供应
因此，运输成本是从中央仓库到各个乡镇的运输成本。
在仿真中，中央仓库的库存变化：
每月初：核心区拆除板卡，经过损耗后，可用数量加入中央仓库库存
每月末：用中央仓库库存满足本月需求，如果库存足够，则减去需求；如果不够，则记录短缺（但库存清零），短缺部分由新购板卡满足（不计入复用率）
复用率 = 总回收利用量 / 总需求
总回收利用量 = 24个月中实际从仓库中取出的回收板卡数量（即满足需求的部分，不超过需求）
总需求 = 24个月的总需求
注意：仓库库存可能剩余，但剩余部分不算入分子。分子是实际被使用的回收板卡数量。
在整数规划部分，我们针对一次具体的场景（即24个月结束后，我们得到总需求和总可用回收板卡量）进行优化，但实际上，我们更关心的是单个月份或一个时间点的调拨。但为了简化，整数规划部分我们独立于仿真，可以针对任意给定的仓库库存和需求分布进行优化。
因此，我们调整：蒙特卡洛仿真只计算复用率，而整数规划部分可以单独使用，输入为仓库库存（由回收板卡组成）和各乡镇的需求。
我们设计两个独立的部分，但整数规划部分可以接受仿真结果中的一次采样（即一个需求场景和一个仓库库存量）作为输入。
代码结构：
class ResourceOptimizationModel:
def __init__(self, n_simulations=10000, months=24):
self.n_simulations = n_simulations
self.months = months
self.regions = [] # 所有地区
self.warehouse_name = 'Central' # 中央仓库
self.demand_means = {} # 每个地区每月需求的均值
self.demand_stddevs = {} # 每个地区每月需求的标准差
self.upgrade_mean = 0 # 核心区每月拆除板卡均值
self.upgrade_stddev = 0 # 核心区每月拆除板卡标准差
self.transport_costs = {} # 从中央仓库到各乡镇的运输成本，键为乡镇名，值为成本
self.loss_rate_mean = 0.15 # 损耗率均值
self.loss_rate_stddev = 0.03 # 损耗率标准差
def load_data(self, demand_params, upgrade_params, transport_costs):
# demand_params: 字典，键为地区名（乡镇），值为(均值, 标准差)
# upgrade_params: (均值, 标准差)
# transport_costs: 字典，键为乡镇名，值为成本
pass
def monte_carlo_simulation(self):
# 记录每次仿真的复用率
reuse_rates = []
for _ in range(self.n_simulations):
total_demand = 0
total_reused = 0
warehouse_stock = 0 # 中央仓库库存，初始为0
for month in range(self.months):
# 1. 拆除板卡（核心区升级）
upgrade_quantity = max(0, int(np.random.normal(self.upgrade_mean, self.upgrade_stddev)))
# 计算损耗
loss_rate = max(0, min(1, np.random.normal(self.loss_rate_mean, self.loss_rate_stddev)))
usable_quantity = int(upgrade_quantity * (1 - loss_rate))
warehouse_stock += usable_quantity
# 2. 生成各乡镇本月需求
monthly_demand = {}
for region, (mean, stddev) in self.demand_params.items():
demand = max(0, int(np.random.normal(mean, stddev)))
monthly_demand[region] = demand
total_demand += demand
# 3. 用仓库库存满足本月需求
# 注意：我们假设中央仓库统一供应，所以总需求是各个乡镇需求之和
total_monthly_demand = sum(monthly_demand.values())
# 实际可复用数量不能超过本月总需求和仓库库存
reused_this_month = min(warehouse_stock, total_monthly_demand)
total_reused += reused_this_month
# 更新仓库库存
warehouse_stock -= reused_this_month
# 注意：如果仓库库存不足，则只使用库存部分，短缺部分由新购板卡满足（不计入复用）
# 计算本次仿真的复用率
if total_demand > 0:
reuse_rate = total_reused / total_demand
else:
reuse_rate = 0
reuse_rates.append(reuse_rate)
# 分析复用率
self.reuse_rates = reuse_rates
mean_reuse = np.mean(reuse_rates)
std_reuse = np.std(reuse_rates)
# 95%置信区间
ci_low = np.percentile(reuse_rates, 2.5)
ci_high = np.percentile(reuse_rates, 97.5)
return mean_reuse, std_reuse, (ci_low, ci_high)
def integer_programming_optimization(self, warehouse_stock, demand_scenario):
# warehouse_stock: 仓库可用的回收板卡数量
# demand_scenario: 字典，键为乡镇，值为该乡镇的需求量
# 建立问题
prob = pulp.LpProblem("Resource_Allocation", pulp.LpMinimize)
# 变量: 运往每个乡镇的板卡数量
regions = demand_scenario.keys()
x = pulp.LpVariable.dicts("ship", regions, lowBound=0, cat='Integer')
# 目标函数: 总运输成本
prob += pulp.lpSum([x[region] * self.transport_costs[region] for region in regions])
# 约束1: 满足每个乡镇的需求
for region in regions:
prob += x[region] >= demand_scenario[region]
# 约束2: 从仓库运出的总量不超过库存
prob += pulp.lpSum([x[region] for region in regions]) <= warehouse_stock
# 求解
prob.solve()
# 提取结果
if pulp.LpStatus[prob.status] == 'Optimal':
solution = {region: x[region].value() for region in regions}
total_cost = pulp.value(prob.objective)
return solution, total_cost
else:
return None, None
def run(self):
# 运行蒙特卡洛仿真
mean_reuse, std_reuse, (ci_low, ci_high) = self.monte_carlo_simulation()
print(f"平均复用率: {mean_reuse:.4f}, 标准差: {std_reuse:.4f}")
print(f"95%置信区间: [{ci_low:.4f}, {ci_high:.4f}]")
# 为了演示整数规划，我们取一次蒙特卡洛仿真的最后一个月（或任意一次）的需求场景和仓库库存
# 但注意：我们的仿真没有记录每个月的最后状态，所以这里我们重新模拟一次（取最后一次仿真的最后一个月）
# 或者我们可以从仿真中抽取一次作为示例
# 这里我们简单生成一个示例场景：
# 仓库库存：从拆除中获得的可用板卡（取一次仿真的最后库存，但注意我们仿真中每个月都消耗了，所以最后库存可能很少）
# 需求场景：取一次仿真的最后一个月需求
# 但注意：我们更关心的是整个周期结束后的总需求和总回收利用，整数规划是针对一次调拨（比如一个月）的。
# 因此，我们调整整数规划的输入：假设我们只优化一个月的调拨，这个月仓库库存为S，这个月的需求为D（各个乡镇）
# 重新模拟一次，记录最后一个月的情况
warehouse_stock = 0
for month in range(self.months):
upgrade_quantity = max(0, int(np.random.normal(self.upgrade_mean, self.upgrade_stddev)))
loss_rate = max(0, min(1, np.random.normal(self.loss_rate_mean, self.loss_rate_stddev)))
usable_quantity = int(upgrade_quantity * (1 - loss_rate))
warehouse_stock += usable_quantity
# 生成本月需求
monthly_demand = {}
for region, (mean, stddev) in self.demand_params.items():
demand = max(0, int(np.random.normal(mean, stddev)))
monthly_demand[region] = demand
# 满足需求
total_demand = sum(monthly_demand.values())
reused_this_month = min(warehouse_stock, total_demand)
warehouse_stock -= reused_this_month
# 现在，我们假设有一个新的月份，仓库库存为当前warehouse_stock（剩余库存），但需求是新的（独立生成）
# 或者我们可以用之前生成过的最后一个月需求，但这里我们重新生成一次需求场景
demand_scenario = {}
for region, (mean, stddev) in self.demand_params.items():
demand_scenario[region] = max(0, int(np.random.normal(mean, stddev)))
# 使用整数规划进行优化
solution, total_cost = self.integer_programming_optimization(warehouse_stock, demand_scenario)
if solution is not None:
print("最优调拨方案:")
for region, quantity in solution.items():
print(f" 运往 {region}: {quantity} 块板卡")
print(f"总运输成本: {total_cost}")
# 可视化复用率分布
plt.hist(self.reuse_rates, bins=50, alpha=0.7)
plt.axvline(ci_low, color='red', linestyle='dashed', linewidth=1, label='95% CI 下限')
plt.axvline(ci_high, color='green', linestyle='dashed', linewidth=1, label='95% CI 上限')
plt.axvline(0.75, color='blue', linewidth=1, label='目标复用率75%')
plt.xlabel('复用率')
plt.ylabel('频次')
plt.legend()
plt.title('蒙特卡洛仿真：复用率分布')
plt.show()
注意：上述代码中，整数规划部分只优化了一个月的调拨，且需求是独立生成的。在实际应用中，可能需要根据具体场景调整。
使用示例：
model = ResourceOptimizationModel(n_simulations=1000, months=24)
demand_params = {
'Town1': (100, 10),
'Town2': (80, 8),
'Town3': (120, 12)
}
upgrade_params = (200, 20) # 核心区每月拆除板卡均值为200，标准差20
transport_costs = {
'Town1': 5,
'Town2': 7,
'Town3': 4
}
model.load_data(demand_params, upgrade_params, transport_costs)
model.run()
注意：这个模型假设所有乡镇的需求都由中央仓库供应，且不考虑仓库之间的调拨。
针对问题：复用率目标75%是否可行？通过蒙特卡洛仿真的置信区间可以判断（例如，置信区间在[72%,81%]之间，则75%的目标是可行的）。
同时，整数规划给出了具体的最优调拨方案，以最小化运输成本。
现在，我们编写完整代码。</think># 资源调度优化模型：蒙特卡洛仿真 + 整数规划
下面我将实现一个完整的资源调度优化模型，该模型结合蒙特卡洛仿真和整数规划来解决板卡资源盘活问题。模型将验证75%的复用率可行性，并提供最优调拨方案。
```python
import numpy as np
import pandas as pd
import pulp
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.stats import norm, poisson
import logging
import os
from tqdm import tqdm
# 配置日志
logging.basicConfig(
filename='resource_optimization.log',
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger()
# 设置可视化风格
sns.set(style="whitegrid", palette="pastel")
plt.rcParams['font.sans-serif'] = ['SimHei'] # 解决中文显示问题
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
class ResourceOptimizationModel:
def __init__(self, simulation_months=24, n_simulations=10000, confidence_level=0.95):
"""
资源优化模型初始化
参数:
simulation_months: 模拟的月数
n_simulations: 蒙特卡洛仿真次数
confidence_level: 置信水平
"""
self.simulation_months = simulation_months
self.n_simulations = n_simulations
self.confidence_level = confidence_level
# 模型数据
self.regions = [] # 地区列表
self.demand_distributions = {} # 需求分布参数
self.removal_distributions = {} # 拆除分布参数
self.transport_costs = {} # 运输成本
self.warehouses = [] # 仓库列表
self.warehouse_capacities = {} # 仓库容量
self.initial_inventory = {} # 初始库存
# 结果存储
self.simulation_results = []
self.optimal_allocation = None
self.reuse_rate_ci = None
def load_demand_data(self, demand_params):
"""
加载需求分布数据
参数:
demand_params: DataFrame格式的需求参数
列: ['地区', '需求均值', '需求标准差']
"""
for _, row in demand_params.iterrows():
region = row['地区']
self.regions.append(region)
self.demand_distributions[region] = {
'mean': row['需求均值'],
'std': row['需求标准差']
}
def load_removal_data(self, removal_params):
"""
加载拆除分布数据
参数:
removal_params: DataFrame格式的拆除参数
列: ['地区', '拆除均值', '拆除标准差']
"""
for _, row in removal_params.iterrows():
region = row['地区']
self.removal_distributions[region] = {
'mean': row['拆除均值'],
'std': row['拆除标准差']
}
def load_transport_costs(self, transport_data):
"""
加载运输成本数据
参数:
transport_data: DataFrame格式的运输成本
列: ['仓库', '地区', '运输成本']
"""
for _, row in transport_data.iterrows():
warehouse = row['仓库']
region = row['地区']
cost = row['运输成本']
if warehouse not in self.transport_costs:
self.transport_costs[warehouse] = {}
self.transport_costs[warehouse][region] = cost
def load_warehouse_data(self, warehouse_data):
"""
加载仓库数据
参数:
warehouse_data: DataFrame格式的仓库参数
列: ['仓库', '容量', '初始库存']
"""
for _, row in warehouse_data.iterrows():
warehouse = row['仓库']
self.warehouses.append(warehouse)
self.warehouse_capacities[warehouse] = row['容量']
self.initial_inventory[warehouse] = row['初始库存']
def simulate_monthly_demand(self):
"""模拟月度需求（正态分布）"""
monthly_demand = {}
for region in self.regions:
params = self.demand_distributions[region]
demand = np.random.normal(params['mean'], params['std'])
monthly_demand[region] = max(0, demand) # 需求不能为负
return monthly_demand
def simulate_monthly_removal(self):
"""模拟月度板卡拆除（正态分布）"""
monthly_removal = {}
for region in self.regions:
params = self.removal_distributions[region]
removal = np.random.normal(params['mean'], params['std'])
monthly_removal[region] = max(0, removal) # 拆除数量不能为负
return monthly_removal
def calculate_reuse_rate(self, simulation_data):
"""计算复用率"""
total_demand = sum(month['demand'] for month in simulation_data)
total_fulfilled = sum(month['fulfilled'] for month in simulation_data)
return total_fulfilled / total_demand if total_demand > 0 else 0
def monte_carlo_simulation(self):
"""执行蒙特卡洛仿真"""
logger.info(f"开始蒙特卡洛仿真: {self.n_simulations}次模拟, {self.simulation_months}个月")
reuse_rates = []
for sim in tqdm(range(self.n_simulations), desc="蒙特卡洛仿真进度"):
# 初始化库存
inventory = self.initial_inventory.copy()
simulation_data = []
for month in range(1, self.simulation_months + 1):
# 模拟本月需求和拆除
monthly_demand = self.simulate_monthly_demand()
monthly_removal = self.simulate_monthly_removal()
# 更新仓库库存（拆除的板卡进入仓库）
for warehouse in self.warehouses:
# 假设拆除的板卡均匀分配到各仓库
warehouse_removal = monthly_removal.get(warehouse, 0)
inventory[warehouse] += warehouse_removal
# 确保库存不超过仓库容量
if inventory[warehouse] > self.warehouse_capacities[warehouse]:
inventory[warehouse] = self.warehouse_capacities[warehouse]
# 尝试满足需求
monthly_fulfilled = 0
for region, demand in monthly_demand.items():
# 找到运输成本最低的仓库
min_cost = float('inf')
source_warehouse = None
for warehouse in self.warehouses:
if warehouse in self.transport_costs and region in self.transport_costs[warehouse]:
cost = self.transport_costs[warehouse][region]
if cost < min_cost and inventory[warehouse] > 0:
min_cost = cost
source_warehouse = warehouse
# 如果找到合适的仓库，尝试满足需求
if source_warehouse:
# 可供应量不能超过仓库库存
supply = min(demand, inventory[source_warehouse])
inventory[source_warehouse] -= supply
monthly_fulfilled += supply
# 记录本月数据
simulation_data.append({
'month': month,
'demand': sum(monthly_demand.values()),
'removal': sum(monthly_removal.values()),
'fulfilled': monthly_fulfilled,
'inventory': sum(inventory.values())
})
# 计算本次仿真的复用率
reuse_rate = self.calculate_reuse_rate(simulation_data)
reuse_rates.append(reuse_rate)
# 分析结果
self.reuse_rates = reuse_rates
mean_reuse = np.mean(reuse_rates)
std_reuse = np.std(reuse_rates)
# 计算置信区间
z_score = norm.ppf(1 - (1 - self.confidence_level) / 2)
margin_of_error = z_score * (std_reuse / np.sqrt(self.n_simulations))
ci_low = mean_reuse - margin_of_error
ci_high = mean_reuse + margin_of_error
self.reuse_rate_ci = (ci_low, ci_high)
logger.info(f"蒙特卡洛仿真完成: 平均复用率={mean_reuse:.4f}, 95%置信区间=[{ci_low:.4f}, {ci_high:.4f}]")
return mean_reuse, std_reuse, (ci_low, ci_high)
def integer_programming_optimization(self, demand_scenario, removal_scenario):
"""
整数规划优化 - 最小化总运输成本
参数:
demand_scenario: 需求场景字典 {地区: 需求}
removal_scenario: 拆除场景字典 {地区: 拆除数量}
"""
logger.info("开始整数规划优化")
try:
# 创建问题实例
prob = pulp.LpProblem("Resource_Allocation_Optimization", pulp.LpMinimize)
# 决策变量: 从仓库w到地区r的运输量
x = {}
for warehouse in self.warehouses:
for region in self.regions:
# 仅当存在运输成本时才创建变量
if warehouse in self.transport_costs and region in self.transport_costs[warehouse]:
var_name = f"x_{warehouse}_{region}"
x[(warehouse, region)] = pulp.LpVariable(var_name, lowBound=0, cat='Integer')
# 目标函数: 最小化总运输成本
transport_cost = pulp.lpSum(
x[(w, r)] * self.transport_costs[w][r]
for (w, r) in x
)
prob += transport_cost
# 约束1: 每个地区的需求必须满足
for region in self.regions:
prob += pulp.lpSum(
x[(w, r)] for (w, r) in x if r == region
) >= demand_scenario[region], f"Demand_{region}"
# 约束2: 每个仓库的发出量不能超过库存
# 库存 = 初始库存 + 拆除量
for warehouse in self.warehouses:
# 计算仓库总库存
removal_qty = removal_scenario.get(warehouse, 0)
total_inventory = self.initial_inventory[warehouse] + removal_qty
prob += pulp.lpSum(
x[(w, r)] for (w, r) in x if w == warehouse
) <= total_inventory, f"Supply_{warehouse}"
# 约束3: 仓库容量限制
for warehouse in self.warehouses:
prob += pulp.lpSum(
x[(w, r)] for (w, r) in x if w == warehouse
) <= self.warehouse_capacities[warehouse], f"Capacity_{warehouse}"
# 求解问题
prob.solve()
# 检查求解状态
if pulp.LpStatus[prob.status] != 'Optimal':
logger.warning(f"优化求解状态: {pulp.LpStatus[prob.status]}")
return None, None
# 提取结果
allocation_plan = []
total_cost = pulp.value(prob.objective)
for (w, r), var in x.items():
if var.value() > 0:
allocation_plan.append({
'仓库': w,
'地区': r,
'数量': var.value(),
'单位成本': self.transport_costs[w][r],
'总成本': var.value() * self.transport_costs[w][r]
})
self.optimal_allocation = {
'plan': allocation_plan,
'total_cost': total_cost,
'total_supply': sum(item['数量'] for item in allocation_plan),
'total_demand': sum(demand_scenario.values())
}
logger.info(f"优化完成: 总成本={total_cost}, 总供应量={self.optimal_allocation['total_supply']}")
return allocation_plan, total_cost
except Exception as e:
logger.error(f"整数规划优化失败: {str(e)}")
return None, None
def visualize_reuse_rate_distribution(self):
"""可视化复用率分布"""
if not hasattr(self, 'reuse_rates'):
raise ValueError("请先运行蒙特卡洛仿真")
plt.figure(figsize=(12, 6))
# 绘制直方图
plt.hist(self.reuse_rates, bins=50, alpha=0.7, color='skyblue', edgecolor='black')
# 添加置信区间和目标线
ci_low, ci_high = self.reuse_rate_ci
plt.axvline(ci_low, color='red', linestyle='--', label=f'95%置信下限: {ci_low:.2%}')
plt.axvline(ci_high, color='green', linestyle='--', label=f'95%置信上限: {ci_high:.2%}')
plt.axvline(0.75, color='blue', linestyle='-', linewidth=2, label='目标复用率: 75%')
plt.axvline(np.mean(self.reuse_rates), color='orange', linestyle='-', linewidth=2, label=f'平均复用率: {np.mean(self.reuse_rates):.2%}')
# 添加标注
plt.title('板卡复用率分布 - 蒙特卡洛仿真结果')
plt.xlabel('复用率')
plt.ylabel('频次')
plt.legend()
# 保存结果
os.makedirs("results", exist_ok=True)
plt.savefig("results/reuse_rate_distribution.png", dpi=300, bbox_inches='tight')
plt.show()
def visualize_allocation_network(self):
"""可视化最优分配网络"""
if not self.optimal_allocation:
raise ValueError("请先运行整数规划优化")
plt.figure(figsize=(14, 10))
# 绘制仓库节点
for i, warehouse in enumerate(self.warehouses):
plt.scatter(i, 1, s=800, color='red', alpha=0.7, label='仓库' if i == 0 else "")
plt.text(i, 1.1, warehouse, ha='center', fontsize=12, fontweight='bold')
# 绘制地区节点
for j, region in enumerate(self.regions):
plt.scatter(j, 0, s=500, color='blue', alpha=0.7, label='地区' if j == 0 else "")
plt.text(j, -0.1, region, ha='center', fontsize=10)
# 绘制分配路线
max_flow = max(item['数量'] for item in self.optimal_allocation['plan'])
for item in self.optimal_allocation['plan']:
w_idx = self.warehouses.index(item['仓库'])
r_idx = self.regions.index(item['地区'])
# 线宽与运输量成正比
linewidth = 1 + (item['数量'] / max_flow) * 5
plt.plot([w_idx, r_idx], [1, 0], 'k-', alpha=0.5, linewidth=linewidth)
# 添加数量标签
mid_x = (w_idx + r_idx) / 2
mid_y = 0.5
plt.text(mid_x, mid_y, f"{item['数量']:.0f}块",
ha='center', va='center', fontsize=9,
bbox=dict(facecolor='white', alpha=0.7, edgecolor='none'))
plt.title('最优板卡分配方案')
plt.ylim(-0.3, 1.3)
plt.axis('off')
plt.legend(loc='upper right')
# 保存结果
plt.savefig("results/allocation_network.png", dpi=300, bbox_inches='tight')
plt.show()
def save_results(self):
"""保存所有结果到文件"""
os.makedirs("results", exist_ok=True)
# 保存蒙特卡洛仿真结果
if hasattr(self, 'reuse_rates'):
reuse_df = pd.DataFrame({
'simulation': range(1, len(self.reuse_rates) + 1),
'reuse_rate': self.reuse_rates
})
reuse_df.to_csv("results/monte_carlo_results.csv", index=False)
# 保存置信区间
with open("results/confidence_interval.txt", "w") as f:
f.write(f"平均复用率: {np.mean(self.reuse_rates):.4f}\n")
f.write(f"95%置信区间: [{self.reuse_rate_ci[0]:.4f}, {self.reuse_rate_ci[1]:.4f}]\n")
f.write(f"目标复用率75% {'可行' if self.reuse_rate_ci[0] <= 0.75 <= self.reuse_rate_ci[1] else '不可行'}")
# 保存整数规划结果
if self.optimal_allocation:
allocation_df = pd.DataFrame(self.optimal_allocation['plan'])
allocation_df.to_csv("results/optimal_allocation.csv", index=False)
# 保存摘要
summary = {
'总成本': [self.optimal_allocation['total_cost']],
'总供应量': [self.optimal_allocation['total_supply']],
'总需求量': [self.optimal_allocation['total_demand']],
'满足率': [self.optimal_allocation['total_supply'] / self.optimal_allocation['total_demand']]
}
summary_df = pd.DataFrame(summary)
summary_df.to_csv("results/optimization_summary.csv", index=False)
logger.info("结果已保存至 results/ 目录")
# 示例用法
if __name__ == "__main__":
# 1. 创建模型实例
model = ResourceOptimizationModel(
simulation_months=24, # 模拟24个月
n_simulations=1000, # 1000次蒙特卡洛仿真
confidence_level=0.95 # 95%置信水平
)
# 2. 加载数据 - 实际应用中可以从文件读取
# 需求分布数据
demand_data = pd.DataFrame({
'地区': ['华东', '华北', '华南', '西南', '西北'],
'需求均值': [120, 100, 90, 80, 60],
'需求标准差': [15, 12, 10, 8, 6]
})
model.load_demand_data(demand_data)
# 拆除分布数据
removal_data = pd.DataFrame({
'地区': ['华东', '华北', '华南', '西南', '西北'],
'拆除均值': [80, 70, 60, 0, 0], # 西南和西北没有拆除
'拆除标准差': [8, 7, 6, 0, 0]
})
model.load_removal_data(removal_data)
# 仓库数据
warehouse_data = pd.DataFrame({
'仓库': ['上海仓', '北京仓', '广州仓'],
'容量': [500, 400, 300],
'初始库存': [200, 150, 100]
})
model.load_warehouse_data(warehouse_data)
# 运输成本数据
transport_data = pd.DataFrame({
'仓库': ['上海仓']*5 + ['北京仓']*5 + ['广州仓']*5,
'地区': ['华东', '华北', '华南', '西南', '西北']*3,
'运输成本': [
1.5, 2.0, 1.8, 3.0, 4.0, # 上海仓
2.0, 1.5, 2.2, 2.5, 3.5, # 北京仓
1.8, 2.2, 1.5, 2.8, 3.8 # 广州仓
]
})
model.load_transport_costs(transport_data)
# 3. 运行蒙特卡洛仿真
mean_reuse, std_reuse, ci = model.monte_carlo_simulation()
print(f"平均复用率: {mean_reuse:.4f}")
print(f"标准差: {std_reuse:.4f}")
print(f"95%置信区间: [{ci[0]:.4f}, {ci[1]:.4f}]")
# 可视化复用率分布
model.visualize_reuse_rate_distribution()
# 4. 运行整数规划优化
# 创建一个需求场景（实际应用中可以使用蒙特卡洛中的场景）
demand_scenario = {
'华东': 120,
'华北': 100,
'华南': 90,
'西南': 80,
'西北': 60
}
# 创建一个拆除场景
removal_scenario = {
'华东': 80,
'华北': 70,
'华南': 60,
'西南': 0,
'西北': 0
}
allocation, total_cost = model.integer_programming_optimization(demand_scenario, removal_scenario)
if allocation:
print("\n最优调拨方案:")
for item in allocation:
print(f"从 {item['仓库']} 运往 {item['地区']}: {item['数量']} 块板卡 (成本: {item['总成本']:.2f}元)")
print(f"总运输成本: {total_cost:.2f}元")
# 可视化分配网络
model.visualize_allocation_network()
# 5. 保存所有结果
model.save_results()
```
## 模型架构与实现详解
### 1. 模型设计
该资源调度优化模型包含两个核心组件：
1. **蒙特卡洛仿真**：验证75%复用率目标的可行性
2. **整数规划优化**：提供最优调拨方案
```mermaid
graph TD
A[初始化模型] --> B[加载数据]
B --> C[蒙特卡洛仿真]
C --> D[分析复用率分布]
D --> E[整数规划优化]
E --> F[可视化结果]
F --> G[保存结果]
```
### 2. 蒙特卡洛仿真实现
```python
def monte_carlo_simulation(self):
reuse_rates = []
for sim in range(self.n_simulations):
inventory = self.initial_inventory.copy()
simulation_data = []
for month in range(self.simulation_months):
# 模拟需求和拆除
monthly_demand = self.simulate_monthly_demand()
monthly_removal = self.simulate_monthly_removal()
# 更新库存
for warehouse in self.warehouses:
warehouse_removal = monthly_removal.get(warehouse, 0)
inventory[warehouse] += warehouse_removal
inventory[warehouse] = min(inventory[warehouse], self.warehouse_capacities[warehouse])
# 满足需求
monthly_fulfilled = 0
for region, demand in monthly_demand.items():
# 寻找最优供应仓库
min_cost, source_warehouse = float('inf'), None
for warehouse in self.warehouses:
if warehouse in self.transport_costs and region in self.transport_costs[warehouse]:
cost = self.transport_costs[warehouse][region]
if cost < min_cost and inventory[warehouse] > 0:
min_cost, source_warehouse = cost, warehouse
# 供应板卡
if source_warehouse:
supply = min(demand, inventory[source_warehouse])
inventory[source_warehouse] -= supply
monthly_fulfilled += supply
# 记录本月数据
simulation_data.append({
'month': month,
'demand': sum(monthly_demand.values()),
'removal': sum(monthly_removal.values()),
'fulfilled': monthly_fulfilled,
'inventory': sum(inventory.values())
})
# 计算复用率
reuse_rate = self.calculate_reuse_rate(simulation_data)
reuse_rates.append(reuse_rate)
# 分析结果
mean_reuse = np.mean(reuse_rates)
std_reuse = np.std(reuse_rates)
z_score = norm.ppf(1 - (1 - self.confidence_level) / 2)
margin_of_error = z_score * (std_reuse / np.sqrt(self.n_simulations))
ci_low = mean_reuse - margin_of_error
ci_high = mean_reuse + margin_of_error
return mean_reuse, std_reuse, (ci_low, ci_high)
```
**关键功能**：
1. **需求与拆除模拟**：使用正态分布生成随机需求与拆除量
2. **库存管理**：动态更新仓库库存，考虑容量限制
3. **需求满足策略**：基于运输成本选择最优供应仓库
4. **复用率计算**：总满足需求 / 总需求
5. **置信区间分析**：计算95%置信区间
### 3. 整数规划优化实现
```python
def integer_programming_optimization(self, demand_scenario, removal_scenario):
# 创建问题实例
prob = pulp.LpProblem("Resource_Allocation_Optimization", pulp.LpMinimize)
# 决策变量
x = {}
for warehouse in self.warehouses:
for region in self.regions:
if warehouse in self.transport_costs and region in self.transport_costs[warehouse]:
var_name = f"x_{warehouse}_{region}"
x[(warehouse, region)] = pulp.LpVariable(var_name, lowBound=0, cat='Integer')
# 目标函数: 最小化总运输成本
transport_cost = pulp.lpSum(
x[(w, r)] * self.transport_costs[w][r]
for (w, r) in x
)
prob += transport_cost
# 约束1: 需求满足
for region in self.regions:
prob += pulp.lpSum(
x[(w, r)] for (w, r) in x if r == region
) >= demand_scenario[region], f"Demand_{region}"
# 约束2: 供应限制
for warehouse in self.warehouses:
removal_qty = removal_scenario.get(warehouse, 0)
total_inventory = self.initial_inventory[warehouse] + removal_qty
prob += pulp.lpSum(
x[(w, r)] for (w, r) in x if w == warehouse
) <= total_inventory, f"Supply_{warehouse}"
# 约束3: 仓库容量
for warehouse in self.warehouses:
prob += pulp.lpSum(
x[(w, r)] for (w, r) in x if w == warehouse
) <= self.warehouse_capacities[warehouse], f"Capacity_{warehouse}"
# 求解
prob.solve()
# 提取结果
if pulp.LpStatus[prob.status] == 'Optimal':
allocation_plan = []
for (w, r), var in x.items():
if var.value() > 0:
allocation_plan.append({
'仓库': w,
'地区': r,
'数量': var.value(),
'单位成本': self.transport_costs[w][r],
'总成本': var.value() * self.transport_costs[w][r]
})
return allocation_plan, pulp.value(prob.objective)
return None, None
```
**优化模型特点**：
- **目标函数**：最小化总运输成本
- **决策变量**：从仓库到地区的板卡运输量（整数）
- **约束条件**：
1. 需求约束：每个地区的需求必须满足
2. 供应约束：每个仓库的发出量不能超过库存
3. 容量约束：仓库库存不能超过容量限制
### 4. 数据可视化
#### 复用率分布可视化
```python
def visualize_reuse_rate_distribution(self):
plt.figure(figsize=(12, 6))
plt.hist(self.reuse_rates, bins=50, alpha=0.7)
plt.axvline(ci_low, color='red', linestyle='--', label='95% CI下限')
plt.axvline(ci_high, color='green', linestyle='--', label='95% CI上限')
plt.axvline(0.75, color='blue', label='目标复用率75%')
plt.xlabel('复用率')
plt.ylabel('频次')
plt.legend()
plt.title('板卡复用率分布 - 蒙特卡洛仿真结果')
plt.show()
```
#### 最优分配网络可视化
```python
def visualize_allocation_network(self):
plt.figure(figsize=(14, 10))
# 绘制仓库节点
for i, warehouse in enumerate(self.warehouses):
plt.scatter(i, 1, s=800, color='red')
plt.text(i, 1.1, warehouse, ha='center')
# 绘制地区节点
for j, region in enumerate(self.regions):
plt.scatter(j, 0, s=500, color='blue')
plt.text(j, -0.1, region, ha='center')
# 绘制分配路线
for item in self.optimal_allocation['plan']:
w_idx = self.warehouses.index(item['仓库'])
r_idx = self.regions.index(item['地区'])
linewidth = 1 + (item['数量'] / max_flow) * 5
plt.plot([w_idx, r_idx], [1, 0], 'k-', linewidth=linewidth)
plt.text((w_idx+r_idx)/2, 0.5, f"{item['数量']}块", ha='center')
plt.title('最优板卡分配方案')
plt.axis('off')
plt.show()
```
### 5. 模型应用示例
```python
# 创建模型实例
model = ResourceOptimizationModel(simulation_months=24, n_simulations=1000)
# 加载数据
model.load_demand_data(demand_df) # 需求分布
model.load_removal_data(removal_df) # 拆除分布
model.load_warehouse_data(warehouse_df) # 仓库信息
model.load_transport_costs(transport_df) # 运输成本
# 运行蒙特卡洛仿真
mean_reuse, std_reuse, ci = model.monte_carlo_simulation()
print(f"95%置信区间: [{ci[0]:.2%}, {ci[1]:.2%}]")
print(f"75%复用率目标{'可行' if ci[0] <= 0.75 <= ci[1] else '不可行'}")
# 运行整数规划优化
demand_scenario = {'华东': 120, '华北': 100, '华南': 90, '西南': 80, '西北': 60}
removal_scenario = {'华东': 80, '华北': 70, '华南': 60}
allocation, total_cost = model.integer_programming_optimization(demand_scenario, removal_scenario)
# 输出最优方案
for item in allocation:
print(f"从 {item['仓库']} 运往 {item['地区']}: {item['数量']}块板卡")
# 保存结果
model.save_results()
```
## 模型优势与价值
1. **可行性验证**：
- 通过蒙特卡洛仿真量化复用率的不确定性
- 提供95%置信区间："我们有95%的信心，板卡复用率将落在72%到81%之间"
- 直观判断75%目标是否可行
2. **最优调度方案**：
- 整数规划提供最小成本的调拨方案
- 明确指导："A仓库的50块板卡应运往C乡镇，B仓库的30块板卡应运往D乡镇"
- 考虑实际约束（仓库容量、整数运输量）
3. **决策支持**：
- 可视化结果便于理解与汇报
- 完整的数据分析报告
- 可扩展性强，支持更多约束和目标
## 扩展方向
1. **多目标优化**：
```python
# 添加最大化复用率目标
prob += pulp.lpSum(x[(w, r)] for (w, r) in x), "Maximize_Reuse"
# 设置多目标权重
prob += 0.7 * transport_cost + 0.3 * (-reuse_objective) # 负号因为要最大化
```
2. **动态库存模型**：
```python
# 考虑板卡老化损耗
def calculate_dynamic_loss(age, base_loss=0.15):
return min(0.5, base_loss + 0.01 * age) # 每月增加1%损耗
```
3. **时间相关运输**：
```python
# 添加运输时间约束
prob += pulp.lpSum(
x[(w, r)] * transport_time[(w, r)]
for (w, r) in x
) <= max_transport_time
```
4. **随机规划**：
```python
# 考虑需求不确定性
for scenario in scenarios:
prob += pulp.lpSum(
x[(w, r)] for (w, r) in x if r == region
) >= demand_scenario[region][scenario] * scenario_prob[scenario]
```
##
本文提供了截至2012年11月的世界顶级超级计算机排名情况，包括Top500、Green500及Graph500榜单。中国天河一号A（Tianhe-1A）在Top500中位列第八。文章详细列举了各上榜计算机的配置信息，如制造商、所属机构、核心数量、最大运算速度等。
扫一扫
1645
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
