def predict(model_path, im_path):
'''
Test procedure
---------------
:param model_path: path of the saved model
:param im_path: path of an image
'''
# TODO 3: load configurations from saved model, initialize the model.
# Note: you can complete this section by referring to Part 4: test.
# step 1: load configurations from saved model using torch.load(model_path)
# and get the configs dictionary, configs = checkpoint['configs'],
# then get each config from configs, eg., norm_size = configs['norm_size']
checkpoint = torch.load(model_path)
configs = checkpoint['configs']
norm_size = configs['norm_size']
output_size = configs['output_size']
hidden_size = configs['hidden_size']
n_layers = configs['n_layers']
act_type = configs['act_type']
# step 2: initialize the model by MLP()
model = MLP(norm_size[0] * norm_size[1], output_size, hidden_size,
n_layers, act_type)
# step 3: load model parameters we saved in model_path
# hint: similar to what we do in Part 4: test.
model.load_state_dict(checkpoint['state_dict'])
# End TODO 3
# enter the evaluation mode
model.eval()
# image pre-processing, similar to what we do in ListDataset()
transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(norm_size),
transforms.ToTensor()
])
# image pre-processing, similar to what we do in ListDataset()
im = cv2.imread(im_path)
im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
im = transform(im)
im.sub_(0.5).div_(0.5)
# input im into the model
with torch.no_grad():
input = im.view(1, -1)
out = model(input)
prediction = out.argmax(1)[0].item()
# convert index of prediction to the corresponding character
letters = string.ascii_letters[-26:] # ABCD...XYZ
prediction = letters[prediction]
print('Prediction: {}'.format(prediction))
def main():
parser = argparse.ArgumentParser(description='Pytorch example: CIFAR-10')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--model', '-m', default='result/model_final',
help='Path to the model for test')
parser.add_argument('--image', '-i', default='image.png',
help='Path to the model for test')
parser.add_argument('--unit', '-u', type=int, default=1000,
help='Number of units')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('')
# Set up a neural network to test
net = MLP(args.unit, 28*28, 10)
# Load designated network weight
net.load_state_dict(torch.load(args.model))
# Set model to GPU
device = 'cpu'
if args.gpu >= 0:
# Make a specified GPU current
device = 'cuda:' + str(args.gpu)
net = net.to(device)
# Load image
transform = transforms.Compose( [
transforms.Grayscale(),
transforms.Resize((28, 28)),
transforms.ToTensor()] )
image = transform(Image.open(args.image, 'r')).unsqueeze(0).to(device)
with torch.no_grad():
# Reshape the input
image = image.view(-1, 28*28)
if args.gpu >= 0:
image = image.to(device)
# Forward
outputs = net(image)
# Predict the label
# _, predicted = torch.max(outputs, 1)
_, predicted = torch.topk(outputs, 3)
# Print the result
print('Predicted label : {0}, {1}, {2}'.format(predicted[0][0].tolist(),predicted[0][1].tolist(),predicted[0][2].tolist()))
print("Loaded Network to GPU ... ")
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
if not ft.dir_exist(
os.path.join(proj_path, "checkpoint", "MLPTwoStep{}".format(option))):
os.makedirs(
os.path.join(proj_path, "checkpoint", "MLPTwoStep{}".format(option)))
# if having epoch saved, then load already trained model
if not start_epoch == 0:
# load the existing model and resume training
checkpoint = torch.load(
os.path.join(proj_path, "checkpoint", "MLPTwoStep{}".format(option),
"cp_{:03d}.pth".format(start_epoch)))
net.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
# load the existing training result
acc_val_ex, acc_train_ex, loss_val_ex, loss_train_ex = load_train_result(
os.path.join(proj_path, "checkpoint", "MLPTwoStep{}".format(option),
"training_result_{:03d}.npz".format(start_epoch)))
acc_val[:start_epoch] = acc_val_ex[:start_epoch]
acc_train[:start_epoch] = acc_train_ex[:start_epoch]
loss_val[:start_epoch] = loss_val_ex[:start_epoch]
loss_train[:start_epoch] = loss_train_ex[:start_epoch]
print("Loaded existing model check point ...")
# train the network
start_t = time.time()
print_freq = 20
def test(model_path,
im_dir='data/character_classification/images',
test_file_path='data/character_classification/test.json',
batch_size=8,
device='cpu'):
'''
Test procedure
---------------
:param model_path: path of the saved model
:param im_dir: path to directory with images
:param test_file_path: file with test image paths and labels
:param batch_size: test batch size
:param device: 'cpu' or 'cuda'
'''
# load configurations from saved model, initialize and test the model
checkpoint = torch.load(model_path)
configs = checkpoint['configs']
norm_size = configs['norm_size']
output_size = configs['output_size']
hidden_size = configs['hidden_size']
n_layers = configs['n_layers']
act_type = configs['act_type']
# initialize the model by MLP()
model = MLP(norm_size[0] * norm_size[1], output_size, hidden_size,
n_layers, act_type)
# load model parameters we saved in model_path
model.load_state_dict(checkpoint['state_dict'])
model = model.to(device)
print('[Info] Load model from {}'.format(model_path))
# enter the evaluation mode
model.eval()
# test loader
testloader = dataLoader(im_dir, test_file_path, norm_size, batch_size)
# run the test process
n_correct = 0.
n_ims = 0.
logits = []
all_labels = []
with torch.no_grad(
): # we do not need to compute gradients during test stage
for ims, labels in testloader:
ims, labels = ims.to(device), labels.type(torch.float).to(device)
input = ims.view(ims.size(0), -1)
out = model(input)
predictions = out.argmax(1)
n_correct += torch.sum(predictions == labels)
n_ims += ims.size(0)
logits.append(out)
all_labels.append(labels)
logits = torch.cat(logits, dim=0).detach().cpu().numpy()
all_labels = torch.cat(all_labels, dim=0).cpu().numpy()
tsne = TSNE(n_components=2, init='pca')
Y = tsne.fit_transform(logits)
letters = list(string.ascii_letters[-26:])
Y = (Y - Y.min(0)) / (Y.max(0) - Y.min(0))
for i in range(len(all_labels)):
if (all_labels[i] < 26):
c = plt.cm.rainbow(float(all_labels[i]) / 26)
plt.text(Y[i, 0],
Y[i, 1],
s=letters[int(all_labels[i])],
color=c)
plt.show()
print('[Info] Test accuracy = {:.1f}%'.format(100 * n_correct / n_ims))
def main():
parser = argparse.ArgumentParser(description='Pytorch example: MNIST')
parser.add_argument('--batchsize', '-b', type=int, default=100,
help='Number of images in each mini-batch')
parser.add_argument('--epoch', '-e', type=int, default=20,
help='Number of sweeps over the training data')
parser.add_argument('--frequency', '-f', type=int, default=-1,
help='Frequency of taking a snapshot')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--unit', '-u', type=int, default=1000,
help='Number of units')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# unit: {}'.format(args.unit))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
net = MLP(args.unit, 28*28, 10)
# Load designated network weight
if args.resume:
net.load_state_dict(torch.load(args.resume))
# Set model to GPU
if args.gpu >= 0:
# Make a specified GPU current
device = 'cuda:' + str(args.gpu)
net = net.to(device)
# Setup a loss and an optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
# Load the MNIST
transform = transforms.Compose( [transforms.ToTensor()] )
trainvalset = datasets.MNIST(root='./data', train=True,
download=True, transform=transform)
# Split train/val
n_samples = len(trainvalset)
trainsize = int(n_samples * 0.9)
valsize = n_samples - trainsize
trainset, valset = torch.utils.data.random_split(trainvalset, [trainsize, valsize])
trainloader = torch.utils.data.DataLoader(trainset, batch_size=args.batchsize,
shuffle=True, num_workers=2)
valloader = torch.utils.data.DataLoader(valset, batch_size=args.batchsize,
shuffle=True, num_workers=2)
# Setup result holder
x = []
ac_train = []
ac_val = []
# Train
for ep in range(args.epoch): # Loop over the dataset multiple times
running_loss = 0.0
correct_train = 0
total_train = 0
correct_val = 0
total_val = 0
for i, data in enumerate(trainloader, 0):
# Get the inputs; data is a list of [inputs, labels]
inputs, labels = data
if args.gpu >= 0:
inputs = inputs.to(device)
labels = labels.to(device)
# Reshape the input
inputs = inputs.view(-1, 28*28)
# Reset the parameter gradients
optimizer.zero_grad()
# Forward
outputs = net(inputs)
# Predict the label
_, predicted = torch.max(outputs, 1)
# Check whether estimation is right
c = (predicted == labels).squeeze()
for i in range(len(predicted)):
correct_train += c[i].item()
total_train += 1
# Backward + Optimize
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# Add loss
running_loss += loss.item()
# Report loss of the epoch
print('[epoch %d] loss: %.3f' % (ep + 1, running_loss))
# Save the model
if (ep + 1) % args.frequency == 0:
path = args.out + "/model_" + str(ep + 1)
torch.save(net.state_dict(), path)
# Validation
with torch.no_grad():
for data in valloader:
images, labels = data
if args.gpu >= 0:
images = images.to(device)
labels = labels.to(device)
# Reshape the input
images = images.view(-1, 28*28)
# Forward
outputs = net(images)
# Predict the label
_, predicted = torch.max(outputs, 1)
# Check whether estimation is right
c = (predicted == labels).squeeze()
for i in range(len(predicted)):
correct_val += c[i].item()
total_val += 1
# Record result
x.append(ep+1)
ac_train.append(100 * correct_train / total_train)
ac_val.append(100 * correct_val / total_val)
print('Finished Training')
path = args.out + "/model_final"
torch.save(net.state_dict(), path)
# Draw graph
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(x, ac_train, label='Training')
ax.plot(x, ac_val, label='Validation')
ax.legend()
ax.set_xlabel("Epoch")
ax.set_ylabel("Accuracy [%]")
ax.set_ylim(80, 100)
plt.savefig(args.out + '/accuracy_mnist_mlp.png')
