Delete train_ast.py

train_ast.py

@@ -1,214 +0,0 @@
-# 说明：
-# - 本脚本采用 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")