def immontage(imgs, sz=None):
''' Montage color images '''
# input is required as a list of images
# assert isinstance(imgs, list)
if sz is not None:
size = sz
if sz[1] < 0:
size = (sz[0], numpy.floor(len(imgs)*1.0/sz[0])+1)
else:
imh, imw = imgs[0].shape[:2]
mgh = numpy.int(numpy.sqrt(imw*len(imgs)/imh))
mgw = numpy.int(numpy.sqrt(imh*len(imgs)/imw))
if mgh*mgw < len(imgs):
mgw += 1
mgh += 1
size = (mgh, mgw)
if imgs[0].ndim is 2:
return montage2d(arr_in=numpy.asarray(imgs), grid_shape=size)
else:
c1 = [im[:, :, 0] for im in imgs]
c2 = [im[:, :, 1] for im in imgs]
c3 = [im[:, :, 2] for im in imgs]
c1m = montage2d(arr_in=numpy.asarray(c1), grid_shape=size)
c2m = montage2d(arr_in=numpy.asarray(c2), grid_shape=size)
c3m = montage2d(arr_in=numpy.asarray(c3), grid_shape=size)
return numpy.dstack((c1m, c2m, c3m))
def _show_plot(c_subax, cur_var):
if len(cur_var.shape) >= 2:
c_mat = cur_var[0, 0] if cur_var.shape[1] == 1 else cur_var[0]
else:
c_mat = cur_var
if normalize:
if not np.isnan(c_mat.mean()):
c_mat = c_mat.astype(np.float32) - c_mat.mean()
if c_mat.std() > 0:
c_mat = c_mat.astype(np.float32) / c_mat.std()
if len(c_mat.shape) == 1:
if len(c_mat) > max_bars:
c_mat = c_mat[:max_bars]
ind = np.array(range(len(c_mat)))
c_subax.bar(ind, c_mat)
elif len(c_mat.shape) == 2:
c_subax.imshow(c_mat, **im_settings)
elif len(c_mat.shape) == 3:
c_subax.imshow(montage2d(c_mat), **im_settings)
elif len(c_mat.shape) == 4:
c_subax.imshow(montage2d(
np.stack([montage2d(c_layer) for c_layer in c_mat], 0)),
**im_settings)
def canonical_image(self, blob_name, feature_idx, k, tmp_fname):
# load the image and reconstruction
act_env = lmdb.open(self.config.max_activation_dbname, map_size=recon.config.config.lmdb_map_size)
act_key = self._get_key(blob_name, feature_idx)
with act_env.begin() as txn:
val = txn.get(act_key)
if val == None:
raise Exception('activation for key {} not yet stored'.format(act_key))
activations = pkl.loads(val)[-k:]
img_patches = []
rec_patches = []
# crop patches from the image and reconstruction
for i, act in enumerate(activations):
rec = act['reconstruction']
img = act['img']
top_left, bottom_right = act['patch_bbox']
top, left, bottom, right = top_left + bottom_right
img = img[top:bottom+1, left:right+1]
rec = rec[top:bottom+1, left:right+1]
img_patches.append(img)
rec_patches.append(rec)
# display the patches in a grid, then save to a file
patch_size = [0, 0]
for img, rec in zip(img_patches, rec_patches):
patch_size[0] = max(img.shape[0], patch_size[0])
patch_size[0] = max(rec.shape[0], patch_size[0])
patch_size[1] = max(img.shape[1], patch_size[1])
patch_size[1] = max(rec.shape[1], patch_size[1])
def scale(patch):
assert len(patch.shape) == 3
if patch.shape[:2] == patch_size:
return patch
new_patch = np.zeros(tuple(patch_size) + patch.shape[2:3], dtype=patch.dtype)
new_patch[:patch.shape[0], :patch.shape[1], :patch.shape[2]] = patch[:, :, :]
return new_patch
img_patches = (scale(img) for img in img_patches)
rec_patches = (scale(rec) for rec in rec_patches)
pad_img_patches = [np.pad(img, ((0, 2), (0, 2), (0, 0)), 'constant')
for img in img_patches]
pad_rec_patches = [np.pad(rec, ((0, 2), (0, 2), (0, 0)), 'constant')
for rec in rec_patches]
img_patches = np.vstack([img[np.newaxis] for img in pad_img_patches])
rec_patches = np.vstack([rec[np.newaxis] for rec in pad_rec_patches])
img_mon_channels = []
rec_mon_channels = []
for channel in range(img_patches.shape[-1]):
imgs = img_patches[:, :, :, channel]
mon = montage.montage2d(imgs, fill=0, rescale_intensity=False)
img_mon_channels.append(mon)
recs = rec_patches[:, :, :, channel]
mon = montage.montage2d(recs, fill=0, rescale_intensity=False)
rec_mon_channels.append(mon)
img = np.dstack(img_mon_channels)
rec = np.dstack(rec_mon_channels)
combined = np.hstack([img, np.zeros([img.shape[0], 5, img.shape[2]], dtype=img.dtype), rec])
io.imsave(tmp_fname, combined)
def montage_by(config,df,timepoint='t2',n=10,size=25,return_index=False,**kwargs):
clip_edge = int((float(size)/2))+1
b = config['image']['size']-1
s = select(select_range(df,ImageX=[clip_edge,b-clip_edge],ImageY=[clip_edge,b-clip_edge]),**kwargs).sample(n)
arr = np.dstack([slice_well(config,r,timepoint=timepoint,size=size) for i,r in s.iterrows()]).transpose([2,0,1])
if not return_index:
return montage.montage2d(arr)
else:
return montage.montage2d(arr), s.index
def montage_ndimage(ndimg, **kwargs):
"""create montage mpl plot for 3D ndimage
in gray (ndim == 3)
or color (ndim == 4)
"""
if np.ndim(ndimg) == 3:
m = montage2d(ndimg, fill=0)
elif np.ndim(ndimg) == 4: # + rgb dimension
m = np.stack(
(montage2d(np.squeeze(ndimg[..., 0]),
fill=0), montage2d(np.squeeze(ndimg[..., 1]), fill=0),
montage2d(np.squeeze(ndimg[..., 2]), fill=0)),
axis=2)
im = plt.imshow(m, **kwargs)
return im
def calc_montage_layer_view(td_seg_model,
layer_id,
img_in,
border_padding=1,
scale_f=2.0,
cmap_fun=cm.get_cmap('RdBu'),
verbose=False):
"""
Calculate a RGB representation of the image in the 3rd layer of the neural network
"""
img_representation = layer_id.get_output_at(0)
if verbose:
print('input:', img_in.shape, 'layer:', layer_id.name, 'output:',
img_representation)
img_func = K.function(
[td_seg_model.input, K.learning_phase()], [img_representation])
rgb_outputs = img_func([img_in,
0])[0] # training phase so elements are removed
if verbose: print('out_shape', rgb_outputs.shape)
_, _, l_wid, l_height = rgb_outputs.shape
rgb8_outputs = rgb_outputs
rgb8_outputs = (rgb8_outputs - np.mean(rgb8_outputs)) / (
scale_f * rgb8_outputs.std()) + 0.5
rgb8_outputs = rgb8_outputs.clip(-1, 1).astype(np.float32).reshape(
(-1, l_wid, l_height))
if border_padding > 0:
rgb8_outputs = np.pad(rgb8_outputs, border_padding,
mode='constant')[border_padding:-border_padding]
rgb_montage = montage2d(rgb8_outputs)
if verbose: print('montage_shape', rgb_montage.shape)
return cmap_fun(rgb_montage)
def montage_wb_ratio(input_image, patch_shape, n_filters, ele_print=False):
patches = view_as_windows(input_image, patch_shape)
patches = patches.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb, _ = kmeans2(patches, n_filters, minit='random')
fb = fb.reshape((-1, ) + patch_shape)
fb_montage = montage2d(fb, fill=False, rescale_intensity=True)
shape_var = np.ceil(np.sqrt(n_filters))
elements = np.split(np.hstack(np.split(fb_montage, shape_var)),
shape_var**2,
axis=1)
del elements[n_filters:]
wb_ratios = []
bin_elements = []
for element in elements:
thresh = threshold_mean(element)
binary = element > thresh
ratio = np.sum(binary) / binary.size
wb_ratios.append(ratio)
if ele_print:
bin_elements.append(binary)
wb_ratios = sorted(wb_ratios, reverse=True)
if ele_print:
show_images(elements)
show_images(bin_elements)
return (wb_ratios)
def test_grid_shape():
n_images = 6
height, width = 2, 2
arr_in = np.arange(n_images * height * width, dtype=np.float32)
arr_in = arr_in.reshape(n_images, height, width)
arr_out = montage2d(arr_in, grid_shape=(3, 2))
correct_arr_out = np.array([[0., 1., 4., 5.], [2., 3., 6., 7.],
[8., 9., 12., 13.], [10., 11., 14., 15.],
[16., 17., 20., 21.], [18., 19., 22., 23.]])
assert_array_equal(arr_out, correct_arr_out)
def test_shape():
n_images = 15
height, width = 11, 7
arr_in = np.arange(n_images * height * width)
arr_in = arr_in.reshape(n_images, height, width)
alpha = int(np.ceil(np.sqrt(n_images)))
arr_out = montage2d(arr_in)
assert_equal(arr_out.shape, (alpha * height, alpha * width))
def test_shape():
n_images = 15
height, width = 11, 7
arr_in = np.arange(n_images * height * width)
arr_in = arr_in.reshape(n_images, height, width)
alpha = int(np.ceil(np.sqrt(n_images)))
arr_out = montage2d(arr_in)
assert_equal(arr_out.shape, (alpha * height, alpha * width))
def montage_projection(im_dir, trange=None, context=None):
"""
Generate a montage of x projections.
im_dir : str, path to directory containing [x,y,z] data saved as tif
trange : object which can be used for linear indexing, set of timepoints to use
context : spark context object for parallelization
"""
import thunder as td
import skimage.external.tifffile as tif
from glob import glob
from skimage.util.montage import montage2d
from skimage.exposure import rescale_intensity as rescale
import numpy as np
from skimage import io
exp_name = im_dir.split('/')[-2]
print('Exp name: {0}'.format(exp_name))
ims = td.images.fromtif(im_dir + 'TM*.tif', engine=context)
print('Experiment dims: {0}'.format(ims.shape))
if trange is None:
trange = np.arange(ims.shape[0])
ims_cropped = ims[trange].median_filter([1,3,3])
dims = ims_cropped.dims
from scipy.ndimage import percentile_filter
float_dtype = 'float32'
def my_dff(y, perc, window):
baseFunc = lambda x: percentile_filter(x.astype(float_dtype), perc, window, mode='reflect')
b = baseFunc(y)
return ((y - b) / (b + .1))
dff_fun = lambda v: my_dff(v, 15, 800)
chop = 16
reshape_fun = lambda v: v.reshape(dims[0], dims[1], chop, dims[2] // chop)
montage_fun = lambda v: montage2d(v.T).T
def im_fun(v):
return montage_fun(reshape_fun(v).max(3))
out_dtype = 'uint16'
montage_ims = ims_cropped.map_as_series(dff_fun, value_size=ims_cropped.shape[0], dtype=float_dtype, chunk_size='35').map(im_fun)
dff_lim = montage_ims.map(lambda v: [v.max(), v.min()]).toarray()
rescale_fun = lambda v: rescale(v, in_range=(dff_lim.min(), dff_lim.max()), out_range=out_dtype).astype(out_dtype)
montage_rescaled = montage_ims.map(rescale_fun).toarray()[:,-1::-1,:]
return montage_rescaled
def plot_batch(image_batch, figure_path, label_batch=None):
all_groups = {label: montage2d(np.stack([img[:,:,0] for img, lab in img_lab_list],0))
for label, img_lab_list in groupby(zip(image_batch, label_batch), lambda x: x[1])}
fig, c_axs = plt.subplots(1,len(all_groups), figsize=(len(all_groups)*4, 8), dpi = 600)
for c_ax, (c_label, c_mtg) in zip(c_axs, all_groups.items()):
c_ax.imshow(c_mtg, cmap='bone')
c_ax.set_title(c_label)
c_ax.axis('off')
fig.savefig(os.path.join(figure_path))
plt.close()
def collage(bubbles):
ex = RGBExtractor()
ex.shp = (200, 200)
images = [ex.extract(*p) for p in bubble_params(bubbles)]
if len(images) == 3:
return np.vstack(images)
r, g, b = tuple(montage2d(np.array([a[:, :, i] for a in images]))
for i in range(3))
return np.dstack((r, g, b)).astype(np.uint8)
def collage(bubbles):
ex = RGBExtractor()
ex.shp = (200, 200)
images = [ex.extract(*p) for p in bubble_params(bubbles)]
if len(images) == 3:
return np.vstack(images)
r, g, b = tuple(
montage2d(np.array([a[:, :, i] for a in images])) for i in range(3))
return np.dstack((r, g, b)).astype(np.uint8)
def test_fill():
n_images = 3
height, width = 2, 3,
arr_in = np.arange(n_images * height * width)
arr_in = arr_in.reshape(n_images, height, width)
arr_out = montage2d(arr_in, fill=0)
gt = np.array([[0., 1., 2., 6., 7., 8.], [3., 4., 5., 9., 10., 11.],
[12., 13., 14., 0., 0., 0.], [15., 16., 17., 0., 0., 0.]])
assert_array_equal(arr_out, gt)
def show_and_save_montage_of_patches(patches, is_show, is_save, save_filename=None):
if is_show or is_save:
if patches.ndim == 3:
patches_montage = montage2d(patches)
else:
patches_montage = patches
if is_show:
imshow(patches_montage)
if is_save and (save_filename is not None):
save_filename = os.path.join(THIS_FILE_PATH, save_filename)
imsave(save_filename, patches_montage)
def show_montage_filters(imgs_src):
# show the features that extract from MRI using UNET
# change position of axis from (240,240,64) to (64,240,240)
imgs_show = np.moveaxis(imgs_src, -1, 0)
# print(imgs_tmp.shape)
slice_montage = montage2d(imgs_show)
fig, (ax1) = plt.subplots(1, 1, figsize=(12, 12))
ax1.imshow(slice_montage, cmap='gray')
ax1.axis('off')
ax1.set_title('Features')
plt.show()
def show_batch_sample(gen, path=None):
from matplotlib import pyplot as plt
from skimage.util.montage import montage2d
batch_x, batch_y = next(gen)
x = montage2d(np.squeeze(batch_x[:, :, :, 0]))
fig = plt.figure(figsize=(15, 15))
plt.imshow(x, cmap='bone')
plt.axis('off')
if path:
plt.savefig(path)
else:
plt.show()
def show_and_save_montage_of_patches(patches,
is_show,
is_save,
save_filename=None):
if is_show or is_save:
if patches.ndim == 3:
patches_montage = montage2d(patches)
else:
patches_montage = patches
if is_show:
imshow(patches_montage)
if is_save and (save_filename is not None):
save_filename = os.path.join(THIS_FILE_PATH, save_filename)
imsave(save_filename, patches_montage)
def test_grid_shape():
n_images = 6
height, width = 2, 2
arr_in = np.arange(n_images * height * width, dtype=np.float32)
arr_in = arr_in.reshape(n_images, height, width)
arr_out = montage2d(arr_in, grid_shape=(3,2))
correct_arr_out = np.array(
[[ 0., 1., 4., 5.],
[ 2., 3., 6., 7.],
[ 8., 9., 12., 13.],
[ 10., 11., 14., 15.],
[ 16., 17., 20., 21.],
[ 18., 19., 22., 23.]]
)
assert_array_equal(arr_out, correct_arr_out)
def test_simple():
n_images = 3
height, width = 2, 3,
arr_in = np.arange(n_images * height * width)
arr_in = arr_in.reshape(n_images, height, width)
arr_out = montage2d(arr_in)
gt = np.array(
[[ 0. , 1. , 2. , 6. , 7. , 8. ],
[ 3. , 4. , 5. , 9. , 10. , 11. ],
[ 12. , 13. , 14. , 8.5, 8.5, 8.5],
[ 15. , 16. , 17. , 8.5, 8.5, 8.5]]
)
assert_array_equal(arr_out, gt)
def montage_wb_ratio (input_image, patch_shape, n_filters, ele_print = False):
from skimage.util.shape import view_as_windows
from skimage.util.montage import montage2d
from scipy.cluster.vq import kmeans2
patches = view_as_windows(gray_crab, patch_shape)
patches = patches.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb, _ = kmeans2(patches, n_filters, minit='points')
fb = fb.reshape((-1,) + patch_shape)
fb_montage = montage2d(fb, fill=False, rescale_intensity=True)
elements = np.split(np.hstack(np.split(fb_montage, 4)), 16, axis=1)
del elements[n_filters:]
wb_ratios = []
bin_elements = []
for element in elements:
thresh = threshold_otsu(element)
binary = element > thresh
ratio = np.sum(binary) / binary.size
wb_ratios.append(ratio)
if ele_print:
bin_elements.append(binary)
wb_ratios = sorted(wb_ratios, reverse = True)
if ele_print:
show_images(elements)
show_images(bin_elements)
return(wb_ratios)
def test_simple():
n_images = 3
height, width = 2, 3
arr_in = np.arange(n_images * height * width)
arr_in = arr_in.reshape(n_images, height, width)
arr_out = montage2d(arr_in)
gt = np.array(
[
[0.0, 1.0, 2.0, 6.0, 7.0, 8.0],
[3.0, 4.0, 5.0, 9.0, 10.0, 11.0],
[12.0, 13.0, 14.0, 8.5, 8.5, 8.5],
[15.0, 16.0, 17.0, 8.5, 8.5, 8.5],
]
)
assert_array_equal(arr_out, gt)
def test_rescale_intensity():
n_images = 4
height, width = 3, 3
arr_in = np.arange(n_images * height * width, dtype=np.float32)
arr_in = arr_in.reshape(n_images, height, width)
arr_out = montage2d(arr_in, rescale_intensity=True)
gt = np.array([[0., 0.125, 0.25, 0., 0.125, 0.25],
[0.375, 0.5, 0.625, 0.375, 0.5, 0.625],
[0.75, 0.875, 1., 0.75, 0.875, 1.],
[0., 0.125, 0.25, 0., 0.125, 0.25],
[0.375, 0.5, 0.625, 0.375, 0.5, 0.625],
[0.75, 0.875, 1., 0.75, 0.875, 1.]])
assert_equal(arr_out.min(), 0.0)
assert_equal(arr_out.max(), 1.0)
assert_array_equal(arr_out, gt)
def check_batch_sample(gen, path=None):
train_val_df = load_train_csv(cfg)
train_df, val_df = split_train_val(train_val_df, 0.25)
train_gen = BaseGenerator(train_df,
cfg.train_dir,
batch_size=cfg.batch_size,
aug_args=cfg.aug_args,
target_shape=cfg.input_shape[:2],
use_yellow=False)
batch_x, batch_y = next(train_gen)
x = montage2d(np.squeeze(batch_x[:, :, :, 0]))
fig = plt.figure(figsize=(15, 15))
plt.imshow(x, cmap='bone')
plt.axis('off')
if path:
plt.savefig(path)
else:
plt.show()
def test_rescale_intensity():
n_images = 4
height, width = 3, 3
arr_in = np.arange(n_images * height * width, dtype=np.float32)
arr_in = arr_in.reshape(n_images, height, width)
arr_out = montage2d(arr_in, rescale_intensity=True)
gt = np.array(
[[ 0. , 0.125, 0.25 , 0. , 0.125, 0.25 ],
[ 0.375, 0.5 , 0.625, 0.375, 0.5 , 0.625],
[ 0.75 , 0.875, 1. , 0.75 , 0.875, 1. ],
[ 0. , 0.125, 0.25 , 0. , 0.125, 0.25 ],
[ 0.375, 0.5 , 0.625, 0.375, 0.5 , 0.625],
[ 0.75 , 0.875, 1. , 0.75 , 0.875, 1. ]]
)
assert_equal(arr_out.min(), 0.0)
assert_equal(arr_out.max(), 1.0)
assert_array_equal(arr_out, gt)
def coronal_montage(img, n_rows=4, n_cols=4, flip_x=False, flip_y=True, flip_z=True):
"""
Create a montage of all coronal (XZ) slices from a 3D image
Parameters
----------
img: 3D image to montage
n_rows: number of montage rows
n_cols: number of montage columns
rot: CCW 90deg rotations to apply to each section
Returns
-------
cor_mont: coronal slice montage of img
"""
# Total number of sections to extract
n = n_rows * n_cols
# Source image dimensions
nx, ny, nz = img.shape
# Coronal (XZ) sections
yy = np.linspace(0, ny-1, n).astype(int)
cors = img[:,yy,:]
if flip_x:
cors = np.flip(cors, axis=0)
if flip_y:
cors = np.flip(cors, axis=1)
if flip_z:
cors = np.flip(cors, axis=2)
# Permute image axes for montage2d: original y becomes new x
img = np.transpose(cors, (1,2,0))
# Construct montage of coronal sections
cor_mont = montage2d(img, fill=0, grid_shape=(n_rows, n_cols))
return cor_mont
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
loaded_model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=opt,
metrics=['accuracy'])
print("Loaded model from disk")
score = loaded_model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
score = loaded_model.evaluate(x_train, y_train, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#%%
from skimage.util.montage import montage2d
predictions = loaded_model.predict(all_masks_gt, batch_size=32, verbose=1)
#%%
classes = np.argmax(predictions,axis=1)
#%%
pl.imshow(montage2d(all_masks_gt[np.where((classes!=2)&((labels_gt==2)))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where((classes==1)&((labels_gt!=1)))[0]].squeeze()))
#%%
cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:,0]<0.5)[0]])).play(gain=3., magnification = 5, fr = 10)
#%%
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt==2)&(predictions[:,1]>=0.05))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt==2)&(predictions[:,1]>0.05))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where((predictions[:,1]>0.1))[0]].squeeze()))
def test_error_ndim():
arr_error = np.random.randn(1, 2, 3, 4)
with pytest.raises(AssertionError):
montage2d(arr_error)
m1 = cm.movie(np.concatenate([cv2.copyMakeBorder(img.T,xx,xx,yy,yy, cv2.BORDER_CONSTANT,0).T[None,:860,:560] for img in m],0))
m1.save('/mnt/ceph/neuro/zebra/05292014Fish1-4/thresholded_components_movie_' + str(ID) + '.hdf5')
#%% load each movie and create a super movie
movies = []
for ID in range(1,41):
print(ID)
movies.append(cm.load('/mnt/ceph/neuro/zebra/05292014Fish1-4/thresholded_components_movie_' + str(ID) + '.hdf5').astype(np.float32))
movies = np.array(movies)
movies = movies.transpose([1,0,3,2])
#%%
montmov = []
from skimage.util.montage import montage2d
for idx,fr in enumerate(movies):
print(idx)
montmov.append(montage2d(fr,grid_shape=(5,8)).astype(np.float32))
movies = []
montmov = np.array(montmov)
montmov = cm.movie(montmov)
#%%
montmov = cm.load('/mnt/ceph/neuro/zebra/05292014Fish1-4/thresholded_components_movie_all.hdf5')
#%% save frames in avi
import tifffile as tiff
for idx,vid_frame in enumerate(montmov):
print(idx)
tiff.imsave('/mnt/ceph/neuro/zebra/05292014Fish1-4/frames/'+str(idx)+'_.tif',vid_frame)
#%% Plane 11
if ploton:
from sklearn.preprocessing import normalize
def experiment(plot_path, ds_name, no_aug, affine_std, scale_u_range,
scale_x_range, scale_y_range, xlat_range, hflip, intens_flip,
intens_scale_range, intens_offset_range, grid_h, grid_w, seed):
settings = locals().copy()
import os
import sys
import cmdline_helpers
intens_scale_range_lower, intens_scale_range_upper = cmdline_helpers.colon_separated_range(
intens_scale_range)
intens_offset_range_lower, intens_offset_range_upper = cmdline_helpers.colon_separated_range(
intens_offset_range)
scale_u_range = cmdline_helpers.colon_separated_range(scale_u_range)
scale_x_range = cmdline_helpers.colon_separated_range(scale_x_range)
scale_y_range = cmdline_helpers.colon_separated_range(scale_y_range)
import numpy as np
from skimage.util.montage import montage2d
from PIL import Image
from batchup import data_source
import data_loaders
import augmentation
n_chn = 0
if ds_name == 'mnist':
d_source = data_loaders.load_mnist(zero_centre=False)
elif ds_name == 'usps':
d_source = data_loaders.load_usps(zero_centre=False, scale28=True)
elif ds_name == 'svhn_grey':
d_source = data_loaders.load_svhn(zero_centre=False, greyscale=True)
elif ds_name == 'svhn':
d_source = data_loaders.load_svhn(zero_centre=False, greyscale=False)
elif ds_name == 'cifar':
d_source = data_loaders.load_cifar10()
elif ds_name == 'stl':
d_source = data_loaders.load_stl()
elif ds_name == 'syndigits':
d_source = data_loaders.load_syn_digits(zero_centre=False,
greyscale=False)
elif ds_name == 'synsigns':
d_source = data_loaders.load_syn_signs(zero_centre=False,
greyscale=False)
elif ds_name == 'gtsrb':
d_source = data_loaders.load_gtsrb(zero_centre=False, greyscale=False)
else:
print('Unknown dataset \'{}\''.format(ds_name))
return
# Delete the training ground truths as we should not be using them
del d_source.train_y
n_classes = d_source.n_classes
print('Loaded data')
src_aug = augmentation.ImageAugmentation(
hflip,
xlat_range,
affine_std,
intens_flip=intens_flip,
intens_scale_range_lower=intens_scale_range_lower,
intens_scale_range_upper=intens_scale_range_upper,
intens_offset_range_lower=intens_offset_range_lower,
intens_offset_range_upper=intens_offset_range_upper,
scale_u_range=scale_u_range,
scale_x_range=scale_x_range,
scale_y_range=scale_y_range)
def augment(X):
if not no_aug:
X = src_aug.augment(X)
return X,
rampup_weight_in_list = [0]
print('Rendering...')
train_ds = data_source.ArrayDataSource([d_source.train_X],
repeats=-1).map(augment)
n_samples = len(d_source.train_X)
if seed != 0:
shuffle_rng = np.random.RandomState(seed)
else:
shuffle_rng = np.random
batch_size = grid_h * grid_w
display_batch_iter = train_ds.batch_iterator(batch_size=batch_size,
shuffle=shuffle_rng)
best_src_test_err = 1.0
x_batch, = next(display_batch_iter)
montage = []
for chn_i in range(x_batch.shape[1]):
m = montage2d(x_batch[:, chn_i, :, :], grid_shape=(grid_h, grid_w))
montage.append(m[:, :, None])
montage = np.concatenate(montage, axis=2)
if montage.shape[2] == 1:
montage = montage[:, :, 0]
lower = min(0.0, montage.min())
upper = max(1.0, montage.max())
montage = (montage - lower) / (upper - lower)
montage = (np.clip(montage, 0.0, 1.0) * 255.0).astype(np.uint8)
Image.fromarray(montage).save(plot_path)
kernel = gabor_kernel(frequency, theta=theta)
params = "theta=%d,\nfrequency=%.2f" % (theta * 180 / np.pi, frequency)
kernel_params.append(params)
# Save kernel and the power image for each image
results.append((kernel, [power(image_gray, kernel)]))
output = power(image_gray, kernel)
# astro = color.rgb2gray(data.astronaut())
astro = output
# -- filterbank1 on original image
patches3 = view_as_windows(astro, patch_shape)
patches1 = patches3.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb3, _ = kmeans2(patches1, n_filters, minit="points")
fb1 = fb3.reshape((-1,) + patch_shape)
fb1_montage = montage2d(fb1, rescale_intensity=True)
# -- filterbank2 LGN-like image
astro_dog = ndi.gaussian_filter(astro, 0.5) - ndi.gaussian_filter(astro, 1)
patches2 = view_as_windows(astro_dog, patch_shape)
patches2 = patches2.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb2, _ = kmeans2(patches2, n_filters, minit="points")
fb2 = fb2.reshape((-1,) + patch_shape)
fb2_montage = montage2d(fb2, rescale_intensity=True)
# --
fig, axes = plt.subplots(2, 2, figsize=(7, 6))
ax0, ax1, ax2, ax3 = axes.ravel()
ax0.imshow(astro, cmap=plt.cm.gray)
ax0.set_title("Image (original)")
def plot_weights(weights, num_h_units, num_x_units):
size = int(math.sqrt(num_x_units))
hidden_units = weights.reshape(num_h_units, size, size)
display = montage2d(hidden_units)
plt.imshow(display, cmap='binary')
plt.show()
annotated = locate(data)
plt.title("Augmented")
plt.imshow(annotated)
plt.show()
#%% visualize_results
num_sampl = 30000
predictions = model.predict(
all_masks_gt[:num_sampl, :, :, None], batch_size=32, verbose=1)
cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:num_sampl, 0] >= 0.95)[
0]])).play(gain=3., magnification=5, fr=10)
#%%
cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:num_sampl, 1] >= 0.95)[
0]])).play(gain=3., magnification=5, fr=10)
#%%
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt[:num_sampl] == 0) & (
predictions[:num_sampl, 1] > 0.95))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt[:num_sampl] == 1) & (
predictions[:num_sampl, 0] > 0.95))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where(
(predictions[:num_sampl, 0] > 0.95))[0]].squeeze()))
#%% retrieve and test
json_file = open(json_path, 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights(model_path)
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
loaded_model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=opt,
optimizer=opt,
metrics=['accuracy'])
print("Loaded model from disk")
score = loaded_model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
score = loaded_model.evaluate(x_train, y_train, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#%%
from skimage.util.montage import montage2d
predictions = loaded_model.predict(all_masks_gt, batch_size=32, verbose=1)
#%%
classes = np.argmax(predictions, axis=1)
#%%
pl.imshow(montage2d(all_masks_gt[np.where(
(classes != 2) & ((labels_gt == 2)))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where(
(classes == 1) & ((labels_gt != 1)))[0]].squeeze()))
#%%
cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:, 0] < 0.5)[0]])).play(
gain=3., magnification=5, fr=10)
#%%
pl.imshow(montage2d(all_masks_gt[np.where(
(labels_gt == 2) & (predictions[:, 1] >= 0.05))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where(
(labels_gt == 2) & (predictions[:, 1] > 0.05))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where(
m1 = cm.movie(np.concatenate([cv2.copyMakeBorder(img.T,xx,xx,yy,yy, cv2.BORDER_CONSTANT,0).T[None,:860,:560] for img in m],0))
m1.save('/mnt/ceph/neuro/zebra/05292014Fish1-4/thresholded_components_movie_' + str(ID) + '.hdf5')
#%% load each movie and create a super movie
movies = []
for ID in range(1,41):
print(ID)
movies.append(cm.load('/mnt/ceph/neuro/zebra/05292014Fish1-4/thresholded_components_movie_' + str(ID) + '.hdf5').astype(np.float32))
movies = np.array(movies)
movies = movies.transpose([1,0,3,2])
#%%
montmov = []
from skimage.util.montage import montage2d
for idx,fr in enumerate(movies):
print(idx)
montmov.append(montage2d(fr,grid_shape=(5,8)).astype(np.float32))
movies = []
montmov = np.array(montmov)
montmov = cm.movie(montmov)
#%%
montmov = cm.load('/mnt/ceph/neuro/zebra/05292014Fish1-4/thresholded_components_movie_all.hdf5')
#%% save frames in avi
import tifffile as tiff
for idx,vid_frame in enumerate(montmov):
print(idx)
tiff.imsave('/mnt/ceph/neuro/zebra/05292014Fish1-4/frames/'+str(idx)+'_.tif',vid_frame)
#%% Plane 11
if ploton:
from sklearn.preprocessing import normalize
EDGE_CROP = 16
NB_EPOCHS = 70
GAUSSIAN_NOISE = 0.1
UPSAMPLE_MODE = 'SIMPLE'
# downsampling inside the network
NET_SCALING = None
# downsampling in preprocessing
IMG_SCALING = (1, 1)
# number of validation images to use
VALID_IMG_COUNT = 400
# maximum number of steps_per_epoch in training
MAX_TRAIN_STEPS = 200
AUGMENT_BRIGHTNESS = False
dropout = 0.4
montage_rgb = lambda x: np.stack(
[montage2d(x[:, :, :, i]) for i in range(x.shape[3])], -1)
# get currrent working directory
print()
# print(os.getcwd())
print()
ship_dir = '/home/speri/airbus_detection/'
train_image_dir = os.path.join(ship_dir, 'train_v2')
test_image_dir = os.path.join(ship_dir, 'test_v2')
def multi_rle_encode(img):
labels = label(img[:, :, 0])
return [rle_encode(labels == k) for k in np.unique(labels[labels > 0])]
def test_error_ndim():
arr_error = np.random.randn(1, 2, 3, 4)
montage2d(arr_error)
print(ID)
pl.tight_layout()
#%% predictions for Plan 11
from skimage.util.montage import montage2d
predictions, final_crops = cm.components_evaluation.evaluate_components_CNN(
Ab[()][:, gnb:],
dims,
np.array(gSig).astype(np.int),
model_name='model/cnn_model',
patch_size=50,
loaded_model=None,
isGPU=False)
#%%
idx = np.argsort(predictions[:, 0])[:10] #[[0,1,2,3,5,9]]
Ab_part = Ab[()][:, gnb:][:, idx]
pl.imshow(montage2d(final_crops[idx]))
pl.figure() crd = cm.utils.visualization.plot_contours(
Ab_part.toarray().reshape(tuple(dims)+(-1,), order = 'F').transpose([1,0,2]).\
reshape((dims[1]*dims[0],-1),order = 'F'), cv2.resize(Cn_,tuple(dims[::-1])).T, thr=0.9, vmax = 0.95,
display_numbers=True)
pl.figure() crd = cm.utils.visualization.plot_contours(
Ab_part.toarray().reshape(tuple(dims)+(-1,), order = 'F').transpose([1,0,2]).\
reshape((dims[1]*dims[0],-1),order = 'F'), img, thr=0.9, display_numbers=True, vmax = .001)
#%%
count = 0
for cf, sp_c in zip(Cf[idx + gnb], final_crops[idx]):
pl.subplot(10, 2, 2 * count + 1)
pl.imshow(sp_c[10:-10, 10:-10])
pl.axis('off')
pl.subplot(10, 2, 2 * count + 2)
pl.plot(cf)
ax1.set_title('Band 1')
ax2.matshow(train_images[0,:,:,1])
ax2.set_title('Band 2')
# # Training Overview
# Here we use the montage functionality of skimage to make preview tiles of randomly selected icebergs and ships. This helps us get a better idea about the diversity in the data.
# In[ ]:
fig, (ax1s, ax2s) = plt.subplots(2,2, figsize = (8,8))
obj_list = dict(ships = train_df.query('is_iceberg==0').sample(16).index,
icebergs = train_df.query('is_iceberg==1').sample(16).index)
for ax1, ax2, (obj_type, idx_list) in zip(ax1s, ax2s, obj_list.items()):
ax1.imshow(montage2d(train_images[idx_list,:,:,0]))
ax1.set_title('%s Band 1' % obj_type)
ax1.axis('off')
ax2.imshow(montage2d(train_images[idx_list,:,:,1]))
ax2.set_title('%s Band 2' % obj_type)
ax2.axis('off')
# # Testing Data Overview
# To see how different the test data looks from the training and it looks like the data is much messier (multiple objects, different skews and angles). Clearly we will require some augmentation to do well here
# In[ ]:
fig, (ax1, ax2) = plt.subplots(1,2, figsize = (12,12))
idx_list = test_df.sample(49).index
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights(model_name + '.h5')
print("Loaded model from disk")
return loaded_model.predict(msks, batch_size=32, verbose=1)
predictions = run_classifier(all_masks_gt)
#%% show results classifier
pl.figure(figsize=(20, 30))
is_positive = 0
for a in grouper(100, np.where(predictions[:, is_positive] > .95)[0]):
a_ = [aa for aa in a if aa is not None]
img_mont_ = all_masks_gt[np.array(a_)].squeeze()
shps_img = img_mont_.shape
img_mont = montage2d(img_mont_)
shps_img_mont = np.array(img_mont.shape) // 50
pl.imshow(img_mont)
inp = pl.pause(.1)
# pl.cla()
break
#%% Curate data. Remove wrong negatives or wrong positives
is_positive = 0 # should be 0 when processing negatives
to_be_checked = np.where(labels_gt == is_positive)[0]
wrong = []
count = 0
for a in grouper(50, to_be_checked):
a_ = [aa for aa in a if aa is not None]
loaded_model = model_from_json(loaded_model_json)
loaded_model.load_weights(model_name + '.h5')
print("Loaded model from disk")
return loaded_model.predict(msks, batch_size=32, verbose=1)
predictions = run_classifier(all_masks_gt)
#%% show results classifier
pl.figure(figsize=(20, 30))
is_positive = 0
for a in grouper(100, np.where(predictions[:, is_positive] > .95)[0]):
a_ = [aa for aa in a if aa is not None]
img_mont_ = all_masks_gt[np.array(a_)].squeeze()
shps_img = img_mont_.shape
img_mont = montage2d(img_mont_)
shps_img_mont = np.array(img_mont.shape) // 50
pl.imshow(img_mont)
inp = pl.pause(.1)
# pl.cla()
break
#%% Curate data. Remove wrong negatives or wrong positives
is_positive = 2 # should be 0 when processing negatives
to_be_checked = np.where(labels_gt == is_positive)[0]
to_be_checked = to_be_checked[to_be_checked < 1000]
wrong = []
count = 0
for a in grouper(50, to_be_checked):
a_ = [aa for aa in a if aa is not None]
from skimage.util.shape import view_as_windows
from skimage.util.montage import montage2d
np.random.seed(42)
patch_shape = 8, 8
n_filters = 49
astro = color.rgb2gray(data.astronaut())
# -- filterbank1 on original image
patches1 = view_as_windows(astro, patch_shape)
patches1 = patches1.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb1, _ = kmeans2(patches1, n_filters, minit='points')
fb1 = fb1.reshape((-1, ) + patch_shape)
fb1_montage = montage2d(fb1, rescale_intensity=True)
# -- filterbank2 LGN-like image
astro_dog = ndi.gaussian_filter(astro, .5) - ndi.gaussian_filter(astro, 1)
patches2 = view_as_windows(astro_dog, patch_shape)
patches2 = patches2.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb2, _ = kmeans2(patches2, n_filters, minit='points')
fb2 = fb2.reshape((-1, ) + patch_shape)
fb2_montage = montage2d(fb2, rescale_intensity=True)
# --
fig, axes = plt.subplots(2, 2, figsize=(7, 6))
ax0, ax1, ax2, ax3 = axes.ravel()
ax0.imshow(astro, cmap=plt.cm.gray)
ax0.set_title("Image (original)")
print('The ROI of this pictured is positioned too far left, so that the last clusters areas exceed the image border. This picture will not be processed to clusters.')
break_parentloop = True
elif row_start_stop_cells[row_number, 0] < 0:
print('The ROI of this pictured is positioned too far right, so that the last clusters areas exceed the image border. This picture will not be processed to clusters.')
break_parentloop = True
if break_parentloop:
continue
all_squares = all_squares[1:] # remove first zeroes frame (created just for the vstack to work at the first iteration)
all_squares = np.random.permutation(all_squares)
pad_value = np.mean(im[:cell_size,:cell_size]).astype(int)
reconstructed_im = np.ones((leadingzeros_y-rest_y_u,np.shape(im)[1])) * pad_value
scrambled_image = np.zeros((1, np.shape(im)[1]))
for row_number, sub_im_row in enumerate(sub_im_rows):
shuffled_squares = montage2d(all_squares[:row_start_stop_cells[row_number, 2]], grid_shape=(1,row_start_stop_cells[row_number, 2]))
all_squares = all_squares[row_start_stop_cells[row_number, 2]:]
padded_row = np.pad(shuffled_squares, ((0,0),(row_start_stop_cells[row_number,0],row_start_stop_cells[row_number,1])), 'constant' ,constant_values=pad_value)
scrambled_image = np.vstack((scrambled_image, padded_row))
scrambled_image = scrambled_image[1:]
scrambled_image = np.pad(scrambled_image, ((leadingzeros_y-rest_y_u, np.shape(im)[0]-(leadingzeros_y+nonzero_y+rest_y_d)),(0,0)), 'constant' ,constant_values=pad_value)
#~ imgplot = plt.imshow(scrambled_image, cmap = cm.Greys_r, interpolation='nearest')
#~ plt.show()
toimage(scrambled_image, cmin=0, cmax=255).save(input_folder+path.splitext(pic)[0]+'_cell'+str("%03d" % (cell_size))+'rand.jpg') # use this instead of imsave to avoide rescaling to maximal dynamic range
print('Done!')
loaded_model.load_weights(model_path)
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
loaded_model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=opt,
metrics=['accuracy'])
print("Loaded model from disk")
score = loaded_model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
score = loaded_model.evaluate(x_train, y_train, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#%%
from skimage.util.montage import montage2d
#%%
predictions = loaded_model.predict(all_masks_gt, batch_size=32, verbose=1)
cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:, 1] > 0.1)[0]])).play(
gain=3., magnification=5, fr=10)
#%%
for i in range(3):
pl.subplot(2,2,i+1)
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt ==i) & (
predictions[:, i] < 0.1) & (predictions[:, i] < 0.1))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where(labels_gt == 3)[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where(
predictions[:, 2] <= 0.25)[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt == 3) & (
predictions[:, 3] <= 0.25) & (predictions[:, 3] <= 0.25))[0]].squeeze()))
total_labels = np.array(total_labels)[rand_perm]
np.savez('use_cases/edge-cutter/residual_crops_all_classes.npz',
all_masks_gt=total_crops, labels_gt=total_labels)
#%%
# the data, shuffled and split between train and test sets
with np.load('use_cases/edge-cutter/residual_crops_all_classes.npz') as ld:
all_masks_gt = ld['all_masks_gt']
labels_gt = ld['labels_gt']
#%%
num_sampl = 30000
predictions = loaded_model.predict(
all_masks_gt[:num_sampl, :, :, None], batch_size=32, verbose=1)
#cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:num_sampl,1]<0.1)[0]])).play(gain=3., magnification = 5, fr = 10)
#%%
from skimage.util.montage import montage2d
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt[:num_sampl] == 2) & (
predictions[:num_sampl, 0] <= 0.5))[0]].squeeze()))
#%%
fname_new = '/mnt/ceph/neuro/labeling/neurofinder.03.00.test/images/final_map/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_.mmap'
gSig = [8, 8]
gt_file = os.path.join(os.path.split(fname_new)[0], os.path.split(
fname_new)[1][:-4] + 'match_masks.npz')
base_name = fname_new.split('/')[5]
maxT = 8100
with np.load(gt_file, encoding='latin1') as ld:
print(ld.keys())
locals().update(ld)
A_gt = scipy.sparse.coo_matrix(A_gt[()])
dims = (d1, d2)
C_gt = C_gt[:, :maxT]
YrA_gt = YrA_gt[:, :maxT]
f_gt = f_gt[:, :maxT]
print("Shape of classes in validation dataset {}".format(
data.validation.labels.shape))
#sample image
sample = data.train.images[5].reshape(28, 28)
plt.imshow(sample, cmap='gray')
plt.title('Sample image')
plt.axis('off')
plt.show()
#function to display montage of input data
imgs = data.train.images[0:100]
montage_img = np.zeros([100, 28, 28])
for i in range(len(imgs)):
montage_img[i] = imgs[i].reshape(28, 28)
plt.imshow(montage2d(montage_img), cmap='gray')
plt.title('Sample of imput data')
plt.axis('off')
plt.show()
images = data.train.images
images = np.reshape(images, [images.shape[0], 28, 28])
mean_img = np.mean(images, axis=0)
std_img = np.std(images, axis=0)
plt.imshow(mean_img)
plt.title('Mean image of the data')
plt.colorbar()
plt.axis('off')
plt.show()
metrics=['accuracy'])
print("Loaded model from disk")
score = loaded_model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
score = loaded_model.evaluate(x_train, y_train, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#%%
from skimage.util.montage import montage2d
#%%
predictions = loaded_model.predict(all_masks_gt, batch_size=32, verbose=1)
cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:, 1] > 0.1)[0]])).play(
gain=3., magnification=5, fr=10)
#%%
for i in range(3):
pl.subplot(2, 2, i + 1)
pl.imshow(
montage2d(
all_masks_gt[np.where((labels_gt == i) & (predictions[:, i] < 0.1)
& (predictions[:, i] < 0.1))[0]].squeeze()))
#%%
pl.imshow(montage2d(all_masks_gt[np.where(labels_gt == 3)[0]].squeeze()))
#%%
pl.imshow(
montage2d(all_masks_gt[np.where(predictions[:, 2] <= 0.25)[0]].squeeze()))
#%%
pl.imshow(
montage2d(
all_masks_gt[np.where((labels_gt == 3) & (predictions[:, 3] <= 0.25)
& (predictions[:, 3] <= 0.25))[0]].squeeze()))
rand_perm = np.random.permutation(len(total_crops))
total_crops = np.array(total_crops)[rand_perm]
total_labels = np.array(total_labels)[rand_perm]
np.savez('use_cases/edge-cutter/residual_crops_all_classes.npz',all_masks_gt = total_crops, labels_gt = total_labels)
#%%
# the data, shuffled and split between train and test sets
with np.load('use_cases/edge-cutter/residual_crops_all_classes.npz') as ld:
all_masks_gt = ld['all_masks_gt']
labels_gt = ld['labels_gt']
#%%
num_sampl = 30000
predictions = loaded_model.predict(all_masks_gt[:num_sampl,:,:,None], batch_size=32, verbose=1)
#cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:num_sampl,1]<0.1)[0]])).play(gain=3., magnification = 5, fr = 10)
#%%
from skimage.util.montage import montage2d
pl.imshow(montage2d(all_masks_gt[np.where((labels_gt[:num_sampl]==2)&(predictions[:num_sampl,0]<=0.5))[0]].squeeze()))
#%%
fname_new = '/mnt/ceph/neuro/labeling/neurofinder.03.00.test/images/final_map/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_.mmap'
gSig = [8,8]
gt_file = os.path.join(os.path.split(fname_new)[0], os.path.split(fname_new)[1][:-4] + 'match_masks.npz')
base_name = fname_new.split('/')[5]
maxT = 8100
with np.load(gt_file, encoding = 'latin1') as ld:
print(ld.keys())
locals().update(ld)
A_gt = scipy.sparse.coo_matrix(A_gt[()])
dims = (d1,d2)
C_gt = C_gt[:,:maxT]
YrA_gt = YrA_gt[:,:maxT]
f_gt = f_gt[:,:maxT]
try:
def test_error_ndim():
arr_error = np.random.randn(1, 2, 3, 4)
montage2d(arr_error)
