File size: 5,880 Bytes
0ca529a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | import os
import math
from dataclasses import dataclass, field
from typing import Optional
def resolve_max_steps(
configured_max_steps: int,
num_epochs: int,
steps_per_epoch: int,
) -> int:
"""Resolve the explicit step limit or the epoch-derived training length."""
if steps_per_epoch <= 0:
raise ValueError(
"Training requires at least one full global step per epoch. "
"Reduce the global batch size or provide more training samples."
)
if configured_max_steps > 0:
return configured_max_steps
return math.ceil(num_epochs * steps_per_epoch)
@dataclass
class TrainingArguments:
""" Arguments for training."""
num_nodes: int = field(
default=1,
metadata={"help": "The number of nodes for the student/teacher model (only for on-policy KD)."}
)
num_gpus_per_node: int = field(
default=8,
metadata={"help": "The number of gpus per node for the student/teacher model (only for on-policy KD)."}
)
num_epochs: int = field(
default=1,
metadata={"help": "Number of training epochs."}
)
max_steps: int = field(
default=-1,
metadata={
"help": (
"Maximum global training steps. A positive value overrides "
"num_epochs; for on-policy KD, one global step is one rollout "
"iteration."
)
},
)
train_batch_size: int = field(
default=128,
metadata={"help": "Global training batch size."}
)
micro_train_batch_size: int = field(
default=1,
metadata={"help": "Micro training batch size per GPU."}
)
learning_rate: float = field(
default=1e-6
)
lr_warmup_ratio: float = field(
default=0.05
)
min_lr: float = field(
default=1e-8
)
lr_scheduler: str = field(
default="cosine_with_min_lr"
)
max_norm: float = field(
default=1.0,
metadata={"help": "Gradient clipping."}
)
weight_decay: float = field(
default=0.0,
metadata={"help": "Weight decay."}
)
adam_betas: str = field(
default="(0.9, 0.98)"
)
eval_steps: int = field(
default=-1,
metadata={"help": "Evaluation every n step."}
)
save_steps: int = field(
default=-1,
metadata={"help": "Save checkpoints every n step."}
)
backend: str = field(
default="fsdp2",
metadata={
"choices": ["fsdp2"],
"help": "Student training backend."
}
)
gradient_checkpointing: bool = field(
default=False
)
gradient_checkpointing_use_reentrant: bool = field(
default=False
)
train_enable_sleep: bool = field(
default=False,
metadata={"help": "[Deprecated] Use --enable_sleep instead."}
)
enable_sleep: bool = field(
default=False,
metadata={"help": "Enable sleep mode for all components (student, teacher, rollout)."}
)
full_determinism: bool = field(
default=False,
metadata={"help": "Enable reproducible behavior during distributed training."}
)
load_checkpoint: bool = field(
default=False
)
ckpt_path: str = field(
default="./ckpt/checkpoints_distill"
)
save_path: str = field(
default="./ckpt/"
)
seed: int = field(
default=42,
)
use_dynamic_bsz: bool = field(
default=False,
metadata={"help": "Enable dynamic batch size based on token count per GPU."}
)
max_token_len_per_gpu: int = field(
default=0,
metadata={"help": "Maximum total token count per micro-batch when use_dynamic_bsz is True."}
)
bf16: bool = field(
default=False
)
local_rank: int = field(
default=int(os.getenv("LOCAL_RANK", -1)),
metadata={"help": "Local rank for distributed training. Automatically set."}
)
chunked_loss_size: int = field(
default=None,
metadata={"help": "Token chunk size for chunked loss. If None, chunked loss is disabled."}
)
def __post_init__(self):
# Ray actors run from a temporary working directory. Resolve output paths
# in the driver before the arguments are serialized and sent to actors so
# relative paths keep their command-invocation semantics.
self.save_path = self._resolve_driver_path(self.save_path)
self.ckpt_path = self._resolve_driver_path(self.ckpt_path)
backend_choices = self.__class__.__dataclass_fields__["backend"].metadata["choices"]
if self.backend not in backend_choices:
raise ValueError(
f"Unsupported training backend '{self.backend}'"
f"Supported choices: {backend_choices}"
)
if isinstance(self.adam_betas, str):
try:
cleaned_str = self.adam_betas.strip().strip('()')
parts = [p.strip() for p in cleaned_str.split(',')]
if len(parts) != 2:
raise ValueError("adam_betas must contain two values.")
self.adam_betas = (float(parts[0]), float(parts[1]))
except Exception as e:
raise ValueError(
f"Cannot parse '{self.adam_betas}' to valid adam_betas. Make sure the format to be '(beta1, beta2)'。"
) from e
else:
raise TypeError(f"Expected str for adam_betas, but get {type(self.adam_betas)}")
if self.save_steps <= 0:
self.save_steps = float("inf")
if self.eval_steps <= 0:
self.eval_steps = float("inf")
@staticmethod
def _resolve_driver_path(path: str) -> str:
return os.path.abspath(os.path.expanduser(path))
|