Upload train_ast.py

train_ast.py

@@ -0,0 +1,214 @@
+# 说明：
+# - 本脚本采用 LLaMA-3.1-8B（4bit）+ LoRA 微调，开启梯度检查点。
+# - 启用“packing 感知”的 GA（gradient_accumulation_steps）估算：
+#   通过对样本长度做贪心装箱，估计 packing 后的有效填充率 f_pack，
+#   据此计算每步大致 50k tokens/update 的梯度累积步数。
+# - 训练统计（总 tokens / 每步 tokens / 峰值显存 / 用时）会写入 outputs/training_summary.txt。
+#
+
+# =========================================================
+
+from unsloth import FastLanguageModel, is_bfloat16_supported
+import torch, time, numpy as np
+from transformers import TrainingArguments
+from trl import SFTTrainer
+from datasets import load_dataset
+
+# ===== 基本配置 =====
+max_seq_length = 5000
+per_device_bs  = 10
+TARGET_TOKENS_PER_UPDATE = 50_000  # 按 token 计费的目标预算（每步约 5 万 token）
+
+# ===== 分布式世界大小工具 =====
+def get_world_size():
+    if torch.distributed.is_available() and torch.distributed.is_initialized():
+        return torch.distributed.get_world_size()
+    return 1
+
+# Step 1: 加载 8k 上下文的预训练模型（4bit 量化）
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name       = "unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit",
+    max_seq_length   = max_seq_length,
+    dtype            = None,
+    load_in_4bit     = True,
+)
+
+# Step 2: 应用 LoRA（轻量 rank + 小 dropout；保留你当前设置）
+model = FastLanguageModel.get_peft_model(
+    model,
+    r                      = 16,
+    target_modules         = [
+        "q_proj", "k_proj", "v_proj", "o_proj",
+        "gate_proj", "up_proj", "down_proj"
+    ],
+    lora_alpha             = 16,
+    lora_dropout           = 0.05,  # 注：若追求 Unsloth “全速补丁”，可在**另一个实验**中将其设为 0.0
+    bias                   = "none",
+    use_gradient_checkpointing = "unsloth",  # 降显存
+    random_state           = 3407,
+    use_rslora             = False,
+    loftq_config           = None,
+)
+
+# Step 3: 数据与格式化（当前为 AST -> 描述）
+# 【若切换到 Code 输入：将文案"AST sequence"改为"Code"，并在 PROMPT 中将 ### AST: 改为 ### Code:】
+alpaca_prompt = r"""
+
+Given the following AST sequence, generate a natural language description for it.
+
+### AST:
+{}
+
+### Description:
+{}"""
+
+EOS_TOKEN = tokenizer.eos_token
+
+def formatting_prompts_func(examples):
+    # 【若切换输入形式：将下行的 'sequence' 替换为相应字段（如 'code'、'sbt' 等）】
+    sequences = examples["sequence"]
+    docstrings = examples["docstring"]
+    texts = []
+    for seq, doc in zip(sequences, docstrings):
+        texts.append(alpaca_prompt.format(seq, doc) + EOS_TOKEN)
+    return {"text": texts}
+
+# 【若切换输入形式：替换数据集名称/拆分，例如 ShijiaD/CodeXGLUE-Code-Docstring 等】
+dataset = load_dataset("ShijiaD/workshop-ast-compress-docstring", split="train")
+dataset = dataset.map(formatting_prompts_func, batched=True)
+
+# ====== packing 感知的 GA 估算（通过贪心装箱估计 f_pack） ======
+WORLD_SIZE = get_world_size()
+
+SAMPLE_SIZE = min(5000, len(dataset))
+if SAMPLE_SIZE < len(dataset):
+    sample_idx = np.random.RandomState(3407).choice(len(dataset), size=SAMPLE_SIZE, replace=False)
+    sample_ds  = dataset.select(sample_idx)
+else:
+    sample_ds  = dataset
+
+# 1) 统计每条样本的 token 长度（不截断，仅用于估算）
+def _len_map(batch):
+    enc = tokenizer(batch["text"], add_special_tokens=True, truncation=False)
+    ids = enc["input_ids"]
+    if isinstance(ids[0], list):
+        lens = [len(x) for x in ids]
+    else:
+        lens = [len(ids)]
+    return {"_len": lens}
+
+lens = sample_ds.map(_len_map, batched=True, desc="Tokenizing for packing estimate")["_len"]
+lens = [int(x) for x in lens if isinstance(x, (int, np.integer)) and x > 0]
+if len(lens) == 0:
+    raise RuntimeError("长度估算失败：样本长度列表为空。")
+
+# 2) 贪心装箱，模拟 TRL 的 packing（按 max_seq_length 填充，样本间估计加入 1 个分隔 token）
+sep_cost = 1
+bins_used_tokens = []  # 每个“箱子”中有效内容 token 数
+current = 0
+for L in lens:
+    if L > max_seq_length:
+        # 超窗样本在训练中会被截断；此处按上限计入估算
+        L = max_seq_length
+    need = (sep_cost if current > 0 else 0) + L
+    if current + need > max_seq_length:
+        bins_used_tokens.append(current)
+        current = L
+    else:
+        current += need
+if current > 0:
+    bins_used_tokens.append(current)
+
+total_capacity = len(bins_used_tokens) * max_seq_length
+total_used     = sum(bins_used_tokens)
+f_pack = float(total_used) / float(total_capacity) if total_capacity > 0 else 1.0
+f_pack = min(max(f_pack, 1e-3), 1.0)  # 保证数值稳定
+
+# 3) 按 f_pack 估算每步 token，并计算 GA
+tokens_per_micro = per_device_bs * max_seq_length * f_pack * WORLD_SIZE
+raw_accum = TARGET_TOKENS_PER_UPDATE / max(1.0, tokens_per_micro)
+gradient_accumulation_steps = max(1, int(round(raw_accum)))
+
+approx_tokens_per_update = int(round(per_device_bs * max_seq_length * f_pack * gradient_accumulation_steps * WORLD_SIZE))
+print(
+    f"[TokenBudget/packing-aware] fill≈{f_pack:.3f}, per_device_bs={per_device_bs}, "
+    f"GA={gradient_accumulation_steps}, ≈tokens/update={approx_tokens_per_update:,} "
+    f"(target≈{TARGET_TOKENS_PER_UPDATE:,})"
+)
+
+# Step 4: 训练参数
+training_args = TrainingArguments(
+    per_device_train_batch_size   = per_device_bs,
+    gradient_accumulation_steps   = gradient_accumulation_steps,   # ← 动态 GA
+    num_train_epochs              = 3,
+    warmup_ratio                  = 0.05,
+    learning_rate                 = 5e-5,
+    fp16                          = False,
+    bf16                          = True,
+    logging_steps                 = 20,
+    optim                         = "adamw_8bit",
+    weight_decay                  = 0.01,
+    lr_scheduler_type             = "linear",
+    gradient_checkpointing        = True,
+    seed                          = 3407,
+    output_dir                    = "outputs",
+    save_strategy                 = "epoch",
+)
+
+# 构建 Trainer（packing=True）
+trainer = SFTTrainer(
+    model               = model,
+    tokenizer           = tokenizer,
+    train_dataset       = dataset,
+    dataset_text_field  = "text",
+    max_seq_length      = max_seq_length,
+    packing             = True,   # 保持与估算口径一致
+    dataset_num_proc    = 2,
+    args                = training_args,
+)
+
+# Step 5: GPU 信息
+gpu_stats       = torch.cuda.get_device_properties(0)
+max_memory      = round(gpu_stats.total_memory / 1024**3, 3)
+start_reserved  = round(torch.cuda.max_memory_reserved() / 1024**3, 3)
+print(f"GPU = {gpu_stats.name}. Max memory = {max_memory} GB.")
+print(f"Reserved before train: {start_reserved} GB.")
+
+# Step 6: 训练与计时
+t0 = time.time()
+trainer_stats = trainer.train()
+t1 = time.time()
+elapsed_hours = (t1 - t0) / 3600.0
+
+# Step 7: 训练统计（粗略估计，与 f_pack/GA 口径一致）
+used_memory   = round(torch.cuda.max_memory_reserved() / 1024**3, 3)
+used_for_lora = round(used_memory - start_reserved, 3)
+print(f"Peak reserved memory = {used_memory} GB.")
+print(f"Peak reserved memory for training = {used_for_lora} GB.")
+print(f"Peak reserved memory % of max memory = {used_memory/max_memory*100:.2f}%.")
+
+total_steps = trainer.state.global_step
+approx_tokens_per_micro  = int(round(per_device_bs * max_seq_length * f_pack * WORLD_SIZE))
+approx_tokens_per_update = approx_tokens_per_micro * gradient_accumulation_steps
+total_train_tokens       = int(total_steps * approx_tokens_per_update)
+
+summary_lines = []
+summary_lines.append("\n================= Training Summary =================")
+summary_lines.append(f"Total train tokens (approx):  {total_train_tokens:,}")
+summary_lines.append(f"Avg tokens / microbatch:      {approx_tokens_per_micro:,}")
+summary_lines.append(f"Approx tokens / update:       {approx_tokens_per_update:,}")
+summary_lines.append(f"Elapsed time:                 {elapsed_hours:.2f} hours")
+summary_lines.append(f"Peak reserved memory:         {used_memory} GB")
+summary_lines.append("====================================================\n")
+
+print("\n".join(summary_lines))
+
+import os
+os.makedirs("outputs", exist_ok=True)
+with open("outputs/training_summary.txt", "w", encoding="utf-8") as f:
+    f.write("\n".join(summary_lines))
+
+# Step 8: 保存模型（当前保存至 lora_model_ast）
+# 【若切换输入形式：可更换目录名以便区分，例如 lora_model_code / lora_model_sbt】
+model.save_pretrained("lora_model_ast")
+tokenizer.save_pretrained("lora_model_ast")