def run_z(y, x, models):
# Prep data
# model prediction and normalizations output float64
x = np.array(x, dtype='float64')
y = np.array(y, dtype='float64')
axes = 'ZYX'
# Prepare the dict for metrics
d = {
'output': [],
'columns': ['output', 'rmse', 'ssim'],
'id_vars': ['output'],
'var_name': 'metric'
}
# Define comparisons
def get_output(name, y, x):
return [name, np.sqrt(mse(x, y)), ssim(x, y)]
# Normalize GT dynamic range to enable comparisons w/ numbers
yn = util.percentile_norm(y, axes)
# Get the comparison for normalized input im
xn = util.percentile_norm(x, axes)
d['output'].append(get_output('input', yn, xn))
predictions = {'models': ['input', 'N(GT)'], 'ims': [xn, yn]}
for m in models:
model = CARE(config=None, name=m, basedir='models')
restored = model.predict_probabilistic(x, axes, n_tiles=(1, 4, 4))
pred = restored.mean()
y_pred_n = util.percentile_norm(pred, axes)
d['output'].append(get_output(m, yn, y_pred_n))
predictions['models'].append(m)
predictions['ims'].append(y_pred_n)
# Plot a random stack
zix = util.get_randint_ixs(1, len(y))
ims = [[im[zix] for im in predictions['ims']]]
plt.figure(figsize=(16, 10))
plot_some(np.stack(ims), title_list=[predictions['models']])
plt.show()
# Costruct a df for the barplot
df = pd.DataFrame(
d['output'],
columns=d['columns'],
)
df = pd.melt(df, id_vars=d['id_vars'], var_name=d['var_name'])
g = sns.catplot(x='metric',
y='value',
hue='output',
kind='bar',
sharey=False,
data=df)
g.ax.set_ylim(0, 1)
plt.show()
###############
# Show result #
###############
plt.figure(figsize=(16, 10))
plot_some(np.stack([x[imageNumber], restored]),
title_list=[['source image', 'predicted (CARE)']],
pmin=2,
pmax=99.8)
plt.show()
#########################
# Predict probabilistic #
#########################
restored_prob = model.predict_probabilistic(x[imageNumber],
"YX",
normalizer=None) #axes?
plt.figure(figsize=(16, 10))
plot_some(np.stack([restored_prob.mean(),
restored_prob.scale()]),
title_list=[['mean', 'scale']])
plt.show()
######################
# Save the two files #
######################
imsave("restoredImage.tif", restored)
imsave("notRestoredImage.tif", x[imageNumber])
# CSBDeep has a save_tiff_imagej_compatible function that can be used also (TODO: study the difference)
# Sometimes, the images appears grey on ImageJ. It may be because of that.
def predict(self, file_fn, n_tiles=(1, 4, 4), keep_meta=True):
JVM().start()
pixel_reso = get_space_time_resolution(file_fn)
print("Prediction {}".format(file_fn))
print(" -- Using pixel sizes and frame interval", pixel_reso)
ir = bf.ImageReader(file_fn)
reader = ir.rdr
loci_pixel_type = reader.getPixelType()
if loci_pixel_type == 1:
# uint8
dtype = numpy.uint8
elif loci_pixel_type == 3:
# uint16
dtype = numpy.uint16
else:
print(
"Error: Pixel-type not supported. Pixel type must be 8- or 16-bit"
)
return
if self.probabilistic:
dtype = numpy.float32
series = 0
z_size = reader.getSizeZ()
y_size = reader.getSizeY()
x_size = reader.getSizeX()
c_size = reader.getSizeC()
t_size = reader.getSizeT()
z_out_size = int(z_size * self.low_scaling[0])
y_out_size = int(y_size * self.low_scaling[1])
x_out_size = int(x_size * self.low_scaling[2])
if c_size != len(self.train_channels):
print(
" -- Warning: Number of Channels during training and prediction do not match. Using channels {} for prediction"
.format(self.train_channels))
for ch in self.train_channels:
model = CARE(
None,
"CH_{}_model".format(ch),
basedir=pathlib.Path(self.out_dir) / "models",
)
out_channels = 1
if self.probabilistic:
out_channels = 2
res_image_ch = numpy.zeros(
shape=(t_size, z_out_size, out_channels, y_out_size,
x_out_size),
dtype=dtype,
)
print(" -- Predicting channel {}".format(ch))
for t in tqdm(range(t_size), total=t_size):
img_3d = numpy.zeros((z_size, y_size, x_size), dtype=dtype)
for z in range(z_size):
img_3d[z, :, :] = ir.read(series=series,
z=z,
c=ch,
t=t,
rescale=False)
img_3d_ch_ex = rescale(
img_3d,
self.low_scaling,
preserve_range=True,
order=self.order,
multichannel=False,
mode="reflect",
anti_aliasing=True,
)
if not self.probabilistic:
# non-probabilistic
pred = model.predict(img_3d_ch_ex,
axes="ZYX",
n_tiles=n_tiles)
di = numpy.iinfo(dtype)
pred = pred.clip(di.min, di.max).astype(dtype)
res_image_ch[t, :, 0, :, :] = pred
else:
# probabilistic
pred = model.predict_probabilistic(img_3d_ch_ex,
axes="ZYX",
n_tiles=n_tiles)
di = numpy.float32
res_image_ch[t, :, 0, :, :] = pred.mean()
res_image_ch[t, :, 1, :, :] = pred.scale()
if False:
ch_t_out_fn = os.path.join(
os.path.dirname(file_fn),
os.path.splitext(os.path.basename(file_fn))[0] +
"_care_predict_tp{:04d}_ch{}.tif".format(t, ch),
)
print("Saving time-point {} and channel {} to file '{}'".
format(t, ch, ch_t_out_fn))
tifffile.imsave(
ch_t_out_fn,
pred[None, :, None, :, :],
imagej=True,
metadata={"axes": "TZCYX"},
)
ch_out_fn = os.path.join(
os.path.dirname(file_fn),
os.path.splitext(os.path.basename(file_fn))[0] +
"_care_predict_ch{}.tif".format(ch),
)
print(" -- Saving channel {} CARE prediction to file '{}'".format(
ch, ch_out_fn))
if keep_meta:
reso = (
1 / (pixel_reso.X / self.low_scaling[2]),
1 / (pixel_reso.Y / self.low_scaling[1]),
)
spacing = pixel_reso.Z / self.low_scaling[0]
unit = pixel_reso.Xunit
finterval = pixel_reso.T
tifffile.imsave(
ch_out_fn,
res_image_ch,
imagej=True,
resolution=reso,
metadata={
"axes": "TZCYX",
"finterval": finterval,
"spacing": spacing,
"unit": unit,
},
)
else:
tifffile.imsave(ch_out_fn, res_image_ch)
res_image_ch = None # should trigger gc and free the memory
