def __init__(self, params):
self.learning_rate = params.learning_rate
self.batch_size = params.batch_size
self.feature_size = params.feature_size
self.num_epochs = params.num_epochs
self.loss_type = params.loss_type
self.sess = tf.Session()
self.network = AutoencoderNetwork()
self.losses = LossFunctions()
def __init__(self,
Y,
nnodes,
actFunction='Sigmoid',
lossFcn='CrossEntropy'):
super(OutputLayer, self).__init__(nnodes, actFunction)
self.Y = Y
self.lossFcn = LossFunctions.Factory(lossFcn)
self.L = None
def processPatchIdxOverlap(self, currVectorField, indexArray, lastVectorField, idxs, samplingRateIdx, spacing, sampler):
for patchIdx, idx in enumerate(idxs):
print('register patch %i out of %i patches.' % (patchIdx, len(idxs)))
optimizer = optim.Adam(self.net.parameters(),amsgrad=True)
self.netOptim.setOptimizer(optimizer)
imgDataToWork, labelDataToWork = sampler.getSubSample(idx, self.userOpts.normImgPatches)
imgDataToWork = imgDataToWork.to(self.userOpts.device)
if labelDataToWork is not None:
labelDataToWork = labelDataToWork.to(self.userOpts.device)
currDefFieldIdx, offset = self.getSubCurrDefFieldIdx(currVectorField, idx)
currVectorFieldGPU = currVectorField[:, :, currDefFieldIdx[0]:currDefFieldIdx[0]+currDefFieldIdx[3], currDefFieldIdx[1]:currDefFieldIdx[1]+currDefFieldIdx[4], currDefFieldIdx[2]:currDefFieldIdx[2]+currDefFieldIdx[5]].to(device=self.userOpts.device)
idxGPU = indexArray[currDefFieldIdx[0]:currDefFieldIdx[0]+currDefFieldIdx[3], currDefFieldIdx[1]:currDefFieldIdx[1]+currDefFieldIdx[4], currDefFieldIdx[2]:currDefFieldIdx[2]+currDefFieldIdx[5]].to(device=self.userOpts.device)
idxGPU[idxGPU < 1] = 1
currVectorFieldGPU = currVectorFieldGPU / idxGPU[None,None,...]
lastVectorFieldGPU = lastVectorField[:, :, currDefFieldIdx[0]:currDefFieldIdx[0]+currDefFieldIdx[3], currDefFieldIdx[1]:currDefFieldIdx[1]+currDefFieldIdx[4], currDefFieldIdx[2]:currDefFieldIdx[2]+currDefFieldIdx[5]].to(device=self.userOpts.device)
patchIteration=0
lossCounter = 0
runningLoss = torch.ones(10, device=self.userOpts.device)
runningCC = torch.ones(10, device=self.userOpts.device)
runningDSC = torch.ones(10, device=self.userOpts.device)
runningSmmoth = torch.ones(10, device=self.userOpts.device)
runningCycle = torch.ones(10, device=self.userOpts.device)
lossCalculator = lf.LossFunctions(imgDataToWork, spacing)
while True:
[loss, crossCorr, diceLoss, smoothnessDF, cycleLoss] = self.netOptim.optimizeNet(imgDataToWork, lossCalculator, labelDataToWork, lastVectorFieldGPU, currVectorFieldGPU, offset, samplingRateIdx, False)
if False:
self.printParameterInfo()
detachLoss = loss.detach()
runningLoss[lossCounter] = detachLoss
runningCC[lossCounter] = crossCorr.detach()
runningDSC[lossCounter] = diceLoss.detach()
runningSmmoth[lossCounter] = smoothnessDF.detach()
runningCycle[lossCounter] = cycleLoss.detach()
if lossCounter == 9:
meanLoss = runningLoss.mean()
self.logFile.write(str(float(meanLoss)) + ';' + str(patchIdx) + '\n')
self.logFile.flush()
lossCounter = 0
if (self.iterationValidation(detachLoss, meanLoss, patchIteration, self.userOpts.numberOfEpochs[samplingRateIdx], 0, self.userOpts.lossTollerance)):
break
else:
lossCounter+=1
patchIteration+=1
currVectorField[:, :, idx[0]+self.patchShift:idx[0]+imgDataToWork.shape[2]-self.patchShift,
idx[1]+self.patchShift:idx[1]+imgDataToWork.shape[3]-self.patchShift,
idx[2]+self.patchShift:idx[2]+imgDataToWork.shape[4]-self.patchShift] += currVectorFieldGPU[:,:,offset[0]+self.patchShift:offset[0]+imgDataToWork.shape[2]-self.patchShift,offset[1]+self.patchShift:offset[1]+imgDataToWork.shape[3]-self.patchShift,offset[2]+self.patchShift:offset[2]+imgDataToWork.shape[4]-self.patchShift].to("cpu")
indexArray[idx[0]+self.patchShift:idx[0]+imgDataToWork.shape[2]-self.patchShift,
idx[1]+self.patchShift:idx[1]+imgDataToWork.shape[3]-self.patchShift,
idx[2]+self.patchShift:idx[2]+imgDataToWork.shape[4]-self.patchShift] += 1
def testAlmostEqual(self):
func = SingleVarFunctions.Func1 #Parametric Model
#Input Data
xData = [-2, -1, 0, 1, 2]
yData = [func(x, [2, 3]) for x in xData]
#Initialize model parameters
params = [2, 3]
self.assertAlmostEqual(LossFunctions.SSE(params, func, xData, yData),
0.0)
def main():
np.random.seed(0)
height = 25
width = 25
#Create the D matrix
D_w = toeplitz(np.hstack([1, np.zeros(width - 2)]),
np.hstack([1, -1, np.zeros(width - 2)]))
D_h = toeplitz(np.hstack([1, np.zeros(height - 2)]),
np.hstack([1, -1, np.zeros(height - 2)]))
D2 = np.kron(D_w, np.eye(height))
D3 = np.kron(np.eye(width), D_h)
D = np.r_[D2, D3]
#copy kernel from matlab to compare directly
kernel = np.array([[0.0318, 0.0375, 0.0397, 0.0375, 0.0318],
[0.0375, 0.0443, 0.0469, 0.0443, 0.0375],
[0.0397, 0.0469, 0.0495, 0.0469, 0.0397],
[0.0375, 0.0443, 0.0469, 0.0443, 0.0375],
[0.0318, 0.0375, 0.0397, 0.0375, 0.0318]])
weights = np.zeros([height, width])
weights[4, 4] = 1
weights[height - 5, width - 5] = 1
weights = convolve2d(weights, kernel, mode='same')
weights = convolve2d(weights, kernel, mode='same')
weights[
weights != 0] = weights[weights != 0] / np.mean(np.mean(weights)) - 1
(Xtrain, Ytrain) = genCorr(np.reshape(weights, height * width), 250)
(Xval, Yval) = genCorr(np.reshape(weights, height * width), 100)
(Xtest, Ytest) = genCorr(np.reshape(weights, height * width), 250)
CS = [1, 10, 100, 1000]
KChoices = [5, 25, 45, 65, 85]
Lamb2 = [0, 0.1, 0.5, 0.8, 1]
BestAccuracy = 0
w0 = np.zeros(Xtrain.shape[1])
#Search for best validation parameters
for C in CS:
for k in KChoices:
for lam2 in Lamb2:
KTVS = LF.KtvSVM(D,
huber=0.00001,
lambda1=1.0 / C,
lambda2=lam2,
k=k)
(w, primal) = MiniBatchStochSubGradientDescent(
Xtrain,
Ytrain,
KTVS,
w0,
alpha0=np.power(10.0, 3),
N=25,
eta=2,
tol=np.power(10.0, -6),
compareEach=100,
epochs=10000)
currAccuracy = float(
np.sum(np.sign(np.dot(Xval, w)) == Yval)) / len(Yval)
if (currAccuracy > BestAccuracy):
wbest = w
BestAccuracy = currAccuracy
print 'Found better validation set solution of ', str(
BestAccuracy *
100), '% at k:', str(k), ' and lambda: ', str(
1.0 / C), ' and lambda2: ', str(lam2)
TestAccuracy = float(
np.sum(np.sign(np.dot(Xtest, wbest)) == Ytest)) / len(Ytest)
print 'Best accuracy: ', str(100 * TestAccuracy), '%'
def main():
"""
Goal: process images by file lists, evaluating the datasize with different model size
Version: 5.0
"""
print('PyTorch Version: ', torch.__version__)
print('Torchvision Version: ', torchvision.__version__)
now = datetime.datetime.now()
random.seed(1)
torch.manual_seed(1)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
args = arg_process()
runFileName = sys.argv[0].split('.')[0]
# need to modify according to the enviroment
version = args.dataversion
gpuid = args.gpuid
model_name = args.modelname
num_epochs = args.epochs
lr = args.learningrate
batch_size = args.batchsize
model_version = args.modelversion
feature_map = args.featuremap
loss_function = args.lossfunction
pool_size = args.poolsize
classes = 3
# logPath = os.path.join('result', model_name+'_log.txt')
logPath = os.path.join('result', runFileName + '_log_' + 'v{}'.format(args.dataversion) + '.txt')
# logPath = os.path.join('result', runFileName+'_log_'+'v{}'.format(version)+'.txt')
# resultPath = os.path.join('result', 'result_'+'v{}'.format(version)+'.pt')
data_transforms = transforms.Compose([
transforms.ToTensor()
])
# move to GPU
device = torch.device(gpuid if torch.cuda.is_available() else 'cpu')
# obtian the subject information in LOSO
verFolder = 'v_{}'.format(version)
filePath = os.path.join('data', 'MEGC2019', verFolder, 'video442subName.txt')
subjects = []
with open(filePath, 'r') as f:
for textline in f:
texts = textline.strip('\n')
subjects.append(texts)
# predicted and label vectors
preds_db = {}
preds_db['casme2'] = torch.tensor([])
preds_db['smic'] = torch.tensor([])
preds_db['samm'] = torch.tensor([])
preds_db['all'] = torch.tensor([])
labels_db = {}
labels_db['casme2'] = torch.tensor([])
labels_db['smic'] = torch.tensor([])
labels_db['samm'] = torch.tensor([])
labels_db['all'] = torch.tensor([])
# open the log file and begin to record
log_f = open(logPath,'a')
log_f.write('{}\n'.format(now))
log_f.write('-' * 80 + '\n')
log_f.write('-' * 80 + '\n')
log_f.write('Results:\n')
time_s = time.time()
for subject in subjects:
print('Subject Name: {}'.format(subject))
print('---------------------------')
# random.seed(1)
# setup a dataloader for training
imgDir = os.path.join('data', 'MEGC2019', verFolder, '{}_train.txt'.format(subject))
image_db_train = MEGC2019(imgList=imgDir,transform=data_transforms)
dataloader_train = torch.utils.data.DataLoader(image_db_train, batch_size=batch_size, shuffle=True, num_workers=1)
# Initialize the model
print('\tCreating deep model....')
if model_name == 'rcn_a':
model_ft = MeNets.RCN_A(num_input=3, featuremaps=feature_map, num_classes=classes, num_layers=1, pool_size=pool_size, model_version=model_version)
elif model_name == 'rcn_s':
model_ft = MeNets.RCN_S(num_input=3, featuremaps=feature_map, num_classes=classes, num_layers=1, pool_size=pool_size)
elif model_name == 'rcn_w':
model_ft = MeNets.RCN_W(num_input=3, featuremaps=feature_map, num_classes=classes, num_layers=1, pool_size=pool_size)
elif model_name == 'rcn_p':
model_ft = MeNets.RCN_P(num_input=3, featuremaps=feature_map, num_classes=classes, num_layers=1, pool_size=pool_size)
elif model_name == 'rcn_c':
model_ft = MeNets.RCN_C(num_input=3, featuremaps=feature_map, num_classes=classes, num_layers=1, pool_size=pool_size)
elif model_name == 'rcn_f':
model_ft = MeNets.RCN_F(num_input=3, featuremaps=feature_map, num_classes=classes, num_layers=1, pool_size=pool_size)
params_to_update = model_ft.parameters()
optimizer_ft = optim.SGD(params_to_update, lr=lr, momentum=0.9)
# optimizer_ft = optim.Adam(params_to_update, lr=lr)
if loss_function == 'crossentropy':
criterion = nn.CrossEntropyLoss()
elif loss_function == 'focal':
criterion = LossFunctions.FocalLoss(class_num=classes,device=device)
elif loss_function == 'balanced':
criterion = LossFunctions.BalancedLoss(class_num=classes, device=device)
elif loss_function == 'cosine':
criterion = LossFunctions.CosineLoss()
model_ft = model_ft.to(device) # from cpu to gpu
# Train and evaluate
model_ft = train_model(model_ft, dataloader_train, criterion, optimizer_ft, device, num_epochs=num_epochs)
# torch.save(model_ft, os.path.join('data', 'model_s{}.pth').format(subject))
# Test model
imgDir = os.path.join('data', 'MEGC2019', verFolder, '{}_test.txt'.format(subject))
image_db_test = MEGC2019(imgList=imgDir,transform=data_transforms)
dataloaders_test = torch.utils.data.DataLoader(image_db_test, batch_size=batch_size, shuffle=False,
num_workers=1)
preds, labels = test_model(model_ft, dataloaders_test, device)
acc = torch.sum(preds == labels).double()/len(preds)
print('\tSubject {} has the accuracy:{:.4f}\n'.format(subject,acc))
print('---------------------------\n')
log_f.write('\tSubject {} has the accuracy:{:.4f}\n'.format(subject,acc))
# saving the subject results
preds_db['all'] = torch.cat((preds_db['all'], preds), 0)
labels_db['all'] = torch.cat((labels_db['all'], labels), 0)
if subject.find('sub')!= -1:
preds_db['casme2'] = torch.cat((preds_db['casme2'], preds), 0)
labels_db['casme2'] = torch.cat((labels_db['casme2'], labels), 0)
else:
if subject.find('s')!= -1:
preds_db['smic'] = torch.cat((preds_db['smic'], preds), 0)
labels_db['smic'] = torch.cat((labels_db['smic'], labels), 0)
else:
preds_db['samm'] = torch.cat((preds_db['samm'], preds), 0)
labels_db['samm'] = torch.cat((labels_db['samm'], labels), 0)
time_e = time.time()
hours, rem = divmod(time_e-time_s,3600)
miniutes, seconds = divmod(rem,60)
# evaluate all data
eval_acc = metrics.accuracy()
eval_f1 = metrics.f1score()
acc_w, acc_uw = eval_acc.eval(preds_db['all'], labels_db['all'])
f1_w, f1_uw = eval_f1.eval(preds_db['all'], labels_db['all'])
print('\nThe dataset has the UAR and UF1:{:.4f} and {:.4f}'.format(acc_uw, f1_uw))
log_f.write('\nOverall:\n\tthe UAR and UF1 of all data are {:.4f} and {:.4f}\n'.format(acc_uw, f1_uw))
# casme2
if preds_db['casme2'].nelement() != 0:
acc_w, acc_uw = eval_acc.eval(preds_db['casme2'], labels_db['casme2'])
f1_w, f1_uw = eval_f1.eval(preds_db['casme2'], labels_db['casme2'])
print('\nThe casme2 dataset has the UAR and UF1:{:.4f} and {:.4f}'.format(acc_uw, f1_uw))
log_f.write('\tthe UAR and UF1 of casme2 are {:.4f} and {:.4f}\n'.format(acc_uw, f1_uw))
# smic
if preds_db['smic'].nelement() != 0:
acc_w, acc_uw = eval_acc.eval(preds_db['smic'], labels_db['smic'])
f1_w, f1_uw = eval_f1.eval(preds_db['smic'], labels_db['smic'])
print('\nThe smic dataset has the UAR and UF1:{:.4f} and {:.4f}'.format(acc_uw, f1_uw))
log_f.write('\tthe UAR and UF1 of smic are {:.4f} and {:.4f}\n'.format(acc_uw, f1_uw))
# samm
if preds_db['samm'].nelement() != 0:
acc_w, acc_uw = eval_acc.eval(preds_db['samm'], labels_db['samm'])
f1_w, f1_uw = eval_f1.eval(preds_db['samm'], labels_db['samm'])
print('\nThe samm dataset has the UAR and UF1:{:.4f} and {:.4f}'.format(acc_uw, f1_uw))
log_f.write('\tthe UAR and UF1 of samm are {:.4f} and {:.4f}\n'.format(acc_uw, f1_uw))
# writing parameters into log file
print('\tNetname:{}, Dataversion:{}\n\tLearning rate:{}, Epochs:{}, Batchsize:{}.'.format(model_name,version,lr,num_epochs,batch_size))
print('\tElapsed time: {:0>2}:{:0>2}:{:05.2f}'.format(int(hours),int(miniutes),seconds))
log_f.write('\nOverall:\n\tthe weighted and unweighted accuracy of all data are {:.4f} and {:.4f}\n'.format(acc_w,acc_uw))
log_f.write('\nSetting:\tNetname:{}, Dataversion:{}\n\tLearning rate:{}, Epochs:{}, Batchsize:{}.\n'.format(model_name,
version,
lr,
num_epochs,
batch_size))
# # save subject's results
# torch.save({
# 'predicts':preds_db,
# 'labels':labels_db,
# 'weight_acc':acc_w,
# 'unweight_acc':acc_uw
# },resultPath)
log_f.write('-' * 80 + '\n')
log_f.write('-' * 80 + '\n')
log_f.write('\n')
log_f.close()
def run(self,
net,
samplingRate,
samplingRateIdx,
dataloader,
validationDataLoader,
resultModels=[]):
self.net = net
self.net.train()
optimizer = optim.Adam(self.net.parameters(), amsgrad=True)
netOptim = NetOptimizer.NetOptimizer(self.net, None, optimizer,
self.userOpts)
receptiveFieldOffset = Utils.getReceptiveFieldOffset(
self.userOpts.netDepth)
padVals = (receptiveFieldOffset, receptiveFieldOffset,
receptiveFieldOffset, receptiveFieldOffset,
receptiveFieldOffset, receptiveFieldOffset)
samplerShift = (0, 0, 0)
for epoch in range(self.userOpts.numberOfEpochs[samplingRateIdx]):
for i, data in enumerate(dataloader, 0):
netOptim.initSmoother(data['image'].shape[1] * 3)
lastField = None
if len(resultModels) > 0:
currentState = copy.deepcopy(self.net.state_dict())
with torch.no_grad():
# self.net.eval()
useContext = self.userOpts.useContext
self.userOpts.useContext = False
for previousSampleIdxs in range(samplingRateIdx):
modelToApply = resultModels[previousSampleIdxs]
self.net.load_state_dict(
modelToApply['model_state'])
defField = self.getDeformationField(
data, modelToApply['samplingRate'],
self.userOpts.patchSize[previousSampleIdxs],
self.userOpts.
useMedianForSampling[previousSampleIdxs],
samplerShift)
upSampleRate = 1.0 / modelToApply['samplingRate']
defField = defField * upSampleRate
defField = sampleImg(defField, upSampleRate)
if lastField is None:
lastField = defField
else:
lastField = Utils.combineDeformationFields(
defField, lastField)
self.userOpts.useContext = useContext
self.net.load_state_dict(currentState)
self.net.train()
sampledImgData, sampledMaskData, sampledLabelData, _ = Utils.sampleImgData(
data, samplingRate)
if lastField is None:
currDefField = torch.zeros(
(data['image'].shape[0], data['image'].shape[1] * 3,
data['image'].shape[2], data['image'].shape[3],
data['image'].shape[4]),
device="cpu",
requires_grad=False)
else:
currDefField = lastField
currDefField = currDefField * samplingRate
currDefField = Utils.sampleImg(currDefField, samplingRate)
sampler = Sampler(sampledMaskData, sampledImgData,
sampledLabelData,
self.userOpts.patchSize[samplingRateIdx])
if self.userOpts.randomSampling[samplingRateIdx]:
numberofSamplesPerRun = int(
sampledImgData.numel() /
(self.userOpts.patchSize[samplingRateIdx] *
self.userOpts.patchSize[samplingRateIdx] *
self.userOpts.patchSize[samplingRateIdx]))
if numberofSamplesPerRun < 1:
numberofSamplesPerRun = 1
idxs = sampler.getIndicesForRandomization()
idxs = sampler.getRandomSubSamplesIdxs(
numberofSamplesPerRun, idxs)
else:
idxs = sampler.getIndicesForOneShotSampling(
samplerShift,
self.userOpts.useMedianForSampling[samplingRateIdx])
lastDeffield = currDefField.clone()
for _, idx in enumerate(idxs):
imgDataToWork = sampler.getSubSampleImg(
idx, self.userOpts.normImgPatches)
imgDataToWork = imgDataToWork.to(self.userOpts.device)
lossCalculator = lf.LossFunctions(
imgDataToWork, dataloader.dataset.getSpacingXZFlip(i))
currDefFieldIdx, offset = self.getSubCurrDefFieldIdx(
currDefField, idx)
currDefFieldGPU = currDefField[:, :, currDefFieldIdx[0]:
currDefFieldIdx[0] +
currDefFieldIdx[3],
currDefFieldIdx[1]:
currDefFieldIdx[1] +
currDefFieldIdx[4],
currDefFieldIdx[2]:
currDefFieldIdx[2] +
currDefFieldIdx[5]].to(
device=self.userOpts.
device)
lastDeffieldGPU = lastDeffield[:, :, currDefFieldIdx[0]:
currDefFieldIdx[0] +
currDefFieldIdx[3],
currDefFieldIdx[1]:
currDefFieldIdx[1] +
currDefFieldIdx[4],
currDefFieldIdx[2]:
currDefFieldIdx[2] +
currDefFieldIdx[5]].to(
device=self.userOpts.
device)
[loss, crossCorr, diceLoss, smoothnessDF, cycleLoss
] = netOptim.optimizeNet(imgDataToWork, lossCalculator,
None, lastDeffieldGPU,
currDefFieldGPU, offset,
samplingRateIdx, False)
#TODO: log also other loss values
detachLoss = loss.detach()
self.logFile.write(
str(epoch) + ';' + str(float(detachLoss)) + '\n')
self.logFile.flush()
currDefField[:, :, idx[0]:idx[0] + imgDataToWork.shape[2],
idx[1]:idx[1] + imgDataToWork.shape[3],
idx[2]:idx[2] + imgDataToWork.
shape[4]] = currDefFieldGPU[:, :, offset[
0]:offset[0] + imgDataToWork.shape[2],
offset[1]:
offset[1] +
imgDataToWork.
shape[3],
offset[2]:
offset[2] +
imgDataToWork.
shape[4]].to(
"cpu")
del imgDataToWork, sampledImgData, sampledMaskData, sampledLabelData
##
## Validation
##
if epoch % self.userOpts.validationIntervall == 0:
torch.save(
{
'epoch': epoch,
'model_state_dict': self.net.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss,
'samplingRate': samplingRate
}, self.userOpts.outputPath + os.path.sep +
'registrationModel' + str(samplingRateIdx) + str(epoch) +
'.pt')
validationLosses, landmarkDistances = self.validateModel(
validationDataLoader, netOptim, samplingRate,
samplingRateIdx, padVals, samplerShift, resultModels)
if len(landmarkDistances) > 0:
self.validationLogFile.write(
str(epoch) + ';' + str(np.mean(validationLosses)) +
';' + str(np.std(validationLosses)) + ';' +
str(np.mean(landmarkDistances)) + ';' + '\n')
else:
self.validationLogFile.write(
str(epoch) + ';' + str(np.mean(validationLosses)) +
';' + str(np.std(validationLosses)) + ';' + '0.0' +
'\n')
self.validationLogFile.flush()
del validationLosses
self.net.train()
return self.net
def optimizeNet(self,
imgDataToWork,
labelToWork,
lastDefField=None,
currDefFields=None,
idx=None,
itIdx=0,
printLoss=False):
# zero the parameter gradients
self.optimizer.zero_grad()
defFields = self.net(imgDataToWork)
addedField = lastDefField[:, :, idx[0]:idx[0] + defFields.shape[2],
idx[1]:idx[1] + defFields.shape[3],
idx[2]:idx[2] +
defFields.shape[4]] + defFields
currDefFields[:, :, idx[0]:idx[0] + defFields.shape[2],
idx[1]:idx[1] + defFields.shape[3], idx[2]:idx[2] +
defFields.shape[4]] = addedField.detach()
cropStart0 = int((imgDataToWork.shape[2] - defFields.shape[2]) / 2)
cropStart1 = int((imgDataToWork.shape[3] - defFields.shape[3]) / 2)
cropStart2 = int((imgDataToWork.shape[4] - defFields.shape[4]) / 2)
imgDataToWork = imgDataToWork[:, :, cropStart0:cropStart0 +
defFields.shape[2],
cropStart1:cropStart1 +
defFields.shape[3],
cropStart2:cropStart2 +
defFields.shape[4]]
lossCalculator = lf.LossFunctions(imgDataToWork, addedField,
currDefFields, self.spacing)
boundaryLoss = 0.0
smoothnessLoss = 0.0
smoothNessWeight = self.userOpts.smoothW[itIdx]
crossCorrWeight = self.userOpts.ccW
cyclicWeight = self.userOpts.cycleW
crossCorrWeight, smoothNessWeight, cyclicWeight = self.normalizeWeights(
crossCorrWeight, smoothNessWeight, cyclicWeight)
if self.userOpts.boundarySmoothnessW[itIdx] > 0.0:
boundaryLoss = lossCalculator.smoothBoundary(
idx, self.userOpts.device)
if imgDataToWork.shape[1] > 2:
smoothnessLoss = lossCalculator.smoothnessVecFieldT(
self.userOpts.device)
else:
smoothnessLoss = lossCalculator.smoothnessVecField(
self.userOpts.device)
smoothnessDF = smoothnessLoss + boundaryLoss * self.userOpts.boundarySmoothnessW[
itIdx]
imgDataDef = Utils.getImgDataDef(
imgDataToWork.shape, self.userOpts.device
) #torch.empty(imgDataToWork.shape, device=self.userOpts.device, requires_grad=False)#
for chanIdx in range(-1, imgDataToWork.shape[1] - 1):
imgToDef = imgDataToWork[:, None, chanIdx, ]
chanRange = range(chanIdx * 3, chanIdx * 3 + 3)
deformedTmp = Utils.deformImage(imgToDef, addedField[:,
chanRange, ],
self.userOpts.device, False)
imgDataDef[:, chanIdx + 1, ] = deformedTmp[:, 0, ]
cycleImgData = Utils.getCycleImgData(
defFields.shape, self.userOpts.device
) #torch.empty(defFields.shape, device=self.userOpts.device)
zeroIndices = Utils.getZeroIdxField(defFields.shape,
self.userOpts.device)
outOfBoundsTensor = torch.zeros(zeroIndices[0].shape,
dtype=torch.uint8,
device=self.userOpts.device)
if self.userOpts.cycleW > 0.0:
for chanIdx in range(imgDataToWork.shape[1] - 1, -1, -1):
chanRange = range(chanIdx * 3, chanIdx * 3 + 3)
self.cycleLossCalculationMethod(zeroIndices, cycleImgData,
addedField, chanRange, None,
idx, outOfBoundsTensor)
crossCorr = lossCalculator.normCrossCorr(imgDataDef,
self.userOpts.device)
cycleLoss = lossCalculator.cycleLoss(cycleImgData, outOfBoundsTensor,
self.userOpts.device)
# loss = crossCorrWeight * crossCorr + self.userOpts.cycleW * cycleLoss
loss = crossCorrWeight * crossCorr + smoothNessWeight * smoothnessDF + self.userOpts.cycleW * cycleLoss
if printLoss:
print('%.5f; %.5f; %5f; %5f; %.5f' %
(loss, crossCorr, smoothnessLoss, boundaryLoss, cycleLoss))
# print('%.5f; %5f; %5f; %.5f' % (crossCorr, smoothnessLoss, boundaryLoss, cycleLoss))
# print('cc: %.5f smmothness: %.5f cycleLoss: %.5f' % (crossCorr, smoothnessDF, cycleLoss))
# print('weighted cc: %.5f smmothness: %.5f cycleLoss: %.5f' % (crossCorrWeight * crossCorr, smoothNessWeight * smoothnessDF, self.userOpts.cycleW * cycleLoss))
torch.cuda.empty_cache()
# print(torch.cuda.memory_allocated() / 1048576.0)
loss.backward()
self.optimizer.step()
return loss
nTLS = 7.0
freq = 1e3
###################################
# Staging for Loss Calculations #
###################################
omega = 2 * np.pi * freq
density = nTLS / vol
tMatrix = np.linspace(minT, maxT, num=nT)
if len(sys.argv) > 1:
suff = "_" + sys.argv[1]
else:
suff = ""
tlsdata = LF.ImportData("Data/tls.tot" + suff)
tlsdata, nPts = LF.CleanData(tlsdata,
constG=constG,
constY=constY,
constT=constT)
original = LF.calculateLossFunction(tlsdata,
density,
omega,
tMatrix,
BoltzmannCorrection=BoltzmannCorrection)
shuffleIndices = [0, 3, 4, 5, 6, 7, 10]
tlskde = BS.tlsKDE()
tlskde.fit(tlsdata, shuffleIndices, bandwidth=0.186379686016)
class Autoencoder:
def __init__(self, params):
self.learning_rate = params.learning_rate
self.batch_size = params.batch_size
self.feature_size = params.feature_size
self.num_epochs = params.num_epochs
self.loss_type = params.loss_type
self.sess = tf.Session()
self.network = AutoencoderNetwork()
self.losses = LossFunctions()
def create_dataset(self, is_training, data, batch_size):
"""Create dataset given input data
Args:
is_training: (bool) whether to use the train or test pipeline.
At training, we shuffle the data and have multiple epochs
data: (array) corresponding array containing the input data
batch_size: (int) size of each batch to consider from the data
Returns:
output: (dict) contains what will be the input of the tensorflow graph
"""
num_samples = data.shape[0]
# create dataset object
dataset = tf.data.Dataset.from_tensor_slices(data)
if is_training:
dataset = dataset.shuffle(num_samples).repeat()
dataset = dataset.batch(batch_size)
dataset = dataset.prefetch(1)
# create reinitializable iterator from dataset
iterator = dataset.make_initializable_iterator()
data = iterator.get_next()
iterator_init = iterator.initializer
return {'data': data, 'iterator_init': iterator_init}
def create_model(self, is_training, inputs, output_size):
"""Model function defining the graph operations.
Args:
is_training: (bool) whether we are training or not
inputs: (dict) contains the inputs of the graph (features, labels...)
this can be `tf.placeholder` or outputs of `tf.data`
output_size: (int) size of the output layer
Returns:
model_spec: (dict) contains the graph operations or nodes needed for training / evaluation
"""
data = inputs['data']
with tf.variable_scope('model', reuse=not is_training):
features = self.network.encoder(data, self.feature_size,
is_training)
output = self.network.decoder(features, output_size, is_training)
if self.loss_type == 'bce':
loss = self.losses.binary_cross_entropy(data, output)
else:
loss = self.losses.mean_square_error(data, output)
if is_training:
optimizer = tf.train.AdamOptimizer(self.learning_rate)
train_op = optimizer.minimize(loss)
model_spec = inputs
model_spec['loss'] = loss
model_spec['variable_init_op'] = tf.global_variables_initializer()
model_spec['features'] = features
model_spec['output'] = output
if is_training:
model_spec['train_op'] = train_op
return model_spec
def evaluate_dataset(self, is_training, num_batches, model_spec):
"""Evaluate the model
Args:
is_training: (bool) whether we are training or not
num_batches: (integer) number of batches to train/test
model_spec: (dict) contains the graph operations or nodes needed for evaluation
Returns:
avg_loss: (float) average loss for the given number of batches (training phase)
"""
avg_loss = 0.0
self.sess.run(model_spec['iterator_init'])
if is_training:
for j in range(num_batches):
_, loss = self.sess.run(
[model_spec['train_op'], model_spec['loss']])
avg_loss = avg_loss + loss
else:
for j in range(num_batches):
loss = self.sess.run(model_spec['loss'])
avg_loss = avg_loss + loss
avg_loss /= num_batches
return avg_loss
def train(self, train_data, val_data):
"""Train the model
Args:
train_data: (array) corresponding array containing the training data
val_data: (array) corresponding array containing the validation data
Returns:
output: (dict) contains the history of train/val loss
"""
train_history_loss = []
val_history_loss = []
# create training and validation dataset
train_dataset = self.create_dataset(True, train_data, self.batch_size)
val_dataset = self.create_dataset(False, val_data, self.batch_size)
# create train and validation models
output_size = train_data.shape[1]
train_model = self.create_model(True, train_dataset, output_size)
val_model = self.create_model(False, val_dataset, output_size)
# set number of batches
TRAIN_BATCHES = train_data.shape[0] // self.batch_size
VALIDATION_BATCHES = val_data.shape[0] // self.batch_size
# initialize global variables
self.sess.run(train_model['variable_init_op'])
# training and validation phases
print('Training phase...')
for i in range(self.num_epochs):
train_loss = self.evaluate_dataset(True, TRAIN_BATCHES,
train_model)
val_loss = self.evaluate_dataset(False, VALIDATION_BATCHES,
val_model)
print("(Epoch %d / %d) Training Loss: %.5lf; Validation Loss: %.5lf" % \
(i + 1, self.num_epochs, train_loss, val_loss))
train_history_loss.append(train_loss)
val_history_loss.append(val_loss)
return {
'train_history_loss': train_history_loss,
'val_history_loss': val_history_loss
}
def test(self, test_data):
"""Test the model
Args:
test_data: (array) corresponding array containing the testing data
"""
# create dataset
test_dataset = self.create_dataset(False, test_data, self.batch_size)
# reuse model used in training phase
output_size = test_data.shape[1]
test_model = self.create_model(False, test_dataset, output_size)
# evaluate model
TEST_BATCHES = test_data.shape[0] // self.batch_size
print("Testing phase...")
test_loss = self.evaluate_dataset(False, TEST_BATCHES, test_model)
print("Testing Loss: %lf\n" % test_loss)
def latent_features(self, data, batch_size=-1):
"""Obtain latent features learnt by the model
Args:
data: (array) corresponding array containing the data
batch_size: (int) size of each batch to consider from the data
Returns:
features: (array) array containing the features from the data
"""
if batch_size == -1:
batch_size = data.shape[0]
# create dataset
dataset = self.create_dataset(False, data, batch_size)
# we will use only the encoder network
with tf.variable_scope('model', reuse=True):
encoder = self.network.encoder(dataset['data'], self.feature_size)
# obtain the features from the input data
self.sess.run(dataset['iterator_init'])
num_batches = data.shape[0] // batch_size
features = np.zeros((data.shape[0], self.feature_size))
for j in range(num_batches):
features[j * batch_size:j * batch_size +
batch_size] = self.sess.run(encoder)
return features
def reconstruct_data(self, data, batch_size=-1):
"""Reconstruct Data
Args:
data: (array) corresponding array containing the data
batch_size: (int) size of each batch to consider from the data
Returns:
reconstructed: (array) array containing the reconstructed data
"""
if batch_size == -1:
batch_size = data.shape[0]
# create dataset
dataset = self.create_dataset(False, data, batch_size)
# reuse model used in training
model_spec = self.create_model(False, dataset, data.shape[1])
# obtain the reconstructed data
self.sess.run(model_spec['iterator_init'])
num_batches = data.shape[0] // batch_size
reconstructed = np.zeros(data.shape)
pos = 0
for j in range(num_batches):
reconstructed[pos:pos + batch_size] = self.sess.run(
model_spec['output'])
pos += batch_size
return reconstructed
def plot_latent_space(self, data, labels, save=False):
"""Plot the latent space learnt by the model
Args:
data: (array) corresponding array containing the data
labels: (array) corresponding array containing the labels
save: (bool) whether to save the latent space plot
Returns:
fig: (figure) plot of the latent space
"""
# obtain the latent features
features = self.latent_features(data)
# plot only the first 2 dimensions
fig = plt.figure(figsize=(8, 6))
plt.scatter(features[:, 0],
features[:, 1],
c=labels,
marker='o',
edgecolor='none',
cmap=plt.cm.get_cmap('jet', 10),
s=10)
plt.colorbar()
if (save):
fig.savefig('latent_space.png')
return fig
vol = 1.0
nTLS = 1.0
#freq = 1e3
#vol = vol * 1e-30
###################################
# Staging for Loss Calculations #
###################################
if len(sys.argv) > 1:
suff = "_" + sys.argv[1]
else:
suff = ""
tlsdata = np.loadtxt("pp-tls.tot" + suff)
tlsdata = LF.RemoveOutliers(tlsdata)
print tlsdata.shape
#tlsdata = LF.RemoveDuplicates(tlsdata)
nPts = tlsdata.shape[0]
fMatrix = np.logspace(np.log10(minF), np.log10(maxF), num=nF)
fMatrix = fMatrix[:] * 2 * np.pi
density = nTLS / vol
print np.mean(tlsdata[:, 7])
tlsdata[:, 5] = 1.0 / tlsdata[:, 5] * 0.0101804979 * 1e-12
tlsdata[:, 6] = 1.0 / tlsdata[:, 6] * 0.0101804979 * 1e-12
tlsdata[:, 7] = dipole
tlsdata[:, 8] = dipole
originalLoss = DL.calculateSusceptibility(
Y = (X >= 0)
return X, Y
#nsamples = 10
#X, Y = load_planar_dataset()
X, Y = load_sign_class_dataset(1000)
DNN.append(NNLayers.InputLayer(X))
DNN.append(NNLayers.FeedFwdLayer(nnodes=2, actfcn='Tanh'))
#DNN.append( NNLayers.FeedFwdLayer( nnodes=2, actfcn='ReLU' ) )
DNN.append(NNLayers.FeedFwdLayer(nnodes=1, actfcn='Sigmoid'))
nlayers = len(DNN)
CrossEntropyFcn = LossFunctions.Factory('CrossEntropy')
#np.random.seed(2)
# initialization
for i in range(1, nlayers):
DNN[i].SetNNodesPrev(DNN[i - 1].GetNNodes())
DNN[i].Initialize()
# main loop
for j in range(nepochs):
# dummy init A
A = None
# forward prop
for i in range(nlayers):