agentworkshop 0.7.33 → 0.7.37

package/.output/.AgentWorkShop/aml-python/aml_eval.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""
+AML 权威评估器(平台代码,独立于训练进程):
+  加载数据集 + artifacts/model.onnx → one-step(val/test)+ horizon 闭环滚动(test)
+  → 反归一化计算 NRMSE/RMSE/MAE → 合并写 metrics.json → 协议行输出。
+
+权威指标在这里统一计算,不采信 Agent 训练代码的自报(平台信任边界)。
+训练进程(workspace/train.py)先行独立运行;本评估器是流水线第二拍。
+
+用法: aml_eval.py --job <job.json>
+退出码: 0 成功(metrics.json 权威段就绪);1 失败(含 test 切分为空/模型不可加载)。
+"""
+import argparse
+import json
+import os
+import sys
+import traceback
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))  # amlkit 与本文件同目录
+
+JOB_DIR = Path(os.environ.get("AML_JOB_DIR", "")).resolve()
+ARTIFACTS = JOB_DIR / "artifacts"
+
+
+def emit(obj):
+    sys.stdout.write("##AML " + json.dumps(obj, ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--job", required=True)
+    args = ap.parse_args()
+    job = json.loads(Path(args.job).read_text(encoding="utf-8"))
+
+    import numpy as np
+    import amlkit
+
+    emit({"type": "stage", "stage": "evaluating"})
+    bundle = amlkit.load_bundle(job["datasetPath"])
+    manifest = bundle.manifest
+    n_all = manifest["shapes"]["x"][2]
+    n_tgt = manifest["shapes"]["y"][2]
+    h_steps = manifest["shapes"]["x"][1]
+    horizon = manifest["shapes"]["u"][1]
+
+    model_path = ARTIFACTS / "model.onnx"
+    if not model_path.is_file():
+        emit({"type": "error", "message": "训练完成但未产出 artifacts/model.onnx(须调用 amlkit.export_torch_onnx 或自行按契约导出)"})
+        return 1
+
+    import onnxruntime as ort
+
+    sess = ort.InferenceSession(str(model_path), providers=["CPUExecutionProvider"])
+    inp_name = sess.get_inputs()[0].name
+
+    def predict_next(hist_norm):
+        out = sess.run(None, {inp_name: hist_norm.astype(np.float32)[None, ...]})[0]
+        return np.asarray(out[0], dtype=np.float64)  # [n_tgt] 归一化
+
+    def denorm_targets(y_norm):
+        mean = np.array(manifest["norm"]["y"]["mean"], dtype=np.float64)
+        std = np.array(manifest["norm"]["y"]["std"], dtype=np.float64)
+        return y_norm * std + mean
+
+    def eval_one_step(split_name, max_windows=2000):
+        x = bundle.get("x", split_name)
+        y = bundle.get("y", split_name)
+        if x.shape[0] == 0:
+            return None
+        idx = np.linspace(0, x.shape[0] - 1, min(max_windows, x.shape[0])).astype(int)
+        preds = []
+        truths = []
+        for i in idx:
+            preds.append(predict_next(x[i]))
+            truths.append(y[i][0])
+        preds = np.array(preds)
+        truths = np.array(truths)
+        p_raw = denorm_targets(preds)
+        t_raw = denorm_targets(truths)
+        per_target = []
+        # NRMSE 分母 = train 切分的目标 std(manifest 归一化统计,固定口径):
+        # 用 test 切分局部 std 会在"整批 settle 后近常量"的切片上把指标放大数十倍,
+        # 且同一模型跨切分不可比。与 rollout 指标同口径。
+        train_y_std = np.array(manifest["norm"]["y"]["std"], dtype=np.float64)
+        for j in range(n_tgt):
+            rmse = float(np.sqrt(np.mean((p_raw[:, j] - t_raw[:, j]) ** 2)))
+            std = float(train_y_std[j]) or 1e-9
+            per_target.append({
+                "rmse": rmse,
+                "mae": float(np.mean(np.abs(p_raw[:, j] - t_raw[:, j]))),
+                "nrmse": rmse / std,
+            })
+        return {
+            "windows": int(idx.size),
+            "nrmse": float(np.mean([d["nrmse"] for d in per_target])),
+            "perTarget": per_target,
+        }
+
+    # 闭环滚动:预测回填 target 列;control 列取未来 U;feature 列持最后观测(persistence)
+    ctrl_positions = [manifest["allNodes"].index(cid) for cid in manifest["controlNodes"]]
+    tgt_positions = [manifest["allNodes"].index(tid) for tid in manifest["targetNodes"]]
+    feat_positions = [p for p in range(n_all) if p not in ctrl_positions and p not in tgt_positions]
+
+    def eval_rollout(max_windows=500):
+        x = bundle.get("x", "test")
+        u = bundle.get("u", "test")
+        y = bundle.get("y", "test")
+        if x.shape[0] == 0:
+            return None
+        idx = np.linspace(0, x.shape[0] - 1, min(max_windows, x.shape[0])).astype(int)
+        errs = np.zeros(n_tgt)
+        count = 0
+        for i in idx:
+            hist = x[i].copy()  # [H, n_all] 归一化
+            for k in range(horizon):
+                nxt = predict_next(hist[-h_steps:])
+                row = np.zeros(n_all, dtype=np.float64)
+                row[feat_positions] = hist[-1][feat_positions]
+                for cp, uv in zip(ctrl_positions, u[i][k]):
+                    row[cp] = uv
+                for tp, yv in zip(tgt_positions, nxt):
+                    row[tp] = yv
+                hist = np.vstack([hist, row[None, :]])
+                truth_k = y[i][k]
+                errs += (nxt - truth_k) ** 2
+                count += 1
+        # 逐 (窗口, 步) 平方误差均值 → 逐步 RMSE(与预测服务逐拍输出同口径)
+        rmse_norm = np.sqrt(errs / max(1, count))
+        std = np.array(manifest["norm"]["y"]["std"], dtype=np.float64)
+        nrmse = float(np.mean(rmse_norm / std))
+        return {"windows": int(idx.size), "horizon": horizon, "nrmse": nrmse}
+
+    ev_val = eval_one_step("val")
+    ev_test = eval_one_step("test")
+    ev_roll = eval_rollout()
+    if ev_test is None:
+        emit({"type": "error", "message": "test 切分为空(byRun 切分后无测试批次),无法评估"})
+        return 1
+
+    platform_metrics = {"platform": {
+        "oneStepVal": ev_val,
+        "oneStepTest": ev_test,
+        "rolloutTest": ev_roll,
+        "ioSpec": {
+            "historySteps": h_steps,
+            "horizonSteps": horizon,
+            "allNodes": manifest["allNodes"],
+            "controlNodes": manifest["controlNodes"],
+            "targetNodes": manifest["targetNodes"],
+            "norm": manifest["norm"],
+            "assumptions": "rollout: control 取未来 U,feature 持最后观测(persistence),target 回填预测",
+        },
+    }}
+    merged = amlkit.save_metrics(platform_metrics)
+    emit({"type": "metrics", "metrics": {"platform": platform_metrics["platform"], "agent": {
+        k: v for k, v in merged.items() if k != "platform"}}})
+    emit({"type": "done"})
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except SystemExit:
+        raise
+    except Exception as e:  # noqa: BLE001 - 评估器顶层兜底:失败必须带回信息而非裸崩
+        emit({"type": "error", "message": "评估器异常:%s" % e})
+        traceback.print_exc()
+        sys.exit(1)

package/.output/.AgentWorkShop/aml-python/amlkit.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+"""
+AML 平台种(amlkit)—— Agent 训练代码唯一允许的平台依赖。
+
+职责:
+  1. 加载 AML 数据集快照(memmap 零拷贝);
+  2. 进度协议上报(##AML NDJSON 行,stdout 唯一契约通道);
+  3. 指标落盘(metrics.json 合并写);
+  4. torch 模型 → one-step ONNX 导出助手(统一 IO 契约)。
+
+模型 IO 契约(canonical one-step,MPC 面向):
+  输入  history: float32 [batch, historySteps, nAllNodes](归一化)
+  输出  y_next : float32 [batch, nTargetNodes](归一化的"下一拍"目标)
+  多步预测 = 闭环滚动:预测输出回填 history 的 target 列,control 列取未来 U,
+  feature 列持最后观测值(persistence 假设,评估器与推理服务同口径实现)。
+"""
+import json
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+
+
+class Bundle:
+    """数据集快照句柄:x/u/y 为 float32 memmap,split 切片为连续段。"""
+
+    def __init__(self, dataset_path):
+        base = Path(dataset_path)
+        self.manifest = json.loads((base / "manifest.json").read_text(encoding="utf-8"))
+        sp = self.manifest["split"]
+        n = sp["train"] + sp["val"] + sp["test"]
+        shapes = self.manifest["shapes"]
+        arrays = base / "arrays"
+        self.x = np.memmap(arrays / "x.f32", dtype="<f4", mode="r", shape=tuple(shapes["x"]))
+        self.u = np.memmap(arrays / "u.f32", dtype="<f4", mode="r", shape=tuple(shapes["u"]))
+        self.y = np.memmap(arrays / "y.f32", dtype="<f4", mode="r", shape=tuple(shapes["y"]))
+        self.splits = {
+            "train": slice(0, sp["train"]),
+            "val": slice(sp["train"], sp["train"] + sp["val"]),
+            "test": slice(sp["train"] + sp["val"], n),
+        }
+
+    def get(self, name, split):
+        """name in {x,u,y};返回该切分的 numpy 拷贝(便于 shuffle/负采样)"""
+        arr = getattr(self, name)
+        return np.array(arr[self.splits[split]])
+
+
+def load_bundle(dataset_path):
+    return Bundle(dataset_path)
+
+
+def _safe_job_path(*parts):
+    """作业目录内收敛:resolve 规范化 + parents 前缀校验,越界即抛错。
+
+    平台工件(metrics.json / model.onnx)只允许写进作业目录 artifacts/ 下。
+    """
+    env_job_dir = os.environ.get("AML_JOB_DIR", "")
+    if not env_job_dir:
+        raise RuntimeError("AML_JOB_DIR 未设置(只能经 aml_run.py 运行)")
+    root = Path(env_job_dir).resolve()
+    target = root.joinpath(*parts).resolve()
+    if target != root and root not in target.parents:
+        raise RuntimeError("工件路径越界(已拒绝): %s" % target)
+    return str(target)
+
+
+def _artifacts_dir():
+    d = _safe_job_path("artifacts")
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def report_progress(pct, note=""):
+    """进度上报(0-100);协议行之外的 print 也会被平台收进 run.log,但只有 ##AML 行被解析。"""
+    pct = max(0, min(100, int(pct)))
+    _emit({"type": "progress", "progress": pct, "note": str(note)[:200]})
+
+
+def _emit(obj):
+    sys.stdout.write("##AML " + json.dumps(obj, ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+def save_metrics(extra):
+    """合并写 artifacts/metrics.json(agent 侧自报指标;平台会在评估阶段补权威指标)"""
+    p = Path(_artifacts_dir()) / "metrics.json"
+    cur = {}
+    if p.exists():
+        try:
+            cur = json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            cur = {}
+    cur.update(extra)
+    p.write_text(json.dumps(cur, ensure_ascii=False, indent=2), encoding="utf-8")
+    return cur
+
+
+def export_torch_onnx(model, manifest, path=None):
+    """把接受 [batch, H, nAll] → [batch, nTgt](归一化)的 torch 模型导出为契约 ONNX。
+
+    返回导出路径;失败抛异常(训练作业按失败处理,不静默)。
+    """
+    import torch  # 惰性:仅深度模型需要
+
+    h = manifest["shapes"]["x"][1]
+    n_all = manifest["shapes"]["x"][2]
+    n_tgt = manifest["shapes"]["y"][2]
+    p = _safe_job_path("artifacts", "model.onnx") if path is None else str(path)
+    model = model.cpu().eval()
+    dummy = torch.zeros(1, h, n_all, dtype=torch.float32)
+    with torch.no_grad():
+        torch.onnx.export(
+            model, dummy, p,
+            input_names=["history"], output_names=["y_next"],
+            dynamic_axes={"history": {0: "batch"}, "y_next": {0: "batch"}},
+            opset_version=17,
+        )
+    return p

package/.output/.AgentWorkShop/aml-python/requirements.txt

@@ -0,0 +1,7 @@
+numpy>=1.26,<3.0
+pandas>=2.1
+scikit-learn>=1.4
+torch>=2.2
+onnx>=1.15
+onnxscript>=0.1
+onnxruntime>=1.18

package/.output/.AgentWorkShop/aml-python/train-example.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+"""AML 参考训练实现(one-step 线性基线;e2e --real 模式与 Agent 的起点范本)。
+
+契约:
+  - 数据:amlkit.load_bundle(归一化 float32;x [N,H,nAll] / y [N,F,nTgt]);
+  - 模型:输入 [batch, H, nAll](展平)→ 输出 [batch, nTgt](下一拍目标,归一化);
+  - 产出:amlkit.export_torch_onnx(契约 ONNX)+ amlkit.save_metrics(自报指标,门禁另由平台评估器复算)。
+
+超参经作业 params 传入:lr / epochs / hidden / batch。
+"""
+import json
+import os
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+
+import amlkit
+
+
+def main():
+    job_dir = Path(os.environ["AML_JOB_DIR"]).resolve()
+    job = json.loads((job_dir / "job.json").read_text(encoding="utf-8"))
+    params = job.get("params", {})
+
+    bundle = amlkit.load_bundle(job["datasetPath"])
+    manifest = bundle.manifest
+    h_steps = manifest["shapes"]["x"][1]
+    n_all = manifest["shapes"]["x"][2]
+    n_tgt = manifest["shapes"]["y"][2]
+
+    x_train = bundle.get("x", "train")
+    y_train = bundle.get("y", "train")[:, 0, :]  # 下一拍目标(第 0 个 horizon 步)
+    x_val = bundle.get("x", "val")
+    y_val = bundle.get("y", "val")[:, 0, :]
+
+    hidden = int(params.get("hidden", 128))
+    model = nn.Sequential(
+        nn.Flatten(),
+        nn.Linear(h_steps * n_all, hidden),
+        nn.ReLU(),
+        nn.Linear(hidden, n_tgt),
+    )
+    opt = torch.optim.Adam(model.parameters(), lr=float(params.get("lr", 1e-3)))
+    loss_fn = nn.MSELoss()
+
+    xt = torch.tensor(x_train, dtype=torch.float32)
+    yt = torch.tensor(y_train, dtype=torch.float32)
+    xv = torch.tensor(x_val, dtype=torch.float32) if x_val.shape[0] else None
+    yv = torch.tensor(y_val, dtype=torch.float32) if y_val.shape[0] else None
+
+    epochs = int(params.get("epochs", 80))
+    batch = int(params.get("batch", 256))
+    n = xt.shape[0]
+    best_val = float("inf")
+    train_loss = 0.0
+    val_loss = None
+    for epoch in range(epochs):
+        model.train()
+        perm = torch.randperm(n)
+        total = 0.0
+        for i in range(0, n, batch):
+            idx = perm[i:i + batch]
+            opt.zero_grad()
+            loss = loss_fn(model(xt[idx]), yt[idx])
+            loss.backward()
+            opt.step()
+            total += float(loss) * idx.shape[0]
+        train_loss = total / max(1, n)
+        if xv is not None:
+            model.eval()
+            with torch.no_grad():
+                val_loss = float(loss_fn(model(xv), yv))
+            best_val = min(best_val, val_loss)
+        amlkit.report_progress(5 + 90 * (epoch + 1) // epochs,
+                               "epoch %d/%d train=%.5f val=%s" % (epoch + 1, epochs, train_loss, val_loss if val_loss is not None else "n/a"))
+
+    amlkit.save_metrics({"agent": {
+        "kind": "mlp_one_step_baseline",
+        "epochs": epochs,
+        "train_loss_last": train_loss,
+        "val_loss_best": None if val_loss is None else best_val,
+        "params": params,
+    }})
+
+    amlkit.export_torch_onnx(model, manifest)
+    amlkit.report_progress(99, "exported onnx")
+    print("train-example done")
+
+
+if __name__ == "__main__":
+    main()

package/.output/.AgentWorkShop/schema.json

@@ -87,6 +87,7 @@
 
     { "key": "workshop.idle_sweep_ms", "type": "number", "group": "workshop", "label": "空产线扫描(ms)", "labelKey": "settings.runtime.workshop.idleSweepMs", "description": "车间空闲产线扫描周期", "applies": "restart", "default": 30000, "min": 5000, "max": 600000 },
     { "key": "workshop.idle_grace_ms", "type": "number", "group": "workshop", "label": "空闲宽限(ms)", "labelKey": "settings.runtime.workshop.idleGraceMs", "description": "产线空闲判定的宽限时长", "applies": "restart", "default": 120000, "min": 10000, "max": 3600000 },
+    { "key": "workshop.stall_ms", "type": "number", "group": "workshop", "label": "任务停滞判定(ms)", "labelKey": "settings.runtime.workshop.stallMs", "description": "运行中任务进度停滞超过该时长先催办一次;再过同样时长仍无变化则收口:有产出保留成果(COMPLETED),完全无产出才取消。默认 5 分钟", "applies": "restart", "default": 300000, "min": 10000, "max": 7200000 },
 
     { "key": "backup.disabled", "type": "boolean", "group": "backup", "label": "禁用自动备份", "labelKey": "settings.runtime.backup.disabled", "description": "关闭运行数据自动备份", "applies": "restart", "default": false, "aliases": ["BACKUP_DISABLED"] },
     { "key": "backup.interval_hours", "type": "number", "group": "backup", "label": "备份间隔(h)", "labelKey": "settings.runtime.backup.intervalHours", "description": "自动备份间隔小时数", "applies": "restart", "default": 24, "min": 1, "max": 720, "aliases": ["BACKUP_INTERVAL_HOURS"] },
@@ -105,7 +106,7 @@
     { "key": "aml.python.indexUrl", "type": "string", "group": "aml", "label": "pip 镜像源", "labelKey": "settings.runtime.aml.indexUrl", "description": "venv 依赖安装的 PyPI 兼容镜像(空=默认源);仅 venv 供给阶段使用,训练进程不联网", "applies": "restart", "default": "", "aliases": ["AML_PYTHON_INDEX_URL"] },
     { "key": "aml.job.timeoutMs", "type": "number", "group": "aml", "label": "作业墙钟超时(ms)", "labelKey": "settings.runtime.aml.jobTimeoutMs", "description": "单个训练作业的墙钟上限,超时杀整棵进程树", "applies": "live", "default": 1800000, "min": 30000, "max": 21600000, "aliases": ["AML_JOB_TIMEOUT_MS"] },
     { "key": "aml.job.maxConcurrent", "type": "number", "group": "aml", "label": "最大并发作业", "labelKey": "settings.runtime.aml.jobMaxConcurrent", "description": "同时运行的训练子进程数上限(FIFO 队列)", "applies": "live", "default": 2, "min": 1, "max": 8, "aliases": ["AML_JOB_MAX_CONCURRENT"] },
-    { "key": "aml.job.diskQuotaMb", "type": "number", "group": "aml", "label": "AML 磁盘配额(MB)", "labelKey": "settings.runtime.aml.jobDiskQuotaMb", "description": "data/aml 目录总配额,超限拒绝新建数据集/作业并提示清扫", "applies": "live", "default": 2048, "min": 128, "max": 1048576, "aliases": ["AML_DISK_QUOTA_MB"] },
+    { "key": "aml.job.diskQuotaMb", "type": "number", "group": "aml", "label": "AML 磁盘配额(MB)", "labelKey": "settings.runtime.aml.jobDiskQuotaMb", "description": "./aml 资产根总配额(数据集/作业/模型/虚拟环境),超限拒绝新建数据集/作业并提示清扫", "applies": "live", "default": 2048, "min": 128, "max": 1048576, "aliases": ["AML_DISK_QUOTA_MB"] },
     { "key": "aml.job.stallMs", "type": "number", "group": "aml", "label": "作业停摆判定(ms)", "labelKey": "settings.runtime.aml.jobStallMs", "description": "无进度协议输出持续该时长则判定停摆并终止作业", "applies": "live", "default": 600000, "min": 60000, "max": 7200000, "aliases": ["AML_JOB_STALL_MS"] },
     { "key": "aml.dataset.maxRows", "type": "number", "group": "aml", "label": "数据集行数上限", "labelKey": "settings.runtime.aml.datasetMaxRows", "description": "单个数据集滑窗样本上限,超出建议加粗 beatMs", "applies": "live", "default": 200000, "min": 1000, "max": 5000000 },
     { "key": "aml.dataset.retentionDays", "type": "number", "group": "aml", "label": "无引用数据集保留(天)", "labelKey": "settings.runtime.aml.datasetRetentionDays", "description": "无模型/实验引用的数据集快照保留天数(GC)", "applies": "live", "default": 30, "min": 1, "max": 3650 },

package/.output/nitro.json

@@ -1,5 +1,5 @@
 {
-  "date": "2026-09-11T08:36:51.373Z",
+  "date": "2026-09-12T04:01:42.180Z",
   "preset": "node-server",
   "framework": {
     "name": "nuxt",