Training in progress, step 20000

README.md

@@ -0,0 +1,47 @@
+---
+tags:
+- generated_from_trainer
+model-index:
+- name: myBit-Llama2-jp-127M-8
+  results: []
+---
+
+<!-- This model card has been generated automatically according to the information the Trainer had access to. You
+should probably proofread and complete it, then remove this comment. -->
+
+# myBit-Llama2-jp-127M-8
+
+This model is a fine-tuned version of [](https://huggingface.co/) on an unknown dataset.
+
+## Model description
+
+More information needed
+
+## Intended uses & limitations
+
+More information needed
+
+## Training and evaluation data
+
+More information needed
+
+## Training procedure
+
+### Training hyperparameters
+
+The following hyperparameters were used during training:
+- learning_rate: 0.0024
+- train_batch_size: 48
+- eval_batch_size: 16
+- seed: 42
+- optimizer: Adam with betas=(0.9,0.95) and epsilon=1e-08
+- lr_scheduler_type: linear
+- lr_scheduler_warmup_steps: 5000
+- num_epochs: 2
+
+### Framework versions
+
+- Transformers 4.38.2
+- Pytorch 2.3.0+cu121
+- Datasets 2.20.0
+- Tokenizers 0.15.2

config.json

@@ -1,4 +1,5 @@
 {
+  "_name_or_path": "stardust-coder/myBit-Llama2-jp-127M-8",
   "architectures": [
     "BitLlamaForCausalLM"
   ],

generation_config.json

@@ -0,0 +1,6 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "transformers_version": "4.38.2"
+}

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b581acb80ad24fa7c79ad61c35fcf509c3b6bc9663f05ee558665fc5b9fb4381
+oid sha256:26f3b718f41f41050fc0e3d3c5fa0e0cd9d71e89acf95a5680e1eab5e3f7bb68
 size 510960712

modeling_bit_llama.py

@@ -0,0 +1,169 @@
+import warnings
+from typing import Optional, Tuple
+from transformers.models.llama.modeling_llama import (
+    LlamaConfig, 
+    LlamaModel,
+    LlamaForCausalLM,
+    LlamaAttention,
+    LlamaFlashAttention2,
+    LlamaSdpaAttention,
+    LlamaMLP,
+    LlamaDecoderLayer,
+)
+from mybitnet.bitnet import BitLinear, BitLinear158b
+import torch
+from torch import nn
+
+class BitLlamaConfig(LlamaConfig):
+    model_type = "bit_llama"
+
+    def __init__(self, bitnet_type="1.58b", bits=8, **kwargs):
+        super().__init__(**kwargs)
+        self.bitnet_type = bitnet_type
+        if self.bitnet_type not in ["1.58b", "1b"]:
+            raise ValueError("bitnet_type must be either '1.58b' or '1b'.")
+        self.bits = bits
+
+
+class BitLlamaMLP(LlamaMLP):
+    def __init__(self, config):
+        super().__init__(config)
+        if config.bitnet_type=="1b":
+            self.gate_proj = BitLinear(self.hidden_size, self.intermediate_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=False)
+            self.up_proj = BitLinear(self.hidden_size, self.intermediate_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.down_proj = BitLinear(self.intermediate_size, self.hidden_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+        elif config.bitnet_type=="1.58b":
+            self.gate_proj = BitLinear158b(self.hidden_size, self.intermediate_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.up_proj = BitLinear158b(self.hidden_size, self.intermediate_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.down_proj = BitLinear158b(self.intermediate_size, self.hidden_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+        else:
+            raise ValueError("bitnet_type must be either '1.58b' or '1b'.")
+        
+class BitLlamaAttention(LlamaAttention):
+    def __init__(self, config: BitLlamaConfig, layer_idx: Optional[int] = None):
+        super().__init__(config)
+        if config.bitnet_type=="1b":
+            self.q_proj = BitLinear(self.hidden_size, self.num_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.k_proj = BitLinear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.v_proj = BitLinear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.o_proj = BitLinear(self.hidden_size, self.hidden_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+        elif config.bitnet_type=="1.58b":
+            self.q_proj = BitLinear158b(self.hidden_size, self.num_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.k_proj = BitLinear158b(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.v_proj = BitLinear158b(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.o_proj = BitLinear158b(self.hidden_size, self.hidden_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+        else:
+            raise ValueError("bitnet_type must be either '1.58b' or '1b'.")
+
+class BitLlamaFlashAttention2(LlamaFlashAttention2):
+    def __init__(self, config: BitLlamaConfig, layer_idx: Optional[int] = None):
+        super().__init__(config, layer_idx)
+        if config.bitnet_type=="1b":
+            self.q_proj = BitLinear(self.hidden_size, self.num_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.k_proj = BitLinear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.v_proj = BitLinear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.o_proj = BitLinear(self.hidden_size, self.hidden_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+        elif config.bitnet_type=="1.58b":
+            self.q_proj = BitLinear158b(self.hidden_size, self.num_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.k_proj = BitLinear158b(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.v_proj = BitLinear158b(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.o_proj = BitLinear158b(self.hidden_size, self.hidden_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+        else:
+            raise ValueError("bitnet_type must be either '1.58b' or '1b'.")
+
+class BitLlamaSdpaAttention(LlamaSdpaAttention):
+    def __init__(self, config: BitLlamaConfig, layer_idx: Optional[int] = None):
+        super().__init__(config, layer_idx)
+        if config.bitnet_type=="1b":
+            self.q_proj = BitLinear(self.hidden_size, self.num_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.k_proj = BitLinear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.v_proj = BitLinear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+            self.o_proj = BitLinear(self.hidden_size, self.hidden_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits, flg_before_linear=True)
+        elif config.bitnet_type=="1.58b":
+            self.q_proj = BitLinear158b(self.hidden_size, self.num_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.k_proj = BitLinear158b(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.v_proj = BitLinear158b(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+            self.o_proj = BitLinear158b(self.hidden_size, self.hidden_size, bias=False, rms_norm_eps=config.rms_norm_eps, bits=config.bits)
+        else:
+            raise ValueError("bitnet_type must be either '1.58b' or '1b'.")
+
+BITLLAMA_ATTENTION_CLASSES = {
+    "eager": BitLlamaAttention,
+    "flash_attention_2": BitLlamaFlashAttention2,
+    "sdpa": BitLlamaSdpaAttention,
+}
+
+class BitLlamaDecoderLayer(LlamaDecoderLayer):
+    def __init__(self, config: BitLlamaConfig, layer_idx: int):
+        super().__init__(config, layer_idx)
+        self.self_attn = BITLLAMA_ATTENTION_CLASSES[config._attn_implementation](config=config, layer_idx=layer_idx)
+        self.mlp = BitLlamaMLP(config)
+        del self.input_layernorm
+        del self.post_attention_layernorm
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Tuple[torch.Tensor]] = None,
+        output_attentions: Optional[bool] = False,
+        use_cache: Optional[bool] = False,
+        cache_position: Optional[torch.LongTensor] = None,
+        **kwargs,
+    ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]:
+        """
+        refers: https://github.com/huggingface/transformers/blob/c5f0288bc7d76f65996586f79f69fba8867a0e67/src/transformers/models/llama/modeling_llama.py#L693
+        """
+        if "padding_mask" in kwargs:
+            warnings.warn(
+                "Passing `padding_mask` is deprecated and will be removed in v4.37. Please make sure use `attention_mask` instead.`"
+            )
+
+        residual = hidden_states
+
+        # Self Attention
+        hidden_states, self_attn_weights, present_key_value = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_value=past_key_value,
+            output_attentions=output_attentions,
+            use_cache=use_cache,
+            cache_position=cache_position,
+            **kwargs,
+        )
+        hidden_states = residual + hidden_states
+
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+
+        outputs = (hidden_states,)
+
+        if output_attentions:
+            outputs += (self_attn_weights,)
+
+        if use_cache:
+            outputs += (present_key_value,)
+
+        return outputs
+
+class BitLlamaModel(LlamaModel):
+    config_class = BitLlamaConfig
+
+    def __init__(self, config: BitLlamaConfig):
+        super().__init__(config)
+        self.layers = nn.ModuleList(
+            [BitLlamaDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+        )
+
+class BitLlamaForCausalLM(LlamaForCausalLM):
+    config_class = BitLlamaConfig
+
+    def __init__(self, config: BitLlamaConfig):
+        super().__init__(config)
+        self.model = BitLlamaModel(config)
+        self.lm_head = BitLinear(config.hidden_size, config.vocab_size, bias=False, bits=config.bits, flg_before_linear=True)
+        

tokenizer.json

@@ -1,11 +1,6 @@
 {
   "version": "1.0",
-  "truncation": {
-    "direction": "Right",
-    "max_length": 128,
-    "strategy": "LongestFirst",
-    "stride": 0
-  },
+  "truncation": null,
   "padding": null,
   "added_tokens": [
     {

training_args.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:378c8dca9ab4008867b807e0eeddacf9aa311c85503fe3aaab57ed4de6c904ef
+oid sha256:6c8e7ec44e1776ef605b9c45d71c47e2f1c7215e1d93d69c6f5fa553f95458d8
 size 4856