def define_loss(self, dataset):
if self.output_type == "regression":
self.criterion = nnloss.MSELoss()
else:
if self.weighted_loss:
num_samples = len(dataset)
# distribution of classes in the dataset
label_to_count = {n: 0 for n in range(self.number_classes)}
for idx in list(range(num_samples)):
label = dataset.load_datapoint(idx)[-1]
label_to_count[label] += 1
label_percentage = {
l: label_to_count[l] / num_samples for l in label_to_count.keys()
}
median_perc = median(list(label_percentage.values()))
class_weights = [
median_perc / label_percentage[c] if label_percentage[c] != 0 else 0
for c in range(self.number_classes)
]
weights = torch.FloatTensor(class_weights).to(self.device)
else:
weights = None
if self.classification_loss_type == 'cross-entropy':
self.criterion = nnloss.CrossEntropyLoss(weight=weights)
else:
if weights is not None:
raise NotImplementedErrore
self.criterion = log_f1_micro_loss
def get_criterion(name, **kwargs):
"""
Returns criterion by name.
:param name: criterion name (str)
:param kwargs: kwargs passed to criterion constructor.
:return: corresponding criterion from torch.nn module.
"""
return {
'bce': loss.BCELoss(),
'bcewithlogits': loss.BCEWithLogitsLoss(),
'cosineembedding': loss.CosineEmbeddingLoss(),
'crossentropy': loss.CrossEntropyLoss(),
'hingeembedding': loss.HingeEmbeddingLoss(),
'kldiv': loss.KLDivLoss(),
'l1': loss.L1Loss(),
'mse': loss.MSELoss(),
'marginranking': loss.MarginRankingLoss(),
'multilabelmargin': loss.MultiLabelMarginLoss(),
'multilabelsoftmargin': loss.MultiLabelSoftMarginLoss(),
'multimargin': loss.MultiMarginLoss(),
'nll': loss.NLLLoss(),
'nll2d': loss.NLLLoss2d(),
'poissonnll': loss.PoissonNLLLoss(),
'smoothl1': loss.SmoothL1Loss(),
'softmargin': loss.SoftMarginLoss(),
'tripletmargin': loss.TripletMarginLoss()
}[name.strip().lower()]
def __init__(self, args):
input_size = (args.inputSize, args.inputSize)
self.run_name = args.runName
self.input_size = input_size
self.lr = args.learningRate
self.criterion = nnloss.MSELoss()
self.transforms = {}
self.model = SiameseNetwork()
if torch.cuda.device_count() > 1:
logger.info('Using {} GPUs'.format(torch.cuda.device_count()))
self.model = nn.DataParallel(self.model)
for s in ('train', 'validation', 'test'):
self.transforms[s] = get_pretrained_iv3_transforms(s)
logger.debug('Num params: {}'.format(
len([_ for _ in self.model.parameters()])))
self.optimizer = Adam(self.model.parameters(), lr=self.lr)
self.lr_scheduler = ReduceLROnPlateau(self.optimizer,
factor=0.1,
patience=10,
min_lr=1e-5,
verbose=True)
def loss_fn(loss_fn: str = "mse"):
"""
:param loss_fn: implement loss function for training
:return: loss function module(class)
"""
if loss_fn == "mse":
return loss.MSELoss()
elif loss_fn == "L1":
return loss.L1Loss()
elif loss_fn == "neg_pearson":
return NegPearsonLoss()
elif loss_fn == "multi_margin":
return loss.MultiMarginLoss()
elif loss_fn == "bce":
return loss.BCELoss()
elif loss_fn == "huber":
return loss.HuberLoss()
elif loss_fn == "cosine_embedding":
return loss.CosineEmbeddingLoss()
elif loss_fn == "cross_entropy":
return loss.CrossEntropyLoss()
elif loss_fn == "ctc":
return loss.CTCLoss()
elif loss_fn == "bce_with_logits":
return loss.BCEWithLogitsLoss()
elif loss_fn == "gaussian_nll":
return loss.GaussianNLLLoss()
elif loss_fn == "hinge_embedding":
return loss.HingeEmbeddingLoss()
elif loss_fn == "KLDiv":
return loss.KLDivLoss()
elif loss_fn == "margin_ranking":
return loss.MarginRankingLoss()
elif loss_fn == "multi_label_margin":
return loss.MultiLabelMarginLoss()
elif loss_fn == "multi_label_soft_margin":
return loss.MultiLabelSoftMarginLoss()
elif loss_fn == "nll":
return loss.NLLLoss()
elif loss_fn == "nll2d":
return loss.NLLLoss2d()
elif loss_fn == "pairwise":
return loss.PairwiseDistance()
elif loss_fn == "poisson_nll":
return loss.PoissonNLLLoss()
elif loss_fn == "smooth_l1":
return loss.SmoothL1Loss()
elif loss_fn == "soft_margin":
return loss.SoftMarginLoss()
elif loss_fn == "triplet_margin":
return loss.TripletMarginLoss()
elif loss_fn == "triplet_margin_distance":
return loss.TripletMarginWithDistanceLoss()
else:
log_warning("use implemented loss functions")
raise NotImplementedError(
"implement a custom function(%s) in loss.py" % loss_fn)
def __init__(self, scale: float = 1.0, size_average=None, reduce=None, reduction='mean'):
"""
reconstruction loss.
:return L2(x, x')
"""
super(ReconstructionLoss, self).__init__(size_average, reduce, reduction)
# sample-wise & element-wise mean
self._mse_loss = L.MSELoss(reduction=reduction)
self._scale = scale
def __init__(self, args):
input_size = (args.input_size, args.input_size)
self.run_name = args.run_name
self.input_size = input_size
self.lr = args.learning_rate
self.output_type = args.output_type
network_architecture_class = InceptionSiameseNetwork
network_architecture_transforms = get_pretrained_iv3_transforms
if args.model_type == "light":
network_architecture_class = LightSiameseNetwork
network_architecture_transforms = get_light_siamese_transforms
# define the loss measure
if self.output_type == "regression":
self.criterion = nnloss.MSELoss()
self.model = network_architecture_class()
elif self.output_type == "classification":
self.criterion = nnloss.CrossEntropyLoss()
self.n_classes = 4 # replace by args
self.model = network_architecture_class(
output_type=self.output_type, n_classes=self.n_classes
)
self.transforms = {}
if torch.cuda.device_count() > 1:
logger.info("Using {} GPUs".format(torch.cuda.device_count()))
self.model = torch.nn.DataParallel(self.model)
for s in ("train", "validation", "test", "inference"):
self.transforms[s] = network_architecture_transforms(s)
logger.debug("Num params: {}".format(len([_ for _ in self.model.parameters()])))
self.optimizer = Adam(self.model.parameters(), lr=self.lr)
# reduces the learning rate when loss plateaus, i.e. doesn't improve
self.lr_scheduler = ReduceLROnPlateau(
self.optimizer, factor=0.1, patience=10, min_lr=1e-5, verbose=True
)
# creates tracking file for tensorboard
self.writer = SummaryWriter(args.checkpoint_path)
self.device = args.device
self.model_path = args.model_path
self.prediction_path = args.prediction_path
self.model_type = args.model_type
self.is_statistical_model = args.statistical_model
self.is_neural_model = args.neural_model
self.log_step = args.log_step
def transfer_similarity_loss(reconstructions, source_images, weight):
"""
Computes a loss encouraging similarity between source and transferred.
"""
if weight == 0:
return 0
# todo : check pairewise mse
reconstruction_similarity_criterion = loss.MSELoss()
reconstruction_similarity_loss = reconstruction_similarity_criterion(
reconstructions, source_images)
return reconstruction_similarity_loss
def test_network():
wine_attributes = ["alch","malic","ash","alcash","mag","phen","flav","nfphens","proant","color","hue","dil","prol"]
columns = ["class","alch","malic","ash","alcash","mag","phen","flav","nfphens","proant","color","hue","dil","prol"]
"""
0) class
1) Alcohol
2) Malic acid
3) Ash
4) Alcalinity of ash
5) Magnesium
6) Total phenols
7) Flavanoids
8) Nonflavanoid phenols
9) Proanthocyanins
10)Color intensity
11)Hue
12)OD280/OD315 of diluted wines
13)Proline
"""
from Induction.IntGrad.integratedGradients import random_baseline_integrated_gradients, integrated_gradients
exit()
df = read_data_pd("../../Data/wine.csv",columns = columns)
df.columns = columns # Add columns to dataframe.
#Cov.columns = ["Sequence", "Start", "End", "Coverage"]
dataman = Datamanager.Datamanager(dataframe_train=df,classes=3,dataset="wine")
model = network.NN_3_25("wine",in_dim=13,out_dim=3)
print(model.input_type)
optimizer = optim.Adam(model.parameters(), lr=0.01,betas=(0.9,0.999),eps=1e-6)
#loss = network.RootMeanSquareLoss()
#loss = t_loss.L1Loss()
loss = t_loss.MSELoss()
network.train(model, dataman,validation=True, optimizer = optimizer,loss_function = loss, batch=20, iterations=50)
def get_criterion(name, **kwargs):
"""
Returns criterion instance given the name.
Args:
name (str): criterion name
kwargs (dict): keyword arguments passed to criterion constructor
Returns:
Corresponding criterion from torch.nn module
Available criteria:
BCE, BCEWithLogits, CosineEmbedding, CrossEntropy, HingeEmbedding, KLDiv,
L1, MSE, MarginRanking, MultilabelMargin, MultilabelSoftmargin, MultiMargin,
NLL, PoissoNLL, SmoothL1, SoftMargin, TripletMargin
"""
return {
'bce': loss.BCELoss(**kwargs),
'bcewithlogits': loss.BCEWithLogitsLoss(**kwargs),
'cosineembedding': loss.CosineEmbeddingLoss(**kwargs),
'crossentropy': loss.CrossEntropyLoss(**kwargs),
'hingeembedding': loss.HingeEmbeddingLoss(**kwargs),
'kldiv': loss.KLDivLoss(**kwargs),
'l1': loss.L1Loss(**kwargs),
'mse': loss.MSELoss(**kwargs),
'marginranking': loss.MarginRankingLoss(**kwargs),
'multilabelmargin': loss.MultiLabelMarginLoss(**kwargs),
'multilabelsoftmargin': loss.MultiLabelSoftMarginLoss(**kwargs),
'multimargin': loss.MultiMarginLoss(**kwargs),
'nll': loss.NLLLoss(**kwargs),
'poissonnll': loss.PoissonNLLLoss(**kwargs),
'smoothl1': loss.SmoothL1Loss(**kwargs),
'softmargin': loss.SoftMarginLoss(**kwargs),
'tripletmargin': loss.TripletMarginLoss(**kwargs)
}[name.strip().lower()]
def __init__(self, args):
input_size = (args.input_size, args.input_size)
self.run_name = args.run_name
self.input_size = input_size
self.lr = args.learning_rate
self.output_type = args.output_type
self.test_epoch = args.test_epoch
self.freeze = args.freeze
self.no_augment = args.no_augment
self.augment_type = args.augment_type
self.weighted_loss = args.weighted_loss
self.save_all = args.save_all
self.probability = args.probability
self.classification_loss_type = args.classification_loss_type
self.disable_cuda = args.disable_cuda
network_architecture_class = InceptionSiameseNetwork
network_architecture_transforms = get_pretrained_iv3_transforms
if args.model_type == "shared":
network_architecture_class = InceptionSiameseShared
network_architecture_transforms = get_pretrained_iv3_transforms
elif args.model_type == "light":
network_architecture_class = LightSiameseNetwork
network_architecture_transforms = get_light_siamese_transforms
elif args.model_type == "after":
network_architecture_class = InceptionCNNNetwork
network_architecture_transforms = get_pretrained_iv3_transforms
elif args.model_type == "vgg":
network_architecture_class = VggSiameseNetwork
network_architecture_transforms = get_pretrained_vgg_transforms
elif args.model_type == "attentive":
network_architecture_class = AttentiveNetwork
network_architecture_transforms = get_pretrained_attentive_transforms
# define the loss measure
if self.output_type == "regression":
self.criterion = nnloss.MSELoss()
self.model = network_architecture_class()
elif self.output_type == "classification":
self.number_classes = args.number_classes
self.model = network_architecture_class(
output_type=self.output_type,
n_classes=self.number_classes,
freeze=self.freeze,
)
if self.classification_loss_type == 'cross-entropy':
self.criterion = nnloss.CrossEntropyLoss()
else:
self.criterion = log_f1_micro_loss
self.transforms = {}
if torch.cuda.device_count() > 1:
logger.info("Using {} GPUs".format(torch.cuda.device_count()))
self.model = torch.nn.DataParallel(self.model)
for s in ("train", "validation", "test", "inference"):
self.transforms[s] = network_architecture_transforms(
s, self.no_augment, self.augment_type
)
logger.debug("Num params: {}".format(len([_ for _ in self.model.parameters()])))
self.optimizer = Adam(self.model.parameters(), lr=self.lr)
# reduces the learning rate when loss plateaus, i.e. doesn't improve
self.lr_scheduler = ReduceLROnPlateau(
self.optimizer, factor=0.1, patience=10, min_lr=1e-5, verbose=True
)
if not self.disable_cuda:
self.scaler = torch.cuda.amp.GradScaler()
else:
self.scaler = None
# creates tracking file for tensorboard
self.writer = SummaryWriter(args.checkpoint_path)
self.device = args.device
self.model_path = args.model_path
self.trained_model_path = args.trained_model_path
self.prediction_path = args.prediction_path
self.model_type = args.model_type
self.is_statistical_model = args.statistical_model
self.is_neural_model = args.neural_model
self.log_step = args.log_step
def train():
# INITIALIZATIONS
tr_loss = list()
tr_ssim_loss = list()
ssimCriterion = SSIM()
mseCriterion = Loss.MSELoss()
lossCrit = mseCriterion
vld_mse_loss = list()
vld_ssim_loss = list()
vld_mse_loss_in = list()
vld_ssim_loss_in = list()
vi = 0
i = 0
# LOAD LATEST (or SPECIFIC) MODEL
s_epoch = load_model(-1)
for epoch in range(s_epoch, params.epochs):
print('epoch {}/{}...'.format(epoch + 1, params.epochs))
adjust_learning_rate(epoch)
###########################################
# Training
l = 0
itt = 0
TAG = 'Training'
if not params.Validation_Only:
for local_batch, local_labels, sliceID, orig_size, usr in training_DG:
X = Variable(torch.FloatTensor(local_batch.float())).to(params.device)
y = Variable(torch.FloatTensor(local_labels.float())).to(params.device)
input_mag = normalize_batch_torch(get_magnitude(X))
LOST_mag = normalize_batch_torch(y[:, :, :, :, 0])
if params.complex_net:
X = normalize_complex_batch_by_magnitude_only(X, False)
y = normalize_complex_batch_by_magnitude_only(y, True)
else:
X = get_magnitude(X)
y = y[:, :, :, :, 0]
X = normalize_batch_torch(X)
y = normalize_batch_torch(y)
y_pred = net(X)
if params.complex_net:
loss = lossCrit(magnitude(y_pred).squeeze(1), y[:, :, :, :, 0].squeeze(1))
simloss = ssimCriterion(magnitude(y_pred), y[:, :, :, :, 0])
else:
loss = lossCrit(y_pred, y)
simloss = ssimCriterion(y_pred, y)
tr_loss.append(loss.cpu().data.numpy())
tr_ssim_loss.append(simloss.cpu().data.numpy())
l += loss.data[0]
optimizer.zero_grad()
loss.backward()
i += 1
optimizer.step()
inloss = mseCriterion(input_mag, LOST_mag)
print('Epoch: {0} - {1:.3f}%'.format(epoch + 1, 100 * (itt * params.batch_size) / len(
training_DG.dataset.input_IDs))
+ ' \tIter: ' + str(i)
+ '\tLoss: {0:.6f}'.format(loss.data[0])
+ '\tInputLoss: {0:.6f}'.format(inloss.data[0]))
itt += 1
if itt % 100 == 0:
is_best = 0
save_checkpoint({
'epoch': epoch + 1,
'loss': tr_loss,
'arch': 'recoNet_Model1',
'state_dict': net.state_dict(),
'optimizer': optimizer.state_dict(),
}, is_best, filename=params.model_save_dir + 'MODEL_EPOCH{}.pth'.format(epoch + 1))
print('Model Saved!')
avg_loss = params.batch_size * l / len(training_DG.dataset.input_IDs)
print('Total Loss : {0:.6f} \t Avg. Loss {1:.6f}'.format(l, avg_loss))
else:
load_model(epoch + 1)
#####################################
# Validation
vitt = 0
vld_mse = 0
vld_ssim = 0
vld_psnr = 0
vld_mse_in = 0
vld_ssim_in = 0
vld_psnr_in = 0
TAG = 'Validation'
with torch.no_grad():
for local_batch, local_labels, sliceID, orig_size, usr in validation_DG:
X = Variable(torch.FloatTensor(local_batch.float())).to(params.device)
y = Variable(torch.FloatTensor(local_labels.float())).to(params.device)
input_mag = normalize_batch_torch(get_magnitude(X))
LOST_mag = normalize_batch_torch(y[:, :, :, :, 0])
if params.complex_net:
X = normalize_complex_batch_by_magnitude_only(X, False)
y = normalize_complex_batch_by_magnitude_only(y, True)
else:
X = get_magnitude(X)
y = y[:, :, :, :, 0]
X = normalize_batch_torch(X)
y = normalize_batch_torch(y)
y_pred = net(X)
if params.complex_net:
mseloss = mseCriterion(magnitude(y_pred).squeeze(1), y[:, :, :, :, 0].squeeze(1))
ssimloss = ssimCriterion(magnitude(y_pred), y[:, :, :, :, 0])
else:
mseloss = mseCriterion(y_pred, y)
ssimloss = ssimCriterion(y_pred, y)
mseloss_in = mseCriterion(input_mag, LOST_mag)
ssimloss_in = ssimCriterion(input_mag, LOST_mag)
vld_mse_loss.append(mseloss.cpu().data.numpy())
vld_ssim_loss.append(ssimloss.cpu().data.numpy())
vld_mse_loss_in.append(mseloss_in.cpu().data.numpy())
vld_ssim_loss_in.append(ssimloss_in.cpu().data.numpy())
vld_mse += mseloss.data[0]
vld_ssim += ssimloss.data[0]
vld_mse_in += mseloss_in.data[0]
vld_ssim_in += ssimloss_in.data[0]
vi += 1
vitt += 1
if params.complex_net:
inloss = mseCriterion(magnitude(X).squeeze(1), y[:, :, :, :, 0].squeeze(1))
else:
inloss = mseCriterion(X, y)
print('Epoch: {0} - {1:.3f}%'.format(epoch + 1, 100 * (vitt * params.batch_size) / len(
validation_DG.dataset.input_IDs))
+ ' \tIter: ' + str(vi)
+ '\tSME: {0:.6f}'.format(mseloss.data[0])
+ '\tSSIM: {0:.6f}'.format(ssimloss.data[0])
+ '\tInputLoss: {0:.6f}'.format(inloss.data[0]))
avg_factor = params.batch_size / len(validation_DG.dataset.input_IDs)
print('Avg. MSE : {0:.6f}'.format(vld_mse * avg_factor)
+ '\tAvg. SSIM : {0:.6f}'.format(vld_ssim * avg_factor)
+ '\tAvg. PSNR : {0:.6f}'.format(vld_psnr * avg_factor)
+ 'Avg. Input_MSE : {0:.6f}'.format(vld_mse_in * avg_factor)
+ '\tAvg. Input_SSIM : {0:.6f}'.format(vld_ssim_in * avg_factor)
+ '\tAvg. Input_PSNR : {0:.6f}'.format(vld_psnr_in * avg_factor)
)
writer.close()
pytest.param(
"nn.modules.loss",
"MarginRankingLoss",
{},
[],
{},
loss.MarginRankingLoss(),
id="MarginRankingLossConf",
),
pytest.param(
"nn.modules.loss",
"MSELoss",
{},
[],
{},
loss.MSELoss(),
id="MSELossConf",
),
pytest.param(
"nn.modules.loss",
"MultiLabelMarginLoss",
{},
[],
{},
loss.MultiLabelMarginLoss(),
id="MultiLabelMarginLossConf",
),
pytest.param(
"nn.modules.loss",
"MultiLabelSoftMarginLoss",
{},
def train(net):
###########################################
#
# INITIALIZATIONS
#
############################################
optimizer = optim.Adam(net.parameters(), lr=params.args.lr)
# optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9)
LOSS = list()
SSIMLOSS = list()
ssimCriterion = SSIM()
mseCriterion = Loss.MSELoss()
kscCriterion = KspaceConsistency()
tvCriterion = TotalVariations()
lossCrit = mseCriterion
vld_MSE_LOSS = list()
vld_SSIM_LOSS = list()
vld_MSE_LOSS_in = list()
vld_SSIM_LOSS_in = list()
vi = 0
i = 0
bt = 0
###########################################
#
# LOAD LATEST (or SPECIFIC) MODEL
#
############################################
models = os.listdir(params.model_save_dir);
s_epoch = 0
def load_model(epoch):
print('loading model at epoch ' + str(epoch))
net.load_state_dict(torch.load(params.model_save_dir + models[0][0:11] + str(epoch) + '.pth')['state_dict'])
optimizer.load_state_dict(
torch.load(params.model_save_dir + models[0][0:11] + str(epoch) + '.pth')['optimizer'])
LOSS = torch.load(params.model_save_dir + models[0][0:11] + str(epoch) + '.pth')['loss']
print(len(models))
if len(models) > 0:
if s_epoch == -1:
s_epoch = max([int(epo[11:-4]) for epo in models[:]])
print("Loading model ...")
load_model(s_epoch)
s_epoch = s_epoch - 1
print("Model loaded !")
for epoch in range(s_epoch, params.epochs):
print('epoch {}/{}...'.format(epoch + 1, params.epochs))
adjust_learning_rate(optimizer, epoch)
###########################################
#
# Training
#
############################################
l = 0
itt = 0
TAG = 'Training'
MAX = list()
if not params.Validation_Only:
for local_batch, local_labels, sliceID, orig_size, usr in training_DG:
X = Variable(torch.FloatTensor(local_batch.float())).to(params.device)
y = Variable(torch.FloatTensor(local_labels.float())).to(params.device)
input_mag = normalizeBatch_torch(get_magnitude(X))
LOST_mag = normalizeBatch_torch(y[:, :, :, :, 0])
if params.complex_net:
X = normalizeComplexBatch_byMagnitudeOnly(X, False)
y = normalizeComplexBatch_byMagnitudeOnly(y, True)
else:
X = get_magnitude(X)
y = y[:, :, :, :, 0]
X = normalizeBatch_torch(X)
y = normalizeBatch_torch(y)
y_pred = net(X)
if params.complex_net:
loss = lossCrit(magnitude(y_pred).squeeze(1), y[:, :, :, :, 0].squeeze(1))
else:
loss = lossCrit(y_pred, y)
simloss = ssimCriterion(y_pred, y)
if params.complex_net:
loss = lossCrit(magnitude(y_pred).squeeze(1), y[:, :, :, :, 0].squeeze(1))
simloss = ssimCriterion(magnitude(y_pred), y[:, :, :, :, 0])
else:
loss = lossCrit(y_pred, y)
simloss = ssimCriterion(y_pred, y)
LOSS.append(loss.cpu().data.numpy())
SSIMLOSS.append(simloss.cpu().data.numpy())
l += loss.data[0]
optimizer.zero_grad()
loss.backward()
i += 1
optimizer.step()
inloss = mseCriterion(input_mag, LOST_mag)
print('Epoch: {0} - {1:.3f}%'.format(epoch + 1, 100 * (itt * params.batch_size) / len(
training_DG.dataset.input_IDs))
+ ' \tIter: ' + str(i)
+ '\tLoss: {0:.6f}'.format(loss.data[0])
+ '\tInputLoss: {0:.6f}'.format(inloss.data[0]))
itt += 1
if itt % 100 == 0:
is_best = 0
save_checkpoint({
'epoch': epoch + 1,
'loss': LOSS,
'arch': 'recoNet_Model1',
'state_dict': net.state_dict(),
'optimizer': optimizer.state_dict(),
}, is_best, filename=params.model_save_dir + 'MODEL_EPOCH{}.pth'.format(epoch + 1))
print('Model Saved!')
avg_loss = params.batch_size * l / len(training_DG.dataset.input_IDs)
print('Total Loss : {0:.6f} \t Avg. Loss {1:.6f}'.format(l, avg_loss))
else:
load_model(epoch + 1)
#####################################
#
# Validation
#
#####################################
vl = 0
vitt = 0
vld_mse = 0
vld_ssim = 0
vld_psnr = 0
vld_mse_in = 0
vld_ssim_in = 0
vld_psnr_in = 0
TAG = 'Validation'
with torch.no_grad():
for local_batch, local_labels, sliceID, orig_size, usr in validation_DG:
X = Variable(torch.FloatTensor(local_batch.float())).to(params.device)
y = Variable(torch.FloatTensor(local_labels.float())).to(params.device)
input_mag = normalizeBatch_torch(get_magnitude(X))
LOST_mag = normalizeBatch_torch(y[:, :, :, :, 0])
if params.complex_net:
X = normalizeComplexBatch_byMagnitudeOnly(X, False)
y = normalizeComplexBatch_byMagnitudeOnly(y, True)
else:
X = get_magnitude(X)
y = y[:, :, :, :, 0]
X = normalizeBatch_torch(X)
y = normalizeBatch_torch(y)
y_pred = net(X)
if params.complex_net:
mseloss = mseCriterion(magnitude(y_pred).squeeze(1), y[:, :, :, :, 0].squeeze(1))
ssimloss = ssimCriterion(magnitude(y_pred), y[:, :, :, :, 0])
else:
mseloss = mseCriterion(y_pred, y)
ssimloss = ssimCriterion(y_pred, y)
mseloss_in = mseCriterion(input_mag, LOST_mag)
ssimloss_in = ssimCriterion(input_mag, LOST_mag)
vld_MSE_LOSS.append(mseloss.cpu().data.numpy())
vld_SSIM_LOSS.append(ssimloss.cpu().data.numpy())
vld_MSE_LOSS_in.append(mseloss_in.cpu().data.numpy())
vld_SSIM_LOSS_in.append(ssimloss_in.cpu().data.numpy())
vld_mse += mseloss.data[0]
vld_ssim += ssimloss.data[0]
vld_mse_in += mseloss_in.data[0]
vld_ssim_in += ssimloss_in.data[0]
vi += 1
vitt += 1
if params.complex_net:
inloss = mseCriterion(magnitude(X).squeeze(1), y[:, :, :, :, 0].squeeze(1))
else:
inloss = mseCriterion(X, y)
print('Epoch: {0} - {1:.3f}%'.format(epoch + 1, 100 * (vitt * params.batch_size) / len(
validation_DG.dataset.input_IDs))
+ ' \tIter: ' + str(vi)
+ '\tSME: {0:.6f}'.format(mseloss.data[0])
+ '\tSSIM: {0:.6f}'.format(ssimloss.data[0])
+ '\tInputLoss: {0:.6f}'.format(inloss.data[0]))
avg_factor = params.batch_size / len(validation_DG.dataset.input_IDs)
print('Avg. MSE : {0:.6f}'.format(vld_mse * avg_factor)
+ '\tAvg. SSIM : {0:.6f}'.format(vld_ssim * avg_factor)
+ '\tAvg. PSNR : {0:.6f}'.format(vld_psnr * avg_factor)
+ 'Avg. Input_MSE : {0:.6f}'.format(vld_mse_in * avg_factor)
+ '\tAvg. Input_SSIM : {0:.6f}'.format(vld_ssim_in * avg_factor)
+ '\tAvg. Input_PSNR : {0:.6f}'.format(vld_psnr_in * avg_factor)
)
writer.close()
