def forward(self, x=None, c=None, train=True):
if train:
if self.conditional:
c = idx2onehot(c, n=2) # used to be 10
full_x = torch.cat((x, c), dim=-1)
else:
full_x = x
full_x = self.MLP_q(full_x)
alpha_q_lin = self.linear_latent_q(full_x)
alpha_q = self.softmax_q(alpha_q_lin)
else:
alpha_q_lin = None
alpha_q = None
if self.conditional:
c = idx2onehot(c, n=2) # used to be 10
c = self.MLP_p(c)
alpha_p_lin = self.linear_latent_p(c)
alpha_p = self.softmax_p(alpha_p_lin)
alpha_p_sparsemax = self.sparsemax_p(alpha_p_lin)
return alpha_q, alpha_p, alpha_p_sparsemax, c
def forward(self, x=None, c=None, train=True):
if train:
if self.conditional:
c = idx2onehot(c, n=self.num_labels) # used to be 10
# concatenate labels to the images as in:
# https://github.com/rasbt/deeplearning-models/blob/master/pytorch_ipynb/autoencoder/ae-cnn-cvae_no-out-concat.ipynb
c_concat = c.view(-1, self.num_labels, 1, 1)
c_concat = torch.ones(c.size()[0],
self.num_labels,
x.size()[2],
x.size()[3],
dtype=x.dtype).cuda() * c_concat
full_x = torch.cat((x, c_concat), dim=1)
full_x = self.MLP_q(full_x)
alpha_q_lin = self.linear_latent_q(full_x)
alpha_q = self.softmax_q(alpha_q_lin)
else:
alpha_q_lin = None
alpha_q = None
if self.conditional:
c = idx2onehot(c, n=2)
c = self.MLP_p(c)
alpha_p_lin = self.linear_latent_p(c)
alpha_p = self.softmax_p(alpha_p_lin)
alpha_p_max = self.sparsemax_p(alpha_p_lin)
return alpha_q, alpha_p, alpha_p_max, c
def forward(self, z, c=None, d=None):
if self.conditional:
c = idx2onehot(c, n=self.num_labels)
z = torch.cat((z, c), dim=-1)
if self.num_domains > 0:
d = idx2onehot(d.cpu(), n=self.num_domains).to(self.device)
z = torch.cat((z, d), dim=-1)
x = self.fc1(z)
x = self.fc2(x)
x = self.decoder(x.view(-1, 1024, 1, 1))
return x
def decode(self, z, c):
c = idx2onehot(c, n=10)
z = torch.cat((z, c), dim=-1)
h2 = self.fc3(z)
h2 = h2.view(-1, 2, 14, 14)
h2 = self.conv2(h2)
return h2
def forward(self, x, c=None):
x = x.view([-1, 1, 28, 28])
if self.conditional:
c = idx2onehot(c, n=28)
c = c.reshape(-1, 1, 28, 1)
x = torch.cat((x, c), dim=-1)
print(x.shape)
x = self.conv1(x)
print(x.shape)
x = self.pool(x)
x = self.relu(x)
x = self.conv2(x)
print(x.shape)
x = self.pool(x)
x = self.relu(x)
x = self.conv3(x)
print(x.shape)
x = self.pool(x)
x = self.relu(x)
x = x.view([-1, 128 * 4 * 4])
#x = self.fc(x)
print(x.shape)
if not (self.variational or self.conditional):
return self.linear_z(x)
means = self.linear_means(x)
log_vars = self.linear_log_var(x)
return means, log_vars
def forward(self, z,d=None):
if self.num_domains > 0:
d = idx2onehot(d.cpu(), n=self.num_domains).to(self.device)
z = torch.cat((z,d), dim=-1)
x = self.MLP(z)
x = F.normalize(x, p=2, dim=1)
return x
def decode(self, z, y, label, alpha):
z = z.view(-1, 20)
y_c = idx2onehot(y, 10, label, alpha)
cat = torch.cat((z, y_c), dim=-1)
h3 = self.relu(self.fc3(cat))
ret = self.sigmoid(self.fc4(h3))
ret = torch.narrow(ret, 1, 0, 784)
return ret
def forward(self, z, c):
if self.conditional:
c = idx2onehot(c.type(torch.LongTensor).to('cuda'), n=3*18)
z = torch.cat((z, c), dim=-1)
x = self.model(z)
return x
def forward(self, z, c):
if self.conditional:
c = idx2onehot(c.cpu(), n=10).to(self.device)
z = torch.cat((z, c), dim=-1)
x = self.MLP(z)
return x
def forward(self, z, c):
if self.conditional:
c = idx2onehot(c, n=10)
z = torch.cat((z, c), dim=-1)
x = self.MLP(z)
return x
def forward(self, x, c=None):
if self.conditional:
c = idx2onehot(c, n=10)
x = torch.cat((x, c), dim=-1)
z = self.MLP(x)
return z
def forward(self, x, c=None):
if self.conditional:
c = idx2onehot(c, n=28)
c = c.reshape(-1, 1, 28, 1)
x = T.cat((x, c), dim=-1)
f_d = self.convs(x)
x = self.last_conv(f_d)
f_d = F.avg_pool2d(f_d, 4, 1, 0)
return x.squeeze(), f_d.squeeze()
def encode(self, x, c):
c = idx2onehot(c, n=10)
c = torch.unsqueeze(c, -1)
c = torch.unsqueeze(c, -1)
c = c.expand(-1, -1, x.size()[2], x.size()[3])
x = torch.cat((x, c), dim=1)
h1 = self.conv1(x)
h1 = h1.view(-1, 784)
h1 = self.fc1(h1)
return self.fc21(h1), self.fc22(h1)
def forward(self, z, c, c2=None, alpha=1):
if self.conditional:
#print("decoder")
c = idx2onehot(c, 10, c2, alpha)
z = torch.cat((z, c), dim=-1)
x = self.MLP(z)
return x
def decode(self, z, c):
if c is not None:
# restructure input
qq = utils.idx2onehot(c.view(-1, 1), self.num_class)
z = torch.cat([z, qq], 1)
recon_x = self.Decoder_input(z)
recon_x = recon_x.view(recon_x.size(0), -1, self.img_size_s,
self.img_size_s)
recon_x = self.Decoder(recon_x)
return recon_x
def forward(self, z, c):
if self.conditional:
c = idx2onehot(c, n=self.num_labels)
z = torch.cat((z, c), dim=-1)
elif self.subspace:
z = torch.cat((z, c), dim=-1)
z = self.fc(z)
x = self.decoder(z)
return x
def forward(self, z, c):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
if self.conditional:
c = idx2onehot(c, n=10)
c = c.to(device)
z = z.to(device)
z = torch.cat((z, c), dim=-1)
z = z.to(device)
x = self.MLP(z)
return x
def forward(self, x, c=None):
if self.conditional:
c = idx2onehot(c, n=10)
x = torch.cat((x, c), dim=-1)
x = self.MLP(x)
means = self.linear_means(x)
log_vars = self.linear_log_var(x)
return means, log_vars
def forward(self, x, d=None):
if self.num_domains>0:
d = idx2onehot(d.cpu(), n=self.num_domains).to('cuda')
x = torch.cat((x, d), dim=-1)
x = self.MLP(x)
means = self.linear_means(x)
log_vars = self.linear_log_var(x)
means = F.normalize(means, p=2, dim=1)
log_vars = F.normalize(log_vars, p=2, dim=1)
return means, log_vars
def forward(self, z, c):
if self.conditional:
c = idx2onehot(c, n=10)
z = torch.cat((z, c), dim=1)
x = self.fc(z)
x = x.view(-1, 64, 7, 7)
x = self.conv(x)
# BECAUSE MNIST is -1 to 1, rescale from 0 to 1
x = x.view(-1, 28 * 28)
x = x * 2 - 1
return x
def forward(self, x, c=None, c2=None, alpha=1):
if self.conditional:
#print("encoder")
c = idx2onehot(c, 10, c2, alpha)
x = torch.cat((x, c), dim=-1)
x = self.MLP(x)
means = self.linear_means(x)
log_vars = self.linear_log_var(x)
return means, log_vars
def forward(self, x, c=None):
x = self.encoder(x)
c = idx2onehot(c, n=self.num_labels)
x = torch.cat((x, c), dim=-1)
x = self.fc(x)
means = self.linear_means(x)
log_vars = self.linear_log_var(x)
w_sam = self.reparameterize(means, log_vars)
return means, log_vars, w_sam
def forward(self, x, c=None):
x = x.view(-1, 1, 28, 28)
x = self.conv(x)
x = x.view(-1, 64 * 7 * 7)
if self.conditional:
c = idx2onehot(c, n=10)
x = torch.cat((x, c), dim=1)
x = self.fc(x)
means = self.linear_means(x)
log_vars = self.linear_log_var(x)
return means, log_vars
def encode(self, x, c):
if c is not None:
# restructure input
qq = utils.idx2onehot(c.view(-1, 1), self.num_class)
qq = qq.view(-1, self.num_class, 1,
1).expand(-1, -1, self.img_size, self.img_size)
x = torch.cat([x, qq], 1)
x = self.Encoder(x)
x = x.view(x.size(0), -1)
# exit()
mu, logvar = self.mu(x), self.logvar(x)
z = self.reparameterize(mu, logvar)
return mu, logvar, z
def forward(self, z, c=None):
if self.conditional:
c = idx2onehot(c, n=10)
z = T.cat((z, c), dim=-1)
z = self.fc(z)
z = z.view([-1, 256, 4, 4])
x = self.c1(z)
x = self.relu(x)
x = self.c2(x)
x = self.relu(x)
x = self.c3(x)
x = self.sig(x)
#x = x.view([-1,28*28])
return x
def forward(self, x, c=None):
if self.conditional:
c = idx2onehot(c.type(torch.LongTensor).to('cuda'), n=3*18)
c = c.reshape(-1,3, 18, 1)
x = torch.cat((x, c), dim=-1)
x = self.conv1(x)
x = self.bn1(x)
x = self.pool(x)
x = self.relu(x)
x = self.model(x)
if not (self.variational or self.conditional):
return self.linear_z(x)
means = self.linear_means(x)
log_vars = self.linear_log_var(x)
return means, log_vars
def forward(self, x, c=None):
if self.conditional:
c = idx2onehot(c, n=28)
c = c.reshape(-1, 1, 28, 1)
x = torch.cat((x, c), dim=-1)
x = self.conv1(x)
x = self.bn1(x)
x = self.pool(x)
x = self.relu(x)
x = self.model(x)
if not (self.variational or self.conditional):
return self.linear_z(x)
means = self.linear_means(x)
log_vars = self.linear_log_var(x)
return means, log_vars
def learning(self):
torch.manual_seed(self.opt.seed)
coef_hat = torch.FloatTensor([self.opt.coef_hat]*self.opt.batch_size*self.opt.n_step).view(self.opt.batch_size, self.opt.n_step)
rho_hat = torch.FloatTensor([self.opt.rho_hat]*self.opt.batch_size*self.opt.n_step).view(self.opt.batch_size, self.opt.n_step)
while True:
# batch-trace
states, actions, rewards, dones, action_log_probs = self.q_batch.get(block=True)
logit_log_probs = self.actor(states)
V = self.critic(states).view(self.opt.batch_size, self.opt.n_step) * (1 - dones)
action_probs = torch.exp(action_log_probs)
logit_probs = torch.exp(logit_log_probs)
is_rate = torch.prod(logit_probs / (action_probs + 1e-6), dim=-1).detach()
coef = torch.min(coef_hat, is_rate) * (1 - dones)
rho = torch.min(rho_hat, is_rate) * (1 - dones)
# V-trace
v_trace = torch.zeros((self.opt.batch_size, self.opt.n_step)).to(self.device)
target_V = V.detach()
for rev_step in reversed(range(states.size(1) - 1)):
v_trace[:, rev_step] = target_V[:, rev_step] \
+ rho[:, rev_step] * (rewards[:, rev_step] + self.opt.gamma*target_V[:, rev_step+1] - target_V[:, rev_step]) \
+ self.opt.gamma * coef[:, rev_step] * (v_trace[:, rev_step+1] - target_V[:, rev_step+1])
# actor loss
onehot_actions = torch.FloatTensor(
idx2onehot(actions.cpu().numpy(), self.opt.batch_size, self.n_act)).to(self.device)
logit_log_probs = torch.sum(logit_log_probs * onehot_actions, dim=-1)
advantages = rewards + self.opt.gamma * v_trace - V
pg_loss = -torch.sum(logit_log_probs * advantages.detach())
actor_loss = pg_loss
self.actor_optimizer.zero_grad()
actor_loss.backward()
self.actor_optimizer.step()
# critic
critic_loss = torch.mean((v_trace.detach() - V)**2)
self.critic_optimizer.zero_grad()
critic_loss.backward()
self.critic_optimizer.step()
if isValidation:
validation_loss = self.calculate_loss(X_val, y_val)
logger.info('epoch %i, seq %i/%i, tr loss %f te loss %f lr: %f' %
(epoch + 1, idx + 1, n_train, train_loss, validation_loss, learning_rate))
else:
logger.info('epoch %i, seq %i/%i, train loss %f lr: %f' %
(epoch + 1, idx + 1, n_train, train_loss, learning_rate))
learning_rate *= learning_rate_decay
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
in_dim, hidden_dim, out_dim = 300, 128, 3
data = cPickle.load(open("./data/corpus.p", "rb"))
W = cPickle.load(open("./data/word2vec.p", "rb"))
W2V = np.array(W[0]).astype(theano.config.floatX)
train_X, train_Y = data[0], data[1]
train_x = [np.matrix(W2V[sen_idx]) for sen_idx in train_X]
train_y = [idx2onehot(label, out_dim) for l in train_Y for label in l]
model = VanillaRNN(n_in=in_dim, n_out=out_dim, n_hidden=hidden_dim)
model.build_model()
t0 = datetime.now()
model.f_update(train_x[0], train_y[0], 0.01, 0.5)
print model.by.get_value().shape
print "Elapsed time: %f" % ((datetime.now() - t0).microseconds / 1000.0)
def encode(self, x, y, label, alpha):
y = idx2onehot(y, 10, label, alpha)
con = torch.cat((x, y), dim=-1)
h1 = self.relu(self.fc1(con))
return self.fc21(h1), self.fc22(h1)
logger.info(
'epoch %i, seq %i/%i, tr loss %f te loss %f lr: %f'
% (epoch + 1, idx + 1, n_train, train_loss,
validation_loss, learning_rate))
else:
logger.info(
'epoch %i, seq %i/%i, train loss %f lr: %f' %
(epoch + 1, idx + 1, n_train, train_loss,
learning_rate))
learning_rate *= learning_rate_decay
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
in_dim, hidden_dim, out_dim = 300, 128, 3
data = cPickle.load(open("./data/corpus.p", "rb"))
W = cPickle.load(open("./data/word2vec.p", "rb"))
W2V = np.array(W[0]).astype(theano.config.floatX)
train_X, train_Y = data[0], data[1]
train_x = [np.matrix(W2V[sen_idx]) for sen_idx in train_X]
train_y = [idx2onehot(label, out_dim) for l in train_Y for label in l]
model = VanillaRNN(n_in=in_dim, n_out=out_dim, n_hidden=hidden_dim)
model.build_model()
t0 = datetime.now()
model.f_update(train_x[0], train_y[0], 0.01, 0.5)
print model.by.get_value().shape
print "Elapsed time: %f" % ((datetime.now() - t0).microseconds / 1000.0)
