def main(args): ### Get Network net = get_net() keras_params_d = pickle.load(open(args.in_fn, 'rb')) # Copy keras parameters to the eddl convolutional layers update_eddl_net_params(keras_params_d, net, args.include_top) # Check if everything is ok check_params(keras_params_d, net, args.include_top) # Save network weights eddl.save(net, args.out_fn, "bin")
def main(args): ## Read input dataset x_train, y_train, x_test, y_test = read_input(args.in_ds) ## Net architecture net = models.tissue_detector_DNN() ## Net compilation eddl.build( net, eddl.rmsprop(0.00001), ["soft_cross_entropy"], ["categorical_accuracy"], eddl.CS_GPU() if args.gpu else eddl.CS_CPU() ) eddl.summary(net) ## Fit and evaluation eddl.fit(net, [x_train], [y_train], args.batch_size, args.epochs) eddl.evaluate(net, [x_test], [y_test]) eddl.save(net, "tissue_detector_model.bin")
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): 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 = 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 main(args): eddl.download_flickr() epochs = 2 if args.small else 50 olength = 20 outvs = 2000 embdim = 32 # True: remove last layers and set new top = flatten # new input_size: [3, 256, 256] (from [224, 224, 3]) net = eddl.download_resnet18(True, [3, 256, 256]) lreshape = eddl.getLayer(net, "top") # create a new model from input output image_in = eddl.getLayer(net, "input") # Decoder ldecin = eddl.Input([outvs]) ldec = eddl.ReduceArgMax(ldecin, [0]) ldec = eddl.RandomUniform(eddl.Embedding(ldec, outvs, 1, embdim, True), -0.05, 0.05) ldec = eddl.Concat([ldec, lreshape]) layer = eddl.LSTM(ldec, 512, True) out = eddl.Softmax(eddl.Dense(layer, outvs)) eddl.setDecoder(ldecin) net = eddl.Model([image_in], [out]) # Build model eddl.build( net, eddl.adam(0.01), ["softmax_cross_entropy"], ["accuracy"], eddl.CS_GPU(mem=args.mem) if args.gpu else eddl.CS_CPU(mem=args.mem)) eddl.summary(net) # Load dataset x_train = Tensor.load("flickr_trX.bin", "bin") y_train = Tensor.load("flickr_trY.bin", "bin") if args.small: x_train = x_train.select([f"0:{2 * args.batch_size}", ":", ":", ":"]) y_train = y_train.select([f"0:{2 * args.batch_size}", ":"]) xtrain = Tensor.permute(x_train, [0, 3, 1, 2]) y_train = Tensor.onehot(y_train, outvs) # batch x timesteps x input_dim y_train.reshape_([y_train.shape[0], olength, outvs]) eddl.fit(net, [xtrain], [y_train], args.batch_size, epochs) eddl.save(net, "img2text.bin", "bin") print("\n === INFERENCE ===\n") # Get all the reshapes of the images. Only use the CNN timage = Tensor([x_train.shape[0], 512]) # images reshape cnn = eddl.Model([image_in], [lreshape]) eddl.build( cnn, eddl.adam(0.001), # not relevant ["mse"], # not relevant ["mse"], # not relevant eddl.CS_GPU(mem=args.mem) if args.gpu else eddl.CS_CPU(mem=args.mem)) eddl.summary(cnn) # forward images xbatch = Tensor([args.batch_size, 3, 256, 256]) # numbatches = x_train.shape[0] / args.batch_size j = 0 eddl.next_batch([x_train], [xbatch]) eddl.forward(cnn, [xbatch]) ybatch = eddl.getOutput(lreshape) sample = str(j * args.batch_size) + ":" + str((j + 1) * args.batch_size) timage.set_select([sample, ":"], ybatch) # Create Decoder non recurrent for n-best ldecin = eddl.Input([outvs]) image = eddl.Input([512]) lstate = eddl.States([2, 512]) ldec = eddl.ReduceArgMax(ldecin, [0]) ldec = eddl.RandomUniform(eddl.Embedding(ldec, outvs, 1, embdim), -0.05, 0.05) ldec = eddl.Concat([ldec, image]) lstm = eddl.LSTM([ldec, lstate], 512, True) lstm.isrecurrent = False # Important out = eddl.Softmax(eddl.Dense(lstm, outvs)) decoder = eddl.Model([ldecin, image, lstate], [out]) eddl.build( decoder, eddl.adam(0.001), # not relevant ["softmax_cross_entropy"], # not relevant ["accuracy"], # not relevant eddl.CS_GPU(mem=args.mem) if args.gpu else eddl.CS_CPU(mem=args.mem)) eddl.summary(decoder) # Copy params from trained net eddl.copyParam(eddl.getLayer(net, "LSTM1"), eddl.getLayer(decoder, "LSTM2")) eddl.copyParam(eddl.getLayer(net, "dense1"), eddl.getLayer(decoder, "dense2")) eddl.copyParam(eddl.getLayer(net, "embedding1"), eddl.getLayer(decoder, "embedding2")) # N-best for sample s s = 1 if args.small else 100 # sample 100 # three input tensors with batch_size = 1 (one sentence) treshape = timage.select([str(s), ":"]) text = y_train.select([str(s), ":", ":"]) # 1 x olength x outvs for j in range(olength): print(f"Word: {j}") word = None if j == 0: word = Tensor.zeros([1, outvs]) else: word = text.select(["0", str(j - 1), ":"]) word.reshape_([1, outvs]) # batch = 1 treshape.reshape_([1, 512]) # batch = 1 state = Tensor.zeros([1, 2, 512]) # batch = 1 input_ = [word, treshape, state] eddl.forward(decoder, input_) # outword = eddl.getOutput(out) vstates = eddl.getStates(lstm) for i in range(len(vstates)): vstates[i].reshape_([1, 1, 512]) state.set_select([":", str(i), ":"], vstates[i]) print("All done")