Source code for quantdata.dysanos.grid.torch_train

from dataclasses import dataclass, field, asdict
import math
from cdxcore.pretty import PrettyObject
from cdxcore.verbose import Context
from cdxcore.subdir import SubDir
from cdxcore.err import verify, verify_inp
from cdxcore.version import version
from cdxcore.uniquehash import unique_label48_8
from quantdata.dysanos.grid.torch_market import GridMarketDefinition
from quantdata.dysanos.grid.torch_model import SanosModelConfig, BaseEnvironment
from quantdata.dysanos.grid.torch_gfx import VizConfig, Visualizer
from quantdata.pool import PoolConfig
import torch as torch
import time as time
import numpy as np
import os
import warnings

if os.environ.get("DYSANONS_USE_LAPTOP") is not None:
    _cache_root = SubDir(r"C:\users\public\.dysanos_grid/")
else:
    _cache_root = SubDir("~/.dysanos_grid")
    
[docs] @dataclass(frozen=True, kw_only=True) class TrainConfig: num_epochs : int = 5000 #: total epochs batch_size : int|None = None #: batch size, or None for all samples val_batch_size : int|None = None #: batch size for validation, or None for all samples pcnt_validation : float = 0. #: fraction of samples to use for validation. Will be automatically adjusted such that there are always at least 2 training samples. lr : float = 1E-3 #: initial learning rate final_lr : float = 1E-5 #: final learning rate weight_decay : float = 1e-4 #: weight decay for regularization compile : bool = False #: compile torch clip_grad_norm : float|None = None #: max norm for gradient clipping clip_grad : float|None = None #: max for gradient clipping epoch_interval: int = 200 #: after how many epochs to update visualization and store checkpoint time_interval : float = 2*60 #: after how many seconds to update visualization and store checkpoint def __post_init__(self): verify_inp( self.num_epochs > 0, f"Expected 'num_epochs' to be positive, but found {self.num_epochs}" ) verify_inp( self.final_lr > 0., f"Expected 'final_lr' to be positive, but found {self.final_lr}" ) verify_inp( self.lr >= self.final_lr, f"Expected 'lr' to be greater than or equal to 'final_lr' {self.final_lr}, but found {self.lr}" ) verify_inp( self.weight_decay >= 0., f"Expected 'weight_decay' to be non-negative, but found {self.weight_decay}" ) verify_inp( self.epoch_interval > 0, f"Expected 'epoch_interval' to be positive, but found {self.epoch_interval}" ) verify_inp( self.time_interval > 0., f"Expected 'time_interval' to be positive, but found {self.time_interval}" ) verify_inp( self.pcnt_validation >= 0. and self.pcnt_validation < 1., f"Expected 'pcnt_validation' to be in [0,1), but found {self.pcnt_validation:.2f}" ) verify_inp( self.weight_decay >= 0., f"Expected 'weight_decay' to be non-negative, but found {self.weight_decay}" ) verify_inp( self.clip_grad_norm >= 0., f"Expected 'clip_grad_norm' to be non-negative, but found {self.clip_grad_norm}" ) if not self.clip_grad_norm is None else None verify_inp( self.clip_grad >= 0., f"Expected 'clip_grad' to be non-negative, but found {self.clip_grad}" ) if not self.clip_grad is None else None def __str__(self): return f"epochs={self.num_epochs},lr={self.lr:.4g}->{self.final_lr:.4g},wdec={self.weight_decay:.4g},bsize={'all' if self.batch_size is None else self.batch_size},vbsize={'all' if self.val_batch_size is None else self.val_batch_size},"+\ f"pcnt_val={self.pcnt_validation:.2f},compile={self.compile},epoch_interval={self.epoch_interval},time_interval={self.time_interval:.1f}s"+\ f"clip={self.clip_grad_norm:.2g},{self.clip_grad:.2g}"
[docs] def lr_for_epoch(self, epoch: int) -> float: if epoch <= 0: return self.lr if epoch >= self.num_epochs - 1: return self.final_lr p = epoch / (self.num_epochs - 1) return self.lr * (self.final_lr / self.lr) ** p
[docs] def set_lr_for_epoch(self, epoch: int, optimizer: torch.optim.Optimizer) -> float: lr = self.lr_for_epoch(epoch) for param_group in optimizer.param_groups: param_group['lr'] = lr return lr
[docs] def get_trn_vld_samples(self, num_total_samples : int) -> tuple[int,int]: num_trn_samples = max(2, min(math.ceil(num_total_samples * (1. - self.pcnt_validation)), num_total_samples)) num_vld_samples = num_total_samples - num_trn_samples return num_trn_samples, num_vld_samples
[docs] @dataclass class MetricTracker: trn_epochs : list[int] = field(default_factory=list) trn_losses : list[float] = field(default_factory=list) lr : list[float] = field(default_factory=list) val_epochs : list[int] = field(default_factory=list) val_losses : list[float] = field(default_factory=list) vld_epochs : list[int] = field(default_factory=list) vld_losses : list[float] = field(default_factory=list)
[docs] def train( market : PrettyObject,*, mdl_config : SanosModelConfig, trn_config : TrainConfig = TrainConfig(), viz_config : VizConfig = VizConfig(), restart : bool = False, just_load : bool = False, env : BaseEnvironment = BaseEnvironment(), verbose : Context = Context.all ) -> dict: """ Train model """ verify_inp( not (restart and just_load), f"Expected at most one of 'restart' and 'just_load' to be True, but found both True" ) verbose = verbose if not verbose is None else Context.all verbose = verbose if not just_load else Context.quiet verbose.write(lambda : f"Training {mdl_config.label} version {mdl_config.user_version} group '{mdl_config.group}' for {trn_config.num_epochs} epochs on {market.grid_market_def.ticker} for date range {market.grid_market_def.date_range}") verbose.write(lambda : f"Using {'all samples' if trn_config.batch_size is None else f'batches of {trn_config.batch_size} samples'} with learning rate {trn_config.lr:.4g} and weight decay {trn_config.weight_decay:.4g}.") verbose.report(1,lambda : f"Model config: {mdl_config}") verbose.report(1,lambda : f"Grid config: {market.grid_market_def.grid_config}") verbose.report(1,lambda : f"Mk Arb Free pre-processor: {market.grid_market_def.mk_arb_free}") verbose.report(1,lambda : f"Options filter: {market.grid_market_def.options_filter}") verbose.report(1,lambda : f"Raw day filter: {market.grid_market_def.raw_day_filter}") verbose.report(1,lambda : f"Expiry filter: {market.grid_market_def.expiry_filter}") num_total_samples = len(market.dates) num_trn_samples, num_vld_samples = trn_config.get_trn_vld_samples(num_total_samples) verify_inp( num_vld_samples == 0, f"Cannot train with validation samples") # create model # ------------ with verbose.write_t(lambda : f"Instantiating {mdl_config.label} version {mdl_config.user_version} on {env}... ", end='') as tme: T, N = market.grid_market_def.TN model = mdl_config.create( env, num_expiries=T, num_market_strikes=N ) verbose.write(lambda : f"done; this took {tme}.", head=False ) if model.debug: warnings.warn("** WARNING: model is running in (very slow) debug mode. **") optimizer = torch.optim.AdamW( model.parameters(), lr=trn_config.lr, weight_decay=trn_config.weight_decay ) # load # ---- path = _cache_root(ext="pt") if mdl_config.group == "" else _cache_root(mdl_config.group,ext="pt") file_name = unique_label48_8(mdl_config.label, as_file_name=True) cache_ffn = path.full_file_name(file_name) start_epoch = 0 tracker = MetricTracker() model_version = model.version.unique_id48 if not restart and path.exists(file_name): verbose.write(lambda : f"Found existing recovery checkpoint '{cache_ffn}'. Restoring model state from this checkpoint.") state = torch.load(cache_ffn, map_location=env.device, weights_only=False) user_version = state.pop("version", None) mdl_version = state.pop("mdl_version", None) err = None if user_version is None: err = f"Checkpoint '{cache_ffn}' does not contain a 'version'. This is likely an invalid checkpoint file." elif user_version != mdl_config.user_version: err = f"Checkpoint '{cache_ffn}' file user_version {user_version} does not match model user_version {mdl_config.user_version}." elif not mdl_version is None and model_version != mdl_version: err = f"Checkpoint '{cache_ffn}' file model version {mdl_version} does not match model version {model_version}." else: model.load_state_dict(state.pop("model_state_dict")) if just_load: model_output = None tdata = None return model_output, model, tdata optimizer.load_state_dict(state.pop("optimizer_state_dict")) tracker = MetricTracker(**state.pop("tracker")) start_epoch = tracker.trn_epochs[-1] + 1 if not err is None: if just_load: raise RuntimeError(err) warnings.warn(err + f" -- Restarting training.") else: if just_load: if restart: raise RuntimeError(f"Using 'read_only' and 'restart' together is not allowed. Restarting training will overwrite the checkpoint file '{cache_ffn}'.") raise RuntimeError(f"Checkpoint '{cache_ffn}' does not exist. Cannot load model.") verbose.write(lambda : f"Using recovery checkpoint '{cache_ffn}'.") # preprocess & copy data into tensors # ----------------------------------- with verbose.write_t(lambda : f"Preparing data set {mdl_config.label} version {mdl_config.user_version} on {env}... ", end='') as tme: total_tdata = mdl_config.torch_data( env = env, market = market, # no reload here message_context = None, verbose = Context.quiet ) trn_tdata = { k: v[:num_trn_samples,...] if v.shape[0]>1 else v for k, v in total_tdata.items() } vld_tdata = { k: v[num_trn_samples:,...] if v.shape[0]>1 else v for k, v in total_tdata.items() } if num_vld_samples > 0 else None verbose.write(lambda : f"done; this took {tme}.", head=False ) with verbose.write_t(lambda : f"\rComputing loss... ", end='') as tme: trn_ld0 = model( trn_tdata, training=False ) vld_ld0 = model( vld_tdata, training=False ) if vld_tdata is not None else None str_vld = f" and validation loss {vld_ld0['loss']:.4g}" if not vld_ld0 is None else "" verbose.write(lambda : f"\n{'Initial' if start_epoch == 0 else 'Current'} training loss is {trn_ld0['loss']:.4g}{str_vld}. This took {tme}.", head=False ) def sample(): if trn_config.batch_size is None or trn_config.batch_size >= num_trn_samples: return trn_tdata, None else: idx = torch.randint(0, num_trn_samples, (trn_config.batch_size,)) return { k: v[idx,...] if not v is None else None for k, v in trn_tdata.items() }, idx # compile # ------- def gradient_step( batch ): loss = model( batch, training=True ) model.verify( lambda : torch.isfinite(loss).all(), "Internal error: loss infinite" ) return loss def valuation( all_data ): with torch.no_grad(): return model( all_data, training=False ) if start_epoch < trn_config.num_epochs and trn_config.compile: with verbose.write_t(lambda : f"Compiling {mdl_config.label} version {mdl_config.user_version} for {env.device}: training... ", end='') as tme: gradient_step = torch.compile( mode="reduce-overhead", dynamic=False, fullgraph=True, disable=model.debug, )( gradient_step ) _ = gradient_step(sample()[0]) del _ verbose.write("valuation... ", head=False, end='') valuation = torch.compile( mode="reduce-overhead", dynamic=False, fullgraph=True, disable=model.debug, )( valuation ) _ = valuation(trn_tdata) if not vld_tdata is None: verbose.write("validation... ", head=False, end='') _ = valuation(vld_tdata) del _ verbose.write(lambda : f"done; this took {tme}.", head=False ) # visualization & seralization # ---------------------------- disp = Visualizer( market=market, model_output0=PrettyObject({k:v.detach().cpu().numpy() for k,v in trn_ld0.items() if not v is None}), viz_config=viz_config, mdl_config=mdl_config ) del trn_ld0, vld_ld0 def viz_and_store(*, epoch: int, final : bool = False): """ call valuation and then visualize and store the model """ model.eval() trn_ld = valuation( trn_tdata ) vld_ld = valuation( vld_tdata ) if not vld_tdata is None else None assert len(tracker.val_epochs) == 0 or tracker.val_epochs[-1] <= epoch+1, f"Expected last validation epoch {tracker.val_epochs[-1]} to be less than or equal to current epoch {epoch+1}" if len(tracker.val_epochs)==0 or tracker.val_epochs[-1] < epoch+1: tracker.val_losses.append(trn_ld['loss'].cpu().item()) tracker.val_epochs.append(epoch+1) else: tracker.val_losses[-1] = trn_ld['loss'].cpu().item() tracker.val_epochs[-1] = epoch+1 if not vld_ld is None: if len(tracker.vld_epochs)==0 or tracker.vld_epochs[-1] < epoch+1: tracker.vld_losses.append(vld_ld['loss'].cpu().item()) tracker.vld_epochs.append(epoch+1) else: tracker.vld_losses[-1] = vld_ld['loss'].cpu().item() tracker.vld_epochs[-1] = epoch+1 # convert to numpy def compute( ld ): if ld is None: return None, None model_output = PrettyObject({k:v.detach().cpu().numpy() for k,v in ld.items() if not v is None}) weights = [ np.mean( market.weights[i,...][market.weights[i,...]>0] ) for i in range(market.weights.shape[0]) ] errors = [ model_output.errors[i,...][market.weights[i,...]>0] for i in range(model_output.errors.shape[0]) ] raw_errors = [ model_output.raw_errors[i,...][market.weights[i,...]>0] for i in range(model_output.raw_errors.shape[0]) ] # per sample summary # raw_errors = abs( weight*(fit-mid) ) # errors = raw_errors**2 if raw_errors<1 else 2*raw_errors - 1 (huber loss) es = PrettyObject() es.error_stats = PrettyObject() es.error_stats.weights = np.array(weights) es.error_stats.medians = np.array([ np.median(err) for err in errors ]) es.error_stats.means = np.array([ np.mean(err) for err in errors ]) es.error_stats.p90 = np.array([ np.quantile(err, 0.9) for err in errors ]) es.raw_error_stats = PrettyObject() es.raw_error_stats.weights = np.array(weights) es.raw_error_stats.medians = np.array([ np.median(err) for err in raw_errors ]) es.raw_error_stats.means = np.array([ np.mean(err) for err in raw_errors ]) es.raw_error_stats.p90 = np.array([ np.quantile(err, 0.9) for err in raw_errors ]) return model_output, es trn_model_output, trn_es = compute(trn_ld) vld_model_output, vld_es = compute(vld_ld) tmp_name = path.full_temp_file_name(file_name, ext="tmp", create_directory=True) torch.save(dict(version=mdl_config.user_version, mdl_version=model_version, tracker=asdict(tracker), optimizer_state_dict=optimizer.state_dict(), model_state_dict=model.state_dict(), grid_market_def=asdict(market.grid_market_def), mdl_config=asdict(mdl_config), mdl_config_class=mdl_config.__class__.__name__, trn_config=asdict(trn_config), error_stats=dict(trn_es.error_stats), raw_error_stats=dict(trn_es.raw_error_stats), vld_error_stats=dict(vld_es.error_stats) if not vld_es is None else {}, vld_raw_error_stats=dict(vld_es.raw_error_stats) if not vld_es is None else {}, ), tmp_name) os.rename(tmp_name, cache_ffn) # tracker, num_total_epochs, *, model_output, error_stats, final : bool = False ): disp(tracker=tracker, num_total_epochs=trn_config.num_epochs, model_output=trn_model_output, error_stats=trn_es, #vld_model_output=vld_model_output, vld_error_stats=vld_es, final=final) return (trn_model_output, vld_model_output) if final else None # train # ----- epoch = start_epoch if start_epoch < trn_config.num_epochs: with verbose.write_t(lambda : f"Training {mdl_config} with {trn_config} on {env}:") as tme: last_update = time.time() try: for epoch in range(start_epoch, trn_config.num_epochs): # ------------------------- # Training # ------------------------- model.train() train_loss = 0.0 optimizer.zero_grad(set_to_none=True) batch, idx = sample() loss = gradient_step(batch) loss.backward() # Optional but often useful if trn_config.clip_grad_norm is not None: torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=trn_config.clip_grad_norm) lr = trn_config.set_lr_for_epoch(epoch, optimizer) optimizer.step() train_loss = loss.detach().item() tracker.trn_losses.append(train_loss) tracker.trn_epochs.append(epoch+1) if epoch in [0,trn_config.num_epochs-1] or (tme.interval_test(1.) and ((epoch+1) % 10 == 0)): verbose.report(1, lambda : f"\rEpoch {epoch+1}/{trn_config.num_epochs}, Loss: {train_loss:.4g}. So far this took {tme}.", end='') if epoch in [0,trn_config.num_epochs-1] or ((epoch+1) % trn_config.epoch_interval == 0) or ((time.time() - last_update) > trn_config.time_interval): viz_and_store(epoch=epoch) last_update = time.time() if num_vld_samples == 0: verbose.report(1, lambda : f"\rEpoch {epoch+1}/{trn_config.num_epochs}, Trn loss: {train_loss:.4g}. Val loss: {tracker.val_losses[-1]:.4g}. So far this took {tme}. [Check point saved]", end='') else: verbose.report(1, lambda : f"\rEpoch {epoch+1}/{trn_config.num_epochs}, Trn loss: {train_loss:.4g}, "+\ f"Val loss: {tracker.val_losses[-1]:.4g}, "+\ f"Vld loss: {tracker.vld_losses[-1]:.4g}. So far this took {tme}. [Check point saved]", end='') except KeyboardInterrupt as e: verbose.write(lambda : f"\r*** Training interrupted at epoch {epoch+1}/{trn_config.num_epochs}. This took {tme}. Saving checkpoint and exiting.") viz_and_store(epoch=epoch,final=True) raise e verbose.write(lambda : f"\rModel trained for {trn_config.num_epochs} epochs. This took {tme}.") # finalize & return # ----------------- model.eval() trn_model_output,\ vld_model_output = viz_and_store(epoch=epoch,final=True) mo_path = path(ext="mo", fmt=SubDir.PYTREE_HDF5) verbose1 = verbose(1) verbose1.write(lambda : f"\rModel checkpoint file is'{cache_ffn}'.") with verbose1.write_t(lambda : f"\rWriting model output to '{mo_path.full_file_name(file_name)}'... ", end='') as tme: mo_path.write(file_name, trn_model_output, raise_on_error=True) verbose1.write(lambda : f"done; this took {tme}.", head=False ) str_vld = f", validation loss: {tracker.vld_losses[-1]:.4g}" if not vld_model_output is None else "" verbose.write(lambda : f"\rModel {mdl_config.label} version {mdl_config.user_version} group '{mdl_config.group}' trained for {trn_config.num_epochs} epochs. "+\ f"Final training loss: {tracker.trn_losses[-1]:.4g}, valuation loss: {tracker.val_losses[-1]:.4g}{str_vld}. This took {tme}.") return trn_model_output, model, trn_tdata
[docs] def load_model_market( ffn, env : BaseEnvironment = BaseEnvironment(), *, pool_config : PoolConfig = PoolConfig.off(), verbose : Context = Context.all ): """ Load model and market from a file ``ffn``. """ if not os.path.exists(ffn): raise FileNotFoundError(f"File '{ffn}' does not exist") with verbose.write_t(lambda : f"Loading model from '{ffn}' on {env}... ", end='') as tme: state = torch.load(ffn, map_location=env.device, weights_only=False) verbose.write(lambda : f"done; this took {tme}.", head=False ) user_version = state.pop("version", None) mdl_version = state.pop("mdl_version", None) mdl_config_class = state.pop("mdl_config_class", None) mdl_config = state.pop("mdl_config", None) grid_market_def = state.pop("grid_market_def", None) verify( not (mdl_version is None or mdl_config is None or mdl_config_class is None or grid_market_def is None), lambda : f"File '{ffn}' does not contain a valid model configuration.") grid_market_def = GridMarketDefinition(**grid_market_def) mdl_config = SanosModelConfig(**mdl_config) verify(user_version == mdl_config.user_version, lambda : f"File '{ffn}' user_version {user_version} does not match configured model user_version {mdl_config.user_version}.") with verbose.write_t(lambda : f"Loading market... ", end='') as tme: market = grid_market_def.load( pool_config = pool_config, verbose=Context.quiet ) verbose.write(lambda : f"done; this took {tme}. Found {len(market.dates)} dates.", head=False ) with verbose.write_t(lambda : f"Instantiating {mdl_config.label} version {mdl_config.user_version} on {env}... ", end='') as tme: T, N = market.grid_market_def.TN model = mdl_config.create( env, num_expiries=T, num_market_strikes=N ) verify(model.version.unique_id48 == mdl_version, lambda : f"File '{ffn}' model version {mdl_version} does not match model version {model.version.unique_id48}.") verbose.write(lambda : f"done; this took {tme}.", head=False ) if model.debug: warnings.warn("** WARNING: model is running in (very slow) debug mode. **") return model, market