Upload folder using huggingface_hub

.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
+tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,144 @@
+---
+library_name: Diffusers
+pipeline_tag: text-to-image
+inference: true
+base_model:
+- Tongyi-MAI/Z-Image-Turbo
+---
+
+This tiny model is for debugging. It is randomly initialized with the config adapted from [Tongyi-MAI/Z-Image-Turbo](https://huggingface.co/Tongyi-MAI/Z-Image-Turbo).
+
+File size:
+- 2.4MB  text_encoder/model.safetensors
+- 1.4MB  transformer/diffusion_pytorch_model.safetensors
+- 0.5MB  vae/diffusion_pytorch_model.safetensors
+
+### Example usage:
+
+```python
+import torch
+from diffusers import ZImagePipeline
+
+model_id = "yujiepan/z-image-tiny-random"
+torch_dtype = torch.bfloat16
+device = "cuda"
+pipe = ZImagePipeline.from_pretrained(model_id, torch_dtype=torch_dtype)
+pipe = pipe.to(device)
+
+prompt = "Flowers and trees"
+image = pipe(
+    prompt=prompt,
+    height=1024,
+    width=1024,
+    num_inference_steps=9,  # This actually results in 8 DiT forwards
+    guidance_scale=0.0,     # Guidance should be 0 for the Turbo models
+    generator=torch.Generator("cuda").manual_seed(42),
+).images[0]
+print(image)
+```
+
+### Codes to create this repo:
+
+```python
+import json
+
+import torch
+from diffusers import (
+    AutoencoderKL,
+    DiffusionPipeline,
+    FlowMatchEulerDiscreteScheduler,
+    ZImagePipeline,
+    ZImageTransformer2DModel,
+)
+from huggingface_hub import hf_hub_download
+from transformers import AutoConfig, AutoTokenizer, Qwen2Tokenizer, Qwen3Model
+from transformers.generation import GenerationConfig
+
+source_model_id = "Tongyi-MAI/Z-Image-Turbo"
+save_folder = "/tmp/yujiepan/z-image-tiny-random"
+
+torch.set_default_dtype(torch.bfloat16)
+scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(
+    source_model_id, subfolder='scheduler')
+tokenizer = AutoTokenizer.from_pretrained(
+    source_model_id, subfolder='tokenizer')
+
+def save_json(path, obj):
+    import json
+    from pathlib import Path
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    with open(path, 'w', encoding='utf-8') as f:
+        json.dump(obj, f, indent=2, ensure_ascii=False)
+
+def init_weights(model):
+    import torch
+    torch.manual_seed(42)
+    with torch.no_grad():
+        for name, p in sorted(model.named_parameters()):
+            torch.nn.init.normal_(p, 0, 0.1)
+            print(name, p.shape, p.dtype, p.device)
+
+with open(hf_hub_download(source_model_id, filename='text_encoder/config.json', repo_type='model'), 'r', encoding='utf - 8') as f:
+    config = json.load(f)
+    config.update({
+        "head_dim": 32,
+        'hidden_size': 8,
+        'intermediate_size': 32,
+        'max_window_layers': 1,
+        'num_attention_heads': 8,
+        'num_hidden_layers': 2,
+        'num_key_value_heads': 4,
+        'tie_word_embeddings': True,
+    })
+    save_json(f'{save_folder}/text_encoder/config.json', config)
+    text_encoder_config = AutoConfig.from_pretrained(
+        f'{save_folder}/text_encoder')
+    text_encoder = Qwen3Model(text_encoder_config).to(torch.bfloat16)
+    generation_config = GenerationConfig.from_pretrained(
+        source_model_id, subfolder='text_encoder')
+    text_encoder.generation_config = generation_config
+    init_weights(text_encoder)
+
+with open(hf_hub_download(source_model_id, filename='transformer/config.json', repo_type='model'), 'r', encoding='utf-8') as f:
+    config = json.load(f)
+    config.update({
+        'dim': 64,
+        'axes_dims': [8, 8, 16],
+        'n_heads': 2,
+        'n_kv_heads': 4,
+        'n_layers': 2,
+        'cap_feat_dim': 8,
+        'in_channels': 8,
+    })
+    save_json(f'{save_folder}/transformer/config.json', config)
+    transformer_config = ZImageTransformer2DModel.load_config(
+        f'{save_folder}/transformer')
+    transformer = ZImageTransformer2DModel.from_config(
+        transformer_config)
+    init_weights(transformer)
+
+with open(hf_hub_download(source_model_id, filename='vae/config.json', repo_type='model'), 'r', encoding='utf-8') as f:
+    config = json.load(f)
+    config.update({
+        'layers_per_block': 1,
+        'block_out_channels': [32, 32],
+        'latent_channels': 8,
+        'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
+        'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D']
+    })
+    save_json(f'{save_folder}/vae/config.json', config)
+    vae_config = AutoencoderKL.load_config(f'{save_folder}/vae')
+    vae = AutoencoderKL.from_config(vae_config)
+    init_weights(vae)
+
+pipeline = ZImagePipeline(
+    scheduler=scheduler,
+    text_encoder=text_encoder,
+    tokenizer=tokenizer,
+    transformer=transformer,
+    vae=vae,
+)
+pipeline = pipeline.to(torch.bfloat16)
+pipeline.save_pretrained(save_folder, safe_serialization=True)
+print(pipeline)
+```

model_index.json

@@ -0,0 +1,24 @@
+{
+  "_class_name": "ZImagePipeline",
+  "_diffusers_version": "0.36.0.dev0",
+  "scheduler": [
+    "diffusers",
+    "FlowMatchEulerDiscreteScheduler"
+  ],
+  "text_encoder": [
+    "transformers",
+    "Qwen3Model"
+  ],
+  "tokenizer": [
+    "transformers",
+    "Qwen2Tokenizer"
+  ],
+  "transformer": [
+    "diffusers",
+    "ZImageTransformer2DModel"
+  ],
+  "vae": [
+    "diffusers",
+    "AutoencoderKL"
+  ]
+}

scheduler/scheduler_config.json

@@ -0,0 +1,18 @@
+{
+  "_class_name": "FlowMatchEulerDiscreteScheduler",
+  "_diffusers_version": "0.36.0.dev0",
+  "base_image_seq_len": 256,
+  "base_shift": 0.5,
+  "invert_sigmas": false,
+  "max_image_seq_len": 4096,
+  "max_shift": 1.15,
+  "num_train_timesteps": 1000,
+  "shift": 3.0,
+  "shift_terminal": null,
+  "stochastic_sampling": false,
+  "time_shift_type": "exponential",
+  "use_beta_sigmas": false,
+  "use_dynamic_shifting": false,
+  "use_exponential_sigmas": false,
+  "use_karras_sigmas": false
+}

text_encoder/config.json

@@ -0,0 +1,36 @@
+{
+  "architectures": [
+    "Qwen3Model"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 151643,
+  "dtype": "bfloat16",
+  "eos_token_id": 151645,
+  "head_dim": 32,
+  "hidden_act": "silu",
+  "hidden_size": 8,
+  "initializer_range": 0.02,
+  "intermediate_size": 32,
+  "layer_types": [
+    "full_attention",
+    "full_attention"
+  ],
+  "max_position_embeddings": 40960,
+  "max_window_layers": 1,
+  "model_type": "qwen3",
+  "num_attention_heads": 8,
+  "num_hidden_layers": 2,
+  "num_key_value_heads": 4,
+  "rms_norm_eps": 1e-06,
+  "rope_parameters": {
+    "rope_theta": 1000000,
+    "rope_type": "default"
+  },
+  "sliding_window": null,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0.dev0",
+  "use_cache": true,
+  "use_sliding_window": false,
+  "vocab_size": 151936
+}

text_encoder/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25eeb02baf45bca7a4d6d353ee850b77a57f0f589a8718c5b00b3a48b8d3ea9f
+size 2461344

tokenizer/chat_template.jinja

@@ -0,0 +1,89 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
+        {%- set ns.multi_step_tool = false %}
+        {%- set ns.last_query_index = index %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {%- if loop.last or (not loop.last and reasoning_content) %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+            {%- else %}
+                {{- '<|im_start|>' + message.role + '\n' + content }}
+            {%- endif %}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- endif %}
+{%- endif %}

tokenizer/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05d47c87966b4db779200053de490f89936ed529f8ab889244e271630715fcfe
+size 11422638

tokenizer/tokenizer_config.json

@@ -0,0 +1,30 @@
+{
+  "add_prefix_space": false,
+  "additional_special_tokens": null,
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "is_local": false,
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}

transformer/config.json

@@ -0,0 +1,31 @@
+{
+  "_class_name": "ZImageTransformer2DModel",
+  "_diffusers_version": "0.36.0.dev0",
+  "all_f_patch_size": [
+    1
+  ],
+  "all_patch_size": [
+    2
+  ],
+  "axes_dims": [
+    8,
+    8,
+    16
+  ],
+  "axes_lens": [
+    1536,
+    512,
+    512
+  ],
+  "cap_feat_dim": 8,
+  "dim": 64,
+  "in_channels": 8,
+  "n_heads": 2,
+  "n_kv_heads": 4,
+  "n_layers": 2,
+  "n_refiner_layers": 2,
+  "norm_eps": 1e-05,
+  "qk_norm": true,
+  "rope_theta": 256.0,
+  "t_scale": 1000.0
+}

transformer/diffusion_pytorch_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4edbc5f3277b151aca0d61adfc6f4a8abc583a3835eaa2469a3ee2cc8ba75500
+size 1411000

vae/config.json

@@ -0,0 +1,32 @@
+{
+  "_class_name": "AutoencoderKL",
+  "_diffusers_version": "0.36.0.dev0",
+  "_name_or_path": "flux-dev",
+  "act_fn": "silu",
+  "block_out_channels": [
+    32,
+    32
+  ],
+  "down_block_types": [
+    "DownEncoderBlock2D",
+    "DownEncoderBlock2D"
+  ],
+  "force_upcast": true,
+  "in_channels": 3,
+  "latent_channels": 8,
+  "latents_mean": null,
+  "latents_std": null,
+  "layers_per_block": 1,
+  "mid_block_add_attention": true,
+  "norm_num_groups": 32,
+  "out_channels": 3,
+  "sample_size": 1024,
+  "scaling_factor": 0.3611,
+  "shift_factor": 0.1159,
+  "up_block_types": [
+    "UpDecoderBlock2D",
+    "UpDecoderBlock2D"
+  ],
+  "use_post_quant_conv": false,
+  "use_quant_conv": false
+}

vae/diffusion_pytorch_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e71547b596ef6dfd8f8d09d61aadc533353269654c9b07b60e33a8c0472161c
+size 456470