Upload Jeeves model (trust_remote_code)

README.md

@@ -0,0 +1,51 @@
+---
+library_name: transformers
+tags:
+- jeeves
+- causal-lm
+- looped-transformer
+- value-residual
+- sentencepiece
+license: apache-2.0
+---
+
+# Jeeves (75M)
+
+A compact language model using **Looped Transformer + Value Residual Learning**.
+
+## Usage
+
+```python
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+tokenizer = AutoTokenizer.from_pretrained("REPO_ID", trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained("REPO_ID", trust_remote_code=True)
+
+inputs = tokenizer("Hello, how are you?", return_tensors="pt")
+outputs = model.generate(**inputs, max_new_tokens=50)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+```
+
+**Note:** `trust_remote_code=True` is required.
+
+## Architecture
+
+| Component | Value |
+|---|---|
+| Parameters | 74.9M |
+| Unique layers | 8 |
+| Effective depth | 15 |
+| Loop | block[4] x 8 |
+| Value residual | True |
+| Hidden dim | 768 |
+| FFN dim | 2048 |
+| Attention heads | 12 (Q) / 4 (KV) |
+| Vocab size | 32,000 |
+| Max seq length | 512 |
+| Training step | 1,100 |
+
+## Key Innovations
+
+- **Looped Transformer** ([arXiv 2311.12424](https://arxiv.org/abs/2311.12424))
+- **Value Residual Learning** ([arXiv 2410.17897](https://arxiv.org/abs/2410.17897))
+- **Input Injection** for loop stability

config.json

@@ -0,0 +1,40 @@
+{
+  "architectures": [
+    "JeevesForCausalLM"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_jeeves.JeevesConfig",
+    "AutoModelForCausalLM": "modeling_jeeves.JeevesForCausalLM",
+    "AutoTokenizer": [
+      "tokenization_jeeves.JeevesTokenizer",
+      null
+    ]
+  },
+  "bos_token_id": 1,
+  "d_ff": 2048,
+  "d_model": 768,
+  "dropout": 0.0,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "head_dim": 64,
+  "hidden_size": 768,
+  "init_std": 0.02,
+  "loop_block_idx": 4,
+  "max_seq_len": 512,
+  "model_type": "jeeves",
+  "n_heads": 12,
+  "n_kv_heads": 4,
+  "n_layers": 8,
+  "n_loop_iters": 8,
+  "norm_eps": 1e-05,
+  "pad_token_id": 0,
+  "rope_base": 10000.0,
+  "tie_embeddings": true,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0",
+  "use_flash_attention": false,
+  "use_input_injection": true,
+  "use_value_residual": true,
+  "value_residual_alpha_init": -2.0,
+  "vocab_size": 32000
+}

configuration_jeeves.py

@@ -0,0 +1,96 @@
+"""HuggingFace-compatible configuration for Jeeves.
+
+This file gets uploaded to the Hub so users can load with:
+    from transformers import AutoConfig
+    config = AutoConfig.from_pretrained("Anurich/Jeeves-Small-75M", trust_remote_code=True)
+"""
+
+from transformers import PretrainedConfig
+
+
+class JeevesConfig(PretrainedConfig):
+    """Configuration for the Jeeves language model.
+
+    Jeeves uses a Looped Transformer architecture with Value Residual Learning.
+    A single middle block is run N times (looped) with input injection,
+    giving effective depth much larger than the number of unique parameters.
+    """
+
+    model_type = "jeeves"
+
+    def __init__(
+        self,
+        d_model: int = 768,
+        n_layers: int = 8,
+        n_heads: int = 12,
+        n_kv_heads: int = 4,
+        vocab_size: int = 32000,
+        max_seq_len: int = 512,
+        d_ff: int = None,
+        norm_eps: float = 1e-5,
+        rope_base: float = 10000.0,
+        tie_embeddings: bool = True,
+        dropout: float = 0.0,
+        init_std: float = 0.02,
+        use_flash_attention: bool = True,
+        # Looped Transformer
+        loop_block_idx: int = None,
+        n_loop_iters: int = 1,
+        use_input_injection: bool = True,
+        # Value Residual Learning
+        use_value_residual: bool = False,
+        value_residual_alpha_init: float = -2.0,
+        # Special tokens
+        pad_token_id: int = 0,
+        bos_token_id: int = 1,
+        eos_token_id: int = 2,
+        **kwargs,
+    ):
+        # HF saves tie_word_embeddings in config.json; avoid passing it twice
+        kwargs.pop("tie_word_embeddings", None)
+        super().__init__(
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_embeddings,
+            **kwargs,
+        )
+        self.d_model = d_model
+        self.n_layers = n_layers
+        self.n_heads = n_heads
+        self.n_kv_heads = n_kv_heads
+        self.vocab_size = vocab_size
+        self.max_seq_len = max_seq_len
+        self.norm_eps = norm_eps
+        self.rope_base = rope_base
+        self.tie_embeddings = tie_embeddings
+        self.dropout = dropout
+        self.init_std = init_std
+        self.use_flash_attention = use_flash_attention
+
+        # Looped Transformer
+        self.loop_block_idx = loop_block_idx
+        self.n_loop_iters = n_loop_iters
+        self.use_input_injection = use_input_injection
+
+        # Value Residual Learning
+        self.use_value_residual = use_value_residual
+        self.value_residual_alpha_init = value_residual_alpha_init
+
+        # Compute FFN dimension
+        if d_ff is None:
+            raw = int(8 / 3 * d_model)
+            self.d_ff = ((raw + 255) // 256) * 256
+        else:
+            self.d_ff = d_ff
+
+        # Derived
+        self.head_dim = d_model // n_heads
+        self.hidden_size = d_model  # HF convention
+
+    @property
+    def effective_depth(self) -> int:
+        if self.loop_block_idx is not None:
+            return (self.loop_block_idx + self.n_loop_iters
+                    + (self.n_layers - self.loop_block_idx - 1))
+        return self.n_layers

generation_config.json

@@ -0,0 +1,9 @@
+{
+  "do_sample": true,
+  "temperature": 0.7,
+  "top_k": 50,
+  "top_p": 0.9,
+  "max_new_tokens": 512,
+  "eos_token_id": 2,
+  "pad_token_id": 0
+}

model.safetensors

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

modeling_jeeves.py

@@ -0,0 +1,314 @@
+"""HuggingFace-compatible Jeeves model.
+
+This file gets uploaded to the Hub so users can load with:
+    from transformers import AutoModelForCausalLM
+    model = AutoModelForCausalLM.from_pretrained("Anurich/Jeeves-Small-75M", trust_remote_code=True)
+
+The architecture is self-contained — no local imports needed.
+Features: Looped Transformer + Value Residual Learning + GQA + RoPE + SwiGLU.
+"""
+
+import math
+from typing import Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import GenerationMixin, PreTrainedModel
+from transformers.modeling_outputs import CausalLMOutputWithPast
+
+from .configuration_jeeves import JeevesConfig
+
+
+# ---------------------------------------------------------------------------
+# Core layers
+# ---------------------------------------------------------------------------
+
+class RMSNorm(nn.Module):
+    """Root Mean Square Layer Normalization."""
+    def __init__(self, dim: int, eps: float = 1e-5):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        output = x.float() * torch.rsqrt(x.float().pow(2).mean(-1, keepdim=True) + self.eps)
+        return output.type_as(x) * self.weight
+
+
+class SwiGLUFFN(nn.Module):
+    """SwiGLU Feed-Forward Network."""
+    def __init__(self, d_model: int, d_ff: int, dropout: float = 0.0):
+        super().__init__()
+        self.gate_proj = nn.Linear(d_model, d_ff, bias=False)
+        self.up_proj = nn.Linear(d_model, d_ff, bias=False)
+        self.down_proj = nn.Linear(d_ff, d_model, bias=False)
+        self.dropout = nn.Dropout(dropout) if dropout > 0 else nn.Identity()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.dropout(self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x)))
+
+
+# ---------------------------------------------------------------------------
+# RoPE
+# ---------------------------------------------------------------------------
+
+def precompute_rope_freqs(head_dim: int, max_seq_len: int, base: float = 10000.0,
+                          device=None) -> torch.Tensor:
+    freqs = 1.0 / (base ** (torch.arange(0, head_dim, 2, device=device).float() / head_dim))
+    t = torch.arange(max_seq_len, device=device).float()
+    freqs = torch.outer(t, freqs)
+    return torch.polar(torch.ones_like(freqs), freqs)
+
+
+def apply_rope(q, k, freqs_cis):
+    if q.device.type == 'mps':
+        return _apply_rope_real(q, k, freqs_cis)
+    q_c = torch.view_as_complex(q.float().reshape(*q.shape[:-1], -1, 2))
+    k_c = torch.view_as_complex(k.float().reshape(*k.shape[:-1], -1, 2))
+    f = freqs_cis.unsqueeze(0).unsqueeze(2)
+    q_r = torch.view_as_real(q_c * f).flatten(-2)
+    k_r = torch.view_as_real(k_c * f).flatten(-2)
+    return q_r.type_as(q), k_r.type_as(k)
+
+
+def _apply_rope_real(q, k, freqs_cis):
+    cos = freqs_cis.real.unsqueeze(0).unsqueeze(2)
+    sin = freqs_cis.imag.unsqueeze(0).unsqueeze(2)
+
+    def _rotate(x):
+        pairs = x.float().reshape(*x.shape[:-1], -1, 2)
+        r, i = pairs[..., 0], pairs[..., 1]
+        out = torch.stack([r * cos - i * sin, r * sin + i * cos], dim=-1).flatten(-2)
+        return out.type_as(x)
+
+    return _rotate(q), _rotate(k)
+
+
+def repeat_kv(x: torch.Tensor, n_rep: int) -> torch.Tensor:
+    if n_rep == 1:
+        return x
+    b, s, kv, d = x.shape
+    return x[:, :, :, None, :].expand(b, s, kv, n_rep, d).reshape(b, s, kv * n_rep, d)
+
+
+# ---------------------------------------------------------------------------
+# Attention with Value Residual Learning
+# ---------------------------------------------------------------------------
+
+class GQAWithValueResidual(nn.Module):
+    """Grouped-Query Attention with optional Value Residual Learning."""
+
+    def __init__(self, config: JeevesConfig):
+        super().__init__()
+        self.d_model = config.d_model
+        self.n_heads = config.n_heads
+        self.n_kv_heads = config.n_kv_heads
+        self.head_dim = config.head_dim
+        self.n_kv_groups = config.n_heads // config.n_kv_heads
+        self.use_flash_attention = config.use_flash_attention
+        self.use_value_residual = config.use_value_residual
+
+        self.q_proj = nn.Linear(config.d_model, config.n_heads * config.head_dim, bias=False)
+        self.k_proj = nn.Linear(config.d_model, config.n_kv_heads * config.head_dim, bias=False)
+        self.v_proj = nn.Linear(config.d_model, config.n_kv_heads * config.head_dim, bias=False)
+        self.o_proj = nn.Linear(config.n_heads * config.head_dim, config.d_model, bias=False)
+        self.attn_dropout = nn.Dropout(config.dropout) if config.dropout > 0 else nn.Identity()
+
+        if config.use_value_residual:
+            self.alpha_logit = nn.Parameter(torch.tensor(config.value_residual_alpha_init))
+
+    def forward(self, x, freqs_cis, mask=None, first_layer_v=None):
+        batch, seq_len, _ = x.shape
+        q = self.q_proj(x).view(batch, seq_len, self.n_heads, self.head_dim)
+        k = self.k_proj(x).view(batch, seq_len, self.n_kv_heads, self.head_dim)
+        v = self.v_proj(x).view(batch, seq_len, self.n_kv_heads, self.head_dim)
+        raw_v = v
+
+        if self.use_value_residual and first_layer_v is not None:
+            alpha = torch.sigmoid(self.alpha_logit)
+            v = (1.0 - alpha) * v + alpha * first_layer_v
+
+        q, k = apply_rope(q, k, freqs_cis)
+        k = repeat_kv(k, self.n_kv_groups)
+        v = repeat_kv(v, self.n_kv_groups)
+
+        q, k, v = q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)
+
+        is_accel = q.is_cuda or q.device.type == 'mps'
+        if self.use_flash_attention and is_accel:
+            attn_out = F.scaled_dot_product_attention(q, k, v, attn_mask=None, is_causal=True)
+        else:
+            scale = 1.0 / math.sqrt(self.head_dim)
+            scores = torch.matmul(q, k.transpose(-2, -1)) * scale
+            if mask is not None:
+                scores = scores + mask
+            w = F.softmax(scores, dim=-1, dtype=torch.float32).type_as(q)
+            w = self.attn_dropout(w)
+            attn_out = torch.matmul(w, v)
+
+        attn_out = attn_out.transpose(1, 2).contiguous().view(batch, seq_len, -1)
+        return self.o_proj(attn_out), raw_v
+
+
+# ---------------------------------------------------------------------------
+# Transformer Block
+# ---------------------------------------------------------------------------
+
+class TransformerBlock(nn.Module):
+    def __init__(self, config: JeevesConfig):
+        super().__init__()
+        self.attn_norm = RMSNorm(config.d_model, eps=config.norm_eps)
+        self.attention = GQAWithValueResidual(config)
+        self.ffn_norm = RMSNorm(config.d_model, eps=config.norm_eps)
+        self.ffn = SwiGLUFFN(config.d_model, config.d_ff, config.dropout)
+
+    def forward(self, x, freqs_cis, mask=None, first_layer_v=None):
+        h, raw_v = self.attention(self.attn_norm(x), freqs_cis, mask, first_layer_v)
+        x = x + h
+        x = x + self.ffn(self.ffn_norm(x))
+        return x, raw_v
+
+
+# ---------------------------------------------------------------------------
+# Jeeves Model (HuggingFace-compatible)
+# ---------------------------------------------------------------------------
+
+class JeevesForCausalLM(PreTrainedModel, GenerationMixin):
+    """Jeeves: Looped Transformer + Value Residual Learning.
+
+    Loads native Jeeves weights directly — no conversion needed.
+    """
+    config_class = JeevesConfig
+    supports_gradient_checkpointing = False
+    _tied_weights_keys = {"lm_head.weight": "tok_emb.weight"}
+
+    def __init__(self, config: JeevesConfig):
+        super().__init__(config)
+        self.config = config
+
+        # Embedding
+        self.tok_emb = nn.Embedding(config.vocab_size, config.d_model)
+
+        # Layer structure
+        if config.loop_block_idx is not None:
+            n_early = config.loop_block_idx
+            n_late = config.n_layers - config.loop_block_idx - 1
+            self.early_layers = nn.ModuleList([TransformerBlock(config) for _ in range(n_early)])
+            self.loop_block = TransformerBlock(config)
+            self.late_layers = nn.ModuleList([TransformerBlock(config) for _ in range(n_late)])
+            self.n_loop_iters = config.n_loop_iters
+            self.use_input_injection = config.use_input_injection
+            self.looped = True
+        else:
+            self.layers = nn.ModuleList([TransformerBlock(config) for _ in range(config.n_layers)])
+            self.looped = False
+
+        self.norm = RMSNorm(config.d_model, eps=config.norm_eps)
+        self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
+
+        if config.tie_embeddings:
+            self.lm_head.weight = self.tok_emb.weight
+
+        # Store RoPE params — freqs_cis is computed fresh in forward()
+        # to avoid corruption from HF's meta-device initialization
+        self._rope_head_dim = config.head_dim
+        self._rope_max_seq_len = config.max_seq_len
+        self._rope_base = config.rope_base
+        self._freqs_cache = None
+
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.tok_emb
+
+    def set_input_embeddings(self, value):
+        self.tok_emb = value
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head = new_embeddings
+
+    def _get_freqs_cis(self, seq_len: int, device: torch.device) -> torch.Tensor:
+        """Get RoPE frequencies, computing and caching on first call."""
+        if self._freqs_cache is None or self._freqs_cache.device != device:
+            self._freqs_cache = precompute_rope_freqs(
+                self._rope_head_dim, self._rope_max_seq_len, self._rope_base, device
+            )
+        return self._freqs_cache[:seq_len]
+
+    def _make_causal_mask(self, seq_len, device):
+        mask = torch.full((seq_len, seq_len), float("-inf"), device=device)
+        return torch.triu(mask, diagonal=1)
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        **kwargs,
+    ) -> CausalLMOutputWithPast:
+        if inputs_embeds is None:
+            h = self.tok_emb(input_ids)
+        else:
+            h = inputs_embeds
+
+        batch, seq_len, _ = h.shape
+        device = h.device
+        freqs_cis = self._get_freqs_cis(seq_len, device)
+
+        mask = None
+        is_accel = h.is_cuda or h.device.type == 'mps'
+        if not self.config.use_flash_attention or not is_accel:
+            mask = self._make_causal_mask(seq_len, device)
+
+        first_layer_v = None
+
+        if self.looped:
+            # Early layers
+            for i, layer in enumerate(self.early_layers):
+                h, raw_v = layer(h, freqs_cis, mask, first_layer_v)
+                if i == 0 and self.config.use_value_residual:
+                    first_layer_v = raw_v
+
+            # Looped block with input injection
+            loop_input = h
+            for loop_iter in range(self.n_loop_iters):
+                h, _ = self.loop_block(h, freqs_cis, mask, first_layer_v)
+                if self.use_input_injection and loop_iter < self.n_loop_iters - 1:
+                    h = h + loop_input
+
+            # Late layers
+            for layer in self.late_layers:
+                h, _ = layer(h, freqs_cis, mask, first_layer_v)
+        else:
+            for i, layer in enumerate(self.layers):
+                h, raw_v = layer(h, freqs_cis, mask, first_layer_v)
+                if i == 0 and self.config.use_value_residual:
+                    first_layer_v = raw_v
+
+        h = self.norm(h)
+        logits = self.lm_head(h)
+
+        loss = None
+        if labels is not None:
+            loss = F.cross_entropy(
+                logits.view(-1, self.config.vocab_size),
+                labels.view(-1),
+                ignore_index=-100,
+            )
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+        )
+
+    def prepare_inputs_for_generation(self, input_ids, **kwargs):
+        return {"input_ids": input_ids}
+
+    @staticmethod
+    def _reorder_cache(past, beam_idx):
+        return past

special_tokens_map.json

@@ -0,0 +1,15 @@
+{
+  "bos_token": "<s>",
+  "eos_token": "</s>",
+  "unk_token": "<unk>",
+  "pad_token": "<pad>",
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|tool_call|>",
+    "<|tool_result|>",
+    "<|system|>",
+    "<|user|>",
+    "<|assistant|>"
+  ]
+}

tokenization_jeeves.py

@@ -0,0 +1,106 @@
+"""Custom SentencePiece tokenizer for Jeeves model.
+
+Wraps SentencePiece directly for exact token ID match with training.
+
+Usage:
+    from transformers import AutoTokenizer
+    tokenizer = AutoTokenizer.from_pretrained("REPO_ID", trust_remote_code=True)
+"""
+
+import os
+from typing import Dict, List, Optional, Tuple
+
+import sentencepiece as spm
+from transformers import PreTrainedTokenizer
+
+
+class JeevesTokenizer(PreTrainedTokenizer):
+    """SentencePiece BPE tokenizer for Jeeves models."""
+
+    vocab_files_names = {"vocab_file": "tokenizer.model"}
+    model_input_names = ["input_ids", "attention_mask"]
+
+    def __init__(
+        self,
+        vocab_file: str,
+        bos_token: str = "<s>",
+        eos_token: str = "</s>",
+        unk_token: str = "<unk>",
+        pad_token: str = "<pad>",
+        chat_template: Optional[str] = None,
+        additional_special_tokens: Optional[List[str]] = None,
+        **kwargs,
+    ):
+        self.vocab_file = vocab_file
+        self.sp_model = spm.SentencePieceProcessor()
+        self.sp_model.Load(vocab_file)
+
+        if additional_special_tokens is None:
+            additional_special_tokens = [
+                "<|im_start|>", "<|im_end|>",
+                "<|tool_call|>", "<|tool_result|>",
+                "<|system|>", "<|user|>", "<|assistant|>",
+            ]
+
+        super().__init__(
+            bos_token=bos_token, eos_token=eos_token,
+            unk_token=unk_token, pad_token=pad_token,
+            additional_special_tokens=additional_special_tokens,
+            chat_template=chat_template, **kwargs,
+        )
+
+    @property
+    def vocab_size(self) -> int:
+        return self.sp_model.GetPieceSize()
+
+    def get_vocab(self) -> Dict[str, int]:
+        vocab = {self.sp_model.IdToPiece(i): i for i in range(self.vocab_size)}
+        vocab.update(self.added_tokens_encoder)
+        return vocab
+
+    def _tokenize(self, text: str) -> List[str]:
+        return self.sp_model.EncodeAsPieces(text)
+
+    def _convert_token_to_id(self, token: str) -> int:
+        return self.sp_model.PieceToId(token)
+
+    def _convert_id_to_token(self, index: int) -> str:
+        if index < 0 or index >= self.vocab_size:
+            return self.unk_token
+        return self.sp_model.IdToPiece(index)
+
+    def convert_tokens_to_string(self, tokens: List[str]) -> str:
+        return self.sp_model.DecodePieces(tokens)
+
+    def save_vocabulary(
+        self, save_directory: str, filename_prefix: Optional[str] = None
+    ) -> Tuple[str]:
+        if not os.path.isdir(save_directory):
+            os.makedirs(save_directory, exist_ok=True)
+        out_path = os.path.join(
+            save_directory,
+            (filename_prefix + "-" if filename_prefix else "") + "tokenizer.model",
+        )
+        if os.path.abspath(self.vocab_file) != os.path.abspath(out_path):
+            import shutil
+            shutil.copyfile(self.vocab_file, out_path)
+        return (out_path,)
+
+    def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):
+        if token_ids_1 is None:
+            return token_ids_0
+        return token_ids_0 + token_ids_1
+
+    def get_special_tokens_mask(self, token_ids_0, token_ids_1=None, already_has_special_tokens=False):
+        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,
+            )
+        n = len(token_ids_0) + (len(token_ids_1) if token_ids_1 else 0)
+        return [0] * n
+
+    def create_token_type_ids_from_sequences(self, token_ids_0, token_ids_1=None):
+        if token_ids_1 is None:
+            return [0] * len(token_ids_0)
+        return [0] * len(token_ids_0) + [1] * len(token_ids_1)

tokenizer.model

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

tokenizer_config.json

@@ -0,0 +1,26 @@
+{
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_jeeves.JeevesTokenizer",
+      null
+    ]
+  },
+  "tokenizer_class": "JeevesTokenizer",
+  "bos_token": "<s>",
+  "eos_token": "</s>",
+  "unk_token": "<unk>",
+  "pad_token": "<pad>",
+  "chat_template": "{% for message in messages %}<|im_start|>{{ message['role'] }}\n{{ message['content'] }}<|im_end|>\n{% endfor %}{% if add_generation_prompt %}<|im_start|>assistant\n{% endif %}",
+  "add_bos_token": false,
+  "add_eos_token": false,
+  "clean_up_tokenization_spaces": false,
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|tool_call|>",
+    "<|tool_result|>",
+    "<|system|>",
+    "<|user|>",
+    "<|assistant|>"
+  ]
+}