def cifar10Data(args):
cifar_train = datasets.CIFAR10(root='data/', train=True).transform_first(transform())
cifar_val = datasets.CIFAR10(root='data/', train=False).transform_first(transform())
train_data = gluon.data.DataLoader(cifar_train, batch_size=args.batch_size, shuffle=True,
num_workers=args.num_workers)
val_data = gluon.data.DataLoader(cifar_val, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers)
return train_data, val_data
def create_and_train(self, model_name: str, batch_size: int,
learning_rate: float, epochs: int):
"""
Create a ModelCreationService and Train it
:param model_name: model name
:param batch_size: size of the batch
:param learning_rate: learning rate to be used
:param epochs: nb of epochs to train the model
:return:
"""
model = model_creation_service.ModelCreationService()
acc = accuracy_calculation_service.AccuracyCalculationService()
save_model = model_manipulation_service.ModelManipulationService()
# datasets
try:
cifar_train = datasets.CIFAR10(train=True)
X, y = cifar_train[0:10]
except Exception as ex:
raise ex
# transform image
try:
transform = data_transformation_service.DataTransformationService()
transformer = transform.data_transformation()
cifar_train = cifar_train.transform_first(transformer)
# train data
train_data = gluon.data.DataLoader(cifar_train,
batch_size=batch_size,
shuffle=True)
cifar_valid = gluon.data.vision.CIFAR10(train=False)
valid_data = gluon.data.DataLoader(
cifar_valid.transform_first(transformer),
batch_size=batch_size)
except Exception as ex:
raise ex
# build model
try:
net = model.create_model()
net.initialize(init=init.Xavier())
softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()
except Exception as ex:
raise ex
try:
trainer = gluon.Trainer(net.collect_params(), 'sgd',
{'learning_rate': learning_rate})
for epoch in range(epochs):
train_loss, train_acc, valid_acc = 0., 0., 0.
tic = time.time()
for data, label in train_data:
# forward + backward
with autograd.record():
output = net(data)
loss = softmax_cross_entropy(output, label)
loss.backward()
# update parameters
trainer.step(batch_size)
# calculate training metrics
train_loss += loss.mean().asscalar()
train_acc += acc.acc(output=output, label=label)
# calculate validation accuracy
for data, label in valid_data:
valid_acc += acc.acc(net(data), label)
print(
"Epoch %d: loss %.3f, train acc %.3f, test acc %.3f, in %.1f sec"
% (epoch, train_loss / len(train_data),
train_acc / len(train_data),
valid_acc / len(valid_data), time.time() - tic))
except Exception as ex:
raise ex
try:
save_model.save_model(
net, os.path.join(self.path.model_dir, model_name))
except Exception as ex:
raise ex
from mxnet.gluon.data import DataLoader
from mxnet.gluon.data.vision import transforms, datasets
transformer = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(mean=0.13, std=0.31)])
cifar10_train = datasets.CIFAR10(root='data/',
train=True).transform_first(transformer)
train_data = DataLoader(dataset=cifar10_train,
batch_size=8,
shuffle=True,
num_workers=0)
for data, label in train_data:
print("Shape of data: {}".format(data.shape))
print("Shape of label: {}".format(label.shape))
break
return x
normalize = T.Normalize(mean=[0.491, 0.482, 0.447], std=[0.247, 0.243, 0.262])
train_transfrom = T.Compose([
RandomCrop(32, padding=4),
# T.RandomResizedCrop(32),
T.RandomFlipLeftRight(),
T.ToTensor(),
normalize
])
val_transform = T.Compose([T.ToTensor(), normalize])
trainset = datasets.CIFAR10('./data',
train=True).transform_first(train_transfrom)
trainloader = gluon.data.DataLoader(trainset,
batch_size=args.batch_size,
shuffle=True,
num_workers=2)
testset = datasets.CIFAR10('./data',
train=False).transform_first(val_transform)
testloader = gluon.data.DataLoader(testset,
batch_size=args.batch_size,
shuffle=False,
num_workers=2)
best_prec = 0
# Create a numpy array.
x = np.array([[1, 2], [3, 4]])
# Convert the numpy array to a mxnet ndarry.
y = nd.array(x)
# Convert the mxnet ndarry to a numpy array.
z = y.asnumpy()
# ================================================================== #
# 4. Input pipline #
# ================================================================== #
# Download and construct CIFAR-10 dataset.
train_dataset = datasets.CIFAR10(root='../../data', train=True)
# Fetch one data pair (read data from disk).
image, label = train_dataset[0]
print(image.shape)
print(label)
# Data loader (this provides queues and threads in a very simple way).
train_loader = gluon.data.DataLoader(dataset=train_dataset,
batch_size=64,
shuffle=True)
# When iteration starts, queue and thread start to load data from files.
data_iter = iter(train_loader)
# Mini-batch images and labels.
def train(current_host, hosts, num_cpus, num_gpus, channel_input_dirs,
model_dir, hyperparameters, **kwargs):
# Set random seeds
random.seed(0)
np.random.seed(0)
mx.random.seed(777)
## retrieve the hyperparameters we set in notebook (with some defaults)
batch_size = hyperparameters.get('batch_size', 128)
epochs = hyperparameters.get('epochs', 30)
extra = hyperparameters.get('extra', 3)
peak = hyperparameters.get('peak', 5)
momentum = hyperparameters.get('momentum', 0.91)
lr = hyperparameters.get('lr', 0.1)
min_lr = hyperparameters.get('min_lr', 0.005)
wd = hyperparameters.get('wd', 0.0005)
##
#Inform properly the algorithm about hardware choice
if len(hosts) == 1:
kvstore = 'device' if num_gpus > 0 else 'local'
else:
kvstore = 'dist_device_sync'
part_index = 0
for i, host in enumerate(hosts):
if host == current_host:
part_index = i
break
num_parts = len(hosts)
#Set-up the right context
ctx = [mx.gpu(i) for i in range(num_gpus)] if num_gpus > 0 else [mx.cpu()]
# Define the transforms to be applied
means = [0.4914, 0.4822, 0.4465]
stds = [0.2023, 0.1994, 0.2010]
transform_train = Compose([
RandomCrop(32, padding=4, padding_mode='reflect'),
transforms.RandomFlipLeftRight(),
transforms.ToTensor(),
transforms.Normalize(means, stds)
])
transform_test = Compose(
[transforms.ToTensor(),
transforms.Normalize(means, stds)])
# Load the datasets
given_path = channel_input_dirs['training']
trainset = datasets.CIFAR10(root=given_path, train=True)
testset = datasets.CIFAR10(root=given_path, train=False)
sampler = mx.gluon.data.RandomSampler(len(trainset))
batch_sampler = ContinuousBatchSampler(
sampler,
batch_size=batch_size,
datalen=len(trainset),
max_iters=int(len(trainset) / batch_size + 1) * 45)
train_data = DataLoader(
trainset.transform_first(transform_train),
batch_sampler=batch_sampler,
num_workers=num_cpus,
)
valid_data = DataLoader(
testset.transform_first(transform_test),
batch_size=1024,
shuffle=False,
num_workers=num_cpus,
)
# Define model and the dtype (wether to use full precision or half precision)
dtype = 'float16'
model = resnet18Basic(num_classes=10)
# Define the learner and fit!
learner = GluonLearner(model, hybridize=False, ctx=ctx)
learner.fit(
train_data=train_data,
valid_data=valid_data,
epochs=epochs,
extra=extra,
peak=peak,
lr=lr,
min_lr=min_lr,
momentum=momentum,
initializer=mx.init.Xavier(rnd_type='gaussian',
factor_type='out',
magnitude=2),
optimizer=mx.optimizer.SGD(learning_rate=lr,
rescale_grad=1.0 / batch_size,
momentum=momentum,
wd=wd,
multi_precision=(dtype == 'float16')),
early_stopping_criteria=lambda e: e >= 0.94,
kvstore=kvstore,
dtype=dtype,
)
return model
from mxnet.gluon import model_zoo
from mxnet.gluon import nn
from mxnet.gluon.data.vision import transforms, datasets
import matplotlib.pyplot as plt
label_text = ['airplane', 'automobile', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck']
net = model_zoo.vision.resnet18_v1()
net.output = nn.Dense(10)
net.load_parameters(filename="output/ResNet18-4.params")
transformer = transforms.Compose([transforms.ToTensor(),
transforms.Normalize(0.13, 0.31)])
cifar10_val = datasets.CIFAR10(root='data/',train=False)
plt.figure()
for i in range(6):
img, label = cifar10_val[i]
data = transformer(img).expand_dims(axis=0)
output = net.forward(data)
pre_label = output.argmax(axis=1).astype("int32").asscalar()
print("Predict label is: {}, Ground truth is: {}".format(
label_text[pre_label], label_text[label]))
plt.subplot(2,3,i+1)
plt.axis('off')
plt.imshow(img.asnumpy())
plt.title("Predict: " + label_text[pre_label] + "\n" + "Truth: " +
label_text[label])
plt.savefig("Prediction result.png")
# Hyper-parameters
num_epochs = 10
num_classes = 10
batch_size = 100
learning_rate = 0.01
# Image preprocessing modules
transformer = transforms.Compose([
transforms.RandomFlipLeftRight(),
transforms.RandomResizedCrop(32),
transforms.ToTensor()
])
# CIFAR-10 dataset
train_dataset = datasets.CIFAR10(root='../../data', train=True)
train_dataset = train_dataset.transform_first(transformer)
test_dataset = datasets.CIFAR10(root='../../data', train=False)
test_dataset = test_dataset.transform_first(transformer)
# DataLoader
train_loader = gluon.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True)
test_loader = gluon.data.DataLoader(test_dataset,
batch_size=batch_size,
shuffle=True)
def test(ctx, val_data):
metric = mx.metric.Accuracy(name="valid_accuracy")
for _, batch in enumerate(val_data):
data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0)
label = gluon.utils.split_and_load(batch[1],
ctx_list=ctx,
batch_axis=0)
outputs = [net(X) for X in data]
metric.update(label, outputs)
return metric.get()
#
# Prepare the dataset
#
cifar_train = datasets.CIFAR10(train=True)
cifar_test = datasets.CIFAR10(train=False)
class_names = [
"airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse",
"ship", "truck"
]
transform_train = transforms.Compose([
gcv_transforms.RandomCrop(32, pad=4),
transforms.RandomFlipLeftRight(),
transforms.ToTensor(),
transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])
])
transform_test = transforms.Compose([
transforms.ToTensor(),
