A LLM trained only on data from certain time periods to reduce modern bias
Python
Add files via upload
Hayk Grigorian36ea94d8b9c4
diff --git a/configurator.py b/configurator.pynew file mode 100644index 0000000..d7c5b5c--- /dev/null+++ b/configurator.py@@ -0,0 +1,47 @@+"""+Poor Man's Configurator. Probably a terrible idea. Example usage:+$ python train.py config/override_file.py --batch_size=32+this will first run config/override_file.py, then override batch_size to 32++The code in this file will be run as follows from e.g. train.py:+>>> exec(open('configurator.py').read())++So it's not a Python module, it's just shuttling this code away from train.py+The code in this script then overrides the globals()++I know people are not going to love this, I just really dislike configuration+complexity and having to prepend config. to every single variable. If someone+comes up with a better simple Python solution I am all ears.+"""++import sys+from ast import literal_eval++for arg in sys.argv[1:]:+ if '=' not in arg:+ # assume it's the name of a config file+ assert not arg.startswith('--')+ config_file = arg+ print(f"Overriding config with {config_file}:")+ with open(config_file) as f:+ print(f.read())+ exec(open(config_file).read())+ else:+ # assume it's a --key=value argument+ assert arg.startswith('--')+ key, val = arg.split('=')+ key = key[2:]+ if key in globals():+ try:+ # attempt to eval it it (e.g. if bool, number, or etc)+ attempt = literal_eval(val)+ except (SyntaxError, ValueError):+ # if that goes wrong, just use the string+ attempt = val+ # ensure the types match ok+ assert type(attempt) == type(globals()[key])+ # cross fingers+ print(f"Overriding: {key} = {attempt}")+ globals()[key] = attempt+ else:+ raise ValueError(f"Unknown config key: {key}")diff --git a/model.py b/model.pynew file mode 100644index 0000000..ae51c7a--- /dev/null+++ b/model.py@@ -0,0 +1,330 @@+"""+Full definition of a GPT Language Model, all of it in this single file.+References:+1) the official GPT-2 TensorFlow implementation released by OpenAI:+https://github.com/openai/gpt-2/blob/master/src/model.py+2) huggingface/transformers PyTorch implementation:+https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt2/modeling_gpt2.py+"""++import math+import inspect+from dataclasses import dataclass++import torch+import torch.nn as nn+from torch.nn import functional as F++class LayerNorm(nn.Module):+ """ LayerNorm but with an optional bias. PyTorch doesn't support simply bias=False """++ def __init__(self, ndim, bias):+ super().__init__()+ self.weight = nn.Parameter(torch.ones(ndim))+ self.bias = nn.Parameter(torch.zeros(ndim)) if bias else None++ def forward(self, input):+ return F.layer_norm(input, self.weight.shape, self.weight, self.bias, 1e-5)++class CausalSelfAttention(nn.Module):++ def __init__(self, config):+ super().__init__()+ assert config.n_embd % config.n_head == 0+ # key, query, value projections for all heads, but in a batch+ self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd, bias=config.bias)+ # output projection+ self.c_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias)+ # regularization+ self.attn_dropout = nn.Dropout(config.dropout)+ self.resid_dropout = nn.Dropout(config.dropout)+ self.n_head = config.n_head+ self.n_embd = config.n_embd+ self.dropout = config.dropout+ # flash attention make GPU go brrrrr but support is only in PyTorch >= 2.0+ self.flash = hasattr(torch.nn.functional, 'scaled_dot_product_attention')+ if not self.flash:+ print("WARNING: using slow attention. Flash Attention requires PyTorch >= 2.0")+ # causal mask to ensure that attention is only applied to the left in the input sequence+ self.register_buffer("bias", torch.tril(torch.ones(config.block_size, config.block_size))+ .view(1, 1, config.block_size, config.block_size))++ def forward(self, x):+ B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd)++ # calculate query, key, values for all heads in batch and move head forward to be the batch dim+ q, k, v = self.c_attn(x).split(self.n_embd, dim=2)+ k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)+ q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)+ v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)++ # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T)+ if self.flash:+ # efficient attention using Flash Attention CUDA kernels+ y = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=None, dropout_p=self.dropout if self.training else 0, is_causal=True)+ else:+ # manual implementation of attention+ att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))+ att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))+ att = F.softmax(att, dim=-1)+ att = self.attn_dropout(att)+ y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)+ y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side++ # output projection+ y = self.resid_dropout(self.c_proj(y))+ return y++class MLP(nn.Module):++ def __init__(self, config):+ super().__init__()+ self.c_fc = nn.Linear(config.n_embd, 4 * config.n_embd, bias=config.bias)+ self.gelu = nn.GELU()+ self.c_proj = nn.Linear(4 * config.n_embd, config.n_embd, bias=config.bias)+ self.dropout = nn.Dropout(config.dropout)++ def forward(self, x):+ x = self.c_fc(x)+ x = self.gelu(x)+ x = self.c_proj(x)+ x = self.dropout(x)+ return x++class Block(nn.Module):++ def __init__(self, config):+ super().__init__()+ self.ln_1 = LayerNorm(config.n_embd, bias=config.bias)+ self.attn = CausalSelfAttention(config)+ self.ln_2 = LayerNorm(config.n_embd, bias=config.bias)+ self.mlp = MLP(config)++ def forward(self, x):+ x = x + self.attn(self.ln_1(x))+ x = x + self.mlp(self.ln_2(x))+ return x++@dataclass+class GPTConfig:+ block_size: int = 1024+ vocab_size: int = 50304 # GPT-2 vocab_size of 50257, padded up to nearest multiple of 64 for efficiency+ n_layer: int = 12+ n_head: int = 12+ n_embd: int = 768+ dropout: float = 0.0+ bias: bool = True # True: bias in Linears and LayerNorms, like GPT-2. False: a bit better and faster++class GPT(nn.Module):++ def __init__(self, config):+ super().__init__()+ assert config.vocab_size is not None+ assert config.block_size is not None+ self.config = config++ self.transformer = nn.ModuleDict(dict(+ wte = nn.Embedding(config.vocab_size, config.n_embd),+ wpe = nn.Embedding(config.block_size, config.n_embd),+ drop = nn.Dropout(config.dropout),+ h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]),+ ln_f = LayerNorm(config.n_embd, bias=config.bias),+ ))+ self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)+ # with weight tying when using torch.compile() some warnings get generated:+ # "UserWarning: functional_call was passed multiple values for tied weights.+ # This behavior is deprecated and will be an error in future versions"+ # not 100% sure what this is, so far seems to be harmless. TODO investigate+ self.transformer.wte.weight = self.lm_head.weight # https://paperswithcode.com/method/weight-tying++ # init all weights+ self.apply(self._init_weights)+ # apply special scaled init to the residual projections, per GPT-2 paper+ for pn, p in self.named_parameters():+ if pn.endswith('c_proj.weight'):+ torch.nn.init.normal_(p, mean=0.0, std=0.02/math.sqrt(2 * config.n_layer))++ # report number of parameters+ print("number of parameters: %.2fM" % (self.get_num_params()/1e6,))++ def get_num_params(self, non_embedding=True):+ """+ Return the number of parameters in the model.+ For non-embedding count (default), the position embeddings get subtracted.+ The token embeddings would too, except due to the parameter sharing these+ params are actually used as weights in the final layer, so we include them.+ """+ n_params = sum(p.numel() for p in self.parameters())+ if non_embedding:+ n_params -= self.transformer.wpe.weight.numel()+ return n_params++ def _init_weights(self, module):+ if isinstance(module, nn.Linear):+ torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)+ if module.bias is not None:+ torch.nn.init.zeros_(module.bias)+ elif isinstance(module, nn.Embedding):+ torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)++ def forward(self, idx, targets=None):+ device = idx.device+ b, t = idx.size()+ assert t <= self.config.block_size, f"Cannot forward sequence of length {t}, block size is only {self.config.block_size}"+ pos = torch.arange(0, t, dtype=torch.long, device=device) # shape (t)++ # forward the GPT model itself+ tok_emb = self.transformer.wte(idx) # token embeddings of shape (b, t, n_embd)+ pos_emb = self.transformer.wpe(pos) # position embeddings of shape (t, n_embd)+ x = self.transformer.drop(tok_emb + pos_emb)+ for block in self.transformer.h:+ x = block(x)+ x = self.transformer.ln_f(x)++ if targets is not None:+ # if we are given some desired targets also calculate the loss+ logits = self.lm_head(x)+ loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1)+ else:+ # inference-time mini-optimization: only forward the lm_head on the very last position+ logits = self.lm_head(x[:, [-1], :]) # note: using list [-1] to preserve the time dim+ loss = None++ return logits, loss++ def crop_block_size(self, block_size):+ # model surgery to decrease the block size if necessary+ # e.g. we may load the GPT2 pretrained model checkpoint (block size 1024)+ # but want to use a smaller block size for some smaller, simpler model+ assert block_size <= self.config.block_size+ self.config.block_size = block_size+ self.transformer.wpe.weight = nn.Parameter(self.transformer.wpe.weight[:block_size])+ for block in self.transformer.h:+ if hasattr(block.attn, 'bias'):+ block.attn.bias = block.attn.bias[:,:,:block_size,:block_size]++ @classmethod+ def from_pretrained(cls, model_type, override_args=None):+ assert model_type in {'gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'}+ override_args = override_args or {} # default to empty dict+ # only dropout can be overridden see more notes below+ assert all(k == 'dropout' for k in override_args)+ from transformers import GPT2LMHeadModel+ print("loading weights from pretrained gpt: %s" % model_type)++ # n_layer, n_head and n_embd are determined from model_type+ config_args = {+ 'gpt2': dict(n_layer=12, n_head=12, n_embd=768), # 124M params+ 'gpt2-medium': dict(n_layer=24, n_head=16, n_embd=1024), # 350M params+ 'gpt2-large': dict(n_layer=36, n_head=20, n_embd=1280), # 774M params+ 'gpt2-xl': dict(n_layer=48, n_head=25, n_embd=1600), # 1558M params+ }[model_type]+ print("forcing vocab_size=50257, block_size=1024, bias=True")+ config_args['vocab_size'] = 50257 # always 50257 for GPT model checkpoints+ config_args['block_size'] = 1024 # always 1024 for GPT model checkpoints+ config_args['bias'] = True # always True for GPT model checkpoints+ # we can override the dropout rate, if desired+ if 'dropout' in override_args:+ print(f"overriding dropout rate to {override_args['dropout']}")+ config_args['dropout'] = override_args['dropout']+ # create a from-scratch initialized minGPT model+ config = GPTConfig(**config_args)+ model = GPT(config)+ sd = model.state_dict()+ sd_keys = sd.keys()+ sd_keys = [k for k in sd_keys if not k.endswith('.attn.bias')] # discard this mask / buffer, not a param++ # init a huggingface/transformers model+ model_hf = GPT2LMHeadModel.from_pretrained(model_type)+ sd_hf = model_hf.state_dict()++ # copy while ensuring all of the parameters are aligned and match in names and shapes+ sd_keys_hf = sd_hf.keys()+ sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.masked_bias')] # ignore these, just a buffer+ sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.bias')] # same, just the mask (buffer)+ transposed = ['attn.c_attn.weight', 'attn.c_proj.weight', 'mlp.c_fc.weight', 'mlp.c_proj.weight']+ # basically the openai checkpoints use a "Conv1D" module, but we only want to use a vanilla Linear+ # this means that we have to transpose these weights when we import them+ assert len(sd_keys_hf) == len(sd_keys), f"mismatched keys: {len(sd_keys_hf)} != {len(sd_keys)}"+ for k in sd_keys_hf:+ if any(k.endswith(w) for w in transposed):+ # special treatment for the Conv1D weights we need to transpose+ assert sd_hf[k].shape[::-1] == sd[k].shape+ with torch.no_grad():+ sd[k].copy_(sd_hf[k].t())+ else:+ # vanilla copy over the other parameters+ assert sd_hf[k].shape == sd[k].shape+ with torch.no_grad():+ sd[k].copy_(sd_hf[k])++ return model++ def configure_optimizers(self, weight_decay, learning_rate, betas, device_type):+ # start with all of the candidate parameters+ param_dict = {pn: p for pn, p in self.named_parameters()}+ # filter out those that do not require grad+ param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}+ # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.+ # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.+ decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]+ nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]+ optim_groups = [+ {'params': decay_params, 'weight_decay': weight_decay},+ {'params': nodecay_params, 'weight_decay': 0.0}+ ]+ num_decay_params = sum(p.numel() for p in decay_params)+ num_nodecay_params = sum(p.numel() for p in nodecay_params)+ print(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")+ print(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")+ # Create AdamW optimizer and use the fused version if it is available+ fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters+ use_fused = fused_available and device_type == 'cuda'+ extra_args = dict(fused=True) if use_fused else dict()+ optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)+ print(f"using fused AdamW: {use_fused}")++ return optimizer++ def estimate_mfu(self, fwdbwd_per_iter, dt):+ """ estimate model flops utilization (MFU) in units of A100 bfloat16 peak FLOPS """+ # first estimate the number of flops we do per iteration.+ # see PaLM paper Appendix B as ref: https://arxiv.org/abs/2204.02311+ N = self.get_num_params()+ cfg = self.config+ L, H, Q, T = cfg.n_layer, cfg.n_head, cfg.n_embd//cfg.n_head, cfg.block_size+ flops_per_token = 6*N + 12*L*H*Q*T+ flops_per_fwdbwd = flops_per_token * T+ flops_per_iter = flops_per_fwdbwd * fwdbwd_per_iter+ # express our flops throughput as ratio of A100 bfloat16 peak flops+ flops_achieved = flops_per_iter * (1.0/dt) # per second+ flops_promised = 312e12 # A100 GPU bfloat16 peak flops is 312 TFLOPS+ mfu = flops_achieved / flops_promised+ return mfu++ @torch.no_grad()+ def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None):+ """+ Take a conditioning sequence of indices idx (LongTensor of shape (b,t)) and complete+ the sequence max_new_tokens times, feeding the predictions back into the model each time.+ Most likely you'll want to make sure to be in model.eval() mode of operation for this.+ """+ for _ in range(max_new_tokens):+ # if the sequence context is growing too long we must crop it at block_size+ idx_cond = idx if idx.size(1) <= self.config.block_size else idx[:, -self.config.block_size:]+ # forward the model to get the logits for the index in the sequence+ logits, _ = self(idx_cond)+ # pluck the logits at the final step and scale by desired temperature+ logits = logits[:, -1, :] / temperature+ # optionally crop the logits to only the top k options+ if top_k is not None:+ v, _ = torch.topk(logits, min(top_k, logits.size(-1)))+ logits[logits < v[:, [-1]]] = -float('Inf')+ # apply softmax to convert logits to (normalized) probabilities+ probs = F.softmax(logits, dim=-1)+ # sample from the distribution+ idx_next = torch.multinomial(probs, num_samples=1)+ # append sampled index to the running sequence and continue+ idx = torch.cat((idx, idx_next), dim=1)++ return idxdiff --git a/sample.py b/sample.pynew file mode 100644index 0000000..fa337f2--- /dev/null+++ b/sample.py@@ -0,0 +1,85 @@+"""+Sample from a trained model (London GPT)+"""+import os+import pickle+import torch+from contextlib import nullcontext+from model import GPTConfig, GPT+from tokenizers import ByteLevelBPETokenizer++# ─── tokenizer setup ────────────────────────────────────────────────+tok_folder = "tokenizer_london"+vocab_path = os.path.join(tok_folder, "vocab.json")+merges_path = os.path.join(tok_folder, "merges.txt")+if not (os.path.isfile(vocab_path) and os.path.isfile(merges_path)):+ raise FileNotFoundError(f"Cannot find tokenizer files in {tok_folder}: {vocab_path}, {merges_path}")++tokenizer = ByteLevelBPETokenizer(vocab_path, merges_path)+encode = lambda s: tokenizer.encode(s).ids+decode = lambda ids: tokenizer.decode(ids)+# ────────────────────────────────────────────────────────────────────++# ─── experiment settings (you can override via CLI) ────────────────+import sys+import argparse+parser = argparse.ArgumentParser()+parser.add_argument("--out_dir", default="out_london")+parser.add_argument("--device", default="cpu")+parser.add_argument("--start", default="\n")+parser.add_argument("--num_samples", type=int, default=10)+parser.add_argument("--max_new_tokens", type=int, default=500)+parser.add_argument("--temperature", type=float, default=0.8)+parser.add_argument("--top_k", type=int, default=200)+parser.add_argument("--seed", type=int, default=1337)+parser.add_argument("--compile", action="store_true")+args = parser.parse_args()++out_dir = args.out_dir+start = args.start+num_samples = args.num_samples+max_new_tokens = args.max_new_tokens+temperature = args.temperature+top_k = args.top_k+seed = args.seed+compile_flag = args.compile+device_str = args.device+# ────────────────────────────────────────────────────────────────────++# reproducibility & device+torch.manual_seed(seed)+device = torch.device(device_str)+ctx = nullcontext() if device.type == "cpu" else torch.amp.autocast(device_type=device.type, dtype=torch.float32)++# ─── load model checkpoint ──────────────────────────────────────────+ckpt_path = os.path.join(out_dir, "ckpt.pt")+if not os.path.isfile(ckpt_path):+ raise FileNotFoundError(f"Checkpoint not found: {ckpt_path}")+ckpt = torch.load(ckpt_path, map_location=device)+gptconf = GPTConfig(**ckpt["model_args"])+model = GPT(gptconf)+sd = ckpt["model"]+# strip prefix if present+for k in list(sd.keys()):+ if k.startswith("_orig_mod."):+ sd[k[len("_orig_mod."):]] = sd.pop(k)+model.load_state_dict(sd)+model.eval().to(device)+if compile_flag:+ model = torch.compile(model)+# ────────────────────────────────────────────────────────────────────++# prepare prompt tensor+if start.startswith("FILE:"):+ with open(start[5:], "r", encoding="utf-8") as f:+ start = f.read()+ids = encode(start)+x = torch.tensor([ids], dtype=torch.long, device=device)++# ─── generation ─────────────────────────────────────────────────────+with torch.no_grad(), ctx:+ for i in range(num_samples):+ y = model.generate(x, max_new_tokens, temperature=temperature, top_k=top_k)+ print(decode(y[0].tolist()))+ print("---------------")+# ────────────────────────────────────────────────────────────────────diff --git a/train.py b/train.pynew file mode 100644index 0000000..5b2c39e--- /dev/null+++ b/train.py@@ -0,0 +1,339 @@+"""+This training script can be run both on a single gpu in debug mode,+and also in a larger training run with distributed data parallel (ddp).++To run on a single GPU, example:+$ python train.py --batch_size=32 --compile=False++To run with DDP on 4 gpus on 1 node, example:+$ torchrun --standalone --nproc_per_node=4 train.py++To run with DDP on 4 gpus across 2 nodes, example:+- Run on the first (master) node with example IP 123.456.123.456:+$ torchrun --nproc_per_node=8 --nnodes=2 --node_rank=0 --master_addr=123.456.123.456 --master_port=1234 train.py+- Run on the worker node:+$ torchrun --nproc_per_node=8 --nnodes=2 --node_rank=1 --master_addr=123.456.123.456 --master_port=1234 train.py+(If your cluster does not have Infiniband interconnect prepend NCCL_IB_DISABLE=1)+"""++import os+import time+import math+import pickle+from contextlib import nullcontext+import torch+torch._dynamo.config.suppress_errors = True+++import numpy as np+import torch+from torch.nn.parallel import DistributedDataParallel as DDP+from torch.distributed import init_process_group, destroy_process_group++from model import GPTConfig, GPT++# -----------------------------------------------------------------------------+# default config values designed to train a gpt2 (124M) on OpenWebText+# I/O+out_dir = 'out'+eval_interval = 2000+log_interval = 1+eval_iters = 200+eval_only = False # if True, script exits right after the first eval+always_save_checkpoint = True # if True, always save a checkpoint after each eval+init_from = 'scratch' # 'scratch' or 'resume' or 'gpt2*'+# wandb logging+wandb_log = False # disabled by default+wandb_project = 'owt'+wandb_run_name = 'gpt2' # 'run' + str(time.time())+# data+dataset = 'openwebtext'+gradient_accumulation_steps = 5 * 8 # used to simulate larger batch sizes+batch_size = 12 # if gradient_accumulation_steps > 1, this is the micro-batch size+block_size = 1024+# model+n_layer = 12+n_head = 12+n_embd = 768+dropout = 0.0 # for pretraining 0 is good, for finetuning try 0.1++bias = False # do we use bias inside LayerNorm and Linear layers?+# adamw optimizer+learning_rate = 6e-4 # max learning rate+max_iters = 600000 # total number of training iterations+weight_decay = 1e-1+beta1 = 0.9+beta2 = 0.95+grad_clip = 1.0 # clip gradients at this value, or disable if == 0.0+# learning rate decay settings+decay_lr = True # whether to decay the learning rate+warmup_iters = 2000 # how many steps to warm up for+lr_decay_iters = 600000 # should be ~= max_iters per Chinchilla+min_lr = 6e-5 # minimum learning rate, should be ~= learning_rate/10 per Chinchilla+# DDP settings+backend = 'nccl' # 'nccl', 'gloo', etc.+# system+device = 'cuda' # examples: 'cpu', 'cuda', 'cuda:0', 'cuda:1' etc., or try 'mps' on macbooks+dtype = 'bfloat16' if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else 'float16' # 'float32', 'bfloat16', or 'float16', the latter will auto implement a GradScaler+compile = True # use PyTorch 2.0 to compile the model to be faster+# -----------------------------------------------------------------------------+config_keys = [k for k,v in globals().items() if not k.startswith('_') and isinstance(v, (int, float, bool, str))]+exec(open('configurator.py').read()) # overrides from command line or config file+config = {k: globals()[k] for k in config_keys} # will be useful for logging+# -----------------------------------------------------------------------------++# various inits, derived attributes, I/O setup+ddp = int(os.environ.get('RANK', -1)) != -1 # is this a ddp run?+if ddp:+ init_process_group(backend=backend)+ ddp_rank = int(os.environ['RANK'])+ ddp_local_rank = int(os.environ['LOCAL_RANK'])+ ddp_world_size = int(os.environ['WORLD_SIZE'])+ device = f'cuda:{ddp_local_rank}'+ torch.cuda.set_device(device)+ master_process = ddp_rank == 0 # this process will do logging, checkpointing etc.+ seed_offset = ddp_rank # each process gets a different seed+ # world_size number of processes will be training simultaneously, so we can scale+ # down the desired gradient accumulation iterations per process proportionally+ assert gradient_accumulation_steps % ddp_world_size == 0+ gradient_accumulation_steps //= ddp_world_size+else:+ # if not ddp, we are running on a single gpu, and one process+ master_process = True+ seed_offset = 0+ ddp_world_size = 1+tokens_per_iter = gradient_accumulation_steps * ddp_world_size * batch_size * block_size+print(f"tokens per iteration will be: {tokens_per_iter:,}")++if master_process:+ os.makedirs(out_dir, exist_ok=True)+torch.manual_seed(1337 + seed_offset)+torch.backends.cuda.matmul.allow_tf32 = True # allow tf32 on matmul+torch.backends.cudnn.allow_tf32 = True # allow tf32 on cudnn+device_type = 'cuda' if 'cuda' in device else 'cpu' # for later use in torch.autocast+# note: float16 data type will automatically use a GradScaler+ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]+ctx = nullcontext() if device_type == 'cpu' else torch.amp.autocast(device_type=device_type, dtype=ptdtype)++# poor man's data loader+data_dir = os.path.join('data', dataset)+def get_batch(split):+ # We recreate np.memmap every batch to avoid a memory leak, as per+ # https://stackoverflow.com/questions/45132940/numpy-memmap-memory-usage-want-to-iterate-once/61472122#61472122+ if split == 'train':+ data = np.memmap(os.path.join(data_dir, 'train.bin'), dtype=np.uint16, mode='r')+ else:+ data = np.memmap(os.path.join(data_dir, 'val.bin'), dtype=np.uint16, mode='r')+ ix = torch.randint(len(data) - block_size, (batch_size,))+ x = torch.stack([torch.from_numpy((data[i:i+block_size]).astype(np.int64)) for i in ix])+ y = torch.stack([torch.from_numpy((data[i+1:i+1+block_size]).astype(np.int64)) for i in ix])+ if device_type == 'cuda':+ # pin arrays x,y, which allows us to move them to GPU asynchronously (non_blocking=True)+ x, y = x.pin_memory().to(device, non_blocking=True), y.pin_memory().to(device, non_blocking=True)+ else:+ x, y = x.to(device), y.to(device)+ return x, y++# init these up here, can override if init_from='resume' (i.e. from a checkpoint)+iter_num = 0+best_val_loss = 1e9++# attempt to derive vocab_size from the dataset+meta_path = os.path.join(data_dir, 'meta.pkl')+meta_vocab_size = None+if os.path.exists(meta_path):+ with open(meta_path, 'rb') as f:+ meta = pickle.load(f)+ meta_vocab_size = meta['vocab_size']+ print(f"found vocab_size = {meta_vocab_size} (inside {meta_path})")++# model init+model_args = dict(n_layer=n_layer, n_head=n_head, n_embd=n_embd, block_size=block_size,+ bias=bias, vocab_size=None, dropout=dropout) # start with model_args from command line+if init_from == 'scratch':+ # init a new model from scratch+ print("Initializing a new model from scratch")+ # determine the vocab size we'll use for from-scratch training+ if meta_vocab_size is None:+ print("defaulting to vocab_size of GPT-2 to 50304 (50257 rounded up for efficiency)")+ model_args['vocab_size'] = meta_vocab_size if meta_vocab_size is not None else 50304+ gptconf = GPTConfig(**model_args)+ model = GPT(gptconf)+elif init_from == 'resume':+ print(f"Resuming training from {out_dir}")+ # resume training from a checkpoint.+ ckpt_path = os.path.join(out_dir, 'ckpt.pt')+ checkpoint = torch.load(ckpt_path, map_location=device)+ checkpoint_model_args = checkpoint['model_args']+ # force these config attributes to be equal otherwise we can't even resume training+ # the rest of the attributes (e.g. dropout) can stay as desired from command line+ for k in ['n_layer', 'n_head', 'n_embd', 'block_size', 'bias', 'vocab_size']:+ model_args[k] = checkpoint_model_args[k]+ # create the model+ gptconf = GPTConfig(**model_args)+ model = GPT(gptconf)+ state_dict = checkpoint['model']+ # fix the keys of the state dictionary :(+ # honestly no idea how checkpoints sometimes get this prefix, have to debug more+ unwanted_prefix = '_orig_mod.'+ for k,v in list(state_dict.items()):+ if k.startswith(unwanted_prefix):+ state_dict[k[len(unwanted_prefix):]] = state_dict.pop(k)+ model.load_state_dict(state_dict)+ iter_num = checkpoint['iter_num']+ best_val_loss = checkpoint['best_val_loss']+elif init_from.startswith('gpt2'):+ print(f"Initializing from OpenAI GPT-2 weights: {init_from}")+ # initialize from OpenAI GPT-2 weights+ override_args = dict(dropout=dropout)+ model = GPT.from_pretrained(init_from, override_args)+ # read off the created config params, so we can store them into checkpoint correctly+ for k in ['n_layer', 'n_head', 'n_embd', 'block_size', 'bias', 'vocab_size']:+ model_args[k] = getattr(model.config, k)+# crop down the model block size if desired, using model surgery+if block_size < model.config.block_size:+ model.crop_block_size(block_size)+ model_args['block_size'] = block_size # so that the checkpoint will have the right value+model.to(device)++# initialize a GradScaler. If enabled=False scaler is a no-op+scaler = torch.cuda.amp.GradScaler(enabled=(dtype == 'float16'))++# optimizer+optimizer = model.configure_optimizers(weight_decay, learning_rate, (beta1, beta2), device_type)+if init_from == 'resume':+ optimizer.load_state_dict(checkpoint['optimizer'])+checkpoint = None # free up memory++# compile the model+if compile:+ print("compiling the model... (takes a ~minute)")+ unoptimized_model = model+ model = torch.compile(model) # requires PyTorch 2.0++# wrap model into DDP container+if ddp:+ model = DDP(model, device_ids=[ddp_local_rank])++# helps estimate an arbitrarily accurate loss over either split using many batches[email protected]_grad()+def estimate_loss():+ out = {}+ model.eval()+ for split in ['train', 'val']:+ losses = torch.zeros(eval_iters)+ for k in range(eval_iters):+ X, Y = get_batch(split)+ with ctx:+ logits, loss = model(X, Y)+ losses[k] = loss.item()+ out[split] = losses.mean()+ model.train()+ return out++# learning rate decay scheduler (cosine with warmup)+def get_lr(it):+ # 1) linear warmup for warmup_iters steps+ if it < warmup_iters:+ return learning_rate * (it + 1) / (warmup_iters + 1)+ # 2) if it > lr_decay_iters, return min learning rate+ if it > lr_decay_iters:+ return min_lr+ # 3) in between, use cosine decay down to min learning rate+ decay_ratio = (it - warmup_iters) / (lr_decay_iters - warmup_iters)+ assert 0 <= decay_ratio <= 1+ coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff ranges 0..1+ return min_lr + coeff * (learning_rate - min_lr)++# logging+if wandb_log and master_process:+ import wandb+ wandb.init(project=wandb_project, name=wandb_run_name, config=config)++# training loop+X, Y = get_batch('train') # fetch the very first batch+t0 = time.time()+local_iter_num = 0 # number of iterations in the lifetime of this process+raw_model = model.module if ddp else model # unwrap DDP container if needed+running_mfu = -1.0+while True:++ # determine and set the learning rate for this iteration+ lr = get_lr(iter_num) if decay_lr else learning_rate+ for param_group in optimizer.param_groups:+ param_group['lr'] = lr++ # evaluate the loss on train/val sets and write checkpoints+ if iter_num % eval_interval == 0 and master_process:+ losses = estimate_loss()+ print(f"step {iter_num}: train loss {losses['train']:.4f}, val loss {losses['val']:.4f}")+ if wandb_log:+ wandb.log({+ "iter": iter_num,+ "train/loss": losses['train'],+ "val/loss": losses['val'],+ "lr": lr,+ "mfu": running_mfu*100, # convert to percentage+ })+ if losses['val'] < best_val_loss or always_save_checkpoint:+ best_val_loss = losses['val']+ if iter_num > 0:+ checkpoint = {+ 'model': raw_model.state_dict(),+ 'optimizer': optimizer.state_dict(),+ 'model_args': model_args,+ 'iter_num': iter_num,+ 'best_val_loss': best_val_loss,+ 'config': config,+ }+ print(f"saving checkpoint to {out_dir}")+ torch.save(checkpoint, os.path.join(out_dir, 'ckpt.pt'))+ if iter_num == 0 and eval_only:+ break++ # forward backward update, with optional gradient accumulation to simulate larger batch size+ # and using the GradScaler if data type is float16+ for micro_step in range(gradient_accumulation_steps):+ if ddp:+ # in DDP training we only need to sync gradients at the last micro step.+ # the official way to do this is with model.no_sync() context manager, but+ # I really dislike that this bloats the code and forces us to repeat code+ # looking at the source of that context manager, it just toggles this variable+ model.require_backward_grad_sync = (micro_step == gradient_accumulation_steps - 1)+ with ctx:+ logits, loss = model(X, Y)+ loss = loss / gradient_accumulation_steps # scale the loss to account for gradient accumulation+ # immediately async prefetch next batch while model is doing the forward pass on the GPU+ X, Y = get_batch('train')+ # backward pass, with gradient scaling if training in fp16+ scaler.scale(loss).backward()+ # clip the gradient+ if grad_clip != 0.0:+ scaler.unscale_(optimizer)+ torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)+ # step the optimizer and scaler if training in fp16+ scaler.step(optimizer)+ scaler.update()+ # flush the gradients as soon as we can, no need for this memory anymore+ optimizer.zero_grad(set_to_none=True)++ # timing and logging+ t1 = time.time()+ dt = t1 - t0+ t0 = t1+ if iter_num % log_interval == 0 and master_process:+ # get loss as float. note: this is a CPU-GPU sync point+ # scale up to undo the division above, approximating the true total loss (exact would have been a sum)+ lossf = loss.item() * gradient_accumulation_steps+ if local_iter_num >= 5: # let the training loop settle a bit+ mfu = raw_model.estimate_mfu(batch_size * gradient_accumulation_steps, dt)+ running_mfu = mfu if running_mfu == -1.0 else 0.9*running_mfu + 0.1*mfu+ print(f"iter {iter_num}: loss {lossf:.4f}, time {dt*1000:.2f}ms, mfu {running_mfu*100:.2f}%")+ iter_num += 1+ local_iter_num += 1++ # termination conditions+ if iter_num > max_iters:+ break++if ddp:+ destroy_process_group()