Download code/extract_anima_intervention_features.py from ij/anima-style-factor-intervention-v4: direct link, hf CLI and curl.
- Browser
- Download file 13 kB
-
https://huggingface.co/datasets/ij/anima-style-factor-intervention-v4/resolve/main/code/extract_anima_intervention_features.py
- Command line
-
hf download hf://datasets/ij/anima-style-factor-intervention-v4/code/extract_anima_intervention_features.py
-
curl -L -o extract_anima_intervention_features.py https://huggingface.co/datasets/ij/anima-style-factor-intervention-v4/resolve/main/code/extract_anima_intervention_features.py
13 kB
| from __future__ import annotations | |
| import argparse | |
| from collections import defaultdict | |
| from concurrent.futures import ThreadPoolExecutor | |
| import hashlib | |
| import json | |
| from pathlib import Path | |
| import sys | |
| import time | |
| import torch | |
| ROOT = Path(__file__).resolve().parents[1] | |
| sys.path.insert(0, str(ROOT / "src")) | |
| sys.path.insert(0, str(ROOT / "scripts")) | |
| from anima_style_probe.factor_interventions import apply_intervention # noqa: E402 | |
| from anima_style_probe.feature_parts import completed_part_records, write_feature_part # noqa: E402 | |
| from anima_style_probe.image_preprocess import PREPROCESS_VERSION, image_tensor # noqa: E402 | |
| from anima_style_probe.style_dataset import ( # noqa: E402 | |
| assigned_shards, | |
| iter_prefetched_batches, | |
| iter_style_samples, | |
| ) | |
| from extract_anima_feature_parts import encode_independent_stills # noqa: E402 | |
| from extract_anima_introspective import configure_comfy # noqa: E402 | |
| def read_jsonl(path: Path) -> list[dict]: | |
| with path.open(encoding="utf-8") as handle: | |
| return [json.loads(line) for line in handle if line.strip()] | |
| def flush_part( | |
| output_dir: Path, | |
| worker_index: int, | |
| part_index: int, | |
| features: list[torch.Tensor], | |
| records: list[dict], | |
| *, | |
| blocks: list[int], | |
| sigma: float, | |
| noise_seed: int, | |
| manifest_sha256: str, | |
| selection: str, | |
| ) -> None: | |
| write_feature_part( | |
| output_dir, | |
| "anima", | |
| worker_index, | |
| part_index, | |
| {"features": torch.cat(features).to(torch.bfloat16)}, | |
| { | |
| "kind": f"factor_intervention_anima_{selection}", | |
| "blocks": blocks, | |
| "sigma": sigma, | |
| "noise_seed": noise_seed, | |
| "preprocess_version": PREPROCESS_VERSION, | |
| "transform_resolution": 768, | |
| "manifest_sha256": manifest_sha256, | |
| "records": records, | |
| }, | |
| ) | |
| def main() -> int: | |
| parser = argparse.ArgumentParser(description="Extract transformed-Anima pilot features.") | |
| parser.add_argument("--comfy-root", type=Path, required=True) | |
| parser.add_argument("--config", type=Path, required=True) | |
| parser.add_argument("--dataset-root", type=Path, required=True) | |
| parser.add_argument("--manifest", type=Path, required=True) | |
| parser.add_argument("--output-dir", type=Path, required=True) | |
| parser.add_argument("--worker-index", type=int, required=True) | |
| parser.add_argument("--num-workers", type=int, default=4) | |
| parser.add_argument("--batch-size", type=int, default=64) | |
| parser.add_argument("--source-batch-size", type=int, default=8) | |
| parser.add_argument("--decode-workers", type=int, default=8) | |
| parser.add_argument("--part-size", type=int, default=1024) | |
| parser.add_argument("--image-size", type=int, default=768) | |
| parser.add_argument("--blocks", type=int, nargs="+", default=[8, 18, 26]) | |
| parser.add_argument("--sigma", type=float, default=0.1) | |
| parser.add_argument("--noise-seed", type=int, default=20260715) | |
| parser.add_argument("--selection", choices=("pilot", "train", "all"), default="pilot") | |
| args = parser.parse_args() | |
| if min(args.batch_size, args.source_batch_size, args.decode_workers, args.part_size) < 1: | |
| raise ValueError("batch and worker sizes must be positive") | |
| if args.image_size != 768: | |
| raise ValueError("the Anima pilot is locked to 768x768") | |
| config = json.loads(args.config.read_text(encoding="utf-8")) | |
| manifest_sha256 = hashlib.sha256(args.manifest.read_bytes()).hexdigest() | |
| all_rows = read_jsonl(args.manifest) | |
| if args.selection == "pilot": | |
| rows = [row for row in all_rows if row.get("anima_pilot")] | |
| elif args.selection == "train": | |
| rows = [row for row in all_rows if row.get("split") == "train"] | |
| else: | |
| rows = all_rows | |
| worker_shards = { | |
| path.name | |
| for path in assigned_shards(args.dataset_root, args.worker_index, args.num_workers) | |
| } | |
| rows = [row for row in rows if row["shard"] in worker_shards] | |
| by_source: dict[str, list[dict]] = defaultdict(list) | |
| for row in rows: | |
| by_source[str(row["source_record_id"])].append(row) | |
| completed, part_index = completed_part_records( | |
| args.output_dir, "anima", args.worker_index | |
| ) | |
| for path in args.output_dir.glob(f"anima-w{args.worker_index}-p*.json"): | |
| metadata = json.loads(path.read_text(encoding="utf-8")) | |
| if metadata.get("manifest_sha256") != manifest_sha256: | |
| raise RuntimeError(f"manifest mismatch with completed part: {path}") | |
| pending_by_source = { | |
| source_id: [row for row in variants if row["record_id"] not in completed] | |
| for source_id, variants in by_source.items() | |
| } | |
| pending_by_source = {key: value for key, value in pending_by_source.items() if value} | |
| nodes, model_management = configure_comfy(args.comfy_root) | |
| if not torch.cuda.is_available(): | |
| raise RuntimeError("CUDA is required") | |
| run_started = time.perf_counter() | |
| torch.cuda.reset_peak_memory_stats() | |
| vae = nodes.VAELoader().load_vae(config["comfy"]["vae_name"])[0] | |
| clip = nodes.CLIPLoader().load_clip( | |
| config["comfy"]["clip_name"], | |
| config["comfy"].get("clip_type", "stable_diffusion"), | |
| "default", | |
| )[0] | |
| empty_conditioning = nodes.CLIPTextEncode().encode(clip, "")[0] | |
| if len(empty_conditioning) != 1: | |
| raise RuntimeError("expected one empty-prompt conditioning item") | |
| raw_cross, raw_metadata = empty_conditioning[0] | |
| raw_ids = raw_metadata["t5xxl_ids"].flatten().detach().cpu() | |
| raw_weights = raw_metadata["t5xxl_weights"].flatten().detach().cpu() | |
| raw_cross = raw_cross.detach().cpu() | |
| del clip | |
| model_management.unload_all_models() | |
| model_management.soft_empty_cache() | |
| model = nodes.UNETLoader().load_unet(config["comfy"]["unet_name"], "default")[0] | |
| model_management.load_models_gpu([model]) | |
| device = model.load_device | |
| dtype = model.model.get_dtype_inference() | |
| diffusion_model = model.model.diffusion_model | |
| block_indices = [block - 1 for block in args.blocks] | |
| if min(block_indices) < 0 or max(block_indices) >= len(diffusion_model.blocks): | |
| raise ValueError(f"invalid blocks for {len(diffusion_model.blocks)}-block Anima model") | |
| with torch.inference_mode(): | |
| context = diffusion_model.preprocess_text_embeds( | |
| raw_cross.to(device=device, dtype=dtype), | |
| raw_ids.unsqueeze(0).to(device=device), | |
| t5xxl_weights=raw_weights.unsqueeze(0).unsqueeze(-1).to( | |
| device=device, dtype=dtype | |
| ), | |
| ) | |
| captured: dict[int, list[torch.Tensor]] = {} | |
| def capture(block: int): | |
| def hook(_module, _inputs, output): | |
| spatial_dims = tuple(range(1, output.ndim - 1)) | |
| value = output.detach().float() | |
| mean = value.mean(dim=spatial_dims) | |
| log_std = value.var(dim=spatial_dims, unbiased=False).clamp_min(1e-8).sqrt().log() | |
| captured.setdefault(block, []).append(torch.cat((mean, log_std), dim=-1).cpu()) | |
| return hook | |
| handles = [ | |
| diffusion_model.blocks[index].register_forward_hook(capture(block)) | |
| for block, index in zip(args.blocks, block_indices, strict=True) | |
| ] | |
| decode_pool = ThreadPoolExecutor( | |
| max_workers=args.decode_workers, thread_name_prefix="anima-intervention" | |
| ) | |
| extraction_started = time.perf_counter() | |
| processed = 0 | |
| feature_parts: list[torch.Tensor] = [] | |
| part_records: list[dict] = [] | |
| feature_buffer: list[tuple[torch.Tensor, dict]] = [] | |
| def decode_source(sample): | |
| decoded = [] | |
| for spec in pending_by_source[str(sample.metadata["record_id"])]: | |
| full, _face = apply_intervention( | |
| sample.full_bytes, | |
| sample.face_bytes, | |
| sample.metadata, | |
| spec, | |
| size=args.image_size, | |
| ) | |
| decoded.append( | |
| ( | |
| image_tensor(full).permute(1, 2, 0), | |
| {**spec, "source_shard": sample.shard}, | |
| ) | |
| ) | |
| return decoded | |
| def process_batch(batch: list[tuple[torch.Tensor, dict]]) -> None: | |
| nonlocal processed, part_index, feature_parts, part_records | |
| pixels, records = map(list, zip(*batch, strict=True)) | |
| with torch.inference_mode(): | |
| latents = encode_independent_stills(vae, pixels, model_management) | |
| clean = model.model.process_latent_in(latents).to(device=device, dtype=dtype) | |
| if clean.shape[0] != len(batch): | |
| raise RuntimeError(f"latent batch has {clean.shape[0]} rows for {len(batch)} records") | |
| generator = torch.Generator(device="cpu").manual_seed(args.noise_seed) | |
| noise = torch.randn(clean[:1].shape, generator=generator, dtype=torch.float32).to( | |
| device=device, dtype=dtype | |
| ).expand_as(clean) | |
| sigma = torch.full((clean.shape[0],), args.sigma, device=device, dtype=torch.float32) | |
| noised = args.sigma * noise + (1.0 - args.sigma) * clean | |
| captured.clear() | |
| model.model.apply_model( | |
| noised, | |
| sigma, | |
| c_crossattn=context.expand(clean.shape[0], *context.shape[1:]), | |
| ) | |
| if set(captured) != set(args.blocks): | |
| raise RuntimeError(f"captured blocks {sorted(captured)}, expected {args.blocks}") | |
| features = torch.stack( | |
| [torch.cat(captured[block], dim=0) for block in args.blocks], dim=1 | |
| ) | |
| if features.shape != (len(batch), len(args.blocks), 4096): | |
| raise RuntimeError(f"unexpected Anima feature shape: {tuple(features.shape)}") | |
| feature_parts.append(features) | |
| part_records.extend(records) | |
| processed += len(batch) | |
| if len(part_records) >= args.part_size: | |
| flush_part( | |
| args.output_dir, | |
| args.worker_index, | |
| part_index, | |
| feature_parts, | |
| part_records, | |
| blocks=args.blocks, | |
| sigma=args.sigma, | |
| noise_seed=args.noise_seed, | |
| manifest_sha256=manifest_sha256, | |
| selection=args.selection, | |
| ) | |
| part_index += 1 | |
| feature_parts, part_records = [], [] | |
| print( | |
| json.dumps( | |
| { | |
| "worker": args.worker_index, | |
| "new_records": processed, | |
| "expected": len(rows), | |
| "already_complete": len(completed), | |
| "elapsed_seconds": round(time.perf_counter() - extraction_started, 1), | |
| } | |
| ), | |
| flush=True, | |
| ) | |
| try: | |
| samples = iter_style_samples( | |
| args.dataset_root, | |
| worker_index=args.worker_index, | |
| num_workers=args.num_workers, | |
| include_record_ids=set(pending_by_source), | |
| ) | |
| for source_batch in iter_prefetched_batches(samples, args.source_batch_size): | |
| for group in decode_pool.map(decode_source, source_batch): | |
| feature_buffer.extend(group) | |
| while len(feature_buffer) >= args.batch_size: | |
| process_batch(feature_buffer[: args.batch_size]) | |
| del feature_buffer[: args.batch_size] | |
| if feature_buffer: | |
| process_batch(feature_buffer) | |
| finally: | |
| decode_pool.shutdown() | |
| for handle in handles: | |
| handle.remove() | |
| if part_records: | |
| flush_part( | |
| args.output_dir, | |
| args.worker_index, | |
| part_index, | |
| feature_parts, | |
| part_records, | |
| blocks=args.blocks, | |
| sigma=args.sigma, | |
| noise_seed=args.noise_seed, | |
| manifest_sha256=manifest_sha256, | |
| selection=args.selection, | |
| ) | |
| if processed + len(completed) != len(rows): | |
| raise RuntimeError(f"worker coverage mismatch: {processed} + {len(completed)} != {len(rows)}") | |
| summary = { | |
| "status": "complete", | |
| "worker_index": args.worker_index, | |
| "manifest_sha256": manifest_sha256, | |
| "records": len(rows), | |
| "already_complete": len(completed), | |
| "new_records": processed, | |
| "setup_seconds": extraction_started - run_started, | |
| "elapsed_seconds": time.perf_counter() - extraction_started, | |
| "total_seconds": time.perf_counter() - run_started, | |
| "peak_vram_bytes": torch.cuda.max_memory_allocated(), | |
| "blocks": args.blocks, | |
| "sigma": args.sigma, | |
| "noise_seed": args.noise_seed, | |
| "selection": args.selection, | |
| } | |
| path = args.output_dir / f"anima-worker-{args.worker_index}.json" | |
| path.write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8") | |
| print(json.dumps(summary, indent=2)) | |
| return 0 | |
| if __name__ == "__main__": | |
| raise SystemExit(main()) | |