def load_paths(opt, base, pa, split):
# ignoring the file with no label.
print('\t-> processing {} data'.format(split))
X = []
Y = []
Z = []
# Z = [] (252, 316)
bar = progbar(len(pa), width=opt.barwidth)
for idx, patients in enumerate(pa):
# file contains GT.nii // patient_xx.nii.gz
gt_path = os.path.join(base, patients, 'GT.nii.gz')
img_path = os.path.join(base, patients, patients + '.nii.gz')
gt = nib.load(gt_path).get_data()
for i in range(gt.shape[2]):
if np.sum(gt[:, :, i]) == 0 and split == 'train':
continue
Z.append(((patients, i), gt_path, img_path))
for i in range(gt.shape[0]):
if np.sum(gt[i, :, :]) == 0 and split == 'train':
continue
if i < 162 or i > 413:
continue
X.append(((patients, i), gt_path, img_path))
for i in range(gt.shape[1]):
if np.sum(gt[:, i, :]) == 0 and split == 'train':
continue
if i < 85 or i > 401:
continue
Y.append(((patients, i), gt_path, img_path))
bar.update(idx + 1)
return X, Y, Z
def processing(path, split):
folders_all = []
print("=> start collecting {} data....".format(split))
for yr in [2016, 2017]:
image_set_path = os.path.join(path, 'ImageSets', str(yr),
split + '.txt')
with open(image_set_path, 'r') as f:
folders = f.read()
folders = folders.split()
folders_all += folders
instance_all = []
bar = progbar(len(folders_all), width=40)
for idx, video in enumerate(folders_all):
bar.update(idx + 1)
image_path = os.path.join(path, 'JPEGImages', '480p', video)
gt_path = os.path.join(path, 'Annotations', '480p', video)
for frame in os.listdir(gt_path):
if frame.endswith('.png'):
ground_truth = np.array(
Image.open(os.path.join(gt_path, frame)))
instance_num = np.unique(ground_truth).__len__()
if np.all(ground_truth == 0):
continue
for i in range(instance_num):
if i == 0:
continue
gt_path_ = os.path.join(gt_path, frame)
image_path_ = os.path.join(image_path,
frame.replace('png', 'jpg'))
instance_all.append((image_path_, gt_path_, video, frame, i))
return instance_all
def step(epoch):
self.model.train()
bar = progbar(len(self.train_dataset), width=10)
self.lr_schedulr.step(epoch=epoch)
print('\n Training AT epoch = {}'.format(epoch))
print('current learning rate = {}\n'.format(self.lr_schedulr.get_lr()))
avgLoss = 0
for i, (image, afmap) in enumerate(self.train_dataset):
self.optimizer.zero_grad()
image_var = Variable(image).cuda()
afmap_var = Variable(afmap).cuda()
afmap_pred = self.model(image_var)
loss = self.criterion(afmap_pred, afmap_var)
loss.backward()
self.optimizer.step()
avgLoss = (avgLoss*i + loss.item()) / (i+1)
log = 'Epoch: [%d][%d/%d] Err %1.4f\n' % (epoch, i, len(self.train_dataset), avgLoss)
self.logger['train'].write(log)
bar.update(i, [('avgLoss', avgLoss)])
log = '\n * Finished training epoch # %d Loss: %1.4f\n' % (epoch, avgLoss)
self.logger['train'].write(log)
print(log)
return avgLoss
def test(self, valLoader, epoch):
self.model.eval()
avgLoss = 0
visImg = []
self.progbar = progbar(len(valLoader), width=self.opt.barwidth)
for i, (inputData, line, imgids) in enumerate(valLoader):
if self.opt.debug and i > 10:
break
start = time.time()
inputData_var, line_var = Variable(inputData), Variable(line)
if self.opt.GPU:
inputData_var = inputData_var.cuda()
line_var = line_var.cuda()
dataTime = time.time() - start
loss, line_loss, line_result = self.model.forward(
inputData_var, line_var)
runTime = time.time() - start
avgLoss = (avgLoss * i + loss.item()) / (i + 1)
log = 'Epoch: [%d][%d/%d] Time %1.3f Data %1.3f Err %1.4f\n' % (
epoch, i, len(valLoader), runTime, dataTime, loss.item())
self.logger['val'].write(log)
self.progbar.update(i, [('Time', runTime), ('Loss', loss.item())])
if i <= self.opt.visTest:
visImg.append(inputData.cpu())
visImg.append(line_result.cpu().data)
visImg.append(line)
if i == self.opt.visTest:
self.visualize(visImg, epoch, 'test',
valLoader.dataset.postprocess,
valLoader.dataset.postprocessLine)
outDir = os.path.join(self.opt.resume, str(epoch))
if not os.path.exists(outDir):
os.makedirs(outDir)
for j in range(len(imgids)):
np.save(
os.path.join(outDir, imgids[j] + '_line.npy'),
valLoader.dataset.postprocessLine()(
line_result.cpu().data[j].numpy()))
log = '\n * Finished testing epoch # %d Loss: %1.4f\n' % (epoch,
avgLoss)
self.logger['val'].write(log)
print(log)
return avgLoss
def train(self, trainLoader, epoch):
self.model.train()
print("-> Training epoch # {}".format(str(epoch)))
avgLoss = 0
self.progbar = progbar(len(trainLoader), width=self.opt.barwidth)
for i, (inputData, seg, imgids) in enumerate(trainLoader):
if self.opt.debug and i > 10:
break
start = time.time()
inputData_var, seg_var = Variable(inputData), Variable(seg)
self.optimizer.zero_grad()
if self.opt.GPU:
inputData_var = inputData_var.cuda()
seg_var = seg_var.cuda()
dataTime = time.time() - start
output = self.model.forward(inputData_var)
loss = self.criterion(output,
torch.gt(seg_var, 0).type(torch.float32))
loss.backward()
self.optimizer.step()
runTime = time.time() - start
avgLoss = (avgLoss * i + loss.data) / (i + 1)
log = 'Epoch: [%d][%d/%d] Time %1.3f Data %1.3f Err %1.4f\n' % (
epoch, i, len(trainLoader), runTime, dataTime, loss.data)
self.logger['train'].write(log)
self.progbar.update(i, [('Time', runTime), ('Loss', loss.data)])
log = '\n * Finished training epoch # %d Loss: %1.4f\n' % (epoch,
avgLoss)
self.logger['train'].write(log)
print(log)
return avgLoss
def train(self, trainLoader, epoch):
self.model.train()
print('=> Training epoch # ' + str(epoch))
avgLoss = 0
visImg = []
self.progbar = progbar(len(trainLoader), width=self.opt.barwidth)
for i, (inputData, line, imgids) in enumerate(trainLoader):
if self.opt.debug and i > 10:
break
start = time.time()
inputData_var, line_var = Variable(inputData), Variable(line)
self.optimizer.zero_grad()
if self.opt.GPU:
inputData_var = inputData_var.cuda()
line_var = line_var.cuda()
dataTime = time.time() - start
loss, line_loss, line_result = self.model.forward(
inputData_var, line_var)
loss.backward()
self.optimizer.step()
runTime = time.time() - start
avgLoss = (avgLoss * i + loss.item()) / (i + 1)
log = 'Epoch: [%d][%d/%d] Time %1.3f Data %1.3f Err %1.4f\n' % (
epoch, i, len(trainLoader), runTime, dataTime, loss.item())
self.logger['train'].write(log)
self.progbar.update(i, [('Time', runTime), ('Loss', loss.item())])
if i <= self.opt.visTrain:
visImg.append(inputData)
visImg.append(line_result.cpu().data)
visImg.append(line)
#if i == self.opt.visTrain:
# self.visualize(visImg, epoch, 'train', trainLoader.dataset.postprocess, trainLoader.dataset.postprocessLine)
log = '\n * Finished training epoch # %d Loss: %1.4f\n' % (epoch,
avgLoss)
self.logger['train'].write(log)
print(log)
return avgLoss
def test(self, cfg, epoch=-1):
self.model.eval()
self.load_weight_by_epoch(epoch)
# self.model.cuda()
for name, dataset in zip(cfg.DATASETS.TEST, self.test_dataset):
print('Testing on {} dataset'.format(name.upper()))
bar = progbar(target=len(dataset))
start_time = time.time()
for i, (image, lines, shape_info, fname) in enumerate(dataset):
image_var = Variable(image).cuda()
lines_var = Variable(lines).cuda()
shape_info = Variable(shape_info).cuda()
# image_var = self.input_method(image_var)
afmap_pred = self.model(image_var)
lines_pred, xx, yy = lsgenerator(
afmap_pred[0].cpu().data.numpy())
afmap_gt, label = afm(lines_var, shape_info,
image_var.shape[2], image_var.shape[3])
image_raw = cv2.imread(
osp.join(dataset.dataset.data_root, 'images', fname[0]))
# import pdb
# pdb.set_trace()
output_dict = {
'image': image_raw,
'image_resized': image_var[0].cpu().data.numpy(),
'lines_pred_resized': lines_pred,
'lines_gt': lines.numpy(),
'afmap_pred': afmap_pred[0].cpu().data.numpy(),
'afmap_gt': afmap_gt[0].cpu().data.numpy(),
'fname': fname[0],
'output_dir': osp.join(self.resultDir, name),
}
self.output_method(output_dict, cfg)
bar.update(i)
end_time = time.time()
print('Total images: {}'.format(len(dataset)))
print('Total time: {} ellapsed for {}'.format(
end_time - start_time, cfg.TEST.OUTPUT_MODE))
print('Frames per Second: {}'.format(
len(dataset) / (end_time - start_time)))
def train(self, trainLoader, epoch):
self.model.train()
print("=> Training epoch")
avgLoss = RunningAverage()
avgAcces = {}
for metric in self.metrics:
avgAcces[metric] = RunningAverage()
self.progbar = progbar(len(trainLoader), width=self.opt.barwidth)
for i, (input, target) in enumerate(trainLoader):
if self.opt.debug and i > 10: # check debug.
break
start = time.time()
inputV, targetV= Variable(input), Variable(target)
if self.opt.GPU:
inputV, targetV = inputV.cuda(), targetV.cuda()
self.optimizer.zero_grad()
dataTime = time.time() - start
output = self.model(inputV)
loss = self.criterion(output, targetV) * 255 * 255 / 144 / 144
loss.backward()
self.optimizer.step()
# LOG ===
runTime = time.time() - start
avgLoss.update(float(loss))
logAcc = []
a = output.data.cpu().numpy()
b = targetV.data.cpu().numpy()
for metric in self.metrics:
avgAcces[metric].update(self.metrics[metric](a, b))
logAcc.append((metric, float(avgAcces[metric]())))
del a, b
log = updateLog(epoch, i, len(trainLoader), runTime, dataTime, float(loss), avgAcces)
self.logger['train'].write(log)
self.progbar.update(i, [('Time', runTime), ('loss', float(loss)), *logAcc])
# END LOG ===
log = '\n* Finished training epoch # %d Loss: %1.4f ' % (epoch, avgLoss())
for metric in avgAcces:
log += metric + " %1.4f " % avgAcces[metric]()
log += '\n'
self.logger['train'].write(log)
print(log)
return avgLoss()
def load_paths(opt, base, pa, split):
# ignoring the file with no label.
print('\t-> processing {} data'.format(split))
X = []
bar = progbar(len(pa), width=opt.barwidth)
for idx, patients in enumerate(pa):
# file contains GT.nii // patient_xx.nii.gz
gt_path = os.path.join(base, patients, 'GT.nii.gz')
img_path = os.path.join(base, patients, patients + '.nii.gz')
gt = nib.load(gt_path).get_data()
for i in range(gt.shape[2]):
if np.sum(gt[:, :, i]) == 0 and split == 'train':
continue
X.append(((patients, i), gt_path, img_path))
# if i == gt.shape[2] - 1 and (split == 'val' or split == 'test'): # last slice
# X.append(((patients, -1), None, None))
bar.update(idx + 1)
return X
def train(self, trainLoader, epoch):
self.model.train()
print('=> Training epoch # ' + str(epoch))
# define avgLoss to Zero
avgLoss = 0
visImg = []
# program 진행 상태를 보여주는 클래스
self.progbar = progbar(len(trainLoader), width=self.opt.barwidth)
# trainLoader 에서 데이터 추출 -> torch DataLoader 좀 더 공부..
for i, (inputData, line, imgids) in enumerate(trainLoader):
if self.opt.debug and i > 10:
break
start = time.time()
# Tensor 를 Variable Class로 변환 -> 자동으로 변화도를 계산할 수 있음.
inputData_var, line_var = Variable(inputData), Variable(line)
self.optimizer.zero_grad()
if self.opt.GPU:
inputData_var = inputData_var.cuda()
line_var = line_var.cuda()
dataTime = time.time() - start
# foward 진행 input : original img data, line img data
# self.model : stackedHGB
loss, line_loss, line_result = self.model.forward(
inputData_var, line_var)
# backward 진행
loss.backward()
self.optimizer.step()
# run time 계산
runTime = time.time() - start
# warning zone : 수정 필요
avgLoss = (avgLoss * i + loss.data) / (i + 1)
# warning zone : 수정 필요
log = 'Epoch: [%d][%d/%d] Time %1.3f Data %1.3f Err %1.4f\n' % (
epoch, i, len(trainLoader), runTime, dataTime, loss.data)
self.logger['train'].write(log)
# error zone : probar code 수정 필요 -> type Error & moudle Error but learning에는 지장 없음.
self.progbar.update(i, [('Time', runTime), ('Loss', loss.data)])
if i <= self.opt.visTrain:
visImg.append(inputData)
visImg.append(line_result.cpu().data)
visImg.append(line)
#if i == self.opt.visTrain:
# self.visualize(visImg, epoch, 'train', trainLoader.dataset.postprocess, trainLoader.dataset.postprocessLine)
log = '\n * Finished training epoch # %d Loss: %1.4f\n' % (epoch,
avgLoss)
self.logger['train'].write(log)
print(log)
return avgLoss
def test(self, valLoader, epoch):
print(
"*********************************test****************************"
)
self.model.eval()
avgLoss = 0
visImg = []
self.progbar = progbar(len(valLoader), width=self.opt.barwidth)
print("valLoader : ", len(valLoader))
for i, (inputData, line, imgids) in enumerate(valLoader):
if self.opt.debug and i > 10:
break
start = time.time()
with torch.no_grad():
inputData_var, line_var = Variable(
inputData, volatile=True), Variable(line, volatile=True)
#print(inputData_var.shape, ' ', line_var.shape)
if self.opt.GPU:
inputData_var = inputData_var.cuda()
line_var = line_var.cuda()
dataTime = time.time() - start
loss, line_loss, line_result = self.model.forward(
inputData_var, line_var)
#print("x_1 shape[0]", x_1.shape)
# plt.figure(figsize=(8, 8))
# arr_img1 = []
# if i == 1:
# idx = 1
# for j in range(36):
# img = x_1[1][j].cpu().detach().numpy()
# ax = plt.subplot(6, 6, idx)
# ax.set_xticks([])
# ax.set_yticks([])
# plt.imshow(img, cmap='gray')
# idx += 1
# cv2.imshow("img",img)
# cv2.waitKey(300)
# plt.show()
# for _ in range(8):
# for _ in range(8):
# ax = plt.subplot(8, 8, idx)
# ax.set_xticks([])
# ax.set_yticks([])
# plt.imshow(arr_img1[idx], cmap='gray')
# idx += 1
# print("x_1 shape[0]", x_1[0][0].shape)
# print("x_1[0][0] type : ", type(x_1[0][0]))
# img = x_1[0][0].cpu().detach().numpy()
# print(img)
# cv2.imshow("img",img)
# cv2.waitKey(300000)
runTime = time.time() - start
avgLoss = (avgLoss * i + loss.data) / (i + 1)
log = 'Epoch: [%d][%d/%d] Time %1.3f Data %1.3f Err %1.4f\n' % (
epoch, i, len(valLoader), runTime, dataTime, loss.data)
self.logger['val'].write(log)
self.progbar.update(i, [('Time', runTime), ('Loss', loss.data)])
if i <= self.opt.visTest:
visImg.append(inputData.cpu())
visImg.append(line_result.cpu().data)
visImg.append(line)
if i == self.opt.visTest:
self.visualize(visImg, epoch, 'test',
valLoader.dataset.postprocess,
valLoader.dataset.postprocessLine)
# outDir = os.path.join(self.opt.resume, str(epoch))
# if not os.path.exists(outDir):
# os.makedirs(outDir)
# for j in range(len(imgids)):
# np.save(os.path.join(outDir, imgids[j] + '_line.npy'), valLoader.dataset.postprocessLine()(line_result.cpu().data[j].numpy()))
log = '\n * Finished testing epoch # %d Loss: %1.4f\n' % (epoch,
avgLoss)
self.logger['val'].write(log)
print(log)
return avgLoss
def test(self, valLoader, epoch):
print(
"*********************************test****************************"
)
self.model.eval()
avgLoss = 0
visImg = []
self.progbar = progbar(len(valLoader), width=self.opt.barwidth)
print("valLoader : ", len(valLoader))
for i, (inputData, line, imgids) in enumerate(valLoader):
if self.opt.debug and i > 10:
break
start = time.time()
with torch.no_grad():
inputData_var, line_var = Variable(inputData), Variable(line)
#print(inputData_var.shape, ' ', line_var.shape)
if self.opt.GPU:
inputData_var = inputData_var.cuda()
line_var = line_var.cuda()
dataTime = time.time() - start
loss, line_loss, line_result = self.model.forward(
inputData_var, line_var)
#print(line_result)
img_line = line[0][0].numpy()
''' img_origin imshow
img_origin = inputData[0].numpy()
print(line_result.shape)
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
img_origin = np.transpose(img_origin, (1, 2, 0))
img_origin = t.unNormalize(img_origin, mean, std)
'''
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
img_result = line_result[0].cpu().detach().numpy()
print(np.min(img_result), ' ', np.max(img_result))
img_result_plt = line_result[0][0].cpu().detach().numpy()
img_result = np.transpose(img_result, (1, 2, 0))
img_result = t.unNormalize(img_result, mean, std)
print(img_result)
print(np.min(img_result), ' ', np.max(img_result))
img_result = np.clip(img_result, 0, 255)
img_result = np.uint8(img_result)
#print(img_result)
img_result = cv2.resize(img_result,
dsize=(320, 320),
interpolation=cv2.INTER_LANCZOS4)
cv2.imshow("Gray", img_result)
cv2.waitKey(30000)
#print(img_result)
#print(img_result.shape)
#plt.figure(1)
#plt.axis("off")
# cv2.imshow("Gray",img_result)
#plt.imshow(img_result_plt,cmap="gray")
# plt.imshow(cv2.cvtColor(img_origin, cv2.COLOR_BGR2RGB))
# plt.imshow(img)
#plt.show()
#print("x_1 shape[0]", x_1.shape)
# plt.figure(figsize=(8, 8))
# arr_img1 = []
# if i == 1:
# idx = 1
# for j in range(36):
# img = x_1[1][j].cpu().detach().numpy()
# ax = plt.subplot(6, 6, idx)
# ax.set_xticks([])
# ax.set_yticks([])
# plt.imshow(img, cmap='gray')
# idx += 1
# cv2.imshow("img",img)
# cv2.waitKey(300)
# plt.show()
# for _ in range(8):
# for _ in range(8):
# ax = plt.subplot(8, 8, idx)
# ax.set_xticks([])
# ax.set_yticks([])
# plt.imshow(arr_img1[idx], cmap='gray')
# idx += 1
# print("x_1 shape[0]", x_1[0][0].shape)
# print("x_1[0][0] type : ", type(x_1[0][0]))
# img = x_1[0][0].cpu().detach().numpy()
# print(img)
# cv2.imshow("img",img)
# cv2.waitKey(300000)
return 0
def start(self, lenDS):
self.lenDS = lenDS
self.avgLoss = RunningAverageDict(10.0)
self.avgAcces = RunningAverageDict(0.0)
self.progbar = progbar(self.lenDS, width=self.opt.barwidth)
self.log_interval = int(lenDS / self.log_num)
def process(self, dataLoader, epoch, split):
train = split == 'train'
num_iters = int(dataLoader[1] // self.batchSize)
batch_X, batch_Y = tf.placeholder(tf.float32, shape=[None, 144, 144, 3]), \
tf.placeholder(tf.float32, shape=[None, 144, 144, 3])
# /-------------------------^-------------------------\
out = self.model(batch_X)
loss = self.criterion(out, batch_Y)
train_op = self.train_op.minimize(loss)
# init loss and accuracy
avgLoss = RunningAverage()
avgAcces = {}
for metric in self.metrics:
avgAcces[metric] = RunningAverage()
bar = progbar(num_iters, width=self.opt.barwidth)
print("\n=> [{}]ing epoch : {}".format(split, epoch))
# train
if epoch == 1 and train:
self.sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
# begin one epoch
for i in range(num_iters):
if self.opt.debug and i > 2: # check debug.
break
startTime = time.time()
X_numpy, Y_numpy = self.sess.run(dataLoader[0].get_next())
dataTime = time.time() - startTime
logAcc = []
if train:
it = num_iters * (epoch - 1) + i * self.opt.batchSize
lr, _, cost, out_eval = self.sess.run(
[self.lr, train_op, loss, out],
feed_dict={
batch_X: X_numpy,
batch_Y: Y_numpy,
self.ep: it
})
logAcc.append(('LR', lr))
else:
cost, out_eval = self.sess.run([loss, out],
feed_dict={
batch_X: X_numpy,
batch_Y: Y_numpy
})
runningTime = time.time() - startTime
# log record.
avgLoss.update(cost)
for metric in self.metrics:
avgAcces[metric].update(self.metrics[metric](Y_numpy,
out_eval))
logAcc.append((metric, float(avgAcces[metric]())))
bar.update(i, [('Time', runningTime),
('loss', float(cost)), *logAcc])
log = updateLog(epoch, i, num_iters, runningTime, dataTime, cost,
avgAcces)
self.logger[split].write(log)
coord.request_stop()
coord.join()
return avgLoss()
