Upload folder using huggingface_hub

llamagen-siglip-sb-block-causal/SelftokPipeline/.gitignore

@@ -0,0 +1 @@
+__pycache__

llamagen-siglip-sb-block-causal/SelftokPipeline/README.md

@@ -0,0 +1,163 @@
+# SelftokPipeline
+
+This repository provides an inference pipeline for **Selftok**, a tokenizer and renderer framework for image generation. It consists of three primary components:
+
+1. **Tokenization**: Convert images into discrete tokens.
+2. **Diffusion Decoding**: Reconstruct images from tokens using a 50-step diffusion model.
+3. **One-step Decoding**: Reconstruct images using a fast, one-step renderer.
+
+---
+
+```
+git clone ssh://git@kwe-y.codehub.huawei.com:2222/p84402465/SelftokPipeline.git
+cd ./SelftokPipeline
+```
+
+## Model Config and checkpoint address
+
+### AB66
+
+**Base:**
+
+- yml: /configs/res256/256_AB66-eval.yml
+- checkpoint: s3://bucket-5125-guiyang/outputs/l50043800/selftok/256-32768_AB66/2025-03-05_time_1942/output/ckpt/iter_182999.pth
+
+**Renderer:**
+
+- yml: /configs/renderer/renderer-AB66-data-eval.yml
+- checkpoint: s3://bucket-5125-guiyang/outputs/l50043800/selftok/selftok256-renderer-GAN-AB66-512tokens_rFID/2025-04-16_time_2129/output/ckpt/iter_318999.pth
+
+
+### E31 
+
+**Base:**
+
+- yml: /configs/res512/selftok_sd3_E31-512_modified.yml
+- checkpoint: s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31/2025-05-06_time_2230/output/ckpt/iter_237999.pth
+
+**Renderer:**
+- yml: /configs/renderer/selftok_sd3_E31-512_renderer.yml (2B)
+- yml: /configs/renderer/selftok_sd35_E31-512_renderer_8b.yml (8B)
+- checkpoint: s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31-renderer-GAN/2025-05-13_time_1708/output/ckpt/iter_331999.pth (2B)
+- checkpoint: s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31-renderer-GAN-large/2025-05-19_time_2056/output/ckpt/iter_347999.pth
+
+## 1. Tokenization
+
+This script demonstrates how to convert images into token sequences using a pretrained Selftok model.
+
+```python
+import argparse
+from mimogpt.engine.utils import parse_args_from_yaml
+from torchvision import transforms
+from PIL import Image
+import torch
+import numpy as np
+from mimogpt.infer.SelftokPipeline import SelftokPipeline
+from mimogpt.infer.SelftokPipeline import NormalizeToTensor
+from torchvision.utils import save_image
+
+parser = argparse.ArgumentParser()
+# parser.add_argument("--yml-path", type=str, default="path/to/your/config.yml")
+# parser.add_argument("--pretrained", type=str, default="path/to/your/ckpt.pth")
+parser.add_argument("--yml-path", type=str, default="./configs/res512/selftok_sd3_E31-512_modified.yml")
+parser.add_argument("--pretrained", type=str, default="s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31/2025-05-06_time_2230/output/ckpt/iter_237999.pth")
+parser.add_argument("--data_size", type=int, default=512)
+
+cfg = parse_args_from_yaml(args.yml_path)
+model = SelftokPipeline(cfg=cfg, ckpt_path=args.pretrained, datasize=args.data_size, device='cuda')
+
+img_transform = transforms.Compose([
+    transforms.Resize(args.data_size),
+    transforms.CenterCrop(args.data_size),
+    NormalizeToTensor(),
+])
+
+image_paths = ['path/to/image1.png', 'path/to/image2.png']
+images = [img_transform(Image.open(p)) for p in image_paths]
+images = torch.stack(images).to('cuda')
+
+tokens = model.encoding(images, device='cuda')
+np.save('token.npy', tokens.detach().cpu().numpy())
+```
+
+---
+
+## 2. Diffusion Decoding
+
+Reconstruct images from token sequences using the full diffusion model (50 steps):
+
+```python
+import argparse
+from mimogpt.engine.utils import parse_args_from_yaml
+from torchvision import transforms
+from PIL import Image
+import torch
+import numpy as np
+from mimogpt.infer.SelftokPipeline import SelftokPipeline
+from mimogpt.infer.SelftokPipeline import NormalizeToTensor
+from torchvision.utils import save_image
+
+parser = argparse.ArgumentParser()
+# parser.add_argument("--yml-path", type=str, default="path/to/your/config.yml")
+# parser.add_argument("--pretrained", type=str, default="path/to/your/ckpt.pth")
+parser.add_argument("--yml-path", type=str, default="./configs/res512/selftok_sd3_E31-512_modified.yml")
+parser.add_argument("--pretrained", type=str, default="s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31/2025-05-06_time_2230/output/ckpt/iter_237999.pth")
+parser.add_argument("--data_size", type=int, default=512)
+
+cfg = parse_args_from_yaml(args.yml_path)
+model = SelftokPipeline(cfg=cfg, ckpt_path=args.pretrained, datasize=args.data_size, device='cuda')
+
+tokens = np.load('token.npy')
+images = model.decoding(tokens, device='cuda')
+
+for b, img in enumerate(images):
+    save_image(img, f"re_{b}.png")
+```
+
+---
+
+## 3. One-step Renderer Decoding
+
+Reconstruct images using a fast, one-step renderer:
+
+```python
+import argparse
+from mimogpt.engine.utils import parse_args_from_yaml
+from torchvision import transforms
+from PIL import Image
+import torch
+import numpy as np
+from mimogpt.infer.SelftokPipeline import SelftokPipeline
+from mimogpt.infer.SelftokPipeline import NormalizeToTensor
+from torchvision.utils import save_image
+
+parser = argparse.ArgumentParser()
+## yml and checkpoint path for 2B model 
+parser.add_argument("--yml-path", type=str, default="./configs/renderer/selftok_sd3_E31-512_renderer.yml")
+parser.add_argument("--pretrained", type=str, default="s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31-renderer-GAN/2025-05-13_time_1708/output/ckpt/iter_301999.pth")
+
+## yml and checkpoint path for 8B model, NPU memory cost is around 45G for bs=2
+
+# parser.add_argument("--yml-path", type=str, default="/home/ma-user/work/p84402465/SelftokPipeline_old_v2/configs/renderer/selftok_sd35_E31-512_renderer_8b.yml")
+# parser.add_argument("--pretrained", type=str, default="s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31-renderer-GAN-large/2025-05-19_time_2056/output/ckpt/iter_347999.pth")
+
+parser.add_argument("--data_size", type=int, default=512)
+
+cfg = parse_args_from_yaml(args.yml_path)
+model = SelftokPipeline(cfg=cfg, ckpt_path=args.pretrained, datasize=args.data_size, device='cuda')
+
+tokens = np.load('token.npy')
+images = model.decoding_with_renderer(tokens, device='cuda')
+
+for b, img in enumerate(images):
+    save_image(img, f"render_{b}.png")
+```
+
+---
+
+## Notes
+
+* Replace all `path/to/...` with actual paths on your system or object storage.
+* The scripts assume CUDA is available; modify `device='cuda'` to `'cpu'` if running on CPU.
+
+

llamagen-siglip-sb-block-causal/SelftokPipeline/configs/renderer/renderer-AB66-data-eval.yml

@@ -0,0 +1,180 @@
+common:
+    output_path: 'output'
+    log_path: '/cache/logs'
+    tb_path: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    val_url: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    alex_path: '/cache/data/alexnet-owt-7be5be79.pth'
+    save_per_epochs: 1.0
+    eval_per_epochs: 1.0
+    eval_first: 0
+    use_fp16: 0
+    use_bf16: 1
+    use_zero: 0
+    use_fsdp: 0
+    use_2d_rope: 0
+    use_deepspeed: 0
+    random_seed: 123
+    log_interval: 50
+    machines: 1
+    task: 'selftokenc'
+    experiment_index: 0
+    delete_after_upload: True
+    log_recon_interval: 100
+    val_interval: 0
+    ckpt_interval: 1000
+    vae_path: '/cache/data/sd3_medium.ckpt'
+    resume_exclude_opt: True
+    pre_encode: False
+    resume_from_steps: 0
+    is_eval: True
+
+model:
+    pretrain_model: '/cache/model/iter_149999.pth'
+    fix_encoder: True
+    full_tokens: True
+    fix_decoder: False
+
+optimize:
+    max_epochs: 10000
+    warmup_epochs: 0.01
+    ema_in_cpu: False
+    grad_norm: 0.0
+    set_lpips_loss: True
+    perceptual_weight: 0.1
+    lr_scheduler:
+        dit_lr: 5.0e-5
+        token_lr: 5.0e-5
+        init_lr: 1.0e-4
+        init_step1: 5000
+        init_step2: 50000
+        max_step: 100000
+        min_lr1: 1.0e-4
+        min_lr2: 1.0e-4
+
+tokenizer:
+    is_text_tokenized: False
+    pretrained_dit_path: '/cache/data/sd3_medium.ckpt'
+    params:
+        image_size: 256
+        k: 512
+        # stages: '600,800,1000'
+        # k_per_stage: '450,50,12'
+        # stages: '100,400,600,1000'
+        # k_per_stage: '120,300,48,12'
+        # stages: '100,400,600,1000'
+        # k_per_stage: '128,320,51,13'
+        stages: '1000'
+        k_per_stage: '512'
+        # k_m: 0.0
+        # k_s: 1.0
+        gradient_checkpointing: False
+        in_channels: 16
+        encoder_hidden_size: 16
+        ema_enc: False
+        enc_decay: 0.99
+        L2_lr: 0.
+        two_part_losses: False
+        
+        diffusion_type: 'flow'
+        noise_schedule_config:
+            schedule: 'log_norm'
+            parameterization: 'velocity'
+            force_recon: False
+            m: 0.0
+            s: 1.0
+        
+        enc: 'Enc-Qformer-Uni-XL/2'
+        enable_enc_variable_size: True
+        encoder_config:
+            time_adaln: True
+            qformer_mode: 'dual'
+            pre_norm: False
+            post_norm: True
+            xavier_init: False
+            qk_norm: False
+            attn_mask: False
+            
+        quantizer_config:
+            codebook_size: 32768
+            code_dim: 16
+            w_diversity: 1.0
+            ema_entropy_ratio: 0.8
+            w_commit: 1.0
+            decay: 0.99
+            dead_code_threshold: 0.2
+            reset_cluster_size: 0.2
+            smart_react: True
+            continuous: False
+            reg: [0.1, 0.3]
+            K: 512
+
+        model: 'MMDiT_XL_Renderer'
+        decoder_config:
+            repeat: True
+            sd3_cond_pooling: None
+            class_dropout_prob: 0.
+            train_filter: 'all'
+            freeze_filter: ''
+            # qk_norm: 'rms'
+            init_method: None
+            #register_length: 8
+            time_adaln: 'pos_emb'
+        
+data:   # except those with comments, other fields are useless for tokenizer training
+    batch_size: 12
+    num_workers: 8
+    checker:
+        status: disable
+        anchor_path: checkings/A100_bla
+        check_iter: 20
+        save_check: False
+        master_only: False
+        load_keys:
+            - image
+            - prompt
+            - timesteps
+            - noise
+
+    data_checker:
+        status: disable
+        save_prob: 0.1
+        save_amount: 10
+        save_path: data/precision/result
+        master_only: False
+
+    dataset:
+        target: base.Base
+        # meta_info: configs_t2i/data/selftok_ocr_debug.yml
+        # meta_info: configs_t2i/data/selftok_hucai_debug.yml
+        # meta_info: configs_t2i/data/selftok_256_debug.yml
+        meta_info: configs_t2i/data/selftok_imagenet_hucai_ocr.yml
+        # meta_info: configs_t2i/data/selftok_imagenet.yml
+        enlarge_ratio: 1                        # N epochs
+        max_size: 256                           # max resolution
+        resize_f: 16
+        filter_max_token_len: 128
+        load_t5_cache: False
+        prompt_augmentation: True
+        preprocess_func: center_crop            # augmentation
+        sync_wait_time: 1                       # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        sync_wait_ratio: 1                      # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        
+
+cloud_copy:
+    # - url: s3://bucket-5125-guiyang/data/AIGC/RAW_DATA/imagenet_untar/
+    #   dst: /cache/data/imagenet/
+    - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA/D2/INIT_PARQUET/imagenet_untar/
+      dst: /cache/data/imagenet_untar/imagenet_untar_parquet/
+    - url: s3://bucket-5125-guiyang/data/z84399568/ocr-height_width_ratio_0.9_1.1/parquet_filter_ratio_512_20250303182106/
+      dst: /cache/data/ocr/ocr_parquet/
+    - url: s3://bucket-5125-guiyang/data/z84399568/hucai-face_filter/parquet_part_center_crop_contain_full_face_1p2_20250304195907/
+      dst: /cache/data/hucai/hucai_parquet/
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/mimo/DiT/DiT-XL-2-256x256.pt
+      dst: /cache/data/DiT-XL-2-256x256.pt
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/selftok/alexnet-owt-7be5be79.pth
+      dst: /cache/data/alexnet-owt-7be5be79.pth
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/sd3/transformer/sd3_medium.ckpt
+      dst: /cache/data/sd3_medium.ckpt
+    - url: s3://bucket-5125-guiyang/outputs/l50043800/selftok/256-32768_AB66/2025-03-05_time_1942/output/ckpt/iter_149999.pth
+      dst: /cache/model/iter_149999.pth
+    

llamagen-siglip-sb-block-causal/SelftokPipeline/configs/renderer/selftok_sd35_E31-512_renderer_8b.yml

@@ -0,0 +1,167 @@
+common:
+    output_path: 'output'
+    log_path: '/cache/logs'
+    tb_path: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    val_url: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    alex_path: '/cache/data/alexnet-owt-7be5be79.pth'
+    save_per_epochs: 1.0
+    eval_per_epochs: 1.0
+    eval_first: 0
+    use_fp16: 0
+    use_bf16: 1
+    use_zero: 0
+    use_fsdp: 1
+    use_2d_rope: 0
+    use_deepspeed: 0
+    random_seed: 123
+    log_interval: 50
+    machines: 1
+    task: 'selftokenc'
+    experiment_index: 0
+    delete_after_upload: True
+    log_recon_interval: 100
+    val_interval: 0
+    ckpt_interval: 2000
+    vae_path: '/cache/data/sd3_medium.ckpt'
+    # vae_path: '/cache/model/sd3.5_large.ckpt'
+    resume_exclude_opt: True
+    pre_encode: False
+    resume_from_steps: 0
+    is_eval: True
+
+model:
+    pretrain_model: '/cache/model/iter_237999.pth'
+    fix_encoder: True
+    full_tokens: True
+    fix_decoder: False
+
+optimize:
+    max_epochs: 10000
+    warmup_epochs: 0.01
+    ema_in_cpu: False
+    grad_norm: 0.0
+    set_lpips_loss: True
+    perceptual_weight: 0.1
+    lr_scheduler:
+        dit_lr: 5.0e-5
+        token_lr: 5.0e-5
+        init_lr: 1.0e-4
+        init_step1: 5000
+        init_step2: 50000
+        max_step: 100000
+        min_lr1: 1.0e-4
+        min_lr2: 1.0e-4
+
+tokenizer:
+    is_text_tokenized: False
+    pretrained_dit_path: '/cache/data/sd3.5_large.ckpt'
+    params:
+        image_size: 512
+        k: 1536
+        stages: '200,400,600,800,1000'
+        k_per_stage: '512,512,256,192,64'
+        # k_m: 0.0
+        # k_s: 1.0
+        gradient_checkpointing: False
+        in_channels: 16
+        encoder_hidden_size: 16
+        ema_enc: False
+        enc_decay: 0.99
+        L2_lr: 0.
+        two_part_losses: False
+        
+        diffusion_type: 'flow'
+        noise_schedule_config:
+            schedule: 'log_norm'
+            parameterization: 'velocity'
+            force_recon: False
+            m: 0.0
+            s: 1.0
+        
+        enc: 'Enc-Qformer-Uni-XL/2'
+        enable_enc_variable_size: True
+        encoder_config:
+            time_adaln: True
+            qformer_mode: 'dual'
+            pre_norm: False
+            post_norm: True
+            xavier_init: False
+            qk_norm: False
+            attn_mask: False
+
+        quantizer_config:
+            codebook_size: 16384
+            code_dim: 32
+            w_diversity: 1.0
+            ema_entropy_ratio: 0.8
+            w_commit: 1.0
+            decay: 0.99
+            dead_code_threshold: 0.2
+            reset_cluster_size: 0.2
+            smart_react: True
+            continuous: False
+            reg: [0.1, 0.3]
+            K: 1536
+
+        model: 'MMDiT_XXL_Renderer'
+        decoder_config:
+            sd3_cond_pooling: None
+            class_dropout_prob: 0.1
+            train_filter: 'all'
+            freeze_filter: ''
+            qk_norm: 'rms'
+            init_method: None
+            #register_length: 8
+            time_adaln: 'pos_emb'
+        
+data:   # except those with comments, other fields are useless for tokenizer training
+    batch_size: 4
+    num_workers: 8
+    checker:
+        status: disable
+        anchor_path: checkings/A100_bla
+        check_iter: 20
+        save_check: False
+        master_only: False
+        load_keys:
+            - image
+            - prompt
+            - timesteps
+            - noise
+
+    data_checker:
+        status: disable
+        save_prob: 0.1
+        save_amount: 10
+        save_path: data/precision/result
+        master_only: False
+
+    dataset:
+        target: base.Base
+        meta_info: configs_t2i/data/selftok_512_renderer.yml
+        enlarge_ratio: 1000                     # N epochs
+        max_size: 512                           # max resolution
+        resize_f: 16
+        filter_max_token_len: 128
+        load_t5_cache: False
+        prompt_augmentation: True
+        preprocess_func: center_crop            # augmentation
+        sync_wait_time: 1                       # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        sync_wait_ratio: 1                      # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        
+
+cloud_copy:
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/selftok/alexnet-owt-7be5be79.pth
+      dst: /cache/data/alexnet-owt-7be5be79.pth
+    - url: s3://bucket-5125-guiyang/data/z84399568/model/sd3.5_large.ckpt
+      dst: /cache/data/sd3.5_large.ckpt
+    - url: s3://bucket-5125-guiyang/code/z84378256/rFID/fid_ckpt/inception-2015-12-05.pt
+      dst: /cache/model/fid_ckpt/inception-2015-12-05.pt
+    - url: s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31/2025-05-06_time_2230/output/ckpt/iter_237999.pth
+      dst: /cache/model/iter_237999.pth
+    - url: s3://bucket-5125-guiyang/data/z84399568/OpenImage/parquet/parquet_part0-512_20241024171323/
+      dst: /cache/data/openimage/openimage_parquet/
+    - url: s3://bucket-5125-guiyang/data/z84399568/ocr-height_width_ratio_0.9_1.1/parquet_filter_ratio_512_20250303182106/
+      dst: /cache/data/ocr/ocr_parquet/
+    - url: s3://bucket-5125-guiyang/data/z84399568/hucai-face_filter/parquet_part_center_crop_contain_full_face_1p2_20250304195907/
+      dst: /cache/data/hucai/hucai_parquet/

llamagen-siglip-sb-block-causal/SelftokPipeline/configs/renderer/selftok_sd3_E31-512_renderer.yml

@@ -0,0 +1,167 @@
+common:
+    output_path: 'output'
+    log_path: '/cache/logs'
+    tb_path: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    val_url: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    alex_path: '/cache/data/alexnet-owt-7be5be79.pth'
+    save_per_epochs: 1.0
+    eval_per_epochs: 1.0
+    eval_first: 0
+    use_fp16: 0
+    use_bf16: 1
+    use_zero: 0
+    use_fsdp: 0
+    use_2d_rope: 0
+    use_deepspeed: 0
+    random_seed: 123
+    log_interval: 50
+    machines: 1
+    task: 'selftokenc'
+    experiment_index: 0
+    delete_after_upload: True
+    log_recon_interval: 100
+    val_interval: 0
+    ckpt_interval: 2000
+    vae_path: '/cache/data/sd3_medium.ckpt'
+    resume_exclude_opt: True
+    pre_encode: False
+    resume_from_steps: 0
+    is_eval: True
+
+model:
+    pretrain_model: '/cache/data/iter_69999.pth'
+
+optimize:
+    max_epochs: 1000
+    warmup_epochs: 0.01
+    ema_in_cpu: False
+    grad_norm: 0.0
+    lr_scheduler:
+        dit_lr: 2.0e-5
+        token_lr: 1.0e-4
+        init_lr: 1.0e-4
+        init_step1: 5000
+        init_step2: 50000
+        max_step: 100000
+        min_lr1: 1.0e-4
+        min_lr2: 1.0e-4
+
+tokenizer:
+    is_text_tokenized: False
+    pretrained_dit_path: '/cache/data/sd3_medium.ckpt'
+    params:
+        image_size: 512
+        k: 1536
+        stages: '200,400,600,800,1000'
+        k_per_stage: '512,512,256,192,64'
+        # k_m: 0.0
+        # k_s: 1.0
+        gradient_checkpointing: False
+        in_channels: 16
+        encoder_hidden_size: 16
+        ema_enc: False
+        enc_decay: 0.99
+        L2_lr: 0.
+        two_part_losses: False
+        
+        diffusion_type: 'flow'
+        noise_schedule_config:
+            schedule: 'log_norm'
+            parameterization: 'velocity'
+            force_recon: False
+            m: 0.0
+            s: 1.0
+        
+        enc: 'Enc-Qformer-Uni-XL/2'
+        enable_enc_variable_size: True
+        encoder_config:
+            time_adaln: True
+            qformer_mode: 'dual'
+            pre_norm: False
+            post_norm: True
+            xavier_init: False
+            qk_norm: False
+            attn_mask: False
+
+        quantizer_config:
+            codebook_size: 16384
+            code_dim: 32
+            w_diversity: 1.0
+            ema_entropy_ratio: 0.8
+            w_commit: 1.0
+            decay: 0.99
+            dead_code_threshold: 0.2
+            reset_cluster_size: 0.2
+            smart_react: True
+            # redistribute: False
+            continuous: False
+            reg: [0.1, 0.3]
+            K: 1536
+            # share: True
+
+        model: 'MMDiT_XL_Renderer'
+        context_see_xt: True
+        decoder_config:
+            repeat: False
+            sd3_cond_pooling: None
+            class_dropout_prob: 0.1
+            train_filter: 'all'
+            freeze_filter: ''
+            # qk_norm: 'rms'
+            init_method: None
+            #register_length: 8
+            time_adaln: 'pos_emb'
+
+data:   # except those with comments, other fields are useless for tokenizer training
+    batch_size: 8
+    num_workers: 8
+    checker:
+        status: disable
+        anchor_path: checkings/A100_bla
+        check_iter: 20
+        save_check: False
+        master_only: False
+        load_keys:
+            - image
+            - prompt
+            - timesteps
+            - noise
+
+    data_checker:
+        status: disable
+        save_prob: 0.1
+        save_amount: 10
+        save_path: data/precision/result
+        master_only: False
+
+    dataset:
+        target: base.Base
+        meta_info: configs_t2i/data/selftok_openimage.yml
+        enlarge_ratio: 1000                     # N epochs
+        max_size: 512                           # max resolution
+        resize_f: 16
+        filter_max_token_len: 128
+        load_t5_cache: False
+        prompt_augmentation: True
+        preprocess_func: center_crop            # augmentation
+        sync_wait_time: 1                       # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        sync_wait_ratio: 1                      # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        
+
+cloud_copy:
+    # - url: s3://bucket-5125-guiyang/misc/MGM/models/mimo/DiT/DiT-XL-2-256x256.pt
+    #   dst: /cache/data/DiT-XL-2-256x256.pt
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/selftok/alexnet-owt-7be5be79.pth
+      dst: /cache/data/alexnet-owt-7be5be79.pth
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/sd3/transformer/sd3_medium.ckpt
+      dst: /cache/data/sd3_medium.ckpt
+    - url: s3://bucket-5125-guiyang/data/z84399568/OpenImage/parquet/parquet_part0-512_20241024171323/
+      dst: /cache/data/openimage/openimage_parquet/
+    # - url: s3://bucket-5125-guiyang/code/z84397892/datasets/tokenizer_pretrain/parquet_imagenet21k_w_hw_480/
+    #   dst: /cache/data/imagenet480/imagenet480_parquet/
+    # - url: s3://bucket-5125-guiyang/data/z84399568/ocr-height_width_ratio_0.9_1.1/parquet_filter_ratio_512_20250303182106/
+    #   dst: /cache/data/ocr/ocr_parquet/
+    # - url: s3://bucket-5125-guiyang/data/z84399568/hucai-face_filter/parquet_part_center_crop_contain_full_face_1p2_20250304195907/
+    #   dst: /cache/data/hucai/hucai_parquet/
+    - url: s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31/2025-05-03_time_2230/output/ckpt/iter_69999.pth
+      dst: /cache/data/iter_69999.pth

llamagen-siglip-sb-block-causal/SelftokPipeline/configs/res256/256_AB66-eval.yml

@@ -0,0 +1,194 @@
+common:
+    output_path: 'output'
+    log_path: '/cache/logs'
+    tb_path: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    val_url: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    alex_path: '/cache/data/alexnet-owt-7be5be79.pth'
+    save_per_epochs: 1.0
+    eval_per_epochs: 1.0
+    eval_first: 0
+    use_fp16: 0
+    use_bf16: 1
+    use_zero: 0
+    use_fsdp: 0
+    use_2d_rope: 0
+    use_deepspeed: 0
+    random_seed: 123
+    log_interval: 50
+    machines: 1
+    task: 'selftokenc'
+    experiment_index: 0
+    delete_after_upload: True
+    log_recon_interval: 100
+    val_interval: 0
+    ckpt_interval: 1000
+    vae_path: '/cache/data/sd3_medium.ckpt'
+    resume_exclude_opt: False
+    pre_encode: False
+    resume_from_steps: 0
+    is_eval: True
+
+model:
+    pretrain_model: ''
+
+optimize:
+    max_epochs: 1000
+    warmup_epochs: 0.01
+    ema_in_cpu: False
+    grad_norm: 0.0
+    lr_scheduler:
+        dit_lr: 1.0e-5
+        token_lr: 5.0e-5
+        init_lr: 5.0e-5
+        init_step1: 5000
+        init_step2: 50000
+        max_step: 100000
+        min_lr1: 5.0e-5
+        min_lr2: 5.0e-5
+
+tokenizer:
+    is_text_tokenized: False
+    pretrained_dit_path: '/cache/data/sd3_medium.ckpt'
+    params:
+        image_size: 256
+        k: 512
+        # stages: '600,800,1000'
+        # k_per_stage: '450,50,12'
+        # stages: '100,400,600,1000'
+        # k_per_stage: '120,300,48,12'
+        # stages: '100,400,600,1000'
+        # k_per_stage: '128,320,51,13'
+        stages: '200,400,600,800,1000'
+        k_per_stage: '192,184,72,48,16'
+        # k_m: 0.0
+        # k_s: 1.0
+        gradient_checkpointing: False
+        in_channels: 16
+        encoder_hidden_size: 16
+        ema_enc: False
+        enc_decay: 0.99
+        L2_lr: 0.
+        two_part_losses: False
+        
+        diffusion_type: 'flow'
+        noise_schedule_config:
+            schedule: 'log_norm'
+            parameterization: 'velocity'
+            force_recon: False
+            m: 0.0
+            s: 1.0
+        
+        enc: 'Enc-Qformer-Uni-XL/2'
+        enable_enc_variable_size: True
+        encoder_config:
+            time_adaln: True
+            qformer_mode: 'dual'
+            pre_norm: False
+            post_norm: True
+            xavier_init: False
+            qk_norm: False
+            attn_mask: False
+
+        quantizer_config:
+            codebook_size: 32768
+            code_dim: 16
+            # w_diversity: 0.5
+            w_diversity: 1.0
+            ema_entropy_ratio: 0.8
+            w_commit: 1.0
+            decay: 0.99
+            dead_code_threshold: 0.2
+            reset_cluster_size: 0.2
+            smart_react: True
+            continuous: False
+            reg: [0.1, 0.3]
+            K: 512
+
+        model: 'MMDiT_XL'
+        context_see_xt: True
+        decoder_config:
+            sd3_cond_pooling: None
+            class_dropout_prob: 0.1
+            train_filter: 'all'
+            freeze_filter: ''
+            # qk_norm: 'rms'
+            init_method: None
+            #register_length: 8
+            time_adaln: 'pos_emb'
+
+data:   # except those with comments, other fields are useless for tokenizer training
+    batch_size: 12
+    num_workers: 8
+    checker:
+        status: disable
+        anchor_path: checkings/A100_bla
+        check_iter: 20
+        save_check: False
+        master_only: False
+        load_keys:
+            - image
+            - prompt
+            - timesteps
+            - noise
+
+    data_checker:
+        status: disable
+        save_prob: 0.1
+        save_amount: 10
+        save_path: data/precision/result
+        master_only: False
+
+    dataset:
+        target: base.Base
+        # meta_info: configs_t2i/data/selftok_ocr_debug.yml
+        # meta_info: configs_t2i/data/selftok_hucai_debug.yml
+        # meta_info: configs_t2i/data/selftok_256_debug.yml
+        meta_info: configs_t2i/data/selftok_imagenet_hucai_ocr.yml
+        enlarge_ratio: 1                        # N epochs
+        max_size: 256                           # max resolution
+        resize_f: 16
+        filter_max_token_len: 128
+        load_t5_cache: False
+        prompt_augmentation: True
+        preprocess_func: center_crop            # augmentation
+        sync_wait_time: 1                       # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        sync_wait_ratio: 1                      # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        
+
+cloud_copy:
+    # - url: s3://bucket-5125-guiyang/data/AIGC/RAW_DATA/imagenet_untar/
+    #   dst: /cache/data/imagenet/
+    - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA/D2/INIT_PARQUET/imagenet_untar/
+      dst: /cache/data/imagenet_untar/imagenet_untar_parquet/
+    - url: s3://bucket-5125-guiyang/data/z84399568/ocr-height_width_ratio_0.9_1.1/parquet_filter_ratio_512_20250303182106/
+      dst: /cache/data/ocr/ocr_parquet/
+    - url: s3://bucket-5125-guiyang/data/z84399568/hucai-face_filter/parquet_part_center_crop_contain_full_face_1p2_20250304195907/
+      dst: /cache/data/hucai/hucai_parquet/
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/mimo/DiT/DiT-XL-2-256x256.pt
+      dst: /cache/data/DiT-XL-2-256x256.pt
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/selftok/alexnet-owt-7be5be79.pth
+      dst: /cache/data/alexnet-owt-7be5be79.pth
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/sd3/transformer/sd3_medium.ckpt
+      dst: /cache/data/sd3_medium.ckpt
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/flickr/parquet_part1007/
+    #   dst: /cache/data/flickr/parquet_part1007/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/flickr/parquet_1006_3/
+    #   dst: /cache/data/flickr/parquet_1006_3/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/visual_china/parquet_10111055/
+    #   dst: /cache/data/visual_china/parquet_10111055/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA/V0601/parquet1_internvl2/
+    #   dst: /cache/data/V0601/parquet1_internvl2/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/laion2B-multi/parquet_part10091027-512_20241014102423/
+    #   dst: /cache/data/laion2B-multi/parquet_part10091027-512_20241014102423/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/laion2B-multi/parquet_part4-512_20241014103020/
+    #   dst: /cache/data/laion2B-multi/parquet_part4-512_20241014103020/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/laion2B-multi/parquet_1007_2/
+    #   dst: /cache/data/laion2B-multi/parquet_1007_2/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/laion2B-multi/parquet_1009_2/
+    #   dst: /cache/data/laion2B-multi/parquet_1009_2/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/datacomp/parquet_part1009-512_20241014120509/
+    #   dst: /cache/data/datacomp/parquet_part1009-512_20241014120509/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/datacomp/parquet_part10101630-512_20241014215832/
+    #   dst: /cache/data/datacomp/parquet_part10101630-512_20241014215832/
+    # - url: s3://bucket-5125-guiyang/data/AIGC/TRAIN_DATA_WHOLE_PACK/D2_data/EDD.D2.PT256.B002-1B/datacomp/parquet_part10111115-512_20241014125233/
+    #   dst: /cache/data/datacomp/parquet_part10111115-512_20241014125233/

llamagen-siglip-sb-block-causal/SelftokPipeline/configs/res512/selftok_sd3_E31-512_modified.yml

@@ -0,0 +1,166 @@
+common:
+    output_path: 'output'
+    log_path: '/cache/logs'
+    tb_path: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    val_url: 's3://bucket-5125-guiyang/outputs/selftok_enc_tb/v4'
+    alex_path: '/cache/data/alexnet-owt-7be5be79.pth'
+    save_per_epochs: 1.0
+    eval_per_epochs: 1.0
+    eval_first: 0
+    use_fp16: 0
+    use_bf16: 1
+    use_zero: 0
+    use_fsdp: 0
+    use_2d_rope: 0
+    use_deepspeed: 0
+    random_seed: 123
+    log_interval: 50
+    machines: 1
+    task: 'selftokenc'
+    experiment_index: 0
+    delete_after_upload: True
+    log_recon_interval: 100
+    val_interval: 0
+    ckpt_interval: 2000
+    vae_path: '/cache/data/sd3_medium.ckpt'
+    resume_exclude_opt: True
+    pre_encode: False
+    resume_from_steps: 0
+    is_eval: True
+
+model:
+    pretrain_model: '/cache/data/iter_69999.pth'
+
+optimize:
+    max_epochs: 1000
+    warmup_epochs: 0.01
+    ema_in_cpu: False
+    grad_norm: 0.0
+    lr_scheduler:
+        dit_lr: 2.0e-5
+        token_lr: 1.0e-4
+        init_lr: 1.0e-4
+        init_step1: 5000
+        init_step2: 50000
+        max_step: 100000
+        min_lr1: 1.0e-4
+        min_lr2: 1.0e-4
+
+tokenizer:
+    is_text_tokenized: False
+    pretrained_dit_path: '/cache/data/sd3_medium.ckpt'
+    params:
+        image_size: 512
+        k: 1536
+        stages: '200,400,600,800,1000'
+        k_per_stage: '512,512,256,192,64'
+        # k_m: 0.0
+        # k_s: 1.0
+        gradient_checkpointing: False
+        in_channels: 16
+        encoder_hidden_size: 16
+        ema_enc: False
+        enc_decay: 0.99
+        L2_lr: 0.
+        two_part_losses: False
+        
+        diffusion_type: 'flow'
+        noise_schedule_config:
+            schedule: 'log_norm'
+            parameterization: 'velocity'
+            force_recon: False
+            m: 0.0
+            s: 1.0
+        
+        enc: 'Enc-Qformer-Uni-XL/2'
+        enable_enc_variable_size: True
+        encoder_config:
+            time_adaln: True
+            qformer_mode: 'dual'
+            pre_norm: False
+            post_norm: True
+            xavier_init: False
+            qk_norm: False
+            attn_mask: False
+
+        quantizer_config:
+            codebook_size: 16384
+            code_dim: 32
+            w_diversity: 1.0
+            ema_entropy_ratio: 0.8
+            w_commit: 1.0
+            decay: 0.99
+            dead_code_threshold: 0.2
+            reset_cluster_size: 0.2
+            smart_react: True
+            # redistribute: False
+            continuous: False
+            reg: [0.1, 0.3]
+            K: 1536
+            # share: True
+
+        model: 'MMDiT_XL'
+        context_see_xt: True
+        decoder_config:
+            sd3_cond_pooling: None
+            class_dropout_prob: 0.1
+            train_filter: 'all'
+            freeze_filter: ''
+            # qk_norm: 'rms'
+            init_method: None
+            #register_length: 8
+            time_adaln: 'pos_emb'
+
+data:   # except those with comments, other fields are useless for tokenizer training
+    batch_size: 8
+    num_workers: 8
+    checker:
+        status: disable
+        anchor_path: checkings/A100_bla
+        check_iter: 20
+        save_check: False
+        master_only: False
+        load_keys:
+            - image
+            - prompt
+            - timesteps
+            - noise
+
+    data_checker:
+        status: disable
+        save_prob: 0.1
+        save_amount: 10
+        save_path: data/precision/result
+        master_only: False
+
+    dataset:
+        target: base.Base
+        meta_info: configs_t2i/data/selftok_openimage.yml
+        enlarge_ratio: 1000                     # N epochs
+        max_size: 512                           # max resolution
+        resize_f: 16
+        filter_max_token_len: 128
+        load_t5_cache: False
+        prompt_augmentation: True
+        preprocess_func: center_crop            # augmentation
+        sync_wait_time: 1                       # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        sync_wait_ratio: 1                      # if ROMA bandwidth limit reached, set ratio as >=2, wait>=1
+        
+
+cloud_copy:
+    # - url: s3://bucket-5125-guiyang/misc/MGM/models/mimo/DiT/DiT-XL-2-256x256.pt
+    #   dst: /cache/data/DiT-XL-2-256x256.pt
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/selftok/alexnet-owt-7be5be79.pth
+      dst: /cache/data/alexnet-owt-7be5be79.pth
+    - url: s3://bucket-5125-guiyang/misc/MGM/models/sd3/transformer/sd3_medium.ckpt
+      dst: /cache/data/sd3_medium.ckpt
+    - url: s3://bucket-5125-guiyang/data/z84399568/OpenImage/parquet/parquet_part0-512_20241024171323/
+      dst: /cache/data/openimage/openimage_parquet/
+    # - url: s3://bucket-5125-guiyang/code/z84397892/datasets/tokenizer_pretrain/parquet_imagenet21k_w_hw_480/
+    #   dst: /cache/data/imagenet480/imagenet480_parquet/
+    # - url: s3://bucket-5125-guiyang/data/z84399568/ocr-height_width_ratio_0.9_1.1/parquet_filter_ratio_512_20250303182106/
+    #   dst: /cache/data/ocr/ocr_parquet/
+    # - url: s3://bucket-5125-guiyang/data/z84399568/hucai-face_filter/parquet_part_center_crop_contain_full_face_1p2_20250304195907/
+    #   dst: /cache/data/hucai/hucai_parquet/
+    - url: s3://bucket-5125-guiyang/outputs/l50043800/selftok/E31/2025-05-03_time_2230/output/ckpt/iter_69999.pth
+      dst: /cache/data/iter_69999.pth

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+from .build import build_dataloader
+from .selftok_dataset import *

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/base_dataset.py

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+import os
+import random
+import traceback
+import warnings
+from PIL import Image, ImageFile
+from torchvision import transforms
+from torch.utils.data import Dataset
+from mimogpt.tokenizer import get_text_tokenizer
+from mimogpt.datasets.build import DATALOADER_REGISTRY
+from mimogpt.datasets.transforms import get_zip_idx, make_zip_fns, make_zip_dataset
+import torch
+#from .slim_zipfile import SlimZipFile as ZipFile
+from zipfile import ZipFile
+
+try:
+    import moxing as mox
+except ImportError:
+    print("no moxing !!!")
+
+warnings.filterwarnings("ignore")
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+class DatasetBase(Dataset):
+    def __init__(
+        self,
+        zip_root,
+        pkl_root,
+        data_list,
+        columns,
+        local_shuffle_type,
+        text_tokenizer_path=None,
+        tokenizer_type="mimo_chinese",
+        text_seq_length=128,
+        image_seq_length=256,
+        total_seq_length=640,
+        is_text_tokenized=True,
+        split_range=(0, 1024),
+        do_unzip=False,
+        pkl_format="pickle",
+        train_task="mimo",
+        resize_size=256,
+        txt_zip_root=None,
+        txt_zip_name=None,
+        transform=None,
+        target_transform=None,
+    ):
+        assert pkl_format in ("pkl", "pickle", "pandas", "parquet")
+
+        if local_shuffle_type in (4, 5):
+            self.this_card_all_idx = get_zip_idx(split_range, train_task)
+        else:
+            self.this_card_all_idx = list(range(int(split_range[0]), int(split_range[1])))
+
+        self.samples = make_zip_dataset(os.path.join(pkl_root, data_list), self.this_card_all_idx, columns, pkl_format)
+        self.zip_files = make_zip_fns(os.path.join(zip_root, data_list), self.this_card_all_idx)
+        self.zip_fns = [None] * len(self.this_card_all_idx)
+        if txt_zip_root:
+            self.txt_zip_files = make_zip_fns(os.path.join(txt_zip_root, txt_zip_name), self.this_card_all_idx)
+            self.txt_zip_fns = [None] * len(self.this_card_all_idx)
+
+        self.do_unzip = do_unzip
+        self.columns = columns
+        self.zip_root = zip_root
+        self.text_seq_length = text_seq_length
+        self.image_seq_length = image_seq_length
+        self.total_seq_length = total_seq_length
+        self.max_size = len(self.samples)
+        self.transform = transform
+        self.target_transform = target_transform
+        self.resize_size = resize_size
+
+        # init tokenizer
+        self.is_text_tokenized = is_text_tokenized
+        if tokenizer_type == "PanguTokenizer":
+            tokenizer_type = "unify_interleaved_pangu"
+        if is_text_tokenized:
+            self.tokenizer = get_text_tokenizer(text_tokenizer_path, tokenizer_type=tokenizer_type)
+        self.tokenizer_type = tokenizer_type
+
+    def set_max_size(self, max_size=None):
+        if max_size is not None:
+            self.max_size = max_size
+
+    def init_zip_fns(self, zip_idx):
+        # for more details, https://discuss.pytorch.org/t/dataloader-with-zipfile-failed/42795
+        if self.zip_fns[zip_idx] is None:
+            self.zip_fns[zip_idx] = ZipFile(self.zip_files[zip_idx])
+
+    def get_img_desc(self, index, ratio_filter=False):
+        while True:
+            ann = self.samples.loc[index]
+            res = {col: ann.get(col) for col in self.columns}
+
+            key = ann.get(self.columns[0])
+            zip_idx = ann.get("zip_idx")
+
+            try:
+                if self.do_unzip:
+                    real_zip_idx = self.this_card_all_idx[zip_idx]
+                    with open(os.path.join(self.zip_root, str(real_zip_idx), str(key)), "rb") as f:
+                        sample = Image.open(f).convert("RGB")
+                else:
+                    self.init_zip_fns(zip_idx)
+                    with self.zip_fns[zip_idx].open(str(key), "r") as f:
+                        sample = Image.open(f).convert("RGB")
+                    try:
+                        rank = torch.distributed.get_rank() 
+                        with open(f'/cache/load_record_{rank}.txt',"a",encoding='utf-8') as file:
+                            data_name = str(ann.get('dataset'))
+                            file_name = str(ann.get('relative_img_path'))
+                            file.write(f'{data_name}/{file_name}'+"\n")
+                    except Exception as e:
+                        data_name = str(ann.get('dataset'))
+                        file_name = str(ann.get('relative_img_path'))
+                        print(f'load {data_name}/{file_name} failed'+"\n")
+
+                if ratio_filter:
+                    w, h = sample.width, sample.height
+                    if (w * 1.0 / h) < 0.48:  # 竖图
+                        # image = transforms.functional.crop(image, top, left, h, w)
+                        sample = transforms.functional.crop(sample, int((h - 2 * w) / 2.0), 0, int(2 * w), w)
+                    if (w * 1.0 / h) > 2.1:  # 横图
+                        sample = transforms.functional.crop(sample, 0, int((w - 2 * h) / 2.0), h, int(2 * h))
+
+                res["image"] = sample
+                res["zip_fn"] = self.zip_fns[zip_idx]
+                res["zip_idx"] = zip_idx
+                return res
+            except Exception as e:
+                # solve missing image case.
+                old_index = index
+                index = index + random.randint(1, 9)
+                index = max(0, index)
+                if index >= len(self.samples) - 1:
+                    # for last index fail case.
+                    index = 0
+                print(
+                    "Warning: load zip_idx={}-{} fail, change index {}->{} ".format(
+                        self.zip_files[zip_idx], old_index, old_index, index
+                    )
+                )
+
+    def __len__(self):
+        return self.max_size
+
+    def __del__(self):
+        for zip_fn in self.zip_fns:
+            if zip_fn is not None:
+                zip_fn.close()
+
+    def truncate(self, text, max_len=256):
+        if self.tokenizer_type == "unify_interleaved_pangu":
+            text_enc = self.tokenizer.tokenizer.tokenize(text)
+        else:
+            text_enc = self.tokenizer.tokenizer.encode(text, add_special_tokens=False)
+        if len(text_enc) > max_len:
+            text_enc = text_enc[:max_len]
+        text_truncated = self.tokenizer.decode_text(text_enc)
+        return text_truncated

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/build.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+from ..utils import Registry
+
+DATALOADER_REGISTRY = Registry("DATALOADER")
+
+
+def build_dataloader(cfg, name=None):
+    loader_name = cfg.dataloader.train.dataloader if name is None else name
+    loader = DATALOADER_REGISTRY.get(loader_name)(cfg)
+    return loader

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/selftok_dataset.py

@@ -0,0 +1,685 @@
+import os
+import random
+import traceback
+import warnings
+from mimogpt.utils import hf_logger
+from torchvision.datasets import ImageFolder
+from PIL import Image, ImageFile
+from torchvision import transforms
+import torch
+from torch.utils.data import Dataset, DataLoader, ConcatDataset
+from mimogpt.datasets.build import DATALOADER_REGISTRY
+from .slim_zipfile import SlimZipFile as ZipFile
+import numpy as np
+import pandas as pd
+import glob
+import torch.distributed as dist
+import torch.utils.data as data
+import operator
+import itertools
+from mimogpt.datasets.base_dataset import ZipFile, DatasetBase
+from mimogpt.datasets.transforms import set_visual_transforms,NormalizeToTensor, RandomResize
+
+try:
+    import moxing as mox
+except ImportError:
+    print("no moxing !!!")
+
+
+RES_LIST_256 = [(128, 512), (128, 480), (128, 448), (128, 416), 
+                (160, 416), (160, 384), (160, 352), (192, 352),
+                (192, 320), (224, 320), (224, 288), (224, 256),
+                (256, 256), (256, 224), (288, 224), (320, 224),
+                (320, 192), (352, 192), (352, 160), (384, 160),
+                (416, 160), (416, 128), (448, 128), (480, 128), (512, 128)]
+
+RES_LIST_512 = [(256, 832), (256, 896), (256, 960), (256, 1024), 
+                (320, 704), (320, 768), (320, 832), (320, 896), 
+                (384, 576), (384, 640), (384, 704), (448, 512), 
+                (448, 576), (512, 448), (512, 512), (576, 384), 
+                (576, 448), (640, 384), (704, 320), (704, 384),
+                (768, 320), (832, 256), (832, 320), (896, 256),
+                (896, 320), (960, 256), (1024, 256)]
+
+class ConditionalResize(transforms.Resize):
+    """
+    Resize transform but only if the input is smaller than the resize dims
+    """
+
+    @property
+    def resize_height(self):
+        return self.size if isinstance(self.size, int) else self.size[0]
+
+    @property
+    def resize_width(self):
+        return self.size if isinstance(self.size, int) else self.size[1]
+
+    def forward(self, img):
+        """
+        Args:
+            img (PIL Image or Tensor): Image to be scaled.
+
+        Returns:
+            PIL Image or Tensor: Rescaled image.
+        """
+        r_h, r_w = self.resize_height, self.resize_width
+        if isinstance(img, torch.Tensor):
+            h, w = img.shape[1:]
+        else:  # PIL Image
+            w, h = img.size
+        if w < r_w or h < r_h:
+            return super().forward(img)
+        else:
+            return img
+
+
+def center_crop_arr(pil_image, image_size):
+    """
+    Center cropping implementation from ADM.
+    https://github.com/openai/guided-diffusion/blob/8fb3ad9197f16bbc40620447b2742e13458d2831/guided_diffusion/image_datasets.py#L126
+    """
+    while min(*pil_image.size) >= 2 * image_size:
+        pil_image = pil_image.resize(
+            tuple(x // 2 for x in pil_image.size), resample=Image.BOX
+        )
+
+    scale = image_size / min(*pil_image.size)
+    pil_image = pil_image.resize(
+        tuple(round(x * scale) for x in pil_image.size), resample=Image.BICUBIC
+    )
+
+    arr = np.array(pil_image)
+    crop_y = (arr.shape[0] - image_size) // 2
+    crop_x = (arr.shape[1] - image_size) // 2
+    return Image.fromarray(arr[crop_y: crop_y + image_size, crop_x: crop_x + image_size])
+
+def worker_init_reset_seed(worker_id):
+    initial_seed = torch.initial_seed() % 2**31
+    seed_all_rng(initial_seed + worker_id)
+  
+    
+def cal_resize_crop(img_h, img_w, resos_list):
+    aspect_list = [h / w for h, w in resos_list]
+    aspect_list = np.array(aspect_list)
+
+    img_reso = img_h / img_w
+    ar_errors = img_reso - aspect_list
+    select_bucket_id = np.abs(ar_errors).argmin()
+    crop_size = (resos_list[select_bucket_id][0], resos_list[select_bucket_id][1])
+    target_ratio = crop_size[0] / crop_size[1]
+
+    if img_reso > target_ratio:
+        scale = resos_list[select_bucket_id][1] / img_w
+        resized_size = (int(img_h * scale + 0.5), resos_list[select_bucket_id][1])
+    else:
+        scale = resos_list[select_bucket_id][0] / img_h
+        resized_size = (resos_list[select_bucket_id][0], int(img_w * scale + 0.5))
+
+    return resized_size, crop_size, target_ratio, select_bucket_id
+
+
+
+class CustomLatentDataset(Dataset):
+    def __init__(self, features_dir, preload_data=False):
+        self.features_dir = features_dir
+        self.preload_data = preload_data
+        self.features_files = sorted(os.listdir(features_dir))
+        
+        if preload_data:
+            self.features = []
+            for i in range(len(self.features_files)):
+                if i % 50000 == 0:
+                    print(f"Loaded {float(i) / len(self.features_files) * 100.0:.1f}% data...")
+                feature_file = self.features_files[i]
+                feature = np.load(os.path.join(self.features_dir, feature_file))
+                self.features.append(feature)
+
+    def __len__(self):
+        return len(self.features_files)
+
+    def __getitem__(self, idx):
+        if self.preload_data:
+            feature = torch.from_numpy(self.features[idx])
+            return feature
+        else:
+            feature_file = self.features_files[idx]
+            features = np.load(os.path.join(self.features_dir, feature_file))
+            return torch.from_numpy(features)
+        
+    
+
+
+#################################################################
+###############  Multi-res Multi-ratio Dataset ##################
+#################################################################
+class BucketManger:
+    def __init__(self, image_path):
+        self.image_path = image_path
+        self.buckets = {}
+        self.image_list = []
+        self.aspect_errors = []
+        for root, dirs, files in os.walk(image_path):
+            for file in files:
+                image_file = os.path.join(root,file)
+                with open(image_file, 'rb') as f:
+                    sample = Image.open(f).convert("RGB")
+                ratio = sample.height / sample.width
+                resized_size, crop_size, res_ratio, select_bucket_id = cal_resize_crop(
+                    sample.height, sample.width, RES_LIST)
+                error = abs(ratio - res_ratio)
+                if select_bucket_id not in self.buckets:
+                    self.buckets[select_bucket_id] = []
+                self.aspect_errors.append(error)
+                info = {'img_path':image_file,
+                        'bucket_id':select_bucket_id,
+                        'res_ratio':res_ratio,
+                        'resized_size':resized_size, 
+                        'crop_size':crop_size}
+                self.buckets[select_bucket_id].append(image_file)
+                self.image_list.append(info)
+                random.shuffle(self.image_list)
+        print(f"aspect error: mean {np.array(self.aspect_errors).mean()}, median {np.median(np.array(self.aspect_errors))}, max {np.array(self.aspect_errors).max()}")
+        for bucket_id in reversed(sorted(self.buckets.keys(), key=lambda b: len(self.buckets[b]))):
+            print(f"bucket {bucket_id}: {RES_LIST[bucket_id]}, entries {len(self.buckets[bucket_id])}")
+
+class MimoSimpleImageDataset(DatasetBase):
+    def __init__(self, bucket_id_shift=0, data_res='256-fix', ResizeType=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.bucket_id_shift = bucket_id_shift
+
+        if data_res == '256-fix':
+            self.data_size= 256
+        else:
+            self.data_size= 512 
+
+        self.preprocess = transforms.Compose(
+            [
+                ResizeType,
+                transforms.CenterCrop(self.data_size),
+                NormalizeToTensor(),
+            ]
+        )
+
+    def __getitem__(self, index):
+        sample = self.get_img_desc(index)
+        image = sample.get("image")
+        image = self.preprocess(image)
+        
+        data = {'img':image, 'bucket_id':self.bucket_id_shift}
+        return data
+    
+class MimoLowtoHighImageDataset(DatasetBase):
+    def __init__(self, bucket_id_shift=0, data_res='256-fix', ResizeType=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.bucket_id_shift = bucket_id_shift
+
+        if data_res == '1024-fix':
+            self.data_size= 1024
+            self.lth = [256, 512, 1024]
+        elif data_res == '512-fix':
+            self.data_size= 512 
+            self.lth = [256, 512]
+        else:
+            self.data_size= 256
+            self.lth = [256]
+            
+        self.preprocess = transforms.Compose(
+            [
+                ResizeType,
+                transforms.RandomCrop(self.data_size),
+                #NormalizeToTensor(),
+            ]
+        )
+        
+    def __getitem__(self, index):
+        sample = self.get_img_desc(index)
+        image = sample.get("image")
+        image = self.preprocess(image)
+        all_res_img = {}
+        for res in self.lth:
+            all_res_img[str(res)] = transforms.Compose([transforms.Resize(res),NormalizeToTensor()])(image) 
+        image = NormalizeToTensor()(image)
+        
+        data = {'img':image, 'all_res_img':all_res_img, 'bucket_id':self.bucket_id_shift}
+        return data
+            
+class MimoMultiImageDataset(DatasetBase):
+    def __init__(self, bucket_id_shift=0, data_res='256', ResizeType=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.bucket_id_shift = bucket_id_shift
+        self.data_res = data_res
+        if data_res == '256':
+            self.res_list= RES_LIST_256
+        else:
+            self.res_list= RES_LIST_512 
+        
+    def __getitem__(self, index):
+        sample = self.get_img_desc(index)
+        image = sample.get("image")
+
+        resized_size, crop_size, res_ratio, select_bucket_id = cal_resize_crop(
+                    image.height, image.width, self.res_list)
+        
+        shape_transform= transforms.Compose([
+            transforms.Resize(resized_size),
+            transforms.CenterCrop(crop_size),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+        img = shape_transform(image)
+        data = {'img':img, 'bucket_id':select_bucket_id+self.bucket_id_shift}
+        return data
+        
+
+class CustomBucketImageDataset(Dataset):
+    def __init__(self, image_path, bucket_id_shift, data_res):
+        self.image_path = image_path
+        self.imglist = []
+        for root, dirs, files in os.walk(image_path):
+            for file in files:
+                image_file = os.path.join(root,file)
+                self.imglist.append(image_file)
+        self.bucket_id_shift = bucket_id_shift
+        if data_res == '256':
+            self.res_list= RES_LIST_256
+        else:
+            self.res_list= RES_LIST_512 
+     
+    def __len__(self):
+        return len(self.imglist)
+
+    def __getitem__(self, idx):
+        img_path = self.imglist[idx]
+        with open(img_path, 'rb') as f:
+            img = Image.open(f).convert("RGB")
+            
+        resized_size, crop_size, res_ratio, select_bucket_id = cal_resize_crop(
+                    img.height, img.width, self.res_list)
+        
+        shape_transform= transforms.Compose([
+            transforms.Resize(resized_size),
+            transforms.CenterCrop(crop_size),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+        img = shape_transform(img)
+        data = {'img':img, 'bucket_id':select_bucket_id+self.bucket_id_shift}
+        return data
+    
+    
+class CustomBucketLatentDataset(Dataset):
+    def __init__(self, features_dir, bucket_id_shift,**kwargs):
+        self.features_dir = features_dir
+        self.imglist = sorted(os.listdir(features_dir))
+        random.shuffle(self.imglist)
+        self.bucket_id_shift = bucket_id_shift
+        
+#         self.buckets = {}
+#         for feature_file in self.imglist[0,]:
+#             info = np.load(os.path.join(self.features_dir, feature_file))
+            
+#             select_bucket_id = int(info['arr_1'])
+#             if select_bucket_id not in self.buckets:
+#                 self.buckets[select_bucket_id] = 0
+#             self.buckets[select_bucket_id] += 1
+            
+            
+#         for bucket_id in reversed(sorted(self.buckets.keys(), key=lambda b: self.buckets[b])):
+#             print(f"{features_dir} bucket {bucket_id}: {RES_LIST_256[bucket_id]}, entries {self.buckets[bucket_id]}")
+
+     
+    def __len__(self):
+        return len(self.imglist)
+
+    def __getitem__(self, idx):
+        feature_file = self.imglist[idx]
+        info = np.load(os.path.join(self.features_dir, feature_file))
+        data = {'img':torch.from_numpy(info['arr_0']), 'bucket_id':torch.from_numpy(info['arr_1'])+self.bucket_id_shift}
+        return data
+    
+class AspectRatioGroupedDataset(data.IterableDataset):
+    def __init__(self, dataset, batch_size, bucket_len, *args, **kwargs):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.bucket_len = bucket_len
+        self._caches = [[] for _ in range(bucket_len)]
+
+    def __iter__(self):
+        for sample in self.dataset:
+            bucket_id = sample['bucket_id']
+            cache = self._caches[bucket_id]
+            
+            if 'all_res_img' in sample.keys():
+                cache.append([sample['img'],sample['all_res_img']])
+            else:
+                cache.append(sample['img'])
+                
+            if len(cache) == self.batch_size:
+                data = cache[:]
+                del cache[:]
+                if 'all_res_img' in sample.keys():
+                    out_data = {}
+                    temp = [sap[0] for sap in data]
+                    out_data['img'] = torch.stack(temp,dim=0)
+                    for res in sample['all_res_img'].keys():
+                        temp = [sap[1][res] for sap in data]
+                        out_data[res] = torch.stack(temp,dim=0)
+                    yield out_data
+                else:
+                    yield torch.stack(data,dim=0)
+
+
+def get_resize_transform(resize_type, res):
+    if 'RandomResize' in resize_type:
+        rand_ratio = float(resize_type.split('-')[-1])
+        hf_logger.info(f"Using RandomResize ratio {rand_ratio}...")
+        ResizeType = RandomResize(res, ratio=rand_ratio, interpolation=transforms.InterpolationMode.BICUBIC)
+    elif resize_type == 'ConditionalResize':
+        hf_logger.info(f"Using ConditionalResize...")
+        ResizeType = ConditionalResize(res, interpolation=transforms.InterpolationMode.BICUBIC)
+    else:
+        hf_logger.info(f"Using Resize...")
+        ResizeType = transforms.Resize(res, interpolation=transforms.InterpolationMode.BICUBIC)
+    return ResizeType
+
+def build_bucketloader(cfg, image_path_list, batch_size):
+    #train_bm = BucketManger(image_path)
+    #imglist = train_bm.image_list
+    bucket_len_dict = {'256':len(RES_LIST_256),'512':len(RES_LIST_512), '256-fix':1,'512-fix':1}
+    bucket_len = 0
+    datasets = []
+    res_dict = []
+    train_balance_ratios=[]
+    train_balance_number=[]
+    bucket_id_shift = {}
+    
+    # type,  zip_root, pkl_root, data_list,columns, pkl_format, split_range,  data_res, ratio = info[:8]
+
+    for image_path_info in image_path_list:
+        data_res = image_path_info[-3]
+        train_balance_ratios.append(image_path_info[-1])
+        if data_res not in res_dict:
+            bucket_id_shift[data_res] = sum([bucket_len_dict[x] for x in res_dict])
+            res_dict.append(data_res)
+            bucket_len = bucket_len + bucket_len_dict[data_res]
+            
+    for image_path_info in image_path_list:
+        type = image_path_info[0]
+        if type.startswith('Mimo'):
+            zip_root, pkl_root, data_list, columns, pkl_format, split_range, data_res, resize_type = image_path_info[1:9]
+            if type == 'MimoMultiImageDataset':
+                dataset_type = MimoMultiImageDataset
+                vision_transform = None
+            elif type == 'MimoLowtoHighImageDataset':
+                dataset_type = MimoLowtoHighImageDataset
+                input_res = cfg.dataloader.train.get("input_res", 256)
+                resize_res = cfg.dataloader.train.get("resize_res", 256)
+                vision_transform = set_visual_transforms(mode="train", resize_res=resize_res, input_res=input_res, augment_choice="selftok")
+                ResizeType = get_resize_transform(resize_type, resize_res)
+            else:
+                dataset_type = MimoSimpleImageDataset
+                input_res = cfg.dataloader.train.get("input_res", 256)
+                resize_res = cfg.dataloader.train.get("resize_res", 256)
+                vision_transform = set_visual_transforms(mode="train", resize_res=resize_res, input_res=input_res, augment_choice="selftok")
+                ResizeType = get_resize_transform(resize_type, resize_res)
+                
+            dataset = dataset_type(
+                zip_root=zip_root,
+                pkl_root=pkl_root,
+                data_list=data_list,
+                split_range=split_range,
+                columns=columns,
+                local_shuffle_type=cfg.dataloader.local_shuffle_type,
+                is_text_tokenized=False,
+                transform=vision_transform,
+                pkl_format=pkl_format,
+                bucket_id_shift=bucket_id_shift[data_res],
+                data_res=data_res,
+                ResizeType = ResizeType,
+            )
+            tensor = torch.zeros(cfg.world_size).cuda()
+            tensor[cfg.rank] = len(dataset)
+            dist.all_reduce(tensor, op=dist.ReduceOp.SUM)
+            # min_dataset_length = int(tensor.min().item())
+            min_dataset_length = int(tensor.min())
+            print("rank{}, set dataset size from {} to {}".format(cfg.rank, len(dataset), min_dataset_length))
+            dataset.set_max_size(min_dataset_length)
+            dataset_len = min_dataset_length
+        else:
+            if type == 'CustomBucketImageDataset':
+                dataset_type = CustomBucketImageDataset
+            elif type == 'CustomBucketLatentDataset':
+                dataset_type = CustomBucketLatentDataset
+            else:
+                dataset_type = CustomBucketLatentDataset
+                
+            zip_root = image_path_info[1]
+            data_res = image_path_info[2]
+            dataset = dataset_type(
+                zip_root, 
+                bucket_id_shift[data_res],
+                data_res=data_res,
+            )
+            dataset_len = len(dataset)
+        datasets.append(dataset)
+        train_balance_number.append(dataset_len)
+        
+    train_dataset = ConcatDataset(datasets)
+    if len(res_dict) > 1 and any(item > 0 for item in train_balance_ratios):
+        weights = []
+        for i in range(len(train_balance_ratios)):
+            count = train_balance_number[i]
+            ratio = train_balance_ratios[i]
+            weights += np.full(count, ratio / count).tolist()
+        sampler = torch.utils.data.WeightedRandomSampler(weights=weights, num_samples=len(weights))
+    else:
+        sampler = torch.utils.data.distributed.DistributedSampler(train_dataset, num_replicas=1, rank=0)
+    
+    dataloader = DataLoader(
+        train_dataset,
+        sampler=sampler,
+        batch_sampler=None,
+        num_workers=cfg.dataloader.num_workers,
+        pin_memory=True,
+        prefetch_factor = 16, # mfu1
+        collate_fn=operator.itemgetter(0),
+        worker_init_fn=None,
+    )
+    dataloader = AspectRatioGroupedDataset(dataloader, batch_size, bucket_len)
+    
+    return dataloader, sum(train_balance_number) // batch_size
+
+def build_simpleimageloader(cfg, val_image_path, batch_size):
+    
+    val_transform = transforms.Compose([
+        transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, cfg.dataloader.train.get("input_res", 256))),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+    ])
+    val_path = val_image_path[0][1]
+    val_dataset = ImageFolder(val_path, transform=val_transform)
+    hf_logger.info(f"val set length: {len(val_dataset)}...")
+    val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset)
+    val_dataloader = DataLoader(
+        val_dataset,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=cfg.dataloader.num_workers,
+        sampler = val_sampler,
+        prefetch_factor = 16, # mfu1
+        pin_memory=True,
+        drop_last=True
+    )
+    return val_dataloader, len(val_dataset) // batch_size
+
+@DATALOADER_REGISTRY.register
+def CustomBucketDataloader(cfg):
+    train_image_path = cfg.dataloader.train_img_path
+    val_image_path = cfg.dataloader.val_img_path
+    train_dataloader, train_loader_len = build_bucketloader(cfg, train_image_path, cfg.dataloader.train.batch_size)
+    if cfg.dataloader.setval:
+        if val_image_path[0] in ['CustomBucketLatentDataset','CustomBucketImageDataset']:
+            val_dataloader, val_loader_len = build_bucketloader(cfg, val_image_path, cfg.dataloader.train.batch_size)
+        else:
+            val_dataloader, val_loader_len = build_simpleimageloader(cfg, val_image_path, cfg.dataloader.val.batch_size)
+    else:
+        val_dataloader, val_loader_len = None, None
+
+    return {'train':train_dataloader, 'val':val_dataloader, 'train_loader_len':train_loader_len, 'val_loader_len':val_loader_len }
+
+
+class MultiResImageFolder(ImageFolder):
+    def __init__(self, root, extra_transform, base_res, low_res_list):
+        super().__init__(root)
+        self.extra_transform = extra_transform
+        self.base_t = transforms.Compose([
+            transforms.Resize(base_res),
+            transforms.CenterCrop(base_res),
+            extra_transform
+        ])
+        if type(low_res_list) is list:
+            self.low_res_list = low_res_list
+        else:
+            self.low_res_list = [low_res_list]
+        self.low_res_t_dict = {}  
+        self.low_res_t_dict['res'] = {}
+        for res in self.low_res_list:
+            self.low_res_t_dict[res] = transforms.Compose([
+                transforms.Resize(res),
+                transforms.CenterCrop(res),
+                extra_transform
+            ])
+        self.root = root
+
+    def __getitem__(self, index):
+        """
+        Args:
+            index (int): Index
+        Returns:
+            tuple: (sample, target) where target is class_index of the target class.
+        """
+        path, target = self.samples[index]
+        sample = self.loader(path)
+        base_sample = self.base_t(sample)
+        if self.target_transform is not None:
+            target = self.target_transform(target)
+        extras = {'target': target}
+        for res in self.low_res_list:
+            extras[f'res_{res}'] = self.low_res_t_dict[res](sample)
+        return base_sample, extras
+
+
+@DATALOADER_REGISTRY.register
+def CustomImgDataloader(cfg):
+    if hasattr(cfg.dataloader, 'low_res_list') and cfg.dataloader.low_res_list is not None:
+        extra_transform =  transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+    ])
+        train_dataset = MultiResImageFolder(cfg.dataloader.train_img_path, extra_transform, cfg.tokenizer.params.image_size, cfg.dataloader.low_res_list)
+    else:
+        train_transform = transforms.Compose([
+            transforms.Resize(cfg.tokenizer.params.image_size),
+            transforms.CenterCrop(cfg.tokenizer.params.image_size),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+        ])
+        train_dataset = ImageFolder(cfg.dataloader.train_img_path, transform=train_transform)
+
+    val_transform = transforms.Compose([
+        transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, cfg.tokenizer.params.image_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+    ])
+    # hf_logger.info(f"Current train set length: {len(train_dataset)}...")
+    if cfg.dataloader.trainval:
+        val_for_train = ImageFolder(cfg.dataloader.val_img_path, transform=train_transform)
+        train_dataset = ConcatDataset([train_dataset, val_for_train])
+        # hf_logger.info(f"New train set length: {len(train_dataset)}...")
+    
+    train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
+    train_dataloader = DataLoader(
+        train_dataset,
+        batch_size=cfg.dataloader.batch_size,
+        #shuffle=True,
+        sampler = train_sampler,
+        num_workers=cfg.dataloader.num_workers,
+        prefetch_factor = 16, # mfu1
+        pin_memory=True,
+        drop_last=True
+    )
+    hf_logger.info(f'Train Dataset contains {len(train_dataset):,}')
+    if cfg.dataloader.setval:
+        val_dataset = ImageFolder(cfg.dataloader.val_img_path, transform=val_transform)
+        hf_logger.info(f"val set length: {len(val_dataset)}...")
+        val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset)
+        val_dataloader = DataLoader(
+            val_dataset,
+            batch_size=16,
+            shuffle=False,
+            num_workers=cfg.dataloader.num_workers,
+            sampler = val_sampler,
+            prefetch_factor = 16, # mfu1
+            pin_memory=True,
+            drop_last=True
+        )
+        hf_logger.info(f'Val Dataset contains {len(val_dataset):,}')
+    else:
+        val_dataset, val_dataloader = None, None
+
+    return {'train':train_dataloader, 'val':val_dataloader}
+
+
+@DATALOADER_REGISTRY.register
+def CustomLatentDataloader(cfg):
+    
+    features_dir = f"{cfg.dataloader.feature_path}/{cfg.dataloader.dataset_name}{cfg.tokenizer.params.image_size}_features"
+    val_features_dir = f"{cfg.dataloader.val_feature_path}/{cfg.dataloader.dataset_name}{cfg.tokenizer.params.image_size}_features"
+    # labels_dir = f"{cfg.dataloader.feature_path}/{cfg.dataloader.dataset_name}{cfg.tokenizer.params.image_size}_labels"
+    # val_labels_dir = f"{cfg.dataloader.val_feature_path}/{cfg.dataloader.dataset_name}{cfg.tokenizer.params.image_size}_labels"
+    if cfg.tokenizer.params.model == 'MMDiT_XL':
+        # sd3
+        features_dir += "/sd3-features-256"
+        val_features_dir += "/sd3-features-256"
+    train_dataset = CustomLatentDataset(features_dir, cfg.dataloader.preload_data)
+    if cfg.dataloader.get("open_image", False):
+        openimg_dataset = CustomLatentDataset(cfg.dataloader.openimg_features_dir, cfg.dataloader.preload_data)
+        train_dataset = ConcatDataset([train_dataset, openimg_dataset])
+        hf_logger.info(f"New train set length: {len(train_dataset)}...")
+
+    # if cfg.dataloader.trainval:
+    #     val_for_train = CustomLatentDataset(val_features_dir, val_labels_dir, cfg.dataloader.preload_data)
+    #     train_dataset = ConcatDataset([train_dataset, val_for_train])
+    #     hf_logger.info(f"New train set length: {len(train_dataset)}...")
+
+    train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
+    train_dataloader = DataLoader(
+        train_dataset,
+        batch_size=cfg.dataloader.batch_size,
+        shuffle=False,
+        sampler = train_sampler,
+        num_workers=cfg.dataloader.num_workers,
+        prefetch_factor = 16, # mfu1
+        pin_memory=True,
+        drop_last=True
+    )
+    if cfg.dataloader.setval:
+        val_dataset = CustomLatentDataset(val_features_dir, cfg.dataloader.preload_data)
+        val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset)
+        val_dataloader = DataLoader(
+            val_dataset,
+            batch_size=8,
+            shuffle=False,
+            num_workers=cfg.dataloader.num_workers,
+            sampler = val_sampler,
+            prefetch_factor = 16, # mfu1
+            pin_memory=True,
+            drop_last=True
+        )
+    else:
+        val_dataset, val_dataloader = None, None
+
+    return {'train':train_dataloader, 'val':val_dataloader}
+

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/slim_zipfile.py

@@ -0,0 +1,812 @@
+"""
+Read and write ZIP files.
+XXX references to utf-8 need further investigation.
+"""
+
+import binascii
+import importlib.util
+import io
+import itertools
+import os
+import posixpath
+import shutil
+import stat
+import struct
+import sys
+import threading
+import time
+import contextlib
+import pathlib
+
+try:
+    import zlib  # We may need its compression method
+
+    crc32 = zlib.crc32
+except ImportError:
+    zlib = None
+    crc32 = binascii.crc32
+
+try:
+    import moxing as mox
+except ImportError:
+    mox = None
+
+
+class BadZipFile(Exception):
+    pass
+
+
+ZIP64_LIMIT = (1 << 31) - 1
+ZIP_FILECOUNT_LIMIT = (1 << 16) - 1
+ZIP_MAX_COMMENT = (1 << 16) - 1
+
+# constants for Zip file compression methods
+ZIP_STORED = 0
+ZIP_DEFLATED = 8
+ZIP_BZIP2 = 12
+ZIP_LZMA = 14
+# Other ZIP compression methods not supported
+
+DEFAULT_VERSION = 20
+ZIP64_VERSION = 45
+BZIP2_VERSION = 46
+LZMA_VERSION = 63
+# we recognize (but not necessarily support) all features up to that version
+MAX_EXTRACT_VERSION = 63
+
+# Below are some formats and associated data for reading/writing headers using
+# the struct module.  The names and structures of headers/records are those used
+# in the PKWARE description of the ZIP file format:
+#     http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+# (URL valid as of January 2008)
+
+# The "end of central directory" structure, magic number, size, and indices
+# (section V.I in the format document)
+structEndArchive = b"<4s4H2LH"
+stringEndArchive = b"PK\005\006"
+sizeEndCentDir = struct.calcsize(structEndArchive)
+
+_ECD_SIGNATURE = 0
+_ECD_DISK_NUMBER = 1
+_ECD_DISK_START = 2
+_ECD_ENTRIES_THIS_DISK = 3
+_ECD_ENTRIES_TOTAL = 4
+_ECD_SIZE = 5
+_ECD_OFFSET = 6
+_ECD_COMMENT_SIZE = 7
+# These last two indices are not part of the structure as defined in the
+# spec, but they are used internally by this module as a convenience
+_ECD_COMMENT = 8
+_ECD_LOCATION = 9
+
+# The "central directory" structure, magic number, size, and indices
+# of entries in the structure (section V.F in the format document)
+structCentralDir = "<4s4B4HL2L5H2L"
+stringCentralDir = b"PK\001\002"
+sizeCentralDir = struct.calcsize(structCentralDir)
+
+# indexes of entries in the central directory structure
+_CD_SIGNATURE = 0
+_CD_CREATE_VERSION = 1
+_CD_CREATE_SYSTEM = 2
+_CD_EXTRACT_VERSION = 3
+_CD_EXTRACT_SYSTEM = 4
+_CD_FLAG_BITS = 5
+_CD_COMPRESS_TYPE = 6
+_CD_TIME = 7
+_CD_DATE = 8
+_CD_CRC = 9
+_CD_COMPRESSED_SIZE = 10
+_CD_UNCOMPRESSED_SIZE = 11
+_CD_FILENAME_LENGTH = 12
+_CD_EXTRA_FIELD_LENGTH = 13
+_CD_COMMENT_LENGTH = 14
+_CD_DISK_NUMBER_START = 15
+_CD_INTERNAL_FILE_ATTRIBUTES = 16
+_CD_EXTERNAL_FILE_ATTRIBUTES = 17
+_CD_LOCAL_HEADER_OFFSET = 18
+
+# General purpose bit flags
+# Zip Appnote: 4.4.4 general purpose bit flag: (2 bytes)
+_MASK_ENCRYPTED = 1 << 0
+# Bits 1 and 2 have different meanings depending on the compression used.
+_MASK_COMPRESS_OPTION_1 = 1 << 1
+# _MASK_COMPRESS_OPTION_2 = 1 << 2
+# _MASK_USE_DATA_DESCRIPTOR: If set, crc-32, compressed size and uncompressed
+# size are zero in the local header and the real values are written in the data
+# descriptor immediately following the compressed data.
+_MASK_USE_DATA_DESCRIPTOR = 1 << 3
+# Bit 4: Reserved for use with compression method 8, for enhanced deflating.
+# _MASK_RESERVED_BIT_4 = 1 << 4
+_MASK_COMPRESSED_PATCH = 1 << 5
+_MASK_STRONG_ENCRYPTION = 1 << 6
+# _MASK_UNUSED_BIT_7 = 1 << 7
+# _MASK_UNUSED_BIT_8 = 1 << 8
+# _MASK_UNUSED_BIT_9 = 1 << 9
+# _MASK_UNUSED_BIT_10 = 1 << 10
+_MASK_UTF_FILENAME = 1 << 11
+# Bit 12: Reserved by PKWARE for enhanced compression.
+# _MASK_RESERVED_BIT_12 = 1 << 12
+# _MASK_ENCRYPTED_CENTRAL_DIR = 1 << 13
+# Bit 14, 15: Reserved by PKWARE
+# _MASK_RESERVED_BIT_14 = 1 << 14
+# _MASK_RESERVED_BIT_15 = 1 << 15
+
+# The "local file header" structure, magic number, size, and indices
+# (section V.A in the format document)
+structFileHeader = "<4s2B4HL2L2H"
+stringFileHeader = b"PK\003\004"
+sizeFileHeader = struct.calcsize(structFileHeader)
+
+_FH_SIGNATURE = 0
+_FH_EXTRACT_VERSION = 1
+_FH_EXTRACT_SYSTEM = 2
+_FH_GENERAL_PURPOSE_FLAG_BITS = 3
+_FH_COMPRESSION_METHOD = 4
+_FH_LAST_MOD_TIME = 5
+_FH_LAST_MOD_DATE = 6
+_FH_CRC = 7
+_FH_COMPRESSED_SIZE = 8
+_FH_UNCOMPRESSED_SIZE = 9
+_FH_FILENAME_LENGTH = 10
+_FH_EXTRA_FIELD_LENGTH = 11
+
+# The "Zip64 end of central directory locator" structure, magic number, and size
+structEndArchive64Locator = "<4sLQL"
+stringEndArchive64Locator = b"PK\x06\x07"
+sizeEndCentDir64Locator = struct.calcsize(structEndArchive64Locator)
+
+# The "Zip64 end of central directory" record, magic number, size, and indices
+# (section V.G in the format document)
+structEndArchive64 = "<4sQ2H2L4Q"
+stringEndArchive64 = b"PK\x06\x06"
+sizeEndCentDir64 = struct.calcsize(structEndArchive64)
+
+_CD64_SIGNATURE = 0
+_CD64_DIRECTORY_RECSIZE = 1
+_CD64_CREATE_VERSION = 2
+_CD64_EXTRACT_VERSION = 3
+_CD64_DISK_NUMBER = 4
+_CD64_DISK_NUMBER_START = 5
+_CD64_NUMBER_ENTRIES_THIS_DISK = 6
+_CD64_NUMBER_ENTRIES_TOTAL = 7
+_CD64_DIRECTORY_SIZE = 8
+_CD64_OFFSET_START_CENTDIR = 9
+
+_DD_SIGNATURE = 0x08074B50
+
+
+def _EndRecData64(fpin, offset, endrec):
+    """
+    Read the ZIP64 end-of-archive records and use that to update endrec
+    """
+    try:
+        fpin.seek(offset - sizeEndCentDir64Locator, 2)
+    except OSError:
+        # If the seek fails, the file is not large enough to contain a ZIP64
+        # end-of-archive record, so just return the end record we were given.
+        return endrec
+
+    data = fpin.read(sizeEndCentDir64Locator)
+    if len(data) != sizeEndCentDir64Locator:
+        return endrec
+    sig, diskno, reloff, disks = struct.unpack(structEndArchive64Locator, data)
+    if sig != stringEndArchive64Locator:
+        return endrec
+
+    if diskno != 0 or disks > 1:
+        raise BadZipFile("zipfiles that span multiple disks are not supported")
+
+    # Assume no 'zip64 extensible data'
+    fpin.seek(offset - sizeEndCentDir64Locator - sizeEndCentDir64, 2)
+    data = fpin.read(sizeEndCentDir64)
+    if len(data) != sizeEndCentDir64:
+        return endrec
+    sig, sz, _, read_version, disk_num, disk_dir, dircount, dircount2, dirsize, diroffset = struct.unpack(
+        structEndArchive64, data
+    )
+    if sig != stringEndArchive64:
+        return endrec
+
+    # Update the original endrec using data from the ZIP64 record
+    endrec[_ECD_SIGNATURE] = sig
+    endrec[_ECD_DISK_NUMBER] = disk_num
+    endrec[_ECD_DISK_START] = disk_dir
+    endrec[_ECD_ENTRIES_THIS_DISK] = dircount
+    endrec[_ECD_ENTRIES_TOTAL] = dircount2
+    endrec[_ECD_SIZE] = dirsize
+    endrec[_ECD_OFFSET] = diroffset
+    return endrec
+
+
+def _EndRecData(fpin):
+    """Return data from the "End of Central Directory" record, or None.
+    The data is a list of the nine items in the ZIP "End of central dir"
+    record followed by a tenth item, the file seek offset of this record."""
+
+    # Determine file size
+    fpin.seek(0, 2)
+    filesize = fpin.tell()
+
+    # Check to see if this is ZIP file with no archive comment (the
+    # "end of central directory" structure should be the last item in the
+    # file if this is the case).
+    try:
+        fpin.seek(-sizeEndCentDir, 2)
+    except OSError:
+        return None
+    data = fpin.read()
+    if len(data) == sizeEndCentDir and data[0:4] == stringEndArchive and data[-2:] == b"\000\000":
+        # the signature is correct and there's no comment, unpack structure
+        endrec = struct.unpack(structEndArchive, data)
+        endrec = list(endrec)
+
+        # Append a blank comment and record start offset
+        endrec.append(b"")
+        endrec.append(filesize - sizeEndCentDir)
+
+        # Try to read the "Zip64 end of central directory" structure
+        return _EndRecData64(fpin, -sizeEndCentDir, endrec)
+
+    # Either this is not a ZIP file, or it is a ZIP file with an archive
+    # comment.  Search the end of the file for the "end of central directory"
+    # record signature. The comment is the last item in the ZIP file and may be
+    # up to 64K long.  It is assumed that the "end of central directory" magic
+    # number does not appear in the comment.
+    maxCommentStart = max(filesize - (1 << 16) - sizeEndCentDir, 0)
+    fpin.seek(maxCommentStart, 0)
+    data = fpin.read()
+    start = data.rfind(stringEndArchive)
+    if start >= 0:
+        # found the magic number; attempt to unpack and interpret
+        recData = data[start : start + sizeEndCentDir]
+        if len(recData) != sizeEndCentDir:
+            # Zip file is corrupted.
+            return None
+        endrec = list(struct.unpack(structEndArchive, recData))
+        commentSize = endrec[_ECD_COMMENT_SIZE]  # as claimed by the zip file
+        comment = data[start + sizeEndCentDir : start + sizeEndCentDir + commentSize]
+        endrec.append(comment)
+        endrec.append(maxCommentStart + start)
+
+        # Try to read the "Zip64 end of central directory" structure
+        return _EndRecData64(fpin, maxCommentStart + start - filesize, endrec)
+
+    # Unable to find a valid end of central directory structure
+    return None
+
+
+class ZipInfo(object):
+    __slots__ = (
+        "filename",
+        "header_offset",
+        "CRC",
+        "compress_size",
+        "file_size",
+    )
+
+    def __init__(self, filename="NoName"):
+        self.filename = filename
+        self.compress_size = 0  # Size of the compressed file
+        self.file_size = 0  # Size of the uncompressed file
+
+    def _decodeExtra(self, extra):
+        # Try to decode the extra field.
+        unpack = struct.unpack
+        while len(extra) >= 4:
+            tp, ln = unpack("<HH", extra[:4])
+            if ln + 4 > len(extra):
+                raise BadZipFile("Corrupt extra field %04x (size=%d)" % (tp, ln))
+            if tp == 0x0001:
+                data = extra[4 : ln + 4]
+                # ZIP64 extension (large files and/or large archives)
+                try:
+                    if self.file_size in (0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF):
+                        field = "File size"
+                        (self.file_size,) = unpack("<Q", data[:8])
+                        data = data[8:]
+                    if self.compress_size == 0xFFFF_FFFF:
+                        field = "Compress size"
+                        (self.compress_size,) = unpack("<Q", data[:8])
+                        data = data[8:]
+                    if self.header_offset == 0xFFFF_FFFF:
+                        field = "Header offset"
+                        (self.header_offset,) = unpack("<Q", data[:8])
+                except struct.error:
+                    raise BadZipFile(f"Corrupt zip64 extra field. " f"{field} not found.") from None
+
+            extra = extra[ln + 4 :]
+
+
+class _SharedFile:
+    def __init__(self, file, pos, close, lock, writing):
+        self._file = file
+        self._pos = pos
+        self._close = close
+        self._lock = lock
+        self._writing = writing
+        self.seekable = file.seekable
+
+    def tell(self):
+        return self._pos
+
+    def seek(self, offset, whence=0):
+        with self._lock:
+            if self._writing():
+                raise ValueError(
+                    "Can't reposition in the ZIP file while "
+                    "there is an open writing handle on it. "
+                    "Close the writing handle before trying to read."
+                )
+            self._file.seek(offset, whence)
+            self._pos = self._file.tell()
+            return self._pos
+
+    def read(self, n=-1):
+        with self._lock:
+            if self._writing():
+                raise ValueError(
+                    "Can't read from the ZIP file while there "
+                    "is an open writing handle on it. "
+                    "Close the writing handle before trying to read."
+                )
+            self._file.seek(self._pos)
+            data = self._file.read(n)
+            self._pos = self._file.tell()
+            return data
+
+    def close(self):
+        if self._file is not None:
+            fileobj = self._file
+            self._file = None
+            self._close(fileobj)
+
+
+class ZipExtFile(io.BufferedIOBase):
+    """File-like object for reading an archive member.
+    Is returned by ZipFile.open().
+    """
+
+    # Max size supported by decompressor.
+    MAX_N = 1 << 31 - 1
+
+    # Read from compressed files in 4k blocks.
+    MIN_READ_SIZE = 4096
+
+    # Chunk size to read during seek
+    MAX_SEEK_READ = 1 << 24
+
+    def __init__(self, fileobj, mode, zipinfo, close_fileobj=False):
+        self._fileobj = fileobj
+        self._close_fileobj = close_fileobj
+        self._compress_left = zipinfo.compress_size
+        self._left = zipinfo.file_size
+        self._eof = False
+        self._readbuffer = b""
+        self._offset = 0
+
+        self.newlines = None
+
+        self.mode = mode
+        self.name = zipinfo.filename
+
+        if hasattr(zipinfo, "CRC"):
+            self._expected_crc = zipinfo.CRC
+            self._running_crc = crc32(b"")
+        else:
+            self._expected_crc = None
+
+        self._seekable = False
+        try:
+            if fileobj.seekable():
+                self._orig_compress_start = fileobj.tell()
+                self._orig_compress_size = zipinfo.compress_size
+                self._orig_file_size = zipinfo.file_size
+                self._orig_start_crc = self._running_crc
+                self._seekable = True
+        except AttributeError:
+            pass
+
+        self._decrypter = None
+
+    def _init_decrypter(self):
+        raise NotImplementedError
+
+    def readline(self, limit=-1):
+        """Read and return a line from the stream.
+        If limit is specified, at most limit bytes will be read.
+        """
+
+        if limit < 0:
+            # Shortcut common case - newline found in buffer.
+            i = self._readbuffer.find(b"\n", self._offset) + 1
+            if i > 0:
+                line = self._readbuffer[self._offset : i]
+                self._offset = i
+                return line
+
+        return io.BufferedIOBase.readline(self, limit)
+
+    def peek(self, n=1):
+        """Returns buffered bytes without advancing the position."""
+        if n > len(self._readbuffer) - self._offset:
+            chunk = self.read(n)
+            if len(chunk) > self._offset:
+                self._readbuffer = chunk + self._readbuffer[self._offset :]
+                self._offset = 0
+            else:
+                self._offset -= len(chunk)
+
+        # Return up to 512 bytes to reduce allocation overhead for tight loops.
+        return self._readbuffer[self._offset : self._offset + 512]
+
+    def readable(self):
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        return True
+
+    def read(self, n=-1):
+        """Read and return up to n bytes.
+        If the argument is omitted, None, or negative, data is read and returned until EOF is reached.
+        """
+        if self.closed:
+            raise ValueError("read from closed file.")
+        if n is None or n < 0:
+            buf = self._readbuffer[self._offset :]
+            self._readbuffer = b""
+            self._offset = 0
+            while not self._eof:
+                buf += self._read1(self.MAX_N)
+            return buf
+
+        end = n + self._offset
+        if end < len(self._readbuffer):
+            buf = self._readbuffer[self._offset : end]
+            self._offset = end
+            return buf
+
+        n = end - len(self._readbuffer)
+        buf = self._readbuffer[self._offset :]
+        self._readbuffer = b""
+        self._offset = 0
+        while n > 0 and not self._eof:
+            data = self._read1(n)
+            if n < len(data):
+                self._readbuffer = data
+                self._offset = n
+                buf += data[:n]
+                break
+            buf += data
+            n -= len(data)
+        return buf
+
+    def _update_crc(self, newdata):
+        # Update the CRC using the given data.
+        if self._expected_crc is None:
+            # No need to compute the CRC if we don't have a reference value
+            return
+        self._running_crc = crc32(newdata, self._running_crc)
+        # Check the CRC if we're at the end of the file
+        if self._eof and self._running_crc != self._expected_crc:
+            raise BadZipFile("Bad CRC-32 for file %r" % self.name)
+
+    def read1(self, n):
+        """Read up to n bytes with at most one read() system call."""
+
+        if n is None or n < 0:
+            buf = self._readbuffer[self._offset :]
+            self._readbuffer = b""
+            self._offset = 0
+            while not self._eof:
+                data = self._read1(self.MAX_N)
+                if data:
+                    buf += data
+                    break
+            return buf
+
+        end = n + self._offset
+        if end < len(self._readbuffer):
+            buf = self._readbuffer[self._offset : end]
+            self._offset = end
+            return buf
+
+        n = end - len(self._readbuffer)
+        buf = self._readbuffer[self._offset :]
+        self._readbuffer = b""
+        self._offset = 0
+        if n > 0:
+            while not self._eof:
+                data = self._read1(n)
+                if n < len(data):
+                    self._readbuffer = data
+                    self._offset = n
+                    buf += data[:n]
+                    break
+                if data:
+                    buf += data
+                    break
+        return buf
+
+    def _read1(self, n):
+        # Read up to n compressed bytes with at most one read() system call,
+        # decrypt and decompress them.
+        if self._eof or n <= 0:
+            return b""
+
+        # Read from file.
+        data = self._read2(n)
+        self._eof = self._compress_left <= 0
+        data = data[: self._left]
+        self._left -= len(data)
+        if self._left <= 0:
+            self._eof = True
+        self._update_crc(data)
+        return data
+
+    def _read2(self, n):
+        if self._compress_left <= 0:
+            return b""
+
+        n = max(n, self.MIN_READ_SIZE)
+        n = min(n, self._compress_left)
+
+        data = self._fileobj.read(n)
+        self._compress_left -= len(data)
+        if not data:
+            raise EOFError
+
+        if self._decrypter is not None:
+            data = self._decrypter(data)
+        return data
+
+    def close(self):
+        try:
+            if self._close_fileobj:
+                self._fileobj.close()
+        finally:
+            super().close()
+
+    def seekable(self):
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        return self._seekable
+
+    def seek(self, offset, whence=0):
+        if self.closed:
+            raise ValueError("seek on closed file.")
+        if not self._seekable:
+            raise io.UnsupportedOperation("underlying stream is not seekable")
+        curr_pos = self.tell()
+        if whence == 0:  # Seek from start of file
+            new_pos = offset
+        elif whence == 1:  # Seek from current position
+            new_pos = curr_pos + offset
+        elif whence == 2:  # Seek from EOF
+            new_pos = self._orig_file_size + offset
+        else:
+            raise ValueError("whence must be os.SEEK_SET (0), " "os.SEEK_CUR (1), or os.SEEK_END (2)")
+
+        if new_pos > self._orig_file_size:
+            new_pos = self._orig_file_size
+
+        if new_pos < 0:
+            new_pos = 0
+
+        read_offset = new_pos - curr_pos
+        buff_offset = read_offset + self._offset
+
+        if buff_offset >= 0 and buff_offset < len(self._readbuffer):
+            # Just move the _offset index if the new position is in the _readbuffer
+            self._offset = buff_offset
+            read_offset = 0
+        elif read_offset < 0:
+            # Position is before the current position. Reset the ZipExtFile
+            self._fileobj.seek(self._orig_compress_start)
+            self._running_crc = self._orig_start_crc
+            self._compress_left = self._orig_compress_size
+            self._left = self._orig_file_size
+            self._readbuffer = b""
+            self._offset = 0
+            self._eof = False
+            read_offset = new_pos
+            if self._decrypter is not None:
+                self._init_decrypter()
+
+        while read_offset > 0:
+            read_len = min(self.MAX_SEEK_READ, read_offset)
+            self.read(read_len)
+            read_offset -= read_len
+
+        return self.tell()
+
+    def tell(self):
+        if self.closed:
+            raise ValueError("tell on closed file.")
+        if not self._seekable:
+            raise io.UnsupportedOperation("underlying stream is not seekable")
+        filepos = self._orig_file_size - self._left - len(self._readbuffer) + self._offset
+        return filepos
+
+
+class SlimZipFile:
+    fp = None  # Set here since __del__ checks it
+
+    def __init__(self, file: str, mode="r", allowZip64=True, compresslevel=None):
+        if mode not in ("r",):
+            raise ValueError("ZipFile requires mode 'r'")
+
+        self._allowZip64 = allowZip64
+        self._didModify = False
+        self.debug = 0  # Level of printing: 0 through 3
+        self.NameToInfo = {}  # Find file info given name
+        self.mode = mode
+        self.pwd = None
+        self._comment = b""
+
+        self._filePassed = 0
+        self.filename = file
+        if file.startswith("s3://"):
+            assert mox is not None, f"File path starts with s3:// {file}, you need to run on Modelarts!!"
+            self.fp = mox.file.File(file, "rb")
+        else:
+            self.fp = io.open(file, "rb")
+        self._fileRefCnt = 1
+        self._lock = threading.RLock()
+        self._seekable = True
+        self._writing = False
+        self._RealGetContents()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def _RealGetContents(self):
+        """Read in the table of contents for the ZIP file."""
+        fp = self.fp
+        try:
+            endrec = _EndRecData(fp)
+        except OSError:
+            raise BadZipFile("File is not a zip file")
+        if not endrec:
+            raise BadZipFile("File is not a zip file")
+
+        size_cd = endrec[_ECD_SIZE]  # bytes in central directory
+        offset_cd = endrec[_ECD_OFFSET]  # offset of central directory
+        self._comment = endrec[_ECD_COMMENT]  # archive comment
+
+        # "concat" is zero, unless zip was concatenated to another file
+        concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
+        if endrec[_ECD_SIGNATURE] == stringEndArchive64:
+            # If Zip64 extension structures are present, account for them
+            concat -= sizeEndCentDir64 + sizeEndCentDir64Locator
+
+        # self.start_dir:  Position of start of central directory
+        self.start_dir = offset_cd + concat
+        fp.seek(self.start_dir, 0)
+        data = fp.read(size_cd)
+        fp = io.BytesIO(data)
+        total = 0
+        while total < size_cd:
+            centdir = fp.read(sizeCentralDir)
+            if len(centdir) != sizeCentralDir:
+                raise BadZipFile("Truncated central directory")
+            centdir = struct.unpack(structCentralDir, centdir)
+            if centdir[_CD_SIGNATURE] != stringCentralDir:
+                raise BadZipFile("Bad magic number for central directory")
+
+            filename = fp.read(centdir[_CD_FILENAME_LENGTH])
+            flags = centdir[_CD_FLAG_BITS]
+            if flags & _MASK_UTF_FILENAME:
+                # UTF-8 file names extension
+                filename = filename.decode("utf-8")
+            else:
+                # Historical ZIP filename encoding
+                filename = filename.decode("cp437")
+            # Create ZipInfo instance to store file information
+            x = ZipInfo(filename)
+            extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
+            _ = fp.read(centdir[_CD_COMMENT_LENGTH])  # x.comment
+
+            x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET]
+            (_, _, extract_version, _, _, _, _, _, x.CRC, x.compress_size, x.file_size) = centdir[1:12]
+            if extract_version > MAX_EXTRACT_VERSION:
+                raise NotImplementedError("zip file version %.1f" % (extract_version / 10))
+            _, _, _ = centdir[15:18]
+
+            x._decodeExtra(extra)
+            x.header_offset = x.header_offset + concat
+            self.NameToInfo[x.filename] = x
+
+            # update total bytes read from central directory
+            total = (
+                total
+                + sizeCentralDir
+                + centdir[_CD_FILENAME_LENGTH]
+                + centdir[_CD_EXTRA_FIELD_LENGTH]
+                + centdir[_CD_COMMENT_LENGTH]
+            )
+
+        # from pympler import asizeof
+        # print("size of x = {:.6f}GB".format(asizeof.asizeof(self.NameToInfo) / 1024. / 1024. / 1024.))
+
+    def namelist(self):
+        return list(self.NameToInfo.keys())
+
+    def getinfo(self, name):
+        info = self.NameToInfo.get(name)
+        if info is None:
+            raise KeyError("There is no item named %r in the archive" % name)
+
+        return info
+
+    def read(self, name, pwd=None):
+        """Return file bytes for name."""
+        with self.open(name, "r", pwd) as fp:
+            return fp.read()
+
+    def open(self, name, mode="r", *, force_zip64=False):
+        if mode not in {
+            "r",
+        }:
+            raise ValueError('open() requires mode "r"')
+
+        if not self.fp:
+            raise ValueError("Attempt to use ZIP archive that was already closed")
+
+        # Make sure we have an info object
+        zinfo = self.getinfo(name)
+
+        # Open for reading:
+        self._fileRefCnt += 1
+        zef_file = _SharedFile(self.fp, zinfo.header_offset, self._fpclose, self._lock, lambda: self._writing)
+        try:
+            # Skip the file header:
+            fheader = zef_file.read(sizeFileHeader)
+            if len(fheader) != sizeFileHeader:
+                raise BadZipFile("Truncated file header")
+            fheader = struct.unpack(structFileHeader, fheader)
+            if fheader[_FH_SIGNATURE] != stringFileHeader:
+                raise BadZipFile("Bad magic number for file header")
+
+            fname = zef_file.read(fheader[_FH_FILENAME_LENGTH])
+            if fheader[_FH_EXTRA_FIELD_LENGTH]:
+                zef_file.seek(fheader[_FH_EXTRA_FIELD_LENGTH], whence=1)
+
+            if fheader[_FH_GENERAL_PURPOSE_FLAG_BITS] & _MASK_UTF_FILENAME:
+                # UTF-8 filename
+                fname_str = fname.decode("utf-8")
+            else:
+                fname_str = fname.decode("cp437")
+
+            if fname_str != zinfo.filename:
+                raise BadZipFile("File name in directory %r and header %r differ." % (zinfo.filename, fname))
+
+            return ZipExtFile(zef_file, mode, zinfo, True)
+        except:
+            zef_file.close()
+            raise
+
+    def __del__(self):
+        """Call the "close()" method in case the user forgot."""
+        self.close()
+
+    def close(self):
+        """Close the file, and for mode 'w', 'x' and 'a' write the ending
+        records."""
+        if self.fp is None:
+            return
+
+        fp = self.fp
+        self.fp = None
+        self._fpclose(fp)
+
+    def _write_end_record(self):
+        raise NotImplementedError
+
+    def _fpclose(self, fp):
+        assert self._fileRefCnt > 0
+        self._fileRefCnt -= 1
+        if not self._fileRefCnt and not self._filePassed:
+            fp.close()

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/slim_zipfile2.py

@@ -0,0 +1,810 @@
+"""
+Read and write ZIP files.
+XXX references to utf-8 need further investigation.
+"""
+import binascii
+import importlib.util
+import io
+import itertools
+import os
+import posixpath
+import shutil
+import stat
+import struct
+import sys
+import threading
+import time
+import contextlib
+import pathlib
+
+try:
+    import zlib # We may need its compression method
+    crc32 = zlib.crc32
+except ImportError:
+    zlib = None
+    crc32 = binascii.crc32
+
+try:
+    import moxing as mox
+except ImportError:
+    mox = None
+
+class BadZipFile(Exception):
+    pass
+
+
+ZIP64_LIMIT = (1 << 31) - 1
+ZIP_FILECOUNT_LIMIT = (1 << 16) - 1
+ZIP_MAX_COMMENT = (1 << 16) - 1
+
+# constants for Zip file compression methods
+ZIP_STORED = 0
+ZIP_DEFLATED = 8
+ZIP_BZIP2 = 12
+ZIP_LZMA = 14
+# Other ZIP compression methods not supported
+
+DEFAULT_VERSION = 20
+ZIP64_VERSION = 45
+BZIP2_VERSION = 46
+LZMA_VERSION = 63
+# we recognize (but not necessarily support) all features up to that version
+MAX_EXTRACT_VERSION = 63
+
+# Below are some formats and associated data for reading/writing headers using
+# the struct module.  The names and structures of headers/records are those used
+# in the PKWARE description of the ZIP file format:
+#     http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+# (URL valid as of January 2008)
+
+# The "end of central directory" structure, magic number, size, and indices
+# (section V.I in the format document)
+structEndArchive = b"<4s4H2LH"
+stringEndArchive = b"PK\005\006"
+sizeEndCentDir = struct.calcsize(structEndArchive)
+
+_ECD_SIGNATURE = 0
+_ECD_DISK_NUMBER = 1
+_ECD_DISK_START = 2
+_ECD_ENTRIES_THIS_DISK = 3
+_ECD_ENTRIES_TOTAL = 4
+_ECD_SIZE = 5
+_ECD_OFFSET = 6
+_ECD_COMMENT_SIZE = 7
+# These last two indices are not part of the structure as defined in the
+# spec, but they are used internally by this module as a convenience
+_ECD_COMMENT = 8
+_ECD_LOCATION = 9
+
+# The "central directory" structure, magic number, size, and indices
+# of entries in the structure (section V.F in the format document)
+structCentralDir = "<4s4B4HL2L5H2L"
+stringCentralDir = b"PK\001\002"
+sizeCentralDir = struct.calcsize(structCentralDir)
+
+# indexes of entries in the central directory structure
+_CD_SIGNATURE = 0
+_CD_CREATE_VERSION = 1
+_CD_CREATE_SYSTEM = 2
+_CD_EXTRACT_VERSION = 3
+_CD_EXTRACT_SYSTEM = 4
+_CD_FLAG_BITS = 5
+_CD_COMPRESS_TYPE = 6
+_CD_TIME = 7
+_CD_DATE = 8
+_CD_CRC = 9
+_CD_COMPRESSED_SIZE = 10
+_CD_UNCOMPRESSED_SIZE = 11
+_CD_FILENAME_LENGTH = 12
+_CD_EXTRA_FIELD_LENGTH = 13
+_CD_COMMENT_LENGTH = 14
+_CD_DISK_NUMBER_START = 15
+_CD_INTERNAL_FILE_ATTRIBUTES = 16
+_CD_EXTERNAL_FILE_ATTRIBUTES = 17
+_CD_LOCAL_HEADER_OFFSET = 18
+
+# General purpose bit flags
+# Zip Appnote: 4.4.4 general purpose bit flag: (2 bytes)
+_MASK_ENCRYPTED = 1 << 0
+# Bits 1 and 2 have different meanings depending on the compression used.
+_MASK_COMPRESS_OPTION_1 = 1 << 1
+# _MASK_COMPRESS_OPTION_2 = 1 << 2
+# _MASK_USE_DATA_DESCRIPTOR: If set, crc-32, compressed size and uncompressed
+# size are zero in the local header and the real values are written in the data
+# descriptor immediately following the compressed data.
+_MASK_USE_DATA_DESCRIPTOR = 1 << 3
+# Bit 4: Reserved for use with compression method 8, for enhanced deflating.
+# _MASK_RESERVED_BIT_4 = 1 << 4
+_MASK_COMPRESSED_PATCH = 1 << 5
+_MASK_STRONG_ENCRYPTION = 1 << 6
+# _MASK_UNUSED_BIT_7 = 1 << 7
+# _MASK_UNUSED_BIT_8 = 1 << 8
+# _MASK_UNUSED_BIT_9 = 1 << 9
+# _MASK_UNUSED_BIT_10 = 1 << 10
+_MASK_UTF_FILENAME = 1 << 11
+# Bit 12: Reserved by PKWARE for enhanced compression.
+# _MASK_RESERVED_BIT_12 = 1 << 12
+# _MASK_ENCRYPTED_CENTRAL_DIR = 1 << 13
+# Bit 14, 15: Reserved by PKWARE
+# _MASK_RESERVED_BIT_14 = 1 << 14
+# _MASK_RESERVED_BIT_15 = 1 << 15
+
+# The "local file header" structure, magic number, size, and indices
+# (section V.A in the format document)
+structFileHeader = "<4s2B4HL2L2H"
+stringFileHeader = b"PK\003\004"
+sizeFileHeader = struct.calcsize(structFileHeader)
+
+_FH_SIGNATURE = 0
+_FH_EXTRACT_VERSION = 1
+_FH_EXTRACT_SYSTEM = 2
+_FH_GENERAL_PURPOSE_FLAG_BITS = 3
+_FH_COMPRESSION_METHOD = 4
+_FH_LAST_MOD_TIME = 5
+_FH_LAST_MOD_DATE = 6
+_FH_CRC = 7
+_FH_COMPRESSED_SIZE = 8
+_FH_UNCOMPRESSED_SIZE = 9
+_FH_FILENAME_LENGTH = 10
+_FH_EXTRA_FIELD_LENGTH = 11
+
+# The "Zip64 end of central directory locator" structure, magic number, and size
+structEndArchive64Locator = "<4sLQL"
+stringEndArchive64Locator = b"PK\x06\x07"
+sizeEndCentDir64Locator = struct.calcsize(structEndArchive64Locator)
+
+# The "Zip64 end of central directory" record, magic number, size, and indices
+# (section V.G in the format document)
+structEndArchive64 = "<4sQ2H2L4Q"
+stringEndArchive64 = b"PK\x06\x06"
+sizeEndCentDir64 = struct.calcsize(structEndArchive64)
+
+_CD64_SIGNATURE = 0
+_CD64_DIRECTORY_RECSIZE = 1
+_CD64_CREATE_VERSION = 2
+_CD64_EXTRACT_VERSION = 3
+_CD64_DISK_NUMBER = 4
+_CD64_DISK_NUMBER_START = 5
+_CD64_NUMBER_ENTRIES_THIS_DISK = 6
+_CD64_NUMBER_ENTRIES_TOTAL = 7
+_CD64_DIRECTORY_SIZE = 8
+_CD64_OFFSET_START_CENTDIR = 9
+
+_DD_SIGNATURE = 0x08074b50
+
+
+def _EndRecData64(fpin, offset, endrec):
+    """
+    Read the ZIP64 end-of-archive records and use that to update endrec
+    """
+    try:
+        fpin.seek(offset - sizeEndCentDir64Locator, 2)
+    except OSError:
+        # If the seek fails, the file is not large enough to contain a ZIP64
+        # end-of-archive record, so just return the end record we were given.
+        return endrec
+
+    data = fpin.read(sizeEndCentDir64Locator)
+    if len(data) != sizeEndCentDir64Locator:
+        return endrec
+    sig, diskno, reloff, disks = struct.unpack(structEndArchive64Locator, data)
+    if sig != stringEndArchive64Locator:
+        return endrec
+
+    if diskno != 0 or disks > 1:
+        raise BadZipFile("zipfiles that span multiple disks are not supported")
+
+    # Assume no 'zip64 extensible data'
+    fpin.seek(offset - sizeEndCentDir64Locator - sizeEndCentDir64, 2)
+    data = fpin.read(sizeEndCentDir64)
+    if len(data) != sizeEndCentDir64:
+        return endrec
+    sig, sz, _, read_version, disk_num, disk_dir, \
+        dircount, dircount2, dirsize, diroffset = \
+        struct.unpack(structEndArchive64, data)
+    if sig != stringEndArchive64:
+        return endrec
+
+    # Update the original endrec using data from the ZIP64 record
+    endrec[_ECD_SIGNATURE] = sig
+    endrec[_ECD_DISK_NUMBER] = disk_num
+    endrec[_ECD_DISK_START] = disk_dir
+    endrec[_ECD_ENTRIES_THIS_DISK] = dircount
+    endrec[_ECD_ENTRIES_TOTAL] = dircount2
+    endrec[_ECD_SIZE] = dirsize
+    endrec[_ECD_OFFSET] = diroffset
+    return endrec
+
+
+def _EndRecData(fpin):
+    """Return data from the "End of Central Directory" record, or None.
+    The data is a list of the nine items in the ZIP "End of central dir"
+    record followed by a tenth item, the file seek offset of this record."""
+
+    # Determine file size
+    fpin.seek(0, 2)
+    filesize = fpin.tell()
+
+    # Check to see if this is ZIP file with no archive comment (the
+    # "end of central directory" structure should be the last item in the
+    # file if this is the case).
+    try:
+        fpin.seek(-sizeEndCentDir, 2)
+    except OSError:
+        return None
+    data = fpin.read()
+    if (len(data) == sizeEndCentDir and
+        data[0:4] == stringEndArchive and
+        data[-2:] == b"\000\000"):
+        # the signature is correct and there's no comment, unpack structure
+        endrec = struct.unpack(structEndArchive, data)
+        endrec=list(endrec)
+
+        # Append a blank comment and record start offset
+        endrec.append(b"")
+        endrec.append(filesize - sizeEndCentDir)
+
+        # Try to read the "Zip64 end of central directory" structure
+        return _EndRecData64(fpin, -sizeEndCentDir, endrec)
+
+    # Either this is not a ZIP file, or it is a ZIP file with an archive
+    # comment.  Search the end of the file for the "end of central directory"
+    # record signature. The comment is the last item in the ZIP file and may be
+    # up to 64K long.  It is assumed that the "end of central directory" magic
+    # number does not appear in the comment.
+    maxCommentStart = max(filesize - (1 << 16) - sizeEndCentDir, 0)
+    fpin.seek(maxCommentStart, 0)
+    data = fpin.read()
+    start = data.rfind(stringEndArchive)
+    if start >= 0:
+        # found the magic number; attempt to unpack and interpret
+        recData = data[start:start+sizeEndCentDir]
+        if len(recData) != sizeEndCentDir:
+            # Zip file is corrupted.
+            return None
+        endrec = list(struct.unpack(structEndArchive, recData))
+        commentSize = endrec[_ECD_COMMENT_SIZE] #as claimed by the zip file
+        comment = data[start+sizeEndCentDir:start+sizeEndCentDir+commentSize]
+        endrec.append(comment)
+        endrec.append(maxCommentStart + start)
+
+        # Try to read the "Zip64 end of central directory" structure
+        return _EndRecData64(fpin, maxCommentStart + start - filesize,
+                             endrec)
+
+    # Unable to find a valid end of central directory structure
+    return None
+
+
+class ZipInfo(object):
+    __slots__ = (
+        'filename',
+        'header_offset',
+        'CRC',
+        'compress_size',
+        'file_size',
+    )
+
+    def __init__(self, filename="NoName"):
+        self.filename = filename
+        self.compress_size = 0          # Size of the compressed file
+        self.file_size = 0              # Size of the uncompressed file
+
+
+    def _decodeExtra(self, extra):
+        # Try to decode the extra field.
+        unpack = struct.unpack
+        while len(extra) >= 4:
+            tp, ln = unpack('<HH', extra[:4])
+            if ln+4 > len(extra):
+                raise BadZipFile("Corrupt extra field %04x (size=%d)" % (tp, ln))
+            if tp == 0x0001:
+                data = extra[4:ln+4]
+                # ZIP64 extension (large files and/or large archives)
+                try:
+                    if self.file_size in (0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF):
+                        field = "File size"
+                        self.file_size, = unpack('<Q', data[:8])
+                        data = data[8:]
+                    if self.compress_size == 0xFFFF_FFFF:
+                        field = "Compress size"
+                        self.compress_size, = unpack('<Q', data[:8])
+                        data = data[8:]
+                    if self.header_offset == 0xFFFF_FFFF:
+                        field = "Header offset"
+                        self.header_offset, = unpack('<Q', data[:8])
+                except struct.error:
+                    raise BadZipFile(f"Corrupt zip64 extra field. "
+                                     f"{field} not found.") from None
+
+            extra = extra[ln+4:]
+
+
+class _SharedFile:
+    def __init__(self, file, pos, close, lock, writing):
+        self._file = file
+        self._pos = pos
+        self._close = close
+        self._lock = lock
+        self._writing = writing
+        self.seekable = file.seekable
+
+    def tell(self):
+        return self._pos
+
+    def seek(self, offset, whence=0):
+        with self._lock:
+            if self._writing():
+                raise ValueError("Can't reposition in the ZIP file while "
+                        "there is an open writing handle on it. "
+                        "Close the writing handle before trying to read.")
+            self._file.seek(offset, whence)
+            self._pos = self._file.tell()
+            return self._pos
+
+    def read(self, n=-1):
+        with self._lock:
+            if self._writing():
+                raise ValueError("Can't read from the ZIP file while there "
+                        "is an open writing handle on it. "
+                        "Close the writing handle before trying to read.")
+            self._file.seek(self._pos)
+            data = self._file.read(n)
+            self._pos = self._file.tell()
+            return data
+
+    def close(self):
+        if self._file is not None:
+            fileobj = self._file
+            self._file = None
+            self._close(fileobj)
+
+
+class ZipExtFile(io.BufferedIOBase):
+    """File-like object for reading an archive member.
+       Is returned by ZipFile.open().
+    """
+
+    # Max size supported by decompressor.
+    MAX_N = 1 << 31 - 1
+
+    # Read from compressed files in 4k blocks.
+    MIN_READ_SIZE = 4096
+
+    # Chunk size to read during seek
+    MAX_SEEK_READ = 1 << 24
+
+    def __init__(self, fileobj, mode, zipinfo, close_fileobj=False):
+        self._fileobj = fileobj
+        self._close_fileobj = close_fileobj
+        self._compress_left = zipinfo.compress_size
+        self._left = zipinfo.file_size
+        self._eof = False
+        self._readbuffer = b''
+        self._offset = 0
+
+        self.newlines = None
+
+        self.mode = mode
+        self.name = zipinfo.filename
+
+        if hasattr(zipinfo, 'CRC'):
+            self._expected_crc = zipinfo.CRC
+            self._running_crc = crc32(b'')
+        else:
+            self._expected_crc = None
+
+        self._seekable = False
+        try:
+            if fileobj.seekable():
+                self._orig_compress_start = fileobj.tell()
+                self._orig_compress_size = zipinfo.compress_size
+                self._orig_file_size = zipinfo.file_size
+                self._orig_start_crc = self._running_crc
+                self._seekable = True
+        except AttributeError:
+            pass
+
+        self._decrypter = None
+
+    def _init_decrypter(self):
+        raise NotImplementedError
+
+    def readline(self, limit=-1):
+        """Read and return a line from the stream.
+        If limit is specified, at most limit bytes will be read.
+        """
+
+        if limit < 0:
+            # Shortcut common case - newline found in buffer.
+            i = self._readbuffer.find(b'\n', self._offset) + 1
+            if i > 0:
+                line = self._readbuffer[self._offset: i]
+                self._offset = i
+                return line
+
+        return io.BufferedIOBase.readline(self, limit)
+
+    def peek(self, n=1):
+        """Returns buffered bytes without advancing the position."""
+        if n > len(self._readbuffer) - self._offset:
+            chunk = self.read(n)
+            if len(chunk) > self._offset:
+                self._readbuffer = chunk + self._readbuffer[self._offset:]
+                self._offset = 0
+            else:
+                self._offset -= len(chunk)
+
+        # Return up to 512 bytes to reduce allocation overhead for tight loops.
+        return self._readbuffer[self._offset: self._offset + 512]
+
+    def readable(self):
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        return True
+
+    def read(self, n=-1):
+        """Read and return up to n bytes.
+        If the argument is omitted, None, or negative, data is read and returned until EOF is reached.
+        """
+        if self.closed:
+            raise ValueError("read from closed file.")
+        if n is None or n < 0:
+            buf = self._readbuffer[self._offset:]
+            self._readbuffer = b''
+            self._offset = 0
+            while not self._eof:
+                buf += self._read1(self.MAX_N)
+            return buf
+
+        end = n + self._offset
+        if end < len(self._readbuffer):
+            buf = self._readbuffer[self._offset:end]
+            self._offset = end
+            return buf
+
+        n = end - len(self._readbuffer)
+        buf = self._readbuffer[self._offset:]
+        self._readbuffer = b''
+        self._offset = 0
+        while n > 0 and not self._eof:
+            data = self._read1(n)
+            if n < len(data):
+                self._readbuffer = data
+                self._offset = n
+                buf += data[:n]
+                break
+            buf += data
+            n -= len(data)
+        return buf
+
+    def _update_crc(self, newdata):
+        # Update the CRC using the given data.
+        if self._expected_crc is None:
+            # No need to compute the CRC if we don't have a reference value
+            return
+        self._running_crc = crc32(newdata, self._running_crc)
+        # Check the CRC if we're at the end of the file
+        if self._eof and self._running_crc != self._expected_crc:
+            raise BadZipFile("Bad CRC-32 for file %r" % self.name)
+
+    def read1(self, n):
+        """Read up to n bytes with at most one read() system call."""
+
+        if n is None or n < 0:
+            buf = self._readbuffer[self._offset:]
+            self._readbuffer = b''
+            self._offset = 0
+            while not self._eof:
+                data = self._read1(self.MAX_N)
+                if data:
+                    buf += data
+                    break
+            return buf
+
+        end = n + self._offset
+        if end < len(self._readbuffer):
+            buf = self._readbuffer[self._offset:end]
+            self._offset = end
+            return buf
+
+        n = end - len(self._readbuffer)
+        buf = self._readbuffer[self._offset:]
+        self._readbuffer = b''
+        self._offset = 0
+        if n > 0:
+            while not self._eof:
+                data = self._read1(n)
+                if n < len(data):
+                    self._readbuffer = data
+                    self._offset = n
+                    buf += data[:n]
+                    break
+                if data:
+                    buf += data
+                    break
+        return buf
+
+    def _read1(self, n):
+        # Read up to n compressed bytes with at most one read() system call,
+        # decrypt and decompress them.
+        if self._eof or n <= 0:
+            return b''
+
+        # Read from file.
+        data = self._read2(n)
+        self._eof = self._compress_left <= 0
+        data = data[:self._left]
+        self._left -= len(data)
+        if self._left <= 0:
+            self._eof = True
+        self._update_crc(data)
+        return data
+
+    def _read2(self, n):
+        if self._compress_left <= 0:
+            return b''
+
+        n = max(n, self.MIN_READ_SIZE)
+        n = min(n, self._compress_left)
+
+        data = self._fileobj.read(n)
+        self._compress_left -= len(data)
+        if not data:
+            raise EOFError
+
+        if self._decrypter is not None:
+            data = self._decrypter(data)
+        return data
+
+    def close(self):
+        try:
+            if self._close_fileobj:
+                self._fileobj.close()
+        finally:
+            super().close()
+
+    def seekable(self):
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        return self._seekable
+
+    def seek(self, offset, whence=0):
+        if self.closed:
+            raise ValueError("seek on closed file.")
+        if not self._seekable:
+            raise io.UnsupportedOperation("underlying stream is not seekable")
+        curr_pos = self.tell()
+        if whence == 0: # Seek from start of file
+            new_pos = offset
+        elif whence == 1: # Seek from current position
+            new_pos = curr_pos + offset
+        elif whence == 2: # Seek from EOF
+            new_pos = self._orig_file_size + offset
+        else:
+            raise ValueError("whence must be os.SEEK_SET (0), "
+                             "os.SEEK_CUR (1), or os.SEEK_END (2)")
+
+        if new_pos > self._orig_file_size:
+            new_pos = self._orig_file_size
+
+        if new_pos < 0:
+            new_pos = 0
+
+        read_offset = new_pos - curr_pos
+        buff_offset = read_offset + self._offset
+
+        if buff_offset >= 0 and buff_offset < len(self._readbuffer):
+            # Just move the _offset index if the new position is in the _readbuffer
+            self._offset = buff_offset
+            read_offset = 0
+        elif read_offset < 0:
+            # Position is before the current position. Reset the ZipExtFile
+            self._fileobj.seek(self._orig_compress_start)
+            self._running_crc = self._orig_start_crc
+            self._compress_left = self._orig_compress_size
+            self._left = self._orig_file_size
+            self._readbuffer = b''
+            self._offset = 0
+            self._eof = False
+            read_offset = new_pos
+            if self._decrypter is not None:
+                self._init_decrypter()
+
+        while read_offset > 0:
+            read_len = min(self.MAX_SEEK_READ, read_offset)
+            self.read(read_len)
+            read_offset -= read_len
+
+        return self.tell()
+
+    def tell(self):
+        if self.closed:
+            raise ValueError("tell on closed file.")
+        if not self._seekable:
+            raise io.UnsupportedOperation("underlying stream is not seekable")
+        filepos = self._orig_file_size - self._left - len(self._readbuffer) + self._offset
+        return filepos
+
+
+class SlimZipFile:
+    fp = None                   # Set here since __del__ checks it
+
+    def __init__(self, file: str, mode="r", allowZip64=True, compresslevel=None):
+        if mode not in ('r',):
+            raise ValueError("ZipFile requires mode 'r'")
+
+        self._allowZip64 = allowZip64
+        self._didModify = False
+        self.debug = 0  # Level of printing: 0 through 3
+        self.NameToInfo = {}    # Find file info given name
+        self.mode = mode
+        self.pwd = None
+        self._comment = b''
+
+        self._filePassed = 0
+        self.filename = file
+        if file.startswith("s3://"):
+            assert mox is not None, f"File path starts with s3:// {file}, you need to run on Modelarts!!"
+            self.fp = mox.file.File(file, "rb")
+        else:
+            self.fp = io.open(file, "rb")
+        self._fileRefCnt = 1
+        self._lock = threading.RLock()
+        self._seekable = True
+        self._writing = False
+        self._RealGetContents()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def _RealGetContents(self):
+        """Read in the table of contents for the ZIP file."""
+        fp = self.fp
+        try:
+            endrec = _EndRecData(fp)
+        except OSError:
+            raise BadZipFile("File is not a zip file")
+        if not endrec:
+            raise BadZipFile("File is not a zip file")
+
+        size_cd = endrec[_ECD_SIZE]             # bytes in central directory
+        offset_cd = endrec[_ECD_OFFSET]         # offset of central directory
+        self._comment = endrec[_ECD_COMMENT]    # archive comment
+
+        # "concat" is zero, unless zip was concatenated to another file
+        concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
+        if endrec[_ECD_SIGNATURE] == stringEndArchive64:
+            # If Zip64 extension structures are present, account for them
+            concat -= (sizeEndCentDir64 + sizeEndCentDir64Locator)
+
+        # self.start_dir:  Position of start of central directory
+        self.start_dir = offset_cd + concat
+        fp.seek(self.start_dir, 0)
+        data = fp.read(size_cd)
+        fp = io.BytesIO(data)
+        total = 0
+        while total < size_cd:
+            centdir = fp.read(sizeCentralDir)
+            if len(centdir) != sizeCentralDir:
+                raise BadZipFile("Truncated central directory")
+            centdir = struct.unpack(structCentralDir, centdir)
+            if centdir[_CD_SIGNATURE] != stringCentralDir:
+                raise BadZipFile("Bad magic number for central directory")
+
+            filename = fp.read(centdir[_CD_FILENAME_LENGTH])
+            flags = centdir[_CD_FLAG_BITS]
+            if flags & _MASK_UTF_FILENAME:
+                # UTF-8 file names extension
+                filename = filename.decode('utf-8')
+            else:
+                # Historical ZIP filename encoding
+                filename = filename.decode('cp437')
+            # Create ZipInfo instance to store file information
+            x = ZipInfo(filename)
+            extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
+            _ = fp.read(centdir[_CD_COMMENT_LENGTH]) # x.comment
+
+            x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET]
+            (_, _, extract_version, _, _, _, _, _, x.CRC, x.compress_size, x.file_size) = centdir[1:12]
+            if extract_version > MAX_EXTRACT_VERSION:
+                raise NotImplementedError("zip file version %.1f" % (extract_version / 10))
+            _, _, _ = centdir[15:18]
+
+            x._decodeExtra(extra)
+            x.header_offset = x.header_offset + concat
+            self.NameToInfo[x.filename] = x
+
+            # update total bytes read from central directory
+            total = (total + sizeCentralDir + centdir[_CD_FILENAME_LENGTH]
+                     + centdir[_CD_EXTRA_FIELD_LENGTH]
+                     + centdir[_CD_COMMENT_LENGTH])
+
+        # from pympler import asizeof
+        # print("size of x = {:.6f}GB".format(asizeof.asizeof(self.NameToInfo) / 1024. / 1024. / 1024.))
+
+    def namelist(self):
+        return list(self.NameToInfo.keys())
+
+    def getinfo(self, name):
+        info = self.NameToInfo.get(name)
+        if info is None:
+            raise KeyError(
+                'There is no item named %r in the archive' % name)
+
+        return info
+
+    def read(self, name, pwd=None):
+        """Return file bytes for name."""
+        with self.open(name, "r", pwd) as fp:
+            return fp.read()
+
+    def open(self, name, mode="r", *, force_zip64=False):
+        if mode not in {"r", }:
+            raise ValueError('open() requires mode "r"')
+
+        if not self.fp:
+            raise ValueError(
+                "Attempt to use ZIP archive that was already closed")
+
+        # Make sure we have an info object
+        zinfo = self.getinfo(name)
+
+        # Open for reading:
+        self._fileRefCnt += 1
+        zef_file = _SharedFile(self.fp, zinfo.header_offset,
+                               self._fpclose, self._lock, lambda: self._writing)
+        try:
+            # Skip the file header:
+            fheader = zef_file.read(sizeFileHeader)
+            if len(fheader) != sizeFileHeader:
+                raise BadZipFile("Truncated file header")
+            fheader = struct.unpack(structFileHeader, fheader)
+            if fheader[_FH_SIGNATURE] != stringFileHeader:
+                raise BadZipFile("Bad magic number for file header")
+
+            fname = zef_file.read(fheader[_FH_FILENAME_LENGTH])
+            if fheader[_FH_EXTRA_FIELD_LENGTH]:
+                zef_file.seek(fheader[_FH_EXTRA_FIELD_LENGTH], whence=1)
+
+            if fheader[_FH_GENERAL_PURPOSE_FLAG_BITS] & _MASK_UTF_FILENAME:
+                # UTF-8 filename
+                fname_str = fname.decode("utf-8")
+            else:
+                fname_str = fname.decode("cp437")
+
+            if fname_str != zinfo.filename:
+                raise BadZipFile(
+                    'File name in directory %r and header %r differ.'
+                    % (zinfo.filename, fname))
+
+            return ZipExtFile(zef_file, mode, zinfo, True)
+        except:
+            zef_file.close()
+            raise
+
+    def __del__(self):
+        """Call the "close()" method in case the user forgot."""
+        self.close()
+
+    def close(self):
+        """Close the file, and for mode 'w', 'x' and 'a' write the ending
+        records."""
+        if self.fp is None:
+            return
+
+        fp = self.fp
+        self.fp = None
+        self._fpclose(fp)
+
+    def _write_end_record(self):
+        raise NotImplementedError
+
+    def _fpclose(self, fp):
+        assert self._fileRefCnt > 0
+        self._fileRefCnt -= 1
+        if not self._fileRefCnt and not self._filePassed:
+            fp.close()

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/t2i_dataset.py

@@ -0,0 +1,464 @@
+import os
+import math
+import re
+import random
+from copy import deepcopy
+import time
+import pickle
+import yaml
+import cv2
+from PIL import Image, PngImagePlugin, ImageFile
+import PIL
+import zipfile
+import tarfile
+
+Image.MAX_IMAGE_PIXELS = 933120000
+PngImagePlugin.MAX_TEXT_CHUNK = 1024 * 2**20
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+import pandas
+import numpy as np
+
+import torch
+from torch.utils import data
+
+# temp
+import os, sys
+sys.path.append(os.getcwd())
+
+from mimogpt.datasets.utils.ordered_yaml import ordered_yaml
+from mimogpt.datasets.slim_zipfile2 import SlimZipFile
+# from zipfile import ZipFile
+# from zipfile2 import ZipFile
+from mimogpt.datasets.utils.checker import DataChecker
+
+def pick_available_prompt(item, keys):
+    pattern = r'[^\u0000-\u007F]'
+    for key in keys:
+        if item[key] != '#':
+            if re.search(pattern, item[key]):
+                continue
+            return {key: item[key]}
+    return []
+
+def random_pick_available_prompt(item, keys):
+    pattern = r'[^\u0000-\u007F]'
+    prompts = {}
+    for key in keys:
+        if item[key] not in ['#', '']:
+            if re.search(pattern, item[key]):
+                continue
+            prompts[key] = item[key]
+
+    return prompts
+
+def random_pick_imagenet_ablation(item, key):
+    pattern = r'[^\u0000-\u007F]'
+    prompts = {}
+
+    if item[key] in ['#', '']:
+        raise NotImplementedError
+    if re.search(pattern, item[key]):
+        raise NotImplementedError
+
+    synset = [prompt.strip(' ') for prompt in item[key].split(',')]
+    for i in range(len(synset)):
+        prompts[str(i)] = synset[i]
+
+    return prompts
+
+def mox_copy(src, dst, unzip=False, delete_zip=False, threads=1, is_processing=False):
+    import moxing as mox
+    mox.file.copy_parallel(src, dst, threads=threads, is_processing=is_processing)
+    if unzip:
+        assert dst.endswith('.zip')
+        unzip_dst = os.path.abspath(dst.replace('.zip', ''))
+        if not os.path.exists(unzip_dst):
+            zip_file = zipfile.ZipFile(dst, 'r')
+            for f in zip_file.namelist():
+                zip_file.extract(f, unzip_dst)
+            zip_file.close()
+        if delete_zip:
+            os.remove(dst)
+
+def identity(a):
+    return a
+
+def identity2(a, b):
+    return a
+
+class Base(data.Dataset):
+    def __init__(self, opt):
+        super(Base, self).__init__()
+        self.checker = DataChecker(opt)
+
+        self.opt = opt['dataset']
+        self.rank = opt['rank']
+        self.replicas = opt['world_size']
+        self.batch_size = opt['batch_size']
+        self.enlarge_ratio = opt.dataset['enlarge_ratio']
+        assert self.rank < self.replicas
+
+        self.load_t5_cache = self.opt['load_t5_cache']
+        self.prompt_fn = random_pick_available_prompt if self.opt['prompt_augmentation'] else pick_available_prompt
+        self.prompts_randomless = self.opt.get('prompts_randomless', False)
+
+        self.sync_wait_time = self.opt.get('sync_wait_time', 1)
+        self.sync_wait_count = self.rank
+        self.sync_wait_ratio = self.opt.get('sync_wait_ratio', 1)
+        self._load_meta_info()
+
+        self.low_res_list = [] if 'low_res_list' not in self.opt else self.opt['low_res_list']
+        self.max_size = self.opt['max_size']
+        self.resize_f = self.opt['resize_f']
+        if self.opt['preprocess_func'] == 'identity':
+            self.preprocess_img_func = identity
+        elif self.opt['preprocess_func'] == 'resize_max':
+            self.preprocess_img_func = self.resize_max
+        elif self.opt['preprocess_func'] == 'center_crop':
+            self.preprocess_img_func = self.center_crop
+        else:
+            raise NotImplementedError
+        
+        self.enable_data_warmup = self.opt.get('enable_data_warmup', False)
+        
+    def _sync_data(self, pack):
+        if pack['sync_data'] and not os.path.exists(pack['zip']):
+            s3_path = os.path.join(pack['s3_zip_root'], os.path.basename(pack['zip']))
+            os.makedirs(os.path.dirname(pack['zip']), exist_ok=True)
+            print(f"Mox copy {s3_path} to {pack['zip']}")
+            remain = self.sync_wait_count % self.sync_wait_ratio
+            time.sleep(self.sync_wait_time * remain)
+            # mox_copy(s3_path, pack['zip'])
+            mox_copy(s3_path, pack['zip'], True)
+            self.sync_wait_count += 1
+
+    def get_balance_num(self, x, target, a=1, b=5):
+        ratio = x / target
+        return int(min(max(a, ratio), b))
+
+    def _load_meta_info(self):
+        self.packs = []
+        self._len = 0
+        with open(self.opt['meta_info'], mode='r') as f:
+            Loader, _ = ordered_yaml()
+            data_opt = yaml.load(f, Loader=Loader)
+
+        for info in data_opt['info']:
+            if len(info) == 10:
+                parquet_root, zip_root, t5_root, file_list, sync_data, \
+                s3_zip_root, is_cfg, duplicate, prompt_keys, dataset_name = info
+                balanced = 0
+            elif len(info) == 11:
+                parquet_root, zip_root, t5_root, file_list, sync_data, \
+                s3_zip_root, is_cfg, duplicate, prompt_keys, balanced, dataset_name = info
+            else:
+                raise NotImplementedError
+
+            duplicate = int(duplicate)
+            with open(file_list, 'r') as f:
+                parquet_list = f.readlines()
+                for parquet_name in parquet_list:
+
+                    parquet_name, parquet_len = parquet_name.strip('\n').split(' ')
+                    parquet_path = os.path.join(parquet_root, parquet_name)
+
+                    if dataset_name in ['Imagenet-1K-ablation']:
+                        zip_path = os.path.join(zip_root, parquet_name.split('-')[0] + '.tar')
+                    elif dataset_name in ['imagenet_untar']:
+                        parquet2zip_name_tmp = parquet_name[:2]+'_'+parquet_name[2:]
+                        zip_path = os.path.join(zip_root, parquet2zip_name_tmp.split('-')[0] + '.zip')
+                    else:
+                        zip_path = os.path.join(zip_root, parquet_name.replace('.parquet', '.zip'))
+
+                    t5_path = os.path.join(t5_root, parquet_name.replace('.parquet', '')) if t5_root is not None else None
+
+                    if balanced > 0:
+                        pack_num = 0
+                        balanced_list = []
+                        parquet = pandas.read_parquet(parquet_path)
+                        for i in range(parquet.shape[0]):
+                            cur_num = self.get_balance_num(int(parquet.iloc[i]['tag_count']), balanced)
+                            pack_num += cur_num
+                            balanced_list.extend([i] * cur_num)
+                        assert len(balanced_list) == pack_num
+                        pack_dic = {
+                            'parquet': parquet_path,
+                            'zip': zip_path,
+                            't5': t5_path,
+                            'cfg': is_cfg,
+                            'num': pack_num * duplicate,
+                            'sync_data': sync_data,
+                            's3_zip_root': s3_zip_root,
+                            'duplicate': duplicate,
+                            'prompt_keys': prompt_keys,
+                            'dataset_name': dataset_name,
+                            'balanced': balanced,
+                            'balanced_list': balanced_list
+                        }
+                    else:
+                        pack_dic = {
+                            'parquet': parquet_path,
+                            'zip': zip_path,
+                            't5': t5_path,
+                            'cfg': is_cfg,
+                            'num': int(parquet_len) * duplicate,
+                            'sync_data': sync_data,
+                            's3_zip_root': s3_zip_root,
+                            'duplicate': duplicate,
+                            'prompt_keys': prompt_keys,
+                            'dataset_name': dataset_name,
+                            'balanced': balanced,
+                        }
+
+                    self.packs.append(pack_dic)
+                    self._len += pack_dic['num']
+
+
+        self.paths = []
+        self.zip_fn = {}
+        self.t5_fn = {}
+
+        # self.num_sample_per_rank = math.ceil(self._len / self.replicas)
+        # assert self.num_sample_per_rank > 0
+        # start_idx = self.num_sample_per_rank * self.rank
+        # end_idx = start_idx + self.num_sample_per_rank
+
+        self.num_sample_per_rank = self._len // self.replicas
+        num_redundant_rank = self._len % self.replicas
+        assert self.num_sample_per_rank > 0
+        if num_redundant_rank > self.rank:
+            start_idx = (self.num_sample_per_rank + 1) * self.rank
+            end_idx = start_idx + self.num_sample_per_rank + 1
+        else:
+            start_idx = num_redundant_rank + self.num_sample_per_rank * self.rank
+            end_idx = start_idx + self.num_sample_per_rank 
+        self.num_sample_per_rank = math.ceil(self._len / self.replicas)
+
+        pack_g = torch.Generator()
+        pack_g.manual_seed(3407)
+        shuffle_pack_index = torch.randperm(len(self.packs), generator=pack_g).tolist()
+        # print(shuffle_pack_index)
+        self.packs = [self.packs[i] for i in shuffle_pack_index]
+
+        for i, pack in enumerate(self.packs):
+            if end_idx <= 0:
+                break
+            if start_idx < pack['num']:
+                if pack['dataset_name'] in ['7M_human_open', '7M_human_vertical']:
+                    suffix = '.jpg'
+                else:
+                    suffix = ''
+                self._sync_data(pack)
+                try:
+                    parquet = pandas.read_parquet(pack['parquet'])
+                except Exception as e:
+                    print(f'Error: {e}, parquet_path: {pack["parquet"]}')
+
+                for ii in range(max(0, start_idx), min(pack['num'], end_idx)):
+                    id_key = 'ID'
+                    # cheat
+                    ii = ii // pack['duplicate']
+                    if pack['balanced'] > 0:
+                        # cheat of cheat
+                        ii = pack['balanced_list'][ii]
+
+                    # if pack['dataset_name'] in ['Imagenet-1K-ablation']:
+                    if pack['dataset_name'] in ['Imagenet-1K-ablation'] or pack['dataset_name'] in ['imagenet_untar']:
+                        prompt = random_pick_imagenet_ablation(parquet.iloc[ii], "origin_caption")
+                        id_key = 'origin_ID1'
+                    else:
+                        prompt = self.prompt_fn(parquet.iloc[ii], pack["prompt_keys"])
+                    if len(prompt) == 0:
+                        continue
+                    single_dict = {
+                            'img_path': str(parquet.iloc[ii][id_key] + suffix),
+                            'prompt': prompt,
+                            'cfg': pack['cfg'],
+                            't5': pack['t5'],
+                            'zip': pack['zip'],
+                            'dataset_name': pack['dataset_name'],
+                            'parquet': pack["parquet"].split("/")[-1].replace('.parquet', ''),
+                        }
+                    if self.prompts_randomless:
+                        single_dict['full_prompt'] = deepcopy(single_dict['prompt'])
+                        
+                    self.paths.append(single_dict)
+                    
+            start_idx -= pack['num']
+            end_idx -= pack['num']
+
+        del self.packs
+        random.shuffle(self.paths)
+        print(f'Base dataloader [rank{self.rank}], length: {len(self.paths)}, Total length: {len(self)}')
+
+    def _read_img(self, dic):
+        if dic['zip'] not in self.zip_fn:
+            if dic['zip'].endswith('.tar'):
+                self.zip_fn[dic['zip']] = tarfile.open(dic['zip'], 'r')
+            else:
+                # self.zip_fn[dic['zip']] = SlimZipFile(dic['zip'])
+                self.zip_fn[dic['zip']] = zipfile.ZipFile(dic['zip'])
+
+        if dic['zip'].endswith('.tar'):
+            f = self.zip_fn[dic['zip']].extractfile(self.zip_fn[dic['zip']].getmember(dic['img_path']))
+        else:
+            f = self.zip_fn[dic['zip']].open(dic['img_path'], 'r')
+
+        img = np.ascontiguousarray(Image.open(f).convert('RGB')).astype(np.float32)
+        return self.preprocess_img_func(img)
+
+    def resize_max(self, img):
+        h, w = img.shape[:2]
+        reduce_factor = max(1, (h * w / self.max_size ** 2) ** 0.5)
+        w = ((w // reduce_factor) // self.resize_f) * self.resize_f
+        h = ((h // reduce_factor) // self.resize_f) * self.resize_f
+        ratio = h / w
+        img = cv2.resize(img, (int(w), int(h)), interpolation=cv2.INTER_AREA)
+
+        if ratio > 2 or ratio < 0.5:
+            return False, img
+        else:
+            return True, img
+
+    def center_crop(self, img):
+        h, w = img.shape[0:2]
+        size = min(h, w)
+        ratio = h / w
+
+        h = (h - size) // 2
+        w = (w - size) // 2
+        img = img[h:h + size, w:w + size, ...]
+        img = cv2.resize(img, (self.max_size, self.max_size), interpolation=cv2.INTER_AREA)
+
+        # if (size < self.max_size) or (ratio > 2) or (ratio < 0.5): # will be a bug if use small size images to train, will filter them out
+        if (ratio > 2) or (ratio < 0.5):
+            return False, img
+        elif (size < self.max_size) and (self.max_size<=1024):
+            return False, img
+        else:
+            return True, img
+
+    def _process(self, dic):
+        retry_image = 0
+        prompt_key: str = random.choice(list(dic['prompt'].keys()))
+        while retry_image <= 3:
+            if dic['t5'] is not None and self.load_t5_cache:
+                # if dic['t5'] not in self.t5_fn:
+                #     self.t5_fn[dic['t5']] = SlimZipFile(dic['t5'])
+                # with self.t5_fn[dic['t5']].open(dic['img_path'] + '.pkl', 'r') as f: 
+                #     t5_tensor = pickle.load(f)['T5_feature']
+                retry = 0
+                t5_tensor = None
+                while retry <= 3:
+                    t5_path = os.path.join(dic['t5'], prompt_key + ".zip", dic['img_path'] + '.pkl')
+                    try:
+                        t5_tensor = torch.load(t5_path, map_location='cpu')
+                        filter_max_token_len = self.opt['filter_max_token_len']
+                        if t5_tensor.shape[1] <= filter_max_token_len:
+                            break
+                    except Exception as e:
+                        print(f'Error: {e}, t5_path: {t5_path}, retry time {retry}')
+                        pass
+                    index = random.randint(0, len(self.paths) - 1)
+                    dic = self.paths[index]
+                    retry += 1
+            else:
+                t5_tensor = None
+
+            try:
+                is_pass, img = self._read_img(dic)
+            except Exception as e:
+                print(f'Error: {e}, img_path: {dic["img_path"]}, zip_path: {dic["zip"]}')
+                is_pass = False
+
+            if is_pass:
+                break
+            else:
+                index = random.randint(0, len(self.paths) - 1)
+                dic = self.paths[index]
+                prompt_key = random.choice(list(dic['prompt'].keys()))
+                retry_image += 1
+
+        # generate original and low resolution
+        ret = {}
+        original_img = img
+        for res in self.low_res_list:
+            low_img = cv2.resize(original_img, (res, res), interpolation=cv2.INTER_AREA)
+            low_img = (torch.from_numpy(low_img.transpose(2, 0, 1)).float() / 127.5) - 1
+            low_img = low_img.contiguous()
+            ret[f'image_{res}'] = low_img
+        img = (torch.from_numpy(img.transpose(2, 0, 1)).float() / 127.5) - 1
+        img = img.contiguous()
+
+        if self.prompts_randomless:
+            prompt = dic["prompt"].pop(prompt_key)
+            if len(dic["prompt"].keys()) == 0:
+                dic["prompt"] = deepcopy(dic['full_prompt'])
+        else:
+            prompt = dic["prompt"][prompt_key]
+        ret = ret | {
+            'image': img,
+            'prompt': prompt,
+            #'cfg': dic['cfg'],
+            #'t5': t5_tensor,
+            #'t5_path': None if dic['t5'] is None else os.path.join(dic['t5'], prompt_key + ".zip", dic['img_path'] + '.pkl'),
+            'debug_info': [dic['dataset_name'], dic["parquet"], dic["img_path"], prompt_key]
+        }
+
+        self.checker.save(ret, dic)
+        return ret
+
+    def get_index_from_accelerate(self, index):
+        index -= self.batch_size * self.rank
+        r = index % (self.replicas * self.batch_size)
+        d = index // (self.replicas * self.batch_size)
+        index = d * self.batch_size + r
+        return index
+
+    def get_warmup_index_from_accelerate(self, index):
+        index = index // self.replicas
+        return index
+
+    def __getitem__(self, ori_index):
+        # if self.enable_data_warmup:
+        #     index = self.get_warmup_index_from_accelerate(ori_index)
+        # else:
+        #     index = self.get_index_from_accelerate(ori_index)
+        index = ori_index
+        index = index % len(self.paths)
+        dic = self.paths[index]
+        data_dic = self._process(dic)
+        # print(f'Base dataloader [rank{self.rank}], ori_index: {ori_index}, index: {index}, prompt: {data_dic["prompt"]}')
+        return data_dic
+
+    def __len__(self):
+        return self.num_sample_per_rank * self.enlarge_ratio
+    
+
+def build_t2i_trainloader(data_config, rank, world_size):
+    data_config['rank'] = rank
+    data_config['world_size'] = world_size
+    train_dataset = Base(data_config)
+    dataloader_args = dict(
+        dataset=train_dataset,
+        batch_size=data_config['batch_size'],
+        shuffle=False,
+        num_workers=data_config['num_workers'],
+        pin_memory=True,
+        drop_last=True,
+        prefetch_factor=16,
+        # collate_fn=collate_list,
+        persistent_workers=True
+    )
+    train_dataloader = torch.utils.data.DataLoader(**dataloader_args)
+    return train_dataloader
+
+
+if __name__ == "__main__":
+    with open('./configs/mimo/selftok/sd3_v1227_test/512-debug-newdata.yml', 'r') as file:
+        config = yaml.safe_load(file)
+    config = config['data']
+    config['rank'] = 0
+    config['world_size'] = 1
+    train_dataset = Base(config)

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/transforms.py

@@ -0,0 +1,604 @@
+# -*- coding: utf-8 -*-
+import cv2
+import os
+import re
+import torch
+import pickle
+import random
+import numpy as np
+import pandas as pd
+import torch.distributed as dist
+from PIL import Image
+from torchvision import transforms
+from torchvision.transforms import functional as F
+from mimogpt.engine.utils import mox_copy
+
+class RandomResize(transforms.Resize):
+    """
+    Resize transform but only if the input is smaller than the resize dims
+    """
+    def __init__(self, size, interpolation=F.InterpolationMode.BILINEAR, max_size=None, antialias="warn", ratio=0.5):
+        super().__init__(size, interpolation, max_size, antialias)
+        self.ratio = ratio
+
+    def forward(self, img):
+        """
+        Args:
+            img (PIL Image or Tensor): Image to be scaled.
+
+        Returns:
+            PIL Image or Tensor: Rescaled image.
+        """
+        if isinstance(img, torch.Tensor):
+            h, w = img.shape[1:]
+        else:  # PIL Image
+            w, h = img.size
+        r = torch.rand(1)
+        if r > self.ratio:
+            # print('fix 256')
+            return F.resize(img, self.size, self.interpolation, self.max_size, self.antialias)
+        else:
+            r = (r*1./self.ratio)[0].item()
+            res = r * self.size + (1-r) * min(w,h)
+            res = int(max(res, self.size))
+            # print(f'{res}')
+            return F.resize(img, res, self.interpolation, self.max_size, self.antialias)
+        
+def set_visual_transforms(
+    mode,
+    input_res=224,
+    resize_res=256,
+    norm_mean=(0.48145466, 0.4578275, 0.40821073),
+    norm_std=(0.26862954, 0.26130258, 0.27577711),
+    augment_choice="vlip",
+):
+    if augment_choice == "vlip":
+        normalize = transforms.Normalize(mean=norm_mean, std=norm_std)
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(resize_res),
+                    transforms.RandomCrop(input_res),
+                    transforms.ToTensor(),
+                    normalize,
+                ]
+            )
+        elif mode in ["eval", "val", "test"]:
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(input_res),
+                    transforms.CenterCrop(input_res),
+                    transforms.ToTensor(),
+                    normalize,
+                ]
+            )
+        else:
+            raise NotImplementedError
+
+    elif augment_choice == "clip":
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize((resize_res, resize_res), interpolation=transforms.InterpolationMode.BICUBIC),
+                    NormalizeToTensor(),
+                ]
+            )
+        elif mode in ["eval", "val", "test"]:
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize((resize_res, resize_res), interpolation=transforms.InterpolationMode.BICUBIC),
+                    NormalizeToTensor(),
+                ]
+            )
+        else:
+            raise NotImplementedError
+
+    elif augment_choice == "mimo":
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(resize_res, interpolation=transforms.InterpolationMode.BICUBIC),
+                    transforms.CenterCrop(input_res),
+                    NormalizeToTensor(),
+                ]
+            )
+        elif mode in ["eval", "val", "test"]:
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(input_res),
+                    transforms.CenterCrop(input_res),
+                    NormalizeToTensor(),
+                ]
+            )
+        else:
+            raise NotImplementedError
+    elif augment_choice == "selftok":
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(resize_res, interpolation=transforms.InterpolationMode.BICUBIC),
+                    transforms.RandomCrop(input_res),
+                    NormalizeToTensor(),
+                ]
+            )
+        elif mode in ["eval", "val", "test"]:
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(input_res),
+                    transforms.CenterCrop(input_res),
+                    NormalizeToTensor(),
+                ]
+            )
+        else:
+            raise NotImplementedError
+
+    elif augment_choice == "prior":
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(resize_res, interpolation=transforms.InterpolationMode.BICUBIC),
+                    transforms.CenterCrop(input_res),
+                    NormalizeToTensor(),
+                ]
+            )
+        elif mode in ["eval", "val", "test"]:
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(resize_res, interpolation=transforms.InterpolationMode.BICUBIC),
+                    transforms.CenterCrop(input_res),
+                    NormalizeToTensor(),
+                ]
+            )
+        else:
+            raise NotImplementedError
+
+    elif augment_choice == "round":
+        preprocess = transforms.Compose(
+            [
+                transforms.Resize(resize_res, interpolation=transforms.InterpolationMode.BICUBIC),
+                transforms.RandomResizedCrop(
+                    size=input_res,
+                    scale=((input_res / resize_res) ** 2, 0.618),
+                    interpolation=transforms.InterpolationMode.BICUBIC,
+                ),
+                NormalizeToTensor(),
+            ]
+        )
+
+    elif augment_choice == "noCrop":
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(resize_res, interpolation=transforms.InterpolationMode.BICUBIC),
+                    NormalizeToTensor(),
+                ]
+            )
+        elif mode in ["eval", "val", "test"]:
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(resize_res, interpolation=transforms.InterpolationMode.BICUBIC),
+                    NormalizeToTensor(),
+                ]
+            )
+        else:
+            raise NotImplementedError
+
+    elif augment_choice == "simple":
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    NormalizeToTensor(),
+                ]
+            )
+        elif mode in ["eval", "val", "test"]:
+            preprocess = transforms.Compose(
+                [
+                    NormalizeToTensor(),
+                ]
+            )
+        else:
+            raise NotImplementedError
+
+    elif augment_choice == "V06":
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    NormalizeToTensor(),
+                ]
+            )
+        elif mode in ["eval", "val", "test"]:
+            preprocess = transforms.Compose(
+                [
+                    NormalizeToTensor(),
+                ]
+            )
+        else:
+            raise NotImplementedError
+
+    elif augment_choice == "sr":
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(resize_res, interpolation=transforms.InterpolationMode.BICUBIC),
+                    transforms.RandomCrop(input_res),
+                    NormalizeToTensor(),
+                ]
+            )
+        else:
+            raise NotImplementedError
+
+    elif augment_choice == "mimo_interleaved":
+        if mode == "train":
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(resize_res),
+                    transforms.CenterCrop(input_res),
+                    NormalizeToTensor(),
+                ]
+            )
+        elif mode in ["eval", "val", "test"]:
+            preprocess = transforms.Compose(
+                [
+                    transforms.Resize(input_res),
+                    transforms.CenterCrop(input_res),
+                    NormalizeToTensor(),
+                ]
+            )
+        else:
+            raise NotImplementedError
+
+    else:
+        raise NotImplementedError
+
+    return preprocess
+
+
+def text_transform(caption):
+    pat = re.compile(r"[#]+")
+    res = re.sub(pat, " ", caption)
+    return res
+
+
+class CaptionDropout(object):
+    def __init__(self, rate):
+        assert isinstance(rate, float)
+        self.rate = rate
+
+    def __call__(self, caption):
+        if random.random() < self.rate:
+            return ""
+        else:
+            return caption
+
+
+class NormalizeToTensor(object):
+    """Convert ndarrays in sample to Tensors."""
+
+    def __init__(self, reshape=True):
+        self.reshape = reshape
+
+    def __call__(self, image):
+        image = np.array(image).astype(np.float32)
+        image = (image / 127.5 - 1.0).astype(np.float32)
+        if self.reshape:
+            image = np.reshape(image, (image.shape[0], image.shape[1], -1))
+        image = image.transpose((2, 0, 1))
+        return torch.from_numpy(image)
+
+
+def get_zip_idx(split_range, train_task="mimo"):
+    zip_min_split, zip_max_split = split_range
+    rank = dist.get_rank()
+    world_size = dist.get_world_size()
+    try:
+        # training in cloud
+        import moxing as mox
+
+        # this rule need same to multi_modality/common/cloud_copy.py#L91
+        this_node_all_idx = list(range(zip_min_split, zip_max_split))[(rank // 8) :: max(world_size // 8, 1)]
+        if train_task == "pangu":
+            this_card_all_idx = this_node_all_idx
+        else:
+            if world_size > zip_max_split - zip_min_split:
+                this_card_all_idx = this_node_all_idx
+            else:
+                this_card_all_idx = this_node_all_idx[(rank % 8) :: 8]
+    except:
+        # training in local, different rules compare to training in cloud
+        zip_per_rank = (zip_max_split - zip_min_split) // world_size
+        this_card_all_idx = list(range(rank * zip_per_rank + zip_min_split, (rank + 1) * zip_per_rank + zip_min_split))
+
+    return this_card_all_idx
+
+
+def make_zip_dataset(data_list, this_card_all_idx, col_used, index_format="pkl"):
+    def preprocess(pkl_path):
+        if pkl_path.startswith("s3://"):
+            # We prevent using memarts here in main process, it will cause segment fault in dataloader process
+            # So here we copy pkl files into /cache/
+            data_item_local = pkl_path.replace("s3://", "/cache/")
+            if not os.path.exists(data_item_local):
+                print(f"mox_copy({pkl_path}, {data_item_local})")
+                mox_copy(pkl_path, data_item_local)
+        else:
+            data_item_local = pkl_path
+        return data_item_local
+
+    # hard code to load old pkl
+    def _load_pickle(data_item):
+        list_ = pd.read_pickle(data_item)
+        columns = len(list_[0])
+        if columns == 2:
+            df = pd.DataFrame(list_, columns=["ID", "caption_en"])
+        elif columns == 3:  # MTI_ori_split_en_zh_pkl
+            df = pd.DataFrame(list_, columns=["ID", "caption_en", "_"])
+        elif columns == 4:  # MJ
+            df = pd.DataFrame(list_, columns=["ID", "caption_zh", "_", "caption_en"])
+        elif columns >= 5:  # 0527_super
+            col = ["_"] * columns
+            col[0], col[1] = "ID", "caption_en"
+            df = pd.DataFrame(list_, columns=col)
+        else:
+            raise NotImplementedError
+
+        df = df.loc[:, col_used]
+        return df
+
+    def _load_pandas(data_item):
+        df = pd.read_pickle(data_item)
+        df = df.loc[:, col_used]
+        return df
+
+    def _load_parquet(data_item):
+        df = pd.read_parquet(data_item)
+        df = df.loc[:, col_used]
+        return df
+
+    def isvalid(pd_val):
+        if isinstance(pd_val, (dict, list, tuple)):
+            if len(pd_val) > 0:
+                return True
+            else:
+                return False
+        else:
+            if pd_val not in ("#", ""):
+                return True
+            else:
+                return False
+
+    if index_format in ["pkl", "pickle"]:
+        load_func = _load_pickle
+    elif index_format == "pandas":
+        load_func = _load_pandas
+    elif index_format == "parquet":
+        load_func = _load_parquet
+    else:
+        raise NotImplementedError
+
+    dataframes = []
+    data_list = [preprocess(data_list.format(zip_idx)) for zip_idx in this_card_all_idx]
+    print(f"Reading {data_list}...")
+
+    for zip_idx, sub_data_list in enumerate(data_list):
+        try:
+            sub_df = load_func(sub_data_list)
+        except Exception as e:
+            print(f"ERROR opening pkl:{sub_data_list} !!!!")
+            raise e
+        for col in col_used:  # filter rows with empty value in col_used
+            sub_df = sub_df[sub_df[col].map(isvalid)]
+        sub_df.insert(sub_df.shape[1], "zip_idx", zip_idx, allow_duplicates=False)
+        dataframes.append(sub_df)
+
+    print(f"Read {data_list} Finished!")
+    dataframe = pd.concat(dataframes, ignore_index=True)
+    print("total data num before filtering: {}, {}, {}".format(len(dataframe), data_list, col_used))
+    return dataframe
+
+
+def make_zip_fns(data_list, this_card_all_idx):
+    zip_files = []
+    for zip_idx in this_card_all_idx:
+        if data_list.endswith("pkl"):
+            zip_path = data_list.replace(".pkl", ".zip").format(zip_idx)
+        elif data_list.endswith("parquet"):
+            zip_path = data_list.replace(".parquet", ".zip").format(zip_idx)
+        elif data_list.endswith("zip"):
+            zip_path = data_list.format(zip_idx)
+        else:
+            raise NotImplementedError
+        zip_files.append(zip_path)
+    return zip_files
+
+
+def canny(original_img):
+    img1 = cv2.GaussianBlur(original_img, (9, 9), 0)
+    thresh1 = random.randint(50, 125)
+    thresh2 = thresh1 + random.randint(50, 100)
+    canny_img = cv2.Canny(img1, thresh1, thresh2)
+    # thresh
+    canny_img[canny_img > 127] = 255
+    canny_img[canny_img <= 127] = 0
+    stacked_img = np.stack((canny_img,) * 3, axis=-1)
+    return stacked_img
+
+
+def shapen_USM(I):
+    sigma = 3
+    kernel_size = (0, 0)
+    L = cv2.GaussianBlur(I, kernel_size, sigma)
+    L = L.astype(np.int32)
+    I = I.astype(np.int32)
+    H = I - L
+    a = 1.5
+    O = I + a * H
+    O[O > 255] = 255
+    O[O < 0] = 0
+    O = O.astype(np.uint8)
+    return O
+
+
+def xDoG(original_img, kernel_size=0, sigma=1.4, k_sigma=1.6, epsilon=0, phi=10, gamma=0.98, aug=True):
+    # XDOG filer
+    epsilon /= 255
+    g1 = cv2.GaussianBlur(original_img, (kernel_size, kernel_size), sigma)
+    g2 = cv2.GaussianBlur(original_img, (kernel_size, kernel_size), sigma * k_sigma)
+    dog = g1 - gamma * g2
+    dog /= dog.max()
+    xdog = 1 + np.tanh(phi * (dog - epsilon))
+    xdog[xdog >= 1] = 1
+    xdog = 255 - xdog.astype("uint8") * 255
+    xdog = cv2.fastNlMeansDenoising(xdog, None, 80, 15, 21)
+    # sharpen
+    if aug and random.uniform(0, 1) > 0.3:
+        xdog = shapen_USM(xdog)
+    else:
+        xdog = shapen_USM(xdog)
+    # thresh
+    xdog[xdog > 127] = 255
+    xdog[xdog <= 127] = 0
+    stacked_img = np.stack((xdog,) * 3, axis=-1)
+    return stacked_img
+
+
+def generate_sketch(pil_image, aug=True):
+    # genertate edge
+    cv2_image = cv2.cvtColor(np.asarray(pil_image), cv2.COLOR_RGB2GRAY)
+    if aug:
+        if random.uniform(0, 1) > 0.5:
+            edge = canny(cv2_image)
+        else:
+            edge = xDoG(cv2_image)
+    else:
+        edge = xDoG(cv2_image, aug=False)
+    edge = Image.fromarray(cv2.cvtColor(edge, cv2.COLOR_BGR2RGB))
+    return edge
+
+
+def choice_box(image, grit):
+    elem = random.choice(grit)
+    bbox = elem.get("box")
+    caption = elem.get("caption_en")
+
+    return image, bbox, caption
+
+
+def get_multi_res_info_(w, h, size=512):
+    """
+    general ratio | aspect ratio | vq token numbers
+    1 : 2         | 16 : 32      | 512
+    9 : 16        | 18 : 32      | 576
+    3 : 4         | 28 : 20      | 560
+    1 : 1         | 24 : 24      | 576
+    4 : 3         | 20 : 28      | 560
+    16 : 9        | 32 : 18      | 576
+    2 : 1         | 32 : 16      | 512
+    """
+    if size == 512:
+        ratio0, w0, h0 = 16.0 / 32, 256, 512  # vq tokens = 512
+        ratio1, w1, h1 = 18.0 / 32, 288, 512  # vq tokens = 576
+        ratio2, w2, h2 = 20.0 / 28, 320, 448  # vq tokens = 560
+        ratio3, w3, h3 = 24.0 / 24, 384, 384  # vq tokens = 576
+        ratio4, w4, h4 = 28.0 / 20, 448, 320  # vq tokens = 560
+        ratio5, w5, h5 = 32.0 / 18, 512, 288  # vq tokens = 576
+        ratio6, w6, h6 = 32.0 / 16, 512, 256  # vq tokens = 512
+    elif size == 736:
+        ratio0, w0, h0 = 22.0 / 46, 352, 736  # vq tokens = 1012
+        ratio1, w1, h1 = 24.0 / 42, 384, 672  # vq tokens = 1008
+        ratio2, w2, h2 = 28.0 / 36, 448, 576  # vq tokens = 1008
+        ratio3, w3, h3 = 36.0 / 36, 512, 512  # vq tokens = 1024
+        ratio4, w4, h4 = 28.0 / 20, 576, 448  # vq tokens = 1008
+        ratio5, w5, h5 = 42.0 / 24, 672, 384  # vq tokens = 1008
+        ratio6, w6, h6 = 46.0 / 22, 736, 352  # vq tokens = 1012
+
+    aspect_ratio = w * 1.0 / h
+    if aspect_ratio < (ratio0 + ratio1) / 2:
+        return ratio0, w0, h0
+    elif (ratio0 + ratio1) / 2 <= aspect_ratio < (ratio1 + ratio2) / 2:
+        return ratio1, w1, h1
+    elif (ratio1 + ratio2) / 2 <= aspect_ratio < (ratio2 + ratio3) / 2:
+        return ratio2, w2, h2
+    elif (ratio2 + ratio3) / 2 <= aspect_ratio < (ratio3 + ratio4) / 2:
+        return ratio3, w3, h3
+    elif (ratio3 + ratio4) / 2 <= aspect_ratio < (ratio4 + ratio5) / 2:
+        return ratio4, w4, h4
+    elif (ratio4 + ratio5) / 2 <= aspect_ratio < (ratio5 + ratio6) / 2:
+        return ratio5, w5, h5
+    elif (ratio5 + ratio6) / 2 <= aspect_ratio:
+        return ratio6, w6, h6
+
+
+def get_multi_res_info(w, h, size=384):
+    """
+    general ratio | aspect ratio | vq token numbers
+    1 : 2         | 11 : 22      | 242
+    9 : 16        | 12 : 21      | 252
+                  | 13 : 19      | 247
+    3 : 4         | 14 : 18      | 252
+                  | 15 : 17      | 255
+    1 : 1         | 16 : 16      | 256
+                  | 17 : 15      | 255
+    4 : 3         | 18 : 14      | 252
+                  | 19 : 13      | 247
+    16 : 9        | 21 : 12      | 252
+    2 : 1         | 22 : 11      | 242
+    """
+    if size != 384:
+        return get_multi_res_info_(w, h, size)
+    else:
+        ratio0, w0, h0 = 11.0 / 22, 176, 352  # vq tokens = 242
+        ratio1, w1, h1 = 12.0 / 21, 192, 336  # vq tokens = 252
+        ratio2, w2, h2 = 13.0 / 19, 208, 304  # vq tokens = 247
+        ratio3, w3, h3 = 14.0 / 18, 224, 288  # vq tokens = 252
+        ratio4, w4, h4 = 15.0 / 17, 240, 272  # vq tokens = 255
+        ratio5, w5, h5 = 16.0 / 16, 256, 256  # vq tokens = 256
+        ratio6, w6, h6 = 17.0 / 15, 272, 240  # vq tokens = 255
+        ratio7, w7, h7 = 18.0 / 14, 288, 224  # vq tokens = 252
+        ratio8, w8, h8 = 19.0 / 13, 304, 208  # vq tokens = 247
+        ratio9, w9, h9 = 21.0 / 12, 336, 192  # vq tokens = 252
+        ratio10, w10, h10 = 22.0 / 11, 352, 176  # vq tokens = 242
+
+        aspect_ratio = w * 1.0 / h
+        if aspect_ratio < (ratio0 + ratio1) / 2:
+            return ratio0, w0, h0
+        elif (ratio0 + ratio1) / 2 <= aspect_ratio < (ratio1 + ratio2) / 2:
+            return ratio1, w1, h1
+        elif (ratio1 + ratio2) / 2 <= aspect_ratio < (ratio2 + ratio3) / 2:
+            return ratio2, w2, h2
+        elif (ratio2 + ratio3) / 2 <= aspect_ratio < (ratio3 + ratio4) / 2:
+            return ratio3, w3, h3
+        elif (ratio3 + ratio4) / 2 <= aspect_ratio < (ratio4 + ratio5) / 2:
+            return ratio4, w4, h4
+        elif (ratio4 + ratio5) / 2 <= aspect_ratio < (ratio5 + ratio6) / 2:
+            return ratio5, w5, h5
+        elif (ratio5 + ratio6) / 2 <= aspect_ratio < (ratio6 + ratio7) / 2:
+            return ratio6, w6, h6
+        elif (ratio6 + ratio7) / 2 <= aspect_ratio < (ratio7 + ratio8) / 2:
+            return ratio7, w7, h7
+        elif (ratio7 + ratio8) / 2 <= aspect_ratio < (ratio8 + ratio9) / 2:
+            return ratio8, w8, h8
+        elif (ratio8 + ratio9) / 2 <= aspect_ratio < (ratio9 + ratio10) / 2:
+            return ratio9, w9, h9
+        elif (ratio9 + ratio10) / 2 <= aspect_ratio:
+            return ratio10, w10, h10
+
+
+def get_multi_res_infer(w, h):
+    """
+    general ratio | aspect ratio | vq token numbers
+    1 : 2         | 11 : 22      | 242
+    9 : 16        | 12 : 21      | 252
+    3 : 4         | 14 : 18      | 252
+    1 : 1         | 16 : 16      | 256
+    4 : 3         | 18 : 14      | 252
+    16 : 9        | 21 : 12      | 252
+    2 : 1         | 22 : 11      | 242
+    """
+
+    ratios_list = np.array([11 / 22, 12 / 21, 14 / 18, 16 / 16, 18 / 14, 21 / 12, 22 / 11])
+    w_h_list = [(11, 22), (12, 21), (14, 18), (16, 16), (18, 14), (21, 12), (22, 11)]
+
+    ratio_in = w / h
+    index = np.argmin(abs(ratios_list - ratio_in))
+
+    return w_h_list[index]

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/utils/__version__.py

@@ -0,0 +1 @@
+__version__ = '2.0'

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/utils/checker.py

@@ -0,0 +1,136 @@
+import os
+import pickle
+import random
+
+import cv2
+import numpy as np
+
+import torch
+import torch.distributed as dist
+
+from mimogpt.datasets.utils.log import mimo_logger
+
+class Checker:
+    def __init__(self, opt):
+        # self.logger = mimo_logger('skip')
+        self.status = opt['checker']['status']
+        self.anchor_path = opt['checker']['anchor_path']
+        self.check_iter = opt['checker']['check_iter']
+        self.save_check = opt['checker']['save_check']
+        self.rank = opt['rank']
+        self.master_only = opt['checker']['master_only']
+
+        if (self.rank != 0 and self.master_only) or self.status == 'disable':
+            self._func = lambda x, y, z: x
+        elif self.status == 'record':
+            self._func = self._record
+            os.makedirs(self.anchor_path, exist_ok=True)
+            print(f'[Checker] [rank{self.rank}] init record')
+        elif self.status == 'check':
+            self._func = self._check
+            print(f'[Checker] [rank{self.rank}] init check')
+        elif self.status == 'load_check':
+            self._func = self._load_check
+            self.load_keys = opt['checker']['load_keys']
+            print(f'[Checker] [rank{self.rank}] init load_check')
+        else:
+            # self.logger.error(f'Not implemented status: {self.status}')
+            raise
+
+    def _record(self, value, key, cur_iter):
+        anchor_file = os.path.join(self.anchor_path, key) + f'_{cur_iter}_{self.rank}.pth'
+        torch.save(value, anchor_file)
+        print(f'[Checker] [rank{self.rank}] save anchor: {key}, anchor_file: {anchor_file}')
+        return value
+
+    def _check(self, value, key, cur_iter):
+        anchor_file = os.path.join(self.anchor_path, key) + f'_{cur_iter}_{self.rank}.pth'
+        if self.save_check:
+            check_file = os.path.join(self.anchor_path, key) + f'_{cur_iter}_{self.rank}_check.pth'
+            torch.save(value, check_file)
+        anchor_value = torch.load(anchor_file)
+        if isinstance(anchor_value, torch.Tensor):
+            anchor_value = anchor_value.to(value.device)
+            print(f'[Checker] [rank{self.rank}] anchor: {key}, anchor_file: {anchor_file}, diff: {(anchor_value - value).abs().float().mean()}')
+        elif isinstance(anchor_value, list) and isinstance(anchor_value[0], torch.Tensor):
+            diff = 0
+            for i in range(len(anchor_value)):
+                diff += (anchor_value[i] - value[i]).abs().float().mean()
+            print(f'[Checker] [rank{self.rank}] anchor: {key}, anchor_file: {anchor_file}, diff: {diff / len(anchor_value)}')
+        else:
+            print(f'[Checker] [rank{self.rank}] anchor: {key}, anchor_file: {anchor_file}, same: {anchor_value == value}')    
+        return value
+
+    def _load_check(self, value, key, cur_iter):
+        anchor_file = os.path.join(self.anchor_path, key) + f'_{cur_iter}_{self.rank}.pth'
+        if self.save_check:
+            check_file = os.path.join(self.anchor_path, key) + f'_{cur_iter}_{self.rank}_check.pth'
+            torch.save(value, check_file)
+        anchor_value = torch.load(anchor_file)
+        if isinstance(anchor_value, torch.Tensor):
+            anchor_value = anchor_value.to(value.device)
+        elif isinstance(anchor_value, list) and isinstance(anchor_value[0], torch.Tensor):
+            for i in range(len(anchor_value)):
+                anchor_value[i] = anchor_value[i].to(value[0].device)
+        if key in self.load_keys:
+            return anchor_value
+        else:
+            if isinstance(anchor_value, torch.Tensor):
+                print(f'[Checker] [rank{self.rank}] anchor: {key}, anchor_file: {anchor_file}, diff: {(anchor_value - value).abs().float().mean()}')
+            elif isinstance(anchor_value, list) and isinstance(anchor_value[0], torch.Tensor):
+                diff = 0
+                for i in range(len(anchor_value)):
+                    diff += (anchor_value[i] - value[i]).abs().float().mean()
+                print(f'[Checker] [rank{self.rank}] anchor: {key}, anchor_file: {anchor_file}, diff: {diff / len(anchor_value)}')
+            else:
+                print(f'[Checker] [rank{self.rank}] anchor: {key}, anchor_file: {anchor_file}, same: {anchor_value == value}')
+            return value
+        
+    def check_point(self, value, key, cur_iter):
+        if cur_iter < self.check_iter:
+            return self._func(value, key, cur_iter)
+        else:
+            return value
+
+
+class DataChecker:
+    def __init__(self, opt):
+        # self.logger = mimo_logger('skip')
+
+        self.status = opt['data_checker']['status']
+
+        self.save_prob = opt['data_checker']['save_prob']
+        self.save_amount = opt['data_checker']['save_amount']
+        self.save_path = opt['data_checker']['save_path']
+        self.rank = opt['rank']
+        self.master_only = opt['checker']['master_only']
+    
+        if (self.rank != 0 and self.master_only) or self.status == 'disable':
+            self._func = self._pass
+        elif self.status == 'save':
+            self._func = self._save
+            self.count = 0
+            os.makedirs(self.save_path, exist_ok=True)
+            print(f'[DataChecker] [rank{self.rank}] init record')
+        else:
+            # self.logger.error(f'Not implemented status: {self.status}')
+            raise
+
+    def _pass(self, ret, dict):
+        pass
+    
+    def _save(self, ret, dic):
+        
+        if self.count >= self.save_amount:
+            self._func = lambda x, y: x
+            return
+        if random.random() < self.save_prob:
+            image = (ret['image'] + 1) * 127.5
+            image = image.permute(1, 2, 0).numpy()[:, :, ::-1]
+            cv2.imwrite(os.path.join(self.save_path, os.path.basename(dic['zip']) + '_' + dic['img_path'] + '.png'), image)
+            with open(os.path.join(self.save_path, os.path.basename(dic['zip']) + '_' + dic['img_path'] + '.txt'), 'w') as f:
+                f.write(ret['prompt'])
+            self.count += 1
+
+    def save(self, ret, dic):
+        self._func(ret, dic)

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/utils/dist.py

@@ -0,0 +1,54 @@
+import datetime
+import functools
+
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+
+def master_only(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        local_rank, rank, _ = get_dist_info()
+        if rank == 0:
+            return func(*args, **kwargs)
+    return wrapper
+
+def get_dist_info():
+    if dist.is_available():
+        initialized = dist.is_initialized()
+    else:
+        initialized = False
+    if initialized:
+        rank = dist.get_rank()
+        local_rank = dist.local_rank
+        world_size = dist.get_world_size()
+    else:
+        rank = 0
+        world_size = 1
+        local_rank = 0
+    return local_rank, rank, world_size
+
+
+def _init_dist_pytorch(backend, **dist_params):
+    if backend == "nccl" and mp.get_start_method(allow_none=True) is None:
+        mp.set_start_method('spawn')
+    torch.cuda.set_device(dist_params["local_rank"])
+    dist.init_process_group(
+        backend=backend, 
+        init_method=dist_params["init_method"],
+        timeout=datetime.timedelta(hours=0.5),
+        world_size=dist_params["world_size"],
+        rank=dist_params["rank"],
+    )
+    dist.local_rank = dist_params["local_rank"]
+    print(
+        "init dist: init_method=%s, rank=%s, local_rank=%s, world_size=%s"
+        % (dist_params['init_method'], dist_params['rank'], dist_params["local_rank"], dist_params['world_size'])
+    )
+
+
+def init_dist(launcher, **dist_params):
+    if launcher == "pytorch":
+        _init_dist_pytorch(**dist_params)
+    else:
+        raise ValueError(f'init_dist({launcher}, dist_params={dist_params})')

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/utils/log.py

@@ -0,0 +1,63 @@
+import time
+import logging
+
+from .dist import get_dist_info
+from .__version__ import __version__
+
+initialized_logger = {}
+
+def get_root_logger(logger_name, log_level=logging.INFO, log_file=None):
+    """Get the root logger.
+
+    The logger will be initialized if it has not been initialized. By default a
+    StreamHandler will be added. If `log_file` is specified, a FileHandler will
+    also be added.
+
+    Args:
+        logger_name (str): root logger name
+        log_file (str | None): The log filename. If specified, a FileHandler
+            will be added to the root logger.
+        log_level (int): The root logger level. Note that only the process of
+            rank 0 is affected, while other processes will set the level to
+            "Error" and be silent most of the time.
+
+    Returns:
+        logging.Logger: The root logger.
+    """
+    logger = logging.getLogger(logger_name)
+    # if the logger has been initialized, just return it
+    if logger_name in initialized_logger:
+        return logger
+    format_str = '%(asctime)s - %(name)s [%(levelname)s]: %(message)s'
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(logging.Formatter(format_str))
+    logger.addHandler(stream_handler)
+    logger.propagate = False
+    local_rank, rank, world_size = get_dist_info()
+    logger.setLevel(log_level)
+    if rank != 0:
+        logger.setLevel('ERROR')
+    else:
+        logger.setLevel(log_level)
+    if log_file is not None:
+        # add file handler
+        file_handler = logging.FileHandler(log_file, 'w')
+        file_handler.setFormatter(logging.Formatter(format_str))
+        file_handler.setLevel(log_level)
+        logger.addHandler(file_handler)
+    initialized_logger[logger_name] = True
+    return logger
+
+loglevel_map = {
+    'debug': logging.DEBUG,
+    'info': logging.INFO,
+    'warn': logging.WARN,
+    'error': logging.ERROR,
+    'critical': logging.CRITICAL,
+    'skip': None, 
+}
+
+def mimo_logger(log_level, log_file=None):
+    log_level = loglevel_map[log_level]
+    logger = get_root_logger("Flame2_" + __version__, log_level=log_level, log_file=log_file)
+    return logger

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/datasets/utils/ordered_yaml.py

@@ -0,0 +1,26 @@
+import yaml
+from collections import OrderedDict
+
+def ordered_yaml():
+    """Support OrderedDict for yaml.
+
+    Returns:
+        yaml Loader and Dumper.
+    """
+    try:
+        from yaml import CDumper as Dumper
+        from yaml import CLoader as Loader
+    except ImportError:
+        from yaml import Dumper, Loader
+
+    _mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
+
+    def dict_representer(dumper, data):
+        return dumper.represent_dict(data.items())
+
+    def dict_constructor(loader, node):
+        return OrderedDict(loader.construct_pairs(node))
+
+    Dumper.add_representer(OrderedDict, dict_representer)
+    Loader.add_constructor(_mapping_tag, dict_constructor)
+    return Loader, Dumper

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/__init__.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+import os
+from mimogpt.engine.utils import *
+from .trainer_selftok_enc import TrainerSelftokEnc
+
+
+DEVICE_TYPE = os.environ.get("DEVICE_TYPE", "gpu")
+
+def setup_task(cfg, is_root):
+    if cfg.common.task == 'selftokenc':
+        Trainer = TrainerSelftokEnc(cfg)
+        hook_list = [
+            SelfTokHook(cfg),
+            SelfTokSaveHook(cfg, is_root=is_root),
+        ]
+        if cfg.common.val_interval > 0:
+            hook_list.append(EvalSelftokHook(cfg))
+        # 
+    else:
+        raise NotImplementedError
+
+    cfg.profile = cfg.common.use_profile if hasattr(cfg.common, "use_profile") else 0
+    if cfg.profile and DEVICE_TYPE == "gpu":
+        hook_list.insert(0, TorchProfileHook(cfg))
+    if cfg.profile and DEVICE_TYPE == "ascend":
+        hook_list.insert(0, NPUTorchProfileHook(cfg))
+
+    return Trainer, hook_list

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/trainer_selftok_enc.py

@@ -0,0 +1,419 @@
+# -*- coding: utf-8 -*-
+import os
+import sys
+import torch
+import deepspeed
+import functools
+import numpy as np
+from time import time as ttime
+import time
+from itertools import repeat
+import torch.distributed as dist
+from torch.cuda.amp import autocast
+from easydict import EasyDict
+from collections import OrderedDict
+from torch.cuda.amp import GradScaler
+from copy import deepcopy
+from diffusers.models import AutoencoderKL
+import moxing as mox
+sys.path.append(".")
+from mimogpt.utils import hf_logger, AverageMeter
+from mimogpt.models import build_backbone
+from mimogpt.datasets import build_dataloader
+from mimogpt.engine.utils import TrainerBase, print_model_param_num, print_model_params
+from mimogpt.engine.utils import clip_gradient, build_optimizer, setup_deepspeed, build_selftok_optimizer
+from mimogpt.models.selftok.multires_image_tokenizer import MultiImageTokenizer ### mark
+from mimogpt.models.selftok.image_tokenizer import ImageTokenizer
+from mimogpt.models.selftok.sd3.sd3_impls import SDVAE, CFGDenoiser, SD3LatentFormat
+from mimogpt.datasets.t2i_dataset import build_t2i_trainloader
+import re
+
+
+DEVICE_TYPE = os.environ.get("DEVICE_TYPE", "gpu")
+
+
+
+log_dict_keys = [
+    "loss", "dm_mse", "L2_loss", "commit_loss", "loss_small", "loss_mid", "loss_large", "loss_uncon",
+    "diversity_entropy", "perplexity", "deterministic_entropy", "enc_sum_grad", "delta_embed", 
+    "n_active", "n_reactive", "perplexity_list", "deter_list", "cosine_sim",
+]
+
+def requires_grad(model, flag=True):
+    """
+    Set requires_grad flag for all parameters in a model.
+    """
+    for p in model.parameters():
+        p.requires_grad = flag
+
+@torch.no_grad()
+def update_ema(ema_model, model, decay=0.9999):
+    """
+    Step the EMA model towards the current model.
+    """
+    ema_params = OrderedDict(ema_model.named_parameters())
+    model_params = OrderedDict(model.named_parameters())
+
+    for name, param in model_params.items():
+        name = name.replace("module.", "")
+        ema_params[name].mul_(decay).add_(param.data, alpha=1 - decay)
+
+
+def load_state(model, state_dict, prefix='',init_method = None):
+    model_dict = model.state_dict()  # 当前网络结构
+    if prefix == 'model.diffusion_model.':
+        excluded_keys = ['context_embedder.bias', 'context_embedder.weight']
+        if init_method == 1:
+            excluded_keys = ['context_embedder.bias', 'context_embedder.weight', 'final_layer.adaLN_modulation.1.bias', 'final_layer.adaLN_modulation.1.weight', 'final_layer.linear.bias', 'final_layer.linear.weight']
+            pretrained_dict = {k.replace(prefix,''): v for k, v in state_dict.items() if k.replace(prefix,'') in model_dict and k.replace(prefix,'') not in excluded_keys and 'context_block' not in k}
+        elif init_method == 2:
+            pretrained_dict = {k.replace(prefix,''): v for k, v in state_dict.items() if k.replace(prefix,'') in model_dict and k.replace(prefix,'') not in excluded_keys and 'context_block' not in k and 'x_block.attn' not in k}
+        else:
+            pretrained_dict = {k.replace(prefix,''): v for k, v in state_dict.items() if k.replace(prefix,'') in model_dict and k.replace(prefix,'') not in excluded_keys and 'context_block' not in k}
+    elif prefix == 'encoder.':
+        excluded_keys = ['query', 'q_norm1', 'q_norm2', 'post_norm', 'q_mlp', 'adaLN', 't_emb', 'final', 'quantizer']
+        pretrained_dict = {k.replace(prefix,''): v for k, v in state_dict.items() if k.replace(prefix,'') in model_dict and all(ek not in k for ek in excluded_keys)}
+    else:
+        pretrained_dict = {k.replace(prefix,''): v for k, v in state_dict.items() if k.replace(prefix,'') in model_dict}
+
+    dict_t = deepcopy(pretrained_dict)
+    for key, weight in dict_t.items():
+        if key in model_dict and model_dict[key].shape != dict_t[key].shape:
+            pretrained_dict.pop(key)
+   
+    m, u = model.load_state_dict(pretrained_dict, strict=False)
+    if len(m) > 0:
+        hf_logger.info(f"model missing keys:{m}")
+    if len(u) > 0:
+        hf_logger.info(f"mode unexpected keys:{u}")
+
+
+class TrainerSelftokEnc(TrainerBase):
+    def __init__(self, cfg):
+        super().__init__()
+        self.cfg = cfg
+        self.set_attribute()
+        # dataloaders
+        rank = dist.get_rank() #0 # machine index
+        world_size = dist.get_world_size() #1 # num nodes
+        print(f"Rank {rank} with world size {world_size} initiating dataset...")
+        self.data_loader = build_t2i_trainloader(cfg.data, rank, world_size)
+        self._data_loader_iter = iter(self.data_loader)
+        hf_logger.info("dataloader length:", len(self.data_loader))
+        self.cfg.dataloader_len = len(self.data_loader)
+        
+        # models
+        self.set_vae()  # load vae and set to eval
+        self.low_res_list = None
+        self.decoder_use_low_res_rec = cfg.tokenizer.params.decoder_config.get('low_res', False)
+        if hasattr(cfg.model, 'fix_decoder'):
+            cfg.tokenizer.params.train_encoder_only = cfg.model.fix_decoder
+        self.model = ImageTokenizer(**cfg.tokenizer.params)
+        self.model.set_train()                          # set encoder and decoder to train
+
+        state_dict = None
+        #self.ema = self.set_ema_model(self.model.model) # create ema model, disable grad
+        self.ema = None
+        pretrain_model_path = self.get_pretrain_model_path()
+        if pretrain_model_path is not None:
+            state_dict = torch.load(pretrain_model_path, map_location="cpu")
+            try:
+                hf_logger.info(f"Loading all...")
+                #self.ema.load_state_dict(state_dict['ema_state_dict'], strict=True)
+                self.model.load_state_dict(state_dict['state_dict'], strict=True)
+            except:
+                import time
+                time.sleep(10 * (dist.get_rank() % 8))
+                hf_logger.info(f"Loading partial state dict for rank: {dist.get_rank()}...")
+                load_state(self.model, state_dict['state_dict'])
+        else:
+            if hasattr(self.cfg.tokenizer, "pretrained_dit_path") and self.cfg.tokenizer.pretrained_dit_path:
+                teacher_path = self.cfg.tokenizer.pretrained_dit_path
+                hf_logger.info(f'mmdit init_from {teacher_path}...')
+                state_dict = torch.load(
+                    teacher_path,
+                    map_location='cpu'
+                )
+                load_state(self.model.model, state_dict, 'model.diffusion_model.', init_method = cfg.tokenizer.params.decoder_config.init_method)
+
+        
+        print_model_param_num(cfg.model, self.model)
+        print_model_param_num('encoder', self.model.encoder)
+        print_model_param_num('decoder', self.model.model)
+        self.model.cuda()
+        if hasattr(self.cfg.common, "use_fsdp") and self.cfg.common.use_fsdp:
+            print("USING FSDP from Pytorch...")
+            from torch.distributed.fsdp import (
+                FullyShardedDataParallel as FSDP,
+                MixedPrecision,
+                BackwardPrefetch,
+                ShardingStrategy,
+                FullStateDictConfig,
+                StateDictType,
+            )
+            from torch.distributed.fsdp.fully_sharded_data_parallel import (
+                CPUOffload,
+                BackwardPrefetch,
+            )
+            from torch.distributed.fsdp.wrap import (
+                size_based_auto_wrap_policy,
+                transformer_auto_wrap_policy,
+                enable_wrap,
+                wrap,
+            )
+            
+            from mimogpt.models.selftok.sd3.mmdit import JointBlock
+            print("Using size based policy")
+            my_auto_wrap_policy = functools.partial(
+                transformer_auto_wrap_policy, transformer_layer_cls={JointBlock}, )
+
+            bf16 = MixedPrecision(
+                ## param precision
+                param_dtype=torch.float32,
+                # Gradient communication precision.
+                reduce_dtype=torch.bfloat16,
+                # Buffer precision.
+                buffer_dtype=torch.bfloat16,
+            )
+
+            fp32 = MixedPrecision(
+                ## param precision
+                param_dtype=torch.float32,
+                # Gradient communication precision.
+                reduce_dtype=torch.float32,
+                # Buffer precision.
+                buffer_dtype=torch.float32,
+            )
+ 
+            self.model = FSDP(self.model,
+                                  auto_wrap_policy=my_auto_wrap_policy,
+                                  mixed_precision=fp32,
+                                  device_id=torch.cuda.current_device(),
+                                  # sharding_strategy=ShardingStrategy.FULL_SHARD,
+                                  sharding_strategy=ShardingStrategy._HYBRID_SHARD_ZERO2,
+                              	  forward_prefetch=True,
+                                  #sharding_strategy=ShardingStrategy.SHARD_GRAD_OP,
+                                  backward_prefetch=BackwardPrefetch.BACKWARD_PRE,
+                                  use_orig_params=True,
+                                  limit_all_gathers=True)
+            
+
+            self.optimizer = build_selftok_optimizer(self.model, self.cfg)
+            if state_dict is not None and (not self.resume_exclude_opt) and 'opt' in state_dict:
+                if hasattr(self.cfg.common, "use_fsdp") and self.cfg.common.use_fsdp:
+                    from torch.distributed.fsdp import FullStateDictConfig, FullOptimStateDictConfig, StateDictType
+                    from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+
+                    save_policy = FullStateDictConfig(rank0_only=False)
+                    save_opt_policy = FullOptimStateDictConfig(rank0_only=False)
+                    FSDP.set_state_dict_type(self.model, StateDictType.FULL_STATE_DICT, save_policy, save_opt_policy)
+                    opt_state = FSDP.optim_state_dict_to_load(
+                            self.model, self.optimizer,state_dict['opt']
+                    )
+                    self.optimizer.load_state_dict(opt_state)
+                else:
+                    self.optimizer.load_state_dict(state_dict['opt'])
+            from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler
+            self._scaler = ShardedGradScaler(enabled=self.use_fp16)
+            dist.barrier()
+        else:
+            # setup DDP
+            self.model.cuda()
+            self.model = torch.nn.parallel.DistributedDataParallel(self.model, device_ids=[cfg.rank % 8], find_unused_parameters=True)
+            dist.barrier()
+            if dist.get_rank() % 8==1:
+                for n,p in self.model.module.named_parameters():
+                    print(n, p.requires_grad)
+
+            # create optimizer and scaler
+            self.optimizer = build_selftok_optimizer(self.model, self.cfg)
+            if state_dict is not None and (not self.resume_exclude_opt) and 'opt' in state_dict:
+                self.optimizer.load_state_dict(state_dict['opt'])
+            if self.use_zero:
+                from fairscale.optim.grad_scaler import ShardedGradScaler
+                from fairscale.nn.data_parallel import ShardedDataParallel
+                self.model = ShardedDataParallel(
+                    self.model.module,
+                    self.optimizer,
+                    reduce_buffer_size=2000000,
+                    reduce_fp16=self.use_fp16,
+                )
+                self._scaler = ShardedGradScaler(enabled=self.use_fp16)
+            else:
+                if DEVICE_TYPE == "ascend":
+                    dynamic = cfg.common.use_dynamic if hasattr(cfg.common, "use_dynamic") else True
+                    self._scaler = GradScaler(enabled=self.use_fp16, dynamic=dynamic)
+                else: 
+                    self._scaler = GradScaler(enabled=self.use_fp16)
+
+        # logging
+        self.meters = EasyDict()
+        for key in log_dict_keys:
+            self.meters[key] = AverageMeter(self.cfg.common.log_interval, fstr="%.5f")
+        self.meters["lpips"] = AverageMeter(1, fstr="%.5f")     # only log the most recent lpips
+        self.meters["psnr"] = AverageMeter(1, fstr="%.5f")     # only log the most recent psnr
+        self.flops1 = None
+        self.flops2 = None
+
+    def get_pretrain_model_path(self):
+        try:
+            ckpts = mox.file.list_directory(self.cfg.model.recovery_path, recursive=False)
+            max_iter = -1
+            for ckpt in ckpts:
+                matched = re.search(r"iter_(\d+).pth", ckpt)
+                if matched:
+                    current_iter = int(matched.group(1))
+                    if current_iter > max_iter:
+                        max_iter = current_iter
+                        max_iter_ckpt = ckpt
+            hf_logger.info(f"Downloading resume model from {self.cfg.model.recovery_path}, {max_iter_ckpt}...")
+            mox.file.copy(os.path.join(self.cfg.model.recovery_path, max_iter_ckpt), dst_url='/cache/model/pretrained.pth')
+            pretrain_model_path = '/cache/model/pretrained.pth'
+        except:
+            if hasattr(self.cfg.model, "pretrain_model") and self.cfg.model.pretrain_model:
+                if 's3://' in self.cfg.model.pretrain_model:
+                    hf_logger.info(f"Downloading pretrained model from {self.cfg.model.pretrain_model}...")
+                    mox.file.copy_parallel(self.cfg.model.pretrain_model, '/cache/model/pretrained.pth')
+                    pretrain_model_path = '/cache/model/pretrained.pth'
+                else:
+                    pretrain_model_path = self.cfg.model.pretrain_model
+            else:
+                # no pretrain model provided
+                pretrain_model_path = None
+        return pretrain_model_path
+
+    def set_attribute(self):
+        self.start_time = ttime()
+        self.vae_path = self.cfg.common.vae_path
+        self.resume_exclude_opt = self.cfg.common.resume_exclude_opt
+        self.pre_encode = self.cfg.common.pre_encode
+        self.log_every = self.cfg.common.log_interval
+        self.full_tokens = self.cfg.model.full_tokens \
+            if hasattr(self.cfg.model, "full_tokens") else False
+        if not hasattr(self.cfg.model, "fix_encoder"):
+            self.cfg.model.fix_encoder = False
+        if not hasattr(self.cfg.model, "fix_decoder"):
+            self.cfg.model.fix_decoder = False
+        self.dist = EasyDict()
+        self.dist.rank = dist.get_rank()
+        self.dist.world_size = dist.get_world_size()
+        self.dist_rank = dist.get_rank()
+        self.dist_world_size = dist.get_world_size() 
+        self.use_deepspeed = self.cfg.common.use_deepspeed \
+            if hasattr(self.cfg.common, "use_deepspeed") else False
+        self.use_fp16 = self.cfg.common.use_fp16
+        self.use_bf16 = self.cfg.common.use_bf16
+        self.use_zero = self.cfg.common.use_zero
+
+    def set_vae(self):
+        if self.cfg.tokenizer.params.model == 'MMDiT_XL':
+            self.vae = SDVAE(device="cpu", dtype=torch.bfloat16)
+            state_dict = torch.load(self.vae_path, map_location='cpu')
+            load_state(self.vae, state_dict, 'first_stage_model.')
+        else:
+            self.vae = AutoencoderKL.from_pretrained(self.vae_path)
+        self.vae.cuda()
+        self.vae.eval()
+    
+    def set_ema_model(self, model):
+        ema = deepcopy(model).to(torch.float32)  # Create an EMA of the model for use after training
+        requires_grad(ema, False)
+        update_ema(ema, model, decay=0)
+        if not self.cfg.optimize.ema_in_cpu:
+            ema = ema.cuda()
+        ema.eval()
+        return ema
+
+    def get_model(self,):
+        model = self.model.module if hasattr(self.model, "module") else self.model
+        return model
+    
+    
+    def run_step(self):
+        torch.cuda.synchronize()
+        t0 = time.perf_counter()
+        batch = next(self._data_loader_iter)  # b n c h w
+        x = batch['image'].cuda()
+        if self.low_res_list is not None:
+            x_low = batch[f'image_{self.low_res_list[0]}'].cuda()
+        if not self.use_deepspeed:
+            self.optimizer.zero_grad()
+        # get vae latent
+        with torch.no_grad():
+            latent = self.vae.encode(x)
+            latent = SD3LatentFormat().process_in(latent)
+            if self.low_res_list is not None:
+                latent_low = self.vae.encode(x_low)
+                latent_low = SD3LatentFormat().process_in(latent_low)
+        full_tokens = self.full_tokens
+        
+        with autocast(dtype=torch.bfloat16, cache_enabled=False):
+            if hasattr(self, 'renderer'):
+                with torch.no_grad():
+                    ids, ids_emb, render_latents = self.renderer(
+                        x=latent_low,
+                        recon=self.decoder_use_low_res_rec,
+                    )
+                token_embeds = ids_emb
+                low_res_latent = render_latents
+            else:
+                token_embeds = None
+                low_res_latent = None
+
+            self._loss, log_dict = self.model(
+                x=latent, full_tokens=full_tokens, step=self.iter,
+                token_embeds=token_embeds, low_res_latent=low_res_latent
+            )
+            
+        self._loss.backward()
+        self.optimizer.step()
+
+        # prepare logs
+        grads = [param.grad.abs().sum().item()
+                if param.grad is not None else 0.0
+                for param in self.get_model().encoder.parameters()
+        ]
+        sum_grads = sum(grads)
+        log_dict['enc_sum_grad'] = sum_grads
+        for k, v in log_dict.items():
+            reduced_metric = torch.from_numpy(np.array(v)).float().cuda() / self.dist.world_size
+            if isinstance(v,list):
+                self.meters[k].reduce_update_list(reduced_metric)
+            else:
+                self.meters[k].reduce_update(reduced_metric)
+        self.batch_mse = log_dict['dm_mse']
+        self.n_active = log_dict['n_active']
+
+        torch.cuda.synchronize()
+        t1 = time.perf_counter()
+        if dist.get_rank() == 0:
+            import datetime
+            current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            number_nodes = 40
+            number_npus_per_node = 8
+            iteration = self.iter
+            total_iterations = 120000
+            consumed_images = self.iter * x.shape[0] * number_npus_per_node * number_nodes
+            elapsed_time_per_iteration = (t1-t0)*1000  # 毫秒
+            throughput_per_gpu = 89.8  # TFLOP/s/GPU (computing without renderer)
+            learning_rate = 1E-04
+            global_batch_size = x.shape[0] * number_npus_per_node * number_nodes
+            lm_loss = self.batch_mse
+            loss_scale = 1.0
+            grad_norm = sum_grads
+            skipped_iterations = 0
+            nan_iterations = 0
+            baseline_time = 1300  # 毫秒
+
+            print(f"[{current_time}] iteration: {iteration}/{total_iterations} | "
+                f"consumed images: {consumed_images} | "
+                f"elapsed time per iteration (ms): {elapsed_time_per_iteration:.1f} | "
+                f"throughput per GPU (TFLOP/s/GPU): {throughput_per_gpu:.1f} | "
+                f"learning rate: {learning_rate:.7E} | "
+                f"global batch size:  {global_batch_size} | "
+                f"lm loss: {lm_loss:.6E} | "
+                f"loss scale: {loss_scale:.1f} | "
+                f"grad norm: {grad_norm:.3f} | "
+                f"number of skipped iterations:   {skipped_iterations} | "
+                f"number of nan iterations:   {nan_iterations} | "
+                f"baseline(ms): {baseline_time:.1f} |")

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/__init__.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+from .context_utils import MemartsCopyContext
+from .checkpoint import (
+    set_seed,
+    get_state_dict,
+    get_state_dict_resume,
+    print_model_params,
+    print_model_param_num,
+    SaveModel,
+    LoadStateDict,
+    LoadStateDict_resume,
+    SavePipeline,
+    SaveModelandDisc,
+)
+from .selftok_hook import build_selftok_optimizer, SelfTokHook, SelfTokSaveHook
+from .selftok_validation import EvalSelftokHook
+from .optimizer import clip_gradient, build_optimizer, setup_deepspeed
+from .parameter import parse_args, parse_args_from_yaml
+from .cloud_copy import mox_copy, vid_dataset_copy, img_dataset_copy, common_cloud_copy, universal_cloud_copy
+from .train_loop import HookBase, TrainerBase
+from .record import (
+    TimerAndLogger,
+    SimpleLogger,
+    UniversalMeterLogger,
+    TensorboardLogger,
+    TensorboardPriorLogger,
+    VideoMeterLogger,
+)
+from .scheduler import LRScheduler
+from .profile import TorchProfileHook
+from .profile_npu import NPUTorchProfileHook
+from .ema import EMAhook
+
+__all__ = [
+    "EvalSelftokHook",
+    "build_selftok_optimizer",
+    "SelfTokHook",
+    "SelfTokSaveHook",
+    "clip_gradient",
+    "build_optimizer",
+    "setup_deepspeed",
+    "set_seed",
+    "get_state_dict",
+    "get_state_dict_resume",
+    "print_model_params",
+    "print_model_param_num",
+    "parse_args",
+    "parse_args_from_yaml",
+    "mox_copy",
+    "vid_dataset_copy",
+    "img_dataset_copy",
+    "common_cloud_copy",
+    "universal_cloud_copy",
+    "HookBase",
+    "TrainerBase",
+    "SimpleLogger",
+    "TimerAndLogger",
+    "UniversalMeterLogger",
+    "VideoMeterLogger",
+    "TensorboardLogger",
+    "TensorboardPriorLogger",
+    "LRScheduler",
+    "SaveModel",
+    "SavePipeline",
+    "LoadStateDict",
+    "LoadStateDict_resume",
+    "TorchProfileHook",
+    "EMAhook",
+    "NPUTorchProfileHook",
+    "SaveModelandDisc",
+]

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/checkpoint.py

@@ -0,0 +1,836 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import copy
+import yaml
+import json
+import shutil
+import torch
+import random
+import numpy as np
+from fairscale.optim import OSS
+
+from .cloud_copy import mox_copy
+from .train_loop import HookBase
+from mimogpt.utils import hf_logger
+
+import torch.distributed as dist
+
+
+def set_seed(seed):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def get_state_dict(pretrained_path):
+    if "ViT-B-32.pt" not in pretrained_path and "RN50.pt" not in pretrained_path:
+        # for HW pretrained model
+        state_dict = torch.load(pretrained_path, map_location=torch.device("cpu"))
+        if "state_dict" in state_dict.keys():
+            state_dict = state_dict["state_dict"]
+        if "module" in state_dict.keys():
+            state_dict = state_dict["module"]
+        return state_dict
+    else:
+        # for openai official pretrained model
+        model = torch.jit.load(pretrained_path, map_location="cpu")
+        state_dict = model.state_dict()
+        for key in ["input_resolution", "context_length", "vocab_size"]:
+            del state_dict[key]
+        return state_dict
+
+
+def get_state_dict_resume(pretrained_path):
+    state_dict = torch.load(pretrained_path, map_location=torch.device("cpu"))
+    if len(state_dict) < 10:
+        print(state_dict.keys())
+    return state_dict
+
+
+def print_model_params(model):
+    print("\n--------------- trainable params ---------------")
+    for name, param in model.named_parameters():
+        if param.requires_grad:
+            print(name)
+    print("--------------- trainable params ---------------\n")
+
+
+def print_model_param_num(model_info, model):
+    params_total = sum(p.numel() for p in model.parameters())
+    params_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    if torch.distributed.is_initialized():
+        if torch.distributed.get_rank() == 0:
+            print(
+                "\nmodel_info:\n{}\ntotal_params: {}\ntrainable_params: {}\n".format(
+                    model_info, params_total / 1024 / 1024, params_trainable / 1024 / 1024
+                )
+            )
+    else:
+        print(
+            "\nmodel_info:\n{}\ntotal_params: {}\ntrainable_params: {}\n".format(
+                model_info, params_total, params_trainable
+            )
+        )
+
+
+def calc_total_flops(model_info, model):
+    from thop import profile
+
+    input_v = torch.randn(1, 8, 3, 224, 224).cuda()  # img:[1, 1, 3, 224, 224] / video:[1, 8, 3, 224, 224]
+    input_t = torch.ones(1, 80).long().cuda()  # [1, 80]
+    flops, params = profile(model, inputs=(input_v, input_t))
+    print("model: {}\nflops: {:.2f} Gflops\ntotal_params: {:.2f} M".format(model_info, flops / 1.0e9, params / 1.0e6))
+
+
+class SaveModel(HookBase):
+    def __init__(self, cfg, is_root):
+        self.output_path = cfg.common.output_path
+        self.is_root = is_root
+        self.save_interval = int(cfg.common.save_per_epochs * getattr(cfg, 'dataloader_len', 2000))
+
+        # only for save config before train
+        self._cfg = cfg
+        self.delete_after_upload = cfg.common.get("delete_after_upload", False)
+        self.only_save_lora = cfg.common.get("only_save_lora", False)
+
+    @property
+    def save_path(self):
+        if self.__dict__.get("_output_path", None) is None:
+            output_path = os.path.join(self.output_path, "ckpt")
+            os.makedirs(output_path, exist_ok=True)
+            self.__dict__["_output_path"] = output_path
+        return self.__dict__["_output_path"]
+
+    def before_train(self):
+        self.save_config()
+        self.save_code()
+
+    def after_step(self):
+        if self.trainer.iter % self.save_interval == (self.save_interval - 1):
+            if self.only_save_lora:
+                save_name = "lora_iter_%d.pth" % (self.trainer.iter)
+            else:
+                save_name = "iter_%d.pth" % (self.trainer.iter)
+            # tmp_cfg = copy.deepcopy(self._cfg.__dict__)
+            #
+            # self.save_model({
+            #     'iter': self.trainer.iter,
+            #     'state_dict': self.trainer.model.module.state_dict(),
+            #     'opt': self.trainer.optimizer.state_dict(),
+            #     'cfg': tmp_cfg
+            # }, save_name)
+            if hasattr(self._cfg.common, "use_fsdp") and self._cfg.common.use_fsdp:
+                from torch.distributed.fsdp import FullStateDictConfig, StateDictType
+                from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+
+                save_policy = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+
+                with FSDP.state_dict_type(self.trainer.model, StateDictType.FULL_STATE_DICT, save_policy):
+                    cpu_state = self.trainer.model.state_dict()
+                    self.save_model(cpu_state, save_name)
+            elif hasattr(self._cfg.common, "use_deepspeed") and self._cfg.common.use_deepspeed:
+                self.save_model_deepspeed(save_name)
+            else:
+                if hasattr(self.trainer.model, "module"):
+                    self.save_model(self.trainer.model.module.state_dict(), save_name)
+                else:
+                    self.save_model(self.trainer.model.state_dict(), save_name)
+            torch.cuda.empty_cache()
+
+    def save_config(self):
+        if self.is_root:
+            hf_logger.save_args(self._cfg)
+            run_save_path = os.path.join(self.output_path, "run.yml")
+            if not os.path.isfile(run_save_path):
+                try:
+                    with open(run_save_path, "w") as args_fh:
+                        yaml.dump(self._cfg.__dict__, args_fh, sort_keys=False)
+                    hf_logger.info("Run configs dump to %s" % run_save_path)
+                except:
+                    hf_logger.info("fail to dump run config!!")
+
+    def save_code(self):
+        if self.is_root:
+            try:
+                import moxing as mox
+
+                local_code_path = os.path.abspath(os.path.join(os.path.abspath(__file__), "../../.."))
+                roma_code_path = os.path.join(self._cfg.train_url, os.path.split(local_code_path)[-1])
+                mox_copy(local_code_path, roma_code_path, parallel=True)
+                hf_logger.info("backup code success, roma_code_path:{}".format(roma_code_path))
+            except:
+                pass
+
+    def save_model(self, checkpoint, save_name):
+        if self.is_root:
+            local_weights = os.path.join(self.save_path, save_name)
+            for k, v in checkpoint.items():
+                checkpoint[k] = checkpoint[k].cpu()
+            torch.save(checkpoint, local_weights)
+            self.upload_and_delete_local_model(local_weights)
+
+    def save_model_deepspeed(self, save_name, ema_state=None):
+        # deepspeed save pths
+        self.trainer.model.cpu().save_checkpoint(self.save_path, f"deepspeed_save_dir_{save_name[:-4]}")
+        self.trainer.model.cuda()
+        pth_src_path = os.path.join(self.save_path, f"deepspeed_save_dir_{save_name[:-4]}")
+        if ema_state is not None:
+            if self.is_root:
+                local_weights = os.path.join(pth_src_path, "ema.pt")
+                torch.save(ema_state, local_weights)
+        if hasattr(self._cfg.common, "deepspeed_merge_save") and self._cfg.common.deepspeed_merge_save:
+            # create nas path to merge deepspeed pths
+            MA_NFS_MOUNT_VOLUMES = json.loads(os.getenv("MA_NFS_MOUNT_VOLUMES"))
+            nas_dst_path = MA_NFS_MOUNT_VOLUMES[0]["local_path"]
+            nas_dst_path = os.path.join(nas_dst_path, "ckpt_tmp_{}".format(os.getenv("MASTER_ADDR")))
+            if dist.get_rank() == 0 and not os.path.exists(nas_dst_path):
+                os.mkdir(nas_dst_path)
+                os.mkdir(os.path.join(nas_dst_path, f"deepspeed_save_dir_{save_name[:-4]}"))
+            dist.barrier()
+            # copy local pths to nas
+            if dist.get_rank() % 8 == 0:
+                os.system("cp {}/* {}/deepspeed_save_dir_{}".format(pth_src_path, nas_dst_path, save_name[:-4]))
+            dist.barrier()
+            # merge pths to one on nas
+            if dist.get_rank() == 0:
+                os.system("cp {} {}".format(os.path.join(self.save_path, "latest"), nas_dst_path))
+                merged_pth_path = os.path.join(self.save_path, save_name)
+                try:
+                    os.system("python {}/zero_to_fp32.py {} {}".format(self.save_path, nas_dst_path, merged_pth_path))
+                    self.upload_and_delete_local_model(merged_pth_path)
+                except Exception as e:
+                    print("save and upload deepspeed checkpoint {} failed, error: ".format(merged_pth_path, e))
+                shutil.rmtree(nas_dst_path)
+            dist.barrier()
+            # delete local tmp pths
+            if dist.get_rank() % 8 == 0:
+                shutil.rmtree(pth_src_path)
+        else:
+            self.upload_and_delete_local_model(pth_src_path, rank0_only=False, parallel=True)
+        dist.barrier()
+
+    def upload_and_delete_local_model(self, local_weights, rank0_only=True, parallel=False):
+        device_rank = dist.get_rank()
+        allow_current_device_operate_files = (device_rank % 8 == 0 and not rank0_only) or (
+            device_rank == 0 and rank0_only
+        )
+        try:
+            import moxing as mox
+
+            roma_weights_fp = os.path.join(self._cfg.train_url, local_weights)
+            roma_weights_dirname = os.path.dirname(roma_weights_fp)
+            if allow_current_device_operate_files:
+                if not mox.file.exists(roma_weights_dirname):
+                    mox.file.make_dirs(roma_weights_dirname)
+                mox_copy(local_weights, roma_weights_fp, parallel)
+                hf_logger.info("save weight success, roma_weights_fp:{}".format(roma_weights_fp))
+        except:
+            hf_logger.info("save weight success, local_weights_fp:{}".format(local_weights))
+
+        if self.delete_after_upload and allow_current_device_operate_files:
+            if os.path.isdir(local_weights):
+                shutil.rmtree(local_weights)
+            else:
+                os.remove(local_weights)
+            hf_logger.info(f"{local_weights} removed")
+
+
+class SavePipeline(SaveModel):
+    def save_model(self, checkpoint, save_name):
+        # if hasattr(self.trainer.optimizer, "consolidate_state_dict"):
+        #     self.trainer.optimizer.consolidate_state_dict(recipient_rank=0)
+        if dist.get_rank() == 0:
+            if not os.path.exists("/cache/pipe"):
+                vae = self.trainer.first_stage_model
+                tokenizer = self.trainer.tokenizer
+                text_encoder = self.trainer.cond_stage_model
+                unet = self.trainer.model.module if hasattr(self.trainer.model, "module") else self.trainer.model
+                scheduler = self.trainer.noise_scheduler
+                from diffusers import TextToVideoSDPipeline
+
+                t2v_pipe = TextToVideoSDPipeline(
+                    vae=vae, text_encoder=text_encoder, tokenizer=tokenizer, unet=unet, scheduler=scheduler
+                )
+                t2v_pipe.save_pretrained("/cache/pipe/")
+                import moxing as mox
+
+                roma_weights_dirname = os.path.join(self._cfg.train_url)
+                if not mox.file.exists(roma_weights_dirname):
+                    mox.file.make_dirs(roma_weights_dirname)
+                mox_copy("/cache/pipe/", roma_weights_dirname, parallel=True)
+                hf_logger.info("save pipe success, roma_weights_fp:{}".format(roma_weights_dirname))
+            else:
+                unet = self.trainer.model.module if hasattr(self.trainer.model, "module") else self.trainer.model
+                unet.save_pretrained("/cache/pipe/unet", variant="iter" + str(self.trainer.iter))
+                # unet.save_pretrained('/cache/pipe/unet')
+                # ckpt_name = f'diffusion_pytorch_model.iter{self.trainer.iter}.bin'
+                # roma_weights_fp = os.path.join(self._cfg.train_url, 'unet', ckpt_name)
+                # mox_copy(f'/cache/pipe/unet/{ckpt_name}', roma_weights_fp)
+                # hf_logger.info("save pipe success, roma_weights_fp:{}".format(roma_weights_fp))
+                optimizer = None if isinstance(self.trainer.optimizer, OSS) else self.trainer.optimizer.state_dict()
+                state = {
+                    "iter": self.trainer.iter,
+                    "opt": optimizer,
+                    "cfg": copy.deepcopy(self._cfg.__dict__),
+                }
+                torch.save(state, "/cache/pipe/unet/state.pth")
+                roma_weights_dirname = os.path.join(self._cfg.train_url, "unet")
+                mox_copy("/cache/pipe/unet", roma_weights_dirname, parallel=True)
+
+        dist.barrier()
+
+
+class LoadStateDict(HookBase):
+    def __init__(self, pretrained_path, task, cfg):
+        self.task = task
+        self.pretrained_path = pretrained_path
+        self.use_deepspeed = cfg.common.use_deepspeed
+        self.cfg = cfg
+
+    def before_train(self):
+        if self.use_deepspeed:
+            return
+        if self.task == "vlip":
+            self.load_vlip()
+        elif self.task == "mimo":
+            self.load_mimo()
+        elif self.task == "mimo_gpt":
+            self.load_mimo_gpt()
+        elif self.task in ("mimo_interleaved", "mimo_interleaved_enc"):
+            self.load_mimo_interleaved()
+        elif self.task == "video_ldm":
+            self.load_video_ldm()
+        elif self.task == "mmdit":
+            self.load_mmdit()
+        else:
+            self.load_mimo()
+
+    def load_mimo_interleaved(self):
+        print("I AM IN load_mimo_interleaved!!!!")
+        if self.pretrained_path:
+            state_dict = get_state_dict(self.pretrained_path)
+            try:
+                hf_logger.info("pretrained_path is {}".format(self.pretrained_path))
+                self.trainer.model.module.load_state_dict(state_dict)
+                hf_logger.info("successful loaded state dict from {}".format(self.pretrained_path))
+            except:
+                hf_logger.info("\nload pretrained_path: strict=False, remove visual branches......\n")
+
+                model_dict = self.trainer.model.module.state_dict()  # 当前网络结构
+                pretrained_dict = {k: v for k, v in state_dict.items() if k in model_dict}  # 预训练模型中可用的weight
+
+                # load V2
+                cur_vocab = model_dict["text_embeddings.weight"].shape[0]
+                use_df = self.cfg.tokenizer.get("use_dfvqgan", False)
+                if use_df:
+                    img_vocab = 8192
+                else:
+                    img_vocab = 16384
+                for key, weight in state_dict.items():
+                    if key in model_dict and model_dict[key].shape != state_dict[key].shape:
+                        if "text_embeddings" in key:
+                            pretrained_dict[key] = torch.cat(
+                                (
+                                    state_dict[key][:30522],
+                                    model_dict[key][30522:cur_vocab, :].to(state_dict[key].device),
+                                ),
+                                dim=0,
+                            )
+                            hf_logger.info(
+                                "[{}] shape change: pretrained model {} --> new model {}".format(
+                                    key, state_dict[key].shape, model_dict[key].shape
+                                )
+                            )
+                        elif "to_logits" in key:
+                            pretrained_dict[key] = torch.cat(
+                                (
+                                    state_dict[key][:30522],
+                                    model_dict[key][30522:cur_vocab].to(state_dict[key].device),
+                                    state_dict[key][-img_vocab:],
+                                ),
+                                dim=0,
+                            )
+                            hf_logger.info(
+                                "[{}] shape change: pretrained model {} --> new model {}".format(
+                                    key, state_dict[key].shape, model_dict[key].shape
+                                )
+                            )
+                        elif "text_pos_embeddings" in key:
+                            pre_len = state_dict[key].shape[0]
+                            cur_len = model_dict[key].shape[0]
+                            if pre_len < cur_len:
+                                pretrained_dict[key] = torch.cat(
+                                    (
+                                        state_dict[key][:pre_len],
+                                        model_dict[key][pre_len:cur_len].to(state_dict[key].device),
+                                    ),
+                                    dim=0,
+                                )
+                            else:
+                                pretrained_dict[key] = state_dict[key][:pre_len]
+                        else:
+                            pretrained_dict.pop(key)
+                            hf_logger.info(
+                                "[{}] popped: pretrained model {} --> new model {}".format(
+                                    key, state_dict[key].shape, model_dict[key].shape
+                                )
+                            )
+
+                # 输出没有加载的参数
+                for k in model_dict:
+                    if k not in pretrained_dict:
+                        hf_logger.info("{} not loaded".format(k))
+
+                model_dict.update(pretrained_dict)
+                self.trainer.model.module.load_state_dict(model_dict, strict=False)
+
+    def load_mimo_gpt(self):
+        if self.pretrained_path:
+            state_dict = get_state_dict(self.pretrained_path)
+            try:
+                hf_logger.info("pretrained_path is {}".format(self.pretrained_path))
+                self.trainer.model.module.load_state_dict(state_dict)
+                hf_logger.info("successful loaded state dict from {}".format(self.pretrained_path))
+            except:
+                hf_logger.info("\nload pretrained_path: strict=False, remove visual branches......\n")
+
+                model_dict = self.trainer.model.module.state_dict()  # 当前网络结构
+                pretrained_dict = dict()
+                for k, v in state_dict.items():
+                    if "decoder" in k and "transformer" not in k:
+                        k = k.replace("decoder", "decoder.transformer")
+                        if ".c_" in k:
+                            v = v.t()
+                    if k in model_dict:
+                        pretrained_dict[k] = v
+                pretrained_keys = list(pretrained_dict.keys())
+
+                for key in pretrained_keys:
+                    if model_dict[key].shape != pretrained_dict[key].shape:
+                        print(
+                            "[{}] shape change: pretrained model {} --> new model {}".format(
+                                key, pretrained_dict[key].shape, model_dict[key].shape
+                            )
+                        )
+                        # pretrained_dict.pop(key)
+                        if len(model_dict[key].shape) == 2:
+                            cur_shape0, cur_shape1 = model_dict[key].shape
+                            pre_shape0, pre_shape1 = pretrained_dict[key].shape
+                            if cur_shape0 >= pre_shape0 and cur_shape1 >= pre_shape1:
+                                tmp = torch.cat(
+                                    (
+                                        state_dict[key],
+                                        model_dict[key][pre_shape0:, :pre_shape1].to(state_dict[key].device),
+                                    ),
+                                    dim=0,
+                                )
+                                tmp = torch.cat(
+                                    (tmp, model_dict[key][:, pre_shape1:].to(state_dict[key].device)), dim=1
+                                )
+                                pretrained_dict[key] = tmp
+                            else:
+                                pretrained_dict.pop(key)
+                        elif len(model_dict[key].shape) == 1:
+                            cur_shape0 = model_dict[key].shape[0]
+                            pre_shape0 = pretrained_dict[key].shape[0]
+                            if cur_shape0 >= pre_shape0:
+                                tmp = torch.cat(
+                                    (state_dict[key], model_dict[key][pre_shape0:].to(state_dict[key].device)), dim=0
+                                )
+                                pretrained_dict[key] = tmp
+                            else:
+                                pretrained_dict.pop(key)
+
+                # 输出没有加载的参数
+                for k in model_dict:
+                    if k not in pretrained_dict:
+                        hf_logger.info("{} not loaded".format(k))
+
+                model_dict.update(pretrained_dict)
+                self.trainer.model.module.load_state_dict(model_dict, strict=True)
+
+    def load_mimo(self):
+        if self.pretrained_path:
+            state_dict = get_state_dict(self.pretrained_path)
+            try:
+                hf_logger.info("pretrained_path is {}".format(self.pretrained_path))
+                self.trainer.model.module.load_state_dict(state_dict)
+                hf_logger.info("successful loaded state dict from {}".format(self.pretrained_path))
+            except:
+                hf_logger.info("\nload pretrained_path: strict=False, remove visual branches......\n")
+
+                model_dict = self.trainer.model.module.state_dict()  # 当前网络结构
+                pretrained_dict = {k: v for k, v in state_dict.items() if k in model_dict}  # 预训练模型中可用的weight
+
+                # # TODO: hard code, load 3B model weights
+                # for key, _ in model_dict.items():
+                #     if "transformer.layers." in key:
+                #         cur_layer_id = key.split('layers')[-1].split('.')[1]  # '41'
+                #         # ref_layer_id = int(cur_layer_id) // 2
+                #         if int(cur_layer_id) > 23:
+                #             ref_layer_id = int(cur_layer_id) - 24
+                #             k_ref = key.replace('transformer.layers.{}.'.format(cur_layer_id),
+                #                                 'transformer.layers.{}.'.format(ref_layer_id))
+                #             if k_ref in state_dict and model_dict[key].shape == state_dict[k_ref].shape:
+                #                 pretrained_dict[key] = state_dict[k_ref]
+                #                 hf_logger.info('{} weight is load from {}'.format(key, k_ref))
+
+                cur_vocab = model_dict["text_embeddings.weight"].shape[0]
+                img_vocab = 16384
+                for key, weight in state_dict.items():
+                    if key in model_dict and model_dict[key].shape != state_dict[key].shape:
+                        if "text_embeddings" in key:
+                            pretrained_dict[key] = torch.cat(
+                                (
+                                    state_dict[key][:30522],
+                                    model_dict[key][30522:cur_vocab, :].to(state_dict[key].device),
+                                ),
+                                dim=0,
+                            )
+                            hf_logger.info(
+                                "[{}] shape change: pretrained model {} --> new model {}".format(
+                                    key, state_dict[key].shape, model_dict[key].shape
+                                )
+                            )
+                        elif "to_logits" in key:
+                            pretrained_dict[key] = torch.cat(
+                                (
+                                    state_dict[key][:30522],
+                                    model_dict[key][30522:cur_vocab].to(state_dict[key].device),
+                                    state_dict[key][-img_vocab:],
+                                ),
+                                dim=0,
+                            )
+                            hf_logger.info(
+                                "[{}] shape change: pretrained model {} --> new model {}".format(
+                                    key, state_dict[key].shape, model_dict[key].shape
+                                )
+                            )
+                        elif "text_pos_embeddings" in key:
+                            pre_len = state_dict[key].shape[0]
+                            cur_len = model_dict[key].shape[0]
+                            if pre_len < cur_len:
+                                pretrained_dict[key] = torch.cat(
+                                    (
+                                        state_dict[key][:pre_len],
+                                        model_dict[key][pre_len:cur_len].to(state_dict[key].device),
+                                    ),
+                                    dim=0,
+                                )
+                            else:
+                                pretrained_dict[key] = state_dict[key][:pre_len]
+                        else:
+                            pretrained_dict.pop(key)
+                            hf_logger.info(
+                                "[{}] popped: pretrained model {} --> new model {}".format(
+                                    key, state_dict[key].shape, model_dict[key].shape
+                                )
+                            )
+
+                        # if "condition_to_decoder" in key:
+                        #     pretrained_dict[key] = state_dict[key][:, :512]
+                        #     hf_logger.info("[{}] shape change: pretrained model {} --> new model {}"
+                        #                    .format(key, state_dict[key].shape, model_dict[key].shape))
+                        # elif 'image_row_embeddings' in key or 'image_col_embeddings' in key:
+                        #     pretrained_dict[key] = torch.cat(
+                        #         (state_dict[key][:16, :],
+                        #          model_dict[key][16:32, :].to(state_dict[key].device)),
+                        #         dim=0)
+                        #     hf_logger.info("[{}] shape change: pretrained model {} --> new model {}"
+                        #                    .format(key, state_dict[key].shape, model_dict[key].shape))
+
+                # # load dalle weights
+                # for key, weight in state_dict.items():
+                #     # text_embeddings: 16384 + 128 -> 21128 + 128
+                #     if key == 'text_embeddings.weight':
+                #         if model_dict[key].shape != state_dict[key].shape:
+                #             pretrained_dict.pop(key)
+                #             print("[{}] shape change: pretrained model {} --> new model {}"
+                #                   .format(key, state_dict[key].shape, model_dict[key].shape))
+                #
+                #     if key in ['to_logits.1.weight', 'to_logits.1.bias']:
+                #         if model_dict[key].shape != state_dict[key].shape:
+                #             total_vocab_size = model_dict[key].shape[0]
+                #             pretrained_dict[key] = torch.cat(
+                #                 (model_dict[key][:total_vocab_size - 8192].to(state_dict[key].device),
+                #                  state_dict[key][-8192:]), dim=0)
+                #
+                # # load GPT2 weights
+                # for key, _ in model_dict.items():
+                #     if "decoder." in key:
+                #         k_ref = key.replace("decoder.", "")
+                #         if k_ref in state_dict and model_dict[key].shape == state_dict[k_ref].shape:
+                #             pretrained_dict[key] = state_dict[k_ref]
+                #
+                # for key, weight in state_dict.items():
+                #     if key in model_dict and model_dict[key].shape != state_dict[key].shape:
+                #         pretrained_dict.pop(key)
+                #         hf_logger.info("[{}] shape change: pretrained model {} --> new model {}"
+                #                        .format(key, state_dict[key].shape, model_dict[key].shape))
+
+                # 输出没有加载的参数
+                for k in model_dict:
+                    if k not in pretrained_dict:
+                        hf_logger.info("{} not loaded".format(k))
+
+                model_dict.update(pretrained_dict)
+                self.trainer.model.module.load_state_dict(model_dict, strict=False)
+
+    def load_vlip(self):
+        if self.pretrained_path:
+            state_dict = get_state_dict(self.pretrained_path)
+            try:
+                hf_logger.info("pretrained_path is {}".format(self.pretrained_path))
+                self.trainer.model.module.load_state_dict(state_dict)
+                hf_logger.info("successful loaded state dict from {}".format(self.pretrained_path))
+            except:
+                hf_logger.info("\nload pretrained_path: strict=False, remove visual branches......\n")
+                state_dict["state_dict"] = state_dict
+
+                model_dict = self.trainer.model.module.state_dict()  # 当前网络结构
+                pretrained_dict = {
+                    k: v for k, v in state_dict["state_dict"].items() if k in model_dict
+                }  # 预训练模型中可用的weight
+
+                for k, _ in model_dict.items():
+                    if "frame_fusion" in k:
+                        k_ref = k.replace("frame_fusion", "transformer")
+                        pretrained_dict[k] = state_dict["state_dict"][k_ref]
+
+                for k, _ in model_dict.items():
+                    if "textual." in k:
+                        k_ref = k.replace("textual.", "")
+                        pretrained_dict[k] = state_dict["state_dict"][k_ref]
+
+                # for CLIP_VIP
+                for key, weight in state_dict["state_dict"].items():
+                    if "in_proj_weight" in key:
+                        q_proj, k_proj, v_proj = weight.chunk(3, dim=0)
+                        key_q = key.replace("in_proj_weight", "q_proj.weight")
+                        key_k = key.replace("in_proj_weight", "k_proj.weight")
+                        key_v = key.replace("in_proj_weight", "v_proj.weight")
+                        pretrained_dict[key_q] = q_proj
+                        pretrained_dict[key_k] = k_proj
+                        pretrained_dict[key_v] = v_proj
+                    elif "in_proj_bias" in key:
+                        q_proj, k_proj, v_proj = weight.chunk(3, dim=0)
+                        key_q = key.replace("in_proj_bias", "q_proj.bias")
+                        key_k = key.replace("in_proj_bias", "k_proj.bias")
+                        key_v = key.replace("in_proj_bias", "v_proj.bias")
+                        pretrained_dict[key_q] = q_proj
+                        pretrained_dict[key_k] = k_proj
+                        pretrained_dict[key_v] = v_proj
+                    elif key == "visual.positional_embedding":
+                        pretrained_dict["visual.positional_embedding.weight"] = weight
+                    elif key == "visual.class_embedding":
+                        pretrained_dict["visual.added_cls"] = weight.expand(3, -1)
+
+                # 输出没有加载的参数
+                for k in model_dict:
+                    if k not in pretrained_dict:
+                        hf_logger.info("{} not loaded".format(k))
+
+                model_dict.update(pretrained_dict)
+                self.trainer.model.module.load_state_dict(model_dict, strict=False)
+
+    def load_video_ldm(self):
+        if self.pretrained_path:
+            state = torch.load(self.pretrained_path, "cpu")
+            if hasattr(self.trainer.model, "module"):
+                missing_keys, unexpected_keys = self.trainer.model.module.load_state_dict(state, strict=False)
+            else:
+                missing_keys, unexpected_keys = self.trainer.model.load_state_dict(state, strict=False)
+            hf_logger.info(f"missing_keys: {missing_keys}")
+            hf_logger.info(f"unexpected_keys: {unexpected_keys}")
+
+    def load_mmdit(self):
+        if self.pretrained_path:
+            state_dict = get_state_dict(self.pretrained_path)
+            try:
+                hf_logger.info("pretrained_path is {}".format(self.pretrained_path))
+                self.trainer.model.module.load_state_dict(state_dict)
+                hf_logger.info("successful loaded state dict from {}".format(self.pretrained_path))
+            except:
+                hf_logger.info("\nload pretrained_path: strict=False, remove invalid parameter......\n")
+
+                model_dict = self.trainer.model.module.state_dict()  # 当前网络结构
+                pretrained_dict = {k: v for k, v in state_dict.items() if k in model_dict}  # 预训练模型中可用的weight
+
+                for key, weight in state_dict.items():
+                    if key in model_dict and model_dict[key].shape != state_dict[key].shape:
+                        if "x_embedder.proj.weight" in key:  # [1280, 4, 2, 2] -> [1280, 16, 2, 2]
+                            pretrained_dict[key] = torch.cat(
+                                (state_dict[key], model_dict[key][:, 4:].to(state_dict[key].device)), dim=1
+                            )
+                            hf_logger.info(
+                                "[{}] shape change: pretrained model {} --> new model {}".format(
+                                    key, state_dict[key].shape, model_dict[key].shape
+                                )
+                            )
+                        else:
+                            pretrained_dict.pop(key)
+                            hf_logger.info(
+                                "[{}] popped: pretrained model {} --> new model {}".format(
+                                    key, state_dict[key].shape, model_dict[key].shape
+                                )
+                            )
+
+                # 输出没有加载的参数
+                for k in model_dict:
+                    if k not in pretrained_dict:
+                        hf_logger.info("{} not loaded".format(k))
+
+                model_dict.update(pretrained_dict)
+                self.trainer.model.module.load_state_dict(model_dict, strict=False)
+
+    def load_selftok(self):
+        if self.pretrained_path:
+            state_dict = get_state_dict(self.pretrained_path)
+            try:
+                hf_logger.info("pretrained_path is {}".format(self.pretrained_path))
+                self.trainer.model.module.load_state_dict(state_dict)
+                hf_logger.info("successful loaded state dict from {}".format(self.pretrained_path))
+            except:
+                hf_logger.info("\nload pretrained_path: strict=False, remove invalid parameter......\n")
+
+                model_dict = self.trainer.model.module.state_dict()  # 当前网络结构
+                pretrained_dict = {k: v for k, v in state_dict.items() if k in model_dict}  # 预训练模型中可用的weight
+
+                cur_vocab = model_dict["image_embeddings.weight"]
+                print('cur_vocab',cur_vocab.shape)
+                img_vocab = 16384
+                for key, weight in state_dict.items():
+                    if "image_embeddings" in key:
+                        print(model_dict[key].shape)
+                        print('state_dict',state_dict[key].shape)
+                        pretrained_dict[key] = torch.cat(
+                            (
+                                state_dict[key][:16384],
+                                model_dict[key][16384:].to(state_dict[key].device),
+                            ),
+                            dim=0,
+                        )
+                        hf_logger.info(
+                            "[{}] shape change: pretrained model {} --> new model {}".format(
+                                key, state_dict[key].shape, model_dict[key].shape
+                            )
+                        )
+                    elif "head" in key:
+                        pretrained_dict[key] = torch.cat(
+                            (
+                                state_dict[key][:16384],
+                                model_dict[key][16384:].to(state_dict[key].device),
+                            ),
+                            dim=0,
+                        )
+                        hf_logger.info(
+                            "[{}] shape change: pretrained model {} --> new model {}".format(
+                                key, state_dict[key].shape, model_dict[key].shape
+                            )
+                        )
+
+                # 输出没有加载的参数
+                for k in model_dict:
+                    if k not in pretrained_dict:
+                        hf_logger.info("{} not loaded".format(k))
+
+                model_dict.update(pretrained_dict)
+                self.trainer.model.module.load_state_dict(model_dict, strict=False)
+
+
+class LoadStateDict_resume(HookBase):
+    def __init__(self, pretrained_path):
+        self.pretrained_path = pretrained_path
+
+    def before_train(self):
+        if self.pretrained_path:
+            state_dict = get_state_dict_resume(self.pretrained_path)
+
+            self.trainer.optimizer.load_state_dict(state_dict["opt"])
+            hf_logger.info("successfully resume optimizer state dict from {}".format(self.pretrained_path))
+
+            self.trainer.iter = state_dict["iter"]
+            hf_logger.info("successfully resume from iter: {}".format(self.trainer.iter))
+
+            self.trainer.model.module.load_state_dict(state_dict["state_dict"])
+            hf_logger.info("successfully resume model state dict from {}".format(self.pretrained_path))
+
+
+class SaveModelandDisc(HookBase):
+    def __init__(self, cfg, is_root):
+        self.output_path = cfg.common.output_path
+        self.is_root = is_root
+        self.save_interval = int(cfg.common.save_per_epochs * getattr(cfg, 'dataloader_len', 2000))
+
+        # only for save config before train
+        self._cfg = cfg
+        self.delete_after_upload = cfg.common.get("delete_after_upload", False)
+
+    @property
+    def save_path(self):
+        if self.__dict__.get("_output_path", None) is None:
+            output_path = os.path.join(self.output_path, "ckpt")
+            os.makedirs(output_path, exist_ok=True)
+            self.__dict__["_output_path"] = output_path
+        return self.__dict__["_output_path"]
+
+    def before_train(self):
+        self.save_config()
+        self.save_code()
+
+    def after_step(self):
+        if self.trainer.iter % self.save_interval == (self.save_interval - 1):
+            save_name = "iter_%d.pth" % (self.trainer.iter)
+            save_disc_name = "iter_%d_disc.pth" % (self.trainer.iter)
+
+            self.save_model(self.trainer.model.module.state_dict(), save_name)
+            self.save_model(self.trainer.loss.module.discriminator.state_dict(), save_disc_name)
+            torch.cuda.empty_cache()
+
+    def save_config(self):
+        if self.is_root:
+            hf_logger.save_args(self._cfg)
+            run_save_path = os.path.join(self.output_path, "run.yml")
+            if not os.path.isfile(run_save_path):
+                try:
+                    with open(run_save_path, "w") as args_fh:
+                        yaml.dump(self._cfg.__dict__, args_fh, sort_keys=False)
+                    hf_logger.info("Run configs dump to %s" % run_save_path)
+                except:
+                    hf_logger.info("fail to dump run config!!")
+
+    def save_code(self):
+        if self.is_root:
+            try:
+                import moxing as mox
+
+                local_code_path = os.path.abspath(os.path.join(os.path.abspath(__file__), "../../.."))
+                roma_code_path = os.path.join(self._cfg.train_url, os.path.split(local_code_path)[-1])
+                mox_copy(local_code_path, roma_code_path, parallel=True)
+                hf_logger.info("backup code success, roma_code_path:{}".format(roma_code_path))
+            except:
+                pass
+
+    def save_model(self, checkpoint, save_name):
+        if self.is_root:
+            local_weights = os.path.join(self.save_path, save_name)
+            torch.save(checkpoint, local_weights)
+            try:
+                import moxing as mox
+
+                roma_weights_fp = os.path.join(self._cfg.train_url, local_weights)
+                roma_weights_dirname = os.path.dirname(roma_weights_fp)
+                if not mox.file.exists(roma_weights_dirname):
+                    mox.file.make_dirs(roma_weights_dirname)
+                mox_copy(local_weights, roma_weights_fp)
+                hf_logger.info("save weight success, roma_weights_fp:{}".format(roma_weights_fp))
+            except:
+                hf_logger.info("save weight success, local_weights_fp:{}".format(local_weights))
+
+            if self.delete_after_upload:
+                os.remove(local_weights)
+                hf_logger.info(f"{local_weights} removed")

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/cloud_copy.py

@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+
+import os
+import time
+import subprocess
+from typing import Any
+from pathlib import Path
+from contextlib import ContextDecorator
+
+try:
+    os.environ["MOX_SILENT_MODE"] = "1"
+    os.environ["MOX_FILE_LARGE_FILE_METHOD"] = "1"  # for moxing download acceleration
+    import moxing as mox
+
+    mox.file.set_auth(is_secure=False)
+
+except:
+    mox = None
+from mimogpt.utils import read_from_yaml
+
+
+class MemartsCopyContext(ContextDecorator):
+    def __init__(self):
+        """
+        This context manager is only in use when memarts is enabled, if memarts is not enabled it does nothing.
+        It basically set _USE_MEMARTS to False when enter this context, then set _USE_MEMARTS back to True when exit
+        Because normal mox copy in main process will cause error in dataloader when memarts is enabled,
+        so we need to use this context manager to wrap any mox copy call to avoid error.
+
+        To use this context manager:
+        with MemartsCopyContext():
+            mox.file.copy(xxx, xx)
+
+        or
+
+        @MemartsCopyContext()
+        def mox_copy(src, dst):
+            mox.file.copy_parallel(src, dst)
+        """
+        self.use_memarts = (os.environ.get("USE_MEMARTS") == "1") and (mox is not None)
+
+    def __enter__(self):
+        if self.use_memarts:
+            mox.file.file_io._USE_MEMARTS = False
+
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any):
+        if self.use_memarts:
+            mox.file.file_io._USE_MEMARTS = True
+
+
+def _check_dir(dist_dir):
+    copy_flag = True
+    if os.path.exists(dist_dir):
+        copy_flag = False
+    if not os.path.exists(os.path.dirname(dist_dir)):
+        os.makedirs(os.path.dirname(dist_dir))
+    return copy_flag
+
+
+def cmd_exec(cmd, just_print=False):
+    t = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+    print("\n{}:INFO:{}".format(t, cmd))
+    if not just_print:
+        os.system(cmd)
+
+
+@MemartsCopyContext()
+def mox_copy(src, dst, parallel=False):
+    if src == dst:
+        cmd_exec("mox_copy, src=dst={}, return".format(src), just_print=True)
+        return
+    if not (src.startswith("s3://") or dst.startswith("s3://")):
+        cmd_exec(
+            "mox_copy, at least one of src and dst need startswith s3://, src={}, dst={}, return".format(src, dst),
+            just_print=True,
+        )
+        return
+    while True:
+        failed = 0
+        try:
+            cmd_exec(f"mox copy: {src} {dst}", just_print=True)
+            if parallel:
+                mox.file.copy_parallel(src, dst)
+            else:
+                mox.file.copy(src, dst)
+            break
+        except Exception as e:
+            failed += 1
+            time.sleep(60)
+            if failed % 10 == 0:
+                cmd_exec(
+                    "error, maybe need check. copy failed {} times from {} to {}".format(failed, src, dst),
+                    just_print=True,
+                )
+                cmd_exec("error message: {}".format(e), just_print=True)
+
+
+def uncompress(tar_file):
+    ret = subprocess.check_output("ps -ef | grep tar | grep xf | grep -v grep | grep -v 'sh -c' | wc -l", shell=True)
+    ret = int(ret.decode("utf-8"))
+    if ret > 0:
+        cmd_exec("find uncompress running process:", just_print=True)
+        os.system("ps -ef | grep tar | grep xf | grep -v grep | grep -v 'sh -c'")
+    tar_name = os.path.split(tar_file)[-1]
+    tar_dir = os.path.dirname(tar_file)
+    cmd_exec("cd {} && tar -xf {} && rm -rf {} &".format(tar_dir, tar_name, tar_name))
+
+
+def copy_data_to_cache(src_dir="", dist_dir="", rank=0, world_size=1, args=None):
+    start_t = time.time()
+    copy_flag = _check_dir(dist_dir)
+
+    if args is not None and args.local_shuffle_type == 4:
+        local_shuffle = args.local_shuffle_type
+        zip_max_split = args.zip_max_split
+        print(
+            "training in cloud, using local_shuffle_type={}, zip_max_split={}".format(
+                args.local_shuffle_type, zip_max_split
+            )
+        )
+    else:
+        local_shuffle = 0
+        zip_max_split = -1
+
+    if copy_flag:
+        print("copy from {} to {}".format(src_dir, dist_dir))
+        tar_files = []
+        t0 = time.time()
+        if ".mindrecord" in src_dir:
+            src_dir = os.path.split(src_dir)[0]
+            dist_dir = os.path.split(dist_dir)[0]
+
+        last_file = None
+        allready_uncompress = []
+        copy_dir = []
+
+        if mox.file.is_directory(src_dir):  # no new tar in tar !!!
+            subfiles = [subfile for subfile in mox.file.list_directory(src_dir, recursive=False)]
+            subfiles.sort()
+            for subfile in subfiles:
+                sub_src_dir = os.path.join(src_dir, subfile)
+                sub_dist_dir = os.path.join(dist_dir, subfile)
+
+                if local_shuffle and "split_part" in sub_src_dir:
+                    if sub_src_dir.endswith("_map.pkl"):
+                        continue
+                    part_idx = int(
+                        os.path.split(sub_src_dir)[-1][-8:-4]
+                    )  # "AAAA_split_partBBBB.pkl" or "AAAA_split_partBBBB.zip"
+                    if part_idx % world_size != rank or part_idx >= zip_max_split:
+                        continue
+
+                # uncompress last file
+                if last_file is not None and last_file.endswith(".tar"):
+                    uncompress(last_file)
+                    allready_uncompress.append(last_file)
+
+                # copy new file
+                cmd_exec("copy from {} to {}".format(sub_src_dir, sub_dist_dir), just_print=True)
+                if mox.file.is_directory(sub_src_dir):
+                    mox_copy(sub_src_dir, sub_dist_dir, parallel=True)
+                    copy_dir.append(sub_dist_dir)
+                    last_file = None
+                else:
+                    mox_copy(sub_src_dir, sub_dist_dir)
+                    last_file = sub_dist_dir
+
+            if last_file is not None and last_file.endswith(".tar"):
+                uncompress(last_file)
+                allready_uncompress.append(last_file)
+
+        else:
+            mox_copy(src_dir, dist_dir)
+            if dist_dir.endswith("tar") or dist_dir.endswith("tar.gz"):
+                tar_files.append(dist_dir)
+
+        t1 = time.time()
+        cmd_exec("copy datasets, time used={:.2f}s".format(t1 - t0), just_print=True)
+
+        # final check, no tar forget
+        for _dir in copy_dir:
+            tar_list = list(Path(_dir).glob("**/*.tar"))
+            tar_files.extend(tar_list)
+            tar_list = list(Path(_dir).glob("**/*.tar.gz"))
+            tar_files.extend(tar_list)
+
+        tar_files = [x for x in tar_files if str(x) not in allready_uncompress]
+
+        cmd_exec("tar_files:{}".format(tar_files), just_print=True)
+        for tar_file in tar_files:
+            tar_dir = os.path.dirname(tar_file)
+            cmd_exec("cd {} && tar -xf {} && rm -rf {} &".format(tar_dir, tar_file, tar_file))
+
+        # final check, no tar process
+        while True:
+            ret = subprocess.check_output(
+                "ps -ef | grep tar | grep xf | grep -v grep | grep -v 'sh -c' | wc -l", shell=True
+            )
+            ret = int(ret.decode("utf-8"))
+            if ret == 0:
+                cmd_exec("not find tar process, break", just_print=True)
+                break
+            else:
+                cmd_exec("find {} tar process, sleep 10s".format(ret), just_print=True)
+                os.system("ps -ef | grep tar | grep xf | grep -v grep | grep -v 'sh -c'")
+            time.sleep(10)
+
+        cmd_exec("copy data completed!", just_print=True)
+
+    else:
+        cmd_exec(
+            "since data already exists, copying is not required, src={}, dst={}".format(src_dir, dist_dir),
+            just_print=True,
+        )
+
+    end_t = time.time()
+    cmd_exec("copy cost total time {:.2f} sec".format(end_t - start_t), just_print=True)
+
+
+def vid_dataset_copy(fp, args=None):
+    import moxing as mox
+    from pathlib import Path
+
+    y = read_from_yaml(fp)
+    src = y["data_path"]["cloud_copy"]["src_dir"]
+    dst = y["data_path"]["cloud_copy"]["dst_dir"]
+
+    if os.path.exists(os.path.dirname(dst)):
+        print("Train dataset exist, skip dataset copy.")
+        return
+
+    # print("Copying data from {} to {}".format(src, dst))
+    # tar_files = []
+    # mox.file.copy_parallel(src, dst)
+    # tar_files.extend(list(Path(dst).glob('**/*.tar')))
+
+    subfiles = [
+        "CC3M.tar",
+        "dev_test.tar",
+        "vid_test.tar",
+        "vid_9_open_1fps.tar",
+        "models.tar",
+        "json.tar",
+    ]  # , 'open_pretrain_0328.tar', 'open_pretrain_0331.tar']
+    for subfile in subfiles:
+        s3_tar_file = os.path.join(src, subfile)
+        tar_file = os.path.join(dst, subfile)
+        print("Copying data from {} to {}".format(s3_tar_file, tar_file))
+        mox.file.copy(s3_tar_file, tar_file)
+
+        tar_dir = os.path.dirname(tar_file)
+        print("cd {}; tar -xvf {} > /dev/null 2>&1; rm -rf {}".format(tar_dir, tar_file, tar_file))
+        os.system("cd {}; tar -xvf {} > /dev/null 2>&1; rm -rf {}".format(tar_dir, tar_file, tar_file))
+    return y
+
+
+def img_dataset_copy(fp, rank=0, world_size=1, args=None):
+    import moxing as mox
+    from pathlib import Path
+
+    y = read_from_yaml(fp)
+    src = y["data_path"]["cloud_copy"]["src_dir"]
+    dst = y["data_path"]["cloud_copy"]["dst_dir"]
+
+    if os.path.exists(os.path.dirname(dst)):
+        print("Train dataset exist, skip dataset copy.")
+        return
+
+    local_shuffle = int(y["dataloader"]["local_shuffle_type"])
+    zip_max_split = int(y["data_path"]["zip_max_split"])
+    zip_min_split = int(y["data_path"]["zip_min_split"]) if "zip_min_split" in y["data_path"] else 0
+    do_unzip = bool(y["data_path"]["do_unzip"])
+
+    subfiles = [subfile for subfile in mox.file.list_directory(src, recursive=False)]
+    subfiles.sort()
+    for subfile in subfiles:
+        sub_src_file = os.path.join(src, subfile)
+        sub_dst_file = os.path.join(dst, subfile)
+
+        if local_shuffle and "split_part" in sub_src_file:
+            if sub_src_file.endswith("_map.pkl") or sub_src_file.endswith("_otn.pkl"):
+                continue
+            part_idx = int(
+                os.path.split(sub_src_file)[-1][-8:-4]
+            )  # "AAAA_split_partBBBB.pkl" or "AAAA_split_partBBBB.zip"
+            if part_idx % world_size != rank or part_idx >= zip_max_split or part_idx < zip_min_split:
+                continue
+
+            # TODO hard code for MTI_ori_split
+            if "MTI_ori_split" in sub_src_file and sub_src_file.endswith(".pkl"):
+                sub_src_file = sub_src_file.replace("MTI_ori_split", "MTI_ori_split_en_zh_pkl")
+
+            mox.file.copy(sub_src_file, sub_dst_file)
+
+            if sub_dst_file.endswith(".zip") and do_unzip:
+                zip_dir, zip_name = os.path.split(sub_dst_file)
+                zip_idx = int(zip_name[-8:-4])  # AAAA_split_partBBBB.zip"
+                cmd_unzip = "(cd {}; mkdir {}; unzip -qq {} -d {}/ > /dev/null 2>&1; rm -rf {})&".format(
+                    zip_dir, zip_idx, zip_name, zip_idx, zip_name
+                )
+                print(cmd_unzip)
+                os.system(cmd_unzip)
+
+    # copy aux tar files
+    s3_tar_files = y["data_path"]["cloud_copy"]["aux_tars"]
+    for s3_tar_file in s3_tar_files:
+        tar_name = os.path.basename(s3_tar_file)
+        dst_tar_file = os.path.join(dst, tar_name)
+        mox.file.copy(s3_tar_file, dst_tar_file)
+
+        if dst_tar_file.endswith(".tar"):
+            tar_dir = os.path.dirname(dst_tar_file)
+            print("cd {}; tar -xvf {} > /dev/null 2>&1; rm -rf {}".format(tar_dir, tar_name, tar_name))
+            os.system("cd {}; tar -xvf {} > /dev/null 2>&1; rm -rf {}".format(tar_dir, tar_name, tar_name))
+    return y
+
+
+# below are new api, img_dataset_copy is deprecated.
+def mox_copy_with_check(cloud_file, local_file, parallel=False):
+    if os.path.exists(local_file) or os.path.exists(local_file[:-4]):
+        print(f"mox_copy, dst={local_file} already exists!, skip copy")
+        return
+    mox_copy(cloud_file, local_file, parallel)
+
+
+def common_cloud_copy(cfg, rank=0, world_size=1):
+    # step1: copy aux file
+    src_files = cfg.cloud_copy.src_files
+    dst_dir = cfg.cloud_copy.dst_dir
+    for cloud_file in src_files:
+        if os.path.splitext(cloud_file)[-1]:  # file
+            file_name = os.path.basename(cloud_file)
+            local_file = os.path.join(dst_dir, file_name)
+        else:  # directory
+            cloud_file = os.path.dirname(cloud_file)
+            file_name = cloud_file.split("/")[-1]
+            local_file = os.path.join(dst_dir, file_name)
+        mox_copy_with_check(cloud_file, local_file, mox.file.is_directory(cloud_file))
+
+        if file_name.endswith(".tar"):
+            print("cd {}; tar -xvf {} > /dev/null 2>&1; rm -rf {}".format(dst_dir, file_name, file_name))
+            os.system("cd {}; tar -xvf {} > /dev/null 2>&1; rm -rf {}".format(dst_dir, file_name, file_name))
+        if file_name.endswith(".zip"):
+            print("cd {}; unzip {} > /dev/null 2>&1; rm -rf {}".format(dst_dir, file_name, file_name))
+            os.system("cd {}; unzip {} > /dev/null 2>&1; rm -rf {}".format(dst_dir, file_name, file_name))
+        if file_name.endswith(".whl"):
+            print("cd {}; pip install {}".format(dst_dir, file_name))
+            os.system("cd {}; pip install {}".format(dst_dir, file_name))
+
+    # step2, check memarts
+    if os.environ.get("USE_MEMARTS") == "1":
+        return
+
+    # step3, copy train zip and pkl
+    for _, info in cfg.data_path.train.__dict__.items():
+        zip_root, pkl_root, data_list, type, columns, pkl_format, split_range, ratio = info[:8]
+
+        # step2, check memarts
+        # if os.environ.get("USE_MEMARTS") == "1" and type != '':
+        #     continue
+
+        for idx in range(split_range[0], split_range[1]):
+            # split entire list by nodes (here world size is the total nodes of one job， rank is node number)
+            if idx % world_size != rank:
+                continue
+
+            # copy pkl
+            if pkl_root:
+                pkl_name = data_list.format(idx)
+                cloud_file = os.path.join(pkl_root, pkl_name)
+                mox_copy_with_check(
+                    cloud_file, cloud_file.replace("s3://", "/cache/"), mox.file.is_directory(cloud_file)
+                )
+
+            # copy zip
+            if zip_root:
+                if data_list.endswith("pkl"):
+                    zip_name = data_list.replace(".pkl", ".zip").format(idx)
+                elif data_list.endswith("parquet"):
+                    zip_name = data_list.replace(".parquet", ".zip").format(idx)
+                else:
+                    raise NotImplementedError
+                cloud_file = os.path.join(zip_root, zip_name)
+                mox_copy_with_check(
+                    cloud_file, cloud_file.replace("s3://", "/cache/"), mox.file.is_directory(cloud_file)
+                )
+
+            # TODO: hard code for multi-zip data copy
+            if len(info) >= 9 and isinstance(info[8], (list, tuple)):
+                file_root, file_name = info[8]
+                if isinstance(file_root, str) and file_root.startswith("s3://"):
+                    file_name = file_name.format(idx)
+                    cloud_file = os.path.join(file_root, file_name)
+                    mox_copy_with_check(
+                        cloud_file, cloud_file.replace("s3://", "/cache/"), mox.file.is_directory(cloud_file)
+                    )
+
+
+def apply_filename_adapter(type, file_pattern, idx):
+    if type is None:
+        return file_pattern.format(idx)
+    if type == "webvid_raw":
+        return file_pattern.format(idx * 50 + 1, (idx + 1) * 50)
+    else:
+        raise NotImplementedError
+
+
+def universal_cloud_copy(
+    url=None,
+    dst=None,
+    local_shuffle=False,
+    file_pattern=None,
+    adapter_type=None,
+    split_range=None,
+    cmd=None,
+    rank=0,
+    world_size=1,
+):
+    if url is None or dst is None:
+        return
+    if local_shuffle:
+        assert (
+            file_pattern is not None and split_range is not None
+        ), f"Set file pattern and split range in yaml for local shuffle"
+        for idx in range(split_range[0], split_range[1]):
+            # split entire list by nodes (here world size is the total nodes of one job， rank is node number)
+            if idx % world_size != rank:
+                continue
+            cur_file = apply_filename_adapter(adapter_type, file_pattern, idx)
+            cloud_file = os.path.join(url, cur_file)
+            local_file = os.path.join(dst, cur_file)
+            if os.path.exists(local_file):
+                # only mimo needs this because of debug mode 1, skip already copied files
+                print(f"mox_copy, dst={local_file} already exists!, skip copy")
+                continue
+            if not mox.file.exists(cloud_file):
+                print(f"mox_copy, src={cloud_file} not exists, skip copy")
+                continue
+            is_dir = mox.file.is_directory(cloud_file)
+            mox_copy(cloud_file, local_file, is_dir)
+    else:
+        if os.path.exists(dst):
+            # only mimo needs this because of debug mode 1, skip already copied files
+            print(f"mox_copy, dst={dst} already exists!, skip copy")
+            return
+        is_dir = mox.file.is_directory(url)
+        mox_copy(url, dst, parallel=is_dir)
+        if cmd is not None:
+            print(f"Begin to run: {cmd}")
+            os.system(cmd)

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/context_utils.py

@@ -0,0 +1,39 @@
+import os
+from contextlib import ContextDecorator
+from typing import Any
+
+try:
+    import moxing as mox
+
+    mox.file.set_auth(is_secure=False)
+except ImportError:
+    mox = None
+
+
+class MemartsCopyContext(ContextDecorator):
+    def __init__(self):
+        """
+        This context manager is only in use when memarts is enabled, if memarts is not enabled it does nothing.
+        It basically set _USE_MEMARTS to False when enter this context, then set _USE_MEMARTS back to True when exit
+        Because normal mox copy in main process will cause error in dataloader when memarts is enabled,
+        so we need to use this context manager to wrap any mox copy call to avoid error.
+
+        To use this context manager:
+        with MemartsCopyContext():
+            mox.file.copy(xxx, xx)
+
+        or
+
+        @MemartsCopyContext()
+        def mox_copy(src, dst):
+            mox.file.copy_parallel(src, dst)
+        """
+        self.use_memarts = (os.environ.get("USE_MEMARTS") == "1") and (mox is not None)
+
+    def __enter__(self):
+        if self.use_memarts:
+            mox.file.file_io._USE_MEMARTS = False
+
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any):
+        if self.use_memarts:
+            mox.file.file_io._USE_MEMARTS = True

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/ema.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+
+
+from .train_loop import HookBase
+import torch
+import copy
+import os
+from .cloud_copy import mox_copy
+from mimogpt.utils import hf_logger
+
+
+def devices():
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    else:
+        return torch.device("cpu")
+
+
+class EMAhook(HookBase):
+    def __init__(self, cfg, is_root):
+        self.cfg = cfg
+        self.use_ema = self.cfg.optimize.use_ema
+        self.ema_test_interval = self.cfg.optimize.ema_test_interval
+        self.ema_factor = self.cfg.optimize.ema_factor
+        self.ema_in_cpu = self.cfg.optimize.ema_in_cpu
+        self.gradient_accumulation_steps = self.cfg.optimize.get("gradient_accumulation_steps", 1)
+
+        # self.Trainer = Trainer
+
+        self.is_root = is_root
+        self.save_interval = int(self.cfg.common.save_per_epochs * self.cfg.dataloader_len)
+        self.delete_after_upload = cfg.common.get("delete_after_upload", False)
+        self.output_path = self.cfg.common.output_path
+
+    def after_step(self):
+        # print((self.trainer.iter + 1))
+        # print(self.use_ema)
+        if self.use_ema and (self.trainer.iter + 1) % self.gradient_accumulation_steps == 0:
+            with torch.no_grad():
+                for p, p_ema in zip(self.trainer.model.parameters(), self.trainer.ema_model.parameters()):
+                    if self.ema_in_cpu:
+                        p1 = p.data.detach().clone().cpu()
+                    else:
+                        p1 = p.data.detach().clone()
+                    p_ema.data.mul_(self.ema_factor).add_((1 - self.ema_factor) * p1)
+
+        if self.trainer.iter % self.save_interval == (self.save_interval - 1):
+            if self.cfg.optimize.use_ema:
+                save_name = "ema_iter_%d.pth" % (self.trainer.iter)
+                self.save_model(self.trainer.ema_model.state_dict(), save_name)
+                torch.cuda.empty_cache()
+
+    def before_train(self):
+        if self.use_ema:
+            print("Build EMA Model...")
+            if self.ema_in_cpu:
+                self.trainer.ema_model = copy.deepcopy(self.trainer.model_before_ddp)
+            else:
+                self.trainer.ema_model = copy.deepcopy(self.trainer.model_before_ddp).to(devices())
+            self.trainer.ema_model.requires_grad_(False)
+            self.trainer.ema_model.eval()
+            print("Done...")
+
+    @property
+    def save_path(self):
+        if self.__dict__.get("_output_path", None) is None:
+            output_path = os.path.join(self.output_path, "ckpt")
+            os.makedirs(output_path, exist_ok=True)
+            self.__dict__["_output_path"] = output_path
+        return self.__dict__["_output_path"]
+
+    def save_model(self, checkpoint, save_name):
+        if self.use_ema:
+            if self.is_root:
+                local_weights = os.path.join(self.save_path, save_name)
+                torch.save(checkpoint, local_weights)
+                try:
+                    import moxing as mox
+
+                    roma_weights_fp = os.path.join(self.cfg.train_url, local_weights)
+                    roma_weights_dirname = os.path.dirname(roma_weights_fp)
+                    if not mox.file.exists(roma_weights_dirname):
+                        mox.file.make_dirs(roma_weights_dirname)
+                    mox_copy(local_weights, roma_weights_fp)
+                    hf_logger.info("save weight success, roma_weights_fp:{}".format(roma_weights_fp))
+                    if self.delete_after_upload:
+                        os.remove(local_weights)
+                        hf_logger.info(f"{local_weights} removed")
+                except:
+                    hf_logger.info("save weight success, local_weights_fp:{}".format(local_weights))

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/lion.py

@@ -0,0 +1,85 @@
+from typing import Tuple, Optional, Callable
+
+import torch
+from torch.optim.optimizer import Optimizer
+
+# functions
+
+
+def exists(val):
+    return val is not None
+
+
+# update functions
+
+
+def update_fn(p, grad, exp_avg, lr, wd, beta1, beta2):
+    # stepweight decay
+
+    p.data.mul_(1 - lr * wd)
+
+    # weight update
+
+    update = exp_avg.clone().mul_(beta1).add(grad, alpha=1 - beta1).sign_()
+    p.add_(update, alpha=-lr)
+
+    # decay the momentum running average coefficient
+
+    exp_avg.mul_(beta2).add_(grad, alpha=1 - beta2)
+
+
+# class
+
+
+class Lion(Optimizer):
+    def __init__(
+        self,
+        params,
+        lr: float = 1e-4,
+        betas: Tuple[float, float] = (0.9, 0.99),
+        weight_decay: float = 0.0,
+        eps: float = 0.0,
+        use_triton: bool = False,
+    ):
+        assert lr > 0.0
+        assert all([0.0 <= beta <= 1.0 for beta in betas])
+
+        defaults = dict(lr=lr, betas=betas, weight_decay=weight_decay)
+
+        super().__init__(params, defaults)
+
+        self.update_fn = update_fn
+
+        # if use_triton:
+        #     from lion_pytorch.triton import update_fn as triton_update_fn
+        #     self.update_fn = triton_update_fn
+
+    @torch.no_grad()
+    def step(self, closure: Optional[Callable] = None):
+
+        loss = None
+        if exists(closure):
+            with torch.enable_grad():
+                loss = closure()
+
+        for group in self.param_groups:
+            for p in filter(lambda p: exists(p.grad), group["params"]):
+
+                grad, lr, wd, beta1, beta2, state = (
+                    p.grad,
+                    group["lr"],
+                    group["weight_decay"],
+                    *group["betas"],
+                    self.state[p],
+                )
+
+                # init state - exponential moving average of gradient values
+
+                if len(state) == 0:
+                    state["exp_avg"] = torch.zeros_like(p)
+
+                exp_avg = state["exp_avg"]
+
+                self.update_fn(p, grad, exp_avg, lr, wd, beta1, beta2)
+
+        return loss

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/optimizer.py

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+import os
+import json
+import torch
+import inspect
+import deepspeed
+
+DEVICE_TYPE = os.environ.get("DEVICE_TYPE", "gpu")
+
+
+def get_optimizer(cfg, parameters):
+    if cfg.optimize.optimizer == "adam":
+        optimize_cls = torch.optim.Adam
+    elif cfg.optimize.optimizer == "adamw":
+        optimize_cls = torch.optim.AdamW
+    elif cfg.optimize.optimizer == "sgd":
+        optimize_cls = torch.optim.SGD
+    elif cfg.optimize.optimizer == "adamw1":
+        from .lion import Lion
+
+        optimize_cls = Lion
+    else:
+        raise NotImplementedError("Not Implement {} optimizer !!!".format(cfg.optimize.optimizer))
+
+    if hasattr(cfg.common, "use_deepspeed") and cfg.common.use_deepspeed:
+        return optimize_cls(
+            parameters,
+            lr=cfg.optimize.lr,
+            weight_decay=cfg.optimize.get("weight_decay", 0.01),
+            betas=cfg.optimize.get("betas", (0.9, 0.999)),
+            eps=cfg.optimize.get("eps", 1e-08),
+        )
+        # return deepspeed.ops.adam.DeepSpeedCPUAdam(parameters, cfg.optimize.lr)
+    elif cfg.common.use_zero:
+        print("USING ZeRO")
+        from fairscale import __version__ as __fs_version__
+        from fairscale.optim import OSS
+
+        oss_kwargs = {"broadcast_fp16": cfg.common.use_fp16}
+        if __fs_version__ >= "0.4.6":
+            oss_kwargs["force_broadcast_object"] = True
+        return OSS(
+            parameters,
+            optimize_cls,
+            lr=cfg.optimize.lr,
+            weight_decay=cfg.optimize.get("weight_decay", 0.01),
+            betas=cfg.optimize.get("betas", (0.9, 0.999)),
+            eps=cfg.optimize.get("eps", 1e-08),
+            **oss_kwargs,
+        )
+    else:
+        return optimize_cls(
+            parameters,
+            lr=cfg.optimize.lr,
+            weight_decay=cfg.optimize.get("weight_decay", 0.01),
+            betas=cfg.optimize.get("betas", (0.9, 0.999)),
+            eps=cfg.optimize.get("eps", 1e-08),
+        )
+
+
+def build_optimizer(cfg, model):
+    from mimogpt.models.modules.llama.model import RMSNorm
+    from mimogpt.models.modules.nanoGPT.model import LayerNorm
+
+    norm_types = (
+        torch.nn.BatchNorm2d,
+        torch.nn.BatchNorm1d,
+        torch.nn.BatchNorm3d,
+        torch.nn.SyncBatchNorm,
+        torch.nn.GroupNorm,
+        torch.nn.InstanceNorm1d,
+        torch.nn.InstanceNorm2d,
+        torch.nn.InstanceNorm3d,
+        torch.nn.LayerNorm,
+        torch.nn.LocalResponseNorm,
+        RMSNorm,
+        LayerNorm,
+    )
+
+    nodecay_names = []
+    for name, mod in model.named_modules():
+        if hasattr(mod, "bias"):
+            nodecay_names.append("{}.bias".format(name))
+        if isinstance(mod, norm_types):
+            if hasattr(mod, "weight"):
+                nodecay_names.append("{}.weight".format(name))
+            if hasattr(mod, "scale"):
+                nodecay_names.append("{}.scale".format(name))
+
+    model_params = [(n, p) for n, p in model.named_parameters() if p.requires_grad]
+    decay_params = [p for n, p in model_params if n not in nodecay_names]
+    nodecay_params = [p for n, p in model_params if n in nodecay_names]
+    # decay_params = [p for n, p in model_params if p.dim() >= 2]
+    # nodecay_params = [p for n, p in model_params if p.dim() < 2]
+    grouped_parameters = [
+        {
+            "params": decay_params,
+            "init_lr": cfg.optimize.lr,
+            "lr": cfg.optimize.lr,
+            "weight_decay": cfg.optimize.weight_decay,
+        },
+        {
+            "params": nodecay_params,
+            "init_lr": cfg.optimize.lr,
+            "lr": cfg.optimize.lr,
+            "weight_decay": 0.0,
+        },
+    ]
+    num_all_params = sum(p.numel() for n, p in model_params)
+    num_decay_params = sum(p.numel() for p in decay_params)
+    num_nodecay_params = sum(p.numel() for p in nodecay_params)
+    print(f"num all trained parameter tensors: {len(model_params)}, with {num_all_params:,} parameters")
+    print(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+    print(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+
+    # exclude = lambda n: "bn" in n or "ln" in n or "bias" in n or 'logit_scale' in n or 'LayerNorm' in n
+    # include = lambda n: not exclude(n)
+    #
+    # params_to_learn = [
+    #     "frame_position_embeddings",
+    #     "temporal_fusion",
+    #     "visual_decoder",
+    #     "text_decoder",
+    # ]
+    #
+    # model_params = [(n, p) for n, p in model.named_parameters() if p.requires_grad]
+    # grouped_parameters = [
+    #     # params to learn
+    #     {
+    #         'params': [p for n, p in model_params if any(nd in n for nd in params_to_learn) and exclude(n)],
+    #         "init_lr": cfg.optimize.lr,
+    #         "lr": cfg.optimize.lr,
+    #         "weight_decay": 0.,
+    #     },
+    #     {
+    #         'params': [p for n, p in model_params if any(nd in n for nd in params_to_learn) and include(n)],
+    #         "init_lr": cfg.optimize.lr,
+    #         "lr": cfg.optimize.lr,
+    #         "weight_decay": cfg.optimize.weight_decay,
+    #     },
+    #
+    #     # params to tune
+    #     {
+    #         'params': [p for n, p in model_params if not any(nd in n for nd in params_to_learn) and exclude(n)],
+    #         "init_lr": cfg.optimize.lr * cfg.optimize.tune_lr_scale,
+    #         "lr": cfg.optimize.lr * cfg.optimize.tune_lr_scale,
+    #         "weight_decay": 0.
+    #     },
+    #     {
+    #         'params': [p for n, p in model_params if not any(nd in n for nd in params_to_learn) and include(n)],
+    #         "init_lr": cfg.optimize.lr * cfg.optimize.tune_lr_scale,
+    #         "lr": cfg.optimize.lr * cfg.optimize.tune_lr_scale,
+    #         "weight_decay": cfg.optimize.weight_decay
+    #     }
+    # ]
+
+    optimizer = get_optimizer(cfg, grouped_parameters)
+    return optimizer
+
+
+def setup_deepspeed(args, rank):
+    deepspeed_config = json.load(open(args.deepspeed_config))
+    if "fp16" in deepspeed_config:
+        assert "bf16" not in deepspeed_config
+        if deepspeed_config["fp16"]["enabled"] is False:
+            torch.backends.cuda.matmul.allow_tf32 = args.tf32
+            torch.backends.cudnn.allow_tf32 = args.tf32
+            if args.tf32:
+                print(["rank", rank, "enable tf32 if device support"])
+        else:
+            torch.backends.cuda.matmul.allow_tf32 = False
+            torch.backends.cudnn.allow_tf32 = False
+    elif "bf16" in deepspeed_config:
+        assert "fp16" not in deepspeed_config
+        if deepspeed_config["bf16"]["enabled"] is False:
+            torch.backends.cuda.matmul.allow_tf32 = args.tf32
+            torch.backends.cudnn.allow_tf32 = args.tf32
+            if args.tf32:
+                print(["rank", rank, "enable tf32 if device support"])
+        else:
+            torch.backends.cuda.matmul.allow_tf32 = False
+            torch.backends.cudnn.allow_tf32 = False
+    else:
+        torch.backends.cuda.matmul.allow_tf32 = args.tf32
+        torch.backends.cudnn.allow_tf32 = args.tf32
+        if args.tf32:
+            print(["rank", rank, "enable tf32 if device support"])
+
+
+def clip_gradient(optimizer, grad_clip=5.0, eps=1.0e-15):
+    """
+    Clips gradients computed during backpropagation to avoid explosion of gradients.
+
+    :param optimizer: optimizer with the gradients to be clipped
+    :param grad_clip: clip value
+    """
+    for group in optimizer.param_groups:
+        for param in group["params"]:
+            if param.grad is not None:
+                param.grad.data = torch.where(
+                    torch.isnan(param.grad.data), torch.zeros_like(param.grad.data), param.grad.data
+                )
+                param.grad.data = torch.where(
+                    torch.abs(param.grad.data) < eps, torch.zeros_like(param.grad.data), param.grad.data
+                )
+                param.grad.data.clamp_(-grad_clip, grad_clip)

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/parameter.py

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+
+import os
+import re
+import sys
+import yaml
+import argparse
+import deepspeed
+from easydict import EasyDict
+
+from mimogpt.utils import read_from_yaml
+from .cloud_copy import copy_data_to_cache
+
+__all__ = ["parse_args", "ConfigObject", "parse_args_from_yaml"]
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="DeepLearning framework based on PyTorch")
+
+    # ----------------------distributed parameter-----------------------
+    parser.add_argument("--backend", type=str, default="nccl", help="use for current backend for distributed")
+    parser.add_argument("--init_method", type=str, default="tcp://127.0.0.1:56947", help="init method for distributed")
+    parser.add_argument("--rank", type=int, default=0, help="current rank for distributed")
+    parser.add_argument("--local_rank", type=int, default=0, help="local rank, range 0-7")
+    parser.add_argument("--world_size", type=int, default=1, help="current process number for distributed")
+
+    # -----------------------common parameter-----------------------
+    parser.add_argument("--yml_path", type=str, default="", help="cfg name")
+    parser.add_argument("--list_data_root", type=str, help="root of dataset-list location, usually a folder")
+    parser.add_argument("--img_data_root", type=str, help="root of dataset-img location, usually a folder")
+    parser.add_argument("--eval_data_dir", type=str, help="eval dataset location, usually a folder")
+    parser.add_argument("--eval_imagenet_dir", type=str, help="eval dataset location, usually a folder")
+    parser.add_argument("--pretrained_path", type=str, help="pretrained model path")
+    parser.add_argument("--load_optimizer", type=int, default=0, help="0: don't load; 1:load optimizer")
+    parser.add_argument(
+        "--caption_shuffle_percent",
+        type=float,
+        default=0,
+        help="shuffle the caption with a certain probability, from 0 to 1, don't shuffle if set to 0",
+    )
+    parser.add_argument("--train_data_index", type=int, default=0, help="train_data_index")
+    parser.add_argument(
+        "--local_shuffle_type",
+        type=int,
+        help="0: not use local shuffle "
+        "1: use local shuffle by node "
+        "2: use local shuffle by card "
+        "4: use local shuffle by card in zip format, recommend",
+    )
+    parser.add_argument("--zip_max_split", type=int, default=1024, help="used when local_shuffle_type=4")
+    parser.add_argument(
+        "--visual_memory_format", type=str, default="contiguous_format", help="channels_last or " "contiguous_format"
+    )
+    parser.add_argument("--show_model_arch", type=int, default=0, help="show model arch and params on log")
+    parser.add_argument("--output_path", type=str, default="./exp", help="output path for saving log and pth")
+    parser.add_argument("--log_interval", type=int, default=100, help="steps to show log info")
+    parser.add_argument("--save_per_epochs", type=float, default=0.5, help="epochs to save pth, can be less than 1")
+    parser.add_argument("--max_epochs", type=int, default=3, help="training epochs")
+    parser.add_argument("--warmup_epochs", type=float, default=0.5, help="warmup epochs, can be less than 1")
+    parser.add_argument("--lr_scheduler", type=str, default="cosine", help="lr scheduler")
+    parser.add_argument("--DATALOADER", type=str, default="CLIP_zip_dataloader")
+    parser.add_argument(
+        "--data_list", type=str, help="list name (pattern, code auto change idx to number) to match training data"
+    )
+    parser.add_argument("--mode", type=str, default="trian", help="training sign, do not change ")
+    parser.add_argument("--resume", type=int, default=0, help="resume model")
+    parser.add_argument("--prefetch_factor", type=int, default=2, help="prefetch in dataloader, for faster training")
+    parser.add_argument("--lr", type=float, default=0.0008, help="learning rate")
+    # parser.add_argument('--optimizer', type=str, default='fused_adamw', help='optimizer')
+    parser.add_argument("--weight_decay", type=float, default=0.0, help="weight decay")
+    parser.add_argument("--label_smooth", type=float, default=0.1, help="label smooth")
+    parser.add_argument("--image_size", type=int, default=224, help="reshape the size of image")
+    parser.add_argument("--num_workers", type=int, default=6, help="process number of data loader")
+    parser.add_argument("--tokenizer_type", type=str, default="bert_chinese", help="tokenizer type in data loader")
+
+    # ----------------------debug related----------------------
+    parser.add_argument("--fix_inputs", type=int, default=0, help="ignore dataloader when training, for profiling")
+    parser.add_argument("--profile", type=int, default=0, help="pytorch profile")
+    parser.add_argument("--profile_skip_first", type=int, default=5, help="pytorch profile")
+    parser.add_argument("--profile_wait", type=int, default=5, help="pytorch profile")
+    parser.add_argument("--profile_warmup", type=int, default=2, help="pytorch profile")
+    parser.add_argument("--profile_active", type=int, default=3, help="pytorch profile")
+    parser.add_argument("--profile_repeat", type=int, default=5, help="pytorch profile")
+    parser.add_argument("--profile_step", type=int, default=150, help="npu profile")
+    parser.add_argument("--debug", action="store_true")
+
+    # ----------------------optmize----------------------
+    parser.add_argument("--base_lr", type=float, help="base learning rate")
+    parser.add_argument("--use_fp16", type=int, help="flag for triggering AMP")
+    parser.add_argument("--CRITERION", type=str, default="clip_loss_gather_parallel", help="loss function")
+    parser.add_argument("--beta1", type=float, default=0.9, help="adam beta1")
+    parser.add_argument("--beta2", type=float, default=0.96, help="adam beta2")
+
+    # ----------------------model----------------------
+    parser.add_argument("--embed_dim", type=int, default=512, help="dimension of output")
+    parser.add_argument("--BACKBONE", type=str, help="model backbone")
+    parser.add_argument("--context_length", type=int, default=80, help="length of token sent to model")
+
+    # ----------------------eval----------------------
+    parser.add_argument("--eval_first", type=int, default=0, help="whether eval at 1st step")
+    parser.add_argument("--eval_yml_path", type=str, default="", help="cfg name for eval")
+    # hwzhquery eval
+    parser.add_argument("--do_multilabeling", type=int, default=0, help="validation related @xkx")
+    parser.add_argument(
+        "--min_recall", type=float, default=0.8, help="hwzhquery eval for thr reliable, eg. recall=80%, test acc"
+    )
+    parser.add_argument("--exclude", type=list, default=[], help="hwzhquery exclude some part when eval")
+    parser.add_argument("--test_plan", type=list, default=[], help="settings for hwzhquery")
+    parser.add_argument("--eval_hierarchy", type=str, help="path to hwzhquery imgs")
+    parser.add_argument("--labels_root", type=str, help="path to hwzhquery labels")
+    parser.add_argument("--map_en_zh", type=str, help="pkl of hwzhquery")
+    # hwzhquery eval (need to be clarify)
+    parser.add_argument("--windows_path", type=str)
+    parser.add_argument("--thres", type=int, default=0, help="have correlation to thr reliable")
+    # others eval
+    parser.add_argument("--eval_coco_dir", type=str, help="path to coco dir")
+    parser.add_argument("--eval_coco_cn_dir", type=str, help="path to coco-cn dir")
+    parser.add_argument("--eval_muge_dir", type=str, help="path to muge dir")
+    parser.add_argument("--eval_coco_en_dir", type=str, help="path to coco-en dir")
+    parser.add_argument("--eval_imagenet_en_dir", type=str, help="path to imagenet-en dir")
+
+    # ---------------------ema----------------------------------
+    parser.add_argument("--ema", type=int, default=0, help="whether use ema")
+    parser.add_argument("--ema_decay", type=float, default=0.999, help="ema_decay")
+    parser.add_argument(
+        "--ema_multi_tensor_apply_chunk_size", type=int, default=10000, help="ema_multi_tensor_apply_chunk_size"
+    )
+
+    # train on cloud
+    parser.add_argument("--random_seed", type=int, help="random_seed")
+    parser.add_argument("--train_url", type=str, help="train_url")
+    parser.add_argument("--cloud_list_data_root", type=str, help="root path to list on OBS, start with s3:")
+    parser.add_argument("--cloud_img_data_root", type=str, help="root path to img or zip on OBS, start with s3:")
+    parser.add_argument("--user_id", type=str, default="", help="user account")
+    parser.add_argument("--tf32", action="store_true")
+    parser = deepspeed.add_config_arguments(parser)
+    args, unknown = parser.parse_known_args()
+    # args = merge_args(args, args.yml_path)
+
+    try:
+        import moxing as mox
+
+        args.list_data_root = args.cloud_list_data_root
+        args.img_data_root = args.cloud_img_data_root
+    except:
+        pass
+    return EasyDict(vars(args))
+
+
+class ConfigObject:
+    def __init__(self, entries):
+        for a, b in entries.items():
+            if isinstance(b, (list, tuple)):
+                setattr(self, a, [ConfigObject(x) if isinstance(x, dict) else x for x in b])
+            else:
+                setattr(self, a, ConfigObject(b) if isinstance(b, dict) else b)
+
+    def __str__(self):
+        return str(self.__dict__)
+
+    def __repr__(self):
+        return self.__str__()
+
+    def merge_from_args(self, args):
+        for k, v in args.__dict__.items():
+            if k in self.__dict__:
+                # yml file has a higher priority than parameters
+                continue
+            if v is not None:
+                self.__dict__[k] = v
+
+
+def parse_args_from_yaml(yml_path):
+    config = read_from_yaml(yml_path)
+    config_obj = EasyDict(config)
+    return config_obj
+
+
+def parse_replace_roma(fp, copy_to_cache=False, rank=0, world_size=1, args=None):
+    y = read_from_yaml(fp)
+    for y_key in y.keys():
+        y_val = y[y_key]
+        if type(y_val) is str and y_val.startswith("s3://"):
+            # copy to /cache and replace to /cache
+            y_val_cache = y_val.replace("s3://", "/cache/")
+            if copy_to_cache:
+                # rank and world_size means node rank and node world_size
+                # ugly for rec with idx
+                if y_val_cache.endswith(".rec"):
+                    y_val_rec_idx = y_val.replace(".rec", ".idx")
+                    y_val_cache_rec_idx = y_val_cache.replace(".rec", ".idx")
+                    print("copy {} to {}".format(y_val_rec_idx, y_val_cache_rec_idx))
+                    copy_data_to_cache(y_val_rec_idx, y_val_cache_rec_idx, rank=rank, world_size=world_size, args=args)
+                copy_data_to_cache(y_val, y_val_cache, rank=rank, world_size=world_size, args=args)
+            y[y_key] = y_val_cache
+    return y
+
+
+def merge_args(args, args_yml_fn):
+    if os.path.exists(args_yml_fn):
+        args_dict = args.__dict__
+        args_yml = parse_replace_roma(args_yml_fn, copy_to_cache=False)
+
+        # make sure key in yml is subset of parameter.py
+        for key in args_yml:
+            assert key in args_dict, "{} in yml not in args_dict, please set into common/parameter.py".format(key)
+
+        args_dict_merge = dict(args_dict, **args_yml)
+        args = ConfigObject(args_dict_merge)
+    elif len(args_yml_fn) != 0:
+        print("yml file {} is not existed".format(args_yml_fn))
+        exit(0)
+
+    sys_args = sys.argv[1:]
+    for arg in sys_args:
+        if re.match("^--(.*)=(.*)$", arg):
+            arg = arg.replace("--", "")
+            key, val = arg.split("=")
+            default_value = getattr(args, key, "key_not_exist")
+            if default_value == "key_not_exist":
+                # TODO, string type
+                setattr(args, key, val)
+            else:
+                new_value = type(default_value)(val)
+                if default_value != new_value:
+                    print("set {} from {} to {}".format(key, default_value, new_value))
+                    setattr(args, key, new_value)
+        else:
+            print("unmatched, arg: {}".format(arg))
+
+    return args

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/profile.py

@@ -0,0 +1,71 @@
+import pprint
+import os
+import torch.distributed as dist
+from torch.profiler import profile, schedule, ProfilerActivity, tensorboard_trace_handler
+
+from mimogpt.engine.utils.train_loop import HookBase
+from mimogpt.utils import hf_logger
+
+
+class Nothing(object):
+    def __init__(self, *args, **kwargs):
+        return
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return
+
+    def start(self):
+        return
+
+    def stop(self):
+        return
+
+    def step(self):
+        return
+
+    def export_chrome_trace(self, path):
+        return
+
+
+class TorchProfileHook(HookBase):
+    def __init__(self, cfg):
+        is_root = dist.get_rank() == 0
+        if is_root:
+            skip_first = cfg.get("profile_skip_first", 0)
+            wait = cfg.get("profile_wait", 1)
+            warmup = cfg.get("profile_warmup", 1)
+            active = cfg.get("profile_active", 1)
+            repeat = cfg.get("profile_repeat", 0)
+
+            profile_tb_logger = os.path.join(cfg.common.log_path, "gpu_profile_results")
+            os.makedirs(profile_tb_logger, exist_ok=True)
+
+            my_schedule = schedule(wait=wait, warmup=warmup, active=active, repeat=repeat, skip_first=skip_first)
+            tb_logger_trace_handler = tensorboard_trace_handler(profile_tb_logger)
+            self.profiler = profile(
+                schedule=my_schedule,
+                activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
+                record_shapes=True,
+                profile_memory=True,
+                with_stack=False,
+                with_flops=False,
+                with_modules=False,
+                on_trace_ready=tb_logger_trace_handler,
+            )
+            hf_logger.info("Profile enabled in rank 0")
+        else:
+            self.profiler = Nothing()
+
+    def before_train(self):
+        self.profiler.start()
+        hf_logger.info(f"Profiller start!!!!!")
+
+    def after_step(self):
+        self.profiler.step()
+
+    def after_train(self):
+        self.profiler.stop()
+        hf_logger.info(f"Profiller stop!!!!!")

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/profile_npu.py

@@ -0,0 +1,57 @@
+import os
+import torch.distributed as dist
+
+DEVICE_TYPE = os.environ.get("DEVICE_TYPE", "gpu")
+if DEVICE_TYPE == "ascend":
+    import torch_npu
+
+from torch.profiler import ProfilerActivity, tensorboard_trace_handler
+from mimogpt.engine.utils.profiler_npu.profile_utils import (
+    get_profile_fn,
+    trace_handler,
+    Nothing,
+)
+from mimogpt.engine.utils.train_loop import HookBase
+from mimogpt.utils import hf_logger
+
+
+class NPUTorchProfileHook(HookBase):
+    def __init__(self, cfg):
+        train_schedule, profile_fn = get_profile_fn(cfg)
+        experimental_config = torch_npu.profiler._ExperimentalConfig(
+            aic_metrics=torch_npu.profiler.AiCMetrics.PipeUtilization,
+            profiler_level=torch_npu.profiler.ProfilerLevel.Level1,  # 如需修改profiling级别，可在此调整参数Leval0、Leval1、Leval2
+            l2_cache=False,  # 此参数仅在Leval2时设置成True
+        )
+        profile_tb_logger = os.path.join(cfg.common.log_path, "ascend_profile_results")
+        os.makedirs(profile_tb_logger, exist_ok=True)
+        tb_logger_trace_handler = tensorboard_trace_handler(profile_tb_logger)
+
+        if cfg.profile and DEVICE_TYPE == "ascend" and dist.get_rank() == 0:
+            self.profiler = profile_fn(
+                activities=[
+                    ProfilerActivity.CPU,
+                    ProfilerActivity.CUDA,
+                ],
+                schedule=train_schedule,
+                record_shapes=True,
+                profile_memory=True,
+                with_stack=False,
+                with_flops=False,
+                with_modules=False,
+                experimental_config=experimental_config,  # 专家参数默认级别Leval0，可根据需要设置不同Leval
+                on_trace_ready=tb_logger_trace_handler,
+            )
+        else:
+            self.profiler = Nothing()
+
+    def before_train(self):
+        self.profiler.__enter__()
+        hf_logger.info(f"NPU Profiller start!!!!!")
+
+    def after_step(self):
+        self.profiler.step()
+
+    def after_train(self):
+        self.profiler.__exit__(None, None, None)
+        hf_logger.info(f"NPU Profiller stop!!!!!")

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/profiler_npu/profile_utils.py

@@ -0,0 +1,85 @@
+import os
+import torch
+import torch.distributed as dist
+from torch.profiler import profile, schedule
+from .timeline_analysis import parse_timeline
+
+
+class Nothing(object):
+    def __init__(self, *args, **kwargs):
+        return
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return
+
+    def start(self):
+        return
+
+    def stop(self):
+        return
+
+    def step(self):
+        return
+
+    def export_chrome_trace(self, path):
+        return
+
+
+def trace_handler(prof, train_url, name="train"):
+    if not os.path.exists("pytorch_profile"):
+        os.makedirs("pytorch_profile")
+
+    src = os.path.join("pytorch_profile", "timeline_{}_step_{}.json".format(name, prof.step_num))
+    prof.export_chrome_trace(src)
+    analysis_ret = parse_timeline(src)
+
+    try:
+        import moxing as mox
+
+        if train_url is not None:
+            dst = os.path.join(train_url, src)
+            dst_dirname = os.path.dirname(dst)
+            if not mox.file.exists(dst_dirname):
+                mox.file.make_dirs(dst_dirname)
+            mox.file.copy(src, dst)
+            print("save profile timeline from {} to {}".format(src, dst))
+
+            for name in analysis_ret:
+                dst = os.path.join(train_url, name)
+                mox.file.copy(name, dst)
+                print("save profile files from {} to {}".format(name, dst))
+        else:
+            print("skip backup profile timeline since train_url=None")
+    except:
+        pass
+
+
+def get_profile_fn(args):
+    if dist.get_rank() == 0 and args.profile:
+        my_schedule = schedule(
+            skip_first=args.profile_skip_first,
+            wait=args.profile_wait,
+            warmup=args.profile_warmup,
+            active=args.profile_active,
+            repeat=args.profile_repeat,
+        )
+        profile_fn = profile
+    else:
+        my_schedule = None
+        profile_fn = Nothing()
+    return my_schedule, profile_fn
+
+
+def print_memory_status(msg, empty_cache=True, is_print=True):
+    if empty_cache:
+        torch.cuda.empty_cache()
+
+    mem_res = torch.cuda.memory_reserved() / (1024**3)
+    mem_alloc = torch.cuda.memory_allocated() / (1024**3)
+    if is_print:
+        print("{}, memory_reserved={:.2f}G, memory_allocated={:.2f}G".format(msg, mem_res, mem_alloc))
+
+    return mem_res, mem_alloc

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/profiler_npu/timeline_analysis.py

@@ -0,0 +1,129 @@
+import re
+import os
+import json
+import pandas as pd
+import yaml
+import argparse
+
+
+def parse_yaml(fp):
+    with open(fp, "r") as fd:
+        cont = fd.read()
+        try:
+            y = yaml.load(cont, Loader=yaml.FullLoader)
+        except:
+            y = yaml.load(cont)
+        return y
+
+
+def parse_timeline(filepath):
+    # 算子名->算子类型映射
+    cate2name = parse_yaml(os.path.join(os.path.dirname(__file__), "mapping.yml"))
+    name2cate = {}
+    for cate_name, op_names in cate2name.items():
+        for op_name in op_names:
+            name2cate[op_name] = cate_name
+
+    filedir, filename = os.path.split(filepath)
+    print("start analysis {}".format(filepath))
+    with open(filepath) as fn:
+        ops = json.load(fn)
+
+    ops = ops["traceEvents"]
+    print("find {} events".format(len(ops)))
+
+    cat_ = [x["cat"] if "cat" in x.keys() else None for x in ops]
+    cat_key = list(set(cat_))
+
+    out_filenames = []
+
+    for key in cat_key:
+        if key is None:
+            cat_this = [x for x in ops if "cat" not in x.keys()]
+        else:
+            cat_this = [x for x in ops if "cat" in x.keys() and x["cat"] == key]
+
+        print("")
+        print("find cat={}, cnt={}".format(key, len(cat_this)))
+
+        if key in ["Kernel", "kernel"]:
+            stream7 = [x for x in cat_this if x["args"]["stream"] == 7]
+            not_stream7 = [x for x in cat_this if x["args"]["stream"] != 7]  # nccl, pass
+            tot_time = sum([x["dur"] for x in stream7]) / 1000
+            print("stream7: total_time={}ms".format(tot_time))
+
+            ops_groupby_op_name = {}
+            ops_groupby_cate = {}
+
+            for x in stream7:
+                if x["name"] not in ops_groupby_op_name.keys():
+                    ops_groupby_op_name[x["name"]] = []  # name, dur#
+                ops_groupby_op_name[x["name"]].append(x["dur"])
+
+                op_name_this = x["name"][5:] if x["name"].startswith("void ") else x["name"]
+                real_cate_name = []
+                for name_pattern, cate_name in name2cate.items():
+                    ret = re.match(name_pattern, op_name_this)
+                    if ret is not None:
+                        real_cate_name.append(cate_name)
+
+                if len(real_cate_name) > 1:
+                    print("ERROR: op_name: {}, has many pattern: {}".format(x["name"], real_cate_name))
+                    exit()
+                elif len(real_cate_name) == 1:
+                    real_cate_name = real_cate_name[0]
+                else:
+                    real_cate_name = x["name"]
+
+                if real_cate_name not in ops_groupby_cate.keys():
+                    ops_groupby_cate[real_cate_name] = []  # name, dur#
+                ops_groupby_cate[real_cate_name].append(x["dur"])
+
+            for save_tag, init_data in [["init", ops_groupby_op_name], ["cate", ops_groupby_cate]]:
+                ops_list = []
+                for k, v in init_data.items():
+                    min_ = min(v)
+                    max_ = max(v)
+                    tot_ = sum(v)
+                    mean_ = tot_ / len(v)
+                    cnt_ = len(v)
+                    percent_ = tot_ / 1000.0 / tot_time
+                    ops_list.append([k, cnt_, tot_ / 1000, mean_ / 1000, min_ / 1000, max_ / 1000, percent_])
+
+                ops_list.sort(key=lambda x: x[-1], reverse=True)
+                df = pd.DataFrame(ops_list, columns=["op_name", "cnt", "sum_t", "avg_t", "min_t", "max_t", "percent"])
+
+                save_name = "op_statistic_" + save_tag + "_" + filename.replace(".json", ".xlsx")
+                save_name = os.path.join(filedir, save_name)
+                out_filenames.append(save_name)
+                df.to_excel(save_name, index=False)
+
+            summary = [[x["name"], x["dur"] / 1000.0] for x in stream7]
+            df = pd.DataFrame(
+                summary,
+                columns=[
+                    "op_name",
+                    "dur",
+                ],
+            )
+
+            save_name = "op_summary_" + filename.replace(".json", ".xlsx")
+            save_name = os.path.join(filedir, save_name)
+            out_filenames.append(save_name)
+            df.to_excel(save_name, index=False)
+
+    return out_filenames
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="gpu timeline parser")
+    parser.add_argument(
+        "--filepath",
+        type=str,
+        default=None,
+        help="filepath",
+    )
+    args, _ = parser.parse_known_args()
+
+    if os.path.exists(args.filepath):
+        parse_timeline(args.filepath)

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/record.py

@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+
+import os
+import time
+import torch
+import psutil
+import datetime
+import torch.distributed as dist
+
+try:
+    from torch.utils.tensorboard import SummaryWriter
+except:
+    print("# Ascend didn't support SummaryWriter, skipped")
+from .train_loop import HookBase
+from mimogpt.utils import hf_logger
+
+
+def get_cpu_mem_status():
+    mem = psutil.virtual_memory()
+    tot_mem = float(mem.total) / (1024**3)
+    used_mem = float(mem.used) / (1024**3)
+    return "[{:.1f}G/{:.1f}G]".format(used_mem, tot_mem)
+
+
+class TimerAndLogger(HookBase):
+    def __init__(self, cfg, metrics=None):
+        self.cfg = cfg
+        self.metrics = metrics
+        self.is_root = dist.get_rank() == 0
+
+    def before_train(self):
+        self._train_time = 0
+        self._train_time_log_interval = 0
+        self._train_time_epoch = 0
+
+    def after_train(self):
+        if self.is_root:
+            hf_logger.info(
+                "Finish training, total time: {}".format(str(datetime.timedelta(seconds=int(self._train_time))))
+            )
+
+    def before_step(self):
+        self._start_time = time.perf_counter()
+
+    def after_step(self):
+        if self.is_root:
+            step_time = time.perf_counter() - self._start_time
+            self._train_time += step_time
+            self._train_time_log_interval += step_time
+            self._train_time_epoch += step_time
+            current_epoch = self.trainer.iter // self.cfg.dataloader_len
+            current_iter = self.trainer.iter % self.cfg.dataloader_len
+            if (current_iter + 1) % self.cfg.common.log_interval == 0:
+                if self.cfg.dataloader.train.hybrid:
+                    frame_num = (
+                        (self.cfg.dataloader.train.batch_size.image + self.cfg.dataloader.train.batch_size.video * 8)
+                        * self.cfg.world_size
+                        * self.cfg.common.log_interval
+                        // 2
+                    )
+                else:
+                    frame_num = (
+                        (self.cfg.dataloader.train.batch_size.video * 8)
+                        * self.cfg.world_size
+                        * self.cfg.common.log_interval
+                    )
+                FPS = int(frame_num / self._train_time_log_interval)
+                metric_value = self.metrics(self.trainer._outs)
+                current_ime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+                hf_logger.info(
+                    "{} training: [{}][{}/{}] iterations, loss: {:.8f}, {}: {:.8f}, lr: {:.8f}, lr_tune: {:.8f}, speed: {:.3f}s/it, scaler: {}, {} FPS".format(
+                        current_ime,
+                        current_epoch,
+                        current_iter + 1,
+                        self.cfg.dataloader_len,
+                        self.trainer._loss.item(),
+                        self.metrics.name,
+                        round(metric_value.item() * 100, 2),
+                        self.trainer.optimizer.param_groups[0]["lr"],
+                        self.trainer.optimizer.param_groups[-1]["lr"],
+                        self._train_time_log_interval / self.cfg.common.log_interval,
+                        self.trainer._scaler.get_scale(),
+                        FPS,
+                    )
+                )
+                self._train_time_log_interval = 0
+            if (current_iter + 1) == self.cfg.dataloader_len:
+                frame_num = (
+                    (self.cfg.dataloader.train.batch_size.image + self.cfg.dataloader.train.batch_size.video * 8)
+                    * self.cfg.world_size
+                    * self.cfg.common.log_interval
+                    // 2
+                )
+                FPS = int(frame_num / self._train_time_epoch)
+                mem_reserved = "{:.1f}G".format(torch.cuda.memory_reserved() / (1024**3))
+                hf_logger.info(
+                    "training: epoch: {}, mean speed: {:.3f}s/it, mean FPS: {}, gpu_mem: {}, cpu_mem: {}".format(
+                        current_epoch,
+                        self._train_time_epoch / self.cfg.dataloader_len,
+                        FPS,
+                        mem_reserved,
+                        get_cpu_mem_status(),
+                    )
+                )
+                self._train_time_epoch = 0
+
+
+class UniversalMeterLogger(HookBase):
+    def __init__(self, cfg):
+        self.cfg = cfg
+
+    def before_train(self):
+        self._train_time = 0
+
+    def after_train(self):
+        hf_logger.info("Finish training, total time: {}".format(str(datetime.timedelta(seconds=int(self._train_time)))))
+
+    def before_step(self):
+        self._start_time = time.perf_counter()
+
+    def after_step(self):
+        step_time = time.perf_counter() - self._start_time
+        self._train_time += step_time
+        self.trainer.meters.batch_time.update(step_time)
+        current_iter = self.trainer.iter % self.cfg.dataloader_len
+        current_epoch = self.trainer.iter // self.cfg.dataloader_len
+        if self.cfg.common.task == "mimo_vqgan":
+            lr_d = self.trainer.optimizer_d.param_groups[0]["lr"]
+            lr_g = self.trainer.optimizer_g.param_groups[0]["lr"]
+        if (current_iter + 1) % self.cfg.common.log_interval == 0:
+            data_cnt = (
+                self.cfg.dataloader.train.batch_size
+                * self.trainer.dist.world_size
+                * self.trainer.gradient_accumulation_steps
+            )
+            fps = data_cnt / step_time
+            meters = self.trainer.meters
+            totals = self.trainer.totals
+            total_iters = totals.total_iters
+            remain_secs = (total_iters - self.trainer.iter) * meters.batch_time.avg
+            remain_time = datetime.timedelta(seconds=round(remain_secs))
+            finish_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time() + remain_secs))
+            time_str = f"\tRemainingTime {remain_time} ({finish_time})"
+            msg = f"Iter: [{current_iter+1}/{totals.iter_per_epoch}]"
+            msg += f"\tEpoch: [{current_epoch}/{totals.epochs} ({totals.total_iters})]"
+            for k in meters.keys():
+                msg += f"\t{k} {meters[k].get_val_str()} ({meters[k].get_avg_str()})"
+            if self.cfg.common.task == "mimo_vqgan":
+                msg += f"\tlr_d: {lr_d} \tlr_g: {lr_g}"
+            msg += time_str
+            msg += f"\tFPS {fps: .3f}"
+            hf_logger.info(msg)
+
+
+class VideoMeterLogger(UniversalMeterLogger):
+    def after_step(self):
+        step_time = time.perf_counter() - self._start_time
+        self._train_time += step_time
+        self.trainer.meters.batch_time.update(step_time)
+        current_iter = self.trainer.iter % self.cfg.dataloader_len
+        current_epoch = self.trainer.iter // self.cfg.dataloader_len
+        if (current_iter + 1) % self.cfg.common.log_interval == 0:
+            data_cnt = (
+                self.cfg.dataloader.train.batch_size
+                * self.cfg.dataloader.train.video_length
+                * self.trainer.dist.world_size
+                * self.trainer.gradient_accumulation_steps
+            )
+            fps = data_cnt / step_time
+            meters = self.trainer.meters
+            totals = self.trainer.totals
+            total_iters = totals.total_iters
+            remain_secs = (total_iters - self.trainer.iter) * meters.batch_time.avg
+            remain_time = datetime.timedelta(seconds=round(remain_secs))
+            finish_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time() + remain_secs))
+            time_str = f"\tRemainingTime {remain_time} ({finish_time})"
+            msg = f"Iter: [{current_iter+1}/{totals.iter_per_epoch}]"
+            msg += f"\tEpoch: [{current_epoch}/{totals.epochs} ({totals.total_iters})]"
+            for k in meters.keys():
+                msg += f"\t{k} {meters[k].get_val_str()} ({meters[k].get_avg_str()})"
+            msg += time_str
+            msg += f"\tFPS {fps: .3f}"
+            hf_logger.info(msg)
+
+
+class SimpleLogger(HookBase):
+    def __init__(self, cfg):
+        self.cfg = cfg
+        self.last_fps = 0
+        self.is_root = dist.get_rank() == 0
+
+    def before_train(self):
+        self._train_time = 0
+        self._train_time_log_interval = 0
+        self._train_time_epoch = 0
+        self._avg_loss = {}
+        self._avg_loss_for_last_metric = {}
+
+    def after_train(self):
+        if self.is_root:
+            hf_logger.info(
+                "Finish training, total time: {}".format(str(datetime.timedelta(seconds=int(self._train_time))))
+            )
+            CI_Metric = f"[Last metrics]: "
+            for k, v in self._avg_loss_for_last_metric.items():
+                CI_Metric += f"{k}: {v[1] / v[0]:.3f}, "
+            CI_Metric += f"FPS: {self.last_fps:.6f}"
+            hf_logger.info(CI_Metric)
+
+    def before_step(self):
+        self._start_time = time.perf_counter()
+
+    def after_step(self):
+        if self.is_root:
+            step_time = time.perf_counter() - self._start_time
+            self._train_time += step_time
+            self._train_time_log_interval += step_time
+            self._train_time_epoch += step_time
+            current_epoch = self.trainer.iter // self.cfg.dataloader_len
+            current_iter = self.trainer.iter % self.cfg.dataloader_len
+
+            for k, v in self.trainer._outs.items():
+                if isinstance(v, torch.Tensor):
+                    v = v.mean().item()
+                if k not in self._avg_loss.keys():
+                    self._avg_loss[k] = [0, 0.0]
+                self._avg_loss[k][0] += 1
+                self._avg_loss[k][1] += v
+
+            if (current_iter + 1) % self.cfg.common.log_interval == 0:
+                data_cnt = (
+                    self.cfg.dataloader.train.batch_size * self.trainer.dist.world_size * self.cfg.common.log_interval
+                )
+                fps = data_cnt / self._train_time_log_interval
+                self.last_fps = fps
+                logging_info = "training: [{}][{}/{}] iterations, loss: {:.3f}, ".format(
+                    current_epoch,
+                    current_iter + 1,
+                    self.cfg.dataloader_len,
+                    self.trainer._loss.item(),
+                )
+
+                for k, v in self._avg_loss.items():
+                    cur_loss = self.trainer._outs[k]
+                    if isinstance(cur_loss, torch.Tensor):
+                        cur_loss = cur_loss.mean().item()
+                    logging_info += f"{k}: {cur_loss:.3f}({v[1] / v[0]:.3f}), "
+
+                logging_info += "lr: {:.8f}, speed: {:.3f}s/it, FPS: {:.3f}, scaler: {}".format(
+                    self.trainer.optimizer.param_groups[0]["lr"],
+                    self._train_time_log_interval / self.cfg.common.log_interval,
+                    fps,
+                    self.trainer._scaler.get_scale(),
+                )
+
+                hf_logger.info(logging_info)
+                self._train_time_log_interval = 0
+                self._avg_loss_for_last_metric = self._avg_loss
+                self._avg_loss = {}
+
+            if (current_iter + 1) == self.cfg.dataloader_len:
+                mem_reserved = "{:.1f}G".format(torch.cuda.memory_reserved() / (1024**3))
+                hf_logger.info(
+                    "training: epoch: {}, mean speed: {:.3f}s/it, gpu_mem: {}, cpu_mem: {}".format(
+                        current_epoch,
+                        self._train_time_epoch / self.cfg.dataloader_len,
+                        mem_reserved,
+                        get_cpu_mem_status(),
+                    )
+                )
+                self._train_time_epoch = 0
+
+
+class TensorboardLogger(HookBase):
+    def __init__(self, cfg):
+        self.cfg = cfg
+        self.is_root = dist.get_rank() == 0
+        self.log_root_dir = cfg.common.log_path
+        if self.is_root:
+            event_path = os.path.join(self.log_root_dir, "events")
+            os.makedirs(event_path, exist_ok=True)
+            self.tb_logger = SummaryWriter(event_path, max_queue=1, flush_secs=10)
+
+    def after_step(self):
+        if self.is_root:
+            current_iter = self.trainer.iter
+            if (current_iter + 1) % self.cfg.common.log_interval == 0:
+                name_value_dict = {}
+                meters = self.trainer.meters
+                for k in meters.keys():
+                    self.tb_logger.add_scalar(k, meters[k].avg, current_iter)
+
+    def after_train(self):
+        if self.is_root:
+            self.tb_logger.close()
+
+
+class TensorboardPriorLogger(TensorboardLogger):
+    def __init__(self, cfg):
+        super().__init__(cfg)
+        self.eval_interval = cfg.evaluation.validation.eval_interval
+        self.test_interval = getattr(cfg.evaluation.test, "test_interval", -1)
+
+    def after_step(self):
+        super().after_step()
+        if self.is_root:
+            current_iter = self.trainer.iter
+            if current_iter % self.eval_interval == int(self.eval_interval - 1):
+                name_value_dict = {}
+                meters = self.trainer.eval_board
+                for k in meters.keys():
+                    self.tb_logger.add_scalar(k, meters[k], current_iter)
+            if current_iter % self.test_interval == int(self.test_interval - 1):
+                name_value_dict = {}
+                meters = self.trainer.test_board
+                for k in meters.keys():
+                    self.tb_logger.add_scalar(k, meters[k], current_iter)
+
+    def after_train(self):
+        if self.is_root:
+            self.tb_logger.close()

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/scheduler.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+import math
+from .train_loop import HookBase
+
+
+class LRScheduler(HookBase):
+    def __init__(self, optimizer, init_lr, warmup_iter=0, scheduler=None):
+        self._optimizer = optimizer
+
+        self.init_lr = init_lr
+        self.scheduler = scheduler
+        self.warmup_iter = warmup_iter
+
+    def before_step(self):
+        for param_group in self._optimizer.param_groups:
+            param_group["lr"] = self.calc_learning_rate(self.trainer.iter, param_group["init_lr"])
+
+    def calc_learning_rate(self, iter, init_lr, minimum_lr=1.0e-7):
+        if iter < self.warmup_iter:
+            new_lr = (iter + 1) / self.warmup_iter * (init_lr - minimum_lr) + minimum_lr
+        else:
+            if self.scheduler == "linear":
+                new_lr = minimum_lr + (init_lr - minimum_lr) * (
+                    (self.trainer.max_iter - iter) / (self.trainer.max_iter - self.warmup_iter)
+                )
+            elif self.scheduler == "cosine":
+                new_lr = minimum_lr + 0.5 * (init_lr - minimum_lr) * (
+                    1 + math.cos(math.pi * (iter - self.warmup_iter) / (self.trainer.max_iter - self.warmup_iter))
+                )
+            else:
+                new_lr = init_lr
+        return new_lr

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/selftok/lr_scheduler.py

@@ -0,0 +1,53 @@
+import math
+
+class MyLRScheduler:
+    def __init__(
+        self,
+        optimizer,
+        init_step1 = 5000,
+        init_step2 = 50000,
+        max_step = 100000,
+        init_lr = 1e-3,
+        min_lr1 = 1e-4,
+        min_lr2 = 1e-5,
+    ):
+        self.optimizer = optimizer
+        self.init_step1 = init_step1
+        self.init_step2 = init_step2
+        self.max_step = max_step
+        self.init_lr = init_lr
+        self.min_lr1 = min_lr1
+        self.min_lr2 = min_lr2
+        self.idx = -1
+        for idx, param_group in enumerate(optimizer.param_groups):
+            if param_group['name'] == 'encoder':
+                self.idx = idx
+
+    def step(self, cur_step):
+        if cur_step < self.init_step1 or self.idx < 0:
+            return
+        elif cur_step < self.init_step2:
+            step_lr_schedule(self.optimizer, self.init_step2-cur_step, self.init_step2-self.init_step1, self.init_lr, self.min_lr1, self.idx)
+        else:
+            cosine_lr_schedule(self.optimizer, self.init_step2, cur_step, self.max_step, self.min_lr1, self.min_lr2, self.idx)
+        
+            
+def cosine_lr_schedule(optimizer, init_step, cur_step, max_step, init_lr, min_lr, idx):
+    cur_step -= init_step
+    max_step -= init_step
+    lr = (init_lr - min_lr) * 0.5 * (
+        1.0 + math.cos(math.pi * cur_step / max_step)
+    ) + min_lr
+    param_group = optimizer.param_groups[idx]
+    param_group["lr"] = lr
+
+def step_lr_schedule(optimizer, step, max_step, init_lr, min_lr, idx):
+    lr = min_lr + (init_lr - min_lr) * max(1, step) / max_step
+    param_group = optimizer.param_groups[idx]    
+    param_group["lr"] = lr
+
+def step_lr_schedule2(optimizer, init_step, cur_step, init_lr, min_lr, decay_rate=0.999, idx=0):
+    step = cur_step - init_step
+    lr = max(min_lr, init_lr * (decay_rate**step))
+    param_group = optimizer.param_groups[idx]    
+    param_group["lr"] = lr

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/selftok/threshold_scheduler.py

@@ -0,0 +1,64 @@
+from mimogpt.models.selftok.models_ours import Encoder
+
+class ThresholdScheduler:
+    def __init__(
+        self,
+        init_threshold,
+        final_threshold,
+        constant_step=4000,
+        end_step=20000,
+    ):
+        assert end_step > constant_step
+        self.init_threshold = init_threshold
+        self.final_threshold = final_threshold
+        self.constant_step = constant_step
+        self.end_step = end_step
+        self.fn = max if final_threshold <= init_threshold else min
+        
+    def step(self, encoder, cur_iter):
+        if cur_iter <= self.constant_step:
+            return
+        rate = (self.init_threshold-self.final_threshold) / (self.end_step-self.constant_step)
+        cur_threshold = self.init_threshold - rate * (cur_iter-self.constant_step)
+        cur_threshold = self.fn(self.final_threshold, cur_threshold)
+        encoder.quantizer._codebook.threshold_ema_dead_code = cur_threshold
+        
+
+
+class ObjectiveScheduler:
+    def __init__(self, start_iter, end_iter):
+        self.start = start_iter
+        self.end = end_iter
+
+    def step(self, tokenizer, cur_iter):
+        if cur_iter <= self.start:
+            return
+        if cur_iter >= self.end:
+            return
+        delta = cur_iter - self.start
+        rate = 1. / (self.end - self.start)
+        tokenizer.recon_ratio = 1. - rate * delta
+        return
+    
+
+class LowResDroprateScheduler:
+    def __init__(self, start_iter=0, end_iter=0, start_rate=0.0, end_rate=0.0):
+        self.start_iter = start_iter
+        self.end_iter = end_iter
+        self.start_rate = start_rate
+        self.end_rate = end_rate
+        if self.end_iter != self.start_iter:
+            self.r = (self.start_rate - self.end_rate) / (self.end_iter - self.start_iter)
+        else:
+            self.r = 0
+
+    def step(self, mmdit, cur_iter):
+        if cur_iter < self.start_iter:
+            mmdit.low_res_drop_rate = 1.0
+        elif cur_iter < self.end_iter:
+            mmdit.low_res_drop_rate = self.start_rate - self.r * (cur_iter - self.start_iter)
+        else:
+            mmdit.low_res_drop_rate = self.end_rate
+        if cur_iter % 50 == 0:
+            print("cur_iter", cur_iter, "mmdit.low_res_drop_rate", mmdit.low_res_drop_rate)
+        return

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/selftok_hook.py

@@ -0,0 +1,302 @@
+# -*- coding: utf-8 -*-
+
+import os
+# import time
+from time import time
+import torch
+import psutil
+import datetime
+import torch.distributed as dist
+from diffusers.models import AutoencoderKL
+from collections import OrderedDict
+from .selftok.lr_scheduler import MyLRScheduler
+from .checkpoint import SaveModel
+from .selftok.threshold_scheduler import ThresholdScheduler, ObjectiveScheduler, LowResDroprateScheduler
+try:
+    from torch.utils.tensorboard import SummaryWriter
+except:
+    print("# Ascend didn't support SummaryWriter, skipped")
+from .train_loop import HookBase
+from mimogpt.utils import hf_logger
+import moxing as mox
+
+
+def extract_exp_name(output_path, train_url):
+    try:
+        outputs = train_url.split('/')
+        for i, output in enumerate(outputs):
+            if 'time' in output and output[0] == '2':
+                part2 = output[5:].replace('time_', '')
+                part1 = outputs[i-1]
+                break
+        return f"{part1}_{part2}"
+    except:
+        return "debug"
+    
+
+
+def build_selftok_optimizer(model, cfg):
+    fix_encoder, fix_decoder = cfg.model.fix_encoder, cfg.model.fix_decoder
+    if hasattr(model, "module"):
+        model_base = model.module
+    else:
+        model_base = model
+    
+    param_groups = []
+    if not fix_encoder:
+        if isinstance(model_base.encoder,dict):
+            train_encoder_res = cfg.tokenizer.params.train_encoder_res
+            param_groups.append({
+            'params': model_base.encoder[train_encoder_res].parameters(),
+            'lr': cfg.optimize.lr_scheduler.init_lr,
+            'name': 'encoder'
+            })
+        else:
+            param_groups.append({
+                'params': model_base.encoder.parameters(),
+                'lr': cfg.optimize.lr_scheduler.init_lr,
+                'name': 'encoder'
+            })
+    if not fix_decoder:
+        token_lr = cfg.optimize.lr_scheduler.token_lr if hasattr(cfg.optimize.lr_scheduler, "token_lr") else None
+        if token_lr is None:
+            param_groups.append({
+                'params': model_base.model.parameters(),
+                'lr': cfg.optimize.lr_scheduler.dit_lr,
+                'name': 'decoder'
+            })
+        else:
+            param_groups.append({
+                'params': model_base.model.get_params_by_filter(select_list=['x_block', 'x_embedder']),
+                'lr': cfg.optimize.lr_scheduler.dit_lr,
+                'name': 'decoder'
+            })
+            param_groups.append({
+                'params': model_base.model.get_params_by_filter(remove_list=['x_block', 'x_embedder']),
+                'lr': token_lr,
+                'name': 'token'
+            })  # when train_filter does not include x_block and x_embedder, these two param groups equal model.parameters()
+    opt = torch.optim.AdamW(param_groups, betas=(0.9, 0.99), weight_decay=0)
+    return opt
+
+
+class SelfTokHook(HookBase):
+    def __init__(self, cfg):
+        self.cfg = cfg
+        self.set_attribute()
+        self.is_root = (dist.get_rank() == 0)
+        self.log_root_dir = os.path.join(cfg.common.output_path, "tb")
+        self.save_interval = self.cfg.common.ckpt_interval
+        
+        self.exp_name = extract_exp_name(cfg.common.output_path, cfg.train_url)
+        self.debug = (self.exp_name == 'debug')
+        self.tb_copy_dir = os.path.join(cfg.common.tb_path, self.exp_name)
+        hf_logger.info(f"tb copy dir: {self.tb_copy_dir}")
+        hf_logger.info(f"Log root path: {self.log_root_dir}")
+        if self.is_root and not self.debug:
+            os.makedirs(self.log_root_dir, exist_ok=True)
+            self.tb_logger = SummaryWriter(self.log_root_dir, max_queue=1, flush_secs=10)
+        else:
+            self.tb_logger = None
+
+    @torch.no_grad()
+    def update_ema(self, ema_factor=0.9999):
+        if hasattr(self.cfg.common, "use_fsdp") and self.cfg.common.use_fsdp:
+            from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+            with FSDP.summon_full_params(self.trainer.model):
+                with torch.no_grad():
+                    if self.trainer.ema is not None:
+                        for p, p_ema in zip(self.trainer.model.model.parameters(), self.trainer.ema.parameters()):
+                            if self.ema_in_cpu:
+                                p1 = p.data.detach().clone().cpu()
+                            else:
+                                p1 = p.data.detach().clone()
+                            p_ema.data.mul_(ema_factor).add_((1 - ema_factor) * p1)
+        else:
+            with torch.no_grad():
+                if hasattr(self.trainer.model, "module"):
+                    model_before_ddp = self.trainer.model.module.model
+                else:
+                    model_before_ddp = self.trainer.model.model
+                for p, p_ema in zip(model_before_ddp.parameters(), self.trainer.ema.parameters()):
+                    if self.ema_in_cpu:
+                        p1 = p.data.detach().clone().cpu()
+                    else:
+                        p1 = p.data.detach().clone()
+                    p_ema.data.mul_(ema_factor).add_((1 - ema_factor) * p1)
+
+    def set_attribute(self):
+        self.dead_code_threshold = self.cfg.tokenizer.params.quantizer_config.dead_code_threshold
+        self.init_step1 = self.cfg.optimize.lr_scheduler.init_step1
+        self.init_step2 = self.cfg.optimize.lr_scheduler.init_step2
+        self.max_step = self.cfg.optimize.lr_scheduler.max_step
+        self.min_lr1 = self.cfg.optimize.lr_scheduler.min_lr1
+        self.min_lr2 = self.cfg.optimize.lr_scheduler.min_lr2 
+        self.ema_in_cpu = self.cfg.optimize.ema_in_cpu
+        self.gradient_accumulation_steps = self.cfg.optimize.get("gradient_accumulation_steps", 1)
+
+    def set_scheduler(self):
+        if hasattr(self.cfg.optimize, "dead_code_scheduler"):
+            self.dead_code_scheduler = ThresholdScheduler(
+                init_threshold=self.dead_code_threshold,
+                final_threshold=self.cfg.optimize.dead_code_scheduler.final_threshold,
+                constant_step=self.cfg.optimize.dead_code_scheduler.constant_step,
+                end_step=self.cfg.optimize.dead_code_scheduler.end_step
+            )
+        self.lr_scheduler = MyLRScheduler(
+            self.trainer.optimizer, 
+            init_step1=self.init_step1,
+            init_step2=self.init_step2,
+            max_step=self.max_step,
+            init_lr=self.cfg.optimize.lr_scheduler.init_lr,
+            min_lr1=self.min_lr1,
+            min_lr2=self.min_lr2
+        )
+        if hasattr(self.cfg.optimize, 'objective_scheduler'):
+            self.objective_scheduler = ObjectiveScheduler(**self.cfg.optimize.objective_scheduler)
+        if hasattr(self.cfg.optimize, 'low_res_drop_rate_scheduler'):
+            self.low_res_drop_rate_scheduler = LowResDroprateScheduler(
+                **self.cfg.optimize.low_res_drop_rate_scheduler
+            )
+    
+    def before_step(self):
+        current_iter = self.trainer.iter
+        if hasattr(self.trainer.model, "module"):
+            model_base = self.trainer.model.module
+        else:
+            model_base = self.trainer.model
+        if hasattr(self, 'low_res_drop_rate_scheduler'):
+            self.low_res_drop_rate_scheduler.step(model_base.model, current_iter)
+
+    def update_scheduler(self):
+        current_iter = self.trainer.iter
+        self.lr_scheduler.step(current_iter)
+        if hasattr(self.trainer.model, "module"):
+            model_base = self.trainer.model.module
+        else:
+            model_base = self.trainer.model
+        if hasattr(self, 'objective_scheduler'):
+            self.objective_scheduler.step(model_base, current_iter)
+        if hasattr(self, "dead_code_scheduler"):    
+            self.dead_code_scheduler.step(model_base.encoder, current_iter)
+
+    def ema_update(self):
+        if (self.trainer.iter + 1) % self.gradient_accumulation_steps == 0:
+            self.update_ema()
+    
+    def log(self):
+        if self.trainer.iter % self.trainer.log_every == 0:
+            if self.is_root:
+                torch.cuda.synchronize()
+                self.trainer.end_time = time()
+                steps_per_sec = self.trainer.log_every / (self.trainer.end_time - self.trainer.start_time)
+                lrr = self.trainer.optimizer.param_groups[0]["lr"]
+                current_iter = self.trainer.iter
+                logging_info = f"(step={current_iter:07d}), lr={lrr:.8f}, "
+                
+                meters = self.trainer.meters
+                for k, v in meters.items():
+                    avg_metric = meters[k].avg
+                    if k in ['perplexity_list', 'deter_list']:
+                        metric_str = ",".join([str(int(p)) for p in avg_metric.tolist()])
+                        avg_metric = avg_metric.mean()
+                        logging_info += f"avg_{k}={metric_str}, "
+                    elif k in ['n_active', 'n_reactive']:
+                        logging_info += f"avg_{k}={int(avg_metric):04d}, "
+                    elif k not in ['loss_small', 'loss_mid', 'loss_large', 'loss_uncon']:
+                        logging_info += f"avg_{k}={avg_metric:.4f}, "
+                    if not self.debug:
+                        self.tb_logger.add_scalar(f"avg_{k}", avg_metric, current_iter)
+                        
+                ###
+                logging_info += f"steps/sec={steps_per_sec:.2f}"
+                hf_logger.info(logging_info)
+
+                if not self.debug:
+                    mox.file.copy_parallel(self.log_root_dir, self.tb_copy_dir)
+                self.trainer.start_time = time()
+
+    def after_step(self):
+        self.update_scheduler()
+        self.log()
+
+    def after_train(self):
+        if self.is_root and not self.debug:
+            self.tb_logger.close()
+
+    def set_train_state(self):
+        fix_encoder, fix_decoder = self.cfg.model.fix_encoder, self.cfg.model.fix_decoder
+        if hasattr(self.trainer.model, "module"):
+            model_base = self.trainer.model.module
+        else:
+            model_base = self.trainer.model
+        if fix_encoder:
+            model_base.encoder.eval()
+        if fix_decoder:
+            model_base.model.eval()
+
+    def before_train(self):
+        self.set_scheduler()
+        self.set_train_state()
+        
+
+class SelfTokSaveHook(SaveModel):
+    def __init__(self, cfg, is_root):
+        super().__init__(cfg, is_root)
+        self.cfg = cfg
+        self.save_interval = self.cfg.common.ckpt_interval
+
+    def save_model(self, checkpoint, save_name):
+        if self.is_root:
+            local_weights = os.path.join(self.save_path, save_name)
+            # for k, v in checkpoint.items():
+            #     checkpoint[k] = checkpoint[k].cpu()
+            torch.save(checkpoint, local_weights)
+            self.upload_and_delete_local_model(local_weights)
+
+
+    def after_step(self):
+        if self.trainer.iter % self.save_interval == (self.save_interval - 1) and self.trainer.iter > 0:
+            save_name = "iter_%d.pth" % (self.trainer.iter)
+            # ema_state = self.trainer.ema.state_dict()
+            # for k, v in ema_state.items():
+            #     ema_state[k] = ema_state[k].cpu()
+            if hasattr(self.cfg.common, "use_fsdp") and self.cfg.common.use_fsdp:
+                from torch.distributed.fsdp import FullStateDictConfig, FullOptimStateDictConfig, StateDictType
+                from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+
+                save_policy = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                save_opt_policy = FullOptimStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                #with FSDP.state_dict_type(self.trainer.model, StateDictType.FULL_STATE_DICT, save_policy, save_opt_policy):
+                FSDP.set_state_dict_type(self.trainer.model, StateDictType.FULL_STATE_DICT, save_policy, save_opt_policy)
+                cpu_state = self.trainer.model.state_dict()
+                #original_osd = self.trainer.optimizer.state_dict()
+                #opt_state =  FSDP.optim_state_dict(self.trainer.model, self.trainer.optimizer, optim_state_dict=original_osd)
+                save_data = {
+                    'iter': self.trainer.iter,
+                    'state_dict': cpu_state,
+                    #'ema_state_dict': ema_state,
+                    #'opt': opt_state,
+                    'cfg': self.cfg
+                }
+                self.save_model(save_data, save_name)
+                hf_logger.info(f"Saved checkpoint to {save_name}")
+                torch.cuda.empty_cache()
+            else:
+                if hasattr(self.trainer.model, "module"):
+                    state_dict = self.trainer.model.module.state_dict()
+                    # self.save_model(self.trainer.model.module.state_dict(), save_name)
+                else:
+                    state_dict = self.trainer.model.state_dict()
+                for k, v in state_dict.items():
+                    state_dict[k] = state_dict[k].cpu()
+                save_data = {
+                    'iter': self.trainer.iter,
+                    'state_dict': state_dict,
+                    'opt': self.trainer.optimizer.state_dict(),
+                    'cfg': self.cfg
+                }
+            self.save_model(save_data, save_name)
+            hf_logger.info(f"Saved checkpoint to {save_name}")
+            torch.cuda.empty_cache()
+    

llamagen-siglip-sb-block-causal/SelftokPipeline/mimogpt/engine/utils/selftok_validation.py

@@ -0,0 +1,238 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import torch
+import torch.distributed as dist
+import torch.nn.functional as F
+from torchvision import transforms
+from torchvision.utils import save_image
+from torchvision import models as tv
+
+from mimogpt.models.selftok.diffusion import create_diffusion
+from mimogpt.models.selftok.sd3.rectified_flow import RectifiedFlow
+from mimogpt.models.selftok.sd3.sd3_impls import SDVAE, CFGDenoiser, SD3LatentFormat
+
+import lpips as lps
+import numpy as np
+from PIL import Image
+from lpips.pretrained_networks import alexnet
+from mimogpt.utils import hf_logger
+from .train_loop import HookBase
+from .selftok_hook import extract_exp_name
+
+
+try:
+    import moxing as mox
+
+    def tqdm(_iter):
+        return _iter
+
+except:
+    from tqdm import tqdm
+
+__all__ = ["EvalSelftokHook"]
+
+def norm_ip(img, low, high):
+    img.clamp_(min=low, max=high)
+    img.sub_(low).div_(max(high - low, 1e-5))
+
+class local_alexnet(alexnet):
+    def __init__(self, path):
+        super().__init__(requires_grad=False, pretrained=False)
+        tv_alexnet = tv.alexnet(pretrained=False)
+        tv_alexnet.load_state_dict(torch.load(path))
+        alexnet_pretrained_features = tv_alexnet.features
+        for x in range(2):
+            self.slice1.add_module(str(x), alexnet_pretrained_features[x])
+        for x in range(2, 5):
+            self.slice2.add_module(str(x), alexnet_pretrained_features[x])
+        for x in range(5, 8):
+            self.slice3.add_module(str(x), alexnet_pretrained_features[x])
+        for x in range(8, 10):
+            self.slice4.add_module(str(x), alexnet_pretrained_features[x])
+        for x in range(10, 12):
+            self.slice5.add_module(str(x), alexnet_pretrained_features[x])
+        for param in self.parameters():
+            param.requires_grad = False
+
+
+class EvalSelftokHook(HookBase):
+    def __init__(self, cfg):
+        self.cfg = cfg
+        eval_interval = cfg.common.val_interval
+        self.eval_interval = int(eval_interval)
+        self.best_metric = -1
+        self.lpips_loss = lps.LPIPS(net='alex', pnet_rand=True)
+        self.lpips_loss.net = local_alexnet(cfg.common.alex_path)
+        self.lpips_loss = self.lpips_loss.cuda()
+        self.is_root = (dist.get_rank() == 0)
+        self.cond_vary = (not cfg.model.full_tokens) \
+            if hasattr(cfg.model, "full_tokens") else True
+        self.recon_tfm = transforms.Compose([
+            transforms.ToPILImage(),
+            transforms.Resize(size=128),
+            transforms.ToTensor()
+        ])
+        self.local_url = '/cache/data/val/'
+        if dist.get_rank() % 8 == 0:
+            os.makedirs(self.local_url, exist_ok=True)
+        self.exp_name = extract_exp_name(cfg.common.output_path, cfg.train_url)
+        self.img_url = os.path.join(cfg.common.val_url, self.exp_name)
+        if dist.get_rank() % 8 == 0:
+            mox.file.make_dirs(self.img_url)
+        self.model_type = 'sd3' if self.cfg.tokenizer.params.model == 'MMDiT_XL' else 'dit'
+
+    def after_step(self):
+        if self.trainer.iter % self.eval_interval == 0 and self.trainer.iter > 0:
+            self.validate()
+
+    def train_mode(self, encoder_training, dm_training):
+        if hasattr(self.trainer.model, "module"):
+            model = self.trainer.model.module
+        else:
+            model = self.trainer.model
+        if encoder_training:
+            model.encoder.train()
+        if dm_training:
+            model.model.train()
+
+    def eval_mode(self):
+        if hasattr(self.trainer.model, "module"):
+            model = self.trainer.model.module
+        else:
+            model = self.trainer.model
+        encoder_training, dm_training = model.encoder.training, model.model.training
+        model.encoder.eval()
+        model.model.eval()
+        return encoder_training, dm_training
+
+    def compute_psnr(self, recon, ori):
+        x = torch.from_numpy(np.array(Image.open(ori))).cuda().float()
+        y = torch.from_numpy(np.array(Image.open(recon))).cuda().float()
+        mse = F.mse_loss(x, y)
+        psnr = 20 * torch.log10(torch.Tensor([255.0]).to(x.device)) - 10 * torch.log10(mse)
+        return psnr
+
+    def process_input(self, x_0):
+        if type(x_0) is list:
+            x_0 = x_0[0]    # remove class label
+        with torch.no_grad():
+            x_0 = x_0.cuda()
+            if not self.trainer.pre_encode:
+                if self.model_type == 'sd3':
+                    x_0 = self.trainer.vae.encode(x_0)
+                else:
+                    x_0 = self.trainer.vae.encode(x_0).latent_dist.sample().mul_(0.18215)
+            else:
+                x_0 = x_0.squeeze(dim=1)
+            if self.model_type == 'sd3':
+                x_0 = SD3LatentFormat().process_in(x_0)
+        return x_0
+    
+    def validate(self):
+        encoder_training, dm_training = self.eval_mode()
+        lpips = 0.0
+        psnr = 0.0
+        tests = 10
+        total_steps = 50
+        start_steps = 49
+        for t in range(tests):
+            x_0 = next(self.trainer.val_data_loader_iter)
+            x_0 = self.process_input(x_0)
+            noise = torch.randn_like(x_0, device=x_0.device)
+            with torch.no_grad():
+                if hasattr(self.trainer.model, "module"):
+                    model_base = self.trainer.model.module
+                else:
+                    model_base = self.trainer.model
+                recon = self.reconstruct_val(
+                    total_steps, start_steps, self.trainer.ema, noise, x_0, 
+                    diti=model_base.diti, encoder=model_base.encoder, ddim=True,
+                    cond_vary=self.cond_vary
+                )["pred_x_0"]
+                
+                # original image, reconstruction
+                if self.model_type == 'sd3':
+                    x_0 = SD3LatentFormat().process_out(x_0)
+                    recon = SD3LatentFormat().process_out(recon)
+                    img_0, img_recon = \
+                        self.trainer.vae.decode(x_0),\
+                        self.trainer.vae.decode(recon)
+                else:
+                    img_0, img_recon = \
+                        self.trainer.vae.decode(x_0 / 0.18215).sample,\
+                        self.trainer.vae.decode(recon / 0.18215).sample
+            
+            lpips_batch = self.lpips_loss(img_recon.clamp(-1,1), img_0.clamp(-1,1))
+            lpips += lpips_batch.mean()
+            norm_ip(img_recon, -1, 1)
+            norm_ip(img_0, -1, 1)
+            cur_psnr = 0.0
+            currank = dist.get_rank()
+            for b in range(len(img_0)):
+                save_image(img_recon[b], f"/cache/recon_{currank}.png")
+                save_image(img_0[b], f"/cache/ori_{currank}.png")
+                cur_sub_psnr = self.compute_psnr(f"/cache/recon_{currank}.png", f"/cache/ori_{currank}.png")
+                cur_psnr += cur_sub_psnr
+            cur_psnr /= len(img_0)
+            # print(cur_psnr)
+            psnr += cur_psnr.mean()
+        meters = self.trainer.meters["lpips"]
+        mean_lpips = (lpips / float(tests)) / dist.get_world_size()
+        meters.reduce_update(mean_lpips)
+        if self.is_root:
+            hf_logger.info(f"Step {self.trainer.iter}: Val LPIPS on {tests} batches={meters.avg:.4f}.")
+
+        meters = self.trainer.meters["psnr"]
+        mean_psnr = (psnr / float(tests)) / dist.get_world_size()
+        meters.reduce_update(mean_psnr)
+        if self.is_root:
+            hf_logger.info(f"Step {self.trainer.iter}: Val PSNR on {tests} batches={meters.avg:.4f}.")
+
+        images = torch.cat((img_0, img_recon), dim=0)
+        images = images.clamp(-1, 1)
+        images = (images-images.min()) / (images.max()-images.min())
+        images = [self.recon_tfm(img) for img in images]
+
+        if dist.get_rank() % torch.cuda.device_count() == 0:
+            eval_image_file = f"{self.local_url}/val_{self.trainer.iter:07d}_{t}.png"
+            save_image(images, eval_image_file, nrow=len(x_0), normalize=True, value_range=(0, 1))
+            mox.file.copy(eval_image_file, f'{self.img_url}/val_{self.trainer.iter:07d}_{t}.png')
+                    
+        self.train_mode(encoder_training, dm_training)
+
+
+    def reconstruct_val(self, num_steps, t, model, noise=None, x0=None, y=None, diti=None, encoder=None, 
+        cond_vary=False, ddim=False, dit=None):
+        # print(str(num_steps))
+        if self.model_type == 'sd3':
+            diffusion = RectifiedFlow(num_steps, **self.cfg.tokenizer.params.noise_schedule_config)
+        else:
+            diffusion = create_diffusion(str(num_steps))
+        N = x0.shape[0]
+        device = x0.device
+        x_t = noise
+
+        with torch.no_grad():
+            if diti is None:
+                model_kwargs = {'y': y}
+            else:
+                if self.model_type == 'sd3':
+                    t_mapped = torch.tensor([diffusion.timestep_map[0]]*N, device=device).long()
+                else:
+                    t_mapped = torch.tensor([diffusion.timestep_map[t]]*N, device=device).long()
+                k = diti.to_indices(t_mapped)
+                encoder_hidden_states, _, ori_hidden_states, mask, _, _ = encoder(x0, d=k)
+
+                model_kwargs = dict(
+                    encoder_hidden_states=encoder_hidden_states,
+                    mask=mask
+                )
+            pred_x_0 = diffusion.p_sample_loop(
+                model.forward, x_t.shape, x_t, clip_denoised=False, 
+                model_kwargs=model_kwargs, progress=False, device=device,
+                start_t=t, ddim=ddim,cond_vary=cond_vary, diti=diti, encoder=encoder, 
+                x_0 = x0, ori_hidden_states=ori_hidden_states, dit=dit
+            )
+        return {"x_t": x_t, "pred_x_0": pred_x_0}