Merge 0761ffa7cd into f659b55761

[fix] residual step order
Merge pull request #868 from DaoyuanLi2816/fix/final-accumulation-checkpoint
2026-09-23 17:04:35 +08:00 · 2026-09-23 00:07:30 +08:00 · 2026-09-22 23:39:01 +08:00 · 2026-09-22 23:20:45 +08:00 · 2026-09-21 23:24:55 -07:00 · 2026-09-21 23:24:55 -07:00
14 changed files with 51 additions and 93 deletions
--- a/dataset/lm_dataset.py
+++ b/dataset/lm_dataset.py
@ -28,10 +28,13 @@ def pre_processing_chat(conversations, add_system_ratio=0.2):
            return [{'role': 'system', 'content': random.choice(SYSTEM_PROMPTS)}] + conversations
    return conversations

-def post_processing_chat(prompt_content, empty_think_ratio=0.2):
+def post_processing_chat(prompt_content, empty_think_ratio=0.2, remove_empty_think=None):
    # 以80%概率移除空思考标签
-    if '<think>\n\n</think>\n\n' in prompt_content and random.random() > empty_think_ratio:
-        prompt_content = prompt_content.replace('<think>\n\n</think>\n\n', '')
+    if '<think>\n\n</think>\n\n' in prompt_content:
+        if remove_empty_think is None:
+            remove_empty_think = random.random() > empty_think_ratio
+        if remove_empty_think:
+            prompt_content = prompt_content.replace('<think>\n\n</think>\n\n', '')
    return prompt_content

 class PretrainDataset(Dataset):
@ -139,12 +142,13 @@ class DPODataset(Dataset):
        chosen_prompt = self.tokenizer.apply_chat_template(
            chosen, tokenize=False, add_generation_prompt=False
        )
-        chosen_prompt = post_processing_chat(chosen_prompt)

        rejected_prompt = self.tokenizer.apply_chat_template(
            rejected, tokenize=False, add_generation_prompt=False
        )
-        rejected_prompt = post_processing_chat(rejected_prompt)
+        remove_empty_think = random.random() > 0.2
+        chosen_prompt = post_processing_chat(chosen_prompt, remove_empty_think=remove_empty_think)
+        rejected_prompt = post_processing_chat(rejected_prompt, remove_empty_think=remove_empty_think)
        chosen_encoding = self.tokenizer(
            chosen_prompt, truncation=True, max_length=self.max_length, padding='max_length'
        )
--- a/eval_llm.py
+++ b/eval_llm.py
@ -23,7 +23,7 @@ def init_model(args):
        model.load_state_dict(torch.load(ckp, map_location=args.device), strict=True)
        if args.lora_weight != 'None':
            apply_lora(model)
-            load_lora(model, f'./{args.save_dir}/{args.lora_weight}_{args.hidden_size}.pth')
+            load_lora(model, f'./{args.save_dir}/{args.lora_weight}_{args.hidden_size}{moe_suffix}.pth')
    else:
        model = AutoModelForCausalLM.from_pretrained(args.load_from, trust_remote_code=True)
    get_model_params(model, model.config)
--- a/model/model_minimind.py
+++ b/model/model_minimind.py
@ -125,10 +125,10 @@ class Attention(nn.Module):
        if self.flash and (seq_len > 1) and (not self.is_causal or past_key_value is None) and (attention_mask is None or torch.all(attention_mask == 1)):
            output = F.scaled_dot_product_attention(xq, xk, xv, dropout_p=self.dropout if self.training else 0.0, is_causal=self.is_causal)
        else:
-            scores = (xq @ xk.transpose(-2, -1)) / math.sqrt(self.head_dim)
+            scores = (xq @ xk.transpose(-2, -1)).float() / math.sqrt(self.head_dim)
            if self.is_causal: scores[:, :, :, -seq_len:] += torch.full((seq_len, seq_len), float("-inf"), device=scores.device).triu(1)
            if attention_mask is not None: scores += (1.0 - attention_mask.unsqueeze(1).unsqueeze(2)) * -1e9
-            output = self.attn_dropout(F.softmax(scores.float(), dim=-1).type_as(xq)) @ xv
+            output = self.attn_dropout(F.softmax(scores, dim=-1).type_as(xq)) @ xv
        output = output.transpose(1, 2).reshape(bsz, seq_len, -1)
        output = self.resid_dropout(self.o_proj(output))
        return output, past_kv
--- a/requirements.txt
+++ b/requirements.txt
@ -28,6 +28,8 @@ streamlit==1.50.0
 einops==0.8.1
 swanlab==0.9.8
 modelscope==1.37.0
+fastapi==0.120.1
+uvicorn==0.38.0
 # torch==2.6.0
 # torchvision==0.21.0
 # peft==0.7.1
--- a/scripts/serve_openai_api.py
+++ b/scripts/serve_openai_api.py
@ -40,7 +40,7 @@ def init_model(args):
        model.load_state_dict(torch.load(ckp, map_location=device), strict=True)
        if args.lora_weight != 'None':
            apply_lora(model)
-            load_lora(model, f'../{args.save_dir}/lora/{args.lora_weight}_{args.hidden_size}.pth')
+            load_lora(model, f'../{args.save_dir}/{args.lora_weight}_{args.hidden_size}{moe_suffix}.pth')
    else:
        model = AutoModelForCausalLM.from_pretrained(args.load_from, trust_remote_code=True)
    print(f'MiniMind模型参数量: {sum(p.numel() for p in model.parameters()) / 1e6:.2f} M(illion)')
@ -202,7 +202,7 @@ async def chat_completions(request: ChatRequest):
            with torch.no_grad():
                generated_ids = model.generate(
                    inputs["input_ids"],
-                    max_length=inputs["input_ids"].shape[1] + request.max_tokens,
+                    max_new_tokens=request.max_tokens,
                    do_sample=True,
                    attention_mask=inputs["attention_mask"],
                    pad_token_id=tokenizer.pad_token_id,
--- a/trainer/train_agent.py
+++ b/trainer/train_agent.py
@ -240,12 +240,10 @@ def calculate_rewards(prompts, completions, gt_batch, tools_batch, num_gen, rewa

 # ================================ 工具与 Reward = End ================================
 def rl_train_epoch(epoch, loader, iters, rollout_engine, ref_model, reward_model=None, start_step=0, wandb=None, use_sglang=False):
-    last_step = start_step
    for step, batch in enumerate(loader, start=start_step + 1):
        messages_batch = batch['messages']
        tools_batch = batch['tools']
        gt_batch = batch['gt']
-        last_step = step

        with torch.no_grad():
            completions, contexts, prompt_ids_batch, response_ids_batch, response_masks_batch, response_old_logps_batch, turn_outputs_batch, unfinished_batch = rollout_batch(rollout_engine, tokenizer, messages_batch, tools_batch, args.num_generations, max_turns=3, max_new_tokens=args.max_gen_len, thinking_ratio=args.thinking_ratio, device=args.device)
@ -273,8 +271,6 @@ def rl_train_epoch(epoch, loader, iters, rollout_engine, ref_model, reward_model
        rewards = calculate_rewards(prompts, completions, gt_batch, tools_batch, args.num_generations, reward_model, device=args.device, turn_outputs_batch=turn_outputs_batch, unfinished_batch=unfinished_batch)

        with autocast_ctx:
-            # 反向传播必须经过 DDP 包装后的模块：直接调用 .module 会跳过
-            # DDP 的 prepare_for_backward，梯度不会 all-reduce，各卡静默发散。
            res = model(input_ids, attention_mask=full_mask)
            aux_loss = res.aux_loss if lm_config.use_moe else torch.tensor(0.0, device=args.device)
            logits = res.logits[:, :-1, :]
@ -333,7 +329,7 @@ def rl_train_epoch(epoch, loader, iters, rollout_engine, ref_model, reward_model
        loss = (policy_loss + aux_loss) / args.accumulation_steps
        loss.backward()

-        if step % args.accumulation_steps == 0:
+        if step % args.accumulation_steps == 0 or step == iters:
            if args.grad_clip > 0: torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
            optimizer.step(); scheduler.step(); optimizer.zero_grad()

@ -367,10 +363,6 @@ def rl_train_epoch(epoch, loader, iters, rollout_engine, ref_model, reward_model
        del per_token_logps, ref_per_token_logps
        del completions, rewards, grouped_rewards, mean_r, std_r, advantages, completion_mask

-    if last_step > start_step and last_step % args.accumulation_steps != 0:
-        if args.grad_clip > 0: torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
-        optimizer.step(); scheduler.step(); optimizer.zero_grad()
-

 if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="MiniMind Agent RL")
@ -471,7 +463,6 @@ if __name__ == "__main__":
    if args.use_compile == 1:
        model = torch.compile(model)
        Logger('torch.compile enabled')
-        rollout_engine.update_policy(model)
    if dist.is_initialized():
        # 同 train_ppo：RoPE buffer 各 rank 一致，每步广播纯属浪费
        model = DistributedDataParallel(model, device_ids=[local_rank], broadcast_buffers=False)
--- a/trainer/train_distillation.py
+++ b/trainer/train_distillation.py
@ -38,14 +38,12 @@ def distillation_loss(student_logits, teacher_logits, temperature=1.0, reduction

 def train_epoch(epoch, loader, iters, teacher_model, lm_config_student, start_step=0, wandb=None, alpha=0.0, temperature=1.0):
    start_time = time.time()
-    last_step = start_step
    
    if teacher_model is not None:
        teacher_model.eval()
        teacher_model.requires_grad_(False)

    for step, (input_ids, labels) in enumerate(loader, start=start_step + 1):
-        last_step = step
        input_ids = input_ids.to(args.device)
        labels = labels.to(args.device)
        loss_mask = (labels[..., 1:] != -100).float()
@ -94,7 +92,7 @@ def train_epoch(epoch, loader, iters, teacher_model, lm_config_student, start_st

        scaler.scale(loss).backward()

-        if step % args.accumulation_steps == 0:
+        if step % args.accumulation_steps == 0 or step == iters:
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
            scaler.step(optimizer)
@ -135,13 +133,6 @@ def train_epoch(epoch, loader, iters, teacher_model, lm_config_student, start_st

        del input_ids, labels, loss_mask, res, student_logits, ce_loss, distill_loss, loss

-    if last_step > start_step and last_step % args.accumulation_steps != 0:
-        scaler.unscale_(optimizer)
-        torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
-        scaler.step(optimizer)
-        scaler.update()
-        optimizer.zero_grad(set_to_none=True)
-

 if __name__ == "__main__":
    # 模拟用moe模型蒸馏dense模型，也可以用更大teacher_hidden_size模型蒸馏更小student_hidden_size的
--- a/trainer/train_dpo.py
+++ b/trainer/train_dpo.py
@ -52,10 +52,8 @@ def dpo_loss(ref_log_probs, policy_log_probs, mask, beta):

 def train_epoch(epoch, loader, iters, ref_model, lm_config, start_step=0, wandb=None, beta=0.1):
    start_time = time.time()
-    last_step = start_step

    for step, batch in enumerate(loader, start=start_step + 1):
-        last_step = step
        x_chosen = batch['x_chosen'].to(args.device)
        x_rejected = batch['x_rejected'].to(args.device)
        y_chosen = batch['y_chosen'].to(args.device)
@ -86,7 +84,7 @@ def train_epoch(epoch, loader, iters, ref_model, lm_config, start_step=0, wandb=

        scaler.scale(loss).backward()

-        if step % args.accumulation_steps == 0:
+        if step % args.accumulation_steps == 0 or step == iters:
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
            scaler.step(optimizer)
@ -120,13 +118,6 @@ def train_epoch(epoch, loader, iters, ref_model, lm_config, start_step=0, wandb=
        del x_chosen, x_rejected, y_chosen, y_rejected, mask_chosen, mask_rejected, x, y, mask
        del ref_outputs, ref_logits, ref_log_probs, outputs, logits, policy_log_probs, loss

-    if last_step > start_step and last_step % args.accumulation_steps != 0:
-        scaler.unscale_(optimizer)
-        torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
-        scaler.step(optimizer)
-        scaler.update()
-        optimizer.zero_grad(set_to_none=True)
-

 if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="MiniMind DPO (Direct Preference Optimization)")
--- a/trainer/train_full_sft.py
+++ b/trainer/train_full_sft.py
@ -23,11 +23,9 @@ warnings.filterwarnings('ignore')

 def train_epoch(epoch, loader, iters, start_step=0, wandb=None):
    start_time = time.time()
-    last_step = start_step
    for step, (input_ids, labels) in enumerate(loader, start=start_step + 1):
        input_ids = input_ids.to(args.device)
        labels = labels.to(args.device)
-        last_step = step
        lr = get_lr(epoch * iters + step, args.epochs * iters, args.learning_rate)
        for param_group in optimizer.param_groups:
            param_group['lr'] = lr
@ -39,7 +37,7 @@ def train_epoch(epoch, loader, iters, start_step=0, wandb=None):

        scaler.scale(loss).backward()

-        if step % args.accumulation_steps == 0:
+        if step % args.accumulation_steps == 0 or step == iters:
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)

@ -73,13 +71,6 @@ def train_epoch(epoch, loader, iters, start_step=0, wandb=None):

        del input_ids, labels, res, loss

-    if last_step > start_step and last_step % args.accumulation_steps != 0:
-        scaler.unscale_(optimizer)
-        torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
-        scaler.step(optimizer)
-        scaler.update()
-        optimizer.zero_grad(set_to_none=True)
-

 if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="MiniMind Full SFT")
--- a/trainer/train_grpo.py
+++ b/trainer/train_grpo.py
@ -96,8 +96,6 @@ def grpo_train_epoch(epoch, loader, iters, rollout_engine, ref_model, reward_mod
        rewards = calculate_rewards(prompts, completions, reward_model).to(args.device)  # [B*num_gen]

        with autocast_ctx:
-            # 反向传播必须经过 DDP 包装后的模块：直接调用 .module 会跳过
-            # DDP 的 prepare_for_backward，梯度不会 all-reduce，各卡静默发散。
            res = model(outputs, attention_mask=full_mask)
            aux_loss = res.aux_loss if lm_config.use_moe else torch.tensor(0.0, device=args.device)
            per_token_logps = F.log_softmax(res.logits[:, :-1, :], dim=-1).gather(2, outputs[:, 1:].unsqueeze(-1)).squeeze(-1).gather(1, logp_pos)
@ -146,7 +144,7 @@ def grpo_train_epoch(epoch, loader, iters, rollout_engine, ref_model, reward_mod
        loss = (policy_loss + aux_loss) / args.accumulation_steps  # scalar
        loss.backward()

-        if step % args.accumulation_steps == 0:
+        if step % args.accumulation_steps == 0 or step == iters:
            if args.grad_clip > 0:
                torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
            optimizer.step()
@ -197,13 +195,6 @@ def grpo_train_epoch(epoch, loader, iters, rollout_engine, ref_model, reward_mod
        del prompt_inputs, outputs, completion_ids, per_token_logps, ref_per_token_logps
        del completions, rewards, grouped_rewards, mean_r, std_r, advantages, completion_mask, completion_pad_mask, prompt_lens, logp_pos

-    if step > start_step and step % args.accumulation_steps != 0:
-        if args.grad_clip > 0:
-            torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
-        optimizer.step()
-        scheduler.step()
-        optimizer.zero_grad()
-

 if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="MiniMind GRPO (Group Relative Policy Optimization)")
@ -312,7 +303,6 @@ if __name__ == "__main__":
    if args.use_compile == 1:
        model = torch.compile(model)
        Logger('torch.compile enabled')
-        rollout_engine.update_policy(model)
    if dist.is_initialized():
        # 同 train_ppo：RoPE buffer 各 rank 一致，每步广播纯属浪费
        model = DistributedDataParallel(model, device_ids=[local_rank], broadcast_buffers=False)
--- a/trainer/train_lora.py
+++ b/trainer/train_lora.py
@ -24,11 +24,9 @@ warnings.filterwarnings('ignore')

 def train_epoch(epoch, loader, iters, lora_params, start_step=0, wandb=None):
    start_time = time.time()
-    last_step = start_step
    for step, (input_ids, labels) in enumerate(loader, start=start_step + 1):
        input_ids = input_ids.to(args.device)
        labels = labels.to(args.device)
-        last_step = step
        lr = get_lr(epoch * iters + step, args.epochs * iters, args.learning_rate)
        for param_group in optimizer.param_groups:
            param_group['lr'] = lr
@ -40,7 +38,7 @@ def train_epoch(epoch, loader, iters, lora_params, start_step=0, wandb=None):

        scaler.scale(loss).backward()

-        if step % args.accumulation_steps == 0:
+        if step % args.accumulation_steps == 0 or step == iters:
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(lora_params, args.grad_clip)
            scaler.step(optimizer)
@ -68,13 +66,6 @@ def train_epoch(epoch, loader, iters, lora_params, start_step=0, wandb=None):

        del input_ids, labels, res, loss

-    if last_step > start_step and last_step % args.accumulation_steps != 0:
-        scaler.unscale_(optimizer)
-        torch.nn.utils.clip_grad_norm_(lora_params, args.grad_clip)
-        scaler.step(optimizer)
-        scaler.update()
-        optimizer.zero_grad(set_to_none=True)
-
 if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="MiniMind LoRA Fine-tuning")
    parser.add_argument("--save_dir", type=str, default="../out", help="模型保存目录")
--- a/trainer/train_ppo.py
+++ b/trainer/train_ppo.py
@ -166,16 +166,12 @@ def ppo_train_epoch(epoch, loader, iters, rollout_engine, ref_model, actor_sched
            for i in range(0, B, mb_size):
                inds = b_inds[i:i + mb_size]
                
-                # 反向传播必须经过 DDP 包装后的模块：直接调用 .module 会跳过
-                # DDP 的 prepare_for_backward，梯度不会 all-reduce，各卡静默发散。
                mb_values_seq = critic_model(input_ids=gen_out[inds], attention_mask=full_mask[inds])
                mb_resp_values = mb_values_seq.gather(1, logp_pos[inds])

                with autocast_ctx:
                    res = actor_model(input_ids=gen_out[inds], attention_mask=full_mask[inds])
                    aux_loss = res.aux_loss if lm_config.use_moe else torch.tensor(0.0, device=args.device)
-                    # 在 autocast 内计算 log_softmax，避免直接对 fp16/bf16 logits
-                    # 计算造成额外数值偏差。
                    mb_resp_logp = F.log_softmax(res.logits[:, :-1], dim=-1).gather(2, labels[inds].unsqueeze(-1)).squeeze(-1).gather(1, logp_pos[inds])

                log_ratio = mb_resp_logp - old_resp_logp[inds]
@ -427,7 +423,6 @@ if __name__ == "__main__":
    if args.use_compile == 1:
        actor_model = torch.compile(actor_model)
        Logger('torch.compile enabled')
-        rollout_engine.update_policy(actor_model)
    if dist.is_initialized():
        # freqs_cos/freqs_sin 各 rank 由 config 确定性算出，默认每步广播一次纯属浪费
        actor_model = DistributedDataParallel(actor_model, device_ids=[local_rank], broadcast_buffers=False)
--- a/trainer/train_pretrain.py
+++ b/trainer/train_pretrain.py
@ -23,11 +23,9 @@ warnings.filterwarnings('ignore')

 def train_epoch(epoch, loader, iters, start_step=0, wandb=None):
    start_time = time.time()
-    last_step = start_step
    for step, (input_ids, labels) in enumerate(loader, start=start_step + 1):
        input_ids = input_ids.to(args.device)
        labels = labels.to(args.device)
-        last_step = step
        lr = get_lr(epoch * iters + step, args.epochs * iters, args.learning_rate)
        for param_group in optimizer.param_groups:
            param_group['lr'] = lr
@ -39,7 +37,7 @@ def train_epoch(epoch, loader, iters, start_step=0, wandb=None):

        scaler.scale(loss).backward()

-        if step % args.accumulation_steps == 0:
+        if step % args.accumulation_steps == 0 or step == iters:
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)

@ -72,13 +70,6 @@ def train_epoch(epoch, loader, iters, start_step=0, wandb=None):

        del input_ids, labels, res, loss

-    if last_step > start_step and last_step % args.accumulation_steps != 0:
-        scaler.unscale_(optimizer)
-        torch.nn.utils.clip_grad_norm_(model.parameters(), args.grad_clip)
-        scaler.step(optimizer)
-        scaler.update()
-        optimizer.zero_grad(set_to_none=True)
-

 if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="MiniMind Pretraining")
--- a/trainer/train_tokenizer.py
+++ b/trainer/train_tokenizer.py
@ -8,18 +8,39 @@ DATA_PATH = '../dataset/sft_t2t_mini.jsonl'
 TOKENIZER_DIR = '../model_learn_tokenizer/'
 VOCAB_SIZE = 6400
 SPECIAL_TOKENS_NUM = 36
+MAX_LINES = 0  # 0 表示读取全部；设为正数则只取前 N 条（快速试跑）

-def get_texts(data_path):
+def get_texts(data_path, max_lines=MAX_LINES):
+    """逐行产出用于训练 BPE 的文本，兼容两种主线数据格式。
+
+    pretrain_t2t(_mini).jsonl 是 {"text": ...}，
+    sft_t2t(_mini).jsonl 是 {"conversations": [{"role":..., "content":...}, ...]}。
+    原先只解析 conversations，所以把 DATA_PATH 指向预训练语料时一条文本都取不到，
+    BPE 仅基于 initial_alphabet 训练，产出一个没有任何 merge 的词表，且全程不报错。
+    """
+    used = 0
    with open(data_path, 'r', encoding='utf-8', errors='ignore') as f:
-        for i, line in enumerate(f):
-            if i >= 10000: break # 选10000行测试
+        for line in f:
+            if max_lines and used >= max_lines:
+                break
            try:
                data = json.loads(line)
-                contents = [item.get('content') for item in data.get('conversations', []) if item.get('content')]
-                if contents:
-                    yield "\n".join(contents)
            except json.JSONDecodeError:
                continue
+            if 'text' in data:
+                text = str(data['text'])
+            else:
+                contents = [item.get('content') for item in data.get('conversations', []) if item.get('content')]
+                text = "\n".join(contents) if contents else ''
+            if text.strip():
+                used += 1
+                yield text
+    if used == 0:
+        raise ValueError(
+            f'{data_path} 中没有可用文本：每行应为 {{"text": ...}} 或 '
+            f'{{"conversations": [{{"role":..., "content":...}}, ...]}}。'
+            f'继续训练只会得到一个空词表。'
+        )

 def train_tokenizer(data_path, tokenizer_dir, vocab_size, special_tokens_num=SPECIAL_TOKENS_NUM):
    tokenizer = Tokenizer(models.BPE())
Author	SHA1	Message	Date
王翛玄	fce2e7f1b7	Merge `0761ffa7cd` into `f659b55761`	2026-09-23 17:04:35 +08:00
jingyaogong	f659b55761	[fix] residual step order	2026-09-23 00:07:30 +08:00
jingyaogong	6fff76fe04	Merge pull request #868 from DaoyuanLi2816/fix/final-accumulation-checkpoint [fix] save final checkpoints after the residual accumulation step	2026-09-22 23:39:01 +08:00
jingyaogong	7da0f92ff6	Merge pull request #867 from DaoyuanLi2816/fix/lora-inference-paths [fix] align LoRA inference paths with training output	2026-09-22 23:20:45 +08:00
Daoyuan Li	a6ffddc0ea	fix: update residual gradients before saving final checkpoints	2026-09-21 23:24:55 -07:00
Daoyuan Li	4b86522f8a	fix: align LoRA inference paths with training output	2026-09-21 23:24:55 -07:00
jingyaogong	1e6e909f88	[update] trim redundant comments	2026-09-20 20:33:40 +08:00
jingyaogong	b00be3e5ca	Merge pull request #769 from qizwiz/fix/llm-response-unguarded fix: guard against empty/filtered LLM responses in chat_api.py	2026-09-20 20:19:39 +08:00
jingyaogong	7f5ba40a4e	Merge pull request #821 from lycDragonSlayer/refactor/remove-redundant-update-policy [refactor] remove redundant rollout update_policy after torch.compile	2026-09-20 20:13:29 +08:00
jingyaogong	949488fdb4	Merge pull request #829 from DaoyuanLi2816/fix/dpo-paired-think-format [fix] keep DPO preference-pair think formatting aligned	2026-09-20 20:07:46 +08:00
jingyaogong	e41bf7cacf	Merge pull request #863 from Linxiushen/fix-fp16-attention-mask-nan [fix] float16 下 attention mask 的 -1e9 溢出成 -inf，导致整条序列输出 NaN	2026-09-20 19:49:22 +08:00
jingyaogong	b330a4d5c0	Merge pull request #860 from Linxiushen/fix-tokenizer-pretrain-format [fix] train_tokenizer 读预训练语料时产出 0 条文本，静默训出空词表	2026-09-20 19:47:52 +08:00
jingyaogong	b956bad49f	Merge pull request #865 from Linxiushen/fix-requirements-missing-fastapi [fix] requirements.txt 缺 fastapi/uvicorn，按 README 跑 serve_openai_api.py 直接崩	2026-09-20 19:42:22 +08:00
jingyaogong	d698c06fc5	Merge pull request #864 from Linxiushen/fix-nonstream-max-tokens [fix] serve_openai_api 非流式端点的 max_tokens 不生效，与流式端点行为不一致	2026-09-20 19:42:05 +08:00
Linxiushen	984a2c3611	[fix] requirements.txt 缺 fastapi/uvicorn，按 README 跑 serve_openai_api.py 直接崩 README 的「第0步」让用户 pip install -r requirements.txt 完成环境搭建，随后在 OpenAI 兼容服务一节给出可直接运行的命令（README.md:1652）： cd scripts && python serve_openai_api.py 但 scripts/serve_openai_api.py 第12行 import uvicorn、第16-17行 from fastapi import ... 都是顶层硬依赖，而 requirements.txt 里两个都没有。复现（venv 严格按 requirements.txt 装齐）： $ cd scripts && python serve_openai_api.py --help ModuleNotFoundError: No module named 'uvicorn' 补上两行。版本已在独立 venv 里验证可与已声明的 pydantic==2.11.5 共存。	2026-09-20 11:57:27 +08:00
Linxiushen	d4b67f1783	[fix] serve_openai_api 非流式端点的 max_tokens 不生效，与流式端点行为不一致非流式分支传的是 max_length，但 MiniMindForCausalLM.generate() 的签名里没有这个形参（只有 max_new_tokens=8192），max_length 被 **kwargs 吞掉后无人处理，于是 request.max_tokens 对生成长度零约束。同一文件的流式分支（第117行）传的是 max_new_tokens=max_tokens，精确生效。同一个请求参数在两条路径上行为完全不同。判决性实验：同时传 max_length=15 与 max_new_tokens=20， prompt 长度 10 -> 实际输出总长 30（新增 20），证明 max_length 被无视。改为与流式分支一致的 max_new_tokens=request.max_tokens（一行）。	2026-09-20 11:54:35 +08:00
Linxiushen	ba10c4d17b	[fix] float16 下 attention mask 的 -1e9 溢出成 -inf，导致整条序列输出 NaN Attention.forward 的手写 softmax 分支（flash SDPA 关闭时走这里）： scores = (xq @ xk.transpose(-2, -1)) / math.sqrt(self.head_dim) ... if attention_mask is not None: scores += (1.0 - mask) * -1e9 output = ... F.softmax(scores.float(), dim=-1) ... scores 的 dtype 跟随 xq/xk。float16 模型下它是 float16，而 torch.finfo(torch.float16).min ≈ -65504，把 -1e9 累加进去会饱和成 -inf （不是一个很大的有限负数）。当某个 query 在因果范围内可见的 key 全被 mask 掉时（左 padding 必然出现），softmax 整行 = NaN，并在下一层通过 K/V 投影扩散到同序列里 mask=1 的有效 token 上。 .float() 加在 softmax 那一刻已经太晚——溢出发生在它之前。修复：把 float32 提升提前到加 mask 之前，两处共 2 行。 fp32/bf16 路径数值等价（fp32 下原来的 .float() 本就是 no-op）。	2026-09-20 11:50:28 +08:00
Linxiushen	cb08b9300b	[fix] train_tokenizer 读预训练语料时产出 0 条文本，静默训出空词表 get_texts() 只解析 data.get('conversations')，但主线预训练数据 pretrain_t2t(_mini).jsonl 的每行是 {"text": ...}（README「数据集下载」一节）。把 DATA_PATH 指向预训练语料时，生成器一条文本都不产出，BpeTrainer 仅基于 initial_alphabet 训练，得到一个没有任何 merge 的词表，全程不报错。复现（改 DATA_PATH 为任意 pretrain_t2t*.jsonl，或直接调用）： from train_tokenizer import get_texts sum(1 for _ in get_texts('../dataset/pretrain_t2t_mini.jsonl')) # 修复前: 0 # 修复后: 1270238 改动： - get_texts 同时兼容 {"text": ...} 与 {"conversations": [...]} 两种格式 - 产出 0 条时 raise ValueError，而不是让调用方拿到一个空词表 - 把硬编码的 `if i >= 10000: break` 提为模块级 MAX_LINES（默认 0 = 全量）。原先这一行也会让 SFT 语料只用前 10000 行，且无从关闭；另外它按「行号」计数而非「有效文本条数」，遇到空内容或解析失败的行会提前耗尽配额。验证：用 pretrain_t2t 的前 3000 篇跑 train_tokenizer(vocab_size=2000)，得到 vocab=2000 / merges=1708；修复前同样输入得到 0 条 merge。两种格式各 20000 行的合成数据上，产出条数均为 20000（修复前分别是 0 和 10000）。	2026-09-20 10:33:51 +08:00
Daoyuan Li	56d4cddfd8	[fix] keep DPO preference pair think formatting aligned	2026-08-29 18:29:00 -07:00
$TOPSAIL\78190$ TOPSAIL\78190	0c91dea4a2	[refactor] remove redundant rollout update_policy after torch.compile	2026-08-24 12:43:50 +08:00
Jonathan Hill	182bff1bd8	fix: guard against empty/filtered LLM responses in chat_api.py Add null check before accessing choices[0].message.content in the non-streaming path. An empty choices list causes IndexError; a None message (returned by some providers on content-filtered responses with HTTP 200) causes AttributeError.	2026-05-18 03:44:31 -05:00