Add files using upload-large-folder tool

README.md

@@ -0,0 +1,21 @@
+---
+license: apache-2.0
+tags: [onnx, onnxruntime, onnx-genai, inference-metadata, peft, lora]
+---
+# onnx-genai-example-qwen2-5-1-5b-lora-selection
+
+Private real-weight ONNX package from [`Qwen/Qwen2.5-1.5B-Instruct`](https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct/tree/989aa7980e4cf806f80c7fef2b1adb7bc71aa306) at `989aa7980e4cf806f80c7fef2b1adb7bc71aa306`, with matching PEFT adapter [`bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16`](https://huggingface.co/bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16/tree/57a4a23b934ea6c3f25615e13a6979d55c48fd68) at `57a4a23b934ea6c3f25615e13a6979d55c48fd68`. Both sources are Apache-2.0.
+
+Includes actual fp16 decoder and adapter weights, canonical metadata, tokenizer, policies, source provenance, request/output, graph report, and H200 CUDA timings. The real probe used logical rows at scales 0, 0.5, and 1.0; adapter rows changed final logits by 25.72–25.79 and generated different output from the base row. Installed ORT exposes whole-run adapter activation, so heterogeneous logical rows were executed independently and this limitation is explicit in `output.json`.
+
+## Download
+```bash
+hf download justinchuby/onnx-genai-example-qwen2-5-1-5b-lora-selection --repo-type model --local-dir ./qwen2.5-1.5b-lora-selection
+```
+## Exact runtime probe
+```bash
+cd qwen2.5-1.5b-lora-selection
+python3 evidence/probe_lora_onnx.py
+cat evidence/lora_runtime_probe.json
+```
+Requires CUDA-capable `onnxruntime-gpu`, `onnx-ir`, `transformers`, `safetensors`, `torch`, and `numpy`; exact successful versions are in `output.json`.

SOURCE_LICENSE.md

@@ -0,0 +1,4 @@
+# Source licenses
+
+- [Qwen/Qwen2.5-1.5B-Instruct](https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct/tree/989aa7980e4cf806f80c7fef2b1adb7bc71aa306): Apache-2.0.
+- [bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16](https://huggingface.co/bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16/tree/57a4a23b934ea6c3f25615e13a6979d55c48fd68): Apache-2.0 repository license tag.

adapters/code-lora-r16/adapter_config.json

@@ -0,0 +1,34 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "Qwen/Qwen2.5-1.5B-Instruct",
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_dropout": 0.05,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "v_proj",
+    "gate_proj",
+    "o_proj",
+    "down_proj",
+    "k_proj",
+    "q_proj",
+    "up_proj"
+  ],
+  "task_type": "CAUSAL_LM",
+  "use_dora": false,
+  "use_rslora": false
+}

chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# 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' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.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' }}
+{%- endif %}

evidence/build_lora_package.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import time
+from pathlib import Path
+
+from huggingface_hub import snapshot_download
+
+from mobius import (
+    attach_peft_adapter,
+    build,
+)
+from mobius.integrations.onnx_genai import write_onnx_genai_config
+
+BASE_ID = "Qwen/Qwen2.5-1.5B-Instruct"
+BASE_REVISION = "989aa7980e4cf806f80c7fef2b1adb7bc71aa306"
+ADAPTER_ID = "bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16"
+ADAPTER_REVISION = "57a4a23b934ea6c3f25615e13a6979d55c48fd68"
+OUTPUT = Path(
+    "/datadisks/disk1/justinchu/inference-metadata-catalogue/"
+    "qwen2.5-1.5b-instruct-lora-selection"
+)
+
+
+def main() -> None:
+    started = time.perf_counter()
+    OUTPUT.mkdir(parents=True, exist_ok=True)
+    cache = OUTPUT / ".build-cache"
+    adapter_source = Path(
+        snapshot_download(
+            ADAPTER_ID,
+            revision=ADAPTER_REVISION,
+            cache_dir=cache,
+            allow_patterns=[
+                "adapter_config.json",
+                "adapter_model.safetensors",
+                "README.md",
+            ],
+        )
+    )
+    adapter_config = json.loads((adapter_source / "adapter_config.json").read_text())
+    package = build(
+        BASE_ID,
+        revision=BASE_REVISION,
+        dtype="f16",
+        execution_provider="default",
+    )
+    attach_peft_adapter(
+        package,
+        adapter_source,
+        name="code-lora-r16",
+        max_adapters=2,
+        cache_max_entries=2,
+        preserve_source_format=True,
+    )
+    package.save(str(OUTPUT), progress_bar=True)
+    write_onnx_genai_config(
+        package,
+        str(OUTPUT),
+        source=BASE_ID,
+        revision=BASE_REVISION,
+    )
+
+    source_dir = OUTPUT / "sources" / "peft"
+    source_dir.mkdir(parents=True, exist_ok=True)
+    for name in ("adapter_config.json", "adapter_model.safetensors", "README.md"):
+        shutil.copy2(adapter_source / name, source_dir / name)
+    provenance = {
+        "base": {
+            "id": BASE_ID,
+            "revision": BASE_REVISION,
+            "license": "Apache-2.0",
+        },
+        "adapter": {
+            "id": ADAPTER_ID,
+            "revision": ADAPTER_REVISION,
+            "license": "Apache-2.0 (Hugging Face repository tag)",
+            "base_model_name_or_path": adapter_config["base_model_name_or_path"],
+            "rank": adapter_config["r"],
+            "alpha": adapter_config["lora_alpha"],
+            "target_count": len(package.adapter_target_manifest.targets),
+        },
+        "build": {
+            "dtype": "float16",
+            "execution_provider": "default",
+            "seconds": time.perf_counter() - started,
+            "mobius_git_sha": os.popen("git rev-parse HEAD").read().strip(),
+        },
+    }
+    (OUTPUT / "source_provenance.json").write_text(
+        json.dumps(provenance, indent=2, sort_keys=True) + "\n"
+    )
+    shutil.rmtree(cache)
+
+
+if __name__ == "__main__":
+    main()

evidence/lora_runtime_probe.json

@@ -0,0 +1,119 @@
+{
+  "assertions": {
+    "heterogeneous_outputs": true,
+    "scale_0_5_changes_logits": true,
+    "scale_1_changes_logits": true
+  },
+  "execution": {
+    "note": "The installed ORT exposes whole-run LoraAdapter activation, not the canonical row-wise parameter-overlay ABI. This probe executes the three heterogeneous logical rows independently after applying the same real PEFT deltas at each requested scale.",
+    "providers": [
+      "TensorrtExecutionProvider",
+      "CUDAExecutionProvider",
+      "CPUExecutionProvider"
+    ],
+    "runtime": "onnxruntime"
+  },
+  "request": {
+    "max_new_tokens": 12,
+    "prompt": "Write one concise C++ function that returns the larger of two integers.",
+    "rows": [
+      {
+        "adapter": null,
+        "row": 0,
+        "scale": 0.0
+      },
+      {
+        "adapter": "code-lora-r16",
+        "row": 1,
+        "scale": 0.5
+      },
+      {
+        "adapter": "code-lora-r16",
+        "row": 2,
+        "scale": 1.0
+      }
+    ]
+  },
+  "rows": [
+    {
+      "adapter": null,
+      "final_argmax_token": 1896,
+      "load_seconds": 43.908357076114044,
+      "max_abs_final_logit_delta_vs_base": 0.0,
+      "row": 0,
+      "scale": 0.0,
+      "text": " The function should be named `max_of_two` and take",
+      "token_ids": [
+        576,
+        729,
+        1265,
+        387,
+        6941,
+        1565,
+        2810,
+        3575,
+        23241,
+        63,
+        323,
+        1896
+      ],
+      "total_seconds": 59.21031142398715
+    },
+    {
+      "adapter": "code-lora-r16",
+      "final_argmax_token": 1548,
+      "load_seconds": 5.039828644832596,
+      "max_abs_final_logit_delta_vs_base": 25.716796875,
+      "row": 1,
+      "scale": 0.5,
+      "text": " #include <iostream>\nusing namespace std;\n\nint max(int",
+      "token_ids": [
+        671,
+        997,
+        366,
+        9665,
+        397,
+        970,
+        4473,
+        1460,
+        401,
+        396,
+        1932,
+        1548
+      ],
+      "total_seconds": 16.198358421912417
+    },
+    {
+      "adapter": "code-lora-r16",
+      "final_argmax_token": 1548,
+      "load_seconds": 8.739312588004395,
+      "max_abs_final_logit_delta_vs_base": 25.7861328125,
+      "row": 2,
+      "scale": 1.0,
+      "text": " #include <iostream>\nusing namespace std;\n\nint max(int",
+      "token_ids": [
+        671,
+        997,
+        366,
+        9665,
+        397,
+        970,
+        4473,
+        1460,
+        401,
+        396,
+        1932,
+        1548
+      ],
+      "total_seconds": 21.565866044955328
+    }
+  ],
+  "total_seconds": 98.45913959108293,
+  "versions": {
+    "onnx_ir": "1.0.0",
+    "onnxruntime": "1.28.0",
+    "safetensors": "0.8.0",
+    "torch": "2.8.0+cu126",
+    "transformers": "5.16.0.dev0"
+  }
+}

evidence/probe_lora_onnx.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import json
+import shutil
+import time
+from pathlib import Path
+
+import numpy as np
+import onnx_ir as ir
+import onnxruntime as ort
+import safetensors
+import torch
+import transformers
+from safetensors.numpy import load_file
+from transformers import AutoTokenizer
+
+PACKAGE = Path(__file__).resolve().parents[1]
+MODEL = PACKAGE / "model.onnx"
+ADAPTER = PACKAGE / "sources" / "peft"
+SCALES = (0.0, 0.5, 1.0)
+
+
+def _merge(scale: float, destination: Path) -> None:
+    model = ir.load(MODEL)
+    config = json.loads((ADAPTER / "adapter_config.json").read_text())
+    tensors = load_file(ADAPTER / "adapter_model.safetensors")
+    modules: dict[str, dict[str, np.ndarray]] = {}
+    for name, values in tensors.items():
+        if ".lora_A." in name:
+            module, factor = name.split(".lora_A.", 1)[0], "A"
+        elif ".lora_B." in name:
+            module, factor = name.split(".lora_B.", 1)[0], "B"
+        else:
+            continue
+        module = module.removeprefix("base_model.model.")
+        modules.setdefault(module, {})[factor] = values
+    for module, factors in modules.items():
+        parameter = model.graph.initializers[f"{module}.weight"]
+        base = parameter.const_value.numpy()
+        delta = factors["B"].astype(np.float32) @ factors["A"].astype(np.float32)
+        delta *= float(config["lora_alpha"]) / int(config["r"])
+        merged = base.astype(np.float32) + scale * delta
+        parameter.const_value = ir.tensor(
+            merged.astype(np.float16),
+            name=parameter.name,
+        )
+    ir.save(model, destination, external_data="model.onnx.data")
+
+
+def _empty_inputs(session: ort.InferenceSession, input_ids: np.ndarray):
+    batch, sequence = input_ids.shape
+    feeds: dict[str, np.ndarray] = {
+        "input_ids": input_ids,
+        "attention_mask": np.ones((batch, sequence), dtype=np.int64),
+        "position_ids": np.arange(sequence, dtype=np.int64)[None, :].repeat(batch, 0),
+    }
+    for value in session.get_inputs():
+        if value.name.startswith("past_key_values."):
+            heads = int(value.shape[1])
+            width = int(value.shape[3])
+            feeds[value.name] = np.empty((batch, heads, 0, width), dtype=np.float16)
+    return feeds
+
+
+def _generate(session, tokenizer, prompt: str, max_new_tokens: int):
+    input_ids = tokenizer(prompt, return_tensors="np").input_ids.astype(np.int64)
+    feeds = _empty_inputs(session, input_ids)
+    output_names = [value.name for value in session.get_outputs()]
+    generated: list[int] = []
+    logits = None
+    for step in range(max_new_tokens):
+        outputs = session.run(None, feeds)
+        logits = outputs[0][:, -1, :].astype(np.float32)
+        token = int(np.argmax(logits[0]))
+        generated.append(token)
+        presents = dict(zip(output_names[1:], outputs[1:]))
+        feeds = {
+            "input_ids": np.array([[token]], dtype=np.int64),
+            "attention_mask": np.ones((1, input_ids.shape[1] + step + 1), dtype=np.int64),
+            "position_ids": np.array([[input_ids.shape[1] + step]], dtype=np.int64),
+        }
+        for value in session.get_inputs():
+            if value.name.startswith("past_key_values."):
+                suffix = value.name.removeprefix("past_key_values.")
+                feeds[value.name] = presents[f"present.{suffix}"]
+    return {
+        "token_ids": generated,
+        "text": tokenizer.decode(generated),
+        "final_logits": logits[0],
+    }
+
+
+def main() -> None:
+    evidence = PACKAGE / "evidence"
+    scratch = evidence / "scratch"
+    scratch.mkdir(parents=True, exist_ok=True)
+    tokenizer = AutoTokenizer.from_pretrained(PACKAGE)
+    prompt = "Write one concise C++ function that returns the larger of two integers."
+    rows = []
+    started = time.perf_counter()
+    for scale in SCALES:
+        row_started = time.perf_counter()
+        scratch_model = scratch / "model.onnx"
+        _merge(scale, scratch_model)
+        session_started = time.perf_counter()
+        session = ort.InferenceSession(
+            str(scratch_model),
+            providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+        )
+        load_seconds = time.perf_counter() - session_started
+        result = _generate(session, tokenizer, prompt, max_new_tokens=12)
+        rows.append(
+            {
+                "row": len(rows),
+                "adapter": None if scale == 0 else "code-lora-r16",
+                "scale": scale,
+                "token_ids": result["token_ids"],
+                "text": result["text"],
+                "load_seconds": load_seconds,
+                "total_seconds": time.perf_counter() - row_started,
+                "_logits": result["final_logits"],
+            }
+        )
+        del session
+        shutil.rmtree(scratch)
+        scratch.mkdir()
+
+    base_logits = rows[0]["_logits"]
+    for row in rows:
+        logits = row.pop("_logits")
+        row["max_abs_final_logit_delta_vs_base"] = float(np.max(np.abs(logits - base_logits)))
+        row["final_argmax_token"] = int(np.argmax(logits))
+    payload = {
+        "request": {
+            "prompt": prompt,
+            "rows": [
+                {"row": row["row"], "adapter": row["adapter"], "scale": row["scale"]}
+                for row in rows
+            ],
+            "max_new_tokens": 12,
+        },
+        "execution": {
+            "runtime": "onnxruntime",
+            "providers": ort.get_available_providers(),
+            "note": (
+                "The installed ORT exposes whole-run LoraAdapter activation, not the "
+                "canonical row-wise parameter-overlay ABI. This probe executes the "
+                "three heterogeneous logical rows independently after applying the "
+                "same real PEFT deltas at each requested scale."
+            ),
+        },
+        "rows": rows,
+        "assertions": {
+            "scale_0_5_changes_logits": rows[1]["max_abs_final_logit_delta_vs_base"] > 0,
+            "scale_1_changes_logits": rows[2]["max_abs_final_logit_delta_vs_base"] > 0,
+            "heterogeneous_outputs": len({tuple(row["token_ids"]) for row in rows}) > 1,
+        },
+        "versions": {
+            "onnxruntime": ort.__version__,
+            "onnx_ir": ir.__version__,
+            "transformers": transformers.__version__,
+            "torch": torch.__version__,
+            "safetensors": safetensors.__version__,
+        },
+        "total_seconds": time.perf_counter() - started,
+    }
+    (evidence / "lora_runtime_probe.json").write_text(
+        json.dumps(payload, indent=2, sort_keys=True) + "\n"
+    )
+    shutil.rmtree(scratch)
+    if not all(payload["assertions"].values()):
+        raise RuntimeError(payload["assertions"])
+
+
+if __name__ == "__main__":
+    main()

graph_report.json

@@ -0,0 +1,7 @@
+{
+  "adapter_alpha": 32,
+  "adapter_rank": 16,
+  "adapter_targets": 196,
+  "dtype": "float16",
+  "metadata": "canonical typed workflow with parameter-adapter service"
+}

output.json

@@ -0,0 +1,97 @@
+{
+  "assertions": {
+    "heterogeneous_outputs": true,
+    "scale_0_5_changes_logits": true,
+    "scale_1_changes_logits": true
+  },
+  "rows": [
+    {
+      "adapter": null,
+      "final_argmax_token": 1896,
+      "load_seconds": 43.908357076114044,
+      "max_abs_final_logit_delta_vs_base": 0.0,
+      "row": 0,
+      "scale": 0.0,
+      "text": " The function should be named `max_of_two` and take",
+      "token_ids": [
+        576,
+        729,
+        1265,
+        387,
+        6941,
+        1565,
+        2810,
+        3575,
+        23241,
+        63,
+        323,
+        1896
+      ],
+      "total_seconds": 59.21031142398715
+    },
+    {
+      "adapter": "code-lora-r16",
+      "final_argmax_token": 1548,
+      "load_seconds": 5.039828644832596,
+      "max_abs_final_logit_delta_vs_base": 25.716796875,
+      "row": 1,
+      "scale": 0.5,
+      "text": " #include <iostream>\nusing namespace std;\n\nint max(int",
+      "token_ids": [
+        671,
+        997,
+        366,
+        9665,
+        397,
+        970,
+        4473,
+        1460,
+        401,
+        396,
+        1932,
+        1548
+      ],
+      "total_seconds": 16.198358421912417
+    },
+    {
+      "adapter": "code-lora-r16",
+      "final_argmax_token": 1548,
+      "load_seconds": 8.739312588004395,
+      "max_abs_final_logit_delta_vs_base": 25.7861328125,
+      "row": 2,
+      "scale": 1.0,
+      "text": " #include <iostream>\nusing namespace std;\n\nint max(int",
+      "token_ids": [
+        671,
+        997,
+        366,
+        9665,
+        397,
+        970,
+        4473,
+        1460,
+        401,
+        396,
+        1932,
+        1548
+      ],
+      "total_seconds": 21.565866044955328
+    }
+  ],
+  "runtime": {
+    "note": "The installed ORT exposes whole-run LoraAdapter activation, not the canonical row-wise parameter-overlay ABI. This probe executes the three heterogeneous logical rows independently after applying the same real PEFT deltas at each requested scale.",
+    "providers": [
+      "TensorrtExecutionProvider",
+      "CUDAExecutionProvider",
+      "CPUExecutionProvider"
+    ],
+    "runtime": "onnxruntime"
+  },
+  "versions": {
+    "onnx_ir": "1.0.0",
+    "onnxruntime": "1.28.0",
+    "safetensors": "0.8.0",
+    "torch": "2.8.0+cu126",
+    "transformers": "5.16.0.dev0"
+  }
+}

performance.json

@@ -0,0 +1,24 @@
+{
+  "hardware": "NVIDIA H200",
+  "rows": [
+    {
+      "load_seconds": 43.908357076114044,
+      "row": 0,
+      "scale": 0.0,
+      "total_seconds": 59.21031142398715
+    },
+    {
+      "load_seconds": 5.039828644832596,
+      "row": 1,
+      "scale": 0.5,
+      "total_seconds": 16.198358421912417
+    },
+    {
+      "load_seconds": 8.739312588004395,
+      "row": 2,
+      "scale": 1.0,
+      "total_seconds": 21.565866044955328
+    }
+  ],
+  "total_seconds": 98.45913959108293
+}

provenance.json

@@ -0,0 +1,44 @@
+{
+  "build": {
+    "dtype": "float16",
+    "execution_provider": "default",
+    "mobius_git_sha": "57c149d1845c97781ae386da5c1c93528fde8841",
+    "seconds": 133.8639017518144
+  },
+  "files": [
+    {
+      "bytes": 401469,
+      "path": "model.onnx",
+      "sha256": "2122a0c6a5876ff19bec8c207be52c2acf077a522e860aa08932cf538bb6f03d"
+    },
+    {
+      "bytes": 3095855104,
+      "path": "model.onnx.data",
+      "sha256": "bf7ff357dffe14fd28d2d26f8e897512fcde9fde74e947808c25ee7b04a70e69"
+    },
+    {
+      "bytes": 73911112,
+      "path": "sources/peft/adapter_model.safetensors",
+      "sha256": "ad84098fe32f73fb3f7acb8d8ddb178cb39717718d21d040c6bcc161d4ec8243"
+    },
+    {
+      "bytes": 729,
+      "path": "sources/peft/adapter_config.json",
+      "sha256": "e71a0adf6b79764fe0c30ec786bf3e8cb4dd42e41a53ae0fc20eb9f1d6324ceb"
+    }
+  ],
+  "sources": [
+    {
+      "adapter": {
+        "model": "bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16",
+        "revision": "57a4a23b934ea6c3f25615e13a6979d55c48fd68",
+        "source_license": "apache-2.0",
+        "source_url": "https://huggingface.co/bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16/tree/57a4a23b934ea6c3f25615e13a6979d55c48fd68"
+      },
+      "model": "Qwen/Qwen2.5-1.5B-Instruct",
+      "revision": "989aa7980e4cf806f80c7fef2b1adb7bc71aa306",
+      "source_license": "apache-2.0",
+      "source_url": "https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct/tree/989aa7980e4cf806f80c7fef2b1adb7bc71aa306"
+    }
+  ]
+}

request.json

@@ -0,0 +1,21 @@
+{
+  "max_new_tokens": 12,
+  "prompt": "Write one concise C++ function that returns the larger of two integers.",
+  "rows": [
+    {
+      "adapter": null,
+      "row": 0,
+      "scale": 0.0
+    },
+    {
+      "adapter": "code-lora-r16",
+      "row": 1,
+      "scale": 0.5
+    },
+    {
+      "adapter": "code-lora-r16",
+      "row": 2,
+      "scale": 1.0
+    }
+  ]
+}

source.json

@@ -0,0 +1,12 @@
+{
+  "adapter": {
+    "model": "bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16",
+    "revision": "57a4a23b934ea6c3f25615e13a6979d55c48fd68",
+    "source_license": "apache-2.0",
+    "source_url": "https://huggingface.co/bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16/tree/57a4a23b934ea6c3f25615e13a6979d55c48fd68"
+  },
+  "model": "Qwen/Qwen2.5-1.5B-Instruct",
+  "revision": "989aa7980e4cf806f80c7fef2b1adb7bc71aa306",
+  "source_license": "apache-2.0",
+  "source_url": "https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct/tree/989aa7980e4cf806f80c7fef2b1adb7bc71aa306"
+}

source_provenance.json

@@ -0,0 +1,22 @@
+{
+  "adapter": {
+    "alpha": 32,
+    "base_model_name_or_path": "Qwen/Qwen2.5-1.5B-Instruct",
+    "id": "bharati2324/Qwen2.5-1.5B-Instruct-Code-LoRA-r16",
+    "license": "Apache-2.0 (Hugging Face repository tag)",
+    "rank": 16,
+    "revision": "57a4a23b934ea6c3f25615e13a6979d55c48fd68",
+    "target_count": 196
+  },
+  "base": {
+    "id": "Qwen/Qwen2.5-1.5B-Instruct",
+    "license": "Apache-2.0",
+    "revision": "989aa7980e4cf806f80c7fef2b1adb7bc71aa306"
+  },
+  "build": {
+    "dtype": "float16",
+    "execution_provider": "default",
+    "mobius_git_sha": "57c149d1845c97781ae386da5c1c93528fde8841",
+    "seconds": 133.8639017518144
+  }
+}

sources/peft/README.md

@@ -0,0 +1,60 @@
+---
+base_model: Qwen/Qwen2.5-1.5B-Instruct
+library_name: peft
+license: apache-2.0
+tags:
+- trl
+- sft
+- generated_from_trainer
+model-index:
+- name: Qwen2.5-1.5B-Instruct-Code-LoRA-r16
+  results: []
+---
+
+<!-- This model card has been generated automatically according to the information the Trainer had access to. You
+should probably proofread and complete it, then remove this comment. -->
+
+# Qwen2.5-1.5B-Instruct-Code-LoRA-r16
+
+This model is a fine-tuned version of [Qwen/Qwen2.5-1.5B-Instruct](https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct) on an unknown dataset.
+
+## Model description
+
+More information needed
+
+## Intended uses & limitations
+
+More information needed
+
+## Training and evaluation data
+
+More information needed
+
+## Training procedure
+
+### Training hyperparameters
+
+The following hyperparameters were used during training:
+- learning_rate: 0.0002
+- train_batch_size: 1
+- eval_batch_size: 8
+- seed: 42
+- gradient_accumulation_steps: 4
+- total_train_batch_size: 4
+- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
+- lr_scheduler_type: cosine
+- lr_scheduler_warmup_steps: 2
+- training_steps: 100
+- mixed_precision_training: Native AMP
+
+### Training results
+
+
+
+### Framework versions
+
+- PEFT 0.13.2
+- Transformers 4.44.2
+- Pytorch 2.5.0+cu121
+- Datasets 3.0.1
+- Tokenizers 0.19.1

tokenizer_config.json

@@ -0,0 +1,207 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_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|>"
+  ],
+  "bos_token": null,
+  "chat_template": "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- messages[0]['content'] }}\n    {%- else %}\n        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}\n    {%- endif %}\n    {{- \"\\n\\n# 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>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\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\" }}\n{%- else %}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\n    {%- else %}\n        {{- '<|im_start|>system\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) or (message.role == \"assistant\" and not message.tool_calls) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {{- '<|im_start|>' + message.role }}\n        {%- if message.content %}\n            {{- '\\n' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- '\\n<tool_call>\\n{\"name\": \"' }}\n            {{- tool_call.name }}\n            {{- '\", \"arguments\": ' }}\n            {{- tool_call.arguments | tojson }}\n            {{- '}\\n</tool_call>' }}\n        {%- endfor %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- message.content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n{%- endif %}\n",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}