def run_alexnet_ann_recall_test_simulation_trial3(): # instantiate alexnet from mnist trained alex_cnn = AlexNet() alex_cnn.load_state_dict(torch.load("trained_models/alexnet.pt", map_location=torch.device("cpu"))) alex_cnn.eval() alex_capture = Intermediate_Capture(alex_cnn.fc1) # for now capture final output return run_alexnet_ann_recall_simulation(alex_cnn=alex_cnn, alex_capture=alex_capture, output_name="alexnet_recall_task_trial3.txt", num_nodes=1024)
def bpda_all(): model_list = { 'naive-alexnet':"/media/dsg3/dsgprivate/yuhang/model/alexnet/naive/naive_param.pkl", 'new-AT-alexnet':"/media/dsg3/dsgprivate/yuhang/model/alexnet/nat/naive_param.pkl", 'ensemble-AT-alexnet':"/media/dsg3/dsgprivate/yuhang/model/alexnet/eat/naive_param.pkl", #'DPLAT-alexnet':"/media/dsg3/dsgprivate/yuhang/model/alexnet/dplat/lat_param.pkl", } if args.model == 'alexnet': model = AlexNet(enable_lat=args.enable_lat, epsilon=args.lat_epsilon, pro_num=args.lat_pronum, batch_size=args.model_batchsize, num_classes=200, if_dropout=args.dropout ).cuda() elif args.model == 'alexnetBN': model = AlexNetBN(enable_lat=args.enable_lat, epsilon=args.lat_epsilon, pro_num=args.lat_pronum, batch_size=args.model_batchsize, num_classes=200, if_dropout=args.dropout ).cuda() # if cifar then normalize epsilon from [0,255] to [0,1] ''' if args.dataset == 'cifar10': eps = args.attack_epsilon / 255.0 else: eps = args.attack_epsilon ''' eps = args.attack_epsilon #eps = args.attack_epsilon # the last layer of densenet is F.log_softmax, while CrossEntropyLoss have contained Softmax() attack = Attack(dataroot = "/media/dsg3/dsgprivate/lat/data/sampled_imagenet/", dataset = args.dataset, batch_size = args.attack_batchsize, target_model = model, criterion = nn.CrossEntropyLoss(), epsilon = eps, alpha = args.attack_alpha, iteration = args.attack_iter) for target in model_list: print('------Now target model is {} -------'.format(target)) model_path = model_list[target] model.load_state_dict(torch.load((model_path))) print('model successfully loaded') attack.i_fgsm()
class TestNetwork(): def __init__(self, dataset, batch_size, epochs): self.dataset = dataset self.batch_size = batch_size self.epochs = epochs # letters contains 27 classes, digits contains 10 classes num_classes = 27 if dataset == 'letters' else 10 # Load mdoel and use cuda if available self.model = AlexNet(num_classes) if torch.cuda.is_available(): self.model.cuda() # Load testing dataset kwargs = { 'num_workers': 1, 'pin_memory': True } if torch.cuda.is_available() else {} self.test_loader = torch.utils.data.DataLoader(EMNIST( './data', dataset, download=True, transform=transforms.Compose([ transforms.Lambda(correct_rotation), transforms.Resize((224, 224)), transforms.Grayscale(3), transforms.ToTensor(), ]), train=False), batch_size=batch_size, shuffle=True, **kwargs) # Optimizer and loss function self.loss_fn = nn.CrossEntropyLoss() def test(self, epoch): """ Test the model for one epoch with a pre trained network :param epoch: Current epoch :return: None """ # Load weights from trained model state_dict = torch.load( './trained_models/{}_{}.pth'.format(self.dataset, epoch), map_location=lambda storage, loc: storage)['model'] self.model.load_state_dict(state_dict) self.model.eval() test_loss = 0 test_correct = 0 progress = None for batch_idx, (data, target) in enumerate(self.test_loader): # Get data and label if torch.cuda.is_available(): data, target = data.cuda(), target.cuda() data, target = Variable(data), Variable(target) # output = self.model(data) loss = self.loss_fn(output, target) test_loss += loss.data[0] pred = output.data.max(1, keepdim=True)[1] test_correct += pred.eq(target.data.view_as(pred)).sum() # Print information about current step current_progress = int(100 * (batch_idx + 1) * self.batch_size / len(self.test_loader.dataset)) if current_progress is not progress and current_progress % 5 == 0: progress = current_progress print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, (batch_idx + 1) * len(data), len(self.test_loader.dataset), current_progress, loss.data[0])) test_loss /= (len(self.test_loader.dataset) / self.batch_size) test_correct /= len(self.test_loader.dataset) test_correct *= 100 # Print information about current epoch print( 'Test Epoch: {} \tCorrect: {:3.2f}%\tAverage loss: {:.6f}'.format( epoch, test_correct, test_loss)) def start(self): """ Start testing the network :return: None """ for epoch in range(1, self.epochs + 1): self.test(epoch)
elif args.model == 'resnet': cnn = ResNet18(enable_lat=args.enable_lat, epsilon=args.epsilon, pro_num=args.pro_num, batch_size=args.batchsize, num_classes=200, if_dropout=args.dropout) #cnn.apply(conv_init) elif args.model == 'alexnetBN': cnn = AlexNetBN(enable_lat=args.enable_lat, epsilon=args.epsilon, pro_num=args.pro_num, batch_size=args.batchsize, num_classes=200, if_dropout=args.dropout) cnn.cuda() if os.path.exists(real_model_path): cnn.load_state_dict(torch.load(real_model_path)) print('model successfully loaded.') else: print("load model failed.") if args.test_flag: if args.adv_flag: test_all(cnn) else: test_op(cnn) else: train_op(cnn)
import torch from torch.nn.functional import softmax from alexnet import AlexNet from utils import cifar10_loader, device, cifar10_classes torch.random.manual_seed(128) batch_size = 1 testloader = cifar10_loader(train=False, batch_size=batch_size) net = AlexNet() net.load_state_dict(torch.load("model/model.h5")) net.eval() correct = 0 total = 0 def run(): global correct, total with torch.no_grad(): for data in testloader: images, labels = data inputs, labels = images.to(device), labels.to(device) outputs = net(inputs) _, predicted = torch.topk(outputs.data, 5) #print(predicted) indexes = predicted.numpy()[0].tolist() #print(indexes) #print(softmax(outputs).numpy()[0][indexes]) #print([cifar10_classes[i] for i in indexes])
def test_task2(root_path): ''' :param root_path: root path of test data, e.g. ./dataset/task2/test/0/ :return results: a dict of classification results results = {'audio_0000.pkl': 23, ‘audio_0001’: 11, ...} This means audio 'audio_0000.pkl' is matched to video 'video_0023' and ‘audio_0001’ is matched to 'video_0011'. ''' results = dict() os.chdir(os.path.split(os.path.realpath(__file__))[0]) audio_transforms = transforms.Compose([transforms.ToTensor()]) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') label_list = [9, 2, 3, 8, 7, 6, 5, 0, 4, 1] audio_model = ResNet.resnet18(num_classes=10) audio_model = audio_model.to(device) audio_model = torch.nn.DataParallel(audio_model) audio_model.load_state_dict(torch.load('./model/resnet18.pth')) audio_model.eval() audio_class_features = [] video_class_features = [] audio_motion_features = [] video_motion_features = [] Files = list(filter(lambda x: x.endswith(".pkl"), os.listdir(root_path))) Files.sort() for sample in Files: audio_path = root_path + '/' + sample data = np.load(audio_path, allow_pickle=True)['audio'] for i in range(4): S = librosa.resample(data[:, i], orig_sr=44100, target_sr=11000) S = np.abs(librosa.stft(S[5650:-5650], n_fft=510, hop_length=128)) S = np.log10(S + 0.0000001) S = np.clip(S, -5, 5) S -= np.min(S) S = 255 * (S / np.max(S)) if S.shape[-1] < 256: S = np.pad(S, ((0, 0), (int(np.ceil((256 - S.shape[-1]) / 2)), int(np.floor( (256 - S.shape[-1]) / 2))))) if S.shape[-1] > 256: S = S[:, int(np.ceil((S.shape[-1] - 256) / 2)):-int(np.floor((S.shape[-1] - 256) / 2))] if i == 0: feature = np.uint8(S)[:, :, np.newaxis] else: feature = np.concatenate( (np.uint8(S)[:, :, np.newaxis], feature), axis=-1) X = audio_transforms(feature) X = X.to(device) class_feature_t = torch.softmax(audio_model(X.unsqueeze(0)), dim=-1).squeeze(0) class_feature = np.zeros(10) for i in range(10): class_feature[label_list[i]] = class_feature_t[i] threshold = 0.35 label_list2 = [1, 2, 0, 3] label = [0] * 4 for i in range(4): if np.max(data[:, i]) > threshold: label[label_list2[i]] = 1 audio_class_features.append(class_feature) audio_motion_features.append(label) net = AlexNet() net.load_state_dict(torch.load('./model/alexnet.pt')) k = 0 while os.path.exists(root_path + '/video_' + str('%04d' % k)): video_class_feature, video_move_feature = get_video_feature( net, root_path + '/video_' + str('%04d' % k)) video_class_features.append(video_class_feature) video_motion_features.append(video_move_feature) k = k + 1 indices = pairing(audio_class_features, audio_motion_features, video_class_features, video_motion_features, -100) j = 0 for sample in Files: results[sample] = indices[j][1] j = j + 1 return results
targets = torch.tensor(testset.targets) targets[targets >= 5] = 5 testset.targets = targets.tolist() testloader = torch.utils.data.DataLoader(testset, batch_size=args.bs, shuffle=False, num_workers=4) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # Model print('==> Building model..') net = AlexNet(5) checkpoint_path = 'cifar_10_alexnet.t7' checkpoint = torch.load(checkpoint_path,map_location=torch.device('cpu')) try: net.load_state_dict(checkpoint['net']) except: new_check_point = OrderedDict() for k, v in checkpoint['net'].items(): name = k[7:] # remove `module.` # name = k[9:] # remove `module.1.` new_check_point[name] = v net.load_state_dict(new_check_point) net = net.to(device) if device == 'cuda': net = torch.nn.DataParallel(net) cudnn.benchmark = True
if args.model == 'vgg': model = VGG16(enable_lat=False, epsilon=0.6, pro_num=5, batch_size=args.batch_size, if_dropout=True) elif args.model == 'resnet': model = ResNet50(enable_lat=False, epsilon=0.6, pro_num=5, batch_size=args.batch_size, if_dropout=True) elif args.model == 'alexnet': model = AlexNet(enable_lat=False, epsilon=0.6, pro_num=5, batch_size=args.batch_size, num_classes=200, if_dropout=True) model.cuda() if os.path.exists(args.model_path): model.load_state_dict(torch.load(args.model_path)) print('load model successfully.') else: print("load failed.") if args.test_flag: test_all(model) else: test_op(model)
class TrainNetwork(): def __init__(self, dataset, batch_size, epochs, lr, lr_decay_epoch, momentum): assert (dataset == 'letters' or dataset == 'mnist') self.dataset = dataset self.batch_size = batch_size self.epochs = epochs self.lr = lr self.lr_decay_epoch = lr_decay_epoch self.momentum = momentum # letters contains 27 classes, digits contains 10 classes num_classes = 27 if dataset == 'letters' else 10 # Load pre learned AlexNet with changed number of output classes state_dict = torch.load('./trained_models/alexnet.pth') state_dict['classifier.6.weight'] = torch.zeros(num_classes, 4096) state_dict['classifier.6.bias'] = torch.zeros(num_classes) self.model = AlexNet(num_classes) self.model.load_state_dict(state_dict) # Use cuda if available if torch.cuda.is_available(): self.model.cuda() # Load training dataset kwargs = { 'num_workers': 1, 'pin_memory': True } if torch.cuda.is_available() else {} self.train_loader = torch.utils.data.DataLoader( EMNIST('./data', dataset, download=True, transform=transforms.Compose([ transforms.Lambda(correct_rotation), transforms.Lambda(random_transform), transforms.Resize((224, 224)), transforms.RandomResizedCrop(224, (0.9, 1.1), ratio=(0.9, 1.1)), transforms.Grayscale(3), transforms.ToTensor(), ])), batch_size=batch_size, shuffle=True, **kwargs) # Optimizer and loss function self.optimizer = optim.SGD(self.model.parameters(), lr=self.lr, momentum=self.momentum) self.loss_fn = nn.CrossEntropyLoss() def reduce_learning_rate(self, epoch): """ Reduce the learning rate by factor 0.1 every lr_decay_epoch :param optimizer: Optimizer containing the learning rate :param epoch: Current epoch :param init_lr: Initial learning rate :param lr_decay_epoch: Number of epochs until learning rate gets reduced :return: None """ lr = self.lr * (0.1**(epoch // self.lr_decay_epoch)) if epoch % self.lr_decay_epoch == 0: print('LR is set to {}'.format(lr)) for param_group in self.optimizer.param_groups: param_group['lr'] = lr def train(self, epoch): """ Train the model for one epoch and save the result as a .pth file :param epoch: Current epoch :return: None """ self.model.train() train_loss = 0 train_correct = 0 progress = None for batch_idx, (data, target) in enumerate(self.train_loader): # Get data and label if torch.cuda.is_available(): data, target = data.cuda(), target.cuda() data, target = Variable(data), Variable(target) # Optimize using backpropagation self.optimizer.zero_grad() output = self.model(data) loss = self.loss_fn(output, target) train_loss += loss.data[0] pred = output.data.max(1, keepdim=True)[1] train_correct += pred.eq(target.data.view_as(pred)).sum() loss.backward() self.optimizer.step() # Print information about current step current_progress = int(100 * (batch_idx + 1) * self.batch_size / len(self.train_loader.dataset)) if current_progress is not progress and current_progress % 5 == 0: progress = current_progress print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, (batch_idx + 1) * len(data), len(self.train_loader.dataset), current_progress, loss.data[0])) train_loss /= (len(self.train_loader.dataset) / self.batch_size) train_correct /= len(self.train_loader.dataset) train_correct *= 100 # Print information about current epoch print( 'Train Epoch: {} \tCorrect: {:3.2f}%\tAverage loss: {:.6f}'.format( epoch, train_correct, train_loss)) # Save snapshot torch.save( { 'model': self.model.state_dict(), 'optimizer': self.optimizer.state_dict() }, './trained_models/{}_{}.pth'.format(self.dataset, epoch)) def start(self): """ Start training the network :return: None """ for epoch in range(1, self.epochs + 1): self.reduce_learning_rate(epoch) self.train(epoch)
# Model print('==> Building model..') net = AlexNet() net = net.to(device) if device == 'cuda': net = torch.nn.DataParallel(net) cudnn.benchmark = True if args.resume: # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!' checkpoint = torch.load('./checkpoint/ckpt.pth') net.load_state_dict(checkpoint['net']) best_acc = checkpoint['acc'] start_epoch = checkpoint['epoch'] criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=0.9, weight_decay=5e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200) # Training def train(epoch): print('\nEpoch: %d' % epoch) net.train()
class LiveShowcase: def __init__(self, path_to_model): num_classes = 27 # Member variables self.status = 'Ready' self.last_words = None self.dictionary_set = set(nltk.corpus.words.words()) # Load pre learned AlexNet state_dict = torch.load(path_to_model, map_location=lambda storage, loc: storage)['model'] self.model = AlexNet(num_classes) self.model.load_state_dict(state_dict) self.model.eval() def process_image(self, image, bounding_boxes): """ Process image to find and classify characters and build 5 most probable words :param image: rgb image :param bounding_boxes: list of bounding boxes containing characters (min_x, min_y, width, height) :return: None """ self.status = 'Processing' # Find 5 most probable words subimages = extract_characters(image, bounding_boxes) words = classify_characters(self.model, subimages) self.last_words = words[:5] self.status = 'Ready' def start(self, max_bounding_boxes=10): """ Start the live showcase using a camera :return: None """ # Try to open a connection to the camera cap = cv2.VideoCapture(0) if not cap.isOpened(): print('Error: No camera found') return cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 960) print('Press q to stop the live showcase') while True: # Capture frame-by-frame ret, image = cap.read() output = image # Find bounding boxes for each character image = preprocess_image(image) bounding_boxes = find_bounding_boxes(image) bounding_boxes = filter_bounding_boxes(image, bounding_boxes) for box in bounding_boxes: cv2.rectangle(output, (box[0], box[1]), (box[0] + box[2], box[1] + box[3]), (0, 0, 255), 2) # Process image if no other image is processed if self.status.__contains__('Ready'): if len(bounding_boxes) > max_bounding_boxes: self.status = 'Ready [Warning: too many bounding boxes]' self.last_words = None else: thread = threading.Thread(target=self.process_image, args=(image, bounding_boxes), daemon=True) thread.start() # Draw status bar with last recognized words cv2.putText(output, 'Status: {}'.format(self.status), (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA) if self.last_words: for offset, word in zip(range(len(self.last_words)), self.last_words): color = (0, 0, 0) # Use green color if word is in dictionary if word[0].lower() in self.dictionary_set: color = (0, 255, 0) cv2.putText(output, '{} ({:5.2f}%)'.format(word[0], 100 * word[1]), (10, 20 + (offset + 1) * 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1, cv2.LINE_AA) # Draw bounding box around detected word if self.last_words and len(bounding_boxes) > 1: word = self.last_words[0] color = (0, 0, 255) # Use green color if word is in dictionary if word[0].lower() in self.dictionary_set: color = (0, 255, 0) text = '{} ({:5.2f}%)'.format(word[0], 100 * word[1]) padding = 10 top_left = (np.min([b[0] for b in bounding_boxes]) - padding, np.min([b[1] for b in bounding_boxes]) - padding) bottom_right = (np.max([b[0]+b[2] for b in bounding_boxes]) + padding, np.max([b[1]+b[3] for b in bounding_boxes]) + padding) text_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)[0] cv2.rectangle(output, (top_left[0] - 1, top_left[1] - text_size[1] - 2 * padding), (top_left[0] + text_size[0] + 2 * padding, top_left[1]), color, thickness=cv2.FILLED) cv2.putText(output, text, (top_left[0] + padding, top_left[1] - padding), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA) cv2.rectangle(output, top_left, bottom_right, color, 2) # Display the resulting frame cv2.imshow('Image internal', image) cv2.imshow('Showcase', output) if cv2.waitKey(1) & 0xFF == ord('q'): break # When everything done, release the capture cap.release() cv2.destroyAllWindows()
def main(): progress = default_progress() experiment_dir = 'experiment/miniplaces' # Here's our data train_loader = torch.utils.data.DataLoader(CachedImageFolder( 'dataset/miniplaces/simple/train', transform=transforms.Compose([ transforms.Resize(128), transforms.RandomCrop(119), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV) ])), batch_size=64, shuffle=True, num_workers=6, pin_memory=True) val_loader = torch.utils.data.DataLoader(CachedImageFolder( 'dataset/miniplaces/simple/val', transform=transforms.Compose([ transforms.Resize(128), transforms.CenterCrop(119), transforms.ToTensor(), transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV) ])), batch_size=512, shuffle=False, num_workers=6, pin_memory=True) # Create a simplified AlexNet with half resolution. model = AlexNet(first_layer='conv1', last_layer='fc8', layer_sizes=dict(fc6=2048, fc7=2048), output_channels=100, half_resolution=True, include_lrn=False, split_groups=False).cuda() # Use Kaiming initialization for the weights for name, val in model.named_parameters(): if 'weight' in name: init.kaiming_uniform_(val) else: # Init positive bias in many layers to avoid dead neurons. assert 'bias' in name init.constant_( val, 0 if any( name.startswith(layer) for layer in ['conv1', 'conv3', 'fc8']) else 1) # An abbreviated training schedule: 40000 batches. # TODO: tune these hyperparameters. # init_lr = 0.002 init_lr = 0.002 # max_iter = 40000 - 34.5% @1 # max_iter = 50000 - 37% @1 # max_iter = 80000 - 39.7% @1 # max_iter = 100000 - 40.1% @1 max_iter = 100000 criterion = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.SGD( model.parameters(), lr=init_lr, momentum=0.9, # 0.9, # weight_decay=0.001) weight_decay=0.001) iter_num = 0 best = dict(val_accuracy=0.0) model.train() # Oh, hold on. Let's actually resume training if we already have a model. checkpoint_filename = 'miniplaces.pth.tar' best_filename = 'best_%s' % checkpoint_filename best_checkpoint = os.path.join(experiment_dir, best_filename) try_to_resume_training = False if try_to_resume_training and os.path.exists(best_checkpoint): checkpoint = torch.load(os.path.join(experiment_dir, best_filename)) iter_num = checkpoint['iter'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) best['val_accuracy'] = checkpoint['accuracy'] def save_checkpoint(state, is_best): filename = os.path.join(experiment_dir, checkpoint_filename) ensure_dir_for(filename) torch.save(state, filename) if is_best: shutil.copyfile(filename, os.path.join(experiment_dir, best_filename)) def validate_and_checkpoint(): model.eval() val_loss, val_acc = AverageMeter(), AverageMeter() for input, target in progress(val_loader): # Load data input_var, target_var = [ Variable(d.cuda(non_blocking=True)) for d in [input, target] ] # Evaluate model with torch.no_grad(): output = model(input_var) loss = criterion(output, target_var) _, pred = output.max(1) accuracy = (target_var.eq(pred) ).data.float().sum().item() / input.size(0) val_loss.update(loss.data.item(), input.size(0)) val_acc.update(accuracy, input.size(0)) # Check accuracy post_progress(l=val_loss.avg, a=val_acc.avg) # Save checkpoint save_checkpoint( { 'iter': iter_num, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), 'accuracy': val_acc.avg, 'loss': val_loss.avg, }, val_acc.avg > best['val_accuracy']) best['val_accuracy'] = max(val_acc.avg, best['val_accuracy']) post_progress(v=val_acc.avg) # Here is our training loop. while iter_num < max_iter: for input, target in progress(train_loader): # Track the average training loss/accuracy for each epoch. train_loss, train_acc = AverageMeter(), AverageMeter() # Load data input_var, target_var = [ Variable(d.cuda(non_blocking=True)) for d in [input, target] ] # Evaluate model output = model(input_var) loss = criterion(output, target_var) train_loss.update(loss.data.item(), input.size(0)) # Perform one step of SGD optimizer.zero_grad() loss.backward() optimizer.step() # Also check training set accuracy _, pred = output.max(1) accuracy = (target_var.eq(pred)).data.float().sum().item() / ( input.size(0)) train_acc.update(accuracy) remaining = 1 - iter_num / float(max_iter) post_progress(l=train_loss.avg, a=train_acc.avg, v=best['val_accuracy']) # Advance iter_num += 1 if iter_num >= max_iter: break # Linear learning rate decay lr = init_lr * remaining for param_group in optimizer.param_groups: param_group['lr'] = lr # Ocassionally check validation set accuracy and checkpoint if iter_num % 1000 == 0: validate_and_checkpoint() model.train()
magnitude_loss = 0.0001 * F.mse_loss(target=real_eig_vals, input=fake_eig_vals) structure_loss = -torch.sum(torch.mul(fake_eig_vecs, real_eig_vecs), 0) normalized_real_eig_vals = normalize_min_max(real_eig_vals) weighted_structure_loss = torch.sum( torch.mul(normalized_real_eig_vals, structure_loss)) return magnitude_loss + weighted_structure_loss netG = Generator(ngpu).to(device) netG.apply(weights_init) if opt.netG != '': netG.load_state_dict(torch.load(opt.netG)) print(netG) netC = AlexNet(ngpu).to(device) netC.load_state_dict(torch.load('./best_model.pth')) print(netC) netC.eval() netD = Discriminator(ngpu).to(device) netD.apply(weights_init) if opt.netD != '': netD.load_state_dict(torch.load(opt.netD)) print(netD) criterion = nn.BCELoss() criterion_sum = nn.BCELoss(reduction='sum') fixed_noise = torch.randn(opt.batchSize, 100, 1, 1, device=device) real_label = 1
[transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) test_dataset = datasets.ImageFolder(root=image_path + "/test", transform=data_transform) test_num = len(test_dataset) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=16, shuffle=True, num_workers=0) model=AlexNet(num_classes=2) model_weight_path = "./models/AlexNet.pth" model.load_state_dict(torch.load(model_weight_path)) model.eval() correct = 0 total = 0 acc = 0.0 confusion_matrix = meter.ConfusionMeter(2) for i, sample in enumerate(test_loader): inputs, labels = sample[0], sample[1] outputs = model(inputs) _, prediction = torch.max(outputs, 1) correct += (labels == prediction).sum().item() total += labels.size(0)
def run_alexnet_ann_recall_test_simulation_trial4(): num_nodes = 10 alex_cnn1 = AlexNet() alex_cnn1.load_state_dict(torch.load("trained_models/alexnet.pt", map_location=torch.device("cpu"))) alex_cnn1.eval() alex_capture1 = Intermediate_Capture(alex_cnn1.layer3) # for now capture final output output_name = "alexnet_recall_task_trial4.txt" alex_cnn2 = AlexNet() alex_cnn2.load_state_dict(torch.load("trained_models/alexnet.pt", map_location=torch.device("cpu"))) alex_cnn2.eval() alex_capture2 = Intermediate_Capture(alex_cnn2.layer4) # for now capture final output alex_cnn3 = AlexNet() alex_cnn3.load_state_dict(torch.load("trained_models/alexnet.pt", map_location=torch.device("cpu"))) alex_cnn3.eval() alex_capture3 = Intermediate_Capture(alex_cnn3.layer5) # for now capture final output transform = transforms.ToTensor() data_raw = MNIST( root='./data/mnist', train=True, download=True, transform=transform) # creating a toy dataset for simple probing mnist_subset = {0:[], 1:[], 2:[], 3:[], 4:[], 5:[], 6:[], 7:[], 8:[], 9:[]} per_class_sizes = {0:10, 1:10, 2:10, 3:10, 4:10, 5:10, 6:10, 7:10, 8:10, 9:10} for i in range(len(data_raw)): image, label = data_raw[i] if len(mnist_subset[label]) < per_class_sizes[label]: mnist_subset[label].append(torch.reshape(image, (1,1, 28,28))) done = True for k in mnist_subset: if len(mnist_subset[k]) < per_class_sizes[k]: done=False if done: break # converts mnist_subset into table that is usable for model input full_pattern_set = [] full_label_set = [] for k in mnist_subset: for v in mnist_subset[k]: full_pattern_set.append(v) full_label_set.append(k) # given list of a desired labels, randomly choose an example of each label from the mnist dataset to store stored_size_vs_performance = [] # list will store tuples of (hopfield perf, popularity perf, ortho perf) for desired_label_size in range(10): desired_labels = list(range(desired_label_size+1)) full_stored_set, full_stored_labels = create_storage_set(desired_labels, mnist_subset, reshape=False, make_numpy=False) print("Num Stored: ", len(desired_labels)) # evaluate hopnet performance ann_model = hopnet(6272) model = CNN_ANN(alex_cnn1, ann_model, alex_capture1, capture_process_fn=lambda x: np.sign(np.exp(x)-np.exp(x).mean())) num_succ, num_fail = evaluate_model_recall(model, full_stored_set, full_stored_labels, full_stored_set, full_stored_labels, verbose=False) print("Alexnet Layer3:", num_succ, ":", num_fail) layer3_perf = int(num_succ) ann_model = hopnet(12544) model = CNN_ANN(alex_cnn2, ann_model, alex_capture2, capture_process_fn=lambda x: np.sign(np.exp(x)-np.exp(x).mean())) num_succ, num_fail = evaluate_model_recall(model, full_stored_set, full_stored_labels, full_stored_set, full_stored_labels, verbose=False) print("Alexnet Layer3:", num_succ, ":", num_fail) layer4_perf = int(num_succ) ann_model = hopnet(2304) model = CNN_ANN(alex_cnn3, ann_model, alex_capture3, capture_process_fn=lambda x: np.sign(np.exp(x)-np.exp(x).mean())) num_succ, num_fail = evaluate_model_recall(model, full_stored_set, full_stored_labels, full_stored_set, full_stored_labels, verbose=False) print("Alexnet Layer3:", num_succ, ":", num_fail) layer5_perf = int(num_succ) stored_size_vs_performance.append((layer3_perf, layer4_perf, layer5_perf)) # write performance to file fh = open("data/graph_sources/" + output_name, "w") for perf in stored_size_vs_performance: fh.write(str(perf[0]) + "," + str(perf[1]) + "," + str(perf[2]) + "\n") fh.close() return stored_size_vs_performance
def test_sample_images(path_to_model, path_to_images, save_path): num_classes = 27 # Load pre learned AlexNet state_dict = torch.load(path_to_model, map_location=lambda storage, loc: storage)['model'] model = AlexNet(num_classes) model.load_state_dict(state_dict) model.eval() # Process every image dictionary = set(nltk.corpus.words.words()) distances = defaultdict(lambda: defaultdict(lambda: 0)) size_distances = defaultdict(lambda: defaultdict(lambda: 0)) corrected_words = defaultdict(lambda: defaultdict(lambda: 0)) with open('{}labels.txt'.format(path_to_images)) as f: for line in f: sections = line.split('; ') if len(sections) < 2: continue fname = sections[0] correct_word = sections[1] # Open image image = cv2.imread('{}{}'.format(path_to_images, fname)) output = image # Find bounding boxes for each character image = preprocess_image(image) _, image = cv2.threshold(image, 90, 255, cv2.THRESH_BINARY_INV) bounding_boxes = find_bounding_boxes(image) bounding_boxes = filter_bounding_boxes(image, bounding_boxes) # Find 5 most probable results subimages = extract_characters(image, bounding_boxes) results = classify_characters(model, subimages) results = results[:5] # Check if word can be corrected corrected_word = '' for word in results: if word[0].lower() in dictionary and corrected_word is '': corrected_word = word[0] # Append to evaluation dicts for evaluation most_probable_word = results[0][0] distance = Levenshtein.distance(most_probable_word, correct_word) distances[len(correct_word)][distance] += 1 size_distances[len(correct_word)][len(most_probable_word)] += 1 corrected_words[len(correct_word)][0] += 1 if corrected_word == correct_word: corrected_words[len(correct_word)][1] += 1 # Print information about current progress print( 'Correct: {:12s} Most probable: {:12s} Corrected: {:12s} Distance: {:1d} Success: {}' .format(correct_word, most_probable_word, corrected_word, distance, corrected_word == correct_word)) # Save results with open('{}/test_results_distance.txt'.format(save_path), 'w') as f: for size in sorted(distances): for distance in sorted(distances[size]): f.write('{};{};{}\n'.format(size, distance, distances[size][distance])) with open('{}/test_results_size.txt'.format(save_path), 'w') as f: for size in sorted(size_distances): for size_distance in sorted(size_distances[size]): f.write('{};{};{}\n'.format( size, size_distance, size_distances[size][size_distance])) with open('{}/test_results_corrected.txt'.format(save_path), 'w') as f: for key in sorted(corrected_words): for count in sorted(corrected_words[key]): f.write('{};{};{}\n'.format(key, count, corrected_words[key][count]))
def run_alexnet_ann_recall_test_simulation_trial7(): output_name="alexnet_recall_task_trial7.txt" num_nodes=10 full_connection_mat = np.ones(shape=(num_nodes,num_nodes)) - np.eye(num_nodes) alex_cnn = AlexNet() alex_cnn.load_state_dict(torch.load("trained_models/alexnet.pt", map_location=torch.device("cpu"))) alex_cnn.eval() alex_capture = Intermediate_Capture(alex_cnn.fc3) # for now capture final output transform = transforms.ToTensor() data_raw = MNIST( root='./data/mnist', train=True, download=True, transform=transform) # creating a toy dataset for simple probing mnist_subset = {0:[], 1:[], 2:[], 3:[], 4:[], 5:[], 6:[], 7:[], 8:[], 9:[]} per_class_sizes = {0:10, 1:10, 2:10, 3:10, 4:10, 5:10, 6:10, 7:10, 8:10, 9:10} for i in range(len(data_raw)): image, label = data_raw[i] if len(mnist_subset[label]) < per_class_sizes[label]: mnist_subset[label].append(torch.reshape(image, (1,1, 28,28))) done = True for k in mnist_subset: if len(mnist_subset[k]) < per_class_sizes[k]: done=False if done: break # converts mnist_subset into table that is usable for model input full_pattern_set = [] full_label_set = [] for k in mnist_subset: for v in mnist_subset[k]: full_pattern_set.append(v) full_label_set.append(k) # given list of a desired labels, randomly choose an example of each label from the mnist dataset to store stored_size_vs_performance = [] # list will store tuples of (hopfield perf, popularity perf, ortho perf) for desired_label_size in range(10): # need to generate probe set each time # when desired label size is k: # probe set is 10 instances each of labels 0 to k-1 desired_labels = list(range(desired_label_size+1)) sub_probe_set = [] sub_probe_labels = [] for des in desired_labels: # add 10 instances of des for inst in mnist_subset[des]: sub_probe_set.append(inst) sub_probe_labels.append(des) full_stored_set, full_stored_labels = create_storage_set(desired_labels, mnist_subset, reshape=False, make_numpy=False) print("Num Stored: ", len(desired_labels)) # evaluate hopnet performance ann_model = hopnet(num_nodes) model = CNN_ANN(alex_cnn, ann_model, alex_capture, capture_process_fn=lambda x: np.sign(np.exp(x)-np.exp(x).mean())) num_succ, num_fail = evaluate_model_recall(model, full_stored_set, full_stored_labels, sub_probe_set, sub_probe_labels, verbose=False) print("Hopfield:", num_succ, ":", num_fail) hopfield_perf = int(num_succ) # evaluate popularity ANN performance # hyperparams: set c = N-1, with randomly generated connectivity matrix ann_model = PopularityANN(N=num_nodes, c=num_nodes-1, connectivity_matrix=full_connection_mat) model = CNN_ANN(alex_cnn, ann_model, alex_capture, capture_process_fn=lambda x: np.sign(np.exp(x)-np.exp(x).mean())) num_succ, num_fail = evaluate_model_recall(model, full_stored_set, full_stored_labels, sub_probe_set, sub_probe_labels, verbose=False) print("PopularityANN:", num_succ, ":", num_fail) popularity_perf = int(num_succ) # evaluate orthogonal hebbs ANN performance ann_model = OrthogonalHebbsANN(N=num_nodes) model = CNN_ANN(alex_cnn, ann_model, alex_capture, capture_process_fn=lambda x: np.sign(np.exp(x)-np.exp(x).mean())) num_succ, num_fail = evaluate_model_recall(model, full_stored_set, full_stored_labels, sub_probe_set, sub_probe_labels, verbose=False) print("OrthogonalHebbsANN:", num_succ, ":", num_fail) ortho_perf = int(num_succ) stored_size_vs_performance.append((hopfield_perf, popularity_perf, ortho_perf)) # write performance to file fh = open("data/graph_sources/" + output_name, "w") for perf in stored_size_vs_performance: fh.write(str(perf[0]) + "," + str(perf[1]) + "," + str(perf[2]) + "\n") fh.close() return stored_size_vs_performance
def run_experiment(args): torch.manual_seed(args.seed) if not args.no_cuda: torch.cuda.manual_seed(args.seed) # Dataset if args.dataset == 'mnist': train_loader, test_loader, _, val_data = prepare_mnist(args) else: create_val_img_folder(args) train_loader, test_loader, _, val_data = prepare_imagenet(args) idx_to_class = {i: c for c, i in val_data.class_to_idx.items()} # Model & Criterion if args.model == 'AlexNet': if args.pretrained: model = models.__dict__['alexnet'](pretrained=True) # Change the last layer in_f = model.classifier[-1].in_features model.classifier[-1] = nn.Linear(in_f, args.classes) else: model = AlexNet(args.classes) criterion = nn.CrossEntropyLoss(size_average=False) else: model = SVM(args.features, args.classes) criterion = MultiClassHingeLoss(margin=args.margin, size_average=False) if not args.no_cuda: model.cuda() # Load saved model and test on it if args.load: model.load_state_dict(torch.load(args.model_path)) val_acc = test(model, criterion, test_loader, 0, [], [], idx_to_class, args) # Optimizer if args.optimizer == 'adam': optimizer = optim.Adam(model.parameters()) else: optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) total_minibatch_count = 0 val_acc = 0 train_losses, train_accs = [], [] val_losses, val_accs = [], [] # Train and test for epoch in range(1, args.epochs + 1): total_minibatch_count = train(model, criterion, optimizer, train_loader, epoch, total_minibatch_count, train_losses, train_accs, args) val_acc = test(model, criterion, test_loader, epoch, val_losses, val_accs, idx_to_class, args) # Save model if args.save: if not os.path.exists(args.models_dir): os.makedirs(args.models_dir) filename = '_'.join( [args.prefix, args.dataset, args.model, 'model.pt']) torch.save(model.state_dict(), os.path.join(args.models_dir, filename)) # Plot graphs fig, axes = plt.subplots(1, 4, figsize=(13, 4)) axes[0].plot(train_losses) axes[0].set_title('Loss') axes[1].plot(train_accs) axes[1].set_title('Acc') axes[1].set_ylim([0, 1]) axes[2].plot(val_losses) axes[2].set_title('Val loss') axes[3].plot(val_accs) axes[3].set_title('Val Acc') axes[3].set_ylim([0, 1]) # Images don't show on Ubuntu # plt.tight_layout() # Save results if not os.path.exists(args.results_dir): os.makedirs(args.results_dir) filename = '_'.join([args.prefix, args.dataset, args.model, 'plot.png']) fig.suptitle(filename) fig.savefig(os.path.join(args.results_dir, filename))
def train_generic_model(model_name="alexnet", dataset="custom", num_classes=-1, batch_size=8, is_transform=1, num_workers=2, lr_decay=1, l2_reg=0, hdf5_path="dataset-bosch-224x224.hdf5", trainset_dir="./TRAIN_data_224_v8", testset_dir="./TEST_data_224_v8", convert_grey=False): CHKPT_PATH = "./checkpoint_{}.PTH".format(model_name) print("CUDA:") print(torch.cuda.is_available()) if is_transform: trans_ls = [] if convert_grey: trans_ls.append(transforms.Grayscale(num_output_channels=1)) trans_ls.extend([ transforms.Resize((224, 224)), # transforms.RandomCrop((224, 224)), # transforms.Grayscale(num_output_channels=1), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) transform = transforms.Compose(trans_ls) else: transform = None print("DATASET FORMAT: {}".format(dataset)) print("TRAINSET PATH: {}".format(trainset_dir)) print("TESTSET PATH: {}".format(testset_dir)) print("HDF5 PATH: {}".format(hdf5_path)) if dataset == "custom": trainset = torchvision.datasets.ImageFolder(root=trainset_dir, transform=transform) train_size = len(trainset) testset = torchvision.datasets.ImageFolder(root=testset_dir, transform=transform) test_size = len(testset) elif dataset == "cifar": trainset = torchvision.datasets.CIFAR10(root="CIFAR_TRAIN_data", train=True, download=True, transform=transform) train_size = len(trainset) testset = torchvision.datasets.CIFAR10(root="CIFAR_TEST_data", train=False, download=True, transform=transform) test_size = len(testset) elif dataset == "hdf5": if num_workers == 1: trainset = Hdf5Dataset(hdf5_path, transform=transform, is_test=False) else: trainset = Hdf5DatasetMPI(hdf5_path, transform=transform, is_test=False) train_size = len(trainset) if num_workers == 1: testset = Hdf5Dataset(hdf5_path, transform=transform, is_test=True) else: testset = Hdf5DatasetMPI(hdf5_path, transform=transform, is_test=True) test_size = len(testset) train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers) test_loader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=True, num_workers=num_workers) if model_name == "alexnet": net = AlexNet(num_classes=num_classes) elif model_name == "lenet5": net = LeNet5(num_classes=num_classes) elif model_name == "stn-alexnet": net = STNAlexNet(num_classes=num_classes) elif model_name == "stn-lenet5": net = LeNet5STN(num_classes=num_classes) elif model_name == "capsnet": net = CapsuleNet(num_classes=num_classes) elif model_name == "convneta": net = ConvNetA(num_classes=num_classes) elif model_name == "convnetb": net = ConvNetB(num_classes=num_classes) elif model_name == "convnetc": net = ConvNetC(num_classes=num_classes) elif model_name == "convnetd": net = ConvNetD(num_classes=num_classes) elif model_name == "convnete": net = ConvNetE(num_classes=num_classes) elif model_name == "convnetf": net = ConvNetF(num_classes=num_classes) elif model_name == "convnetg": net = ConvNetG(num_classes=num_classes) elif model_name == "convneth": net = ConvNetH(num_classes=num_classes) elif model_name == "convneti": net = ConvNetI(num_classes=num_classes) elif model_name == "convnetj": net = ConvNetJ(num_classes=num_classes) elif model_name == "convnetk": net = ConvNetK(num_classes=num_classes) elif model_name == "convnetl": net = ConvNetL(num_classes=num_classes) elif model_name == "convnetm": net = ConvNetM(num_classes=num_classes) elif model_name == "convnetn": net = ConvNetN(num_classes=num_classes) elif model_name == "resnet18": net = models.resnet18(pretrained=False, num_classes=num_classes) print(net) if torch.cuda.is_available(): net = net.cuda() if model_name == "capsnet": criterion = CapsuleLoss() else: criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=LEARNING_RATE, momentum=0.9, weight_decay=l2_reg) if lr_decay: scheduler = ReduceLROnPlateau(optimizer, 'min') best_acc = 0 from_epoch = 0 if os.path.exists(CHKPT_PATH): print("Checkpoint Found: {}".format(CHKPT_PATH)) state = torch.load(CHKPT_PATH) net.load_state_dict(state['state_dict']) optimizer.load_state_dict(state['optimizer']) best_acc = state['best_accuracy'] from_epoch = state['epoch'] for epoch in range(from_epoch, NUM_EPOCHS): #print("Epoch: {}/{}".format(epoch + 1, NUM_EPOCHS)) epoch_loss = 0 correct = 0 for i, data in enumerate(train_loader, 0): #print("Train \t Epoch: {}/{} \t Batch: {}/{}".format(epoch + 1, # NUM_EPOCHS, # i + 1, # ceil(train_size / BATCH_SIZE))) inputs, labels = data inputs, labels = Variable(inputs).type(torch.FloatTensor),\ Variable(labels).type(torch.LongTensor) if model_name == "capsnet": inputs = augmentation(inputs) ground_truth = torch.eye(num_classes).index_select( dim=0, index=labels) if torch.cuda.is_available(): inputs = inputs.cuda() labels = labels.cuda() optimizer.zero_grad() if model_name == "capsnet": classes, reconstructions = net(inputs, ground_truth) loss = criterion(inputs, ground_truth, classes, reconstructions) else: outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() epoch_loss += loss.data[0] if model_name != "capsnet": log_outputs = F.softmax(outputs, dim=1) else: log_outputs = classes pred = log_outputs.data.max(1, keepdim=True)[1] correct += pred.eq(labels.data.view_as(pred)).sum() print( "Epoch: {} \t Training Loss: {:.4f} \t Training Accuracy: {:.2f} \t {}/{}" .format(epoch + 1, epoch_loss / train_size, 100 * correct / train_size, correct, train_size)) correct = 0 test_loss = 0 for i, data in enumerate(test_loader, 0): # print("Test \t Epoch: {}/{} \t Batch: {}/{}".format(epoch + 1, # NUM_EPOCHS, # i + 1, # ceil(test_size / BATCH_SIZE))) inputs, labels = data inputs, labels = Variable(inputs).type( torch.FloatTensor), Variable(labels).type(torch.LongTensor) if model_name == "capsnet": inputs = augmentation(inputs) ground_truth = torch.eye(num_classes).index_select( dim=0, index=labels) if torch.cuda.is_available(): inputs = inputs.cuda() labels = labels.cuda() if model_name == "capsnet": classes, reconstructions = net(inputs) loss = criterion(inputs, ground_truth, classes, reconstructions) else: outputs = net(inputs) loss = criterion(outputs, labels) test_loss += loss.data[0] if model_name != "capsnet": log_outputs = F.softmax(outputs, dim=1) else: log_outputs = classes pred = log_outputs.data.max(1, keepdim=True)[1] correct += pred.eq(labels.data.view_as(pred)).sum() print( "Epoch: {} \t Testing Loss: {:.4f} \t Testing Accuracy: {:.2f} \t {}/{}" .format(epoch + 1, test_loss / test_size, 100 * correct / test_size, correct, test_size)) if correct >= best_acc: if not os.path.exists("./models"): os.mkdir("./models") torch.save( net.state_dict(), "./models/model-{}-{}-{}-{}-val-acc-{:.2f}-train-{}-test-{}-epoch-{}.pb" .format(model_name, dataset, hdf5_path, str(datetime.now()), 100 * correct / test_size, trainset_dir.replace(" ", "_").replace("/", "_"), testset_dir.replace(" ", "_").replace("/", "_"), epoch + 1)) best_acc = max(best_acc, correct) # save checkpoint path state = { 'epoch': epoch, 'state_dict': net.state_dict(), 'optimizer': optimizer.state_dict(), 'best_accuracy': best_acc } torch.save(state, CHKPT_PATH) if lr_decay: # Note that step should be called after validate() scheduler.step(test_loss) print('Finished Training') print("") print("")