Upload modelforseminat_v6.py with huggingface_hub

modelforseminat_v6.py

@@ -551,11 +551,6 @@ class Olmo2ModelForSemiNAT(Olmo2Model):
         # pdb.set_trace()
 
         ################################ 并行处理 #################################
-        
-        # pdb.set_trace()
-        
-        # 这里attention_mask没有用，因为encoder没有attention层
-
 
         length_ground_truth = None  
         if not inference or is_prefill:
@@ -662,18 +657,15 @@ class Olmo2ModelForSemiNAT(Olmo2Model):
             assert length == max_chunk_num
 
 
-            
+            # pdb.set_trace()
             nat_input_embeddings, nat_attention_mask = self.repeat_with_limit_and_pad_chunk_ar(
                 hidden_states, inputs_embeds, accumu_num, length_ground_truth, self.chunk_size_limit, skip_val=-100)
             # pdb.set_trace()
 
-
             if self.mlp:
                 nat_input_embeddings = self.linear_projection(nat_input_embeddings)
                 
 
-
-
             # 处理attention
             mask_nat_attention_mask = self.nat_prepare_4d_full_attention_mask_with_causal(
                 attention_mask=nat_attention_mask,
@@ -682,7 +674,7 @@ class Olmo2ModelForSemiNAT(Olmo2Model):
 
             # pdb.set_trace()
 
-            self.decoder = self.decoder.to(dtype=nat_input_embeddings.dtype)
+            # self.decoder = self.decoder.to(dtype=nat_input_embeddings.dtype)
             if self.position_embedding_type == "relative":
                 nar_chunk_position = torch.arange(
                 0, self.chunk_size_limit).unsqueeze(0).repeat(
@@ -720,30 +712,167 @@ class Olmo2ModelForSemiNAT(Olmo2Model):
         )
 
 
-    def repeat_with_limit_and_pad_chunk_ar(self, x: torch.Tensor, inputs_embeds: torch.Tensor, accumu_num: int, repeat_counts: torch.Tensor, chunk_limit: int, skip_val: int = -100):
-        bs, length, hidden_size = x.size()
+    # def repeat_with_limit_and_pad_chunk_ar(self, x: torch.Tensor, inputs_embeds: torch.Tensor, accumu_num: int, repeat_counts: torch.Tensor, chunk_limit: int, skip_val: int = -100):
+    #     bs, length, hidden_size = x.size()
+    #     # pdb.set_trace()
+    #     acc_num = 0
+    #     out_tensor = torch.zeros(accumu_num, chunk_limit, hidden_size).to(x.device).to(x.dtype)
+    #     for b in range(bs):
+    #         start = repeat_counts[b, 0].item()
+    #         for i in range(1,length):
+    #             if repeat_counts[b, i] != -100:
+    #                 out_tensor[acc_num,0,:] = x[b,i-1,:]
+    #                 # end = min(repeat_counts[b, i], chunk_limit-1)
+    #                 end = repeat_counts[b, i] - 1
+    #                 out_tensor[acc_num, 1:end+1, :] = inputs_embeds[b, start:start+end, :]
+    #                 acc_num += 1
+    #                 start += repeat_counts[b, i]
+    #             else:
+    #                 break
+    #         # pdb.set_trace()
+    #     assert acc_num == accumu_num
+
+    #     # Compute mask: shape (accumu_num, chunk_limit)
+    #     mask = (out_tensor.abs().sum(dim=-1) != 0).to(torch.bfloat16)
+    #     return out_tensor, mask
+
+    def repeat_with_limit_and_pad_chunk_ar(
+        self,
+        x: torch.Tensor,                # (bs, L, H)
+        inputs_embeds: torch.Tensor,    # (bs, L, H)
+        accumu_num: int,
+        repeat_counts: torch.Tensor,    # (bs, L); repeat_counts[b,0]=start; 其余为 Li 或 skip_val
+        chunk_limit: int,
+        skip_val: int = -100,
+    ):
+        bs, L, H = x.size()
+        device, dtype = x.device, x.dtype
+
         # pdb.set_trace()
-        acc_num = 0
-        out_tensor = torch.zeros(accumu_num, chunk_limit, hidden_size).to(x.device).to(x.dtype)
-        for b in range(bs):
-            start = repeat_counts[b, 0].item()
-            for i in range(1,length):
-                if repeat_counts[b, i] != -100:
-                    out_tensor[acc_num,0,:] = x[b,i-1,:]
-                    end = min(repeat_counts[b, i], chunk_limit-1)
-                    out_tensor[acc_num, 1:end+1, :] = inputs_embeds[b, start:start+end, :]
-                    acc_num += 1
-                    start += repeat_counts[b, i]
-                else:
-                    break
-            # pdb.set_trace()
-        assert acc_num == accumu_num
 
-        # Compute mask: shape (accumu_num, chunk_limit)
-        mask = (out_tensor.abs().sum(dim=-1) != 0).to(torch.bfloat16)
+        # 切出每个样本的 chunk 长度 Li（对应原循环中的 i=1..L-1）
+        Li = repeat_counts[:, 1:]                              # (bs, L-1)
+        valid = (Li != skip_val)                               # (bs, L-1)
+        N = int(valid.sum().item())                            # 总 chunk 数
+
+        # 起始位置 start0，并进行边界保护到 [0, L]
+        start0 = repeat_counts[:, 0].clamp(min=0, max=L)       # (bs,)
+
+        # 计算每个 chunk 的起点： s_i = start0 + sum_{j< i} Li_j (exclusive cumsum)
+        Li_pos = torch.where(valid, Li, torch.zeros_like(Li))  # 仅累计有效位置
+        csum = torch.cumsum(Li_pos, dim=1)                     # (bs, L-1)，结束位置
+        excl_csum = csum - Li_pos                              # 开始位置
+        start_pos = start0.unsqueeze(1) + excl_csum            # 加上基础偏置，
+
+        # 计算每个 chunk 的拷贝长度 copy_len = max(Li-1, 0)
+        copy_len = torch.where(valid, Li - 1, torch.zeros_like(Li)) # 每个chunk取多少token作为输入，-1是因为第0位是chunk hidden位
+        copy_len = torch.clamp(copy_len, min=0)                # (bs, L-1)，
+
+        # 索引所有有效 (b, i) 位置
+        b_idx, i_idx = torch.nonzero(valid, as_tuple=True)     # bs是哪个batch，i是batch的哪个位置
+        if N != accumu_num:
+            raise RuntimeError(
+                f"[repeat_with_limit_and_pad_chunk_ar] acc_num({N}) != accumu_num({accumu_num}); 请检查 repeat_counts 与外部统计口径是否一致。"
+            )
+
+        # 准备输出张量
+        out_tensor = torch.zeros(N, chunk_limit, H, device=device, dtype=dtype)
+        lengths    = torch.zeros(N, dtype=torch.long, device=device)
+
+        # 第 0 列放 AR 种子：x[b, i-1, :]
+        ar_src_idx = i_idx                                              # 因为 i_idx 对应原 i-1
+        out_tensor[:, 0, :] = x[b_idx, ar_src_idx, :]                   # (N, H)
+
+        # 构造用于批量 gather 的二维索引以拷贝 NAR 部分（列 1..）
+        C = chunk_limit - 1
+        if C > 0 and N > 0:
+            # 每个样本的列偏移 0..C-1
+            k = torch.arange(C, device=device).unsqueeze(0).expand(N, C)           # (N, C)
+
+            # 对应每行的有效拷贝长度
+            copy_len_flat = copy_len[b_idx, i_idx]                                  # (N,)
+            start_flat    = start_pos[b_idx, i_idx]                                 # (N,)
+
+            # 有效位置掩码：只在 k < copy_len 时拷贝
+            take_mask = k < copy_len_flat.unsqueeze(1)                              # (N, C),每个chunk有多少个token是原输入embedding copy来的
+
+            # 计算需要从 inputs_embeds 取的绝对位置
+            src_pos = (start_flat.unsqueeze(1) + k).masked_fill(~take_mask, 0)      # (N, C)
+
+            # 展平后一次性 gather
+            gather_b = b_idx.repeat_interleave(C)                                   # (N*C,)
+            gather_p = src_pos.reshape(-1)                                          # (N*C,)
+            gathered = inputs_embeds[gather_b, gather_p, :].reshape(N, C, H)        # (N, C, H),哪条样本的哪个位置
+
+            # 将无效位置置零（保持与原实现一致的填充行为）
+            gathered = gathered * take_mask.unsqueeze(-1)                           # (N, C, H),mask掉的变成0
+
+            # 写入 out_tensor 的列 1..C
+            out_tensor[:, 1:1 + C, :] = gathered
+
+        # 记录各行有效长度（含第 0 列）
+        lengths = 1 + copy_len[b_idx, i_idx]
+
+        # 基于长度构造 mask，返回 bfloat16（1/0）
+        cols = torch.arange(chunk_limit, device=device).unsqueeze(0)                # (1, C_total)
+        mask_bool = cols < lengths.unsqueeze(1)                                     # (N, C_total)
+        mask = mask_bool.to(torch.bfloat16)
+
         return out_tensor, mask
 
 
+    # def repeat_with_limit_and_pad_chunk_ar(
+    #     self,
+    #     x: torch.Tensor,                # (bs, L, H)
+    #     inputs_embeds: torch.Tensor,    # (bs, L, H)
+    #     accumu_num: int,
+    #     repeat_counts: torch.Tensor,    # (bs, L); repeat_counts[b,0]=start; 其余为 Li 或 skip_val
+    #     chunk_limit: int,
+    #     skip_val: int = -100,
+    # ):
+    #     bs, L, H = x.size()
+    #     device, dtype = x.device, x.dtype
+
+    #     acc_num = 0
+    #     out_tensor = torch.zeros(accumu_num, chunk_limit, H, device=device, dtype=dtype)
+    #     lengths    = torch.zeros(accumu_num, dtype=torch.long, device=device)  # 每个chunk的有效长度(含第0位)
+
+    #     for b in range(bs):
+    #         # 起点：来自 repeat_counts[b,0]，做一次边界保护
+    #         start = int(repeat_counts[b, 0].item())
+    #         if start < 0: start = 0
+    #         if start > L: start = L  # 超界时后续 copy_len 会变成 0
+
+    #         for i in range(1, L):
+    #             Li = int(repeat_counts[b, i].item())
+    #             if Li == skip_val:
+    #                 break
+
+    #             out_tensor[acc_num, 0, :] = x[b, i - 1, :]
+    #             copy_len = Li - 1
+
+    #             if copy_len > 0:
+    #                 # 左右切片都用 copy_len，确保长度一致
+    #                 out_tensor[acc_num, 1:1 + copy_len, :] = inputs_embeds[b, start:start + copy_len, :]
+
+    #             # 记录该 chunk 的有效长度（包含第0列的AR位）
+    #             lengths[acc_num] = 1 + copy_len
+    #             acc_num += 1
+    #     if acc_num != accumu_num:
+    #         raise RuntimeError(
+    #             f"[repeat_with_limit_and_pad_chunk_ar] acc_num({acc_num}) != accumu_num({accumu_num}); "
+    #             f"请检查 repeat_counts 与外部统计口径是否一致。"
+    #         )
+
+    #     # 基于长度构造 mask：(accumu_num, chunk_limit)；保持返回 dtype 为 bfloat16
+    #     cols = torch.arange(chunk_limit, device=device).unsqueeze(0)    # (1, C)
+    #     mask_bool = cols < lengths.unsqueeze(1)                         # (N, C) bool
+    #     # 与原接口一致：返回 bfloat16（1.0/0.0）
+    #     mask = mask_bool.to(torch.bfloat16)
+
+    #     return out_tensor, mask
+
+
     def build_slice_matrix(self, input_ids, slice_pos: torch.Tensor):
         bs, num_slices = slice_pos.shape
         seq_len = input_ids.size(1)
@@ -1167,14 +1296,14 @@ class Olmo2ForCausalLMForSemiNAT(Olmo2ForCausalLM):
                     # pdb.set_trace()
                     try:
                         nar_labels[chunk, :length_ground_truth[b, i]] = labels[
-                            b, last_cut + 1:slice_pos[b, i] + 1]
+                            b, last_cut + 1:slice_pos[b, i] + 1] #slice_pos是包含尾部token，所以+1
                     except:
                         pdb.set_trace()
                     last_cut = slice_pos[b, i]
                     chunk += 1
                 else:
                     break
-        # pdb.set_trace()
+        pdb.set_trace()
         return nar_labels
 
     def fixed_cross_entropy(self,