def main(args):
img = ecvl.ImRead(args.in_img)
augs = ecvl.SequentialAugmentationContainer([
ecvl.AugRotate([-5, 5]),
ecvl.AugMirror(.5),
ecvl.AugFlip(.5),
ecvl.AugGammaContrast([3, 5]),
ecvl.AugAdditiveLaplaceNoise([0, 0.2 * 255]),
ecvl.AugCoarseDropout([0, 0.55], [0.02, 0.1], 0.5),
ecvl.AugAdditivePoissonNoise([0, 40]),
ecvl.AugResizeDim([500, 500]),
])
ecvl.AugmentationParam.SetSeed(0)
augs.Apply(img)
print("Executing ImageToTensor")
t = ecvl.ImageToTensor(img)
t.div_(128)
t.mult_(128)
print("Executing TensorToImage")
img = ecvl.TensorToImage(t)
print("Executing TensorToView")
ecvl.TensorToView(t)
_ = ecvl.AugmentationFactory.create(AUG_TXT)
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugRotate([-5, 5]),
ecvl.AugAdditiveLaplaceNoise([0, 0.2 * 255]),
ecvl.AugCoarseDropout([0, 0.55], [0.02, 0.1], 0),
ecvl.AugAdditivePoissonNoise([0, 40]),
ecvl.AugResizeDim([30, 30]),
])
test_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim([30, 30]),
])
ds_augs = ecvl.DatasetAugmentations([training_augs, None, test_augs])
batch_size = 64
print("Creating a DLDataset")
d = ecvl.DLDataset(args.in_ds, batch_size, ds_augs, ecvl.ColorType.GRAY)
print("Create x and y")
x = Tensor(
[batch_size, d.n_channels_, d.resize_dims_[0], d.resize_dims_[1]])
y = Tensor([batch_size, len(d.classes_)])
# Load a batch of d.batch_size_ images into x and corresponding labels
# into y. Images are resized to the dimensions specified in the
# augmentations chain
print("Executing LoadBatch on training set")
d.LoadBatch(x, y)
# Change colortype and channels
img = ecvl.TensorToImage(x)
img.colortype_ = ecvl.ColorType.GRAY
img.channels_ = "xyc"
# Switch to Test split and load a batch of images
print("Executing LoadBatch on test set")
d.SetSplit(ecvl.SplitType.test)
d.LoadBatch(x, y)
def eddl_load_data_isic(path=None, batch_size=32, debug=True):
"""
:param path: Path to YAML file
:param batch_size: default 32
:param debug: default True
:return: ecvl.DLDataset, x, y
"""
size = [224, 224]
training_augs = ecvl.SequentialAugmentationContainer(
[ecvl.AugResizeDim(size)])
"""
ecvl.AugMirror(.5),
ecvl.AugFlip(.5),
ecvl.AugRotate([-180, 180]),
ecvl.AugAdditivePoissonNoise([0, 10]),
ecvl.AugGammaContrast([0.5, 1.5]),
ecvl.AugGaussianBlur([0, 0.8]),
ecvl.AugCoarseDropout([0, 0.3], [0.02, 0.05], 0.5)
"""
if debug:
print("Applying the following augmentation on train set: resizeDim {}".
format(size))
validation_augs = ecvl.SequentialAugmentationContainer(
[ecvl.AugResizeDim(size)])
if debug:
print(
"Applying the following augmentation on validation set: resizeDim {}"
.format(size))
dataset_augs = ecvl.DatasetAugmentations(
[training_augs, validation_augs, None])
if debug:
print("Reading dataset")
d = ecvl.DLDataset(path, batch_size, dataset_augs)
#x = eddlT.create([batch_size, d.n_channels_, size[0], size[1]])
#y = eddlT.create([batch_size, len(d.classes_)])
if debug:
num_samples_train = len(d.GetSplit())
num_batches_train = num_samples_train // batch_size
d.SetSplit(ecvl.SplitType.validation)
num_samples_val = len(d.GetSplit())
num_batches_val = num_samples_val // batch_size
print("User batch size: {} ".format(batch_size))
print("Total number of train samples: {} , in {} batches".format(
num_samples_train, num_batches_train))
print("Total number of validation samples: {} , in {} batches".format(
num_samples_val, num_batches_val))
return d #, x, y
def get_net(net_name='vgg16',
in_size=[256, 256],
num_classes=2,
lr=1e-5,
augs=False,
gpus=[1],
lsb=1,
init=eddl.HeNormal,
dropout=None,
l2_reg=None):
## Network definition
in_ = eddl.Input([3, in_size[0], in_size[1]])
if net_name == 'vgg16':
out = models.VGG16_promort(in_,
num_classes,
init=init,
l2_reg=l2_reg,
dropout=dropout)
else:
print('model %s not available' % net_name)
sys.exit(-1)
net = eddl.Model([in_], [out])
eddl.build(
net,
eddl.rmsprop(lr),
["soft_cross_entropy"],
["categorical_accuracy"],
#eddl.CS_GPU([1,1], mem="low_mem") if gpu else eddl.CS_CPU()
eddl.CS_GPU(gpus, mem="low_mem", lsb=lsb) if gpus else eddl.CS_CPU()
#eddl.CS_GPU(gpus, mem="low_mem") if gpus else eddl.CS_CPU()
)
eddl.summary(net)
eddl.setlogfile(net, "promort_VGG16_classification")
if augs:
## Set augmentations
training_augs = ecvl.SequentialAugmentationContainer(
[ecvl.AugMirror(.5),
ecvl.AugFlip(.5),
ecvl.AugRotate([-10, 10])])
validation_augs = ecvl.SequentialAugmentationContainer([])
dataset_augs = [training_augs, validation_augs, None]
else:
dataset_augs = [None, None, None]
return net, dataset_augs
def UNITOPatho(resolution = 800):
if resolution == 800:
#for 800 micron resolution images
image_size = 1812
ds_file = 'unitopath-public/800/unitopath-public-800.yml'
elif resolution == 7000:
#for 7000 micron resolution images
image_size = 15855
ds_file = 'unitopath-public/7000/unitopath-public-7000.yml'
else:
print(f'Resolution must be 800 or 7000, got {resolution}')
exit(1)
base_augmention = []
while image_size//2 > size[0]:
base_augmention.append(ecvl.AugResizeDim([image_size//2,image_size//2]))
image_size = image_size//2
base_augmention.append(ecvl.AugResizeDim(size))
#Augmentation examples
training_augs = ecvl.SequentialAugmentationContainer( base_augmention + [
ecvl.AugMirror(.5),
ecvl.AugFlip(.5),
ecvl.AugRotate([-180, 180])
])
#Augmentationd for training, validation and test sets
dataset_augs = ecvl.DatasetAugmentations(
[training_augs, None, None]
)
return ecvl.DLDataset(ds_file, batch_size, dataset_augs)
def main(args):
head, ext = os.path.splitext(os.path.basename(args.in_fn))
img = ecvl.ImRead(args.in_fn)
c = ecvl.SequentialAugmentationContainer([ecvl.AugFlip(0.5)])
da = ecvl.DatasetAugmentations([c, None, None])
# some output images should be flipped
for i in range(10):
da.Apply(ecvl.SplitType.training, img)
out_fn = "%s_flip_%d%s" % (head, i, ext)
print("writing", out_fn)
ecvl.ImWrite(out_fn, img)
def main(args):
batch_size = args.batch_size
image_size = args.size, args.size
thresh = 0.5
if args.weights:
os.makedirs(args.weights, exist_ok=True)
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(image_size,
ecvl.InterpolationType.cubic,
gt_interp=ecvl.InterpolationType.nearest),
ecvl.AugMirror(.5),
ecvl.AugFlip(.5),
ecvl.AugRotate([-180, 180]),
ecvl.AugAdditivePoissonNoise([0, 10]),
ecvl.AugGammaContrast([0.5, 1.5]),
ecvl.AugGaussianBlur([0, 0.8]),
ecvl.AugCoarseDropout([0, 0.03], [0.02, 0.05], 0.25),
ecvl.AugToFloat32(255, divisor_gt=255),
ecvl.AugNormalize([0.6681, 0.5301, 0.5247],
[0.1337, 0.1480, 0.1595]), # isic stats
])
validation_test_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(image_size,
ecvl.InterpolationType.cubic,
gt_interp=ecvl.InterpolationType.nearest),
ecvl.AugToFloat32(255, divisor_gt=255),
ecvl.AugNormalize([0.6681, 0.5301, 0.5247],
[0.1337, 0.1480, 0.1595]), # isic stats
])
dataset_augs = ecvl.DatasetAugmentations(
[training_augs, validation_test_augs, validation_test_augs])
print('Reading dataset')
d = ecvl.DLDataset(args.in_ds,
args.batch_size,
dataset_augs,
ctype=ecvl.ColorType.RGB)
num_classes = len(d.classes_) or d.n_channels_gt_
size = d.n_channels_, args.size, args.size
if args.ckpts:
net = eddl.import_net_from_onnx_file(args.ckpts, size)
else:
in_ = eddl.Input(size)
out = Unet(in_, num_classes)
out_sigm = eddl.Sigmoid(out)
net = eddl.Model([in_], [out_sigm])
# model_path = utils.DownloadModel(segmentation_zoo[args.model]['url'], f'{args.model}.onnx', 'model_onnx')
# net = eddl.import_net_from_onnx_file(model_path, size)
# eddl.removeLayer(net, segmentation_zoo[args.model]['to_remove'])
# top = eddl.getLayer(net, segmentation_zoo[args.model]['top'])
#
# out = eddl.Sigmoid(eddl.Conv(top, num_classes, [3, 3], name='last_layer'))
# data_input = eddl.getLayer(net, segmentation_zoo[args.model]['input']) # input of the onnx
# net = eddl.Model([data_input], [out])
loss_name = 'binary_cross_entropy'
metric_name = 'mean_squared_error'
eddl.build(
net, eddl.adam(args.learning_rate), [loss_name], [metric_name],
eddl.CS_GPU(args.gpu, mem="low_mem") if args.gpu else eddl.CS_CPU(),
True)
out = eddl.getOut(net)[0]
# if not args.ckpts:
# eddl.initializeLayer(net, "last_layer")
eddl.summary(net)
eddl.setlogfile(net, 'skin_lesion_segmentation')
x = Tensor([args.batch_size, *size])
y = Tensor([args.batch_size, d.n_channels_gt_, size[1], size[2]])
miou = 0.
if args.train:
num_samples_train = len(d.GetSplit())
num_batches_train = num_samples_train // args.batch_size
num_samples_val = len(d.GetSplit(ecvl.SplitType.validation))
num_batches_val = num_samples_val // args.batch_size
evaluator = utils.Evaluator()
print('Starting training')
for e in range(args.epochs):
d.SetSplit(ecvl.SplitType.training)
eddl.reset_loss(net)
s = d.GetSplit()
random.shuffle(s)
d.split_.training_ = s
d.ResetAllBatches()
for b in range(num_batches_train):
d.LoadBatch(x, y)
# x_ = x.select(["0"])
# x_.normalize_(0, 1)
# x_.mult_(255.)
# x_.save(f'images/train_{e}_{b}.png')
#
# y_ = y.select(["0"])
# # y_.mult_(255.)
# y_.save(f'images/train_gt_{e}_{b}.png')
eddl.train_batch(net, [x], [y])
losses = eddl.get_losses(net)
metrics = eddl.get_metrics(net)
print(
f'Train - epoch [{e + 1}/{args.epochs}] - batch [{b + 1}/{num_batches_train}]'
f' - {loss_name}={losses[0]:.3f} - {metric_name}={metrics[0]:.3f}',
flush=True)
d.SetSplit(ecvl.SplitType.validation)
evaluator.ResetEval()
eddl.reset_loss(net)
for b in range(num_batches_val):
n = 0
print(
f'Validation - epoch [{e + 1}/{args.epochs}] - batch [{b + 1}/{num_batches_val}]'
)
d.LoadBatch(x, y)
eddl.forward(net, [x])
output = eddl.getOutput(out)
for bs in range(args.batch_size):
img = output.select([str(bs)])
gt = y.select([str(bs)])
img_np = np.array(img, copy=False)
gt_np = np.array(gt, copy=False)
iou = evaluator.BinaryIoU(img_np, gt_np, thresh=thresh)
print(f' - IoU: {iou:.3f}', end="", flush=True)
if args.out_dir:
# C++ BinaryIoU modifies image as a side effect
img_np[img_np >= thresh] = 1
img_np[img_np < thresh] = 0
img_t = ecvl.TensorToView(img)
img_t.colortype_ = ecvl.ColorType.GRAY
img_t.channels_ = "xyc"
img.mult_(255.)
# orig_img
orig_img = x.select([str(bs)])
orig_img.mult_(255.)
orig_img_t = ecvl.TensorToImage(orig_img)
orig_img_t.colortype_ = ecvl.ColorType.BGR
orig_img_t.channels_ = "xyc"
tmp, labels = ecvl.Image.empty(), ecvl.Image.empty()
ecvl.CopyImage(img_t, tmp, ecvl.DataType.uint8)
ecvl.ConnectedComponentsLabeling(tmp, labels)
ecvl.CopyImage(labels, tmp, ecvl.DataType.uint8)
contours = ecvl.FindContours(tmp)
ecvl.CopyImage(orig_img_t, tmp, ecvl.DataType.uint8)
tmp_np = np.array(tmp, copy=False)
for cseq in contours:
for c in cseq:
tmp_np[c[0], c[1], 0] = 0
tmp_np[c[0], c[1], 1] = 0
tmp_np[c[0], c[1], 2] = 255
filename = d.samples_[d.GetSplit()[n]].location_[0]
head, tail = os.path.splitext(
os.path.basename(filename))
bname = "%s.png" % head
output_fn = os.path.join(args.out_dir, bname)
ecvl.ImWrite(output_fn, tmp)
if e == 0:
gt_t = ecvl.TensorToView(gt)
gt_t.colortype_ = ecvl.ColorType.GRAY
gt_t.channels_ = "xyc"
gt.mult_(255.)
gt_filename = d.samples_[d.GetSplit()
[n]].label_path_
gt_fn = os.path.join(args.out_dir,
os.path.basename(gt_filename))
ecvl.ImWrite(gt_fn, gt_t)
n += 1
print()
last_miou = evaluator.MIoU()
print(
f'Validation - epoch [{e + 1}/{args.epochs}] - Total MIoU: {last_miou:.3f}'
)
if last_miou > miou:
miou = last_miou
eddl.save_net_to_onnx_file(
net,
os.path.join(args.weights,
f'isic_segm_{args.model}_epoch_{e + 1}.onnx'))
print('Weights saved')
elif args.test:
evaluator = utils.Evaluator()
evaluator.ResetEval()
d.SetSplit(ecvl.SplitType.test)
num_samples_test = len(d.GetSplit())
num_batches_test = num_samples_test // batch_size
for b in range(num_batches_test):
n = 0
print(f'Test - batch [{b + 1}/{num_batches_test}]')
d.LoadBatch(x, y)
eddl.forward(net, [x])
output = eddl.getOutput(out)
for bs in range(args.batch_size):
img = output.select([str(bs)])
gt = y.select([str(bs)])
img_np, gt_np = np.array(img, copy=False), np.array(gt,
copy=False)
iou = evaluator.BinaryIoU(img_np, gt_np, thresh=thresh)
print(f' - IoU: {iou:.3f}', end="", flush=True)
if args.out_dir:
# C++ BinaryIoU modifies image as a side effect
img_np[img_np >= thresh] = 1
img_np[img_np < thresh] = 0
img_t = ecvl.TensorToView(img)
img_t.colortype_ = ecvl.ColorType.GRAY
img_t.channels_ = "xyc"
img.mult_(255.)
# orig_img
orig_img = x.select([str(bs)])
orig_img.mult_(255.)
orig_img_t = ecvl.TensorToImage(orig_img)
orig_img_t.colortype_ = ecvl.ColorType.BGR
orig_img_t.channels_ = "xyc"
tmp, labels = ecvl.Image.empty(), ecvl.Image.empty()
ecvl.CopyImage(img_t, tmp, ecvl.DataType.uint8)
ecvl.ConnectedComponentsLabeling(tmp, labels)
ecvl.CopyImage(labels, tmp, ecvl.DataType.uint8)
contours = ecvl.FindContours(tmp)
ecvl.CopyImage(orig_img_t, tmp, ecvl.DataType.uint8)
tmp_np = np.array(tmp, copy=False)
for cseq in contours:
for c in cseq:
tmp_np[c[0], c[1], 0] = 0
tmp_np[c[0], c[1], 1] = 0
tmp_np[c[0], c[1], 2] = 255
filename = d.samples_[d.GetSplit()[n]].location_[0]
head, tail = os.path.splitext(os.path.basename(filename))
bname = "%s.png" % head
output_fn = os.path.join(args.out_dir, bname)
ecvl.ImWrite(output_fn, tmp)
gt_t = ecvl.TensorToView(gt)
gt_t.colortype_ = ecvl.ColorType.GRAY
gt_t.channels_ = "xyc"
gt.mult_(255.)
gt_filename = d.samples_[d.GetSplit()[n]].label_path_
gt_fn = os.path.join(args.out_dir,
os.path.basename(gt_filename))
ecvl.ImWrite(gt_fn, gt_t)
n += 1
miou = evaluator.MIoU()
print(f'Test - Total MIoU: {miou:.3f}')
def main(args):
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugRotate([-5, 5]),
ecvl.AugAdditiveLaplaceNoise([0, 0.2 * 255]),
ecvl.AugCoarseDropout([0, 0.55], [0.02, 0.1], 0),
ecvl.AugAdditivePoissonNoise([0, 40]),
ecvl.AugToFloat32(255),
])
test_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugToFloat32(255),
])
ecvl.AugmentationParam.SetSeed(0)
ds_augs = ecvl.DatasetAugmentations([training_augs, test_augs])
print("Reading the dataset")
d = ecvl.DLDataset(args.in_ds, args.batch_size, ds_augs,
ecvl.ColorType.GRAY, ecvl.ColorType.none,
args.num_workers, args.queue_ratio, [True, False])
num_batches_training = d.GetNumBatches(ecvl.SplitType.training)
num_batches_test = d.GetNumBatches(ecvl.SplitType.test)
print("n. training batches:", num_batches_training)
print("n. test batches:", num_batches_test)
for i in range(args.epochs):
tm_epoch = time.perf_counter()
print("Starting training")
d.SetSplit(ecvl.SplitType.training)
d.ResetBatch(split=d.current_split_, shuffle=True)
# Spawn the threads
d.Start()
for j in range(num_batches_training):
tm = time.perf_counter()
print(
f"Epoch {i}/{args.epochs-1} (batch {j}/{num_batches_training-1}) - ",
end="")
print(f"|fifo| {d.GetQueueSize()} - ", end="")
samples, x, y = d.GetBatch()
# Sleep to simulate EDDL train_batch
print("sleeping... - ", end="")
d.sleep_for(datetime.timedelta(milliseconds=500))
# eddl.train_batch(net, [x], [y])
elapsed = time.perf_counter() - tm
print(f"Elapsed time: {1e3*elapsed:.3f} ms")
d.Stop()
print("Starting test")
d.SetSplit(ecvl.SplitType.test)
# Reset current split without shuffling
d.ResetBatch(d.current_split_, False)
d.Start()
for j in range(num_batches_test):
tm = time.perf_counter()
print(
f"Test: Epoch {i}/{args.epochs-1} (batch {j}/{num_batches_test-1}) - ",
end="")
print(f"|fifo| {d.GetQueueSize()} - ", end="")
_, x, y = d.GetBatch()
# # Resize net for last batch
# if j == num_batches_test - 1 and x.shape[0] != args.batch_size:
# # last mini-batch could have different size
# net.resize(x.shape[0])
# Sleep to simulate EDDL evaluate_batch
print("sleeping... - ", end="")
d.sleep_for(datetime.timedelta(milliseconds=500))
# eddl.eval_batch(net, [x], [y])
elapsed = time.perf_counter() - tm
print(f"Elapsed time: {1e3*elapsed:.3f} ms")
d.Stop()
elapsed = time.perf_counter() - tm_epoch
print(f"Epoch elapsed time: {elapsed:.3f} s")
def main(args):
num_classes = 1
size = [512, 512] # size of images
thresh = 0.5
best_dice = -1
if args.out_dir:
os.makedirs(args.out_dir, exist_ok=True)
in_ = eddl.Input([1, size[0], size[1]])
out = SegNetBN(in_, num_classes)
out_sigm = eddl.Sigmoid(out)
net = eddl.Model([in_], [out_sigm])
eddl.build(net, eddl.adam(0.0001), ["cross_entropy"],
["mean_squared_error"],
eddl.CS_GPU([1], mem='low_mem') if args.gpu else eddl.CS_CPU())
eddl.summary(net)
eddl.setlogfile(net, "pneumothorax_segmentation_training")
if args.ckpts and os.path.exists(args.ckpts):
print("Loading checkpoints '{}'".format(args.ckpts))
eddl.load(net, args.ckpts, 'bin')
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
ecvl.AugMirror(0.5),
ecvl.AugRotate([-10, 10]),
ecvl.AugBrightness([0, 30]),
ecvl.AugGammaContrast([0, 3]),
])
validation_augs = ecvl.SequentialAugmentationContainer(
[ecvl.AugResizeDim(size)])
dataset_augs = ecvl.DatasetAugmentations(
[training_augs, validation_augs, None])
print("Reading dataset")
d = ecvl.DLDataset(args.in_ds, args.batch_size, dataset_augs,
ecvl.ColorType.GRAY)
# Prepare tensors which store batch
x = Tensor([args.batch_size, d.n_channels_, size[0], size[1]])
y = Tensor([args.batch_size, d.n_channels_gt_, size[0], size[1]])
# Retrieve indices of images with a black ground truth
# which are not include in a split
train_split = d.GetSplit(ecvl.SplitType.training)
val_split = d.GetSplit(ecvl.SplitType.validation)
test_split = d.GetSplit(ecvl.SplitType.test)
all_split = set(train_split + val_split + test_split)
images_list = set(range(len(d.samples_)))
# Obtain images with black ground truth
black_images = images_list - all_split
# Add a 25% of training samples with black ground truth.
num_samples_train = math.floor(len(train_split) * 1.25)
num_batches_train = num_samples_train // args.batch_size
# Add a 25% of validation samples with black ground truth.
num_samples_validation = math.floor(len(val_split) * 1.25)
num_batches_validation = num_samples_validation // args.batch_size
black_images = list(black_images)
black_training = black_images[0:-(num_samples_validation - len(val_split))]
black_validation = black_images[-(num_samples_validation -
len(val_split)):]
indices = list(range(args.batch_size))
evaluator = utils.Evaluator()
print("Starting training")
for e in range(args.epochs):
print("Epoch {:d}/{:d} - Training".format(e + 1, args.epochs),
flush=True)
d.SetSplit(ecvl.SplitType.training)
eddl.reset_loss(net)
s = d.GetSplit()
random.shuffle(s)
d.split_.training_ = s
random.shuffle(black_training)
d.ResetAllBatches()
# Indices to track mask and black vector in PneumothoraxLoadBatch
m_i = 0
b_i = 0
for i, b in enumerate(range(num_batches_train)):
d, images, labels, _, m_i, b_i = PneumothoraxLoadBatch(
d, black_training, m_i, b_i)
x, y = fill_tensors(images, labels, x, y)
x.div_(255.0)
y.div_(255.0)
eddl.train_batch(net, [x], [y], indices)
if i % args.log_interval == 0:
print("Epoch {:d}/{:d} (batch {:d}/{:d}) - ".format(
e + 1, args.epochs, b + 1, num_batches_train),
end="",
flush=True)
eddl.print_loss(net, b)
print()
d.SetSplit(ecvl.SplitType.validation)
evaluator.ResetEval()
print("Epoch %d/%d - Evaluation" % (e + 1, args.epochs), flush=True)
m_i = 0
b_i = 0
for b in range(num_batches_validation):
n = 0
print("Epoch {:d}/{:d} (batch {:d}/{:d}) ".format(
e + 1, args.epochs, b + 1, num_batches_validation),
end="",
flush=True)
d, images, labels, names, m_i, b_i = PneumothoraxLoadBatch(
d, black_validation, m_i, b_i)
x, y = fill_tensors(images, labels, x, y)
x.div_(255.0)
y.div_(255.0)
eddl.forward(net, [x])
output = eddl.getOutput(out_sigm)
# Compute Dice metric and optionally save the output images
for k in range(args.batch_size):
pred = output.select([str(k)])
gt = y.select([str(k)])
pred_np = np.array(pred, copy=False)
gt_np = np.array(gt, copy=False)
# DiceCoefficient modifies image as a side effect
dice = evaluator.DiceCoefficient(pred_np, gt_np, thresh=thresh)
print("- Dice: {:.6f} ".format(dice), end="", flush=True)
if args.out_dir:
# Save original image fused together with prediction and
# ground truth
pred_np *= 255
pred_ecvl = ecvl.TensorToImage(pred)
pred_ecvl.colortype_ = ecvl.ColorType.GRAY
pred_ecvl.channels_ = "xyc"
ecvl.ResizeDim(pred_ecvl, pred_ecvl, (1024, 1024),
ecvl.InterpolationType.nearest)
filename_gt = names[n + 1]
gt_ecvl = ecvl.ImRead(filename_gt,
ecvl.ImReadMode.GRAYSCALE)
filename = names[n]
# Image as BGR
img_ecvl = ecvl.ImRead(filename)
ecvl.Stack([img_ecvl, img_ecvl, img_ecvl], img_ecvl)
img_ecvl.channels_ = "xyc"
img_ecvl.colortype_ = ecvl.ColorType.BGR
image_np = np.array(img_ecvl, copy=False)
pred_np = np.array(pred_ecvl, copy=False)
gt_np = np.array(gt_ecvl, copy=False)
pred_np = pred_np.squeeze()
gt_np = gt_np.squeeze()
# Prediction summed in R channel
image_np[:, :, -1] = np.where(pred_np == 255, pred_np,
image_np[:, :, -1])
# Ground truth summed in G channel
image_np[:, :, 1] = np.where(gt_np == 255, gt_np,
image_np[:, :, 1])
n += 2
head, tail = os.path.splitext(os.path.basename(filename))
bname = "{}.png".format(head)
filepath = os.path.join(args.out_dir, bname)
ecvl.ImWrite(filepath, img_ecvl)
print()
mean_dice = evaluator.MeanMetric()
if mean_dice > best_dice:
print("Saving weights")
eddl.save(
net, "pneumothorax_segnetBN_adam_lr_0.0001_"
"loss_ce_size_512_{}.bin".format(e + 1), "bin")
best_dice = mean_dice
print("Mean Dice Coefficient: {:.6g}".format(mean_dice))
def main(args):
if not ecvl.ECVL_EDDL:
print("No EDDL support - quitting")
sys.exit(0)
img = ecvl.ImRead(args.in_img)
augs = ecvl.SequentialAugmentationContainer([
ecvl.AugCenterCrop(), # Make image square
ecvl.AugRotate([-5, 5]),
ecvl.AugMirror(.5),
ecvl.AugFlip(.5),
ecvl.AugGammaContrast([3, 5]),
ecvl.AugAdditiveLaplaceNoise([0, 0.2 * 255]),
ecvl.AugCoarseDropout([0, 0.55], [0.02, 0.1], 0.5),
ecvl.AugAdditivePoissonNoise([0, 40]),
ecvl.AugResizeDim([500, 500]),
ecvl.AugCenterCrop([224, 224]),
ecvl.AugToFloat32(255),
ecvl.AugNormalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
ecvl.AugmentationParam.SetSeed(0)
print("Applying augmentations")
augs.Apply(img)
print("Executing ImageToTensor")
t = ecvl.ImageToTensor(img)
t.div_(128)
t.mult_(128)
print("Executing TensorToImage")
img = ecvl.TensorToImage(t)
print("Executing TensorToView")
ecvl.TensorToView(t)
print("Applying augmentations (from text)")
newdeal_augs = ecvl.AugmentationFactory.create(AUG_TXT)
newdeal_augs.Apply(img)
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugRotate([-5, 5]),
ecvl.AugAdditiveLaplaceNoise([0, 0.2 * 255]),
ecvl.AugCoarseDropout([0, 0.55], [0.02, 0.1], 0),
ecvl.AugAdditivePoissonNoise([0, 40]),
ecvl.AugResizeDim([30, 30]),
ecvl.AugToFloat32(255),
ecvl.AugNormalize(0.449, 0.226), # mean of imagenet stats
])
test_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim([30, 30]),
ecvl.AugToFloat32(255),
ecvl.AugNormalize(0.449, 0.226), # mean of imagenet stats
])
# number of augmentation containers must match number of dataset splits
ds_augs = ecvl.DatasetAugmentations([training_augs, test_augs])
batch_size = 64
print("Creating a DLDataset")
d = ecvl.DLDataset(args.in_ds, batch_size, ds_augs, ecvl.ColorType.GRAY)
print("Create x and y")
x = Tensor(
[batch_size, d.n_channels_, d.resize_dims_[0], d.resize_dims_[1]])
y = Tensor([batch_size, len(d.classes_)])
# Load a batch of d.batch_size_ images into x and corresponding labels
# into y. Images are resized to the dimensions specified in the
# augmentations chain
print("Executing LoadBatch on training set")
d.LoadBatch(x, y)
# Change colortype and channels
img = ecvl.TensorToImage(x)
img.colortype_ = ecvl.ColorType.GRAY
img.channels_ = "xyc"
# Switch to Test split and load a batch of images
print("Executing LoadBatch on test set")
d.SetSplit(ecvl.SplitType.test)
d.LoadBatch(x, y)
# Save some input images
ecvl.ImWrite("mnist_batch.png", ecvl.MakeGrid(x, 8, False))
ecvl.ImWrite("mnist_batch_normalized.png", ecvl.MakeGrid(x, 8, True))
def classificate(args):
args = dotdict(args)
ckpts_dir = opjoin(settings.TRAINING_DIR, 'ckpts')
outputfile = None
inference = None
train = True if args.mode == 'training' else False
batch_size = args.batch_size if args.mode == 'training' else args.test_batch_size
weight_id = args.weight_id
weight = dj_models.ModelWeights.objects.get(id=weight_id)
if train:
pretrained = None
if weight.pretrained_on:
pretrained = weight.pretrained_on.location
else:
inference_id = args.inference_id
inference = dj_models.Inference.objects.get(id=inference_id)
pretrained = weight.location
save_stdout = sys.stdout
size = [args.input_h, args.input_w] # Height, width
try:
model = bindings.models_binding[args.model_id]
except KeyError:
raise Exception(
f'Model with id: {args.model_id} not found in bindings.py')
try:
dataset_path = str(
dj_models.Dataset.objects.get(id=args.dataset_id).path)
except KeyError:
raise Exception(
f'Dataset with id: {args.dataset_id} not found in bindings.py')
dataset = bindings.dataset_binding.get(args.dataset_id)
if dataset is None and not train:
# Binding does not exist. it's a single image dataset
# Use as dataset "stub" the dataset on which model has been trained
dataset = bindings.dataset_binding.get(weight.dataset_id.id)
elif dataset is None and train:
raise Exception(
f'Dataset with id: {args.dataset_id} not found in bindings.py')
basic_augs = ecvl.SequentialAugmentationContainer(
[ecvl.AugResizeDim(size)])
train_augs = basic_augs
val_augs = basic_augs
test_augs = basic_augs
if args.train_augs:
train_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
ecvl.AugmentationFactory.create(args.train_augs)
])
if args.val_augs:
val_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
ecvl.AugmentationFactory.create(args.val_augs)
])
if args.test_augs:
test_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
ecvl.AugmentationFactory.create(args.test_augs)
])
logging.info('Reading dataset')
print('Reading dataset', flush=True)
dataset = dataset(
dataset_path, batch_size,
ecvl.DatasetAugmentations([train_augs, val_augs, test_augs]))
d = dataset.d
num_classes = dataset.num_classes
in_ = eddl.Input([d.n_channels_, size[0], size[1]])
out = model(in_,
num_classes) # out is already softmaxed in classific models
net = eddl.Model([in_], [out])
if train:
logfile = open(Path(weight.logfile), 'w')
else:
logfile = open(inference.logfile, 'w')
outputfile = open(inference.outputfile, 'w')
with redirect_stdout(logfile):
# Save args to file
print('args: ' + json.dumps(args, indent=2, sort_keys=True),
flush=True)
logging.info('args: ' + json.dumps(args, indent=2, sort_keys=True))
eddl.build(
net, eddl.sgd(args.lr,
0.9), [bindings.losses_binding.get(args.loss)],
[bindings.metrics_binding.get(args.metric)],
eddl.CS_GPU([1], mem='low_mem') if args.gpu else eddl.CS_CPU())
eddl.summary(net)
if pretrained and os.path.exists(pretrained):
eddl.load(net, pretrained)
logging.info('Weights loaded')
# Create tensor for images and labels
images = eddlT.create([batch_size, d.n_channels_, size[0], size[1]])
labels = eddlT.create([batch_size, num_classes])
logging.info(f'Starting {args.mode}')
print(f'Starting {args.mode}', flush=True)
if train:
num_samples_train = len(d.GetSplit(ecvl.SplitType.training))
num_batches_train = num_samples_train // batch_size
num_samples_val = len(d.GetSplit(ecvl.SplitType.validation))
num_batches_val = num_samples_val // batch_size
indices = list(range(batch_size))
for e in range(args.epochs):
eddl.reset_loss(net)
d.SetSplit(ecvl.SplitType.training)
s = d.GetSplit()
random.shuffle(s)
d.split_.training_ = s
d.ResetCurrentBatch()
# total_loss = 0.
# total_metric = 0.
for i in range(num_batches_train):
d.LoadBatch(images, labels)
images.div_(255.0)
eddl.train_batch(net, [images], [labels], indices)
total_loss = net.fiterr[0]
total_metric = net.fiterr[1]
print(
f'Train Epoch: {e + 1}/{args.epochs} [{i + 1}/{num_batches_train}] {net.lout[0].name}'
f'({net.losses[0].name}={total_loss / net.inferenced_samples:1.3f},'
f'{net.metrics[0].name}={total_metric / net.inferenced_samples:1.3f})',
flush=True)
logging.info(
f'Train Epoch: {e + 1}/{args.epochs} [{i + 1}/{num_batches_train}] {net.lout[0].name}'
f'({net.losses[0].name}={total_loss / net.inferenced_samples:1.3f},'
f'{net.metrics[0].name}={total_metric / net.inferenced_samples:1.3f})'
)
eddl.save(net, opjoin(ckpts_dir, f'{weight_id}.bin'))
logging.info('Weights saved')
print('Weights saved', flush=True)
if len(d.split_.validation_) > 0:
logging.info(f'Validation {e}/{args.epochs}')
print(f'Validation {e}/{args.epochs}', flush=True)
d.SetSplit(ecvl.SplitType.validation)
d.ResetCurrentBatch()
for i in range(num_batches_val):
d.LoadBatch(images, labels)
images.div_(255.0)
eddl.eval_batch(net, [images], [labels], indices)
# eddl.evaluate(net, [images], [labels])
total_loss = net.fiterr[0]
total_metric = net.fiterr[1]
print(
f'Val Epoch: {e + 1}/{args.epochs} [{i + 1}/{num_batches_val}] {net.lout[0].name}'
f'({net.losses[0].name}={total_loss / net.inferenced_samples:1.3f},'
f'{net.metrics[0].name}={total_metric / net.inferenced_samples:1.3f})',
flush=True)
logging.info(
f'Val Epoch: {e + 1}/{args.epochs} [{i + 1}/{num_batches_val}] {net.lout[0].name}'
f'({net.losses[0].name}={total_loss / net.inferenced_samples:1.3f},'
f'{net.metrics[0].name}={total_metric / net.inferenced_samples:1.3f})'
)
else:
d.SetSplit(ecvl.SplitType.test)
num_samples_test = len(d.GetSplit())
num_batches_test = num_samples_test // batch_size
preds = np.empty((0, num_classes), np.float64)
for b in range(num_batches_test):
d.LoadBatch(images)
images.div_(255.0)
eddl.forward(net, [images])
print(f'Infer Batch {b + 1}/{num_batches_test}', flush=True)
logging.info(f'Infer Batch {b + 1}/{num_batches_test}')
# print(
# f'Evaluation {b + 1}/{num_batches} {net.lout[0].name}({net.losses[0].name}={total_loss / net.inferenced_samples:1.3f},'
# f'{net.metrics[0].name}={total_metric / net.inferenced_samples:1.3f})')
# logging.info(
# f'Evaluation {b + 1}/{num_batches} {net.lout[0].name}({net.losses[0].name}={total_loss / net.inferenced_samples:1.3f},'
# f'{net.metrics[0].name}={total_metric / net.inferenced_samples:1.3f})')
# Save network predictions
for i in range(batch_size):
pred = np.array(eddlT.select(eddl.getTensor(out), i),
copy=False)
# gt = np.argmax(np.array(labels)[indices])
# pred = np.append(pred, gt).reshape((1, num_classes + 1))
preds = np.append(preds, pred, axis=0)
pred_name = d.samples_[d.GetSplit()[b * batch_size +
i]].location_
# print(f'{pred_name};{pred}')
outputfile.write(f'{pred_name};{pred.tolist()}\n')
outputfile.close()
print('<done>')
logfile.close()
del net
del out
del in_
return
eddl.build(
net,
eddl.adam(0.0001), # Optimizer
["cross_entropy"], # Losses
["categorical_accuracy"], # Metrics
eddl.CS_GPU([1]) # Computing service
)
# Show model architecture
eddl.summary(net)
################
# ECVL DATASET #
################
train_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(shape, ecvl.InterpolationType.nearest),
ecvl.AugRotate([-10, 10])
])
validation_augs = ecvl.SequentialAugmentationContainer(
[ecvl.AugResizeDim(shape, ecvl.InterpolationType.nearest)])
# Set data augmentations for each partition
dataset_augs = ecvl.DatasetAugmentations([train_augs, validation_augs, None])
# Load data from .yml
dataset = ecvl.DLDataset(data_yml_path, batch_size, dataset_augs,
ecvl.ColorType.GRAY)
# Get number of training batches
dataset.SetSplit(ecvl.SplitType.training)
n_train_batches = int(len(dataset.GetSplit()) / batch_size)
# Get number of validation batches
def main(args):
batch_size = args.batch_size
image_size = args.size, args.size
if args.weights:
os.makedirs(args.weights, exist_ok=True)
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(image_size, ecvl.InterpolationType.cubic),
ecvl.AugMirror(.5),
ecvl.AugFlip(.5),
ecvl.AugRotate([-180, 180]),
ecvl.AugAdditivePoissonNoise([0, 10]),
ecvl.AugGammaContrast([0.5, 1.5]),
ecvl.AugGaussianBlur([0, 0.8]),
ecvl.AugCoarseDropout([0, 0.03], [0.02, 0.05], 0.25),
ecvl.AugToFloat32(255),
])
validation_test_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(image_size),
ecvl.AugToFloat32(255),
])
dataset_augs = ecvl.DatasetAugmentations(
[training_augs, validation_test_augs, validation_test_augs])
print('Reading dataset')
d = ecvl.DLDataset(args.in_ds,
args.batch_size,
dataset_augs,
ctype=ecvl.ColorType.RGB)
num_classes = len(d.classes_)
size = d.n_channels_, args.size, args.size
if args.ckpts:
net = eddl.import_net_from_onnx_file(args.ckpts, size)
else:
model_path = utils.DownloadModel(classification_zoo[args.model]['url'],
f'{args.model}.onnx', 'model_onnx')
net = eddl.import_net_from_onnx_file(model_path, size)
eddl.removeLayer(net, classification_zoo[args.model]
['to_remove']) # remove last Linear of resnet
top = eddl.getLayer(
net,
classification_zoo[args.model]['top']) # get flatten of resnet
out = eddl.Softmax(eddl.Dense(top, num_classes, True,
'classifier')) # true is for the bias
data_input = eddl.getLayer(
net, classification_zoo[args.model]['input']) # input of the onnx
net = eddl.Model([data_input], [out])
eddl.build(
net, eddl.adam(args.learning_rate), ['softmax_cross_entropy'],
['accuracy'],
eddl.CS_GPU(args.gpu, mem="low_mem") if args.gpu else eddl.CS_CPU(),
False)
out = eddl.getOut(net)[0]
if not args.ckpts:
eddl.initializeLayer(net, "classifier")
eddl.summary(net)
eddl.setlogfile(net, 'skin_lesion_classification')
x = Tensor([batch_size, *size])
y = Tensor([batch_size, num_classes])
metric_fn = eddl.getMetric('accuracy')
best_accuracy = 0.
if args.train:
num_samples_train = len(d.GetSplit())
num_batches_train = num_samples_train // args.batch_size
num_samples_val = len(d.GetSplit(ecvl.SplitType.validation))
num_batches_val = num_samples_val // args.batch_size
print('Starting training')
for e in range(args.epochs):
if args.out_dir:
current_path = os.path.join(args.out_dir, f'Epoch_{e}')
for c in d.classes_:
c_dir = os.path.join(current_path, c)
os.makedirs(c_dir, exist_ok=True)
d.SetSplit(ecvl.SplitType.training)
eddl.reset_loss(net)
s = d.GetSplit()
random.shuffle(s)
d.split_.training_ = s
d.ResetAllBatches()
for b in range(num_batches_train):
d.LoadBatch(x, y)
eddl.train_batch(net, [x], [y])
losses = eddl.get_losses(net)
metrics = eddl.get_metrics(net)
print(
f'Train - epoch [{e + 1}/{args.epochs}] - batch [{b + 1}/{num_batches_train}]'
f' - loss={losses[0]:.3f} - accuracy={metrics[0]:.3f}',
flush=True)
d.SetSplit(ecvl.SplitType.validation)
values = np.zeros(num_batches_val)
eddl.reset_loss(net)
for b in range(num_batches_val):
n = 0
d.LoadBatch(x, y)
eddl.forward(net, [x])
output = eddl.getOutput(out)
value = metric_fn.value(y, output)
values[b] = value
if args.out_dir:
for k in range(args.batch_size):
result = output.select([str(k)])
target = y.select([str(k)])
result_a = np.array(result, copy=False)
target_a = np.array(target, copy=False)
classe = np.argmax(result_a).item()
gt_class = np.argmax(target_a).item()
single_image = x.select([str(k)])
img_t = ecvl.TensorToView(single_image)
img_t.colortype_ = ecvl.ColorType.BGR
single_image.mult_(255.)
filename = d.samples_[d.GetSplit()[n]].location_[0]
head, tail = os.path.splitext(
os.path.basename(filename))
bname = '{}_gt_class_{}.png'.format(head, gt_class)
cur_path = os.path.join(current_path,
d.classes_[classe], bname)
ecvl.ImWrite(cur_path, img_t)
n += 1
print(
f'Validation - epoch [{e + 1}/{args.epochs}] - batch [{b + 1}/{num_batches_val}] -'
f' accuracy={np.mean(values[:b + 1] / batch_size):.3f}')
last_accuracy = np.mean(values / batch_size)
print(
f'Validation - epoch [{e + 1}/{args.epochs}] - total accuracy={last_accuracy:.3f}'
)
if last_accuracy > best_accuracy:
best_accuracy = last_accuracy
print('Saving weights')
eddl.save_net_to_onnx_file(
net,
f'isic_classification_{args.model}_epoch_{e + 1}.onnx')
elif args.test:
d.SetSplit(ecvl.SplitType.test)
num_samples_test = len(d.GetSplit())
num_batches_test = num_samples_test // batch_size
values = np.zeros(num_batches_test)
eddl.reset_loss(net)
for b in range(num_batches_test):
d.LoadBatch(x, y)
eddl.forward(net, [x])
output = eddl.getOutput(out)
value = metric_fn.value(y, output)
values[b] = value
if args.out_dir:
n = 0
for k in range(args.batch_size):
result = output.select([str(k)])
target = y.select([str(k)])
result_a = np.array(result, copy=False)
target_a = np.array(target, copy=False)
classe = np.argmax(result_a).item()
gt_class = np.argmax(target_a).item()
single_image = x.select([str(k)])
img_t = ecvl.TensorToView(single_image)
img_t.colortype_ = ecvl.ColorType.BGR
single_image.mult_(255.)
filename = d.samples_[d.GetSplit()[n]].location_[0]
head, tail = os.path.splitext(os.path.basename(filename))
bname = "%s_gt_class_%s.png" % (head, gt_class)
cur_path = os.path.join(args.out_dir, d.classes_[classe],
bname)
ecvl.ImWrite(cur_path, img_t)
n += 1
print(
f'Test - batch [{b + 1}/{num_batches_test}] - accuracy={np.mean(values[:b + 1] / batch_size):.3f}'
)
print(f'Test - total accuracy={np.mean(values / batch_size):.3f}')
eddl.build(
net,
eddl.adam(0.0001), # Optimizer
["cross_entropy"], # Losses
["categorical_accuracy"], # Metrics
eddl.CS_GPU([1]), # Computing service
False # To avoid reinitializing the weights
)
# Show model architecture
eddl.summary(net)
################
# ECVL DATASET #
################
test_augs = ecvl.SequentialAugmentationContainer(
[ecvl.AugResizeDim(shape, ecvl.InterpolationType.nearest)])
# Set data augmentations for each partition
dataset_augs = ecvl.DatasetAugmentations([None, None, test_augs])
# Load data from .yml
dataset = ecvl.DLDataset(data_yml_path, batch_size, dataset_augs,
ecvl.ColorType.GRAY)
# Get number of training batches
dataset.SetSplit(ecvl.SplitType.test)
n_batches = int(len(dataset.GetSplit()) / batch_size)
############
# TRAINING #
############
def main(args):
num_classes = 1
size = [192, 192] # size of images
thresh = 0.5
if args.out_dir:
os.makedirs(args.out_dir, exist_ok=True)
in_ = eddl.Input([3, size[0], size[1]])
out = SegNet(in_, num_classes)
out_sigm = eddl.Sigmoid(out)
net = eddl.Model([in_], [out_sigm])
eddl.build(net, eddl.adam(0.0001), ["cross_entropy"],
["mean_squared_error"],
eddl.CS_GPU([1]) if args.gpu else eddl.CS_CPU())
eddl.summary(net)
eddl.setlogfile(net, "skin_lesion_segmentation_inference")
if not os.path.exists(args.ckpts):
raise RuntimeError('Checkpoint "{}" not found'.format(args.ckpts))
eddl.load(net, args.ckpts, "bin")
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
])
test_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
])
dataset_augs = ecvl.DatasetAugmentations([training_augs, None, test_augs])
print("Reading dataset")
d = ecvl.DLDataset(args.in_ds, args.batch_size, dataset_augs)
x = Tensor([args.batch_size, d.n_channels_, size[0], size[1]])
y = Tensor([args.batch_size, d.n_channels_gt_, size[0], size[1]])
print("Testing")
d.SetSplit(ecvl.SplitType.test)
num_samples_test = len(d.GetSplit())
num_batches_test = num_samples_test // args.batch_size
evaluator = utils.Evaluator()
evaluator.ResetEval()
for b in range(num_batches_test):
n = 0
print("Batch {:d}/{:d} ".format(b + 1, num_batches_test),
end="",
flush=True)
d.LoadBatch(x, y)
x.div_(255.0)
y.div_(255.0)
eddl.forward(net, [x])
output = eddl.getOutput(out_sigm)
for k in range(args.batch_size):
img = output.select([str(k)])
gt = y.select([str(k)])
img_np, gt_np = np.array(img, copy=False), np.array(gt, copy=False)
iou = evaluator.BinaryIoU(img_np, gt_np, thresh=thresh)
print("- IoU: %.6g " % iou, end="", flush=True)
if args.out_dir:
# C++ BinaryIoU modifies image as a side effect
img_np[img_np >= thresh] = 1
img_np[img_np < thresh] = 0
img_t = ecvl.TensorToView(img)
img_t.colortype_ = ecvl.ColorType.GRAY
img_t.channels_ = "xyc"
img.mult_(255.)
# orig_img
orig_img = x.select([str(k)])
orig_img.mult_(255.)
orig_img_t = ecvl.TensorToImage(orig_img)
orig_img_t.colortype_ = ecvl.ColorType.BGR
orig_img_t.channels_ = "xyc"
tmp, labels = ecvl.Image.empty(), ecvl.Image.empty()
ecvl.CopyImage(img_t, tmp, ecvl.DataType.uint8)
ecvl.ConnectedComponentsLabeling(tmp, labels)
ecvl.CopyImage(labels, tmp, ecvl.DataType.uint8)
contours = ecvl.FindContours(tmp)
ecvl.CopyImage(orig_img_t, tmp, ecvl.DataType.uint8)
tmp_np = np.array(tmp, copy=False)
for cseq in contours:
for c in cseq:
tmp_np[c[0], c[1], 0] = 0
tmp_np[c[0], c[1], 1] = 0
tmp_np[c[0], c[1], 2] = 255
filename = d.samples_[d.GetSplit()[n]].location_[0]
head, tail = os.path.splitext(os.path.basename(filename))
bname = "%s.png" % head
output_fn = os.path.join(args.out_dir, bname)
ecvl.ImWrite(output_fn, tmp)
gt_t = ecvl.TensorToView(gt)
gt_t.colortype_ = ecvl.ColorType.GRAY
gt_t.channels_ = "xyc"
gt.mult_(255.)
gt_filename = d.samples_[d.GetSplit()[n]].label_path_
gt_fn = os.path.join(args.out_dir,
os.path.basename(gt_filename))
ecvl.ImWrite(gt_fn, gt_t)
n += 1
print()
print("MIoU: %.6g" % evaluator.MeanMetric())
def main(args):
num_classes = 8
size = [224, 224] # size of images
in_ = eddl.Input([3, size[0], size[1]])
out = VGG16(in_, num_classes)
net = eddl.Model([in_], [out])
eddl.build(net, eddl.sgd(0.001, 0.9), ["soft_cross_entropy"],
["categorical_accuracy"],
eddl.CS_GPU([1]) if args.gpu else eddl.CS_CPU())
eddl.summary(net)
eddl.setlogfile(net, "skin_lesion_classification_inference")
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
])
test_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
])
dataset_augs = ecvl.DatasetAugmentations([training_augs, None, test_augs])
print("Reading dataset")
d = ecvl.DLDataset(args.in_ds, args.batch_size, dataset_augs)
if args.out_dir:
for c in d.classes_:
os.makedirs(os.path.join(args.out_dir, c), exist_ok=True)
x = Tensor([args.batch_size, d.n_channels_, size[0], size[1]])
y = Tensor([args.batch_size, len(d.classes_)])
d.SetSplit(ecvl.SplitType.test)
num_samples = len(d.GetSplit())
num_batches = num_samples // args.batch_size
metric = eddl.getMetric("categorical_accuracy")
total_metric = []
if not os.path.exists(args.ckpts):
raise RuntimeError('Checkpoint "{}" not found'.format(args.ckpts))
eddl.load(net, args.ckpts, "bin")
print("Testing")
for b in range(num_batches):
n = 0
print("Batch {:d}/{:d}".format(b + 1, num_batches))
d.LoadBatch(x, y)
x.div_(255.0)
eddl.forward(net, [x])
output = eddl.getOutput(out)
sum_ = 0.0
for j in range(args.batch_size):
result = output.select([str(j)])
target = y.select([str(j)])
ca = metric.value(target, result)
total_metric.append(ca)
sum_ += ca
if args.out_dir:
result_a = np.array(result, copy=False)
target_a = np.array(target, copy=False)
classe = np.argmax(result_a).item()
gt_class = np.argmax(target_a).item()
single_image = x.select([str(j)])
img_t = ecvl.TensorToView(single_image)
img_t.colortype_ = ecvl.ColorType.BGR
single_image.mult_(255.)
filename = d.samples_[d.GetSplit()[n]].location_[0]
head, tail = os.path.splitext(os.path.basename(filename))
bname = "%s_gt_class_%s.png" % (head, gt_class)
cur_path = os.path.join(args.out_dir, d.classes_[classe],
bname)
ecvl.ImWrite(cur_path, img_t)
n += 1
print("categorical_accuracy:", sum_ / args.batch_size)
total_avg = sum(total_metric) / len(total_metric)
print("Total categorical accuracy:", total_avg)
def main(args):
num_classes = 8
size = [224, 224] # size of images
in_ = eddl.Input([3, size[0], size[1]])
out = VGG16(in_, num_classes)
net = eddl.Model([in_], [out])
eddl.build(net, eddl.sgd(0.001, 0.9), ["soft_cross_entropy"],
["categorical_accuracy"],
eddl.CS_GPU([1]) if args.gpu else eddl.CS_CPU())
eddl.summary(net)
eddl.setlogfile(net, "skin_lesion_classification")
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
ecvl.AugMirror(.5),
ecvl.AugFlip(.5),
ecvl.AugRotate([-180, 180]),
ecvl.AugAdditivePoissonNoise([0, 10]),
ecvl.AugGammaContrast([0.5, 1.5]),
ecvl.AugGaussianBlur([0, 0.8]),
ecvl.AugCoarseDropout([0, 0.3], [0.02, 0.05], 0.5)
])
validation_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
])
dataset_augs = ecvl.DatasetAugmentations(
[training_augs, validation_augs, None])
print("Reading dataset")
d = ecvl.DLDataset(args.in_ds, args.batch_size, dataset_augs)
x = Tensor([args.batch_size, d.n_channels_, size[0], size[1]])
y = Tensor([args.batch_size, len(d.classes_)])
num_samples_train = len(d.GetSplit())
num_batches_train = num_samples_train // args.batch_size
d.SetSplit(ecvl.SplitType.validation)
num_samples_val = len(d.GetSplit())
num_batches_val = num_samples_val // args.batch_size
indices = list(range(args.batch_size))
metric = eddl.getMetric("categorical_accuracy")
print("Starting training")
for e in range(args.epochs):
print("Epoch {:d}/{:d} - Training".format(e + 1, args.epochs),
flush=True)
if args.out_dir:
current_path = os.path.join(args.out_dir, "Epoch_%d" % e)
for c in d.classes_:
c_dir = os.path.join(current_path, c)
os.makedirs(c_dir, exist_ok=True)
d.SetSplit(ecvl.SplitType.training)
eddl.reset_loss(net)
total_metric = []
s = d.GetSplit()
random.shuffle(s)
d.split_.training_ = s
d.ResetAllBatches()
for b in range(num_batches_train):
print("Epoch {:d}/{:d} (batch {:d}/{:d}) - ".format(
e + 1, args.epochs, b + 1, num_batches_train),
end="",
flush=True)
d.LoadBatch(x, y)
x.div_(255.0)
tx, ty = [x], [y]
eddl.train_batch(net, tx, ty, indices)
eddl.print_loss(net, b)
print()
print("Saving weights")
eddl.save(net, "isic_classification_checkpoint_epoch_%s.bin" % e,
"bin")
print("Epoch %d/%d - Evaluation" % (e + 1, args.epochs), flush=True)
d.SetSplit(ecvl.SplitType.validation)
for b in range(num_batches_val):
n = 0
print("Epoch {:d}/{:d} (batch {:d}/{:d}) - ".format(
e + 1, args.epochs, b + 1, num_batches_val),
end="",
flush=True)
d.LoadBatch(x, y)
x.div_(255.0)
eddl.forward(net, [x])
output = eddl.getOutput(out)
sum_ = 0.0
for k in range(args.batch_size):
result = output.select([str(k)])
target = y.select([str(k)])
ca = metric.value(target, result)
total_metric.append(ca)
sum_ += ca
if args.out_dir:
result_a = np.array(result, copy=False)
target_a = np.array(target, copy=False)
classe = np.argmax(result_a).item()
gt_class = np.argmax(target_a).item()
single_image = x.select([str(k)])
img_t = ecvl.TensorToView(single_image)
img_t.colortype_ = ecvl.ColorType.BGR
single_image.mult_(255.)
filename = d.samples_[d.GetSplit()[n]].location_[0]
head, tail = os.path.splitext(os.path.basename(filename))
bname = "%s_gt_class_%s.png" % (head, gt_class)
cur_path = os.path.join(current_path, d.classes_[classe],
bname)
ecvl.ImWrite(cur_path, img_t)
n += 1
print("categorical_accuracy:", sum_ / args.batch_size)
total_avg = sum(total_metric) / len(total_metric)
print("Total categorical accuracy:", total_avg)
def main(args):
num_classes = 10
size = [28, 28] # size of images
ctype = ecvl.ColorType.GRAY
in_ = eddl.Input([1, size[0], size[1]])
out = LeNet(in_, num_classes)
net = eddl.Model([in_], [out])
eddl.build(net, eddl.sgd(0.001, 0.9), ["soft_cross_entropy"],
["categorical_accuracy"],
eddl.CS_GPU([1]) if args.gpu else eddl.CS_CPU())
eddl.summary(net)
eddl.setlogfile(net, "mnist")
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugRotate([-5, 5]),
ecvl.AugAdditivePoissonNoise([0, 10]),
ecvl.AugGaussianBlur([0, 0.8]),
ecvl.AugCoarseDropout([0, 0.3], [0.02, 0.05], 0),
])
dataset_augs = ecvl.DatasetAugmentations([training_augs, None, None])
print("Reading dataset")
d = ecvl.DLDataset(args.in_ds, args.batch_size, dataset_augs, ctype)
x_train = Tensor([args.batch_size, d.n_channels_, size[0], size[1]])
y_train = Tensor([args.batch_size, len(d.classes_)])
num_samples = len(d.GetSplit())
num_batches = num_samples // args.batch_size
indices = list(range(args.batch_size))
print("Training")
for i in range(args.epochs):
eddl.reset_loss(net)
s = d.GetSplit()
random.shuffle(s)
d.split_.training_ = s
d.ResetCurrentBatch()
for j in range(num_batches):
print("Epoch %d/%d (batch %d/%d) - " %
(i + 1, args.epochs, j + 1, num_batches),
end="",
flush=True)
d.LoadBatch(x_train, y_train)
x_train.div_(255.0)
tx, ty = [x_train], [y_train]
eddl.train_batch(net, tx, ty, indices)
eddl.print_loss(net, j)
print()
print("Saving weights")
eddl.save(net, "mnist_checkpoint.bin", "bin")
print("Evaluation")
d.SetSplit(ecvl.SplitType.test)
num_samples = len(d.GetSplit())
num_batches = num_samples // args.batch_size
for i in range(num_batches):
print("batch %d / %d - " % (i, num_batches), end="", flush=True)
d.LoadBatch(x_train, y_train)
x_train.div_(255.0)
eddl.evaluate(net, [x_train], [y_train])
def test_dataset():
num_classes = 2
size = [256, 256] # size of images
training_augs = ecvl.SequentialAugmentationContainer([
#ecvl.AugResizeDim(size),
ecvl.AugMirror(.5),
ecvl.AugFlip(.5),
ecvl.AugRotate([-180, 180]),
#ecvl.AugAdditivePoissonNoise([0, 10]),
#ecvl.AugGammaContrast([0.5, 1.5]),
#ecvl.AugGaussianBlur([0, 0.8]),
#ecvl.AugCoarseDropout([0, 0.3], [0.02, 0.05], 0.5),
])
dataset_augs = [training_augs, None, None]
in_ = eddl.Input([3, size[0], size[1]])
out = VGG16(in_, num_classes)
net = eddl.Model([in_], [out])
eddl.build(
net,
eddl.rmsprop(1e-5),
#eddl.sgd(0.001, 0.9),
["soft_cross_entropy"],
["categorical_accuracy"],
eddl.CS_GPU([1], mem="low_mem") # eddl.CS_CPU()
)
eddl.summary(net)
# Read Cassandra password
try:
from private_data import cass_pass
except ImportError:
cass_pass = getpass('Insert Cassandra password: '******'prom', password=cass_pass)
cd = CassandraDataset(ap, ['cassandra_db'])
# Flow 0: read rows from db, create splits and save everything
# Level 0
cd.init_listmanager(table='promort.ids_osk_0',
id_col='patch_id',
split_ncols=1,
num_classes=2,
metatable='promort.metadata_osk_0',
partition_cols=['sample_name', 'sample_rep', 'label'])
cd.read_rows_from_db()
cd.save_rows('/tmp/osk_0_rows.pckl')
cd.init_datatable(table='promort.data_osk_0')
cd.split_setup(batch_size=32,
split_ratios=[7, 2, 1],
max_patches=120000,
augs=[])
cd.save_splits('/tmp/osk_0_splits.pckl')
## Flow 1: read saved rows, create and save splits
#cd.load_rows('/tmp/rows.pckl')
#cd.init_datatable(table='promort.data_osk_0')
#cd.split_setup(batch_size=32, split_ratios=[7,2,1],
# max_patches=120000, augs=[])
#cd.save_splits('/tmp/osk_0_splits.pckl')
## Flow 2: read saved splits
#cd.load_splits('/tmp/osk_0_splits.pckl', batch_size=32, augs=[])
## fit generator
cassandra_fit(cd, net, epochs=1)
# change batch size
cd.set_batchsize(16)
cassandra_fit(cd, net, epochs=1)
# change partitioning and balance
cd.split_setup(max_patches=1000, split_ratios=[10, 1, 1], balance=[2, 1])
cassandra_fit(cd, net, epochs=1)
def main(args):
num_classes = 1
size = [192, 192] # size of images
thresh = 0.5
if args.out_dir:
os.makedirs(args.out_dir, exist_ok=True)
in_ = eddl.Input([3, size[0], size[1]])
out = SegNet(in_, num_classes)
out_sigm = eddl.Sigmoid(out)
net = eddl.Model([in_], [out_sigm])
eddl.build(net, eddl.adam(0.0001), ["cross_entropy"],
["mean_squared_error"],
eddl.CS_GPU([1]) if args.gpu else eddl.CS_CPU())
eddl.summary(net)
eddl.setlogfile(net, "skin_lesion_segmentation")
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
ecvl.AugMirror(0.5),
ecvl.AugFlip(0.5),
ecvl.AugRotate([-180, 180]),
ecvl.AugAdditivePoissonNoise([0, 10]),
ecvl.AugGammaContrast([0.5, 1.5]),
ecvl.AugGaussianBlur([0, 0.8]),
ecvl.AugCoarseDropout([0, 0.3], [0.02, 0.05], 0.5)
])
validation_augs = ecvl.SequentialAugmentationContainer(
[ecvl.AugResizeDim(size)])
dataset_augs = ecvl.DatasetAugmentations(
[training_augs, validation_augs, None])
print("Reading dataset")
d = ecvl.DLDataset(args.in_ds, args.batch_size, dataset_augs)
x = Tensor([args.batch_size, d.n_channels_, size[0], size[1]])
y = Tensor([args.batch_size, d.n_channels_gt_, size[0], size[1]])
num_samples_train = len(d.GetSplit())
num_batches_train = num_samples_train // args.batch_size
d.SetSplit(ecvl.SplitType.validation)
num_samples_validation = len(d.GetSplit())
num_batches_validation = num_samples_validation // args.batch_size
indices = list(range(args.batch_size))
evaluator = utils.Evaluator()
print("Starting training")
for e in range(args.epochs):
print("Epoch {:d}/{:d} - Training".format(e + 1, args.epochs),
flush=True)
d.SetSplit(ecvl.SplitType.training)
eddl.reset_loss(net)
s = d.GetSplit()
random.shuffle(s)
d.split_.training_ = s
d.ResetAllBatches()
for b in range(num_batches_train):
print("Epoch {:d}/{:d} (batch {:d}/{:d}) - ".format(
e + 1, args.epochs, b + 1, num_batches_train),
end="",
flush=True)
d.LoadBatch(x, y)
x.div_(255.0)
y.div_(255.0)
tx, ty = [x], [y]
eddl.train_batch(net, tx, ty, indices)
eddl.print_loss(net, b)
print()
print("Saving weights")
eddl.save(net, "isic_segmentation_checkpoint_epoch_%s.bin" % e, "bin")
d.SetSplit(ecvl.SplitType.validation)
evaluator.ResetEval()
print("Epoch %d/%d - Evaluation" % (e + 1, args.epochs), flush=True)
for b in range(num_batches_validation):
n = 0
print("Epoch {:d}/{:d} (batch {:d}/{:d}) ".format(
e + 1, args.epochs, b + 1, num_batches_validation),
end="",
flush=True)
d.LoadBatch(x, y)
x.div_(255.0)
y.div_(255.0)
eddl.forward(net, [x])
output = eddl.getOutput(out_sigm)
for k in range(args.batch_size):
img = output.select([str(k)])
gt = y.select([str(k)])
img_np = np.array(img, copy=False)
gt_np = np.array(gt, copy=False)
iou = evaluator.BinaryIoU(img_np, gt_np, thresh=thresh)
print("- IoU: %.6g " % iou, end="", flush=True)
if args.out_dir:
# C++ BinaryIoU modifies image as a side effect
img_np[img_np >= thresh] = 1
img_np[img_np < thresh] = 0
img_t = ecvl.TensorToView(img)
img_t.colortype_ = ecvl.ColorType.GRAY
img_t.channels_ = "xyc"
img.mult_(255.)
# orig_img
orig_img = x.select([str(k)])
orig_img.mult_(255.)
orig_img_t = ecvl.TensorToImage(orig_img)
orig_img_t.colortype_ = ecvl.ColorType.BGR
orig_img_t.channels_ = "xyc"
tmp, labels = ecvl.Image.empty(), ecvl.Image.empty()
ecvl.CopyImage(img_t, tmp, ecvl.DataType.uint8)
ecvl.ConnectedComponentsLabeling(tmp, labels)
ecvl.CopyImage(labels, tmp, ecvl.DataType.uint8)
contours = ecvl.FindContours(tmp)
ecvl.CopyImage(orig_img_t, tmp, ecvl.DataType.uint8)
tmp_np = np.array(tmp, copy=False)
for cseq in contours:
for c in cseq:
tmp_np[c[0], c[1], 0] = 0
tmp_np[c[0], c[1], 1] = 0
tmp_np[c[0], c[1], 2] = 255
filename = d.samples_[d.GetSplit()[n]].location_[0]
head, tail = os.path.splitext(os.path.basename(filename))
bname = "%s.png" % head
output_fn = os.path.join(args.out_dir, bname)
ecvl.ImWrite(output_fn, tmp)
if e == 0:
gt_t = ecvl.TensorToView(gt)
gt_t.colortype_ = ecvl.ColorType.GRAY
gt_t.channels_ = "xyc"
gt.mult_(255.)
gt_filename = d.samples_[d.GetSplit()[n]].label_path_
gt_fn = os.path.join(args.out_dir,
os.path.basename(gt_filename))
ecvl.ImWrite(gt_fn, gt_t)
n += 1
print()
print("MIoU: %.6g" % evaluator.MeanMetric())
def main(args):
num_classes = 1
size = [512, 512] # size of images
thresh = 0.5
if args.out_dir:
os.makedirs(args.out_dir, exist_ok=True)
in_ = eddl.Input([1, size[0], size[1]])
out = SegNetBN(in_, num_classes)
out_sigm = eddl.Sigmoid(out)
net = eddl.Model([in_], [out_sigm])
eddl.build(
net,
eddl.adam(0.0001),
["cross_entropy"],
["mean_squared_error"],
eddl.CS_GPU([1]) if args.gpu else eddl.CS_CPU()
)
eddl.summary(net)
eddl.setlogfile(net, "pneumothorax_segmentation_inference")
if not os.path.exists(args.ckpts):
raise RuntimeError('Checkpoint "{}" not found'.format(args.ckpts))
eddl.load(net, args.ckpts, "bin")
training_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
])
test_augs = ecvl.SequentialAugmentationContainer([
ecvl.AugResizeDim(size),
])
dataset_augs = ecvl.DatasetAugmentations([training_augs, None, test_augs])
print("Reading dataset")
d = ecvl.DLDataset(args.in_ds, args.batch_size, dataset_augs,
ecvl.ColorType.GRAY)
x = Tensor([args.batch_size, d.n_channels_, size[0], size[1]])
print("Testing")
d.SetSplit(ecvl.SplitType.test)
num_samples_test = len(d.GetSplit())
num_batches_test = num_samples_test // args.batch_size
evaluator = utils.Evaluator()
evaluator.ResetEval()
for b in range(num_batches_test):
n = 0
print("Batch {:d}/{:d} ".format(
b + 1, num_batches_test), end="", flush=True)
d.LoadBatch(x)
x.div_(255.0)
eddl.forward(net, [x])
if args.out_dir:
output = eddl.getOutput(out_sigm)
for k in range(args.batch_size):
img = output.select([str(k)])
img_I = ecvl.TensorToImage(img)
img_I.colortype_ = ecvl.ColorType.GRAY
img_I.channels_ = "xyc"
ecvl.Threshold(img_I, img_I, thresh, 255)
filename = d.samples_[d.GetSplit()[n]].location_[0]
head, tail = os.path.splitext(os.path.basename(filename))
bname = "{}.png".format(head)
output_fn = os.path.join(args.out_dir, bname)
ecvl.ImWrite(output_fn, img_I)
n += 1
print()
