宜博 / 2080tiserver

Commit d2a4537da212fc7db121eea3cb43043f877e2c06

Authored by yibo
1 parent ccf5db19

删除本地 minimax-h3/ 旧代码，已打包备份 

生产已全面切到 raylight（2026-08-22起），minimax-h3 的路由代码(gateway.py/api.py等)
今天已经从服务器上删除（保留console/models/venv/outputs/logs）。本地这份是同样的代码，
删前打包备份到 ~/Documents/lemonAI/2080tiserver-backups/
minimax-h3-local-repo-backup-20260824.zip，另外服务器上实际删除的文件也单独打包
下载在同目录 minimax-h3-code-backup-20260824.tar.gz（包含console/models/venv/outputs/
logs之外的全部内容，比本地这份更全，含DISABLED-README.md等本地没有的文件）。

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Inline Side-by-side
Showing 37 changed files with 0 additions and 2404 deletions
minimax-h3/API.md deleted
View file @ccf5db1
1   -# MiniMax-H3 视频生成 API
2   -
3   -服务在服务器上：`/data/models/minimax-h3/api.py` + `api-run.sh`（本地是副本）。
4   -
5   -## 为什么是异步任务式，不是同步接口
6   -
7   -| 事实 | 后果 |
8   -|---|---|
9   -| 模型加载 240 s（首次，fp32 权重从机械盘读；page cache 命中 20 s） | 不能每请求加载 |
10   -| 单条视频 Turbo 4 步约 **7 分钟**，50 步约 **90 分钟** | 同步 HTTP 必然超时 |
11   -| 一条生成占 **12.3 G 显存 + 约 32 G 内存** | 22 G 卡上同时只能跑一条 |
12   -
13   -所以接口是：**提交任务拿 id → 轮询状态 → 下载文件**。并发提交会排队，不会 OOM。
14   -
15   -## 启动
16   -
17   -```bash
18   -cd /data/models/minimax-h3
19   -./api-run.sh 1 8010 # GPU_ID=1, PORT=8010
20   -# 后台跑：
21   -setsid nohup ./api-run.sh 1 8010 > logs/api.log 2>&1 < /dev/null &
22   -```
23   -
24   -⚠️ **显存前提**：这条服务常驻约 12.3 G。llm38 跑 256K 上下文时占 57.3 G（四卡各约 14.3 G），
25   -两者在同一张卡上放不下。跑视频前先 `docker stop llm38`（这是测试机，见工作区 `CLAUDE.md`），
26   -或把 H3 放到 llm38 没用满的卡上并自行核算。恢复用 `qwen38-deploy/RESTORE-GPU.md`。
27   -
28   -## 接口
29   -
30   -### `GET /health`
31   -```json
32   -{"status":"ok","model":"ready","gpu":"1","queued":0,"running":0}
33   -```
34   -`status` 在模型加载完成前是 `loading`。**别在 `loading` 时提交任务**——会排队但看不出进度。
35   -
36   -### `POST /v1/videos` → `202`
37   -
38   -```bash
39   -curl -X POST http://192.168.110.67:8010/v1/videos \
40   - -H "Content-Type: application/json" \
41   - -d '{
42   - "prompt": "一只橘猫趴在洒满阳光的窗台上，慢慢眨眼，尾巴轻轻摆动",
43   - "width": 832, "height": 480, "frames": 124,
44   - "steps": 4, "turbo": true, "seed": 7
45   - }'
46   -```
47   -
48   -```json
49   -{"id":"ca0f2f095ddd","status":"queued","queue_position":1,
50   - "eta_seconds":428,"poll":"/v1/videos/ca0f2f095ddd"}
51   -```
52   -
53   -| 字段 | 默认 | 范围 | 说明 |
54   -|---|---|---|---|
55   -| `prompt` | 必填 | 1–2000 字符 | 中英文都行；含人物台词时用英文引号包住那句 |
56   -| `width` | 832 | 64–**832** | |
57   -| `height` | 480 | 64–**480** | |
58   -| `frames` | 124 | 8–**124** | 24 fps，124 帧 ≈ 5.17 秒 |
59   -| `steps` | 4 | 1–50 | turbo 时应 ≤8 |
60   -| `turbo` | true | | true=4 步蒸馏 LoRA；false=全质量多步 |
61   -| `seed` | 0 | 0–2³¹−1 | 同 seed 同参数结果可复现 |
62   -| `flow_shift` | 自动 | | 不传则 turbo=6.0 / 非 turbo=12.0 |
63   -
64   -**上界不是随手写的**：832×480×124f 是实测跑通的最高档（峰值 12.2 G）。再大在 22 G 卡上 OOM，
65   -所以在入口就挡住，而不是让它跑 7 分钟后崩掉。
66   -
67   -错误码：
68   -- `422` 参数越界或缺失（pydantic 校验）
69   -- `400` `turbo=true` 且 `steps>8`（Turbo LoRA 是 4 步蒸馏的，多步没意义）
70   -
71   -### `GET /v1/videos/{id}`
72   -
73   -```json
74   -{"id":"ca0f2f095ddd","status":"running","step":0,"total_steps":4,
75   - "elapsed_seconds":132, ...}
76   -```
77   -
78   -`status`: `queued` → `running` → `done` / `failed`。
79   -完成后多出 `file`、`size_bytes`、`peak_vram_gb`、`download`。
80   -
81   -### `GET /v1/videos/{id}/file`
82   -返回 mp4。任务未完成时返回 `409`。
83   -
84   -### `GET /v1/videos?limit=50`
85   -列出最近任务。
86   -
87   -## 完整调用示例（Python）
88   -
89   -```python
90   -import time, requests
91   -API = "http://192.168.110.67:8010"
92   -
93   -r = requests.post(f"{API}/v1/videos", json={
94   - "prompt": "清晨的中式庭院，一位女子坐在长廊上喝茶，阳光透过竹叶",
95   - "steps": 4, "turbo": True, "seed": 42,
96   -}, timeout=30)
97   -r.raise_for_status()
98   -jid = r.json()["id"]
99   -print("任务", jid, "预计", r.json()["eta_seconds"], "秒")
100   -
101   -while True:
102   - j = requests.get(f"{API}/v1/videos/{jid}", timeout=30).json()
103   - if j["status"] in ("done", "failed"):
104   - break
105   - print(j["status"], j.get("elapsed_seconds", 0), "s")
106   - time.sleep(20)
107   -
108   -if j["status"] == "failed":
109   - raise SystemExit("失败: " + j["error"])
110   -
111   -open(f"{jid}.mp4", "wb").write(
112   - requests.get(f"{API}/v1/videos/{jid}/file", timeout=300).content)
113   -print("已保存", j["size_bytes"], "字节，峰值显存", j["peak_vram_gb"], "G")
114   -```
115   -
116   -## 服务端会自己验产物
117   -
118   -**写出文件不等于成功**——fp16 时代踩过：全黑视频照样写出 24 KB 的 mp4 并返回退出码 0。
119   -所以 worker 在写文件前会检查：
120   -
121   -- 抽 8 帧算像素 `std`，`< 1.0` 判为纯色 → 任务标 `failed`
122   -- 音频张量含非有限值 → 任务标 `failed`
123   -
124   -这两条不通过时**不会**给你一个"成功但没用"的文件。
125   -
126   -## 任务记录会落盘（2026-08-20 起）
127   -
128   -`JOBS` 曾经只在内存里，进程重启（比如 `h3-console` 弹性调度器切 fl2va/ref2va 分区时的
129   -kill+restart）就把这张表清空——视频文件在 `outputs/` 没事，但 id→文件路径这层映射没了，
130   -`GET /v1/videos/{id}`、下载都会 404。现在改成每次状态变化都往 sqlite 写一份：
131   -
132   -- 落盘文件是 **`jobs_gpu{GPU_ID}.sqlite3`**（跟 `api.py` 同目录），四张卡各一份，不共享——
133   - 一个进程只会在同一张 GPU 上起来，per-GPU 分文件天然不会有另一个进程来抢，不用处理
134   - 跨进程写锁竞争。
135   -- 进程启动时会把这个文件读回内存，日志能看到 `[api] 从磁盘恢复了 N 条历史任务记录`。
136   -- **in-flight（`queued`/`running`）的记录没法真正恢复**——GPU 上下文和排队队列本来就不落盘，
137   - 重启后没有任何东西能"接着跑"。这类记录读回来会被**改判为 `failed`**，`error` 字段写明
138   - "进程重启导致这条任务的执行状态丢失"。只有 `done`/`failed` 这两个终态是完整保留的。
139   -- 只影响**直接调用 `api.py`/`gateway.py` 的场景**——如果你是通过 `h3-console`（端口 8080）
140   - 提交的任务，即使碰到上面这种真正没法恢复的 in-flight 丢失，console 自己也存了一份
141   - 影子记录，历史和已完成任务的文件不受影响。
142   -
143   -## 已知限制
144   -
145   -- **无鉴权**，和这台机器上其他服务一致。放到公网前必须加。
146   -- **单 worker 串行**。要并发就每张空闲卡起一个实例（不同 PORT），自己在上层做负载。
147   -- `turbo=false` 时会 `clear_lora()`，任务结束后再挂回来。**混合提交 turbo/非 turbo 时
148   - 每次切换都有 LoRA 装卸开销**，批量跑同一种模式更快。
minimax-h3/README.md deleted
View file @ccf5db1
1   -# MiniMax-H3 视频生成部署（4 × RTX 2080 Ti）
2   -
3   -在 `192.168.110.67` 上用 DiffSynth-Studio 跑 MiniMax-H3 FL2VA（文生视频 + 原生立体声）。
4   -
5   -> **状态（2026-08-18）**：环境已装好并通过全部兼容性实测；模型下载中（33 GB / 6 MB/s）；
6   -> 尚未完成首次出片。验收结果见本文末「验收记录」，未填即表示还没跑通。
7   -
8   -服务器侧根目录 **`/data/models/minimax-h3/`**，本目录是其脚本副本 + 决策记录。
9   -
10   ----
11   -
12   -## 一、为什么不能照抄官方示例
13   -
14   -官方 [MiniMax-H3.md](https://github.com/modelscope/DiffSynth-Studio/blob/main/docs/en/Model_Details/MiniMax-H3.md)
15   -的示例在这台机器上**跑不起来**，有三处必须改。
16   -
17   -### 1. `torch.bfloat16` → `torch.float16`（致命）
18   -
19   -官方示例的 `vram_config` 与 `torch_dtype` 全用 bf16。sm_75 上实测：
20   -
21   -```
22   -[ERR] SDPA bfloat16 EFFICIENT_ATTENTION → RuntimeError: No available kernel
23   -[ERR] SDPA bfloat16 FLASH_ATTENTION → RuntimeError: No available kernel
24   -[OK ] SDPA bfloat16 MATH → 只剩朴素实现
25   -[OK ] SDPA float16 EFFICIENT_ATTENTION → 可用
26   -```
27   -
28   -bf16 不是"慢一点"，是**没有任何高效 attention kernel**。PyTorch 会静默掉到 MATH 后端，
29   -在 H3 的 ~14,100 token 序列上要物化 `14100 × 14100 × 56` 的注意力矩阵，必然 OOM。
30   -
31   -FP16 路径实测（真实 H3 形状 S=14100 H=56 D=128）：
32   -
33   -```
34   -SDPA EFFICIENT fp16 → OK, 0.21s
35   -fp16 GEMM 有效算力 → 54.3 TFLOPS （2080Ti fp16 张量核满血）
36   -fp16 深链数值稳定性 → finite
37   -```
38   -
39   -**注意**：`llm-setup.md` 说 "Turing…不支持 bf16，跑 GGUF 走 llama.cpp 是唯一实际路径" ——
40   -前半句对，后半句对扩散模型不成立。PyTorch + bitsandbytes NF4 在 sm_75 上是通的，见下。
41   -
42   -### 2. `vram_limit` 取错了下标（会 OOM）
43   -
44   -```python
45   -vram_limit=torch.cuda.mem_get_info("cuda")[1] / (1024 ** 3) - 2 # 官方：[1] = 总显存
46   -vram_limit=torch.cuda.mem_get_info("cuda")[0] / (1024 ** 3) - 2 # 本机：[0] = 空闲显存
47   -```
48   -
49   -`mem_get_info()` 返回 `(free, total)`。这台机器四张卡都有常驻服务（llm38 / embedding / SD / whisper），
50   -按总显存 21.5G 要预算，实际只有 12–15G 可用，必 OOM。
51   -
52   -### 3. `offload_device="disk"` 不能用
53   -
54   -`model_inference_low_vram/` 那组示例把权重 offload 到磁盘。本机 `/data` 是
55   -**7200rpm 机械盘**（HGST HUS726020ALA610，实测顺序读 184 MB/s）。
56   -NF4 DiT 16 GB，每个去噪步都要过一遍，光 I/O 就 **87 秒/步**。
57   -
58   -改用 CPU 内存 offload：物理内存 128 GB，可用 123 GB，单 worker 常驻约 32 GB，宽裕。
59   -
60   ----
61   -
62   -## 二、attention backend：只用 PyTorch SDPA
63   -
64   -| Backend | sm_75 | 处置 |
65   -|---|---|---|
66   -| FlashAttention 2 / 3 / 4 | ❌ 仅 sm_80–sm_121 | **不装** |
67   -| SageAttention | ❌ 需 sm_80+ | **不装** |
68   -| xFormers | ⚠️ 系统已装 0.0.33，fp16 可用 | 不用（见下） |
69   -| PyTorch SDPA | ✅ EFFICIENT（cutlass）后端 | **采用** |
70   -
71   -DiffSynth 的 `diffsynth/core/attention/attention.py` 里有自动优先级，
72   -**xformers 排在 torch 前面会被自动选中**。实测：
73   -
74   -```
75   -不设环境变量 → selected = xformers
76   -DIFFSYNTH_ATTENTION_IMPLEMENTATION=torch → selected = torch
77   -```
78   -
79   -两者 fp16 下都能跑，但锁死 `torch` 保证可复现。`run.sh` 已导出该变量。
80   -
81   -H3 的 DiT 只用最干净的 attention 调用（无 mask / 无 causal / 无 sliding window，
82   -见 `minimax_h3_dit.py:79`），不会踩 flex_attention 需要 torch.compile 的坑。
83   -
84   ----
85   -
86   -## 三、NF4 量化在 Turing 上成立
87   -
88   -NF4 走 bitsandbytes 的 `Linear4bit`。bitsandbytes 的 4-bit 最低要求正好是
89   -**sm_75**，2080 Ti 卡在支持线上；其 CMakeLists 的架构列表明确含 `75`。
90   -
91   -**服务器上原有的 bitsandbytes 0.45.1 是坏的**（在 `~/.local`）：
92   -
93   -```
94   -AttributeError: 'NoneType' object has no attribute 'cquantize_blockwise_fp16_nf4'
95   -```
96   -
97   -CUDA 动态库没加载上。已在 venv 内装 0.50.1 覆盖。实测通过：
98   -
99   -```
100   -[OK ] NF4 fp16 forward out=(1024,14336) finite=True rel_err=0.0913
101   -[OK ] NF4 prequantized reload match=True ← 这正是加载 .safetensors 时走的分支
102   -```
103   -
104   ----
105   -
106   -## 四、多卡：H3 不支持模型并行
107   -
108   -DiffSynth 的序列并行（`diffsynth/utils/xfuser/`）**只被 `wan_video.py` 和
109   -`mova_audio_video.py` 引用**；`minimax_h3_audio_video.py` 里零引用 xfuser / torch.distributed。
110   -
111   -叠加硬件事实（`llm-setup.md` 第 2.2 节）：四卡无 P2P（`topo -p2p r` 全 CNS），
112   -GPU0/1 与 GPU2/3 跨 NUMA。
113   -
114   -> **结论：不要试图把 4×22G 当成一张 88G 卡。**
115   -> 多卡只能做**独立 worker 并发**（每卡一个进程），不能拆单个任务。
116   -
117   -并发数上限由**内存**而非显存决定：每 worker 常驻约 32 GB（DiT NF4 16 GB +
118   -文本编码器 NF4 14.3 GB + VAE 1.8 GB），128 GB 内存 → **最多 2–3 个 worker**。
119   -
120   ----
121   -
122   -## 五、模型与算力
123   -
124   -DiT 是**稠密 30.9B**（50 层 / hidden 5376 / 56 heads × 128 / ffn 14336，无 MoE）。
125   -480×832×124 帧 → 视频 latent 35×30×52，patch(1,2,2) → **≈14,100 token**。
126   -每步约 830 TFLOP。
127   -
128   -| 文件 | 大小 |
129   -|---|---|
130   -| `minimax-h3-fl2va-nf4.safetensors` | 15.98 GB |
131   -| `minimax-h3-text-encoder-nf4.safetensors`（Qwen3-VL 32B） | 14.27 GB |
132   -| `video_vae_nf4.safetensors` | 1.50 GB |
133   -| `audio_vae_nf4.safetensors` | 0.26 GB |
134   -| `minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors`（LoRA） | 1.29 GB |
135   -| **合计** | **33.3 GB** |
136   -
137   -Turbo LoRA 能叠在 NF4 上——`core/vram/layers.py:445` 的
138   -`AutoWrappedQuantizedModule(AutoTorchModule, LoRAHotLoadMixin)` 在量化输出**之后**做
139   -`out += x@A@B`，不需要反量化基座权重。这是最大的性能杠杆：
140   -
141   -| 方案 | 步数 | 单条 5 秒视频（估算） |
142   -|---|---|---|
143   -| NF4 全量 | 50 | 20–35 分钟 |
144   -| NF4 + Turbo LoRA | 4 | **2–4 分钟** |
145   -
146   -> 文件名里的 `bf16` 只是 LoRA 权重的存储精度，加载时会按 `pipe.torch_dtype` 转成 fp16，不影响。
147   -
148   ----
149   -
150   -## 六、安装了什么（以及没动什么）
151   -
152   -**全部落在 `/data/models/minimax-h3/`。系统级零改动。**
153   -
154   -- 没装 CUDA、没动驱动（570.153.02 保持）、没碰 `/usr`、没改 `~/.local`
155   -- 系统 `nvcc` 是 11.5，很老，但**推理用不到**——pip 的 torch wheel 自带 CUDA runtime
156   -- venv 用 `--system-site-packages` 复用已验证的 `torch 2.9.0+cu128`
157   - （其 `arch_list` 含 `sm_75`），省 3 GB 下载
158   -- **只装了 bitsandbytes 0.50.1 + diffsynth（`-e . --no-deps`）**，其余依赖系统已齐
159   -- **不要设 `PYTHONNOUSERSITE=1`**：`torch` / `transformers` / `av` 都住在 `~/.local`，
160   - 屏蔽掉会连 torch 一起丢。venv 的 site-packages 本来就排在 `~/.local` 前面，
161   - 我们的 bnb 0.50.1 自然覆盖坏掉的 0.45.1
162   -
163   -### 容器变更（用户已授权，可逆）
164   -
165   -| 容器 | 动作 | 恢复 |
166   -|---|---|---|
167   -| `llm`（旧 llama.cpp，unhealthy 5 天，已被 llm38 取代） | **已停** | `docker start llm` |
168   -| `whisper` | 停后**已恢复** | — |
169   -| `llm38`（Qwen3.8-27B，经 FRP 对外供 `qwen.wudaima.com`） | **全程未碰** | — |
170   -
171   -启动参数完整备份在 `/data/models/minimax-h3/backup/`（`llm.inspect.json` /
172   -`whisper.inspect.json` / `restore-notes.txt`）。两者都是 `restart=unless-stopped`，
173   -手动 stop 不会被自动拉起。
174   -
175   ----
176   -
177   -## 七、目录与路径
178   -
179   -| 用途 | 路径 |
180   -|---|---|
181   -| 根目录 | `/data/models/minimax-h3/` |
182   -| venv | `/data/models/minimax-h3/venv/` |
183   -| DiffSynth 源码 | `/data/models/minimax-h3/DiffSynth-Studio/`（HEAD `0361581`） |
184   -| **模型权重** | `/data/models/minimax-h3/models/` |
185   -| **日志** | `/data/models/minimax-h3/logs/` |
186   -| **输出视频** | `/data/models/minimax-h3/outputs/` |
187   -| 脚本 | `/data/models/minimax-h3/scripts/` |
188   -| 容器备份 | `/data/models/minimax-h3/backup/` |
189   -
190   -## 八、启动命令
191   -
192   -```bash
193   -cd /data/models/minimax-h3
194   -
195   -./run.sh 1 # GPU1，Turbo 4-step，480x832x124f（默认）
196   -./run.sh 1 --no-turbo --steps 50 # 全质量 50 步
197   -./run.sh 2 --prompt "..." --seed 7
198   -./run.sh 1 --fp32-accum # 若出现 NaN/伪影：关 fp16 累加（约慢一倍）
199   -```
200   -
201   -多 worker（每卡一个独立进程，**内存上限 2–3 个**）：
202   -
203   -```bash
204   -./run.sh 0 --prompt "..." & # GPU0（NUMA0）
205   -./run.sh 1 --prompt "..." & # GPU1（NUMA0）
206   -./run.sh 2 --prompt "..." & # GPU2（NUMA1）
207   -./run.sh 3 --prompt "..." & # GPU3（NUMA1）
208   -```
209   -
210   -`run.sh` 会按 GPU 编号选 NUMA 节点绑核（GPU0/1→node0，GPU2/3→node1），
211   -但服务器上**没装 `numactl`**，目前这段会自动跳过。装了会更快。
212   -
213   -## 九、脚本
214   -
215   -| 脚本 | 作用 |
216   -|---|---|
217   -| `run.sh` | 启动器：设环境变量 + 选 GPU + 落日志 |
218   -| `t2va.py` | 推理主体（fp16 / SDPA / CPU offload） |
219   -| `download.py` | 用 DiffSynth 自己的 `ModelConfig` 下载，保证落盘布局与加载时解析一致 |
220   -| `verify.py` | 逐文件比对字节数 vs ModelScope + 解析 safetensors 头 |
221   -| `probe-turing-caps.py` | sm_75 能力探测（bf16/fp16 × 各 attention 后端） |
222   -| `probe-h3-shapes.py` | 真实 H3 形状下的 attention + GEMM 吞吐 |
223   -| `probe-nf4-fp16.py` | NF4 fp16 前向 + prequantized 重载 |
224   -| `probe-attention-backend.py` | 验证 DiffSynth 实际选中的后端 |
225   -
226   -换硬件或升级 torch/bnb 后，**先跑 probe-* 四个再动别的**。
227   -
228   -## 十、下载注意
229   -
230   -出口带宽 **5.9 MB/s 封顶**（`llm-setup.md` 第三节），33 GB 约 **95 分钟**。
231   -
232   -- 必须 `setsid`，**只用 `nohup` 不够**——SSH 通道关闭时进程仍会被带走（本次踩过）
233   -- **不要开两个下载进程**：并行不会更快（出口带宽是瓶颈），只会争抢同一个
234   - `._____temp` 分片互相破坏（本次踩过，事后用 `verify.py` 校验）
235   -- ModelScope 可达；HuggingFace / ghcr 不通
236   -
237   -## 十一、失败时的降级顺序
238   -
239   -1. fp16 出 NaN → `--fp32-accum`（关 fp16 累加，约慢一倍）
240   -2. 仍不行 → 把 norm / adaln 提到 fp32
241   -3. 显存不够 → 调小 `--vram-reserve`，或换 pruned 权重
242   - （`minimax-h3-fl2va-pruned-nf4.safetensors`，9.76 GB / 18.7B，但 **Turbo LoRA 与之不兼容**，层数不同）
243   -
244   ----
245   -
246   -## ★ 2026-08-18 实测推翻本文档第一节：fp16 是故障本身，不是修复 ★
247   -
248   -本 README 第一节写「`torch.bfloat16` → `torch.float16`（致命）」，把改用 fp16 当作**必须的修正**。
249   -**实测结论相反：改成 fp16 才是这条线出不了片的根本原因。**
250   -
251   -### 对照实验（唯一变量是 dtype）
252   -
253   -同分辨率 448×256×28f、同 prompt、同权重、同 Turbo LoRA，只改 `torch_dtype`：
254   -
255   -| | fp32 | fp16 |
256   -|---|---|---|
257   -| 视频像素 | mean=140.9 **std=50.6** max=255 | mean=0 **std=0** max=0 |
258   -| 音频 | **finite=True** | finite=False |
259   -| 生成耗时 | 62s | 40s |
260   -| 峰值显存 | 16.3G | 16.3G |
261   -| 结果 | **正常出片 ✅** | **124 帧纯黑 ❌** |
262   -
263   -模型、权重、管线、Turbo LoRA、VAE 全部正常——**唯一的问题是 fp16 的动态范围装不下这个模型**。
264   -
265   -### 为什么之前的 probe 没测出来
266   -
267   -`probe-nf4-fp16.py` / `probe-h3-shapes.py` 用的是**合成小张量**，测的是「NF4 fp16 前向不报错、数值有限」。
268   -这类测试测不出真实模型在 **50 层残差累积**后的量级。实测 `dit.blocks.0` 输入 absmax 89 → 输出 38176，
269   -逼近 fp16 上限 65504；再往后必然溢出。**「单层不溢出」推不出「50 层不溢出」。**
270   -
271   -### 溢出机理：`.to(x.dtype)` 这个模式在库里反复出现
272   -
273   -```python
274   -# minimax_h3_dit.py:61-67
275   -def _modulate_scale_shift(x, shift, scale, indices):
276   - return (x * (1.0 + scale.index_select(0, indices)) + shift.index_select(0, indices)).to(x.dtype)
277   -def _modulate_gate(x, gate, other, indices):
278   - return (x + gate.index_select(0, indices) * other).to(x.dtype)
279   -```
280   -
281   -库作者自己的注释说「index_select on the AdaLN params can promote the expression」——
282   -表达式确实被提升到 fp32 算，但**结果又降回 fp16**，恰好丢掉了提升带来的动态范围。
283   -DiT 有 50 个 block × 每个 2 次 = **100 个这样的降回点**。`condition_proj` 那里是同一个病灶的另一个实例
284   -（fp32 真值 absmax 79554 > 65504）。
285   -
286   -### 逐点修 fp16 是行不通的（四条弯路，都实测过）
287   -
288   -1. `--fp32-accum` —— 开关生效（`fp16_reduced_accum` True→False）但**输出逐字节相同**。
289   - 它管的是 reduced-precision reduction，与这里的溢出无关。README 第十一节把它列为降级第一档，**对此故障不对症**。
290   -2. 替换 `AutoWrappedLinear.forward` —— 会绕过 `preparing()`/onload 换入机制。
291   -3. 只替换 `linear_forward`、最后仍 `.to(fp16)` —— **无效**：fp32 算得对，溢出发生在那次类型转换上。
292   - （自检若只查转换前的张量，会永远显示"正常"——踩过。）
293   -4. 钳位到 65504 再降回 —— **反而更糟**：`blocks.0` 是 `h = x + attn(norm1(x))`，
294   - x 恰好等于 fp16 最大可表示值时再加任何正数立刻变 inf（实测 3.45% 非有限）。钳位不留余量等于自造故障。
295   -
296   -每修一处，NaN 就移到下一处——因为问题是全局的动态范围，不是某几个点。
297   -
298   -### 另一个方法教训：诊断配置必须与故障配置逐项一致
299   -
300   -前几轮诊断用的是中文 prompt「一只橘猫…」，而实际失败的是 `t2va.py` 的**英文默认 prompt**。
301   -不同文本 → 不同嵌入量级 → 溢出点不同。定位出的路径在真实故障里根本不触发，白跑了几轮。
302   -
303   -### 退出码不可信
304   -
305   -原 `t2va.py` 只检查 `audio` 是否非有限，**从不检查 video**，全黑视频照样打印 `[done]` 并返回 **0**。
306   -已补上 video 的有限性 + 纯色检查（std < 1.0 判失败），坏产物以**退出码 3** 退出。
307   -
308   ----
309   -
310   -## 冒烟测试前置检查（2026-08-18 17:59，llm38 切 256K 之后）
311   -
312   -环境侧已全部验证，剩下的唯一变量是权重本身。
313   -
314   -| 检查项 | 结果 |
315   -|---|---|
316   -| attention 后端 @ 真实 DiT 形状 (1,56,14100,128) fp16 | ✅ SDPA 选中，`finite=True`（xformers 可用但被 env 钉死为 torch） |
317   -| bitsandbytes 版本 | ✅ **0.50.1**（成功压住 `~/.local` 里坏的 0.45.1） |
318   -| NF4 fp16 前向 + 预量化重载 | ✅ `rel_err=0.0913`，reload `match=True` |
319   -| 已落盘 3 文件字节 + safetensors 头 | ✅ video_vae / audio_vae / turbo LoRA 全对 |
320   -
321   -### ⚠️ `t2va.py:47` 的地板值现在是个雷
322   -
323   -```python
324   -vram_limit = max(6.0, free_gb - args.vram_reserve)
325   -```
326   -
327   -这个 `6.0` 地板是在**每卡还有 12–15 GB 空闲**时写的。2026-08-18 llm38 上下文提到 256K 后（KV 从 8 GiB 涨到 32 GiB），空闲显存腰斩，地板值开始**反过来盖掉安全余量**：
328   -
329   -| | 空闲 | 实得 `vram_limit` | 余量 | |
330   -|---|---|---|---|---|
331   -| GPU0 | 6.58G | 6.00G | +0.58G | 勉强，无缓冲 |
332   -| **GPU1** | **7.51G** | 6.00G | **+1.51G** | 勉强，最宽裕 → **冒烟测试用这张** |
333   -| GPU2 | 5.25G | 6.00G | **−0.75G** | ❌ **必 OOM**：地板要的比卡上有的还多 |
334   -| GPU3 | 6.59G | 6.00G | +0.59G | 勉强，无缓冲 |
335   -
336   -`--vram-reserve` **调不动这个地板**——`max()` 在外层。
337   -
338   -### ✅ 正解：跑 H3 之前先停 llm38
339   -
340   -用户 2026-08-18 明确：**这是测试机，不是生产环境，停 llm38 让路是预期做法**（见工作区 `CLAUDE.md`）。所以上面整张表都不必绕，串行跑就行：
341   -
342   -```bash
343   -docker stop llm38 # 让出约 57 GB
344   -./run.sh 1 ... # 四卡各约 21 GB 空闲 → vram_limit 约 19 G，地板值失效
345   -docker start llm38 # 跑完起回来，约 15 秒
346   -```
347   -
348   -这样测出来的还是**干净数字**（无抢占），比在争抢状态下测更有参考价值。
349   -
350   -**地板值仍值得修**（低优先级）：`max(6.0, ...)` 在放不下时会去要一个不存在的额度而不是报错。真要多负载共存时才会再咬人；目前串行跑绕开了。
351   -
352   -### 脚本漂移（已修）
353   -
354   -本 README 第九节列了 8 个脚本、并说「换硬件后先跑 probe-* 四个」，但**服务器上原本只有 3 个**（`download.py` / `t2va.py` / `verify.py`），4 个 probe 从没上过服务器，那条指示在服务器上无法执行。已补齐到 `/data/models/minimax-h3/scripts/`。
355   -
356   -> 另注：`run.sh` 在服务器上位于 `/data/models/minimax-h3/run.sh`（顶层），本地副本放在 `scripts/` 下，两边路径不一致。README 第八节的 `cd /data/models/minimax-h3 && ./run.sh 1` 以服务器为准。
357   -
358   ----
359   -
360   -## 验收记录
361   -
362   -**2026-08-18 22:31 首次成功出片。** 配置：`dtype=fp32` · Turbo 4-step · 832×480×124f · GPU1 · `vram_limit=7.3G`
363   -
364   -### 产物验证（ffprobe + 逐像素 + 音频样本）
365   -
366   -| 项目 | 实测 |
367   -|---|---|
368   -| 文件 | `outputs/t2va_20260818-223136.mp4` **7,859,869 字节 (7.5 MB)** |
369   -| 视频流 | h264 **832×480** · 24 fps · **124 帧** · 5.167 s |
370   -| 实际解码帧数 | **124**（与声明一致，无截断） |
371   -| 像素 | mean 69.33 · **std 57.85** · 全域 0–255 |
372   -| **帧间平均差异** | **16.99** → 真实动态视频，非静止图 |
373   -| 音频流 | aac · **32000 Hz · 双声道** · 163 帧 · 5.175 s |
374   -| 音频电平 | mean **−34.0 dB** · max **−14.9 dB**（静音应为 −91 dB） |
375   -| 音频样本 | absmax 0.1799 · rms 0.0199 · **非零样本 100%** |
376   -
377   -> 验证方法上的教训：`ffmpeg -af volumedetect -f null -` 的输出容易被 grep 漏掉，
378   -> 误报成"无音频流"。**直接用 PyAV 解码样本算 rms** 更可靠。
379   -
380   -### 性能与显存（fp32，全部实测）
381   -
382   -| 分辨率 | 步数 | 生成耗时 | 每步 | 峰值显存 | 结果 |
383   -|---|---|---|---|---|---|
384   -| 448×256×28f | 4 (turbo) | 62 s | 15.5 s | 16.3 G | ✅ std 50.6 |
385   -| 640×384×61f | 4 (turbo) | 171 s | 42.8 s | 11.4 G | ✅ std 51.7 |
386   -| **832×480×124f** | **4 (turbo)** | **553 s** | **107 s** | **12.2 G** | ✅ std 66.8 |
387   -| 832×480×124f | 4 (turbo)，真实 prompt | 556 s | 138.9 s | 12.3 G | ✅ **本次验收** |
388   -
389   -> 同配置两次每步耗时 107 s vs 138.9 s，差异来自并发：验收那次有另一条 50 步任务
390   -> 在别的卡上同时跑，抢 CPU 与内存带宽（权重 offload 在 CPU 侧）。**单任务跑约 107 s/步。**
391   -
392   -**加载耗时**：首次从机械盘读 fp32 权重 **238 s**；page cache 命中后 fp16 只要 **12–15 s**。
393   -反复调试时第二次之后极快，不必每次预留 6 分钟。
394   -
395   -### 与 fp16 的对照（唯一变量是 dtype）
396   -
397   -| | fp32 | fp16 |
398   -|---|---|---|
399   -| 每步耗时 | 107 s | 36.8 s（快 2.9×） |
400   -| 峰值显存 | 12.2 G | 15.9 G |
401   -| **产物** | **正常出片** | **124 帧纯黑 / 音频 NaN** |
402   -
403   -fp16 更快更省显存，但**根本出不了片**。这不是速度取舍，是能用与不能用的区别。详见上一节。
404   -
405   -### 启动命令（已验证）
406   -
407   -```bash
408   -cd /data/models/minimax-h3
409   -echo "你的提示词" > prompt.txt # 从文件读，避开多层 shell 引号
410   -./realrun.sh turbo # Turbo 4-step，全分辨率，约 10 分钟
411   -./realrun.sh full50 # 50 步全质量，约 90 分钟
412   -```
413   -
414   -直接调用也可（`--vram-reserve` 现按 dtype 自适应，fp32 默认 14）：
415   -
416   -```bash
417   -./run.sh 1 --prompt "$(cat prompt.txt)" --seed 42
418   -```
419   -
420   -> **prompt 必须从文件读。** 直接在 `ssh … bash -c "…"` 里传含引号的 prompt 会被
421   -> 三层 shell 吃掉，传进去是空串，报错是
422   -> `RuntimeError: cannot reshape tensor of 0 elements into shape [1, 0, -1, 128]`
423   -> ——看着像 transformers 的 bug，实际是**输入为空**。0 元素张量崩在 reshape 是这个的典型指纹。
424   -
425   -### 50 步全质量（2026-08-18 23:51 完成，已验收）
426   -
427   -同 prompt、同 seed，`--no-turbo --steps 50`：
428   -
429   -| 项目 | 实测 |
430   -|---|---|
431   -| 文件 | `outputs/t2va_20260818-235141.mp4` **6,726,194 字节 (6.4 MB)** |
432   -| 生成耗时 | **5364 s（89 分钟）· 107.3 s/步** |
433   -| 峰值显存 | **9.1 G**（比 turbo 的 12.3 G 更低——无 LoRA 层） |
434   -| 视频 | h264 832×480 · 24 fps · **124 帧** · 5.167 s |
435   -| 像素 | mean 71.63 · **std 59.68** · 全域 0–255 |
436   -| 帧间平均差异 | **7.366** |
437   -| 音频 | mean **−27.2 dB** · max **−9.2 dB** · 331776 样本 |
438   -
439   -**与 Turbo 4-step 的对比**：
440   -
441   -| | Turbo 4-step | 50 步全质量 |
442   -|---|---|---|
443   -| 耗时 | 556 s | **5364 s（9.6×）** |
444   -| 峰值显存 | 12.3 G | 9.1 G |
445   -| 像素 std | 57.85 | 59.68 |
446   -| 帧间差异 | **16.99** | **7.366** |
447   -| 音频电平 | −34.0 / −14.9 dB | **−27.2 / −9.2 dB** |
448   -
449   -50 步的帧间差异明显更小、音频更响。**帧间差异小不等于质量差**——更多去噪步数带来更平滑的时序连贯性；
450   -Turbo 的 16.99 里有一部分是 4 步蒸馏残留的帧间抖动。哪个观感更好需要人眼判断，
451   -这两条客观指标只能说明**两者都是真实动态视频，且 50 步的时序更稳**。
452   -
453   -**每步耗时 107.3 s 与单任务 turbo 的 107 s 完全一致**——证明这个数字是这台机器上
454   -fp32 全分辨率的稳定值，不随步数或 LoRA 变化。
455   -
456   -
457   -
minimax-h3/api-run.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# 启动 MiniMax-H3 视频 API。用法: ./api-run.sh [GPU_ID] [PORT] [PARTITION]
3   -# PARTITION=fl2va 收首末帧；ref2va 收任意多张参考图。一个进程一个分区，各占一张卡。
4   -set -uo pipefail
5   -B=/data/models/minimax-h3
6   -GPU="${1:-1}"; PORT="${2:-8010}"; export H3_PARTITION="${3:-fl2va}"
7   -export CUDA_VISIBLE_DEVICES="$GPU"
8   -export DIFFSYNTH_ATTENTION_IMPLEMENTATION=torch
9   -export DIFFSYNTH_MODEL_BASE_PATH="$B/models"
10   -export MODELSCOPE_CACHE="$B/.mscache"
11   -export PYTORCH_ALLOC_CONF=expandable_segments:True
12   -export PYTHONUNBUFFERED=1
13   -cd "$B"
14   -echo "[api] GPU=$GPU PORT=$PORT PARTITION=$H3_PARTITION 首次加载约 240 秒（fp32 权重从机械盘读）"
15   -exec "$B/venv/bin/python" -m uvicorn api:app --host 0.0.0.0 --port "$PORT" --workers 1
minimax-h3/api.py deleted
View file @ccf5db1
1   -"""MiniMax-H3 文生视频 HTTP API（异步任务式）。
2   -
3   -为什么不是同步接口：模型加载 238s、单条视频 7 分钟（50 步 90 分钟），
4   -同步 HTTP 必然超时。所以是「提交任务拿 id → 轮询状态 → 下载文件」。
5   -
6   -为什么是串行单 worker：一条生成占 ~12.3G 显存 + ~32G CPU 内存，
7   -一张 22G 卡同时只能跑一条。并发提交会排队，不会 OOM。
8   -"""
9   -import os, sys, time, uuid, threading, queue, traceback, io, sqlite3, urllib.request
10   -from typing import Optional, Literal
11   -from pathlib import Path
12   -
13   -BASE = Path("/data/models/minimax-h3")
14   -OUT = BASE / "outputs"; OUT.mkdir(exist_ok=True)
15   -# 一个进程只跑一个分区。两套权重的 DiT、processor、Turbo LoRA 三样都不同，
16   -# 同进程装两套要么重建 pipe（每次重读 16G 权重），要么常驻 77G 内存。
17   -# 每卡一个进程本来就是这台机器唯一的并发方式（H3 不支持模型并行），顺手就把分区分开了。
18   -PARTITION = os.environ.get("H3_PARTITION", "fl2va")
19   -# 没上 GPU 的那部分权重存哪。cpu 是每进程一份 40G 匿名内存，并发被 125G 内存卡在 3 个；
20   -# disk 让权重留在 safetensors 文件里（layers.py 里 offload() 就是 .to("meta")），
21   -# 每次前向从文件读进显存，走 OS 页缓存——多个进程读同一个文件，物理内存里只有一份。
22   -OFFLOAD = os.environ.get("H3_OFFLOAD", "cpu")
23   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION", "torch")
24   -os.environ.setdefault("DIFFSYNTH_MODEL_BASE_PATH", str(BASE / "models"))
25   -os.environ.setdefault("MODELSCOPE_CACHE", str(BASE / ".mscache"))
26   -os.environ.setdefault("PYTORCH_ALLOC_CONF", "expandable_segments:True")
27   -
28   -import torch
29   -from fastapi import FastAPI, HTTPException
30   -from fastapi.responses import FileResponse
31   -from pydantic import BaseModel, Field, model_validator
32   -
33   -def _rows(width: int, height: int, frames: int) -> float:
34   - """序列行数：潜帧数 x 宽 x 高 / 1024。真正决定显存/算力的量，帧数和分辨率是同一笔预算。"""
35   - latent_frames = (max(frames, 5) - 5) // 17 * 5 + 2
36   - return latent_frames * width * height / 1024
37   -
38   -# 22G 卡的显存墙按 rows 算，不是单独卡 frames——实测边界（2026-08-20 long15s.sh）：
39   -# 832x480x124f rows=14430 稳定基准；448x256x362f rows=11984、576x320x362f rows=19260 都能跑
40   -# （后者峰值 14.5G，换入换出吃紧但没崩）；640x384x362f rows=25680 OOM（撞到 20.6G）。
41   -# 20000 卡在 19260（能跑）和 25680（OOM）之间，留安全余量。
42   -# 支持环境变量覆盖：只用于临时拉高某一个 worker 做边界探测实验，默认值（生产用的这道
43   -# 安全线）不变——测完记得把起这个 worker 的进程重启回不带这个环境变量的状态。
44   -ROWS_LIMIT = int(os.environ.get("H3_ROWS_LIMIT", 20000))
45   -
46   -# ---------------- 任务模型 ----------------
47   -class GenReq(BaseModel):
48   - prompt: str = Field(min_length=1, max_length=2000)
49   - # 上界取模型自己的默认档 1344x768。pipeline 本身不限分辨率，只把长宽向上取整到 32 的倍数，
50   - # 真正的墙是这张 22G 卡：序列行数按 h*w/1024 每潜帧算，832x480 是 390 行/帧 x 37 帧 = 14430 行，
51   - # 1344x768 是 1008 行/帧 = 37296 行，注意力是平方级，涨 2.6 倍行数就是涨约 6.7 倍算力。
52   - # 832x480 带三张参考图实测峰值 13.7G，往上哪一档撞墙没测过，超了就是这条任务 failed，不会拖死服务。
53   - width: int = Field(832, ge=64, le=1344)
54   - height: int = Field(480, ge=64, le=768)
55   - # 上界 362=15s（协议规格上限），是否真能生成看下面 _check_rows——832x480 撞了还是会被拒。
56   - frames: int = Field(124, ge=8, le=362)
57   - steps: int = Field(4, ge=1, le=50)
58   - turbo: bool = True
59   - seed: int = Field(0, ge=0, le=2**31 - 1)
60   - flow_shift: Optional[float] = None
61   - # 首末帧条件（FL2VA）。给了首帧，这一段就从那张画面长出去——同一间屋子、同一个人。
62   - # 不给就是纯文生视频，屋子和人由模型自己编，跨条对不上。
63   - first_frame_url: Optional[str] = None
64   - last_frame_url: Optional[str] = None
65   - # 参考图（Ref2VA）。首帧只管这一段从哪开始，参考图全程参与注意力，管的是「中间别乱改」。
66   - # 张数没有硬上限，代价是序列变长：一张按 ref_image_short_edge 缩放后折成 token，
67   - # 短边 480 时约 390 行，而目标视频本身才 14430 行。
68   - reference_image_urls: list[str] = []
69   - ref_image_short_edge: int = Field(480, ge=64, le=2048)
70   - # CFG 引导强度 / 负面提示词。pipeline 自己默认 cfg_scale=1.0（约等于不引导）、
71   - # negative_prompt=""，我们的代码之前从没传过，一直裸跑默认值。Optional，留空=不覆盖，
72   - # 跟以前行为一样；蒸馏 LoRA（turbo）模型引导太强有时反而出伪影，调高前留意这点。
73   - cfg_scale: Optional[float] = Field(None, ge=0)
74   - negative_prompt: Optional[str] = Field(None, max_length=2000)
75   -
76   - @model_validator(mode="after")
77   - def _check_rows(self):
78   - rows = _rows(self.width, self.height, self.frames)
79   - if rows > ROWS_LIMIT:
80   - raise ValueError(f"分辨率×帧数超出显存安全上限（rows={rows:.0f} > {ROWS_LIMIT}）；"
81   - f"降低 frames 或分辨率，例如 448x256/576x320 可到 362 帧，832x480 建议 ≤124 帧")
82   - return self
83   -
84   -class Job(BaseModel):
85   - id: str
86   - status: Literal["queued", "loading", "running", "done", "failed"]
87   - req: GenReq
88   - created_at: float
89   - started_at: Optional[float] = None
90   - finished_at: Optional[float] = None
91   - step: int = 0
92   - total_steps: int = 0
93   - file: Optional[str] = None
94   - size_bytes: Optional[int] = None
95   - error: Optional[str] = None
96   - peak_vram_gb: Optional[float] = None
97   -
98   -JOBS: dict[str, Job] = {}
99   -Q: "queue.Queue[str]" = queue.Queue()
100   -LOCK = threading.Lock()
101   -STATE = {"model": "loading", "loaded_at": None, "gpu": os.environ.get("CUDA_VISIBLE_DEVICES", "?")}
102   -
103   -# ---------------- 任务记录落盘 ----------------
104   -# 之前 JOBS 只在内存里，进程重启（比如 h3-console 的弹性调度器切分区）就把这张表清空——
105   -# 视频文件在 outputs/ 没事，但 id→文件路径这层映射没了，前端/API 都查不到。改成每次状态变化
106   -# 都往 sqlite 写一份，进程起来时先读回内存。四个 GPU 各一个进程，按 GPU id 分开的文件，
107   -# 不共享一份——共享一份要处理多进程并发写 sqlite 的锁竞争，没必要：反正一个进程只会在同一张
108   -# GPU 上起来，per-GPU 的文件天然不会有另一个进程来抢。
109   -JOBS_DB = BASE / f"jobs_gpu{os.environ.get('CUDA_VISIBLE_DEVICES', 'x')}.sqlite3"
110   -_JOBS_CON = sqlite3.connect(JOBS_DB, check_same_thread=False)
111   -_JOBS_CON.execute(
112   - "CREATE TABLE IF NOT EXISTS jobs (id TEXT PRIMARY KEY, updated_at REAL NOT NULL, data TEXT NOT NULL)"
113   -)
114   -_JOBS_CON.commit()
115   -
116   -def _persist(job: Job):
117   - with LOCK:
118   - _JOBS_CON.execute(
119   - "INSERT INTO jobs (id, updated_at, data) VALUES (?,?,?) "
120   - "ON CONFLICT(id) DO UPDATE SET updated_at=excluded.updated_at, data=excluded.data",
121   - (job.id, time.time(), job.model_dump_json()),
122   - )
123   - _JOBS_CON.commit()
124   -
125   -def _load_jobs():
126   - """进程刚起来时把上次落盘的任务记录读回内存。in-flight 的状态没法恢复——Q 是空的，
127   - GPU 上下文也是全新的，没有任何东西能"接着跑"。落盘时正好是 queued/running 的一律
128   - 改判为 failed 并写清原因，不然它会卡成一条永远显示"运行中"但没有 worker 会再碰的
129   - 死记录，比直接查不到这个 id 更容易让人误判成"卡住了，再等等"。"""
130   - n = 0
131   - for (data,) in _JOBS_CON.execute("SELECT data FROM jobs"):
132   - try:
133   - j = Job.model_validate_json(data)
134   - except Exception:
135   - continue # 单条记录损坏不该挡住整个服务启动
136   - if j.status in ("queued", "running"):
137   - j.status = "failed"
138   - j.error = "进程重启导致这条任务的执行状态丢失（GPU 上下文和排队状态不落盘，无法恢复）"
139   - j.finished_at = j.finished_at or time.time()
140   - JOBS[j.id] = j
141   - n += 1
142   - if n:
143   - print(f"[api] 从磁盘恢复了 {n} 条历史任务记录（{JOBS_DB.name}）", flush=True)
144   -
145   -_load_jobs()
146   -
147   -# ---------------- 推理 worker ----------------
148   -# DiT、processor、Turbo LoRA 三样成套，跨分区混用会对不上层。
149   -# ref2v 的 Turbo LoRA 只有 v0.1，fl2v 那个是 v1.0 768p——这一项两边成色不同。
150   -PARTITIONS = {
151   - "fl2va": {"dit": "minimax-h3-fl2va-nf4.safetensors",
152   - "processor": "FL2VA/processor/",
153   - "lora": "minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"},
154   - # ref2v 的 bf16 版实测出 124 帧噪点：同尺寸同 seed，挂上它是噪点、摘掉就出画面，
155   - # 换 flow_shift 无效（见 docs/H3 的二分表）。改用 comfyui 版试另一套键名。
156   - "ref2va": {"dit": "minimax-h3-ref2va-nf4.safetensors",
157   - "processor": "Ref2VA/processor/",
158   - "lora": "minimax_h3_ref2v_turbo_4step_v0.1_comfyui_bf16.safetensors"},
159   -}
160   -
161   -def _turbo_lora_config():
162   - from diffsynth.pipelines.minimax_h3_audio_video import ModelConfig
163   - return ModelConfig(model_id="lightx2v/Minimax-h3-Turbo",
164   - origin_file_pattern=PARTITIONS[PARTITION]["lora"])
165   -
166   -def _build_pipe():
167   - from diffsynth.pipelines.minimax_h3_audio_video import MiniMaxH3Pipeline, ModelConfig
168   - part = PARTITIONS[PARTITION]
169   - DT = torch.float32 # fp16 在 sm_75 上出全黑视频，见 README
170   - # 常驻显存里留给权重多少 GB，剩下的全是激活。默认公式是按 832x480 调的（留 14G 给激活，实测峰值 13.7G）。
171   - # 分辨率往上走就得调低它：1280x720 在默认值下要 22.3G、卡只有 21.49G，差约 1G 撞 OOM；
172   - # 调低后权重多从内存流几趟，慢一点，换来激活空间。用 H3_VRAM_LIMIT 覆盖。
173   - free = torch.cuda.mem_get_info("cuda")[0] / 1024**3
174   - vram_limit = float(os.environ.get("H3_VRAM_LIMIT", max(4.0, free - 14.0)))
175   - offload_dt = "disk" if OFFLOAD == "disk" else DT
176   - vc = dict(offload_dtype=offload_dt, offload_device=OFFLOAD,
177   - onload_dtype=offload_dt, onload_device=OFFLOAD,
178   - preparing_dtype=DT, preparing_device="cuda",
179   - computation_dtype=DT, computation_device="cuda")
180   - NF4 = "DiffSynth-Studio/MiniMax-H3-NF4"
181   - pipe = MiniMaxH3Pipeline.from_pretrained(
182   - torch_dtype=DT, device="cuda",
183   - model_configs=[ModelConfig(model_id=NF4, origin_file_pattern=f, **vc) for f in
184   - [part["dit"], "minimax-h3-text-encoder-nf4.safetensors",
185   - "video_vae_nf4.safetensors", "audio_vae_nf4.safetensors"]],
186   - processor_config=ModelConfig(model_id="MiniMax/MiniMax-H3",
187   - origin_file_pattern=part["processor"]),
188   - vram_limit=vram_limit)
189   - pipe.load_lora(pipe.dit, _turbo_lora_config())
190   - return pipe
191   -
192   -def _fetch_image(url):
193   - from PIL import Image
194   - with urllib.request.urlopen(url, timeout=60) as resp:
195   - return Image.open(io.BytesIO(resp.read())).convert("RGB")
196   -
197   -def _keyframes(req):
198   - """取首末帧图，缩到出片尺寸。都没给就返回 (None, None)，pipeline 退回纯文生视频。"""
199   - from PIL import Image
200   - images, indices = [], []
201   - for index, url in ((0, req.first_frame_url), (-1, req.last_frame_url)):
202   - if url is None:
203   - continue
204   - images.append(_fetch_image(url).resize((req.width, req.height), Image.LANCZOS))
205   - indices.append(index)
206   - return (images, indices) if images else (None, None)
207   -
208   -def _references(req):
209   - """参考图按请求顺序取下来。尺寸交给 pipeline 按 ref_image_short_edge 归一，这里不动。"""
210   - if not req.reference_image_urls:
211   - return None
212   - return [{"type": "image", "image": _fetch_image(url)} for url in req.reference_image_urls]
213   -
214   -def worker():
215   - from diffsynth.utils.data.audio_video import write_video_audio
216   - import numpy as np
217   - t0 = time.time()
218   - pipe = _build_pipe()
219   - STATE["model"] = "ready"; STATE["loaded_at"] = time.time()
220   - print(f"[api] 模型就绪，耗时 {time.time()-t0:.0f}s", flush=True)
221   -
222   - while True:
223   - jid = Q.get()
224   - j = JOBS[jid]
225   - try:
226   - j.status = "running"; j.started_at = time.time()
227   - j.total_steps = j.req.steps
228   - _persist(j)
229   - torch.cuda.reset_peak_memory_stats()
230   - fs = j.req.flow_shift if j.req.flow_shift is not None else (6.0 if j.req.turbo else 12.0)
231   - if not j.req.turbo:
232   - pipe.clear_lora()
233   - keyframes, keyframe_indices = _keyframes(j.req)
234   - cfg_scale = j.req.cfg_scale if j.req.cfg_scale is not None else 1.0
235   - negative_prompt = j.req.negative_prompt if j.req.negative_prompt is not None else ""
236   - video, audio = pipe(prompt=j.req.prompt, negative_prompt=negative_prompt,
237   - height=j.req.height, width=j.req.width,
238   - num_frames=j.req.frames, num_inference_steps=j.req.steps,
239   - seed=j.req.seed, flow_shift=fs, cfg_scale=cfg_scale,
240   - keyframes=keyframes, keyframe_indices=keyframe_indices,
241   - references=_references(j.req),
242   - ref_image_short_edge=j.req.ref_image_short_edge)
243   - # 产物必须验过才算成功——全黑视频也能写出文件（踩过）
244   - a = np.stack([np.asarray(f.convert("RGB"), dtype=np.float32)
245   - for f in video[:: max(1, len(video)//8)]])
246   - if a.std() < 1.0:
247   - raise RuntimeError(f"生成结果近乎纯色 (std={a.std():.3f})，判为失败")
248   - if torch.is_tensor(audio) and not torch.isfinite(audio).all():
249   - raise RuntimeError("音频含非有限值，判为失败")
250   - out = OUT / f"api_{jid}.mp4"
251   - write_video_audio(video=video, audio=audio, output_path=str(out),
252   - fps=24, audio_sample_rate=32000)
253   - j.file = str(out); j.size_bytes = out.stat().st_size
254   - j.peak_vram_gb = round(torch.cuda.max_memory_allocated()/1024**3, 2)
255   - j.status = "done"
256   - except Exception as e:
257   - j.status = "failed"; j.error = f"{type(e).__name__}: {e}"
258   - traceback.print_exc()
259   - finally:
260   - j.finished_at = time.time()
261   - _persist(j)
262   - if not j.req.turbo: # 下一个任务可能要 turbo，把 LoRA 挂回去
263   - try:
264   - pipe.load_lora(pipe.dit, _turbo_lora_config())
265   - except Exception:
266   - traceback.print_exc()
267   - Q.task_done()
268   -
269   -# ---------------- HTTP ----------------
270   -app = FastAPI(title="MiniMax-H3 Video API", version="1.0")
271   -
272   -@app.on_event("startup")
273   -def _start():
274   - threading.Thread(target=worker, daemon=True).start()
275   -
276   -@app.get("/health")
277   -def health():
278   - return {"status": "ok" if STATE["model"] == "ready" else "loading",
279   - "model": STATE["model"], "gpu": STATE["gpu"], "partition": PARTITION,
280   - "offload": OFFLOAD, "queued": Q.qsize(),
281   - "running": sum(1 for j in JOBS.values() if j.status == "running")}
282   -
283   -@app.post("/v1/videos", status_code=202)
284   -def create(req: GenReq):
285   - if req.turbo and req.steps > 8:
286   - raise HTTPException(400, "turbo 模式步数应 ≤8（LoRA 是 4 步蒸馏的）；要多步请传 turbo=false")
287   - jid = uuid.uuid4().hex[:12]
288   - with LOCK:
289   - JOBS[jid] = Job(id=jid, status="queued", req=req, created_at=time.time())
290   - _persist(JOBS[jid]) # LOCK 外面调用 —— _persist 自己会拿 LOCK，Lock 不可重入，嵌套会死锁
291   - Q.put(jid)
292   - # 耗时的自变量是序列行数（潜帧数 x 宽 x 高 / 1024），不是分辨率——分辨率和帧数是同一笔预算。
293   - # 基准点 832x480x124f = 14430 行，4 步实测 692 秒 = 4 x 132 + 163
294   - #（163 是文本编码 + 参考图编码 + VAE 解码，它也跟帧数走，所以一起按行数缩放）。
295   - # 回代：1280x736x56f（15640 行）估 749 / 实测 736；832x480x22f（2730 行）估 131 / 实测 96。
296   - # 注意力是平方级，行数越大这个线性估计偏得越小。
297   - rows = _rows(req.width, req.height, req.frames)
298   - est = round((req.steps * 132 + 163) * rows / 14430)
299   - return {"id": jid, "status": "queued", "queue_position": Q.qsize(),
300   - "eta_seconds": est, "poll": f"/v1/videos/{jid}"}
301   -
302   -@app.get("/v1/videos/{jid}")
303   -def get(jid: str):
304   - j = JOBS.get(jid)
305   - if not j: raise HTTPException(404, "无此任务")
306   - d = j.model_dump()
307   - if j.status == "running" and j.started_at:
308   - d["elapsed_seconds"] = round(time.time() - j.started_at)
309   - if j.status == "done":
310   - d["download"] = f"/v1/videos/{jid}/file"
311   - return d
312   -
313   -@app.get("/v1/videos/{jid}/file")
314   -def download(jid: str):
315   - j = JOBS.get(jid)
316   - if not j: raise HTTPException(404, "无此任务")
317   - if j.status != "done": raise HTTPException(409, f"任务尚未完成（当前 {j.status}）")
318   - return FileResponse(j.file, media_type="video/mp4", filename=f"{jid}.mp4")
319   -
320   -@app.get("/v1/videos")
321   -def listjobs(limit: int = 50):
322   - js = sorted(JOBS.values(), key=lambda x: x.created_at, reverse=True)[:limit]
323   - return {"jobs": [{"id": j.id, "status": j.status, "created_at": j.created_at,
324   - "size_bytes": j.size_bytes, "error": j.error} for j in js]}
minimax-h3/burst-test.py deleted
View file @ccf5db1
1   -"""压并发：12 条同时投给调度层，看三件事。
2   -
3   -1. 派发会不会打偏——调度层是「读 health 挑最闲的」，同时提交时几个请求可能读到同一份快照。
4   - 顺序提交测不出这个，必须真并发。
5   -2. queue_position 和 eta_seconds 在排队时说了什么。
6   -3. 队列有没有上限、超了会怎样。
7   -"""
8   -import json, time, urllib.request
9   -from collections import Counter
10   -from concurrent.futures import ThreadPoolExecutor
11   -
12   -GW = "http://127.0.0.1:8000"
13   -N = 12
14   -SPEC = {"prompt": "一只橘猫趴在洒满阳光的窗台上，慢慢眨眼", "frames": 22, "steps": 4, "turbo": True}
15   -
16   -
17   -def call(path, data=None, timeout=60):
18   - req = urllib.request.Request(GW + path, data=data,
19   - headers={"Content-Type": "application/json"} if data else {})
20   - with urllib.request.urlopen(req, timeout=timeout) as r:
21   - return json.load(r)
22   -
23   -
24   -def submit(i):
25   - t = time.time()
26   - job = call("/v1/videos", json.dumps(dict(SPEC, seed=100 + i)).encode())
27   - return i, job, time.time() - t
28   -
29   -
30   -t0 = time.time()
31   -with ThreadPoolExecutor(max_workers=N) as pool:
32   - results = sorted(pool.map(submit, range(N)))
33   -print(f"12 条并发提交耗时 {time.time() - t0:.2f}s\n")
34   -
35   -for i, job, dt in results:
36   - print(f" #{i:<2} {job['backend'][-4:]} queue_position={job['queue_position']} "
37   - f"eta={job['eta_seconds']}s ({dt:.2f}s)")
38   -
39   -spread = Counter(job["backend"][-4:] for _, job, _ in results)
40   -print(f"\n派发分布: {dict(sorted(spread.items()))} 理想是每个 {N // 4} 条")
41   -
42   -ids = [job["id"] for _, job, _ in results]
43   -print("\n--- 轮询")
44   -while True:
45   - time.sleep(30)
46   - states = [call(f"/v1/videos/{jid}") for jid in ids]
47   - c = Counter(s["status"] for s in states)
48   - print(f" {dict(c)}", flush=True)
49   - if all(s["status"] in ("done", "failed") for s in states):
50   - break
51   -
52   -total = time.time() - t0
53   -print(f"\n12 条全部完成，墙钟 {total:.0f}s")
54   -for s in sorted(states, key=lambda s: s["created_at"]):
55   - took = s["finished_at"] - s["started_at"]
56   - wait = s["started_at"] - s["created_at"]
57   - print(f" {s['id'][:6]} {s['status']} 排队{wait:5.0f}s 执行{took:4.0f}s {s['backend'][-4:]}")
minimax-h3/concurrency-test.py deleted
View file @ccf5db1
1   -"""四张卡同时跑同一条任务，量并发缩水。
2   -
3   -各端口和自己的单跑基线比：cpu 模式 692s，disk 模式 767s。
4   -任务规格从 8011 上那条已完成的 826db7b3f08e 原样取，保证四条完全一致。
5   -"""
6   -import json, time, urllib.request
7   -
8   -# 8010/8011 是三小时前起的，跑的还是加 H3_OFFLOAD 之前的 api.py，/health 里没有 offload 字段，
9   -# 所以模式和基线都写在这里。
10   -MODE = {8010: "cpu", 8011: "cpu", 8012: "disk", 8013: "disk"}
11   -BASELINE = {"cpu": 692, "disk": 767}
12   -
13   -
14   -def call(port, path, body=None):
15   - url = f"http://127.0.0.1:{port}{path}"
16   - req = urllib.request.Request(url, data=body,
17   - headers={"Content-Type": "application/json"} if body else {})
18   - with urllib.request.urlopen(req, timeout=60) as r:
19   - return json.load(r)
20   -
21   -
22   -spec = json.dumps(call(8011, "/v1/videos/826db7b3f08e")["req"]).encode()
23   -
24   -jobs = {}
25   -for port, mode in MODE.items():
26   - jobs[port] = (call(port, "/v1/videos", spec)["id"], mode)
27   - print(f"{port} ({mode}) -> {jobs[port][0]}", flush=True)
28   -
29   -print("--- 四条已同时投出，开始轮询", flush=True)
30   -pending = dict(jobs)
31   -while pending:
32   - time.sleep(60)
33   - for port in list(pending):
34   - jid, mode = pending[port]
35   - j = call(port, f"/v1/videos/{jid}")
36   - if j["status"] in ("done", "failed"):
37   - took = j["finished_at"] - j["started_at"]
38   - base = BASELINE[mode]
39   - print(f"{port} ({mode}) {j['status']} {took:.0f}s 基线{base}s "
40   - f"缩水{(took/base-1)*100:+.1f}% 峰值显存{j.get('peak_vram_gb')}G "
41   - f"{j.get('size_bytes')}字节", flush=True)
42   - del pending[port]
43   - else:
44   - print(f" {port} {j['status']} {j.get('elapsed_seconds', 0)}s", flush=True)
minimax-h3/direct-backend-test.py deleted
View file @ccf5db1
1   -"""验直连后端端口这条老路还通不通——调度层是加在旁边的，不该动到它。
2   -
3   -走的是 API.md 里那段完整调用示例的形状：POST 拿 id → 轮询 → 下载。
4   -"""
5   -import json, time, urllib.request
6   -
7   -API = "http://127.0.0.1:8010"
8   -SPEC = {"prompt": "一只橘猫趴在洒满阳光的窗台上，慢慢眨眼", "frames": 22, "steps": 4,
9   - "turbo": True, "seed": 99}
10   -
11   -
12   -def call(path, data=None, timeout=60):
13   - req = urllib.request.Request(API + path, data=data,
14   - headers={"Content-Type": "application/json"} if data else {})
15   - with urllib.request.urlopen(req, timeout=timeout) as r:
16   - return json.load(r)
17   -
18   -
19   -print("health:", call("/health"))
20   -job = call("/v1/videos", json.dumps(SPEC).encode())
21   -print("提交:", job)
22   -
23   -while True:
24   - time.sleep(20)
25   - j = call(f"/v1/videos/{job['id']}")
26   - print(" ", j["status"], j.get("elapsed_seconds", 0), "s", flush=True)
27   - if j["status"] in ("done", "failed"):
28   - break
29   -
30   -if j["status"] == "failed":
31   - raise SystemExit("失败: " + j["error"])
32   -
33   -with urllib.request.urlopen(f"{API}/v1/videos/{job['id']}/file", timeout=300) as r:
34   - data = r.read()
35   -print(f"下载 {len(data)} 字节，后端记录 {j['size_bytes']}，一致={len(data) == j['size_bytes']}")
minimax-h3/gateway-run.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# 起调度层。用法: ./gateway-run.sh [PORT]
3   -# 后端列表用 H3_BACKENDS 覆盖，默认 8010,8011,8012,8013。
4   -# 这一层不碰模型也不占显存，秒起秒停，随便重启。
5   -set -uo pipefail
6   -B=/data/models/minimax-h3
7   -PORT="${1:-8000}"
8   -export PYTHONUNBUFFERED=1
9   -cd "$B"
10   -echo "[gateway] PORT=$PORT 后端=${H3_BACKENDS:-8010,8011,8012,8013}"
11   -exec "$B/venv/bin/python" -m uvicorn gateway:app --host 0.0.0.0 --port "$PORT" --workers 1
minimax-h3/gateway-test.py deleted
View file @ccf5db1
1   -"""验调度层：往 :8000 投 5 条（比后端多一条），看是不是每卡一条、多出来那条排队。
2   -
3   -用短任务（22 帧）只是为了快，路由逻辑和长任务完全一样。
4   -"""
5   -import json, time, urllib.request
6   -
7   -GW = "http://127.0.0.1:8000"
8   -SPEC = {"prompt": "一只橘猫趴在洒满阳光的窗台上，慢慢眨眼，尾巴轻轻摆动",
9   - "width": 832, "height": 480, "frames": 22, "steps": 4, "turbo": True, "seed": 7}
10   -
11   -
12   -def call(path, data=None, timeout=60):
13   - req = urllib.request.Request(GW + path, data=data,
14   - headers={"Content-Type": "application/json"} if data else {})
15   - with urllib.request.urlopen(req, timeout=timeout) as r:
16   - return json.load(r)
17   -
18   -
19   -ids = []
20   -for i in range(5):
21   - job = call("/v1/videos", json.dumps(dict(SPEC, seed=7 + i)).encode())
22   - ids.append(job["id"])
23   - print(f"第{i+1}条 -> {job['backend']} id={job['id']} 队列位置={job['queue_position']}", flush=True)
24   -
25   -print("\n--- 派发结果")
26   -used = {}
27   -for jid in ids:
28   - b = call(f"/v1/videos/{jid}")["backend"]
29   - used.setdefault(b, []).append(jid)
30   -for b, js in sorted(used.items()):
31   - print(f"{b}: {len(js)} 条 {js}")
32   -print(f"用上了 {len(used)}/4 个后端")
33   -
34   -print("\n--- 轮询到全部完成")
35   -while True:
36   - time.sleep(30)
37   - states = [call(f"/v1/videos/{jid}") for jid in ids]
38   - print(" " + " ".join(f"{s['id'][:6]}:{s['status']}" for s in states), flush=True)
39   - if all(s["status"] in ("done", "failed") for s in states):
40   - break
41   -
42   -print("\n--- 结果")
43   -for s in states:
44   - took = (s["finished_at"] - s["started_at"]) if s.get("started_at") else 0
45   - print(f"{s['id']} {s['status']} {took:.0f}s {s.get('size_bytes')}字节 {s['backend']}")
46   -
47   -ok = [s for s in states if s["status"] == "done"]
48   -if ok:
49   - with urllib.request.urlopen(f"{GW}/v1/videos/{ok[0]['id']}/file", timeout=300) as r:
50   - data = r.read()
51   - print(f"\n经调度层下载 {ok[0]['id']}: {len(data)} 字节 "
52   - f"(后端记录 {ok[0]['size_bytes']}) 一致={len(data) == ok[0]['size_bytes']}")
minimax-h3/gateway.py deleted
View file @ccf5db1
1   -"""四个 H3 实例前面的调度层。
2   -
3   -api.py 是单 worker 串行，一个进程独占一张卡，所以并发的唯一办法是往不同端口投。
4   -这一层把「投哪个端口」收掉：对外只有一个地址，接口和 api.py 逐字相同，
5   -调用方原来怎么写现在还怎么写，只把端口换成 8000。
6   -
7   -自己不存任何状态。任务 id 归哪个后端，问一遍就知道——四个后端一次扫描的代价可以忽略，
8   -换来的是这个进程随时能重启，不丢任何东西（api.py 的 JOBS 本来也在内存里，
9   -调度层再存一份 id→后端 的映射，就是第二个会丢的地方）。
10   -"""
11   -import os, json, threading, urllib.request, urllib.error
12   -from concurrent.futures import ThreadPoolExecutor
13   -
14   -from fastapi import FastAPI, HTTPException
15   -from fastapi.responses import StreamingResponse
16   -
17   -BACKENDS = [f"http://127.0.0.1:{port.strip()}" for port in
18   - os.environ.get("H3_BACKENDS", "8010,8011,8012,8013").split(",")]
19   -POOL = ThreadPoolExecutor(max_workers=16)
20   -# 最闲的那个后端已经压了这么多条时，再来的提交直接 429 顶回去。
21   -# 没有这个上限的话队列是无界的：投 1000 条全部返回 202，最后一条两天后才开始跑，
22   -# 调用方却收到「已接受」。宁可当场说满了。默认 4 条 ≈ 45 分钟积压。
23   -MAX_QUEUE = int(os.environ.get("H3_MAX_QUEUE", "4"))
24   -# 选后端是「读一遍各家队列深度，再往最闲的那个投」。这中间不能插进另一个提交，
25   -# 否则同时来的请求会读到同一份快照、一起挑中同一个后端，全堆在一张卡上。
26   -# 锁只圈住选 + 投这一段（约 30 毫秒），任务本身要跑十几分钟，序列化的代价可以忽略。
27   -PICK = threading.Lock()
28   -
29   -
30   -def fetch(url, data=None, timeout=30):
31   - req = urllib.request.Request(url, data=data,
32   - headers={"Content-Type": "application/json"} if data else {})
33   - with urllib.request.urlopen(req, timeout=timeout) as resp:
34   - return json.load(resp)
35   -
36   -
37   -def health_all():
38   - def one(backend):
39   - try:
40   - return dict(fetch(backend + "/health", timeout=5), backend=backend)
41   - except Exception as e:
42   - return {"backend": backend, "status": "down", "error": f"{type(e).__name__}: {e}"}
43   - return list(POOL.map(one, BACKENDS))
44   -
45   -
46   -def find_owner(jid):
47   - """任务归谁，挨个问。后端对陌生 id 返回 404，urlopen 抛异常，接住当没有。"""
48   - def one(backend):
49   - try:
50   - return backend, fetch(f"{backend}/v1/videos/{jid}", timeout=5)
51   - except Exception:
52   - return backend, None
53   - for backend, job in POOL.map(one, BACKENDS):
54   - if job is not None:
55   - return backend, job
56   - raise HTTPException(404, "无此任务")
57   -
58   -
59   -app = FastAPI(title="MiniMax-H3 Gateway", version="1.0")
60   -
61   -
62   -@app.get("/health")
63   -def health():
64   - backends = health_all()
65   - ready = [b for b in backends if b.get("status") == "ok"]
66   - return {"status": "ok" if ready else "unavailable",
67   - "ready": len(ready), "total": len(backends),
68   - "queued": sum(b.get("queued", 0) for b in ready),
69   - "running": sum(b.get("running", 0) for b in ready),
70   - "backends": backends}
71   -
72   -
73   -# 同步 def，让 FastAPI 把它丢进线程池。写成 async def 会让下面这些阻塞的 HTTP 调用
74   -# 卡住事件循环——那样确实也能歪打正着地把提交排成队，但任何一个后端卡住，
75   -# 5 秒超时就会连轮询一起堵死。要串行就用锁明说。
76   -@app.post("/v1/videos", status_code=202)
77   -def create(req: dict):
78   - # 给了首末帧就只能走 fl2va；其余都走 ref2va——ref2va 不给参考图就退回纯文生视频，
79   - # 所以「没有首末帧」这一类不需要再细分。
80   - want = "fl2va" if (req.get("first_frame_url") or req.get("last_frame_url")) else "ref2va"
81   - with PICK:
82   - candidates = [b for b in health_all()
83   - if b.get("status") == "ok" and b.get("partition") == want]
84   - if not candidates:
85   - raise HTTPException(503, f"没有就绪的 {want} 实例")
86   - # 排队最短的那个。queued 是还在队列里的，running 是正在跑的那条，两个都要算。
87   - pick = min(candidates, key=lambda b: b["queued"] + b["running"])
88   - ahead = pick["queued"] + pick["running"]
89   - if ahead >= MAX_QUEUE:
90   - raise HTTPException(429, f"队列满：{len(candidates)} 个 {want} 实例每个都压着 "
91   - f"{ahead} 条（上限 {MAX_QUEUE}）。等一会儿再投，"
92   - f"或调大 H3_MAX_QUEUE")
93   - try:
94   - job = fetch(pick["backend"] + "/v1/videos", data=json.dumps(req).encode())
95   - except urllib.error.HTTPError as e:
96   - raise HTTPException(e.code, e.read().decode())
97   - # eta_seconds 是这一条自己的执行时间，不含排队。前面还压着 ahead 条，
98   - # 真正的等待还要加上它们——它们规格可能不同，这里不替调用方瞎乘。
99   - return dict(job, backend=pick["backend"], queue_ahead=ahead, poll=f"/v1/videos/{job['id']}")
100   -
101   -
102   -@app.get("/v1/videos/{jid}")
103   -def get(jid: str):
104   - backend, job = find_owner(jid)
105   - return dict(job, backend=backend)
106   -
107   -
108   -@app.get("/v1/videos/{jid}/file")
109   -def download(jid: str):
110   - backend, job = find_owner(jid)
111   - if job["status"] != "done":
112   - raise HTTPException(409, f"任务尚未完成（当前 {job['status']}）")
113   - resp = urllib.request.urlopen(f"{backend}/v1/videos/{jid}/file", timeout=300)
114   - return StreamingResponse(resp, media_type="video/mp4",
115   - headers={"Content-Disposition": f'attachment; filename="{jid}.mp4"'})
116   -
117   -
118   -@app.get("/v1/videos")
119   -def listjobs(limit: int = 50):
120   - def one(backend):
121   - try:
122   - return [dict(j, backend=backend)
123   - for j in fetch(f"{backend}/v1/videos?limit={limit}", timeout=5)["jobs"]]
124   - except Exception:
125   - return []
126   - jobs = [job for part in POOL.map(one, BACKENDS) for job in part]
127   - jobs.sort(key=lambda j: j["created_at"], reverse=True)
128   - return {"jobs": jobs[:limit]}
minimax-h3/long15s.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# 15 秒（362 帧 = 17*21+5）可行性验证。低分辨率先验证长时长通路，再考虑全分辨率。
3   -# 用法: ./long15s.sh <GPU> <FRAMES> <W> <H> [额外参数...]
4   -set -uo pipefail
5   -cd /data/models/minimax-h3
6   -P="$(cat prompt.txt)"
7   -GPU="$1"; F="$2"; W="$3"; H="$4"; shift 4
8   -./run.sh "$GPU" --frames "$F" --width "$W" --height "$H" --prompt "$P" --seed 42 "$@"
minimax-h3/pin-cache.sh deleted
View file @ccf5db1
1   -#!/bin/bash
2   -# 把 H3 权重的页缓存钉住：告诉内核 user.slice 下的 40 G 不许回收。
3   -# 不钉的话，别的程序一申请大块内存，权重缓存就被丢掉，
4   -# 之后每次前向都要回机械盘 /dev/sdb 读 34.4 G，单条耗时会成倍涨。
5   -#
6   -# 重跑安全。撤销：sudo rm /etc/systemd/system/user-.slice.d/h3-cache.conf && sudo systemctl daemon-reload
7   -set -e
8   -
9   -echo "需要 admin 密码（sudo 用的是你自己的密码，不是 root 的）"
10   -
11   -sudo mkdir -p /etc/systemd/system/user-.slice.d
12   -printf '[Slice]\nMemoryMin=40G\n' | sudo tee /etc/systemd/system/user-.slice.d/h3-cache.conf > /dev/null
13   -sudo systemctl daemon-reload
14   -sudo systemctl set-property user.slice MemoryMin=40G
15   -sudo systemctl set-property "user-$(id -u).slice" MemoryMin=40G
16   -
17   -echo
18   -echo "=== 生效情况（两行都应该是 42949672960，即 40 G）"
19   -grep -H . /sys/fs/cgroup/user.slice/memory.min
20   -grep -H . "/sys/fs/cgroup/user.slice/user-$(id -u).slice/memory.min"
21   -
22   -echo
23   -echo "=== 当前被保护的量"
24   -grep -H . /sys/fs/cgroup/user.slice/memory.current
minimax-h3/prompt.txt deleted
View file @ccf5db1
1   -清晨的中式庭院，一位穿浅蓝色棉麻衬衫的年轻女子坐在木质长廊上，手里捧着一杯冒着热气的茶。她微笑着说 "Good morning, the tea smells wonderful today." 阳光透过竹叶洒在她脸上，微风吹动她的头发，远处有清脆的鸟鸣声。
minimax-h3/realrun.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# 真实测试：从文件读 prompt，避开多层 shell 引号
3   -set -uo pipefail
4   -cd /data/models/minimax-h3
5   -P="$(cat prompt.txt)"
6   -echo "[prompt] ${#P} 字符: ${P:0:40}..."
7   -case "$1" in
8   - turbo) ./run.sh 1 --prompt "$P" --seed 42 ;;
9   - full50) ./run.sh 2 --no-turbo --steps 50 --prompt "$P" --seed 42 ;;
10   -esac
minimax-h3/restart-8010.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# 重启 8010 的 ref2va 实例，把常驻权重压到 4G 换激活空间，验 1280x720 能不能跑。
3   -set -uo pipefail
4   -cd /data/models/minimax-h3
5   -PID=$(ss -lptn "sport = :8010" | grep -o "pid=[0-9]*" | cut -d= -f2 | sort -u)
6   -[ -n "$PID" ] && kill "$PID"
7   -sleep 8
8   -export H3_VRAM_LIMIT=4
9   -setsid nohup ./api-run.sh 1 8010 ref2va > logs/api-8010.log 2>&1 < /dev/null &
10   -sleep 12
11   -pgrep -af uvicorn
minimax-h3/run-verify.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# 把调度层临时换成 H3_MAX_QUEUE=1 跑一遍验证，跑完恢复默认。
3   -set -uo pipefail
4   -cd /data/models/minimax-h3
5   -
6   -restart_gateway() {
7   - PID=$(ss -lptn "sport = :8000" | grep -o "pid=[0-9]*" | cut -d= -f2 | sort -u)
8   - [ -n "$PID" ] && { kill $PID; sleep 3; }
9   - setsid nohup ./gateway-run.sh 8000 > logs/gateway.log 2>&1 < /dev/null &
10   - sleep 5
11   -}
12   -
13   -export H3_MAX_QUEUE=1
14   -restart_gateway
15   -echo "调度层已起，H3_MAX_QUEUE=1"
16   -./venv/bin/python verify-fixes.py
17   -
18   -echo
19   -echo "=== 恢复默认 H3_MAX_QUEUE"
20   -unset H3_MAX_QUEUE
21   -restart_gateway
22   -curl -s http://127.0.0.1:8000/health | grep -o '"ready":[0-9]*'
minimax-h3/run.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# MiniMax-H3 FL2VA NF4 launcher. usage: ./run.sh <GPU_ID> [args for t2va.py ...]
3   -# ./run.sh 1 # turbo 4-step, 480x832x124f
4   -# ./run.sh 1 --no-turbo --steps 50 # full quality
5   -# ./run.sh 2 --prompt "..." --seed 7
6   -set -euo pipefail
7   -B=/data/models/minimax-h3
8   -GPU="${1:-1}"; shift || true
9   -
10   -export CUDA_VISIBLE_DEVICES="$GPU"
11   -export DIFFSYNTH_ATTENTION_IMPLEMENTATION=torch # sm_75: no flash/sage; pin instead of auto-picking xformers
12   -export DIFFSYNTH_MODEL_BASE_PATH="$B/models"
13   -export MODELSCOPE_CACHE="$B/.mscache"
14   -export PYTHONUNBUFFERED=1
15   -# 22GB 卡上激活与权重贴着上限，碎片会直接压垮它（实测 reserved-but-unallocated 达 2.49GB）
16   -export PYTORCH_ALLOC_CONF=expandable_segments:True
17   -# NOTE: deliberately NOT setting PYTHONNOUSERSITE -- the venv's site-packages already
18   -# precedes ~/.local in sys.path, so our bitsandbytes 0.50.1 shadows the broken 0.45.1 there.
19   -
20   -# GPU0/1 sit on NUMA0, GPU2/3 on NUMA1 -- keep the CPU-offloaded weights on the near node.
21   -case "$GPU" in 0|1) NODE=0 ;; 2|3) NODE=1 ;; *) NODE="" ;; esac
22   -BIND=(); if [ -n "$NODE" ] && command -v numactl >/dev/null 2>&1; then BIND=(numactl --cpunodebind="$NODE" --membind="$NODE"); fi
23   -
24   -LOG="$B/logs/gpu${GPU}_$(date +%Y%m%d-%H%M%S).log"
25   -echo "[run] GPU=$GPU numa=${NODE:-none} log=$LOG"
26   -"${BIND[@]}" "$B/venv/bin/python" "$B/scripts/t2va.py" "$@" 2>&1 | tee "$LOG"
minimax-h3/scripts/diag-nan.py deleted
View file @ccf5db1
1   -"""定位 NaN 的产生位置：对 dit / text_encoder 挂 forward hook，
2   -找出第一个『输入有限、输出非有限』的模块。"""
3   -import os, sys, time, torch
4   -sys.argv = [sys.argv[0]]
5   -BASE = "/data/models/minimax-h3"
6   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION", "torch")
7   -os.environ.setdefault("DIFFSYNTH_MODEL_BASE_PATH", f"{BASE}/models")
8   -os.environ.setdefault("MODELSCOPE_CACHE", f"{BASE}/.mscache")
9   -
10   -from diffsynth.pipelines.minimax_h3_audio_video import MiniMaxH3Pipeline, ModelConfig
11   -
12   -DTYPE = torch.float16
13   -free_gb = torch.cuda.mem_get_info("cuda")[0] / 1024**3
14   -vram_limit = max(6.0, free_gb - 2.0)
15   -print(f"[env] free={free_gb:.1f}G vram_limit={vram_limit:.1f}G", flush=True)
16   -
17   -vc = dict(offload_dtype=DTYPE, offload_device="cpu", onload_dtype=DTYPE, onload_device="cpu",
18   - preparing_dtype=DTYPE, preparing_device="cuda",
19   - computation_dtype=DTYPE, computation_device="cuda")
20   -NF4 = "DiffSynth-Studio/MiniMax-H3-NF4"
21   -t0 = time.time()
22   -pipe = MiniMaxH3Pipeline.from_pretrained(
23   - torch_dtype=DTYPE, device="cuda",
24   - model_configs=[
25   - ModelConfig(model_id=NF4, origin_file_pattern="minimax-h3-fl2va-nf4.safetensors", **vc),
26   - ModelConfig(model_id=NF4, origin_file_pattern="minimax-h3-text-encoder-nf4.safetensors", **vc),
27   - ModelConfig(model_id=NF4, origin_file_pattern="video_vae_nf4.safetensors", **vc),
28   - ModelConfig(model_id=NF4, origin_file_pattern="audio_vae_nf4.safetensors", **vc),
29   - ],
30   - processor_config=ModelConfig(model_id="MiniMax/MiniMax-H3", origin_file_pattern="FL2VA/processor/"),
31   - vram_limit=vram_limit)
32   -print(f"[load] {time.time()-t0:.0f}s", flush=True)
33   -
34   -pipe.load_lora(pipe.dit, ModelConfig(model_id="lightx2v/Minimax-h3-Turbo",
35   - origin_file_pattern="minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"))
36   -
37   -def finite(x):
38   - if torch.is_tensor(x):
39   - return bool(torch.isfinite(x).all()), (float(x.abs().max()) if x.numel() and x.is_floating_point() else None)
40   - return True, None
41   -
42   -hits = [] # 第一个坏掉的模块
43   -seen = set()
44   -def mk(name):
45   - def hook(mod, inp, out):
46   - if name in seen: return
47   - ok_in = all(finite(t)[0] for t in inp if torch.is_tensor(t))
48   - outs = out if isinstance(out, (tuple, list)) else (out,)
49   - for o in outs:
50   - ok, mx = finite(o)
51   - if not ok:
52   - seen.add(name)
53   - hits.append((name, type(mod).__name__, ok_in, mx))
54   - return
55   - return hook
56   -
57   -handles = []
58   -for tag, mod in (("dit", pipe.dit), ("txt", pipe.text_encoder)):
59   - for n, m in mod.named_modules():
60   - if n: # 跳过根
61   - handles.append(m.register_forward_hook(mk(f"{tag}.{n}")))
62   -print(f"[hook] {len(handles)} 个模块已挂钩", flush=True)
63   -
64   -video, audio = pipe(prompt="一只橘猫在窗台上打哈欠，阳光洒进来",
65   - height=480, width=832, num_frames=124,
66   - num_inference_steps=4, seed=42, flow_shift=6.0)
67   -for h in handles: h.remove()
68   -
69   -print("\n===== 结果 =====", flush=True)
70   -for t, nm in (("video", video), ("audio", audio)):
71   - if torch.is_tensor(nm):
72   - print(f"{t}: shape={tuple(nm.shape)} dtype={nm.dtype} finite={bool(torch.isfinite(nm).all())} "
73   - f"absmax={float(nm.abs().max()) if nm.is_floating_point() else 'n/a'}")
74   - else:
75   - print(f"{t}: type={type(nm)}")
76   -print(f"\n第一批非有限输出的模块（共 {len(hits)}，只列前 15）：")
77   -for n, cls, ok_in, mx in hits[:15]:
78   - print(f" {n} [{cls}] 输入有限={ok_in} 输出absmax={mx}")
79   -if not hits:
80   - print(" 无 —— dit/text_encoder 内部全程有限，问题在 VAE 解码或后处理")
minimax-h3/scripts/diag3.py deleted
View file @ccf5db1
1   -"""定位 NaN 的产生位置：对 dit / text_encoder 挂 forward hook，
2   -找出第一个『输入有限、输出非有限』的模块。"""
3   -import os, sys, time, torch
4   -sys.argv = [sys.argv[0]]
5   -BASE = "/data/models/minimax-h3"
6   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION", "torch")
7   -os.environ.setdefault("DIFFSYNTH_MODEL_BASE_PATH", f"{BASE}/models")
8   -os.environ.setdefault("MODELSCOPE_CACHE", f"{BASE}/.mscache")
9   -
10   -from diffsynth.pipelines.minimax_h3_audio_video import MiniMaxH3Pipeline, ModelConfig
11   -
12   -DTYPE = torch.float16
13   -free_gb = torch.cuda.mem_get_info("cuda")[0] / 1024**3
14   -vram_limit = max(6.0, free_gb - 2.0)
15   -print(f"[env] free={free_gb:.1f}G vram_limit={vram_limit:.1f}G", flush=True)
16   -
17   -vc = dict(offload_dtype=DTYPE, offload_device="cpu", onload_dtype=DTYPE, onload_device="cpu",
18   - preparing_dtype=DTYPE, preparing_device="cuda",
19   - computation_dtype=DTYPE, computation_device="cuda")
20   -NF4 = "DiffSynth-Studio/MiniMax-H3-NF4"
21   -t0 = time.time()
22   -pipe = MiniMaxH3Pipeline.from_pretrained(
23   - torch_dtype=DTYPE, device="cuda",
24   - model_configs=[
25   - ModelConfig(model_id=NF4, origin_file_pattern="minimax-h3-fl2va-nf4.safetensors", **vc),
26   - ModelConfig(model_id=NF4, origin_file_pattern="minimax-h3-text-encoder-nf4.safetensors", **vc),
27   - ModelConfig(model_id=NF4, origin_file_pattern="video_vae_nf4.safetensors", **vc),
28   - ModelConfig(model_id=NF4, origin_file_pattern="audio_vae_nf4.safetensors", **vc),
29   - ],
30   - processor_config=ModelConfig(model_id="MiniMax/MiniMax-H3", origin_file_pattern="FL2VA/processor/"),
31   - vram_limit=vram_limit)
32   -print(f"[load] {time.time()-t0:.0f}s", flush=True)
33   -
34   -pipe.load_lora(pipe.dit, ModelConfig(model_id="lightx2v/Minimax-h3-Turbo",
35   - origin_file_pattern="minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"))
36   -
37   -# 与 t2va.py 一致的修复：整条路径（含 LoRA）抬到 fp32
38   -def _fp32_all(mod):
39   - mod.computation_dtype = torch.float32
40   - orig = mod.forward
41   - def fwd(x, *a, **kw):
42   - return orig(x.float(), *a, **kw).to(x.dtype)
43   - mod.forward = fwd
44   -_fp32_all(pipe.dit.condition_proj)
45   -print("[fix ] condition_proj 全路径 -> fp32", flush=True)
46   -
47   -def finite(x):
48   - if torch.is_tensor(x):
49   - return bool(torch.isfinite(x).all()), (float(x.abs().max()) if x.numel() and x.is_floating_point() else None)
50   - return True, None
51   -
52   -hits = [] # 第一个坏掉的模块
53   -seen = set()
54   -def mk(name):
55   - def hook(mod, inp, out):
56   - if name in seen: return
57   - ok_in = all(finite(t)[0] for t in inp if torch.is_tensor(t))
58   - outs = out if isinstance(out, (tuple, list)) else (out,)
59   - for o in outs:
60   - ok, mx = finite(o)
61   - if not ok:
62   - seen.add(name)
63   - ins=[float(t.abs().max()) for t in inp if torch.is_tensor(t) and t.is_floating_point() and t.numel()]
64   - hits.append((name, type(mod).__name__, ok_in, mx, max(ins) if ins else None))
65   - return
66   - return hook
67   -
68   -handles = []
69   -for tag, mod in (("dit", pipe.dit), ("txt", pipe.text_encoder)):
70   - for n, m in mod.named_modules():
71   - if n: # 跳过根
72   - handles.append(m.register_forward_hook(mk(f"{tag}.{n}")))
73   -print(f"[hook] {len(handles)} 个模块已挂钩", flush=True)
74   -
75   -video, audio = pipe(prompt="一只橘猫在窗台上打哈欠，阳光洒进来",
76   - height=480, width=832, num_frames=124,
77   - num_inference_steps=1, seed=42, flow_shift=6.0)
78   -for h in handles: h.remove()
79   -
80   -print("\n===== 结果 =====", flush=True)
81   -for t, nm in (("video", video), ("audio", audio)):
82   - if torch.is_tensor(nm):
83   - print(f"{t}: shape={tuple(nm.shape)} dtype={nm.dtype} finite={bool(torch.isfinite(nm).all())} "
84   - f"absmax={float(nm.abs().max()) if nm.is_floating_point() else 'n/a'}")
85   - else:
86   - print(f"{t}: type={type(nm)}")
87   -print(f"\n第一批非有限输出的模块（共 {len(hits)}，只列前 15）：")
88   -print(">>> 真源头（输入有限=True）：")
89   -for h in hits:
90   - if h[2]: print(f" ★ {h[0]} [{h[1]}] 输入absmax={h[4]} 输出absmax={h[3]}")
91   -print(">>> 下游受害者（前 5）：")
92   -for h in [x for x in hits if not x[2]][:5]:
93   - print(f" {h[0]} [{h[1]}]")
94   -if not hits:
95   - print(" 无 —— dit/text_encoder 内部全程有限，问题在 VAE 解码或后处理")
minimax-h3/scripts/diag4.py deleted
View file @ccf5db1
1   -"""用与实际失败运行完全一致的配置定位 NaN：同 prompt、同修复、同显存参数。"""
2   -import os, time, torch
3   -BASE="/data/models/minimax-h3"
4   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION","torch")
5   -os.environ.setdefault("DIFFSYNTH_MODEL_BASE_PATH", f"{BASE}/models")
6   -os.environ.setdefault("MODELSCOPE_CACHE", f"{BASE}/.mscache")
7   -os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF","expandable_segments:True")
8   -from diffsynth.pipelines.minimax_h3_audio_video import MiniMaxH3Pipeline, ModelConfig
9   -
10   -PROMPT = ("A girl is very happy, she is speaking in english: "
11   - "“I enjoy working with Diffsynth-Studio, it's a perfect framework.”")
12   -DT=torch.float16
13   -free=torch.cuda.mem_get_info("cuda")[0]/1024**3
14   -vram_limit=max(6.0, free-5.0) # 与 --vram-reserve 5 一致
15   -print(f"[env] free={free:.1f}G vram_limit={vram_limit:.1f}G", flush=True)
16   -vc=dict(offload_dtype=DT,offload_device="cpu",onload_dtype=DT,onload_device="cpu",
17   - preparing_dtype=DT,preparing_device="cuda",computation_dtype=DT,computation_device="cuda")
18   -NF4="DiffSynth-Studio/MiniMax-H3-NF4"
19   -pipe=MiniMaxH3Pipeline.from_pretrained(torch_dtype=DT,device="cuda",
20   - model_configs=[ModelConfig(model_id=NF4,origin_file_pattern=p,**vc) for p in
21   - ["minimax-h3-fl2va-nf4.safetensors","minimax-h3-text-encoder-nf4.safetensors",
22   - "video_vae_nf4.safetensors","audio_vae_nf4.safetensors"]],
23   - processor_config=ModelConfig(model_id="MiniMax/MiniMax-H3",origin_file_pattern="FL2VA/processor/"),
24   - vram_limit=vram_limit)
25   -pipe.load_lora(pipe.dit, ModelConfig(model_id="lightx2v/Minimax-h3-Turbo",
26   - origin_file_pattern="minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"))
27   -
28   -FP16_MAX=65504.0
29   -def _fix(mod, tag):
30   - mod.computation_dtype = torch.float32
31   - orig = mod.forward
32   - def fwd(x,*a,**kw):
33   - out = orig(x.float(),*a,**kw)
34   - print(f'[cp] fp32 out absmax={float(out.abs().max()):.1f} finite={bool(torch.isfinite(out).all())} dtype={out.dtype}', flush=True)
35   - return out
36   - mod.forward=fwd
37   -_fix(pipe.dit.condition_proj, "condition_proj")
38   -print("[fix ] condition_proj fp32+clamp 已装", flush=True)
39   -
40   -# 先单独查文本编码器输出——它是整条条件链的源头
41   -te_out={}
42   -def te_hook(m,i,o):
43   - t = o[0] if isinstance(o,(tuple,list)) else o
44   - if torch.is_tensor(t) and t.is_floating_point():
45   - te_out["absmax"]=float(t.abs().max()); te_out["finite"]=bool(torch.isfinite(t).all())
46   - te_out["shape"]=tuple(t.shape); te_out["dtype"]=str(t.dtype)
47   -h_te = pipe.text_encoder.register_forward_hook(te_hook)
48   -
49   -hits=[]; seen=set()
50   -def mk(name):
51   - def hook(mod, inp, out):
52   - if name in seen: return
53   - ok_in = all(bool(torch.isfinite(t).all()) for t in inp if torch.is_tensor(t) and t.is_floating_point())
54   - outs = out if isinstance(out,(tuple,list)) else (out,)
55   - for o in outs:
56   - if torch.is_tensor(o) and o.is_floating_point() and not torch.isfinite(o).all():
57   - seen.add(name)
58   - ins=[float(t.abs().max()) for t in inp if torch.is_tensor(t) and t.is_floating_point() and t.numel()]
59   - fin=torch.isfinite(o)
60   - hits.append((name, type(mod).__name__, ok_in,
61   - float(o[fin].abs().max()) if fin.any() else float("nan"),
62   - max(ins) if ins else None,
63   - float((~fin).float().mean())*100))
64   - return
65   - return hook
66   -handles=[]
67   -for tag,mod in (("dit",pipe.dit),("txt",pipe.text_encoder),
68   - ("vvae",pipe.video_vae),("avae",pipe.audio_vae)):
69   - for n,m in mod.named_modules():
70   - if n: handles.append(m.register_forward_hook(mk(f"{tag}.{n}")))
71   -print(f"[hook] {len(handles)} 个模块", flush=True)
72   -
73   -video, audio = pipe(prompt=PROMPT, height=480,width=832,num_frames=124,
74   - num_inference_steps=1, seed=0, flow_shift=6.0)
75   -for h in handles: h.remove()
76   -h_te.remove()
77   -
78   -print("\n===== 结果 =====")
79   -print("[文本编码器输出]", te_out)
80   -import numpy as np
81   -try:
82   - a=np.stack([np.asarray(f.convert("RGB"),dtype=np.float32) for f in video[::20]])
83   - print(f"[video] frames={len(video)} mean={a.mean():.4f} std={a.std():.4f}")
84   -except Exception as e:
85   - print("[video]", type(video), e)
86   -print(f"[audio] finite={bool(torch.isfinite(audio).all())}")
87   -print(f"\n>>> 真源头（输入有限=True），共 {len([h for h in hits if h[2]])} 个：")
88   -for h in hits:
89   - if h[2]: print(f" ★ {h[0]} [{h[1]}] 输入absmax={h[4]} 有限部分absmax={h[3]} 非有限占比={h[5]:.4f}%")
90   -print(f">>> 受害者总数 {len([h for h in hits if not h[2]])}，前 5：")
91   -for h in [x for x in hits if not x[2]][:5]: print(f" {h[0]} [{h[1]}]")
minimax-h3/scripts/download.py deleted
View file @ccf5db1
1   -"""Pre-download MiniMax-H3 NF4 weights via DiffSynth's own ModelConfig,
2   -so the on-disk layout matches exactly what the pipeline later resolves.
3   -
4   -已下过的会被 download_if_necessary() 跳过，重跑是幂等的。
5   -两个分区：FL2VA 收首末帧，Ref2VA 收任意多张参考图/参考视频，
6   -DiT 与 processor 各一套，VAE 和文本编码器共用。"""
7   -import os, time, traceback
8   -from diffsynth.core.loader import ModelConfig
9   -
10   -JOBS = [ # small first, so a load smoke-test can start early
11   - ("MiniMax/MiniMax-H3", "FL2VA/processor/"),
12   - ("DiffSynth-Studio/MiniMax-H3-NF4", "audio_vae_nf4.safetensors"),
13   - ("DiffSynth-Studio/MiniMax-H3-NF4", "video_vae_nf4.safetensors"),
14   - ("lightx2v/Minimax-h3-Turbo", "minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"),
15   - ("DiffSynth-Studio/MiniMax-H3-NF4", "minimax-h3-text-encoder-nf4.safetensors"),
16   - ("DiffSynth-Studio/MiniMax-H3-NF4", "minimax-h3-fl2va-nf4.safetensors"),
17   - # Ref2VA：参考图模式。Turbo LoRA 只有 v0.1，FL2V 那个是 v1.0 768p。
18   - ("MiniMax/MiniMax-H3", "Ref2VA/processor/"),
19   - ("lightx2v/Minimax-h3-Turbo", "minimax_h3_ref2v_turbo_4step_v0.1_bf16.safetensors"),
20   - ("DiffSynth-Studio/MiniMax-H3-NF4", "minimax-h3-ref2va-nf4.safetensors"),
21   - # 上面那个 bf16 版实测出噪点（二分见 docs/H3）。comfyui 版是另一套键名，试它能不能被认。
22   - ("lightx2v/Minimax-h3-Turbo", "minimax_h3_ref2v_turbo_4step_v0.1_comfyui_bf16.safetensors"),
23   -]
24   -
25   -for i, (mid, pat) in enumerate(JOBS, 1):
26   - t0 = time.time()
27   - print(f"[{i}/{len(JOBS)}] {mid} :: {pat}", flush=True)
28   - for attempt in range(1, 6):
29   - try:
30   - ModelConfig(model_id=mid, origin_file_pattern=pat).download_if_necessary()
31   - print(f" done in {time.time()-t0:.0f}s", flush=True)
32   - break
33   - except Exception:
34   - print(f" attempt {attempt} failed:\n{traceback.format_exc()}", flush=True)
35   - time.sleep(15)
36   - else:
37   - print(f" GIVING UP on {mid}::{pat}", flush=True)
38   -print("ALL DOWNLOADS FINISHED", flush=True)
minimax-h3/scripts/probe-attention-backend.py deleted
View file @ccf5db1
1   -import os, sys, torch
2   -from diffsynth.core.attention import attention_forward
3   -A = sys.modules[attention_forward.__module__]
4   -print("DIFFSYNTH_ATTENTION_IMPLEMENTATION env =", os.environ.get("DIFFSYNTH_ATTENTION_IMPLEMENTATION"))
5   -print("selected =", A.ATTENTION_IMPLEMENTATION,
6   - "| xformers=", A.XFORMERS_AVAILABLE, "flash2=", A.FLASH_ATTN_2_AVAILABLE,
7   - "flash3=", A.FLASH_ATTN_3_AVAILABLE, "flash4=", A.FLASH_ATTN_4_AVAILABLE, "sage=", A.SAGE_ATTN_AVAILABLE)
8   -dev="cuda:1"
9   -q=torch.randn(1,56,14100,128,device=dev,dtype=torch.float16)
10   -o=A.attention_forward(q,q,q)
11   -print("[OK] attention_forward fp16 S=14100:", tuple(o.shape), "finite=", bool(torch.isfinite(o).all()))
minimax-h3/scripts/probe-cp.py deleted
View file @ccf5db1
1   -"""摸清 dit.condition_proj 的溢出幅度：权重/输入/fp32 参考输出的量级。"""
2   -import os, time, torch
3   -BASE="/data/models/minimax-h3"
4   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION","torch")
5   -os.environ.setdefault("DIFFSYNTH_MODEL_BASE_PATH", f"{BASE}/models")
6   -os.environ.setdefault("MODELSCOPE_CACHE", f"{BASE}/.mscache")
7   -from diffsynth.pipelines.minimax_h3_audio_video import MiniMaxH3Pipeline, ModelConfig
8   -DT=torch.float16
9   -free=torch.cuda.mem_get_info("cuda")[0]/1024**3
10   -vc=dict(offload_dtype=DT,offload_device="cpu",onload_dtype=DT,onload_device="cpu",
11   - preparing_dtype=DT,preparing_device="cuda",computation_dtype=DT,computation_device="cuda")
12   -NF4="DiffSynth-Studio/MiniMax-H3-NF4"
13   -pipe=MiniMaxH3Pipeline.from_pretrained(torch_dtype=DT,device="cuda",
14   - model_configs=[ModelConfig(model_id=NF4,origin_file_pattern=p,**vc) for p in
15   - ["minimax-h3-fl2va-nf4.safetensors","minimax-h3-text-encoder-nf4.safetensors",
16   - "video_vae_nf4.safetensors","audio_vae_nf4.safetensors"]],
17   - processor_config=ModelConfig(model_id="MiniMax/MiniMax-H3",origin_file_pattern="FL2VA/processor/"),
18   - vram_limit=max(6.0,free-2.0))
19   -pipe.load_lora(pipe.dit, ModelConfig(model_id="lightx2v/Minimax-h3-Turbo",
20   - origin_file_pattern="minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"))
21   -
22   -cp = pipe.dit.condition_proj
23   -print("[cp] type:", type(cp).__name__)
24   -for n,p_ in cp.named_parameters(recurse=True):
25   - print(f" param {n}: shape={tuple(p_.shape)} dtype={p_.dtype} absmax={float(p_.abs().max()):.4g}")
26   -for n,b in cp.named_buffers(recurse=True):
27   - print(f" buf {n}: {tuple(b.shape)} {b.dtype}")
28   -
29   -cap={}
30   -def hook(m,i,o):
31   - x=i[0]
32   - cap["x"]=x.detach()
33   - cap["o"]=o.detach() if torch.is_tensor(o) else None
34   -h=cp.register_forward_hook(hook)
35   -try:
36   - pipe(prompt="测试", height=480,width=832,num_frames=124,
37   - num_inference_steps=1, seed=42, flow_shift=6.0)
38   -except Exception as e:
39   - print("[gen] 提前中断（预期）:", type(e).__name__, str(e)[:120])
40   -h.remove()
41   -
42   -x=cap.get("x")
43   -if x is None:
44   - print("!! 没抓到输入"); raise SystemExit(1)
45   -print(f"\n[输入] shape={tuple(x.shape)} dtype={x.dtype} absmax={float(x.abs().max()):.6g} "
46   - f"mean={float(x.float().mean()):.4g} std={float(x.float().std()):.4g} finite={bool(torch.isfinite(x).all())}")
47   -o=cap.get("o")
48   -if o is not None:
49   - fin=torch.isfinite(o)
50   - print(f"[fp16 输出] absmax={float(o[fin].abs().max()) if fin.any() else float('nan'):.6g} "
51   - f"非有限占比={100*(~fin).float().mean():.2f}%")
52   -
53   -# fp32 参考
54   -W=None;B=None
55   -for n,p_ in cp.named_parameters(recurse=True):
56   - if n.endswith("weight"): W=p_
57   - if n.endswith("bias"): B=p_
58   -if W is not None:
59   - ref=torch.nn.functional.linear(x.float(), W.float(), B.float() if B is not None else None)
60   - print(f"[fp32 参考] absmax={float(ref.abs().max()):.6g} (fp16 上限 65504)")
61   - print(f" → 超出 fp16 上限的元素占比 {100*(ref.abs()>65504).float().mean():.4f}%")
minimax-h3/scripts/probe-h3-shapes.py deleted
View file @ccf5db1
1   -import torch, time
2   -dev="cuda:1"
3   -torch.cuda.set_device(dev)
4   -from torch.nn.attention import SDPBackend, sdpa_kernel
5   -S, H, D = 14100, 56, 128 # real H3 shape @ 480x832x124f
6   -for dt in (torch.float16,):
7   - q=k=v=torch.randn(1,H,S,D,device=dev,dtype=dt)
8   - for be,nm in ((SDPBackend.EFFICIENT_ATTENTION,"EFFICIENT"),):
9   - try:
10   - with sdpa_kernel(be):
11   - torch.cuda.synchronize(); t0=time.time()
12   - o=torch.nn.functional.scaled_dot_product_attention(q,k,v)
13   - torch.cuda.synchronize()
14   - print(f"[OK ] SDPA {nm} fp16 S={S} H={H} D={D}: {o.shape} {time.time()-t0:.2f}s peak={torch.cuda.max_memory_allocated(dev)/2**30:.2f}G")
15   - except Exception as e:
16   - print(f"[ERR] SDPA {nm} fp16 D={D}: {type(e).__name__}: {str(e)[:200]}")
17   - del q,k,v
18   - torch.cuda.empty_cache(); torch.cuda.reset_peak_memory_stats(dev)
19   -
20   -# fp16 GEMM throughput on this card (H3 block-ish shape)
21   -a=torch.randn(14100,5376,device=dev,dtype=torch.float16); b=torch.randn(5376,28672,device=dev,dtype=torch.float16)
22   -for _ in range(2): c=a@b
23   -torch.cuda.synchronize(); t0=time.time()
24   -for _ in range(5): c=a@b
25   -torch.cuda.synchronize()
26   -fl=2*14100*5376*28672*5
27   -print(f"fp16 GEMM effective: {fl/(time.time()-t0)/1e12:.1f} TFLOPS")
28   -# fp16 overflow sanity on a deep-ish accumulation
29   -x=torch.randn(4096,4096,device=dev,dtype=torch.float16)*4
30   -y=x
31   -for i in range(20): y=torch.nn.functional.layer_norm(y@x/64,(4096,))
32   -print("fp16 deep-chain finite:", bool(torch.isfinite(y).all()))
minimax-h3/scripts/probe-nf4-fp16.py deleted
View file @ccf5db1
1   -import os, torch
2   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION","torch")
3   -import bitsandbytes as bnb
4   -print("bnb", bnb.__version__)
5   -dev="cuda:1"
6   -# --- NF4 quantize + forward in FP16 on sm_75 ---
7   -lin = torch.nn.Linear(5376, 14336, bias=False, dtype=torch.float16)
8   -q = bnb.nn.Linear4bit(5376, 14336, bias=False, compute_dtype=torch.float16, quant_type="nf4", compress_statistics=True)
9   -q.weight = bnb.nn.Params4bit(lin.weight.data, requires_grad=False, quant_type="nf4", compress_statistics=True)
10   -q = q.to(dev)
11   -x = torch.randn(1024, 5376, device=dev, dtype=torch.float16)
12   -y = q(x)
13   -ref = torch.nn.functional.linear(x, lin.weight.to(dev))
14   -err = (y.float()-ref.float()).abs().mean().item()/ref.float().abs().mean().item()
15   -print(f"[OK ] NF4 fp16 forward: out={tuple(y.shape)} dtype={y.dtype} finite={bool(torch.isfinite(y).all())} rel_err={err:.4f}")
16   -# --- prequantized round-trip (what DiffSynth actually does when loading .safetensors) ---
17   -qs = q.weight.quant_state.as_dict(packed=True)
18   -w2 = bnb.nn.Params4bit.from_prequantized(data=q.weight.data, quantized_stats={k:(v.to(dev) if torch.is_tensor(v) else v) for k,v in qs.items()}, requires_grad=False, device=dev)
19   -q2 = bnb.nn.Linear4bit(5376,14336,bias=False,compute_dtype=torch.float16,quant_type="nf4")
20   -q2.weight = w2; q2 = q2.to(dev)
21   -y2 = q2(x)
22   -print(f"[OK ] NF4 prequantized reload: match={torch.allclose(y,y2)} dtype={y2.dtype}")
23   -# --- DiffSynth attention backend selection ---
24   -import sys
25   -from diffsynth.core.attention import attention_forward
26   -A = sys.modules[attention_forward.__module__]
27   -print("ATTENTION_IMPLEMENTATION =", A.ATTENTION_IMPLEMENTATION,
28   - "| xformers_avail =", A.XFORMERS_AVAILABLE, "| flash2 =", A.FLASH_ATTN_2_AVAILABLE, "| sage =", A.SAGE_ATTN_AVAILABLE)
29   -o = A.attention_forward(*[torch.randn(1,56,4096,128,device=dev,dtype=torch.float16)]*3)
30   -print("[OK ] diffsynth attention_forward fp16:", tuple(o.shape), "finite=", bool(torch.isfinite(o).all()))
minimax-h3/scripts/probe-turing-caps.py deleted
View file @ccf5db1
1   -import torch, subprocess, sys, os
2   -print("torch", torch.__version__, "cuda", torch.version.cuda)
3   -print("arch_list", torch.cuda.get_arch_list())
4   -print("n_gpu", torch.cuda.device_count())
5   -for i in range(torch.cuda.device_count()):
6   - free, total = torch.cuda.mem_get_info(i)
7   - p = torch.cuda.get_device_properties(i)
8   - print(f" gpu{i} {p.name} sm_{p.major}{p.minor} free={free/2**30:.1f}G total={total/2**30:.1f}G")
9   -
10   -dev = "cuda:0"
11   -def t(name, fn):
12   - try:
13   - r = fn(); print(f"[OK ] {name}: {r}")
14   - except Exception as e:
15   - print(f"[ERR] {name}: {type(e).__name__}: {str(e)[:180]}")
16   -
17   -t("fp16 matmul", lambda: (torch.randn(512,512,device=dev,dtype=torch.float16) @ torch.randn(512,512,device=dev,dtype=torch.float16)).float().abs().mean().item())
18   -t("bf16 matmul", lambda: (torch.randn(512,512,device=dev,dtype=torch.bfloat16) @ torch.randn(512,512,device=dev,dtype=torch.bfloat16)).float().abs().mean().item())
19   -t("bf16 layernorm", lambda: torch.nn.functional.layer_norm(torch.randn(8,512,device=dev,dtype=torch.bfloat16),(512,)).float().abs().mean().item())
20   -
21   -from torch.nn.attention import SDPBackend, sdpa_kernel
22   -q=lambda dt: torch.randn(1,8,1024,64,device=dev,dtype=dt)
23   -for dt in (torch.float16, torch.bfloat16):
24   - for be in (SDPBackend.FLASH_ATTENTION, SDPBackend.EFFICIENT_ATTENTION, SDPBackend.MATH):
25   - def f(dt=dt,be=be):
26   - with sdpa_kernel(be):
27   - return tuple(torch.nn.functional.scaled_dot_product_attention(q(dt),q(dt),q(dt)).shape)
28   - t(f"SDPA {str(dt).split('.')[-1]:9s} {be.name}", f)
29   -def auto():
30   - return tuple(torch.nn.functional.scaled_dot_product_attention(q(torch.float16),q(torch.float16),q(torch.float16)).shape)
31   -t("SDPA fp16 AUTO", auto)
32   -
33   -print("--- installed pkgs of interest ---")
34   -import importlib.metadata as md
35   -for name in ["transformers","accelerate","diffusers","bitsandbytes","torchao","safetensors","einops","modelscope","av","torchaudio","torchcodec","librosa","peft","xformers","flash_attn","sageattention","imageio","imageio-ffmpeg","numpy"]:
36   - try: print(f" {name}=={md.version(name)}")
37   - except Exception: print(f" {name}: NOT INSTALLED")
38   -print("--- ffmpeg ---")
39   -print(subprocess.run(["bash","-lc","ffmpeg -version 2>&1|head -1; which ffmpeg"],capture_output=True,text=True).stdout)
minimax-h3/scripts/probe2.py deleted
View file @ccf5db1
1   -"""量清楚 condition_proj 的 fp32 真值幅度：决定是局部修还是整条路径抬 fp32。"""
2   -import os, torch, torch.nn.functional as F
3   -BASE="/data/models/minimax-h3"
4   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION","torch")
5   -os.environ.setdefault("DIFFSYNTH_MODEL_BASE_PATH", f"{BASE}/models")
6   -os.environ.setdefault("MODELSCOPE_CACHE", f"{BASE}/.mscache")
7   -from diffsynth.pipelines.minimax_h3_audio_video import MiniMaxH3Pipeline, ModelConfig
8   -DT=torch.float16
9   -free=torch.cuda.mem_get_info("cuda")[0]/1024**3
10   -vc=dict(offload_dtype=DT,offload_device="cpu",onload_dtype=DT,onload_device="cpu",
11   - preparing_dtype=DT,preparing_device="cuda",computation_dtype=DT,computation_device="cuda")
12   -NF4="DiffSynth-Studio/MiniMax-H3-NF4"
13   -pipe=MiniMaxH3Pipeline.from_pretrained(torch_dtype=DT,device="cuda",
14   - model_configs=[ModelConfig(model_id=NF4,origin_file_pattern=p,**vc) for p in
15   - ["minimax-h3-fl2va-nf4.safetensors","minimax-h3-text-encoder-nf4.safetensors",
16   - "video_vae_nf4.safetensors","audio_vae_nf4.safetensors"]],
17   - processor_config=ModelConfig(model_id="MiniMax/MiniMax-H3",origin_file_pattern="FL2VA/processor/"),
18   - vram_limit=max(6.0,free-2.0))
19   -pipe.load_lora(pipe.dit, ModelConfig(model_id="lightx2v/Minimax-h3-Turbo",
20   - origin_file_pattern="minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"))
21   -
22   -cp = pipe.dit.condition_proj
23   -class Stop(Exception): pass
24   -res={}
25   -orig_lf = cp.linear_forward
26   -orig_lora = cp.lora_forward
27   -def lf(x, weight, bias):
28   - o32 = F.linear(x.float(), weight.float(), bias.float() if bias is not None else None)
29   - res["x_absmax"]=float(x.abs().max()); res["x_dtype"]=str(x.dtype)
30   - res["lin32_absmax"]=float(o32.abs().max())
31   - res["lin32_over_fp16"]=float((o32.abs()>65504).float().mean())*100
32   - res["lin32"]=o32
33   - return o32
34   -def lora(x, out):
35   - o = out
36   - for A,B in zip(cp.lora_A_weights, cp.lora_B_weights):
37   - o = o + x.float() @ A.T.to(device=x.device,dtype=torch.float32) @ B.T.to(device=x.device,dtype=torch.float32)
38   - res["n_lora"]=len(cp.lora_A_weights)
39   - res["final32_absmax"]=float(o.abs().max())
40   - res["final32_over_fp16"]=float((o.abs()>65504).float().mean())*100
41   - res["p999"]=float(torch.quantile(o.abs().flatten().float(), 0.999))
42   - raise Stop()
43   -cp.linear_forward=lf; cp.lora_forward=lora
44   -try:
45   - pipe(prompt="一只橘猫在窗台上打哈欠", height=480,width=832,num_frames=124,
46   - num_inference_steps=1, seed=42, flow_shift=6.0)
47   -except Stop:
48   - pass
49   -print("\n===== condition_proj fp32 真值 =====")
50   -for k in ["x_dtype","x_absmax","lin32_absmax","lin32_over_fp16","n_lora","final32_absmax","final32_over_fp16","p999"]:
51   - if k in res: print(f" {k:20s} = {res[k]}")
52   -print(f" fp16 上限 = 65504")
minimax-h3/scripts/run.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# MiniMax-H3 FL2VA NF4 launcher. usage: ./run.sh <GPU_ID> [args for t2va.py ...]
3   -# ./run.sh 1 # turbo 4-step, 480x832x124f
4   -# ./run.sh 1 --no-turbo --steps 50 # full quality
5   -# ./run.sh 2 --prompt "..." --seed 7
6   -set -euo pipefail
7   -B=/data/models/minimax-h3
8   -GPU="${1:-1}"; shift || true
9   -
10   -export CUDA_VISIBLE_DEVICES="$GPU"
11   -export DIFFSYNTH_ATTENTION_IMPLEMENTATION=torch # sm_75: no flash/sage; pin instead of auto-picking xformers
12   -export DIFFSYNTH_MODEL_BASE_PATH="$B/models"
13   -export MODELSCOPE_CACHE="$B/.mscache"
14   -export PYTHONUNBUFFERED=1
15   -# NOTE: deliberately NOT setting PYTHONNOUSERSITE -- the venv's site-packages already
16   -# precedes ~/.local in sys.path, so our bitsandbytes 0.50.1 shadows the broken 0.45.1 there.
17   -
18   -# GPU0/1 sit on NUMA0, GPU2/3 on NUMA1 -- keep the CPU-offloaded weights on the near node.
19   -case "$GPU" in 0|1) NODE=0 ;; 2|3) NODE=1 ;; *) NODE="" ;; esac
20   -BIND=(); if [ -n "$NODE" ] && command -v numactl >/dev/null 2>&1; then BIND=(numactl --cpunodebind="$NODE" --membind="$NODE"); fi
21   -
22   -LOG="$B/logs/gpu${GPU}_$(date +%Y%m%d-%H%M%S).log"
23   -echo "[run] GPU=$GPU numa=${NODE:-none} log=$LOG"
24   -"${BIND[@]}" "$B/venv/bin/python" "$B/scripts/t2va.py" "$@" 2>&1 | tee "$LOG"
minimax-h3/scripts/t2va.py deleted
View file @ccf5db1
1   -#!/usr/bin/env python
2   -"""MiniMax-H3 FL2VA (NF4) Text -> Video+Audio on RTX 2080 Ti (Turing / sm_75).
3   -
4   -Turing deltas vs the official example (all deliberate):
5   - * FP16 everywhere, never BF16 -- sm_75 has no bf16 SDPA kernel at all
6   - (EFFICIENT and FLASH both report "No available kernel"), so bf16 silently
7   - falls back to the MATH backend and OOMs on a ~14k-token sequence.
8   - * DIFFSYNTH_ATTENTION_IMPLEMENTATION=torch -- FlashAttention 2/3/4 and
9   - SageAttention are sm_80+. xformers works here but would be auto-selected
10   - ahead of torch; pin the backend so runs are reproducible.
11   - * vram_limit from mem_get_info()[0] (FREE) not [1] (TOTAL) -- other processes
12   - share these GPUs.
13   - * offload to "cpu", never "disk" -- /data is a 7200rpm HDD (184 MB/s).
14   -"""
15   -import os, sys, time, argparse
16   -
17   -BASE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
18   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION", "torch")
19   -os.environ.setdefault("DIFFSYNTH_MODEL_BASE_PATH", os.path.join(BASE, "models"))
20   -
21   -p = argparse.ArgumentParser()
22   -p.add_argument("--prompt", default="A girl is very happy, she is speaking in english: "
23   - "“I enjoy working with Diffsynth-Studio, it's a perfect framework.”")
24   -p.add_argument("--height", type=int, default=480)
25   -p.add_argument("--width", type=int, default=832)
26   -p.add_argument("--frames", type=int, default=124)
27   -p.add_argument("--steps", type=int, default=4)
28   -p.add_argument("--flow-shift", type=float, default=None, help="default 6.0 with turbo, 12.0 without")
29   -p.add_argument("--seed", type=int, default=0)
30   -p.add_argument("--turbo", action="store_true", default=True)
31   -p.add_argument("--no-turbo", dest="turbo", action="store_false")
32   -p.add_argument("--dtype", choices=["fp32","fp16"], default="fp32",
33   - help="fp32=唯一能在 sm_75 上出片的选择（默认）；fp16 只用于复现全黑故障")
34   -p.add_argument("--no-fp32-residual", dest="fp32_residual", action="store_false",
35   - help="关闭 DiT 残差流的 fp32 兜底（默认开启；关掉在 sm_75 上会出全黑视频）")
36   -p.add_argument("--no-fp32-cond", dest="fp32_cond", action="store_false",
37   - help="关闭 condition_proj 的 fp32 兜底（默认开启；关掉在 sm_75 上会出全黑视频）")
38   -p.add_argument("--fp32-accum", action="store_true",
39   - help="disable fp16 reduced-precision reduction (~2x slower, use if output is NaN/artifacted)")
40   -p.add_argument("--vram-reserve", type=float, default=None,
41   - help="留给激活的显存(GB)。默认按 dtype 自适应：fp32=14（实测全分辨率峰值 12.2G），fp16=5")
42   -p.add_argument("--out", default=None)
43   -args = p.parse_args()
44   -
45   -import torch
46   -if args.fp32_accum:
47   - torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction = False
48   -
49   -from diffsynth.pipelines.minimax_h3_audio_video import MiniMaxH3Pipeline, ModelConfig
50   -from diffsynth.utils.data.audio_video import write_video_audio
51   -
52   -# dtype 决定这条线能不能出片。实测(2026-08-18, sm_75, 448x256x28f, 唯一变量是 dtype)：
53   -# fp32 -> 视频 std=50.6、音频 finite ✅ fp16 -> 124 帧纯黑、音频 NaN ❌
54   -# 原因是 fp16 的动态范围装不下这个 bf16 训练的模型：dit.blocks.0 输入 absmax 89
55   -# 已放大到 38176，50 层残差累积后必然突破 fp16 上限 65504。
56   -# bf16 在 sm_75 上不可用（无硬件支持），所以 fp32 是这张卡上唯一能出片的选择。
57   -# 保留 --dtype fp16 只为复现/对照，不要用它出片。
58   -DTYPE = {"fp32": torch.float32, "fp16": torch.float16}[args.dtype]
59   -free_gb = torch.cuda.mem_get_info("cuda")[0] / 1024**3 # [0]=free, official example wrongly uses [1]=total
60   -if args.vram_reserve is None:
61   - # fp32 的激活是 fp16 的两倍，权重要多让位。实测 832x480x124f fp32：
62   - # vram_limit 7.3G 时峰值 12.2G，跑通；vram_limit 19.3G 时 OOM。
63   - args.vram_reserve = 14.0 if DTYPE is torch.float32 else 5.0
64   -vram_limit = max(4.0, free_gb - args.vram_reserve)
65   -if vram_limit + 1.0 > free_gb:
66   - print(f"[warn] 空闲显存仅 {free_gb:.1f}G，vram_limit={vram_limit:.1f}G 几乎没有余量，"
67   - f"很可能 OOM。先停掉占显存的服务（见 qwen38-deploy/RESTORE-GPU.md）", flush=True)
68   -
69   -prop = torch.cuda.get_device_properties(0)
70   -print(f"[env] GPU={prop.name} sm_{prop.major}{prop.minor} free={free_gb:.1f}G vram_limit={vram_limit:.1f}G", flush=True)
71   -print(f"[env] dtype={DTYPE} attention={os.environ['DIFFSYNTH_ATTENTION_IMPLEMENTATION']} "
72   - f"fp16_reduced_accum={torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction}", flush=True)
73   -assert prop.major == 7, "this script is tuned for Turing; re-check dtype choices on other archs"
74   -
75   -vram_config = dict(
76   - offload_dtype=DTYPE, offload_device="cpu", # not "disk": /data is a spinning HDD
77   - onload_dtype=DTYPE, onload_device="cpu",
78   - preparing_dtype=DTYPE, preparing_device="cuda",
79   - computation_dtype=DTYPE, computation_device="cuda",
80   -)
81   -NF4 = "DiffSynth-Studio/MiniMax-H3-NF4"
82   -
83   -t0 = time.time()
84   -pipe = MiniMaxH3Pipeline.from_pretrained(
85   - torch_dtype=DTYPE, device="cuda",
86   - model_configs=[
87   - ModelConfig(model_id=NF4, origin_file_pattern="minimax-h3-fl2va-nf4.safetensors", **vram_config),
88   - ModelConfig(model_id=NF4, origin_file_pattern="minimax-h3-text-encoder-nf4.safetensors", **vram_config),
89   - ModelConfig(model_id=NF4, origin_file_pattern="video_vae_nf4.safetensors", **vram_config),
90   - ModelConfig(model_id=NF4, origin_file_pattern="audio_vae_nf4.safetensors", **vram_config),
91   - ],
92   - processor_config=ModelConfig(model_id="MiniMax/MiniMax-H3", origin_file_pattern="FL2VA/processor/"),
93   - vram_limit=vram_limit,
94   -)
95   -print(f"[load] pipeline ready in {time.time()-t0:.0f}s", flush=True)
96   -
97   -if args.turbo:
98   - # LoRA rides on the NF4 layers: AutoWrappedQuantizedModule inherits LoRAHotLoadMixin,
99   - # so lora_forward() adds x@A@B to the quantized output -- no base dequantisation needed.
100   - pipe.load_lora(pipe.dit, ModelConfig(
101   - model_id="lightx2v/Minimax-h3-Turbo",
102   - origin_file_pattern="minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"))
103   -# --- sm_75 必需：condition_proj 在 fp16 下累加溢出 -> inf -> 全管线 NaN -> 全黑视频 ---
104   -# 实测(2026-08-18)：该层输入 absmax≈17808、权重 absmax≈4.66、K=5120，
105   -# fp16 累加器(上限 65504)有 0.04% 的输出溢出成 inf，随后污染下游 999 个模块。
106   -# 它只是 (1,5120)x(5376,5120) 的一次投影，改走 fp32 的算力开销可忽略。
107   -# 注意：--fp32-accum 对此无效——溢出发生在累加器量级，不是 reduced-precision reduction。
108   -def _force_fp32_linear(mod, tag):
109   - """该层在 fp32 里算，且**输出保持 fp32**流入 token_refiner。
110   -
111   - 实测(2026-08-18, sm_75)：
112   - 文本编码器输出 absmax 15328（有限、健康，源头不在它）；
113   - condition_proj 的 fp32 真值 absmax 可达 79554，而 fp16 上限 65504。
114   - 产生的 inf 会污染下游 2985 个模块，最终 124 帧纯黑（且原脚本退出码为 0）。
115   - 根因是 Turing 无 bf16：模型按 bf16 训练（bf16 有 fp32 的动态范围），
116   - fp16 装不下这条条件路径。
117   -
118   - 走过的四条弯路，都记下来免得后人重走：
119   - 1) 替换整个 forward —— 绕过 preparing/onload 换入机制。
120   - 2) 只换 linear_forward、最后仍 `.to(fp16)` —— 无效：fp32 算得对，
121   - 溢出发生在那次类型转换上。自检若只查转换前的张量会永远显示"正常"。
122   - 3) 钳位到 65504 再降回 fp16 —— **反而更糟**：token_refiner.blocks.0 是
123   - `h = x + attn(norm1(x))`，x 恰好等于 fp16 最大可表示值时，
124   - 再加任何正数立刻变 inf（实测 3.45% 非有限）。钳位不留余量等于自造故障。
125   - 4) 输出保持 fp32 但 vram_limit=19.3G —— 数值对了但 CUDA OOM。
126   - 配 `--vram-reserve 5`(vram_limit 16.3G) + PYTORCH_ALLOC_CONF=expandable_segments:True
127   - 后峰值 17.2G，有余量。
128   -
129   - 库里 _embed() 在 token_refiner 之后本来就有 `text_embed.to(dtype)`，
130   - 那时已归一化、量级回落，那次转换是安全的。
131   - 下游 RMSNorm 会因 dtype 不一致发性能警告（非错误），可忽略。
132   - """
133   - mod.computation_dtype = torch.float32
134   - orig = mod.forward
135   - def fwd(x, *a, **kw):
136   - out = orig(x.float(), *a, **kw)
137   - if not torch.isfinite(out).all():
138   - print(f"[warn] {tag} 即使 fp32 仍非有限", flush=True)
139   - return out # 保持 fp32：既不降回也不钳位
140   - mod.forward = fwd
141   - return mod
142   -
143   -# --- sm_75 必需 #2：DiT 残差流保持 fp32 ---
144   -# 实测(2026-08-18)：dit.blocks.0 输入 absmax 89.25 → 输出 38176，且有极少量元素溢出。
145   -# 50 个 block × 每个 2 次残差相加 = 100 个溢出点，累积后必然爆 fp16 的 65504。
146   -#
147   -# 病灶与 condition_proj 同构，见 minimax_h3_dit.py:61-67：
148   -# def _modulate_gate(x, gate, other, indices):
149   -# return (x + gate.index_select(0, indices) * other).to(x.dtype)
150   -# ^^^^^^^^^^ 提升到 fp32 算完又降回 fp16
151   -# 库作者自己的注释也写了 "index_select on the AdaLN params can promote the expression"，
152   -# 但把结果降回 fp16 恰恰丢掉了提升带来的动态范围。
153   -#
154   -# 做法是标准混合精度：**累加器(残差流)fp32，喂给子模块的张量仍 fp16**。
155   -# _modulate_gate -> 返回 fp32（它的输出就是残差流，下游是 RMSNorm，容忍混合 dtype）
156   -# _modulate_scale_shift -> 显式返回 fp16（它的输出喂给 attn/mlp 的 Linear4bit，必须是 fp16）
157   -# 额外显存约 300 MB（残差流 (seq,5376) 一份 fp32），实测峰值仍在 16 GB 以内。
158   -def _patch_dit_residual_fp32():
159   - from diffsynth.models import minimax_h3_dit as _m
160   -
161   - def _mss(x, shift, scale, indices):
162   - return (x.float() * (1.0 + scale.index_select(0, indices).float())
163   - + shift.index_select(0, indices).float()).to(torch.float16)
164   -
165   - def _mg(x, gate, other, indices):
166   - # 不降回 fp16：这一份就是残差流
167   - return x.float() + gate.index_select(0, indices).float() * other.float()
168   -
169   - _m._modulate_scale_shift = _mss
170   - _m._modulate_gate = _mg
171   - print("[fix ] DiT 残差流已切到 fp32（_modulate_gate 不再降回 fp16）", flush=True)
172   -
173   -# 这两个补丁是 fp16 专用的挽救措施（最终证明救不回来，见 README）。
174   -# fp32 下必须失效，否则强制 .to(float16) 会与 fp32 权重冲突：
175   -# RuntimeError: mat1 and mat2 must have the same dtype, but got Half and Float
176   -if args.fp32_residual and DTYPE is torch.float16:
177   - _patch_dit_residual_fp32()
178   -
179   -if args.fp32_cond and DTYPE is torch.float16:
180   - _force_fp32_linear(pipe.dit.condition_proj, "dit.condition_proj")
181   - print("[fix ] dit.condition_proj 已切到 fp32 计算（规避 sm_75 fp16 累加溢出）", flush=True)
182   -
183   -flow_shift = args.flow_shift if args.flow_shift is not None else (6.0 if args.turbo else 12.0)
184   -
185   -print(f"[gen ] {args.width}x{args.height} {args.frames}f steps={args.steps} "
186   - f"turbo={args.turbo} flow_shift={flow_shift} seed={args.seed}", flush=True)
187   -t1 = time.time()
188   -video, audio = pipe(
189   - prompt=args.prompt,
190   - height=args.height, width=args.width, num_frames=args.frames,
191   - num_inference_steps=args.steps, seed=args.seed, flow_shift=flow_shift,
192   -)
193   -gen_s = time.time() - t1
194   -
195   -import torch as _t
196   -_bad = []
197   -if not _t.isfinite(audio if _t.is_tensor(audio) else _t.tensor(0.)).all():
198   - _bad.append("audio 含非有限值")
199   -# video 是 PIL 帧列表；原脚本从不检查它，导致全黑视频也返回 0 —— 实测踩过
200   -def _video_stats(v):
201   - import numpy as _np
202   - if _t.is_tensor(v):
203   - a = v.float()
204   - return float(a.mean()), float(a.std()), bool(_t.isfinite(a).all())
205   - try:
206   - arrs = [_np.asarray(f.convert("RGB"), dtype=_np.float32) for f in v[:: max(1, len(v)//8)]]
207   - a = _np.stack(arrs)
208   - return float(a.mean()), float(a.std()), True
209   - except Exception:
210   - return None, None, True
211   -_mean, _std, _fin = _video_stats(video)
212   -if not _fin:
213   - _bad.append("video 含非有限值")
214   -if _std is not None and _std < 1.0:
215   - _bad.append(f"video 近乎纯色 (std={_std:.3f}, mean={_mean:.3f})")
216   -if _bad:
217   - print("[FAIL] " + "；".join(_bad), flush=True)
218   -
219   -out = args.out or os.path.join(BASE, "outputs", f"t2va_{time.strftime('%Y%m%d-%H%M%S')}.mp4")
220   -os.makedirs(os.path.dirname(out), exist_ok=True)
221   -write_video_audio(video=video, audio=audio, output_path=out, fps=24, audio_sample_rate=32000)
222   -
223   -print(f"[done] generation {gen_s:.0f}s ({gen_s/max(args.steps,1):.1f}s/step), "
224   - f"peak VRAM {torch.cuda.max_memory_allocated()/1024**3:.1f}G", flush=True)
225   -print(f"[out ] {out} ({os.path.getsize(out)/1024**2:.1f} MB)", flush=True)
226   -if _bad:
227   - sys.exit(3) # 不要用退出码 0 报告一个坏产物
minimax-h3/scripts/test-fp32.py deleted
View file @ccf5db1
1   -"""关键对照实验：小分辨率下 fp32 端到端能否出片。
2   -若 fp32 出片而 fp16 全黑 → 确认是动态范围问题，而非模型/权重/流程问题。
3   -小分辨率是为了让 fp32 装得下（seq_len 从 ~14100 降到 ~800）。"""
4   -import os, sys, time, torch, numpy as np
5   -BASE="/data/models/minimax-h3"
6   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION","torch")
7   -os.environ.setdefault("DIFFSYNTH_MODEL_BASE_PATH", f"{BASE}/models")
8   -os.environ.setdefault("MODELSCOPE_CACHE", f"{BASE}/.mscache")
9   -os.environ.setdefault("PYTORCH_ALLOC_CONF","expandable_segments:True")
10   -from diffsynth.pipelines.minimax_h3_audio_video import MiniMaxH3Pipeline, ModelConfig
11   -
12   -DT = torch.float32 if os.environ.get("TEST_DTYPE","fp32")=="fp32" else torch.float16
13   -H = int(os.environ.get("TEST_H", 256)); W = int(os.environ.get("TEST_W", 448)); F_ = int(os.environ.get("TEST_F", 28))
14   -print(f"[cfg] dtype={DT} {W}x{H} {F_}f", flush=True)
15   -free=torch.cuda.mem_get_info("cuda")[0]/1024**3
16   -vc=dict(offload_dtype=DT,offload_device="cpu",onload_dtype=DT,onload_device="cpu",
17   - preparing_dtype=DT,preparing_device="cuda",computation_dtype=DT,computation_device="cuda")
18   -NF4="DiffSynth-Studio/MiniMax-H3-NF4"
19   -t0=time.time()
20   -pipe=MiniMaxH3Pipeline.from_pretrained(torch_dtype=DT,device="cuda",
21   - model_configs=[ModelConfig(model_id=NF4,origin_file_pattern=p,**vc) for p in
22   - ["minimax-h3-fl2va-nf4.safetensors","minimax-h3-text-encoder-nf4.safetensors",
23   - "video_vae_nf4.safetensors","audio_vae_nf4.safetensors"]],
24   - processor_config=ModelConfig(model_id="MiniMax/MiniMax-H3",origin_file_pattern="FL2VA/processor/"),
25   - vram_limit=max(4.0,free-float(os.environ.get("TEST_RESERVE",5))))
26   -print(f"[load] {time.time()-t0:.0f}s", flush=True)
27   -pipe.load_lora(pipe.dit, ModelConfig(model_id="lightx2v/Minimax-h3-Turbo",
28   - origin_file_pattern="minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"))
29   -
30   -PROMPT=("A girl is very happy, she is speaking in english: "
31   - "“I enjoy working with Diffsynth-Studio, it's a perfect framework.”")
32   -t1=time.time()
33   -video,audio = pipe(prompt=PROMPT,height=H,width=W,num_frames=F_,
34   - num_inference_steps=4,seed=0,flow_shift=6.0)
35   -print(f"[gen ] {time.time()-t1:.0f}s peak={torch.cuda.max_memory_allocated()/1024**3:.1f}G", flush=True)
36   -a=np.stack([np.asarray(f.convert("RGB"),dtype=np.float32) for f in video[::5]])
37   -print(f"[video] frames={len(video)} mean={a.mean():.4f} std={a.std():.4f} max={a.max():.1f}", flush=True)
38   -print(f"[audio] finite={bool(torch.isfinite(audio).all())}", flush=True)
39   -print("[VERDICT] " + ("出片正常 ✅" if a.std()>1.0 else "仍为纯色 ❌"), flush=True)
minimax-h3/scripts/test-patch.py deleted
View file @ccf5db1
1   -import os, torch, torch.nn.functional as F
2   -BASE="/data/models/minimax-h3"
3   -os.environ.setdefault("DIFFSYNTH_ATTENTION_IMPLEMENTATION","torch")
4   -os.environ.setdefault("DIFFSYNTH_MODEL_BASE_PATH", f"{BASE}/models")
5   -os.environ.setdefault("MODELSCOPE_CACHE", f"{BASE}/.mscache")
6   -from diffsynth.pipelines.minimax_h3_audio_video import MiniMaxH3Pipeline, ModelConfig
7   -DT=torch.float16
8   -free=torch.cuda.mem_get_info("cuda")[0]/1024**3
9   -vc=dict(offload_dtype=DT,offload_device="cpu",onload_dtype=DT,onload_device="cpu",
10   - preparing_dtype=DT,preparing_device="cuda",computation_dtype=DT,computation_device="cuda")
11   -NF4="DiffSynth-Studio/MiniMax-H3-NF4"
12   -pipe=MiniMaxH3Pipeline.from_pretrained(torch_dtype=DT,device="cuda",
13   - model_configs=[ModelConfig(model_id=NF4,origin_file_pattern=p,**vc) for p in
14   - ["minimax-h3-fl2va-nf4.safetensors","minimax-h3-text-encoder-nf4.safetensors",
15   - "video_vae_nf4.safetensors","audio_vae_nf4.safetensors"]],
16   - processor_config=ModelConfig(model_id="MiniMax/MiniMax-H3",origin_file_pattern="FL2VA/processor/"),
17   - vram_limit=max(6.0,free-2.0))
18   -pipe.load_lora(pipe.dit, ModelConfig(model_id="lightx2v/Minimax-h3-Turbo",
19   - origin_file_pattern="minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors"))
20   -
21   -cp = pipe.dit.condition_proj
22   -stats = {"calls":0, "inf_out":0}
23   -orig_lf = cp.linear_forward # 改 linear_forward 而不是 forward：
24   - # 这样 onload/preparing/LoRA 全套机制保持不变
25   -def lf(x, weight, bias):
26   - stats["calls"] += 1
27   - out = F.linear(x.float(), weight.float(), bias.float() if bias is not None else None)
28   - if not torch.isfinite(out).all(): stats["inf_out"] += 1
29   - return out.to(x.dtype)
30   -cp.linear_forward = lf
31   -print("[patch] linear_forward 已替换", flush=True)
32   -
33   -video, audio = pipe(prompt="一只橘猫在窗台上打哈欠", height=480, width=832,
34   - num_frames=124, num_inference_steps=1, seed=42, flow_shift=6.0)
35   -print(f"[stat] condition_proj 被调用 {stats['calls']} 次，其中 fp32 仍非有限 {stats['inf_out']} 次", flush=True)
36   -import numpy as np
37   -a=np.stack([np.asarray(f.convert("RGB"),dtype=np.float32) for f in video[::20]])
38   -print(f"[video] frames={len(video)} mean={a.mean():.4f} std={a.std():.4f} max={a.max():.1f}", flush=True)
39   -print(f"[audio] finite={bool(torch.isfinite(audio).all())} absmax={float(audio.abs().max()):.4g}", flush=True)
minimax-h3/scripts/verify.py deleted
View file @ccf5db1
1   -"""Verify every downloaded weight: exact byte size vs ModelScope, and a safetensors header parse."""
2   -import os, sys, json, struct, urllib.request
3   -
4   -BASE = os.environ.get("DIFFSYNTH_MODEL_BASE_PATH", "/data/models/minimax-h3/models")
5   -WANT = {
6   - "DiffSynth-Studio/MiniMax-H3-NF4": ["minimax-h3-fl2va-nf4.safetensors",
7   - "minimax-h3-ref2va-nf4.safetensors",
8   - "minimax-h3-text-encoder-nf4.safetensors",
9   - "video_vae_nf4.safetensors", "audio_vae_nf4.safetensors"],
10   - "lightx2v/Minimax-h3-Turbo": ["minimax_h3_fl2v_turbo_4step_v1.0_768p_bf16.safetensors",
11   - "minimax_h3_ref2v_turbo_4step_v0.1_bf16.safetensors"],
12   -}
13   -PROCESSORS = ["MiniMax/MiniMax-H3/FL2VA/processor", "MiniMax/MiniMax-H3/Ref2VA/processor"]
14   -
15   -def remote_sizes(mid):
16   - u = f"https://www.modelscope.cn/api/v1/models/{mid}/repo/files?Recursive=true"
17   - d = json.load(urllib.request.urlopen(u, timeout=60))
18   - return {f["Path"]: f.get("Size", 0) for f in d.get("Data", {}).get("Files", []) if f.get("Type") == "blob"}
19   -
20   -def header_ok(path):
21   - with open(path, "rb") as f:
22   - n = struct.unpack("<Q", f.read(8))[0]
23   - if not (0 < n < 200_000_000): return False, f"bad header len {n}"
24   - hdr = json.loads(f.read(n))
25   - end = max(v["data_offsets"][1] for k, v in hdr.items() if k != "__metadata__")
26   - expect = 8 + n + end
27   - actual = os.path.getsize(path)
28   - return expect == actual, f"tensors={len(hdr)} expect={expect} actual={actual}"
29   -
30   -bad = 0
31   -for mid, files in WANT.items():
32   - rs = remote_sizes(mid)
33   - for fn in files:
34   - p = os.path.join(BASE, mid, fn)
35   - if not os.path.exists(p):
36   - print(f"MISSING {mid}/{fn}"); bad += 1; continue
37   - got, want = os.path.getsize(p), rs.get(fn, -1)
38   - size_ok = (got == want)
39   - ok, detail = header_ok(p)
40   - flag = "OK " if (size_ok and ok) else "BAD "
41   - if not (size_ok and ok): bad += 1
42   - print(f"{flag} {fn}\n size {got} vs remote {want} {'==' if size_ok else '!= MISMATCH'} | header {'ok' if ok else 'BROKEN'} ({detail})")
43   -
44   -need = ["tokenizer.json", "tokenizer_config.json", "preprocessor_config.json", "chat_template.json", "vocab.json", "merges.txt"]
45   -for processor in PROCESSORS:
46   - pdir = os.path.join(BASE, processor)
47   - missing = [f for f in need if not os.path.exists(os.path.join(pdir, f))]
48   - print((f"OK {processor}: all present" if not missing else f"BAD {processor} missing: {missing}"))
49   - bad += len(missing)
50   -print("\nRESULT:", "ALL GOOD" if bad == 0 else f"{bad} PROBLEM(S)")
51   -sys.exit(1 if bad else 0)
minimax-h3/start-all.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# 起全套：四张卡按默认分区起（GPU0/1 ref2va，GPU2/3 fl2va）+ 一个调度层。已经在跑的会先停掉。
3   -# 用法: ./start-all.sh
4   -#
5   -# 停某个端口要按端口找 PID，不要用 pkill -f "port 8010"——bash -c 的命令行本身含这个模式，
6   -# 会把自己的 ssh 会话一起杀掉（踩过，退出码 255）。
7   -set -uo pipefail
8   -cd /data/models/minimax-h3
9   -
10   -for PORT in 8000 8010 8011 8012 8013; do
11   - PID=$(ss -lptn "sport = :$PORT" | grep -o "pid=[0-9]*" | cut -d= -f2 | sort -u)
12   - [ -n "$PID" ] && { echo "停 $PORT (PID $PID)"; kill $PID; }
13   -done
14   -sleep 8
15   -
16   -# GPU 与端口的对应写死在这里，改了要同步改 README。
17   -# H3_OFFLOAD=disk 是关键：不设就是 cpu，每进程多占 40G 内存，四张卡只能起 3 个。
18   -export H3_OFFLOAD=disk
19   -# 2026-08-20：默认分区从「4 张全 ref2va」改成 2/2 固定分裂——GPU0/1 ref2va，GPU2/3 fl2va。
20   -# console 的弹性调度器（h3-console/server.py 的 supervisor）仍然在跑，需求超出这个 2/2
21   -# 基线时照样会临时 flip 别的卡；这里只是把冷启动默认值往实际更常见的 fl2va 需求上偏，
22   -# 减少「提交 fl2va 任务却撞上 4 张全 ref2va」时那 13-20 秒 flip 冷启动 + 最长 30 秒探测延迟。
23   -setsid nohup ./api-run.sh 1 8010 ref2va > logs/api-8010.log 2>&1 < /dev/null &
24   -setsid nohup ./api-run.sh 2 8011 fl2va > logs/api-8011.log 2>&1 < /dev/null &
25   -setsid nohup ./api-run.sh 0 8012 ref2va > logs/api-8012.log 2>&1 < /dev/null &
26   -setsid nohup ./api-run.sh 3 8013 fl2va > logs/api-8013.log 2>&1 < /dev/null &
27   -setsid nohup ./gateway-run.sh 8000 > logs/gateway.log 2>&1 < /dev/null &
28   -
29   -echo "等后端加载（disk 模式约 20 秒）"
30   -for i in $(seq 1 30); do
31   - sleep 5
32   - READY=$(curl -s --max-time 5 http://127.0.0.1:8000/health | grep -o '"ready":[0-9]*' | cut -d: -f2)
33   - echo " ready=${READY:-?}/4"
34   - [ "${READY:-0}" = "4" ] && break
35   -done
36   -curl -s http://127.0.0.1:8000/health
37   -echo
minimax-h3/start-gateway.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -set -uo pipefail
3   -cd /data/models/minimax-h3
4   -PID=$(ss -lptn "sport = :8000" | grep -o "pid=[0-9]*" | cut -d= -f2 | sort -u)
5   -[ -n "$PID" ] && { echo "停旧的 (PID $PID)"; kill "$PID"; sleep 3; }
6   -setsid nohup ./gateway-run.sh 8000 > logs/gateway.log 2>&1 < /dev/null &
7   -sleep 5
8   -pgrep -af "gateway:app"
minimax-h3/submit-same.py deleted
View file @ccf5db1
1   -"""把 8011 上某条已完成任务的请求原样投给另一个端口，用来做单变量对照。"""
2   -import json, sys, urllib.request
3   -
4   -src_port, dst_port, job_id = sys.argv[1], sys.argv[2], sys.argv[3]
5   -
6   -with urllib.request.urlopen(f"http://127.0.0.1:{src_port}/v1/videos/{job_id}", timeout=30) as r:
7   - req = json.load(r)["req"]
8   -
9   -body = json.dumps(req).encode()
10   -post = urllib.request.Request(f"http://127.0.0.1:{dst_port}/v1/videos", data=body,
11   - headers={"Content-Type": "application/json"})
12   -with urllib.request.urlopen(post, timeout=30) as r:
13   - print(json.load(r))
minimax-h3/verify-fixes.py deleted
View file @ccf5db1
1   -"""验三处修复：eta 跟帧数走、队列满返回 429、派发仍然分散。
2   -
3   -跑之前要把调度层的 H3_MAX_QUEUE 调成 1，否则填满默认上限 4 要投 16 条、跑 6 分半。
4   -用 22 帧的短任务，路由和限流逻辑与长任务完全一样。
5   -"""
6   -import json, urllib.request, urllib.error
7   -from collections import Counter
8   -from concurrent.futures import ThreadPoolExecutor
9   -
10   -GW = "http://127.0.0.1:8000"
11   -CASES = [
12   - ("832x480x124f 4步（基准，实测 767s）", {"width": 832, "height": 480, "frames": 124, "steps": 4}),
13   - ("1280x736x56f 4步（实测 736s）", {"width": 1280, "height": 736, "frames": 56, "steps": 4}),
14   - ("832x480x22f 4步（实测 96s）", {"width": 832, "height": 480, "frames": 22, "steps": 4}),
15   -]
16   -SPEC = {"prompt": "一只橘猫趴在洒满阳光的窗台上，慢慢眨眼", "turbo": True}
17   -
18   -
19   -def post(body):
20   - req = urllib.request.Request(GW + "/v1/videos", data=json.dumps(body).encode(),
21   - headers={"Content-Type": "application/json"})
22   - try:
23   - with urllib.request.urlopen(req, timeout=60) as r:
24   - return r.status, json.load(r)
25   - except urllib.error.HTTPError as e:
26   - return e.code, e.read().decode()
27   -
28   -
29   -print("=== 1. eta 是否跟帧数走（改之前三档全报 691）")
30   -results = [post(dict(SPEC, seed=200 + i, **spec)) for i, (_, spec) in enumerate(CASES)]
31   -for (name, _), (code, body) in zip(CASES, results):
32   - print(f" {name:38} -> eta={body['eta_seconds']}s {body['backend'][-4:]}")
33   -
34   -print("\n=== 2. 队列满是否 429（H3_MAX_QUEUE=1，前 3 条已占 3 张卡）")
35   -with ThreadPoolExecutor(max_workers=4) as pool:
36   - burst = list(pool.map(lambda i: post(dict(SPEC, seed=300 + i, frames=22, steps=4)), range(4)))
37   -for i, (code, body) in enumerate(burst):
38   - detail = body if isinstance(body, str) else f"{body['backend'][-4:]} queue_ahead={body['queue_ahead']}"
39   - print(f" #{i} HTTP {code} {detail}")
40   -
41   -accepted = [b for c, b in results + burst if c == 202]
42   -print(f"\n=== 3. 派发分布: {dict(Counter(b['backend'][-4:] for b in accepted))}")
43   -print(f"接受 {len(accepted)} 条，拒绝 {len(results) + len(burst) - len(accepted)} 条")
minimax-h3/watch-8012.sh deleted
View file @ccf5db1
1   -#!/usr/bin/env bash
2   -# 盯 disk offload 那条任务：耗时、内存、以及 rchar/read_bytes——
3   -# rchar 是所有读（含页缓存命中），read_bytes 是真正落到存储层的。
4   -# 两者差得越大说明页缓存命中越好；read_bytes 跟着涨就是在读机械盘，方案不成立。
5   -set -uo pipefail
6   -PID=$(pgrep -f "port 8012")
7   -JOB="$1"
8   -while true; do
9   - S=$(curl -s --max-time 5 "http://127.0.0.1:8012/v1/videos/$JOB")
10   - ST=$(echo "$S" | grep -o '"status":"[a-z]*"' | cut -d'"' -f4)
11   - EL=$(echo "$S" | grep -o '"elapsed_seconds":[0-9]*' | cut -d: -f2)
12   - RC=$(grep "^rchar:" /proc/$PID/io | tr -dc 0-9)
13   - RB=$(grep "^read_bytes:" /proc/$PID/io | tr -dc 0-9)
14   - PD=$(grep "^Private_Dirty:" /proc/$PID/smaps_rollup | tr -dc 0-9)
15   - printf "%s %-8s 已跑%4ss rchar=%6.1fG read_bytes=%6.2fG 私有内存=%5.2fG\n" \
16   - "$(date +%H:%M:%S)" "$ST" "${EL:-0}" \
17   - "$(echo "$RC/1073741824" | bc -l)" "$(echo "$RB/1073741824" | bc -l)" \
18   - "$(echo "$PD/1048576" | bc -l)"
19   - case "$ST" in done|failed) echo "$S"; break;; esac
20   - sleep 60
21   -done