Upload 3 files

.gitattributes

@@ -37,3 +37,4 @@ z_image_turbo_onnx/text_encoder/q4f16/model.onnx.data filter=lfs diff=lfs merge=
 z_image_turbo_onnx/text_encoder/qdq-q4f16/model.onnx.data filter=lfs diff=lfs merge=lfs -text
 z_image_turbo_onnx/transformer/q4f16/model.onnx.data filter=lfs diff=lfs merge=lfs -text
 z_image_turbo_onnx/transformer/qdq-q4f16/model.onnx.data filter=lfs diff=lfs merge=lfs -text
+z_image_turbo_onnx/text_encoder/q4f16-genai/model.onnx.data filter=lfs diff=lfs merge=lfs -text

z_image_turbo_onnx/text_encoder/q4f16-genai/model.onnx

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

z_image_turbo_onnx/text_encoder/q4f16-genai/model.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0893f98bd5445308dbe421fbe300f586a47ae7ef71157b3e586b67fb55ed6261
+size 1526231040

z_image_turbo_onnx/text_encoder/q4f16-genai/modify_genai_model.py

@@ -0,0 +1,196 @@
+"""
+
+How to generate Z-image text encoder into genai-webgpu-q4f16 onnx model:
+1. Download microsoft/onnxruntime-genai
+2. install pip onnxruntime_genai
+3. cd to src/python/py/models/
+4. mkdir genai-webgpu-q4f16
+5. mkdir z-image-text-encoder
+6. Download transformer models and tokenizers from HuggingFace and move all files into z-image-text-encoder:
+   - https://huggingface.co/Tongyi-MAI/Z-Image-Turbo/tree/main/text_encoder
+   - https://huggingface.co/Tongyi-MAI/Z-Image-Turbo/tree/main/tokenizer
+7. python builder.py -i z-image-text-encoder -o genai-webgpu-q4f16 -p int4 -e webgpu --extra_options int4_block_size=32 int4_accuracy_level=4 int4_op_types_to_quantize=MatMul/Gather enable_webgpu_graph=true
+
+
+Modify the genai-webgpu-q4f16 model:
+1. Remove KV cache inputs (past_key_values.*) and convert them to empty initializers
+2. Remove all outputs (logits, present.*)
+3. Add an `encoder_hidden_state` output (fp32)
+4. Dead code elimination: remove unused nodes and initializers
+"""
+
+import onnx
+from onnx import helper, TensorProto, numpy_helper
+from onnx.external_data_helper import convert_model_to_external_data
+import numpy as np
+import os
+import shutil
+
+# Configuration
+INPUT_MODEL_PATH = r'genai-webgpu-q4f16\model.onnx'
+OUTPUT_DIR = r'genai-webgpu-q4f16-modified'
+OUTPUT_MODEL_NAME = 'model.onnx'
+EXTERNAL_DATA_NAME = 'model.onnx.data'
+
+# Target output node
+TARGET_OUTPUT_NAME = '/model/layers.35/input_layernorm/output_3'
+CAST_OUTPUT_NAME = 'encoder_hidden_state'
+
+# KV cache configuration (batch=1, num_heads=8, seq_len=0, head_dim=128)
+KV_CACHE_SHAPE = (1, 8, 0, 128)
+KV_CACHE_DTYPE = np.float16
+
+
+def main():
+    # Get the directory where the script resides
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    input_model_path = os.path.join(script_dir, INPUT_MODEL_PATH)
+    output_dir = os.path.join(script_dir, OUTPUT_DIR)
+    output_path = os.path.join(output_dir, OUTPUT_MODEL_NAME)
+
+    print(f'Loading model: {input_model_path}')
+    model = onnx.load(input_model_path)
+
+    print('Modifying model...')
+    print(f'Original node count: {len(model.graph.node)}')
+    print(f'Original initializer count: {len(model.graph.initializer)}')
+
+    # 1. Handle KV cache inputs: remove the inputs and replace node references with an empty string (optional input)
+    kv_names = set()
+    for inp in model.graph.input:
+        if inp.name.startswith('past_key_values'):
+            kv_names.add(inp.name)
+
+    print(f'Converting {len(kv_names)} KV cache inputs to Optional (empty name)')
+
+    # Remove KV cache inputs
+    new_inputs = [inp for inp in model.graph.input if not inp.name.startswith('past_key_values')]
+    while len(model.graph.input) > 0:
+        model.graph.input.pop()
+    for inp in new_inputs:
+        model.graph.input.append(inp)
+
+    # Update node input references to ""
+    for node in model.graph.node:
+        for i, inp in enumerate(node.input):
+            if inp in kv_names:
+                node.input[i] = ""
+
+    # 2. Add a Cast node
+    cast_node = helper.make_node(
+        'Cast',
+        inputs=[TARGET_OUTPUT_NAME],
+        outputs=[CAST_OUTPUT_NAME],
+        name='graph_output_cast_encoder_hidden_state',
+        to=TensorProto.FLOAT
+    )
+    model.graph.node.append(cast_node)
+
+    # 3. Remove all existing outputs and add the new output
+    while len(model.graph.output) > 0:
+        model.graph.output.pop()
+    new_output = helper.make_tensor_value_info(CAST_OUTPUT_NAME, TensorProto.FLOAT, None)
+    model.graph.output.append(new_output)
+
+    # 4. Dead code elimination
+    print('Cleaning up unused nodes...')
+
+    initializer_names = set([init.name for init in model.graph.initializer])
+
+    # Build a mapping from index to node
+    node_list = list(model.graph.node)
+    node_idx_map = {i: node for i, node in enumerate(node_list)}
+
+    # Build a mapping from output tensor name to node index
+    output_to_node_idx = {}
+    for i, node in enumerate(node_list):
+        for out in node.output:
+            output_to_node_idx[out] = i
+
+    # Use BFS to find all node indices required to produce the final outputs
+    outputs_needed = set([out.name for out in model.graph.output])
+    tensors_needed = set(outputs_needed)
+    node_indices_to_keep = set()
+
+    visited = set()
+    queue = list(outputs_needed)
+    while queue:
+        tensor = queue.pop(0)
+        if tensor in visited:
+            continue
+        visited.add(tensor)
+        tensors_needed.add(tensor)
+
+        if tensor in output_to_node_idx:
+            idx = output_to_node_idx[tensor]
+            node_indices_to_keep.add(idx)
+            node = node_idx_map[idx]
+            for inp in node.input:
+                if inp and inp not in visited:
+                    queue.append(inp)
+
+    print(f'Number of nodes to keep: {len(node_indices_to_keep)}')
+
+    # Keep nodes in their original order
+    nodes_to_keep = [node_list[i] for i in sorted(node_indices_to_keep)]
+
+    while len(model.graph.node) > 0:
+        model.graph.node.pop()
+    for node in nodes_to_keep:
+        model.graph.node.append(node)
+
+    # 5. Remove unused initializers
+    initializers_needed = tensors_needed & initializer_names
+    to_remove = [init for init in model.graph.initializer if init.name not in initializers_needed]
+    for init in to_remove:
+        model.graph.initializer.remove(init)
+
+    print(f'Optimized node count: {len(model.graph.node)}')
+    print(f'Optimized initializer count: {len(model.graph.initializer)}')
+
+    # 6. Save the model
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Use onnx.save_model with size_threshold=10MB to reduce external data size
+    onnx.save_model(
+        model,
+        output_path,
+        save_as_external_data=True,
+        all_tensors_to_one_file=True,
+        location=EXTERNAL_DATA_NAME,
+        size_threshold=1024*1024*10,
+        convert_attribute=False
+    )
+
+    print(f'\nInputs: {[inp.name for inp in model.graph.input]}')
+    print(f'Outputs: {[out.name for out in model.graph.output]}')
+    print(f'\nModel saved to: {output_path}')
+
+    # Check file sizes
+    model_size = os.path.getsize(output_path) / (1024 * 1024)
+    data_path = os.path.join(output_dir, EXTERNAL_DATA_NAME)
+    data_size = os.path.getsize(data_path) / (1024 * 1024)
+    print(f'\nFile sizes:')
+    print(f'  {OUTPUT_MODEL_NAME}: {model_size:.2f} MB')
+    print(f'  {EXTERNAL_DATA_NAME}: {data_size:.2f} MB')
+
+    if data_size > 2048:
+        print(f'\n⚠️ Warning: external data exceeds 2GB ({data_size:.2f} MB)')
+    else:
+        print(f'\n✓ external data is within the 2GB limit')
+
+    # Validate the model
+    print('\nValidating model...')
+    try:
+        loaded = onnx.load(output_path)
+        onnx.checker.check_model(loaded)
+        print('✓ Model validation passed!')
+    except Exception as e:
+        print(f'✗ Validation failed: {e}')
+        return False
+
+    return True
+
+
+if __name__ == '__main__':
+    main()