def ret_img(img, fsize, stride, model, th=0.4):
row, col = img.shape[-2:]
im2col_fn = im2col_compfn((row, col), fsize, stride, 0, False)
rgbpatch = extract_rgbpatch(img, im2col_fn)
patch_pred = model.predict(rgbpatch)
row_pred, col_pred = (row - fsize) / stride + 1, (col - fsize) / stride + 1
patch_pred = patch_pred.reshape((row_pred, col_pred))
region = np.zeros_like(patch_pred, np.uint8)
heatmap = np.zeros_like(patch_pred, np.float32)
ext = fsize / (8 * stride)
normal_bbox_size = 4 * ext * ext
gauss_normal = gauss_weight((2 * ext, 2 * ext))
for i in xrange(row_pred):
for j in xrange(col_pred):
bbox = vaild_bound(i - ext, j - ext, i + ext, j + ext, (row_pred, col_pred))
neibs = patch_pred[bbox[0]:bbox[2], bbox[1]:bbox[3]]
if (bbox[2] - bbox[0]) * (bbox[3] - bbox[1]) != normal_bbox_size:
gauss = gauss_weight(neibs.shape)
else:
gauss = gauss_normal
heatmap[i, j] = np.average(neibs, weights=gauss)
if np.count_nonzero(neibs > th) > np.prod(neibs.shape) / 2:
region[i, j] = 255
# region = dilation(region, square(5))
# region = filter_region(region)
return region, heatmap
def getbeta(self, inputX):
batches, channels, rows, cols = inputX.shape
assert channels > 1
if self.im2colfn is None:
self.im2colfn = im2col_compfn((rows, cols), self.fsize, stride=self.stride_,
pad=self.pad_, ignore_border=self.im2col_ignore_border)
patches = im2col_catch_compiled(inputX, self.im2colfn)
patches = norm(patches)
beta = choose_method(patches, self.n_hidden, self.noise, self.C, method=self.method)
return beta
def get_train_output_for(self, inputX):
batches, channels, rows, cols = inputX.shape
assert channels > 1
oshape = conv_out_shape((batches, channels, rows, cols),
(self.n_hidden, channels, self.fsize, self.fsize),
pad=self.pad, stride=self.stride, ignore_border=self.im2col_ignore_border)
self.orows, self.ocols = oshape[-2:]
if self.im2colfn is None:
self.im2colfn = im2col_compfn((rows, cols), self.fsize, stride=self.stride,
pad=self.pad, ignore_border=self.im2col_ignore_border)
if self.add_pool and self.poolfn is None:
self.poolfn = pool_fn(self.pool_size, mode=self.mode)
patches = self.forward_decomp_jobs(inputX, splits=splits)
return patches
def valiadte(model_name, fsize):
# constants
fsize_in = 256
stride_in = 16
img_size_in = 2048
model = Model(model_name)
img_size = img_size_in * fsize / fsize_in
stride = img_size * stride_in / img_size_in
im2col_fn = im2col_compfn((img_size, img_size), fsize, stride, 0, False)
test_path = dataset_path + 'test/'
img_list = np.load(dataset_path + 'te_idx.npy')
dice_all = 0.
for img_name in img_list:
img = readTiff(test_path + img_name)
img = resize(img, (img_size, img_size))
svg = readSvg(test_path, img_name[:-5] + '.svg')
dice_all += cal_dice(img, svg, fsize, stride, im2col_fn, model)
dice_all /= len(img_list)
print dice_all
def get_train_output_for(self, inputX):
batches1, channels1, rows1, cols1 = inputX.shape
assert inputX.shape[1] > 1
beta_border = True
forward_border = False
im2colfn_beta1 = im2col_compfn((rows1, cols1), self.fsize1, stride=self.stride1_,
pad=self.pad1_, ignore_border=beta_border)
im2colfn_forward1 = im2col_compfn((rows1, cols1), self.fsize1, stride=self.stride1,
pad=self.pad1, ignore_border=forward_border)
poolfn1 = pool_fn(self.pool_size1, mode=self.mode1)
im2colfn_beta2 = None
im2colfn_forward2 = None
poolfn2 = pool_fn(self.pool_size2, mode=self.mode2)
betalayer1 = BetaLayer_chs(self.dir_name, self.C, self.n_hidden1, self.fsize1,
self.pad1_, self.stride1_, self.noise1, im2col_ignore_border=beta_border,
im2colfn=im2colfn_beta1, method=self.method, visual=self.visual)
beta1 = betalayer1.getbeta(inputX)
self.forwardlayer1_list = []
self.forwardlayer2_list = []
output = None
# self.shortcut = int(np.round(self.n_hidden1 * self.shortcut))
for i in xrange(self.n_hidden1):
starti = time.time()
forwardlayer1 = ForwardLayer_chs(self.dir_name, self.n_hidden1, self.fsize1,
self.pad1, self.stride1, beta1[:, i], self.pool_size1,
self.mode1, self.add_pool1, im2col_ignore_border=forward_border,
im2colfn=im2colfn_forward1, poolfn=poolfn1)
onech_out1 = forwardlayer1.get_train_output_for(inputX)
self.forwardlayer1_list.append(deepcopy(forwardlayer1))
if i < self.shortcut:
shortcut_layer = ShortcutLayer(poolfn=poolfn2)
onech_out2 = shortcut_layer.get_train_output_for(onech_out1)
self.forwardlayer2_list.append(deepcopy(shortcut_layer))
output = np.concatenate([output, onech_out2], axis=1) if output is not None else onech_out2
else:
###################### compile once #####################
batches2, channels2, rows2, cols2 = onech_out1.shape
if im2colfn_beta2 is None:
im2colfn_beta2 = im2col_compfn((rows2, cols2), self.fsize2, stride=self.stride2_,
pad=self.pad2_, ignore_border=beta_border)
if im2colfn_forward2 is None:
im2colfn_forward2 = im2col_compfn((rows2, cols2), self.fsize2, stride=self.stride2,
pad=self.pad2, ignore_border=forward_border)
##########################################################
betalayer2 = BetaLayer(self.dir_name, self.C, self.n_hidden2, self.fsize2,
self.pad2_, self.stride2_, self.noise2, im2col_ignore_border=beta_border,
im2colfn=im2colfn_beta2, method=self.method)
beta2 = betalayer2.getbeta(onech_out1)
for j in xrange(self.n_hidden2):
startj = time.time()
forwardlayer2 = ForwardLayer(self.dir_name, self.n_hidden2, self.fsize2,
self.pad2, self.stride2, beta2[:, j], self.pool_size2,
self.mode2, self.add_pool2, im2col_ignore_border=forward_border,
im2colfn=im2colfn_forward2, poolfn=poolfn2)
onech_out2 = forwardlayer2.get_train_output_for(onech_out1)
self.forwardlayer2_list.append(deepcopy(forwardlayer2))
output = np.concatenate([output, onech_out2], axis=1) if output is not None else onech_out2
print '\tj:', j, time.time() - startj
print 'i:', i, time.time() - starti
return output