def main(args):
eddl.download_mnist()
num_classes = 10
in_ = eddl.Input([784])
layer = in_
layer = eddl.Activation(eddl.Dense(layer, 1024), "relu")
layer = eddl.Activation(eddl.Dense(layer, 1024), "relu")
layer = eddl.Activation(eddl.Dense(layer, 1024), "relu")
out = eddl.Softmax(eddl.Dense(layer, num_classes))
net = eddl.Model([in_], [out])
acc = CategoricalAccuracy()
net.build(
eddl.sgd(0.01, 0.9),
[eddl.getLoss("soft_cross_entropy")],
[acc],
eddl.CS_GPU(mem=args.mem) if args.gpu else eddl.CS_CPU(mem=args.mem)
)
eddl.summary(net)
eddl.plot(net, "model.pdf")
x_train = Tensor.load("mnist_trX.bin")
y_train = Tensor.load("mnist_trY.bin")
x_test = Tensor.load("mnist_tsX.bin")
# y_test = Tensor.load("mnist_tsY.bin")
x_train.div_(255.0)
x_test.div_(255.0)
num_samples = x_train.shape[0]
num_batches = num_samples // args.batch_size
test_samples = x_test.shape[0]
test_batches = test_samples // args.batch_size
eddl.set_mode(net, TRMODE)
for i in range(args.epochs):
for j in range(num_batches):
print("Epoch %d/%d (batch %d/%d)" %
(i + 1, args.epochs, j + 1, num_batches))
indices = np.random.randint(0, num_samples, args.batch_size)
eddl.train_batch(net, [x_train], [y_train], indices)
for j in range(test_batches):
print("Epoch %d/%d (batch %d/%d)" %
(i + 1, args.epochs, j + 1, test_batches))
indices = np.random.randint(0, num_samples, args.batch_size)
eddl.eval_batch(net, [x_train], [y_train], indices)
print("All done")
eddl.train_batch(net, [x], [y]) # Perform training
eddl.print_loss(net, batch_idx)
stdout.write(f"- Elapsed time: {time()-start_time:.2f} seconds\n")
stdout.flush()
print("Saving model...")
eddl.save_net_to_onnx_file(net, "padchest_VGG16_adam_lr-0.0001.onnx")
# Validation
dataset.SetSplit(ecvl.SplitType.validation) # Set validation split
eddl.reset_loss(net) # Reset errors
print("Starting validation:")
for batch_idx in range(n_validation_batches):
stdout.write(
f"Validation - Epoch {epoch}/{epochs} (batch {batch_idx:>4}/{n_validation_batches}) "
)
stdout.flush()
dataset.LoadBatch(x, y) # Load data
eddlT.div_(x, 255.0) # Preprocessing
eddl.eval_batch(net, [x], [y])
eddl.print_loss(net, batch_idx)
stdout.write("\n")
stdout.flush()
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
# Get number of training batches
dataset.SetSplit(ecvl.SplitType.test)
n_batches = int(len(dataset.GetSplit()) / batch_size)
############
# TRAINING #
############
# Placeholder for the batches
x = eddlT.create((batch_size, dataset.n_channels_) + shape)
y = eddlT.create((batch_size, num_classes))
print("Starting test:")
for batch_idx in range(n_batches):
stdout.write(f"Test: batch {batch_idx:>4}/{n_batches} - ")
stdout.flush()
start_time = time()
dataset.LoadBatch(x, y) # Load data
eddlT.div_(x, 255.0) # Preprocessing
eddl.eval_batch(net, [x], [y]) # Perform training
eddl.print_loss(net, batch_idx)
stdout.write(f"- Elapsed time: {time()-start_time:.2f} seconds\n")
stdout.flush()
def main(args):
eddl.download_mnist()
num_classes = 10
in_ = eddl.Input([784])
layer = in_
layer = eddl.ReLu(eddl.Dense(layer, 1024))
layer = eddl.ReLu(eddl.Dense(layer, 1024))
layer = eddl.ReLu(eddl.Dense(layer, 1024))
out = eddl.Softmax(eddl.Dense(layer, num_classes))
net = eddl.Model([in_], [out])
eddl.build(
net, eddl.sgd(0.001, 0.9), ["softmax_cross_entropy"],
["categorical_accuracy"],
eddl.CS_GPU(mem=args.mem) if args.gpu else eddl.CS_CPU(mem=args.mem))
eddl.summary(net)
eddl.plot(net, "model.pdf")
eddl.setlogfile(net, "mnist")
x_train = Tensor.load("mnist_trX.bin")
y_train = Tensor.load("mnist_trY.bin")
x_test = Tensor.load("mnist_tsX.bin")
y_test = Tensor.load("mnist_tsY.bin")
if args.small:
x_train = x_train.select([":6000"])
y_train = y_train.select([":6000"])
x_test = x_test.select([":1000"])
y_test = y_test.select([":1000"])
x_train.div_(255.0)
x_test.div_(255.0)
s = x_train.shape
num_batches = s[0] // args.batch_size
for i in range(args.epochs):
eddl.reset_loss(net)
print("Epoch %d/%d (%d batches)" % (i + 1, args.epochs, num_batches))
for j in range(num_batches):
indices = np.random.randint(0, s[0], args.batch_size)
eddl.train_batch(net, [x_train], [y_train], indices)
losses1 = eddl.get_losses(net)
metrics1 = eddl.get_metrics(net)
for l, m in zip(losses1, metrics1):
print("Loss: %.6f\tMetric: %.6f" % (l, m))
s = x_test.shape
num_batches = s[0] // args.batch_size
for j in range(num_batches):
indices = np.arange(j * args.batch_size,
j * args.batch_size + args.batch_size)
eddl.eval_batch(net, [x_test], [y_test], indices)
losses2 = eddl.get_losses(net)
metrics2 = eddl.get_metrics(net)
for l, m in zip(losses2, metrics2):
print("Loss: %.6f\tMetric: %.6f" % (l, m))
last_batch_size = s[0] % args.batch_size
if last_batch_size:
indices = np.arange(j * args.batch_size,
j * args.batch_size + args.batch_size)
eddl.eval_batch(net, [x_test], [y_test], indices)
losses3 = eddl.get_losses(net)
metrics3 = eddl.get_metrics(net)
for l, m in zip(losses3, metrics3):
print("Loss: %.6f\tMetric: %.6f" % (l, m))
print("All done")