def test(model, testloader, loss_function, device):
model.eval()
model.to(device)
engine = Engine()
def compute_loss(data):
inputs = data[0]
labels = data[1]
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model(inputs)
return loss_function(outputs, labels), outputs
def on_start(state):
print("Running inference ...")
state['iterator'] = tqdm(state['iterator'], leave=False)
class Accuracy():
_accuracy = 0.
_sample_size = 0.
def on_forward(state):
batch_size = state['sample'][1].shape[0]
Accuracy._sample_size += batch_size
Accuracy._accuracy += batch_size * get_accuracy(state['output'].cpu(), state['sample'][1].cpu())
engine.hooks['on_start'] = on_start
engine.hooks['on_forward'] = on_forward
engine.test(compute_loss, testloader)
return Accuracy._accuracy / Accuracy._sample_size
def calibrate(model, testloader, loss_function, device):
"""Calibrates the weight and activation quantization parameters.
Executes forward passes using the input data from `testloader`.
For every forward pass, collects the statistics and calibrates
the quantization parameters for all the weight and activation
quant modules.
Arguments:
model (:class:`QuantizedNet`): nn model to train
testloader (:class:`torch.utils.data.DataLoader`): dataloader to
iterate through the sample data for calibration
loss_function (:class:`torch.nn._Loss`): function to compute loss
device (:class:`torch.device`): the device to run calibration on
Returns:
Module: calibrated quantized model
"""
model.eval()
model.to(device)
engine = Engine()
# Enable profiling to collect statistics and calibrate quant params
model._profile()
# Quantize weights
model._quantize_weights()
def compute_loss(data):
"""Computes the loss from a given nn model."""
inputs = data[0]
labels = data[1]
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model(inputs)
return loss_function(outputs, labels), outputs
def on_start(state):
print("Calibrating quantized network ...")
state['iterator'] = tqdm(state['iterator'], leave=False)
def on_forward(state):
loss = state['loss'].item()
accuracy = get_accuracy(state['output'].cpu(),
state['sample'][1].cpu())
state['iterator'].write('batch %d loss %.3f accuracy %.3f ' %
(state['t'], loss, accuracy),
end='\n')
engine.hooks['on_start'] = on_start
engine.hooks['on_forward'] = on_forward
engine.test(compute_loss, testloader)
return model
def main():
meter_loss = tnt.meter.AverageValueMeter()
classerr = tnt.meter.ClassErrorMeter(accuracy=True)
params = {
'conv0.weight': conv_init(1, 50, 5),
'conv0.bias': torch.zeros(50),
'conv1.weight': conv_init(50, 50, 5),
'conv1.bias': torch.zeros(50),
'linear2.weight': linear_init(800, 512),
'linear2.bias': torch.zeros(512),
'linear3.weight': linear_init(512, 10),
'linear3.bias': torch.zeros(10),
}
for k, v in params.items():
params[k] = Variable(v, requires_grad=True)
def h(sample):
inputs = Variable(sample[0].float() / 255.0)
targets = Variable(torch.LongTensor(sample[1]))
o = f(params, inputs, sample[2])
return F.cross_entropy(o, targets), o
def on_sample(state):
state['sample'].append(state['train'])
def on_forward(state):
classerr.add(state['output'].data,
torch.LongTensor(state['sample'][1]))
meter_loss.add(state['loss'].data[0])
def on_start_epoch(state):
classerr.reset()
state['iterator'] = tqdm(state['iterator'])
def on_end_epoch(state):
print classerr.value()
optimizer = torch.optim.SGD(params.values(),
lr=0.01,
momentum=0.9,
weight_decay=0.0005)
engine = Engine()
engine.hooks['on_sample'] = on_sample
engine.hooks['on_forward'] = on_forward
engine.hooks['on_start_epoch'] = on_start_epoch
engine.hooks['on_end_epoch'] = on_end_epoch
engine.train(h, get_iterator(True), 10, optimizer)
engine.test(h, get_iterator(False))
def test(model, testloader, loss_function, device):
r"""Computes the accuracy and loss of the model for a given datatset.
Arguments:
model (:class:`torch.nn.Module`): nn model
lossf
testloader (:class:`torch.utils.data.DataLoader`): dataloader to
iterate through the data
loss_function (:class:`torch.nn._Loss`): function to compute loss
device (:class:`torch.device`): the device to run inference on
Returns:
accuracy (float): accuracy of the network on given dataset
"""
model.eval()
model.to(device)
engine = Engine()
def compute_loss(data):
"""Computes the loss from a given nn model."""
inputs = data[0]
labels = data[1]
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model(inputs)
return loss_function(outputs, labels), outputs
def on_start(state):
print("Running inference ...")
state['iterator'] = tqdm(state['iterator'], leave=False)
class Accuracy():
_accuracy = 0.;
_sample_size = 0.
def on_forward(state):
batch_size = state['sample'][1].shape[0]
Accuracy._sample_size += batch_size
Accuracy._accuracy += batch_size * get_accuracy(state['output'].cpu(), state['sample'][1].cpu())
engine.hooks['on_start'] = on_start
engine.hooks['on_forward'] = on_forward
engine.test(compute_loss, testloader)
return Accuracy._accuracy / Accuracy._sample_size
for i in range(0, 10):
reset_meters()
num = 20 + i
try:
model.load_state_dict(torch.load('epochs/epoch_%d.pt' % (num)))
except:
saved_state = torch.load('epochs/epoch_%d.pt' % (num))
new_state_dict = OrderedDict()
for k, v in saved_state.items():
namekey = k[7:]
new_state_dict[namekey] = v
model.load_state_dict(new_state_dict)
if GPU:
model.cuda()
index = 0
for j in tqdm(range(train_num)):
engine.test(processor, get_iterator(False))
index = index + 1
test_mi_pre, test_mi_rec, test_mi_f1 = mymeter.micro()
test_ma_pre, test_ma_rec, test_ma_f1 = mymeter.macro()
test_loss = meter_loss.value()[0]
print(
'[Epoch %d] test Loss: %.8f, mi_precision:%.8f mi_recall:%0.8f mi_f1:%0.8f ma_precision:%.8f ma_recall:%0.8f ma_f1:%0.8f'
% (num, test_loss, test_mi_pre, test_mi_rec, test_mi_f1,
test_ma_pre, test_ma_rec, test_ma_f1))
with open('testing_result.txt', 'a') as f:
f.write("%d %.8f %.8f %.8f\n" %
(num, test_loss, test_mi_f1, test_ma_f1))
def main():
"""Train a simple Hybrid Scattering + CNN model on MNIST.
Scattering features are normalized by batch normalization.
The model achieves 99.6% testing accuracy after 10 epochs.
"""
meter_loss = tnt.meter.AverageValueMeter()
classerr = tnt.meter.ClassErrorMeter(accuracy=True)
scat = Scattering(M=28, N=28, J=2).cuda()
K = 81
params = {
'conv1.weight': conv_init(K, 64, 1),
'conv1.bias': torch.zeros(64),
'bn.weight': torch.Tensor(K).uniform_(),
'bn.bias': torch.zeros(K),
'linear2.weight': linear_init(64*7*7, 512),
'linear2.bias': torch.zeros(512),
'linear3.weight': linear_init(512, 10),
'linear3.bias': torch.zeros(10),
}
stats = {'bn.running_mean': torch.zeros(K).cuda(),
'bn.running_var': torch.ones(K).cuda()}
for k, v in params.items():
params[k] = Variable(v.cuda(), requires_grad=True)
def h(sample):
x = scat(sample[0].float().cuda().unsqueeze(1) / 255.0).squeeze(1)
inputs = Variable(x)
targets = Variable(torch.LongTensor(sample[1]).cuda())
o = f(inputs, params, stats, sample[2])
return F.cross_entropy(o, targets), o
def on_sample(state):
state['sample'].append(state['train'])
def on_forward(state):
classerr.add(state['output'].data,
torch.LongTensor(state['sample'][1]))
meter_loss.add(state['loss'].data[0])
def on_start_epoch(state):
classerr.reset()
state['iterator'] = tqdm(state['iterator'])
def on_end_epoch(state):
print 'Training accuracy:', classerr.value()
def on_end(state):
print 'Training' if state['train'] else 'Testing', 'accuracy'
print classerr.value()
optimizer = torch.optim.SGD(params.values(), lr=0.01, momentum=0.9,
weight_decay=0.0005)
engine = Engine()
engine.hooks['on_sample'] = on_sample
engine.hooks['on_forward'] = on_forward
engine.hooks['on_start_epoch'] = on_start_epoch
engine.hooks['on_end_epoch'] = on_end_epoch
engine.hooks['on_end'] = on_end
print 'Training:'
engine.train(h, get_iterator(True), 10, optimizer)
print 'Testing:'
engine.test(h, get_iterator(False))
def main(cfg, cuda=torch.cuda.is_available()):
### flush cfg to output log file:
tqdm.write(str(cfg), file=cfg['logfile'])
tqdm.write('-' * 80, file=cfg['logfile'])
### define dataloader factory:
def get_iterator():
# set up dataloader config:
datasets = cfg['data_paths']
pin_mem = cuda
nworkers = cfg['num_workers']
# (possibly) concatenate datasets together:
ds = SeqTensorDataset(torch.load(datasets[0][0]),
torch.load(datasets[0][1]),
torch.load(datasets[0][2]),
torch.load(datasets[0][3]))
for dataset in datasets[1:]:
ds += SeqTensorDataset(torch.load(dataset[0]),
torch.load(dataset[1]),
torch.load(dataset[2]),
torch.load(dataset[3]))
# return a dataloader iterating over datasets; pagelock memory location if GPU detected:
return DataLoader(ds,
batch_size=cfg['batch_size'],
shuffle=True,
num_workers=nworkers,
collate_fn=sequence_collate_fn,
pin_memory=pin_mem)
### build RawCTCNet model:
in_dim = 1
layers = [(256, 256, d, 3)
for d in [1, 2, 4, 8, 16, 32, 64]] * cfg['num_stacks']
num_labels = 5
out_dim = 512
network = RawCTCNet(in_dim,
num_labels,
layers,
out_dim,
input_kw=1,
input_dil=1,
positions=True,
softmax=False,
causal=False,
batch_norm=True)
print("Constructed network.")
if cuda:
print("CUDA detected; placed network on GPU.")
network.cuda()
if cfg['model'] is not None:
print("Loading model file...")
try:
network.load_state_dict(torch.load(cfg['model']))
except:
print(
"ERR: could not restore model. Check model datatype/dimensions."
)
### build CTC loss function and model evaluation function:
ctc_loss_fn = CTCLoss()
print("Constructed CTC loss function.")
maybe_gpu = lambda tsr, has_cuda: tsr if not has_cuda else tsr.cuda()
def model_loss(sample):
# unpack inputs and wrap in Variables:
signals_, signal_lengths_, sequences_, sequence_lengths_ = sample
signals = Variable(maybe_gpu(signals_.permute(0, 2, 1), cuda),
volatile=True) # BxTxD => BxDxT
signal_lengths = Variable(signal_lengths_, volatile=True)
sequences = Variable(concat_labels(sequences_, sequence_lengths_),
volatile=True)
sequence_lengths = Variable(sequence_lengths_, volatile=True)
# compute predicted labels:
transcriptions = network(signals).permute(2, 0,
1) # Permute: BxDxT => TxBxD
# compute CTC loss and return:
loss = ctc_loss_fn(transcriptions, sequences.int(),
signal_lengths.int(), sequence_lengths.int())
return loss, transcriptions
### build beam search decoder:
beam_labels = [' ', 'A', 'G', 'C', 'T']
beam_blank_id = 0
beam_decoder = CTCBeamDecoder(beam_labels,
beam_width=100,
blank_id=beam_blank_id,
num_processes=cfg['num_workers'])
print("Constructed CTC beam search decoder.")
### build engine, meters, and hooks:
engine = Engine()
# Wrap a tqdm meter around the losses:
def on_start(state):
network.eval()
state['iterator'] = tqdm(state['iterator'])
# (Currently don't do anything w/r/t the sample.)
def on_sample(state):
pass
# occasionally log the loss value and perform beam search decoding:
def on_forward(state):
if (state['t'] % cfg['print_every'] == 0):
# log the ctc loss:
tqdm.write("Step {0} | Loss: {1}".format(state['t'],
state['loss'].data[0],
file=cfg['logfile']))
# beam search decoding:
_, logit_lengths_t, seq_t, seq_lengths_t = state['sample']
scores = mask_padding(state['output'].permute(1, 0, 2),
logit_lengths_t,
fill_logit_idx=0)
logits = F.softmax(scores, dim=2)
_nt_dict_ = {0: ' ', 1: 'A', 2: 'G', 3: 'C', 4: 'T'}
def convert_to_string(toks, voc, num):
try:
nt = ''.join([voc[t] for t in toks[0:num]])
except:
nt = ''
return nt
try:
true_nts = labels2strings(seq_t, lookup=_nt_dict_)
amax_nts = labels2strings(argmax_decode(logits),
lookup=_nt_dict_)
beam_result, beam_scores, beam_times, beam_lengths = beam_decoder.decode(
logits.data)
pred_nts = [
convert_to_string(beam_result[k][0], _nt_dict_,
beam_lengths[k][0])
for k in range(len(beam_result))
]
for i in range(min(len(true_nts), len(pred_nts))):
tqdm.write("True Seq: {0}".format(true_nts[i]),
file=cfg['logfile'])
tqdm.write("Beam Seq: {0}".format(pred_nts[i]),
file=cfg['logfile'])
tqdm.write("Amax Seq: {0}".format(amax_nts[i]),
file=cfg['logfile'])
tqdm.write(
("- " * 10 + "Local Beam Alignment" + " -" * 10),
file=cfg['logfile'])
tqdm.write(ssw(true_nts[i], pred_nts[i]),
file=cfg['logfile'])
tqdm.write("= " * 40, file=cfg['logfile'])
except:
tqdm.write("(WARN: Could not parse batch; skipping...)",
file=cfg['logfile'])
# (Currently don't do anything at end of epoch.)
def on_end(state):
pass
print("Constructed engine. Running validation loop...")
### run validation loop:
engine.hooks['on_start'] = on_start
engine.hooks['on_sample'] = on_sample
engine.hooks['on_forward'] = on_forward
engine.hooks['on_end'] = on_end
engine.test(model_loss, get_iterator())
engine.test(network=network_forward, iterator=test_loader)
if args.visdom:
test_loss_logger.log(state['epoch'] - 1, meter_loss.value()[0])
test_err_logger.log(state['epoch'] - 1, classerr.value()[0])
confusion_logger.log(confusion_meter.value())
print('[Epoch {:03d}] Test loss: {:.4f}\tTop 1: {:.2f}\tTop 5: {:.2f}'.
format(state['epoch'] - 1,
meter_loss.value()[0], classerr.value(k=1),
classerr.value(k=5)))
if args.test_only:
engine.hooks['on_sample'] = on_sample
engine.hooks['on_forward'] = on_forward
engine.test(network=network_forward, iterator=test_loader)
print('Test loss: {:.4f}\tTop 1: {:.2f}\tTop 5: {:.2f}'.format(
meter_loss.value()[0], classerr.value(k=1), classerr.value(k=5)))
else:
optimizer = torch.optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=True)
engine.hooks['on_start'] = on_start
engine.hooks['on_sample'] = on_sample
engine.hooks['on_forward'] = on_forward
engine.hooks['on_start_epoch'] = on_start_epoch
engine.hooks['on_end_epoch'] = on_end_epoch
engine.train(network=network_forward,
iterator=train_loader,
def main(cfg, cuda=torch.cuda.is_available()):
### flush cfg to output log file:
print(('-' * 37) + 'Config' + ('-' * 37), file=sys.stderr)
for k, v in cfg.items():
print(str(k) + ':' + str(v), file=sys.stderr)
print('-' * 80, file=sys.stderr)
### define dataloader factory:
def get_iterator():
# set up dataloader config:
datasets = cfg['data_paths']
pin_mem = cuda
nworkers = cfg['num_workers']
# construct signal dataset:
if cfg['dtype'] == 'npy':
ds = SignalDataset(
torch.from_numpy(np.load(datasets[0])).int(),
torch.from_numpy(np.load(datasets[1])).float())
else:
ds = SignalDataset(torch.load(datasets[0]),
torch.load(datasets[1]))
# return a dataloader iterating over datasets; pagelock memory location if GPU detected:
return DataLoader(
ds,
batch_size=1,
shuffle=False,
sampler=torch.utils.data.sampler.SequentialSampler(ds),
num_workers=nworkers,
pin_memory=pin_mem)
### build RawCTCNet model:
in_dim = 1
layers = [(256, 256, d, 3)
for d in [1, 2, 4, 8, 16, 32, 64]] * cfg['num_stacks']
num_labels = 5
out_dim = 512
network = RawCTCNet(in_dim,
num_labels,
layers,
out_dim,
input_kw=1,
input_dil=1,
positions=True,
softmax=False,
causal=False,
batch_norm=True)
print("Constructed network.", file=sys.stderr)
if cuda:
print("CUDA detected; placed network on GPU.", file=sys.stderr)
network.cuda()
if cfg['model'] is not None:
print("Loading model file...", file=sys.stderr)
try:
network.load_state_dict(torch.load(cfg['model']))
print("...Model file loaded.", file=sys.stderr)
except:
print(
"ERR: could not restore model. Check model datatype/dimensions.",
file=sys.stderr)
### build basecaller function:
maybe_gpu = lambda tsr, has_cuda: tsr if not has_cuda else tsr.cuda()
batchify = BatchSignalTransform(max_length=cfg['batchify_length'],
max_batch_size=cfg['batchify_size'])
def basecall(sample):
# compute predicted labels; the permutes perform `BxTxD => BxDxT => TxBxD`
return (0.0,
network(
Variable(maybe_gpu(
batchify(sample).permute(0, 2, 1), cuda),
volatile=True)).permute(2, 0, 1))
### build beam search decoder:
if (cfg['decoder'] == 'beam'):
beam_labels = [' ', 'A', 'G', 'C', 'T']
beam_blank_id = 0
beam_decoder = CTCBeamDecoder(beam_labels,
beam_width=100,
blank_id=beam_blank_id,
num_processes=cfg['num_workers'])
### build engine, meters, and hooks:
engine = Engine()
# Wrap a tqdm meter around the losses:
def on_start(state):
network.eval() # (set to eval mode for batch-norm)
print("Basecalling to STDOUT. (This could take a while.)",
file=sys.stderr)
state['iterator'] = tqdm(state['iterator'], file=sys.stderr)
# (Currently don't do anything w/r/t the sample.)
def on_sample(state):
pass
# decode outputs:
def on_forward(state):
logits = F.softmax(state['output'].permute(1, 0, 2), dim=2)
# ctc-beam decoding: return best hypothesis
if (cfg['decoder'] == 'beam'):
_nt_dict_ = {0: ' ', 1: 'A', 2: 'G', 3: 'C', 4: 'T'}
def convert_to_string(toks, voc, num):
try:
nt = ''.join([voc[t] for t in toks[0:num]])
except:
nt = ''
return nt
try:
beam_result, beam_scores, beam_times, beam_lengths = beam_decoder.decode(
logits.data)
pred_nts = [
convert_to_string(beam_result[k][0], _nt_dict_,
beam_lengths[k][0])
for k in range(len(beam_result))
]
print("".join(pred_nts))
except:
print("(WARN: Could not parse batch; skipping...)")
# arg-max decoding:
else:
try:
_nt_dict_ = {0: '', 1: 'A', 2: 'G', 3: 'C', 4: 'T'}
amax_nts = labels2strings(argmax_decode(logits),
lookup=_nt_dict_)
print("".join(amax_nts))
except:
print("(WARN: Could not parse batch; skipping...)")
# (Currently don't do anything at end of epoch.)
def on_end(state):
pass
print("Constructed engine. Running basecaller loop...", file=sys.stderr)
### run validation loop:
engine.hooks['on_start'] = on_start
engine.hooks['on_sample'] = on_sample
engine.hooks['on_forward'] = on_forward
engine.hooks['on_end'] = on_end
engine.test(basecall, get_iterator())
def main(model, opt, epoch, loss_fn=F.cross_entropy, lr_scheduler=None):
"""
train model and test on test data
:return:
"""
num_classes = 10
data = CIFAR10Data(train_split=0.8)
train_itr = data.get_train_loader(batch_size=64)
val_itr = data.get_val_loader(batch_size=64)
meter_loss = tnt.meter.AverageValueMeter()
classacc = tnt.meter.ClassErrorMeter(accuracy=True)
confusion_meter = tnt.meter.ConfusionMeter(num_classes, normalized=True)
history = {
'train_loss': [],
'train_acc': [],
'train_lr': [],
'val_loss': [],
'val_acc': []
}
port = 8097
env = 'CIFAR10'
train_loss_logger = VisdomPlotLogger('line',
env=env,
port=port,
opts={'title': 'Train Loss'})
train_err_logger = VisdomPlotLogger('line',
env=env,
port=port,
opts={'title': 'Train Acc'})
test_loss_logger = VisdomPlotLogger('line',
env=env,
port=port,
opts={'title': 'Test Loss'})
test_err_logger = VisdomPlotLogger('line',
env=env,
port=port,
opts={'title': 'Test Acc'})
lr_logger = VisdomPlotLogger('line',
env=env,
port=port,
opts={'title': 'Train LR'})
confusion_logger = VisdomLogger('heatmap',
port=port,
env=env,
opts={
'title': 'Confusion matrix',
'columnnames':
list(range(num_classes)),
'rownames': list(range(num_classes))
})
torch.manual_seed(6666)
torch.cuda.manual_seed(6666)
if torch.cuda.is_available():
device = torch.device('cuda:0')
else:
device = torch.device('cpu')
model.to(device)
def reset_meters():
classacc.reset()
meter_loss.reset()
def h(sample):
x = sample[0].to(device)
y = sample[1].to(device)
o = model(x)
return loss_fn(o, y), o
def on_forward(state):
classacc.add(state['output'].detach(), state['sample'][1])
meter_loss.add(state['loss'].item())
confusion_meter.add(state['output'].detach(), state['sample'][1])
if state['train']:
state['iterator'].set_postfix_str(
s="loss:{:.4f}, acc:{:.4f}%".format(meter_loss.value()[0],
classacc.value()[0]))
def on_start_epoch(state):
current_lr = opt.param_groups[0]['lr']
print('Epoch: %d/%d, lr:%.2e' %
(state['epoch'] + 1, state['maxepoch'], current_lr))
reset_meters()
model.train(True)
state['iterator'] = tqdm(state['iterator'], file=sys.stdout)
lr_logger.log(state['epoch'], current_lr)
history['train_lr'].append(current_lr)
def on_end_epoch(state):
# print('Training loss: %.4f, accuracy: %.2f%%' % (meter_loss.value()[0], classerr.value()[0]))
train_loss_logger.log(state['epoch'], meter_loss.value()[0])
train_err_logger.log(state['epoch'], classacc.value()[0])
history['train_loss'].append(meter_loss.value()[0])
history['train_acc'].append(classacc.value()[0])
# do validation at the end of each epoch
reset_meters()
model.train(False)
engine.test(h, val_itr)
print('Val loss: %.4f, accuracy: %.2f%%' %
(meter_loss.value()[0], classacc.value()[0]))
if lr_scheduler:
if isinstance(lr_scheduler,
torch.optim.lr_scheduler.ReduceLROnPlateau):
lr_scheduler.step(classacc.value()[0], epoch=(epoch + 1))
else:
lr_scheduler.step()
test_loss_logger.log(state['epoch'], meter_loss.value()[0])
test_err_logger.log(state['epoch'], classacc.value()[0])
confusion_logger.log(confusion_meter.value())
history['val_loss'].append(meter_loss.value()[0])
history['val_acc'].append(classacc.value()[0])
engine = Engine()
engine.hooks['on_forward'] = on_forward
engine.hooks['on_start_epoch'] = on_start_epoch
engine.hooks['on_end_epoch'] = on_end_epoch
engine.train(h, train_itr, epoch, opt)
# test
test_itr = data.get_test_loader(batch_size=64)
model.train(False)
engine.test(h, test_itr)
print('Test loss: %.4f, accuracy: %.2f%%' %
(meter_loss.value()[0], classacc.value()[0]))
return history
def main():
model, params, stats = models.__dict__[opt.model](N=opt.N, J=opt.scat)
iter_test = get_iterator(False, opt)
scat = Scattering(M=opt.N, N=opt.N, J=opt.scat, pre_pad=False).cuda()
epoch = 0
if opt.resume != '':
resumeFile = opt.resume
if not resumeFile.endswith('pt7'):
resumeFile = torch.load(opt.resume + '/latest.pt7')['latest_file']
state_dict = torch.load(resumeFile)
model.load_state_dict(state_dict['state_dict'])
print('model was restored from epoch:', epoch)
print('\nParameters:')
print(
pd.DataFrame([(key, v.size(), torch.typename(v.data))
for key, v in params.items()]))
print('\nAdditional buffers:')
print(
pd.DataFrame([(key, v.size(), torch.typename(v))
for key, v in stats.items()]))
n_parameters = sum(
[p.numel() for p in list(params.values()) + list(stats.values())])
print('\nTotal number of parameters: %f' % n_parameters)
meter_loss = meter.AverageValueMeter()
classacc = meter.ClassErrorMeter(topk=[1, 5], accuracy=False)
timer_data = meter.TimeMeter('s')
timer_sample = meter.TimeMeter('s')
timer_train = meter.TimeMeter('s')
timer_test = meter.TimeMeter('s')
def h(sample):
inputs = sample[0].cuda()
if opt.scat > 0:
inputs = scat(inputs)
inputs = Variable(inputs)
targets = Variable(sample[1].cuda().long())
if sample[2]:
model.train()
else:
model.eval()
# y = model.forward(inputs)
y = torch.nn.parallel.data_parallel(model, inputs,
np.arange(opt.ngpu).tolist())
return F.cross_entropy(y, targets), y
def on_sample(state):
global data_time
data_time = timer_data.value()
timer_sample.reset()
state['sample'].append(state['train'])
def on_forward(state):
prev_sum5 = classacc.sum[5]
prev_sum1 = classacc.sum[1]
classacc.add(state['output'].data,
torch.LongTensor(state['sample'][1]))
meter_loss.add(state['loss'].data[0])
next_sum5 = classacc.sum[5]
next_sum1 = classacc.sum[1]
n = state['output'].data.size(0)
curr_top5 = 100.0 * (next_sum5 - prev_sum5) / n
curr_top1 = 100.0 * (next_sum1 - prev_sum1) / n
sample_time = timer_sample.value()
timer_data.reset()
if (state['train']):
txt = 'Train:'
else:
txt = 'Test'
print(
'%s [%i,%i/%i] ; loss: %.3f (%.3f) ; err5: %.2f (%.2f) ; err1: %.2f (%.2f) ; data %.3f ; time %.3f'
% (txt, state['epoch'], state['t'] % len(state['iterator']),
len(state['iterator']), state['loss'].data[0],
meter_loss.value()[0], curr_top5, classacc.value(5), curr_top1,
classacc.value(1), data_time, sample_time))
def on_start(state):
state['epoch'] = epoch
def on_start_epoch(state):
classacc.reset()
meter_loss.reset()
timer_train.reset()
epoch = state['epoch'] + 1
def on_end_epoch(state):
train_loss = meter_loss.value()
train_acc = classacc.value()
train_time = timer_train.value()
meter_loss.reset()
classacc.reset()
timer_test.reset()
engine.test(h, iter_test)
engine = Engine()
engine.hooks['on_sample'] = on_sample
engine.hooks['on_forward'] = on_forward
engine.hooks['on_start_epoch'] = on_start_epoch
engine.hooks['on_end_epoch'] = on_end_epoch
engine.hooks['on_start'] = on_start
engine.test(h, iter_test)
print(classacc.value())
#writer.add_image("val/ground_truth", make_grid(ground_truth, nrow=int(BATCH_SIZE ** 0.5),
# normalize=True, range=(0, 1)).numpy(), state["epoch"])
#writer.add_image("val/reconstructions",make_grid(reconstruction, nrow=int(BATCH_SIZE ** 0.5), normalize=True, range=(0, 1)).numpy(),state["epoch"])
# def on_start(state):
# state['epoch'] = 327
#
# engine.hooks['on_start'] = on_start
# if args.test:
# reset_meters()
# engine.test(test_processor, get_iterator("test"))
# writer.add_scalar('test/loss', meter_loss.value()[0], 0)
# writer.add_scalar('test/accuracy', meter_accuracy.value()[0], 0)
# print(meter_accuracy.value()[0])
#
# else:
engine.hooks['on_sample'] = on_sample
engine.hooks['on_forward'] = on_forward
engine.hooks['on_start_epoch'] = on_start_epoch
engine.hooks['on_end_epoch'] = on_end_epoch
iterator = get_iterator("train")
num_val_iterations = int(VAL_PROP*len(iterator.dataset) / args.batch_size)
if args.test:
engine.test(processor, get_iterator("test"))
writer.add_scalar('test/loss', meter_loss.value()[0], 0)
writer.add_scalar('test/accuracy', meter_accuracy.value()[0], 0)
print('Testing Loss: %.4f (Accuracy: %.2f%%)' % (meter_loss.value()[0], meter_accuracy.value()[0]))
else:
engine.train(processor, iterator, maxepoch=NUM_EPOCHS, optimizer=optimizer)
