Restore LoopCoder-V2 model files

README.md

@@ -1,3 +1,126 @@
 ---
 license: apache-2.0
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- code
+- code-generation
+- code-reasoning
+- agentic-coding
+- tool-use
+- instruction-tuned
+- looped-transformer
+- parallel-loop-transformer
+- plt
 ---
+
+# LoopCoder-V2
+
+LoopCoder-v2 is a 7B instruction-tuned code model based on the Parallel Loop Transformer (PLT). The model studies test-time computation scaling through repeated application of shared Transformer blocks while keeping the parameter count fixed.
+
+The released checkpoint is the two-loop PLT variant (`plt_num_loops=2`). In the accompanying paper, this setting gives the best gain-cost trade-off: the second loop provides most of the useful latent refinement, while additional loops show diminishing or unstable updates.
+
+## Highlights
+
+- 7B dense PLT coder trained from scratch on 18T tokens of mixed text and code data.
+- Instruction-tuned with a matched supervised fine-tuning recipe.
+- Uses cross-loop position offsets and shared-KV gated sliding-window attention.
+- Targets code generation, multilingual code, code reasoning, agentic software engineering, and tool-use workflows.
+- Strongest loop-count setting in the paper: two loops, not more.
+
+## Model Details
+
+| Item | Value |
+| --- | --- |
+| Architecture | `IQuestPLTCoderForCausalLM` |
+| Parameters | Approximately 7B |
+| Hidden size | 5120 |
+| Layers | 14 shared layers |
+| Attention heads | 40 |
+| KV heads | 8 |
+| Head dimension | 128 |
+| Intermediate size | 27648 |
+| Activation | SwiGLU |
+| Normalization | RMSNorm, epsilon 1e-5 |
+| Position embedding | RoPE, theta 500000 |
+| Vocabulary size | 76800 |
+| Max position embeddings | 131072 |
+| Precision | bfloat16 |
+| PLT loops | 2 |
+| PLT window size | 64 |
+
+## Evaluation Summary
+
+Selected results from the paper are shown below. All LoopCoder-v2 variants use the same 7B shared-parameter setup and matched training, tuning, and evaluation protocols.
+
+| Model | HumanEval+ | MultiPL-E | BigCodeBench | LiveCodeBench | SWE-bench Verified | Multi-SWE | Terminal-Bench | Terminal-Bench 2.0 | Mind2Web | BFCL V3 | Avg. |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| Baseline, 1 loop | 81.1 | 69.5 | 40.1 | 27.4 | 43.0 | 14.0 | 26.3 | 11.2 | 35.3 | 32.2 | 38.0 |
+| LoopCoder-v2, 2 loops | 84.1 | 73.9 | 46.1 | 35.4 | 64.4 | 31.0 | 34.2 | 21.0 | 34.5 | 40.1 | 46.5 |
+| LoopCoder-v2, 3 loops | 75.0 | 69.8 | 43.3 | 28.6 | 27.6 | 11.0 | 30.0 | 12.2 | 35.1 | 36.3 | 36.9 |
+| LoopCoder-v2, 4 loops | 76.8 | 67.3 | 40.8 | 24.5 | 22.4 | 9.3 | 26.3 | 9.0 | 41.4 | 39.5 | 34.3 |
+
+The paper's main finding is that PLT loop-count scaling is non-monotonic. The two-loop model improves broadly over the one-loop baseline, including SWE-bench Verified from 43.0 to 64.4 and Multi-SWE from 14.0 to 31.0, while three or more loops regress on many tasks.
+
+## Usage
+
+This checkpoint uses a custom PLT model architecture. Load it in an environment that provides support for `IQuestPLTCoderForCausalLM` and the custom tokenizer/configuration files in this repository.
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+repo_id = "Multilingual-Multimodal-NLP/LoopCoder-V2"
+
+tokenizer = AutoTokenizer.from_pretrained(repo_id, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    repo_id,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+    trust_remote_code=True,
+)
+
+messages = [
+    {"role": "user", "content": "Write a Python function that checks whether a string is a palindrome."}
+]
+
+inputs = tokenizer.apply_chat_template(
+    messages,
+    add_generation_prompt=True,
+    tokenize=True,
+    return_tensors="pt",
+).to(model.device)
+
+outputs = model.generate(
+    inputs,
+    max_new_tokens=512,
+    do_sample=True,
+    temperature=0.6,
+    top_p=0.95,
+    top_k=20,
+)
+
+print(tokenizer.decode(outputs[0][inputs.shape[-1]:], skip_special_tokens=True))
+```
+
+## Training Data
+
+LoopCoder-v2 was trained from scratch on an internal deduplicated mixture of text and code totaling 18T tokens, balanced at a 1:1 text-to-code token ratio. The code portion spans more than 100 programming languages. The largest language shares reported in the paper include Java, Python, JavaScript, Markdown, TypeScript, C, C++, PHP, C#, and HTML.
+
+## Intended Use
+
+LoopCoder-v2 is intended for code generation, code reasoning, repository-level software engineering assistance, and tool-use research. It is especially useful for studying how looped latent computation changes model behavior under fixed parameter count.
+
+## Limitations
+
+LoopCoder-v2 can produce incorrect, insecure, or incomplete code and should not be used without review in production systems. The released model is optimized for coding and tool-use workloads; performance on unrelated open-domain tasks may vary. The paper also shows that increasing PLT loops beyond the two-loop setting can hurt performance, so this checkpoint should be treated as the recommended loop-count configuration rather than evidence that more loops are always better.
+
+## Citation
+
+```bibtex
+@misc{loopcoder_v2_2026,
+  title = {LoopCoder-v2: Only Loop Once for Efficient Test-Time Computation Scaling},
+  author = {Yang, Jian and Guo, Shawn and Zhang, Wei and Zheng, Tianyu and Du, Yaxin and Li, Haau-Sing and Wu, Jiajun and Song, Yue and Xing, Yan and Cai, Qingsong and Huang, Zelong and Hao, Chuan and Tao, Ran and Liu, Xianglong and Zhao, Wayne Xin and Tang, Mingjie and Lv, Weifeng and Zhou, Ming and Dai, Bryan},
+  year = {2026}
+}
+```

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,143 @@
+{% macro render_extra_keys(json_dict, handled_keys) %}
+    {%- if json_dict is mapping %}
+        {%- for json_key in json_dict if json_key not in handled_keys %}
+            {%- if json_dict[json_key] is mapping or (json_dict[json_key] is sequence and json_dict[json_key] is not string) %}
+                {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | tojson | safe) ~ '</' ~ json_key ~ '>' }}
+            {%- else %}
+                {{-'\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | string) ~ '</' ~ json_key ~ '>' }}
+            {%- endif %}
+        {%- endfor %}
+    {%- endif %}
+{% endmacro %}
+
+{%- if messages[0]["role"] == "system" %}
+    {%- set system_message = messages[0]["content"] %}
+    {%- set loop_messages = messages[1:] %}
+{%- else %}
+    {%- set loop_messages = messages %}
+{%- endif %}
+
+{%- if not tools is defined %}
+    {%- set tools = [] %}
+{%- endif %}
+
+{%- if system_message is defined %}
+    {{- "<|im_start|>system\n" + system_message }}
+{%- else %}
+    {%- if tools is iterable and tools | length > 0 %}
+        {{- "<|im_start|>system\nYou are a helpful AI assistant." }}
+    {%- endif %}
+{%- endif %}
+{%- if tools is iterable and tools | length > 0 %}
+    {{- "\n\n# Tools\n\nYou have access to the following functions:\n\n" }}
+    {{- "<tools>" }}
+    {%- for tool in tools %}
+        {%- if tool.function is defined %}
+            {%- set tool = tool.function %}
+        {%- endif %}
+        {{- "\n<function>\n<name>" ~ tool.name ~ "</name>" }}
+        {%- if tool.description is defined %}
+            {{- '\n<description>' ~ (tool.description | trim) ~ '</description>' }}
+        {%- endif %}
+        {{- '\n<parameters>' }}
+        {%- if tool.parameters is defined and tool.parameters is mapping and tool.parameters.properties is defined and tool.parameters.properties is mapping %}
+            {%- for param_name, param_fields in tool.parameters.properties|items %}
+                {{- '\n<parameter>' }}
+                {{- '\n<name>' ~ param_name ~ '</name>' }}
+                {%- if param_fields.type is defined %}
+                    {{- '\n<type>' ~ (param_fields.type | string) ~ '</type>' }}
+                {%- endif %}
+                {%- if param_fields.description is defined %}
+                    {{- '\n<description>' ~ (param_fields.description | trim) ~ '</description>' }}
+                {%- endif %}
+                {%- set handled_keys = ['name', 'type', 'description'] %}
+                {{- render_extra_keys(param_fields, handled_keys) }}
+                {{- '\n</parameter>' }}
+            {%- endfor %}
+        {%- endif %}
+        {% set handled_keys = ['type', 'properties'] %}
+        {{- render_extra_keys(tool.parameters, handled_keys) }}
+        {{- '\n</parameters>' }}
+        {%- set handled_keys = ['type', 'name', 'description', 'parameters'] %}
+        {{- render_extra_keys(tool, handled_keys) }}
+        {{- '\n</function>' }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+{%- endif %}
+{%- if system_message is defined %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if tools is iterable and tools | length > 0 %}
+        {{- '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in loop_messages %}
+    {%- if message.role == "assistant" and message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if (message.content_mask is not defined) or not message.content_mask %}{%- generation %}
+        {%- if message.content is defined and message.content is string and message.content | trim | length > 0 %}
+            {{- '\n' + message.content | trim + '\n' }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+            {%- if tool_call.arguments is defined %}
+                {%- for args_name, args_value in tool_call.arguments|items %}
+                    {{- '<parameter=' + args_name + '>\n' }}
+                    {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                    {{- args_value }}
+                    {{- '\n</parameter>\n' }}
+                {%- endfor %}
+            {%- endif %}
+            {{- '</function>\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+        {%- endgeneration %}{%- else %}
+        {%- if message.content is defined and message.content is string and message.content | trim | length > 0 %}
+            {{- '\n' + message.content | trim + '\n' }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+            {%- if tool_call.arguments is defined %}
+                {%- for args_name, args_value in tool_call.arguments|items %}
+                    {{- '<parameter=' + args_name + '>\n' }}
+                    {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                    {{- args_value }}
+                    {{- '\n</parameter>\n' }}
+                {%- endfor %}
+            {%- endif %}
+            {{- '</function>\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- elif message.role == "user" or message.role == "system" %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role + '\n' }}
+        {%- if (message.content_mask is not defined) or not message.content_mask %}{%- generation %}{{- message.content + '<|im_end|>' }}{%- endgeneration %}{%- else %}{{- message.content + '<|im_end|>' }}{%- endif %}
+        {{- '\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user\n' }}
+        {%- endif %}
+        {{- '<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>\n' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

config.json

@@ -0,0 +1,40 @@
+{
+  "architectures": [
+    "IQuestPLTCoderForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "auto_map": {
+    "AutoConfig": "configuration_iquestpltcoder.IQuestPLTCoderConfig"
+  },
+  "bos_token_id": 1,
+  "dtype": "bfloat16",
+  "eos_token_id": 2,
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 5120,
+  "initializer_range": 0.02,
+  "intermediate_size": 27648,
+  "max_position_embeddings": 131072,
+  "mlp_bias": false,
+  "model_type": "iquestpltcoder",
+  "num_attention_heads": 40,
+  "num_hidden_layers": 14,
+  "num_key_value_heads": 8,
+  "plt_emb_scale": 0.707,
+  "plt_gate_use_hidden_states": true,
+  "plt_hidden_scale": 0.053,
+  "plt_normalize_per_loop": true,
+  "plt_num_loops": 2,
+  "plt_window_size": [
+    64,
+    0
+  ],
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": null,
+  "rope_theta": 500000,
+  "tie_word_embeddings": false,
+  "transformers_version": "4.57.1",
+  "use_cache": true,
+  "vocab_size": 76800
+}

configuration_iquestcoder.py

@@ -0,0 +1,199 @@
+"""IQuestCoder model configuration."""
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class IQuestCoderConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`IQuestCoderModel`]. It is used to instantiate
+    an IQuestCoder model according to the specified arguments, defining the model architecture.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+    Args:
+        vocab_size (`int`, *optional*, defaults to 76800):
+            Vocabulary size of the IQuestCoder model. Defines the number of different tokens that can be represented
+            by the `inputs_ids` passed when calling [`IQuestCoderModel`].
+        hidden_size (`int`, *optional*, defaults to 5120):
+            Dimension of the hidden representations.
+        intermediate_size (`int`, *optional*, defaults to 27648):
+            Dimension of the MLP representations.
+        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 in the Transformer decoder.
+        num_key_value_heads (`int`, *optional*, defaults to 8):
+            This is the number of key_value heads that should be used to implement Grouped Query Attention (GQA).
+            If `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA).
+            If `num_key_value_heads=1`, the model will use Multi Query Attention (MQA).
+        head_dim (`int`, *optional*, defaults to 128):
+            The dimension of each attention head. If not specified, defaults to `hidden_size // num_attention_heads`.
+        hidden_act (`str` or `function`, *optional*, defaults to `"silu"`):
+            The non-linear activation function (function or string) in the decoder.
+        max_position_embeddings (`int`, *optional*, defaults to 16384):
+            The maximum sequence length that this model might ever be used with.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        rms_norm_eps (`float`, *optional*, defaults to 1e-05):
+            The epsilon used by the rms normalization layers.
+        use_cache (`bool`, *optional*, defaults to `True`):
+            Whether or not the model should return the last key/values attentions (not used by all models).
+        pad_token_id (`int`, *optional*):
+            Padding token id.
+        bos_token_id (`int`, *optional*, defaults to 1):
+            Beginning of stream token id.
+        eos_token_id (`int`, *optional*, defaults to 2):
+            End of stream token id.
+        tie_word_embeddings (`bool`, *optional*, defaults to `False`):
+            Whether to tie weight embeddings.
+        rope_theta (`float`, *optional*, defaults to 500000.0):
+            The base period of the RoPE embeddings.
+        rope_scaling (`Dict`, *optional*):
+            Dictionary containing the scaling configuration for the RoPE embeddings. Supports various RoPE scaling
+            types including "linear", "dynamic", "yarn", "longrope", etc.
+        attention_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use a bias in the query, key, value and output projection layers during self-attention.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+        mlp_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use a bias in up_proj, down_proj and gate_proj layers in the MLP layers.
+        clip_qkv (`float`, *optional*):
+            If set, clip the query, key, and value tensors to this value. Borrowed from OLMo for training stability.
+        use_sliding_window (`bool`, *optional*, defaults to `False`):
+            Whether to use sliding window attention. Borrowed from Qwen2.
+        sliding_window (`int`, *optional*):
+            The sliding window size. Only effective when `use_sliding_window=True`.
+        max_window_layers (`int`, *optional*, defaults to 0):
+            The number of layers that don't use sliding window attention. Borrowed from Qwen2.
+
+    Example:
+        ```python
+        >>> from configuration_iquestcoder import IQuestCoderConfig
+        >>> from modeling_iquestcoder import IQuestCoderModel
+
+        >>> # Initializing a IQuestCoder configuration
+        >>> configuration = IQuestCoderConfig()
+
+        >>> # Initializing a model from the configuration
+        >>> model = IQuestCoderModel(configuration)
+
+        >>> # Accessing the model configuration
+        >>> configuration = model.config
+        ```
+    """
+
+    model_type = "iquestcoder"
+    keys_to_ignore_at_inference = ["past_key_values"]
+
+    # Tensor / pipeline parallel plans for vLLM transformers backend.
+    # Same shape as LlamaConfig — IQuestCoder is structurally Llama (RMSNorm + GQA + RoPE + SwiGLU).
+    base_model_tp_plan = {
+        "layers.*.self_attn.q_proj": "colwise",
+        "layers.*.self_attn.k_proj": "colwise",
+        "layers.*.self_attn.v_proj": "colwise",
+        "layers.*.self_attn.o_proj": "rowwise",
+        "layers.*.mlp.gate_proj": "colwise",
+        "layers.*.mlp.up_proj": "colwise",
+        "layers.*.mlp.down_proj": "rowwise",
+    }
+    base_model_pp_plan = {
+        "embed_tokens": (["input_ids"], ["inputs_embeds"]),
+        "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
+        "norm": (["hidden_states"], ["hidden_states"]),
+    }
+
+    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=16384,
+        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,
+        # IQuestCoder specific (borrowed from OLMo)
+        clip_qkv=None,
+        # IQuestCoder specific (borrowed from Qwen2)
+        use_sliding_window=False,
+        sliding_window=None,
+        max_window_layers=0,
+        **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.num_key_value_heads = num_key_value_heads
+        self.head_dim = head_dim
+        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
+        # IQuestCoder specific
+        self.clip_qkv = clip_qkv
+        self.use_sliding_window = use_sliding_window
+        self.sliding_window = sliding_window
+        self.max_window_layers = max_window_layers
+
+        # Validate rope_scaling configuration
+        self._rope_scaling_validation()
+
+        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,
+        )
+
+    def _rope_scaling_validation(self):
+        """Validate the `rope_scaling` configuration."""
+        if self.rope_scaling is None:
+            return
+
+        if not isinstance(self.rope_scaling, dict) or len(self.rope_scaling) < 1:
+            raise ValueError(
+                "`rope_scaling` must be a dictionary with a minimum of one field, `type` or `rope_type`."
+            )
+        
+        rope_scaling_type = self.rope_scaling.get("type", None) or self.rope_scaling.get("rope_type", None)
+        if rope_scaling_type is None:
+            raise ValueError(
+                "`rope_scaling` must have a `type` or `rope_type` field."
+            )
+        
+        valid_rope_types = ["linear", "dynamic", "yarn", "longrope", "llama3"]
+        if rope_scaling_type not in valid_rope_types:
+            raise ValueError(
+                f"`rope_scaling`'s type field must be one of {valid_rope_types}, got {rope_scaling_type}"
+            )
+
+
+__all__ = ["IQuestCoderConfig"]
+

configuration_iquestpltcoder.py

@@ -0,0 +1,209 @@
+"""IQuestPLTCoder model configuration.
+
+Extends the IQuestCoder configuration with PLT (Parallel Loop Transformer)
+specific parameters. PLT reuses the same physical transformer layers across
+multiple loops, with cross-loop processing (CLP) and mixed attention (global
+full-attention + local sliding-window attention gated per head) in loop 1+.
+
+Reference: https://arxiv.org/abs/2510.24824
+"""
+
+from typing import Dict, List, Optional, Union
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class IQuestPLTCoderConfig(PretrainedConfig):
+    r"""
+    Configuration class for [`IQuestPLTCoderModel`].
+
+    This is a PLT (Parallel Loop Transformer) variant of IQuestCoder. The model
+    has `num_hidden_layers` physical transformer layers that are executed
+    `plt_num_loops` times. Weights are shared across loops; each loop adds
+    cross-loop processing and mixed attention via a learned per-head gate.
+
+    Args:
+        vocab_size (`int`, *optional*, defaults to 75904):
+            Vocabulary size of the model (padded to be divisible by 128).
+        hidden_size (`int`, *optional*, defaults to 5120):
+            Dimension of the hidden representations.
+        intermediate_size (`int`, *optional*, defaults to 27648):
+            Dimension of the MLP representations.
+        num_hidden_layers (`int`, *optional*, defaults to 14):
+            Number of physical transformer layers (shared across all loops).
+        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 Grouped Query Attention (GQA).
+        head_dim (`int`, *optional*, defaults to 128):
+            The dimension of each attention head.
+        hidden_act (`str` or `function`, *optional*, defaults to `"silu"`):
+            The non-linear activation function in the decoder (SwiGLU uses SiLU).
+        max_position_embeddings (`int`, *optional*, defaults to 131072):
+            The maximum sequence length that this model might ever be used with.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for
+            initializing all weight matrices.
+        rms_norm_eps (`float`, *optional*, defaults to 1e-05):
+            The epsilon used by the RMS normalization layers.
+        use_cache (`bool`, *optional*, defaults to `True`):
+            Whether the model should return the last key/values attentions.
+        pad_token_id (`int`, *optional*):
+            Padding token id.
+        bos_token_id (`int`, *optional*, defaults to 1):
+            Beginning of stream token id.
+        eos_token_id (`int` or `list`, *optional*, defaults to `[2, 75864, 75869]`):
+            End of stream token id(s).
+        tie_word_embeddings (`bool`, *optional*, defaults to `False`):
+            Whether to tie input embedding and output projection weights.
+        rope_theta (`float`, *optional*, defaults to 500000.0):
+            The base period of the RoPE embeddings.
+        rope_scaling (`Dict`, *optional*):
+            Dictionary containing the scaling configuration for the RoPE
+            embeddings. Supports "linear", "dynamic", "yarn", "longrope", "llama3".
+        attention_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use a bias in the Q, K, V and output projection layers.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+        mlp_bias (`bool`, *optional*, defaults to `False`):
+            Whether to use a bias in the MLP gate/up/down projection layers.
+        plt_num_loops (`int`, *optional*, defaults to 2):
+            Number of times the physical transformer layers are executed.
+            Loop 0 runs standard causal attention and stores KV caches.
+            Loops 1+ run mixed attention with cross-loop processing.
+        plt_window_size (`list` of `int`, *optional*, defaults to `[64, 0]`):
+            Sliding window size `[left, right]` for the local attention in
+            loop 1+. `[64, 0]` means a left-context window of 64 tokens with
+            causal masking (right=0).
+        plt_normalize_per_loop (`bool`, *optional*, defaults to `True`):
+            When True, apply final_layernorm (shared weights) to hidden states
+            at the end of each non-last loop before cross-loop processing.
+        plt_emb_scale (`float`, *optional*, defaults to `None`):
+            Scaling factor for the embedding in CLP: `a * E + b * shift(H)`.
+            `None` means 1.0 (no scaling).
+        plt_hidden_scale (`float`, *optional*, defaults to `None`):
+            Scaling factor for the shifted hidden state in CLP:
+            `a * E + b * shift(H)`. `None` means 1.0 (no scaling).
+        plt_gate_use_hidden_states (`bool`, *optional*, defaults to `False`):
+            Gate input mode. When `False`, the gate is computed as
+            `sigmoid(einsum(Q, W_gate) + b_gate)` per head on the post-RoPE
+            query tensor.  When `True`, gate uses
+            `sigmoid(Linear(RMSNorm(hidden_states)))` (OLMo-style) instead.
+
+    Example:
+        ```python
+        >>> from configuration_iquestpltcoder import IQuestPLTCoderConfig
+        >>> from modeling_iquestpltcoder import IQuestPLTCoderModel
+
+        >>> configuration = IQuestPLTCoderConfig()
+        >>> model = IQuestPLTCoderModel(configuration)
+        >>> configuration = model.config
+        ```
+    """
+
+    model_type = "iquestpltcoder"
+    keys_to_ignore_at_inference = ["past_key_values"]
+
+    def __init__(
+        self,
+        vocab_size=75904,
+        hidden_size=5120,
+        intermediate_size=27648,
+        num_hidden_layers=14,
+        num_attention_heads=40,
+        num_key_value_heads=8,
+        head_dim=128,
+        hidden_act="silu",
+        max_position_embeddings=131072,
+        initializer_range=0.02,
+        rms_norm_eps=1e-5,
+        use_cache=True,
+        pad_token_id=None,
+        bos_token_id=1,
+        eos_token_id=None,
+        tie_word_embeddings=False,
+        rope_theta=500000.0,
+        rope_scaling=None,
+        attention_bias=False,
+        attention_dropout=0.0,
+        mlp_bias=False,
+        # PLT specific
+        plt_num_loops=2,
+        plt_window_size=None,
+        plt_normalize_per_loop=True,
+        plt_emb_scale=None,
+        plt_hidden_scale=None,
+        plt_gate_use_hidden_states=False,
+        **kwargs,
+    ):
+        if eos_token_id is None:
+            eos_token_id = [2, 75864, 75869]
+        if plt_window_size is None:
+            plt_window_size = [64, 0]
+
+        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.num_key_value_heads = num_key_value_heads
+        self.head_dim = head_dim
+        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
+
+        # PLT specific
+        self.plt_num_loops = plt_num_loops
+        self.plt_window_size = plt_window_size
+        self.plt_normalize_per_loop = plt_normalize_per_loop
+        self.plt_emb_scale = plt_emb_scale
+        self.plt_hidden_scale = plt_hidden_scale
+        self.plt_gate_use_hidden_states = plt_gate_use_hidden_states
+
+        self._rope_scaling_validation()
+
+        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,
+        )
+
+    def _rope_scaling_validation(self):
+        """Validate the `rope_scaling` configuration."""
+        if self.rope_scaling is None:
+            return
+
+        if not isinstance(self.rope_scaling, dict) or len(self.rope_scaling) < 1:
+            raise ValueError(
+                "`rope_scaling` must be a dictionary with a minimum of one field, "
+                "`type` or `rope_type`."
+            )
+
+        rope_scaling_type = self.rope_scaling.get("type", None) or self.rope_scaling.get(
+            "rope_type", None
+        )
+        if rope_scaling_type is None:
+            raise ValueError("`rope_scaling` must have a `type` or `rope_type` field.")
+
+        valid_rope_types = ["linear", "dynamic", "yarn", "longrope", "llama3"]
+        if rope_scaling_type not in valid_rope_types:
+            raise ValueError(
+                f"`rope_scaling`'s type field must be one of {valid_rope_types}, "
+                f"got {rope_scaling_type}"
+            )
+
+
+__all__ = ["IQuestPLTCoderConfig"]

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "bos_token_id": 1,
+  "do_sample": true,
+  "eos_token_id": [
+    2
+  ],
+  "pad_token_id": 2,
+  "temperature": 0.6,
+  "top_k": 20,
+  "top_p": 0.95,
+  "transformers_version": "4.57.1",
+  "trust_remote_code": true
+}

model-00001-of-00003.safetensors

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

model-00002-of-00003.safetensors

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

model-00003-of-00003.safetensors

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

model.safetensors.index.json

@@ -0,0 +1,178 @@
+{
+  "metadata": {
+    "total_size": 15231499360
+  },
+  "weight_map": {
+    "lm_head.weight": "model-00001-of-00003.safetensors",
+    "model.embed_tokens.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.self_attn.plt_gate.bias": "model-00001-of-00003.safetensors",
+    "model.layers.0.self_attn.plt_gate.gate_norm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.self_attn.plt_gate.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.0.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.self_attn.plt_gate.bias": "model-00001-of-00003.safetensors",
+    "model.layers.1.self_attn.plt_gate.gate_norm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.self_attn.plt_gate.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.1.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.10.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.self_attn.plt_gate.bias": "model-00003-of-00003.safetensors",
+    "model.layers.10.self_attn.plt_gate.gate_norm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.self_attn.plt_gate.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.10.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.self_attn.plt_gate.bias": "model-00003-of-00003.safetensors",
+    "model.layers.11.self_attn.plt_gate.gate_norm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.self_attn.plt_gate.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.11.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.self_attn.plt_gate.bias": "model-00003-of-00003.safetensors",
+    "model.layers.12.self_attn.plt_gate.gate_norm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.self_attn.plt_gate.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.12.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.self_attn.plt_gate.bias": "model-00003-of-00003.safetensors",
+    "model.layers.13.self_attn.plt_gate.gate_norm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.self_attn.plt_gate.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.13.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.2.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.self_attn.plt_gate.bias": "model-00001-of-00003.safetensors",
+    "model.layers.2.self_attn.plt_gate.gate_norm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.self_attn.plt_gate.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.2.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.3.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.3.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.3.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.3.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "model.layers.3.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.3.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.3.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.3.self_attn.plt_gate.bias": "model-00001-of-00003.safetensors",
+    "model.layers.3.self_attn.plt_gate.gate_norm.weight": "model-00001-of-00003.safetensors",
+    "model.layers.3.self_attn.plt_gate.weight": "model-00001-of-00003.safetensors",
+    "model.layers.3.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.3.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.self_attn.plt_gate.bias": "model-00002-of-00003.safetensors",
+    "model.layers.4.self_attn.plt_gate.gate_norm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.self_attn.plt_gate.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.4.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.self_attn.plt_gate.bias": "model-00002-of-00003.safetensors",
+    "model.layers.5.self_attn.plt_gate.gate_norm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.self_attn.plt_gate.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.5.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.self_attn.plt_gate.bias": "model-00002-of-00003.safetensors",
+    "model.layers.6.self_attn.plt_gate.gate_norm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.self_attn.plt_gate.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.6.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.self_attn.plt_gate.bias": "model-00002-of-00003.safetensors",
+    "model.layers.7.self_attn.plt_gate.gate_norm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.self_attn.plt_gate.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.7.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.self_attn.plt_gate.bias": "model-00002-of-00003.safetensors",
+    "model.layers.8.self_attn.plt_gate.gate_norm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.self_attn.plt_gate.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.8.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.9.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.9.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.9.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "model.layers.9.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.9.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "model.layers.9.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.9.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.9.self_attn.plt_gate.bias": "model-00003-of-00003.safetensors",
+    "model.layers.9.self_attn.plt_gate.gate_norm.weight": "model-00003-of-00003.safetensors",
+    "model.layers.9.self_attn.plt_gate.weight": "model-00003-of-00003.safetensors",
+    "model.layers.9.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "model.layers.9.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "model.norm.weight": "model-00001-of-00003.safetensors"
+  }
+}

special_tokens_map.json

@@ -0,0 +1,46 @@
+{
+  "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|>"
+  ],
+  "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,570 @@
+"""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
+            self.vocab_file = vocab_file
+
+            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:
+            vocab_file = getattr(self, "vocab_file", None)
+            return bool(vocab_file) and os.path.isfile(vocab_file)
+
+        def save_vocabulary(
+            self, save_directory: str, filename_prefix: Optional[str] = None
+        ) -> Tuple[str]:
+            if not self.can_save_slow_tokenizer:
+                return ()
+            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):
+                copyfile(self.vocab_file, out_vocab_file)
+            return (out_vocab_file,)
+
+        @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,282 @@
+{
+  "add_bos_token": false,
+  "add_eos_token": false,
+  "add_prefix_space": 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
+    },
+    "75880": {
+      "content": "<|CLS|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75881": {
+      "content": "<|SEP|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75882": {
+      "content": "<|EOD|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75883": {
+      "content": "<|MASK|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "75884": {
+      "content": "<|PAD|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "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|>"
+  ],
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_iquestcoder.IQuestCoderTokenizer",
+      "tokenization_iquestcoder.IQuestCoderTokenizerFast"
+    ]
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "extra_special_tokens": {},
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "padding_side": "right",
+  "sp_model_kwargs": {},
+  "split_special_tokens": false,
+  "tokenizer_class": "IQuestCoderTokenizer",
+  "unk_token": "<unk>",
+  "use_default_system_prompt": false,
+  "use_fast": true
+}