Skip to content

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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 idx
diff --git a/sample.py b/sample.py
new file mode 100644
index 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.py
new file mode 100644
index 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
+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()