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)