Upload modelforseminat_v5.py with huggingface_hub

modelforseminat_v5.py

@@ -185,14 +185,16 @@ class TwoLayerMLP(nn.Module):
 
 
 class Olmo2ConfigForSemiNAT(Olmo2Config):
-    def __init__(self, chunk_size_limit: int = 5, decoder_layers: int = 1, encoder_layer: int = 1, mlp: bool = False, position_embedding_type: str = "absolute", **kwargs):
+    def __init__(self, chunk_size_limit: int = 5, decoder_layers: int = 1, encoder_layer: int = 1, mlp: bool = False, position_embedding_type: str = "absolute",attn_implementation: str = "sdpa", length_loss_type: str = "ce", **kwargs):
         super().__init__(**kwargs)
         self.chunk_size_limit = chunk_size_limit
         self.decoder_layers = decoder_layers
         self.encoder_layer = encoder_layer
         self.mlp = mlp
         self.position_embedding_type = position_embedding_type
-
+        self._attn_implementation = attn_implementation
+        self.length_loss_type = length_loss_type
+        # pdb.set_trace()
 
 
 class Olmo2AttentionForSemiNAT(nn.Module):
@@ -265,23 +267,26 @@ class Olmo2AttentionForSemiNAT(nn.Module):
             key_states, value_states = past_key_value.update(
                 key_states, value_states, self.layer_idx, cache_kwargs)
 
-        attention_interface: Callable = eager_attention_forward
-
+        # attention_interface: Callable = eager_attention_forward
 
+        
         # pdb.set_trace()
         
+        
+
+
+        # if self.config._attn_implementation != "eager":
+        #     if self.config._attn_implementation == "sdpa" and kwargs.get(
+        #             "output_attentions", False):
+        #         logger.warning_once(
+        #             "`torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. Falling back to "
+        #             'eager attention. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.'
+        #         )
+        #     else:
+        #         attention_interface = ALL_ATTENTION_FUNCTIONS[
+        #             self.config._attn_implementation]
+        attention_interface: Callable = ALL_ATTENTION_FUNCTIONS["sdpa"]  #针对encoder和decoder的新设定
 
-        self.config._attn_implementation = "sdpa"
-        if self.config._attn_implementation != "eager":
-            if self.config._attn_implementation == "sdpa" and kwargs.get(
-                    "output_attentions", False):
-                logger.warning_once(
-                    "`torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. Falling back to "
-                    'eager attention. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.'
-                )
-            else:
-                attention_interface = ALL_ATTENTION_FUNCTIONS[
-                    self.config._attn_implementation]
 
         # pdb.set_trace()
         attn_output, attn_weights = attention_interface(
@@ -292,6 +297,7 @@ class Olmo2AttentionForSemiNAT(nn.Module):
             attention_mask,
             dropout=0.0 if not self.training else self.attention_dropout,
             scaling=self.scaling,
+            is_causal=self.is_causal,
             **kwargs,
         )
         # pdb.set_trace()
@@ -377,7 +383,7 @@ class NATEncoderForSemiNAT(nn.Module):
         super().__init__()
         self.num_layer = num_layer
         self.encoder_layers = nn.ModuleList([
-            Olmo2DecoderLayerForSemiNAT(config, layer_idx)
+            Olmo2DecoderLayerForSemiNAT(config, layer_idx) #check下需不需要is causal false，但attn_mask优先级高于is_causal
             for layer_idx in range(self.num_layer)
         ])
 
@@ -567,7 +573,7 @@ class Olmo2ModelForSemiNAT(Olmo2Model):
             length_ground_truth = length_ground_truth[:,:max_chunk_num]
             chunk_position_ids = position_ids[:,:max_chunk_num]
             chunk_cache_position = cache_position[:max_chunk_num]
-            
+            # pdb.set_trace()
         else:
             
             encoded_input = self.encoder(inputs_embeds[:,position_ids.squeeze(0)],position_embeddings=position_embeddings)
@@ -805,27 +811,25 @@ class Olmo2ModelForSemiNAT(Olmo2Model):
                 nar_chunk_position = torch.arange(
                 0, self.chunk_size_limit).unsqueeze(0).repeat(
                     accumu_num,
-                    1).to(hidden_states.device) 
-
+                    1).to(hidden_states.device)
                 pos = self.rotary_emb(nat_attention_mask, nar_chunk_position)
 
             elif self.position_embedding_type == "absolute":
                 nat_input_embeddings = self.pos_encoder(nat_input_embeddings) # 加上绝对位置编码
                 pos = None  
 
-            
+            # pdb.set_trace()
             nar_hidden_states = self.decoder(
                 nat_input_embeddings,
-                attention_mask=mask_nat_attention_mask,
+                attention_mask=mask_nat_attention_mask, #改下padding mask
                 # attention_mask=None,
                 position_embeddings=pos,
-                # position_embeddings=None, #使��绝对位置，不传相对位置
                 output_attentions=output_attentions,
                 use_cache=use_cache,
                 cache_position=None,
             )
             nar_hidden_states = self.norm(
-                nar_hidden_states)  # bs * max_chunk_num * hidden_size
+                nar_hidden_states)  
             # pdb.set_trace()
 
         return ModelOutputWithPastForSemiNAT(
@@ -1235,53 +1239,37 @@ class Olmo2ForCausalLMForSemiNAT(Olmo2ForCausalLM):
             length_logits = outputs.length_logits
 
             new_length_ground_truth = torch.where(
-                length_ground_truth != -100,  # 条件：不等于 -100
-                length_ground_truth - 1,  # 如果条件为真，执行 labels - 1
-                length_ground_truth  # 否则保持原值
+                length_ground_truth != -100,
+                length_ground_truth - 1,
+                length_ground_truth
             )
 
-            # pdb.set_trace()
-
             shift_length_logits = length_logits[:, :-1, :]
             shift_new_length_ground_truth = new_length_ground_truth[:, 1:]
 
-            logits_flat = shift_length_logits.reshape(
-                -1,
-                self.chunk_size_limit)  # 形状变为 [bs * length, chunk_size_limit]
-            labels_flat = shift_new_length_ground_truth.reshape(
-                -1)  # [bs * length]
-
-            # softmax logits to get probability
-            logits_flat = torch.nn.functional.softmax(logits_flat, dim=-1)
-
-            # 修改 loss 为 MSE: 首先根据 logits 加权得到预测长度（注意不是 argmax），之后与 label 计算 MSE
-
-            # pdb.set_trace()
-            # 计算预测长度
-            predicted_lengths = torch.sum(
-                logits_flat * torch.arange(self.chunk_size_limit).to(
-                    chunk_hidden_states.device).to(chunk_hidden_states.dtype),
-                dim=1)
-            # 计算预测长度与真实长度之间的均方误差
-
-            
-
+            logits_flat = shift_length_logits.reshape(-1, self.chunk_size_limit)
+            labels_flat = shift_new_length_ground_truth.reshape(-1)
 
-            shift_slice_label = slice_label[:, 1:length_logits.size(1)] #用最大chunk数阶段
+            shift_slice_label = slice_label[:, 1:length_logits.size(1)]
             slice_label_flat = shift_slice_label.reshape(-1)
-
-            # 对应 labels_flat 的 global indices
-            indices = torch.arange(0, labels_flat.size(0), device=labels_flat.device)
             mask = (slice_label_flat == -1)
-
-            # pdb.set_trace()
-            # labels_not_ignored = (labels_flat[indices] != -100)
-            # final_mask = mask & labels_not_ignored
-            labels_flat[indices[mask]] = -100
-
-            
-            loss1 = torch.mean((predicted_lengths[labels_flat != -100] -
-                                labels_flat[labels_flat != -100].float())**2)
+            labels_flat[mask] = -100
+
+            length_loss_type = getattr(self.config, "length_loss_type", "ce")
+            if length_loss_type == "mse":
+                logits_softmax = torch.nn.functional.softmax(logits_flat, dim=-1)
+                predicted_lengths = torch.sum(
+                    logits_softmax * torch.arange(self.chunk_size_limit).to(
+                        chunk_hidden_states.device).to(chunk_hidden_states.dtype),
+                    dim=1
+                )
+                loss1 = torch.mean((predicted_lengths[labels_flat != -100] -
+                                    labels_flat[labels_flat != -100].float()) ** 2)
+            elif length_loss_type == "ce":  # cross entropy
+                loss1 = F.cross_entropy(
+                    logits_flat[labels_flat != -100],
+                    labels_flat[labels_flat != -100]
+                )
 
             # pdb.set_trace()