File size: 5,494 Bytes
0707b22 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 | import logging
import os
from types import SimpleNamespace
import torch
from musubi_tuner.dataset import config_utils
from musubi_tuner.dataset.config_utils import BlueprintGenerator, ConfigSanitizer
from musubi_tuner.dataset.image_video_dataset import (
ARCHITECTURE_KANDINSKY5,
ARCHITECTURE_KANDINSKY5_FULL,
ItemInfo,
save_text_encoder_output_cache_kandinsky5,
)
import musubi_tuner.cache_text_encoder_outputs as cache_text_encoder_outputs
from musubi_tuner.kandinsky5.models.text_embedders import get_text_embedder
from musubi_tuner.utils import safetensors_utils
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def _ensure_cache_architecture(item: ItemInfo):
path = item.text_encoder_output_cache_path
if not path or not os.path.exists(path):
return
try:
with safetensors_utils.MemoryEfficientSafeOpen(path) as f:
meta = f.metadata()
if meta.get("architecture") != ARCHITECTURE_KANDINSKY5_FULL:
logger.warning(
f"Removing text-encoder cache with mismatched architecture: {path} "
f"(found {meta.get('architecture')}, expected {ARCHITECTURE_KANDINSKY5_FULL})"
)
os.remove(path)
except Exception as e:
logger.warning(f"Failed to read existing cache {path} ({e}); removing to regenerate.")
os.remove(path)
def encode_and_save_batch(text_embedder, batch: list[ItemInfo], device: torch.device):
prompts = [item.caption for item in batch]
# Keep the cache encoder aligned with training/inference: use video template when the batch contains videos.
is_video_batch = any((item.frame_count or 1) > 1 for item in batch)
content_type = "video" if is_video_batch else "image"
embeds, cu_seqlens, attention_mask = text_embedder.encode(prompts, type_of_content=content_type)
text_embeds = embeds["text_embeds"].to("cpu")
pooled_embed = embeds["pooled_embed"].to("cpu")
attention_mask = attention_mask.to("cpu")
if text_embeds.dim() == 2 and attention_mask.dim() == 2 and cu_seqlens is not None and cu_seqlens.numel() == len(batch) + 1:
# Variable-length packed embeds: slice by cu_seqlens per item.
for idx, item in enumerate(batch):
start = int(cu_seqlens[idx].item())
end = int(cu_seqlens[idx + 1].item())
te = text_embeds[start:end]
pe = pooled_embed[idx]
am = attention_mask[idx].bool().flatten()
if am.numel() != te.shape[0]:
if am.sum().item() == te.shape[0]:
am = am[am]
else:
am = torch.ones((te.shape[0],), dtype=torch.bool)
_ensure_cache_architecture(item)
save_text_encoder_output_cache_kandinsky5(item, te, pe, am)
else:
# Fallback: per-item tensors already aligned on batch dim.
for item, te, pe, am in zip(batch, text_embeds, pooled_embed, attention_mask):
_ensure_cache_architecture(item)
save_text_encoder_output_cache_kandinsky5(item, te, pe, am)
def main():
parser = cache_text_encoder_outputs.setup_parser_common()
parser.add_argument("--text_encoder_qwen", type=str, required=True, help="Qwen2.5-VL checkpoint path")
parser.add_argument("--text_encoder_clip", type=str, required=True, help="CLIP text encoder checkpoint path")
parser.add_argument("--qwen_max_length", type=int, default=512, help="Max length for Qwen tokenizer")
parser.add_argument("--clip_max_length", type=int, default=77, help="Max length for CLIP tokenizer")
parser.add_argument("--quantized_qwen", action="store_true", help="Load Qwen text encoder in 4bit mode")
args = parser.parse_args()
device = args.device if args.device is not None else "cuda" if torch.cuda.is_available() else "cpu"
device = torch.device(device)
blueprint_generator = BlueprintGenerator(ConfigSanitizer())
logger.info(f"Load dataset config from {args.dataset_config}")
user_config = config_utils.load_user_config(args.dataset_config)
blueprint = blueprint_generator.generate(user_config, args, architecture=ARCHITECTURE_KANDINSKY5)
train_dataset_group = config_utils.generate_dataset_group_by_blueprint(blueprint.dataset_group)
datasets = train_dataset_group.datasets
all_cache_files_for_dataset, all_cache_paths_for_dataset = cache_text_encoder_outputs.prepare_cache_files_and_paths(datasets)
text_embedder_conf = SimpleNamespace(
qwen=SimpleNamespace(checkpoint_path=args.text_encoder_qwen, max_length=args.qwen_max_length),
clip=SimpleNamespace(checkpoint_path=args.text_encoder_clip, max_length=args.clip_max_length),
)
text_embedder = get_text_embedder(
text_embedder_conf,
device=device,
quantized_qwen=args.quantized_qwen,
)
def encode_for_text_encoder(batch: list[ItemInfo]):
encode_and_save_batch(text_embedder, batch, device)
cache_text_encoder_outputs.process_text_encoder_batches(
args.num_workers,
args.skip_existing,
args.batch_size,
datasets,
all_cache_files_for_dataset,
all_cache_paths_for_dataset,
encode_for_text_encoder,
)
# remove cache files not in dataset
cache_text_encoder_outputs.post_process_cache_files(
datasets, all_cache_files_for_dataset, all_cache_paths_for_dataset, args.keep_cache
)
if __name__ == "__main__":
main()
|