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))
