Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,5 @@ 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
+papers/iquest-coder-v1-logo.png filter=lfs diff=lfs merge=lfs -text
+papers/results.png filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,26 @@
+Modified MIT License 
+
+Software Copyright© 2025 IQuest Research
+
+Our only modification is that, if the Software (or any derivative works
+thereof) is used for any of your commercial products or services, you shall
+prominently display "IQuest Coder" on the user interface of such product or
+service.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+

README.md

@@ -0,0 +1,183 @@
+---
+license: other
+license_name: iquestcoder
+license_link: >-
+  https://huggingface.co/IQuestLab/IQuest-Coder-V1-40B-Instruct/blob/main/LICENSE
+language:
+  - en
+library_name: transformers
+base_model: IQuestLab/IQuest-Coder-V1-40B-Loop-Instruct
+---
+
+![Evaluation Results](./papers/iquest-coder-v1-logo.png)
+
+<p align="center">
+  📘 <a href="https://iquestlab.github.io">Blog</a >
+  &nbsp;•&nbsp;
+  📄 <a href="https://github.com/IQuestLab/IQuest-Coder-V1/blob/main/papers/IQuest_Coder_Technical_Report.pdf">Technical Report</a >
+</p >
+
+# IQuest-Coder-V1 Model Family
+
+| Model | Link |
+|-------|------|
+| IQuest-Coder-V1-40B-Base-Stage1 | [🤗 Hugging Face](https://huggingface.co/IQuestLab/IQuest-Coder-V1-40B-Base-Stage1) |
+| IQuest-Coder-V1-40B-Base | [🤗 Hugging Face](https://huggingface.co/IQuestLab/IQuest-Coder-V1-40B-Base) |
+| IQuest-Coder-V1-40B-Instruct | [🤗 Hugging Face](https://huggingface.co/IQuestLab/IQuest-Coder-V1-40B-Instruct) |
+| IQuest-Coder-V1-40B-Loop-Instruct | [🤗 Hugging Face](https://huggingface.co/IQuestLab/IQuest-Coder-V1-40B-Loop-Instruct) |
+
+[Clarification: Regarding the Performance of IQuest-Coder-V1](https://github.com/IQuestLab/IQuest-Coder-V1/issues/14#issuecomment-3705756919)
+
+## Sampling Parameters
+For the IQuest-Coder-V1-Instruct: We suggest using Temperature=0.6, TopP=0.85, TopK=20.
+
+
+## IQuest-Coder-V1 Highlights
+
+IQuest-Coder-V1 is a new family of code large language models (LLMs) designed to advance autonomous software engineering and code intelligence. Built on the innovative code-flow multi-stage training paradigm, IQuest-Coder-V1 captures the dynamic evolution of software logic, delivering state-of-the-art performance across critical dimensions:
+
+- **State-of-the-Art Performance**: Achieves leading results on SWE-Bench Verified (76.2%), BigCodeBench (49.9%), LiveCodeBench v6 (81.1%), and other major coding benchmarks, surpassing competitive models across agentic software engineering, competitive programming, and complex tool use.
+- **Code-Flow Training Paradigm**: Moving beyond static code representations, our models learn from repository evolution patterns, commit transitions, and dynamic code transformations to understand real-world software development processes.
+- **Dual Specialization Paths**: Bifurcated post-training delivers two specialized variants—Thinking models (utilizing reasoning-driven RL for complex problem-solving) and Instruct models (optimized for general coding assistance and instruction-following).
+- **Efficient Architecture**: The IQuest-Coder-V1-Loop variant introduces a recurrent mechanism that optimizes the trade-off between model capacity and deployment footprint.
+- **Native Long Context**: All models natively support up to 128K tokens without requiring additional scaling techniques.
+
+## Model Overview
+
+The IQuest-Coder-V1 series includes models ranging from 7B to 40B parameters, with both standard and Loop variants:
+
+| Model | Parameters | Layers | Hidden Size | Attention Heads (Q/KV) | Context Length |
+|-------|------------|--------|-------------|------------------------|----------------|
+| IQuest-Coder-V1-7B-Instruct | 7B | 14 | 5120 | 40/8 | 128K |
+| IQuest-Coder-V1-7B-Thinking | 7B | 14 | 5120 | 40/8 | 128K |
+| IQuest-Coder-V1-14B-Instruct | 14B | 28 | 5120 | 40/8 | 128K |
+| IQuest-Coder-V1-14B-Thinking | 14B | 28 | 5120 | 40/8 | 128K |
+| IQuest-Coder-V1-40B-Instruct | 40B | 80 | 5120 | 40/8 | 128K |
+| IQuest-Coder-V1-40B-Thinking | 40B | 80 | 5120 | 40/8 | 128K |
+| IQuest-Coder-V1-40B-Loop-Instruct | 40B | 80 (2 iterations) | 5120 | 40/8 | 128K |
+| IQuest-Coder-V1-40B-Loop-Thinking | 40B | 80 (2 iterations) | 5120 | 40/8 | 128K |
+
+**Architecture Features:**
+
+- Grouped Query Attention (GQA) for efficient inference
+- Native 128K context length support
+- Vocabulary size: 76,800 tokens
+- Loop variants use recurrent transformer design with shared parameters across two iterations
+
+For more details, please refer to our Technical Report, GitHub.
+
+## Quickstart
+
+IQuest-Coder-V1 uses custom modeling code via Hugging Face's auto_map feature. We recommend using transformers==4.56.0.
+
+### Basic Usage with Transformers
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_name = "IQuestLab/IQuest-Coder-V1-40B-Instruct"
+
+# Load the tokenizer and model
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype="auto",
+    device_map="cuda:0",
+    trust_remote_code=True,
+)
+
+# Prepare the input
+prompt = "Write a Python function to calculate the Fibonacci sequence using dynamic programming."
+messages = [
+    {"role": "user", "content": prompt}
+]
+text = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True
+)
+model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+# Generate response
+generated_ids = model.generate(
+    **model_inputs,
+    max_new_tokens=8192
+)
+generated_ids = generated_ids[0][len(model_inputs.input_ids[0]):]
+response = tokenizer.decode(generated_ids, skip_special_tokens=True)
+
+print(response)
+```
+
+### Using Thinking Models
+
+For complex reasoning tasks, use the Thinking variant:
+
+```python
+model_name = "IQuest/IQuest-Coder-V1-40B-Thinking"
+
+# The Thinking model includes explicit reasoning traces
+# Use similar code as above, but expect longer, more detailed responses
+# with step-by-step problem decomposition
+```
+
+### Deployment with vLLM
+
+For production deployment, you can use vLLM to create an OpenAI-compatible API endpoint. Please refer to the [vLLM PR](https://github.com/vllm-project/vllm/pull/31575/files) for implementation details.
+
+```bash
+vllm serve IQuestLab/IQuest-Coder-V1-40B-Instruct --tensor-parallel-size 8
+```
+
+For Thinking models with reasoning support:
+
+```bash
+vllm serve IQuestLab/IQuest-Coder-V1-40B-Thinking --reasoning-parser qwen3 --tensor-parallel-size 8
+```
+
+
+## Evaluation Results
+![Evaluation Results](./papers/results.png)
+
+## Limitations
+
+- **Reasoning vs. Efficiency Trade-off**: Thinking models provide superior reasoning but generate longer responses; Instruct models are more efficient for straightforward tasks.
+- **Code Execution**: Models generate code but do not execute it; always validate outputs in sandboxed environments.
+- **Domain Specificity**: While trained on diverse codebases, performance may vary on highly specialized or proprietary frameworks.
+- **Factuality**: Models may generate plausible but incorrect code; verify critical implementations thoroughly.
+
+## Citation
+
+If you find our work helpful, please cite:
+
+```bibtex
+@article{iquest-coder-v1-2025,
+  title={IQuest-Coder-V1 Technical Report},
+  author={IQuest Coder Team},
+  url={https://github.com/IQuestLab/IQuest-Coder-V1/blob/main/papers/IQuest_Coder_Technical_Report.pdf}
+  year={2025}
+}
+@article{codescaling,
+  title={Scaling Laws for Code: Every Programming Language Matters},
+  author={Yang, Jian and Guo, Shawn and Jing, Lin and Zhang, Wei and Liu, Aishan and Hao, Chuan and Li, Zhoujun and Zhao, Wayne Xin and Liu, Xianglong and Lv, Weifeng and others},
+  journal={arXiv preprint arXiv:2512.13472},
+  year={2025}
+}
+@article{close_the_loop,
+  title={Close the Loop: Synthesizing Infinite Tool-Use Data via Multi-Agent Role-Playing},
+  author={Yuwen Li, Wei Zhang, Zelong Huang, Mason Yang, Jiajun Wu, Shawn Guo, Huahao Hu, Lingyi Sun, Jian Yang, Mingjie Tang, Byran Dai},
+  journal={arXiv preprint arXiv:2512.23611},
+  year={2025}
+}
+@article{loopcoder,
+  title={LoopCoder: Scaling Code Intelligence via Looped Language Models},
+  author={Jian Yang, Wei Zhang, Shawn Guo, Yizhi Li, Lin Jing, Zhengmao Ye, Shark Liu, Yuyang Song, Jiajun Wu, Che Liu, T. Zheng, Siwei Wu, L. Liao, X. Ma, Chuan Hao, Ran Tao, Yan Xing, Jianzhou Wang, Mingjie Tang, Aishan Liu, Zhoujun Li, Xianglong Liu, Weifeng Lv1, Bryan Dai},
+  year={2025}
+}
+@article{swe_compress,
+  title={Context as a Tool: Context Management for Long-Horizon SWE-Agents},
+  author={hukai Liu, Jian Yang, Bo Jiang, Yizhi Li, Jinyang Guo, Xianglong Liu, Bryan Dai},
+  journal={arXiv preprint arXiv:2512.22087},
+  year={2025}
+}
+```

__init__.py

@@ -0,0 +1,26 @@
+"""IQuestLoopCoder model package."""
+
+from .configuration_iquestloopcoder import IQuestLoopCoderConfig
+from .modeling_iquestloopcoder import (
+    IQuestLoopCoderPreTrainedModel,
+    IQuestLoopCoderModel,
+    IQuestLoopCoderForCausalLM,
+    IQuestLoopCoderCache,
+)
+from .tokenization_iquestcoder import IQuestCoderTokenizer
+
+try:
+    from .tokenization_iquestcoder import IQuestCoderTokenizerFast
+except ImportError:
+    IQuestCoderTokenizerFast = None
+
+__all__ = [
+    "IQuestLoopCoderConfig",
+    "IQuestLoopCoderPreTrainedModel",
+    "IQuestLoopCoderModel",
+    "IQuestLoopCoderForCausalLM",
+    "IQuestLoopCoderCache",
+    "IQuestCoderTokenizer",
+    "IQuestCoderTokenizerFast",
+]
+

added_tokens.json

@@ -0,0 +1,29 @@
+{
+  "</think>": 75873,
+  "</tool_call>": 75877,
+  "</tool_response>": 75879,
+  "</tools>": 75875,
+  "<CLS>": 75858,
+  "<EOD>": 75860,
+  "<MASK>": 75861,
+  "<PAD>": 75862,
+  "<SEP>": 75859,
+  "<think>": 75872,
+  "<tool_call>": 75876,
+  "<tool_response>": 75878,
+  "<tools>": 75874,
+  "<|CLS|>": 75880,
+  "<|EOD|>": 75882,
+  "<|MASK|>": 75883,
+  "<|PAD|>": 75884,
+  "<|SEP|>": 75881,
+  "<|endoftext|>": 75869,
+  "<|file_sep|>": 75871,
+  "<|fim_middle|>": 75866,
+  "<|fim_pad|>": 75868,
+  "<|fim_prefix|>": 75865,
+  "<|fim_suffix|>": 75867,
+  "<|im_end|>": 75864,
+  "<|im_start|>": 75863,
+  "<|repo_name|>": 75870
+}

chat_template.jinja

@@ -0,0 +1,69 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- else %}
+        {{- 'You are LoopCoder, a helpful assistant developed by IQuest.' }}
+    {%- 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' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are LoopCoder, a helpful assistant developed by IQuest.<|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 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.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set content = message.content %}
+        {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- 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' }}
+        {{- 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 %}

config.json

@@ -0,0 +1,69 @@
+{
+  "_name_or_path": "iquestloopcoder",
+  "architectures": [
+    "IQuestLoopCoderForCausalLM"
+  ],
+  "model_type": "iquestloopcoder",
+  "vocab_size": 76800,
+  "hidden_size": 5120,
+  "intermediate_size": 27648,
+  "num_hidden_layers": 80,
+  "eos_token_id": [2, 75864, 75869],
+  "num_attention_heads": 40,
+  "num_key_value_heads": 8,
+  "quantization_config": {
+    "config_groups": {
+      "group_0": {
+        "format": "pack-quantized",
+        "input_activations": null,
+        "output_activations": null,
+        "targets": [
+          "Linear"
+        ],
+        "weights": {
+          "actorder": null,
+          "block_structure": null,
+          "dynamic": false,
+          "group_size": 32,
+          "num_bits": 4,
+          "observer": "mse",
+          "observer_kwargs": {},
+          "strategy": "group",
+          "symmetric": true,
+          "type": "int"
+        }
+      }
+    },
+    "format": "pack-quantized",
+    "global_compression_ratio": null,
+    "ignore": [
+      "lm_head"
+    ],
+    "kv_cache_scheme": null,
+    "quant_method": "compressed-tensors",
+    "quantization_status": "compressed",
+    "sparsity_config": {},
+    "transform_config": {},
+    "version": "0.12.3.a20251110"
+  },
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "max_position_embeddings": 131072,
+  "initializer_range": 0.02,
+  "rms_norm_eps": 1e-05,
+  "use_cache": true,
+  "tie_word_embeddings": false,
+  "rope_theta": 500000,
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "mlp_bias": false,
+  "loop_num": 2,
+  "loop_window_size": 64,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.56.0",
+  "auto_map": {
+    "AutoConfig": "configuration_iquestloopcoder.IQuestLoopCoderConfig",
+    "AutoModel": "modeling_iquestloopcoder.IQuestLoopCoderModel",
+    "AutoModelForCausalLM": "modeling_iquestloopcoder.IQuestLoopCoderForCausalLM"
+  }
+}

configuration_iquestloopcoder.py

@@ -0,0 +1,132 @@
+# Copyright 2024 IQuestLoopCoder Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+"""IQuestLoopCoder model configuration"""
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+
+class IQuestLoopCoderConfig(PretrainedConfig):
+    r"""
+    Configuration class for IQuestLoopCoder model.
+    
+    IQuestLoopCoder extends the standard LLaMA architecture with a loop mechanism:
+    - Loop 1: Standard attention, stores K1, V1
+    - Loop 2+: Mixed attention with gated combination of global (K1,V1) and local (K2,V2) KV
+    
+    The gate is computed as: gate = sigmoid(W @ Q + bias)
+    Mixed output = gate * Attention(Q, K1, V1) + (1 - gate) * SlidingWindowAttention(Q, K2, V2)
+    
+    Args:
+        vocab_size (`int`, *optional*, defaults to 76800):
+            Vocabulary size of the model.
+        hidden_size (`int`, *optional*, defaults to 5120):
+            Dimension of the hidden representations.
+        intermediate_size (`int`, *optional*, defaults to 27648):
+            Dimension of the MLP representations (FFN hidden size).
+        num_hidden_layers (`int`, *optional*, defaults to 80):
+            Number of hidden layers in the Transformer decoder.
+        num_attention_heads (`int`, *optional*, defaults to 40):
+            Number of attention heads for each attention layer.
+        num_key_value_heads (`int`, *optional*, defaults to 8):
+            Number of key-value heads (for GQA). If None, defaults to num_attention_heads.
+        head_dim (`int`, *optional*, defaults to 128):
+            Dimension of each attention head (hidden_size // num_attention_heads).
+        hidden_act (`str` or `function`, *optional*, defaults to `"silu"`):
+            Activation function in the MLP.
+        max_position_embeddings (`int`, *optional*, defaults to 8192):
+            Maximum sequence length.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            Standard deviation for weight initialization.
+        rms_norm_eps (`float`, *optional*, defaults to 1e-5):
+            Epsilon for RMS normalization layers.
+        use_cache (`bool`, *optional*, defaults to `True`):
+            Whether to use past key/values for generation.
+        tie_word_embeddings (`bool`, *optional*, defaults to `False`):
+            Whether to tie input and output embeddings.
+        rope_theta (`float`, *optional*, defaults to 500000.0):
+            Base value for rotary position embeddings.
+        attention_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use bias in attention layers.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            Dropout ratio for attention weights.
+        mlp_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use bias in MLP layers.
+            
+        # Loop-specific parameters
+        loop_num (`int`, *optional*, defaults to 2):
+            Number of loops through the decoder.
+        loop_window_size (`int`, *optional*, defaults to 64):
+            Window size for sliding window attention in Loop 2+.
+    """
+    
+    model_type = "iquestloopcoder"
+    keys_to_ignore_at_inference = ["past_key_values"]
+
+    def __init__(
+        self,
+        vocab_size=76800,
+        hidden_size=5120,
+        intermediate_size=27648,
+        num_hidden_layers=80,
+        num_attention_heads=40,
+        num_key_value_heads=8,
+        head_dim=128,
+        hidden_act="silu",
+        max_position_embeddings=8192,
+        initializer_range=0.02,
+        rms_norm_eps=1e-5,
+        use_cache=True,
+        pad_token_id=None,
+        bos_token_id=1,
+        eos_token_id=2,
+        tie_word_embeddings=False,
+        rope_theta=500000.0,
+        rope_scaling=None,
+        attention_bias=False,
+        attention_dropout=0.0,
+        mlp_bias=False,
+        # Loop-specific parameters
+        loop_num=2,
+        loop_window_size=64,
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        self.max_position_embeddings = max_position_embeddings
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.head_dim = head_dim
+        
+        # GQA support
+        if num_key_value_heads is None:
+            num_key_value_heads = num_attention_heads
+        self.num_key_value_heads = num_key_value_heads
+        
+        self.hidden_act = hidden_act
+        self.initializer_range = initializer_range
+        self.rms_norm_eps = rms_norm_eps
+        self.use_cache = use_cache
+        self.rope_theta = rope_theta
+        self.rope_scaling = rope_scaling
+        self.attention_bias = attention_bias
+        self.attention_dropout = attention_dropout
+        self.mlp_bias = mlp_bias
+        
+        # Loop-specific
+        self.loop_num = loop_num
+        self.loop_window_size = loop_window_size
+
+        super().__init__(
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+

generation_config.json

@@ -0,0 +1,6 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": [2, 75864, 75869],
+  "transformers_version": "4.56.0"
+}

model-00001-of-00005.safetensors

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

model-00002-of-00005.safetensors

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

model-00003-of-00005.safetensors

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

model-00004-of-00005.safetensors

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

model-00005-of-00005.safetensors

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

modeling_iquestloopcoder.py

@@ -0,0 +1,1113 @@
+"""
+Modified MIT License 
+
+Software Copyright© 2025 IQuest Research
+
+Our only modification is that, if the Software (or any derivative works
+thereof) is used for any of your commercial products or services, you shall
+prominently display "IQuest Coder" on the user interface of such product or
+service.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+import logging
+from typing import Any, Callable, Optional, Union, Tuple, List
+
+import torch
+from torch import nn
+
+from transformers.activations import ACT2FN
+from transformers.cache_utils import Cache
+from transformers.generation import GenerationMixin
+from transformers.integrations import use_kernel_forward_from_hub
+from transformers.masking_utils import (
+    create_causal_mask,
+    create_sliding_window_causal_mask,
+)
+from transformers.modeling_flash_attention_utils import FlashAttentionKwargs
+from transformers.modeling_layers import (
+    GenericForQuestionAnswering,
+    GenericForSequenceClassification,
+    GenericForTokenClassification,
+    GradientCheckpointingLayer,
+)
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPast,
+    CausalLMOutputWithPast,
+)
+from transformers.modeling_rope_utils import ROPE_INIT_FUNCTIONS, dynamic_rope_update
+from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from transformers.processing_utils import Unpack
+from transformers.utils import TransformersKwargs, auto_docstring, can_return_tuple
+from transformers.utils.generic import check_model_inputs
+from .configuration_iquestloopcoder import IQuestLoopCoderConfig
+
+
+logger = logging.getLogger(__name__)
+
+
+def needs_iquestloopcoder_cache(
+    cache: Optional[Cache]
+) -> bool:
+    # need to test more conditions
+    if cache is None:
+        return True
+    if isinstance(cache, IQuestLoopCoderCache):
+        return False
+    return True
+
+class IQuestLoopCoderMLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.intermediate_size = config.intermediate_size
+        self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
+        self.act_fn = ACT2FN[config.hidden_act]
+
+    def forward(self, x):
+        down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+        return down_proj
+
+
+def rotate_half(x):
+    """Rotates half the hidden dims of the input."""
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2 :]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def apply_rotary_pos_emb(q, k, cos, sin, position_ids=None, unsqueeze_dim=1):
+    """Applies Rotary Position Embedding to the query and key tensors.
+
+    Args:
+        q (`torch.Tensor`): The query tensor.
+        k (`torch.Tensor`): The key tensor.
+        cos (`torch.Tensor`): The cosine part of the rotary embedding.
+        sin (`torch.Tensor`): The sine part of the rotary embedding.
+        position_ids (`torch.Tensor`, *optional*):
+            Deprecated and unused.
+        unsqueeze_dim (`int`, *optional*, defaults to 1):
+            The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+            sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+            that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+            k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+            cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+            the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+    Returns:
+        `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+    """
+    cos = cos.unsqueeze(unsqueeze_dim)
+    sin = sin.unsqueeze(unsqueeze_dim)
+    q_embed = (q * cos) + (rotate_half(q) * sin)
+    k_embed = (k * cos) + (rotate_half(k) * sin)
+    return q_embed, k_embed
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+    """
+    This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+    num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+    """
+    batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+    if n_rep == 1:
+        return hidden_states
+    hidden_states = hidden_states[:, :, None, :, :].expand(
+        batch, num_key_value_heads, n_rep, slen, head_dim
+    )
+    return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+class IQuestLoopCoderCache(Cache):
+    """Cache implementation for IQuestLoopCoder that manages shared and local KV caches.
+    
+    - shared_key_cache/shared_value_cache: Stores KV from Loop 1 (global context)
+    - local_key_cache/local_value_cache: Stores KV from Loop 2+ (local window, only window_size tokens)
+    """
+    
+    def __init__(self, window_size: int, num_layers: int, loop_num: int=2):
+        # We intentionally don't call super().__init__ because the parent assumes static cache sizes.
+        self.window_size = window_size
+        self.num_layers = num_layers
+        self.loop_num = loop_num
+        
+        # Shared cache: stores Loop 1 KV (global context)   
+        self.shared_key_cache: List[Optional[torch.Tensor]] = [None] * self.num_layers
+        self.shared_value_cache: List[Optional[torch.Tensor]] = [None] * self.num_layers
+        
+        # Local cache: stores Loop 2+ KV (sliding window, only window_size tokens)
+        self.local_key_cache: List[Optional[torch.Tensor]] = [None] * (self.loop_num-1) * self.num_layers
+        self.local_value_cache: List[Optional[torch.Tensor]] = [None] * (self.loop_num-1) * self.num_layers
+        
+        self.layers: List[Any] = []  # attribute expected by HF Cache utilities
+        self._seen_tokens = 0
+    
+    def update_shared(
+        self,
+        key_states: torch.Tensor,
+        value_states: torch.Tensor,
+        layer_idx: int,
+        cache_kwargs: Optional[dict] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Update shared cache (Loop 1 KV)."""
+        # only store the first loop's kv cache
+        loop_idx = cache_kwargs.get("loop_idx", 0)
+        assert loop_idx == 0
+        if layer_idx < 0 or layer_idx >= self.num_layers:
+            raise ValueError(f"layer_idx must be in [0, {self.num_layers}), got {layer_idx}")
+        
+        cached_key = self.shared_key_cache[layer_idx]
+        cached_value = self.shared_value_cache[layer_idx]
+        
+        if cached_key is None:
+            self.shared_key_cache[layer_idx] = key_states
+            self.shared_value_cache[layer_idx] = value_states
+        else:
+            if (
+                key_states.shape[0] != cached_key.shape[0]
+                or key_states.shape[1] != cached_key.shape[1]
+                or key_states.shape[3] != cached_key.shape[3]
+            ):
+                raise ValueError(
+                    "Cached and incoming key/value tensors must match on batch, head, and head_dim dimensions."
+                )
+            assert key_states.shape[2] == 1
+            assert value_states.shape[2] == 1
+            self.shared_key_cache[layer_idx] = torch.cat([cached_key, key_states], dim=2)
+            self.shared_value_cache[layer_idx] = torch.cat([cached_value, value_states], dim=2)
+        
+        result_key = self.shared_key_cache[layer_idx]
+        result_value = self.shared_value_cache[layer_idx]
+        assert result_key is not None and result_value is not None
+        
+        # Track sequence length
+        self._seen_tokens = result_key.shape[2]
+        return result_key, result_value
+    
+    def update_local(
+        self,
+        key_states: torch.Tensor,
+        value_states: torch.Tensor,
+        layer_idx: int,
+        cache_kwargs: Optional[dict] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Update local cache (Loop 2+ KV) with sliding window management.
+        
+        Ensures the local cache always contains at most window_size tokens.
+        Local cache only stores loop_idx > 0 (i.e., loop_idx = 1, 2, ...).
+        For loop_idx = 1, cache_idx = layer_idx + 0 * num_layers = layer_idx (0 to num_layers-1)
+        For loop_idx = 2, cache_idx = layer_idx + 1 * num_layers (num_layers to 2*num_layers-1)
+        """
+        # only store the local kv cache for loop_idx > 0
+        loop_idx = cache_kwargs.get("loop_idx", 0)
+        assert loop_idx > 0, f"update_local should only be called for loop_idx > 0, got {loop_idx}"
+        if layer_idx < 0 or layer_idx >= self.num_layers:
+            raise ValueError(f"layer_idx must be in [0, {self.num_layers}), got {layer_idx}")
+        
+        # Local cache size is (loop_num-1) * num_layers
+        # loop_idx = 1 maps to indices 0 to num_layers-1
+        # loop_idx = 2 maps to indices num_layers to 2*num_layers-1
+        # So offset = (loop_idx - 1) * num_layers
+        cache_idx = layer_idx + (loop_idx - 1) * self.num_layers
+        
+        # Validate cache_idx is within bounds
+        max_cache_idx = (self.loop_num - 1) * self.num_layers
+        if cache_idx >= max_cache_idx:
+            raise IndexError(
+                f"cache_idx {cache_idx} out of range. "
+                f"loop_idx={loop_idx}, layer_idx={layer_idx}, "
+                f"max_cache_idx={max_cache_idx - 1}"
+            )
+        cached_key = self.local_key_cache[cache_idx]
+        cached_value = self.local_value_cache[cache_idx]
+        
+        if cached_key is None:
+            # First token in local cache, for prefill
+            # If prefill sequence is longer than window_size, only keep the last window_size tokens
+            seq_len = key_states.shape[2]
+            if seq_len > self.window_size:
+                # Keep only the last window_size tokens
+                start_idx = seq_len - self.window_size
+                self.local_key_cache[cache_idx] = key_states[:, :, start_idx:, :]
+                self.local_value_cache[cache_idx] = value_states[:, :, start_idx:, :]
+            else:
+                self.local_key_cache[cache_idx] = key_states
+                self.local_value_cache[cache_idx] = value_states
+        else:
+            # store the local kv cache for decode
+            if (
+                key_states.shape[0] != cached_key.shape[0]
+                or key_states.shape[1] != cached_key.shape[1]
+                or key_states.shape[3] != cached_key.shape[3]
+            ):
+                raise ValueError(
+                    "Cached and incoming key/value tensors must match on batch, head, and head_dim dimensions."
+                )
+            assert cached_value is not None
+            assert key_states.shape[2] == 1
+            assert value_states.shape[2] == 1
+            # Concatenate new tokens
+            new_key = torch.cat([cached_key, key_states], dim=2)
+            new_value = torch.cat([cached_value, value_states], dim=2)
+            
+            # Ensure the total length doesn't exceed window_size
+            total_len = new_key.shape[2]
+            if total_len > self.window_size:
+                # Keep only the last window_size tokens
+                self.local_key_cache[cache_idx] = new_key[:, :, -self.window_size:, :]
+                self.local_value_cache[cache_idx] = new_value[:, :, -self.window_size:, :]
+            else:
+                self.local_key_cache[cache_idx] = new_key
+                self.local_value_cache[cache_idx] = new_value
+        
+        result_key = self.local_key_cache[cache_idx]
+        result_value = self.local_value_cache[cache_idx]
+        assert result_key is not None and result_value is not None
+        # Ensure the result is at most window_size (can be less during prefill when sequence is shorter)
+        assert result_key.shape[2] <= self.window_size, f"Local cache size {result_key.shape[2]} exceeds window_size {self.window_size}"
+        
+        return result_key, result_value
+    
+    def get_shared(self, layer_idx: int|List[int]) -> Tuple[Optional[torch.Tensor], Optional[torch.Tensor]]:
+        """Get shared cache for some layer."""
+        if isinstance(layer_idx, list):
+            return [self.get_shared(layer_idx) for layer_idx in layer_idx]
+        if layer_idx < 0 or layer_idx >= self.num_layers:
+            raise ValueError(f"layer_idx must be in [0, {self.num_layers}), got {layer_idx}")
+        return self.shared_key_cache[layer_idx], self.shared_value_cache[layer_idx]
+    
+    def get_local(self, layer_idx: int|List[int], loop_idx: int) -> Tuple[Optional[torch.Tensor], Optional[torch.Tensor]]:
+        """Get local cache for a layer."""
+        assert loop_idx > 0, f"get_local should only be called for loop_idx > 0, got {loop_idx}"
+        if isinstance(layer_idx, list):
+            return [self.get_local(layer_idx, loop_idx) for layer_idx in layer_idx]
+        if layer_idx < 0 or layer_idx >= self.num_layers:
+            raise ValueError(f"layer_idx must be in [0, {self.num_layers}), got {layer_idx}")
+        
+        # Local cache size is (loop_num-1) * num_layers
+        # loop_idx = 1 maps to indices 0 to num_layers-1
+        # loop_idx = 2 maps to indices num_layers to 2*num_layers-1
+        # So offset = (loop_idx - 1) * num_layers
+        cache_idx = layer_idx + (loop_idx - 1) * self.num_layers
+        
+        # Validate cache_idx is within bounds
+        max_cache_idx = (self.loop_num - 1) * self.num_layers
+        if cache_idx >= max_cache_idx:
+            raise IndexError(
+                f"cache_idx {cache_idx} out of range. "
+                f"loop_idx={loop_idx}, layer_idx={layer_idx}, "
+                f"max_cache_idx={max_cache_idx - 1}"
+            )
+        
+        return self.local_key_cache[cache_idx], self.local_value_cache[cache_idx]
+    
+    def update(
+        self,
+        key_states: torch.Tensor,
+        value_states: torch.Tensor,
+        layer_idx: int,
+        cache_kwargs: Optional[dict] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Default update method (for compatibility, updates shared cache)."""
+        loop_idx = cache_kwargs.get("loop_idx", 0)
+        assert loop_idx < self.loop_num
+        if loop_idx == 0:
+            return self.update_shared(key_states, value_states, layer_idx, cache_kwargs)
+        else:
+            return self.update_local(key_states, value_states, layer_idx, cache_kwargs)
+        
+    def get_seq_length(self, layer_idx: Optional[int] = 0) -> int:
+        """Get sequence length from shared cache."""
+        if layer_idx is None:
+            layer_idx = 0
+        if layer_idx < 0 or layer_idx >= self.loop_num * self.num_layers:
+            return 0
+        cached_key = self.shared_key_cache[layer_idx]
+        if cached_key is None:
+            return 0
+        return cached_key.shape[2]
+    
+    def get_max_length(self) -> Optional[int]:
+        return None
+    
+    def get_usable_length(
+        self, new_seq_length: int, layer_idx: Optional[int] = 0
+    ) -> int:
+        return self.get_seq_length(layer_idx)
+    
+    def reorder_cache(self, beam_idx: torch.LongTensor) -> None:
+        # pass
+        raise NotImplementedError("Reorder cache for beam search is not implemented")
+        """Reorder cache for beam search.
+        
+        Reorders both shared cache (Loop 1) and local cache (Loop 2+) according to beam_idx.
+        """
+        # Reorder shared cache (Loop 1, loop_idx=0)
+        for layer_idx in range(self.num_layers):
+            if self.shared_key_cache[layer_idx] is not None:
+                device = self.shared_key_cache[layer_idx].device
+                self.shared_key_cache[layer_idx] = self.shared_key_cache[layer_idx].index_select(0, beam_idx.to(device))
+                self.shared_value_cache[layer_idx] = self.shared_value_cache[layer_idx].index_select(0, beam_idx.to(device))
+        
+        # Reorder local cache (Loop 2+, loop_idx > 0)
+        # Local cache size is (loop_num-1) * num_layers
+        for cache_idx in range(len(self.local_key_cache)):
+            if self.local_key_cache[cache_idx] is not None:
+                device = self.local_key_cache[cache_idx].device
+                self.local_key_cache[cache_idx] = self.local_key_cache[cache_idx].index_select(0, beam_idx.to(device))
+                self.local_value_cache[cache_idx] = self.local_value_cache[cache_idx].index_select(0, beam_idx.to(device))
+    
+    @property
+    def is_compileable(self) -> bool:
+        return False
+    
+    def clear(self) -> None:
+        """Clear all caches."""
+        logger.debug("Clearing IQuestLoopCoderCache")
+        self.shared_key_cache = [None] * self.num_layers
+        self.shared_value_cache = [None] * self.num_layers
+        self.local_key_cache = [None] * self.num_layers * (self.loop_num-1)
+        self.local_value_cache = [None] * self.num_layers * (self.loop_num-1)
+        self._seen_tokens = 0
+
+
+def eager_attention_forward(
+    module: nn.Module,
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    attention_mask: Optional[torch.Tensor],
+    scaling: float,
+    dropout: float = 0.0,
+    **kwargs: Unpack[TransformersKwargs],
+):
+    key_states = repeat_kv(key, module.num_key_value_groups)
+    value_states = repeat_kv(value, module.num_key_value_groups)
+
+    attn_weights = torch.matmul(query, key_states.transpose(2, 3)) * scaling
+    if attention_mask is not None:
+        causal_mask = attention_mask[:, :, :, : key_states.shape[-2]]
+        attn_weights = attn_weights + causal_mask
+
+    attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(
+        query.dtype
+    )
+    attn_weights = nn.functional.dropout(
+        attn_weights, p=dropout, training=module.training
+    )
+    attn_output = torch.matmul(attn_weights, value_states)
+    attn_output = attn_output.transpose(1, 2).contiguous()
+
+    return attn_output, attn_weights
+
+class LoopGateProjection(nn.Module):
+    """Gate projection for mixed attention in Loop 2+.
+    
+    Computes: g = sigmoid(linear(Q)) for each head independently.
+    This gate determines how much to use Loop1's KV (global) vs current loop's KV (local).
+    """
+    
+    def __init__(self, num_heads: int, head_dim: int):
+        super().__init__()
+        self.num_heads = num_heads
+        self.head_dim = head_dim
+        # Each head has its own gate: Linear(head_dim -> 1) per head
+        # Implemented as [num_heads, head_dim] weight + [num_heads] bias
+        self.weight = nn.Parameter(torch.zeros(num_heads, head_dim))
+        self.bias = nn.Parameter(torch.zeros(num_heads))
+    
+    def forward(self, query: torch.Tensor) -> torch.Tensor:
+        """Compute gate values from query tensor.
+        
+        Args:
+            query: [batch, num_heads, seq_len, head_dim]
+            
+        Returns:
+            gate: [batch, num_heads, seq_len, 1]
+        """
+        # query: [batch, num_heads, seq_len, head_dim]
+        # weight: [num_heads, head_dim]
+        # For each head h: gate_h = query[:, h, :, :] @ weight[h, :].T + bias[h]
+        # Using einsum: gate = einsum('bhsd,hd->bhs', query, weight) + bias
+        gate_logits = torch.einsum('bhsd,hd->bhs', query, self.weight)  # [batch, num_heads, seq_len]
+        gate_logits = gate_logits + self.bias[None, :, None]  # broadcast bias
+        gate = torch.sigmoid(gate_logits)
+        return gate.unsqueeze(-1)  # [batch, num_heads, seq_len, 1]
+
+class IQuestLoopCoderAttention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    def __init__(self, config: IQuestLoopCoderConfig, layer_idx: int):
+        super().__init__()
+        self.config = config
+        assert layer_idx >= 0 and layer_idx < config.num_hidden_layers
+        self.layer_idx = layer_idx
+
+        self.head_dim = getattr(
+            config, "head_dim", config.hidden_size // config.num_attention_heads
+        )
+        self.num_key_value_groups = (
+            config.num_attention_heads // config.num_key_value_heads
+        )
+        self.scaling = self.head_dim**-0.5
+        self.attention_dropout = config.attention_dropout
+        self.is_causal = True
+        self.q_proj = nn.Linear(
+            config.hidden_size, config.num_attention_heads * self.head_dim, bias=False
+        )
+        self.k_proj = nn.Linear(
+            config.hidden_size, config.num_key_value_heads * self.head_dim, bias=False
+        )
+        self.v_proj = nn.Linear(
+            config.hidden_size, config.num_key_value_heads * self.head_dim, bias=False
+        )
+        self.o_proj = nn.Linear(
+            config.num_attention_heads * self.head_dim, config.hidden_size, bias=False
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor],
+        attention_mask: Optional[torch.Tensor],
+        past_key_value: Optional[Cache] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+        loop_idx: int = 0,
+        gate_proj: Optional[LoopGateProjection] = None,
+        **kwargs: Unpack[FlashAttentionKwargs],
+    ) -> tuple[torch.Tensor, Optional[torch.Tensor], Optional[tuple[torch.Tensor]]]:
+        if loop_idx == 0:
+            return self.forward_loop1(hidden_states, loop_idx, position_embeddings, attention_mask, past_key_value, cache_position, **kwargs)
+        else:
+            return self.forward_loop2(hidden_states, loop_idx, position_embeddings, attention_mask, past_key_value, cache_position, gate_proj, **kwargs)
+        
+    def forward_loop1(
+        self, 
+        hidden_states: torch.Tensor, 
+        loop_idx: int,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor], 
+        attention_mask: Optional[torch.Tensor], 
+        past_key_value: Optional[IQuestLoopCoderCache] = None, 
+        cache_position: Optional[torch.LongTensor] = None, 
+        **kwargs: Unpack[FlashAttentionKwargs]) -> tuple[torch.Tensor, Optional[torch.Tensor], Optional[tuple[torch.Tensor]]]:
+        input_shape = hidden_states.shape[:-1]
+        hidden_shape = (*input_shape, -1, self.head_dim)
+
+        query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+        key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+        value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+        cos, sin = position_embeddings
+        query_states, key_states = apply_rotary_pos_emb(
+            query_states, key_states, cos, sin
+        )
+
+        if past_key_value is not None:
+            # sin and cos are specific to RoPE models; cache_position needed for the static cache
+            cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position, "loop_idx": loop_idx}
+            key_states, value_states = past_key_value.update(
+                key_states,
+                value_states,
+                self.layer_idx,
+                cache_kwargs,
+            )
+
+        attention_interface: Callable = eager_attention_forward
+        if self.config._attn_implementation != "eager":
+            attention_interface = ALL_ATTENTION_FUNCTIONS[
+                self.config._attn_implementation
+            ]
+
+        attn_output, attn_weights = attention_interface(
+            self,
+            query_states,
+            key_states,
+            value_states,
+            attention_mask,
+            dropout=0.0 if not self.training else self.attention_dropout,
+            scaling=self.scaling,
+            **kwargs,
+        )
+
+        attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+        attn_output = self.o_proj(attn_output)
+        return attn_output, (attn_weights)
+
+
+    def forward_loop2(
+        self, 
+        hidden_states: torch.Tensor, 
+        loop_idx: int,
+        position_embeddings: tuple[torch.Tensor, torch.Tensor], 
+        attention_mask: Optional[torch.Tensor], 
+        past_key_value: Optional[IQuestLoopCoderCache] = None, 
+        cache_position: Optional[torch.LongTensor] = None, 
+        gate_proj: Optional[LoopGateProjection] = None,
+        **kwargs: Unpack[FlashAttentionKwargs]) -> tuple[torch.Tensor, Optional[torch.Tensor], Optional[tuple[torch.Tensor]]]:
+        
+        input_shape = hidden_states.shape[:-1]
+        hidden_shape = (*input_shape, -1, self.head_dim)
+
+        query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+        key_states_local = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+        value_states_local = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+        cos, sin = position_embeddings
+        query_states, key_states_local = apply_rotary_pos_emb(
+            query_states, key_states_local, cos, sin
+        )
+
+        key_states_share, value_states_share = None, None
+        if past_key_value is not None:
+            # get key_share, value_share from past_key_value
+            cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position, "loop_idx": loop_idx}
+            key_states_share, value_states_share = past_key_value.get_shared(self.layer_idx)
+            key_states_local, value_states_local = past_key_value.update(
+                key_states_local,
+                value_states_local,
+                self.layer_idx,
+                cache_kwargs,
+            )
+
+        attention_interface: Callable = eager_attention_forward
+        if self.config._attn_implementation != "eager":
+            attention_interface = ALL_ATTENTION_FUNCTIONS[
+                self.config._attn_implementation
+            ]
+        
+        # Create masks for global and local attention
+        # Global attention: full causal mask (can see all tokens in shared cache)
+        # Local attention: causal mask for local window (can only see window_size tokens in local cache)
+        attention_mask_global = attention_mask  # Use full causal mask for global attention
+        
+        # For local attention, create a mask that matches the local cache size
+        # The local cache already contains only the last window_size tokens,
+        # so we need a causal mask that allows attention within this window
+        attention_mask_local = None
+        if key_states_local is not None and value_states_local is not None:
+            # Local cache has shape [batch, num_heads, local_seq_len, head_dim]
+            # where local_seq_len <= window_size
+            local_seq_len = key_states_local.shape[2]
+            bsz = query_states.shape[0]
+            q_len = query_states.shape[2]
+            
+            # Create a causal mask for local attention
+            # This allows each query position to attend to all positions up to and including itself
+            # within the local window (which is already the last window_size tokens)
+            device = query_states.device
+            dtype = query_states.dtype
+            
+            if attention_mask is not None:
+                # If we have a global mask, we need to adapt it for local attention
+                # The global mask shape is [batch, 1, q_len, global_kv_len]
+                # For local attention, we only need the last local_seq_len positions
+                global_kv_len = attention_mask.shape[-1]
+                
+                if global_kv_len >= local_seq_len:
+                    # Extract the last local_seq_len columns from the global mask
+                    # This represents attention to the last window_size tokens
+                    attention_mask_local = attention_mask[..., -local_seq_len:]
+                else:
+                    # If global mask is shorter than local_seq_len, create a simple causal mask
+                    # This can happen during prefill when local cache is being built
+                    attention_mask_local = torch.triu(
+                        torch.ones((q_len, local_seq_len), device=device, dtype=dtype) * float("-inf"),
+                        diagonal=1
+                    ).unsqueeze(0).expand(bsz, -1, -1, -1)  # [batch, 1, q_len, local_seq_len]
+            else:
+                # No global mask provided, create a simple causal mask for local attention
+                # This allows full attention within the local window (causal)
+                attention_mask_local = torch.triu(
+                    torch.ones((q_len, local_seq_len), device=device, dtype=dtype) * float("-inf"),
+                    diagonal=1
+                ).unsqueeze(0).expand(bsz, -1, -1, -1)  # [batch, 1, q_len, local_seq_len]
+        
+        # global attn: attend to all tokens in shared cache
+        attn_output_global, attn_weights_global = attention_interface(
+            self,
+            query_states,
+            key_states_share,
+            value_states_share,
+            attention_mask_global,
+            dropout=0.0 if not self.training else self.attention_dropout,
+            scaling=self.scaling,
+            **kwargs,
+        )
+
+        # local attn: attend only to tokens in local cache (window_size)
+        attn_output_local, attn_weights_local = attention_interface(
+            self,
+            query_states,
+            key_states_local,
+            value_states_local,
+            attention_mask_local,
+            dropout=0.0 if not self.training else self.attention_dropout,
+            scaling=self.scaling,
+            **kwargs,
+        )
+
+        # attention_interface returns [batch, seq_len, num_heads, head_dim] for eager_attention_forward
+        # but Flash Attention might return [batch, num_heads, seq_len, head_dim]
+        # We need [batch, num_heads, seq_len, head_dim] to match gate shape
+        q_len = query_states.shape[2]  # Query sequence length
+        num_heads = query_states.shape[1]
+        
+        # Normalize attn_output_global to [batch, num_heads, q_len, head_dim]
+        if attn_output_global.dim() == 4:
+            # Check if shape is [batch, seq_len, num_heads, head_dim] (eager) or [batch, num_heads, seq_len, head_dim] (flash)
+            if attn_output_global.shape[1] == q_len:
+                # Shape is [batch, seq_len, num_heads, head_dim], transpose to [batch, num_heads, seq_len, head_dim]
+                attn_output_global = attn_output_global.transpose(1, 2)
+            # Ensure sequence length matches query length (take first q_len tokens)
+            if attn_output_global.shape[2] > q_len:
+                attn_output_global = attn_output_global[:, :, :q_len, :]
+            elif attn_output_global.shape[2] < q_len:
+                # This shouldn't happen, but handle it gracefully
+                raise ValueError(f"attn_output_global seq_len {attn_output_global.shape[2]} < q_len {q_len}")
+        
+        # Normalize attn_output_local to [batch, num_heads, q_len, head_dim]
+        if attn_output_local.dim() == 4:
+            # Check if shape is [batch, seq_len, num_heads, head_dim] (eager) or [batch, num_heads, seq_len, head_dim] (flash)
+            if attn_output_local.shape[1] == q_len:
+                # Shape is [batch, seq_len, num_heads, head_dim], transpose to [batch, num_heads, seq_len, head_dim]
+                attn_output_local = attn_output_local.transpose(1, 2)
+            # Ensure sequence length matches query length (take first q_len tokens)
+            if attn_output_local.shape[2] > q_len:
+                attn_output_local = attn_output_local[:, :, :q_len, :]
+            elif attn_output_local.shape[2] < q_len:
+                # This shouldn't happen, but handle it gracefully
+                raise ValueError(f"attn_output_local seq_len {attn_output_local.shape[2]} < q_len {q_len}")
+
+        assert gate_proj is not None
+        gate = gate_proj(query_states)  # [batch, num_heads, seq_len, 1]
+        mixed_attn_output = attn_output_local * (1 - gate) + attn_output_global * gate
+
+        mixed_attn_output = mixed_attn_output.reshape(*input_shape, -1).contiguous()
+        mixed_attn_output = self.o_proj(mixed_attn_output)
+        return mixed_attn_output, (attn_weights_global, attn_weights_local, attn_output_global, attn_output_local, gate)
+
+
+@use_kernel_forward_from_hub("RMSNorm")
+class IQuestLoopCoderRMSNorm(nn.Module):
+    def __init__(self, hidden_size, eps=1e-6):
+        """
+        IQuestLoopCoderRMSNorm is equivalent to T5LayerNorm
+        """
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+
+    def extra_repr(self):
+        return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"
+
+
+class IQuestLoopCoderDecoderLayer(GradientCheckpointingLayer):
+    def __init__(self, config: IQuestLoopCoderConfig, layer_idx: int):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+
+        self.self_attn = IQuestLoopCoderAttention(config=config, layer_idx=layer_idx)
+
+        self.mlp = IQuestLoopCoderMLP(config)
+        self.input_layernorm = IQuestLoopCoderRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.post_attention_layernorm = IQuestLoopCoderRMSNorm(
+            config.hidden_size, eps=config.rms_norm_eps
+        )
+        self.layer_idx = layer_idx
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        loop_idx: int = 0,
+        gate_proj: Optional[LoopGateProjection] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Cache] = None,
+        use_cache: Optional[bool] = False,
+        cache_position: Optional[torch.LongTensor] = None,
+        position_embeddings: Optional[
+            tuple[torch.Tensor, torch.Tensor]
+        ] = None,  # necessary, but kept here for BC
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple[torch.Tensor]:
+        residual = hidden_states
+        hidden_states = self.input_layernorm(hidden_states)
+        # Self Attention
+        hidden_states, _ = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_value=past_key_value,
+            use_cache=use_cache,
+            cache_position=cache_position,
+            loop_idx=loop_idx,
+            position_embeddings=position_embeddings,
+            gate_proj=gate_proj if loop_idx > 0 else None,
+            **kwargs,
+        )
+
+        hidden_states = residual + hidden_states
+        
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+        return hidden_states
+
+
+@auto_docstring
+class IQuestLoopCoderPreTrainedModel(PreTrainedModel):
+    config: IQuestLoopCoderConfig
+    base_model_prefix = "model"
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["IQuestLoopCoderDecoderLayer"]
+    _skip_keys_device_placement = ["past_key_values"]
+    _supports_flash_attn = True
+    _supports_sdpa = True
+    _supports_flex_attn = True
+
+    _can_compile_fullgraph = True
+    _supports_attention_backend = True
+    _can_record_outputs = {
+        "hidden_states": IQuestLoopCoderDecoderLayer,
+        "attentions": IQuestLoopCoderAttention,
+    }
+
+    # Important for inference with `device_map` / low_cpu_mem_usage:
+    # Avoid initializing parameters that are not present in the checkpoint.
+    # Those should keep their constructor-time initialization (e.g. zeros for LoopGateProjection),
+    # instead of being materialized from meta/empty tensors which can contain NaNs.
+    def _init_weights(self, module: nn.Module) -> None:
+        return
+
+
+class IQuestLoopCoderRotaryEmbedding(nn.Module):
+    def __init__(self, config: IQuestLoopCoderConfig, device=None):
+        super().__init__()
+        # BC: "rope_type" was originally "type"
+        if hasattr(config, "rope_scaling") and isinstance(config.rope_scaling, dict):
+            self.rope_type = config.rope_scaling.get(
+                "rope_type", config.rope_scaling.get("type")
+            )
+        else:
+            self.rope_type = "default"
+        self.max_seq_len_cached = config.max_position_embeddings
+        self.original_max_seq_len = config.max_position_embeddings
+
+        self.config = config
+        self.rope_init_fn = ROPE_INIT_FUNCTIONS[self.rope_type]
+
+        inv_freq, self.attention_scaling = self.rope_init_fn(self.config, device)
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+        self.original_inv_freq = self.inv_freq
+
+    @torch.no_grad()
+    @dynamic_rope_update  # power user: used with advanced RoPE types (e.g. dynamic rope)
+    def forward(self, x, position_ids):
+        inv_freq_expanded = (
+            self.inv_freq[None, :, None]
+            .float()
+            .expand(position_ids.shape[0], -1, 1)
+            .to(x.device)
+        )
+        position_ids_expanded = position_ids[:, None, :].float()
+
+        device_type = (
+            x.device.type
+            if isinstance(x.device.type, str) and x.device.type != "mps"
+            else "cpu"
+        )
+        with torch.autocast(device_type=device_type, enabled=False):  # Force float32
+            freqs = (
+                inv_freq_expanded.float() @ position_ids_expanded.float()
+            ).transpose(1, 2)
+            emb = torch.cat((freqs, freqs), dim=-1)
+            cos = emb.cos() * self.attention_scaling
+            sin = emb.sin() * self.attention_scaling
+
+        return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype)
+
+
+@auto_docstring
+class IQuestLoopCoderModel(IQuestLoopCoderPreTrainedModel):
+    def __init__(self, config: IQuestLoopCoderConfig):
+        super().__init__(config)
+        self.padding_idx = config.pad_token_id
+        self.vocab_size = config.vocab_size
+
+        self.embed_tokens = nn.Embedding(
+            config.vocab_size, config.hidden_size, self.padding_idx
+        )
+        self.layers = nn.ModuleList(
+            [
+                IQuestLoopCoderDecoderLayer(config, layer_idx)
+                for layer_idx in range(config.num_hidden_layers)
+            ]
+        )
+        self.norm = IQuestLoopCoderRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.rotary_emb = IQuestLoopCoderRotaryEmbedding(config=config)
+        self.gradient_checkpointing = False
+        self.loop_num = getattr(self.config, "loop_num", 2)
+        self.loop_window_size = getattr(self.config, "loop_window_size", 64)
+
+        # Gate projections for Loop 2+ (one per layer)
+        self.gate_projections = nn.ModuleList([
+            LoopGateProjection(config.num_attention_heads, config.head_dim)
+            for _ in range(config.num_hidden_layers)
+        ])
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @check_model_inputs
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[Cache] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        use_cache: Optional[bool] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> BaseModelOutputWithPast:
+
+        if (input_ids is None) ^ (inputs_embeds is not None):
+            raise ValueError(
+                "You must specify exactly one of input_ids or inputs_embeds"
+            )
+
+        if inputs_embeds is None:
+            inputs_embeds = self.embed_tokens(input_ids)
+
+        if use_cache is None:
+            use_cache = self.config.use_cache
+
+        if use_cache:
+            if needs_iquestloopcoder_cache(past_key_values):
+                past_key_values = IQuestLoopCoderCache(self.loop_window_size, self.config.num_hidden_layers, self.loop_num)
+
+        if cache_position is None:
+            past_seen_tokens = (
+                past_key_values.get_seq_length() if past_key_values is not None else 0
+            )
+            cache_position = torch.arange(
+                past_seen_tokens,
+                past_seen_tokens + inputs_embeds.shape[1],
+                device=inputs_embeds.device,
+            )
+
+        if position_ids is None:
+            position_ids = cache_position.unsqueeze(0)
+
+        # It may already have been prepared by e.g. `generate`
+        if not isinstance(causal_mask_mapping := attention_mask, dict):
+            # Prepare mask arguments
+            mask_kwargs = {
+                "config": self.config,
+                "input_embeds": inputs_embeds,
+                "attention_mask": attention_mask,
+                "cache_position": cache_position,
+                "past_key_values": past_key_values,
+                "position_ids": position_ids,
+            }
+            # Create the full causal mask for all layers
+            # All layers use full_attention (no sliding window layers)
+            full_attention_mask = create_causal_mask(**mask_kwargs)
+            causal_mask_mapping = {
+                "full_attention": full_attention_mask,
+            }
+
+        hidden_states = inputs_embeds
+
+        # create position embeddings to be shared across the decoder layers
+        position_embeddings = self.rotary_emb(hidden_states, position_ids)
+        hidden_states_list = []
+
+        for loop_idx in range(self.loop_num):
+            # For each loop, use the full_attention mask
+            # Loop 1: uses full_attention mask directly
+            # Loop 2+: forward_loop2 will create local mask internally, but uses full_attention mask for global attention
+            loop_attention_mask = causal_mask_mapping["full_attention"]
+            
+            for layer_idx, decoder_layer in enumerate(self.layers[: self.config.num_hidden_layers]):
+                hidden_states = decoder_layer(
+                    hidden_states,
+                    loop_idx,
+                    gate_proj=self.gate_projections[layer_idx] if loop_idx > 0 else None,
+                    attention_mask=loop_attention_mask,
+                    position_ids=position_ids,
+                    past_key_value=past_key_values,
+                    use_cache=use_cache,
+                    cache_position=cache_position,
+                    position_embeddings=position_embeddings,
+                    **kwargs,
+                )
+            if loop_idx < self.loop_num - 1:
+                hidden_states_list.append(hidden_states)
+
+        hidden_states = self.norm(hidden_states)
+        hidden_states_list.append(hidden_states)
+        
+        return (
+            BaseModelOutputWithPast(
+                last_hidden_state=hidden_states,
+                past_key_values=past_key_values if use_cache else None,
+            ),
+            hidden_states_list,
+        )
+
+
+@auto_docstring
+class IQuestLoopCoderForCausalLM(IQuestLoopCoderPreTrainedModel, GenerationMixin):
+    _tied_weights_keys = ["lm_head.weight"]
+    _tp_plan = {"lm_head": "colwise_rep"}
+    _pp_plan = {"lm_head": (["hidden_states"], ["logits"])}
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.model = IQuestLoopCoderModel(config)
+        self.vocab_size = config.vocab_size
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        # 分块大小配置
+        self.chunk_size = getattr(config, "chunk_size", 2)  # 默认分块大小为2
+
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.model.embed_tokens
+
+    def set_input_embeddings(self, value):
+        self.model.embed_tokens = value
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head = new_embeddings
+
+    def set_decoder(self, decoder):
+        self.model = decoder
+
+    def get_decoder(self):
+        return self.model
+
+    @can_return_tuple
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[Cache] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+        logits_to_keep: Union[int, torch.Tensor] = 0,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> CausalLMOutputWithPast:
+
+        outputs, hidden_states_list = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            cache_position=cache_position,
+            **kwargs,
+        )
+        slice_indices = (
+            slice(-logits_to_keep, None)
+            if isinstance(logits_to_keep, int)
+            else logits_to_keep
+        )
+
+        def _select_token_positions(tensor: torch.Tensor) -> torch.Tensor:
+            if isinstance(slice_indices, slice):
+                return tensor[:, slice_indices, ...]
+            if isinstance(slice_indices, torch.Tensor):
+                return tensor.index_select(1, slice_indices.to(tensor.device))
+            raise TypeError(
+                f"Unsupported index type for logits_to_keep: {type(slice_indices)}"
+            )
+
+        stacked_exit_pdf = None
+
+        expected_logits_cache: Optional[torch.Tensor] = None
+
+        def compute_expected_logits() -> Optional[torch.Tensor]:
+            nonlocal expected_logits_cache
+            if expected_logits_cache is not None:
+                return expected_logits_cache
+            if stacked_exit_pdf is None or not hidden_states_list:
+                return None
+            token_exit_pdf = _select_token_positions(stacked_exit_pdf)
+            expected_logits = None
+            for step_idx, hidden in enumerate(hidden_states_list):
+                step_hidden = _select_token_positions(hidden)
+                step_logits = self.lm_head(step_hidden)
+                weight = (
+                    token_exit_pdf[..., step_idx].unsqueeze(-1).to(step_logits.dtype)
+                )
+                expected_logits = (
+                    step_logits * weight
+                    if expected_logits is None
+                    else expected_logits + step_logits * weight
+                )
+            expected_logits_cache = expected_logits
+            return expected_logits_cache
+
+        logits: Optional[torch.Tensor] = None
+        loss: Optional[torch.Tensor] = None
+
+        hidden_states = outputs.last_hidden_state
+        logits = self.lm_head(hidden_states)
+        logits = logits.float()
+
+        if labels is not None:
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            loss_fct = nn.CrossEntropyLoss()
+            shift_logits = shift_logits.view(-1, self.config.vocab_size)
+            shift_labels = shift_labels.view(-1)
+            shift_labels = shift_labels.to(shift_logits.device)
+            loss = loss_fct(shift_logits, shift_labels)
+
+        result = CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+        return result

recipe.yaml

@@ -0,0 +1,35 @@
+default_stage:
+  default_modifiers:
+    AWQModifier:
+      config_groups:
+        group_0:
+          targets: [Linear]
+          weights:
+            num_bits: 4
+            type: int
+            symmetric: true
+            group_size: 32
+            strategy: group
+            block_structure: null
+            dynamic: false
+            actorder: null
+            scale_dtype: null
+            zp_dtype: null
+            observer: mse
+            observer_kwargs: {}
+          input_activations: null
+          output_activations: null
+          format: null
+      targets: [Linear]
+      ignore: [model.embed_tokens, 're:.*gate_projections.*', model.norm, lm_head, 're:.*rotary_emb.*']
+      mappings:
+      - smooth_layer: re:.*input_layernorm$
+        balance_layers: ['re:.*q_proj$', 're:.*k_proj$', 're:.*v_proj$']
+      - smooth_layer: re:.*v_proj$
+        balance_layers: ['re:.*o_proj$']
+      - smooth_layer: re:.*post_attention_layernorm$
+        balance_layers: ['re:.*gate_proj$', 're:.*up_proj$']
+      - smooth_layer: re:.*up_proj$
+        balance_layers: ['re:.*down_proj$']
+      duo_scaling: true
+      n_grid: 20

special_tokens_map.json

@@ -0,0 +1,48 @@
+{
+  "additional_special_tokens": [
+    "<|CLS|>",
+    "<|SEP|>",
+    "<|EOD|>",
+    "<|MASK|>",
+    "<|PAD|>",
+    "<|fim_prefix|>",
+    "<|fim_middle|>",
+    "<|fim_suffix|>",
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|fim_pad|>",
+    "<|endoftext|>",
+    "<|repo_name|>",
+    "<|file_sep|>",
+    "<think>",
+    "</think>"
+  ],
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": true
+  }
+}

tokenization_iquestcoder.py

@@ -0,0 +1,552 @@
+"""Tokenization classes for IQuestCoder."""
+
+import os
+from shutil import copyfile
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import sentencepiece as spm
+
+from transformers.tokenization_utils import AddedToken, PreTrainedTokenizer
+from transformers.utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+VOCAB_FILES_NAMES = {"vocab_file": "tokenizer.model"}
+
+PRETRAINED_VOCAB_FILES_MAP = {
+    "vocab_file": {},
+    "tokenizer_file": {},
+}
+PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {}
+
+
+
+class IQuestCoderTokenizer(PreTrainedTokenizer):
+
+    vocab_files_names = VOCAB_FILES_NAMES
+    pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
+    max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
+    model_input_names = ["input_ids", "attention_mask"]
+
+    def __init__(
+        self,
+        vocab_file,
+        unk_token="<unk>",
+        bos_token="<s>",
+        eos_token="</s>",
+        pad_token=None,
+        sp_model_kwargs: Optional[Dict[str, Any]] = None,
+        add_bos_token=True,
+        add_eos_token=False,
+        clean_up_tokenization_spaces=False,
+        add_prefix_space=False,
+        legacy=None,
+        use_default_system_prompt=False,
+        chat_template=None,
+        **kwargs,
+    ):
+        self.sp_model_kwargs = {} if sp_model_kwargs is None else sp_model_kwargs
+        bos_token = AddedToken(bos_token, lstrip=False, rstrip=False) if isinstance(bos_token, str) else bos_token
+        eos_token = AddedToken(eos_token, lstrip=False, rstrip=False) if isinstance(eos_token, str) else eos_token
+        unk_token = AddedToken(unk_token, lstrip=False, rstrip=False) if isinstance(unk_token, str) else unk_token
+        pad_token = AddedToken(pad_token, lstrip=False, rstrip=False) if isinstance(pad_token, str) else pad_token
+        
+        # Legacy behavior handling
+        if legacy is None:
+            logger.warning_once(
+                f"You are using the default legacy behaviour of the {self.__class__.__name__}. This is"
+                " expected, and simply means that the `legacy` (previous) behavior will be used so nothing changes for you."
+                " If you want to use the new behaviour, set `legacy=False`. This should only be set if you understand what it"
+                " means, and thoroughly read the reason why this was added as explained in"
+                " https://github.com/huggingface/transformers/pull/24565"
+            )
+            legacy = True
+        
+        self.legacy = legacy
+        self.vocab_file = vocab_file
+        self.add_bos_token = add_bos_token
+        self.add_eos_token = add_eos_token
+        self.add_prefix_space = add_prefix_space
+        self.use_default_system_prompt = use_default_system_prompt
+        self.sp_model = spm.SentencePieceProcessor(**self.sp_model_kwargs)
+        self.sp_model.Load(vocab_file)
+        
+
+        
+        super().__init__(
+            bos_token=bos_token,
+            eos_token=eos_token,
+            unk_token=unk_token,
+            pad_token=pad_token,
+            add_bos_token=add_bos_token,
+            add_eos_token=add_eos_token,
+            sp_model_kwargs=self.sp_model_kwargs,
+            clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+            add_prefix_space=add_prefix_space,
+            legacy=legacy,
+            use_default_system_prompt=use_default_system_prompt,
+            chat_template=chat_template,
+            **kwargs,
+        )
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state["sp_model"] = None
+        return state
+
+    def __setstate__(self, d):
+        self.__dict__ = d
+        self.sp_model = spm.SentencePieceProcessor(**self.sp_model_kwargs)
+        self.sp_model.Load(self.vocab_file)
+
+    @property
+    def vocab_size(self) -> int:
+        """Returns the vocabulary size."""
+        return self.sp_model.get_piece_size()
+
+    def get_vocab(self) -> Dict[str, int]:
+        """Returns the vocabulary as a dictionary of token to index."""
+        vocab = {self.convert_ids_to_tokens(i): i for i in range(self.vocab_size)}
+        vocab.update(self.added_tokens_encoder)
+        return vocab
+
+    def _tokenize(self, text: str) -> List[str]:
+        """
+        Tokenize a string.
+        
+        Args:
+            text (`str`): The text to tokenize.
+            
+        Returns:
+            `List[str]`: The list of tokens.
+        """
+        if self.add_prefix_space:
+            text = " " + text
+            
+        if self.legacy:
+            return self.sp_model.encode(text, out_type=str)
+        
+        # Non-legacy behavior: handle special tokens properly
+        return self.sp_model.encode(text, out_type=str)
+
+    def _convert_token_to_id(self, token: str) -> int:
+        """Converts a token (str) to an id using the vocab."""
+        return self.sp_model.piece_to_id(token)
+
+    def _convert_id_to_token(self, index: int) -> str:
+        """Converts an index (integer) to a token (str) using the vocab."""
+        token = self.sp_model.IdToPiece(index)
+        return token
+
+    def convert_tokens_to_string(self, tokens: List[str]) -> str:
+        """
+        Converts a sequence of tokens (strings) to a single string.
+        
+        This method handles special tokens separately to ensure they are not
+        decoded using the SentencePiece model.
+        
+        Args:
+            tokens (`List[str]`): The list of tokens to convert.
+            
+        Returns:
+            `str`: The decoded string.
+        """
+        current_sub_tokens = []
+        out_string = ""
+        prev_is_special = False
+        for i, token in enumerate(tokens):
+            # make sure that special tokens are not decoded using sentencepiece model
+            if token in self.all_special_tokens:
+                if not prev_is_special and i != 0:
+                    out_string += " "
+                out_string += self.sp_model.decode(current_sub_tokens) + token
+                prev_is_special = True
+                current_sub_tokens = []
+            else:
+                current_sub_tokens.append(token)
+                prev_is_special = False
+        out_string += self.sp_model.decode(current_sub_tokens)
+        return out_string
+
+    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:
+        """
+        Save the vocabulary and special tokens file to a directory.
+        
+        Args:
+            save_directory (`str`):
+                The directory in which to save the vocabulary.
+            filename_prefix (`str`, *optional*):
+                An optional prefix to add to the named of the saved files.
+                
+        Returns:
+            `Tuple(str)`: Paths to the files saved.
+        """
+        if not os.path.isdir(save_directory):
+            logger.error(f"Vocabulary path ({save_directory}) should be a directory")
+            return
+        out_vocab_file = os.path.join(
+            save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]
+        )
+
+        if os.path.abspath(self.vocab_file) != os.path.abspath(out_vocab_file) and os.path.isfile(self.vocab_file):
+            copyfile(self.vocab_file, out_vocab_file)
+        elif not os.path.isfile(self.vocab_file):
+            with open(out_vocab_file, "wb") as fi:
+                content_spiece_model = self.sp_model.serialized_model_proto()
+                fi.write(content_spiece_model)
+
+        return (out_vocab_file,)
+
+    def build_inputs_with_special_tokens(
+        self, 
+        token_ids_0: List[int], 
+        token_ids_1: Optional[List[int]] = None
+    ) -> List[int]:
+        """
+        Build model inputs from a sequence or a pair of sequences for sequence classification tasks by concatenating
+        and adding special tokens.
+        
+        An IQuestCoder sequence has the following format:
+        
+        - single sequence: `<s> X </s>` (if add_eos_token is True) or `<s> X` (default)
+        - pair of sequences: `<s> A </s> <s> B </s>` (if add_eos_token is True) or `<s> A <s> B` (default)
+        
+        Args:
+            token_ids_0 (`List[int]`):
+                List of IDs to which the special tokens will be added.
+            token_ids_1 (`List[int]`, *optional*):
+                Optional second list of IDs for sequence pairs.
+                
+        Returns:
+            `List[int]`: List of input IDs with the appropriate special tokens.
+        """
+        bos_token_id = [self.bos_token_id] if self.add_bos_token else []
+        eos_token_id = [self.eos_token_id] if self.add_eos_token else []
+
+        output = bos_token_id + token_ids_0 + eos_token_id
+
+        if token_ids_1 is not None:
+            output = output + bos_token_id + token_ids_1 + eos_token_id
+
+        return output
+
+    def get_special_tokens_mask(
+        self, 
+        token_ids_0: List[int], 
+        token_ids_1: Optional[List[int]] = None, 
+        already_has_special_tokens: bool = False
+    ) -> List[int]:
+        """
+        Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
+        special tokens using the tokenizer `prepare_for_model` method.
+        
+        Args:
+            token_ids_0 (`List[int]`):
+                List of IDs.
+            token_ids_1 (`List[int]`, *optional*):
+                Optional second list of IDs for sequence pairs.
+            already_has_special_tokens (`bool`, *optional*, defaults to `False`):
+                Whether or not the token list is already formatted with special tokens for the model.
+                
+        Returns:
+            `List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
+        """
+        if already_has_special_tokens:
+            return super().get_special_tokens_mask(
+                token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
+            )
+
+        bos_token_id = [1] if self.add_bos_token else []
+        eos_token_id = [1] if self.add_eos_token else []
+
+        if token_ids_1 is None:
+            return bos_token_id + ([0] * len(token_ids_0)) + eos_token_id
+        return (
+            bos_token_id
+            + ([0] * len(token_ids_0))
+            + eos_token_id
+            + bos_token_id
+            + ([0] * len(token_ids_1))
+            + eos_token_id
+        )
+
+    def create_token_type_ids_from_sequences(
+        self, 
+        token_ids_0: List[int], 
+        token_ids_1: Optional[List[int]] = None
+    ) -> List[int]:
+        """
+        Create a mask from the two sequences passed to be used in a sequence-pair classification task.
+        
+        An IQuestCoder sequence pair mask has the following format:
+        
+        ```
+        0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
+        | first sequence    | second sequence |
+        ```
+        
+        If `token_ids_1` is `None`, this method only returns the first portion of the mask (0s).
+        
+        Args:
+            token_ids_0 (`List[int]`):
+                List of IDs.
+            token_ids_1 (`List[int]`, *optional*):
+                Optional second list of IDs for sequence pairs.
+                
+        Returns:
+            `List[int]`: List of token type IDs according to the given sequence(s).
+        """
+        bos_token_id = [self.bos_token_id] if self.add_bos_token else []
+        eos_token_id = [self.eos_token_id] if self.add_eos_token else []
+
+        output = [0] * len(bos_token_id + token_ids_0 + eos_token_id)
+
+        if token_ids_1 is not None:
+            output += [1] * len(bos_token_id + token_ids_1 + eos_token_id)
+
+        return output
+
+    @property
+    def default_chat_template(self) -> str:
+        """
+        Returns the default chat template for IQuestCoder.
+        
+        This template formats conversations with system, user, and assistant roles.
+        """
+        return DEFAULT_CHAT_TEMPLATE
+
+    def apply_chat_template(
+        self,
+        conversation: Union[List[Dict[str, str]], "Conversation"],
+        chat_template: Optional[str] = None,
+        add_generation_prompt: bool = False,
+        tokenize: bool = True,
+        padding: bool = False,
+        truncation: bool = False,
+        max_length: Optional[int] = None,
+        return_tensors: Optional[str] = None,
+        return_dict: bool = False,
+        **tokenizer_kwargs,
+    ):
+        """
+        Apply a chat template to format a conversation.
+        
+        Args:
+            conversation (`List[Dict[str, str]]` or `Conversation`):
+                A list of dicts with "role" and "content" keys, representing the conversation history.
+            chat_template (`str`, *optional*):
+                A Jinja template to use for formatting. If not provided, the tokenizer's default will be used.
+            add_generation_prompt (`bool`, *optional*, defaults to `False`):
+                Whether to add a generation prompt at the end for the assistant to continue.
+            tokenize (`bool`, *optional*, defaults to `True`):
+                Whether to tokenize the output. If `False`, returns a string.
+            padding (`bool`, *optional*, defaults to `False`):
+                Whether to pad sequences.
+            truncation (`bool`, *optional*, defaults to `False`):
+                Whether to truncate sequences.
+            max_length (`int`, *optional*):
+                Maximum length of the output.
+            return_tensors (`str`, *optional*):
+                The type of tensors to return ("pt", "tf", "np", or None).
+            return_dict (`bool`, *optional*, defaults to `False`):
+                Whether to return a dictionary with additional information.
+            **tokenizer_kwargs:
+                Additional keyword arguments passed to the tokenizer.
+                
+        Returns:
+            `Union[str, List[int], BatchEncoding]`: The formatted (and optionally tokenized) conversation.
+            
+        Example:
+            ```python
+            >>> tokenizer = IQuestCoderTokenizer.from_pretrained("path/to/model")
+            >>> conversation = [
+            ...     {"role": "system", "content": "You are a helpful assistant."},
+            ...     {"role": "user", "content": "Hello!"},
+            ...     {"role": "assistant", "content": "Hi there! How can I help you today?"},
+            ...     {"role": "user", "content": "What's the weather like?"},
+            ... ]
+            >>> tokenizer.apply_chat_template(conversation, add_generation_prompt=True, tokenize=False)
+            '<|system|>\\nYou are a helpful assistant.\\n</|system|><|user|>\\nHello!\\n</|user|>...'
+            ```
+        """
+        # Use parent class implementation with our template
+        return super().apply_chat_template(
+            conversation,
+            chat_template=chat_template,
+            add_generation_prompt=add_generation_prompt,
+            tokenize=tokenize,
+            padding=padding,
+            truncation=truncation,
+            max_length=max_length,
+            return_tensors=return_tensors,
+            return_dict=return_dict,
+            **tokenizer_kwargs,
+        )
+
+
+# Try to import and create Fast tokenizer version
+try:
+    from transformers import PreTrainedTokenizerFast
+    from tokenizers import Tokenizer, decoders, models, normalizers, pre_tokenizers, processors
+    
+    class IQuestCoderTokenizerFast(PreTrainedTokenizerFast):
+        """
+        Construct a "fast" IQuestCoder tokenizer (backed by HuggingFace's *tokenizers* library).
+        
+        This is a fast implementation of [`IQuestCoderTokenizer`] using the 🤗 Tokenizers library.
+        
+        Args:
+            vocab_file (`str`, *optional*):
+                Path to the vocabulary file (SentencePiece model).
+            tokenizer_file (`str`, *optional*):
+                Path to a tokenizer JSON file.
+            unk_token (`str`, *optional*, defaults to `"<unk>"`):
+                The unknown token.
+            bos_token (`str`, *optional*, defaults to `"<s>"`):
+                The beginning of sequence token.
+            eos_token (`str`, *optional*, defaults to `"</s>"`):
+                The end of sequence token.
+            pad_token (`str`, *optional*):
+                The token used for padding.
+            add_bos_token (`bool`, *optional*, defaults to `True`):
+                Whether to add a BOS token at the start of sequences.
+            add_eos_token (`bool`, *optional*, defaults to `False`):
+                Whether to add an EOS token at the end of sequences.
+            add_prefix_space (`bool`, *optional*, defaults to `False`):
+                Whether to add an initial space to the input.
+            use_default_system_prompt (`bool`, *optional*, defaults to `False`):
+                Whether to use the default system prompt.
+            chat_template (`str`, *optional*):
+                A Jinja template for formatting conversations.
+                
+        Example:
+            ```python
+            >>> from tokenization_iquestcoder import IQuestCoderTokenizerFast
+            
+            >>> tokenizer = IQuestCoderTokenizerFast.from_pretrained("path/to/model")
+            >>> tokenizer.encode("Hello, world!")
+            [1, 15043, 29892, 3186, 29991]
+            ```
+        """
+        
+        vocab_files_names = VOCAB_FILES_NAMES
+        pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
+        max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
+        model_input_names = ["input_ids", "attention_mask"]
+        slow_tokenizer_class = IQuestCoderTokenizer
+        
+        def __init__(
+            self,
+            vocab_file=None,
+            tokenizer_file=None,
+            unk_token="<unk>",
+            bos_token="<s>",
+            eos_token="</s>",
+            pad_token=None,
+            add_bos_token=True,
+            add_eos_token=False,
+            add_prefix_space=False,
+            use_default_system_prompt=False,
+            chat_template=None,
+            **kwargs,
+        ):
+            self.add_bos_token = add_bos_token
+            self.add_eos_token = add_eos_token
+            self.add_prefix_space = add_prefix_space
+            self.use_default_system_prompt = use_default_system_prompt
+            
+            if chat_template is None:
+                chat_template = DEFAULT_CHAT_TEMPLATE
+            
+            super().__init__(
+                vocab_file=vocab_file,
+                tokenizer_file=tokenizer_file,
+                unk_token=unk_token,
+                bos_token=bos_token,
+                eos_token=eos_token,
+                pad_token=pad_token,
+                add_bos_token=add_bos_token,
+                add_eos_token=add_eos_token,
+                add_prefix_space=add_prefix_space,
+                use_default_system_prompt=use_default_system_prompt,
+                chat_template=chat_template,
+                **kwargs,
+            )
+        
+        @property
+        def can_save_slow_tokenizer(self) -> bool:
+            return os.path.isfile(self.vocab_file) if self.vocab_file else False
+        
+        @property
+        def default_chat_template(self) -> str:
+            """Returns the default chat template."""
+            return DEFAULT_CHAT_TEMPLATE
+        
+        def build_inputs_with_special_tokens(
+            self, 
+            token_ids_0: List[int], 
+            token_ids_1: Optional[List[int]] = None
+        ) -> List[int]:
+            """Build model inputs with special tokens."""
+            bos_token_id = [self.bos_token_id] if self.add_bos_token else []
+            eos_token_id = [self.eos_token_id] if self.add_eos_token else []
+
+            output = bos_token_id + token_ids_0 + eos_token_id
+
+            if token_ids_1 is not None:
+                output = output + bos_token_id + token_ids_1 + eos_token_id
+
+            return output
+        
+        def get_special_tokens_mask(
+            self, 
+            token_ids_0: List[int], 
+            token_ids_1: Optional[List[int]] = None, 
+            already_has_special_tokens: bool = False
+        ) -> List[int]:
+            """Retrieve special tokens mask."""
+            if already_has_special_tokens:
+                return super().get_special_tokens_mask(
+                    token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
+                )
+
+            bos_token_id = [1] if self.add_bos_token else []
+            eos_token_id = [1] if self.add_eos_token else []
+
+            if token_ids_1 is None:
+                return bos_token_id + ([0] * len(token_ids_0)) + eos_token_id
+            return (
+                bos_token_id
+                + ([0] * len(token_ids_0))
+                + eos_token_id
+                + bos_token_id
+                + ([0] * len(token_ids_1))
+                + eos_token_id
+            )
+        
+        def create_token_type_ids_from_sequences(
+            self, 
+            token_ids_0: List[int], 
+            token_ids_1: Optional[List[int]] = None
+        ) -> List[int]:
+            """Create token type IDs from sequences."""
+            bos_token_id = [self.bos_token_id] if self.add_bos_token else []
+            eos_token_id = [self.eos_token_id] if self.add_eos_token else []
+
+            output = [0] * len(bos_token_id + token_ids_0 + eos_token_id)
+
+            if token_ids_1 is not None:
+                output += [1] * len(bos_token_id + token_ids_1 + eos_token_id)
+
+            return output
+
+except ImportError:
+    # tokenizers library not available, Fast tokenizer not supported
+    IQuestCoderTokenizerFast = None
+    logger.info(
+        "The `tokenizers` library is not installed. "
+        "IQuestCoderTokenizerFast will not be available. "
+        "Install it with `pip install tokenizers`."
+    )
+

tokenizer.model

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

tokenizer_config.json

@@ -0,0 +1,242 @@
+{
+  "add_bos_token": false,
+  "add_eos_token": false,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": true,
+      "special": true
+    },
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": true,
+      "special": true
+    },
+    "75858": {
+      "content": "<CLS>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75859": {
+      "content": "<SEP>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75860": {
+      "content": "<EOD>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75861": {
+      "content": "<MASK>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75862": {
+      "content": "<PAD>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75863": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75864": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75865": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75866": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75867": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75868": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75869": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75870": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75871": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75872": {
+      "content": "<think>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "75873": {
+      "content": "</think>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "75874": {
+      "content": "<tools>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "75875": {
+      "content": "</tools>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "75876": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "75877": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "75878": {
+      "content": "<tool_response>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "75879": {
+      "content": "</tool_response>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|CLS|>",
+    "<|SEP|>",
+    "<|EOD|>",
+    "<|MASK|>",
+    "<|PAD|>",
+    "<|fim_prefix|>",
+    "<|fim_middle|>",
+    "<|fim_suffix|>",
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|fim_pad|>",
+    "<|endoftext|>",
+    "<|repo_name|>",
+    "<|file_sep|>",
+    "<think>",
+    "</think>"
+  ],
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_iquestcoder.IQuestCoderTokenizer",
+      null
+    ]
+  },
+  "bos_token": "<s>",
+  "chat_template": "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0].role == 'system' %}\n        {{- messages[0].content + '\\n\\n' }}\n    {%- else %}\n        {{- 'You are LoopCoder, a helpful assistant developed by IQuest.' }}\n    {%- endif %}\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 LoopCoder, a helpful assistant developed by IQuest.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}\n{%- for message in messages[::-1] %}\n    {%- set index = (messages|length - 1) - loop.index0 %}\n    {%- if ns.multi_step_tool and message.role == \"user\" and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}\n        {%- set ns.multi_step_tool = false %}\n        {%- set ns.last_query_index = index %}\n    {%- endif %}\n{%- endfor %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {%- set content = message.content %}\n        {{- '<|im_start|>' + message.role + '\\n' + content }}\n        {%- if message.tool_calls %}\n            {%- for tool_call in message.tool_calls %}\n                {%- if (loop.first and content) or (not loop.first) %}\n                    {{- '\\n' }}\n                {%- endif %}\n                {%- if tool_call.function %}\n                    {%- set tool_call = tool_call.function %}\n                {%- endif %}\n                {{- '<tool_call>\\n{\"name\": \"' }}\n                {{- tool_call.name }}\n                {{- '\", \"arguments\": ' }}\n                {%- if tool_call.arguments is string %}\n                    {{- tool_call.arguments }}\n                {%- else %}\n                    {{- tool_call.arguments | tojson }}\n                {%- endif %}\n                {{- '}\\n</tool_call>' }}\n            {%- endfor %}\n        {%- endif %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if loop.first 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 %}",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "padding_side": "right",
+  "sp_model_kwargs": {},
+  "split_special_tokens": false,
+  "tokenizer_class": "IQuestCoderTokenizer",
+  "unk_token": "<unk>",
+  "use_fast": false
+}