def main():
# flowers/test/1/image_06743.jpg
# checkpoints/cp_tmp.pth
start_time = time()
criterion = get_criterion()
in_arg = get_args_predict()
device = get_device(in_arg.gpu)
model = load_checkpoint(in_arg.checkpoint_path, device)
cat_to_name = load_names(in_arg.category_names)
top_ps, top_class = predict(
image_path=in_arg.image_path,
model=model,
cat_to_name=cat_to_name,
device=device,
topk=in_arg.top_k
)
print(top_ps)
print(top_class)
tot_time = time() - start_time
print(f"\n** Total Elapsed Runtime: {tot_time:.3f} seconds")
def main():
start_time = time()
in_arg = get_args_train()
data_dir = in_arg.data_dir
device = get_device(in_arg.gpu)
# print(device)
dataloaders = get_dataloaders(data_dir)
criterion = get_criterion()
model = get_model(device=device,
arch=in_arg.arch,
hidden_units=in_arg.hidden_units,
data_dir=in_arg.data_dir,
save_dir=in_arg.save_dir)
# print(model)
optimizer = get_optimizer(model, in_arg.learning_rate)
# print(optimizer)
train(model,
criterion,
optimizer,
epochs=in_arg.epochs,
device=device,
train_loader=dataloaders['train'],
valid_loader=dataloaders['valid'])
tot_time = time() - start_time
print(f"\n** Total Elapsed Runtime: {tot_time:.3f} seconds")
def train_network(network, config, observer=observers.EmptyObserver()):
device = helpers.get_device()
network.to(device)
optimizer = optim.SGD(network.parameters(),
lr=config.lr,
momentum=config.momentum)
min_loss = float('inf')
min_loss_network = None
for epoch in range(config.epochs):
for iteration, data in enumerate(config.train_set_loader, 0):
inputs, labels = data[0].to(device), data[1].to(device)
optimizer.zero_grad()
outputs = network(inputs)
loss = config.criterion(outputs, labels)
loss.backward()
optimizer.step()
observer.update(network, epoch, iteration, loss.item())
validation_loss, validation_accuracy = get_validation_stats(
network=network,
validation_set_loader=config.validation_set_loader,
criterion=config.criterion)
observer.validation_update(network, epoch, validation_loss,
validation_accuracy)
if validation_loss < min_loss:
min_loss = validation_loss
min_loss_network = copy.deepcopy(network)
if validation_loss / min_loss > 1.2:
return min_loss_network
return min_loss_network
def predict(image_path, model, topk=1, gpu=True, cat_to_name=None):
""" Predict the class (or classes) of an image using a trained deep learning model.
"""
model.to(get_device(gpu))
img = process_image(image_path)
img_torch = torch.from_numpy(img)
img_torch = img_torch.unsqueeze_(0)
img_torch = img_torch.float()
with torch.no_grad():
output = model.forward(img_torch.cuda())
probabilities = F.softmax(output.data, dim=1).topk(topk)
index_to_class = {val: key for key, val in model.class_to_idx.items()}
probs = np.array(probabilities[0][0])
classes = [cat_to_name[index_to_class[i]] for i in np.array(probabilities[1][0])] if cat_to_name is not None \
else [index_to_class[i] for i in np.array(probabilities[1][0])]
# Log the prediction results for the user to see them
logging.info('\n'.join([
'Class: {} with probability {}'.format(c, p)
for c, p in zip(classes, probs)
]))
return probs, classes
def test_single_image(model, img, label_list, uncertainty=False, device=None):
if not device:
device = get_device()
num_classes = 10
trans = transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor()])
img_tensor = trans(img)
img_tensor.unsqueeze_(0)
img_variable = Variable(img_tensor)
img_variable = img_variable.to(device)
if uncertainty:
output = model(img_variable)
evidence = relu_evidence(output)
alpha = evidence + 1
uncertainty = num_classes / torch.sum(alpha, dim=1, keepdim=True)
_, preds = torch.max(output, 1)
prob = alpha / torch.sum(alpha, dim=1, keepdim=True)
output = output.flatten()
prob = prob.flatten()
preds = preds.flatten()
label = list(label_list.keys())[list(label_list.values()).index(preds[0])]
print("Predict:", label)
print("Probs:", prob)
print("Uncertainty:", uncertainty)
else:
output = model(img_variable)
_, preds = torch.max(output, 1)
prob = F.softmax(output, dim=1)
output = output.flatten()
prob = prob.flatten()
preds = preds.flatten()
label = list(label_list.keys())[list(label_list.values()).index(preds[0])]
print("Predict:", label)
print("Probs:", prob)
labels = label_list.keys()
fig = plt.figure(figsize=[6.2, 5])
fig, axs = plt.subplots(1, 2, gridspec_kw={"width_ratios": [1, 3]})
plt.title("Classified as: {}".format(
label))
axs[0].imshow(img, cmap="gray")
axs[0].axis("off")
axs[1].bar(labels, prob.cpu().detach().numpy(), width=0.5)
axs[1].set_xlim([0, 9])
axs[1].set_ylim([0, 1])
# axs[1].set_xticks(np.arange(10))
axs[1].set_xlabel("Classes")
axs[1].set_ylabel("Classification Probability")
fig.tight_layout()
plt.savefig("./results/test_image.jpg")
def edl_log_loss(output, target, epoch_num, num_classes, annealing_step, device=None):
if not device:
device = get_device()
evidence = relu_evidence(output)
alpha = evidence + 1
loss = torch.mean(edl_loss(torch.log, target, alpha,
epoch_num, num_classes, annealing_step, device))
return loss
def check_accuracy(model, test_data):
"""
Checks accuracy of a model
"""
correct = 0
total = 0
device = get_device()
with torch.no_grad():
model.eval()
model.to(get_device())
for data in test_data:
images, labels = data
images, labels = images.to(device), labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
return 100 * correct / total
def predict(network, set_loader):
device = helpers.get_device()
network.to(device)
result_predicted = []
with torch.no_grad():
for data in set_loader:
inputs = data[0].to(device)
outputs = network(inputs)
_, predicted = torch.max(outputs, 1)
result_predicted += predicted.tolist()
print(f"{len(result_predicted)} records evaluated")
return np.array(result_predicted)
def loglikelihood_loss(y, alpha, device=None):
if not device:
device = get_device()
y = y.to(device)
alpha = alpha.to(device)
S = torch.sum(alpha, dim=1, keepdim=True)
loglikelihood_err = torch.sum((y - (alpha / S))**2, dim=1, keepdim=True)
loglikelihood_var = torch.sum(alpha * (S - alpha) / (S * S * (S + 1)),
dim=1,
keepdim=True)
loglikelihood = loglikelihood_err + loglikelihood_var
return loglikelihood
def mse_loss(y, alpha, epoch_num, num_classes, annealing_step, device=None):
if not device:
device = get_device()
y = y.to(device)
alpha = alpha.to(device)
loglikelihood = loglikelihood_loss(y, alpha, device=device)
annealing_coef = torch.min(torch.tensor(
1.0, dtype=torch.float32), torch.tensor(epoch_num / annealing_step, dtype=torch.float32))
kl_alpha = (alpha - 1) * (1 - y) + 1
kl_div = annealing_coef * \
kl_divergence(kl_alpha, num_classes, device=device)
return loglikelihood + kl_div
def kl_divergence(alpha, num_classes, device=None):
if not device:
device = get_device()
ones = torch.ones([1, num_classes], dtype=torch.float32, device=device)
sum_alpha = torch.sum(alpha, dim=1, keepdim=True)
first_term = (torch.lgamma(sum_alpha) -
torch.lgamma(alpha).sum(dim=1, keepdim=True) +
torch.lgamma(ones).sum(dim=1, keepdim=True) -
torch.lgamma(ones.sum(dim=1, keepdim=True)))
second_term = ((alpha -
ones).mul(torch.digamma(alpha) -
torch.digamma(sum_alpha)).sum(dim=1,
keepdim=True))
kl = first_term + second_term
return kl
def get_validation_stats(network, validation_set_loader, criterion):
device = helpers.get_device()
network.to(device)
correct = 0
total = 0
loss = 0
with torch.no_grad():
for data in validation_set_loader:
inputs, labels = data[0].to(device), data[1].to(device)
outputs = network(inputs)
_, predicted = torch.max(outputs, 1)
loss_val = criterion(outputs, labels)
loss += loss_val.item()
total += labels.size(0)
correct += (predicted == labels).sum().item()
return loss, correct / total
def kl_divergence(alpha, num_classes, device=None):
if not device:
device = get_device()
beta = torch.ones([1, num_classes], dtype=torch.float32, device=device)
S_alpha = torch.sum(alpha, dim=1, keepdim=True)
S_beta = torch.sum(beta, dim=1, keepdim=True)
lnB = torch.lgamma(S_alpha) - \
torch.sum(torch.lgamma(alpha), dim=1, keepdim=True)
lnB_uni = torch.sum(torch.lgamma(beta), dim=1,
keepdim=True) - torch.lgamma(S_beta)
dg0 = torch.digamma(S_alpha)
dg1 = torch.digamma(alpha)
kl = torch.sum(
(alpha - beta) * (dg1 - dg0), dim=1, keepdim=True) + lnB + lnB_uni
return kl
def main():
parser = argparse.ArgumentParser()
mode_group = parser.add_mutually_exclusive_group(required=True)
mode_group.add_argument("--train",
action="store_true",
help="To train the network.")
mode_group.add_argument("--test",
action="store_true",
help="To test the network.")
parser.add_argument("--epochs",
default=10,
type=int,
help="Desired number of epochs.")
parser.add_argument("--dropout",
action="store_true",
help="Whether to use dropout or not.")
parser.add_argument("--uncertainty",
action="store_true",
help="Use uncertainty or not.")
parser.add_argument("--dataset",
action="store_true",
help="The dataset to use.")
parser.add_argument("--outsample",
action="store_true",
help="Use out of sample test image")
uncertainty_type_group = parser.add_mutually_exclusive_group()
uncertainty_type_group.add_argument(
"--mse",
action="store_true",
help=
"Set this argument when using uncertainty. Sets loss function to Expected Mean Square Error."
)
uncertainty_type_group.add_argument(
"--digamma",
action="store_true",
help=
"Set this argument when using uncertainty. Sets loss function to Expected Cross Entropy."
)
uncertainty_type_group.add_argument(
"--log",
action="store_true",
help=
"Set this argument when using uncertainty. Sets loss function to Negative Log of the Expected Likelihood."
)
dataset_type_group = parser.add_mutually_exclusive_group()
dataset_type_group.add_argument(
"--mnist",
action="store_true",
help="Set this argument when using MNIST dataset")
dataset_type_group.add_argument(
"--emnist",
action="store_true",
help="Set this argument when using EMNIST dataset")
dataset_type_group.add_argument(
"--CIFAR",
action="store_true",
help="Set this argument when using CIFAR dataset")
dataset_type_group.add_argument(
"--fmnist",
action="store_true",
help="Set this argument when using FMNIST dataset")
args = parser.parse_args()
if args.dataset:
if args.mnist:
from mnist import dataloaders, label_list
elif args.CIFAR:
from CIFAR import dataloaders, label_list
elif args.fmnist:
from fashionMNIST import dataloaders, label_list
if args.train:
num_epochs = args.epochs
use_uncertainty = args.uncertainty
num_classes = 10
model = LeNet(dropout=args.dropout)
if use_uncertainty:
if args.digamma:
criterion = edl_digamma_loss
elif args.log:
criterion = edl_log_loss
elif args.mse:
criterion = edl_mse_loss
else:
parser.error(
"--uncertainty requires --mse, --log or --digamma.")
else:
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3, weight_decay=0.005)
exp_lr_scheduler = optim.lr_scheduler.StepLR(optimizer,
step_size=7,
gamma=0.1)
device = get_device()
model = model.to(device)
model, metrics = train_model(model,
dataloaders,
num_classes,
criterion,
optimizer,
scheduler=exp_lr_scheduler,
num_epochs=num_epochs,
device=device,
uncertainty=use_uncertainty)
state = {
"epoch": num_epochs,
"model_state_dict": model.state_dict(),
"optimizer_state_dict": optimizer.state_dict(),
}
if use_uncertainty:
if args.digamma:
torch.save(state, "./results/model_uncertainty_digamma.pt")
print("Saved: ./results/model_uncertainty_digamma.pt")
if args.log:
torch.save(state, "./results/model_uncertainty_log.pt")
print("Saved: ./results/model_uncertainty_log.pt")
if args.mse:
torch.save(state, "./results/model_uncertainty_mse.pt")
print("Saved: ./results/model_uncertainty_mse.pt")
else:
torch.save(state, "./results/model.pt")
print("Saved: ./results/model.pt")
elif args.test:
use_uncertainty = args.uncertainty
device = get_device()
model = LeNet()
model = model.to(device)
optimizer = optim.Adam(model.parameters())
if use_uncertainty:
if args.digamma:
checkpoint = torch.load(
"./results/model_uncertainty_digamma.pt")
if args.log:
checkpoint = torch.load("./results/model_uncertainty_log.pt")
if args.mse:
checkpoint = torch.load("./results/model_uncertainty_mse.pt")
else:
checkpoint = torch.load("./results/model.pt")
filename = "./results/rotate.jpg"
model.load_state_dict(checkpoint["model_state_dict"])
optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
model.eval()
if args.outsample:
img = Image.open("./data/arka.jpg").convert('L').resize((28, 28))
img = TF.to_tensor(img)
img.unsqueeze_(0)
else:
a = iter(dataloaders['test'])
img, label = next(a)
rotating_image_classification(model,
img,
filename,
label_list,
uncertainty=use_uncertainty)
img = transforms.ToPILImage()(img[0][0])
test_single_image(model, img, label_list, uncertainty=use_uncertainty)
''' Configurations. ''' import helpers LEARNING_RATE = 5e-3 NUM_EPOCHS = 501 BATCH_SIZE = 128 LAMBDA_ = 0.5 M_PLUS = 0.9 M_MINUS = 0.1 DECAY_STEP = 20 DECAY_GAMMA = 0.95 CHECKPOINT_FOLDER = './saved_model/' CHECKPOINT_NAME = 'deepcaps.pth' DATASET_FOLDER = './dataset_folder/' GRAPHS_FOLDER = './graphs/' DEVICE = helpers.get_device() helpers.check_path(CHECKPOINT_FOLDER) helpers.check_path(DATASET_FOLDER) helpers.check_path(GRAPHS_FOLDER)
def train_model(model, dataloaders, num_classes, criterion, optimizer, scheduler=None,
num_epochs=25, device=None, uncertainty=False):
since = time.time()
if not device:
device = get_device()
best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0
losses = {"loss": [], "phase": [], "epoch": []}
accuracy = {"accuracy": [], "phase": [], "epoch": []}
evidences = {"evidence": [], "type": [], "epoch": []}
for epoch in range(num_epochs):
print("Epoch {}/{}".format(epoch, num_epochs - 1))
print("-" * 10)
# Each epoch has a training and validation phase
for phase in ["train", "val"]:
if phase == "train":
print("Training...")
model.train() # Set model to training mode
else:
print("Validating...")
model.eval() # Set model to evaluate mode
running_loss = 0.0
running_corrects = 0.0
correct = 0
# Iterate over data.
for i, (inputs, labels) in enumerate(dataloaders[phase]):
inputs = inputs.to(device)
labels = labels.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward
# track history if only in train
with torch.set_grad_enabled(phase == "train"):
if uncertainty:
y = one_hot_embedding(labels)
y = y.to(device)
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(
outputs, y.float(), epoch, num_classes, 10, device)
match = torch.reshape(torch.eq(
preds, labels).float(), (-1, 1))
acc = torch.mean(match)
evidence = relu_evidence(outputs)
alpha = evidence + 1
u = num_classes / torch.sum(alpha, dim=1, keepdim=True)
total_evidence = torch.sum(evidence, 1, keepdim=True)
mean_evidence = torch.mean(total_evidence)
mean_evidence_succ = torch.sum(
torch.sum(evidence, 1, keepdim=True) * match) / torch.sum(match + 1e-20)
mean_evidence_fail = torch.sum(
torch.sum(evidence, 1, keepdim=True) * (1 - match)) / (torch.sum(torch.abs(1 - match)) + 1e-20)
else:
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
if phase == "train":
loss.backward()
optimizer.step()
# statistics
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
if scheduler is not None:
if phase == "train":
scheduler.step()
epoch_loss = running_loss / len(dataloaders[phase].dataset)
epoch_acc = running_corrects.double(
) / len(dataloaders[phase].dataset)
losses["loss"].append(epoch_loss)
losses["phase"].append(phase)
losses["epoch"].append(epoch)
accuracy["accuracy"].append(epoch_acc.item())
accuracy["epoch"].append(epoch)
accuracy["phase"].append(phase)
print("{} loss: {:.4f} acc: {:.4f}".format(
phase.capitalize(), epoch_loss, epoch_acc))
# deep copy the model
if phase == "val" and epoch_acc > best_acc:
best_acc = epoch_acc
best_model_wts = copy.deepcopy(model.state_dict())
print()
time_elapsed = time.time() - since
print("Training complete in {:.0f}m {:.0f}s".format(
time_elapsed // 60, time_elapsed % 60))
print("Best val Acc: {:4f}".format(best_acc))
# load best model weights
model.load_state_dict(best_model_wts)
metrics = (losses, accuracy)
return model, metrics
def rotating_image_classification(model, img, filename, label_list, uncertainty=False, threshold=0.5, device=None):
print(label_list)
if not device:
device = get_device()
num_classes = 10
Mdeg = 180
Ndeg = int(Mdeg / 10) + 1
ldeg = []
lp = []
lu = []
classifications = []
scores = np.zeros((1, num_classes))
rimgs = np.zeros((28, 28 * Ndeg))
for i, deg in enumerate(np.linspace(0, Mdeg, Ndeg)):
nimg = rotate_img(img.numpy()[0], deg).reshape(28, 28)
nimg = np.clip(a=nimg, a_min=0, a_max=1)
rimgs[:, i*28:(i+1)*28] = nimg
trans = transforms.ToTensor()
img_tensor = trans(nimg)
img_tensor.unsqueeze_(0)
img_variable = Variable(img_tensor)
img_variable = img_variable.to(device)
if uncertainty:
output = model(img_variable)
evidence = relu_evidence(output)
alpha = evidence + 1
uncertainty = num_classes / torch.sum(alpha, dim=1, keepdim=True)
_, preds = torch.max(output, 1)
prob = alpha / torch.sum(alpha, dim=1, keepdim=True)
output = output.flatten()
prob = prob.flatten()
preds = preds.flatten()
classifications.append(preds[0].item())
lu.append(uncertainty.mean())
else:
output = model(img_variable)
_, preds = torch.max(output, 1)
prob = F.softmax(output, dim=1)
output = output.flatten()
prob = prob.flatten()
preds = preds.flatten()
classifications.append(preds[0].item())
scores += prob.detach().cpu().numpy() >= threshold
ldeg.append(deg)
lp.append(prob.tolist())
labels = np.arange(10)[scores[0].astype(bool)]
lp = np.array(lp)[:, labels]
c = ["black", "blue", "red", "brown", "purple", "cyan"]
marker = ["s", "^", "o"]*2
labels = labels.tolist()
fig = plt.figure(figsize=[6.2, 5])
fig, axs = plt.subplots(3, gridspec_kw={"height_ratios": [4, 1, 12]})
for i in range(len(labels)):
axs[2].plot(ldeg, lp[:, i], marker=marker[i], c=c[i])
if uncertainty:
labels += ["uncertainty"]
axs[2].plot(ldeg, lu, marker="<", c="red")
print(classifications)
axs[0].set_title("Rotated Image Classifications")
axs[0].imshow(1 - rimgs, cmap="gray")
axs[0].axis("off")
plt.pause(0.001)
empty_lst = []
empty_lst.append(classifications)
axs[1].table(cellText=empty_lst, bbox=[0, 1.2, 1, 1])
axs[1].axis("off")
axs[2].legend(labels)
axs[2].set_xlim([0, Mdeg])
axs[2].set_ylim([0, 1])
axs[2].set_xlabel("Rotation Degree")
axs[2].set_ylabel("Classification Probability")
plt.savefig(filename)
def main():
parser = argparse.ArgumentParser()
mode_group = parser.add_mutually_exclusive_group(required=True)
mode_group.add_argument("--train", action="store_true",
help="To train the network.")
mode_group.add_argument("--test", action="store_true",
help="To test the network.")
mode_group.add_argument("--examples", action="store_true",
help="To example MNIST data.")
parser.add_argument("--epochs", default=10, type=int,
help="Desired number of epochs.")
parser.add_argument("--dropout", action="store_true",
help="Whether to use dropout or not.")
parser.add_argument("--uncertainty", action="store_true",
help="Use uncertainty or not.")
uncertainty_type_group = parser.add_mutually_exclusive_group()
uncertainty_type_group.add_argument("--mse", action="store_true",
help="Set this argument when using uncertainty. Sets loss function to Expected Mean Square Error.")
uncertainty_type_group.add_argument("--digamma", action="store_true",
help="Set this argument when using uncertainty. Sets loss function to Expected Cross Entropy.")
uncertainty_type_group.add_argument("--log", action="store_true",
help="Set this argument when using uncertainty. Sets loss function to Negative Log of the Expected Likelihood.")
args = parser.parse_args()
if args.examples:
examples = enumerate(dataloaders["val"])
batch_idx, (example_data, example_targets) = next(examples)
fig = plt.figure()
for i in range(6):
plt.subplot(2, 3, i+1)
plt.tight_layout()
plt.imshow(example_data[i][0], cmap="gray", interpolation="none")
plt.title("Ground Truth: {}".format(example_targets[0][i]))
plt.xticks([])
plt.yticks([])
plt.savefig("./images/examples.jpg")
elif args.train:
num_epochs = args.epochs
use_uncertainty = args.uncertainty
num_classes = 10
#model = LeNet(dropout=args.dropout)
model = resnet18(False, num_classes=10)
# Have ResNet model take in grayscale rather than RGB
model.conv1 = torch.nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
if use_uncertainty:
if args.digamma:
criterion = edl_digamma_loss
elif args.log:
criterion = edl_log_loss
elif args.mse:
criterion = edl_mse_loss
else:
parser.error(
"--uncertainty requires --mse, --log or --digamma.")
else:
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3, weight_decay=0.005)
exp_lr_scheduler = optim.lr_scheduler.StepLR(
optimizer, step_size=7, gamma=0.1)
device = get_device()
model = model.to(device)
model, metrics = train_model(model, dataloaders, num_classes, criterion,
optimizer, scheduler=exp_lr_scheduler, num_epochs=num_epochs,
device=device, uncertainty=use_uncertainty)
state = {
"epoch": num_epochs,
"model_state_dict": model.state_dict(),
"optimizer_state_dict": optimizer.state_dict(),
}
if use_uncertainty:
if args.digamma:
torch.save(state, "./results/model_uncertainty_digamma.pt")
print("Saved: ./results/model_uncertainty_digamma.pt")
if args.log:
torch.save(state, "./results/model_uncertainty_log.pt")
print("Saved: ./results/model_uncertainty_log.pt")
if args.mse:
torch.save(state, "./results/model_uncertainty_mse.pt")
print("Saved: ./results/model_uncertainty_mse.pt")
else:
torch.save(state, "./results/model.pt")
print("Saved: ./results/model.pt")
elif args.test:
use_uncertainty = args.uncertainty
device = get_device()
#model = LeNet()
#model = LeNet(dropout=args.dropout)
model = resnet18(False, num_classes=10)
# Have ResNet model take in grayscale rather than RGB
model.conv1 = torch.nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
model = model.to(device)
optimizer = optim.Adam(model.parameters())
if use_uncertainty:
if args.digamma:
checkpoint = torch.load(
"./results/model_uncertainty_digamma.pt")
filename = "./results/rotate_uncertainty_digamma.jpg"
if args.log:
checkpoint = torch.load("./results/model_uncertainty_log.pt")
filename = "./results/rotate_uncertainty_log.jpg"
if args.mse:
checkpoint = torch.load("./results/model_uncertainty_mse.pt")
filename = "./results/rotate_uncertainty_mse.jpg"
else:
checkpoint = torch.load("./results/model.pt")
filename = "./results/rotate.jpg"
model.load_state_dict(checkpoint["model_state_dict"])
optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
model.eval()
rotating_image_classification(
model, digit_one, filename, uncertainty=use_uncertainty)
img = Image.open("./data/one.jpg").convert('L')
#test_single_image(model, img, uncertainty=use_uncertainty)
for i, tensor_img in enumerate([digit_zero, digit_one, digit_two,
digit_three, digit_four, digit_five,
digit_six, digit_seven, digit_eight, digit_nine]):
filename = "./results/loss_resnet_zoom_uncertainty_mse_affine_"+str(i)+".jpg"
zoom_image_classification(
model, tensor_img, filename, uncertainty=use_uncertainty)
def train(model, criterion, optimizer, data_dir, epochs=15, print_every=40, gpu=True, save=True, save_dir='.'):
"""
Trains a deep CNN to classify images of flowers
:param model: Model to train
:param criterion: Loss funtion
:param optimizer: Loss function optimizer
:param data_dir: Data directory for training, test and validation sets
:param epochs: Number of epochs to run the training
:param print_every: Print progress every print_every steps
:param gpu: Train on a GPU (if available)
:param save: Save the trained model on disk or not
:param save_dir: Directory where to save the checkpoint file
:return:
"""
device = get_device(gpu)
image_datasets, dataloaders = get_datasets_and_loaders(data_dir)
steps = 0
model.to(device)
# Save model hyperparameters
model.epochs = epochs
for e in range(epochs):
running_loss = 0
for ii, (inputs, labels) in enumerate(dataloaders['train']):
steps += 1
model.train()
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
# Forward and backward passes
outputs = model.forward(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
model.eval()
val_loss = 0
accuracy = 0
for ii, (inputs_val, labels_val) in enumerate(dataloaders['validation']):
optimizer.zero_grad()
inputs_val, labels_val = inputs_val.to(device), labels_val.to(device)
model.to(device)
with torch.no_grad():
outputs = model.forward(inputs_val)
val_loss = criterion(outputs, labels_val)
ps = torch.exp(outputs).data
equality = (labels_val.data == ps.max(1)[1])
accuracy += equality.type_as(torch.FloatTensor()).mean()
val_loss = val_loss / len(dataloaders['validation'])
accuracy = accuracy / len(dataloaders['validation'])
print("Epoch: {}/{}... ".format(e + 1, epochs),
"Loss: {:.4f}".format(running_loss / print_every),
"Validation Loss {:.4f}".format(val_loss),
"Accuracy: {:.4f}".format(accuracy))
running_loss = 0
if save:
save_model(model, image_datasets['train'].class_to_idx, dest=save_dir)
# Check accuracy after training
accuracy = check_accuracy(model, dataloaders['test'])
logging.info('Accuracy of the network on the test images: %d %%' % accuracy)
return model
def select_best_hyper_base(chans: list,
nb_hidden1: list,
nb_hidden2: list,
nb_hidden3: list,
etas: list,
n_runs: int = 10,
epochs: int = 25,
verbose: bool = False) -> dict:
"""
Partial grid search over hyper-parameters for the baseline network, to find
the best combination. This function makes sure that only combinations with
number of channels that increase with depth are tested.
:param chans: number of channels for each convolution layer (3)
:param nb_hidden1: number of hidden units for 1st fully connected layer
:param nb_hidden2: number of hidden units for 2nd fully connected layer
:param nb_hidden3: number of hidden units for 3rd fully connected layer
:param etas: eta values to test
:param n_runs: number of runs over which to average results
:param epochs: number of epochs
:param verbose: activate verbose printing
:return: best_params, dict of best parameters found
"""
device = get_device()
best_acc = 0
best_params = {
"eta": 0,
"chan1": 0,
"chan2": 0,
"chan3": 0,
"nb_hidden1": 0,
"nb_hidden2": 0,
"nb_hidden3": 0
}
# Start grid search
for eta in etas:
for i1 in range(len(chans) - 2):
c1 = chans[i1]
for i2 in range(i1 + 1, len(chans) - 1):
c2 = chans[i2]
for i3 in range(i2 + 1, len(chans)):
c3 = chans[i3]
for h1 in nb_hidden1:
for h2 in nb_hidden2:
for h3 in nb_hidden3:
tot_acc = 0
for i in range(0, n_runs):
# Create net, train it and compute accuracy on test data
model = BaseNet(c1, c2, c3, h1, h2,
h3).to(device)
criterion = nn.CrossEntropyLoss().to(
device)
# A new train/test set is used at each run to avoid overfitting a dataset
train_loader, test_loader = get_data()
train_basic_model(model,
train_loader,
criterion,
epochs,
eta,
optim="Adam")
acc = compute_accuracy(model, test_loader)
tot_acc += acc
del model
# Compute accuracy of the params set
acc_run = tot_acc / n_runs
if verbose:
print(
"Eta = {}, chan1 = {}, chan2 = {}, chan3 = {}, "
"hidden1 = {}, hidden2 = {}, hidden3 = {}, avg_acc = {}"
.format(eta, c1, c2, c3, h1, h2, h3,
acc_run))
# Save params
if acc_run > best_acc:
best_acc = acc_run
best_params["eta"] = eta
best_params["chan1"] = c1
best_params["chan2"] = c2
best_params["chan3"] = c3
best_params["nb_hidden1"] = h1
best_params["nb_hidden2"] = h2
best_params["nb_hidden3"] = h3
if verbose:
print(
"New best combination: Eta = {}, chan1 = {}, chan2 = {}, chan3 = {}, "
"hidden1 = {}, hidden2 = {}, hidden3 = {}, avg_acc = {}"
.format(eta, c1, c2, c3, h1, h2,
h3, acc_run))
print("Best result found! Acc: {}, "
"params: Eta = {}, chan1 = {}, "
"chan2 = {}, chan3 = {}, "
"hidden1 = {}, hidden2 = {}, hidden3 = {}".format(
best_acc, best_params["eta"], best_params["chan1"],
best_params["chan2"], best_params["chan3"],
best_params["nb_hidden1"], best_params["nb_hidden2"],
best_params["nb_hidden3"]))
return best_params
virtualViewport.add_hotspot(rowOneA, (0, 0))
virtualViewport.add_hotspot(rowOneB, (width - w, 0))
virtualViewport.add_hotspot(rowTwoA, (0, 16))
virtualViewport.add_hotspot(rowTwoB, (callingWidth, 16))
virtualViewport.add_hotspot(rowThreeA, (0, 32))
virtualViewport.add_hotspot(rowThreeB, (width - w, 32))
virtualViewport.add_hotspot(rowTime, (0, 50))
return virtualViewport
try:
config = loadConfig()
device = get_device()
font = makeFont("Dot Matrix Regular.ttf", 16)
fontBold = makeFont("Dot Matrix Bold.ttf", 16)
fontBoldLarge = makeFont("Dot Matrix Bold.ttf", 20)
widgetWidth = 256
widgetHeight = 64
stationRenderCount = 0
pauseCount = 0
loop_count = 0
data = loadData(config["transportApi"], config["journey"])
virtual = drawSignage(device, width=widgetWidth,
height=widgetHeight, data=data)
timeAtStart = time.time()
def zoom_image_classification(model,
img,
filename,
uncertainty=False,
threshold=0.2,
device=None):
if not device:
device = get_device()
num_classes = 10
zoom_images = 5
ldeg = []
lp = []
lu = []
classifications = []
scores = np.zeros((1, num_classes))
rimgs = np.zeros((28, 28 * zoom_images))
image_sizes = (np.random.dirichlet([25, 10, 10, 10, 10]) * 28).astype(int)
ss = 0
x = int(np.random.rand() * 28)
y = int(np.random.rand() * 28)
for i, image_size in enumerate(image_sizes):
ss += image_size
nimg = reduce_img(img, ss, [x, y])
nimg = np.clip(a=nimg, a_min=0, a_max=1)
rimgs[:, i * 28:(i + 1) * 28] = nimg
trans = transforms.ToTensor()
img_tensor = trans(nimg)
img_tensor.unsqueeze_(0)
img_variable = Variable(img_tensor)
img_variable = img_variable.to(device)
if uncertainty:
output = model(img_variable)
evidence = relu_evidence(output)
alpha = evidence + 1
uncertainty = num_classes / torch.sum(alpha, dim=1, keepdim=True)
_, preds = torch.max(output, 1)
prob = alpha / torch.sum(alpha, dim=1, keepdim=True)
output = output.flatten()
prob = prob.flatten()
preds = preds.flatten()
classifications.append(preds[0].item())
lu.append(uncertainty.mean())
else:
output = model(img_variable)
_, preds = torch.max(output, 1)
prob = F.softmax(output, dim=1)
output = output.flatten()
prob = prob.flatten()
preds = preds.flatten()
classifications.append(preds[0].item())
scores += prob.detach().cpu().numpy() >= threshold
ldeg.append(ss)
lp.append(prob.tolist())
labels = np.arange(10)[scores[0].astype(bool)]
lp = np.array(lp)[:, labels]
c = ["blue", "red", "brown", "purple", "cyan"]
marker = ["s", "^", "o"] * 2
labels = labels.tolist()
fig = plt.figure(figsize=[6, 5])
fig, axs = plt.subplots(3, gridspec_kw={"height_ratios": [5, 1, 12]})
for i in range(len(labels)):
axs[2].plot(ldeg, lp[:, i], marker=marker[i], c=c[i])
if uncertainty:
labels += ["uncertainty"]
axs[2].plot(ldeg, lu, marker="<", c="black")
#axs[0].set_title("Zoomed \"1\" Digit Classifications")
axs[0].imshow(1 - rimgs, cmap="gray")
axs[0].axis("off")
#plt.pause(0.001)
empty_lst = []
empty_lst.append(classifications)
axs[1].table(cellText=empty_lst, bbox=[0, 1, 1, 1])
axs[1].axis("off")
axs[2].legend(labels)
axs[2].set_xlim([8, 28])
axs[2].set_ylim([0, 1])
axs[2].set_xlabel("Zoom pixels")
axs[2].set_ylabel("Classification Probability")
#fig.show()
fig.savefig(filename)
