def load_data(npz_data, valid_only=True, valid_split=0.2, axes='SCZXY'):
if valid_only:
X_val, Y_val = load_training_data(npz_data,
validation_split=valid_split,
axes=axes,
verbose=True)[1]
return X_val, Y_val
else:
(X,
Y), (X_val,
Y_val), axes = load_training_data(npz_data,
validation_split=valid_split,
axes=axes,
verbose=True)
return (X, Y), (X_val, Y_val), axes
def load(path_data, axes, validation_split, patch_size, data_name):
"""Loads the data patches to train.
Parameters
----------
path_data : str
Path to input data
axes : str
Semantic order of the axis in the image
validation_split : float
Ratio of data kept for validation
patch_size : tuple
Size of the patches
Returns
-------
X,Y : np.array
Input data X for training, Ground truth Y for training
X_val, Y_val : np.array
Input data X_val for validation, Ground truth Y_val for validation
"""
# limit GPU available memory
# limit_gpu_memory(fraction=1/2)
data_generation(path_data, axes, patch_size, data_name)
(X, Y), (X_val, Y_val), axes = load_training_data('data/' + data_name + '.npz', validation_split, verbose=True)
return (X, Y), (X_val, Y_val)
def original():
mypath = Path('isonet_psf_1')
mypath.mkdir(exist_ok=True)
# sys.stdout = open(mypath / 'train_stdout.txt', 'w')
# sys.stderr = open(mypath / 'train_stderr.txt', 'w')
(X, Y), (X_val, Y_val), data_axes = load_training_data(
mypath / 'my_training_data.npz', validation_split=0.1)
ax = axes_dict(data_axes)
n_train, n_val = len(X), len(X_val)
image_size = tuple(
X.shape[i]
for i in ((ax['Z'], ax['Y'],
ax['X']) if (ax['Z'] is not None) else (ax['Y'], ax['X'])))
n_dim = len(image_size)
n_channel_in, n_channel_out = X.shape[ax['C']], Y.shape[ax['C']]
print('number of training images:\t', n_train)
print('number of validation images:\t', n_val)
print('image size (%dD):\t\t' % n_dim, image_size)
print('Channels in / out:\t\t', n_channel_in, '/', n_channel_out)
plt.figure(figsize=(10, 4))
plot_some(X_val[:5], Y_val[:5])
plt.suptitle(
'5 example validation patches (top row: source, bottom row: target)')
plt.savefig(mypath / 'train_1.png')
config = Config(data_axes, n_channel_in, n_channel_out, train_epochs=200)
print(config)
vars(config)
model = IsotropicCARE(config, str(mypath / 'my_model'))
history = model.train(X, Y, validation_data=(X_val, Y_val))
print(sorted(list(history.history.keys())))
plt.figure(figsize=(16, 5))
plot_history(history, ['loss', 'val_loss'],
['mse', 'val_mse', 'mae', 'val_mae'])
plt.savefig(mypath / 'train_history.png')
model.load_weights() # load best weights according to validation loss
plt.figure(figsize=(12, 7))
_P = model.keras_model.predict(X_val[:5])
if config.probabilistic:
_P = _P[..., :(_P.shape[-1] // 2)]
plot_some(X_val[:5], Y_val[:5], _P, pmax=99.5)
plt.suptitle('5 example validation patches\n' +
'top row: input (source), ' +
'middle row: target (ground truth), ' +
'bottom row: predicted from source')
plt.tight_layout()
plt.savefig(mypath / 'train_2.png')
model.export_TF()
def load_data_and_model(npz_data, model_name, valid_split=0.2, axes='SCZXY'):
model = CARE(config=None, name=model_name, basedir='models')
X_val, Y_val = load_training_data(npz_data,
validation_split=valid_split,
axes=axes,
verbose=True)[1]
return X_val, Y_val, model
def _create(img_size,img_axes,patch_size,patch_axes):
U,V = (rng.uniform(size=(n_images,)+img_size) for _ in range(2))
X,Y,XYaxes = create_patches (
raw_data = RawData.from_arrays(U,V,img_axes),
patch_size = patch_size,
patch_axes = patch_axes,
n_patches_per_image = n_patches_per_image,
save_file = save_file
)
(_X,_Y), val_data, _XYaxes = load_training_data(save_file,verbose=True)
assert val_data is None
assert _XYaxes[-1 if backend_channels_last else 1] == 'C'
_X,_Y = (move_image_axes(u,fr=_XYaxes,to=XYaxes) for u in (_X,_Y))
assert np.allclose(X,_X,atol=1e-6)
assert np.allclose(Y,_Y,atol=1e-6)
assert set(XYaxes) == set(_XYaxes)
assert load_training_data(save_file,validation_split=0.5)[2] is not None
assert all(len(x)==3 for x in load_training_data(save_file,n_images=3)[0])
def train(self, channels=None, **config_args):
#limit_gpu_memory(fraction=1)
if channels is None:
channels = self.train_channels
for ch in channels:
print("-- Training channel {}...".format(ch))
(X, Y), (X_val, Y_val), axes = load_training_data(
self.get_training_patch_path() /
'CH_{}_training_patches.npz'.format(ch),
validation_split=0.1,
verbose=False)
c = axes_dict(axes)['C']
n_channel_in, n_channel_out = X.shape[c], Y.shape[c]
config = Config(axes,
n_channel_in,
n_channel_out,
train_epochs=self.train_epochs,
train_steps_per_epoch=self.train_steps_per_epoch,
train_batch_size=self.train_batch_size,
**config_args)
# Training
model = CARE(config,
'CH_{}_model'.format(ch),
basedir=pathlib.Path(self.out_dir) / 'models')
# Show learning curve and example validation results
try:
history = model.train(X, Y, validation_data=(X_val, Y_val))
except tf.errors.ResourceExhaustedError:
print(
"ResourceExhaustedError: Aborting...\n Training data too big for GPU. Are other GPU jobs running? Perhaps, reduce batch-size or patch-size?"
)
return
#print(sorted(list(history.history.keys())))
plt.figure(figsize=(16, 5))
plot_history(history, ['loss', 'val_loss'],
['mse', 'val_mse', 'mae', 'val_mae'])
plt.figure(figsize=(12, 7))
_P = model.keras_model.predict(X_val[:5])
plot_some(X_val[:5], Y_val[:5], _P, pmax=99.5, cmap="gray")
plt.suptitle('5 example validation patches\n'
'top row: input (source), '
'middle row: target (ground truth), '
'bottom row: predicted from source')
plt.show()
print("-- Export model for use in Fiji...")
model.export_TF()
print("Done")
def dev(args):
import json
# Load and parse training data
(X,
Y), (X_val,
Y_val), axes = load_training_data(args.train_data,
validation_split=args.valid_split,
axes=args.axes,
verbose=True)
c = axes_dict(axes)['C']
n_channel_in, n_channel_out = X.shape[c], Y.shape[c]
# Model config
print('args.resume: ', args.resume)
if args.resume:
# If resuming, config=None will reload the saved config
config = None
print('Attempting to resume')
elif args.config:
print('loading config from args')
config_args = json.load(open(args.config))
config = Config(**config_args)
else:
config = Config(axes,
n_channel_in,
n_channel_out,
probabilistic=args.prob,
train_steps_per_epoch=args.steps,
train_epochs=args.epochs)
print(vars(config))
# Load or init model
model = CARE(config, args.model_name, basedir='models')
# Training, tensorboard available
history = model.train(X, Y, validation_data=(X_val, Y_val))
# Plot training results
print(sorted(list(history.history.keys())))
plt.figure(figsize=(16, 5))
plot_history(history, ['loss', 'val_loss'],
['mse', 'val_mse', 'mae', 'val_mae'])
plt.savefig(args.model_name + '_training.png')
# Export model to be used w/ csbdeep fiji plugins and KNIME flows
model.export_TF()
def train(Training_source=".",
Training_target=".",
model_name="No_name",
model_path=".",
Visual_validation_after_training=True,
number_of_epochs=100,
patch_size=64,
number_of_patches=10,
Use_Default_Advanced_Parameters=True,
number_of_steps=300,
batch_size=32,
percentage_validation=15):
'''
Main function of the script. Train the model an save in model_path
Parameters
----------
Training_source : (str) Path to the noisy images
Training_target : (str) Path to the GT images
model_name : (str) name of the model
model_path : (str) path of the model
Visual_validation_after_training : (bool) Predict a random image after training
Number_of_epochs : (int) epochs
path_size : (int) patch sizes
number_of_patches : (int) number of patches for each image
User_Default_Advances_Parameters : (bool) Use default parameters for the training
number_of_steps : (int) number of steps
batch_size : (int) batch size
percentage_validation : (int) percentage validation
Return
-------
void
'''
OutputFile = Training_target + "/*.tif"
InputFile = Training_source + "/*.tif"
base = "/content/"
training_data = base + "/my_training_data.npz"
if (Use_Default_Advanced_Parameters):
print("Default advanced parameters enabled")
batch_size = 64
percentage_validation = 10
percentage = percentage_validation / 100
#here we check that no model with the same name already exist, if so delete
if os.path.exists(model_path + '/' + model_name):
shutil.rmtree(model_path + '/' + model_name)
# The shape of the images.
x = imread(InputFile)
y = imread(OutputFile)
print('Loaded Input images (number, width, length) =', x.shape)
print('Loaded Output images (number, width, length) =', y.shape)
print("Parameters initiated.")
# RawData Object
# This object holds the image pairs (GT and low), ensuring that CARE compares corresponding images.
# This file is saved in .npz format and later called when loading the trainig data.
raw_data = data.RawData.from_folder(basepath=base,
source_dirs=[Training_source],
target_dir=Training_target,
axes='CYX',
pattern='*.tif*')
X, Y, XY_axes = data.create_patches(raw_data,
patch_filter=None,
patch_size=(patch_size, patch_size),
n_patches_per_image=number_of_patches)
print('Creating 2D training dataset')
training_path = model_path + "/rawdata"
rawdata1 = training_path + ".npz"
np.savez(training_path, X=X, Y=Y, axes=XY_axes)
# Load Training Data
(X, Y), (X_val,
Y_val), axes = load_training_data(rawdata1,
validation_split=percentage,
verbose=True)
c = axes_dict(axes)['C']
n_channel_in, n_channel_out = X.shape[c], Y.shape[c]
#Show_patches(X,Y)
#Here we automatically define number_of_step in function of training data and batch size
if (Use_Default_Advanced_Parameters):
number_of_steps = int(X.shape[0] / batch_size) + 1
print(number_of_steps)
#Here we create the configuration file
config = Config(axes,
n_channel_in,
n_channel_out,
probabilistic=False,
train_steps_per_epoch=number_of_steps,
train_epochs=number_of_epochs,
unet_kern_size=5,
unet_n_depth=3,
train_batch_size=batch_size,
train_learning_rate=0.0004)
print(config)
vars(config)
# Compile the CARE model for network training
model_training = CARE(config, model_name, basedir=model_path)
if (Visual_validation_after_training):
Cell_executed = 1
import time
start = time.time()
#@markdown ##Start Training
# Start Training
history = model_training.train(X, Y, validation_data=(X_val, Y_val))
print("Training, done.")
if (Visual_validation_after_training):
Predict_a_image(Training_source, Training_target, model_path,
model_training)
# Displaying the time elapsed for training
dt = time.time() - start
min, sec = divmod(dt, 60)
hour, min = divmod(min, 60)
print("Time elapsed:", hour, "hour(s)", min, "min(s)", round(sec),
"sec(s)")
Show_loss_function(history, model_path)
import matplotlib.pyplot as plt
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
# In[2]:
BaseDir = '/home/sancere/Kepler/CurieTrainingDatasets/Dalmiro_Laura/'
NPZdata = 'WingVeinModelUNET.npz'
ModelDir = '/home/sancere/Kepler/CurieDeepLearningModels/Dalmiro_Laura/'
ModelName = 'WingVeinUNET'
load_path = BaseDir + NPZdata
# In[3]:
(X, Y), (X_val, Y_val), axes = load_training_data(load_path,
validation_split=0.05,
verbose=True)
c = axes_dict(axes)['C']
n_channel_in, n_channel_out = X.shape[c], Y.shape[c]
# In[4]:
plt.figure(figsize=(12, 5))
plot_some(X_val[:5], Y_val[:5])
plt.suptitle(
'5 example validation patches (top row: source, bottom row: target)')
# In[5]:
config = config = Config(axes,
def Train(self):
BinaryName = 'BinaryMask/'
RealName = 'RealMask/'
Raw = sorted(glob.glob(self.BaseDir + '/Raw/' + '*.tif'))
Path(self.BaseDir + '/' + BinaryName).mkdir(exist_ok=True)
Path(self.BaseDir + '/' + RealName).mkdir(exist_ok=True)
RealMask = sorted(glob.glob(self.BaseDir + '/' + RealName + '*.tif'))
ValRaw = sorted(glob.glob(self.BaseDir + '/ValRaw/' + '*.tif'))
ValRealMask = sorted(
glob.glob(self.BaseDir + '/ValRealMask/' + '*.tif'))
print('Instance segmentation masks:', len(RealMask))
if len(RealMask) == 0:
print('Making labels')
Mask = sorted(glob.glob(self.BaseDir + '/' + BinaryName + '*.tif'))
for fname in Mask:
image = imread(fname)
Name = os.path.basename(os.path.splitext(fname)[0])
Binaryimage = label(image)
imwrite((self.BaseDir + '/' + RealName + Name + '.tif'),
Binaryimage.astype('uint16'))
Mask = sorted(glob.glob(self.BaseDir + '/' + BinaryName + '*.tif'))
print('Semantic segmentation masks:', len(Mask))
if len(Mask) == 0:
print('Generating Binary images')
RealfilesMask = sorted(
glob.glob(self.BaseDir + '/' + RealName + '*tif'))
for fname in RealfilesMask:
image = imread(fname)
Name = os.path.basename(os.path.splitext(fname)[0])
Binaryimage = image > 0
imwrite((self.BaseDir + '/' + BinaryName + Name + '.tif'),
Binaryimage.astype('uint16'))
if self.GenerateNPZ:
raw_data = RawData.from_folder(
basepath=self.BaseDir,
source_dirs=['Raw/'],
target_dir='BinaryMask/',
axes='ZYX',
)
X, Y, XY_axes = create_patches(
raw_data=raw_data,
patch_size=(self.PatchZ, self.PatchY, self.PatchX),
n_patches_per_image=self.n_patches_per_image,
save_file=self.BaseDir + self.NPZfilename + '.npz',
)
# Training UNET model
if self.TrainUNET:
print('Training UNET model')
load_path = self.BaseDir + self.NPZfilename + '.npz'
(X, Y), (X_val,
Y_val), axes = load_training_data(load_path,
validation_split=0.1,
verbose=True)
c = axes_dict(axes)['C']
n_channel_in, n_channel_out = X.shape[c], Y.shape[c]
config = Config(axes,
n_channel_in,
n_channel_out,
unet_n_depth=self.depth,
train_epochs=self.epochs,
train_batch_size=self.batch_size,
unet_n_first=self.startfilter,
train_loss='mse',
unet_kern_size=self.kern_size,
train_learning_rate=self.learning_rate,
train_reduce_lr={
'patience': 5,
'factor': 0.5
})
print(config)
vars(config)
model = CARE(config,
name='UNET' + self.model_name,
basedir=self.model_dir)
if self.copy_model_dir is not None:
if os.path.exists(self.copy_model_dir + 'UNET' +
self.copy_model_name + '/' +
'weights_now.h5') and os.path.exists(
self.model_dir + 'UNET' +
self.model_name + '/' +
'weights_now.h5') == False:
print('Loading copy model')
model.load_weights(self.copy_model_dir + 'UNET' +
self.copy_model_name + '/' +
'weights_now.h5')
if os.path.exists(self.model_dir + 'UNET' + self.model_name + '/' +
'weights_now.h5'):
print('Loading checkpoint model')
model.load_weights(self.model_dir + 'UNET' + self.model_name +
'/' + 'weights_now.h5')
if os.path.exists(self.model_dir + 'UNET' + self.model_name + '/' +
'weights_last.h5'):
print('Loading checkpoint model')
model.load_weights(self.model_dir + 'UNET' + self.model_name +
'/' + 'weights_last.h5')
if os.path.exists(self.model_dir + 'UNET' + self.model_name + '/' +
'weights_best.h5'):
print('Loading checkpoint model')
model.load_weights(self.model_dir + 'UNET' + self.model_name +
'/' + 'weights_best.h5')
history = model.train(X, Y, validation_data=(X_val, Y_val))
print(sorted(list(history.history.keys())))
plt.figure(figsize=(16, 5))
plot_history(history, ['loss', 'val_loss'],
['mse', 'val_mse', 'mae', 'val_mae'])
if self.TrainSTAR:
print('Training StarDistModel model with', self.backbone,
'backbone')
self.axis_norm = (0, 1, 2)
if self.CroppedLoad == False:
assert len(Raw) > 1, "not enough training data"
print(len(Raw))
rng = np.random.RandomState(42)
ind = rng.permutation(len(Raw))
X_train = list(map(ReadFloat, Raw))
Y_train = list(map(ReadInt, RealMask))
self.Y = [
label(DownsampleData(y, self.DownsampleFactor))
for y in tqdm(Y_train)
]
self.X = [
normalize(DownsampleData(x, self.DownsampleFactor),
1,
99.8,
axis=self.axis_norm) for x in tqdm(X_train)
]
n_val = max(1, int(round(0.15 * len(ind))))
ind_train, ind_val = ind[:-n_val], ind[-n_val:]
self.X_val, self.Y_val = [self.X[i] for i in ind_val
], [self.Y[i] for i in ind_val]
self.X_trn, self.Y_trn = [self.X[i] for i in ind_train
], [self.Y[i] for i in ind_train]
print('number of images: %3d' % len(self.X))
print('- training: %3d' % len(self.X_trn))
print('- validation: %3d' % len(self.X_val))
if self.CroppedLoad:
self.X_trn = self.DataSequencer(Raw,
self.axis_norm,
Normalize=True,
labelMe=False)
self.Y_trn = self.DataSequencer(RealMask,
self.axis_norm,
Normalize=False,
labelMe=True)
self.X_val = self.DataSequencer(ValRaw,
self.axis_norm,
Normalize=True,
labelMe=False)
self.Y_val = self.DataSequencer(ValRealMask,
self.axis_norm,
Normalize=False,
labelMe=True)
self.train_sample_cache = False
print(Config3D.__doc__)
anisotropy = (1, 1, 1)
rays = Rays_GoldenSpiral(self.n_rays, anisotropy=anisotropy)
if self.backbone == 'resnet':
conf = Config3D(
rays=rays,
anisotropy=anisotropy,
backbone=self.backbone,
train_epochs=self.epochs,
train_learning_rate=self.learning_rate,
resnet_n_blocks=self.depth,
train_checkpoint=self.model_dir + self.model_name + '.h5',
resnet_kernel_size=(self.kern_size, self.kern_size,
self.kern_size),
train_patch_size=(self.PatchZ, self.PatchX, self.PatchY),
train_batch_size=self.batch_size,
resnet_n_filter_base=self.startfilter,
train_dist_loss='mse',
grid=(1, 1, 1),
use_gpu=self.use_gpu,
n_channel_in=1)
if self.backbone == 'unet':
conf = Config3D(
rays=rays,
anisotropy=anisotropy,
backbone=self.backbone,
train_epochs=self.epochs,
train_learning_rate=self.learning_rate,
unet_n_depth=self.depth,
train_checkpoint=self.model_dir + self.model_name + '.h5',
unet_kernel_size=(self.kern_size, self.kern_size,
self.kern_size),
train_patch_size=(self.PatchZ, self.PatchX, self.PatchY),
train_batch_size=self.batch_size,
unet_n_filter_base=self.startfilter,
train_dist_loss='mse',
grid=(1, 1, 1),
use_gpu=self.use_gpu,
n_channel_in=1,
train_sample_cache=False)
print(conf)
vars(conf)
Starmodel = StarDist3D(conf,
name=self.model_name,
basedir=self.model_dir)
print(
Starmodel._axes_tile_overlap('ZYX'),
os.path.exists(self.model_dir + self.model_name + '/' +
'weights_now.h5'))
if self.copy_model_dir is not None:
if os.path.exists(self.copy_model_dir + self.copy_model_name +
'/' + 'weights_now.h5') and os.path.exists(
self.model_dir + self.model_name + '/' +
'weights_now.h5') == False:
print('Loading copy model')
Starmodel.load_weights(self.copy_model_dir +
self.copy_model_name + '/' +
'weights_now.h5')
if os.path.exists(self.copy_model_dir + self.copy_model_name +
'/' + 'weights_last.h5') and os.path.exists(
self.model_dir + self.model_name + '/' +
'weights_last.h5') == False:
print('Loading copy model')
Starmodel.load_weights(self.copy_model_dir +
self.copy_model_name + '/' +
'weights_last.h5')
if os.path.exists(self.copy_model_dir + self.copy_model_name +
'/' + 'weights_best.h5') and os.path.exists(
self.model_dir + self.model_name + '/' +
'weights_best.h5') == False:
print('Loading copy model')
Starmodel.load_weights(self.copy_model_dir +
self.copy_model_name + '/' +
'weights_best.h5')
if os.path.exists(self.model_dir + self.model_name + '/' +
'weights_now.h5'):
print('Loading checkpoint model')
Starmodel.load_weights(self.model_dir + self.model_name + '/' +
'weights_now.h5')
if os.path.exists(self.model_dir + self.model_name + '/' +
'weights_last.h5'):
print('Loading checkpoint model')
Starmodel.load_weights(self.model_dir + self.model_name + '/' +
'weights_last.h5')
if os.path.exists(self.model_dir + self.model_name + '/' +
'weights_best.h5'):
print('Loading checkpoint model')
Starmodel.load_weights(self.model_dir + self.model_name + '/' +
'weights_best.h5')
historyStar = Starmodel.train(self.X_trn,
self.Y_trn,
validation_data=(self.X_val,
self.Y_val),
epochs=self.epochs)
print(sorted(list(historyStar.history.keys())))
plt.figure(figsize=(16, 5))
plot_history(historyStar, ['loss', 'val_loss'], [
'dist_relevant_mae', 'val_dist_relevant_mae',
'dist_relevant_mse', 'val_dist_relevant_mse'
])
from csbdeep.models import Config, CARE
from csbdeep.data import RawData
args = ArgumentParser()
args.add_argument("train_data")
args.add_argument("val_data")
args.add_argument("--num_models", default=5)
args.add_argument("--epochs", default=100)
args.add_argument("--steps_per_epoch", default=400)
args.add_argument("--batch_size", default=32)
args.add_argument("--probabilistic", default=1)
args.add_argument("--is_3d", default=False)
args.add_argument("--models_dir", default="care_probabilistic_models")
args = args.parse_args()
tr_data, _, tr_axes = load_training_data(args.train_data, validation_split=0)
val_data, _, val_axes = load_training_data(args.val_data, validation_split=0)
#val_data = np.load(args.val_data)
#val_data = (val_data["X"], val_data["Y"])
#val_axes = tr_axes # we assume that both training and validation data are saved in the same format
is_3d = bool(args.is_3d)
axes = "ZYX" if is_3d else "YX"
n_dim = 3 if is_3d else 2
config = Config(axes,
n_dim=n_dim,
n_channel_in=1,
n_channel_out=1,
probabilistic=int(args.probabilistic),
train_batch_size=int(args.batch_size),
unet_kern_size=3)
type=int,
default=100)
parser.add_argument(
"--model_dir",
help="the directory to store the models in",
default="models")
parser.add_argument(
"--model_name",
help="the name of your model (will be stored in model_dir)",
default="my_model")
parser.add_argument("-p", "--plot", action="store_true", default=True)
args = parser.parse_args()
# Read the npz file, split into training and validation sets
(X, Y), (X_val, Y_val), axes = load_training_data(
os.path.join(args.base_dir, args.input_filename),
validation_split=0.1,
verbose=True)
c = axes_dict(axes)['C']
n_channel_in, n_channel_out = X.shape[c], Y.shape[c]
if args.plot:
plt.figure(figsize=(12, 5))
plot_some(X_val[:5], Y_val[:5])
plt.suptitle(
'5 example validation patches (top row: source, bottom row: target)'
)
plt.show()
# Construct a CARE model, defining its configuration via a Config object
config = Config(
##############
folderName = "data_test_beads" #test: 'data_test'
filename = "patchTest.npz" #test: "patchTest.npz"
modelName = "modelTest" #test: "modelTest"
baseDir = "models" #test: "models" name of the directory containing the model
stepPerEpoch = 100 #test: '100' can be increased considerably for a well-train model (ex: 400)
validationSplit = 0.1 #test: 0.1 Percentage of patches conserved for validation
#################
# TRAINING DATA #
#################
#10% of validation data are used there.
(X_train,
Y_train), (X_val,
Y_val), axes = load_training_data(folderName + '/' + filename,
validation_split=validationSplit,
verbose=True)
#(X_train, Y_train), (X_val,Y_val), axes = load_training_data('data/synthetic_disks/data.npz', validation_split=0.1, verbose=True)
print("axes : ", axes)
c = axes_dict(axes)['C']
n_channel_in, n_channel_out = X_train.shape[c], Y_train.shape[c]
plt.figure(figsize=(12, 5))
plot_some(X_val[:5], Y_val[:5])
plt.suptitle(
'5 example validation patches (top row: source, bottom row: target)')
#################
# Configuration #
def training(self):
#Loading Files and Plot examples
basepath = 'data/'
training_original_dir = 'training/original/'
training_ground_truth_dir = 'training/ground_truth/'
validation_original_dir = 'validation/original/'
validation_ground_truth_dir = 'validation/ground_truth/'
import glob
from skimage import io
from matplotlib import pyplot as plt
training_original_files = sorted(
glob.glob(basepath + training_original_dir + '*.tif'))
training_original_file = io.imread(training_original_files[0])
training_ground_truth_files = sorted(
glob.glob(basepath + training_ground_truth_dir + '*.tif'))
training_ground_truth_file = io.imread(training_ground_truth_files[0])
print("Training dataset's number of files and dimensions: ",
len(training_original_files), training_original_file.shape,
len(training_ground_truth_files),
training_ground_truth_file.shape)
training_size = len(training_original_file)
validation_original_files = sorted(
glob.glob(basepath + validation_original_dir + '*.tif'))
validation_original_file = io.imread(validation_original_files[0])
validation_ground_truth_files = sorted(
glob.glob(basepath + validation_ground_truth_dir + '*.tif'))
validation_ground_truth_file = io.imread(
validation_ground_truth_files[0])
print("Validation dataset's number of files and dimensions: ",
len(validation_original_files), validation_original_file.shape,
len(validation_ground_truth_files),
validation_ground_truth_file.shape)
validation_size = len(validation_original_file)
if training_size == validation_size:
size = training_size
else:
print(
'Training and validation images should be of the same dimensions!'
)
plt.figure(figsize=(16, 4))
plt.subplot(141)
plt.imshow(training_original_file)
plt.subplot(142)
plt.imshow(training_ground_truth_file)
plt.subplot(143)
plt.imshow(validation_original_file)
plt.subplot(144)
plt.imshow(validation_ground_truth_file)
#preparing inputs for NN from pairs of 32bit TIFF image files with intensities in range 0..1. . Run it only once for each new dataset
from csbdeep.data import RawData, create_patches, no_background_patches
training_data = RawData.from_folder(
basepath=basepath,
source_dirs=[training_original_dir],
target_dir=training_ground_truth_dir,
axes='YX',
)
validation_data = RawData.from_folder(
basepath=basepath,
source_dirs=[validation_original_dir],
target_dir=validation_ground_truth_dir,
axes='YX',
)
# pathces will be created further in "data augmentation" step,
# that's why patch size here is the dimensions of images and number of pathes per image is 1
size1 = 64
X, Y, XY_axes = create_patches(
raw_data=training_data,
patch_size=(size1, size1),
patch_filter=no_background_patches(0),
n_patches_per_image=1,
save_file=basepath + 'training.npz',
)
X_val, Y_val, XY_axes = create_patches(
raw_data=validation_data,
patch_size=(size1, size1),
patch_filter=no_background_patches(0),
n_patches_per_image=1,
save_file=basepath + 'validation.npz',
)
#Loading training and validation data into memory
from csbdeep.io import load_training_data
(X, Y), _, axes = load_training_data(basepath + 'training.npz',
verbose=False)
(X_val,
Y_val), _, axes = load_training_data(basepath + 'validation.npz',
verbose=False)
X.shape, Y.shape, X_val.shape, Y_val.shape
from csbdeep.utils import axes_dict
c = axes_dict(axes)['C']
n_channel_in, n_channel_out = X.shape[c], Y.shape[c]
batch = len(
X
) # You should define number of batches according to the available memory
#batch=1
seed = 1
from keras.preprocessing.image import ImageDataGenerator
data_gen_args = dict(samplewise_center=False,
samplewise_std_normalization=False,
zca_whitening=False,
fill_mode='reflect',
rotation_range=30,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
vertical_flip=True
#width_shift_range=0.2,
#height_shift_range=0.2,
)
# training
image_datagen = ImageDataGenerator(**data_gen_args)
mask_datagen = ImageDataGenerator(**data_gen_args)
image_datagen.fit(X, augment=True, seed=seed)
mask_datagen.fit(Y, augment=True, seed=seed)
image_generator = image_datagen.flow(X, batch_size=batch, seed=seed)
mask_generator = mask_datagen.flow(Y, batch_size=batch, seed=seed)
generator = zip(image_generator, mask_generator)
# validation
image_datagen_val = ImageDataGenerator(**data_gen_args)
mask_datagen_val = ImageDataGenerator(**data_gen_args)
image_datagen_val.fit(X_val, augment=True, seed=seed)
mask_datagen_val.fit(Y_val, augment=True, seed=seed)
image_generator_val = image_datagen_val.flow(X_val,
batch_size=batch,
seed=seed)
mask_generator_val = mask_datagen_val.flow(Y_val,
batch_size=batch,
seed=seed)
generator_val = zip(image_generator_val, mask_generator_val)
# plot examples
x, y = generator.__next__()
x_val, y_val = generator_val.__next__()
plt.figure(figsize=(16, 4))
plt.subplot(141)
plt.imshow(x[0, :, :, 0])
plt.subplot(142)
plt.imshow(y[0, :, :, 0])
plt.subplot(143)
plt.imshow(x_val[0, :, :, 0])
plt.subplot(144)
plt.imshow(y_val[0, :, :, 0])
import os
blocks = 2
channels = 16
learning_rate = 0.0004
learning_rate_decay_factor = 0.95
epoch_size_multiplicator = 20 # basically, how often do we decrease learning rate
epochs = 10
#comment='_side' # adds to model_name
import datetime
#model path
model_path = f'models/CSBDeep/model.h5'
if os.path.isfile(model_path):
print('Your model will be overwritten in the next cell')
kernel_size = 3
from csbdeep.models import Config, CARE
from keras import backend as K
best_mae = 1
steps_per_epoch = len(X) * epoch_size_multiplicator
validation_steps = len(X_val) * epoch_size_multiplicator
if 'model' in globals():
del model
if os.path.isfile(model_path):
os.remove(model_path)
for i in range(epochs):
print('Epoch:', i + 1)
learning_rate = learning_rate * learning_rate_decay_factor
config = Config(axes,
n_channel_in,
n_channel_out,
unet_kern_size=kernel_size,
train_learning_rate=learning_rate,
unet_n_depth=blocks,
unet_n_first=channels)
model = CARE(config, '.', basedir='models')
#os.remove('models/config.json')
if i > 0:
model.keras_model.load_weights(model_path)
model.prepare_for_training()
history = model.keras_model.fit_generator(
generator,
validation_data=generator_val,
validation_steps=validation_steps,
epochs=1,
verbose=0,
shuffle=True,
steps_per_epoch=steps_per_epoch)
if history.history['val_mae'][0] < best_mae:
best_mae = history.history['val_mae'][0]
if not os.path.exists('models/'):
os.makedirs('models/')
model.keras_model.save(model_path)
print(f'Validation MAE:{best_mae:.3E}')
del model
K.clear_session()
#model path
model_path = 'models/CSBDeep/model.h5'
config = Config(axes,
n_channel_in,
n_channel_out,
unet_kern_size=kernel_size,
train_learning_rate=learning_rate,
unet_n_depth=blocks,
unet_n_first=channels)
model = CARE(config, '.', basedir='models')
model.keras_model.load_weights(model_path)
model.export_TF()
# coding: utf-8
# In[1]:
from __future__ import print_function, unicode_literals, absolute_import, division
import numpy as np
from tifffile import imread
from csbdeep.utils import axes_dict, plot_some, plot_history
from csbdeep.utils.tf import limit_gpu_memory
from csbdeep.io import load_training_data
from csbdeep.models import Config, ProjectionCARE
# In[2]:
(X, Y), (X_val, Y_val), axes = load_training_data(
'/local/u934/private/v_kapoor/CurieTrainingDatasets/Drosophilla/DenoisingProjection.npz',
validation_split=0.1,
verbose=True)
c = axes_dict(axes)['C']
n_channel_in, n_channel_out = X.shape[c], Y.shape[c]
# In[3]:
# In[4]:
config = Config(axes,
n_channel_in,
n_channel_out,
unet_n_depth=4,
train_epochs=50,
train_steps_per_epoch=400,
print(imgArray[0].shape)
print(labelArray[0].shape)
raw_data = RawData.from_arrays(imgArray, labelArray, axes='YX')
X, Y, XY_axes = create_patches(
raw_data=raw_data,
patch_size=(128, 128, 1),
patch_axes='YXC',
n_patches_per_image=25,
save_file=
'/mnt/AE3205C73205958D/Data/3dliver_local/pc_adult/2d_slices/imagesXY/image_full/mydata_128x128patch.npz'
)
(X, Y), (X_val, Y_val), axes = load_training_data(
'/mnt/AE3205C73205958D/Data/3dliver_local/pc_adult/2d_slices/imagesXY/image_full/mydata_128x128patch.npz',
validation_split=0.1,
verbose=True)
n = 10
print(X[n].shape)
fig = plt.figure()
pl1_x = fig.add_subplot(2, 5, 1)
pl1_x.imshow(X[n][..., 0])
pl1_y = fig.add_subplot(2, 5, 6)
pl1_y.imshow(Y[n][..., 0])
pl2_x = fig.add_subplot(2, 5, 2)
pl2_x.imshow(X[n + 1][..., 0])
pl2_y = fig.add_subplot(2, 5, 7)
pl2_y.imshow(Y[n + 1][..., 0])
pl3_x = fig.add_subplot(2, 5, 3)
pl3_x.imshow(X[n + 2][..., 0])
def train(self, channels=None, **config_args):
# limit_gpu_memory(fraction=1)
if channels is None:
channels = self.train_channels
with Timer("Training"):
for ch in channels:
print("-- Training channel {}...".format(ch))
(X, Y), (X_val, Y_val), axes = load_training_data(
self.get_training_patch_path() /
"CH_{}_training_patches.npz".format(ch),
validation_split=0.1,
verbose=False,
)
c = axes_dict(axes)["C"]
n_channel_in, n_channel_out = X.shape[c], Y.shape[c]
config = Config(
axes,
n_channel_in,
n_channel_out,
train_epochs=self.train_epochs,
train_steps_per_epoch=self.train_steps_per_epoch,
train_batch_size=self.train_batch_size,
probabilistic=self.probabilistic,
**config_args,
)
# Training
# if (
# pathlib.Path(self.out_dir) / "models" / "CH_{}_model".format(ch)
# ).exists():
# print("config there already")
# config = None
model = CARE(
config,
"CH_{}_model".format(ch),
basedir=pathlib.Path(self.out_dir) / "models",
)
# Show learning curve and example validation results
try:
history = model.train(X, Y, validation_data=(X_val, Y_val))
except tf.errors.ResourceExhaustedError:
print(
" >> ResourceExhaustedError: Aborting...\n Training data too big for GPU. Are other GPU jobs running? Perhaps, reduce batch-size or patch-size?"
)
return
except tf.errors.UnknownError:
print(
" >> UnknownError: Aborting...\n No enough memory available on GPU... are other GPU jobs running?"
)
return
# print(sorted(list(history.history.keys())))
plt.figure(figsize=(16, 5))
plot_history(history, ["loss", "val_loss"],
["mse", "val_mse", "mae", "val_mae"])
plt.figure(figsize=(12, 7))
_P = model.keras_model.predict(X_val[:5])
if self.probabilistic:
_P = _P[..., 0]
plot_some(X_val[:5], Y_val[:5], _P, pmax=99.5, cmap="gray")
plt.suptitle("5 example validation patches\n"
"top row: input (source), "
"middle row: target (ground truth), "
"bottom row: predicted from source")
plt.show()
print("-- Export model for use in Fiji...")
model.export_TF()
print("Done")