Upload folder using huggingface_hub

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,3 @@
+---
+license: mit
+---

configuration_plm.py

@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """PLM model configuration"""
-# Test test
 from transformers.configuration_utils import PretrainedConfig
 from transformers.utils import logging
 
@@ -23,28 +22,27 @@ logger = logging.get_logger(__name__)
 
 class PLMConfig(PretrainedConfig):
     r"""
-    This is the configuration class to store the configuration of a [`Qwen2Model`]. It is used to instantiate a
-    Qwen2 model according to the specified arguments, defining the model architecture. Instantiating a configuration
-    with the defaults will yield a similar configuration to that of
-    Qwen2-7B-beta [Qwen/Qwen2-7B-beta](https://huggingface.co/Qwen/Qwen2-7B-beta).
+    This is the configuration class to store the configuration of a [`PLMModel`]. It is used to instantiate a
+    PLM 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.
+    documentation from [`PretrainedConfig`] for more information. Instantiating a configuration with the
+    defaults will yield a similar configuration to that of the PLM model.
 
 
     Args:
         vocab_size (`int`, *optional*, defaults to 151936):
-            Vocabulary size of the Qwen2 model. Defines the number of different tokens that can be represented by the
-            `inputs_ids` passed when calling [`Qwen2Model`]
+            Vocabulary size of the PLM model. Defines the number of different tokens that can be represented by the
+            `inputs_ids` passed when calling [`PLMModel`]
         hidden_size (`int`, *optional*, defaults to 4096):
             Dimension of the hidden representations.
-        intermediate_size (`int`, *optional*, defaults to 22016):
+        intermediate_size (`int`, *optional*, defaults to 8192):
             Dimension of the MLP representations.
         num_hidden_layers (`int`, *optional*, defaults to 32):
             Number of hidden layers in the Transformer encoder.
-        num_attention_heads (`int`, *optional*, defaults to 32):
+        num_attention_heads (`int`, *optional*, defaults to 16):
             Number of attention heads for each attention layer in the Transformer encoder.
-        num_key_value_heads (`int`, *optional*, defaults to 32):
+        num_key_value_heads (`int`, *optional*, defaults to 16):
             This is the number of key_value heads that should be used to implement Grouped Query Attention. 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) otherwise GQA is used. When
@@ -53,7 +51,12 @@ class PLMConfig(PretrainedConfig):
             paper](https://arxiv.org/pdf/2305.13245.pdf). If it is not specified, will default to `32`.
         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 32768):
+        pretraining_tp (`int`, *optional*, defaults to 1):
+            Experimental feature. Tensor parallelism rank used during pretraining. Please refer to [this
+            document](https://huggingface.co/docs/transformers/parallelism) to understand more about it. This value is
+            necessary to ensure exact reproducibility of the pretraining results. Please refer to [this
+            issue](https://github.com/pytorch/pytorch/issues/76232).
+        max_position_embeddings (`int`, *optional*, defaults to 4096):
             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.
@@ -62,27 +65,25 @@ class PLMConfig(PretrainedConfig):
         use_cache (`bool`, *optional*, defaults to `True`):
             Whether or not the model should return the last key/values attentions (not used by all models). Only
             relevant if `config.is_decoder=True`.
-        tie_word_embeddings (`bool`, *optional*, defaults to `False`):
+        tie_word_embeddings (`bool`, *optional*, defaults to `True`):
             Whether the model's input and output word embeddings should be tied.
-        rope_theta (`float`, *optional*, defaults to 10000.0):
+        rope_scaling (`Dict`, *optional*):
+            Dictionary containing the scaling configuration for the RoPE embeddings. Currently supports normal rope.
+        rope_theta (`float`, *optional*, defaults to 100000.0):
             The base period of the RoPE embeddings.
-        use_sliding_window (`bool`, *optional*, defaults to `False`):
-            Whether to use sliding window attention.
-        sliding_window (`int`, *optional*, defaults to 4096):
-            Sliding window attention (SWA) window size. If not specified, will default to `4096`.
-        max_window_layers (`int`, *optional*, defaults to 28):
-            The number of layers that use SWA (Sliding Window Attention). The bottom layers use SWA while the top use full attention.
+        attention_bias (`bool`, defaults to `False`, *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.
 
     ```python
-    >>> from transformers import Qwen2Model, Qwen2Config
+    >>> from transformers import PLMModel, PLMConfig
 
-    >>> # Initializing a Qwen2 style configuration
-    >>> configuration = Qwen2Config()
+    >>> # Initializing a PLM style configuration
+    >>> configuration = PLMConfig()
 
-    >>> # Initializing a model from the Qwen2-7B style configuration
-    >>> model = Qwen2Model(configuration)
+    >>> # Initializing a model from the PLM style configuration
+    >>> model = PLMModel(configuration)
 
     >>> # Accessing the model configuration
     >>> configuration = model.config
@@ -111,12 +112,10 @@ class PLMConfig(PretrainedConfig):
         use_cache=True,
         pretraining_tp=1,
         tie_word_embeddings=True,
-        rope_theta=10000.0,
+        rope_theta=100000.0,
         rope_scaling=None,
         attention_bias=False,
         attention_dropout=0.0,
-        use_sliding_window=False,
-        sliding_window=4096,
         **kwargs,
     ):
         self.vocab_size = vocab_size
@@ -145,14 +144,6 @@ class PLMConfig(PretrainedConfig):
         self.attention_bias = attention_bias
         self.attention_dropout = attention_dropout
 
-        self.use_sliding_window = use_sliding_window
-        self.sliding_window = sliding_window
-
-        # for backward compatibility
-        if num_key_value_heads is None:
-            num_key_value_heads = num_attention_heads
-        self.attn_implementation = "flash_attention_2"
-
         super().__init__(
             tie_word_embeddings=tie_word_embeddings,
             **kwargs,

modeling_plm.py

@@ -2,7 +2,7 @@
 # Copyright 2024 The PLM team and The HuggingFace Inc. All rights reserved.
 #
 # This code is based on Alibaba's Qwen2 library, DeepSeek-AI's deepseekv2 
-# libraryEleutherAI's GPT-NeoX library and the GPT-NeoX and OPT implementations 
+# library, EleutherAI's GPT-NeoX library and the GPT-NeoX and OPT implementations 
 # in this library. It has been modified from its original forms to accommodate 
 # minor architectural differences compared to GPT-NeoX and OPT used by the Meta 
 # AI team that trained the model.
@@ -253,7 +253,7 @@ class PLMAttention(nn.Module):
         if self.q_lora_rank is None:
             self.q_proj = nn.Linear(
                 self.hidden_size, self.num_heads * self.q_head_dim, bias=False
-            ) # 2048 16 192
+            ) 
         else:
             self.q_a_proj = nn.Linear(
                 self.hidden_size, config.q_lora_rank, bias=config.attention_bias
@@ -267,7 +267,7 @@ class PLMAttention(nn.Module):
             self.hidden_size,
             config.kv_lora_rank + config.qk_rope_head_dim,
             bias=config.attention_bias,
-        ) # 2048 512 64 
+        )  
         self.kv_a_layernorm = PLMRMSNorm(config.kv_lora_rank)
         self.kv_b_proj = nn.Linear(
             config.kv_lora_rank,
@@ -275,7 +275,6 @@ class PLMAttention(nn.Module):
             * (self.q_head_dim - self.qk_rope_head_dim + self.v_head_dim),
             bias=False,
         )  
-
         self.o_proj = nn.Linear(
             self.num_heads * self.v_head_dim,
             self.hidden_size,
@@ -287,11 +286,14 @@ class PLMAttention(nn.Module):
 
 
     def _init_rope(self):
-        self.rotary_emb = PLMRotaryEmbedding(
-            self.qk_rope_head_dim,
-            max_position_embeddings=self.max_position_embeddings,
-            base=self.rope_theta,
-        )
+        if self.config.rope_scaling is None:
+            self.rotary_emb = PLMRotaryEmbedding(
+                self.qk_rope_head_dim,
+                max_position_embeddings=self.max_position_embeddings,
+                base=self.rope_theta,
+            )
+        else:
+            raise ValueError(f"Currently do not support other RoPE scaling type")
 
 
     def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
@@ -318,28 +320,27 @@ class PLMAttention(nn.Module):
         bsz, q_len, _ = hidden_states.size()
 
         if self.q_lora_rank is None:
-            q = self.q_proj(hidden_states) # 9,2048 -> 3072, 16 * 192
+            q = self.q_proj(hidden_states) 
         else:
             q = self.q_b_proj(self.q_a_layernorm(self.q_a_proj(hidden_states)))
-        q = q.view(bsz, q_len, self.num_heads, self.q_head_dim).transpose(1, 2)#[1, 16, 9, 192])
+        q = q.view(bsz, q_len, self.num_heads, self.q_head_dim).transpose(1, 2)
         q_nope, q_pe = torch.split(
             q, [self.qk_nope_head_dim, self.qk_rope_head_dim], dim=-1
-        )# [1, 16, 9, 128] [1, 16, 9, 64]
+        )
 
         compressed_kv = self.kv_a_proj_with_mqa(hidden_states) # 1 9 576
         compressed_kv, k_pe = torch.split(
             compressed_kv, [self.kv_lora_rank, self.qk_rope_head_dim], dim=-1
-        )#  512 64
-        k_pe = k_pe.view(bsz, q_len, 1, self.qk_rope_head_dim).transpose(1, 2)# [1, 1, 9, 64])
+        )
+        k_pe = k_pe.view(bsz, q_len, 1, self.qk_rope_head_dim).transpose(1, 2)
         kv = (
             self.kv_b_proj(self.kv_a_layernorm(compressed_kv))
             .view(bsz, q_len, self.num_heads, self.qk_nope_head_dim + self.v_head_dim)
             .transpose(1, 2)
         )
-        # 1 16 9 256 
         k_nope, value_states = torch.split(
             kv, [self.qk_nope_head_dim, self.v_head_dim], dim=-1
-        ) # 1 16 9 128, 1 16 9 128
+        ) 
         kv_seq_len = value_states.shape[-2]
         if past_key_value is not None:
             if self.layer_idx is None:
@@ -353,7 +354,7 @@ class PLMAttention(nn.Module):
 
         q_pe, k_pe = apply_rotary_pos_emb(q_pe, k_pe, cos, sin, position_ids)
 
-        query_states = k_pe.new_empty(bsz, self.num_heads, q_len, self.q_head_dim)# ([1, 16, 9, 192])
+        query_states = k_pe.new_empty(bsz, self.num_heads, q_len, self.q_head_dim)
         query_states[:, :, :, : self.qk_nope_head_dim] = q_nope
         query_states[:, :, :, self.qk_nope_head_dim :] = q_pe
         
@@ -361,7 +362,7 @@ class PLMAttention(nn.Module):
         key_states[:, :, :, : self.qk_nope_head_dim] = k_nope
         key_states[:, :, :, self.qk_nope_head_dim :] = k_pe
         if past_key_value is not None:
-            cache_kwargs = {"sin": sin, "cos": cos}  # Specific to RoPE models
+            cache_kwargs = {"sin": sin, "cos": cos}
             key_states, value_states = past_key_value.update(
                 key_states, value_states, self.layer_idx, cache_kwargs
             )
@@ -1457,26 +1458,4 @@ class PLMForTokenClassification(PLMPreTrainedModel):
             logits=logits,
             hidden_states=outputs.hidden_states,
             attentions=outputs.attentions,
-        )
-
-
-# if __name__=="__main__":
-#     from IPython import embed
-#     from transformers import Qwen2Tokenizer
-#     import light_hf_proxy
-#     tokenizer = Qwen2Tokenizer.from_pretrained("PLM-Team/PLM-1.8B-Base")
-#     config = PLMConfig.from_pretrained("PLM-Team/PLM-1.8B-Base/config.json" ,attn_implementation="flash_attention_2", torch_dtype=torch.bfloat16)
-#     model = PLMForCausalLM(config).to(torch.bfloat16).to("cuda:7")
-#     input_ids = tokenizer(
-#         "Thanks to the generous support from SIGMOD EC, we will provide scholarship awards to selected students attending the WSDM 2024 conference. For awardees attending in-person, the grant will cover the cost of registration + some travel expenses. The awards will be competitive in the sense that not every student will receive a Travel Award. Each awardee will receive a bursary to partially cover the expense to attend the conference in-person. Awardees are expected to register for the main conference using a free-registration code provided with the award notification email and will have to make their own arrangements for travel and accommodation.Awardees are expected to register for the main conference and will have to make their own arrangements for travel and accommodation."
-#     )
-#     sample = torch.tensor([input_ids["input_ids"]]).to("cuda:7")  # (1,L)
-
-#     # Step 4: Forward pass through the model
-#     with torch.no_grad():
-#         outputs = model(sample)
-
-#     # Optionally, inspect the outputs
-#     print(outputs)
-    
-#     embed()
+        )