def encoder(self, input):
tt = torch.cuda if self.isCuda else torch
h0 = torch.Variable(tt.FloatTensor(self.num_layers, input.size(0), self.hidden_size))
c0 = torch.Variable(tt.FloatTensor(self.num_layers, input.size(0), self.hidden_size))
encoded_input, hidden = self.lstm(input, (h0, c0))
encoded_input = self.relu(encoded_input)
return encoded_input
def decoder(self, encoded_input):
tt = torch.cuda if self.isCuda else torch
h0 = torch.Variable(tt.FloatTensor(self.num_layers, encoded_input.size(0), self.output_size))
c0 = torch.Variable(tt.FloatTensor(self.num_layers, encoded_input.size(0), self.output_size))
decoded_output, hidden = self.lstm(encoded_input, (h0, c0))
decoded_output = self.sigmoid(decoded_output)
return decoded_output
def predict():
"""Predict unseen images"""
"""Step 0: load data and trained model"""
mnist = input_data.read_data_sets("./data/", one_hot=True)
checkpoint_dir = sys.argv[1]
"""Step 1: build the rnn model"""
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes])
weights = tf.Variable(tf.random_normal([n_hidden, n_classes]), name='weights')
biases = tf.Variable(tf.random_normal([n_classes]), name='biases')
pred = rnn_model(x, weights, biases)
correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
"""Step 2: predict new images with the trained model"""
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
"""Step 2.0: load the trained model"""
checkpoint_file = tf.train.latest_checkpoint(checkpoint_dir + 'checkpoints')
print('Loaded the trained model: {}'.format(checkpoint_file))
saver = tf.train.Saver()
saver.restore(sess, checkpoint_file)
"""Step 2.1: predict new data"""
test_len = 500
test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
test_label = mnist.test.labels[:test_len]
print("Testing Accuracy:", sess.run(accuracy, feed_dict={x: test_data, y: test_label}))
def train(args, model):
model.train()
input_transform = output_transform = None
dataset = RVSC(args.datadir, input_transform, output_transform)
loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)
weight = torch.ones(2)
if args.cuda:
weight = weight.cuda()
criterion = CrossEntropyLoss2d(weight)
optimizer = Adam(model.parameters())
for epoch in range(1, args.num_epochs+1):
epoch_loss = []
for step, (images,labels) in enumerate(loader):
if args.cuda:
images = images.cuda()
labels = labels.cuda()
x = torch.Variable(images)
y_true = torch.Variable(labels)
y_pred = model(x)
optimizer.zero_grad()
loss = criterion(y_pred, y_true)
loss.backward()
optimizer.step()
epoch_loss.append(loss.data[0])
print(loss.data[0])
def __init__(self):
self.ps = U.Params(params).init_comps()
self.pre = None
self.post = None
i = torch.constant([0.0] * (4 * 10), shape=(4, 10))
self.src_b = torch.Variable(initial_value=i)
i = torch.constant([0.0] * (4 * 10), shape=(4, 10))
self.mem_b = torch.Variable(initial_value=i)
def forward(self, X):
input = self.embedding(X) #input: [batch_size, len_seq, embedding_size]
input = input.permute(1, 0, 2) #input: [len_seq, batch_size, embedding_size]
hidden_state = torch.Variable(torch.zeros(1*2, len(X), n_hidden)) #[num_layers(=1) * num_directions(=2), batch_size, n_hidden]
cell_state = torch.Variable(torch.zeros(1*2, len(X), n_hidden)) #[num_layers(=1) * num_directions(=2), batch_size, n_hidden]
# final_hidden_state, final_cell_state : [num_layers(=1) * num_directions(=2), batch_size, n_hidden]
output = (final_hidden_state, final_cell_state) = self.lstm(input, (hidden_state, cell_state))
output = output.permute(1, 0, 2) # output : [batch_size, len_seq, n_hidden]
attn_output, attention = self.attention_net(output, final_hidden_state)
return self.out(attn_output), attention # model : [batch_size, num_classes], attention : [batch_size, n_step]
def regularization(self, reg_lambda):
laplacian = torch.Variable(self.laplacian, requires_grad=False)
if self.on_cuda:
laplacian = laplacian.cuda()
weight = self.my_logistic_layers[-1].weight
reg = torch.abs(weight).mm(laplacian) * torch.abs(weight)
return reg.sum() * reg_lambda
def forward(self, predict, score):
dialogue, sel_a, sel_b, reward, partner_reward = predict
response_scores, selection_score = score
reward_transformed = self.transform_reward(reward)
step_rewards = []
discount = th.Variable(cu(th.FloatTensor([1.0])))
for i in range(len(response_scores)):
step_rewards.append(discount * reward_transformed)
discount = discount * self.gamma
loss = th.Variable(cu(th.FloatTensor([0.0])))
for score, step_reward in zip(response_scores, step_rewards):
loss -= score * step_reward
return loss
def categorical_sample(probs, use_cuda=False):
int_acs = torch.multinomial(probs, 1)
if use_cuda:
tensor_type = torch.cuda.FloatTensor
else:
tensor_type = torch.FloatTensor
acs = torch.Variable(tensor_type(*probs.shape).fill_(0)).scatter_(1, int_acs, 1)
return int_acs, acs
def pi_maker(feature,beta,temperature=0.1):
n_bins = len(beta)
w = torch.reshape(torch.linspace(1,n_bins,n_bins),[-1,1]) #make constant or something later
torch.Variable(w, requires_grad=False)
beta, _ = torch.sort(beta)
beta[0] = 0
b = torch.cumsum(-beta,0)
pi = torch.reshape(torch.softmax((w*feature+b)/temperature,0),[-1,1])
return pi
def getCombination(memory, option):
ret = []
if option == 1:
idx = 0
while (idx < len(memory)):
temp = memory[idx]
temp.append(memory[idx + 1])
temp.append(memory[idx + 2])
ret.append(temp)
idx = idx + 3
elif option == 2:
idx = 0
while (idx < len(memory)):
temp = torch.Variable(init=memory[idx])
temp += memory[idx + 1]
temp += memory[idx + 2]
ret.append(temp / 3)
idx = idx + 3
elif option == 3:
idx = 0
while (idx < len(memory)):
temp = memory[idx]
temp2 = memory[idx + 1]
temp3 = memory[idx + 2]
a, b, c = getParams(nn.Module, [temp, temp2, temp3])
idx = idx + 3
ret.append(a * temp + b * temp2 + c * temp3)
elif option == 4:
idx = 0
while (idx < len(memory)):
temp = memory[idx]
temp2 = memory[idx + 1]
temp3 = memory[idx + 2]
ret.append(max(temp2, temp3) + temp, requires_grad=False)
elif option == 5:
idx = 0
while (idx < len(memory)):
temp = memory[idx]
temp2 = memory[idx + 1]
temp3 = memory[idx + 2]
ret.append(max(temp2, temp3, temp), requires_grad=False)
elif option == 6:
ret = memory
return ret
def _forward_alg(self, feats):
init_alphas = torch.full((1, self.output_size), -10000.)
# TODO: sos initialistion
# init_alphas[0][START_OF_SENTENCE] = 0.
forward_var = torch.Variable(init_alphas)
for feat in feats:
alphas_t = []
for next_tag in range(self.output_size):
emit_score = feat[next_tag].veiw(1, -1).expand(
1, self.output_size)
trans_score = self.transitions[next_tag].view(1, -1)
next_tag_var = forward_var + trans_score + emit_score
alphas_t.append(log_sum_exp(next_tag_var).view(1))
forward_var = torch.cat(alphas_t).view(1, -1)
terminal_var = forward_var # TODO: + self.transitions[END_OF_SENTENCE]
alpha = log_sum_exp(terminal_var)
return alpha
def compute_gradient_penalty(self, D, real_samples, fake_samples):
"""Calculates the gradient penalty loss for WGAN GP"""
# Random weight term for interpolation between real and fake samples
alpha = torch.Tensor(np.random.random((real_samples.size(0), 1, 1, 1))).to(self.device)
# Get random interpolation between real and fake samples
interpolates = (alpha * real_samples + ((1 - alpha) * fake_samples)).requires_grad_(True)
d_interpolates = D(interpolates)
fake = torch.Variable( torch.T(real_samples.shape[0], 1).fill_(1.0), requires_grad=False).to(self.device)
# Get gradient w.r.t. interpolates
gradients = autograd.grad(
outputs=d_interpolates,
inputs=interpolates,
grad_outputs=fake,
create_graph=True,
retain_graph=True,
only_inputs=True,
)[0]
gradients = gradients.view(gradients.size(0), -1)
gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
return gradient_penalty
def mi_gradient_ascent(input_sample=None, target_model=None, optimizer=None,
category=None, iterations=0, verbose=False):
""" Implementation of gradient based model inversion attack
Args:
input_sample (torch.tensor): Initialized input sample, usually
randomly generated. Size should match the model input.
target_model (nn.Module): Pretrained model to attack.
optimizer (nn.optim): Optimizer (initialized on image parameters) used
in attack.
category (int): Category to invert.
iterations (int): Query iterations in the attack.
verbose (bool): If True will print the loss at each step in attack.
Returns:
(list(float)): Returns a list of the losses at each iteration.
Example:
Todos:
Write example
"""
category = torch.Variable(torch.LongTensor([category])).to(device)
losses = []
for i_step in range(iterations):
target_model.zero_grad()
out = target_model(input_sample)
loss = -out.take(category)
loss.backward()
#
optimizer.step()
input_sample.grad.zero_()
losses.append(loss.data)
#
return losses
def to_var(x):
if torch.cuda.is_available():
x = x.cuda()
return torch.Variable(x)
import torch.nn as nn from torch.autograd import Variable # ================================================================== # # Table of Contents # # ================================================================== # # 1. Distance function # 2. Loss function # ================================================================== # # 1. Distance function # ================================================================== # # Cosine Similarity input1 = torch.Variable(torch.randn(100, 128)) input2 = Variable(torch.randn(100, 128)) cos = nn.CosineSimilarity(dim=1, eps=1e-6) output = cos(input1, input2) # ================================================================== # # 2. Loss function # ================================================================== # # L1 Loss loss = nn.L1Loss() input = torch.autograd.Variable(torch.randn(3, 5), requires_grad=True) target = torch.autograd.Variable(torch.randn(3, 5)) output = loss(input, target) output.backward()
def gaussian(ins, is_training, mean, stddev):
if is_training:
noise = torch.Variable(ins.data.new(ins.size()).normal_(mean, stddev))
return ins + noise
return ins
def init_hidden(self, batch_size):
return torch.Variable(torch.zeros(self.num_recur_layer, batch_size, self.hidden_size))
dataset = ListDataset(data_dir=data_dir,
listing=listing,
input_transform=input_transform,
target_depth_transform=None,
target_labels_transform=None,
co_transform=co_transform,
file_suffix="jpg")
data_loader = torch.utils.data.DataLoader(dataset=dataset,
batch_size=1,
shuffle=False,
drop_last=False)
counter = 0
for x, y, z in data_loader:
counter += 1
x_var = torch.Variable(x.type(dtype), volatile=True)
z_var = torch.Variable(z.type(dtype), volatile=True)
pred_depth, _ = model(x_var, z_var)
input_rgb_image = x_var[0].data.permute(1, 2,
0).cpu().numpy().astype(np.uint8)
plt.imsave('result_linput_rgb_counter_{}.png'.format(counter),
input_rgb_image)
input_gt_depth_image = z_var[0].data.permute(1, 2, 0).cpu().numpy().astype(
np.uint8)
plt.imsave('result_input_gt_depth_counter_{}.png'.format(counter),
input_gt_depth_image)
