update readme

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+teaser.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,150 @@
 ---
-license: mit
+library_name: diffusers
+inference: true
+tags:
+- lora
+- text-to-image
+- stable-diffusion
+- flux
+base_model: black-forest-labs/FLUX.1-dev
 ---
+
+# ART - Anonymous Region Transformer for Variable Multi-Layer Transparent Image
+- Paper: *[Arxiv](https://arxiv.org/abs/2502.18364)*
+
+- Official Repository: *[ART](https://github.com/microsoft/art-msra)*.
+
+- Project Page: https://art-msra.github.io/
+
+- Demo: [🤗demo](http://20.65.136.27:8060/) 
+
+![teaser](./teaser.png)
+
+
+## News🔥🔥🔥
+
+* Feb, 26 2025. 💥💥💥 Weights uploaded.
+
+## Abstract
+
+Multi-layer image generation is a fundamental task that enables users to isolate, select, and edit specific image layers, thereby revolutionizing interactions with generative models. In this paper, we introduce the Anonymous Region Transformer (ART), which facilitates the direct generation of variable multi-layer transparent images based on a global text prompt and an anonymous region layout.
+
+Inspired by Schema theory, this anonymous region layout allows the generative model to autonomously determine which set of visual tokens should align with which text tokens, which is in contrast to the previously dominant semantic layout for the image generation task.
+
+In addition, the layer-wise region crop mechanism, which only selects the visual tokens belonging to each anonymous region, significantly reduces attention computation costs and enables the efficient generation of images with numerous distinct layers (e.g., 50+). When compared to the full attention approach, our method is over 12 times faster and exhibits fewer layer conflicts.
+
+Furthermore, we propose a high-quality multi-layer transparent image autoencoder that supports the direct encoding and decoding of the transparency of variable multi-layer images in a joint manner.
+
+By enabling precise control and scalable layer generation, ART establishes a new paradigm for interactive content creation.
+
+##  Usage
+Please first clone our repository and run the code below to have a try!
+```python
+import os
+import math
+import torch
+import argparse
+from PIL import Image
+from multi_layer_gen.custom_model_mmdit import CustomFluxTransformer2DModel
+from multi_layer_gen.custom_model_transp_vae import AutoencoderKLTransformerTraining as CustomVAE
+from multi_layer_gen.custom_pipeline import CustomFluxPipelineCfg
+
+def test_sample(pipeline, transp_vae, batch, args):
+
+    def adjust_coordinate(value, floor_or_ceil, k=16, min_val=0, max_val=1024):
+        # Round the value to the nearest multiple of k
+        if floor_or_ceil == "floor":
+            rounded_value = math.floor(value / k) * k
+        else:
+            rounded_value = math.ceil(value / k) * k
+        # Clamp the value between min_val and max_val
+        return max(min_val, min(rounded_value, max_val))
+
+    validation_prompt = batch["wholecaption"]
+    validation_box_raw = batch["layout"]
+    validation_box = [
+        (
+            adjust_coordinate(rect[0], floor_or_ceil="floor"), 
+            adjust_coordinate(rect[1], floor_or_ceil="floor"), 
+            adjust_coordinate(rect[2], floor_or_ceil="ceil"), 
+            adjust_coordinate(rect[3], floor_or_ceil="ceil"), 
+        )
+        for rect in validation_box_raw
+    ]
+    if len(validation_box) > 52:
+        validation_box = validation_box[:52]
+    
+    generator = torch.Generator(device=torch.device("cuda", index=args.gpu_id)).manual_seed(args.seed) if args.seed else None
+    output, rgba_output, _, _ = pipeline(
+        prompt=validation_prompt,
+        validation_box=validation_box,
+        generator=generator,
+        height=args.resolution,
+        width=args.resolution,
+        num_layers=len(validation_box),
+        guidance_scale=args.cfg,
+        num_inference_steps=args.steps,
+        transparent_decoder=transp_vae,
+    )
+    images = output.images   # list of PIL, len=layers
+    rgba_images = [Image.fromarray(arr, 'RGBA') for arr in rgba_output]
+
+    os.makedirs(os.path.join(args.save_dir, this_index), exist_ok=True)
+    for frame_idx, frame_pil in enumerate(images):
+        frame_pil.save(os.path.join(args.save_dir, this_index, f"layer_{frame_idx}.png"))
+        if frame_idx == 0:
+            frame_pil.save(os.path.join(args.save_dir, this_index, "merged.png"))
+    merged_pil = images[1].convert('RGBA')
+    for frame_idx, frame_pil in enumerate(rgba_images):
+        if frame_idx < 2:
+            frame_pil = images[frame_idx].convert('RGBA') # merged and background
+        else:
+            merged_pil = Image.alpha_composite(merged_pil, frame_pil)
+        frame_pil.save(os.path.join(args.save_dir, this_index, f"layer_{frame_idx}_rgba.png"))
+    
+    merged_pil = merged_pil.convert('RGB')
+    merged_pil.save(os.path.join(args.save_dir, this_index, "merged_rgba.png"))
+
+
+args = dict(
+    save_dir="output/",
+    resolution=512,
+    cfg=4.0,
+    steps=28,
+    seed=41,
+    gpu_id=1,
+)
+args = argparse.Namespace(**args)
+
+transformer = CustomFluxTransformer2DModel.from_pretrained("ART-Release/ART_v1.0", subfolder="transformer", torch_dtype=torch.bfloat16)
+transp_vae = CustomVAE.from_pretrained("ART-Release/ART_v1.0", subfolder="transp_vae", torch_dtype=torch.float32)
+pipeline = CustomFluxPipelineCfg.from_pretrained(
+    "black-forest-labs/FLUX.1-dev",
+    transformer=transformer,
+    torch_dtype=torch.bfloat16,
+).to(torch.device("cuda", index=args.gpu_id))
+pipeline.enable_model_cpu_offload(gpu_id=args.gpu_id) # Save GPU memory
+
+sample = {
+    "index": "reso512_3",
+    "wholecaption": 'Floral wedding invitation: green leaves, white flowers; circular border. Center: "JOIN US CELEBRATING OUR WEDDING" (cursive), "DONNA AND HARPER" (bold), "03 JUNE 2023" (small bold). White, green color scheme, elegant, natural.',
+    "layout": [(0, 0, 512, 512), (0, 0, 512, 512), (0, 0, 512, 352), (144, 384, 368, 448), (160, 192, 352, 432), (368, 0, 512, 144), (0, 0, 144, 144), (128, 80, 384, 208), (128, 448, 384, 496), (176, 48, 336, 80)],
+}
+
+test_sample(pipeline=pipeline, transp_vae=transp_vae, batch=sample, args=args)
+
+del pipeline
+if torch.cuda.is_available():
+    torch.cuda.empty_cache()
+```
+
+
+## Citation
+```bibtex
+@article{pu2025art,
+    title={ART: Anonymous Region Transformer for Variable Multi-Layer Transparent Image Generation}, 
+    author={Yifan Pu and Yiming Zhao and Zhicong Tang and Ruihong Yin and Haoxing Ye and Yuhui Yuan and Dong Chen and Jianmin Bao and Sirui Zhang and Yanbin Wang and Lin Liang and Lijuan Wang and Ji Li and Xiu Li and Zhouhui Lian and Gao Huang and Baining Guo},
+    journal={arXiv preprint arXiv:2502.18364},
+    year={2025},
+}
+```