326 lines
13 KiB
Python
326 lines
13 KiB
Python
from __future__ import annotations
|
||
|
||
import copy
|
||
import random
|
||
from typing import Any, Callable
|
||
|
||
from server.aps_domain.constraints import hard_blocking_conflicts
|
||
from server.contracts import ScheduleResult
|
||
from server.engines import get_engine
|
||
from server.engines.base import EngineParams
|
||
from server.timeutil import add_minutes, fmt_date, today0
|
||
|
||
World = dict[str, Any]
|
||
|
||
DEFAULT_MONTE_CARLO_SEED = 20260731
|
||
DEFAULT_MONTE_CARLO_TRIALS = 24
|
||
|
||
|
||
def _counter() -> Callable[[str], int]:
|
||
values: dict[str, int] = {}
|
||
|
||
def next_id(kind: str) -> int:
|
||
values[kind] = values.get(kind, 3000000) + 1
|
||
return values[kind]
|
||
|
||
return next_id
|
||
|
||
|
||
def _bounded_normal(rng: random.Random, mean: float, sigma: float, low: float, high: float) -> float:
|
||
return max(low, min(high, rng.gauss(mean, sigma)))
|
||
|
||
|
||
# ---------------- 可配置分布/相关性/置信区间（矩阵 88 行剩余项） ----------------
|
||
# distributions 结构（缺省与旧行为完全一致）：
|
||
# {"quantity": {"dist": "normal"|"uniform"|"triangular", "sigma"/"low"/"high"/"mode", "mean": 1.0},
|
||
# "efficiency": {...},
|
||
# "shockProbability": 0.15}
|
||
_DEFAULT_DISTRIBUTIONS: dict[str, Any] = {
|
||
"quantity": {"dist": "normal", "mean": 1.0, "sigma": 0.10, "low": 0.80, "high": 1.20},
|
||
"efficiency": {"dist": "normal", "mean": 1.0, "sigma": 0.08, "low": 0.75, "high": 1.25},
|
||
"shockProbability": 0.15,
|
||
}
|
||
|
||
|
||
def _merged_distributions(distributions: dict[str, Any] | None) -> dict[str, Any]:
|
||
"""浅合并用户配置到默认分布表（用户只覆盖要改的维度）。"""
|
||
base = {
|
||
k: dict(v) if isinstance(v, dict) else v
|
||
for k, v in _DEFAULT_DISTRIBUTIONS.items()
|
||
}
|
||
for key, value in (distributions or {}).items():
|
||
if isinstance(value, dict) and isinstance(base.get(key), dict):
|
||
base[key].update(value)
|
||
else:
|
||
base[key] = value
|
||
return base
|
||
|
||
|
||
def _clamp(value: float, low: float, high: float) -> float:
|
||
return max(low, min(high, value))
|
||
|
||
|
||
def _sample_scale(rng: random.Random, cfg: dict[str, Any], z: float | None = None) -> float:
|
||
"""按配置分布采样一个缩放因子（z 供相关性复用同一正态流；None 时内部抽样）。"""
|
||
dist = str(cfg.get("dist") or "normal")
|
||
mean = float(cfg.get("mean") or 1.0)
|
||
low = float(cfg.get("low") or 0.0)
|
||
high = float(cfg.get("high") or 2.0)
|
||
if z is None:
|
||
z = rng.gauss(0.0, 1.0)
|
||
if dist == "uniform":
|
||
lo = float(cfg.get("low") or 0.9)
|
||
hi = float(cfg.get("high") or 1.1)
|
||
return round(rng.uniform(lo, hi), 6)
|
||
if dist == "triangular":
|
||
lo = float(cfg.get("low") or 0.85)
|
||
hi = float(cfg.get("high") or 1.15)
|
||
mode = float(cfg.get("mode") or mean)
|
||
return round(rng.triangular(lo, hi, mode), 6)
|
||
sigma = float(cfg.get("sigma") or 0.10)
|
||
return round(_clamp(mean + sigma * z, low, high), 6)
|
||
|
||
|
||
def _sample_correlated_scales(
|
||
rng: random.Random, distributions: dict[str, Any], correlation: float
|
||
) -> tuple[float, float]:
|
||
"""抽取 quantity/efficiency 缩放因子（支持相关系数 rho ∈ [-1,1]）。
|
||
|
||
共用标准正态流：z1, z2 独立；e = rho*z1 + sqrt(1-rho^2)*z2。
|
||
rho=0 时退化为两个独立正态，且随机流消耗顺序与旧实现一致（种子兼容）。
|
||
"""
|
||
z1 = rng.gauss(0.0, 1.0)
|
||
z2 = rng.gauss(0.0, 1.0)
|
||
rho = max(-1.0, min(1.0, float(correlation or 0.0)))
|
||
e_z = rho * z1 + (1.0 - rho * rho) ** 0.5 * z2
|
||
q_cfg = dict(distributions.get("quantity") or _DEFAULT_DISTRIBUTIONS["quantity"])
|
||
e_cfg = dict(distributions.get("efficiency") or _DEFAULT_DISTRIBUTIONS["efficiency"])
|
||
q_dist = str(q_cfg.get("dist") or "normal")
|
||
e_dist = str(e_cfg.get("dist") or "normal")
|
||
if q_dist == "uniform":
|
||
q = rng.uniform(float(q_cfg.get("low") or 0.9), float(q_cfg.get("high") or 1.1))
|
||
elif q_dist == "triangular":
|
||
q = rng.triangular(float(q_cfg.get("low") or 0.85), float(q_cfg.get("high") or 1.15),
|
||
float(q_cfg.get("mode") or 1.0))
|
||
else:
|
||
q = _sample_scale(rng, q_cfg, z=z1)
|
||
if e_dist == "uniform":
|
||
e = rng.uniform(float(e_cfg.get("low") or 0.9), float(e_cfg.get("high") or 1.1))
|
||
elif e_dist == "triangular":
|
||
e = rng.triangular(float(e_cfg.get("low") or 0.85), float(e_cfg.get("high") or 1.15),
|
||
float(e_cfg.get("mode") or 1.0))
|
||
else:
|
||
e = _sample_scale(rng, e_cfg, z=e_z)
|
||
return q, e
|
||
|
||
|
||
def _perturb_world(
|
||
world: World,
|
||
rng: random.Random,
|
||
*,
|
||
reset_schedule_products: bool,
|
||
distributions: dict[str, Any] | None = None,
|
||
correlation: float = 0.0,
|
||
) -> tuple[World, dict[str, Any]]:
|
||
sandbox = copy.deepcopy(world)
|
||
if reset_schedule_products:
|
||
sandbox["scheduleVersions"] = []
|
||
sandbox["productionOrders"] = []
|
||
sandbox["workOrders"] = []
|
||
sandbox["conflicts"] = []
|
||
dist = _merged_distributions(distributions)
|
||
quantity_scale, efficiency_scale = _sample_correlated_scales(rng, dist, correlation)
|
||
|
||
for order in sandbox.get("salesOrders") or []:
|
||
for item in order.get("items") or []:
|
||
quantity = float(item.get("quantity") or 0.0)
|
||
if quantity > 0:
|
||
item["quantity"] = max(1, int(round(quantity * quantity_scale)))
|
||
for line in sandbox.get("lines") or []:
|
||
base = float(line.get("efficiencyFactor") or 1.0)
|
||
line["efficiencyFactor"] = round(base * efficiency_scale, 6)
|
||
|
||
capacity_shock_line = None
|
||
lines = sandbox.get("lines") or []
|
||
shock_prob = float(dist.get("shockProbability", 0.15) or 0.0)
|
||
if lines and shock_prob > 0 and rng.random() < shock_prob:
|
||
shocked = lines[rng.randrange(len(lines))]
|
||
shocked["efficiencyFactor"] = round(float(shocked.get("efficiencyFactor") or 1.0) * 0.55, 6)
|
||
capacity_shock_line = shocked.get("id")
|
||
|
||
return sandbox, {
|
||
"quantityScale": round(quantity_scale, 6),
|
||
"efficiencyScale": round(efficiency_scale, 6),
|
||
"capacityShockLineId": capacity_shock_line,
|
||
}
|
||
|
||
|
||
def _percentile(values: list[float], percentile: float) -> float:
|
||
if not values:
|
||
return 0.0
|
||
ordered = sorted(values)
|
||
position = (len(ordered) - 1) * percentile
|
||
lower = int(position)
|
||
upper = min(lower + 1, len(ordered) - 1)
|
||
fraction = position - lower
|
||
return round(ordered[lower] * (1.0 - fraction) + ordered[upper] * fraction, 4)
|
||
|
||
|
||
def run_monte_carlo(
|
||
world: World,
|
||
*,
|
||
strategy: str = "COMPREHENSIVE",
|
||
engine_type: str = "RULE",
|
||
trials: int = DEFAULT_MONTE_CARLO_TRIALS,
|
||
seed: int = DEFAULT_MONTE_CARLO_SEED,
|
||
baseline_kpi: dict[str, Any] | None = None,
|
||
planning_horizon_days: int = 14,
|
||
start_date: str | None = None,
|
||
delivery_buffer_ratio: float | None = None,
|
||
freeze_window_hours: float | None = None,
|
||
constraints: dict[str, bool] | None = None,
|
||
reset_schedule_products: bool = False,
|
||
distributions: dict[str, Any] | None = None,
|
||
correlation: float = 0.0,
|
||
confidence_level: float = 0.95,
|
||
) -> dict[str, Any]:
|
||
"""Re-solve fixed-seed demand/capacity perturbations in isolated sandboxes.
|
||
|
||
经统一 Explore 通道执行（矩阵 55 行）：fn 只拿深拷贝沙盒，主干永不外泄写引用；
|
||
每 trial 的 _perturb_world 再在沙盒上做独立扰动，互不污染。
|
||
矩阵 88 行剩余项：distributions 可配置分布（normal/uniform/triangular）、
|
||
correlation 需求-效率扰动相关度（-1..1）、confidence_level 置信区间置信度。
|
||
"""
|
||
from server.aps_domain.explore_boundary import run_explore
|
||
return run_explore(world, lambda sandbox: _monte_carlo_impl(
|
||
sandbox,
|
||
strategy=strategy, engine_type=engine_type, trials=trials, seed=seed,
|
||
baseline_kpi=baseline_kpi, planning_horizon_days=planning_horizon_days,
|
||
start_date=start_date, delivery_buffer_ratio=delivery_buffer_ratio,
|
||
freeze_window_hours=freeze_window_hours, constraints=constraints,
|
||
reset_schedule_products=reset_schedule_products,
|
||
distributions=distributions, correlation=correlation,
|
||
confidence_level=confidence_level,
|
||
))
|
||
from server.aps_domain.explore_boundary import run_explore
|
||
return run_explore(world, lambda sandbox: _monte_carlo_impl(
|
||
sandbox,
|
||
strategy=strategy, engine_type=engine_type, trials=trials, seed=seed,
|
||
baseline_kpi=baseline_kpi, planning_horizon_days=planning_horizon_days,
|
||
start_date=start_date, delivery_buffer_ratio=delivery_buffer_ratio,
|
||
freeze_window_hours=freeze_window_hours, constraints=constraints,
|
||
reset_schedule_products=reset_schedule_products,
|
||
))
|
||
|
||
|
||
def _monte_carlo_impl(
|
||
world: World,
|
||
*,
|
||
strategy: str,
|
||
engine_type: str,
|
||
trials: int,
|
||
seed: int,
|
||
baseline_kpi: dict[str, Any] | None,
|
||
planning_horizon_days: int,
|
||
start_date: str | None,
|
||
delivery_buffer_ratio: float | None,
|
||
freeze_window_hours: float | None,
|
||
constraints: dict[str, bool] | None,
|
||
reset_schedule_products: bool,
|
||
distributions: dict[str, Any] | None,
|
||
correlation: float,
|
||
confidence_level: float,
|
||
) -> dict[str, Any]:
|
||
"""Monte Carlo 核心实现（在统一通道沙盒内运行）。"""
|
||
sample_count = max(1, min(500, int(trials)))
|
||
baseline = baseline_kpi or {}
|
||
baseline_tardiness = max(0.0, float(baseline.get("totalTardiness") or baseline.get("tardiness") or 0.0))
|
||
baseline_conflicts = max(0, int(baseline.get("conflictCount") or baseline.get("conflicts") or 0))
|
||
criteria = {
|
||
"maxTotalTardiness": round(baseline_tardiness + max(1.0, baseline_tardiness * 0.10), 4),
|
||
"maxConflictCount": baseline_conflicts,
|
||
"requireNoHardViolations": True,
|
||
}
|
||
|
||
rng = random.Random(int(seed))
|
||
start = start_date or fmt_date(add_minutes(today0(), 24 * 60))
|
||
outcomes: list[dict[str, Any]] = []
|
||
for trial in range(sample_count):
|
||
sandbox, perturbation = _perturb_world(
|
||
world,
|
||
rng,
|
||
reset_schedule_products=reset_schedule_products,
|
||
distributions=distributions,
|
||
correlation=correlation,
|
||
)
|
||
params = EngineParams(
|
||
orderIds=[],
|
||
engineType=engine_type,
|
||
strategyTemplate=strategy,
|
||
planningHorizonDays=planning_horizon_days,
|
||
startDate=start,
|
||
deliveryBufferRatio=delivery_buffer_ratio,
|
||
freezeWindowHours=freeze_window_hours,
|
||
name=f"mc-{seed}-{trial + 1}",
|
||
constraints=constraints or EngineParams().constraints,
|
||
)
|
||
result: ScheduleResult = get_engine(engine_type).solve(sandbox, params, _counter())
|
||
hard_rows = hard_blocking_conflicts(sandbox, result.versionId, track="fixed")
|
||
hard_ids = {row.get("id") for row in hard_rows}
|
||
critical_unmapped = [
|
||
row for row in sandbox.get("conflicts") or []
|
||
if row.get("versionId") == result.versionId
|
||
and row.get("severity") == "CRITICAL"
|
||
and row.get("id") not in hard_ids
|
||
]
|
||
hard_count = len(hard_rows) + len(critical_unmapped)
|
||
accepted = (
|
||
hard_count == 0
|
||
and float(result.totalTardiness) <= criteria["maxTotalTardiness"] + 1e-9
|
||
and int(result.conflictCount) <= criteria["maxConflictCount"]
|
||
)
|
||
outcomes.append({
|
||
"trial": trial + 1,
|
||
**perturbation,
|
||
"totalTardiness": round(float(result.totalTardiness), 4),
|
||
"conflictCount": int(result.conflictCount),
|
||
"hardViolationCount": hard_count,
|
||
"accepted": accepted,
|
||
})
|
||
|
||
accepted_count = sum(1 for outcome in outcomes if outcome["accepted"])
|
||
tardiness = [float(outcome["totalTardiness"]) for outcome in outcomes]
|
||
return {
|
||
"method": "fixed-seed-monte-carlo",
|
||
"seed": int(seed),
|
||
"trials": sample_count,
|
||
"acceptanceCriteria": criteria,
|
||
"acceptedTrials": accepted_count,
|
||
"robustness": round(accepted_count / sample_count, 6),
|
||
"distribution": {
|
||
"tardinessP50": _percentile(tardiness, 0.50),
|
||
"tardinessP90": _percentile(tardiness, 0.90),
|
||
"tardinessP95": _percentile(tardiness, 0.95),
|
||
"tardinessMax": round(max(tardiness, default=0.0), 4),
|
||
"meanConflicts": round(
|
||
sum(outcome["conflictCount"] for outcome in outcomes) / sample_count, 4
|
||
),
|
||
# 矩阵 88 行剩余项：置信区间（经验分位法）+ 均值/标准差
|
||
"tardinessMean": round(sum(tardiness) / sample_count, 4) if tardiness else 0.0,
|
||
"tardinessStd": round(
|
||
(sum((v - sum(tardiness) / sample_count) ** 2 for v in tardiness) / sample_count) ** 0.5, 4
|
||
) if tardiness else 0.0,
|
||
"confidenceLevel": float(confidence_level),
|
||
"tardinessCI": [
|
||
_percentile(tardiness, (1.0 - float(confidence_level)) / 2.0),
|
||
_percentile(tardiness, 1.0 - (1.0 - float(confidence_level)) / 2.0),
|
||
],
|
||
},
|
||
"config": {
|
||
"distributions": _merged_distributions(distributions),
|
||
"correlation": float(correlation),
|
||
"confidenceLevel": float(confidence_level),
|
||
},
|
||
"outcomes": outcomes,
|
||
}
|