diff --git a/.gitignore b/.gitignore index d6e2115..61bba4d 100644 --- a/.gitignore +++ b/.gitignore @@ -13,9 +13,15 @@ data/ *.pt *.pkl *.bin -*.png -*.jpg +# *.png +# *.jpg *.mp4 *.gif debug* + +.env + +wandb/ + +tmp*/ diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..9250849 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,46 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "Debug PowerPaint (Accelerate)", + "type": "debugpy", + "request": "launch", + "module": "accelerate.commands.launch", + "console": "integratedTerminal", + "justMyCode": false, + "env": { + "CUDA_VISIBLE_DEVICES": "2" + }, + "args": [ + "--config_file", "configs/acc.yaml", + "train_idm_pp1_v2.py", + "--config", "configs/idm_pp1.yaml" + ], + "python": "/mnt/disk1/aiotlab/envs/powerpaint/bin/python" + } + ] +} + +// { +// "version": "0.2.0", +// "configurations": [ + +// { +// "name": "Debug PowerPaint (CUDA:2)", +// "type": "debugpy", +// "request": "launch", +// "program": "${workspaceFolder}/test_ppt.py", +// "console": "integratedTerminal", +// "justMyCode": false, +// "args": [ +// "--config", +// "configs/test.yaml" +// ], +// "env": { +// "CUDA_VISIBLE_DEVICES": "2", +// "CUDA_LAUNCH_BLOCKING": "1" +// } +// } +// ] +// } + diff --git a/configs/acc.yaml b/configs/acc.yaml index c67a194..b2824da 100644 --- a/configs/acc.yaml +++ b/configs/acc.yaml @@ -1,6 +1,6 @@ compute_environment: LOCAL_MACHINE deepspeed_config: {} -distributed_type: MULTI_GPU +distributed_type: NO fsdp_config: {} machine_rank: 0 main_process_ip: null @@ -8,5 +8,5 @@ main_process_port: null main_training_function: main mixed_precision: fp16 num_machines: 1 -num_processes: 8 +num_processes: 1 use_cpu: false diff --git a/configs/finetune_Ploc.yaml b/configs/finetune_Ploc.yaml new file mode 100644 index 0000000..802bb7b --- /dev/null +++ b/configs/finetune_Ploc.yaml @@ -0,0 +1,81 @@ +pretrained_model_name_or_path: "/workdir/radish/hachi/checkpoints/stable-diffusion-inpainting" +ppt1_model_path: "/workdir/radish/hachi/checkpoints/ppt-v1" +#tracker_project_name: "ppt1_finetune_bs64" +#report_to: "wandb" +output_dir: "/workdir/radish/hachi/New_ouput_3" + +# learnable task prompts +task_prompt: + indomain_inpainting: + placeholder_tokens: "P_loc" + initializer_token: "P_ctxt" + num_vectors_per_token: 10 + +# training data +train_data: + resolution: 512 + datasets: + name: "FSC147" + data_path: "/workdir/radish/hachi/OBJ_INS/phase2_V2/train" + +# training hyper-parameters +num_train_epochs: 20 +lr_warmup_steps: 200 +learning_rate: 1e-5 +max_train_steps: 8e3 # max training steps +train_batch_size: 64 # batch size per GPU +dataloader_num_workers: 8 + +gradient_checkpointing: true + +checkpointing_steps: 2e2 +validation_steps: 2e2 +checkpoints_total_limit: 10 +# resume_from_checkpoint: "latest" + + +# validation data +validation_data: + data_root: "/home/hachi/obj-ins/PowerPaint/validation/" + cases: + - image: "test/2_b1/ground_truth.png" # cần resize + mask: "test/2_b1/mask.png" # cần bbox mask + name: 2_b1 + prompt: + - task: "indomain_inpainting" + prompt: "" + negative_prompt: "" + promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A seashell + promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A seashell + tradeoff: 1.0 + negative_promptA: "" + negative_promptB: "" + - task: "indomain_inpainting" + prompt: "" + negative_prompt: "" + promptA: P_obj A seashell + promptB: P_obj A seashell + tradeoff: 1.0 + negative_promptA: "" + negative_promptB: "" + + - image: "val/560_b3/ground_truth.png" # cần resize + mask: "val/560_b3/mask.png" # cần bbox mask + name: 560_b3 + prompt: + - task: "indomain_inpainting" + prompt: "" + negative_prompt: "" + promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo + promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo + tradeoff: 1.0 + negative_promptA: "" + negative_promptB: "" + - task: "indomain_inpainting" + prompt: "" + negative_prompt: "" + promptA: P_obj A flamingo + promptB: P_obj A flamingo + tradeoff: 1.0 + negative_promptA: "" + negative_promptB: "" diff --git a/configs/idm_pp1.yaml b/configs/idm_pp1.yaml new file mode 100644 index 0000000..f6fb953 --- /dev/null +++ b/configs/idm_pp1.yaml @@ -0,0 +1,218 @@ +base_model_path: "/mnt/disk1/aiotlab/hachi/checkpoints/stable-diffusion-inpainting" +ppt1_checkpoint: "/mnt/disk1/aiotlab/hachi/checkpoints/ppt-v1" +tracker_project_name: "idm_pp1_density_map" +report_to: "tensorboard" +output_dir: "/mnt/disk1/aiotlab/hachi/Output/ConvIn+Down0_IDM_PP1_DensityMap_OriginLoss" + +# learnable task prompts +task_prompt: + object_inpainting: + placeholder_tokens: "P_obj" + initializer_token: "a" + num_vectors_per_token: 10 + + indomain_inpainting: + placeholder_tokens: "P_loc" + initializer_token: "P_obj" + num_vectors_per_token: 10 + +# training data +train_root: "/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train" +density_root: "/mnt/disk1/aiotlab/hachi/data/FSC_147/gt_density_map_adaptive_384_VarV2" + +# training hyper-parameters +train_mode: "conv_in+down0" +num_train_epochs: 20 +lr_scheduler: "constant_with_warmup" +lr_warmup_steps: 200 +learning_rate: 2.0e-4 +max_train_steps: 8e3 # max training steps +train_batch_size: 8 # batch size per GPU +by_bucket_sizes: + - size: [512, 512] + value: 8 + - size: [512, 768] + value: 8 + - size: [512, 1024] + value: 8 +dataloader_num_workers: 4 +gradient_accumulation_steps: 4 +gradient_checkpointing: true + +checkpointing_steps: 500 +validation_steps: 500 + + +# validation data +val_root: "/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val" +# validation_data: +# data_root: "/mnt/disk1/aiotlab/hachi/PowerPaint/validation/" +# cases: +# - image: "test/2_b1/ground_truth.png" # cần resize +# mask: "test/2_b1/mask.png" # cần bbox mask +# name: 2_b1 +# prompt: +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A seashell +# promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A seashell +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: P_obj A seashell +# promptB: P_obj A seashell +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" + +# - image: "test/2615_b1/ground_truth.png" # cần resize +# mask: "test/2615_b1/mask.png" # cần bbox mask +# name: 2615_b1 +# prompt: +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A deer +# promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A deer +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: P_obj A deer +# promptB: P_obj A deer +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" + +# - image: "test/7420_b1/ground_truth.png" # cần resize +# mask: "test/7420_b1/mask.png" # cần bbox mask +# name: 7420_b1 +# prompt: +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A deer +# promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A deer +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: P_obj A deer +# promptB: P_obj A deer +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" + + +# - image: "val/560_b3/ground_truth.png" # cần resize +# mask: "val/560_b3/mask.png" # cần bbox mask +# name: 560_b3 +# prompt: +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo +# promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: P_obj A flamingo +# promptB: P_obj A flamingo +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" + +# - image: "val/568_b1/ground_truth.png" # cần resize +# mask: "val/568_b1/mask.png" # cần bbox mask +# name: 568_b1 +# prompt: +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo +# promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: P_obj A flamingo +# promptB: P_obj A flamingo +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" + +# - image: "val/573_b3/ground_truth.png" # cần resize +# mask: "val/573_b3/mask.png" # cần bbox mask +# name: 573_b3 +# prompt: +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo +# promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: P_obj A flamingo +# promptB: P_obj A flamingo +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" + +# - image: "val/578_b2/ground_truth.png" # cần resize +# mask: "val/578_b2/mask.png" # cần bbox mask +# name: 578_b2 +# prompt: +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo +# promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A flamingo +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: P_obj A flamingo +# promptB: P_obj A flamingo +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" + +# - image: "val/3536_b3/ground_truth.png" # cần resize +# mask: "val/3536_b3/mask.png" # cần bbox mask +# name: 3536_b3 +# prompt: +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: ${task_prompt.indomain_inpainting.placeholder_tokens} A chicken wing +# promptB: ${task_prompt.indomain_inpainting.placeholder_tokens} A chicken wing +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" +# - task: "indomain_inpainting" +# prompt: "" +# negative_prompt: "" +# promptA: P_obj A chicken wing +# promptB: P_obj A chicken wing +# tradeoff: 1.0 +# negative_promptA: "" +# negative_promptB: "" \ No newline at end of file diff --git a/configs/test.yaml b/configs/test.yaml new file mode 100644 index 0000000..1d5badd --- /dev/null +++ b/configs/test.yaml @@ -0,0 +1,91 @@ +pretrained_model_name_or_path: "/workdir/radish/hachi/checkpoints/stable-diffusion-inpainting" +ppt1_model_path: "/workdir/radish/hachi/checkpoints/ppt-v1" +#tracker_project_name: "ppt1_finetune_bs64" +#report_to: "wandb" +output_dir: "/workdir/radish/hachi/New_ouput_3" + +# learnable task prompts +task_prompt: + object_inpainting: + placeholder_tokens: "P_obj" + initializer_token: "a" + num_vectors_per_token: 10 + + context_inpainting: + placeholder_tokens: "P_ctxt" + initializer_token: "a" + num_vectors_per_token: 10 + + shape_inpainting: + placeholder_tokens: "P_shape" + initializer_token: "a" + num_vectors_per_token: 10 + +# training data +train_data: + resolution: 512 + datasets: + name: "FSC147" + data_path: "/workdir/radish/hachi/OBJ_INS/phase2_V2/train" + +# training hyper-parameters +num_train_epochs: 20 +lr_warmup_steps: 200 +learning_rate: 1e-5 +max_train_steps: 8e3 # max training steps +train_batch_size: 64 # batch size per GPU +dataloader_num_workers: 8 + +gradient_checkpointing: true + +checkpointing_steps: 2e2 +validation_steps: 2e2 +checkpoints_total_limit: 10 +# resume_from_checkpoint: "latest" + + +# validation data +validation_data: + data_root: "/home/hachi/obj-ins/PowerPaint/validation/" + cases: + - image: "test/2_b1/ground_truth.png" # cần resize + mask: "test/2_b1/mask.png" # cần bbox mask + name: 2_b1 + prompt: + - task: "indomain_inpainting" + prompt: "" + negative_prompt: "" + promptA: ${task_prompt.context_inpainting.placeholder_tokens} A seashell + promptB: ${task_prompt.context_inpainting.placeholder_tokens} A seashell + tradeoff: 1.0 + negative_promptA: "" + negative_promptB: "" + - task: "indomain_inpainting" + prompt: "" + negative_prompt: "" + promptA: P_obj A seashell + promptB: P_obj A seashell + tradeoff: 1.0 + negative_promptA: "" + negative_promptB: "" + + - image: "val/560_b3/ground_truth.png" # cần resize + mask: "val/560_b3/mask.png" # cần bbox mask + name: 560_b3 + prompt: + - task: "indomain_inpainting" + prompt: "" + negative_prompt: "" + promptA: ${task_prompt.context_inpainting.placeholder_tokens} A flamingo + promptB: ${task_prompt.context_inpainting.placeholder_tokens} A flamingo + tradeoff: 1.0 + negative_promptA: "" + negative_promptB: "" + - task: "indomain_inpainting" + prompt: "" + negative_prompt: "" + promptA: P_obj A flamingo + promptB: P_obj A flamingo + tradeoff: 1.0 + negative_promptA: "" + negative_promptB: "" diff --git a/eval/__init__.py b/eval/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/eval/counterfactual.py b/eval/counterfactual.py new file mode 100644 index 0000000..655c19b --- /dev/null +++ b/eval/counterfactual.py @@ -0,0 +1,92 @@ +import os +import torch +from powerpaint.utils.infer import sample_ddim_inpaint_density +from powerpaint.utils.vis import save_img, save_gray, save_grid + +@torch.no_grad() +def infer_val_counterfactual(pipe, unet, text_encoder, vae, val_dataloader, args, accelerator, + global_step: int, weight_dtype, num_batches=2, steps=30, seed=1234): + if not accelerator.is_main_process: + return + + out_dir = os.path.join(args.output_dir, "val_infer", f"step-{global_step}") + os.makedirs(out_dir, exist_ok=True) + + unet.eval(); text_encoder.eval(); + + deltas_zero, deltas_shuf = [], [] + + for bi, batch in enumerate(val_dataloader): + if bi >= num_batches: break + device = accelerator.device + + # chạy 3 variant với cùng seed -> so sánh “đúng” (counterfactual) + out_real = sample_ddim_inpaint_density( + pipe=pipe, unet=unet, text_encoder=text_encoder, vae=vae, + batch=batch, weight_dtype=weight_dtype, num_inference_steps=steps, + seed=seed+bi, density_variant="real" + ) + out_zero = sample_ddim_inpaint_density( + pipe=pipe, unet=unet, text_encoder=text_encoder, vae=vae, + batch=batch, weight_dtype=weight_dtype, num_inference_steps=steps, + seed=seed+bi, density_variant="zero" + ) + out_shuf = sample_ddim_inpaint_density( + pipe=pipe, unet=unet, text_encoder=text_encoder, vae=vae, + batch=batch, weight_dtype=weight_dtype, num_inference_steps=steps, + seed=seed+bi, density_variant="shuf" + ) + + # input + mask + density để compose + pv = batch["pixel_values"].to(device=device, dtype=weight_dtype) + mask = batch["mask"].to(device=device, dtype=weight_dtype) + density = batch["density"].to(device=device, dtype=weight_dtype) + + inp = ((pv.clamp(-1,1) + 1) * 0.5).float() + m = (mask > 0.5).float() + m3 = m.repeat(1,3,1,1) + + comp_real = out_real*m3 + inp*(1-m3) + comp_zero = out_zero*m3 + inp*(1-m3) + comp_shuf = out_shuf*m3 + inp*(1-m3) + + denom = m3.sum(dim=(1,2,3)).clamp_min(1.0) + d0 = (torch.abs(comp_real-comp_zero)*m3).sum(dim=(1,2,3))/denom + ds = (torch.abs(comp_real-comp_shuf)*m3).sum(dim=(1,2,3))/denom + deltas_zero += d0.detach().cpu().tolist() + deltas_shuf += ds.detach().cpu().tolist() + + # save vài ảnh + k = min(4, comp_real.shape[0]) + for i in range(k): + sid = batch.get("id", None) + if isinstance(sid, (list, tuple)): + sid = sid[i] + elif isinstance(sid, torch.Tensor): + sid = str(sid[i].item()) + sid = sid or f"b{bi}_i{i}" + + sub = os.path.join(out_dir, sid) + os.makedirs(sub, exist_ok=True) + save_img(os.path.join(sub, "00_input.png"), inp[i].cpu()) + save_gray(os.path.join(sub, "01_mask.png"), m[i].cpu()) + save_gray(os.path.join(sub, "02_density.png"), density[i].cpu()) + save_img(os.path.join(sub, "10_comp_real.png"), comp_real[i].cpu()) + save_img(os.path.join(sub, "11_comp_zero.png"), comp_zero[i].cpu()) + save_img(os.path.join(sub, "12_comp_shuf.png"), comp_shuf[i].cpu()) + grid = torch.stack([inp[i].cpu(), comp_real[i].cpu(), comp_zero[i].cpu(), comp_shuf[i].cpu()], dim=0) + save_grid(os.path.join(sub, "grid.png"), grid, nrow=4) + + if deltas_zero: + dz = torch.tensor(deltas_zero) + ds = torch.tensor(deltas_shuf) + stats = { + "val/delta_real_zero_mean": dz.mean().item(), + "val/delta_real_shuf_mean": ds.mean().item(), + "val/delta_real_zero_p50": dz.median().item(), + "val/delta_real_shuf_p50": ds.median().item(), + } + accelerator.log(stats, step=global_step) + print(f"[infer_val] {stats} -> {out_dir}") + + unet.train(); text_encoder.train(); diff --git a/eval/infer_pipeline.py b/eval/infer_pipeline.py new file mode 100644 index 0000000..f9536a0 --- /dev/null +++ b/eval/infer_pipeline.py @@ -0,0 +1,102 @@ +import torch +from powerpaint.pipelines.pipeline_indomain_ppt1 import StableDiffusionInpaintIndomainPipeline + +device = "cuda" + +# folder checkpoint đã save kiểu diffusers (vae/, unet/, text_encoder/, tokenizer/, scheduler/) +ckpt_dir = "/path/to/your/output_dir_or_checkpoint" + +pipe = StableDiffusionInpaintIndomainPipeline.from_pretrained( + ckpt_dir, + torch_dtype=torch.float16, + safety_checker=None, + feature_extractor=None, +).to(device) + +pipe.set_progress_bar_config(disable=True) + +@torch.no_grad() +def infer_one_batch(pipe, batch, *, promptA, promptB, steps=30, seed=1234, tradoff=1.0, tradoff_nag=1.0): + # batch tensors (theo doc preprocess: image [-1,1], mask [0,1]) :contentReference[oaicite:2]{index=2} + image = batch["pixel_values"].to(device=device, dtype=torch.float32) # [-1, 1] + mask = batch["mask"].to(device=device, dtype=torch.float32) # [0, 1] (pipeline sẽ binarize) :contentReference[oaicite:3]{index=3} + density = batch["density"].to(device=device, dtype=torch.float32) # [0, 1] (kênh extra 10ch) :contentReference[oaicite:4]{index=4} + + # bucket size (nếu bạn có) + if "bucket_hw" in batch: + H, W = batch["bucket_hw"] + if isinstance(H, torch.Tensor): H = int(H[0].item()) + if isinstance(W, torch.Tensor): W = int(W[0].item()) + else: + # hoặc tự set theo data của bạn + H, W = image.shape[-2], image.shape[-1] + + gen = torch.Generator(device=device).manual_seed(seed) + + out = pipe( + promptA=promptA, + promptB=promptB, + image=image, + mask=mask, + density=density, + height=H, + width=W, + strength=1.0, + tradoff=tradoff, # pipeline dùng để mix embed A/B :contentReference[oaicite:5]{index=5} + tradoff_nag=tradoff_nag, # mix negative A/B :contentReference[oaicite:6]{index=6} + num_inference_steps=steps, + guidance_scale=7.5, # <=1.0 => không CFG (do_classifier_free_guidance=False) :contentReference[oaicite:7]{index=7} + negative_promptA="", + negative_promptB="", + generator=gen, + output_type="pt", # nếu version diffusers bạn support; không thì dùng "np" hoặc "pil" + return_dict=True, + ) + + # out.images thường là torch [B,3,H,W] trong [0,1] (vì postprocess) :contentReference[oaicite:8]{index=8} + return out.images + +# ví dụ: +# imgs = infer_one_batch(pipe, batch, promptA="...", promptB="...", steps=30, seed=1234, tradoff=0.8, tradoff_nag=0.8) +@torch.no_grad() +def log_validation(pipe, accelerator, task_prompt, batch, step, tradoff=1.0): + pipe.set_progress_bar_config(disable=True) + pipe.eval() + + # batch tensors (theo doc preprocess: image [-1,1], mask [0,1]) :contentReference[oaicite:2]{index=2} + image = batch["pixel_values"].to(device=device, dtype=torch.float32) # [-1, 1] + mask = batch["mask"].to(device=device, dtype=torch.float32) # [0, 1] (pipeline sẽ binarize) :contentReference[oaicite:3]{index=3} + density = batch["density"].to(device=device, dtype=torch.float32) # [0, 1] (kênh extra 10ch) :contentReference[oaicite:4]{index=4} + + # bucket size (nếu bạn có) + if "bucket_hw" in batch: + H, W = batch["bucket_hw"][0] + if isinstance(H, torch.Tensor): H = int(H[0].item()) + if isinstance(W, torch.Tensor): W = int(W[0].item()) + else: + # hoặc tự set theo data của bạn + H, W = image.shape[-2], image.shape[-1] + + bz = image.shape[0] + promptA = [] + promptB = [] + for i in range(bz): + prompt = batch["prompt"][i] + promptA.append(f"{task_prompt.object_inpainting.placeholder_tokens} {prompt}") + promptB.append(f"{task_prompt.object_inpainting.placeholder_tokens} {prompt}") + + with torch.autocast(accelerator.device.type): + out = pipe( + promptA=promptA, + promptB=promptB, + image=image, + mask=mask, + density=density, + height=H, + width=W, + ) + + + + + diff --git a/eval/pipe_counterfactual.py b/eval/pipe_counterfactual.py new file mode 100644 index 0000000..22c79d3 --- /dev/null +++ b/eval/pipe_counterfactual.py @@ -0,0 +1,386 @@ +import os +import math +import numpy as np +import torch +from PIL import Image + +def _to_uint8_img(x_chw_01: torch.Tensor) -> np.ndarray: + """x: [C,H,W] in [0,1] -> uint8 [H,W,C]""" + x = x_chw_01.detach().clamp(0, 1).cpu() + x = (x * 255.0 + 0.5).to(torch.uint8) + x = x.permute(1, 2, 0).numpy() + return x + +def save_img(path: str, x_chw_01: torch.Tensor): + arr = _to_uint8_img(x_chw_01) + Image.fromarray(arr).save(path) + +def save_gray(path: str, x_1hw_01: torch.Tensor): + """x: [1,H,W] or [H,W] in [0,1] -> grayscale PNG""" + x = x_1hw_01.detach().clamp(0, 1).cpu() + if x.ndim == 3: + x = x[0] + arr = (x * 255.0 + 0.5).to(torch.uint8).numpy() + Image.fromarray(arr, mode="L").save(path) + +def save_grid(path: str, imgs_nchw_01: torch.Tensor, nrow: int = 4, pad: int = 2): + """ + imgs: [N,3,H,W] in [0,1] + grid = concat theo hàng, có padding trắng + """ + imgs = imgs_nchw_01.detach().clamp(0, 1).cpu() + N, C, H, W = imgs.shape + nrow = max(1, nrow) + ncol = min(nrow, N) + nrows = math.ceil(N / nrow) + + grid_h = nrows * H + (nrows - 1) * pad + grid_w = ncol * W + (ncol - 1) * pad + grid = torch.ones((C, grid_h, grid_w), dtype=imgs.dtype) # nền trắng + + for idx in range(N): + r = idx // nrow + c = idx % nrow + top = r * (H + pad) + left = c * (W + pad) + grid[:, top:top+H, left:left+W] = imgs[idx] + + save_img(path, grid) + +# @torch.no_grad() +# def infer_counterfactual_3( +# pipe, +# batch, +# *, +# out_dir: str, +# global_step: int = 0, +# accelerator=None, # optional +# seed: int = 1234, +# tradoff: float = 1.0, +# tradoff_nag: float = 1.0, +# save_k: int = 4, # lưu tối đa k ảnh trong batch +# ): +# # chỉ main process mới save/log +# if accelerator is not None and (not accelerator.is_main_process): +# return None + +# pipe.safety_checker = None +# device = next(pipe.unet.parameters()).device + +# # lấy H,W theo bucket nếu có +# if "bucket_hw" in batch: +# H, W = batch["bucket_hw"] +# if isinstance(H, torch.Tensor): H = int(H[0].item()) +# if isinstance(W, torch.Tensor): W = int(W[0].item()) +# else: +# H, W = batch["pixel_values"].shape[-2], batch["pixel_values"].shape[-1] +# dtype = pipe.unet.dtype +# image = batch["pixel_values"].to(device=device, dtype=dtype) # [-1,1] +# mask = batch["mask"].to(device=device, dtype=dtype) # [0,1] +# density = batch["density"].to(device=device, dtype=dtype) # [0,1] +# bsz = image.shape[0] + +# promptA = [] +# promptB = [] +# for i in range(bsz): +# prompt = batch["prompt"][i] +# promptA.append(f"P_obj {prompt}") +# promptB.append(f"P_obj {prompt}") + +# # để compose/log: input về [0,1] +# inp = ((image.clamp(-1, 1) + 1) * 0.5).float() +# m = (mask > 0.5).float() +# m3 = m.repeat(1, 3, 1, 1) + +# def run_with_density(density_in: torch.Tensor): +# with torch.autocast(accelerator.device.type): +# out = pipe( +# promptA=promptA, +# promptB=promptB, +# image=image, +# mask=mask, +# density=density_in, +# height=H, +# width=W, +# tradoff=tradoff, +# tradoff_nag=tradoff_nag, +# output_type="pt", +# return_dict=True, +# ).images +# return out # [B,3,H,W] in [0,1] + +# # 3 biến thể +# out_real = run_with_density(density) + +# out_zero = run_with_density(torch.zeros_like(density)) + +# perm = torch.randperm(bsz, device=device) +# out_shuf = run_with_density(density[perm]) + +# # compose vùng ngoài mask lấy input gốc +# comp_real = out_real * m3 + inp * (1 - m3) +# comp_zero = out_zero * m3 + inp * (1 - m3) +# comp_shuf = out_shuf * m3 + inp * (1 - m3) + +# # delta trong vùng mask +# denom = m3.sum(dim=(1, 2, 3)).clamp_min(1.0) +# d0 = (torch.abs(comp_real - comp_zero) * m3).sum(dim=(1, 2, 3)) / denom +# ds = (torch.abs(comp_real - comp_shuf) * m3).sum(dim=(1, 2, 3)) / denom + +# stats = { +# "val/delta_real_zero_mean": d0.mean().item(), +# "val/delta_real_shuf_mean": ds.mean().item(), +# "val/delta_real_zero_p50": d0.median().item(), +# "val/delta_real_shuf_p50": ds.median().item(), +# } + +# # log +# if accelerator is not None and hasattr(accelerator, "log"): +# accelerator.log(stats, step=global_step) +# print(f"[infer_cf] step={global_step} stats={stats}") + +# # save ảnh +# step_dir = os.path.join(out_dir, f"step-{global_step}") +# os.makedirs(step_dir, exist_ok=True) + +# k = min(save_k, bsz) +# for i in range(k): +# sid = batch.get("id", None) +# if isinstance(sid, (list, tuple)): +# sid = sid[i] +# elif isinstance(sid, torch.Tensor): +# sid = str(sid[i].item()) +# sid = sid or f"i{i}" + +# sub = os.path.join(step_dir, sid) +# os.makedirs(sub, exist_ok=True) + +# save_img(os.path.join(sub, "00_input.png"), inp[i].cpu()) +# save_gray(os.path.join(sub, "01_mask.png"), m[i].cpu()) +# save_gray(os.path.join(sub, "02_density_real.png"), density[i].cpu()) + +# # cũng lưu density_shuf/zero để debug +# save_gray(os.path.join(sub, "02_density_zero.png"), torch.zeros_like(density[i]).cpu()) +# save_gray(os.path.join(sub, "02_density_shuf.png"), density[perm][i].cpu()) + +# save_img(os.path.join(sub, "10_comp_real.png"), comp_real[i].cpu()) +# save_img(os.path.join(sub, "11_comp_zero.png"), comp_zero[i].cpu()) +# save_img(os.path.join(sub, "12_comp_shuf.png"), comp_shuf[i].cpu()) + +# grid = torch.stack( +# [inp[i].cpu(), comp_real[i].cpu(), comp_zero[i].cpu(), comp_shuf[i].cpu()], +# dim=0 +# ) +# save_grid(os.path.join(sub, "grid.png"), grid, nrow=4, pad=2) + +# return stats + + + +# ----------------------------- +# Helpers: mask -> bbox, draw bbox on image tensor +# ----------------------------- +def mask_to_bbox(mask_1hw: torch.Tensor, thresh: float = 0.5, pad: int = 2): + """ + mask_1hw: [1,H,W] hoặc [H,W], float/bool + return (x0, y0, x1, y1) theo pixel index (xyxy), hoặc None nếu mask rỗng + """ + m = mask_1hw + if m.ndim == 3: + m = m[0] + m = (m > thresh) + + ys, xs = torch.where(m) + if ys.numel() == 0: + return None + + y0 = int(ys.min().item()) + y1 = int(ys.max().item()) + x0 = int(xs.min().item()) + x1 = int(xs.max().item()) + + H, W = m.shape[-2], m.shape[-1] + x0 = max(0, x0 - pad) + y0 = max(0, y0 - pad) + x1 = min(W - 1, x1 + pad) + y1 = min(H - 1, y1 + pad) + return (x0, y0, x1, y1) + + +def draw_bbox(img_3hw: torch.Tensor, bbox, color=(1.0, 0.0, 0.0), thickness: int = 3): + """ + img_3hw: [3,H,W] float trong [0,1] + bbox: (x0,y0,x1,y1) hoặc None + """ + if bbox is None: + return img_3hw + x0, y0, x1, y1 = bbox + img = img_3hw.clone() + + c = torch.tensor(color, dtype=img.dtype, device=img.device).view(3, 1) # [3,1] + + H, W = img.shape[-2], img.shape[-1] + x0 = max(0, min(W - 1, x0)); x1 = max(0, min(W - 1, x1)) + y0 = max(0, min(H - 1, y0)); y1 = max(0, min(H - 1, y1)) + if x1 < x0 or y1 < y0: + return img + + for t in range(thickness): + yt0 = max(0, y0 - t) + yt1 = min(H - 1, y1 + t) + xt0 = max(0, x0 - t) + xt1 = min(W - 1, x1 + t) + + # top & bottom + img[:, yt0, xt0:xt1 + 1] = c + img[:, yt1, xt0:xt1 + 1] = c + # left & right + img[:, yt0:yt1 + 1, xt0] = c + img[:, yt0:yt1 + 1, xt1] = c + + return img + + +@torch.no_grad() +def infer_counterfactual_3( + pipe, + batch, + *, + out_dir: str, + global_step: int = 0, + accelerator=None, # optional + seed: int = 1234, + tradoff: float = 1.0, + tradoff_nag: float = 1.0, + save_k: int = 4, # lưu tối đa k ảnh trong batch + bbox_pad: int = 2, + bbox_thickness: int = 3, +): + # chỉ main process mới save/log + if accelerator is not None and (not accelerator.is_main_process): + return None + pipe.set_progress_bar_config(disable=True) + pipe.safety_checker = None + device = next(pipe.unet.parameters()).device + + # lấy H,W theo bucket nếu có + if "bucket_hw" in batch: + H, W = batch["bucket_hw"] + if isinstance(H, torch.Tensor): H = int(H[0].item()) + if isinstance(W, torch.Tensor): W = int(W[0].item()) + else: + H, W = batch["pixel_values"].shape[-2], batch["pixel_values"].shape[-1] + + dtype = pipe.unet.dtype + image = batch["pixel_values"].to(device=device, dtype=dtype) # [-1,1] + mask = batch["mask"].to(device=device, dtype=dtype) # [0,1] + density = batch["density"].to(device=device, dtype=dtype) # [0,1] + bsz = image.shape[0] + + promptA, promptB = [], [] + for i in range(bsz): + prompt = batch["prompt"][i] + promptA.append(f"P_obj {prompt}") + promptB.append(f"P_obj {prompt}") + + # để compose/log: input về [0,1] + inp = ((image.clamp(-1, 1) + 1) * 0.5).float() + m = (mask > 0.5).float() + m3 = m.repeat(1, 3, 1, 1) + + # --- chạy pipe (robust autocast ngay cả khi accelerator=None) --- + autocast_device = (accelerator.device.type if accelerator is not None else device.type) + gen = torch.Generator(device=device).manual_seed(seed) + + def run_with_density(density_in: torch.Tensor): + with torch.autocast(autocast_device): + out = pipe( + promptA=promptA, + promptB=promptB, + image=image, + mask=mask, + density=density_in, + height=H, + width=W, + tradoff=tradoff, + tradoff_nag=tradoff_nag, + output_type="pt", + return_dict=True, + generator=gen, # giữ tính "counterfactual" theo seed + ).images + return out # [B,3,H,W] in [0,1] + + # 1 biến thể + out_real = run_with_density(density) + out_zero = run_with_density(torch.zeros_like(density)) + + # compose vùng ngoài mask lấy input gốc + comp_real = out_real * m3 + inp * (1 - m3) + comp_zero = out_zero * m3 + inp * (1 - m3) + + # delta trong vùng mask + denom = m3.sum(dim=(1, 2, 3)).clamp_min(1.0) + d0 = (torch.abs(comp_real - comp_zero) * m3).sum(dim=(1, 2, 3)) / denom + + stats = { + "val/delta_real_zero_mean": d0.mean().item(), + "val/delta_real_zero_p50": d0.median().item(), + } + + # log + if accelerator is not None and hasattr(accelerator, "log"): + accelerator.log(stats, step=global_step) + print(f"[infer_cf] step={global_step} stats={stats}") + + # save ảnh + step_dir = os.path.join(out_dir, f"step-{global_step}") + os.makedirs(step_dir, exist_ok=True) + + k = min(save_k, bsz) + for i in range(k): + sid = batch.get("id", None) + if isinstance(sid, (list, tuple)): + sid = sid[i] + elif isinstance(sid, torch.Tensor): + sid = str(sid[i].item()) + sid = sid or f"i{i}" + + sub = os.path.join(step_dir, sid) + os.makedirs(sub, exist_ok=True) + + # --- compute bbox từ mask (CPU) --- + mi = m[i].detach().cpu() # [1,H,W] + bbox = mask_to_bbox(mi, thresh=0.5, pad=bbox_pad) + + # --- tensors CPU để save + vẽ bbox --- + inp_i = inp[i].detach().cpu() + cr_i = comp_real[i].detach().cpu() + cz_i = comp_zero[i].detach().cpu() + + inp_bbox = draw_bbox(inp_i, bbox, thickness=bbox_thickness) + cr_bbox = draw_bbox(cr_i, bbox, thickness=bbox_thickness) + cz_bbox = draw_bbox(cz_i, bbox, thickness=bbox_thickness) + + # # lưu gốc + # save_img(os.path.join(sub, "00_input.png"), inp_i) + # save_gray(os.path.join(sub, "01_mask.png"), mi) + save_gray(os.path.join(sub, "02_density_real.png"), density[i].detach().cpu()) + + # cũng lưu density_shuf/zero để debug + save_gray(os.path.join(sub, "02_density_zero.png"), torch.zeros_like(density[i]).detach().cpu()) + + # save_img(os.path.join(sub, "10_comp_real.png"), cr_i) + # save_img(os.path.join(sub, "11_comp_zero.png"), cz_i) + + # grid = torch.stack([inp_i, cr_i, cz_i], dim=0) + # save_grid(os.path.join(sub, "grid.png"), grid, nrow=3, pad=2) + + # # lưu phiên bản có bbox + # save_img(os.path.join(sub, "00_input_bbox.png"), inp_bbox) + # save_img(os.path.join(sub, "10_comp_real_bbox.png"), cr_bbox) + # save_img(os.path.join(sub, "11_comp_zero_bbox.png"), cz_bbox) + + grid_bbox = torch.stack([inp_bbox, cr_bbox, cz_bbox], dim=0) + save_grid(os.path.join(sub, "grid_bbox.png"), grid_bbox, nrow=3, pad=2) + + return stats \ No newline at end of file diff --git a/examples/cake.jpg b/examples/cake.jpg deleted file mode 100644 index dba55ac..0000000 Binary files a/examples/cake.jpg and /dev/null differ diff --git a/infer.py b/infer.py new file mode 100644 index 0000000..a7bb8ff --- /dev/null +++ b/infer.py @@ -0,0 +1,112 @@ +import argparse +import os +import torch +from torch.utils.data import DataLoader +from omegaconf import OmegaConf +from safetensors.torch import load_model +from tqdm import tqdm + +from powerpaint.datasets.fsc_147 import build_index_val, FSCDataset, BucketBatchSampler +from powerpaint.pipelines import StableDiffusionInpaintIndomainPipeline +from powerpaint.utils.utils import TokenizerWrapper, add_tokens, expand_unet_conv_in + +from eval.pipe_counterfactual import infer_counterfactual_3 + + + +def parse_args(): + parser = argparse.ArgumentParser(description="Inference script using a trained PowerPaint checkpoint.") + parser.add_argument("--config", type=str, default=None, help="Optional yaml config used during training.") + parser.add_argument("--infer_txt", type=str, default="val_2.txt", help="Text file listing validation sample subdirectories.") + parser.add_argument("--output_folder_name", type=str, default="inference", help="Where to write prediction results") + parser.add_argument("--checkpoint", type=str, default=None, help="Path to checkpoint directory") + return parser.parse_args() + + +def main(): + args = parse_args() + + # load yaml config if provided (this will add attributes such as + # base_model_path, task_prompt, train_root etc. to the args namespace) + if args.config is not None: + print(f"Loading config from {args.config}") + conf = OmegaConf.load(args.config) + for k, v in conf.items(): + setattr(args, k, v) + + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + + # build the pipeline exactly as in training + pipe = StableDiffusionInpaintIndomainPipeline.from_pretrained( + args.base_model_path, + torch_dtype=torch.float32, + local_files_only=True, + ) + pipe.tokenizer = TokenizerWrapper( + from_pretrained=args.base_model_path, + subfolder="tokenizer", + torch_dtype=torch.float32, + local_files_only=True, + ) + + # make sure learned tokens are present (the config should contain + # the same placeholder list used during training) + add_tokens( + tokenizer=pipe.tokenizer, + text_encoder=pipe.text_encoder, + placeholder_tokens=["P_ctxt", "P_shape", "P_obj"], + initialize_tokens=["a", "a", "a"], + num_vectors_per_token=10, + ) + # the training script expanded conv_in, replicate the change here + pipe.unet = expand_unet_conv_in(pipe.unet, extra_in_channels=1, init="mean_scaled") + + # load the checkpoint weights that were produced during training + load_model(pipe.unet, os.path.join(args.checkpoint, "unet/diffusion_pytorch_model.safetensors")) + load_model(pipe.text_encoder, os.path.join("/mnt/disk1/aiotlab/hachi/checkpoints/ppt-v1/text_encoder/text_encoder.safetensors"), strict=False) + + + pipe = pipe.to(device) + pipe.set_progress_bar_config(disable=True) + pipe.safety_checker = None + + # prepare validation dataloader + by_bucket_sizes = { + tuple(item["size"]): item["value"] + for item in args.by_bucket_sizes + } + infer_items = build_index_val(args.infer_txt, args.density_root) + if not hasattr(args, "task_prompt") or args.task_prompt is None: + raise ValueError("task_prompt is required for dataset construction. Provide --config pointing to the training YAML.") + infer_dataset = FSCDataset(infer_items, pipeline=pipe, task_prompt=args.task_prompt, train=False) + infer_sampler = BucketBatchSampler( + dataset=infer_dataset, + by_bucket_sizes=by_bucket_sizes, + shuffle=False, + drop_last=False, + bucket_sampling="proportional" + ) + infer_dataloader = DataLoader( + dataset=infer_dataset, + batch_sampler=infer_sampler, + num_workers=args.dataloader_num_workers, + ) + + out_dir = os.path.join(args.output_dir, args.output_folder_name) + os.makedirs(out_dir, exist_ok=True) + with torch.no_grad(): + for bi, batch in tqdm(enumerate(infer_dataloader), total=len(infer_dataloader)): + stats = infer_counterfactual_3( + pipe, batch, + out_dir=out_dir, + global_step=0, + accelerator=None, + seed=1234 + bi, + tradoff=1.0, + tradoff_nag=1.0, + save_k=4, + ) + + +if __name__ == "__main__": + main() diff --git a/infer.sh b/infer.sh new file mode 100644 index 0000000..f1bf6ff --- /dev/null +++ b/infer.sh @@ -0,0 +1,5 @@ +python infer.py \ + --checkpoint /mnt/disk1/aiotlab/hachi/Output/ConvIn+Down0_IDM_PP1_DensityMap/checkpoint-6000 \ + --config /mnt/disk1/aiotlab/hachi/PowerPaint/configs/idm_pp1.yaml \ + --infer_txt train.txt \ + --output_folder_name train_txt/cp-6000 \ \ No newline at end of file diff --git a/install.sh b/install.sh new file mode 100644 index 0000000..8a49d50 --- /dev/null +++ b/install.sh @@ -0,0 +1,9 @@ +# cài môi trường +conda create -n powerpaint python=3.9 -y +conda activate powerpaint +python -m pip install -r requirements/requirements.txt +# load checkpoint +conda install git-lfs -y +git lfs install +git lfs clone https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-inpainting/ ./checkpoints/stable-diffusion-inpainting +git lfs clone https://huggingface.co/JunhaoZhuang/PowerPaint-v1/ ./checkpoints/ppt-v1 \ No newline at end of file diff --git a/powerpaint/datasets/FSC147.py b/powerpaint/datasets/FSC147.py new file mode 100644 index 0000000..c0b63ba --- /dev/null +++ b/powerpaint/datasets/FSC147.py @@ -0,0 +1,206 @@ +import json +import os +import random + +import cv2 +import numpy as np +import torch +from accelerate.logging import get_logger +from PIL import Image +from torch.utils.data import Dataset +from torchvision import transforms + + +logger = get_logger(__name__) + +def load_data(data_path): + data_info_list = [] + for img_folder in os.listdir(data_path): + try: + # load data + with open(os.path.join(data_path, img_folder, 'annotation.json'), 'r') as f: + anno = json.load(f) + mask_bbox = anno['inpainted_bboxes'][0] + loc_bbox = anno['inpainted_bboxes'][1] + prompt = anno['class_based_caption'] + img_path = os.path.join(data_path, img_folder, 'ground_truth.jpg') + data_info = { + "img_path": img_path, + "mask_bbox": mask_bbox, + "loc_bbox": loc_bbox, + "prompt": prompt + } + data_info_list.append(data_info) + except: + continue + + return data_info_list + +def augment_images(img_path, mask_bbox, loc_bbox, resolution): + """ + Crop và resize img về kích thước resolution, thay đổi tọa độ bbox tương ứng. + Đảm bảo crop vào phần có mask_bbox và loc_bbox + parameters: + img_path: path to img + mask_bbox, loc_bbox: (x1, y1, x2, y2) theo tọa độ ảnh gốc + return: + img: numpy.ndarray [resolution x resolution x 3] + mask: numpy.ndarray [resolution x resolution] + loc_bbox: [x,y,x,y] + """ + img = cv2.imread(img_path) + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + h, w = img.shape[:2] + + # Kích thước hình vuông crop + square_size = min(h, w) + half = square_size // 2 + + # Hai bbox cần đảm bảo nằm trong crop + bboxes = np.array([mask_bbox, loc_bbox]) + + # Tìm min/max của toàn bộ vùng cần cover + x_min = np.min(bboxes[:, 0]) + y_min = np.min(bboxes[:, 1]) + x_max = np.max(bboxes[:, 2]) + y_max = np.max(bboxes[:, 3]) + + # Tâm ban đầu + cx = (x_min + x_max)/2 + cy = (y_min + y_max)/2 + + # Crop ban đầu + crop_x1 = int(cx - half) + crop_y1 = int(cy-half) + crop_x2 = crop_x1 + square_size + crop_y2 = crop_y1 + square_size + + # Hàm dịch crop vào trong ảnh + def shift_into_image(x1, y1, x2, y2, W, H): + dx1 = max(0, -x1) + dy1 = max(0, -y1) + dx2 = max(0, x2 - W) + dy2 = max(0, y2 - H) + return x1 + dx1 - dx2, y1 + dy1 - dy2, x2 + dx1 - dx2, y2 + dy1 - dy2 + + crop_x1, crop_y1, crop_x2, crop_y2 = shift_into_image( + crop_x1, crop_y1, crop_x2, crop_y2, w, h + ) + + # Kiểm tra đảm bảo chứa đủ bbox + for (bx1, by1, bx2, by2) in bboxes: + if not (crop_x1 <= bx1 and bx2 <= crop_x2 and crop_y1 <= by1 and by2 <= crop_y2): + logger.info(f"{img_path} Bbox quá to, không thể chứa trong crop hình vuông min(h,w).") + + # Crop + crop = img[crop_y1:crop_y2, crop_x1:crop_x2] + + # Resize + resized = cv2.resize(crop, (resolution, resolution)) + scale = resolution/square_size + + # Chuyển toạ độ bbox + def convert_bbox(bbox): + x1, y1, x2, y2 = bbox + x1 = int((x1 - crop_x1) * scale) + y1 = int((y1 - crop_y1) * scale) + x2 = int((x2 - crop_x1) * scale) + y2 = int((y2 - crop_y1) * scale) + return [x1, y1, x2, y2] + + new_mask_bbox = convert_bbox(mask_bbox) + new_loc_bbox = convert_bbox(loc_bbox) + + # Tạo mask + mask = np.zeros((resolution, resolution), dtype=np.uint8) + x1, y1, x2, y2 = new_mask_bbox + mask[y1:y2, x1:x2] = 255 + + + return resized, mask, new_loc_bbox + + +class FSCDataset(Dataset): + """ + Dataset class for Fine-tuning PowerPaint on custom local data. + """ + def __init__( + self, + data_path, + transforms, + pipeline, + task_prompt, + resolution + ): + self.transforms = transforms + self.pipeline = pipeline + self.task_prompt = task_prompt + self.resolution = resolution + + self.data_info_list = load_data(data_path) + + + def __len__(self): + return len(self.data_info_list) + + def __getitem__(self, idx): + # Cơ chế retry: Nếu load lỗi ảnh này, tự động lấy ảnh ngẫu nhiên khác + # try: + return self._get_item_inner(idx) + # except Exception as e: + # logger.info(f"Error loading index {idx}: {e}. Retrying with random index...") + # return self.__getitem__(random.randint(0, len(self) - 1)) + + def _get_item_inner(self, idx): + data_info = self.data_info_list[idx] + + output = {} + img, mask, loc_bbox = augment_images(data_info['img_path'], data_info['mask_bbox'], data_info['loc_bbox'], self.resolution) + ToT = transforms.ToTensor() + if self.transforms: + img = Image.fromarray(img).convert('RGB') + output["pixel_values"] = self.transforms(img) + else: + img = Image.fromarray(img).convert('RGB') + + # convert to tensors + img = ToT(img) + + # normalize the image with mean and std + normalize = transforms.Normalize(mean=[0.5], std=[0.5]) + img = normalize(img) + + output["pixel_values"] = img + + mask = Image.fromarray(mask).convert('L') + mask = ToT(mask) + mask[mask != 0] = 1 + output["mask"] = mask + + + + if random.random() < 0.3: + prompt = "" + else: + prompt = data_info['prompt'] + + promptA = self.task_prompt.indomain_inpainting.placeholder_tokens + promptB = self.task_prompt.indomain_inpainting.placeholder_tokens + promptA, promptB = f"{promptA} {prompt}", f"{promptB} {prompt}" + + + prompt = self.pipeline.maybe_convert_prompt(prompt, self.pipeline.tokenizer) + promptA = self.pipeline.maybe_convert_prompt(promptA, self.pipeline.tokenizer) + promptB = self.pipeline.maybe_convert_prompt(promptB, self.pipeline.tokenizer) + output["input_idsA"], output["input_idsB"], output["input_ids"] = self.pipeline.tokenizer( + [promptA, promptB, prompt], + max_length=self.pipeline.tokenizer.model_max_length, + padding="max_length", + truncation=True, + return_tensors="pt", + ).input_ids + alpha = torch.tensor((1.0, 0.0)) + output["tradeoff"] = alpha + + return output + diff --git a/powerpaint/datasets/__init__.py b/powerpaint/datasets/__init__.py index 4ee7acb..3048435 100644 --- a/powerpaint/datasets/__init__.py +++ b/powerpaint/datasets/__init__.py @@ -1,48 +1,48 @@ -import random -from typing import List - -from torch.utils.data import IterableDataset - -from .laion import LaionIterJsonDataset -from .openimage import OpenImageBLIPaug_Dataset - - -class ProbPickingDataset(IterableDataset): - """A dataset wrapper for picking dataset with probability.""" - - def __init__(self, datasets: List[dict]): - super().__init__() - assert sum([dataset["prob"] for dataset in datasets]) == 1 - - self.dataset_list = [] - self.range_list = [] - - start_idx = 0 - for dataset_prob in datasets: - dataset = dataset_prob["dataset"] - prob = dataset_prob["prob"] - end_idx = start_idx + prob - self.dataset_list.append(iter(dataset)) - self.range_list.append([start_idx, end_idx]) - start_idx = end_idx - - def __iter__(self): - while True: - rand_num = random.random() - for idx, (s, e) in enumerate(self.range_list): - if s <= rand_num < e: - iterator = self.dataset_list[idx] - try: - data = next(iterator) - except StopIteration: - iterator = iter(self.dataset_list[idx]) - self.dataset_list[idx] = iterator - data = next(iterator) - yield data - - def __len__(self): - # pesudo length - return 999_999_999 - - -__all__ = ["OpenImageBLIPaug_Dataset", "LaionIterJsonDataset", "ProbPickingDataset"] +# import random +# from typing import List + +# from torch.utils.data import IterableDataset + +# from .laion import LaionIterJsonDataset +# from .openimage import OpenImageBLIPaug_Dataset + + +# class ProbPickingDataset(IterableDataset): +# """A dataset wrapper for picking dataset with probability.""" + +# def __init__(self, datasets: List[dict]): +# super().__init__() +# assert sum([dataset["prob"] for dataset in datasets]) == 1 + +# self.dataset_list = [] +# self.range_list = [] + +# start_idx = 0 +# for dataset_prob in datasets: +# dataset = dataset_prob["dataset"] +# prob = dataset_prob["prob"] +# end_idx = start_idx + prob +# self.dataset_list.append(iter(dataset)) +# self.range_list.append([start_idx, end_idx]) +# start_idx = end_idx + +# def __iter__(self): +# while True: +# rand_num = random.random() +# for idx, (s, e) in enumerate(self.range_list): +# if s <= rand_num < e: +# iterator = self.dataset_list[idx] +# try: +# data = next(iterator) +# except StopIteration: +# iterator = iter(self.dataset_list[idx]) +# self.dataset_list[idx] = iterator +# data = next(iterator) +# yield data + +# def __len__(self): +# # pesudo length +# return 999_999_999 + + +# __all__ = ["OpenImageBLIPaug_Dataset", "LaionIterJsonDataset", "ProbPickingDataset"] diff --git a/powerpaint/datasets/fsc_147.py b/powerpaint/datasets/fsc_147.py new file mode 100644 index 0000000..e7aa5db --- /dev/null +++ b/powerpaint/datasets/fsc_147.py @@ -0,0 +1,484 @@ +import os +import json +import random +import math +import numpy as np +from collections import defaultdict +from typing import List, Dict, Optional, Tuple, Iterator +from dataclasses import dataclass + +import torch +from torch.utils.data import Dataset, Sampler +import torchvision.transforms.functional as TF +from torchvision.transforms import InterpolationMode +from PIL import Image + + +# ----------------------------- +# Buckets + transforms (from our earlier logic) +# ----------------------------- +BUCKETS = [(512, 512), (512, 768), (512, 1024)] # (H, W) + +def choose_bucket(h: int, w: int) -> Tuple[int, int]: + ar = w / h + best = None + best_d = 1e9 + for Hb, Wb in BUCKETS: + ar_b = Wb / Hb + d = abs(math.log(ar / ar_b)) + if d < best_d: + best_d = d + best = (Hb, Wb) + return best + +def resize_cover(img: torch.Tensor, out_h: int, out_w: int, interp: InterpolationMode) -> torch.Tensor: + # img: [C,H,W] + _, h, w = img.shape + scale = max(out_h / h, out_w / w) + new_h = int(math.ceil(h * scale)) + new_w = int(math.ceil(w * scale)) + return TF.resize(img, [new_h, new_w], interpolation=interp, antialias=True) + +def crop(img: torch.Tensor, top: int, left: int, out_h: int, out_w: int) -> torch.Tensor: + return img[:, top:top + out_h, left:left + out_w] + +def bucket_transform( + image: torch.Tensor, # [3,H,W] float in [0,1] + mask: torch.Tensor, # [1,H,W] 0/1 + density: torch.Tensor, # [1,H,W] float + bucket_hw: Tuple[int, int], + train: bool = True, + rng: Optional[random.Random] = None, +) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + Hb, Wb = bucket_hw + if rng is None: + rng = random + + image_r = resize_cover(image, Hb, Wb, InterpolationMode.BICUBIC) + density_r = resize_cover(density, Hb, Wb, InterpolationMode.BILINEAR) + mask_r = resize_cover(mask, Hb, Wb, InterpolationMode.NEAREST) + + _, Hr, Wr = image_r.shape + if train: + top = rng.randint(0, Hr - Hb) + left = rng.randint(0, Wr - Wb) + else: + top = (Hr - Hb) // 2 + left = (Wr - Wb) // 2 + + image_c = crop(image_r, top, left, Hb, Wb) + density_c = crop(density_r, top, left, Hb, Wb) + mask_c = crop(mask_r, top, left, Hb, Wb) + + # safety: keep mask binary + mask_c = (mask_c > 0.5).float() + return image_c, mask_c, density_c + +def preprocess_density( + density: torch.Tensor, # [1,H,W] + c: float = 0.023632803931832314, # p99.9 from your stats + use_log: bool = False, + k: float = 10.0 +) -> torch.Tensor: + d = density.clamp(min=0.0) + d = (d.clamp(max=c) / c) # [0,1] + if use_log: + d = torch.log1p(d * k) / math.log1p(k) + return d + +def bbox_to_mask_xyxy( + bbox: List[float], + h: int, + w: int, + expand_ratio: Optional[float] = 0.1, # giãn theo % + expand_pixels: Optional[int] = None # hoặc giãn theo pixel +) -> torch.Tensor: + """ + bbox: [x1, y1, x2, y2] in pixel coords (xyxy). + expand_ratio: expand each side by ratio * bbox_size (default 10%) + expand_pixels: expand each side by fixed pixels (override ratio if set) + Returns mask [1,H,W] float {0,1}. + """ + + x1, y1, x2, y2 = bbox + + # --- compute expansion --- + bw = x2 - x1 + bh = y2 - y1 + + if expand_pixels is not None: + dx = dy = expand_pixels + else: + dx = bw * expand_ratio + dy = bh * expand_ratio + + # --- expand bbox --- + x1 -= dx + x2 += dx + y1 -= dy + y2 += dy + + # --- round --- + x1 = int(math.floor(x1)) + y1 = int(math.floor(y1)) + x2 = int(math.ceil(x2)) + y2 = int(math.ceil(y2)) + + # --- clamp --- + x1 = max(0, min(w, x1)) + x2 = max(0, min(w, x2)) + y1 = max(0, min(h, y1)) + y2 = max(0, min(h, y2)) + + # --- create mask --- + m = torch.zeros((1, h, w), dtype=torch.float32) + if x2 > x1 and y2 > y1: + m[:, y1:y2, x1:x2] = 1.0 + + return m + +# ----------------------------- +# Index building from your folder structure +# ----------------------------- +@dataclass +class SampleItem: + sample_id: str + img_path: str + ann_path: str + density_path: str + orig_hw: Tuple[int, int] # (H, W) + bucket_hw: Tuple[int, int] # (Hb, Wb) + +def build_index(train_root: str, density_root: str, max_num: int = None) -> List[SampleItem]: + """ + train_root: + train/img1/img.png + train/img1/annotation.json + density_root: + Density/img1.npy + """ + items: List[SampleItem] = [] + subdirs = sorted([d for d in os.listdir(train_root) if os.path.isdir(os.path.join(train_root, d))]) + + for i, sid in enumerate(subdirs): + if max_num: + if i > max_num: + break + img_path = os.path.join(train_root, sid, "ground_truth.jpg") + ann_path = os.path.join(train_root, sid, "annotation.json") + den_path = os.path.join(density_root, f"{sid.split('_')[0]}.npy") + + # read size cheaply + with Image.open(img_path) as im: + w, h = im.size + + bucket_hw = choose_bucket(h, w) + items.append(SampleItem( + sample_id=sid, + img_path=img_path, + ann_path=ann_path, + density_path=den_path, + orig_hw=(h, w), + bucket_hw=bucket_hw, + )) + + if len(items) == 0: + raise RuntimeError("No valid samples found. Check paths and filenames.") + return items + +def build_index_val(val_txt: str, density_root: str, max_num: int = None) -> List[SampleItem]: + items: List[SampleItem] = [] + + subdirs = [] + with open(val_txt, 'r') as f: + for line in f: + subdirs.append(line.strip()) + + for i, sid in enumerate(subdirs): + if max_num: + if i > max_num: + break + img_path = os.path.join(sid, "ground_truth.jpg") + ann_path = os.path.join(sid, "annotation.json") + den_path = os.path.join(density_root, f"{sid.split('/')[-1][:-3]}.npy") + + # read size cheaply + with Image.open(img_path) as im: + w, h = im.size + + bucket_hw = choose_bucket(h, w) + items.append(SampleItem( + sample_id=sid.split('/')[-1], + img_path=img_path, + ann_path=ann_path, + density_path=den_path, + orig_hw=(h, w), + bucket_hw=bucket_hw, + )) + + if len(items) == 0: + raise RuntimeError("No valid samples found. Check paths and filenames.") + return items + + +# ----------------------------- +# Dataset +# ----------------------------- +class FSCDataset(Dataset): + """ + Diffusers-friendly training dataset for SD1.5 inpainting + extra density channel. + Returns dict with: + - pixel_values: float tensor [3,Hb,Wb] in [-1, 1] + - mask: float tensor [1,Hb,Wb] in {0,1} (binary) + - density: float tensor [1,Hb,Wb] in [0,1] after preprocessing + - prompt: str + - bucket_hw: (Hb, Wb) + - id: optional identifier + """ + + def __init__( + self, + items: List[SampleItem], + pipeline, + task_prompt, + *, + density_clip_c: float = 0.023632803931832314, + density_use_log: bool = False, + density_log_k: float = 10.0, + density_dropout_p: float = 0.0, # set >0.0 if you want dataset-level dropout + mask_threshold: int = 127, + train: bool = True, + seed: int = 0, + ): + self.pipeline = pipeline + self.task_prompt = task_prompt + + self.items = items + self.density_clip_c = float(density_clip_c) + self.density_use_log = bool(density_use_log) + self.density_log_k = float(density_log_k) + self.density_dropout_p = float(density_dropout_p) + + self.mask_threshold = int(mask_threshold) + self.train = bool(train) + + # For fast bucketing in sampler + self.bucket_hw_list = [it.bucket_hw for it in items] + + self._rng = random.Random(seed) + + def __len__(self) -> int: + return len(self.items) + + def __getitem__(self, idx: int) -> Dict[str, object]: + it = self.items[idx] + + # load image + image = Image.open(it.img_path).convert("RGB") + image = TF.to_tensor(image) # [3,H,W] in [0,1] + + # load annotation + with open(it.ann_path, "r", encoding="utf-8") as f: + ann = json.load(f) + prompt = ann.get("class_based_caption", "") + ## bbox + bboxes = ann.get("inpainted_bboxes", None) + if bboxes is None: + raise ValueError(f"Missing 'bbox' in {it.ann_path}") + bbox = bboxes[0] + + H, W = image.shape[-2:] + mask = bbox_to_mask_xyxy(bbox, H, W) # [1,H,W] + + # load density + d = np.load(it.density_path).astype(np.float32) + if d.ndim == 3: + if d.shape[0] == 1: + d = d[0] + elif d.shape[-1] == 1: + d = d[..., 0] + else: + d = d[..., 0] + density = torch.from_numpy(d)[None, ...] # [1,H,W] + + # sanity alignment + if density.shape[-2:] != (H, W): + raise ValueError(f"Density shape mismatch for {it.sample_id}: density {tuple(density.shape)} vs image {(H,W)}") + + # preprocess density + density = preprocess_density( + density, + c=self.density_clip_c, + use_log=self.density_use_log, + k=self.density_log_k, + ) + + # optional density dropout + if self.train: + if self.density_dropout_p > 0.0 and self._rng.random() < self.density_dropout_p: + density = torch.zeros_like(density) + + # bucket resize+crop (aligned) + image, mask, density = bucket_transform( + image, mask, density, + bucket_hw=it.bucket_hw, + train=self.train, + rng=self._rng, + ) + + # clamp numeric noise from interpolation – keeps pixel_values ∈ [-1,1] + image = image.clamp(0.0, 1.0) + + # SD expects image normalized to [-1, 1] before VAE encode + pixel_values = image * 2.0 - 1.0 + + if self.train and (self._rng.random() < 0.0): + prompt = "" + + promptA = self.task_prompt.object_inpainting.placeholder_tokens + promptB = self.task_prompt.object_inpainting.placeholder_tokens + promptA, promptB = f"{promptA} {prompt}", f"{promptB} {prompt}" + prompt = self.pipeline.maybe_convert_prompt(prompt, self.pipeline.tokenizer) + promptA = self.pipeline.maybe_convert_prompt(promptA, self.pipeline.tokenizer) + promptB = self.pipeline.maybe_convert_prompt(promptB, self.pipeline.tokenizer) + input_idsA, input_idsB, input_ids = self.pipeline.tokenizer( + [promptA, promptB, prompt], + max_length=self.pipeline.tokenizer.model_max_length, + padding="max_length", + truncation=True, + return_tensors="pt", + ).input_ids + + alpha = torch.tensor((1.0, 0.0)) + + return { + "pixel_values": pixel_values, # [3,Hb,Wb] in [-1,1] + "mask": mask, # [1,Hb,Wb] 0/1 + "density": density, # [1,Hb,Wb] in [0,1] + "prompt": prompt, + "bucket_hw": it.bucket_hw, # tuple(Hb,Wb) + "id": it.sample_id, + "input_idsA": input_idsA, + "input_idsB": input_idsB, + "input_ids": input_ids, + "tradeoff": alpha, + } + +class BucketBatchSampler(Sampler[List[int]]): + """ + Yields batches of indices, where each batch contains indices from the SAME bucket. + Works with a dataset that returns sample["bucket_hw"] = (H, W). + + Two modes: + - by_bucket_sizes=None: fixed batch_size for all buckets + - by_bucket_sizes={(H,W): bs, ...}: variable batch size per bucket + + drop_last: drop incomplete batches inside each bucket. + """ + def __init__( + self, + dataset: Dataset, + batch_size: int = 8, + by_bucket_sizes: Optional[Dict[Tuple[int, int], int]] = None, + shuffle: bool = True, + drop_last: bool = False, + seed: int = 0, + max_samples_per_epoch: Optional[int] = None, + bucket_sampling: str = "proportional", # "proportional" or "uniform" + ): + self.dataset = dataset + self.batch_size = batch_size + self.by_bucket_sizes = by_bucket_sizes + self.shuffle = shuffle + self.drop_last = drop_last + self.seed = seed + self.max_samples_per_epoch = max_samples_per_epoch + assert bucket_sampling in ["proportional", "uniform"] + self.bucket_sampling = bucket_sampling + + # Precompute bucket -> list of indices + self.bucket_to_indices = defaultdict(list) + for i in range(len(dataset)): + # dataset __getitem__ may be expensive, so we try: + # 1) if dataset has precomputed bucket meta, use it + # 2) else fall back to a light call to dataset.get_bucket_hw(i) if you implement it + # 3) else call dataset[i] once (slower) to read bucket_hw + if hasattr(dataset, "bucket_hw_list"): + bhw = dataset.bucket_hw_list[i] + elif hasattr(dataset, "get_bucket_hw"): + bhw = dataset.get_bucket_hw(i) + else: + bhw = dataset[i]["bucket_hw"] + self.bucket_to_indices[tuple(bhw)].append(i) + + self.buckets = sorted(list(self.bucket_to_indices.keys())) + + def _bucket_bs(self, bucket_hw: Tuple[int, int]) -> int: + if self.by_bucket_sizes is not None: + return int(self.by_bucket_sizes[bucket_hw]) + return int(self.batch_size) + + def __len__(self) -> int: + # approximate length in batches for one epoch + total_batches = 0 + for b in self.buckets: + n = len(self.bucket_to_indices[b]) + bs = self._bucket_bs(b) + if self.drop_last: + total_batches += n // bs + else: + total_batches += math.ceil(n/bs) + return total_batches + + def __iter__(self) -> Iterator[List[int]]: + rng = random.Random(self.seed) + + # Copy & shuffle indices within each bucket + bucket_lists = {b: list(idxs) for b, idxs in self.bucket_to_indices.items()} + if self.shuffle: + for b in self.buckets: + rng.shuffle(bucket_lists[b]) + + # Create per-bucket batch queues + bucket_batches = defaultdict(list) + for b in self.buckets: + bs = self._bucket_bs(b) + idxs = bucket_lists[b] + for j in range(0, len(idxs), bs): + batch = idxs[j:j+bs] + if len(batch) < bs and self.drop_last: + continue + bucket_batches[b].append(batch) + + # Decide order of emitting buckets + # proportional: bucket appears proportionally to number of batches it has + # uniform: alternate buckets more evenly (oversamples small buckets if max_samples_per_epoch is None) + bucket_order = [] + if self.bucket_sampling == "proportional": + for b in self.buckets: + bucket_order += [b] * len(bucket_batches[b]) + else: # uniform + # round-robin over buckets until all exhausted + active = [b for b in self.buckets if len(bucket_batches[b]) > 0] + k = 0 + while active: + b = active[k % len(active)] + bucket_order.append(b) + k += 1 + # We'll pop batches later; remove if empty + if len(bucket_batches[b]) <= 1: + active = [x for x in active if x != b] + + if self.shuffle: + rng.shuffle(bucket_order) + + emitted = 0 + # Pop one batch at a time from the chosen bucket + for b in bucket_order: + if not bucket_batches[b]: + continue + batch = bucket_batches[b].pop() + yield batch + emitted += len(batch) + if self.max_samples_per_epoch is not None and emitted >= self.max_samples_per_epoch: + break \ No newline at end of file diff --git a/powerpaint/datasets/utils.py b/powerpaint/datasets/utils.py new file mode 100644 index 0000000..2eb070e --- /dev/null +++ b/powerpaint/datasets/utils.py @@ -0,0 +1,22 @@ +from typing import List, Dict +import torch + +def collate_train(batch: List[Dict]) -> Dict[str, torch.Tensor]: + pixel_values = torch.stack([x["pixel_values"] for x in batch], dim=0) # [B,3,H,W] + masks = torch.stack([x["mask"] for x in batch], dim=0) # [B,1,H,W] + density = torch.stack([x["density"] for x in batch], dim=0) # [B,1,H,W] + + prompts = [x.get("prompt", "") for x in batch] + bucket_hw = batch[0]["bucket_hw"] # same within batch + + out = { + "pixel_values": pixel_values, + "mask": masks, + "density": density, + "prompts": prompts, + "bucket_hw": bucket_hw, + } + # optional ids + if "id" in batch[0]: + out["ids"] = [x["id"] for x in batch] + return out \ No newline at end of file diff --git a/powerpaint/pipelines/__init__.py b/powerpaint/pipelines/__init__.py index 9a0498c..64390ae 100644 --- a/powerpaint/pipelines/__init__.py +++ b/powerpaint/pipelines/__init__.py @@ -1,10 +1,12 @@ from .pipeline_powerpaint import StableDiffusionInpaintPipeline from .pipeline_powerpaint_brushnet import StableDiffusionPowerPaintBrushNetPipeline from .pipeline_powerpaint_controlnet import StableDiffusionControlNetInpaintPipeline +from .pipeline_indomain_ppt1 import StableDiffusionInpaintIndomainPipeline __all__ = [ "StableDiffusionInpaintPipeline", "StableDiffusionControlNetInpaintPipeline", "StableDiffusionPowerPaintBrushNetPipeline", + "StableDiffusionInpaintIndomainPipeline" ] diff --git a/powerpaint/pipelines/pipeline_indomain_ppt1.py b/powerpaint/pipelines/pipeline_indomain_ppt1.py new file mode 100644 index 0000000..014cf67 --- /dev/null +++ b/powerpaint/pipelines/pipeline_indomain_ppt1.py @@ -0,0 +1,1167 @@ +# Copyright 2023 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import inspect +from typing import Any, Callable, Dict, List, Optional, Union + +import numpy as np +import PIL +import torch +from packaging import version +from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer + +from diffusers.configuration_utils import FrozenDict +from diffusers.image_processor import VaeImageProcessor +from diffusers.loaders import FromSingleFileMixin, LoraLoaderMixin, TextualInversionLoaderMixin +from diffusers.models import AsymmetricAutoencoderKL, AutoencoderKL, UNet2DConditionModel +from diffusers.pipelines.pipeline_utils import DiffusionPipeline +from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput +from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker +from diffusers.schedulers import KarrasDiffusionSchedulers +from diffusers.utils import deprecate, is_accelerate_available, is_accelerate_version, logging +from diffusers.utils.torch_utils import randn_tensor + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +def prepare_mask_and_masked_image(image, mask, height, width, return_image: bool = False): + """ + Prepares a pair (image, mask) to be consumed by the Stable Diffusion pipeline. This means that those inputs will be + converted to ``torch.Tensor`` with shapes ``batch x channels x height x width`` where ``channels`` is ``3`` for the + ``image`` and ``1`` for the ``mask``. + + The ``image`` will be converted to ``torch.float32`` and normalized to be in ``[-1, 1]``. The ``mask`` will be + binarized (``mask > 0.5``) and cast to ``torch.float32`` too. + + Args: + image (Union[np.array, PIL.Image, torch.Tensor]): The image to inpaint. + It can be a ``PIL.Image``, or a ``height x width x 3`` ``np.array`` or a ``channels x height x width`` + ``torch.Tensor`` or a ``batch x channels x height x width`` ``torch.Tensor``. + mask (_type_): The mask to apply to the image, i.e. regions to inpaint. + It can be a ``PIL.Image``, or a ``height x width`` ``np.array`` or a ``1 x height x width`` + ``torch.Tensor`` or a ``batch x 1 x height x width`` ``torch.Tensor``. + + + Raises: + ValueError: ``torch.Tensor`` images should be in the ``[-1, 1]`` range. ValueError: ``torch.Tensor`` mask + should be in the ``[0, 1]`` range. ValueError: ``mask`` and ``image`` should have the same spatial dimensions. + TypeError: ``mask`` is a ``torch.Tensor`` but ``image`` is not + (to the other way around). + + Returns: + tuple[torch.Tensor]: The pair (mask, masked_image) as ``torch.Tensor`` with 4 + dimensions: ``batch x channels x height x width``. + """ + + if image is None: + raise ValueError("`image` input cannot be undefined.") + + if mask is None: + raise ValueError("`mask_image` input cannot be undefined.") + + if isinstance(image, torch.Tensor): + if not isinstance(mask, torch.Tensor): + raise TypeError(f"`image` is a torch.Tensor but `mask` (type: {type(mask)} is not") + + # Batch single image + if image.ndim == 3: + assert image.shape[0] == 3, "Image outside a batch should be of shape (3, H, W)" + image = image.unsqueeze(0) + + # Batch and add channel dim for single mask + if mask.ndim == 2: + mask = mask.unsqueeze(0).unsqueeze(0) + + # Batch single mask or add channel dim + if mask.ndim == 3: + # Single batched mask, no channel dim or single mask not batched but channel dim + if mask.shape[0] == 1: + mask = mask.unsqueeze(0) + + # Batched masks no channel dim + else: + mask = mask.unsqueeze(1) + + assert image.ndim == 4 and mask.ndim == 4, "Image and Mask must have 4 dimensions" + assert image.shape[-2:] == mask.shape[-2:], "Image and Mask must have the same spatial dimensions" + assert image.shape[0] == mask.shape[0], "Image and Mask must have the same batch size" + + # Check image is in [-1, 1] + if image.min() < -1 or image.max() > 1: + raise ValueError("Image should be in [-1, 1] range") + + # Check mask is in [0, 1] + if mask.min() < 0 or mask.max() > 1: + raise ValueError("Mask should be in [0, 1] range") + + # Binarize mask + mask[mask < 0.5] = 0 + mask[mask >= 0.5] = 1 + + # Image as float32 + image = image.to(dtype=torch.float32) + elif isinstance(mask, torch.Tensor): + raise TypeError(f"`mask` is a torch.Tensor but `image` (type: {type(image)} is not") + else: + # preprocess image + if isinstance(image, (PIL.Image.Image, np.ndarray)): + image = [image] + if isinstance(image, list) and isinstance(image[0], PIL.Image.Image): + # resize all images w.r.t passed height an width + image = [i.resize((width, height), resample=PIL.Image.LANCZOS) for i in image] + image = [np.array(i.convert("RGB"))[None, :] for i in image] + image = np.concatenate(image, axis=0) + elif isinstance(image, list) and isinstance(image[0], np.ndarray): + image = np.concatenate([i[None, :] for i in image], axis=0) + + image = image.transpose(0, 3, 1, 2) + image = torch.from_numpy(image).to(dtype=torch.float32) / 127.5 - 1.0 + + # preprocess mask + if isinstance(mask, (PIL.Image.Image, np.ndarray)): + mask = [mask] + + if isinstance(mask, list) and isinstance(mask[0], PIL.Image.Image): + mask = [i.resize((width, height), resample=PIL.Image.LANCZOS) for i in mask] + mask = np.concatenate([np.array(m.convert("L"))[None, None, :] for m in mask], axis=0) + mask = mask.astype(np.float32) / 255.0 + elif isinstance(mask, list) and isinstance(mask[0], np.ndarray): + mask = np.concatenate([m[None, None, :] for m in mask], axis=0) + + mask[mask < 0.5] = 0 + mask[mask >= 0.5] = 1 + mask = torch.from_numpy(mask) + + masked_image = image * (mask < 0.5) + + # n.b. ensure backwards compatibility as old function does not return image + if return_image: + return mask, masked_image, image + + return mask, masked_image + +def prepare_density(density, height, width): + """ + Similar to :func:`prepare_mask_and_masked_image` but for the additional + continuous density channel used by the 10‑channel UNet. + The returned tensor has shape ``batch x 1 x height x width`` and dtype + ``torch.float32``; values are in ``[0,1]``. + + Raises: + ValueError: if ``density`` is ``None``. + """ + if density is None: + raise ValueError("`density` input cannot be undefined for a 10‑channel UNet.") + + if isinstance(density, torch.Tensor): + # handle different possible shapes + if density.ndim == 2: # H x W + density = density.unsqueeze(0).unsqueeze(0) + elif density.ndim == 3: + # either (1,H,W) or (B,H,W) + if density.shape[0] == 1: + density = density.unsqueeze(0) + else: + density = density.unsqueeze(1) + assert density.ndim == 4, "Density must have 4 dimensions" + density = density.to(dtype=torch.float32) + else: + # PIL / numpy + if isinstance(density, (PIL.Image.Image, np.ndarray)): + density = [density] + if isinstance(density, list) and isinstance(density[0], PIL.Image.Image): + density = [i.resize((width, height), resample=PIL.Image.LANCZOS) for i in density] + density = np.concatenate([np.array(m.convert("L"))[None, None, :] for m in density], axis=0) + elif isinstance(density, list) and isinstance(density[0], np.ndarray): + density = np.concatenate([m[None, None, :] for m in density], axis=0) + density = density.astype(np.float32) / 255.0 + density = torch.from_numpy(density) + + return density + +class StableDiffusionInpaintIndomainPipeline( + DiffusionPipeline, TextualInversionLoaderMixin, LoraLoaderMixin, FromSingleFileMixin +): + r""" + Pipeline for text-guided image inpainting using Stable Diffusion. + + This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods + implemented for all pipelines (downloading, saving, running on a particular device, etc.). + + The pipeline also inherits the following loading methods: + - [`~loaders.TextualInversionLoaderMixin.load_textual_inversion`] for loading textual inversion embeddings + - [`~loaders.LoraLoaderMixin.load_lora_weights`] for loading LoRA weights + - [`~loaders.LoraLoaderMixin.save_lora_weights`] for saving LoRA weights + + Args: + vae ([`AutoencoderKL`, `AsymmetricAutoencoderKL`]): + Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations. + text_encoder ([`CLIPTextModel`]): + Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). + tokenizer ([`~transformers.CLIPTokenizer`]): + A `CLIPTokenizer` to tokenize text. + unet ([`UNet2DConditionModel`]): + A `UNet2DConditionModel` to denoise the encoded image latents. + scheduler ([`SchedulerMixin`]): + A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of + [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`]. + safety_checker ([`StableDiffusionSafetyChecker`]): + Classification module that estimates whether generated images could be considered offensive or harmful. + Please refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for more details + about a model's potential harms. + feature_extractor ([`~transformers.CLIPImageProcessor`]): + A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`. + """ + + _optional_components = ["safety_checker", "feature_extractor"] + + def __init__( + self, + vae: Union[AutoencoderKL, AsymmetricAutoencoderKL], + text_encoder: CLIPTextModel, + tokenizer: CLIPTokenizer, + unet: UNet2DConditionModel, + scheduler: KarrasDiffusionSchedulers, + safety_checker: StableDiffusionSafetyChecker, + feature_extractor: CLIPImageProcessor, + requires_safety_checker: bool = True, + ): + super().__init__() + + if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1: + deprecation_message = ( + f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`" + f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure " + "to update the config accordingly as leaving `steps_offset` might led to incorrect results" + " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub," + " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`" + " file" + ) + deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False) + new_config = dict(scheduler.config) + new_config["steps_offset"] = 1 + scheduler._internal_dict = FrozenDict(new_config) + + if hasattr(scheduler.config, "skip_prk_steps") and scheduler.config.skip_prk_steps is False: + deprecation_message = ( + f"The configuration file of this scheduler: {scheduler} has not set the configuration" + " `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make" + " sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to" + " incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face" + " Hub, it would be very nice if you could open a Pull request for the" + " `scheduler/scheduler_config.json` file" + ) + deprecate("skip_prk_steps not set", "1.0.0", deprecation_message, standard_warn=False) + new_config = dict(scheduler.config) + new_config["skip_prk_steps"] = True + scheduler._internal_dict = FrozenDict(new_config) + + if safety_checker is None and requires_safety_checker: + logger.warning( + f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure" + " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered" + " results in services or applications open to the public. Both the diffusers team and Hugging Face" + " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling" + " it only for use-cases that involve analyzing network behavior or auditing its results. For more" + " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ." + ) + + if safety_checker is not None and feature_extractor is None: + raise ValueError( + "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety" + " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead." + ) + + is_unet_version_less_0_9_0 = hasattr(unet.config, "_diffusers_version") and version.parse( + version.parse(unet.config._diffusers_version).base_version + ) < version.parse("0.9.0.dev0") + is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64 + if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64: + deprecation_message = ( + "The configuration file of the unet has set the default `sample_size` to smaller than" + " 64 which seems highly unlikely .If you're checkpoint is a fine-tuned version of any of the" + " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-" + " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5" + " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the" + " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`" + " in the config might lead to incorrect results in future versions. If you have downloaded this" + " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for" + " the `unet/config.json` file" + ) + deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False) + new_config = dict(unet.config) + new_config["sample_size"] = 64 + unet._internal_dict = FrozenDict(new_config) + + # Check shapes, assume num_channels_latents == 4, num_channels_mask == 1, num_channels_masked == 4 + if unet.config.in_channels != 9: + logger.info(f"You have loaded a UNet with {unet.config.in_channels} input channels which.") + + self.register_modules( + vae=vae, + text_encoder=text_encoder, + tokenizer=tokenizer, + unet=unet, + scheduler=scheduler, + safety_checker=safety_checker, + feature_extractor=feature_extractor, + ) + self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) + self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor) + self.register_to_config(requires_safety_checker=requires_safety_checker) + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.enable_model_cpu_offload + def enable_model_cpu_offload(self, gpu_id=0): + r""" + Offload all models to CPU to reduce memory usage with a low impact on performance. Moves one whole model at a + time to the GPU when its `forward` method is called, and the model remains in GPU until the next model runs. + Memory savings are lower than using `enable_sequential_cpu_offload`, but performance is much better due to the + iterative execution of the `unet`. + """ + if is_accelerate_available() and is_accelerate_version(">=", "0.17.0.dev0"): + from accelerate import cpu_offload_with_hook + else: + raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.") + + device = torch.device(f"cuda:{gpu_id}") + + if self.device.type != "cpu": + self.to("cpu", silence_dtype_warnings=True) + torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) + + hook = None + for cpu_offloaded_model in [self.text_encoder, self.unet, self.vae]: + _, hook = cpu_offload_with_hook(cpu_offloaded_model, device, prev_module_hook=hook) + + if self.safety_checker is not None: + _, hook = cpu_offload_with_hook(self.safety_checker, device, prev_module_hook=hook) + + # We'll offload the last model manually. + self.final_offload_hook = hook + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._encode_prompt + def _encode_prompt( + self, + promptA, + promptB, + t, + device, + num_images_per_prompt, + do_classifier_free_guidance, + negative_promptA=None, + negative_promptB=None, + t_nag=None, + prompt_embeds: Optional[torch.FloatTensor] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + lora_scale: Optional[float] = None, + ): + r""" + Encodes the prompt into text encoder hidden states. + + Args: + prompt (`str` or `List[str]`, *optional*): + prompt to be encoded + device: (`torch.device`): + torch device + num_images_per_prompt (`int`): + number of images that should be generated per prompt + do_classifier_free_guidance (`bool`): + whether to use classifier free guidance or not + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is + less than `1`). + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input + argument. + lora_scale (`float`, *optional*): + A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded. + """ + # set lora scale so that monkey patched LoRA + # function of text encoder can correctly access it + if lora_scale is not None and isinstance(self, LoraLoaderMixin): + self._lora_scale = lora_scale + + prompt = promptA + negative_prompt = negative_promptA + + if promptA is not None and isinstance(promptA, str): + batch_size = 1 + elif promptA is not None and isinstance(promptA, list): + batch_size = len(promptA) + else: + batch_size = prompt_embeds.shape[0] + + if prompt_embeds is None: + # textual inversion: procecss multi-vector tokens if necessary + if isinstance(self, TextualInversionLoaderMixin): + promptA = self.maybe_convert_prompt(promptA, self.tokenizer) + + text_inputsA = self.tokenizer( + promptA, + padding="max_length", + max_length=self.tokenizer.model_max_length, + truncation=True, + return_tensors="pt", + ) + text_inputsB = self.tokenizer( + promptB, + padding="max_length", + max_length=self.tokenizer.model_max_length, + truncation=True, + return_tensors="pt", + ) + text_input_idsA = text_inputsA.input_ids + text_input_idsB = text_inputsB.input_ids + untruncated_ids = self.tokenizer(promptA, padding="longest", return_tensors="pt").input_ids + + if untruncated_ids.shape[-1] >= text_input_idsA.shape[-1] and not torch.equal( + text_input_idsA, untruncated_ids + ): + removed_text = self.tokenizer.batch_decode( + untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1] + ) + logger.warning( + "The following part of your input was truncated because CLIP can only handle sequences up to" + f" {self.tokenizer.model_max_length} tokens: {removed_text}" + ) + + if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask: + attention_mask = text_inputsA.attention_mask.to(device) + else: + attention_mask = None + + prompt_embedsA = self.text_encoder( + text_input_idsA.to(device), + attention_mask=attention_mask, + ) + prompt_embedsA = prompt_embedsA[0] + + prompt_embedsB = self.text_encoder( + text_input_idsB.to(device), + attention_mask=attention_mask, + ) + prompt_embedsB = prompt_embedsB[0] + prompt_embeds = prompt_embedsA * (t) + (1 - t) * prompt_embedsB + # print("prompt_embeds: ",prompt_embeds) + + if self.text_encoder is not None: + prompt_embeds_dtype = self.text_encoder.dtype + elif self.unet is not None: + prompt_embeds_dtype = self.unet.dtype + else: + prompt_embeds_dtype = prompt_embeds.dtype + + prompt_embeds = prompt_embeds.to(dtype=prompt_embeds_dtype, device=device) + + bs_embed, seq_len, _ = prompt_embeds.shape + # duplicate text embeddings for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) + prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1) + + # get unconditional embeddings for classifier free guidance + if do_classifier_free_guidance and negative_prompt_embeds is None: + uncond_tokensA: List[str] + uncond_tokensB: List[str] + if negative_prompt is None: + uncond_tokensA = [""] * batch_size + uncond_tokensB = [""] * batch_size + elif prompt is not None and type(prompt) is not type(negative_prompt): + raise TypeError( + f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !=" + f" {type(prompt)}." + ) + elif isinstance(negative_prompt, str): + uncond_tokensA = [negative_promptA] + uncond_tokensB = [negative_promptB] + elif batch_size != len(negative_prompt): + raise ValueError( + f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:" + f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches" + " the batch size of `prompt`." + ) + else: + uncond_tokensA = negative_promptA + uncond_tokensB = negative_promptB + + # textual inversion: procecss multi-vector tokens if necessary + if isinstance(self, TextualInversionLoaderMixin): + uncond_tokensA = self.maybe_convert_prompt(uncond_tokensA, self.tokenizer) + uncond_tokensB = self.maybe_convert_prompt(uncond_tokensB, self.tokenizer) + + max_length = prompt_embeds.shape[1] + uncond_inputA = self.tokenizer( + uncond_tokensA, + padding="max_length", + max_length=max_length, + truncation=True, + return_tensors="pt", + ) + uncond_inputB = self.tokenizer( + uncond_tokensB, + padding="max_length", + max_length=max_length, + truncation=True, + return_tensors="pt", + ) + + if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask: + attention_mask = uncond_inputA.attention_mask.to(device) + else: + attention_mask = None + + negative_prompt_embedsA = self.text_encoder( + uncond_inputA.input_ids.to(device), + attention_mask=attention_mask, + ) + negative_prompt_embedsB = self.text_encoder( + uncond_inputB.input_ids.to(device), + attention_mask=attention_mask, + ) + negative_prompt_embeds = negative_prompt_embedsA[0] * (t_nag) + (1 - t_nag) * negative_prompt_embedsB[0] + + # negative_prompt_embeds = negative_prompt_embeds[0] + + if do_classifier_free_guidance: + # duplicate unconditional embeddings for each generation per prompt, using mps friendly method + seq_len = negative_prompt_embeds.shape[1] + + negative_prompt_embeds = negative_prompt_embeds.to(dtype=prompt_embeds_dtype, device=device) + + negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1) + negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) + + # For classifier free guidance, we need to do two forward passes. + # Here we concatenate the unconditional and text embeddings into a single batch + # to avoid doing two forward passes + # print("prompt_embeds: ",prompt_embeds) + prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds]) + + return prompt_embeds + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.run_safety_checker + def run_safety_checker(self, image, device, dtype): + if self.safety_checker is None: + has_nsfw_concept = None + else: + if torch.is_tensor(image): + feature_extractor_input = self.image_processor.postprocess(image, output_type="pil") + else: + feature_extractor_input = self.image_processor.numpy_to_pil(image) + safety_checker_input = self.feature_extractor(feature_extractor_input, return_tensors="pt").to(device) + image, has_nsfw_concept = self.safety_checker( + images=image, clip_input=safety_checker_input.pixel_values.to(dtype) + ) + return image, has_nsfw_concept + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs + def prepare_extra_step_kwargs(self, generator, eta): + # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature + # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. + # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 + # and should be between [0, 1] + + accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys()) + extra_step_kwargs = {} + if accepts_eta: + extra_step_kwargs["eta"] = eta + + # check if the scheduler accepts generator + accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys()) + if accepts_generator: + extra_step_kwargs["generator"] = generator + return extra_step_kwargs + + def check_inputs( + self, + prompt, + height, + width, + strength, + callback_steps, + negative_prompt=None, + prompt_embeds=None, + negative_prompt_embeds=None, + ): + if strength < 0 or strength > 1: + raise ValueError(f"The value of strength should in [0.0, 1.0] but is {strength}") + + if height % 8 != 0 or width % 8 != 0: + raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") + + if (callback_steps is None) or ( + callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0) + ): + raise ValueError( + f"`callback_steps` has to be a positive integer but is {callback_steps} of type" + f" {type(callback_steps)}." + ) + + if prompt is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to" + " only forward one of the two." + ) + elif prompt is None and prompt_embeds is None: + raise ValueError( + "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined." + ) + elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)): + raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") + + if negative_prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if prompt_embeds is not None and negative_prompt_embeds is not None: + if prompt_embeds.shape != negative_prompt_embeds.shape: + raise ValueError( + "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but" + f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`" + f" {negative_prompt_embeds.shape}." + ) + + def prepare_latents( + self, + batch_size, + num_channels_latents, + height, + width, + dtype, + device, + generator, + latents=None, + image=None, + timestep=None, + is_strength_max=True, + return_noise=False, + return_image_latents=False, + ): + shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor) + if isinstance(generator, list) and len(generator) != batch_size: + raise ValueError( + f"You have passed a list of generators of length {len(generator)}, but requested an effective batch" + f" size of {batch_size}. Make sure the batch size matches the length of the generators." + ) + + if (image is None or timestep is None) and not is_strength_max: + raise ValueError( + "Since strength < 1. initial latents are to be initialised as a combination of Image + Noise." + "However, either the image or the noise timestep has not been provided." + ) + + if return_image_latents or (latents is None and not is_strength_max): + image = image.to(device=device, dtype=dtype) + image_latents = self._encode_vae_image(image=image, generator=generator) + + if latents is None: + noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype) + # if strength is 1. then initialise the latents to noise, else initial to image + noise + latents = noise if is_strength_max else self.scheduler.add_noise(image_latents, noise, timestep) + # if pure noise then scale the initial latents by the Scheduler's init sigma + latents = latents * self.scheduler.init_noise_sigma if is_strength_max else latents + else: + noise = latents.to(device) + latents = noise * self.scheduler.init_noise_sigma + + outputs = (latents,) + + if return_noise: + outputs += (noise,) + + if return_image_latents: + outputs += (image_latents,) + + return outputs + + def _encode_vae_image(self, image: torch.Tensor, generator: torch.Generator): + if isinstance(generator, list): + image_latents = [ + self.vae.encode(image[i : i + 1]).latent_dist.sample(generator=generator[i]) + for i in range(image.shape[0]) + ] + image_latents = torch.cat(image_latents, dim=0) + else: + image_latents = self.vae.encode(image).latent_dist.sample(generator=generator) + + image_latents = self.vae.config.scaling_factor * image_latents + + return image_latents + + def prepare_mask_latents( + self, mask, masked_image, batch_size, height, width, dtype, device, generator, do_classifier_free_guidance + ): + # resize the mask to latents shape as we concatenate the mask to the latents + # we do that before converting to dtype to avoid breaking in case we're using cpu_offload + # and half precision + mask = torch.nn.functional.interpolate( + mask, size=(height // self.vae_scale_factor, width // self.vae_scale_factor) + ) + mask = mask.to(device=device, dtype=dtype) + + masked_image = masked_image.to(device=device, dtype=dtype) + masked_image_latents = self._encode_vae_image(masked_image, generator=generator) + + # duplicate mask and masked_image_latents for each generation per prompt, using mps friendly method + if mask.shape[0] < batch_size: + if not batch_size % mask.shape[0] == 0: + raise ValueError( + "The passed mask and the required batch size don't match. Masks are supposed to be duplicated to" + f" a total batch size of {batch_size}, but {mask.shape[0]} masks were passed. Make sure the number" + " of masks that you pass is divisible by the total requested batch size." + ) + mask = mask.repeat(batch_size // mask.shape[0], 1, 1, 1) + if masked_image_latents.shape[0] < batch_size: + if not batch_size % masked_image_latents.shape[0] == 0: + raise ValueError( + "The passed images and the required batch size don't match. Images are supposed to be duplicated" + f" to a total batch size of {batch_size}, but {masked_image_latents.shape[0]} images were passed." + " Make sure the number of images that you pass is divisible by the total requested batch size." + ) + masked_image_latents = masked_image_latents.repeat(batch_size // masked_image_latents.shape[0], 1, 1, 1) + + mask = torch.cat([mask] * 2) if do_classifier_free_guidance else mask + masked_image_latents = ( + torch.cat([masked_image_latents] * 2) if do_classifier_free_guidance else masked_image_latents + ) + + # aligning device to prevent device errors when concatenating it with the latent model input + masked_image_latents = masked_image_latents.to(device=device, dtype=dtype) + return mask, masked_image_latents + + def prepare_density_latents( + self, + density, + batch_size, + height, + width, + dtype, + device, + generator, + do_classifier_free_guidance, + ): + """ + Resize/duplicate the density map and cast it to ``dtype``. This is the + analogue of ``prepare_mask_latents`` for the extra channel. + """ + density = torch.nn.functional.interpolate( + density, size=(height // self.vae_scale_factor, width // self.vae_scale_factor), mode="bilinear", align_corners=False + ) + density = density.to(device=device, dtype=dtype) + + if density.shape[0] < batch_size: + if not batch_size % density.shape[0] == 0: + raise ValueError( + "The passed density maps and the required batch size don't match. " + "Density maps are supposed to be duplicated to a total batch size " + f"of {batch_size}, but {density.shape[0]} were passed. " + "Make sure the number of maps that you pass is divisible by the " + "total requested batch size." + ) + density = density.repeat(batch_size // density.shape[0], 1, 1, 1) + + density = torch.cat([density] * 2) if do_classifier_free_guidance else density + return density + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.get_timesteps + def get_timesteps(self, num_inference_steps, strength, device): + # get the original timestep using init_timestep + init_timestep = min(int(num_inference_steps * strength), num_inference_steps) + + t_start = max(num_inference_steps - init_timestep, 0) + timesteps = self.scheduler.timesteps[t_start * self.scheduler.order :] + + return timesteps, num_inference_steps - t_start + + @torch.no_grad() + def __call__( + self, + promptA: Union[str, List[str]] = None, + promptB: Union[str, List[str]] = None, + image: Union[torch.FloatTensor, PIL.Image.Image] = None, + mask: Union[torch.FloatTensor, PIL.Image.Image] = None, + density: Union[torch.FloatTensor, PIL.Image.Image] = None, + height: Optional[int] = None, + width: Optional[int] = None, + strength: float = 1.0, + tradoff: float = 1.0, + tradoff_nag: float = 1.0, + num_inference_steps: int = 50, + guidance_scale: float = 7.5, + negative_promptA: Optional[Union[str, List[str]]] = None, + negative_promptB: Optional[Union[str, List[str]]] = None, + num_images_per_prompt: Optional[int] = 1, + eta: float = 0.0, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.FloatTensor] = None, + prompt_embeds: Optional[torch.FloatTensor] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None, + callback_steps: int = 1, + cross_attention_kwargs: Optional[Dict[str, Any]] = None, + task_class: Union[torch.Tensor, float, int] = None, + ): + r""" + The call function to the pipeline for generation. + + Args: + prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide image generation. If not defined, you need to pass `prompt_embeds`. + image (`PIL.Image.Image`): + `Image` or tensor representing an image batch to be inpainted (which parts of the image to be masked + out with `mask_image` and repainted according to `prompt`). + mask_image (`PIL.Image.Image`): + `Image` or tensor representing an image batch to mask `image`. White pixels in the mask are repainted + while black pixels are preserved. If `mask_image` is a PIL image, it is converted to a single channel + (luminance) before use. If it's a tensor, it should contain one color channel (L) instead of 3, so the + expected shape would be `(B, H, W, 1)`. + height (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`): + The height in pixels of the generated image. + width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`): + The width in pixels of the generated image. + strength (`float`, *optional*, defaults to 1.0): + Indicates extent to transform the reference `image`. Must be between 0 and 1. `image` is used as a + starting point and more noise is added the higher the `strength`. The number of denoising steps depends + on the amount of noise initially added. When `strength` is 1, added noise is maximum and the denoising + process runs for the full number of iterations specified in `num_inference_steps`. A value of 1 + essentially ignores `image`. + num_inference_steps (`int`, *optional*, defaults to 50): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. This parameter is modulated by `strength`. + guidance_scale (`float`, *optional*, defaults to 7.5): + A higher guidance scale value encourages the model to generate images closely linked to the text + `prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`. + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide what to not include in image generation. If not defined, you need to + pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`). + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + eta (`float`, *optional*, defaults to 0.0): + Corresponds to parameter eta (η) from the [DDIM](https://arxiv.org/abs/2010.02502) paper. Only applies + to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make + generation deterministic. + latents (`torch.FloatTensor`, *optional*): + Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor is generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not + provided, text embeddings are generated from the `prompt` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If + not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generated image. Choose between `PIL.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a + plain tuple. + callback (`Callable`, *optional*): + A function that calls every `callback_steps` steps during inference. The function is called with the + following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`. + callback_steps (`int`, *optional*, defaults to 1): + The frequency at which the `callback` function is called. If not specified, the callback is called at + every step. + cross_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the [`AttentionProcessor`] as defined in + [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + + Examples: + + ```py + >>> import PIL + >>> import requests + >>> import torch + >>> from io import BytesIO + + >>> from diffusers import StableDiffusionInpaintPipeline + + + >>> def download_image(url): + ... response = requests.get(url) + ... return PIL.Image.open(BytesIO(response.content)).convert("RGB") + + + >>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png" + >>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png" + + >>> init_image = download_image(img_url).resize((512, 512)) + >>> mask_image = download_image(mask_url).resize((512, 512)) + + >>> pipe = StableDiffusionInpaintPipeline.from_pretrained( + ... "runwayml/stable-diffusion-inpainting", torch_dtype=torch.float16 + ... ) + >>> pipe = pipe.to("cuda") + + >>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench" + >>> image = pipe(prompt=prompt, image=init_image, mask_image=mask_image).images[0] + ``` + + Returns: + [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`: + If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] is returned, + otherwise a `tuple` is returned where the first element is a list with the generated images and the + second element is a list of `bool`s indicating whether the corresponding generated image contains + "not-safe-for-work" (nsfw) content. + """ + # 0. Default height and width to unet + height = height or self.unet.config.sample_size * self.vae_scale_factor + width = width or self.unet.config.sample_size * self.vae_scale_factor + prompt = promptA + negative_prompt = negative_promptA + # 1. Check inputs + self.check_inputs( + prompt, + height, + width, + strength, + callback_steps, + negative_prompt, + prompt_embeds, + negative_prompt_embeds, + ) + + # 2. Define call parameters + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) + # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` + # corresponds to doing no classifier free guidance. + do_classifier_free_guidance = guidance_scale > 1.0 + + # 3. Encode input prompt + text_encoder_lora_scale = ( + cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None + ) + prompt_embeds = self._encode_prompt( + promptA, + promptB, + tradoff, + device, + num_images_per_prompt, + do_classifier_free_guidance, + negative_promptA, + negative_promptB, + tradoff_nag, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + lora_scale=text_encoder_lora_scale, + ) + + # 4. set timesteps + self.scheduler.set_timesteps(num_inference_steps, device=device) + timesteps, num_inference_steps = self.get_timesteps( + num_inference_steps=num_inference_steps, strength=strength, device=device + ) + # check that number of inference steps is not < 1 - as this doesn't make sense + if num_inference_steps < 1: + raise ValueError( + f"After adjusting the num_inference_steps by strength parameter: {strength}, the number of pipeline" + f"steps is {num_inference_steps} which is < 1 and not appropriate for this pipeline." + ) + # at which timestep to set the initial noise (n.b. 50% if strength is 0.5) + latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt) + # create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise + is_strength_max = strength == 1.0 + + # 5. Preprocess mask and image + mask, masked_image, init_image = prepare_mask_and_masked_image(image, mask, height, width, return_image=True) + mask_condition = mask.clone() + + # 6. Prepare latent variables + num_channels_latents = self.vae.config.latent_channels + num_channels_unet = self.unet.config.in_channels + return_image_latents = num_channels_unet == 4 + + # Preprocess density + if num_channels_unet == 10: + density = prepare_density(density, height, width) + else: + print("num_channels_unet == 9 --- khong ho tro density ") + + latents_outputs = self.prepare_latents( + batch_size * num_images_per_prompt, + num_channels_latents, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + image=init_image, + timestep=latent_timestep, + is_strength_max=is_strength_max, + return_noise=True, + return_image_latents=return_image_latents, + ) + + if return_image_latents: + latents, noise, image_latents = latents_outputs + else: + latents, noise = latents_outputs + + # 7. Prepare mask latent variables + mask, masked_image_latents = self.prepare_mask_latents( + mask, + masked_image, + batch_size * num_images_per_prompt, + height, + width, + prompt_embeds.dtype, + device, + generator, + do_classifier_free_guidance, + ) + + if density is not None: + density_latents = self.prepare_density_latents( + density, + batch_size * num_images_per_prompt, + height, + width, + prompt_embeds.dtype, + device, + generator, + do_classifier_free_guidance, + ) + else: + density_latents = None + + # 8. Check that sizes of mask, masked image and latents match + if num_channels_unet == 9 or num_channels_unet == 10: + num_channels_mask = mask.shape[1] + num_channels_masked_image = masked_image_latents.shape[1] + extra = density_latents.shape[1] if density_latents is not None else 0 + if num_channels_latents + num_channels_mask + num_channels_masked_image + extra != self.unet.config.in_channels: + raise ValueError( + f"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects" + f" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +" + f" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image} + `num_channels_density`: {extra}" + f" = {num_channels_latents+num_channels_masked_image+num_channels_mask+extra}. Please verify the config of" + " `pipeline.unet` or your `mask_image` or `image` input." + ) + elif num_channels_unet != 4: + raise ValueError( + f"The unet {self.unet.__class__} should have either 4 or 9 or 10 input channels, not {self.unet.config.in_channels}." + ) + + # 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline + extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) + + # 10. Denoising loop + num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + # expand the latents if we are doing classifier free guidance + latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents + + # concat latents, mask, masked_image_latents in the channel dimension + latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) + + if num_channels_unet == 9: + latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1) + elif num_channels_unet == 10: + latent_model_input = torch.cat( + [latent_model_input, mask, masked_image_latents, density_latents], dim=1 + ) + # predict the noise residual + if task_class is not None: + noise_pred = self.unet( + sample=latent_model_input, + timestep=t, + encoder_hidden_states=prompt_embeds, + cross_attention_kwargs=cross_attention_kwargs, + return_dict=False, + task_class=task_class, + )[0] + else: + noise_pred = self.unet( + latent_model_input, + t, + encoder_hidden_states=prompt_embeds, + cross_attention_kwargs=cross_attention_kwargs, + return_dict=False, + )[0] + + # perform guidance + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + # compute the previous noisy sample x_t -> x_t-1 + latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + + if num_channels_unet == 4: + init_latents_proper = image_latents[:1] + init_mask = mask[:1] + + if i < len(timesteps) - 1: + noise_timestep = timesteps[i + 1] + init_latents_proper = self.scheduler.add_noise( + init_latents_proper, noise, torch.tensor([noise_timestep]) + ) + + latents = (1 - init_mask) * init_latents_proper + init_mask * latents + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + if callback is not None and i % callback_steps == 0: + callback(i, t, latents) + + if not output_type == "latent": + condition_kwargs = {} + if isinstance(self.vae, AsymmetricAutoencoderKL): + init_image = init_image.to(device=device, dtype=masked_image_latents.dtype) + init_image_condition = init_image.clone() + init_image = self._encode_vae_image(init_image, generator=generator) + mask_condition = mask_condition.to(device=device, dtype=masked_image_latents.dtype) + condition_kwargs = {"image": init_image_condition, "mask": mask_condition} + image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False, **condition_kwargs)[0] + image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype) + else: + image = latents + has_nsfw_concept = None + + if has_nsfw_concept is None: + do_denormalize = [True] * image.shape[0] + else: + do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept] + + image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize) + + # Offload last model to CPU + if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None: + self.final_offload_hook.offload() + + if not return_dict: + return (image, has_nsfw_concept) + + return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept) diff --git a/powerpaint/utils/__init__.py b/powerpaint/utils/__init__.py index 48cfcd1..dafbd90 100644 --- a/powerpaint/utils/__init__.py +++ b/powerpaint/utils/__init__.py @@ -1,4 +1,5 @@ from .loaders import CustomTextualInversionMixin +from .utils import TokenizerWrapper, add_tokens -__all__ = ["CustomTextualInversionMixin"] +__all__ = ["CustomTextualInversionMixin", "TokenizerWrapper", 'add_tokens'] diff --git a/powerpaint/utils/infer.py b/powerpaint/utils/infer.py new file mode 100644 index 0000000..59f701e --- /dev/null +++ b/powerpaint/utils/infer.py @@ -0,0 +1,98 @@ +import inspect +import torch +import torch.nn.functional as F +from diffusers import DDIMScheduler + +def vae_encode_with_generator(vae, x, generator): + # match pipeline: sample(generator=...) * scaling_factor + lat = vae.encode(x).latent_dist.sample(generator=generator) + return lat * vae.config.scaling_factor + +def vae_decode_scaled(vae, latents): + # match pipeline: decode(latents / scaling_factor) + x = vae.decode(latents / vae.config.scaling_factor, return_dict=False)[0] + return x + +@torch.no_grad() +def sample_ddim_inpaint_density( + *, + pipe, unet, text_encoder, vae, + batch, + weight_dtype, + num_inference_steps=30, + guidance_scale=0.0, # bạn đang không dùng CFG + seed=1234, + density_variant="real", + eta=0.0, +): + device = next(unet.parameters()).device + + # --- scheduler: mimic pipeline style --- + scheduler = DDIMScheduler.from_config(pipe.scheduler.config) + if getattr(pipe.scheduler.config, "prediction_type", None) is not None: + scheduler.register_to_config(prediction_type=pipe.scheduler.config.prediction_type) + scheduler.set_timesteps(num_inference_steps, device=device) + + # extra_step_kwargs giống pipeline.prepare_extra_step_kwargs :contentReference[oaicite:3]{index=3} + extra_step_kwargs = {} + step_params = set(inspect.signature(scheduler.step).parameters.keys()) + if "eta" in step_params: + extra_step_kwargs["eta"] = eta + + # --- inputs --- + pixel_values = batch["pixel_values"].to(device=device, dtype=torch.float32) # keep float32 like pipeline preprocess + mask = batch["mask"].to(device=device, dtype=torch.float32) + density = batch["density"].to(device=device, dtype=torch.float32) + bsz = pixel_values.shape[0] + + mask = (mask > 0.5).float() # pipeline binarizes mask :contentReference[oaicite:4]{index=4} + + if density_variant == "zero": + density = torch.zeros_like(density) + elif density_variant == "shuf": + perm = torch.randperm(bsz, device=device) + density = density[perm] + + # --- encoder_hidden_states (giữ cách bạn đang làm) --- + hsA = text_encoder(batch["input_idsA"].to(device), return_dict=False)[0] + hsB = text_encoder(batch["input_idsB"].to(device), return_dict=False)[0] + tradeoff = batch["tradeoff"].to(device).unsqueeze(-1) # [B,2,1] + encoder_hidden_states = (tradeoff[:,0:1,:]*hsA + tradeoff[:,1:,:]*hsB).to(dtype=unet.dtype) + + # --- determinism: use one generator for BOTH VAE sampling + noise --- + gen = torch.Generator(device=device).manual_seed(seed) + if "generator" in step_params: + extra_step_kwargs["generator"] = gen + + # masked_image: match pipeline masked_image = image*(mask<0.5) :contentReference[oaicite:5]{index=5} + masked_image = pixel_values * (mask < 0.5) + + # VAE encodes (match pipeline scaling + generator) + masked_image_latents = vae_encode_with_generator(vae, masked_image.to(dtype=weight_dtype), gen) + latents_ref = vae_encode_with_generator(vae, pixel_values.to(dtype=weight_dtype), gen) + _, _, lh, lw = latents_ref.shape + + # mask_latent: pipeline uses interpolate(mask) without mode => nearest by default :contentReference[oaicite:6]{index=6} + mask_latent = F.interpolate(mask, size=(lh, lw)) + mask_latent = mask_latent.to(device=device, dtype=weight_dtype) + + # density_latent: match pipeline bilinear + align_corners=False :contentReference[oaicite:7]{index=7} + density_latent = F.interpolate(density, size=(lh, lw), mode="bilinear", align_corners=False) + density_latent = density_latent.to(device=device, dtype=weight_dtype) + + # init noise latents + latents = torch.randn((bsz, 4, lh, lw), generator=gen, device=device, dtype=weight_dtype) + + for t in scheduler.timesteps: + # match pipeline: scale_model_input(latents) BEFORE concat :contentReference[oaicite:8]{index=8} + latents_in = scheduler.scale_model_input(latents, t) + + model_in = torch.cat([latents_in, mask_latent, masked_image_latents, density_latent], dim=1) # 10ch + noise_pred = unet(model_in, t, encoder_hidden_states, return_dict=False)[0] + + # (CFG nếu bạn cần sau này thì implement giống pipeline; hiện guidance_scale=0 nên bỏ) + latents = scheduler.step(noise_pred, t, latents, return_dict=False, **extra_step_kwargs)[0] + + out = vae_decode_scaled(vae, latents) + out = (out.clamp(-1, 1) + 1) * 0.5 + return out \ No newline at end of file diff --git a/powerpaint/utils/utils.py b/powerpaint/utils/utils.py new file mode 100644 index 0000000..5d6234f --- /dev/null +++ b/powerpaint/utils/utils.py @@ -0,0 +1,609 @@ +import copy +import os +import random +from logging import WARNING +from typing import Any, List, Optional, Union + +import torch +import torch.nn as nn +import transformers + +# from mmagic.utils import try_import +from mmengine import print_log + + +class TokenizerWrapper: + """Tokenizer wrapper for CLIPTokenizer. Only support CLIPTokenizer + currently. This wrapper is modified from https://github.com/huggingface/dif + fusers/blob/e51f19aee82c8dd874b715a09dbc521d88835d68/src/diffusers/loaders. + py#L358 # noqa. + + Args: + from_pretrained (Union[str, os.PathLike], optional): The *model id* + of a pretrained model or a path to a *directory* containing + model weights and config. Defaults to None. + from_config (Union[str, os.PathLike], optional): The *model id* + of a pretrained model or a path to a *directory* containing + model weights and config. Defaults to None. + + *args, **kwargs: If `from_pretrained` is passed, *args and **kwargs + will be passed to `from_pretrained` function. Otherwise, *args + and **kwargs will be used to initialize the model by + `self._module_cls(*args, **kwargs)`. + """ + + def __init__( + self, + from_pretrained: Optional[Union[str, os.PathLike]] = None, + from_config: Optional[Union[str, os.PathLike]] = None, + *args, + **kwargs, + ): + # transformers = try_import("transformers") + module_cls = transformers.CLIPTokenizer + + assert not (from_pretrained and from_config), ( + "'from_pretrained' and 'from_config' should not be passed " "at the same time." + ) + + if from_config: + print_log( + "Tokenizers from Huggingface transformers do not support " + "'from_config'. Will call 'from_pretrained' instead " + "with the same argument.", + "current", + WARNING, + ) + from_pretrained = from_config + + if from_pretrained: + self.wrapped = module_cls.from_pretrained(from_pretrained, *args, **kwargs) + else: + self.wrapper = module_cls(*args, **kwargs) + + self._from_pretrained = from_pretrained + self.token_map = {} + + def __getattr__(self, name: str) -> Any: + if name == "wrapped": + return super().__getattr__("wrapped") + + try: + return getattr(self.wrapped, name) + except AttributeError: + try: + return super().__getattr__(name) + except AttributeError: + raise AttributeError( + "'name' cannot be found in both " + f"'{self.__class__.__name__}' and " + f"'{self.__class__.__name__}.tokenizer'." + ) + + def try_adding_tokens(self, tokens: Union[str, List[str]], *args, **kwargs): + """Attempt to add tokens to the tokenizer. + + Args: + tokens (Union[str, List[str]]): The tokens to be added. + """ + num_added_tokens = self.wrapped.add_tokens(tokens, *args, **kwargs) + assert num_added_tokens != 0, ( + f"The tokenizer already contains the token {tokens}. Please pass " + "a different `placeholder_token` that is not already in the " + "tokenizer." + ) + + def get_token_info(self, token: str) -> dict: + """Get the information of a token, including its start and end index in + the current tokenizer. + + Args: + token (str): The token to be queried. + + Returns: + dict: The information of the token, including its start and end + index in current tokenizer. + """ + token_ids = self.__call__(token).input_ids + start, end = token_ids[1], token_ids[-2] + 1 + return {"name": token, "start": start, "end": end} + + def add_placeholder_token(self, placeholder_token: str, *args, num_vec_per_token: int = 1, **kwargs): + """Add placeholder tokens to the tokenizer. + + Args: + placeholder_token (str): The placeholder token to be added. + num_vec_per_token (int, optional): The number of vectors of + the added placeholder token. + *args, **kwargs: The arguments for `self.wrapped.add_tokens`. + """ + output = [] + if num_vec_per_token == 1: + self.try_adding_tokens(placeholder_token, *args, **kwargs) + output.append(placeholder_token) + else: + output = [] + for i in range(num_vec_per_token): + ith_token = placeholder_token + f"_{i}" + self.try_adding_tokens(ith_token, *args, **kwargs) + output.append(ith_token) + + for token in self.token_map: + if token in placeholder_token: + raise ValueError( + f"The tokenizer already has placeholder token {token} " + f"that can get confused with {placeholder_token} " + "keep placeholder tokens independent" + ) + self.token_map[placeholder_token] = output + + def replace_placeholder_tokens_in_text( + self, text: Union[str, List[str]], vector_shuffle: bool = False, prop_tokens_to_load: float = 1.0 + ) -> Union[str, List[str]]: + """Replace the keywords in text with placeholder tokens. This function + will be called in `self.__call__` and `self.encode`. + + Args: + text (Union[str, List[str]]): The text to be processed. + vector_shuffle (bool, optional): Whether to shuffle the vectors. + Defaults to False. + prop_tokens_to_load (float, optional): The proportion of tokens to + be loaded. If 1.0, all tokens will be loaded. Defaults to 1.0. + + Returns: + Union[str, List[str]]: The processed text. + """ + if isinstance(text, list): + output = [] + for i in range(len(text)): + output.append(self.replace_placeholder_tokens_in_text(text[i], vector_shuffle=vector_shuffle)) + return output + + for placeholder_token in self.token_map: + if placeholder_token in text: + tokens = self.token_map[placeholder_token] + tokens = tokens[: 1 + int(len(tokens) * prop_tokens_to_load)] + if vector_shuffle: + tokens = copy.copy(tokens) + random.shuffle(tokens) + text = text.replace(placeholder_token, " ".join(tokens)) + return text + + def replace_text_with_placeholder_tokens(self, text: Union[str, List[str]]) -> Union[str, List[str]]: + """Replace the placeholder tokens in text with the original keywords. + This function will be called in `self.decode`. + + Args: + text (Union[str, List[str]]): The text to be processed. + + Returns: + Union[str, List[str]]: The processed text. + """ + if isinstance(text, list): + output = [] + for i in range(len(text)): + output.append(self.replace_text_with_placeholder_tokens(text[i])) + return output + + for placeholder_token, tokens in self.token_map.items(): + merged_tokens = " ".join(tokens) + if merged_tokens in text: + text = text.replace(merged_tokens, placeholder_token) + return text + + def __call__( + self, + text: Union[str, List[str]], + *args, + vector_shuffle: bool = False, + prop_tokens_to_load: float = 1.0, + **kwargs, + ): + """The call function of the wrapper. + + Args: + text (Union[str, List[str]]): The text to be tokenized. + vector_shuffle (bool, optional): Whether to shuffle the vectors. + Defaults to False. + prop_tokens_to_load (float, optional): The proportion of tokens to + be loaded. If 1.0, all tokens will be loaded. Defaults to 1.0 + *args, **kwargs: The arguments for `self.wrapped.__call__`. + """ + replaced_text = self.replace_placeholder_tokens_in_text( + text, vector_shuffle=vector_shuffle, prop_tokens_to_load=prop_tokens_to_load + ) + replaced_text + return self.wrapped.__call__(replaced_text, *args, **kwargs) + + def encode(self, text: Union[str, List[str]], *args, **kwargs): + """Encode the passed text to token index. + + Args: + text (Union[str, List[str]]): The text to be encode. + *args, **kwargs: The arguments for `self.wrapped.__call__`. + """ + replaced_text = self.replace_placeholder_tokens_in_text(text) + return self.wrapped(replaced_text, *args, **kwargs) + + def decode(self, token_ids, return_raw: bool = False, *args, **kwargs) -> Union[str, List[str]]: + """Decode the token index to text. + + Args: + token_ids: The token index to be decoded. + return_raw: Whether keep the placeholder token in the text. + Defaults to False. + *args, **kwargs: The arguments for `self.wrapped.decode`. + + Returns: + Union[str, List[str]]: The decoded text. + """ + text = self.wrapped.decode(token_ids, *args, **kwargs) + if return_raw: + return text + replaced_text = self.replace_text_with_placeholder_tokens(text) + return replaced_text + + def __repr__(self): + """The representation of the wrapper.""" + s = super().__repr__() + prefix = f"Wrapped Module Class: {self._module_cls}\n" + prefix += f"Wrapped Module Name: {self._module_name}\n" + if self._from_pretrained: + prefix += f"From Pretrained: {self._from_pretrained}\n" + s = prefix + s + return s + + +class EmbeddingLayerWithFixes(nn.Module): + """The revised embedding layer to support external embeddings. This design + of this class is inspired by https://github.com/AUTOMATIC1111/stable- + diffusion-webui/blob/22bcc7be428c94e9408f589966c2040187245d81/modules/sd_hi + jack.py#L224 # noqa. + + Args: + wrapped (nn.Emebdding): The embedding layer to be wrapped. + external_embeddings (Union[dict, List[dict]], optional): The external + embeddings added to this layer. Defaults to None. + """ + + def __init__(self, wrapped: nn.Embedding, external_embeddings: Optional[Union[dict, List[dict]]] = None): + super().__init__() + self.wrapped = wrapped + self.num_embeddings = wrapped.weight.shape[0] + + self.external_embeddings = [] + if external_embeddings: + self.add_embeddings(external_embeddings) + + self.trainable_embeddings = nn.ParameterDict() + + @property + def weight(self): + """Get the weight of wrapped embedding layer.""" + return self.wrapped.weight + + def check_duplicate_names(self, embeddings: List[dict]): + """Check whether duplicate names exist in list of 'external + embeddings'. + + Args: + embeddings (List[dict]): A list of embedding to be check. + """ + names = [emb["name"] for emb in embeddings] + assert len(names) == len(set(names)), ( + "Found duplicated names in 'external_embeddings'. Name list: " f"'{names}'" + ) + + def check_ids_overlap(self, embeddings): + """Check whether overlap exist in token ids of 'external_embeddings'. + + Args: + embeddings (List[dict]): A list of embedding to be check. + """ + ids_range = [[emb["start"], emb["end"], emb["name"]] for emb in embeddings] + ids_range.sort() # sort by 'start' + # check if 'end' has overlapping + for idx in range(len(ids_range) - 1): + name1, name2 = ids_range[idx][-1], ids_range[idx + 1][-1] + assert ids_range[idx][1] <= ids_range[idx + 1][0], ( + f"Found ids overlapping between embeddings '{name1}' " f"and '{name2}'." + ) + + def add_embeddings(self, embeddings: Optional[Union[dict, List[dict]]]): + """Add external embeddings to this layer. + + Use case: + + >>> 1. Add token to tokenizer and get the token id. + >>> tokenizer = TokenizerWrapper('openai/clip-vit-base-patch32') + >>> # 'how much' in kiswahili + >>> tokenizer.add_placeholder_tokens('ngapi', num_vec_per_token=4) + >>> + >>> 2. Add external embeddings to the model. + >>> new_embedding = { + >>> 'name': 'ngapi', # 'how much' in kiswahili + >>> 'embedding': torch.ones(1, 15) * 4, + >>> 'start': tokenizer.get_token_info('kwaheri')['start'], + >>> 'end': tokenizer.get_token_info('kwaheri')['end'], + >>> 'trainable': False # if True, will registry as a parameter + >>> } + >>> embedding_layer = nn.Embedding(10, 15) + >>> embedding_layer_wrapper = EmbeddingLayerWithFixes(embedding_layer) + >>> embedding_layer_wrapper.add_embeddings(new_embedding) + >>> + >>> 3. Forward tokenizer and embedding layer! + >>> input_text = ['hello, ngapi!', 'hello my friend, ngapi?'] + >>> input_ids = tokenizer( + >>> input_text, padding='max_length', truncation=True, + >>> return_tensors='pt')['input_ids'] + >>> out_feat = embedding_layer_wrapper(input_ids) + >>> + >>> 4. Let's validate the result! + >>> assert (out_feat[0, 3: 7] == 2.3).all() + >>> assert (out_feat[2, 5: 9] == 2.3).all() + + Args: + embeddings (Union[dict, list[dict]]): The external embeddings to + be added. Each dict must contain the following 4 fields: 'name' + (the name of this embedding), 'embedding' (the embedding + tensor), 'start' (the start token id of this embedding), 'end' + (the end token id of this embedding). For example: + `{name: NAME, start: START, end: END, embedding: torch.Tensor}` + """ + if isinstance(embeddings, dict): + embeddings = [embeddings] + + self.external_embeddings += embeddings + self.check_duplicate_names(self.external_embeddings) + self.check_ids_overlap(self.external_embeddings) + + # set for trainable + added_trainable_emb_info = [] + for embedding in embeddings: + trainable = embedding.get("trainable", False) + if trainable: + name = embedding["name"] + embedding["embedding"] = torch.nn.Parameter(embedding["embedding"]) + self.trainable_embeddings[name] = embedding["embedding"] + added_trainable_emb_info.append(name) + + added_emb_info = [emb["name"] for emb in embeddings] + added_emb_info = ", ".join(added_emb_info) + print_log(f"Successfully add external embeddings: {added_emb_info}.", "current") + + if added_trainable_emb_info: + added_trainable_emb_info = ", ".join(added_trainable_emb_info) + print_log("Successfully add trainable external embeddings: " f"{added_trainable_emb_info}", "current") + + def replace_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor: + """Replace external input ids to 0. + + Args: + input_ids (torch.Tensor): The input ids to be replaced. + + Returns: + torch.Tensor: The replaced input ids. + """ + input_ids_fwd = input_ids.clone() + input_ids_fwd[input_ids_fwd >= self.num_embeddings] = 0 + return input_ids_fwd + + def replace_embeddings( + self, input_ids: torch.Tensor, embedding: torch.Tensor, external_embedding: dict + ) -> torch.Tensor: + """Replace external embedding to the embedding layer. Noted that, in + this function we use `torch.cat` to avoid inplace modification. + + Args: + input_ids (torch.Tensor): The original token ids. Shape like + [LENGTH, ]. + embedding (torch.Tensor): The embedding of token ids after + `replace_input_ids` function. + external_embedding (dict): The external embedding to be replaced. + + Returns: + torch.Tensor: The replaced embedding. + """ + new_embedding = [] + + name = external_embedding["name"] + start = external_embedding["start"] + end = external_embedding["end"] + target_ids_to_replace = list(range(start, end)) + ext_emb = external_embedding["embedding"] + + # do not need to replace + if not (input_ids == start).any(): + return embedding + + # start replace + s_idx, e_idx = 0, 0 + while e_idx < len(input_ids): + if input_ids[e_idx] == start: + if e_idx != 0: + # add embedding do not need to replace + new_embedding.append(embedding[s_idx:e_idx]) + + # check if the next embedding need to replace is valid + actually_ids_to_replace = [int(i) for i in input_ids[e_idx : e_idx + end - start]] + assert actually_ids_to_replace == target_ids_to_replace, ( + f"Invalid 'input_ids' in position: {s_idx} to {e_idx}. " + f"Expect '{target_ids_to_replace}' for embedding " + f"'{name}' but found '{actually_ids_to_replace}'." + ) + + new_embedding.append(ext_emb) + + s_idx = e_idx + end - start + e_idx = s_idx + 1 + else: + e_idx += 1 + + if e_idx == len(input_ids): + new_embedding.append(embedding[s_idx:e_idx]) + + return torch.cat(new_embedding, dim=0) + + def forward(self, input_ids: torch.Tensor, external_embeddings: Optional[List[dict]] = None): + """The forward function. + + Args: + input_ids (torch.Tensor): The token ids shape like [bz, LENGTH] or + [LENGTH, ]. + external_embeddings (Optional[List[dict]]): The external + embeddings. If not passed, only `self.external_embeddings` + will be used. Defaults to None. + + input_ids: shape like [bz, LENGTH] or [LENGTH]. + """ + assert input_ids.ndim in [1, 2] + if input_ids.ndim == 1: + input_ids = input_ids.unsqueeze(0) + + if external_embeddings is None and not self.external_embeddings: + return self.wrapped(input_ids) + + input_ids_fwd = self.replace_input_ids(input_ids) + inputs_embeds = self.wrapped(input_ids_fwd) + + vecs = [] + + if external_embeddings is None: + external_embeddings = [] + elif isinstance(external_embeddings, dict): + external_embeddings = [external_embeddings] + embeddings = self.external_embeddings + external_embeddings + + for input_id, embedding in zip(input_ids, inputs_embeds): + new_embedding = embedding + for external_embedding in embeddings: + new_embedding = self.replace_embeddings(input_id, new_embedding, external_embedding) + vecs.append(new_embedding) + + return torch.stack(vecs) + + +def add_tokens( + tokenizer, text_encoder, placeholder_tokens: list, initialize_tokens: list = None, num_vectors_per_token: int = 1 +): + """Add token for training. + + # TODO: support add tokens as dict, then we can load pretrained tokens. + """ + if initialize_tokens is not None: + assert len(initialize_tokens) == len( + placeholder_tokens + ), "placeholder_token should be the same length as initialize_token" + for ii in range(len(placeholder_tokens)): + tokenizer.add_placeholder_token(placeholder_tokens[ii], num_vec_per_token=num_vectors_per_token) + + # text_encoder.set_embedding_layer() + embedding_layer = text_encoder.text_model.embeddings.token_embedding + + if not isinstance(embedding_layer, EmbeddingLayerWithFixes): + text_encoder.text_model.embeddings.token_embedding = EmbeddingLayerWithFixes(embedding_layer) + embedding_layer = text_encoder.text_model.embeddings.token_embedding + + assert embedding_layer is not None, ( + "Do not support get embedding layer for current text encoder. " "Please check your configuration." + ) + initialize_embedding = [] + + # get exteral_embedding of embedding_layer if have + external_embeddings = {} + for emb in embedding_layer.external_embeddings: + external_embeddings[emb['name']] = emb['embedding'] + + if initialize_tokens is not None: + for ii in range(len(placeholder_tokens)): + if initialize_tokens[ii] not in external_embeddings.keys(): + init_id = tokenizer(initialize_tokens[ii]).input_ids[1] + temp_embedding = embedding_layer.weight[init_id] + initialize_embedding.append(temp_embedding[None, ...].repeat(num_vectors_per_token, 1)) + else: + temp_embedding = external_embeddings[initialize_tokens[ii]] + initialize_embedding.append(temp_embedding) + else: + for ii in range(len(placeholder_tokens)): + init_id = tokenizer("a").input_ids[1] + temp_embedding = embedding_layer.weight[init_id] + len_emb = temp_embedding.shape[0] + init_weight = (torch.rand(num_vectors_per_token, len_emb) - 0.5) / 2.0 + initialize_embedding.append(init_weight) + + # initialize_embedding = torch.cat(initialize_embedding,dim=0) + + token_info_all = [] + for ii in range(len(placeholder_tokens)): + token_info = tokenizer.get_token_info(placeholder_tokens[ii]) + token_info["embedding"] = initialize_embedding[ii] + token_info["trainable"] = True + token_info_all.append(token_info) + embedding_layer.add_embeddings(token_info_all) + + +class ImageProjection(nn.Module): + def __init__( + self, + image_embed_dim: int = 768, + cross_attention_dim: int = 768, + num_image_text_embeds: int = 32, + ): + super().__init__() + + self.num_image_text_embeds = num_image_text_embeds + self.image_embeds = nn.Linear(image_embed_dim, self.num_image_text_embeds * cross_attention_dim) + self.norm = nn.LayerNorm(cross_attention_dim) + + def forward(self, image_embeds: torch.FloatTensor): + batch_size = image_embeds.shape[0] + + # image + image_embeds = self.image_embeds(image_embeds) + image_embeds = image_embeds.reshape(batch_size, self.num_image_text_embeds, -1) + image_embeds = self.norm(image_embeds) + return image_embeds + + +def expand_unet_conv_in(unet, extra_in_channels=1, init="mean_scaled"): + old = unet.conv_in + old_w = old.weight.data + old_b = old.bias.data if old.bias is not None else None + + new_in = old.in_channels + extra_in_channels + new = nn.Conv2d( + new_in, old.out_channels, + kernel_size=old.kernel_size, stride=old.stride, padding=old.padding, + bias=(old.bias is not None), + ).to(old_w.device, dtype=old_w.dtype) + + # copy old weights + new.weight.data[:, :old.in_channels] = old_w + + # init new channel(s) + if init == "zero": + new.weight.data[:, old.in_channels:] = 0 + elif init == "mean_scaled": + mean_w = old_w.mean(dim=1, keepdim=True) # [out,1,kh,kw] + new.weight.data[:, old.in_channels:] = mean_w.repeat(1, extra_in_channels, 1, 1) * 0.1 + else: + nn.init.kaiming_normal_(new.weight.data[:, old.in_channels:]) + + if old_b is not None: + new.bias.data = old_b.clone() + + unet.conv_in = new + unet.config.in_channels = new_in + return unet + +def make_unet_input(noisy_latents, mask_latent, mask_image_latents, density_latent): + """ + IMPORTANT: giữ đúng thứ tự giống code train của bạn: + model_input = cat([noisy_latents, mask, mask_image_latents, density_latent], dim=1) + Shapes: + noisy_latents: [B,4,h,w] + mask_latent: [B,1,h,w] + mask_img_lat: [B,4,h,w] + density_lat: [B,1,h,w] + """ + return torch.cat([noisy_latents, mask_latent, mask_image_latents, density_latent], dim=1) \ No newline at end of file diff --git a/powerpaint/utils/vis.py b/powerpaint/utils/vis.py new file mode 100644 index 0000000..85a43d5 --- /dev/null +++ b/powerpaint/utils/vis.py @@ -0,0 +1,20 @@ +import os +import torch +import torchvision + +def save_img(path, img_01): # [3,H,W] in [0,1] + os.makedirs(os.path.dirname(path), exist_ok=True) + torchvision.utils.save_image(img_01.clamp(0,1), path) + +def save_gray(path, x): # [1,H,W] + os.makedirs(os.path.dirname(path), exist_ok=True) + x = x.detach() + vmin = torch.quantile(x.flatten(), 0.01) + vmax = torch.quantile(x.flatten(), 0.99) + x = (x - vmin) / (vmax - vmin + 1e-8) + torchvision.utils.save_image(x.clamp(0,1), path) + +def save_grid(path, imgs_01, nrow=4): # [N,3,H,W] + os.makedirs(os.path.dirname(path), exist_ok=True) + grid = torchvision.utils.make_grid(imgs_01.clamp(0,1), nrow=nrow) + torchvision.utils.save_image(grid, path) \ No newline at end of file diff --git a/requirements/ppt.yml b/requirements/ppt.yml index a356980..2395cf2 100644 --- a/requirements/ppt.yml +++ b/requirements/ppt.yml @@ -1,160 +1,167 @@ -name: ppt +name: powerpaint channels: + - conda-forge - defaults dependencies: - _libgcc_mutex=0.1=main - _openmp_mutex=5.1=1_gnu - - ca-certificates=2024.3.11=h06a4308_0 - - git-lfs=3.5.1=h06a4308_0 - - ld_impl_linux-64=2.38=h1181459_1 + - asttokens=3.0.0=pyhd8ed1ab_1 + - bzip2=1.0.8=h5eee18b_6 + - ca-certificates=2025.10.5=hbd8a1cb_0 + - comm=0.2.3=pyhe01879c_0 + - debugpy=1.8.16=py39hbdd6827_0 + - decorator=5.2.1=pyhd8ed1ab_0 + - exceptiongroup=1.3.0=pyhd8ed1ab_0 + - executing=2.2.0=pyhd8ed1ab_0 + - expat=2.7.1=h6a678d5_0 + - importlib-metadata=8.7.0=pyhe01879c_1 + - ipykernel=6.30.1=pyh82676e8_0 + - ipython=8.18.1=pyh707e725_3 + - jedi=0.19.2=pyhd8ed1ab_1 + - jupyter_client=8.6.3=pyhd8ed1ab_1 + - jupyter_core=5.8.1=pyh31011fe_0 + - ld_impl_linux-64=2.40=h12ee557_0 - libffi=3.4.4=h6a678d5_1 - - libgcc-ng=11.2.0=h1234567_1 - - libgomp=11.2.0=h1234567_1 + - libgcc=15.2.0=h767d61c_7 + - libgcc-ng=15.2.0=h69a702a_7 + - libgomp=15.2.0=h767d61c_7 + - libsodium=1.0.20=h4ab18f5_0 - libstdcxx-ng=11.2.0=h1234567_1 - - ncurses=6.4=h6a678d5_0 - - openssl=3.0.14=h5eee18b_0 - - pip=24.0=py39h06a4308_0 - - python=3.9.19=h955ad1f_1 - - readline=8.2=h5eee18b_0 - - setuptools=69.5.1=py39h06a4308_0 - - sqlite=3.45.3=h5eee18b_0 - - tk=8.6.14=h39e8969_0 - - wheel=0.43.0=py39h06a4308_0 - - xz=5.4.6=h5eee18b_1 + - libxcb=1.17.0=h9b100fa_0 + - matplotlib-inline=0.1.7=pyhd8ed1ab_1 + - ncurses=6.5=h7934f7d_0 + - nest-asyncio=1.6.0=pyhd8ed1ab_1 + - openssl=3.5.4=h26f9b46_0 + - packaging=25.0=pyh29332c3_1 + - parso=0.8.4=pyhd8ed1ab_1 + - pexpect=4.9.0=pyhd8ed1ab_1 + - pickleshare=0.7.5=pyhd8ed1ab_1004 + - pip=25.1=pyhc872135_2 + - platformdirs=4.3.8=pyhe01879c_0 + - prompt-toolkit=3.0.51=pyha770c72_0 + - psutil=7.0.0=py39h8cd3c5a_0 + - pthread-stubs=0.3=h0ce48e5_1 + - ptyprocess=0.7.0=pyhd8ed1ab_1 + - pure_eval=0.2.3=pyhd8ed1ab_1 + - pygments=2.19.2=pyhd8ed1ab_0 + - python=3.9.23=he99959a_0 + - python-dateutil=2.9.0.post0=pyhe01879c_2 + - python_abi=3.9=2_cp39 + - pyzmq=27.1.0=py39hcf8288c_0 + - readline=8.3=hc2a1206_0 + - setuptools=78.1.1=py39h06a4308_0 + - six=1.17.0=pyhe01879c_1 + - sqlite=3.50.2=hb25bd0a_1 + - stack_data=0.6.3=pyhd8ed1ab_1 + - tk=8.6.15=h54e0aa7_0 + - tornado=6.5.2=py39hd399759_0 + - traitlets=5.14.3=pyhd8ed1ab_1 + - typing_extensions=4.14.1=pyhe01879c_0 + - wcwidth=0.2.13=pyhd8ed1ab_1 + - wheel=0.45.1=py39h06a4308_0 + - xorg-libx11=1.8.12=h9b100fa_1 + - xorg-libxau=1.0.12=h9b100fa_0 + - xorg-libxdmcp=1.1.5=h9b100fa_0 + - xorg-xorgproto=2024.1=h5eee18b_1 + - xz=5.6.4=h5eee18b_1 + - zeromq=4.3.5=hb0a5e54_1 + - zipp=3.23.0=pyhd8ed1ab_0 - zlib=1.2.13=h5eee18b_1 - pip: - - accelerate==0.31.0 - - addict==2.4.0 - - aiofiles==23.2.1 - - altair==5.3.0 - - annotated-types==0.7.0 - - anyio==4.4.0 - - attrs==23.2.0 - - blessed==1.20.0 - - certifi==2024.6.2 - - cfgv==3.4.0 - - charset-normalizer==3.3.2 - - click==8.1.7 - - contourpy==1.2.1 - - controlnet-aux==0.0.3 - - cycler==0.12.1 - - diffusers==0.27.0 - - distlib==0.3.8 - - dnspython==2.6.1 - - einops==0.8.0 - - email-validator==2.2.0 - - exceptiongroup==1.2.1 - - fastapi==0.111.0 - - fastapi-cli==0.0.4 - - ffmpy==0.3.2 - - filelock==3.15.4 - - fonttools==4.53.0 - - fsspec==2024.6.0 - - gpustat==1.1.1 - - gradio==3.41.0 - - gradio-client==0.5.0 - - h11==0.14.0 - - hf-transfer==0.1.6 - - httpcore==1.0.5 - - httptools==0.6.1 - - httpx==0.27.0 - - huggingface-hub==0.23.4 - - identify==2.5.36 - - idna==3.7 - - imageio==2.34.2 - - importlib-metadata==7.2.1 - - importlib-resources==6.4.0 - - jinja2==3.1.4 - - jsonschema==4.22.0 - - jsonschema-specifications==2023.12.1 - - kiwisolver==1.4.5 - - lazy-loader==0.4 - - markdown-it-py==3.0.0 - - markupsafe==2.1.5 - - matplotlib==3.9.0 - - mdurl==0.1.2 - - mpmath==1.3.0 - - networkx==3.2.1 - - nodeenv==1.9.1 - - numpy==1.26.4 - - nvidia-cublas-cu11==11.11.3.6 - - nvidia-cublas-cu12==12.1.3.1 - - nvidia-cuda-cupti-cu11==11.8.87 - - nvidia-cuda-cupti-cu12==12.1.105 - - nvidia-cuda-nvrtc-cu11==11.8.89 - - nvidia-cuda-nvrtc-cu12==12.1.105 - - nvidia-cuda-runtime-cu11==11.8.89 - - nvidia-cuda-runtime-cu12==12.1.105 - - nvidia-cudnn-cu11==8.7.0.84 - - nvidia-cudnn-cu12==8.9.2.26 - - nvidia-cufft-cu11==10.9.0.58 - - nvidia-cufft-cu12==11.0.2.54 - - nvidia-curand-cu11==10.3.0.86 - - nvidia-curand-cu12==10.3.2.106 - - nvidia-cusolver-cu11==11.4.1.48 - - nvidia-cusolver-cu12==11.4.5.107 - - nvidia-cusparse-cu11==11.7.5.86 - - nvidia-cusparse-cu12==12.1.0.106 - - nvidia-ml-py==12.555.43 - - nvidia-nccl-cu11==2.20.5 - - nvidia-nccl-cu12==2.20.5 - - nvidia-nvjitlink-cu12==12.5.40 - - nvidia-nvtx-cu11==11.8.86 - - nvidia-nvtx-cu12==12.1.105 - - opencv-python==4.10.0.84 - - orjson==3.10.5 - - packaging==24.1 - - pandas==2.2.2 - - pillow==10.3.0 - - platformdirs==4.2.2 - - pre-commit==3.7.1 - - psutil==6.0.0 - - pydantic==2.7.4 - - pydantic-core==2.18.4 - - pydub==0.25.1 - - pygments==2.18.0 - - pyparsing==3.1.2 - - python-dateutil==2.9.0.post0 - - python-dotenv==1.0.1 - - python-multipart==0.0.9 - - pytz==2024.1 - - pyyaml==6.0.1 - - referencing==0.35.1 - - regex==2024.5.15 - - requests==2.32.3 - - rich==13.7.1 - - rpds-py==0.18.1 - - safetensors==0.4.3 - - scikit-image==0.24.0 - - scipy==1.13.1 - - semantic-version==2.10.0 - - shellingham==1.5.4 - - six==1.16.0 - - sniffio==1.3.1 - - starlette==0.37.2 - - sympy==1.12.1 - - termcolor==2.4.0 - - tifffile==2024.6.18 - - timm==1.0.7 - - tokenizers==0.13.3 - - tomli==2.0.1 - - toolz==0.12.1 - - torch==2.3.1+cu118 - - torchaudio==2.3.1+cu118 - - torchvision==0.18.1+cu118 - - tqdm==4.66.4 - - transformers==4.28.0 - - triton==2.3.1 - - typer==0.12.3 - - typing-extensions==4.12.2 - - tzdata==2024.1 - - ujson==5.10.0 - - urllib3==2.2.2 - - uvicorn==0.30.1 - - uvloop==0.19.0 - - virtualenv==20.26.3 - - watchfiles==0.22.0 - - wcwidth==0.2.13 - - websockets==11.0.3 - - yapf==0.40.2 - - zipp==3.19.2 + - accelerate==1.10.0 + - addict==2.4.0 + - aiofiles==23.2.1 + - altair==5.5.0 + - annotated-types==0.7.0 + - anyio==4.10.0 + - attrs==25.3.0 + - certifi==2025.8.3 + - charset-normalizer==3.4.3 + - click==8.1.8 + - contourpy==1.3.0 + - controlnet-aux==0.0.3 + - cycler==0.12.1 + - diffusers==0.27.0 + - einops==0.8.1 + - fastapi==0.116.1 + - ffmpy==0.6.1 + - filelock==3.19.1 + - fonttools==4.59.1 + - fsspec==2025.7.0 + - gradio==3.41.0 + - gradio-client==0.5.0 + - h11==0.16.0 + - hf-xet==1.1.8 + - httpcore==1.0.9 + - httpx==0.28.1 + - huggingface-hub==0.23.4 + - idna==3.10 + - imageio==2.37.0 + - importlib-resources==6.5.2 + - jinja2==3.1.6 + - jsonschema==4.25.1 + - jsonschema-specifications==2025.4.1 + - kiwisolver==1.4.7 + - lazy-loader==0.4 + - markdown-it-py==3.0.0 + - markupsafe==2.1.5 + - matplotlib==3.9.4 + - mdurl==0.1.2 + - mmengine==0.10.7 + - mpmath==1.3.0 + - narwhals==2.1.2 + - networkx==3.2.1 + - numpy==1.26.4 + - nvidia-cublas-cu12==12.8.4.1 + - nvidia-cuda-cupti-cu12==12.8.90 + - nvidia-cuda-nvrtc-cu12==12.8.93 + - nvidia-cuda-runtime-cu12==12.8.90 + - nvidia-cudnn-cu12==9.10.2.21 + - nvidia-cufft-cu12==11.3.3.83 + - nvidia-cufile-cu12==1.13.1.3 + - nvidia-curand-cu12==10.3.9.90 + - nvidia-cusolver-cu12==11.7.3.90 + - nvidia-cusparse-cu12==12.5.8.93 + - nvidia-cusparselt-cu12==0.7.1 + - nvidia-nccl-cu12==2.27.3 + - nvidia-nvjitlink-cu12==12.8.93 + - nvidia-nvtx-cu12==12.8.90 + - opencv-python==4.11.0.86 + - orjson==3.11.2 + - pandas==2.3.2 + - pillow==10.4.0 + - pydantic==2.11.7 + - pydantic-core==2.33.2 + - pydub==0.25.1 + - pyparsing==3.2.3 + - python-multipart==0.0.20 + - pytz==2025.2 + - pyyaml==6.0.2 + - referencing==0.36.2 + - regex==2025.7.34 + - requests==2.32.5 + - rich==14.1.0 + - rpds-py==0.27.0 + - safetensors==0.6.2 + - scikit-image==0.24.0 + - scipy==1.13.1 + - semantic-version==2.10.0 + - sniffio==1.3.1 + - starlette==0.47.2 + - sympy==1.14.0 + - termcolor==3.1.0 + - tifffile==2024.8.30 + - timm==1.0.19 + - tokenizers==0.13.3 + - tomli==2.2.1 + - torch==2.8.0 + - torchvision==0.23.0 + - tqdm==4.67.1 + - transformers==4.28.0 + - triton==3.4.0 + - typing-inspection==0.4.1 + - tzdata==2025.2 + - urllib3==2.5.0 + - uvicorn==0.35.0 + - websockets==11.0.3 + - yapf==0.43.0 diff --git a/requirements/requirements.txt b/requirements/requirements.txt index a3f15bc..470c490 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,8 +1,11 @@ accelerate controlnet-aux==0.0.3 +huggingface_hub==0.23.4 diffusers==0.27.0 gradio==3.41.0 opencv-python torch torchvision transformers==4.28.0 +omegaconf +mmengine diff --git a/test.ipynb b/test.ipynb new file mode 100644 index 0000000..9df9051 --- /dev/null +++ b/test.ipynb @@ -0,0 +1,4088 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 17, + "id": "33152e77", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([10, 768])\n", + "tensor([[-0.0100, -0.0130, -0.0072, ..., -0.0289, 0.0108, 0.0081],\n", + " [ 0.0139, 0.0140, -0.0240, ..., -0.0171, 0.0164, 0.0151],\n", + " [ 0.0099, 0.0068, -0.0149, ..., -0.0209, 0.0248, 0.0139],\n", + " ...,\n", + " [ 0.0059, 0.0043, -0.0155, ..., -0.0191, 0.0069, 0.0076],\n", + " [ 0.0041, 0.0046, -0.0177, ..., -0.0138, 0.0133, 0.0110],\n", + " [ 0.0051, 0.0017, -0.0131, ..., -0.0182, 0.0048, 0.0140]])\n" + ] + } + ], + "source": [ + "from safetensors.torch import safe_open\n", + "\n", + "with safe_open(\"/mnt/disk2/hachi/checkpoints/ppt-v1/text_encoder/text_encoder.safetensors\", framework=\"pt\") as f:\n", + " P_obj = f.get_tensor(\n", + " \"text_model.embeddings.token_embedding.trainable_embeddings.P_obj\"\n", + " )\n", + "\n", + "print(P_obj.shape)\n", + "print(P_obj)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1d0b6be0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-7.8510e-07, -1.4687e-06, 1.6191e-06, ..., -1.3243e-06,\n", + " 3.0175e-07, 3.5539e-06],\n", + " [-3.5670e-06, 1.1902e-06, -2.6301e-06, ..., 4.1910e-07,\n", + " 3.4515e-06, -3.1292e-07],\n", + " [-1.8990e-06, 1.2894e-06, -1.0096e-06, ..., 3.0417e-06,\n", + " 4.8280e-06, 8.5682e-08],\n", + " ...,\n", + " [ 1.6964e-06, -3.9907e-07, -4.0606e-07, ..., -4.3008e-06,\n", + " 1.8175e-06, 2.4214e-08],\n", + " [ 4.6473e-07, -1.1944e-06, 4.5821e-06, ..., -5.5786e-07,\n", + " -1.2126e-06, 2.4065e-06],\n", + " [-1.7681e-06, 3.8103e-07, 3.4394e-06, ..., -4.2655e-07,\n", + " 3.4599e-07, -6.4261e-08]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "P_obj - data['text_model.embeddings.token_embedding.trainable_embeddings.P_obj']" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "18734244", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "text_model.embeddings.position_embedding.weight torch.Size([77, 768])\n", + "text_model.embeddings.position_ids torch.Size([1, 77])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_obj torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_shape torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.wrapped.weight torch.Size([49408, 768])\n", + "text_model.encoder.layers.0.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.0.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.0.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.0.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.0.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.0.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.1.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.1.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.1.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.1.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.1.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.10.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.10.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.10.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.10.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.10.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.11.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.11.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.11.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.11.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.11.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.2.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.2.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.2.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.2.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.2.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.3.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.3.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.3.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.3.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.3.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.4.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.4.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.4.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.4.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.4.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.5.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.5.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.5.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.5.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.5.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.6.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.6.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.6.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.6.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.6.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.7.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.7.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.7.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.7.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.7.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.8.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.8.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.8.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.8.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.8.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.9.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.9.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.9.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.9.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.9.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.final_layer_norm.bias torch.Size([768])\n", + "text_model.final_layer_norm.weight torch.Size([768])\n" + ] + } + ], + "source": [ + "from safetensors.torch import safe_open\n", + "\n", + "with safe_open(\"/workdir/radish/hachi/checkpoints/ppt-v1/text_encoder/text_encoder.safetensors\", framework=\"pt\") as f:\n", + " for k in f.keys():\n", + " tensor = f.get_tensor(k)\n", + " print(k, tensor.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "298765cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "conv_in.bias torch.Size([320])\n", + "conv_in.weight torch.Size([320, 10, 3, 3])\n", + "conv_norm_out.bias torch.Size([320])\n", + "conv_norm_out.weight torch.Size([320])\n", + "conv_out.bias torch.Size([4])\n", + "conv_out.weight torch.Size([4, 320, 3, 3])\n", + "down_blocks.0.attentions.0.norm.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.norm.weight torch.Size([320])\n", + "down_blocks.0.attentions.0.proj_in.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.0.proj_out.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.norm.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.norm.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.proj_in.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.1.proj_out.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "down_blocks.0.downsamplers.0.conv.bias torch.Size([320])\n", + "down_blocks.0.downsamplers.0.conv.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.0.conv1.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.conv1.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.0.conv2.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.conv2.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.0.norm1.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.norm1.weight torch.Size([320])\n", + "down_blocks.0.resnets.0.norm2.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.norm2.weight torch.Size([320])\n", + "down_blocks.0.resnets.0.time_emb_proj.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.time_emb_proj.weight torch.Size([320, 1280])\n", + "down_blocks.0.resnets.1.conv1.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.conv1.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.1.conv2.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.conv2.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.1.norm1.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.norm1.weight torch.Size([320])\n", + "down_blocks.0.resnets.1.norm2.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.norm2.weight torch.Size([320])\n", + "down_blocks.0.resnets.1.time_emb_proj.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.time_emb_proj.weight torch.Size([320, 1280])\n", + "down_blocks.1.attentions.0.norm.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.norm.weight torch.Size([640])\n", + "down_blocks.1.attentions.0.proj_in.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.0.proj_out.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.norm.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.norm.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.proj_in.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.1.proj_out.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "down_blocks.1.downsamplers.0.conv.bias torch.Size([640])\n", + "down_blocks.1.downsamplers.0.conv.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.0.conv1.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.conv1.weight torch.Size([640, 320, 3, 3])\n", + "down_blocks.1.resnets.0.conv2.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.conv2.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.0.conv_shortcut.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.conv_shortcut.weight torch.Size([640, 320, 1, 1])\n", + "down_blocks.1.resnets.0.norm1.bias torch.Size([320])\n", + "down_blocks.1.resnets.0.norm1.weight torch.Size([320])\n", + "down_blocks.1.resnets.0.norm2.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.norm2.weight torch.Size([640])\n", + "down_blocks.1.resnets.0.time_emb_proj.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.time_emb_proj.weight torch.Size([640, 1280])\n", + "down_blocks.1.resnets.1.conv1.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.conv1.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.1.conv2.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.conv2.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.1.norm1.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.norm1.weight torch.Size([640])\n", + "down_blocks.1.resnets.1.norm2.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.norm2.weight torch.Size([640])\n", + "down_blocks.1.resnets.1.time_emb_proj.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.time_emb_proj.weight torch.Size([640, 1280])\n", + "down_blocks.2.attentions.0.norm.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.norm.weight torch.Size([1280])\n", + "down_blocks.2.attentions.0.proj_in.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.0.proj_out.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.norm.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.norm.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.proj_in.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.1.proj_out.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "down_blocks.2.downsamplers.0.conv.bias torch.Size([1280])\n", + "down_blocks.2.downsamplers.0.conv.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.0.conv1.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.conv1.weight torch.Size([1280, 640, 3, 3])\n", + "down_blocks.2.resnets.0.conv2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.0.conv_shortcut.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.conv_shortcut.weight torch.Size([1280, 640, 1, 1])\n", + "down_blocks.2.resnets.0.norm1.bias torch.Size([640])\n", + "down_blocks.2.resnets.0.norm1.weight torch.Size([640])\n", + "down_blocks.2.resnets.0.norm2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.norm2.weight torch.Size([1280])\n", + "down_blocks.2.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "down_blocks.2.resnets.1.conv1.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.1.conv2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.1.norm1.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.norm1.weight torch.Size([1280])\n", + "down_blocks.2.resnets.1.norm2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.norm2.weight torch.Size([1280])\n", + "down_blocks.2.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "down_blocks.3.resnets.0.conv1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.0.conv2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.0.norm1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.norm1.weight torch.Size([1280])\n", + "down_blocks.3.resnets.0.norm2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.norm2.weight torch.Size([1280])\n", + "down_blocks.3.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "down_blocks.3.resnets.1.conv1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.1.conv2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.1.norm1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.norm1.weight torch.Size([1280])\n", + "down_blocks.3.resnets.1.norm2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.norm2.weight torch.Size([1280])\n", + "down_blocks.3.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.norm.bias torch.Size([1280])\n", + "mid_block.attentions.0.norm.weight torch.Size([1280])\n", + "mid_block.attentions.0.proj_in.bias torch.Size([1280])\n", + "mid_block.attentions.0.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "mid_block.attentions.0.proj_out.bias torch.Size([1280])\n", + "mid_block.attentions.0.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "mid_block.attentions.0.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "mid_block.resnets.0.conv1.bias torch.Size([1280])\n", + "mid_block.resnets.0.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.0.conv2.bias torch.Size([1280])\n", + "mid_block.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.0.norm1.bias torch.Size([1280])\n", + "mid_block.resnets.0.norm1.weight torch.Size([1280])\n", + "mid_block.resnets.0.norm2.bias torch.Size([1280])\n", + "mid_block.resnets.0.norm2.weight torch.Size([1280])\n", + "mid_block.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "mid_block.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "mid_block.resnets.1.conv1.bias torch.Size([1280])\n", + "mid_block.resnets.1.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.1.conv2.bias torch.Size([1280])\n", + "mid_block.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.1.norm1.bias torch.Size([1280])\n", + "mid_block.resnets.1.norm1.weight torch.Size([1280])\n", + "mid_block.resnets.1.norm2.bias torch.Size([1280])\n", + "mid_block.resnets.1.norm2.weight torch.Size([1280])\n", + "mid_block.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "mid_block.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "time_embedding.linear_1.bias torch.Size([1280])\n", + "time_embedding.linear_1.weight torch.Size([1280, 320])\n", + "time_embedding.linear_2.bias torch.Size([1280])\n", + "time_embedding.linear_2.weight torch.Size([1280, 1280])\n", + "up_blocks.0.resnets.0.conv1.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.0.resnets.0.conv2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.0.resnets.0.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.0.resnets.0.norm1.bias torch.Size([2560])\n", + "up_blocks.0.resnets.0.norm1.weight torch.Size([2560])\n", + "up_blocks.0.resnets.0.norm2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.norm2.weight torch.Size([1280])\n", + "up_blocks.0.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.0.resnets.1.conv1.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.0.resnets.1.conv2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.0.resnets.1.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.0.resnets.1.norm1.bias torch.Size([2560])\n", + "up_blocks.0.resnets.1.norm1.weight torch.Size([2560])\n", + "up_blocks.0.resnets.1.norm2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.norm2.weight torch.Size([1280])\n", + "up_blocks.0.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.0.resnets.2.conv1.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.0.resnets.2.conv2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.0.resnets.2.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.0.resnets.2.norm1.bias torch.Size([2560])\n", + "up_blocks.0.resnets.2.norm1.weight torch.Size([2560])\n", + "up_blocks.0.resnets.2.norm2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.norm2.weight torch.Size([1280])\n", + "up_blocks.0.resnets.2.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.0.upsamplers.0.conv.bias torch.Size([1280])\n", + "up_blocks.0.upsamplers.0.conv.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.attentions.0.norm.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.norm.weight torch.Size([1280])\n", + "up_blocks.1.attentions.0.proj_in.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.0.proj_out.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.norm.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.norm.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.proj_in.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.1.proj_out.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.norm.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.norm.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.proj_in.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.2.proj_out.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv1.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.1.resnets.0.conv2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.resnets.0.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.1.resnets.0.norm1.bias torch.Size([2560])\n", + "up_blocks.1.resnets.0.norm1.weight torch.Size([2560])\n", + "up_blocks.1.resnets.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.1.resnets.1.conv1.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.1.resnets.1.conv2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.resnets.1.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.1.resnets.1.norm1.bias torch.Size([2560])\n", + "up_blocks.1.resnets.1.norm1.weight torch.Size([2560])\n", + "up_blocks.1.resnets.1.norm2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.norm2.weight torch.Size([1280])\n", + "up_blocks.1.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.1.resnets.2.conv1.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.conv1.weight torch.Size([1280, 1920, 3, 3])\n", + "up_blocks.1.resnets.2.conv2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.resnets.2.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.conv_shortcut.weight torch.Size([1280, 1920, 1, 1])\n", + "up_blocks.1.resnets.2.norm1.bias torch.Size([1920])\n", + "up_blocks.1.resnets.2.norm1.weight torch.Size([1920])\n", + "up_blocks.1.resnets.2.norm2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.norm2.weight torch.Size([1280])\n", + "up_blocks.1.resnets.2.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.1.upsamplers.0.conv.bias torch.Size([1280])\n", + "up_blocks.1.upsamplers.0.conv.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.2.attentions.0.norm.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.norm.weight torch.Size([640])\n", + "up_blocks.2.attentions.0.proj_in.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.0.proj_out.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.norm.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.norm.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.proj_in.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.1.proj_out.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.norm.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.norm.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.proj_in.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.2.proj_out.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "up_blocks.2.resnets.0.conv1.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.conv1.weight torch.Size([640, 1920, 3, 3])\n", + "up_blocks.2.resnets.0.conv2.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.conv2.weight torch.Size([640, 640, 3, 3])\n", + "up_blocks.2.resnets.0.conv_shortcut.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.conv_shortcut.weight torch.Size([640, 1920, 1, 1])\n", + "up_blocks.2.resnets.0.norm1.bias torch.Size([1920])\n", + "up_blocks.2.resnets.0.norm1.weight torch.Size([1920])\n", + "up_blocks.2.resnets.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.resnets.0.time_emb_proj.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.time_emb_proj.weight torch.Size([640, 1280])\n", + "up_blocks.2.resnets.1.conv1.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.conv1.weight torch.Size([640, 1280, 3, 3])\n", + "up_blocks.2.resnets.1.conv2.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.conv2.weight torch.Size([640, 640, 3, 3])\n", + "up_blocks.2.resnets.1.conv_shortcut.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.conv_shortcut.weight torch.Size([640, 1280, 1, 1])\n", + "up_blocks.2.resnets.1.norm1.bias torch.Size([1280])\n", + "up_blocks.2.resnets.1.norm1.weight torch.Size([1280])\n", + "up_blocks.2.resnets.1.norm2.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.norm2.weight torch.Size([640])\n", + "up_blocks.2.resnets.1.time_emb_proj.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.time_emb_proj.weight torch.Size([640, 1280])\n", + "up_blocks.2.resnets.2.conv1.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.conv1.weight torch.Size([640, 960, 3, 3])\n", + "up_blocks.2.resnets.2.conv2.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.conv2.weight torch.Size([640, 640, 3, 3])\n", + "up_blocks.2.resnets.2.conv_shortcut.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.conv_shortcut.weight torch.Size([640, 960, 1, 1])\n", + "up_blocks.2.resnets.2.norm1.bias torch.Size([960])\n", + "up_blocks.2.resnets.2.norm1.weight torch.Size([960])\n", + "up_blocks.2.resnets.2.norm2.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.norm2.weight torch.Size([640])\n", + "up_blocks.2.resnets.2.time_emb_proj.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.time_emb_proj.weight torch.Size([640, 1280])\n", + "up_blocks.2.upsamplers.0.conv.bias torch.Size([640])\n", + "up_blocks.2.upsamplers.0.conv.weight torch.Size([640, 640, 3, 3])\n", + "up_blocks.3.attentions.0.norm.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.norm.weight torch.Size([320])\n", + "up_blocks.3.attentions.0.proj_in.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.0.proj_out.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "up_blocks.3.attentions.1.norm.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.norm.weight torch.Size([320])\n", + "up_blocks.3.attentions.1.proj_in.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.1.proj_out.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "up_blocks.3.attentions.2.norm.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.norm.weight torch.Size([320])\n", + "up_blocks.3.attentions.2.proj_in.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.2.proj_out.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "up_blocks.3.resnets.0.conv1.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.conv1.weight torch.Size([320, 960, 3, 3])\n", + "up_blocks.3.resnets.0.conv2.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.conv2.weight torch.Size([320, 320, 3, 3])\n", + "up_blocks.3.resnets.0.conv_shortcut.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.conv_shortcut.weight torch.Size([320, 960, 1, 1])\n", + "up_blocks.3.resnets.0.norm1.bias torch.Size([960])\n", + "up_blocks.3.resnets.0.norm1.weight torch.Size([960])\n", + "up_blocks.3.resnets.0.norm2.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.norm2.weight torch.Size([320])\n", + "up_blocks.3.resnets.0.time_emb_proj.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.time_emb_proj.weight torch.Size([320, 1280])\n", + "up_blocks.3.resnets.1.conv1.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.conv1.weight torch.Size([320, 640, 3, 3])\n", + "up_blocks.3.resnets.1.conv2.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.conv2.weight torch.Size([320, 320, 3, 3])\n", + "up_blocks.3.resnets.1.conv_shortcut.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.conv_shortcut.weight torch.Size([320, 640, 1, 1])\n", + "up_blocks.3.resnets.1.norm1.bias torch.Size([640])\n", + "up_blocks.3.resnets.1.norm1.weight torch.Size([640])\n", + "up_blocks.3.resnets.1.norm2.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.norm2.weight torch.Size([320])\n", + "up_blocks.3.resnets.1.time_emb_proj.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.time_emb_proj.weight torch.Size([320, 1280])\n", + "up_blocks.3.resnets.2.conv1.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.conv1.weight torch.Size([320, 640, 3, 3])\n", + "up_blocks.3.resnets.2.conv2.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.conv2.weight torch.Size([320, 320, 3, 3])\n", + "up_blocks.3.resnets.2.conv_shortcut.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.conv_shortcut.weight torch.Size([320, 640, 1, 1])\n", + "up_blocks.3.resnets.2.norm1.bias torch.Size([640])\n", + "up_blocks.3.resnets.2.norm1.weight torch.Size([640])\n", + "up_blocks.3.resnets.2.norm2.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.norm2.weight torch.Size([320])\n", + "up_blocks.3.resnets.2.time_emb_proj.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.time_emb_proj.weight torch.Size([320, 1280])\n" + ] + } + ], + "source": [ + "from safetensors.torch import safe_open\n", + "\n", + "with safe_open(\"/mnt/disk2/hachi/New_ouput_7/checkpoint-10/unet/diffusion_pytorch_model.safetensors\", framework=\"pt\") as f:\n", + " for k in f.keys():\n", + " tensor = f.get_tensor(k)\n", + " print(k, tensor.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7e26824d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "conv_in.bias torch.Size([320])\n", + "conv_in.weight torch.Size([320, 9, 3, 3])\n", + "conv_norm_out.bias torch.Size([320])\n", + "conv_norm_out.weight torch.Size([320])\n", + "conv_out.bias torch.Size([4])\n", + "conv_out.weight torch.Size([4, 320, 3, 3])\n", + "down_blocks.0.attentions.0.norm.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.norm.weight torch.Size([320])\n", + "down_blocks.0.attentions.0.proj_in.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.0.proj_out.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.norm.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.norm.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.proj_in.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.1.proj_out.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "down_blocks.0.downsamplers.0.conv.bias torch.Size([320])\n", + "down_blocks.0.downsamplers.0.conv.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.0.conv1.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.conv1.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.0.conv2.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.conv2.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.0.norm1.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.norm1.weight torch.Size([320])\n", + "down_blocks.0.resnets.0.norm2.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.norm2.weight torch.Size([320])\n", + "down_blocks.0.resnets.0.time_emb_proj.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.time_emb_proj.weight torch.Size([320, 1280])\n", + "down_blocks.0.resnets.1.conv1.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.conv1.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.1.conv2.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.conv2.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.1.norm1.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.norm1.weight torch.Size([320])\n", + "down_blocks.0.resnets.1.norm2.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.norm2.weight torch.Size([320])\n", + "down_blocks.0.resnets.1.time_emb_proj.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.time_emb_proj.weight torch.Size([320, 1280])\n", + "down_blocks.1.attentions.0.norm.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.norm.weight torch.Size([640])\n", + "down_blocks.1.attentions.0.proj_in.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.0.proj_out.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.norm.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.norm.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.proj_in.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.1.proj_out.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "down_blocks.1.downsamplers.0.conv.bias torch.Size([640])\n", + "down_blocks.1.downsamplers.0.conv.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.0.conv1.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.conv1.weight torch.Size([640, 320, 3, 3])\n", + "down_blocks.1.resnets.0.conv2.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.conv2.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.0.conv_shortcut.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.conv_shortcut.weight torch.Size([640, 320, 1, 1])\n", + "down_blocks.1.resnets.0.norm1.bias torch.Size([320])\n", + "down_blocks.1.resnets.0.norm1.weight torch.Size([320])\n", + "down_blocks.1.resnets.0.norm2.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.norm2.weight torch.Size([640])\n", + "down_blocks.1.resnets.0.time_emb_proj.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.time_emb_proj.weight torch.Size([640, 1280])\n", + "down_blocks.1.resnets.1.conv1.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.conv1.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.1.conv2.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.conv2.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.1.norm1.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.norm1.weight torch.Size([640])\n", + "down_blocks.1.resnets.1.norm2.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.norm2.weight torch.Size([640])\n", + "down_blocks.1.resnets.1.time_emb_proj.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.time_emb_proj.weight torch.Size([640, 1280])\n", + "down_blocks.2.attentions.0.norm.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.norm.weight torch.Size([1280])\n", + "down_blocks.2.attentions.0.proj_in.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.0.proj_out.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.norm.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.norm.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.proj_in.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.1.proj_out.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "down_blocks.2.downsamplers.0.conv.bias torch.Size([1280])\n", + "down_blocks.2.downsamplers.0.conv.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.0.conv1.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.conv1.weight torch.Size([1280, 640, 3, 3])\n", + "down_blocks.2.resnets.0.conv2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.0.conv_shortcut.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.conv_shortcut.weight torch.Size([1280, 640, 1, 1])\n", + "down_blocks.2.resnets.0.norm1.bias torch.Size([640])\n", + "down_blocks.2.resnets.0.norm1.weight torch.Size([640])\n", + "down_blocks.2.resnets.0.norm2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.norm2.weight torch.Size([1280])\n", + "down_blocks.2.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "down_blocks.2.resnets.1.conv1.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.1.conv2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.1.norm1.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.norm1.weight torch.Size([1280])\n", + "down_blocks.2.resnets.1.norm2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.norm2.weight torch.Size([1280])\n", + "down_blocks.2.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "down_blocks.3.resnets.0.conv1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.0.conv2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.0.norm1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.norm1.weight torch.Size([1280])\n", + "down_blocks.3.resnets.0.norm2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.norm2.weight torch.Size([1280])\n", + "down_blocks.3.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "down_blocks.3.resnets.1.conv1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.1.conv2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.1.norm1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.norm1.weight torch.Size([1280])\n", + "down_blocks.3.resnets.1.norm2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.norm2.weight torch.Size([1280])\n", + "down_blocks.3.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.norm.bias torch.Size([1280])\n", + "mid_block.attentions.0.norm.weight torch.Size([1280])\n", + "mid_block.attentions.0.proj_in.bias torch.Size([1280])\n", + "mid_block.attentions.0.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "mid_block.attentions.0.proj_out.bias torch.Size([1280])\n", + "mid_block.attentions.0.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "mid_block.attentions.0.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "mid_block.resnets.0.conv1.bias torch.Size([1280])\n", + "mid_block.resnets.0.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.0.conv2.bias torch.Size([1280])\n", + "mid_block.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.0.norm1.bias torch.Size([1280])\n", + "mid_block.resnets.0.norm1.weight torch.Size([1280])\n", + "mid_block.resnets.0.norm2.bias torch.Size([1280])\n", + "mid_block.resnets.0.norm2.weight torch.Size([1280])\n", + "mid_block.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "mid_block.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "mid_block.resnets.1.conv1.bias torch.Size([1280])\n", + "mid_block.resnets.1.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.1.conv2.bias torch.Size([1280])\n", + "mid_block.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.1.norm1.bias torch.Size([1280])\n", + "mid_block.resnets.1.norm1.weight torch.Size([1280])\n", + "mid_block.resnets.1.norm2.bias torch.Size([1280])\n", + "mid_block.resnets.1.norm2.weight torch.Size([1280])\n", + "mid_block.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "mid_block.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "time_embedding.linear_1.bias torch.Size([1280])\n", + "time_embedding.linear_1.weight torch.Size([1280, 320])\n", + "time_embedding.linear_2.bias torch.Size([1280])\n", + "time_embedding.linear_2.weight torch.Size([1280, 1280])\n", + "up_blocks.0.resnets.0.conv1.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.0.resnets.0.conv2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.0.resnets.0.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.0.resnets.0.norm1.bias torch.Size([2560])\n", + "up_blocks.0.resnets.0.norm1.weight torch.Size([2560])\n", + "up_blocks.0.resnets.0.norm2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.norm2.weight torch.Size([1280])\n", + "up_blocks.0.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.0.resnets.1.conv1.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.0.resnets.1.conv2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.0.resnets.1.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.0.resnets.1.norm1.bias torch.Size([2560])\n", + "up_blocks.0.resnets.1.norm1.weight torch.Size([2560])\n", + "up_blocks.0.resnets.1.norm2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.norm2.weight torch.Size([1280])\n", + "up_blocks.0.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.0.resnets.2.conv1.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.0.resnets.2.conv2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.0.resnets.2.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.0.resnets.2.norm1.bias torch.Size([2560])\n", + "up_blocks.0.resnets.2.norm1.weight torch.Size([2560])\n", + "up_blocks.0.resnets.2.norm2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.norm2.weight torch.Size([1280])\n", + "up_blocks.0.resnets.2.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.0.upsamplers.0.conv.bias torch.Size([1280])\n", + "up_blocks.0.upsamplers.0.conv.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.attentions.0.norm.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.norm.weight torch.Size([1280])\n", + "up_blocks.1.attentions.0.proj_in.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.0.proj_out.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.norm.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.norm.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.proj_in.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.1.proj_out.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.norm.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.norm.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.proj_in.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.2.proj_out.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv1.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.1.resnets.0.conv2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.resnets.0.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.1.resnets.0.norm1.bias torch.Size([2560])\n", + "up_blocks.1.resnets.0.norm1.weight torch.Size([2560])\n", + "up_blocks.1.resnets.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.1.resnets.1.conv1.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.1.resnets.1.conv2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.resnets.1.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.1.resnets.1.norm1.bias torch.Size([2560])\n", + "up_blocks.1.resnets.1.norm1.weight torch.Size([2560])\n", + "up_blocks.1.resnets.1.norm2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.norm2.weight torch.Size([1280])\n", + "up_blocks.1.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.1.resnets.2.conv1.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.conv1.weight torch.Size([1280, 1920, 3, 3])\n", + "up_blocks.1.resnets.2.conv2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.resnets.2.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.conv_shortcut.weight torch.Size([1280, 1920, 1, 1])\n", + "up_blocks.1.resnets.2.norm1.bias torch.Size([1920])\n", + "up_blocks.1.resnets.2.norm1.weight torch.Size([1920])\n", + "up_blocks.1.resnets.2.norm2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.norm2.weight torch.Size([1280])\n", + "up_blocks.1.resnets.2.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.1.upsamplers.0.conv.bias torch.Size([1280])\n", + "up_blocks.1.upsamplers.0.conv.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.2.attentions.0.norm.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.norm.weight torch.Size([640])\n", + "up_blocks.2.attentions.0.proj_in.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.0.proj_out.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.norm.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.norm.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.proj_in.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.1.proj_out.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.norm.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.norm.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.proj_in.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.2.proj_out.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n" + ] + }, + { + "ename": "ValueError", + "evalue": "could not determine the shape of object type 'torch.storage.UntypedStorage'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m safe_open(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/workdir/radish/hachi/checkpoints/ppt-v1/unet/unet.safetensors\u001b[39m\u001b[38;5;124m\"\u001b[39m, framework\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpt\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m f\u001b[38;5;241m.\u001b[39mkeys():\n\u001b[0;32m----> 5\u001b[0m tensor \u001b[38;5;241m=\u001b[39m \u001b[43mf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_tensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mk\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(k, tensor\u001b[38;5;241m.\u001b[39mshape)\n", + "\u001b[0;31mValueError\u001b[0m: could not determine the shape of object type 'torch.storage.UntypedStorage'" + ] + } + ], + "source": [ + "from safetensors.torch import safe_open\n", + "\n", + "with safe_open(\"/workdir/radish/hachi/checkpoints/ppt-v1/unet/unet.safetensors\", framework=\"pt\") as f:\n", + " for k in f.keys():\n", + " tensor = f.get_tensor(k)\n", + " print(k, tensor.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "52ea1324", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "text_model.embeddings.position_ids torch.Size([1, 77])\n", + "text_model.embeddings.token_embedding.wrapped.weight torch.Size([49408, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_shape torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_obj torch.Size([10, 768])\n", + "text_model.embeddings.position_embedding.weight torch.Size([77, 768])\n", + "text_model.encoder.layers.0.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.0.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.0.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.0.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.0.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.1.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.1.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.1.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.1.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.2.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.2.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.2.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.2.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.3.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.3.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.3.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.3.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.4.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.4.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.4.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.4.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.5.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.5.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.5.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.5.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.6.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.6.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.6.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.6.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.7.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.7.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.7.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.7.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.8.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.8.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.8.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.8.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.9.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.9.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.9.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.9.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.10.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.10.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.10.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.10.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.11.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.11.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.11.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.11.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm2.bias torch.Size([768])\n", + "text_model.final_layer_norm.weight torch.Size([768])\n", + "text_model.final_layer_norm.bias torch.Size([768])\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "state_dict = torch.load(\"/mnt/disk2/hachi/New_ouput_7/checkpoint-10/text_encoder/pytorch_model.bin\", map_location=\"cpu\")\n", + "\n", + "for k, v in state_dict.items():\n", + " print(k, v.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5b515d1d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "text_model.embeddings.position_ids torch.Size([1, 77])\n", + "text_model.embeddings.token_embedding.weight torch.Size([49448, 768])\n", + "text_model.embeddings.position_embedding.weight torch.Size([77, 768])\n", + "text_model.encoder.layers.0.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.0.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.0.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.0.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.0.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.1.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.1.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.1.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.1.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.2.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.2.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.2.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.2.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.3.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.3.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.3.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.3.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.4.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.4.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.4.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.4.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.5.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.5.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.5.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.5.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.6.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.6.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.6.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.6.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.7.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.7.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.7.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.7.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.8.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.8.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.8.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.8.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.9.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.9.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.9.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.9.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.10.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.10.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.10.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.10.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.11.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.11.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.11.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.11.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm2.bias torch.Size([768])\n", + "text_model.final_layer_norm.weight torch.Size([768])\n", + "text_model.final_layer_norm.bias torch.Size([768])\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "state_dict = torch.load(\"/workdir/radish/hachi/New_Ouput/checkpoint-200/text_encoder/pytorch_model.bin\", map_location=\"cpu\")\n", + "\n", + "for k, v in state_dict.items():\n", + " print(k, v.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7b0bb3eb", + "metadata": {}, + "outputs": [], + "source": [ + "lt = []\n", + "for i in lt:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "576c9a0c", + "metadata": {}, + "outputs": [], + "source": [ + "if '1' in lt:\n", + " print('có')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "db676b89", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "text_model.embeddings.position_ids torch.Size([1, 77])\n", + "text_model.embeddings.token_embedding.wrapped.weight torch.Size([49408, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_shape torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_obj torch.Size([10, 768])\n", + "text_model.embeddings.position_embedding.weight torch.Size([77, 768])\n", + "text_model.encoder.layers.0.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.0.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.0.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.0.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.0.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.0.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.0.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.1.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.1.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.1.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.1.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.1.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.1.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.2.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.2.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.2.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.2.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.2.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.2.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.3.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.3.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.3.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.3.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.3.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.3.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.4.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.4.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.4.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.4.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.4.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.4.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.5.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.5.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.5.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.5.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.5.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.5.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.6.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.6.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.6.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.6.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.6.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.6.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.7.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.7.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.7.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.7.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.7.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.7.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.8.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.8.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.8.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.8.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.8.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.8.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.9.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.9.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.9.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.9.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.9.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.9.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.10.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.10.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.10.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.10.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.10.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.10.layer_norm2.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.k_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.k_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.v_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.v_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.q_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.q_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.self_attn.out_proj.weight torch.Size([768, 768])\n", + "text_model.encoder.layers.11.self_attn.out_proj.bias torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm1.weight torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm1.bias torch.Size([768])\n", + "text_model.encoder.layers.11.mlp.fc1.weight torch.Size([3072, 768])\n", + "text_model.encoder.layers.11.mlp.fc1.bias torch.Size([3072])\n", + "text_model.encoder.layers.11.mlp.fc2.weight torch.Size([768, 3072])\n", + "text_model.encoder.layers.11.mlp.fc2.bias torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm2.weight torch.Size([768])\n", + "text_model.encoder.layers.11.layer_norm2.bias torch.Size([768])\n", + "text_model.final_layer_norm.weight torch.Size([768])\n", + "text_model.final_layer_norm.bias torch.Size([768])\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "state_dict = torch.load(\"/workdir/radish/hachi/checkpoints/ppt-v2/PowerPaint_Brushnet/pytorch_model.bin\", map_location=\"cpu\")\n", + "\n", + "for k, v in state_dict.items():\n", + " print(k, v.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "dc5dcf39", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0.0024, -0.0033, -0.0174, ..., -0.0183, 0.0134, 0.0122],\n", + " [ 0.0018, -0.0022, -0.0140, ..., -0.0127, 0.0105, 0.0046],\n", + " [-0.0006, 0.0001, -0.0137, ..., -0.0111, 0.0125, 0.0001],\n", + " ...,\n", + " [-0.0042, 0.0033, -0.0111, ..., -0.0145, 0.0117, 0.0078],\n", + " [-0.0044, 0.0042, -0.0100, ..., -0.0145, 0.0122, 0.0089],\n", + " [-0.0019, -0.0012, -0.0094, ..., -0.0143, 0.0110, 0.0110]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state_dict['text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt']" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2438cf4d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "brushnet_down_blocks.0.bias torch.Size([320])\n", + "brushnet_down_blocks.0.weight torch.Size([320, 320, 1, 1])\n", + "brushnet_down_blocks.1.bias torch.Size([320])\n", + "brushnet_down_blocks.1.weight torch.Size([320, 320, 1, 1])\n", + "brushnet_down_blocks.10.bias torch.Size([1280])\n", + "brushnet_down_blocks.10.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_down_blocks.11.bias torch.Size([1280])\n", + "brushnet_down_blocks.11.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_down_blocks.2.bias torch.Size([320])\n", + "brushnet_down_blocks.2.weight torch.Size([320, 320, 1, 1])\n", + "brushnet_down_blocks.3.bias torch.Size([320])\n", + "brushnet_down_blocks.3.weight torch.Size([320, 320, 1, 1])\n", + "brushnet_down_blocks.4.bias torch.Size([640])\n", + "brushnet_down_blocks.4.weight torch.Size([640, 640, 1, 1])\n", + "brushnet_down_blocks.5.bias torch.Size([640])\n", + "brushnet_down_blocks.5.weight torch.Size([640, 640, 1, 1])\n", + "brushnet_down_blocks.6.bias torch.Size([640])\n", + "brushnet_down_blocks.6.weight torch.Size([640, 640, 1, 1])\n", + "brushnet_down_blocks.7.bias torch.Size([1280])\n", + "brushnet_down_blocks.7.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_down_blocks.8.bias torch.Size([1280])\n", + "brushnet_down_blocks.8.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_down_blocks.9.bias torch.Size([1280])\n", + "brushnet_down_blocks.9.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_mid_block.bias torch.Size([1280])\n", + "brushnet_mid_block.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_up_blocks.0.bias torch.Size([1280])\n", + "brushnet_up_blocks.0.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_up_blocks.1.bias torch.Size([1280])\n", + "brushnet_up_blocks.1.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_up_blocks.10.bias torch.Size([640])\n", + "brushnet_up_blocks.10.weight torch.Size([640, 640, 1, 1])\n", + "brushnet_up_blocks.11.bias torch.Size([640])\n", + "brushnet_up_blocks.11.weight torch.Size([640, 640, 1, 1])\n", + "brushnet_up_blocks.12.bias torch.Size([320])\n", + "brushnet_up_blocks.12.weight torch.Size([320, 320, 1, 1])\n", + "brushnet_up_blocks.13.bias torch.Size([320])\n", + "brushnet_up_blocks.13.weight torch.Size([320, 320, 1, 1])\n", + "brushnet_up_blocks.14.bias torch.Size([320])\n", + "brushnet_up_blocks.14.weight torch.Size([320, 320, 1, 1])\n", + "brushnet_up_blocks.2.bias torch.Size([1280])\n", + "brushnet_up_blocks.2.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_up_blocks.3.bias torch.Size([1280])\n", + "brushnet_up_blocks.3.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_up_blocks.4.bias torch.Size([1280])\n", + "brushnet_up_blocks.4.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_up_blocks.5.bias torch.Size([1280])\n", + "brushnet_up_blocks.5.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_up_blocks.6.bias torch.Size([1280])\n", + "brushnet_up_blocks.6.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_up_blocks.7.bias torch.Size([1280])\n", + "brushnet_up_blocks.7.weight torch.Size([1280, 1280, 1, 1])\n", + "brushnet_up_blocks.8.bias torch.Size([640])\n", + "brushnet_up_blocks.8.weight torch.Size([640, 640, 1, 1])\n", + "brushnet_up_blocks.9.bias torch.Size([640])\n", + "brushnet_up_blocks.9.weight torch.Size([640, 640, 1, 1])\n", + "conv_in_condition.bias torch.Size([320])\n", + "conv_in_condition.weight torch.Size([320, 9, 3, 3])\n", + "down_blocks.0.attentions.0.norm.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.norm.weight torch.Size([320])\n", + "down_blocks.0.attentions.0.proj_in.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.0.proj_out.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "down_blocks.0.attentions.0.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.norm.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.norm.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.proj_in.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.1.proj_out.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "down_blocks.0.attentions.1.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "down_blocks.0.downsamplers.0.conv.bias torch.Size([320])\n", + "down_blocks.0.downsamplers.0.conv.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.0.conv1.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.conv1.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.0.conv2.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.conv2.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.0.norm1.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.norm1.weight torch.Size([320])\n", + "down_blocks.0.resnets.0.norm2.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.norm2.weight torch.Size([320])\n", + "down_blocks.0.resnets.0.time_emb_proj.bias torch.Size([320])\n", + "down_blocks.0.resnets.0.time_emb_proj.weight torch.Size([320, 1280])\n", + "down_blocks.0.resnets.1.conv1.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.conv1.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.1.conv2.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.conv2.weight torch.Size([320, 320, 3, 3])\n", + "down_blocks.0.resnets.1.norm1.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.norm1.weight torch.Size([320])\n", + "down_blocks.0.resnets.1.norm2.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.norm2.weight torch.Size([320])\n", + "down_blocks.0.resnets.1.time_emb_proj.bias torch.Size([320])\n", + "down_blocks.0.resnets.1.time_emb_proj.weight torch.Size([320, 1280])\n", + "down_blocks.1.attentions.0.norm.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.norm.weight torch.Size([640])\n", + "down_blocks.1.attentions.0.proj_in.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.0.proj_out.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "down_blocks.1.attentions.0.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.norm.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.norm.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.proj_in.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.1.proj_out.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "down_blocks.1.attentions.1.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "down_blocks.1.downsamplers.0.conv.bias torch.Size([640])\n", + "down_blocks.1.downsamplers.0.conv.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.0.conv1.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.conv1.weight torch.Size([640, 320, 3, 3])\n", + "down_blocks.1.resnets.0.conv2.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.conv2.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.0.conv_shortcut.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.conv_shortcut.weight torch.Size([640, 320, 1, 1])\n", + "down_blocks.1.resnets.0.norm1.bias torch.Size([320])\n", + "down_blocks.1.resnets.0.norm1.weight torch.Size([320])\n", + "down_blocks.1.resnets.0.norm2.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.norm2.weight torch.Size([640])\n", + "down_blocks.1.resnets.0.time_emb_proj.bias torch.Size([640])\n", + "down_blocks.1.resnets.0.time_emb_proj.weight torch.Size([640, 1280])\n", + "down_blocks.1.resnets.1.conv1.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.conv1.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.1.conv2.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.conv2.weight torch.Size([640, 640, 3, 3])\n", + "down_blocks.1.resnets.1.norm1.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.norm1.weight torch.Size([640])\n", + "down_blocks.1.resnets.1.norm2.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.norm2.weight torch.Size([640])\n", + "down_blocks.1.resnets.1.time_emb_proj.bias torch.Size([640])\n", + "down_blocks.1.resnets.1.time_emb_proj.weight torch.Size([640, 1280])\n", + "down_blocks.2.attentions.0.norm.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.norm.weight torch.Size([1280])\n", + "down_blocks.2.attentions.0.proj_in.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.0.proj_out.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "down_blocks.2.attentions.0.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.norm.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.norm.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.proj_in.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.1.proj_out.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "down_blocks.2.attentions.1.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "down_blocks.2.downsamplers.0.conv.bias torch.Size([1280])\n", + "down_blocks.2.downsamplers.0.conv.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.0.conv1.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.conv1.weight torch.Size([1280, 640, 3, 3])\n", + "down_blocks.2.resnets.0.conv2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.0.conv_shortcut.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.conv_shortcut.weight torch.Size([1280, 640, 1, 1])\n", + "down_blocks.2.resnets.0.norm1.bias torch.Size([640])\n", + "down_blocks.2.resnets.0.norm1.weight torch.Size([640])\n", + "down_blocks.2.resnets.0.norm2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.norm2.weight torch.Size([1280])\n", + "down_blocks.2.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.2.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "down_blocks.2.resnets.1.conv1.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.1.conv2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.2.resnets.1.norm1.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.norm1.weight torch.Size([1280])\n", + "down_blocks.2.resnets.1.norm2.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.norm2.weight torch.Size([1280])\n", + "down_blocks.2.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.2.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "down_blocks.3.resnets.0.conv1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.0.conv2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.0.norm1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.norm1.weight torch.Size([1280])\n", + "down_blocks.3.resnets.0.norm2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.norm2.weight torch.Size([1280])\n", + "down_blocks.3.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.3.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "down_blocks.3.resnets.1.conv1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.1.conv2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "down_blocks.3.resnets.1.norm1.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.norm1.weight torch.Size([1280])\n", + "down_blocks.3.resnets.1.norm2.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.norm2.weight torch.Size([1280])\n", + "down_blocks.3.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "down_blocks.3.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.norm.bias torch.Size([1280])\n", + "mid_block.attentions.0.norm.weight torch.Size([1280])\n", + "mid_block.attentions.0.proj_in.bias torch.Size([1280])\n", + "mid_block.attentions.0.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "mid_block.attentions.0.proj_out.bias torch.Size([1280])\n", + "mid_block.attentions.0.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "mid_block.attentions.0.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "mid_block.attentions.0.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "mid_block.resnets.0.conv1.bias torch.Size([1280])\n", + "mid_block.resnets.0.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.0.conv2.bias torch.Size([1280])\n", + "mid_block.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.0.norm1.bias torch.Size([1280])\n", + "mid_block.resnets.0.norm1.weight torch.Size([1280])\n", + "mid_block.resnets.0.norm2.bias torch.Size([1280])\n", + "mid_block.resnets.0.norm2.weight torch.Size([1280])\n", + "mid_block.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "mid_block.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "mid_block.resnets.1.conv1.bias torch.Size([1280])\n", + "mid_block.resnets.1.conv1.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.1.conv2.bias torch.Size([1280])\n", + "mid_block.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "mid_block.resnets.1.norm1.bias torch.Size([1280])\n", + "mid_block.resnets.1.norm1.weight torch.Size([1280])\n", + "mid_block.resnets.1.norm2.bias torch.Size([1280])\n", + "mid_block.resnets.1.norm2.weight torch.Size([1280])\n", + "mid_block.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "mid_block.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "time_embedding.linear_1.bias torch.Size([1280])\n", + "time_embedding.linear_1.weight torch.Size([1280, 320])\n", + "time_embedding.linear_2.bias torch.Size([1280])\n", + "time_embedding.linear_2.weight torch.Size([1280, 1280])\n", + "up_blocks.0.resnets.0.conv1.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.0.resnets.0.conv2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.0.resnets.0.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.0.resnets.0.norm1.bias torch.Size([2560])\n", + "up_blocks.0.resnets.0.norm1.weight torch.Size([2560])\n", + "up_blocks.0.resnets.0.norm2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.norm2.weight torch.Size([1280])\n", + "up_blocks.0.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.0.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.0.resnets.1.conv1.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.0.resnets.1.conv2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.0.resnets.1.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.0.resnets.1.norm1.bias torch.Size([2560])\n", + "up_blocks.0.resnets.1.norm1.weight torch.Size([2560])\n", + "up_blocks.0.resnets.1.norm2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.norm2.weight torch.Size([1280])\n", + "up_blocks.0.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.0.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.0.resnets.2.conv1.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.0.resnets.2.conv2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.0.resnets.2.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.0.resnets.2.norm1.bias torch.Size([2560])\n", + "up_blocks.0.resnets.2.norm1.weight torch.Size([2560])\n", + "up_blocks.0.resnets.2.norm2.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.norm2.weight torch.Size([1280])\n", + "up_blocks.0.resnets.2.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.0.resnets.2.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.0.upsamplers.0.conv.bias torch.Size([1280])\n", + "up_blocks.0.upsamplers.0.conv.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.attentions.0.norm.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.norm.weight torch.Size([1280])\n", + "up_blocks.1.attentions.0.proj_in.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.0.proj_out.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "up_blocks.1.attentions.0.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.norm.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.norm.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.proj_in.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.1.proj_out.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "up_blocks.1.attentions.1.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.norm.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.norm.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.proj_in.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.proj_in.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.2.proj_out.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.proj_out.weight torch.Size([1280, 1280, 1, 1])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_k.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn1.to_v.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_k.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_out.0.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_out.0.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_q.weight torch.Size([1280, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.attn2.to_v.weight torch.Size([1280, 768])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.0.proj.bias torch.Size([10240])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.0.proj.weight torch.Size([10240, 1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.ff.net.2.weight torch.Size([1280, 5120])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm1.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm1.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm3.bias torch.Size([1280])\n", + "up_blocks.1.attentions.2.transformer_blocks.0.norm3.weight torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv1.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.1.resnets.0.conv2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.resnets.0.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.1.resnets.0.norm1.bias torch.Size([2560])\n", + "up_blocks.1.resnets.0.norm1.weight torch.Size([2560])\n", + "up_blocks.1.resnets.0.norm2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.norm2.weight torch.Size([1280])\n", + "up_blocks.1.resnets.0.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.1.resnets.0.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.1.resnets.1.conv1.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.conv1.weight torch.Size([1280, 2560, 3, 3])\n", + "up_blocks.1.resnets.1.conv2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.resnets.1.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.conv_shortcut.weight torch.Size([1280, 2560, 1, 1])\n", + "up_blocks.1.resnets.1.norm1.bias torch.Size([2560])\n", + "up_blocks.1.resnets.1.norm1.weight torch.Size([2560])\n", + "up_blocks.1.resnets.1.norm2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.norm2.weight torch.Size([1280])\n", + "up_blocks.1.resnets.1.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.1.resnets.1.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.1.resnets.2.conv1.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.conv1.weight torch.Size([1280, 1920, 3, 3])\n", + "up_blocks.1.resnets.2.conv2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.conv2.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.1.resnets.2.conv_shortcut.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.conv_shortcut.weight torch.Size([1280, 1920, 1, 1])\n", + "up_blocks.1.resnets.2.norm1.bias torch.Size([1920])\n", + "up_blocks.1.resnets.2.norm1.weight torch.Size([1920])\n", + "up_blocks.1.resnets.2.norm2.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.norm2.weight torch.Size([1280])\n", + "up_blocks.1.resnets.2.time_emb_proj.bias torch.Size([1280])\n", + "up_blocks.1.resnets.2.time_emb_proj.weight torch.Size([1280, 1280])\n", + "up_blocks.1.upsamplers.0.conv.bias torch.Size([1280])\n", + "up_blocks.1.upsamplers.0.conv.weight torch.Size([1280, 1280, 3, 3])\n", + "up_blocks.2.attentions.0.norm.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.norm.weight torch.Size([640])\n", + "up_blocks.2.attentions.0.proj_in.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.0.proj_out.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "up_blocks.2.attentions.0.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.norm.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.norm.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.proj_in.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.1.proj_out.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "up_blocks.2.attentions.1.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.norm.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.norm.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.proj_in.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.proj_in.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.2.proj_out.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.proj_out.weight torch.Size([640, 640, 1, 1])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_k.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn1.to_v.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_k.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_out.0.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_out.0.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_q.weight torch.Size([640, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.attn2.to_v.weight torch.Size([640, 768])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.0.proj.bias torch.Size([5120])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.0.proj.weight torch.Size([5120, 640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.2.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.ff.net.2.weight torch.Size([640, 2560])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm1.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm1.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm3.bias torch.Size([640])\n", + "up_blocks.2.attentions.2.transformer_blocks.0.norm3.weight torch.Size([640])\n", + "up_blocks.2.resnets.0.conv1.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.conv1.weight torch.Size([640, 1920, 3, 3])\n", + "up_blocks.2.resnets.0.conv2.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.conv2.weight torch.Size([640, 640, 3, 3])\n", + "up_blocks.2.resnets.0.conv_shortcut.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.conv_shortcut.weight torch.Size([640, 1920, 1, 1])\n", + "up_blocks.2.resnets.0.norm1.bias torch.Size([1920])\n", + "up_blocks.2.resnets.0.norm1.weight torch.Size([1920])\n", + "up_blocks.2.resnets.0.norm2.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.norm2.weight torch.Size([640])\n", + "up_blocks.2.resnets.0.time_emb_proj.bias torch.Size([640])\n", + "up_blocks.2.resnets.0.time_emb_proj.weight torch.Size([640, 1280])\n", + "up_blocks.2.resnets.1.conv1.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.conv1.weight torch.Size([640, 1280, 3, 3])\n", + "up_blocks.2.resnets.1.conv2.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.conv2.weight torch.Size([640, 640, 3, 3])\n", + "up_blocks.2.resnets.1.conv_shortcut.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.conv_shortcut.weight torch.Size([640, 1280, 1, 1])\n", + "up_blocks.2.resnets.1.norm1.bias torch.Size([1280])\n", + "up_blocks.2.resnets.1.norm1.weight torch.Size([1280])\n", + "up_blocks.2.resnets.1.norm2.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.norm2.weight torch.Size([640])\n", + "up_blocks.2.resnets.1.time_emb_proj.bias torch.Size([640])\n", + "up_blocks.2.resnets.1.time_emb_proj.weight torch.Size([640, 1280])\n", + "up_blocks.2.resnets.2.conv1.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.conv1.weight torch.Size([640, 960, 3, 3])\n", + "up_blocks.2.resnets.2.conv2.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.conv2.weight torch.Size([640, 640, 3, 3])\n", + "up_blocks.2.resnets.2.conv_shortcut.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.conv_shortcut.weight torch.Size([640, 960, 1, 1])\n", + "up_blocks.2.resnets.2.norm1.bias torch.Size([960])\n", + "up_blocks.2.resnets.2.norm1.weight torch.Size([960])\n", + "up_blocks.2.resnets.2.norm2.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.norm2.weight torch.Size([640])\n", + "up_blocks.2.resnets.2.time_emb_proj.bias torch.Size([640])\n", + "up_blocks.2.resnets.2.time_emb_proj.weight torch.Size([640, 1280])\n", + "up_blocks.2.upsamplers.0.conv.bias torch.Size([640])\n", + "up_blocks.2.upsamplers.0.conv.weight torch.Size([640, 640, 3, 3])\n", + "up_blocks.3.attentions.0.norm.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.norm.weight torch.Size([320])\n", + "up_blocks.3.attentions.0.proj_in.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.0.proj_out.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "up_blocks.3.attentions.0.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "up_blocks.3.attentions.1.norm.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.norm.weight torch.Size([320])\n", + "up_blocks.3.attentions.1.proj_in.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.1.proj_out.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "up_blocks.3.attentions.1.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "up_blocks.3.attentions.2.norm.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.norm.weight torch.Size([320])\n", + "up_blocks.3.attentions.2.proj_in.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.proj_in.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.2.proj_out.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.proj_out.weight torch.Size([320, 320, 1, 1])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_k.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn1.to_v.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_k.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_out.0.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_out.0.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_q.weight torch.Size([320, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.attn2.to_v.weight torch.Size([320, 768])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.ff.net.0.proj.bias torch.Size([2560])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.ff.net.0.proj.weight torch.Size([2560, 320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.ff.net.2.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.ff.net.2.weight torch.Size([320, 1280])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm1.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm1.weight torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm2.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm2.weight torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm3.bias torch.Size([320])\n", + "up_blocks.3.attentions.2.transformer_blocks.0.norm3.weight torch.Size([320])\n", + "up_blocks.3.resnets.0.conv1.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.conv1.weight torch.Size([320, 960, 3, 3])\n", + "up_blocks.3.resnets.0.conv2.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.conv2.weight torch.Size([320, 320, 3, 3])\n", + "up_blocks.3.resnets.0.conv_shortcut.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.conv_shortcut.weight torch.Size([320, 960, 1, 1])\n", + "up_blocks.3.resnets.0.norm1.bias torch.Size([960])\n", + "up_blocks.3.resnets.0.norm1.weight torch.Size([960])\n", + "up_blocks.3.resnets.0.norm2.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.norm2.weight torch.Size([320])\n", + "up_blocks.3.resnets.0.time_emb_proj.bias torch.Size([320])\n", + "up_blocks.3.resnets.0.time_emb_proj.weight torch.Size([320, 1280])\n", + "up_blocks.3.resnets.1.conv1.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.conv1.weight torch.Size([320, 640, 3, 3])\n", + "up_blocks.3.resnets.1.conv2.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.conv2.weight torch.Size([320, 320, 3, 3])\n", + "up_blocks.3.resnets.1.conv_shortcut.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.conv_shortcut.weight torch.Size([320, 640, 1, 1])\n", + "up_blocks.3.resnets.1.norm1.bias torch.Size([640])\n", + "up_blocks.3.resnets.1.norm1.weight torch.Size([640])\n", + "up_blocks.3.resnets.1.norm2.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.norm2.weight torch.Size([320])\n", + "up_blocks.3.resnets.1.time_emb_proj.bias torch.Size([320])\n", + "up_blocks.3.resnets.1.time_emb_proj.weight torch.Size([320, 1280])\n", + "up_blocks.3.resnets.2.conv1.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.conv1.weight torch.Size([320, 640, 3, 3])\n", + "up_blocks.3.resnets.2.conv2.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.conv2.weight torch.Size([320, 320, 3, 3])\n", + "up_blocks.3.resnets.2.conv_shortcut.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.conv_shortcut.weight torch.Size([320, 640, 1, 1])\n", + "up_blocks.3.resnets.2.norm1.bias torch.Size([640])\n", + "up_blocks.3.resnets.2.norm1.weight torch.Size([640])\n", + "up_blocks.3.resnets.2.norm2.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.norm2.weight torch.Size([320])\n", + "up_blocks.3.resnets.2.time_emb_proj.bias torch.Size([320])\n", + "up_blocks.3.resnets.2.time_emb_proj.weight torch.Size([320, 1280])\n" + ] + } + ], + "source": [ + "from safetensors.torch import safe_open\n", + "\n", + "with safe_open(\"/workdir/radish/hachi/checkpoints/ppt-v2/PowerPaint_Brushnet/diffusion_pytorch_model.safetensors\", framework=\"pt\") as f:\n", + " for k in f.keys():\n", + " tensor = f.get_tensor(k)\n", + " print(k, tensor.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fef20bd5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anaconda3/envs/powerpaint/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12/18 08:22:51 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Successfully add external embeddings: P_ctxt, P_shape, P_obj.\n", + "12/18 08:22:51 - mmengine - \u001b[4m\u001b[97mINFO\u001b[0m - Successfully add trainable external embeddings: P_ctxt, P_shape, P_obj\n" + ] + } + ], + "source": [ + "from transformers import CLIPTextModel\n", + "\n", + "from powerpaint.utils.utils import TokenizerWrapper, add_tokens\n", + "\n", + "\n", + "text_encoder=CLIPTextModel.from_pretrained(\n", + " \"/workdir/radish/hachi/checkpoints/stable-diffusion-inpainting\",\n", + " subfolder=\"text_encoder\",\n", + " local_files_only=True,\n", + ")\n", + "tokenizer = TokenizerWrapper(\n", + " \"/workdir/radish/hachi/checkpoints/stable-diffusion-inpainting\",\n", + " subfolder='tokenizer',\n", + " local_files_only=True\n", + ")\n", + "add_tokens(\n", + " tokenizer=tokenizer,\n", + " text_encoder=text_encoder,\n", + " placeholder_tokens=[\"P_ctxt\", \"P_shape\", \"P_obj\"],\n", + " initialize_tokens=[\"a\", \"a\", \"a\"],\n", + " num_vectors_per_token=10,\n", + " )\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c4609a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "EmbeddingLayerWithFixes(\n", + " (wrapped): Embedding(49408, 768)\n", + " (trainable_embeddings): ParameterDict(\n", + " (P_ctxt): Parameter containing: [torch.FloatTensor of size 10x768]\n", + " (P_shape): Parameter containing: [torch.FloatTensor of size 10x768]\n", + " (P_obj): Parameter containing: [torch.FloatTensor of size 10x768]\n", + " )\n", + ")" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text_encoder.get_input_embeddings()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ccb84c87", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text_encoder.get_input_embeddings().parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "68a3e964", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Parameter containing:\n", + "tensor([[ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " ...,\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080]],\n", + " requires_grad=True)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text_encoder.get_input_embeddings().trainable_embeddings.P_ctxt" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "19e28ed2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Parameter containing:\n", + "tensor([[-0.0012, 0.0368, 0.0221, ..., 0.0158, 0.0046, -0.0219],\n", + " [ 0.0152, 0.0262, -0.0132, ..., -0.0037, 0.0002, 0.0121],\n", + " [-0.0154, -0.0131, 0.0065, ..., -0.0206, -0.0139, -0.0025],\n", + " ...,\n", + " [ 0.0102, -0.0030, -0.0150, ..., -0.0084, -0.0206, 0.0114],\n", + " [ 0.0011, 0.0032, 0.0003, ..., -0.0018, 0.0003, 0.0019],\n", + " [ 0.0012, 0.0077, -0.0011, ..., -0.0015, 0.0009, 0.0052]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "text_encoder.text_model.requires_grad_(True)\n", + "text_encoder.text_model.encoder.requires_grad_(False)\n", + "text_encoder.text_model.final_layer_norm.requires_grad_(False)\n", + "text_encoder.text_model.embeddings.position_embedding.requires_grad_(False)\n", + "# text_encoder.text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt.requires_grad_(False)\n", + "text_encoder.text_model.embeddings.token_embedding.trainable_embeddings.P_obj.requires_grad_(False)\n", + "text_encoder.text_model.embeddings.token_embedding.trainable_embeddings.P_shape.requires_grad_(False)\n", + "text_encoder.text_model.embeddings.token_embedding.wrapped.weight.requires_grad_(False)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "35047962", + "metadata": {}, + "outputs": [], + "source": [ + "params = [p for p in text_encoder.parameters() if p.requires_grad]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "79dfcd8d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Parameter containing:\n", + " tensor([[ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " ...,\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080],\n", + " [ 0.0013, -0.0011, -0.0126, ..., -0.0124, 0.0120, 0.0080]],\n", + " requires_grad=True)]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "params" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0fa7ca9b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt torch.Size([10, 768])\n" + ] + } + ], + "source": [ + "for name, p in text_encoder.named_parameters():\n", + " if p.requires_grad:\n", + " print(name, p.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7d2716a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Đây là một State Dict. Danh sách các lớp và kích thước tensor:\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt: torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_shape: torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_obj: torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_loc: torch.Size([10, 768])\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "# Đường dẫn tới file của bạn\n", + "checkpoint_path = '/mnt/disk2/hachi/New_ouput_7/task_prompt_step_1000.pt'\n", + "\n", + "# Load file\n", + "data = torch.load(checkpoint_path, map_location=torch.device('cpu'))\n", + "\n", + "# Kiểm tra xem đây là State Dict hay Full Model\n", + "if isinstance(data, dict):\n", + " print(\"Đây là một State Dict. Danh sách các lớp và kích thước tensor:\")\n", + " for key, value in data.items():\n", + " print(f\"{key}: {value.shape}\")\n", + "else:\n", + " print(\"Đây là Full Model. Kiến trúc model là:\")\n", + " print(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "1563ad6f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0.0024, -0.0023, -0.0102, ..., -0.0127, 0.0168, 0.0099],\n", + " [ 0.0022, 0.0099, -0.0118, ..., -0.0072, 0.0153, 0.0081],\n", + " [ 0.0073, 0.0023, -0.0149, ..., -0.0051, 0.0157, 0.0099],\n", + " ...,\n", + " [-0.0066, 0.0033, -0.0138, ..., -0.0154, 0.0180, 0.0102],\n", + " [-0.0006, 0.0034, -0.0151, ..., -0.0156, 0.0130, 0.0084],\n", + " [ 0.0012, -0.0013, -0.0055, ..., -0.0179, 0.0084, 0.0153]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt']" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "057dc7d6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0.0024, -0.0024, -0.0102, ..., -0.0127, 0.0169, 0.0099],\n", + " [ 0.0021, 0.0100, -0.0117, ..., -0.0071, 0.0153, 0.0081],\n", + " [ 0.0073, 0.0023, -0.0150, ..., -0.0051, 0.0157, 0.0100],\n", + " ...,\n", + " [-0.0065, 0.0032, -0.0137, ..., -0.0155, 0.0179, 0.0101],\n", + " [-0.0005, 0.0033, -0.0151, ..., -0.0156, 0.0129, 0.0083],\n", + " [ 0.0012, -0.0014, -0.0055, ..., -0.0180, 0.0083, 0.0153]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['text_model.embeddings.token_embedding.trainable_embeddings.P_loc']" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "40b0c852", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 1.8293e-05, -6.1505e-05, -3.5468e-05, ..., -2.0023e-06,\n", + " 7.2047e-05, -4.4504e-05],\n", + " [-5.9925e-05, 2.5709e-05, 4.3962e-05, ..., 4.1701e-05,\n", + " 7.4374e-05, -1.2740e-05],\n", + " [-3.5858e-05, 2.2943e-06, -6.7805e-05, ..., 5.5692e-05,\n", + " 6.8950e-05, 6.8674e-05],\n", + " ...,\n", + " [ 1.5788e-05, -7.7061e-05, 4.3971e-05, ..., -7.2808e-05,\n", + " -7.7883e-05, -5.6436e-05],\n", + " [ 5.5937e-05, -7.4656e-05, 2.1468e-05, ..., -4.9358e-05,\n", + " -6.7722e-05, -7.0467e-05],\n", + " [ 5.9066e-05, -7.8848e-05, 4.3277e-05, ..., -4.0477e-05,\n", + " -7.3305e-05, -2.1827e-05]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['text_model.embeddings.token_embedding.trainable_embeddings.P_loc'] - data['text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dc22156a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-0.0100, -0.0130, -0.0072, ..., -0.0289, 0.0108, 0.0081],\n", + " [ 0.0139, 0.0140, -0.0240, ..., -0.0171, 0.0164, 0.0151],\n", + " [ 0.0099, 0.0068, -0.0149, ..., -0.0209, 0.0248, 0.0139],\n", + " ...,\n", + " [ 0.0059, 0.0043, -0.0155, ..., -0.0191, 0.0069, 0.0076],\n", + " [ 0.0041, 0.0046, -0.0177, ..., -0.0138, 0.0133, 0.0110],\n", + " [ 0.0051, 0.0017, -0.0131, ..., -0.0182, 0.0048, 0.0140]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['text_model.embeddings.token_embedding.trainable_embeddings.P_obj']" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "2678c1f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Đây là một State Dict. Danh sách các lớp và kích thước tensor:\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt: torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_shape: torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_obj: torch.Size([10, 768])\n", + "text_model.embeddings.token_embedding.trainable_embeddings.P_loc: torch.Size([10, 768])\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "# Đường dẫn tới file của bạn\n", + "checkpoint_path = '/mnt/disk2/hachi/New_ouput_7/task_prompt_step_200.pt'\n", + "\n", + "# Load file\n", + "data2 = torch.load(checkpoint_path, map_location=torch.device('cpu'))\n", + "\n", + "# Kiểm tra xem đây là State Dict hay Full Model\n", + "if isinstance(data2, dict):\n", + " print(\"Đây là một State Dict. Danh sách các lớp và kích thước tensor:\")\n", + " for key, value in data2.items():\n", + " print(f\"{key}: {value.shape}\")\n", + "else:\n", + " print(\"Đây là Full Model. Kiến trúc model là:\")\n", + " print(data2)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "7b3f3438", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['text_model.embeddings.token_embedding.trainable_embeddings.P_obj']- data2['text_model.embeddings.token_embedding.trainable_embeddings.P_obj']" + ] + }, + { + "cell_type": "markdown", + "id": "0f68f06f", + "metadata": {}, + "source": [ + "# Density_map" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f1e3c8d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hi\n" + ] + } + ], + "source": [ + "print('hi')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ed80f7df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scanned files: 4653\n", + "Valid images : 4653\n", + "Unreadable : 0\n", + "\n", + "=== Aspect Ratio (W/H) stats ===\n", + "min : 1.000000\n", + "max : 4.994792\n", + "mean : 1.434617\n", + "p01 : 1.000000\n", + "p05 : 1.000000\n", + "p10 : 1.062500\n", + "p25 : 1.289062\n", + "p50 : 1.445312\n", + "p75 : 1.505208\n", + "p90 : 1.778646\n", + "p95 : 1.890104\n", + "p99 : 2.716979\n", + "\n", + "=== Most common sizes (H x W) ===\n", + "384 x 576 : 771\n", + "384 x 408 : 613\n", + "384 x 512 : 492\n", + "384 x 384 : 296\n", + "384 x 683 : 184\n", + "384 x 577 : 124\n", + "384 x 575 : 114\n", + "384 x 682 : 109\n", + "384 x 578 : 60\n", + "384 x 580 : 51\n", + "384 x 522 : 51\n", + "384 x 579 : 50\n", + "384 x 513 : 45\n", + "384 x 514 : 43\n", + "384 x 526 : 41\n", + "384 x 535 : 36\n", + "384 x 511 : 30\n", + "384 x 574 : 27\n", + "384 x 531 : 26\n", + "384 x 614 : 26\n", + "\n", + "=== Most common AR buckets (step=0.05) ===\n", + "AR ~ 1.5 : 1395\n", + "AR ~ 1.4 : 1046\n", + "AR ~ 1.1 : 652\n", + "AR ~ 1.8 : 409\n", + "AR ~ 1.0 : 315\n", + "AR ~ 1.2 : 178\n", + "AR ~ 1.6 : 167\n", + "AR ~ 1.7 : 141\n", + "AR ~ 1.3 : 86\n", + "AR ~ 1.9 : 82\n", + "AR ~ 2.0 : 39\n", + "AR ~ 2.4 : 26\n", + "AR ~ 2.1 : 24\n", + "AR ~ 2.2 : 16\n", + "AR ~ 2.3 : 12\n", + "AR ~ 3.0 : 11\n", + "AR ~ 2.8 : 9\n", + "AR ~ 2.5 : 9\n", + "AR ~ 2.6 : 7\n", + "AR ~ 3.2 : 6\n", + "\n", + "=== Notes ===\n", + "AR is computed as W/H. If you want H/W instead, swap accordingly.\n" + ] + } + ], + "source": [ + "import os\n", + "from collections import Counter, defaultdict\n", + "\n", + "from PIL import Image\n", + "\n", + "train_path = \"/mnt/disk2/hachi/data/train\"\n", + "\n", + "# Extensions you want to scan\n", + "IMG_EXTS = {\".jpg\", \".jpeg\", \".png\", \".bmp\", \".tif\", \".tiff\", \".webp\"}\n", + "\n", + "def iter_image_files(root):\n", + " for img_folder in os.listdir(root):\n", + " yield os.path.join(root, img_folder, \"ground_truth.jpg\")\n", + " # for dirpath, _, filenames in os.walk(root):\n", + " # for fn in filenames:\n", + " # ext = os.path.splitext(fn)[1].lower()\n", + " # if ext in IMG_EXTS:\n", + " # yield os.path.join(dirpath, fn)\n", + "\n", + "def safe_get_hw(path):\n", + " # Fast: read header only (no full decode) for most formats\n", + " try:\n", + " with Image.open(path) as im:\n", + " w, h = im.size\n", + " if w <= 0 or h <= 0:\n", + " return None\n", + " return h, w\n", + " except Exception:\n", + " return None\n", + "\n", + "def percentile(sorted_vals, p):\n", + " # p in [0, 100]\n", + " if not sorted_vals:\n", + " return None\n", + " k = (len(sorted_vals) - 1) * (p / 100.0)\n", + " f = int(k)\n", + " c = min(f + 1, len(sorted_vals) - 1)\n", + " if f == c:\n", + " return sorted_vals[f]\n", + " return sorted_vals[f] + (sorted_vals[c] - sorted_vals[f]) * (k - f)\n", + "\n", + "def ar_bucket(ar, step=0.1, min_ar=0.2, max_ar=5.0):\n", + " # bucket AR to e.g. 0.1 increments: 1.33 -> 1.3\n", + " ar = max(min(ar, max_ar), min_ar)\n", + " b = round(ar / step) * step\n", + " return f\"{b:.1f}\"\n", + "\n", + "def main():\n", + " size_counter = Counter() # (H, W)\n", + " ar_list = []\n", + " bad_files = []\n", + "\n", + " total = 0\n", + " for p in iter_image_files(train_path):\n", + " total += 1\n", + " hw = safe_get_hw(p)\n", + " if hw is None:\n", + " bad_files.append(p)\n", + " continue\n", + " h, w = hw\n", + " size_counter[(h, w)] += 1\n", + " ar_list.append(w / h)\n", + "\n", + " n = len(ar_list)\n", + " print(f\"Scanned files: {total}\")\n", + " print(f\"Valid images : {n}\")\n", + " print(f\"Unreadable : {len(bad_files)}\")\n", + "\n", + " if n == 0:\n", + " print(\"No valid images found.\")\n", + " return\n", + "\n", + " ar_sorted = sorted(ar_list)\n", + " ar_min = ar_sorted[0]\n", + " ar_max = ar_sorted[-1]\n", + " ar_mean = sum(ar_sorted) / n\n", + "\n", + " print(\"\\n=== Aspect Ratio (W/H) stats ===\")\n", + " print(f\"min : {ar_min:.6f}\")\n", + " print(f\"max : {ar_max:.6f}\")\n", + " print(f\"mean : {ar_mean:.6f}\")\n", + " for p in [1, 5, 10, 25, 50, 75, 90, 95, 99]:\n", + " val = percentile(ar_sorted, p)\n", + " print(f\"p{p:02d} : {val:.6f}\")\n", + "\n", + " # Common HxW\n", + " print(\"\\n=== Most common sizes (H x W) ===\")\n", + " for (h, w), c in size_counter.most_common(20):\n", + " print(f\"{h} x {w} : {c}\")\n", + "\n", + " # AR buckets (to see popular aspect ratios)\n", + " bucket_counter = Counter(ar_bucket(ar, step=0.05) for ar in ar_list)\n", + " print(\"\\n=== Most common AR buckets (step=0.05) ===\")\n", + " for b, c in bucket_counter.most_common(20):\n", + " print(f\"AR ~ {b} : {c}\")\n", + "\n", + " # Show examples for min/max AR (by size)\n", + " # Find one file matching min/max approximately (using size map)\n", + " print(\"\\n=== Notes ===\")\n", + " print(\"AR is computed as W/H. If you want H/W instead, swap accordingly.\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " main()\n" + ] + }, + { + "cell_type": "markdown", + "id": "774acd4e", + "metadata": {}, + "source": [ + "## Check dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0cce7b5d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hi\n" + ] + } + ], + "source": [ + "print(\"hi\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4e9ff206", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/disk1/aiotlab/envs/powerpaint/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "from powerpaint.datasets.fsc_147 import *\n", + "train_root = \"/mnt/disk2/hachi/data/train\"\n", + "density_root = \"/mnt/disk2/hachi/data/gt_density_map_adaptive_384_VarV2\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "977cad7e", + "metadata": {}, + "outputs": [], + "source": [ + "items = build_index(train_root, density_root)\n", + "dataset = FSCDataset(items)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "62343b59", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'pixel_values': tensor([[[ 0.7188, 0.7212, 0.7250, ..., 0.1148, 0.1308, 0.1406],\n", + " [ 0.6959, 0.7002, 0.7074, ..., 0.0466, 0.0577, 0.0644],\n", + " [ 0.6735, 0.6804, 0.6914, ..., -0.0234, -0.0170, -0.0136],\n", + " ...,\n", + " [-0.9686, -0.9678, -0.9703, ..., -0.6909, -0.6967, -0.7004],\n", + " [-0.9676, -0.9666, -0.9698, ..., -0.6961, -0.6883, -0.6831],\n", + " [-0.9705, -0.9697, -0.9722, ..., -0.6833, -0.6698, -0.6611]],\n", + " \n", + " [[ 0.7580, 0.7604, 0.7643, ..., 0.1864, 0.2023, 0.2121],\n", + " [ 0.7351, 0.7394, 0.7466, ..., 0.1172, 0.1283, 0.1350],\n", + " [ 0.7127, 0.7196, 0.7307, ..., 0.0473, 0.0535, 0.0570],\n", + " ...,\n", + " [-1.0000, -1.0000, -1.0000, ..., -0.8253, -0.8436, -0.8542],\n", + " [-1.0000, -1.0000, -1.0000, ..., -0.8444, -0.8460, -0.8451],\n", + " [-1.0000, -1.0000, -1.0000, ..., -0.8381, -0.8333, -0.8299]],\n", + " \n", + " [[ 0.7266, 0.7290, 0.7329, ..., 0.1570, 0.1700, 0.1808],\n", + " [ 0.7037, 0.7081, 0.7153, ..., 0.0981, 0.1068, 0.1143],\n", + " [ 0.6814, 0.6882, 0.6993, ..., 0.0378, 0.0439, 0.0475],\n", + " ...,\n", + " [-0.9922, -0.9931, -0.9903, ..., -0.8435, -0.8549, -0.8604],\n", + " [-0.9931, -0.9941, -0.9911, ..., -0.8550, -0.8547, -0.8538],\n", + " [-0.9903, -0.9911, -0.9886, ..., -0.8491, -0.8414, -0.8366]]]),\n", + " 'mask': tensor([[[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]]]),\n", + " 'density': tensor([[[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]]]),\n", + " 'prompt': 'buffalo',\n", + " 'bucket_hw': (512, 1024),\n", + " 'id': '1074_b2'}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "657570f1", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def show_sample(sample):\n", + " pixel_values = sample[\"pixel_values\"]\n", + " mask = sample[\"mask\"]\n", + " density = sample[\"density\"]\n", + "\n", + " # ===== Convert image from [-1,1] → [0,1]\n", + " img = (pixel_values.clamp(-1, 1) + 1) / 2\n", + " img = img.permute(1, 2, 0).cpu().numpy()\n", + "\n", + " # ===== Convert mask & density\n", + " mask_np = mask.squeeze(0).cpu().numpy()\n", + " density_np = density.squeeze(0).cpu().numpy()\n", + "\n", + " # ===== Overlay mask (red)\n", + " overlay_mask = img.copy()\n", + " overlay_mask[mask_np > 0.5] = [1, 0, 0] # red\n", + "\n", + " # ===== Overlay density (jet heatmap)\n", + " cmap = plt.cm.jet\n", + " density_color = cmap(density_np)[:, :, :3] # remove alpha\n", + "\n", + " alpha = 0.5\n", + " overlay_density = img * (1 - alpha) + density_color * alpha\n", + "\n", + " # ===== Plot\n", + " fig, axes = plt.subplots(2, 3, figsize=(15, 8))\n", + "\n", + " axes[0, 0].imshow(img)\n", + " axes[0, 0].set_title(\"Image\")\n", + "\n", + " axes[0, 1].imshow(mask_np, cmap=\"gray\")\n", + " axes[0, 1].set_title(\"Mask\")\n", + "\n", + " axes[0, 2].imshow(density_np, cmap=\"jet\")\n", + " axes[0, 2].set_title(\"Density\")\n", + "\n", + " axes[1, 0].imshow(overlay_mask)\n", + " axes[1, 0].set_title(\"Image + Mask\")\n", + "\n", + " axes[1, 1].imshow(overlay_density)\n", + " axes[1, 1].set_title(\"Image + Density\")\n", + "\n", + " axes[1, 2].axis(\"off\")\n", + "\n", + " for ax in axes.flatten():\n", + " ax.axis(\"off\")\n", + "\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e78f241f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_sample(dataset[4])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b87698cb", + "metadata": {}, + "outputs": [], + "source": [ + "den = dataset[0][\"density\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "00ac4a7f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor(0.), tensor(0.2354))" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "den.min(), den.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b053cece", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'1074_b2'" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset[0]['id']" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9c9432a4", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "tmp = np.load(os.path.join(density_root, \"1074.npy\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "8f5cb3c1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 0.005579187)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tmp.min(), tmp.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "7fbfd392", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(tmp, 'jet')" + ] + }, + { + "cell_type": "markdown", + "id": "a9c0ed96", + "metadata": {}, + "source": [ + "### make data for val" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9050a3b2", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6e7eedf6", + "metadata": {}, + "outputs": [], + "source": [ + "es_path = \"/mnt/disk2/hachi/data/FSC_final/FSC_easy_annotation.json\"\n", + "df_path = \"/mnt/disk2/hachi/data/FSC_final/FSC_difficult_annotation.json\"\n", + "\n", + "img_folder_list = []\n", + "with open(es_path, 'r') as f:\n", + " data = json.load(f)\n", + " img_folder_list.extend(data.keys())\n", + "\n", + "with open(df_path, 'r') as f:\n", + " data = json.load(f)\n", + " img_folder_list.extend(data.keys())\n", + "\n", + "data_path = \"/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2\"\n", + "img_folder_path_list = []\n", + "for img_folder in img_folder_list:\n", + " if os.path.exists(os.path.join(data_path, \"test\", img_folder)):\n", + " img_folder_path_list.append(os.path.join(data_path, \"test\", img_folder))\n", + " else:\n", + " img_folder_path_list.append(os.path.join(data_path, \"val\", img_folder))\n", + "\n", + "out_path = \"./val.txt\"\n", + "with open(out_path, 'w') as f:\n", + " for img_folder_path in img_folder_path_list:\n", + " f.write(f\"{img_folder_path}\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5eead763", + "metadata": {}, + "outputs": [], + "source": [ + "l = []\n", + "with open('./val.txt', 'r') as f:\n", + " for line in f:\n", + " l.append(line.strip().replace(\n", + " \"/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/\",\n", + " \"/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/\"\n", + " ))\n", + "\n", + "with open('./val_2.txt', 'w') as f:\n", + " for p in l:\n", + " f.write(f\"{p}\\n\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "powerpaint", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.25" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/train.sh b/train.sh new file mode 100644 index 0000000..e8d40b3 --- /dev/null +++ b/train.sh @@ -0,0 +1,4 @@ +$(which python) -m accelerate.commands.launch \ +--config_file configs/acc.yaml \ +train_idm_pp1_v2.py \ +--config configs/idm_pp1.yaml \ No newline at end of file diff --git a/train.txt b/train.txt new file mode 100644 index 0000000..a02b776 --- /dev/null +++ b/train.txt @@ -0,0 +1,10 @@ +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/374_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/1328_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/7036_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/4686_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/5121_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/3076_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/5230_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/546_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/4229_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/train/3211_b3 diff --git a/train_idm_pp1.py b/train_idm_pp1.py new file mode 100644 index 0000000..b526a17 --- /dev/null +++ b/train_idm_pp1.py @@ -0,0 +1,849 @@ +import argparse +import gc +import logging +import math +import os +import shutil +import inspect + +import accelerate +import numpy as np +import torch +import torch.nn.functional as F +from torch.utils.data import DataLoader +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import ProjectConfiguration, set_seed +from omegaconf import OmegaConf +from packaging import version +from PIL import Image +from safetensors.torch import load_model +from tqdm.auto import tqdm +from transformers import PretrainedConfig + +import diffusers +from diffusers.optimization import get_scheduler +from diffusers.training_utils import EMAModel, compute_snr +from diffusers.utils import check_min_version, deprecate, is_wandb_available +from diffusers.utils.hub_utils import load_or_create_model_card, populate_model_card +from diffusers.utils.import_utils import is_xformers_available +from diffusers.utils.torch_utils import is_compiled_module +from powerpaint.datasets.fsc_147 import FSCDataset, BucketBatchSampler, build_index +from powerpaint.datasets.utils import collate_train +from powerpaint.models import UNet2DConditionModel +from powerpaint.pipelines import StableDiffusionInpaintIndomainPipeline +from powerpaint.utils.utils import TokenizerWrapper, add_tokens, expand_unet_conv_in + +# Batch size theo bucket (bạn tự chỉnh theo VRAM) +by_bucket_sizes = { + (512, 512): 12, + (512, 768): 8, + (512, 1024): 6, +} + +if is_wandb_available(): + import wandb + from dotenv import load_dotenv + load_dotenv() + wandb.login() + +logger = get_logger(__name__, log_level="INFO") + +def log_validation(pipe, args, accelerator, step): + logger.info("Running validation... ") + + # pipe = StableDiffusionInpaintIndomainPipeline.from_pretrained( + # args.base_model_path, + # # text_encoder=accelerator.unwrap_model(text_encoder), + # # tokenizer=tokenizer, + # # unet=accelerator.unwrap_model(unet), + # # safety_checker=None, + # # revision=args.revision, + # # variant=args.variant, + # torch_dtype=weight_dtype, + # local_files_only=True, # load files from local cache + # ) + # pipe.text_encoder = text_encoder, + # pipe.tokenizer = tokenizer + pipe.set_progress_bar_config(disable=True) + pipe.unet.eval() + pipe.text_encoder.eval() + + + # load validation images + image_logs = [] + for case in args.validation_data.cases: + validation_prompts = case.prompt + validation_image = Image.open(os.path.join(args.validation_data.data_root, case.image)).convert("RGB") + validation_mask = Image.open(os.path.join(args.validation_data.data_root, case.mask)) + validation_mask = validation_mask.resize((validation_image.size[0], validation_image.size[1]), Image.NEAREST) + validation_mask = validation_mask.convert("L") + hole_value = (0, 0, 0) + validation_image = Image.composite( + Image.new("RGB", (validation_image.size[0], validation_image.size[1]), hole_value), + validation_image, + validation_mask.convert("L"), + ) + image_grid = Image.new( + "RGB", + (validation_image.size[0] * (1 + len(validation_prompts)), validation_image.size[1]), + (255, 255, 255), + ) + image_grid.paste(validation_image, (0, 0)) + for i, p in enumerate(validation_prompts): + with torch.no_grad(): + with torch.autocast(accelerator.device.type): + image = pipe( + promptA=p.promptA, + promptB=p.promptB, + tradoff=p.tradeoff, + tradoff_nag=p.tradeoff, + negative_promptA=p.get("negative_promptA", None), + negative_promptB=p.get("negative_promptB", None), + image=validation_image, + mask=validation_mask, + num_inference_steps=45, + ).images[0] + image_logs.append(image) + image_grid.paste(image, (validation_image.size[0] * (i + 1), 0)) + save_path = os.path.join( + args.output_dir, + f"{case.name}_{str(step).zfill(3)}_{os.path.basename(case.image)}" + ) + os.makedirs(os.path.dirname(save_path), exist_ok=True) + image_grid.save(save_path) + + # image_grid.save(os.path.join(args.output_dir, f"{case.name}_{str(step).zfill(3)}_{os.path.basename(case.image)}")) + + for tracker in accelerator.trackers: + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in image_logs]) + tracker.writer.add_images("validation", np_images, step, dataformats="NHWC") + elif tracker.name == "wandb": + tracker.log( + { + "validation": [ + wandb.Image(image, caption=f"{p.task}") + for image, p in zip(image_logs, args.validation_data.cases[0].prompt) + ] + } + ) + else: + logger.warning(f"image logging not implemented for {tracker.name}") + + pipe.unet.train() + pipe.text_encoder.train() + #return image_logs + +def parse_args(): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--input_perturbation", type=float, default=0, help="The scale of input perturbation. Recommended 0.1." + ) + parser.add_argument( + "--config", + type=str, + default=None, + help="yaml for configuration", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--variant", + type=str, + default=None, + help="Variant of the model files of the pretrained model identifier from huggingface.co/models, 'e.g.' fp16", + ) + parser.add_argument( + "--max_train_samples", + type=int, + default=None, + help=( + "For debugging purposes or quicker training, truncate the number of training examples to this " + "value if set." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="runs/ppt1_sd15", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument( + "--cache_dir", + type=str, + default=None, + help="The directory where the downloaded models and datasets will be stored.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", + default=False, + action="store_true", + help=( + "Whether to center crop the input images to the resolution. If not set, the images will be randomly" + " cropped. The images will be resized to the resolution first before cropping." + ), + ) + parser.add_argument( + "--random_flip", + action="store_true", + help="whether to randomly flip images horizontally", + ) + parser.add_argument( + "--train_batch_size", + type=int, + default=16, + required=False, + help="Batch size (per device) for the training dataloader.", + ) + parser.add_argument("--num_train_epochs", type=int, default=100) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=1e-4, + help="Initial learning rate (after the potential warm-up period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", + type=int, + default=500, + help="Number of steps for the warm-up in the lr scheduler.", # noqa: F401 + ) + parser.add_argument( + "--snr_gamma", + type=float, + default=None, + help="SNR weighting gamma to be used if rebalancing the loss. Recommended value is 5.0. " + "More details here: https://arxiv.org/abs/2303.09556.", + ) + parser.add_argument( + "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes." + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument("--use_ema", action="store_true", help="Whether to use EMA model.") + parser.add_argument( + "--non_ema_revision", + type=str, + default=None, + required=False, + help=( + "Revision of pretrained non-ema model identifier. Must be a branch, tag or git identifier of the local or" + " remote repository specified with --pretrained_model_name_or_path." + ), + ) + parser.add_argument( + "--dataloader_num_workers", + type=int, + default=0, + help=( + "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process." + ), + ) + parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") + parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.") + parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.") + parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer") + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument( + "--prediction_type", + type=str, + default=None, + help="The prediction_type that shall be used for training. Choose between 'epsilon' or 'v_prediction' or leave `None`. If left to `None` the default prediction type of the scheduler: `noise_scheduler.config.prediction_type` is chosen.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints are only suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--checkpoints_total_limit", + type=int, + default=None, + help=("Max number of checkpoints to store."), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + parser.add_argument("--noise_offset", type=float, default=0, help="The scale of noise offset.") + parser.add_argument( + "--validation_epochs", + type=int, + default=5, + help="Run validation every X epochs.", + ) + parser.add_argument( + "--tracker_project_name", + type=str, + default="text2image-fine-tune", + help=( + "The `project_name` argument passed to Accelerator.init_trackers for" + " more information see https://huggingface.co/docs/accelerate/v0.17.0/en/package_reference/accelerator#accelerate.Accelerator" + ), + ) + + args = parser.parse_args() + env_local_rank = int(os.environ.get("LOCAL_RANK", -1)) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + # use omegaconf to manage configurations + if args.config is not None: + config = OmegaConf.load(args.config) + for k, v in config.items(): + args.__dict__[k] = v + return args + +def main(): + args = parse_args() + if args.non_ema_revision is not None: + deprecate( + "non_ema_revision!=None", + "0.15.0", + message=( + "Downloading 'non_ema' weights from revision branches of the Hub is deprecated. Please make sure to" + " use `--variant=non_ema` instead." + ), + ) + + logging_dir = os.path.join(args.output_dir, args.logging_dir) + accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir) + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_config=accelerator_project_config, + ) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + torch.manual_seed(args.seed) + set_seed(args.seed) + + # Handle the repository creation + if accelerator.is_main_process: + if args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # saving training configuration to output_dir + to_save_config = OmegaConf.create(vars(args)) + OmegaConf.save(config=to_save_config, f=os.path.join(args.output_dir, "training_config.yaml")) + + # For mixed precision training we cast all non-trainable weights (vae, non-lora text_encoder and non-lora unet) to half-precision + # as these weights are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + args.mixed_precision = accelerator.mixed_precision + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + args.mixed_precision = accelerator.mixed_precision + + # ========================================== + # setting models: load scheduler, tokenizer and models. + # ========================================== + pipe = StableDiffusionInpaintIndomainPipeline.from_pretrained( + args.base_model_path, + torch_dtype=weight_dtype, + local_files_only=True + ) + pipe.tokenizer = TokenizerWrapper( + from_pretrained=args.base_model_path, + subfolder='tokenizer', + torch_dtype=weight_dtype, + local_files_only=True + ) + + # add pretrained learned task tokens into the tokenizer + add_tokens( + tokenizer=pipe.tokenizer, + text_encoder=pipe.text_encoder, + placeholder_tokens=["P_ctxt", "P_shape", "P_obj"], + initialize_tokens=["a", "a", "a"], + num_vectors_per_token=10, + ) + # load ppt1 checkpoint + load_model(pipe.unet, os.path.join(args.ppt1_checkpoint, "unet/unet.safetensors"), strict=False) + load_model(pipe.text_encoder, os.path.join(args.ppt1_checkpoint, "text_encoder/text_encoder.safetensors"),strict=False ) + + # add new learned task tokens + add_tokens( + tokenizer=pipe.tokenizer, + text_encoder=pipe.text_encoder, + placeholder_tokens=["P_loc"], + initialize_tokens=["P_ctxt"], + num_vectors_per_token=10, + ) + # add the expanded channel + pipe.unet = expand_unet_conv_in(pipe.unet, extra_in_channels=1, init="mean_scaled") + + vae, unet, tokenizer, noise_scheduler = pipe.vae, pipe.unet, pipe.tokenizer, pipe.scheduler + text_encoder= pipe.text_encoder.to(torch.float32) + + + # Freeze all parameters except for the token embeddings of p_loc + unet.requires_grad_(False) + vae.requires_grad_(False) + text_encoder.text_model.requires_grad_(True) + text_encoder.text_model.encoder.requires_grad_(False) + text_encoder.text_model.final_layer_norm.requires_grad_(False) + text_encoder.text_model.embeddings.position_embedding.requires_grad_(False) + text_encoder.text_model.embeddings.token_embedding.trainable_embeddings.P_ctxt.requires_grad_(False) + text_encoder.text_model.embeddings.token_embedding.trainable_embeddings.P_obj.requires_grad_(False) + text_encoder.text_model.embeddings.token_embedding.trainable_embeddings.P_shape.requires_grad_(False) + text_encoder.text_model.embeddings.token_embedding.wrapped.weight.requires_grad_(False) + + for p in unet.conv_in.parameters(): + p.requires_grad = True + + # Check what we set grad True + for name, p in text_encoder.named_parameters(): + if p.requires_grad: + logger.info(f'{name} {p.shape}') + + + # # Don't need to create EMA for the unet because we just finetune text encoder + # if args.use_ema: + # ema_unet = UNet2DConditionModel.from_pretrained( + # args.ppt1_checkpoint, subfolder="unet", torch_dtype=weight_dtype, local_files_only=True + # ) + # ema_unet = EMAModel(ema_unet.parameters(), model_cls=UNet2DConditionModel, model_config=ema_unet.config) + + + # # Taken from [Sayak Paul's Diffusers PR #6511](https://github.com/huggingface/diffusers/pull/6511/files) + # def unwrap_model(model): + # model = accelerator.unwrap_model(model) + # model = model._orig_mod if is_compiled_module(model) else model + # return model + + # `accelerate` 0.16.0 will have better support for customized saving + if version.parse(accelerate.__version__) >= version.parse("0.16.0"): + # create custom saving & loading hooks so that `accelerator.save_state(...)` serializes in a nice format + def save_model_hook(models, weights, output_dir): + if accelerator.is_main_process: + for model in models: + sub_dir = "text_encoder" + model.save_pretrained(os.path.join(output_dir, sub_dir)) + + # make sure to pop weight so that corresponding model is not saved again + weights.pop() + + # def load_model_hook(models, input_dir): + # while len(models) > 0: + # model = models.pop() + + # if isinstance(model, type(unwrap_model(text_encoder))): + # # load transformers style into model + # loaded_model = text_encoder_cls.from_pretrained(input_dir, subfolder="text_encoder") + # model.config = load_model.config + + # model.load_state_dict(load_model.state_dict()) + # del load_model + + accelerator.register_save_state_pre_hook(save_model_hook) + # accelerator.register_load_state_pre_hook(load_model_hook) + + if args.gradient_checkpointing: + text_encoder.gradient_checkpointing_enable() + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32: + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + # Initialize the optimizer + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "Please install bitsandbytes to use 8-bit Adam. You can do so by running `pip install bitsandbytes`" + ) + optimizer_cls = bnb.optim.AdamW8bit + else: + optimizer_cls = torch.optim.AdamW + + # get trainable parameters + embedding_layer = text_encoder.get_input_embeddings() + trainable_prompt = embedding_layer.trainable_embeddings['P_loc'] + + optimizer = optimizer_cls( + [trainable_prompt], + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + # Preparing datasets and dataloader for training + train_root = "/mnt/disk2/hachi/data/train" + density_root = "/mnt/disk2/hachi/data/gt_density_map_adaptive_384_VarV2" + items = build_index(train_root, density_root) + train_dataset = FSCDataset(items, pipeline=pipe, task_prompt=args.task_prompt) + + by_bucket_sizes = { + tuple(item["size"]): item["value"] + for item in args.by_bucket_sizes + } + sampler = BucketBatchSampler( + dataset=train_dataset, + by_bucket_sizes=by_bucket_sizes, + shuffle=True, + drop_last=True, + seed=42, + bucket_sampling="proportional" + ) + train_dataloader = DataLoader( + dataset=train_dataset, + batch_sampler=sampler, + num_workers=args.dataloader_num_workers, + ) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader)/args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs*num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + ) + + # Prepare everything with our `accelerator`. + unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, text_encoder, optimizer, train_dataloader, lr_scheduler + ) + + # Move vae to gpu and cast to weight_dtype + vae.to(accelerator.device, dtype=weight_dtype) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + tracker_config = dict(vars(args)) + + # tensorboard cannot handle list types for config + pop_list = [] + for k, v in tracker_config.items(): + if not isinstance(v, (int, float, str, bool, torch.Tensor)): + pop_list.append(k) + logger.info(f"Removed {k} (type:{type(v)}) from tracker_config") + for k in pop_list: + tracker_config.pop(k) + + accelerator.init_trackers(args.tracker_project_name, tracker_config) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + logger.info(f"***** Running training for {args.tracker_project_name} *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {int(args.max_train_steps)}") + global_step = 0 + first_epoch = 0 + + # Only show the progress bar once on each machine.args.max_train_steps + progress_bar = tqdm( + range(0, int(args.max_train_steps)), + initial=global_step, + desc="Steps", + # Only show the progress bar once on each machine. + disable=not accelerator.is_local_main_process, + ) + + text_encoder.train() + + # Check what we set grad True + for name, p in unet.named_parameters(): + if p.requires_grad: + logger.info(f'{name} {p.shape}') + + pipe.safety_checker = None + if accelerator.is_main_process: + log_validation( + pipe, + args, + accelerator, + global_step, + ) + + # Check what we set grad True + for name, p in unet.named_parameters(): + if p.requires_grad: + logger.info(f'{name} {p.shape}') + + for _ in range(first_epoch, args.num_train_epochs): + train_loss = 0.0 + + for batch in train_dataloader: + + with accelerator.accumulate(text_encoder): + # Convert images to latent space + latents = vae.encode(batch["pixel_values"].to(weight_dtype)).latent_dist.sample() + latents = latents * vae.config.scaling_factor + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + if args.noise_offset: + # https://www.crosslabs.org//blog/diffusion-with-offset-noise + noise += args.noise_offset * torch.randn( + (latents.shape[0], latents.shape[1], 1, 1), device=latents.device + ) + if args.input_perturbation: + new_noise = noise + args.input_perturbation * torch.randn_like(noise) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device) + timesteps = timesteps.long() + + # in mask, 1 for masked region, 0 for known region + mask_image = batch["pixel_values"] * (batch["mask"] < 0.5) + # convert the hole value from 0 to -1 due to value range [-1, 1] + mask_image = mask_image - batch["mask"] + mask_image_latents = vae.encode(mask_image.to(weight_dtype)).latent_dist.sample() + mask_image_latents = mask_image_latents * vae.config.scaling_factor + + mask = torch.nn.functional.interpolate(batch["mask"], size=(64, 64)) + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + if args.input_perturbation: + noisy_latents = noise_scheduler.add_noise(latents, new_noise, timesteps) + else: + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + model_input = torch.cat([noisy_latents, mask, mask_image_latents], dim=1) + + # Get the text embedding for conditioning unet, (bs, 77, 768) + encoder_hidden_statesA = text_encoder(batch["input_idsA"], return_dict=False)[0] + encoder_hidden_statesB = text_encoder(batch["input_idsB"], return_dict=False)[0] + tradeoff = batch["tradeoff"].unsqueeze(-1) + encoder_hidden_states = ( + tradeoff[:, 0:1, :] * encoder_hidden_statesA + tradeoff[:, 1:, :] * encoder_hidden_statesB.detach() + ) + encoder_hidden_states = encoder_hidden_states.to(accelerator.unwrap_model(unet).dtype) + + # Get the target for loss depending on the prediction type + if args.prediction_type is not None: + # set prediction_type of scheduler if defined + noise_scheduler.register_to_config(prediction_type=args.prediction_type) + + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + # Predict the noise residual and compute loss + model_pred = unet(model_input, timesteps, encoder_hidden_states, return_dict=False)[0] + + if args.snr_gamma is None: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + else: + # Compute loss-weights as per Section 3.4 of https://arxiv.org/abs/2303.09556. + # Since we predict the noise instead of x_0, the original formulation is slightly changed. + # This is discussed in Section 4.2 of the same paper. + snr = compute_snr(timesteps) + mse_loss_weights = ( + torch.stack([snr, args.snr_gamma * torch.ones_like(timesteps)], dim=1).min(dim=1)[0] / snr + ) + # We first calculate the original loss. Then we mean over the non-batch dimensions and + # rebalance the sample-wise losses with their respective loss weights. + # Finally, we take the mean of the rebalanced loss. + loss = F.mse_loss(model_pred.float(), target.float(), reduction="none") + loss = loss.mean(dim=list(range(1, len(loss.shape)))) * mse_loss_weights + loss = loss.mean() + + # Gather the losses across all processes for logging (if we use distributed training). + avg_loss = accelerator.gather(loss.repeat(args.train_batch_size)).mean() + train_loss += avg_loss.item() / args.gradient_accumulation_steps + + + # Backpropagate + accelerator.backward(loss) + if accelerator.sync_gradients: + accelerator.clip_grad_norm_([trainable_prompt], args.max_grad_norm) + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Check if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + global_step += 1 + + accelerator.log({"train_loss": train_loss}, step=global_step) + train_loss = 0.0 + + if accelerator.is_main_process: + if global_step % args.checkpointing_steps == 0: + unwrapped_text_encoder = accelerator.unwrap_model(text_encoder) + # Chỉ trích xuất state_dict của phần trainable + trainable_state_dict = { + k: v for k, v in unwrapped_text_encoder.state_dict().items() + if "trainable_embeddings" in k + } + save_path = os.path.join(args.output_dir, f"task_prompt_step_{global_step}.pt") + accelerator.save(trainable_state_dict, save_path) + logger.info(f"Saved state to {save_path}") + + if hasattr(args, "validation_data") is not None and global_step % args.validation_steps == 0: + log_validation( + pipe, + args, + accelerator, + global_step, + ) + + logs = {"step_loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + + if global_step >= args.max_train_steps: + break + + accelerator.wait_for_everyone() + if accelerator.is_main_process: + if hasattr(args, "validation_data"): + logger.info("Running inference...") + log_validation(pipe, args, accelerator, global_step) + + accelerator.end_training() + +if __name__ == "__main__": + main() + + + + diff --git a/train_idm_pp1_v2.py b/train_idm_pp1_v2.py new file mode 100644 index 0000000..8a955dc --- /dev/null +++ b/train_idm_pp1_v2.py @@ -0,0 +1,977 @@ +import argparse +import gc +import logging +import math +import os +import shutil +import inspect +from typing import List, Tuple +import accelerate +import numpy as np +import torch +import torch.nn.functional as F +from torch.utils.data import DataLoader +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import ProjectConfiguration, set_seed +from omegaconf import OmegaConf +from packaging import version +from PIL import Image +from safetensors.torch import load_model +from tqdm.auto import tqdm +from transformers import PretrainedConfig + +import diffusers +from diffusers.optimization import get_scheduler +from diffusers.training_utils import EMAModel, compute_snr +from diffusers.utils import check_min_version, deprecate, is_wandb_available +from diffusers.utils.hub_utils import load_or_create_model_card, populate_model_card +from diffusers.utils.import_utils import is_xformers_available +from diffusers.utils.torch_utils import is_compiled_module +from powerpaint.datasets.fsc_147 import FSCDataset, BucketBatchSampler, build_index, build_index_val +from powerpaint.datasets.utils import collate_train +from powerpaint.models import UNet2DConditionModel +from powerpaint.pipelines import StableDiffusionInpaintIndomainPipeline +from powerpaint.utils.utils import TokenizerWrapper, add_tokens, expand_unet_conv_in + +from eval.pipe_counterfactual import infer_counterfactual_3 +# if is_wandb_available(): +# import wandb +# from dotenv import load_dotenv +# load_dotenv() +# wandb.login() + +logger = get_logger(__name__, log_level="INFO") + +def parse_args(): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--input_perturbation", type=float, default=0, help="The scale of input perturbation. Recommended 0.1." + ) + parser.add_argument( + "--config", + type=str, + default=None, + help="yaml for configuration", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--variant", + type=str, + default=None, + help="Variant of the model files of the pretrained model identifier from huggingface.co/models, 'e.g.' fp16", + ) + parser.add_argument( + "--max_train_samples", + type=int, + default=None, + help=( + "For debugging purposes or quicker training, truncate the number of training examples to this " + "value if set." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="runs/ppt1_sd15", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument( + "--cache_dir", + type=str, + default=None, + help="The directory where the downloaded models and datasets will be stored.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", + default=False, + action="store_true", + help=( + "Whether to center crop the input images to the resolution. If not set, the images will be randomly" + " cropped. The images will be resized to the resolution first before cropping." + ), + ) + parser.add_argument( + "--random_flip", + action="store_true", + help="whether to randomly flip images horizontally", + ) + parser.add_argument( + "--train_batch_size", + type=int, + default=16, + required=False, + help="Batch size (per device) for the training dataloader.", + ) + parser.add_argument("--num_train_epochs", type=int, default=100) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=1e-4, + help="Initial learning rate (after the potential warm-up period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", + type=int, + default=500, + help="Number of steps for the warm-up in the lr scheduler.", # noqa: F401 + ) + parser.add_argument( + "--snr_gamma", + type=float, + default=None, + help="SNR weighting gamma to be used if rebalancing the loss. Recommended value is 5.0. " + "More details here: https://arxiv.org/abs/2303.09556.", + ) + parser.add_argument( + "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes." + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument("--use_ema", action="store_true", help="Whether to use EMA model.") + parser.add_argument( + "--non_ema_revision", + type=str, + default=None, + required=False, + help=( + "Revision of pretrained non-ema model identifier. Must be a branch, tag or git identifier of the local or" + " remote repository specified with --pretrained_model_name_or_path." + ), + ) + parser.add_argument( + "--dataloader_num_workers", + type=int, + default=0, + help=( + "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process." + ), + ) + parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") + parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.") + parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.") + parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer") + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument( + "--prediction_type", + type=str, + default=None, + help="The prediction_type that shall be used for training. Choose between 'epsilon' or 'v_prediction' or leave `None`. If left to `None` the default prediction type of the scheduler: `noise_scheduler.config.prediction_type` is chosen.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints are only suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--checkpoints_total_limit", + type=int, + default=None, + help=("Max number of checkpoints to store."), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + parser.add_argument("--noise_offset", type=float, default=0, help="The scale of noise offset.") + parser.add_argument( + "--validation_epochs", + type=int, + default=5, + help="Run validation every X epochs.", + ) + parser.add_argument( + "--tracker_project_name", + type=str, + default="text2image-fine-tune", + help=( + "The `project_name` argument passed to Accelerator.init_trackers for" + " more information see https://huggingface.co/docs/accelerate/v0.17.0/en/package_reference/accelerator#accelerate.Accelerator" + ), + ) + + args = parser.parse_args() + env_local_rank = int(os.environ.get("LOCAL_RANK", -1)) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + # use omegaconf to manage configurations + if args.config is not None: + config = OmegaConf.load(args.config) + for k, v in config.items(): + args.__dict__[k] = v + return args + +@torch.no_grad() +def vae_encode(vae, pixel_values: torch.Tensor) -> torch.Tensor: + latents = vae.encode(pixel_values).latent_dist.sample() + latents = latents * vae.config.scaling_factor + return latents + +@torch.no_grad() +def vae_decode(vae, latents: torch.Tensor) -> torch.Tensor: + latents = latents / vae.config.scaling_factor + image = vae.decode(latents).sample #[-1, 1] + return image + +# def to_latent_mask(mask: torch.Tensor, lh: int, lw: int) -> torch.Tensor: +# return F.interpolate(mask, size=(lh, lw), mode="nearest") + +def to_latent_mask( + mask: torch.Tensor, + lh: int, + lw: int, + *, + soft: bool = False, + blur_kernel: int = 0, # 0 = no blur, 3/5/7... = avg blur kernel size + blur_iters: int = 1, # số lần blur (1-3 thường đủ) +) -> torch.Tensor: + """ + mask: [B,1,H,W] hoặc [B,H,W] hoặc [H,W] + return: [B,1,lh,lw] float in [0,1] + - soft=False -> nearest, mask gần như nhị phân + - soft=True -> bilinear (+ optional blur) để làm mềm biên + """ + # --- normalize shape to [B,1,H,W] + if mask.dim() == 2: + mask = mask.unsqueeze(0).unsqueeze(0) + elif mask.dim() == 3: + mask = mask.unsqueeze(1) + elif mask.dim() != 4: + raise ValueError(f"mask must be 2D/3D/4D, got shape={tuple(mask.shape)}") + + mask = mask.float() + + # --- resize + if soft: + # bilinear tạo soft edges (giá trị 0..1) + mask = F.interpolate(mask, size=(lh, lw), mode="bilinear", align_corners=False) + mask = mask.clamp(0.0, 1.0) + + # --- optional blur boundary (giảm seam/halo ở rìa) + if blur_kernel and blur_kernel > 1: + if blur_kernel % 2 == 0: + raise ValueError("blur_kernel should be odd (e.g., 3,5,7).") + pad = blur_kernel // 2 + for _ in range(max(1, blur_iters)): + mask = F.avg_pool2d(mask, kernel_size=blur_kernel, stride=1, padding=pad) + mask = mask.clamp(0.0, 1.0) + else: + # nearest giữ mask nhị phân (phù hợp conditioning chuẩn inpainting) + mask = F.interpolate(mask, size=(lh, lw), mode="nearest") + + return mask + +def to_latent_density(density: torch.Tensor, lh: int, lw: int) -> torch.Tensor: + return F.interpolate(density, size=(lh,lw), mode="bilinear", align_corners=False) + +def set_trainable_params(unet, text_encoder, vae, train_mode: str): + """ + Set requires_grad for modules according to train_mode. + + Recommended modes for your use case (SD1.5 inpaint + extra density channel): + - "conv_in": train only unet.conv_in + - "conv_in+down0": train unet.conv_in + unet.down_blocks.0 + - "conv_in+down01": train unet.conv_in + unet.down_blocks.0 + unet.down_blocks.1 + - "unet": train full UNet + - "unet+te": train UNet + text encoder + - "full": train UNet + text encoder + VAE + + By default (common practice): freeze VAE + text encoder unless train_mode includes them. + + Returns: + A dict summary with counts (trainable/all) for each component. + """ + # ---- reset all ---- + if vae is not None: + vae.requires_grad_(False) + vae.eval() + if text_encoder is not None: + text_encoder.requires_grad_(False) + text_encoder.eval() + + unet.requires_grad_(False) + unet.train() # we still want UNet in train mode if any params train + + def _enable_prefix(module, prefix: str): + for name, p in module.named_parameters(): + if name.startswith(prefix): + p.requires_grad = True + + def _enable_any(module, predicate): + for name, p in module.named_parameters(): + if predicate(name): + p.requires_grad = True + + # ---- parse mode ---- + mode = train_mode.strip().lower() + + # UNet selections + if mode in ["conv_in", "convin"]: + _enable_prefix(unet, "conv_in") + + elif mode in ["conv_in+down0", "convin+down0", "conv_in_down0"]: + _enable_prefix(unet, "conv_in") + _enable_prefix(unet, "down_blocks.0") + + elif mode in ["conv_in+down01", "convin+down01", "conv_in_down01"]: + _enable_prefix(unet, "conv_in") + _enable_prefix(unet, "down_blocks.0") + _enable_prefix(unet, "down_blocks.1") + + elif mode in ["unet", "full_unet"]: + unet.requires_grad_(True) + + elif mode in ["unet+te", "unet+text", "unet+text_encoder"]: + unet.requires_grad_(True) + if text_encoder is None: + raise ValueError("text_encoder is None but train_mode requests it.") + text_encoder.requires_grad_(True) + text_encoder.train() + + elif mode in ["full", "all", "unet+te+vae"]: + unet.requires_grad_(True) + if text_encoder is None: + raise ValueError("text_encoder is None but train_mode requests it.") + if vae is None: + raise ValueError("vae is None but train_mode requests it.") + text_encoder.requires_grad_(True) + vae.requires_grad_(True) + text_encoder.train() + vae.train() + + # Optional extra modes you may find useful: + # - "attn_lora_like": train only attention blocks (without LoRA) + elif mode in ["attn", "attention"]: + # Train all attention (self+cross) weights inside UNet + # This is heavier than LoRA but still less than full unet. + _enable_any(unet, lambda n: (".attn" in n) or ("attentions" in n) or ("transformer_blocks" in n)) + + elif mode in ["conv_in+attn", "convin+attn"]: + _enable_prefix(unet, "conv_in") + _enable_any(unet, lambda n: (".attn" in n) or ("attentions" in n) or ("transformer_blocks" in n)) + + else: + raise ValueError( + f"Unknown train_mode='{train_mode}'. " + f"Supported: conv_in, conv_in+down0, conv_in+down01, unet, unet+te, full, attn, conv_in+attn." + ) + + # If UNet has no trainable params after selection, keep it eval to save small overhead + if not any(p.requires_grad for p in unet.parameters()): + unet.eval() + + # ---- return a small summary (useful for logs) ---- + def _count_params(module): + if module is None: + return (0, 0) + all_n = sum(p.numel() for p in module.parameters()) + train_n = sum(p.numel() for p in module.parameters() if p.requires_grad) + return train_n, all_n + + unet_train, unet_all = _count_params(unet) + te_train, te_all = _count_params(text_encoder) + vae_train, vae_all = _count_params(vae) + + return { + "unet_trainable": unet_train, + "unet_all": unet_all, + "text_encoder_trainable": te_train, + "text_encoder_all": te_all, + "vae_trainable": vae_train, + "vae_all": vae_all, + "mode": train_mode, + } + +def get_trainable_params(unet, text_encoder=None, vae=None) -> List[torch.nn.Parameter]: + """ + Return a flat list of trainable parameters (requires_grad=True) across modules. + Use this to build optimizer / gradient clipping. + """ + params: List[torch.nn.Parameter] = [] + for module in (unet, text_encoder, vae): + if module is None: + continue + for p in module.parameters(): + if p.requires_grad: + params.append(p) + + # Safety: avoid empty optimizer + if len(params) == 0: + raise RuntimeError("No trainable parameters found. Check set_trainable_params(train_mode=...).") + return params + +# def infer_before(pipe, args, accelerator): +# pass + +# @torch.no_grad() +# def inpaint_with_density(pipe, batch_val, accelerator, num_inference_steps: int = 30, guidance_scale: float = 7.5): +# pixel_values = batch_val["pixel_values"] +# mask = batch_val["mask"] +# density = batch_val["density"] + +def weighted_latent_mse(model_pred, target, mask_latent, masked_weight=5.0, known_weight=1.0, eps=1e-8): + """ + model_pred, target: [B, C, H, W] (C thường = 4 với SD1.5 latent) + mask_latent: [B, 1, H, W] (1 = masked/hole, 0 = known) + returns: + loss_mean: scalar + loss_per_sample: [B] + """ + # đảm bảo float + đúng device + mask = mask_latent.to(dtype=model_pred.dtype, device=model_pred.device) + # weight map: [B,1,H,W] + w = known_weight + (masked_weight - known_weight) * mask + # expand sang channel: [B,C,H,W] + w = w.expand(-1, model_pred.shape[1], -1, -1) + + mse = (model_pred - target) ** 2 # [B,C,H,W] + + # weighted mean per-sample (normalize theo tổng weight) + num = (mse * w).sum(dim=(1, 2, 3)) + den = w.sum(dim=(1, 2, 3)).clamp_min(eps) + loss_per_sample = num / den # [B] + + return loss_per_sample.mean(), loss_per_sample + +def main(): + args = parse_args() + + logging_dir = os.path.join(args.output_dir, args.logging_dir) + accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir) + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_config=accelerator_project_config, + ) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + torch.manual_seed(args.seed) + set_seed(args.seed) + + # Handle the repository creation + if accelerator.is_main_process: + if args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # saving training configuration to output_dir + to_save_config = OmegaConf.create(vars(args)) + OmegaConf.save(config=to_save_config, f=os.path.join(args.output_dir, "training_config.yaml")) + + # For mixed precision training we cast all non-trainable weights (vae, non-lora text_encoder and non-lora unet) to half-precision + # as these weights are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + args.mixed_precision = accelerator.mixed_precision + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + args.mixed_precision = accelerator.mixed_precision + + # ========================================== + # setting models: load scheduler, tokenizer and models. + # ========================================== + pipe = StableDiffusionInpaintIndomainPipeline.from_pretrained( + args.base_model_path, + torch_dtype=weight_dtype, + local_files_only=True + ) + pipe.tokenizer = TokenizerWrapper( + from_pretrained=args.base_model_path, + subfolder='tokenizer', + torch_dtype=weight_dtype, + local_files_only=True + ) + + # add pretrained learned task tokens into the tokenizer + add_tokens( + tokenizer=pipe.tokenizer, + text_encoder=pipe.text_encoder, + placeholder_tokens=["P_ctxt", "P_shape", "P_obj"], + initialize_tokens=["a", "a", "a"], + num_vectors_per_token=10, + ) + # load ppt1 checkpoint + load_model(pipe.unet, os.path.join(args.ppt1_checkpoint, "unet/unet.safetensors"), strict=False) + load_model(pipe.text_encoder, os.path.join(args.ppt1_checkpoint, "text_encoder/text_encoder.safetensors"),strict=False ) + + # # Infer to check + # if accelerator.is_main_process: + # infer_before(pipe, args, accelerator) + + # add the expanded channel + pipe.unet = expand_unet_conv_in(pipe.unet, extra_in_channels=1, init="mean_scaled") + + vae, tokenizer, noise_scheduler = pipe.vae, pipe.tokenizer, pipe.scheduler + text_encoder, unet = pipe.text_encoder.to(torch.float32), pipe.unet.to(torch.float32) + + set_trainable_params(unet, text_encoder, vae, args.train_mode) + + # Taken from [Sayak Paul's Diffusers PR #6511](https://github.com/huggingface/diffusers/pull/6511/files) + def unwrap_model(model): + model = accelerator.unwrap_model(model) + model = model._orig_mod if is_compiled_module(model) else model + return model + + # `accelerate` 0.16.0 will have better support for customized saving + if version.parse(accelerate.__version__) >= version.parse("0.16.0"): + # create custom saving & loading hooks so that `accelerator.save_state(...)` serializes in a nice format + def save_model_hook(models, weights, output_dir): + if accelerator.is_main_process: + for model in models: + sub_dir = "unet" if isinstance(model, type(unwrap_model(unet))) else "text_encoder" + if sub_dir == "unet": + model.register_to_config(in_channels=10) + model.save_pretrained(os.path.join(output_dir, sub_dir)) + + # make sure to pop weight so that corresponding model is not saved again + weights.pop() + + + accelerator.register_save_state_pre_hook(save_model_hook) + + if args.gradient_checkpointing: + unet.train() + text_encoder.gradient_checkpointing_enable() + unet.enable_gradient_checkpointing() + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32: + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + optimizer_cls = torch.optim.AdamW + parameters = get_trainable_params(unet, text_encoder, vae) + optimizer = optimizer_cls( + parameters, + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + # Preparing datasets and dataloader for training + items = build_index(args.train_root, args.density_root) + train_dataset = FSCDataset(items, pipeline=pipe, task_prompt=args.task_prompt) + + by_bucket_sizes = { + tuple(item["size"]): item["value"] + for item in args.by_bucket_sizes + } + sampler = BucketBatchSampler( + dataset=train_dataset, + by_bucket_sizes=by_bucket_sizes, + shuffle=True, + drop_last=True, + seed=42, + bucket_sampling="proportional" + ) + train_dataloader = DataLoader( + dataset=train_dataset, + batch_sampler=sampler, + num_workers=args.dataloader_num_workers, + ) + + val_items = build_index_val('./val_2.txt', args.density_root, max_num=100) + # val_items = build_index(args.val_root, args.density_root, max_num=100) + val_dataset = FSCDataset(val_items, pipeline=pipe, task_prompt=args.task_prompt, train=False) + val_sampler = BucketBatchSampler( + dataset=val_dataset, + by_bucket_sizes=by_bucket_sizes, + shuffle=False, + drop_last=False, + bucket_sampling="proportional" + ) + val_dataloader = DataLoader( + dataset=val_dataset, + batch_sampler=val_sampler, + num_workers=args.dataloader_num_workers, + ) + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader)/args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs*num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + ) + + # Prepare everything with our `accelerator`. + unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, text_encoder, optimizer, train_dataloader, lr_scheduler + ) + + # Move text_encode and vae to gpu and cast to weight_dtype + vae.to(accelerator.device, dtype=weight_dtype) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + tracker_config = dict(vars(args)) + + # tensorboard cannot handle list types for config + pop_list = [] + for k, v in tracker_config.items(): + if not isinstance(v, (int, float, str, bool, torch.Tensor)): + pop_list.append(k) + logger.info(f"Removed {k} (type:{type(v)}) from tracker_config") + for k in pop_list: + tracker_config.pop(k) + + accelerator.init_trackers(args.tracker_project_name, tracker_config) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + logger.info(f"***** Running training for {args.tracker_project_name} *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {int(args.max_train_steps)}") + global_step = 0 + first_epoch = 0 + + # Only show the progress bar once on each machine.args.max_train_steps + progress_bar = tqdm( + range(0, int(args.max_train_steps)), + initial=global_step, + desc="Steps", + # Only show the progress bar once on each machine. + disable=not accelerator.is_local_main_process, + ) + + unet.train() + text_encoder.train() + + # Check what we set grad True + for name, p in unet.named_parameters(): + if p.requires_grad: + logger.info(f'{name} {p.shape}') + + for _ in range(first_epoch, args.num_train_epochs): + train_loss = 0.0 + for batch in train_dataloader: + with accelerator.accumulate(unet): + # Convert images to latent space + latents = vae_encode(vae, batch["pixel_values"].to(weight_dtype)) + bsz, _, lh, lw = latents.shape + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + if args.noise_offset: + # https://www.crosslabs.org//blog/diffusion-with-offset-noise + noise += args.noise_offset * torch.randn( + (latents.shape[0], latents.shape[1], 1, 1), device=latents.device + ) + if args.input_perturbation: + new_noise = noise + args.input_perturbation * torch.randn_like(noise) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device) + timesteps = timesteps.long() + + # in mask, 1 for masked region, 0 for known region + mask_image = batch["pixel_values"] * (batch["mask"] < 0.5) + # convert the hole value from 0 to -1 due to value range [-1, 1] + mask_image = mask_image - batch["mask"] + mask_image_latents = vae_encode(vae, mask_image.to(weight_dtype)) + + # mask/density to latent resolution + # mask cho model input (binary) + mask = to_latent_mask(batch["mask"], lh, lw, soft=False) + density_latent = to_latent_density(batch["density"], lh, lw) + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + if args.input_perturbation: + noisy_latents = noise_scheduler.add_noise(latents, new_noise, timesteps) + else: + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + model_input = torch.cat([noisy_latents, mask, mask_image_latents, density_latent], dim=1) + + # Get the text embedding for conditioning unet, (bs, 77, 768) + encoder_hidden_statesA = text_encoder(batch["input_idsA"], return_dict=False)[0] + encoder_hidden_statesB = text_encoder(batch["input_idsB"], return_dict=False)[0] + tradeoff = batch["tradeoff"].unsqueeze(-1) + encoder_hidden_states = ( + tradeoff[:, 0:1, :] * encoder_hidden_statesA + tradeoff[:, 1:, :] * encoder_hidden_statesB.detach() + ) + encoder_hidden_states = encoder_hidden_states.to(accelerator.unwrap_model(unet).dtype) + + # Get the target for loss depending on the prediction type + if args.prediction_type is not None: + # set prediction_type of scheduler if defined + noise_scheduler.register_to_config(prediction_type=args.prediction_type) + + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + # Predict the noise residual and compute loss + model_pred = unet(model_input, timesteps, encoder_hidden_states, return_dict=False)[0] + + # # mask cho loss weighting (soft optional) + # mask_w_latent = to_latent_mask( + # batch["mask"], lh, lw, + # soft=True, # bool + # blur_kernel=5, # 0/3/5 + # blur_iters=2, # 1-3 + # ) + # # hyperparams (gợi ý): masked_weight=5~10, known_weight=1 + # masked_w = getattr(args, "masked_loss_weight", 5.0) + # known_w = getattr(args, "known_loss_weight", 1.0) + + # loss + # ## Loss forcus on mask hole + # if args.snr_gamma is None: + # loss, _ = weighted_latent_mse( + # model_pred.float(), + # target.float(), + # mask_latent=mask_w_latent, # mask đã là latent-res [B,1,lh,lw] + # masked_weight=masked_w, + # known_weight=known_w, + # ) + # else: + # snr = compute_snr(timesteps) + # mse_loss_weights = ( + # torch.stack([snr, args.snr_gamma * torch.ones_like(timesteps)], dim=1).min(dim=1)[0] / snr + # ) # [B] + + # _, loss_per_sample = weighted_latent_mse( + # model_pred.float(), + # target.float(), + # mask_latent=mask_w_latent, + # masked_weight=masked_w, + # known_weight=known_w, + # ) + # loss = (loss_per_sample * mse_loss_weights).mean() + + ## Loss origin + if args.snr_gamma is None: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + else: + # Compute loss-weights as per Section 3.4 of https://arxiv.org/abs/2303.09556. + # Since we predict the noise instead of x_0, the original formulation is slightly changed. + # This is discussed in Section 4.2 of the same paper. + snr = compute_snr(timesteps) + mse_loss_weights = ( + torch.stack([snr, args.snr_gamma * torch.ones_like(timesteps)], dim=1).min(dim=1)[0] / snr + ) + # We first calculate the original loss. Then we mean over the non-batch dimensions and + # rebalance the sample-wise losses with their respective loss weights. + # Finally, we take the mean of the rebalanced loss. + loss = F.mse_loss(model_pred.float(), target.float(), reduction="none") + loss = loss.mean(dim=list(range(1, len(loss.shape)))) * mse_loss_weights + loss = loss.mean() + + # Gather the losses across all processes for logging (if we use distributed training). + avg_loss = accelerator.gather(loss.repeat(args.train_batch_size)).mean() + train_loss += avg_loss.item() / args.gradient_accumulation_steps + + + # Backpropagate + accelerator.backward(loss) + if accelerator.sync_gradients: + accelerator.clip_grad_norm_(parameters, args.max_grad_norm) + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Check if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + global_step += 1 + + accelerator.log({"train_loss": train_loss}, step=global_step) + train_loss = 0.0 + + if accelerator.is_main_process: + if (global_step % args.checkpointing_steps == 0): + # _before_ saving state, check if this save would set us over the `checkpoints_total_limit` + if args.checkpoints_total_limit is not None: + checkpoints = os.listdir(args.output_dir) + checkpoints = [d for d in checkpoints if d.startswith("checkpoint")] + checkpoints = sorted(checkpoints, key=lambda x: int(x.split("-")[1])) + + # before we save the new checkpoint, we need to have at _most_ `checkpoints_total_limit - 1` checkpoints + if len(checkpoints) >= args.checkpoints_total_limit: + num_to_remove = len(checkpoints) - args.checkpoints_total_limit + 1 + removing_checkpoints = checkpoints[0:num_to_remove] + + logger.info( + f"{len(checkpoints)} checkpoints already exist, removing {len(removing_checkpoints)} checkpoints" + ) + logger.info(f"removing checkpoints: {', '.join(removing_checkpoints)}") + + for removing_checkpoint in removing_checkpoints: + removing_checkpoint = os.path.join(args.output_dir, removing_checkpoint) + shutil.rmtree(removing_checkpoint) + save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}") + accelerator.save_state(save_path) + logger.info(f"Saved state to {save_path}") + + # infer val + out_root = os.path.join(args.output_dir, "val_infer_cf") + for bi, batch in enumerate(val_dataloader): + stats = infer_counterfactual_3( + pipe, batch, + out_dir=out_root, + global_step=global_step, + accelerator=accelerator, + seed=1234 + bi, + tradoff=1.0, + tradoff_nag=1.0, + save_k=4, + ) + # infer_val_counterfactual(pipe, unet, text_encoder, vae, val_dataloader, args, accelerator, + # global_step=global_step, weight_dtype=weight_dtype, + # num_batches=2, steps=30, seed=1234) + + logs = {"step_loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + + if global_step >= args.max_train_steps: + break + + accelerator.wait_for_everyone() + + accelerator.end_training() + +if __name__ == "__main__": + main() diff --git a/train_ppt.py b/train_ppt.py new file mode 100644 index 0000000..3939250 --- /dev/null +++ b/train_ppt.py @@ -0,0 +1,912 @@ +import argparse +import gc +import logging +import math +import os +import shutil +import inspect + +import accelerate +import numpy as np +import torch +import torch.nn.functional as F +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import ProjectConfiguration, set_seed +from omegaconf import OmegaConf +from packaging import version +from PIL import Image +from safetensors.torch import load_model +from tqdm.auto import tqdm +from transformers import PretrainedConfig + +import diffusers +from diffusers.optimization import get_scheduler +from diffusers.training_utils import EMAModel, compute_snr +from diffusers.utils import check_min_version, deprecate, is_wandb_available +from diffusers.utils.hub_utils import load_or_create_model_card, populate_model_card +from diffusers.utils.import_utils import is_xformers_available +from diffusers.utils.torch_utils import is_compiled_module +from powerpaint.datasets.FSC147 import FSCDataset +from powerpaint.models import UNet2DConditionModel +from powerpaint.pipelines import StableDiffusionInpaintPipeline + + +if is_wandb_available(): + import wandb + from dotenv import load_dotenv + load_dotenv() + wandb.login() + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.27.0.dev0") + +logger = get_logger(__name__, log_level="INFO") + +def log_validation(tokenizer, text_encoder, unet, args, accelerator, weight_dtype, step): + logger.info("Running validation... ") + + pipe = StableDiffusionInpaintPipeline.from_pretrained( + args.pretrained_model_name_or_path, + text_encoder=accelerator.unwrap_model(text_encoder), + tokenizer=tokenizer, + unet=accelerator.unwrap_model(unet), + safety_checker=None, + revision=args.revision, + variant=args.variant, + torch_dtype=weight_dtype, + local_files_only=True, # load files from local cache + ) + pipe = pipe.to(accelerator.device) + pipe.set_progress_bar_config(disable=True) + + if args.enable_xformers_memory_efficient_attention: + pipe.enable_xformers_memory_efficient_attention() + + # load validation images + image_logs = [] + for case in args.validation_data.cases: + validation_prompts = case.prompt + validation_image = Image.open(os.path.join(args.validation_data.data_root, case.image)).convert("RGB") + validation_mask = Image.open(os.path.join(args.validation_data.data_root, case.mask)) + validation_mask = validation_mask.resize((validation_image.size[0], validation_image.size[1]), Image.NEAREST) + validation_mask = validation_mask.convert("L") + hole_value = (0, 0, 0) + validation_image = Image.composite( + Image.new("RGB", (validation_image.size[0], validation_image.size[1]), hole_value), + validation_image, + validation_mask.convert("L"), + ) + image_grid = Image.new( + "RGB", + (validation_image.size[0] * (1 + len(validation_prompts)), validation_image.size[1]), + (255, 255, 255), + ) + image_grid.paste(validation_image, (0, 0)) + for i, p in enumerate(validation_prompts): + with torch.autocast(accelerator.device.type): + image = pipe( + promptA=p.promptA, + promptB=p.promptB, + negative_promptA=p.get("negative_promptA", None), + negative_promptB=p.get("negative_promptB", None), + tradeoff=p.tradeoff, + image=validation_image, + mask=validation_mask, + num_inference_steps=45, + ).images[0] + image_logs.append(image) + image_grid.paste(image, (validation_image.size[0] * (i + 1), 0)) + save_path = os.path.join( + args.output_dir, + f"{case.name}_{str(step).zfill(3)}_{os.path.basename(case.image)}" + ) + os.makedirs(os.path.dirname(save_path), exist_ok=True) + image_grid.save(save_path) + + # image_grid.save(os.path.join(args.output_dir, f"{case.name}_{str(step).zfill(3)}_{os.path.basename(case.image)}")) + gc.collect() + torch.cuda.empty_cache() + + for tracker in accelerator.trackers: + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in image_logs]) + tracker.writer.add_images("validation", np_images, step, dataformats="NHWC") + elif tracker.name == "wandb": + tracker.log( + { + "validation": [ + wandb.Image(image, caption=f"{p.task}") + for image, p in zip(image_logs, args.validation_data.cases[0].prompt) + ] + } + ) + else: + logger.warning(f"image logging not implemented for {tracker.name}") + + del pipe + torch.cuda.empty_cache() + + return image_logs + +def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str): + text_encoder_config = PretrainedConfig.from_pretrained( + pretrained_model_name_or_path, + subfolder='text_encoder', + revision=revision, + ) + model_class = text_encoder_config.architectures[0] + + if model_class == "CLIPTextModel": + from transformers import CLIPTextModel + return CLIPTextModel + + # elif model_class == "RobertaSeriesModelWithTransformation": + # from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation + # return RobertaSeriesModelWithTransformation + + elif model_class == "T5EncoderModel": + from transformers import T5EncoderModel + return T5EncoderModel + + else: + raise ValueError(f"{model_class} is not supported") + +def parse_args(): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--input_perturbation", type=float, default=0, help="The scale of input perturbation. Recommended 0.1." + ) + parser.add_argument( + "--config", + type=str, + default=None, + help="yaml for configuration", + ) + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default=None, + required=False, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--variant", + type=str, + default=None, + help="Variant of the model files of the pretrained model identifier from huggingface.co/models, 'e.g.' fp16", + ) + parser.add_argument( + "--max_train_samples", + type=int, + default=None, + help=( + "For debugging purposes or quicker training, truncate the number of training examples to this " + "value if set." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="runs/ppt1_sd15", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument( + "--cache_dir", + type=str, + default=None, + help="The directory where the downloaded models and datasets will be stored.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", + default=False, + action="store_true", + help=( + "Whether to center crop the input images to the resolution. If not set, the images will be randomly" + " cropped. The images will be resized to the resolution first before cropping." + ), + ) + parser.add_argument( + "--random_flip", + action="store_true", + help="whether to randomly flip images horizontally", + ) + parser.add_argument( + "--train_batch_size", + type=int, + default=16, + required=False, + help="Batch size (per device) for the training dataloader.", + ) + parser.add_argument("--num_train_epochs", type=int, default=100) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=1e-4, + help="Initial learning rate (after the potential warm-up period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", + type=int, + default=500, + help="Number of steps for the warm-up in the lr scheduler.", # noqa: F401 + ) + parser.add_argument( + "--snr_gamma", + type=float, + default=None, + help="SNR weighting gamma to be used if rebalancing the loss. Recommended value is 5.0. " + "More details here: https://arxiv.org/abs/2303.09556.", + ) + parser.add_argument( + "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes." + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument("--use_ema", action="store_true", help="Whether to use EMA model.") + parser.add_argument( + "--non_ema_revision", + type=str, + default=None, + required=False, + help=( + "Revision of pretrained non-ema model identifier. Must be a branch, tag or git identifier of the local or" + " remote repository specified with --pretrained_model_name_or_path." + ), + ) + parser.add_argument( + "--dataloader_num_workers", + type=int, + default=0, + help=( + "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process." + ), + ) + parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") + parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.") + parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.") + parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer") + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument( + "--prediction_type", + type=str, + default=None, + help="The prediction_type that shall be used for training. Choose between 'epsilon' or 'v_prediction' or leave `None`. If left to `None` the default prediction type of the scheduler: `noise_scheduler.config.prediction_type` is chosen.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints are only suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--checkpoints_total_limit", + type=int, + default=None, + help=("Max number of checkpoints to store."), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + parser.add_argument("--noise_offset", type=float, default=0, help="The scale of noise offset.") + parser.add_argument( + "--validation_epochs", + type=int, + default=5, + help="Run validation every X epochs.", + ) + parser.add_argument( + "--tracker_project_name", + type=str, + default="text2image-fine-tune", + help=( + "The `project_name` argument passed to Accelerator.init_trackers for" + " more information see https://huggingface.co/docs/accelerate/v0.17.0/en/package_reference/accelerator#accelerate.Accelerator" + ), + ) + + args = parser.parse_args() + env_local_rank = int(os.environ.get("LOCAL_RANK", -1)) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + # use omegaconf to manage configurations + if args.config is not None: + config = OmegaConf.load(args.config) + for k, v in config.items(): + args.__dict__[k] = v + return args + +def main(): + args = parse_args() + print(args.train_data.datasets.data_path) + print(type(args.train_data.datasets.data_path)) + if args.non_ema_revision is not None: + deprecate( + "non_ema_revision!=None", + "0.15.0", + message=( + "Downloading 'non_ema' weights from revision branches of the Hub is deprecated. Please make sure to" + " use `--variant=non_ema` instead." + ), + ) + + logging_dir = os.path.join(args.output_dir, args.logging_dir) + accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir) + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_config=accelerator_project_config, + ) + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + torch.manual_seed(args.seed) + set_seed(args.seed) + + # Handle the repository creation + if accelerator.is_main_process: + if args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # saving training configuration to output_dir + to_save_config = OmegaConf.create(vars(args)) + OmegaConf.save(config=to_save_config, f=os.path.join(args.output_dir, "training_config.yaml")) + + # For mixed precision training we cast all non-trainable weights (vae, non-lora text_encoder and non-lora unet) to half-precision + # as these weights are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + args.mixed_precision = accelerator.mixed_precision + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + args.mixed_precision = accelerator.mixed_precision + + # ========================================== + # setting models: load scheduler, tokenizer and models. + # ========================================== + text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision) + pipe = StableDiffusionInpaintPipeline.from_pretrained( + args.pretrained_model_name_or_path, + unet=UNet2DConditionModel.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="unet", + torch_dtype=weight_dtype, + local_files_only=True, + ), + revision=args.revision, + variant=args.variant, + local_files_only=True, + ) + + # IMPORTANT: + # 1. Add tokens in the same order and placeholder with training + # 2. set initilize_parameters to False to avoid reinitializing the model + pipe.add_tokens( + placeholder_tokens=["P_obj", "P_ctxt", "P_shape"], + initializer_tokens=["a", "a", "a"], + num_vectors_per_token=10, + initialize_parameters=False, + ) + #loading pre-trained weights + load_model(pipe.unet, os.path.join(args.ppt1_model_path, "unet/unet.safetensors"), strict=False) + load_model(pipe.text_encoder, os.path.join(args.ppt1_model_path, "text_encoder/text_encoder.safetensors"),strict=False ) + + # IMPORTANT: add learnable tokens for task prompts into tokenizer + placeholder_tokens = [v.placeholder_tokens for k, v in args.task_prompt.items()] + initializer_token = [v.initializer_token for k, v in args.task_prompt.items()] + num_vectors_per_token = [v.num_vectors_per_token for k, v in args.task_prompt.items()] + placeholder_token_ids = pipe.add_tokens( + placeholder_tokens, initializer_token, num_vectors_per_token, initialize_parameters=True + ) + + vae, tokenizer, noise_scheduler = pipe.vae, pipe.tokenizer, pipe.scheduler + text_encoder, unet = pipe.text_encoder.to(torch.float32), pipe.unet.to(torch.float32) + + # Freeze all parameters except for the token embeddings in text encoder + vae.requires_grad_(False) + text_encoder.text_model.requires_grad_(True) + text_encoder.text_model.encoder.requires_grad_(False) + text_encoder.text_model.final_layer_norm.requires_grad_(False) + text_encoder.text_model.embeddings.position_embedding.requires_grad_(False) + + # Create EMA for the unet. + if args.use_ema: + ema_unet = UNet2DConditionModel.from_pretrained( + args.ppt1_model_path, subfolder="unet", torch_dtype=weight_dtype, local_files_only=True + ) + ema_unet = EMAModel(ema_unet.parameters(), model_cls=UNet2DConditionModel, model_config=ema_unet.config) + + if args.enable_xformers_memory_efficient_attention: + if is_xformers_available(): + import xformers + + xformers_version = version.parse(xformers.__version__) + if xformers_version == version.parse("0.0.16"): + logger.warning( + "xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details." + ) + unet.enable_xformers_memory_efficient_attention() + else: + raise ValueError("xformers is not available. Make sure it is installed correctly") + + + # Taken from [Sayak Paul's Diffusers PR #6511](https://github.com/huggingface/diffusers/pull/6511/files) + def unwrap_model(model): + model = accelerator.unwrap_model(model) + model = model._orig_mod if is_compiled_module(model) else model + return model + + # `accelerate` 0.16.0 will have better support for customized saving + if version.parse(accelerate.__version__) >= version.parse("0.16.0"): + # create custom saving & loading hooks so that `accelerator.save_state(...)` serializes in a nice format + def save_model_hook(models, weights, output_dir): + if accelerator.is_main_process: + for model in models: + sub_dir = "unet" if isinstance(model, type(unwrap_model(unet))) else "text_encoder" + model.save_pretrained(os.path.join(output_dir, sub_dir)) + + # make sure to pop weight so that corresponding model is not saved again + weights.pop() + + def load_model_hook(models, input_dir): + while len(models) > 0: + model = models.pop() + + if isinstance(model, type(unwrap_model(text_encoder))): + # load transformers style into model + load_model = text_encoder_cls.from_pretrained(input_dir, subfolder="text_encoder") + model.config = load_model.config + else: + # load diffusers style into model + load_model = UNet2DConditionModel.from_pretrained(input_dir, subfolder="unet") + model.register_to_config(**load_model.config) + + model.load_state_dict(load_model.state_dict()) + del load_model + + accelerator.register_save_state_pre_hook(save_model_hook) + accelerator.register_load_state_pre_hook(load_model_hook) + + if args.gradient_checkpointing: + unet.train() + text_encoder.gradient_checkpointing_enable() + unet.enable_gradient_checkpointing() + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32: + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + # Initialize the optimizer + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "Please install bitsandbytes to use 8-bit Adam. You can do so by running `pip install bitsandbytes`" + ) + optimizer_cls = bnb.optim.AdamW8bit + else: + optimizer_cls = torch.optim.AdamW + + optimizer = optimizer_cls( + list(unet.parameters()) + list(text_encoder.get_input_embeddings().parameters()), + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + #preparing datasets and dataloader for training. + train_dataset = FSCDataset(args.train_data.datasets.data_path, transforms=None, pipeline=pipe, task_prompt=args.task_prompt, resolution=args.train_data.resolution) + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=args.train_batch_size, + num_workers=args.dataloader_num_workers, + shuffle=True + ) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + ) + + text_encoder.train() + # Prepare everything with our `accelerator`. + unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, text_encoder, optimizer, train_dataloader, lr_scheduler + ) + unet, text_encoder = accelerator.prepare( + unet, text_encoder + ) + + # Move text_encode and vae to gpu and cast to weight_dtype + vae.to(accelerator.device, dtype=weight_dtype) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + if args.num_train_epochs is None: + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + tracker_config = dict(vars(args)) + + # tensorboard cannot handle list types for config + pop_list = [] + for k, v in tracker_config.items(): + if not isinstance(v, (int, float, str, bool, torch.Tensor)): + pop_list.append(k) + logger.info(f"Removed {k} (type:{type(v)}) from tracker_config") + for k in pop_list: + tracker_config.pop(k) + + accelerator.init_trackers(args.tracker_project_name, tracker_config) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + logger.info(f"***** Running training for {args.tracker_project_name} *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {int(args.max_train_steps)}") + global_step = 0 + first_epoch = 0 + + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint != "latest": + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the most recent checkpoint + dirs = os.listdir(args.output_dir) + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = dirs[-1] if len(dirs) > 0 else None + + if path is None: + logger.info(f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run.") + args.resume_from_checkpoint = None + initial_global_step = 0 + else: + logger.info(f"Resuming from checkpoint {path}") + accelerator.load_state(os.path.join(args.output_dir, path)) + global_step = int(path.split("-")[1]) + + initial_global_step = global_step + # first_epoch = global_step // num_update_steps_per_epoch + + #Only show the progress bar once on each machine.args.max_train_steps + progress_bar = tqdm( + range(0, int(args.max_train_steps)), + initial=initial_global_step, + desc="Steps", + # Only show the progress bar once on each machine. + disable=not accelerator.is_local_main_process, + ) + + unet.train() + text_encoder.train() + # keep original embeddings as reference + orig_embeds_params = accelerator.unwrap_model(text_encoder).get_input_embeddings().weight.data.clone() + + if accelerator.is_main_process: + log_validation( + tokenizer, + text_encoder, + unet, + args, + accelerator, + weight_dtype, + 0, + ) + + + for _ in range(first_epoch, args.num_train_epochs): + train_loss = 0.0 + for batch in train_dataloader: + with accelerator.accumulate(unet): + # Convert images to latent space + latents = vae.encode(batch["pixel_values"].to(weight_dtype)).latent_dist.sample() + latents = latents * vae.config.scaling_factor + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + if args.noise_offset: + # https://www.crosslabs.org//blog/diffusion-with-offset-noise + noise += args.noise_offset * torch.randn( + (latents.shape[0], latents.shape[1], 1, 1), device=latents.device + ) + if args.input_perturbation: + new_noise = noise + args.input_perturbation * torch.randn_like(noise) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device) + timesteps = timesteps.long() + + # in mask, 1 for masked region, 0 for known region + mask_image = batch["pixel_values"] * (batch["mask"] < 0.5) + # convert the hole value from 0 to -1 due to value range [-1, 1] + mask_image = mask_image - batch["mask"] + mask_image_latents = vae.encode(mask_image.to(weight_dtype)).latent_dist.sample() + mask_image_latents = mask_image_latents * vae.config.scaling_factor + + mask = torch.nn.functional.interpolate(batch["mask"], size=(64, 64)) + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + if args.input_perturbation: + noisy_latents = noise_scheduler.add_noise(latents, new_noise, timesteps) + else: + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + model_input = torch.cat([noisy_latents, mask, mask_image_latents], dim=1) + + # Get the text embedding for conditioning unet, (bs, 77, 768) + encoder_hidden_statesA = text_encoder(batch["input_idsA"], return_dict=False)[0] + encoder_hidden_statesB = text_encoder(batch["input_idsB"], return_dict=False)[0] + tradeoff = batch["tradeoff"].unsqueeze(-1) + encoder_hidden_states = ( + tradeoff[:, 0:1, :] * encoder_hidden_statesA + tradeoff[:, 1:, :] * encoder_hidden_statesB.detach() + ) + encoder_hidden_states = encoder_hidden_states.to(accelerator.unwrap_model(unet).dtype) + + # Get the target for loss depending on the prediction type + if args.prediction_type is not None: + # set prediction_type of scheduler if defined + noise_scheduler.register_to_config(prediction_type=args.prediction_type) + + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + # Predict the noise residual and compute loss + model_pred = unet(model_input, timesteps, encoder_hidden_states, return_dict=False)[0] + + if args.snr_gamma is None: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + else: + # Compute loss-weights as per Section 3.4 of https://arxiv.org/abs/2303.09556. + # Since we predict the noise instead of x_0, the original formulation is slightly changed. + # This is discussed in Section 4.2 of the same paper. + snr = compute_snr(timesteps) + mse_loss_weights = ( + torch.stack([snr, args.snr_gamma * torch.ones_like(timesteps)], dim=1).min(dim=1)[0] / snr + ) + # We first calculate the original loss. Then we mean over the non-batch dimensions and + # rebalance the sample-wise losses with their respective loss weights. + # Finally, we take the mean of the rebalanced loss. + loss = F.mse_loss(model_pred.float(), target.float(), reduction="none") + loss = loss.mean(dim=list(range(1, len(loss.shape)))) * mse_loss_weights + loss = loss.mean() + + # Gather the losses across all processes for logging (if we use distributed training). + avg_loss = accelerator.gather(loss.repeat(args.train_batch_size)).mean() + train_loss += avg_loss.item() / args.gradient_accumulation_steps + + # Backpropagate + accelerator.backward(loss) + if accelerator.sync_gradients: + params_to_clip = list(unet.parameters()) + list( + accelerator.unwrap_model(text_encoder).get_input_embeddings().parameters() + ) + accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm) + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Let's make sure we don't update any embedding weights besides the newly added token + index_no_updates = torch.ones((len(tokenizer),), dtype=torch.bool) + index_no_updates[min(placeholder_token_ids) : max(placeholder_token_ids) + 1] = False + + with torch.no_grad(): + accelerator.unwrap_model(text_encoder).get_input_embeddings().weight[index_no_updates] = ( + orig_embeds_params[index_no_updates] + ) + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + if args.use_ema: + ema_unet.step(unet.parameters()) + progress_bar.update(1) + global_step += 1 + + accelerator.log({"train_loss": train_loss}, step=global_step) + train_loss = 0.0 + + if accelerator.is_main_process: + if global_step % args.checkpointing_steps == 0: + # _before_ saving state, check if this save would set us over the `checkpoints_total_limit` + if args.checkpoints_total_limit is not None: + checkpoints = os.listdir(args.output_dir) + checkpoints = [d for d in checkpoints if d.startswith("checkpoint")] + checkpoints = sorted(checkpoints, key=lambda x: int(x.split("-")[1])) + + # before we save the new checkpoint, we need to have at _most_ `checkpoints_total_limit - 1` checkpoints + if len(checkpoints) >= args.checkpoints_total_limit: + num_to_remove = len(checkpoints) - args.checkpoints_total_limit + 1 + removing_checkpoints = checkpoints[0:num_to_remove] + + logger.info( + f"{len(checkpoints)} checkpoints already exist, removing {len(removing_checkpoints)} checkpoints" + ) + logger.info(f"removing checkpoints: {', '.join(removing_checkpoints)}") + + for removing_checkpoint in removing_checkpoints: + removing_checkpoint = os.path.join(args.output_dir, removing_checkpoint) + shutil.rmtree(removing_checkpoint) + save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}") + accelerator.save_state(save_path) + logger.info(f"Saved state to {save_path}") + + if hasattr(args, "validation_data") is not None and global_step % args.validation_steps == 0: + log_validation( + tokenizer, + text_encoder, + unet, + args, + accelerator, + weight_dtype, + global_step, + ) + + logs = {"step_loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + + if global_step >= args.max_train_steps: + break + + # Create the pipeline using the trained modules and save it. + accelerator.wait_for_everyone() + if accelerator.is_main_process: + # Run a final round of inference. + image_logs = [] + if hasattr(args, "validation_data"): + logger.info("Running inference for collecting generated images...") + image_logs = log_validation(tokenizer, text_encoder, unet, args, accelerator, weight_dtype, global_step) + + accelerator.end_training() + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/val.txt b/val.txt new file mode 100644 index 0000000..c21ba95 --- /dev/null +++ b/val.txt @@ -0,0 +1,1679 @@ +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2014_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2018_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2018_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2020_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2020_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2021_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2026_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2026_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2028_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2028_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2028_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2031_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2036_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2040_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2040_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2045_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2046_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2046_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2046_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2051_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2051_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2052_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2052_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2138_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2138_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2139_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2139_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2140_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2140_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2141_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2141_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2141_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2142_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2143_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2145_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2145_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2145_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2146_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2146_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2146_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2147_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2147_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2147_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2150_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2150_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2150_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2151_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2151_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2151_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2152_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2152_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2153_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2153_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2155_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2156_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2156_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2156_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2162_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2162_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2162_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2163_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2163_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2163_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2164_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2164_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2164_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2171_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2171_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2174_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2174_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2174_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2177_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2177_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2177_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2178_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2178_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2179_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2179_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2182_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2182_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2189_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2189_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2190_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2190_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2190_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2191_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2191_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2191_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2192_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2192_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2192_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2193_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2193_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2193_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2195_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2195_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2197_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2197_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2197_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2198_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2199_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2199_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2199_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2203_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2204_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2204_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2204_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2206_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2206_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2206_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2207_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2207_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2207_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2208_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2208_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2209_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2209_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2209_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2210_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2210_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2210_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2211_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2211_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2215_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2215_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2215_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2216_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2216_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2216_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2217_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2217_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2217_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2218_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2220_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2220_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2220_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2223_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2223_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2223_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2225_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2225_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2225_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2226_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2226_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2226_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2227_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2227_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2227_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2232_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2232_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2232_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2233_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2233_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2233_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2234_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2234_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2234_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2235_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2236_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2236_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2237_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2237_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2237_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2238_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2238_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2238_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2239_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2239_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2239_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2240_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2241_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2241_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2241_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2244_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2244_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2244_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2246_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2246_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2246_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2247_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2247_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2247_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2252_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2252_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2252_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2256_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2256_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2257_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2257_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2257_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2258_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2258_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2258_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2260_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2260_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2260_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2262_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2262_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2262_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2264_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2264_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2264_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2265_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2265_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2265_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2267_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2267_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2267_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2268_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2268_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2268_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2269_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2269_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2269_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2270_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2270_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2270_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2271_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2271_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2272_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2272_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2274_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2274_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2274_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2275_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2276_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2276_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2276_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2277_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2277_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2277_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2279_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2279_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2279_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2280_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2281_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2281_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2281_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2284_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2284_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2284_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2285_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2285_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2285_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2286_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2286_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2286_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2288_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/285_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/285_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/285_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/286_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/286_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/286_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/287_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/287_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/288_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/288_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/288_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/289_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/290_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/290_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2913_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2918_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2921_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2923_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2928_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/292_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/292_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/292_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2931_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2938_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/293_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2941_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2945_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2946_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2946_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2951_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2951_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/295_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/295_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/297_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/297_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/297_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/298_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/299_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/299_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/300_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/300_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/301_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/302_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/302_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/302_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/305_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/305_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/306_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/306_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/308_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/308_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/308_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/309_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/309_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/310_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3112_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3112_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3112_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/311_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/311_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/312_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/313_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/313_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3153_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3153_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3155_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3155_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3157_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3159_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3159_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3159_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/315_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/315_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/315_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3160_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/316_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/316_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/316_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/319_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/319_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/320_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/320_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/320_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/321_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/321_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/321_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/322_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/324_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/325_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/325_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3268_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/326_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/326_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3270_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3270_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3271_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3271_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3271_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3276_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3278_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3278_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3279_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3279_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/327_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/327_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3281_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3281_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3282_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3283_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3285_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3285_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/329_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/329_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/329_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3309_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/330_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/330_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/330_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3311_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3317_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3317_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3317_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/331_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3324_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3324_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3324_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3326_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/332_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/332_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3333_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3333_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/334_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/334_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/334_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/335_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/335_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/335_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/336_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/337_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/337_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/339_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/340_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/340_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/340_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/341_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3424_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3424_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/342_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/342_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/343_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/343_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/345_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/345_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/345_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/346_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/346_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/346_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/347_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3493_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3493_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3493_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3494_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3494_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3495_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3495_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3495_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3496_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3498_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3498_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3499_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3499_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3499_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3500_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3500_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3500_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/350_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/350_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/351_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/351_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3643_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3644_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3645_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3646_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3647_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3649_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3649_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3649_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3650_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3650_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3651_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3653_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3655_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3655_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3657_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3657_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3657_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3658_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3658_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3658_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3659_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3659_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3693_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3693_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3693_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3694_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3694_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3694_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3695_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3695_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3695_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3696_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3696_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3698_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3698_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3698_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4063_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4063_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4063_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4065_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4065_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4066_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4066_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4066_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4068_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4068_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4068_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4070_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4072_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4072_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4072_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4074_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4074_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4074_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4078_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4078_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4083_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4083_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4086_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4086_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4086_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4089_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4110_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4111_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4112_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4112_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4112_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4114_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4114_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4115_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4115_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4116_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4116_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4118_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4118_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4118_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4122_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4122_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4122_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4123_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4123_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4170_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4173_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4173_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4173_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4174_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4174_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4174_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4175_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4175_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4175_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4284_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4284_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4288_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4288_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4289_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4289_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4289_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4290_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4292_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4292_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4297_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4298_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4298_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4298_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4302_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4302_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4302_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4304_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4304_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4305_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4407_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4408_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4408_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4409_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4409_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4409_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4412_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4412_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4417_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4421_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4423_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4423_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4423_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4492_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4492_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4492_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4493_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4493_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4494_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4495_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4496_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4498_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4498_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4498_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4499_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4499_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4499_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4500_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4500_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4500_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4501_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4875_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4876_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4876_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4876_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4877_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4877_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4877_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4878_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4878_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4879_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4879_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4880_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4880_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4880_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4881_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4881_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4881_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4883_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4884_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4884_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4884_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4885_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4885_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4885_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4886_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4886_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4886_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4888_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4888_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4888_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4889_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4890_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4890_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4890_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4891_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4891_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4891_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4892_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4893_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4893_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4893_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4894_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4895_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4895_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4896_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4896_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4896_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4898_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4898_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4898_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4900_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4900_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4900_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4901_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4901_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4903_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4903_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4904_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4909_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4909_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4909_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4910_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4910_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4913_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4913_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4915_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4915_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4915_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4917_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4917_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4918_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4920_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4920_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4921_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4922_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4922_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4922_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4923_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4923_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4923_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4925_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4925_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4926_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4926_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4926_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4927_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4927_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4927_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4928_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4930_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4930_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4931_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4931_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4934_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4934_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4935_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4935_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4938_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4939_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4939_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4940_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4940_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4940_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4942_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4946_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4946_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4948_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4948_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4948_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4950_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4950_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4954_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4954_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4954_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4956_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4957_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4959_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4960_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4960_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4960_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4962_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4965_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4965_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4965_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4966_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4966_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4966_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4967_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4967_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4967_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4970_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/4970_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5141_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5141_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5143_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5144_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5145_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5145_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5145_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5147_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5147_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5148_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5148_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5148_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5357_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5357_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5358_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5358_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5361_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5363_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5364_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5364_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5364_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5369_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5369_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5371_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5371_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5373_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5374_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5375_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5375_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5375_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5377_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5377_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5377_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5378_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5379_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5381_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5381_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5381_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5382_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5382_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5382_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5383_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5383_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5383_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5385_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5385_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5385_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5386_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5387_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5387_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5387_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5388_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5388_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5388_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5390_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5391_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5391_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5391_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5458_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5461_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5503_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5503_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5509_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5512_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5562_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5562_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5562_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5564_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5564_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5564_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5565_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5565_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5565_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5568_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5571_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5571_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5571_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5572_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5573_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5573_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5573_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5575_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5575_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5575_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5576_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5576_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5577_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5577_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5581_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5581_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5581_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5583_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5583_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5583_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5584_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5585_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5585_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5585_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5587_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5587_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5587_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5588_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5590_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5590_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5590_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5591_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5591_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5593_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5593_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5593_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5594_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5594_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5594_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5595_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5595_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5595_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5596_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5596_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5596_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5598_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5598_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5598_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5601_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5601_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5601_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5602_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5602_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5602_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5791_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5791_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5791_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5792_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5792_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5792_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5793_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5793_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5793_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5794_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5794_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5794_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5796_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5796_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5797_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5797_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5797_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5799_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5799_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5799_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5800_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5800_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5800_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5802_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5802_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5802_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5803_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5803_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5803_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5805_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5805_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5805_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5806_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5808_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5808_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5808_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5809_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5809_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5809_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5811_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5811_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5811_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5812_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5812_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5812_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5813_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5813_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5813_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5815_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5816_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5817_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5817_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5817_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5818_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5818_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5818_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5820_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5820_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5820_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5821_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5821_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5821_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5823_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5824_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5824_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5825_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5825_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5826_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5826_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5827_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5827_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5827_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5828_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5828_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5830_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5830_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5830_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5831_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5831_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5832_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5833_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5833_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5834_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5834_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5834_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5835_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5835_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5835_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5836_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5836_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5836_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5837_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5837_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5837_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5838_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5838_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5839_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5839_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5839_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5841_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5841_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5842_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5842_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5842_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5843_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5843_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5843_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5844_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5844_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5844_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5845_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5845_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5845_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5846_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5846_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5846_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5847_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5847_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5847_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5848_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5850_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5850_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5850_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5851_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5851_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5852_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5852_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5852_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5853_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5854_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5918_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5919_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5919_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5919_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5920_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5920_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5920_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5923_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5923_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5925_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5925_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5925_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5927_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5927_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5927_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5930_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5930_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5930_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5931_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5931_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5931_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5934_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5934_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5935_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5935_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5935_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5937_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5937_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5937_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5939_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5939_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5939_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5941_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5941_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5941_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5942_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5942_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/5942_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6240_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6240_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6242_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6242_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6244_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6244_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6246_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6246_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6246_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6249_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6249_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6250_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6250_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6251_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6251_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6251_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6253_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6254_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6254_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6254_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6255_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6256_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6256_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6256_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6258_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6258_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6258_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6259_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6259_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6259_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6262_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6262_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6262_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6263_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6263_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6263_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6265_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6265_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6265_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6267_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6267_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6272_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6272_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6272_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6273_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6273_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6273_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6274_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6274_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6275_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6275_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6275_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6276_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6277_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6277_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6277_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6279_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6279_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6279_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6282_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6283_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6283_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6284_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6284_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6284_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6285_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6285_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6285_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6650_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6650_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6650_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6651_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6652_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6652_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6652_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6710_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6732_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6733_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6733_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6733_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6743_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6756_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6756_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6756_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6771_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6804_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6813_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6823_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6827_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/682_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6839_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6839_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6852_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6859_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6859_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/685_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6879_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6879_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6904_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6904_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6904_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/692_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/692_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/692_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/693_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/693_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/693_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6943_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6960_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6960_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6962_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6962_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6962_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6965_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/697_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/697_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/697_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7027_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7027_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/702_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/702_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/702_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/703_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/703_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/704_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/704_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/704_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/705_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7076_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7096_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7096_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/710_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7117_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/711_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/711_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/712_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/712_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/713_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/713_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/713_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7146_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7146_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/714_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/714_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/714_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7175_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7175_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7175_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7176_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7176_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7176_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7192_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7192_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/719_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/719_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7205_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7205_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7262_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7262_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7262_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7277_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7277_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7277_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7341_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7398_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7438_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7438_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7493_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7493_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7493_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7506_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7506_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7506_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7514_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7520_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7527_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7527_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7527_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7542_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7567_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7573_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7573_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7573_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7605_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7617_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7617_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7617_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7627_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7643_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7643_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7650_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7650_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7650_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7689_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7689_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7689_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7709_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7709_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/910_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/985_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/989_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/989_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/989_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/993_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/993_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/993_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/995_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/995_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/995_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/996_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/996_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/998_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/999_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/999_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/999_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1050_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1050_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1061_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1061_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1873_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1873_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1874_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1881_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1881_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1881_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1884_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1884_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1884_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1886_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1887_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1887_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1887_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1888_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1888_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1888_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/1889_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2607_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2607_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2613_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2614_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2614_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2615_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2615_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2615_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/2_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3339_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3339_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3339_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/3342_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4529_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4529_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4529_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4530_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4530_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4530_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4532_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4532_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4532_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4533_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4533_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4533_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4534_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4534_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4534_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4535_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4535_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4535_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4536_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4536_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4536_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4537_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4537_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4537_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4538_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4538_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4538_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4539_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4539_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4539_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4540_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4540_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4540_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4541_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4541_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4542_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4542_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4542_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4543_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4543_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4543_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4544_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4544_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4544_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4545_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4545_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4545_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4546_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4546_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4546_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4547_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4547_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4547_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4548_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4548_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4548_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4551_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4551_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4551_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4552_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4552_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4552_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4555_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4555_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4555_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4557_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4557_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4557_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4558_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4558_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4558_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4559_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4559_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4559_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4560_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4560_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4560_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4561_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4561_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4561_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4562_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4563_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4563_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4563_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4564_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4564_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4564_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4565_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4565_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4565_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4567_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4567_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4567_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4568_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4568_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4568_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4569_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4569_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4569_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4570_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4570_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4570_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4573_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4573_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4573_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4575_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4575_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4575_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4576_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4577_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4577_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4577_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4578_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4578_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4579_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4579_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4579_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4580_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4580_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4582_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4582_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4583_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4583_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/4583_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/554_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/554_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/554_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/555_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/555_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/555_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/556_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/556_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/556_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/557_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/557_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/559_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/559_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/559_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/560_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/560_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/560_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/561_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/561_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/561_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/562_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/562_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/562_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/564_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/564_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/564_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/565_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/565_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/566_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/566_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/566_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/567_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/567_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/567_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/568_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/568_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/568_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/569_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/569_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/569_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/570_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/570_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/570_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/571_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/571_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/571_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/572_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/572_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/572_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/573_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/573_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/573_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/574_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/574_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/574_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/575_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/575_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/576_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/576_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/576_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/577_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/577_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/577_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/578_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/578_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/578_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/579_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/579_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/580_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/580_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/580_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/581_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/581_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/581_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/583_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/583_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/584_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/584_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/584_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/585_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/585_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/586_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/586_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/586_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/587_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/587_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/587_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/588_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/588_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/588_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/589_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/589_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/589_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6068_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6068_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6068_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6069_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6069_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6069_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6070_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6070_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6070_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6071_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6071_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6071_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6072_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6072_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6072_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6073_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6073_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6074_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6074_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6074_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6076_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6076_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6076_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6077_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6077_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6077_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6078_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6078_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6078_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6079_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6079_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6079_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6081_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6081_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6081_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6082_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6082_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6082_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6753_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6753_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6753_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6798_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6798_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6814_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6814_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6814_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6833_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6833_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6833_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6847_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6847_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6847_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6869_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6869_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6871_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/6871_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6893_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6893_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6893_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6901_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6901_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6901_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6956_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6956_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6956_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6980_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6980_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/6980_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7056_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7056_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7065_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7065_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7065_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7082_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7090_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7090_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7090_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7106_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7106_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7106_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7134_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7134_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7134_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7140_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7140_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7140_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7153_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7248_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7248_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7248_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7295_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7295_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7295_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7312_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7312_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7312_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/7415_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/7415_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/7415_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7420_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7420_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7420_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7459_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7459_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7463_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7463_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7463_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7472_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7472_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7472_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7474_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7474_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7474_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7480_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7480_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/749_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7500_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/750_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/750_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7525_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7525_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7525_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7530_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7530_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7535_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7535_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7535_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/753_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/753_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/753_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7547_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7547_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7547_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/754_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7550_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7550_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7550_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/755_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/755_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/755_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/757_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/757_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/757_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/758_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/758_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/758_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7598_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7598_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7598_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/759_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/760_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/760_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/760_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/7615_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7622_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7622_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/763_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/763_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/765_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/766_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/766_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/766_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7679_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7679_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/test/7679_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/925_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/926_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/926_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/926_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/929_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/929_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/929_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/930_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/930_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/930_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/932_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/932_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/932_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/933_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/933_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/934_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/934_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/934_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/941_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/941_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/941_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/942_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/945_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/945_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/946_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/946_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/946_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/955_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/955_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/959_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/959_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/959_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/960_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/960_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/960_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/961_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/961_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/962_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/962_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/962_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/964_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/964_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/964_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/969_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/973_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/976_b1 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/977_b3 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/982_b2 +/mnt/disk2/hachi/data/workdir/radish/hachi/OBJ_INS/phase2_V2/val/982_b3 diff --git a/val_2.txt b/val_2.txt new file mode 100644 index 0000000..cd3ad99 --- /dev/null +++ b/val_2.txt @@ -0,0 +1,1679 @@ +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2014_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2018_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2018_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2020_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2020_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2021_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2026_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2026_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2028_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2028_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2028_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2031_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2036_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2040_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2040_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2045_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2046_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2046_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2046_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2051_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2051_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2052_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2052_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2138_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2138_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2139_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2139_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2140_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2140_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2141_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2141_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2141_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2142_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2143_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2145_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2145_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2145_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2146_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2146_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2146_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2147_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2147_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2147_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2150_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2150_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2150_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2151_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2151_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2151_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2152_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2152_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2153_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2153_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2155_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2156_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2156_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2156_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2162_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2162_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2162_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2163_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2163_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2163_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2164_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2164_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2164_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2171_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2171_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2174_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2174_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2174_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2177_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2177_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2177_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2178_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2178_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2179_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2179_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2182_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2182_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2189_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2189_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2190_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2190_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2190_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2191_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2191_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2191_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2192_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2192_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2192_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2193_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2193_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2193_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2195_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2195_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2197_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2197_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2197_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2198_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2199_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2199_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2199_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2203_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2204_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2204_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2204_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2206_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2206_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2206_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2207_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2207_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2207_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2208_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2208_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2209_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2209_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2209_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2210_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2210_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2210_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2211_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2211_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2215_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2215_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2215_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2216_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2216_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2216_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2217_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2217_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2217_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2218_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2220_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2220_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2220_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2223_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2223_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2223_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2225_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2225_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2225_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2226_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2226_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2226_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2227_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2227_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2227_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2232_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2232_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2232_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2233_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2233_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2233_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2234_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2234_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2234_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2235_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2236_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2236_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2237_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2237_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2237_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2238_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2238_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2238_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2239_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2239_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2239_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2240_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2241_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2241_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2241_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2244_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2244_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2244_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2246_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2246_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2246_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2247_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2247_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2247_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2252_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2252_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2252_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2256_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2256_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2257_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2257_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2257_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2258_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2258_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2258_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2260_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2260_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2260_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2262_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2262_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2262_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2264_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2264_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2264_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2265_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2265_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2265_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2267_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2267_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2267_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2268_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2268_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2268_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2269_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2269_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2269_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2270_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2270_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2270_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2271_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2271_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2272_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2272_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2274_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2274_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2274_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2275_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2276_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2276_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2276_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2277_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2277_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2277_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2279_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2279_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2279_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2280_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2281_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2281_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2281_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2284_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2284_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2284_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2285_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2285_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2285_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2286_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2286_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2286_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2288_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/285_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/285_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/285_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/286_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/286_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/286_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/287_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/287_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/288_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/288_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/288_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/289_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/290_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/290_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2913_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2918_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2921_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2923_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2928_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/292_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/292_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/292_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2931_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2938_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/293_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2941_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2945_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2946_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2946_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2951_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2951_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/295_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/295_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/297_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/297_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/297_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/298_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/299_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/299_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/300_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/300_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/301_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/302_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/302_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/302_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/305_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/305_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/306_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/306_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/308_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/308_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/308_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/309_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/309_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/310_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3112_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3112_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3112_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/311_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/311_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/312_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/313_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/313_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3153_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3153_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3155_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3155_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3157_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3159_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3159_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3159_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/315_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/315_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/315_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3160_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/316_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/316_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/316_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/319_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/319_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/320_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/320_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/320_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/321_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/321_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/321_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/322_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/324_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/325_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/325_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3268_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/326_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/326_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3270_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3270_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3271_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3271_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3271_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3276_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3278_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3278_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3279_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3279_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/327_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/327_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3281_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3281_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3282_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3283_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3285_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3285_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/329_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/329_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/329_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3309_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/330_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/330_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/330_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3311_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3317_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3317_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3317_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/331_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3324_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3324_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3324_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3326_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/332_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/332_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3333_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3333_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/334_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/334_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/334_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/335_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/335_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/335_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/336_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/337_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/337_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/339_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/340_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/340_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/340_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/341_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3424_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3424_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/342_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/342_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/343_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/343_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/345_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/345_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/345_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/346_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/346_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/346_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/347_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3493_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3493_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3493_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3494_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3494_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3495_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3495_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3495_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3496_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3498_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3498_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3499_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3499_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3499_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3500_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3500_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3500_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/350_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/350_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/351_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/351_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3643_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3644_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3645_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3646_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3647_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3649_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3649_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3649_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3650_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3650_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3651_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3653_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3655_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3655_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3657_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3657_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3657_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3658_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3658_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3658_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3659_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3659_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3693_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3693_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3693_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3694_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3694_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3694_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3695_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3695_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3695_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3696_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3696_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3698_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3698_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3698_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4063_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4063_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4063_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4065_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4065_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4066_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4066_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4066_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4068_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4068_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4068_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4070_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4072_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4072_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4072_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4074_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4074_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4074_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4078_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4078_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4083_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4083_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4086_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4086_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4086_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4089_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4110_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4111_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4112_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4112_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4112_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4114_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4114_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4115_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4115_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4116_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4116_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4118_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4118_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4118_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4122_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4122_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4122_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4123_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4123_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4170_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4173_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4173_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4173_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4174_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4174_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4174_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4175_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4175_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4175_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4284_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4284_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4288_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4288_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4289_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4289_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4289_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4290_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4292_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4292_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4297_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4298_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4298_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4298_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4302_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4302_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4302_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4304_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4304_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4305_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4407_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4408_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4408_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4409_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4409_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4409_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4412_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4412_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4417_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4421_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4423_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4423_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4423_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4492_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4492_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4492_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4493_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4493_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4494_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4495_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4496_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4498_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4498_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4498_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4499_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4499_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4499_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4500_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4500_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4500_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4501_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4875_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4876_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4876_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4876_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4877_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4877_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4877_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4878_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4878_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4879_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4879_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4880_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4880_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4880_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4881_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4881_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4881_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4883_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4884_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4884_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4884_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4885_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4885_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4885_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4886_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4886_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4886_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4888_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4888_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4888_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4889_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4890_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4890_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4890_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4891_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4891_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4891_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4892_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4893_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4893_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4893_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4894_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4895_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4895_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4896_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4896_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4896_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4898_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4898_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4898_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4900_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4900_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4900_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4901_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4901_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4903_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4903_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4904_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4909_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4909_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4909_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4910_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4910_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4913_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4913_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4915_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4915_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4915_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4917_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4917_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4918_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4920_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4920_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4921_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4922_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4922_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4922_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4923_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4923_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4923_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4925_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4925_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4926_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4926_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4926_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4927_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4927_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4927_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4928_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4930_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4930_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4931_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4931_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4934_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4934_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4935_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4935_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4938_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4939_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4939_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4940_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4940_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4940_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4942_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4946_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4946_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4948_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4948_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4948_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4950_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4950_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4954_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4954_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4954_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4956_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4957_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4959_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4960_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4960_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4960_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4962_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4965_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4965_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4965_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4966_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4966_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4966_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4967_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4967_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4967_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4970_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/4970_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5141_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5141_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5143_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5144_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5145_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5145_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5145_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5147_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5147_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5148_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5148_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5148_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5357_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5357_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5358_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5358_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5361_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5363_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5364_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5364_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5364_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5369_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5369_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5371_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5371_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5373_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5374_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5375_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5375_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5375_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5377_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5377_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5377_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5378_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5379_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5381_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5381_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5381_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5382_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5382_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5382_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5383_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5383_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5383_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5385_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5385_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5385_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5386_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5387_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5387_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5387_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5388_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5388_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5388_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5390_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5391_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5391_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5391_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5458_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5461_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5503_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5503_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5509_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5512_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5562_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5562_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5562_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5564_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5564_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5564_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5565_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5565_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5565_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5568_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5571_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5571_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5571_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5572_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5573_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5573_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5573_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5575_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5575_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5575_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5576_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5576_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5577_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5577_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5581_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5581_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5581_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5583_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5583_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5583_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5584_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5585_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5585_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5585_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5587_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5587_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5587_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5588_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5590_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5590_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5590_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5591_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5591_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5593_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5593_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5593_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5594_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5594_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5594_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5595_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5595_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5595_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5596_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5596_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5596_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5598_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5598_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5598_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5601_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5601_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5601_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5602_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5602_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5602_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5791_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5791_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5791_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5792_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5792_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5792_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5793_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5793_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5793_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5794_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5794_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5794_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5796_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5796_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5797_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5797_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5797_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5799_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5799_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5799_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5800_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5800_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5800_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5802_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5802_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5802_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5803_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5803_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5803_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5805_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5805_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5805_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5806_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5808_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5808_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5808_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5809_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5809_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5809_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5811_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5811_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5811_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5812_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5812_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5812_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5813_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5813_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5813_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5815_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5816_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5817_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5817_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5817_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5818_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5818_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5818_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5820_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5820_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5820_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5821_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5821_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5821_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5823_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5824_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5824_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5825_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5825_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5826_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5826_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5827_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5827_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5827_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5828_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5828_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5830_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5830_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5830_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5831_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5831_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5832_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5833_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5833_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5834_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5834_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5834_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5835_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5835_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5835_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5836_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5836_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5836_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5837_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5837_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5837_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5838_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5838_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5839_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5839_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5839_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5841_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5841_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5842_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5842_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5842_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5843_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5843_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5843_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5844_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5844_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5844_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5845_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5845_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5845_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5846_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5846_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5846_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5847_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5847_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5847_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5848_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5850_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5850_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5850_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5851_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5851_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5852_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5852_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5852_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5853_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5854_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5918_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5919_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5919_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5919_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5920_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5920_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5920_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5923_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5923_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5925_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5925_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5925_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5927_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5927_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5927_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5930_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5930_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5930_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5931_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5931_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5931_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5934_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5934_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5935_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5935_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5935_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5937_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5937_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5937_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5939_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5939_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5939_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5941_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5941_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5941_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5942_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5942_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/5942_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6240_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6240_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6242_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6242_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6244_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6244_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6246_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6246_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6246_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6249_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6249_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6250_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6250_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6251_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6251_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6251_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6253_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6254_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6254_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6254_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6255_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6256_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6256_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6256_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6258_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6258_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6258_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6259_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6259_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6259_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6262_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6262_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6262_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6263_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6263_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6263_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6265_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6265_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6265_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6267_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6267_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6272_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6272_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6272_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6273_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6273_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6273_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6274_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6274_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6275_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6275_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6275_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6276_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6277_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6277_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6277_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6279_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6279_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6279_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6282_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6283_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6283_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6284_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6284_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6284_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6285_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6285_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6285_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6650_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6650_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6650_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6651_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6652_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6652_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6652_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6710_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6732_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6733_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6733_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6733_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6743_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6756_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6756_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6756_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6771_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6804_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6813_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6823_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6827_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/682_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6839_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6839_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6852_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6859_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6859_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/685_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6879_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6879_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6904_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6904_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6904_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/692_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/692_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/692_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/693_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/693_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/693_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6943_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6960_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6960_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6962_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6962_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6962_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6965_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/697_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/697_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/697_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7027_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7027_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/702_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/702_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/702_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/703_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/703_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/704_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/704_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/704_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/705_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7076_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7096_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7096_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/710_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7117_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/711_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/711_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/712_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/712_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/713_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/713_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/713_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7146_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7146_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/714_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/714_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/714_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7175_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7175_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7175_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7176_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7176_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7176_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7192_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7192_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/719_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/719_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7205_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7205_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7262_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7262_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7262_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7277_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7277_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7277_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7341_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7398_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7438_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7438_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7493_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7493_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7493_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7506_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7506_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7506_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7514_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7520_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7527_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7527_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7527_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7542_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7567_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7573_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7573_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7573_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7605_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7617_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7617_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7617_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7627_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7643_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7643_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7650_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7650_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7650_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7689_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7689_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7689_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7709_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7709_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/910_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/985_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/989_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/989_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/989_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/993_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/993_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/993_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/995_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/995_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/995_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/996_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/996_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/998_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/999_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/999_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/999_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1050_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1050_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1061_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1061_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1873_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1873_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1874_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1881_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1881_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1881_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1884_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1884_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1884_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1886_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1887_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1887_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1887_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1888_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1888_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1888_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/1889_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2607_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2607_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2613_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2614_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2614_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2615_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2615_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2615_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/2_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3339_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3339_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3339_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/3342_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4529_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4529_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4529_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4530_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4530_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4530_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4532_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4532_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4532_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4533_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4533_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4533_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4534_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4534_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4534_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4535_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4535_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4535_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4536_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4536_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4536_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4537_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4537_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4537_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4538_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4538_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4538_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4539_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4539_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4539_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4540_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4540_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4540_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4541_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4541_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4542_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4542_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4542_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4543_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4543_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4543_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4544_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4544_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4544_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4545_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4545_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4545_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4546_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4546_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4546_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4547_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4547_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4547_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4548_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4548_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4548_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4551_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4551_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4551_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4552_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4552_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4552_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4555_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4555_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4555_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4557_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4557_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4557_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4558_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4558_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4558_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4559_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4559_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4559_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4560_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4560_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4560_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4561_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4561_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4561_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4562_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4563_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4563_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4563_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4564_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4564_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4564_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4565_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4565_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4565_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4567_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4567_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4567_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4568_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4568_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4568_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4569_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4569_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4569_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4570_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4570_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4570_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4573_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4573_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4573_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4575_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4575_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4575_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4576_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4577_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4577_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4577_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4578_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4578_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4579_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4579_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4579_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4580_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4580_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4582_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4582_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4583_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4583_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/4583_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/554_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/554_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/554_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/555_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/555_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/555_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/556_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/556_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/556_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/557_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/557_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/559_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/559_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/559_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/560_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/560_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/560_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/561_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/561_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/561_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/562_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/562_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/562_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/564_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/564_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/564_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/565_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/565_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/566_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/566_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/566_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/567_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/567_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/567_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/568_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/568_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/568_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/569_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/569_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/569_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/570_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/570_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/570_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/571_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/571_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/571_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/572_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/572_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/572_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/573_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/573_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/573_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/574_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/574_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/574_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/575_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/575_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/576_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/576_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/576_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/577_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/577_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/577_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/578_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/578_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/578_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/579_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/579_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/580_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/580_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/580_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/581_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/581_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/581_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/583_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/583_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/584_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/584_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/584_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/585_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/585_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/586_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/586_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/586_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/587_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/587_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/587_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/588_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/588_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/588_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/589_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/589_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/589_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6068_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6068_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6068_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6069_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6069_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6069_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6070_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6070_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6070_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6071_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6071_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6071_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6072_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6072_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6072_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6073_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6073_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6074_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6074_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6074_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6076_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6076_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6076_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6077_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6077_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6077_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6078_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6078_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6078_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6079_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6079_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6079_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6081_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6081_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6081_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6082_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6082_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6082_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6753_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6753_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6753_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6798_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6798_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6814_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6814_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6814_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6833_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6833_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6833_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6847_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6847_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6847_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6869_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6869_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6871_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/6871_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6893_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6893_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6893_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6901_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6901_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6901_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6956_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6956_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6956_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6980_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6980_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/6980_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7056_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7056_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7065_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7065_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7065_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7082_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7090_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7090_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7090_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7106_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7106_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7106_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7134_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7134_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7134_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7140_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7140_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7140_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7153_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7248_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7248_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7248_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7295_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7295_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7295_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7312_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7312_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7312_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/7415_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/7415_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/7415_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7420_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7420_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7420_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7459_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7459_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7463_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7463_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7463_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7472_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7472_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7472_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7474_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7474_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7474_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7480_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7480_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/749_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7500_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/750_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/750_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7525_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7525_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7525_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7530_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7530_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7535_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7535_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7535_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/753_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/753_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/753_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7547_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7547_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7547_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/754_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7550_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7550_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7550_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/755_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/755_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/755_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/757_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/757_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/757_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/758_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/758_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/758_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7598_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7598_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7598_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/759_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/760_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/760_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/760_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/7615_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7622_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7622_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/763_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/763_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/765_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/766_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/766_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/766_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7679_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7679_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/test/7679_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/925_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/926_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/926_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/926_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/929_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/929_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/929_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/930_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/930_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/930_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/932_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/932_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/932_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/933_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/933_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/934_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/934_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/934_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/941_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/941_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/941_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/942_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/945_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/945_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/946_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/946_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/946_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/955_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/955_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/959_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/959_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/959_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/960_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/960_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/960_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/961_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/961_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/962_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/962_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/962_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/964_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/964_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/964_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/969_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/973_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/976_b1 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/977_b3 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/982_b2 +/mnt/disk1/aiotlab/hachi/data/OBJ_INS_FSC/val/982_b3