def get_df():
#########################################################################3
image_dir = '/home/work/dsb/ext/weebly/Tissue images'
anno_dir = '/home/work/dsb/ext/weebly/Annotations'
#correct directory addresses accordingly here
############################################################################
image_paths = os.listdir(image_dir)
ids = [x.split('.')[0] for x in image_paths]
image_paths = [os.path.join(image_dir, path) for path in image_paths]
mask_paths = [os.path.join(anno_dir, '{}.xml'.format(id)) for id in ids]
df = []
for id, image_path, mask_path in zip(ids, image_paths, mask_paths):
print(id, end=',')
image = cv2.imread(image_path)
mask, nb_instance, nb_gt, mask_vals = read_mask(
mask_path, image.shape[:2])
df.append({
'image': image,
'mask': mask,
'nb_instance': nb_instance,
'nb_gt': nb_gt,
'mask_vals': mask_vals,
'id': id,
'image_path': image_path,
'mask_path': mask_path
})
df = pd.DataFrame(df)
df['shape'] = df['image'].apply(lambda x: x.shape)
save_to_cache(df, 'weebly')
def predict_test_rcnn_half(df_name, weight_dir, weight_fl=None):
config = DsbConfig()
config.BATCH_SIZE = 1
config.GPU_COUNT = 1
unet_ratio, tp = 1, 'all'
df = load_from_cache(df_name)
df['shape'] = df['image'].apply(
lambda x: (x.shape[0] // 2, x.shape[1] // 2, x.shape[2]))
output_names = ['mask', 'ly', 'lx', 'ldr', 'ldl']
nb_outputs = [0, 9, 10, 11, 12]
preds_df = pd.DataFrame(index=df.index, columns=output_names)
vals = np.unique(df['shape'])
if weight_fl is None:
weight_fls = glob.glob(os.path.join(weight_dir, '*.hdf5'))
weight_fls = sorted(
weight_fls,
key=lambda x: float(os.path.basename(x)[:-5].split('_')[-1]))
weight_fl = weight_fls[0]
for nb, shape in enumerate(vals):
ind_shape = df[df['shape'] == shape].index
new_shape = 64 * int(np.ceil(max(shape) / 64))
print('{}/{}'.format(nb, len(vals)), len(ind_shape), shape, new_shape)
model = model_rcnn(tp, unet_ratio, 'sgd', config, weight_dir,
new_shape)
#model = model_unet(new_shape, unet_ratio, tp, config=config)
model.load_weights(weight_fl)
model.compile(1e-3)
images = np.stack([
cv2.resize(image,
dsize=(shape[1], shape[0]),
interpolation=cv2.INTER_LINEAR)
for image in df.loc[ind_shape, 'image']
], 0)
if (new_shape, new_shape) != shape[:2]:
y1, x1 = (new_shape - images.shape[1]) // 2, (new_shape -
images.shape[2]) // 2
y2, x2 = new_shape - images.shape[
1] - y1, new_shape - images.shape[2] - x1
images = np.pad(images, ((0, 0), (y1, y2), (x1, x2), (0, 0)),
mode='constant',
constant_values=0)
else:
y1, x1, y2, x2 = 0, 0, 0, 0
inputs = get_inputs_rcnn(images)
y_preds = model.keras_model.predict(inputs, batch_size=1, verbose=1)
for nb_output, output_name in zip(nb_outputs, output_names):
y_pred = y_preds[nb_output][:, :, :, :1]
if (new_shape, new_shape) != shape:
y_pred = y_pred[:, y1:new_shape - y2, x1:new_shape - x2, :1]
preds_df.loc[ind_shape,
output_name] = list(y_pred.astype('float16'))
save_to_cache(preds_df, os.path.join(weight_dir,
'{}_half'.format(df_name)))
def get_masks():
###############################################################################
boundary_dir = '/home/work/dsb/ext/2009isbi/segmented-lpc-boundary'
save_dir = '/home/work/dsb/ext/2009isbi/segmented-lpc-mask'
################################################################################
os.path.exists(boundary_dir)
folders = next(os.walk(boundary_dir))[1]
masks = []
for folder in folders:
fls = next(os.walk(os.path.join(boundary_dir, folder)))[2]
fls = sorted(fls, key=lambda x: int(x[:-4].split('-')[-1]))
for fl in fls:
pass
id = os.path.basename(fl)[:-4]
filepath = os.path.join(boundary_dir, folder, fl)
boundary = cv2.imread(filepath, 0)
mask = boundary2mask(boundary)
check_sanity(mask, boundary, folder, fl)
plt.imsave(
os.path.join(save_dir, folder, '{}_mask.png'.format(id)), mask)
masks.append({'id': '{}_{}'.format(folder, id), 'mask': mask})
masks = pd.DataFrame(masks)
df = load_from_cache('2009isbi')
df = pd.merge(df, masks, how='left', on='id')
df = df.dropna(0)
df['nb_instance'] = df['mask'].apply(lambda x: x.max())
save_to_cache(df, '2009isbi')
def get_df():
###################################################################
data_dir = '/home/work/dsb/ext/TNBC_NucleiSegmentation'
#correct directory address accordingly
######################################################################3
assert os.path.exists(data_dir)
image_folders = glob.glob(os.path.join(data_dir, 'Slide*'))
image_folders = sorted(image_folders)
df = []
for image_folder in image_folders:
image_fls = os.listdir(image_folder)
image_fls = sorted(image_fls)
for image_fl in image_fls:
filepath = os.path.join(image_folder, image_fl)
image = cv2.imread(filepath)
mask_path = filepath.replace('Slide', 'GT')
mask_unet = cv2.imread(mask_path, 0)
assert len(np.unique(mask_unet)) == 2
_, mask = cv2.connectedComponents(mask_unet, connectivity=4)
df.append({
'image': image,
'mask': mask,
'image_path': filepath,
'mask_path': mask_path,
'id': image_fl[:-4],
'nb_instance': mask.max(),
'shape': image.shape
})
df = pd.DataFrame(df)
save_to_cache(df, 'TNBC')
def get_cons_scale(df_name, weight_dir, tag='half', n_jobs=18):
fl_name = os.path.join(weight_dir, '{}_{}'.format(df_name, tag))
if tag != 'two':
preds_df = load_from_cache(fl_name)
else:
fl_names = glob.glob(os.path.join(weight_dir, '{}_{}'.format(df_name, tag),
'{}_{}_[0-9+].dat'.format(df_name, tag)))+\
glob.glob(os.path.join(weight_dir, '{}_{}'.format(df_name, tag),
'{}_{}_[0-9][0-9].dat'.format(df_name, tag)))
preds_df = load_from_cache_multi(os.path.join(
weight_dir, '{}_{}'.format(df_name, tag),
'{}_{}'.format(df_name, tag)),
nb=len(fl_names))
print(preds_df.shape)
cons_total = Parallel(n_jobs)(delayed(get_cons_local_valid)(
preds_df.loc[ind, 'pred_scale'],
np.concatenate(preds_df.loc[ind,
['mask', 'ly', 'lx', 'ldr', 'ldl']], -1))
for ind in preds_df.index)
preds_df['con'] = cons_total
if tag != 'two':
save_to_cache(preds_df,
os.path.join(weight_dir, '{}_{}'.format(df_name, tag)))
else:
save_to_cache_multi(
preds_df,
os.path.join(weight_dir, '{}_{}'.format(df_name, tag),
'{}_{}'.format(df_name, tag)), 10)
def get_mask(df_name, config, weight_dir, save_name, n_jobs=18):
save_dir = os.path.join(weight_dir, save_name)
os.path.exists(save_dir)
#df = load_from_cache(df_name)
fl_name = os.path.join(weight_dir, df_name)
if os.path.exists('{}.dat'.format(fl_name)):
preds_df = load_from_cache(fl_name)
else:
fl_names = glob.glob(
os.path.join(weight_dir, '{}_[0-9+].dat'.format(df_name)))
preds_df = load_from_cache_multi(fl_name, nb=len(fl_names))
print(preds_df.shape)
masks0 = Parallel(n_jobs)(delayed(postprocess)(np.concatenate(
preds_df.loc[ind, ['mask', 'ly', 'lx', 'ldr', 'ldl']], -1), config)
for ind in preds_df.index)
masks0 = Parallel(n_jobs)(delayed(renumber_mask)(mask) for mask in masks0)
masks0 = [x[0] for x in masks0]
preds_df['pred0'] = masks0
masks = Parallel(n_jobs)(delayed(modify_w_unet)(
preds_df.loc[ind, 'pred0'],
np.concatenate(preds_df.loc[ind,
['mask', 'ly', 'lx', 'ldr', 'ldl']], -1))
for ind in preds_df.index)
preds_df['pred'] = masks
save_to_cache(preds_df, os.path.join(weight_dir, df_name))
def train_valid_split():
df = load_from_cache('train_df_fixed')
df_256 = load_from_cache('train_df_256_fixed')
df_256['id'] = df.loc[df_256['image_id'].values, 'id'].values
train_ids = df['id'][::2]
valid_ids = df['id'][1::2]
train_df = df_256.loc[df_256['id'].isin(train_ids)]
valid_df = df_256.loc[df_256['id'].isin(valid_ids)]
save_to_cache(train_df, 'train_final_df')
save_to_cache(valid_df, 'valid_df')
def get_test_df(test_dir, save_name='test_df'):
test_ids = list(next(os.walk(test_dir)))[1]
test_df = []
for id_ in test_ids:
path = os.path.join(test_dir, id_, 'images', id_+'.png')
image = cv2.imread(path)
test_df.append({'id':id_, 'image':image, 'path': path,
'shape':image.shape})
test_df = pd.DataFrame(test_df).sort_values('shape').reset_index()
save_to_cache(test_df, save_name)
def main():
################################################################################
weight_dir = '/media/work/Data/dsb/cache/UnetRCNN_180410-221747'
################################################################################
df_name = 'stage2_df'
df = load_from_cache(df_name)
tags = ['quarter', 'half', None, 'two']
preds = []
for tag in tags:
if tag is None:
fl = os.path.join(weight_dir, '{}.dat'.format(df_name))
pred = load_file(fl)
elif tag == 'two':
fl_names = glob.glob(os.path.join(weight_dir, '{}_{}'.format(df_name, tag),
'{}_{}_[0-9+].dat'.format(df_name, tag)))+\
glob.glob(os.path.join(weight_dir, '{}_{}'.format(df_name, tag),
'{}_{}_[0-9][0-9].dat'.format(df_name, tag)))
pred = load_from_cache_multi(os.path.join(weight_dir,
'{}_{}'.format(df_name, tag),
'{}_{}'.format(df_name, tag)),
nb=len(fl_names))
else:
fl = os.path.join(weight_dir, '{}_{}.dat'.format(df_name,tag))
pred = load_file(fl)
preds.append(pred)
nb_fls = len(tags)
results = []
for ind in df.index:
masks = [pred.loc[ind, 'pred'] for pred in preds]
scores = [pred.loc[ind, 'con'] for pred in preds]
res={}
for key, vals in zip(np.arange(nb_fls),scores):
for nb in range(len(vals)):
res['{}_{}'.format(key, nb)] = vals[nb]
res = pd.Series(res).sort_values()
res = res[res<0.2]
mask = np.zeros_like(masks[0], dtype='int16')
val = 1
for ind_res in res.index:
size, label = ind_res.split('_')
size, label = int(size), int(label)
index = masks[size]==label+1
if (np.sum(mask[index]>0)/np.sum(index))<0.5:
mask[(index)&(mask==0)] = val
val = val+1
results.append(mask)
preds_df = pd.DataFrame(index = df.index)
preds_df['pred'] = results
save_to_cache(preds_df, os.path.join(weight_dir, 'preds_df_scale_01'))
make_submission(preds_df)
def get_cons(df_name, weight_dir, n_jobs=18):
fl_name = os.path.join(weight_dir, df_name)
preds_df = load_from_cache(fl_name)
print(preds_df.shape)
cons_total = Parallel(n_jobs)(delayed(get_cons_local_valid)(
preds_df.loc[ind, 'pred'],
np.concatenate(preds_df.loc[ind,
['mask', 'ly', 'lx', 'ldr', 'ldl']], -1))
for ind in preds_df.index)
preds_df['con'] = cons_total
save_to_cache(preds_df, os.path.join(weight_dir, '{}'.format(df_name)))
def main():
config = DsbConfig()
df = load_from_cache('train_df_fixed')
df_cut = resave(df, config)
df_cut['shape_id'] = df.loc[df_cut['image_id'].values, 'shape_id'].values
save_to_cache(df_cut, 'train_df_256_fixed')
for df_name in ['2009isbi', 'TNBC', 'weebly']:
df = load_from_cache(df_name)
df_cut = resave(df, config)
save_to_cache(df_cut, '{}_256'.format(df_name))
def get_mask_scale(df_name,
config,
weight_dir,
save_name,
tag='half',
n_jobs=18):
fl_name = os.path.join(weight_dir, df_name + '_' + tag)
if os.path.exists('{}.dat'.format(fl_name)):
preds_df = load_from_cache(fl_name)
else:
fl_names = glob.glob(os.path.join(weight_dir, '{}_{}_[0-9+].dat'.format(df_name, tag)))+\
glob.glob(os.path.join(weight_dir, '{}_{}_[0-9][0-9].dat'.format(df_name, tag)))
preds_df = load_from_cache_multi(fl_name, nb=len(fl_names))
print(preds_df.shape)
save_dir = os.path.join(weight_dir, save_name)
os.path.exists(save_dir)
df = load_from_cache(df_name)
masks0_scale = Parallel(n_jobs)(delayed(postprocess)(np.concatenate(
preds_df.loc[ind, ['mask', 'ly', 'lx', 'ldr', 'ldl']], -1), config)
for ind in preds_df.index)
masks0_scale = Parallel(n_jobs)(delayed(renumber_mask)(mask)
for mask in masks0_scale)
preds_df['pred0_scale'] = [x[0].astype('int16') for x in masks0_scale]
masks_scale = Parallel(n_jobs)(delayed(modify_w_unet)(
preds_df.loc[ind, 'pred0_scale'],
np.concatenate(preds_df.loc[ind,
['mask', 'ly', 'lx', 'ldr', 'ldl']], -1))
for ind in preds_df.index)
preds_df['pred_scale'] = [x.astype('int16') for x in masks_scale]
masks = Parallel(n_jobs)(
delayed(cv2.resize)(preds_df.loc[ind, 'pred_scale'],
dsize=(df.loc[ind,
'shape'][1], df.loc[ind,
'shape'][0]),
interpolation=cv2.INTER_NEAREST)
for ind in df.index)
preds_df['pred'] = [x.astype('int16') for x in masks]
if tag != 'two':
save_to_cache(preds_df,
os.path.join(weight_dir, '{}_{}'.format(df_name, tag)))
else:
save_to_cache_multi(
preds_df,
os.path.join(weight_dir, '{}_{}'.format(df_name, tag),
'{}_{}'.format(df_name, tag)), 10)
def get_train_df(train_dir, save_name):
train_ids = list(next(os.walk(train_dir)))[1]
train_df = []
for id_ in train_ids:
image = cv2.imread(os.path.join(train_dir, id_, 'images', id_+'.png'))
gray = is_gray(image)
shape = image.shape[:2] if gray else image.shape
masks = []
for mask_fl in glob.glob(os.path.join(train_dir, id_, 'masks', '*.*')):
mask_ = cv2.imread(mask_fl, 0)
masks.append((mask_>0).astype(np.uint8))
masks = np.stack(masks, 2)
mask = mask_m21(masks)
train_df.append({'id':id_, 'image':image,
'is_gray':gray, 'shape':shape, 'mask':mask,
'nb_instance':mask.max()})
train_df = pd.DataFrame(train_df).sort_values('shape').reset_index()
train_df['shape_id'] = LabelEncoder().fit_transform(train_df['shape'])
save_to_cache(train_df, save_name)
def get_images():
######################################################################
data_dir = '/media/work/Ubuntu 16.0/ext/2009_ISBI/data/images/dna-images'
# where images are stored
########################################################################3
os.path.exists(data_dir)
df = []
folders = next(os.walk(data_dir))[1]
for folder in folders:
fls = next(os.walk(os.path.join(data_dir, folder)))[2]
fls = sorted(fls, key=lambda x: int(x[:-4].split('-')[-1]))
for fl in fls:
filepath = os.path.join(data_dir, folder, fl)
image = cv2.imread(filepath)
df.append({
'image': image,
'shape': image.shape,
'md5': md5sum(filepath),
'path': filepath,
'id': '{}_{}'.format(folder, fl[:-4])
})
df = pd.DataFrame(df)
save_to_cache(df, '2009isbi')
def main():
config = DsbConfig()
df_name = 'stage2_df'
save_name = 'stage2'
###################################################################################
weight_dir = '/home/work/data/dsb/cache/UnetRCNN_180410-221747'
#correct directory address where model weight for prediction is saved
##################################################################################
predict_test_rcnn(df_name, weight_dir)
predict_test_rcnn_half(df_name, weight_dir)
predict_test_rcnn_quarter(df_name, weight_dir)
predict_test_rcnn_two(df_name, weight_dir)
#combine predictions for zoom 2
for nb in range(25):
fl = os.path.join(weight_dir, 'stage2_df_two_{}.dat'.format(nb))
if os.path.exists(fl):
continue
else:
fls = glob.glob(
os.path.join(weight_dir, 'stage2_df_two_{}_*.dat'.format(nb)))
preds_df = load_from_cache_multi(fl[:-4], len(fls))
save_to_cache(preds_df, fl)
for fl in fls:
os.remove(fl)
get_mask(df_name, config, weight_dir, save_name)
get_mask_scale(df_name, config, weight_dir, save_name, tag='half')
get_mask_scale(df_name, config, weight_dir, save_name, tag='quarter')
get_mask_scale(df_name, config, weight_dir, save_name, tag='two')
get_cons(df_name, weight_dir)
get_cons_scale(df_name, weight_dir, tag='half')
get_cons_scale(df_name, weight_dir, tag='quarter')
get_cons_scale(df_name, weight_dir, tag='two')
def predict_test_rcnn_two(df_name,
weight_dir,
weight_fl=None,
start=0,
end=100,
start_run=0):
config = DsbConfig()
config.BATCH_SIZE = 1
config.GPU_COUNT = 1
max_shape = 1024
unet_ratio, tp = 1, 'all'
df = load_from_cache(df_name)
df['shape'] = df['image'].apply(
lambda x: (x.shape[0] * 2, x.shape[1] * 2, x.shape[2]))
output_names = ['mask', 'ly', 'lx', 'ldr', 'ldl']
nb_outputs = [0, 9, 10, 11, 12]
vals = np.unique(df['shape'])
if weight_fl is None:
weight_fls = glob.glob(os.path.join(weight_dir, '*.hdf5'))
weight_fls = sorted(
weight_fls,
key=lambda x: float(os.path.basename(x)[:-5].split('_')[-1]))
weight_fl = weight_fls[0]
for nb, shape in enumerate(vals):
if (nb < start) | (nb >= end):
continue
if max(shape) <= max_shape:
new_shape = 64 * int(np.ceil(max(shape) / 64))
else:
new_shape = 512 * int(np.ceil(max(shape) / 512))
ind_shape = df[df['shape'] == shape].index
print('{}/{}'.format(nb, len(vals)), len(ind_shape), shape, new_shape)
if len(ind_shape) * (new_shape // 512)**2 > 800:
nb_run = (len(ind_shape) * (new_shape // 512)**2) // 800 + 1
size = int(len(ind_shape) / nb_run) + 1
ind_shape0 = ind_shape.copy()
else:
nb_run = 1
size = len(ind_shape)
for run in range(nb_run):
if run < start_run:
continue
if nb_run != 1:
start, end = run * size, min((run + 1) * size, len(ind_shape0))
ind_shape = ind_shape0[start:end]
preds_df = pd.DataFrame(index=df.index[ind_shape],
columns=output_names)
model = model_rcnn(tp, unet_ratio, 'sgd', config, weight_dir,
min(new_shape, max_shape))
#model = model_unet(new_shape, unet_ratio, tp, config=config)
model.load_weights(weight_fl)
model.compile(1e-3)
images = np.stack([
cv2.resize(image,
dsize=(shape[1], shape[0]),
interpolation=cv2.INTER_LINEAR)
for image in df.loc[ind_shape, 'image']
], 0)
print(images.shape)
if (new_shape, new_shape) != shape[:2]:
y1, x1 = (new_shape - images.shape[1]) // 2, (
new_shape - images.shape[2]) // 2
y2, x2 = new_shape - images.shape[
1] - y1, new_shape - images.shape[2] - x1
images = np.pad(images, ((0, 0), (y1, y2), (x1, x2), (0, 0)),
mode='constant',
constant_values=0)
else:
y1, x1, y2, x2 = 0, 0, 0, 0
X = get_inputs_rcnn(images)
if new_shape > max_shape:
nb_cut = int(np.ceil(new_shape / 512)) - 1
y_preds = [np.zeros((images.shape[0], new_shape, new_shape, 1), dtype='float32')]+\
[np.zeros((images.shape[0], new_shape, new_shape, 2), dtype='float32') for _ in range(4)]
for nb_y in range(nb_cut):
start_y, end_y = 512 * nb_y, 512 * (nb_y + 2)
shift_start_y = 0 if nb_y == 0 else 256
shift_end_y = 0 if nb_y == nb_cut - 1 else -256
for nb_x in range(nb_cut):
start_x, end_x = 512 * nb_x, 512 * (nb_x + 2)
shift_start_x = 0 if nb_x == 0 else 256
shift_end_x = 0 if nb_x == nb_cut - 1 else -256
print(start_y, end_y, start_x, end_x)
print(shift_start_y, shift_end_y, shift_start_x,
shift_end_x)
X_nb = [
X[0][:, 4 * start_y:4 * end_y,
4 * start_x:4 * end_x], X[1][:, start_y:end_y,
start_x:end_x]
]
preds = model.keras_model.predict(X_nb,
batch_size=1,
verbose=1)
for i, nb_output in enumerate(nb_outputs):
y_preds[i][:, start_y+shift_start_y:end_y+shift_end_y,
start_x+shift_start_x:end_x+shift_end_x]=\
preds[nb_output][:,shift_start_y:max_shape+shift_end_y,
shift_start_x:max_shape+shift_end_x]
del preds
else:
y_preds = model.keras_model.predict(X, batch_size=1, verbose=1)
y_preds = [y_preds[i] for i in nb_outputs]
for i, output_name in enumerate(output_names):
y_pred = y_preds[i][:, :, :, :1]
if (new_shape, new_shape) != shape:
y_pred = y_pred[:, y1:new_shape - y2,
x1:new_shape - x2, :1]
preds_df.loc[ind_shape,
output_name] = list(y_pred.astype('float16'))
if nb_run == 1:
save_to_cache(
preds_df,
os.path.join(weight_dir, '{}_two_{}'.format(df_name, nb)))
else:
save_to_cache(
preds_df,
os.path.join(weight_dir,
'{}_two_{}_{}'.format(df_name, nb, run)))
if len(df) < 200:
preds_df = load_from_cache_multi(
os.path.join(weight_dir, '{}_two'.format(df_name)), len(vals))
save_to_cache(preds_df,
os.path.join(weight_dir, '{}_two'.format(df_name)))
for nb in range(len(vals)):
os.remove(
os.path.join(weight_dir, '{}_two_{}.dat'.format(df_name, nb)))
def predict_test_rcnn(df_name, weight_dir, weight_fl=None):
config = DsbConfig()
config.BATCH_SIZE = 1
config.GPU_COUNT = 1
max_shape = 1024
unet_ratio, tp = 1, 'all'
df = load_from_cache(df_name)
output_names = ['mask', 'ly', 'lx', 'ldr', 'ldl']
nb_outputs = [0, 9, 10, 11, 12]
preds_df = pd.DataFrame(index=df.index, columns=output_names)
vals = np.unique(df['shape'])
if weight_fl is None:
weight_fls = glob.glob(os.path.join(weight_dir, '*.hdf5'))
weight_fls = sorted(
weight_fls,
key=lambda x: float(os.path.basename(x)[:-5].split('_')[-1]))
weight_fl = weight_fls[0]
for nb, shape in enumerate(vals):
ind_shape = df[df['shape'] == shape].index
if max(shape) <= max_shape:
new_shape = 64 * int(np.ceil(max(shape) / 64))
else:
new_shape = 512 * int(np.ceil(max(shape) / 512))
print('{}/{}'.format(nb, len(vals)), len(ind_shape), shape, new_shape)
model = model_rcnn(tp, unet_ratio, 'sgd', config, weight_dir,
min(new_shape, max_shape))
#model = model_unet(new_shape, unet_ratio, tp, config=config)
model.load_weights(weight_fl)
model.compile(1e-3)
images = np.stack(df.loc[ind_shape, 'image'], 0)
if (new_shape, new_shape) != shape:
y1, x1 = (new_shape - images.shape[1]) // 2, (new_shape -
images.shape[2]) // 2
y2, x2 = new_shape - images.shape[
1] - y1, new_shape - images.shape[2] - x1
images = np.pad(images, ((0, 0), (y1, y2), (x1, x2), (0, 0)),
mode='constant',
constant_values=0)
else:
y1, x1, y2, x2 = 0, 0, 0, 0
X = get_inputs_rcnn(images)
if new_shape > max_shape:
nb_cut = int(np.ceil(new_shape / 512)) - 1
y_preds = [np.zeros((images.shape[0], new_shape, new_shape, 1), dtype='float32')]+\
[np.zeros((images.shape[0], new_shape, new_shape, 2), dtype='float32') for _ in range(12)]
for nb_y in range(nb_cut):
start_y, end_y = 512 * nb_y, 512 * (nb_y + 2)
shift_start_y = 0 if nb_y == 0 else 256
shift_end_y = 0 if nb_y == nb_cut - 1 else -256
for nb_x in range(nb_cut):
start_x, end_x = 512 * nb_x, 512 * (nb_x + 2)
shift_start_x = 0 if nb_x == 0 else 256
shift_end_x = 0 if nb_x == nb_cut - 1 else -256
print(start_y, end_y, start_x, end_x)
print(shift_start_y, shift_end_y, shift_start_x,
shift_end_x)
X_nb = [
X[0][:, 4 * start_y:4 * end_y, 4 * start_x:4 * end_x],
X[1][:, start_y:end_y, start_x:end_x]
]
preds = model.keras_model.predict(X_nb,
batch_size=1,
verbose=1)
for nb_output in range(13):
y_preds[nb_output][:, start_y+shift_start_y:end_y+shift_end_y,
start_x+shift_start_x:end_x+shift_end_x]=\
preds[nb_output][:,shift_start_y:max_shape+shift_end_y,
shift_start_x:max_shape+shift_end_x]
else:
y_preds = model.keras_model.predict(X, batch_size=1, verbose=1)
for nb_output, output_name in zip(nb_outputs, output_names):
y_pred = y_preds[nb_output][:, :, :, :1]
if (new_shape, new_shape) != shape:
y_pred = y_pred[:, y1:new_shape - y2, x1:new_shape - x2, :1]
preds_df.loc[ind_shape,
output_name] = list(y_pred.astype('float16'))
if len(preds_df) > 500:
save_to_cache_multi(preds_df, os.path.join(weight_dir, df_name),
len(preds_df) // 500 + 1)
else:
save_to_cache(preds_df, os.path.join(weight_dir, df_name))
