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