#!/usr/bin/env python3 """Prepare selected historical Any2Ego checkpoints and size-bounded base models. CPU/file I/O only. No data archive, training, inference, API call or upload. Original checkpoints stay read-only. Sources are explicit CLI paths. Re-running checks cached shards and existing files rather than overwriting arbitrary data. """ from concurrent.futures import ThreadPoolExecutor import argparse import hashlib import json import os from pathlib import Path import shutil import sys from reshard_weights import BLOCK, SIDECARS, now, read_header, reshard, sha_file, write_atomic_json, load_source LIMIT = 5_000_000_000 SELECTED = [{'component': 'generator_hoi', 'source': 'outputs/train_vace_hoi_lora_r128_sq_sq480/epoch-4.safetensors', 'path': 'checkpoints/generator_hoi/ckpt.safetensors', 'selection': 'paper-index HOI LoRA, epoch4', 'sha256': '16760be1abceff62f816e2837ba6517ea84d504263f37cc756d5cc3eb627c68d'}, {'component': 'generator_global', 'source': 'outputs/train_caption_hoi_v2clean_sq_sq480/epoch-4.safetensors', 'path': 'checkpoints/generator_global/ckpt.safetensors', 'selection': 'paper-index Global caption branch, epoch4', 'sha256': 'f7b83d712eac12caeb772d926165fce76b2ac02a413536f354d875d40ed345aa'}, {'component': 'generator_spatial', 'source': 'outputs/train_caption_hoi_v2clean_sq_teacher_sroute_capdrop15/epoch-2.safetensors', 'path': 'checkpoints/generator_spatial/ckpt.safetensors', 'selection': 'paper-index Spatial caption branch, epoch2; historical teacher caption training', 'sha256': '940a2bc83f63056d4672562947e9ae503b1489932f41b1a917e5d0a8285f9fe0'}, {'component': 'reward_preview', 'source': 'outputs/train_caption_hoi_v2clean_sq_teacher_oracle_capdrop15/epoch-4.safetensors', 'path': 'checkpoints/reward_preview/ckpt.safetensors', 'selection': 'teacher-caption Global reward preview, epoch4', 'sha256': '79732eef0f1efbb90b8d7090fb17b4946cc7b84e1915b57995bf3536f2559e55'}, {'component': 'mask_predictor', 'source': 'outputs/train_phiseg_bugfix_exofull/epoch-9.pt', 'path': 'checkpoints/mask_predictor/ckpt.pt', 'selection': 'historical evaluated PhiSeg, epoch9; exo_full_context/BN settings must match', 'sha256': '3dccf97f938c22f6143020164431a956e0b6335439a691a9b38af99a7d62ba7d'}, {'component': 'sft_only', 'source': 'outputs/train_student_qwen_b200fix/v0-20260911-034450/checkpoint-4070/adapter_model.safetensors', 'path': 'checkpoints/sft_only/adapter_model.safetensors', 'selection': 'Qwen3-VL-8B LoRA, step4070', 'sha256': '072df399b4320b17313a64fb7c024d1f981464e9852c979f4644391e77853f2e'}, {'component': 'caption_grpo', 'source': 'outputs/train_captioner_grpo/v2-20260917-122629/checkpoint-3800/adapter_model.safetensors', 'path': 'checkpoints/caption_grpo/adapter_model.safetensors', 'selection': 'Qwen3-VL-8B GRPO LoRA, step3800', 'sha256': '290aacd2808639e3c3e10c81c69acfdd843100b8888ad183a2e03ba6e43f5d11'}, {'component': 'mask_predictor_paperalign_candidate', 'source': 'outputs/train_phiseg_paperalign/epoch-4.pt', 'path': 'research/mask_predictor_paperalign/epoch-4.pt', 'selection': 'last existing paper-align checkpoint, not validated best/final', 'sha256': '4cd0d08b16782c7ca3566db23d378b206880203f013b3c017791712aa66d0704'}, {'component': 'vlm_comparison', 'source': 'outputs/train_vlm_hoi_sq480/epoch-0.safetensors', 'path': 'research/vlm_comparison/epoch-0.safetensors', 'selection': 'paper-index continuous VLM comparison, epoch0', 'sha256': 'f6abd392ec7b18e182c1e4c0e840794aa29c629036b290c013fe6ee4c0df1de4'}, {'component': 'joint_branch', 'source': 'outputs/train_joint_hoi/epoch-3.safetensors', 'path': 'research/joint_branch/epoch-3.safetensors', 'selection': 'last normal joint checkpoint; gate-edited ablations excluded', 'sha256': '522d9ff9e721ab7ee9a7272a6dfbdf0aaedb1c6c4e8f5fa1d9b27ac73ba0fad0'}, {'component': 'caption_dpo', 'source': 'outputs/train_caption_dpo_v2clean_sq_sq480/epoch-2.safetensors', 'path': 'research/caption_dpo/epoch-2.safetensors', 'selection': 'last available DPO checkpoint, not asserted best', 'sha256': 'ff13d7f409c6392a00f3dfcb42c32fccb11c77b4ad2f721e276fe96513017bbf'}, {'component': 'native_narr_dit', 'source': 'outputs/train_narr_caption_dit_r128/epoch-4.safetensors', 'path': 'research/native_narr_dit/epoch-4.safetensors', 'selection': 'native narration DiT LoRA, epoch4', 'sha256': 'a112106d5a2bd851c3a635ac752268aa8154a1eab5101d4ee762f97f64fa3b1a'}] PREVIOUS_CODE = { 'generator_defaults.py': 'f576a6ceaa29cfb78ba8d783ddadf52bffcfb5f30a8740d55f9e55af1b0a4369', 'diffusion/infer_caption.py': '377b52f76012189f6ca779c645d2891a8769e160c27a11d09a5591889de93aeb', 'diffusion/infer_vace_hoi.py': '37e8ecb9f92551d048524226f22f4c0f86086eb69ca6e9a7bf56d69b47c955d4', 'model_resources.py': None, } def copy_verified(source, target, expected=None): source, target = Path(source), Path(target) stat = source.stat() if not source.is_file() or stat.st_size > LIMIT: raise ValueError('unexpected source or large file must be sharded: ' + str(source)) if target.is_symlink(): raise ValueError('refusing to write through an existing symlink') if target.exists(): if not target.is_file(): raise ValueError('destination is not a regular file') source_hash = sha_file(source) if expected and source_hash != expected: raise ValueError('selected source checkpoint hash differs') if target.stat().st_size != stat.st_size or sha_file(target) != source_hash: raise ValueError('existing destination differs; will not overwrite it: ' + str(target)) return {'bytes': stat.st_size, 'sha256': source_hash} target.parent.mkdir(parents=True, exist_ok=True) temporary = target.with_name(target.name + '.partial') digest = hashlib.sha256() with source.open('rb') as inp, temporary.open('wb') as out: for block in iter(lambda: inp.read(BLOCK), b''): out.write(block) digest.update(block) out.flush() actual = digest.hexdigest() if expected and actual != expected: raise ValueError('selected source checkpoint hash differs') after = source.stat() if (after.st_size, after.st_mtime_ns) != (stat.st_size, stat.st_mtime_ns): raise ValueError('source changed during copy') if temporary.stat().st_size != stat.st_size or sha_file(temporary) != actual: raise ValueError('independent copy readback SHA256 differs') temporary.chmod(0o644) temporary.replace(target) print('COPIED', target, f'{stat.st_size / 1e9:.3f} GB', flush=True) return {'bytes': stat.st_size, 'sha256': actual} def selected_weights(project, output): result = [] for row in SELECTED: source, target = project / row['source'], output / row['path'] record = copy_verified(source, target, row['sha256']) item = {**row, **record, 'format_preserved': True} if source.suffix == '.safetensors': tensors, _, _ = read_header(source) item['tensor_count'] = len(tensors) item['has_spatial_route'] = any('spatial_route' in tensor['name'] for tensor in tensors) if row['component'] in ('sft_only', 'caption_grpo'): for name in ('adapter_config.json', 'additional_config.json'): config = json.loads((source.parent / name).read_text()) if name == 'adapter_config.json': config['base_model_name_or_path'] = 'Qwen/Qwen3-VL-8B-Instruct' destination = target.parent / name text = json.dumps(config, ensure_ascii=False, indent=2) + '\n' if destination.exists() and destination.read_text() != text: raise ValueError('existing adapter config differs') destination.write_text(text) item['config_normalization'] = 'only base_model_name_or_path normalized to official Qwen ID' result.append(item) return result def copied_vlm(vlm, output): root, index, tensors, files, _, _ = load_source(vlm) if any(info['bytes'] > LIMIT for info in files): raise ValueError('VLM base needs resharding before copying') dest = output / 'models/Qwen3-VL-8B-Instruct' for name in [info['name'] for info in files] + ['model.safetensors.index.json']: copy_verified(root / name, dest / name) for name in sorted(SIDECARS | {'README.md'}): if (root / name).is_file(): copy_verified(root / name, dest / name) return dict(component='captioner_base', base_model='Qwen/Qwen3-VL-8B-Instruct', path='models/Qwen3-VL-8B-Instruct', shard_count=len(files), tensor_count=len(tensors), unchanged_original_shards=True, raw_tensor_bytes=sum(t['nbytes'] for t in tensors)) def copied_clip(clip, output): dest = output / 'models/CLIP-ViT-H-14-laion2B-s32B-b79K' copy_verified(clip / 'model.safetensors', dest / 'model.safetensors') for name in sorted(SIDECARS): if (clip / name).is_file(): copy_verified(clip / name, dest / name) copy_verified(clip / 'README.md', dest / 'UPSTREAM_README.md') (dest / 'README.md').write_text("""--- license: mit library_name: transformers pipeline_tag: zero-shot-image-classification --- # CLIP ViT-H/14 base dependency for Any2Ego The original Transformers `model.safetensors` and processor/tokenizer files are copied unchanged and hash-verified. This is not an Any2Ego-trained model. The project uses `CLIPModel`/`CLIPProcessor.from_pretrained` here; redundant OpenCLIP/bin copies are intentionally omitted. See `UPSTREAM_README.md` for source model documentation and terms. Prepared locally, not uploaded. """) tensors, _, _ = read_header(dest / 'model.safetensors') return dict(component='reward_clip_base', base_model='laion/CLIP-ViT-H-14-laion2B-s32B-b79K', path='models/CLIP-ViT-H-14-laion2B-s32B-b79K', shard_count=1, tensor_count=len(tensors), format_preserved=True) def ensure_shards(source, dest, prefix, kind, resume): manifest_path = dest / 'reshard_manifest.json' if not manifest_path.is_file(): return reshard(source, dest, LIMIT, kind, resume, prefix, base_model='Wan-AI/Wan2.1-VACE-1.3B') manifest = json.loads(manifest_path.read_text()) spec = manifest['spec'] if spec['source']['path'] != str(source.resolve()) or spec['max_shard_bytes'] != LIMIT or spec['prefix'] != prefix: raise ValueError('cached shards have different inputs') for row in spec['source_files']: stat = (source.parent / row['name']).stat() if (stat.st_size, stat.st_mtime_ns) != (row['bytes'], row['mtime_ns']): raise ValueError('cached shard source changed') if sha_file(source.parent / row['name']) != manifest['source_file_sha256'][row['name']]: raise ValueError('cached shard source SHA256 differs') if not all(manifest['validation'].values()): raise ValueError('cached shards not fully validated') if sha_file(dest / (prefix + '.safetensors.index.json')) != manifest['output_index_sha256']: raise ValueError('cached shard index changed') for row in manifest['output_shards']: path = dest / row['name'] if path.stat().st_size != row['bytes'] or row['bytes'] > LIMIT or sha_file(path) != row['sha256']: raise ValueError('cached shard file changed') print('REUSING VERIFIED SHARDS', dest, flush=True) return manifest def support_code(core, output): support = output / 'code_support' rows = [] for name, previous in PREVIOUS_CODE.items(): record = copy_verified(core / name, support / name) rows.append(dict(path=name, previous_sha256=previous, new_sha256=record['sha256'])) copy_verified(core / 'project_paths.py', support / 'project_paths.py') write_atomic_json(support / 'loader_patch.json', { 'note': 'Installer patches only exact known original files, never unknown local edits.', 'files': rows}) tools = Path(__file__).resolve().parent for source in sorted(tools.glob('*.py')): copy_verified(source, output / 'tools' / source.name) for source in sorted((tools / 'tests').glob('*.py')): copy_verified(source, output / 'tools/tests' / source.name) def native_reader_validation(output): os.environ['CUDA_VISIBLE_DEVICES'] = '' from safetensors import safe_open import torch records, total = [], 0 for path in sorted(output.rglob('*.safetensors')): tensors, metadata, _ = read_header(path) expected = {t['name']: t for t in tensors} with safe_open(path, framework='pt', device='cpu') as reader: if set(reader.keys()) != set(expected) or (reader.metadata() or {}) != metadata: raise ValueError('native reader tensor names/metadata differ') for name in reader.keys(): value = reader.get_slice(name) if list(value.get_shape()) != expected[name]['shape'] or value.get_dtype() != expected[name]['dtype']: raise ValueError('native reader shape/dtype differs') records.append(dict(path=str(path.relative_to(output)), tensor_count=len(tensors), names_shapes_dtypes_verified=True)) total += len(tensors) if torch.cuda.is_initialized(): raise RuntimeError('unexpected CUDA initialization') result = dict(reader='safetensors.safe_open(framework=pt, device=cpu), slices only', safetensors_files=len(records), tensor_entries=total, files=records, CUDA_initialized=False, model_loaded=False, inference_run=False) write_atomic_json(output / 'native_reader_validation.json', result) return result def root_readme(output, trained, transformer, encoder, vlm): rows = '\n'.join(f"| {r['component']} | {r['bytes']/1024**2:.1f} | {r['selection']} |" for r in trained) text = f"""--- tags: - exo-to-ego - video-generation - safetensors - lora - research --- # Ego-Exo / Any2Ego — 本地 5GB 权重分片包 **只整理权重，不是新训练结果，也尚未上传 HF。** 所有文件不超过 5,000,000,000 字节（包含 safetensors 头）。不是 split/tar 片段； 模型张量保留完整，一个张量不会被切成两半。原始模型/检查点没有修改。 ## 目录与分片 - `models/Wan2.1-VACE-1.3B/transformer/`：原生 DiT+VACE 底座，{len(transformer['output_shards'])} 片； `diffusion_pytorch_model.safetensors.index.json`。 - `models/Wan2.1-VACE-1.3B/text_encoder/`：原生 umT5-XXL BF16，{len(encoder['output_shards'])} 片； `model.safetensors.index.json`。原 .pth 的完整存储逐字节转存 safetensors， 不改变 key、shape、dtype 或值；只用 weights_only/FakeTensor 读取元信息。 - Wan VAE 和 `google/umt5-xxl/` tokenizer 保留原格式。 - `models/Qwen3-VL-8B-Instruct/`：官方基座原有 {vlm['shard_count']} 片已小于 5GB，完整保留。 - `models/CLIP-ViT-H-14-laion2B-s32B-b79K/`：Transformers 格式原单文件保留； 未重复打包 OpenCLIP/bin 副本。 - `checkpoints/`：7 个主链路训练产物；`research/`：5 个辅助实验快照。 它们本来就小于 5GB，保留原 safetensors/.pt 与必要的 adapter 配置。 - `code_support/`、`tools/`：分片加载兼容补丁、校验/安装/重新分片工具与 CPU 小测试。 基础模型仍是上游模型，不是合并后的 Any2Ego 训练权重；没有合并 LoRA。 上游模型各自遵守原许可证，不能把整个 bundle 统一声明为新的自有模型。 训练数据、caption、视频、optimizer/RNG/log/缓存不包含在这个**权重包**里。 ## 训练产物选择 | Component | MiB | 来源/选择 | |---|---:|---| {rows} Historical Spatial epoch2 使用 teacher captions 训练，不冒称新的 GRPO-caption 重训结果；PhiSeg epoch9 对应 exo_full_context/BN 实验支路，推理需匹配 `--exo_full_context --bn_batch_stats` 与数据设置。paperalign epoch4 只是候选， 未声明最佳/收敛。辅助 joint/VLM/DPO/native-narr 权重不可替代主分支。 SFT/GRPO 为 Qwen3-VL-8B 的 rank16/alpha32 LoRA，非机器人项目的 27B 权重。 Adapter 权重原样保留，配置只将基座路径规范为官方 Qwen ID。 ## 接到现有代码（不会自动训练或推理） GitHub 源码：`https://github.com/coisini-gif/exo-ego-video-converter`（私密仓库需访问权限）。 下载权重包后，在源码 checkout 的 `code/core` 下使用模型。 ```bash BUNDLE=/your/downloaded/ego_exo_5gb_20261102 CORE=/your/exo-ego-video-converter/code/core # 先看计划；无写入、无模型加载 python "$BUNDLE/tools/attach_model_bundle.py" --bundle "$BUNDLE" --code-root "$CORE" # 仅对不存在的资源建链接，旧版 loader 按已知 SHA256 安全补丁；有自定义改动会拒绝覆盖 python "$BUNDLE/tools/attach_model_bundle.py" --bundle "$BUNDLE" --code-root "$CORE" --apply # 文件完整性校验（需要读完整包，但不使用 GPU） python "$BUNDLE/tools/verify_model_bundle.py" --bundle "$BUNDLE" ``` Wan 的这两个索引**不能直接传入旧版二进制 loader**。兼容补丁分别把 DiT、T5 的 shard 列表传给一个 `ModelConfig(path=[...])`，再加入 VAE； 已覆盖 HOI/Global/Spatial 推理、generator training defaults 和 reward preview 共用的 build_pipe。原单文件路径仍然兼容，`WAN_MODEL_ROOT` 可覆盖 Wan 位置。 这不是标准 diffusers 架构转换；不要直接对 Wan 分片子目录调用 `transformers.AutoModel.from_pretrained`，也不需要先合并回 >5GB 文件。 若用 research 旧入口，设置 `MODEL_ROOT=$BUNDLE/models`，并显式指定对应 `$BUNDLE/research/...` 检查点；这些旧入口仍需用 `wan_model_paths` 解析 Wan 组件，或采用 core 主入口。未声称所有历史脚本均已自动改为分片加载。 运行推理/训练还需要论文对应数据、mask、caption、第三方框架和正确版本。 **权重完整性校验并不等于完整 GPU 复现或论文指标复现。** ## 校验与 HF `bundle_manifest.json` / `CHECKSUMS.sha256` 提供文件哈希；两个大组件各自的 `reshard_manifest.json` 还包含每个原张量的 SHA256，输出独立回读逐张量验证。 `native_reader_validation.json` 使用原生 safetensors CPU reader 验证所有 名称、形状和 dtype，未实例化模型/分配 GPU。 整个目录可作为 **private HF model repo** 的上传目录（含模型/权重 README）。 如只发布自训产物，可仅上传 `checkpoints/` 和 `research/`，依赖官方基座。 此步骤**没有任何网络上传**，上传仍需个人 HF Write 登录/token；GitHub token 不能用于 HF。不保存或打包密钥。可在 HF 单独建 repo 后使用 `hf upload` 或 huggingface_hub 上传目录；Wan 模型资源布局需保留不变。 """ (output / 'README.md').write_text(text) def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--project-root', type=Path, required=True) parser.add_argument('--wan-base', type=Path, required=True) parser.add_argument('--vlm-base', type=Path, required=True) parser.add_argument('--clip-base', type=Path, required=True) parser.add_argument('--code-root', type=Path, required=True) parser.add_argument('--output-dir', type=Path, required=True) parser.add_argument('--resume', action='store_true') args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = '' output = args.output_dir.resolve() for source in (args.project_root, args.wan_base, args.vlm_base, args.clip_base, args.code_root): source = source.resolve() if output == source or source in output.parents or output in source.parents: raise ValueError('output must not overlap an original resource/code directory') output.mkdir(parents=True, exist_ok=True) spec = dict(project_root=str(args.project_root.resolve()), wan_base=str(args.wan_base.resolve()), vlm_base=str(args.vlm_base.resolve()), clip_base=str(args.clip_base.resolve()), max_file_bytes=LIMIT) state_path = output / '.bundle_state.json' if state_path.exists() and json.loads(state_path.read_text()) != spec: raise ValueError('existing bundle state has different source paths') if not state_path.exists() and any(output.iterdir()): existing = output / 'bundle_manifest.json' if not existing.is_file() or json.loads(existing.read_text()).get('sources') != spec: raise ValueError('unrelated nonempty output directory; use a fresh directory') from verify_model_bundle import verify verify(output) write_atomic_json(state_path, spec) with ThreadPoolExecutor(max_workers=3) as pool: f_trained = pool.submit(selected_weights, args.project_root, output) f_vlm = pool.submit(copied_vlm, args.vlm_base, output) f_clip = pool.submit(copied_clip, args.clip_base, output) trained, vlm, clip = f_trained.result(), f_vlm.result(), f_clip.result() wan_dest = output / 'models/Wan2.1-VACE-1.3B' for name in ('Wan2.1_VAE.pth', 'config.json', 'LICENSE.txt'): copy_verified(args.wan_base / name, wan_dest / name) for source in sorted((args.wan_base / 'google/umt5-xxl').iterdir()): if source.is_file() and source.name in SIDECARS: copy_verified(source, wan_dest / 'google/umt5-xxl' / source.name) transformer = ensure_shards(args.wan_base / 'diffusion_pytorch_model.safetensors', wan_dest / 'transformer', 'diffusion_pytorch_model', 'Wan2.1-VACE-1.3B native base transformer (DiT and VACE, not trained Any2Ego branches)', args.resume) encoder = ensure_shards(args.wan_base / 'models_t5_umt5-xxl-enc-bf16.pth', wan_dest / 'text_encoder', 'model', 'Wan native umT5-XXL BF16 text encoder (lossless PyTorch storage to safetensors)', args.resume) write_atomic_json(wan_dest / 'model_components.json', { 'loader': 'DiffSynth ModelConfig: one str/list per component', 'transformer': 'transformer/diffusion_pytorch_model.safetensors.index.json', 'text_encoder': 'text_encoder/model.safetensors.index.json', 'vae': 'Wan2.1_VAE.pth', 'tokenizer': 'google/umt5-xxl', 'tensor_key_architecture_conversion': False}) (wan_dest / 'README.md').write_text("""# Wan2.1-VACE-1.3B base dependency (native DiffSynth keys) Upstream: Wan-AI/Wan2.1-VACE-1.3B, original LICENSE.txt included. Not trained Any2Ego branches. Native DiT/VACE is in transformer/; native BF16 umT5 is in text_encoder/. Supply shard lists to separate ModelConfig objects. VAE and umt5 tokenizer stay unchanged. See the parent README/code_support for loading. This is not a diffusers/Transformers architecture conversion; no upload yet. """) support_code(args.code_root, output) native = native_reader_validation(output) sys.path.insert(0, str(args.code_root)) from model_resources import wan_model_paths, wan_tokenizer_path paths = wan_model_paths(wan_dest, strict=True) if [len(paths[0]), len(paths[1])] != [len(transformer['output_shards']), len(encoder['output_shards'])]: raise ValueError('sharded loader path count differs') wan_tokenizer_path(wan_dest, strict=True) root_readme(output, trained, transformer, encoder, vlm) files = [] for path in sorted(output.rglob('*')): if path.is_symlink(): raise ValueError('upload bundle must contain actual files, not symlinks') if not path.is_file() or path.name in ('bundle_manifest.json', 'CHECKSUMS.sha256', '.bundle_state.json'): continue if path.suffix == '.partial' or path.name.startswith('.reshard') or path.name.endswith('.pyc'): raise ValueError('unfinished/cache file must not enter completed model bundle') if path.stat().st_size > LIMIT: raise ValueError('file limit exceeded') files.append(dict(path=str(path.relative_to(output)), bytes=path.stat().st_size, sha256=sha_file(path))) manifest = dict(schema_version=1, status='complete', created_at_UTC=now(), sources=spec, max_file_bytes=LIMIT, trained_components=trained, base_components=[{'component': 'wan_transformer', 'path': 'models/Wan2.1-VACE-1.3B/transformer', 'shard_count': len(transformer['output_shards']), 'tensor_count': transformer['spec']['tensor_count']}, {'component': 'wan_text_encoder', 'path': 'models/Wan2.1-VACE-1.3B/text_encoder', 'shard_count': len(encoder['output_shards']), 'tensor_count': encoder['spec']['tensor_count']}, vlm, clip], files=files, total_file_bytes=sum(row['bytes'] for row in files), largest_file_bytes=max(row['bytes'] for row in files), native_reader=native['reader'], validation={'all_copied_weights_read_back_SHA256_verified': True, 'resharded_tensor_bytes_independently_SHA256_verified': True, 'native_reader_names_shapes_dtypes_verified': True, 'core_sharded_loader_paths_verified': True}, GPU_used=False, model_loaded=False, inference_run=False, training_run=False, upload_run=False, raw_dataset_included=False) write_atomic_json(output / 'bundle_manifest.json', manifest) checksum_rows = files + [dict(path='bundle_manifest.json', sha256=sha_file(output / 'bundle_manifest.json'))] (output / 'CHECKSUMS.sha256').write_text(''.join(row['sha256'] + ' ' + row['path'] + '\n' for row in checksum_rows)) state_path.unlink() print(json.dumps({'output': str(output), 'status': 'complete', 'trained_components': len(trained), 'wan_transformer_shards': len(transformer['output_shards']), 'wan_text_encoder_shards': len(encoder['output_shards']), 'qwen_shards': vlm['shard_count'], 'total_GB': round(manifest['total_file_bytes']/1e9, 3), 'largest_file_bytes': manifest['largest_file_bytes'], 'GPU_used': False, 'upload_run': False}, indent=2), flush=True) if __name__ == '__main__': main()