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
