def test_Trainer_Conv1D_TwoPatterns(self): cleanup() try: traindataset = UCRDataset("TwoPatterns", partition="train", ratio=.75, randomstate=0, augment_data_noise=.1) validdataset = UCRDataset("TwoPatterns", partition="valid", ratio=.75, randomstate=0) nclasses = traindataset.nclasses traindataloader = torch.utils.data.DataLoader(traindataset, batch_size=8, shuffle=True, num_workers=0, pin_memory=True) validdataloader = torch.utils.data.DataLoader(validdataset, batch_size=8, shuffle=False, num_workers=0, pin_memory=True) model = ConvShapeletModel(num_layers=3, hidden_dims=50, ts_dim=1, n_classes=nclasses) if torch.cuda.is_available(): model = model.cuda() config = dict(epochs=2, learning_rate=1e-3, earliness_factor=.75, visdomenv="unittest", switch_epoch=1, loss_mode="loss_cross_entropy", show_n_samples=0, store="/tmp") trainer = Trainer(model, traindataloader, validdataloader, **config) trainer.fit() except Exception as e: self.fail(logging.exception(e)) self.assertEqual(trainer.get_phase(), EARLINESS_PHASE_NAME) # should have written two model files self.assertTrue( os.path.exists( "/tmp/model_{}.pth".format(CLASSIFICATION_PHASE_NAME))) self.assertTrue( os.path.exists("/tmp/model_{}.pth".format(EARLINESS_PHASE_NAME)))
def test_Trainer_TwoPatterns(self): try: traindataset = UCRDataset("TwoPatterns", partition="train", ratio=.75, randomstate=0, augment_data_noise=.1) validdataset = UCRDataset("TwoPatterns", partition="valid", ratio=.75, randomstate=0) nclasses = traindataset.nclasses traindataloader = torch.utils.data.DataLoader(traindataset, batch_size=8, shuffle=True, num_workers=0, pin_memory=True) validdataloader = torch.utils.data.DataLoader(validdataset, batch_size=8, shuffle=False, num_workers=0, pin_memory=True) model = DualOutputRNN(input_dim=1, nclasses=nclasses, hidden_dims=20, num_rnn_layers=1, dropout=.2) if torch.cuda.is_available(): model = model.cuda() config = dict( epochs=2, learning_rate=1e-3, earliness_factor=.75, visdomenv="unittest", switch_epoch=1, loss_mode="twophase_linear_loss", show_n_samples=0, store="/tmp", overwrite=True, ) trainer = Trainer(model, traindataloader, validdataloader, **config) trainer.fit() except Exception as e: self.fail(logging.exception(e))
if optimizer is None: optimizer = optim.Adam(model.parameters(), lr=learning_rate) # Reload model if desired if os.path.exists(fn): print(f"Loading from {fn}") model.load_state_dict(torch.load(fn)) t = Trainer(model, optimizer, batchsize=batchsize, callbacks=callbacks, seed=seed, print_every=25, window=window, cuda=True) for epoch in range(n_epochs): model.run_disc = True model.train(True) t.fit(*train_args) model.train(False) t.test(*test_args) t.print_summary() torch.save(model.state_dict(), fn) # Output vectors np.savez("model", user_bas=model.embed_user.bias.weight.data.numpy(), user_vec=model.embed_user.vect.weight.data.numpy(), item_bas=model.embed_item.bias.weight.data.numpy(), item_vec=model.embed_item.vect.weight.data.numpy())
def train(args): classmapping = args.classmapping hyperparameterfolder = args.hyperparameterfolder # prepare dataset, model, hyperparameters for the respective experiments args = experiments(args) if classmapping is not None: print("overwriting classmapping with manual input") args.classmapping = classmapping if hyperparameterfolder is not None: print("overwriting hyperparameterfolder with manual input") args.hyperparameterfolder = hyperparameterfolder traindataloader, testdataloader = prepare_dataset(args) args.nclasses = traindataloader.dataset.nclasses classname = traindataloader.dataset.classname klassenname = traindataloader.dataset.klassenname args.seqlength = traindataloader.dataset.sequencelength #args.seqlength = args.samplet args.input_dims = traindataloader.dataset.ndims model = getModel(args) store = os.path.join(args.store, args.experiment) logger = Logger(columns=["accuracy"], modes=["train", "test"], rootpath=store) visdomenv = "{}_{}".format(args.experiment, args.dataset) visdomlogger = VisdomLogger(env=visdomenv) if args.model in ["transformer"]: optimizer = ScheduledOptim( optim.Adam(filter(lambda x: x.requires_grad, model.parameters()), betas=(0.9, 0.98), eps=1e-09, weight_decay=args.weight_decay), model.d_model, args.warmup) elif args.model in ["rnn", "msresnet", "tempcnn"]: optimizer = optim.Adam(filter(lambda x: x.requires_grad, model.parameters()), betas=(0.9, 0.999), eps=1e-08, weight_decay=args.weight_decay, lr=args.learning_rate) else: raise ValueError( args.model + "no valid model. either 'rnn', 'msresnet', 'transformer', 'tempcnn'" ) config = dict(epochs=args.epochs, learning_rate=args.learning_rate, show_n_samples=args.show_n_samples, store=store, visdomlogger=visdomlogger, overwrite=args.overwrite, checkpoint_every_n_epochs=args.checkpoint_every_n_epochs, test_every_n_epochs=args.test_every_n_epochs, logger=logger, optimizer=optimizer) trainer = Trainer(model, traindataloader, testdataloader, **config) logger = trainer.fit() # stores all stored values in the rootpath of the logger logger.save() #pth = store+"/npy/confusion_matrix_{epoch}.npy".format(epoch = args.epochs) parse_run(store, args.classmapping, outdir=store) #confusionmatrix2table(pth, # classnames=klassenname, # outfile=store+"/npy/table.tex") #texconfmat(pth) #accuracy2table(store+"/npy/confusion_matrix_{epoch}.npy".format(epoch = args.epochs), classnames=klassenname) #stats = trainer.test_epoch(evaldataloader) pass
''' import os import sys import time import logging logging.basicConfig(format='%(asctime)s [%(levelname)s] %(message)s', level=logging.INFO) # gets env vars + set up MAX_NUM_THREADS from config import * # training_utils imports from utils.trainer import Trainer from utils.data import get_data, DataBunch logger = logging.getLogger(__name__) if __name__ == "__main__": x, y = get_data(seed=SEED) # PREPROCESSING data = DataBunch(x, y) data.process() # TRAINING trainer = Trainer(data) trainer.fit(n_epochs=5) sys.exit(0)
def train(args): if args.hyperparametercsv is not None: args = readHyperparameterCSV(args) region = "HOLL_2018_MT_pilot" traindataloader = getDataloader( dataset=args.dataset, partition=args.train_on, batch_size=args.batchsize, num_workers=args.workers, shuffle=True, pin_memory=True, train_valid_split_ratio=args.train_valid_split_ratio, train_valid_split_seed=args.train_valid_split_seed, region=region, classmapping=args.classmapping, seed=args.seed, ndvi=args.ndvi, nsamples=args.nsamples) testdataloader = getDataloader( dataset=args.dataset, partition=args.test_on, batch_size=args.batchsize, num_workers=args.workers, shuffle=False, pin_memory=True, train_valid_split_ratio=args.train_valid_split_ratio, train_valid_split_seed=args.train_valid_split_seed, region=region, classmapping=args.classmapping, seed=args.seed, ndvi=args.ndvi, nsamples=args.nsamples) #evaldataloader = getDataloader(dataset=args.dataset, # partition="eval", # batch_size=args.batchsize, # num_workers=args.workers, # shuffle=False, # pin_memory=True, # train_valid_split_ratio=args.train_valid_split_ratio, # train_valid_split_seed=args.train_valid_split_seed, # region=region) args.nclasses = traindataloader.dataset.nclasses args.seqlength = traindataloader.dataset.sequencelength args.input_dims = traindataloader.dataset.ndims model = getModel(args) # np.array([np.array(p.shape).prod() for p in model.parameters()]).sum() if not args.no_visdom: visdomenv = "{}_{}_{}".format(args.experiment, args.dataset, args.loss_mode.replace("_", "-")) else: visdomenv = None print("Visdom Environment: {}".format(visdomenv)) config = dict(epochs=args.epochs, learning_rate=args.learning_rate, earliness_factor=args.earliness_factor, visdomenv=visdomenv, switch_epoch=args.switch_epoch, loss_mode=args.loss_mode, show_n_samples=args.show_n_samples, store=os.path.join(args.store, args.experiment, args.dataset), overwrite=args.overwrite, ptsepsilon=args.epsilon, test_every_n_epochs=args.test_every_n_epochs, entropy_factor=args.entropy_factor, resume_optimizer=args.resume_optimizer, warmup_steps=args.warmup_steps, earliness_reward_power=args.earliness_reward_power) trainer = Trainer(model, traindataloader, testdataloader, **config) trainer.fit() #stats = trainer.test_epoch(evaldataloader) pass
def eval(dataset, batchsize, workers, num_rnn_layers, dropout, hidden_dims, store="/tmp", epochs=30, switch_epoch=30, learning_rate=1e-3, visdomenv="run", earliness_factor=.75, show_n_samples=1, modelname="DualOutputRNN", loss_mode=None, load_weights=None, entropy_factor=0): if dataset == "synthetic": traindataset = SyntheticDataset(num_samples=2000, T=100) validdataset = SyntheticDataset(num_samples=1000, T=100) else: traindataset = UCRDataset(dataset, partition="trainvalid") validdataset = UCRDataset(dataset, partition="test") nclasses = traindataset.nclasses np.random.seed(0) torch.random.manual_seed(0) traindataloader = torch.utils.data.DataLoader(traindataset, batch_size=batchsize, shuffle=True, num_workers=workers, pin_memory=True) np.random.seed(1) torch.random.manual_seed(1) validdataloader = torch.utils.data.DataLoader(validdataset, batch_size=batchsize, shuffle=False, num_workers=workers, pin_memory=True) if modelname == "DualOutputRNN": model = DualOutputRNN(input_dim=1, nclasses=nclasses, hidden_dim=hidden_dims, num_rnn_layers=num_rnn_layers, dropout=dropout) else: raise ValueError( "Invalid Model, Please insert either 'DualOutputRNN' or 'AttentionRNN'" ) if load_weights is not None: model.load(load_weights) # parse epoch 29 from filename e.g., 'models/TwoPatterns/run/model_29.pth' start_epoch = int( os.path.basename(load_weights).split("_")[-1].split(".")[0]) else: start_epoch = 0 if torch.cuda.is_available(): model = model.cuda() #if run is None: # visdomenv = "{}_{}_{}".format(args.experiment, dataset,args.loss_mode.replace("_","-")) # storepath = store #else: # visdomenv = run #storepath = os.path.join(store, dataset) if switch_epoch is None: switch_epoch = int(epochs / 2) config = dict(epochs=epochs, learning_rate=learning_rate, earliness_factor=earliness_factor, visdomenv=visdomenv, switch_epoch=switch_epoch, loss_mode=loss_mode, show_n_samples=show_n_samples, store=store, entropy_factor=entropy_factor) trainer = Trainer(model, traindataloader, validdataloader, config=config) logged_data = trainer.fit(start_epoch=start_epoch) return logged_data