def test_3_testResNet50WithOCLagainstPytorchImplementation(self):
netOcl = resnet50(True)
netpy = resnet50(False)
self.equalizeWeights(netpy, netOcl)
batch_size = 100
_, testLoader = getDataLoaders(batch_size, batch_size)
netOcl.eval()
netpy.eval()
dataIter = iter(testLoader)
images, labels = dataIter.next()
start = time.time()
outputs_ocl = netOcl(images)
print(" Ocl Inference Time [sec]: ", time.time() - start)
start = time.time()
outputs_py = netpy(images)
print("Pytorch-Inferencing Time [sec]: ", time.time() - start)
_, predicted_ocl = torch.max(outputs_ocl, 1)
_, predicted_py = torch.max(outputs_py, 1)
for (pred_ocl, pred_py) in zip(predicted_ocl, predicted_py):
#print("ocl-predict: ", classes[pred_ocl])
#print("py-predict: ", classes[pred_py])
self.assertTrue(torch.equal(pred_ocl, pred_py))
self.assertEqual(
classes[pred_py], classes[pred_ocl],
"OpenCL and reference PyTorch implementation predictions are not equal: torch={} - ocl={}."
.format(classes[pred_py], classes[pred_ocl]))
def test_2_getDimensionsOfInputDataForRandomBatchSize_testForDimensionality(
self):
batch_size = random.randrange(1, 15)
_, testLoader = getDataLoaders(batch_size, batch_size)
dataIter = iter(testLoader)
images, labels = dataIter.next()
self.assertEqual(images.size()[0], batch_size)
self.assertEqual(images.size()[1], 3)
self.assertEqual(images.size()[2], 32)
self.assertEqual(images.size()[3], 32)
def test_0_createResNet50_and_inference_input_without_exception(self):
net = resnet50(False)
batch_size = 1
_, testLoader = getDataLoaders(batch_size, batch_size)
net.eval()
dataIter = iter(testLoader)
images, labels = dataIter.next()
outputs = net(images)
_, predicted = torch.max(outputs, 1)
def test_1_createResNet50_with_convolution_and_inference_input_without_exception(
self):
net = resnet50(True)
batch_size = 1
_, testLoader = getDataLoaders(batch_size, batch_size)
net.eval()
dataIter = iter(testLoader)
images, labels = dataIter.next()
#print("Run inferencing...")
outputs = net(images)
_, predicted = torch.max(outputs, 1)
print(predicted)
print("Predicted: ", classes[predicted[0]])
print("Ground Truth: ", classes[labels[0]])
def test_10_forwardImage_shouldprovideSameResultAsVanilla(self):
batch_size = 1
out_channels = 5
kernel_size = 5
_, testLoader = getDataLoaders(batch_size, batch_size)
dataIter = iter(testLoader)
images, labels = dataIter.next()
convolution = OCL_Conv2D(images.size()[1],
out_channels,
kernel_size,
use_ocl=True)
convolutionOrig = Conv2d(images.size()[1], out_channels, kernel_size)
convolutionOrig.weight.data = convolution.weight.data
convWeight_plane = convolution.weight[0][0]
origWeight_plane = convolutionOrig.weight[0][0]
result = convolution.forward(images)
resultOrig = convolutionOrig.forward(images)
self.assertIsNotNone(result, "Result should not be None")
self.assertIsNotNone(resultOrig, "orig Result should not be None")
self.assertEqual(result.size()[0],
resultOrig.size()[0],
"Resulting Batch size should be the same")
self.assertEqual(result.size()[1],
resultOrig.size()[1],
"Resulting amount of Channels should be the same")
self.assertEqual(result.size()[2],
result.size()[2],
"Resulting height should be the same.")
self.assertEqual(result.size()[3],
result.size()[3],
"Resulting width should be the same.")
print("Testing equality of weights.")
for j in range(convWeight_plane.size()[0]):
for i in range(convWeight_plane.size()[1]):
val_ocl = convWeight_plane[j][i]
val_orig = origWeight_plane[j][i]
self.assertEqual(
val_ocl, val_orig,
"Original and OCL implementation should be the same, but was ocl={:5.23f}, orig={:5.23f}"
.format(val_ocl, val_orig))
print("Testing equality of result.")
for batchIdx in range(result.size()[0]):
for channelIdx in range(result.size()[1]):
for col in range(result.size()[2]):
for row in range(result.size()[3]):
val_ocl = result[batchIdx][channelIdx][col][row]
val_orig = resultOrig[batchIdx][channelIdx][col][row]
self.assertEqual(
val_ocl, val_orig,
"Result of orig. and ocl impl. should be the same, but was ocl={:5.23f}, orig={:5.23f}"
.format(val_ocl, val_orig))
userInput = input('\nProceed? [y/n] ')
if userInput.upper() not in ['Y', 'N']:
print('Please enter "y" or "n"!')
continue
else:
if userInput.upper() == 'N':
print('\nAborted!\n')
exit()
else:
break
#---Get dataloaders---
trainloader, testloader, validloader, class_to_idx = utils.getDataLoaders(
train_dir,
test_dir,
valid_dir)
#---TRAINING MODE---
print('\nENTERING TRAINING MODE...')
model.to(device)
model.train()
running_loss = 0
validationFreq = 50
validationCountdown = validationFreq
validation_loss, training_loss = [], []
for epoch in range(epochs):
print(f'Beginning epoch: {epoch + 1} of {epochs}')
def main(args):
data_dir = args.data_dir
save_dir = args.save_dir
arch = args.arch
learning_rate = args.learning_rate
hidden_units = args.hidden_units
epochs = args.epochs
gpu = args.gpu
print(args)
# cuda is avaliable
cuda = utils.isCudaAvaliable(gpu)
# datasets and dataloader
datasets = utils.getDatasets(data_dir)
dataloaders = utils.getDataLoaders(datasets)
# build network
model = utils.getModelsByArch(arch)
# custom model args and classifier
model = utils.ininModelArgsAndClassifier(model, hidden_units)
# define criterion and optimizer
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr=learning_rate)
# train model
steps = 0
running_loss = 0
print_every = 20
if cuda:
model.cuda()
else:
model.cpu()
print('train start')
for e in range(epochs):
model.train()
for images, labels in iter(dataloaders['train']):
steps += 1
images, labels = Variable(images), Variable(labels)
optimizer.zero_grad()
if cuda:
images, labels = images.cuda(), labels.cuda()
outputs = model.forward(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.data[0]
if steps % print_every == 0:
model.eval()
accuracy = 0
test_loss = 0
for ii, (images, labels) in enumerate(dataloaders['valid']):
images, labels = Variable(images, volatile=True), Variable(
labels, volatile=True)
if cuda:
images, labels = images.cuda(), labels.cuda()
output = model.forward(images)
test_loss += criterion(output, labels).data[0]
ps = torch.exp(output).data
equality = (labels.data == ps.max(1)[1])
accuracy += equality.type_as(torch.FloatTensor()).mean()
print(
"Epoch: {}/{}.. ".format(e + 1, epochs),
"Training Loss: {:.3f}.. ".format(running_loss /
print_every),
"Test Loss: {:.3f}.. ".format(test_loss /
len(dataloaders['valid'])),
"Test Accuracy: {:.3f}".format(accuracy /
len(dataloaders['valid'])))
running_loss = 0
model.train()
print('train finsh')
# set checkpoint
if save_dir:
checkpoint = {
'epochs': epochs,
'arch': arch,
'learning_rate': learning_rate,
'hidden_units': hidden_units,
'gpu': gpu,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'class_to_idx': datasets['train'].class_to_idx
}
torch.save(checkpoint, save_dir)
print('checkpoint save success')