def main(args): print("reading", args.in_fn) d = ecvl.Dataset(args.in_fn) print("name:", d.name_) print("description:", d.description_) print("classes:", d.classes_) print("features:", d.features_) print("n. samples:", len(d.samples_)) print(" training:", len(d.split_.training_)) print(" validation:", len(d.split_.validation_)) print(" test:", len(d.split_.test_)) print("loading first sample image") print(" location:", d.samples_[0].location_) print(" label_path:", d.samples_[0].label_path_) img = d.samples_[0].LoadImage() out_path = "img0.png" print("saving first sample image as", out_path) ecvl.ImWrite(out_path, img) # check setter for completeness, but why would anyone want to do this? loc = ["/foo/bar"] d.samples_[0].location_ = loc assert d.samples_[0].location_ == loc lp = "/foo/tar" d.samples_[0].label_path_ = lp assert d.samples_[0].label_path_ == lp
def main(args): print("reading", args.in_fn) d = ecvl.Dataset(args.in_fn) print("name:", d.name_) print("description:", d.description_) print("classes:", d.classes_) print("features:", d.features_) print("n. samples:", len(d.samples_)) print("splits:") for s in d.split_: print(f' "{s.split_name_}":') print(f' type: {s.split_type_}') print(f' n. samples: {len(s.samples_indices_)}') print(f' drop last: {s.drop_last_}') print(f' n. batches: {s.num_batches_}') print(f' last batch: {s.last_batch_}') print(f' no label: {s.no_label_}') print(f"current split: {d.current_split_}") print(f"task: {d.task_}") print("loading first sample image") print(" location:", d.samples_[0].location_) print(" label_path:", d.samples_[0].label_path_) img = d.samples_[0].LoadImage() out_path = "img0.png" print("saving first sample image as", out_path) ecvl.ImWrite(out_path, img) # check setter for completeness, but why would anyone want to do this? loc = ["/foo/bar"] d.samples_[0].location_ = loc assert d.samples_[0].location_ == loc lp = "/foo/tar" d.samples_[0].label_path_ = lp assert d.samples_[0].label_path_ == lp
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): head, _ = os.path.splitext(os.path.basename(args.in_fn)) levels = ecvl.OpenSlideGetLevels(args.in_fn) # for each level, extract a region with size = size of the last level dims = [0, 0] + levels[-1] # [x, y, w, h] region to read print("Reading %s" % args.in_fn) for i in range(len(levels)): img = ecvl.OpenSlideRead(args.in_fn, i, dims) out_fn = "%s_level_%d.png" % (head, i) print("Writing %s" % out_fn) ecvl.ImWrite(out_fn, img)
def main(args): head, ext = os.path.splitext(os.path.basename(args.in_fn)) tmp = ecvl.Image.empty() img = ecvl.ImRead(args.in_fn) print("Resizing image by new width, height") ecvl.ResizeDim(img, tmp, [225, 300], ecvl.InterpolationType.nearest) ecvl.ImWrite("%s_resized%s" % (head, ext), tmp) print("Resizing image by scale factor") ecvl.ResizeScale(img, tmp, [2, 2], ecvl.InterpolationType.cubic) ecvl.ImWrite("%s_resized_scale%s" % (head, ext), tmp) print("Flipping image") ecvl.Flip2D(img, tmp) ecvl.ImWrite("%s_flipped%s" % (head, ext), tmp) print("Mirroring image") ecvl.Mirror2D(img, tmp) ecvl.ImWrite("%s_mirrored%s" % (head, ext), tmp) print("Rotating image") ecvl.Rotate2D(img, tmp, 60) ecvl.ImWrite("%s_rotated%s" % (head, ext), tmp) print("Rotating image with scaling and resizing") ecvl.RotateFullImage2D(img, tmp, 60, 1.5) ecvl.ImWrite("%s_rotated_full%s" % (head, ext), tmp) print("Changing color space to gray") ecvl.ChangeColorSpace(img, tmp, ecvl.ColorType.GRAY) ecvl.ImWrite("%s_gray%s" % (head, ext), tmp) print("Calculating Otsu threshold") # image must be gray thr = ecvl.OtsuThreshold(tmp) print(" %d" % thr) print("Applying fixed threshold") ecvl.Threshold(tmp, tmp, thr, 255) ecvl.ImWrite("%s_threshold%s" % (head, ext), tmp) print("Labeling connected components") labels = ecvl.Image.empty() ecvl.ConnectedComponentsLabeling(tmp, labels) ecvl.ImWrite("%s_labels%s" % (head, ext), labels) print("Finding contours") contours = ecvl.FindContours(tmp) print(" [%r ... %r]" % (contours[0], contours[-1])) print("Applying filter") # kernel must be float64, "xyc" and with one color channel kernel = ecvl.Image([3, 3, 1], ecvl.DataType.float64, "xyc", ecvl.ColorType.GRAY) a = np.array(kernel, copy=False) a.fill(0.11) ecvl.Filter2D(img, tmp, kernel) ecvl.ImWrite("%s_filter%s" % (head, ext), tmp) print("Applying separable filter") ecvl.SeparableFilter2D(img, tmp, [1, 2, 1], [1, 0, -1]) ecvl.ImWrite("%s_separable_filter%s" % (head, ext), tmp) print("Blurring with gaussian kernel") ecvl.GaussianBlur(img, tmp, 5, 5, 0.0) ecvl.ImWrite("%s_gaussian_blur%s" % (head, ext), tmp) print("Adding Laplace noise") stddev = 255 * 0.05 ecvl.AdditiveLaplaceNoise(img, tmp, stddev) ecvl.ImWrite("%s_laplace_noise%s" % (head, ext), tmp) print("Adjusting contrast") gamma = 3 ecvl.GammaContrast(img, tmp, gamma) ecvl.ImWrite("%s_gamma_contrast%s" % (head, ext), tmp) print("Setting rectangles to zero (coarse dropout)") prob, drop_size, per_channel = 0.5, 0.1, True ecvl.CoarseDropout(img, tmp, prob, drop_size, per_channel) ecvl.ImWrite("%s_coarse_dropout%s" % (head, ext), tmp) print("Horizontal concatenation") images = [ecvl.ImRead(args.in_fn), ecvl.ImRead(args.in_fn_2)] new_h = int(images[0].dims_[1] / images[1].dims_[1] * images[1].dims_[0]) ecvl.ResizeDim(images[1], images[1], [new_h, images[0].dims_[1]]) ecvl.HConcat(images, tmp) ecvl.ImWrite("hconcat.png", tmp) print("Vertical concatenation") images = [ecvl.ImRead(args.in_fn), ecvl.ImRead(args.in_fn_2)] new_w = int(images[0].dims_[0] / images[1].dims_[0] * images[1].dims_[1]) ecvl.ResizeDim(images[1], images[1], [images[0].dims_[0], new_w]) ecvl.VConcat(images, tmp) ecvl.ImWrite("vconcat.png", tmp) print("Stack along depth dimension") images = [ecvl.ImRead(args.in_fn), ecvl.ImRead(args.in_fn_2)] ecvl.ResizeDim(images[1], images[1], [images[0].dims_[0], images[0].dims_[1]]) ecvl.Stack(images, tmp) print("Morphology") kernel = ecvl.Image([3, 3, 1], ecvl.DataType.uint8, "xyc", ecvl.ColorType.BGR) a = np.array(kernel, copy=False) a.fill(0.11) ecvl.Morphology(img, tmp, ecvl.MorphType.MORPH_BLACKHAT, kernel) ecvl.ImWrite("%s_morphology%s" % (head, ext), tmp) print("Inpaint") ecvl.CopyImage(img, tmp) a = np.array(tmp, copy=False) a[150:200, 100:150, :] = 0 ecvl.ImWrite("%s_inpaint_before%s" % (head, ext), tmp) dims = tmp.dims_[:2] + [1] mask = ecvl.Image(dims, ecvl.DataType.uint8, "xyc", ecvl.ColorType.BGR) b = np.array(mask, copy=False) b.fill(0) b[150:200, 100:150, :] = 1 ecvl.Inpaint(tmp, tmp, mask, 3) ecvl.ImWrite("%s_inpaint_after%s" % (head, ext), tmp) print("Transpose") ecvl.Transpose(img, tmp) ecvl.ImWrite("%s_transpose%s" % (head, ext), tmp) print("GridDistortion") ecvl.GridDistortion(img, tmp) ecvl.ImWrite("%s_grid_distortion%s" % (head, ext), tmp) print("ElasticTransform") ecvl.ElasticTransform(img, tmp) ecvl.ImWrite("%s_elastic_transform%s" % (head, ext), tmp) print("OpticalDistortion") ecvl.OpticalDistortion(img, tmp) ecvl.ImWrite("%s_optical_distortion%s" % (head, ext), tmp) print("Salt") ecvl.Salt(img, tmp, 0.1) ecvl.ImWrite("%s_salt%s" % (head, ext), tmp) print("Pepper") ecvl.Pepper(img, tmp, 0.1) ecvl.ImWrite("%s_pepper%s" % (head, ext), tmp) print("SaltAndPepper") ecvl.SaltAndPepper(img, tmp, 0.1) ecvl.ImWrite("%s_salt_and_pepper%s" % (head, ext), tmp) print("Normalize") ecvl.Normalize(img, tmp, 20, 1.5) ecvl.ImWrite("%s_normalize%s" % (head, ext), tmp) print("CenterCrop") ecvl.CenterCrop(img, tmp, [200, 300]) ecvl.ImWrite("%s_center_crop%s" % (head, ext), tmp) print("ScaleTo") ecvl.ScaleTo(img, tmp, 100, 155) ecvl.ImWrite("%s_scale_to%s" % (head, ext), tmp) print("Applying multiple thresholds") ecvl.ChangeColorSpace(img, tmp, ecvl.ColorType.GRAY) thresholds = ecvl.OtsuMultiThreshold(tmp, 2) print(" otsu thresholds: %r" % (thresholds, )) ecvl.MultiThreshold(tmp, tmp, thresholds) ecvl.ImWrite("%s_multi_threshold%s" % (head, ext), tmp)
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 = [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): 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 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): img = ecvl.ImRead(args.in_fn) inc_brightness(img, 10) ecvl.ImWrite(args.out_fn, img)
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 = 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): head, ext = os.path.splitext(os.path.basename(args.in_fn)) img = ecvl.ImRead(args.in_fn) origin = img.copy() ecvl.ChangeColorSpace(img, img, ecvl.ColorType.GRAY) ecvl.Threshold(img, img, 25, 1) print("Calculating moments") moments = ecvl.Image.empty() ecvl.Moments(img, moments, 2) # use moments to calculate mass/area and center of mass of the image rm = np.array(moments, copy=False) print("Raw moments:") print(rm) M00 = rm[0, 0] M10 = rm[1, 0] M01 = rm[0, 1] # M11 = rm[1, 1] # M02 = rm[0, 2] # M20 = rm[2, 0] # centroid coordinates x = M10 / M00 y = M01 / M00 # central moments ecvl.CentralMoments(img, moments, [x, y]) cm = np.array(moments, copy=False) print("Central moments:") print(cm) u00 = cm[0, 0] u11 = cm[1, 1] u20 = cm[2, 0] u02 = cm[0, 2] # note that central moments can also be computed through the raw moments # u00_bis = M00 # u11_bis = M11 - x * M01 # u20_bis = M20 - x * M10 # u02_bis = M02 - y * M01 # terms of the covariance matrix u_20 = u20 / u00 # or M20 / M00 - (x * x) u_02 = u02 / u00 # or M02 / M00 - (y * y) u_11 = u11 / u00 # or M11 / M00 - (x * y) # Eigenvalues (lambda1, lambda2) and orientation of the eigenvector lambda1 = (u_20 + u_02) / 2 + np.sqrt(4 * u_11 * u_11 + (u_20 - u_02) * (u_20 - u_02)) / 2 lambda2 = (u_20 + u_02) / 2 - np.sqrt(4 * u_11 * u_11 + (u_20 - u_02) * (u_20 - u_02)) / 2 theta = 0.5 * np.arctan2(2 * u_11, (u_20 - u_02)) # rad # Eigenvalues are proportional to the square length of the eigenvector # axes. So the half-axes of the ellipse generated by the eigenvectors are # given by d/sqrt(lambda1) and d/sqrt(lambda2) where d is the proportional # factor. Considering that the moment M00 is the area (the image on which # it is calculated is binary) of the image objects we can calculate d. d = np.sqrt(M00 * np.sqrt(lambda1 * lambda2) / np.pi) # half-axes (a and b) are then a = d / np.sqrt(lambda1) b = d / np.sqrt(lambda2) # We can now draw the ellipses with the same moments as the image objects ecvl.DrawEllipse(origin, [int(x), int(y)], [int(a), int(b)], theta * 180 / np.pi, [0, 0, 255], 2) out_path = "%s_moments%s" % (head, ext) print("Writing %s" % out_path) ecvl.ImWrite(out_path, origin)
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): 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): 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}')