Initial upload of ALM-Qwen model package

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+qwen_generator/qwen_tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text

ALM.py

@@ -0,0 +1,183 @@
+# --- START OF FILE ALM.py ---
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+class AttentionLinkedMemory(nn.Module):
+    """
+    Implements an Attention-Linked Memory Layer.
+
+    This layer retrieves context from a structured memory based on a query.
+    It uses a two-level attention mechanism:
+    1. Within-Bucket Attention: Summarizes each memory bucket based on relevance
+       to the query.
+    2. Between-Bucket Attention: Weights the summarized buckets to find the most
+       relevant buckets for the query, producing a final aggregated context.
+
+    Args:
+        query_dim (int): Dimension of the input query vector.
+        memory_dim (int): Dimension of the memory item vectors.
+        embed_dim (int): Internal embedding dimension for attention. Keys, Queries,
+                         and Values will be projected to this dimension.
+        num_heads (int): Number of attention heads for both levels. Must divide embed_dim.
+        output_dim (int, optional): Dimension of the final output context vector.
+                                   If None, defaults to embed_dim.
+        dropout_rate (float, optional): Dropout probability. Defaults to 0.1.
+    """
+    def __init__(self,
+                 query_dim: int,
+                 memory_dim: int,
+                 embed_dim: int,
+                 num_heads: int,
+                 output_dim: int = None,
+                 dropout_rate: float = 0.1):
+        super().__init__()
+
+        if embed_dim % num_heads != 0:
+            raise ValueError(f"embed_dim ({embed_dim}) must be divisible by num_heads ({num_heads})")
+
+        self.query_dim = query_dim
+        self.memory_dim = memory_dim
+        self.embed_dim = embed_dim
+        self.output_dim = output_dim if output_dim is not None else embed_dim
+        self.num_heads = num_heads
+        self.head_dim = embed_dim // num_heads
+        self.scale = math.sqrt(self.head_dim)
+
+        # --- Level 1 (Within-Bucket) Projections ---
+        self.q_proj_l1 = nn.Linear(query_dim, embed_dim)
+        self.k_proj_l1 = nn.Linear(memory_dim, embed_dim)
+        self.v_proj_l1 = nn.Linear(memory_dim, embed_dim)
+        self.dropout_l1 = nn.Dropout(dropout_rate)
+        self.norm_l1_out = nn.LayerNorm(embed_dim)
+
+        # --- Level 2 (Between-Bucket) Projections ---
+        self.q_proj_l2 = nn.Linear(query_dim, embed_dim)
+        self.k_proj_l2 = nn.Linear(embed_dim, embed_dim)
+        self.v_proj_l2 = nn.Linear(embed_dim, embed_dim)
+        self.dropout_l2 = nn.Dropout(dropout_rate)
+
+        # --- Final Output Projection ---
+        self.out_proj = nn.Linear(embed_dim, self.output_dim)
+        self.norm_final = nn.LayerNorm(self.output_dim)
+
+    def forward(self,
+                query: torch.Tensor,
+                memory_buckets: torch.Tensor,
+                memory_mask: torch.Tensor = None):
+        """
+        Forward pass through the Attention-Linked Memory layer.
+
+        Args:
+            query (torch.Tensor): Input query tensor.
+                Shape: (batch_size, query_dim)
+            memory_buckets (torch.Tensor): Tensor containing memory items organized
+                into buckets. Padded for consistent size.
+                Shape: (batch_size, num_buckets, max_items_per_bucket, memory_dim)
+            memory_mask (torch.Tensor, optional): Boolean mask indicating valid
+                memory items (True) vs padding (False).
+                Shape: (batch_size, num_buckets, max_items_per_bucket)
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+                - aggregated_context (torch.Tensor): The final context vector.
+                  Shape: (batch_size, output_dim)
+                - bucket_attention_weights_l2 (torch.Tensor): Attention weights for buckets (L2).
+                  Shape: (batch_size, num_buckets)
+                - item_attention_weights_l1 (torch.Tensor): Attention weights for items within buckets (L1, averaged over heads).
+                  Shape: (batch_size, num_buckets, max_items_per_bucket)
+        """
+        batch_size, num_buckets, max_items, _ = memory_buckets.shape
+
+        # ========================= Level 1: Within-Bucket Attention =========================
+        q1 = self.q_proj_l1(query).view(batch_size, self.num_heads, 1, 1, self.head_dim)
+        k1 = self.k_proj_l1(memory_buckets)
+        v1 = self.v_proj_l1(memory_buckets)
+
+        k1 = k1.view(batch_size, num_buckets, max_items, self.num_heads, self.head_dim).permute(0, 3, 1, 2, 4)
+        v1 = v1.view(batch_size, num_buckets, max_items, self.num_heads, self.head_dim).permute(0, 3, 1, 2, 4)
+
+        attn_scores_l1 = torch.einsum('bhqid,bhnkd->bhnqk', q1, k1) / self.scale
+        attn_scores_l1 = attn_scores_l1.squeeze(3) # (B, H, N_b, N_i)
+
+        if memory_mask is not None:
+            expanded_mask_l1 = memory_mask.unsqueeze(1) # (B, 1, N_b, N_i)
+            attn_scores_l1 = attn_scores_l1.masked_fill(expanded_mask_l1 == 0, -1e9)
+
+        attn_weights_l1_raw = F.softmax(attn_scores_l1, dim=-1) # (B, H, N_b, N_i)
+        # For returning, average over heads
+        item_attention_weights_l1_for_output = attn_weights_l1_raw.mean(dim=1) # (B, N_b, N_i)
+        
+        attn_weights_l1_dropout = self.dropout_l1(attn_weights_l1_raw)
+
+        bucket_summaries = torch.einsum('bhnk,bhnkd->bhnd', attn_weights_l1_dropout, v1)
+        bucket_summaries = bucket_summaries.permute(0, 2, 1, 3).contiguous().view(batch_size, num_buckets, self.embed_dim)
+        bucket_summaries = self.norm_l1_out(bucket_summaries)
+
+        # ========================= Level 2: Between-Bucket Attention ========================
+        q2 = self.q_proj_l2(query).view(batch_size, self.num_heads, 1, self.head_dim)
+        k2 = self.k_proj_l2(bucket_summaries)
+        v2 = self.v_proj_l2(bucket_summaries)
+
+        # Corrected typo: self.head__dim -> self.head_dim
+        k2 = k2.view(batch_size, num_buckets, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
+        v2 = v2.view(batch_size, num_buckets, self.num_heads, self.head_dim).permute(0, 2, 1, 3)
+
+        attn_scores_l2 = torch.einsum('bhqd,bhnd->bhqn', q2, k2) / self.scale
+        attn_scores_l2 = attn_scores_l2.squeeze(2) # (B, H, N_b)
+        
+        # Optional: Mask entire buckets if they were all padding in L1 (advanced)
+        # For now, assume valid buckets have non-zero summaries
+        # Or if memory_mask indicates all items in a bucket are false, that bucket's summary might be ~0
+        # and L2 attention should naturally give it low weight.
+
+        attn_weights_l2_raw = F.softmax(attn_scores_l2, dim=-1) # (B, H, N_b)
+        bucket_attention_weights_l2_for_output = attn_weights_l2_raw.mean(dim=1) # (B, N_b)
+
+        attn_weights_l2_dropout = self.dropout_l2(attn_weights_l2_raw)
+
+        aggregated_context_heads = torch.einsum('bhn,bhnd->bhd', attn_weights_l2_dropout, v2)
+        aggregated_context = aggregated_context_heads.contiguous().view(batch_size, self.embed_dim)
+
+        # ========================= Final Output Projection ========================
+        final_output = self.out_proj(aggregated_context)
+        final_output = self.norm_final(final_output)
+
+        return final_output, bucket_attention_weights_l2_for_output, item_attention_weights_l1_for_output
+
+# ========================= Example Usage (ALM Standalone) =========================
+if __name__ == '__main__':
+    # Test the modified ALM layer
+    _batch_size = 2
+    _query_dim = 32
+    _memory_dim = 24
+    _embed_dim = 64
+    _num_heads = 4
+    _output_dim = 32
+    _num_buckets = 3
+    _max_items_per_bucket = 5
+
+    alm_layer_test = AttentionLinkedMemory(
+        query_dim=_query_dim, memory_dim=_memory_dim, embed_dim=_embed_dim,
+        num_heads=_num_heads, output_dim=_output_dim
+    )
+
+    query_test = torch.randn(_batch_size, _query_dim)
+    memory_buckets_test = torch.randn(_batch_size, _num_buckets, _max_items_per_bucket, _memory_dim)
+    memory_mask_test = torch.ones(_batch_size, _num_buckets, _max_items_per_bucket, dtype=torch.bool)
+    memory_mask_test[:, :, -1] = 0 # Mask last item in each bucket
+
+    agg_ctx, buck_att, item_att = alm_layer_test(query_test, memory_buckets_test, memory_mask_test)
+
+    print("--- ALM Standalone Test ---")
+    print(f"Aggregated Context Shape: {agg_ctx.shape}") # Expected: (B, output_dim)
+    print(f"Bucket Attention (L2) Shape: {buck_att.shape}") # Expected: (B, num_buckets)
+    print(f"Item Attention (L1) Shape: {item_att.shape}") # Expected: (B, num_buckets, max_items_per_bucket)
+    print("Item Attention for first batch, first bucket:\n", item_att[0, 0, :])
+    print("Sum of item attentions (should be ~1.0 for unmasked items):", item_att[0,0,:-1].sum())
+    print("Attention on masked item (should be ~0.0):", item_att[0,0,-1])
+
+
+# --- END OF FILE ALM.py ---

README.md

@@ -0,0 +1,82 @@
+
+# ALM-Qwen Model: ALM-Qwen-0.5B-testing
+
+This repository contains an Attention-Linked Memory augmented Qwen model (ALM-Qwen).
+
+## Model Components
+
+*   **AttentionLinkedMemory (ALM)**: A custom PyTorch module for two-level attention-based retrieval from structured memory. (See `ALM.py`)
+*   **QwenGenerator**: Wraps a Hugging Face Qwen model (e.g., Qwen2.5-0.5B-Instruct or Qwen2.5-7B-Instruct) for text generation.
+*   **ALMQwenModel_HF**: The main class orchestrating the ALM retrieval and Qwen generation. (See `alm_qwen_hf.py`)
+*   **Saved Weights & Config**:
+    *   `alm_layer_state_dict.pth`: Trained weights for the ALM layer.
+    *   `alm_qwen_hf_config.json`: Configuration for the `ALMQwenModel_HF`, including ALM parameters and paths to the Qwen components.
+    *   `qwen_generator/`: Contains the saved Hugging Face Qwen model and tokenizer.
+
+## How to Use
+
+1.  **Prerequisites**:
+    ```bash
+    pip install torch transformers huggingface_hub sentencepiece accelerate
+    # Add other dependencies if any, e.g., bitsandbytes for quantization
+    ```
+
+2.  **Clone the repository (or download files manually)**:
+    ```bash
+    git lfs install # if large files are used, though typically not for these components directly
+    git clone https://huggingface.co/moelanoby/ALM-Qwen-0.5B-testing
+    cd ALM-Qwen-0.5B-testing
+    ```
+
+3.  **Load the model in Python**:
+    ```python
+    from alm_qwen_hf import ALMQwenModel_HF # Make sure alm_qwen_hf.py and ALM.py are in your PYTHONPATH
+    import torch
+
+    # Desired device
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    # Path to the directory where you cloned/downloaded the model
+    model_directory = "." # Or the specific path if you are running from outside the cloned repo
+
+    # Load the model
+    loaded_model = ALMQwenModel_HF.load_model(model_directory, device=device)
+    print("ALM-Qwen model loaded successfully!")
+
+    # --- Prepare Dummy Input Data (similar to the example in alm_qwen_hf.py) ---
+    # batch_size = 1
+    # alm_query_dim = loaded_model.alm_config['query_dim']
+    # alm_memory_dim = loaded_model.alm_config['memory_dim']
+    # num_kb_buckets = 3 # Example
+    # max_kb_items_per_bucket = 5 # Example
+
+    # query_texts = ["What is the capital of France?"]
+    # query_embeddings_for_alm = torch.randn(batch_size, alm_query_dim)
+    # memory_item_embeddings = torch.randn(batch_size, num_kb_buckets, max_kb_items_per_bucket, alm_memory_dim)
+    # memory_text_items = [[["Paris is the capital of France." for _ in range(max_kb_items_per_bucket)] for _ in range(num_kb_buckets)] for _ in range(batch_size)]
+    # memory_mask = torch.ones(batch_size, num_kb_buckets, max_kb_items_per_bucket, dtype=torch.bool)
+    # memory_mask[:, :, -1] = False # Example mask
+
+    # # Run inference
+    # generated_answers, _, _ = loaded_model(
+    #     query_texts,
+    #     query_embeddings_for_alm,
+    #     memory_item_embeddings,
+    #     memory_text_items,
+    #     memory_mask
+    # )
+    # print(f"Query: {query_texts[0]}")
+    # print(f"Answer: {generated_answers[0]}")
+    ```
+
+## Training
+
+The ALM layer (`alm_layer_state_dict.pth`) might have been trained. The Qwen model inside `qwen_generator/` is typically a pre-trained model from Hugging Face, possibly fine-tuned.
+
+## Notes
+
+*   The Qwen model components can be large. Ensure you have sufficient disk space and network bandwidth.
+*   The `load_model` method in `alm_qwen_hf.py` handles the reconstruction of the composite model.
+
+---
+*This README was auto-generated. Please update with more specific details about your model.*

alm_layer_state_dict.pth

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

alm_qwen_hf_config.json

@@ -0,0 +1,14 @@
+{
+    "alm_config": {
+        "query_dim": 128,
+        "memory_dim": 64,
+        "embed_dim": 256,
+        "num_heads": 8,
+        "output_dim": 128,
+        "dropout_rate": 0.0
+    },
+    "qwen_model_name_or_path": "qwen_generator/qwen_model",
+    "qwen_tokenizer_path": "qwen_generator/qwen_tokenizer",
+    "top_k_buckets": 2,
+    "top_k_items_per_bucket": 1
+}

qwen_generator/qwen_model/config.json

@@ -0,0 +1,28 @@
+{
+  "architectures": [
+    "Qwen2ForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 151643,
+  "eos_token_id": 151645,
+  "hidden_act": "silu",
+  "hidden_size": 896,
+  "initializer_range": 0.02,
+  "intermediate_size": 4864,
+  "max_position_embeddings": 32768,
+  "max_window_layers": 21,
+  "model_type": "qwen2",
+  "num_attention_heads": 14,
+  "num_hidden_layers": 24,
+  "num_key_value_heads": 2,
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 1000000.0,
+  "sliding_window": 32768,
+  "tie_word_embeddings": true,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.51.3",
+  "use_cache": true,
+  "use_sliding_window": false,
+  "vocab_size": 151936
+}

qwen_generator/qwen_model/generation_config.json

@@ -0,0 +1,14 @@
+{
+  "bos_token_id": 151643,
+  "do_sample": true,
+  "eos_token_id": [
+    151645,
+    151643
+  ],
+  "pad_token_id": 151643,
+  "repetition_penalty": 1.1,
+  "temperature": 0.7,
+  "top_k": 20,
+  "top_p": 0.8,
+  "transformers_version": "4.51.3"
+}

qwen_generator/qwen_model/model.safetensors

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

qwen_generator/qwen_tokenizer/added_tokens.json

@@ -0,0 +1,24 @@
+{
+  "</tool_call>": 151658,
+  "<tool_call>": 151657,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

qwen_generator/qwen_tokenizer/special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "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
+  }
+}

qwen_generator/qwen_tokenizer/tokenizer.json

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

qwen_generator/qwen_tokenizer/tokenizer_config.json

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