def main(): prog = "gradient_attacker" descr = "Demonstrate gradient attacks" parser = argparse.ArgumentParser(prog=prog, description=descr) parser.add_argument("-m", "--model", type=str, default=None, required=True, help="Target Model Pickle") parser.add_argument("-d", "--directory", type=str, default=None, required=False, help="Base location of images") args = parser.parse_args() if args.directory is None: image_base = args.model.split('.')[0] else: image_base = args.directory if torch.cuda.is_available(): print("Using GPU 0") device = torch.cuda() else: print("No GPU, using CPU") device = torch.cpu() cpu = torch.cpu() model = torch.load(args.model) dataset = model.dataset()() batch_size = 400 loader = dataset.training(batch_size) criterion = nn.CrossEntropyLoss() model.to(device) for f in range(1,11): f = 0.1*f ga = GradientAttack(model,criterion,f) nga = NormalizedGradientAttack(model,criterion,f) gsa = GradientSignAttack(model,criterion,f) dataiter = iter(dataset.testing(batch_size)) images, labels = dataiter.next() images = images.to(device) ga.visualize(images,model,filename=image_base + "_ga_%1.2f.png" % (f,), diff_multiply = 10) ga_successRate = ga.test(model,dataset.testing(batch_size)) print("The success rate on %s with gradient attack with eps %1.2f is %0.4f" % (args.model, f,ga_successRate)) nga.visualize(images,model,filename=image_base + "_nga_%1.2f.png" % (f,), diff_multiply = 10) nga_successRate = nga.test(model,dataset.testing(batch_size)) print("The success rate on %s with normalized gradient attack eps %1.2f is %0.4f" % (args.model, f,nga_successRate)) gsa.visualize(images,model,filename=image_base + "_gsm_%1.2f.png" % (f,), diff_multiply = 1) gsa_successRate = gsa.test(model,dataset.testing(batch_size)) print("The success rate on %s with gradient sign attack eps %1.2f is %0.4f" % (args.model, f,gsa_successRate))
def main(args): print("start") print(args) #train_dset = build_coco_caption_dsets(args) train_loader = build_caption_loaders(args) # class CaptionEncoder(gluon.HybridBlock): # """Network for sentiment analysis.""" # def __init__(self, prefix=None, params=None): # super(CaptionEncoder, self).__init__(prefix=prefix, params=params) # with self.name_scope(): # self.embedding = None # will set with lm embedding later # self.encoder = None # will set with lm encoder later # # # def hybrid_forward(self, F, data,hiddens): # pylint: disable=arguments-differ # encoded,hiddens = self.encoder(self.embedding(data),hiddens) # Shape(T, N, C) # return encoded,hiddens # new_model = CaptionEncoder() # new_model.embedding = lstm.embedding # new_model.encoder = lstm.encoder # new_model.begin_state = lstm.begin_state # new_model.hybridize() #print(new_model) # def get_features(data, valid_lengths): # # length = data.shape[1] # batch_size = data.shape[0] # hidden_state = new_model.begin_state(func=mx.nd.zeros, batch_size=batch_size, ctx=context[0]) # # mask = mx.nd.arange(length).expand_dims(0).broadcast_axes(axis=(0,), size=(batch_size,)) # # mask = mask < valid_lengths.expand_dims(1).astype('float32') # print(data.shape) # data = mx.nd.transpose(data) # output, (hidden, cell) = new_model(data, hidden_state) # #hidden = mx.nd.transpose(hidden, axes=(1, 0, 2)) # print(hidden.shape) # return (output, hidden) for batch in train_loader: batch = [torch.cuda() for torch in batch] masks = None imgs, objs, boxes, masks, triples, obj_to_img, triple_to_img, caption_h = batch print(caption_h.size())
def get_samples(scene, batch_size, max_words, viterbi, k=10): start_of_sentence = torch.ones(batch_size).long() samples = torch.zeros(batch_size, self.vocab_sz) samples[:,0] = start_of_sentence probs = torch.zeros(batch_size) d_prev = Variable(torch.zeros(batch_size, self.vocab_sz)) d_n = Variable(self.one_hot(start_of_sentence, self.vocab_sz)) for i in range(1, max_words): if torch.cuda().is_available(): d_n, d_prev = d_n.cuda(), d_prev.cuda() out = self.forward_step(d_n, d_prev, scene.unsqueeze(0)) values, indices = torch.max(out, 1) d_prev += d_n d_n = Variable(self.one_hot(indices.data, self.vocab_sz)) samples[:,i] = indices.data probs[i] += torch.log(values) return torch.Tensor(probs), torch.stack(sentences)
def find_closest(self, inputs, nb_closest=5): """ Find the closest word using cosine similarity :param inputs: A tensor of size (batch size, ) of indices of the target words :param nb_closest: The number of closest word to return :return: A tensor of size (bach size x nb_closest) containing indices of the closest words """ result = np.zeros((2, 6)) output = self.out.clone() op = output.transpose(0, 1) ip = op[inputs] input_prob = ip.transpose(0, 1) cos = nn.CosineSimilarity(0) for in_col, token_id in enumerate(inputs.data.cpu().numpy()): cosines = None for o_col, prob in enumerate(output.data.cpu().numpy()): # if token_id == o_col: # continue c = cos(input_prob.data[:, in_col], output.data[:, o_col]) if (cosines is not None): cosines = torch.cat([cosines, c]) else: cosines = c #print(cosines.size()) res = torch.topk(cosines, nb_closest + 1) #print (type(res[1])) res = Variable(res[1]) #print (type (res)) res = res.data.cpu().numpy() result = np.concatenate((result, [res]), axis=0) result = np.delete(result, 0, 0) result = np.delete(result, 0, 0) return (cuda(Variable(torch.from_numpy(result))))
start_epoch = 0 split_id = 0 PATH = 'log' dataset_name = 'market1501' #dataset_name = 'cuhk03' num_classes = 751 #751 for market 1501 #1360 for CUHK-03 # CUHK03 specific cuhk03_labeled = False use_metric_cuhk03 = False cuhk03_classic_split = False ######################################################## if torch.cuda.is_available(): device = torch.device("cuda") else: device = torch.cuda("cpu") sys.stdout = Logger(osp.join(PATH, 'log_train.txt')) print("Dataset is being initialized") ##### Market1501 """ dataset = dataset_manager.init_img_dataset( root='data',name=dataset_name,split_id=split_id, ) """ ##### CUHK03 dataset = dataset_manager.init_img_dataset( root='data', name=dataset_name,
def main(): vocab_size = 50000 embedding_dim = 128 skip_window = 1 batch_size = 1024 data = load_data(TEXT8_FILENAME) print('Data:', len(data)) print(data[:10]) data_tokens_ids, token2id, id2token = build_dataset(data, vocab_size=vocab_size) print('Dataset:', len(data_tokens_ids)) print(data_tokens_ids[:10]) # load words to test embeddings test_words = load_test_words(TEST_WORDS_FILENAME) dataset = SkipGramDataset(data_tokens_ids, skip_window=skip_window) data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True) model = SkipGramModel(vocab_size=len(token2id), embedding_dim=embedding_dim) model = cuda(model) # cross-entropy loss is used as the models outputs unnormalized probability distribution over the vocabulary criterion = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adagrad(model.parameters(), lr=0.1) print('Starting training...') nb_iterations = 0 iteration_step = 1000 max_iterations = 20000 losses = [] time_training_started = datetime.now() tick = datetime.now() while True: for i, (inputs, targets) in enumerate(data_loader): optimizer.zero_grad() inputs_var = cuda(Variable(inputs)) targets_var = cuda(Variable(targets)) outputs = model(inputs_var) loss = criterion(outputs, targets_var) loss.backward() optimizer.step() losses.append(float(loss)) nb_iterations += 1 if nb_iterations % iteration_step == 0: tock = datetime.now() time_for_iterations = tock - tick time_elapsed = tock - time_training_started loss = np.mean(losses) losses = [] log_str = 'Iteration: {}, elapsed time: {} [{} sec/{} iters], loss: {}'.format( nb_iterations, time_elapsed, time_for_iterations.seconds, iteration_step, loss) print(log_str) # find closest word and print them test_samples = cuda( Variable( torch.from_numpy( np.array([token2id[t] for t in test_words])))) random_idx = torch.from_numpy(np.random.choice(batch_size, 3)) random_words_from_batch = cuda(Variable(inputs[random_idx])) test_samples = torch.cat( [test_samples, random_words_from_batch]) closest = model.find_closest(test_samples) closest = closest.data.cpu().numpy() # print some random samples for i, token_id in enumerate(test_samples.data.cpu().numpy()): target_token = id2token[token_id] closest_tokens = [id2token[i] for i in closest[i]] print('Closest to {}: {}'.format( target_token, ', '.join(closest_tokens))) print() tick = datetime.now() if nb_iterations > max_iterations: return
def train_model(model, epochs, train_dataset, val_dataset, batch_size, lr, criterion, optimizer=None, epoch_patience=5, lr_scheduler=None, model_path=None, device=torch.cuda('cpu')): '''Train model and save model with best val score in model_path :returns model with best score on validation dataset best score on validation dataset''' best_val_loss = float('inf') best_model = None best_epoch = 0 train_data = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=0) val_data = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=0) if optimizer is None: optimizer = torch.optim.Adam(model.parameters(), lr=lr) else: optimizer = optimizer(model.parameters(), lr=lr) if lr_scheduler is not None: lr_scheduler = lr_scheduler(optimizer) for epoch in range(epochs): train_loss = 0 batches = 0 for i, (x_batch, y_batch) in enumerate(train_data): x = x_batch.to(device) y = y_batch.to(device) y = torch.squeeze(y) optimizer.zero_grad() y_pred = model(x) loss = criterion(y_pred, y) loss.backward() optimizer.step() train_loss += loss.item() train_loss /= (i + 1) print(f'Epoch {epoch}, training loss = {train_loss} ') model.eval() val_loss = 0 with torch.no_grad(): for i, (x_batch, y_batch) in enumerate(val_data): x = x_batch.to(device) y = y_batch.to(device) y = torch.squeeze(y) y_pred = model(x) loss = criterion(y_pred, y) val_loss += loss.item() val_loss /= (i + 1) print(f'val loss = {val_loss}') if best_val_loss > val_loss: if model_path != None: torch.save(model.state_dict(), model_path) best_model = copy.copy(model) best_epoch = epoch best_val_loss = val_loss elif epoch - best_epoch > epoch_patience: print(f'Early stopping') return best_val_loss, best_model if lr_scheduler is not None: lr_scheduler.step(val_loss) return best_val_loss, best_model
def variable(x, volatile=False): return cuda(Variable(x, volatile=volatile))