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 = 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()
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):
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 eddl_validate_DLDataset(model, out, d):
batch_time = AverageMeter('BatchTime', ':6.3f')
total_time = AverageMeter('TotalTime', ':6.3f')
# Use the image resized dims defined by user or default image size for resnet [224,224]
if hasattr(d, 'resize_dims_'):
size = d.resize_dims_
else:
size = [224, 224]
x = Tensor([d.batch_size_, d.n_channels_, size[0], size[1]])
y = Tensor([d.batch_size_, len(d.classes_)])
d.SetSplit(ecvl.SplitType.validation)
num_samples_val = len(d.GetSplit())
num_batches_val = num_samples_val // d.batch_size_
indices = list(range(d.batch_size_))
metric = eddl.getMetric("categorical_accuracy")
print("Start Evaluation: ", flush=True)
total_metric = []
print("Evaluation (validation set)", flush=True)
d.ResetAllBatches()
d.SetSplit(ecvl.SplitType.validation)
end_total = time.time()
batch_time.reset()
end = time.time()
for b in range(num_batches_val):
n = 0
print("(batch {:d}/{:d}) - ".format(b + 1, num_batches_val),
end="",
flush=True)
d.LoadBatch(x, y)
x.div_(255.0)
eddl.forward(model, [x])
output = eddl.getOutput(out)
sum_ = 0.0
for k in range(d.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 = eddlT.select(x, 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
batch_time.update(time.time() - end)
end = time.time()
print("categorical_accuracy:".format(sum_ / d.batch_size_), flush=True)
print(batch_time)
if (num_batches_val > 0):
total_avg = sum(total_metric) / len(total_metric)
print("Total categorical accuracy:{}".format(total_avg), flush=True)
else:
print(
"Warning! \n "
"Please check your validation set size, it might be smaller than the batch size,\n "
"Validation test didn't execute as batch number is 0")
#total_avg = sum(total_metric) / len(total_metric)
#print("Total categorical accuracy:{}".format(total_avg), flush=True)
total_time.update(time.time() - end_total)
print(total_time, flush=True)
return model
def eddl_train_DLDataset(model,
out,
d,
learning_rate=1e-2,
momentum=0.9,
epochs=10,
dynamic_lr=False):
batch_time = AverageMeter('BatchTime', ':6.3f')
total_time = AverageMeter('TotalTime', ':6.3f')
# Use the image resized dims defined by user or default image size for resnet [224,224]
if hasattr(d, 'resize_dims_'):
size = d.resize_dims_
else:
size = [224, 224]
x = Tensor([d.batch_size_, d.n_channels_, size[0], size[1]])
y = Tensor([d.batch_size_, len(d.classes_)])
d.SetSplit(ecvl.SplitType.training)
num_samples_train = len(d.GetSplit())
num_batches_train = num_samples_train // d.batch_size_
d.SetSplit(ecvl.SplitType.validation)
num_samples_val = len(d.GetSplit())
num_batches_val = num_samples_val // d.batch_size_
indices = list(range(d.batch_size_))
metric = eddl.getMetric("categorical_accuracy")
print("Starting training", flush=True)
end_total = time.time()
for e in range(epochs):
if dynamic_lr and (e % 30 == 0) and e > 0:
# every 30 epochs we want to decrease the learning rate value by 0.1
print(
"every 30 epochs we want to decrease the learning rate value by 0.1"
)
learning_rate = learning_rate * 0.1
eddl.setlr(model, [learning_rate, momentum])
print("Epoch {:d}/{:d} - Training".format(e + 1, epochs), flush=True)
d.SetSplit(ecvl.SplitType.training)
eddl.reset_loss(model)
total_metric = []
s = d.GetSplit()
random.shuffle(s)
d.split_.training_ = s
d.ResetAllBatches()
batch_time.reset()
end = time.time()
for b in range(num_batches_train):
print("Epoch {:d}/{:d} (batch {:d}/{:d}) - ".format(
e + 1, epochs, b + 1, num_batches_train),
end="",
flush=True)
d.LoadBatch(x, y)
x.div_(255.0)
tx, ty = [x], [y]
eddl.train_batch(model, tx, ty, indices)
eddl.print_loss(model, b)
batch_time.update(time.time() - end)
end = time.time()
print(batch_time, flush=True)
print()
#print("Saving weights")
#eddl.save(
# net, "isic_classification_checkpoint_epoch_%s.bin" % e, "bin"
#)
print("Epoch %d/%d - Evaluation (validation set)" % (e + 1, epochs),
flush=True)
d.SetSplit(ecvl.SplitType.validation)
batch_time.reset()
end = time.time()
for b in range(num_batches_val):
n = 0
print("Epoch {:d}/{:d} (batch {:d}/{:d}) - ".format(
e + 1, epochs, b + 1, num_batches_val),
end="",
flush=True)
d.LoadBatch(x, y)
x.div_(255.0)
eddl.forward(model, [x])
output = eddl.getOutput(out)
sum_ = 0.0
for k in range(d.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 = eddlT.select(x, 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
batch_time.update(time.time() - end)
end = time.time()
print("batch categorical accuracy:{}".format(sum_ / d.batch_size_),
flush=True)
print(batch_time, flush=True)
if (num_batches_val > 0):
total_avg = sum(total_metric) / len(total_metric)
print("Total categorical accuracy:{}".format(total_avg),
flush=True)
else:
print(
"Warning! \n "
"Please check your validation set size, it might be smaller than the batch size,\n "
"Validation test didn't execute as batch number is 0")
total_time.update(time.time() - end_total)
print(total_time, flush=True)
return model
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)