def main(args):
slide_fn = args.slide_fn
level = args.level
## Load model
net = models.tissue_detector_DNN()
eddl.build(net, eddl.rmsprop(0.00001), ["soft_cross_entropy"],
["categorical_accuracy"],
eddl.CS_GPU() if args.gpu else eddl.CS_CPU())
eddl.load(net, args.weights_fn, "bin")
eddl.summary(net)
## Load Slide
slide_T, s = read_slide(slide_fn, level)
## Compute tissue mask
#len_T = slide_T.getShape()[0]
#bs = args.batch_size
#nb = int(np.ceil((len_T / bs)))
#print ("n. batches: %d" % nb)
#output_l = []
#for b in range(nb):
# start = bs*b
# stop = bs*(b+1) if bs*(b+1) < len_T else len_T
# b_T = slide_T.select(["%d:%d" % (start, stop)])
output_l = eddl.predict(net, [slide_T])
print(output_l)
## Binarize the output
mask = get_mask(output_l, s, args.threshold)
np.save("mask", mask)
def load_model(self, model_weights):
## Load the ANN tissue detector model implemented by using pyeddl
## Create ANN topology (Same used during training phase)
## The model is assumed being trained by using RGB triplets.
net = models.tissue_detector_DNN()
eddl.build(net, eddl.rmsprop(0.00001), ["soft_cross_entropy"],
["categorical_accuracy"],
eddl.CS_GPU() if self.gpu else eddl.CS_CPU())
# Load weights
eddl.load(net, model_weights, "bin")
self.model = net
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):
net_name = "vgg16"
num_classes = 2
size = [256, 256] # size of images
### Parse GPU
if args.gpu:
gpus = [int(i) for i in args.gpu]
else:
gpus = []
print('GPUs mask: %r' % gpus)
### Get Network
net_init = eddl.HeNormal
net, dataset_augs = get_net(net_name='vgg16',
in_size=size,
num_classes=num_classes,
lr=args.lr,
augs=args.augs_on,
gpus=gpus,
lsb=args.lsb,
init=net_init,
dropout=args.dropout,
l2_reg=args.l2_reg)
out = net.layers[-1]
## Load weights if requested
if args.init_weights_fn:
print("Loading initialization weights")
eddl.load(net, args.init_weights_fn)
## Check options
if args.out_dir:
working_dir = "model_cnn_%s_ps.%d_bs_%d_lr_%.2e" % (
net_name, size[0], args.batch_size, args.lr)
res_dir = os.path.join(args.out_dir, working_dir)
try:
os.makedirs(res_dir, exist_ok=True)
except:
print("Directory already exists.")
sys.exit()
########################################
### Set database and read split file ###
########################################
if not args.cassandra_pwd_fn:
cass_pass = getpass('Insert Cassandra password: '******'prom', password=cass_pass)
#cd = CassandraDataset(ap, ['cassandra_db'])
cd = CassandraDataset(ap, ['127.0.0.1'], seed=args.seed)
# Check if file exists
if Path(args.splits_fn).exists():
# Load splits
cd.load_splits(args.splits_fn,
batch_size=args.batch_size,
augs=dataset_augs)
else:
print("Split file %s not found" % args.splits_fn)
sys.exit(-1)
print('Number of batches for each split (train, val, test):',
cd.num_batches)
## validation index check and creation of split indexes lists
if args.val_split_indexes:
n_splits = cd.num_splits
out_indexes = [i for i in args.val_split_indexes if i > (n_splits - 1)]
if out_indexes:
print("Not valid validation split index: %r" % out_indexes)
sys.exit(-1)
val_splits = args.val_split_indexes
test_splits = args.test_split_indexes
train_splits = [
i for i in range(n_splits)
if (i not in val_splits) and (i not in test_splits)
]
num_batches_tr = np.sum([cd.num_batches[i] for i in train_splits])
num_batches_val = np.sum([cd.num_batches[i] for i in val_splits])
print("Train splits: %r" % train_splits)
print("Val splits: %r" % val_splits)
print("Test splits: %r" % test_splits)
else:
num_batches_tr = cd.num_batches[0]
num_batches_val = cd.num_batches[1]
################################
#### Training and evaluation ###
################################
print("Defining metric...", flush=True)
metric_fn = eddl.getMetric("categorical_accuracy")
loss_fn = eddl.getLoss("soft_cross_entropy")
print("Starting training", flush=True)
loss_l = []
acc_l = []
val_loss_l = []
val_acc_l = []
patience_cnt = 0
val_acc_max = 0.0
#### Code used to find best learning rate. Comment it to perform an actual training
if args.find_opt_lr:
max_epochs = args.epochs
lr_start = args.lr
lr_end = args.lr_end
lr_f = lambda x: 10**(np.log10(lr_start) + (
(np.log10(lr_end) - np.log10(lr_start)) / max_epochs) * x)
####
### Main loop across epochs
for e in range(args.epochs):
## SET LT
if args.find_opt_lr:
eddl.setlr(net, [lr_f(e)])
### Training
cd.current_split = 0 ## Set the training split as the current one
print("Epoch {:d}/{:d} - Training".format(e + 1, args.epochs),
flush=True)
cd.rewind_splits(shuffle=True)
eddl.reset_loss(net)
total_metric = []
total_loss = []
### Looping across batches of training data
pbar = tqdm(range(num_batches_tr))
for b_index, b in enumerate(pbar):
if args.val_split_indexes:
x, y = cd.load_batch_cross(not_splits=val_splits + test_splits)
else:
x, y = cd.load_batch()
x.div_(255.0)
tx, ty = [x], [y]
eddl.train_batch(net, tx, ty)
#print bratch train results
instances = (b_index + 1) * args.batch_size
loss = eddl.get_losses(net)[0]
metr = eddl.get_metrics(net)[0]
msg = "Epoch {:d}/{:d} (batch {:d}/{:d}) - loss: {:.3f}, acc: {:.3f}".format(
e + 1, args.epochs, b + 1, num_batches_tr, loss, metr)
pbar.set_postfix_str(msg)
total_loss.append(loss)
total_metric.append(metr)
loss_l.append(np.mean(total_loss))
acc_l.append(np.mean(total_metric))
pbar.close()
### Evaluation on validation set batches
cd.current_split = 1 ## Set validation split as the current one
total_metric = []
total_loss = []
print("Epoch %d/%d - Evaluation" % (e + 1, args.epochs), flush=True)
pbar = tqdm(range(num_batches_val))
for b_index, b in enumerate(pbar):
if args.val_split_indexes:
x, y = cd.load_batch_cross(not_splits=train_splits +
test_splits)
else:
x, y = cd.load_batch()
x.div_(255.0)
eddl.forward(net, [x])
output = eddl.getOutput(out)
sum_ca = 0.0 ## sum of samples accuracy within a batch
sum_ce = 0.0 ## sum of losses within a batch
n = 0
for k in range(x.getShape()[0]):
result = output.select([str(k)])
target = y.select([str(k)])
ca = metric_fn.value(target, result)
ce = loss_fn.value(target, result)
total_metric.append(ca)
total_loss.append(ce)
sum_ca += ca
sum_ce += ce
n += 1
msg = "Epoch {:d}/{:d} (batch {:d}/{:d}) loss: {:.3f}, acc: {:.3f} ".format(
e + 1, args.epochs, b + 1, num_batches_val, (sum_ce / n),
(sum_ca / n))
pbar.set_postfix_str(msg)
pbar.close()
val_batch_acc_avg = np.mean(total_metric)
val_batch_loss_avg = np.mean(total_loss)
val_loss_l.append(val_batch_loss_avg)
val_acc_l.append(val_batch_acc_avg)
print("loss: {:.3f}, acc: {:.3f}, val_loss: {:.3f}, val_acc: {:.3f}\n".
format(loss_l[-1], acc_l[-1], val_loss_l[-1], val_acc_l[-1]))
## Save weights
if args.save_weights:
print("Saving weights")
path = os.path.join(
res_dir, "promort_%s_weights_ep_%s_vacc_%.2f.bin" %
(net_name, e, val_acc_l[-1]))
eddl.save(net, path, "bin")
# Dump history at the end of each epoch so if the job is interrupted data are not lost.
if args.out_dir:
history = {
'loss': loss_l,
'acc': acc_l,
'val_loss': val_loss_l,
'val_acc': val_acc_l
}
pickle.dump(history,
open(os.path.join(res_dir, 'history.pickle'), 'wb'))
### Patience check
if val_acc_l[-1] > val_acc_max:
val_acc_max = val_acc_l[-1]
patience_cnt = 0
else:
patience_cnt += 1
if patience_cnt > args.patience:
## Exit and complete the training
print("Got maximum patience... training completed")
break
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 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
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):
net_name = "vgg16"
num_classes = 2
size = [256, 256] # size of images
### Get Network
net = get_net(in_size=size, num_classes=num_classes, gpu=args.gpu)
out = net.layers[-1]
## Load weights if requested
print("Loading initialization weights")
if args.weights_fn:
weights_fn = args.weights_fn
elif args.weights_path:
weights_fn = get_best_weight_file(args.weights_path)
else:
print("One of --weights_fn or --weights_path is required")
sys.exit(-1)
eddl.load(net, weights_fn)
## Check options
print("Creating output directory...")
working_dir = "%s_%s" % (os.path.basename(
args.splits_fn), os.path.basename(weights_fn))
res_dir = os.path.join(args.out_dir, working_dir)
os.makedirs(res_dir, exist_ok=True)
fn = os.path.join(res_dir, "pred.csv")
fd = open(fn, "w")
fd.write("patch_id,normal_p,tumor_p,normal_gt,tumor_gt\n")
#################################
### Set database to read data ###
#################################
if not args.cassandra_pwd_fn:
cass_pass = getpass('Insert Cassandra password: '******'prom', password=cass_pass)
#cd = CassandraDataset(ap, ['cassandra_db'])
cd = CassandraDataset(ap, ['127.0.0.1'])
try:
cd.load_splits(args.splits_fn, batch_size=args.batch_size, augs=[])
except:
print("Split file not found")
sys.exit(-1)
print('Number of batches for each split (train, val, test):',
cd.num_batches)
###################
#### Evaluation ###
###################
print("Defining metric...", flush=True)
si = args.split_index
num_batches = cd.num_batches[si]
cd.current_split = si ## Set the current split
cd.rewind_splits(shuffle=False)
rows = cd.row_keys[cd.split[si]]
indexes = cd.current_index[si]
eddl.reset_loss(net)
metric = eddl.getMetric("categorical_accuracy")
### Evaluation on validation set batches
total_metric = []
pbar = tqdm(range(num_batches))
for b_index, b in enumerate(pbar):
ids = rows[indexes - cd.batch_size:indexes]
n = 0
x, y = cd.load_batch()
x.div_(255.0)
eddl.forward(net, [x])
output = eddl.getOutput(out)
sum_ = 0.0
for k in range(x.getShape()[0]):
result = output.select([str(k)])
target = y.select([str(k)])
ca = metric.value(target, result)
total_metric.append(ca)
sum_ += ca
p_id = str(ids[k]['patch_id'])
result_np = result.getdata()[0]
gt_np = target.getdata()[0]
normal_p = result_np[0]
tumor_p = result_np[1]
normal_gt = gt_np[0]
tumor_gt = gt_np[1]
fd.write('%s,%.2f,%.2f,%.2f,%.2f\n' %
(p_id, normal_p, tumor_p, normal_gt, tumor_gt))
n += 1
indexes = cd.current_index[si]
msg = "Batch {:d}/{:d}) - acc: {:.3f} ".format(b + 1, num_batches,
(sum_ / n))
pbar.set_postfix_str(msg)
pbar.close()
fd.close()
total_avg = np.mean(total_metric)
print("Total categorical accuracy: {:.3f}\n".format(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_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)