def collate_fn(self, data):
for num, one in enumerate(data):
data[num] = list(one)
data[num].append(num)
data.sort(key=lambda x:-x[0])
x, y, index = zip(*data)
return cuda(torch.stack(x)), cuda(torch.stack(y)), index
def train(args, model, device, train_loader, optimizer, epoch):
model.train()
class_criterion = nn.CrossEntropyLoss(reduction = 'sum')
info_criterion = nn.KLDivLoss(reduction = 'sum')
for batch in train_loader:
X_pep, X_tcr, y = batch.X_pep.to(device), batch.X_tcr.to(device), batch.y.to(device)
optimizer.zero_grad()
score, p_pep, p_tcr, z_pep, z_tcr, score_fixed = model(X_pep, X_tcr, args.num_sample)
# prior distribution
p_pep_prior = cuda(prior(var_size=p_pep.size()), args.cuda)
p_tcr_prior = cuda(prior(var_size=p_tcr.size()), args.cuda)
# define loss
class_loss = class_criterion(score, y).div(math.log(2)) / args.batch_size
#info_loss = args.K * (info_criterion(p_pep, p_pep_prior)+info_criterion(p_tcr, p_tcr_prior)) / args.batch_size
info_loss = (info_criterion(p_pep, p_pep_prior)+info_criterion(p_tcr, p_tcr_prior)) / args.batch_size
total_loss = class_loss + args.beta* info_loss
optimizer.zero_grad()
total_loss.backward()
optimizer.step()
#print("peptide_prob")
#print(torch.exp(p_pep)[:3])
if epoch % PRINT_EVERY_EPOCH == 0:
print('[TRAIN] Epoch {} Total Loss {:.4f} = {:.4f} + beta {:.4f}'.format(epoch,
total_loss.item(),
class_loss.item(),
info_loss.item()))
def model_init(self):
# TODO: WGAN model_init
if self.model == 'default':
self.D = Discriminator(self.input_channel)
self.G = Generator(self.input_channel)
elif self.model == 'residual':
self.D = Discriminator_res(self.input_channel)
self.G = Generator_res(self.input_channel)
self.D.apply(weights_init)
self.G.apply(weights_init)
self.D_optim = optim.RMSprop(self.D.parameters(), lr=self.D_lr)
self.G_optim = optim.RMSprop(self.G.parameters(), lr=self.G_lr)
if self.cuda:
self.D = cuda(self.D, self.cuda)
self.G = cuda(self.G, self.cuda)
if self.multi_gpu:
self.D = nn.DataParallel(self.D).cuda()
self.G = nn.DataParallel(self.G).cuda()
if not self.ckpt_dir.exists():
self.ckpt_dir.mkdir(parents=True, exist_ok=True)
if self.load_ckpt:
self.load_checkpoint()
def model_init(self):
self.D = cuda(Discriminator(self.hidden_dim), self.cuda)
self.G = cuda(Generator(self.noise_dim), self.cuda)
self.D.weight_init(mean=0.0, std=0.02)
self.G.weight_init(mean=0.0, std=0.02)
self.D_optim = optim.Adam(self.D.parameters(),
lr=self.D_lr,
betas=(0.5, 0.999))
self.G_optim = optim.Adam(self.G.parameters(),
lr=self.G_lr,
betas=(0.5, 0.999))
self.D_optim_scheduler = lr_scheduler.StepLR(self.D_optim,
step_size=1,
gamma=0.5)
self.G_optim_scheduler = lr_scheduler.StepLR(self.G_optim,
step_size=1,
gamma=0.5)
if not self.ckpt_dir.exists():
self.ckpt_dir.mkdir(parents=True, exist_ok=True)
if self.load_ckpt:
self.load_checkpoint()
def validation_binary(model, criterion, valid_loader):
with torch.no_grad():
model.eval()
losses = []
jaccard = []
km = []
for inputs, targets in valid_loader:
inputs = utils.cuda(inputs)
targets = utils.cuda(targets)
outputs = model(inputs)
loss = criterion(outputs, targets)
losses.append(loss.item())
jaccard += [get_jaccard_per_sample(targets, (outputs > 0).float()).item()]
km += [kaggel_metric(targets, (outputs > 0).float()).item()]
valid_loss = np.mean(losses) # type: float
valid_jaccard = np.mean(jaccard).astype(np.float64)
valid_km = np.mean(km).astype(np.float64)
print('Valid loss: {:.5f}, jaccard: {:.5f}, kaggel_metric: {:.5f}'.format(valid_loss, valid_jaccard, valid_km))
metrics = {'valid_loss': valid_loss, 'jaccard_loss': valid_jaccard, 'kaggel_metric': valid_km}
return metrics
def validation_binary(model: nn.Module, criterion, valid_loader):
with torch.no_grad():
model.eval()
losses = []
iou = []
iou_fixed = []
for inputs, targets in valid_loader:
inputs = utils.cuda(inputs)
with torch.no_grad():
targets = utils.cuda(targets)
outputs = model(inputs)
loss = criterion(outputs, targets)
losses.append(loss.item())
targets_npy = targets.cpu().numpy()
outputs_npy = outputs.cpu().numpy()
# iou per image, not batch
for t, o in zip(targets_npy, outputs_npy):
iou.append(metric.iou_metric(t, o > .5))
iou_fixed.append(metric.iou_metric(t, o > .5, fix_zero=True))
# in batch it's distorted
#iou += [metric.iou_metric(targets_npy, (outputs_npy > .5))]
valid_loss = np.mean(losses) # type: float
valid_iou = np.mean(iou).astype(np.float64)
valid_iou_fixed = np.mean(iou_fixed).astype(np.float64)
print("valid loss: {:.4f}, iou: {:.4f}, iou':{:.4f}".format(
valid_loss, valid_iou, valid_iou_fixed))
metrics = {'val_loss': valid_loss, 'val_iou': valid_iou_fixed}
return metrics
def model_init(self):
self.D = Discriminator(self.model_type, self.image_size,
self.hidden_dim, self.n_filter, self.n_repeat)
self.G = Generator(self.model_type, self.image_size, self.hidden_dim,
self.n_filter, self.n_repeat)
self.D = cuda(self.D, self.cuda)
self.G = cuda(self.G, self.cuda)
self.D.weight_init(mean=0.0, std=0.02)
self.G.weight_init(mean=0.0, std=0.02)
self.D_optim = optim.Adam(self.D.parameters(),
lr=self.D_lr,
betas=(0.5, 0.999))
self.G_optim = optim.Adam(self.G.parameters(),
lr=self.G_lr,
betas=(0.5, 0.999))
#self.D_optim_scheduler = lr_scheduler.ExponentialLR(self.D_optim, gamma=0.97)
#self.G_optim_scheduler = lr_scheduler.ExponentialLR(self.G_optim, gamma=0.97)
self.D_optim_scheduler = lr_scheduler.StepLR(self.D_optim,
step_size=1,
gamma=0.5)
self.G_optim_scheduler = lr_scheduler.StepLR(self.G_optim,
step_size=1,
gamma=0.5)
if not self.ckpt_dir.exists():
self.ckpt_dir.mkdir(parents=True, exist_ok=True)
if self.load_ckpt:
self.load_checkpoint()
def grad_penalty(self, inp_real, inp_fake, D):
inp_hat = ()
for idx in range(len(inp_fake)):
e = utils.cuda(torch.rand(self.config.mini_batch_size, 1, 1, 1))
x = inp_real[idx].data
x_wave = inp_fake[idx].data
x_hat = e * x + (1 - e) * x_wave
#x_hat = e*x_wave + (1-e)*x
inp_hat += (utils.cuda(Variable(x_hat, requires_grad=True)), )
out_hat = D(*inp_hat)
gps = ()
for idx in range(len(out_hat)):
gradient = grad(out_hat[idx][0],
inp_hat[idx],
grad_outputs=utils.cuda(
torch.ones(out_hat[idx][0].size())),
create_graph=True)[0]
gradient = gradient.view(self.config.mini_batch_size, -1)
gp = ((gradient.norm(p=2, dim=1) - 1)**2).mean()
gps += (gp, )
return gps
def next_step(self, data, c_fake_data=None):
c_fake_data = utils.cuda(c_fake_data)
#put data into Variables
if self.config.coupled:
x1_data, x2_data, c1_data, c2_data = utils.cuda(
data) #read out data tuple
if self.config.auxclas:
self.c_real1 = Variable(c1_data)
self.c_real2 = Variable(c2_data)
self.c_fake1 = Variable(c_fake_data[0])
self.c_fake2 = Variable(c_fake_data[1])
self.x1_real = Variable(x1_data)
self.x2_real = Variable(x2_data)
else:
x1_data, c1_data = utils.cuda(data) #read out data tuple
if self.config.auxclas:
#set c_real Variable to contain the class conditional vector as input
self.c_real1 = Variable(c1_data)
self.c_fake1 = Variable(c_fake_data)
self.x1_real = Variable(x1_data)
self.this_batch_size = x1_data.size(0)
if self.config.mini_batch_size != self.this_batch_size:
print('batch size is off: ' + str(self.this_batch_size))
def default(self, img):
original_ncol = self.img.size(-1)
original_nrow = self.img.size(-2)
num = original_ncol * original_nrow // (self.filter_size[0] * self.filter_size[1])
seg = torch.clone(self.img)
if self.filter_size == (1, 1):
return torch.tensor(range(num)).view(seg.size())
seg = torch.clone(self.img)
for idx in range(num):
idx = cuda(torch.tensor([[idx]], dtype = torch.long), self.is_cuda)
print('idx', idx.shape)#[1,1]
print('filter_size', self.filter_size)
idx_all = index_transfer(dataset = self.dataset,
idx = idx,
filter_size = self.filter_size,
original_ncol = original_ncol,
original_nrow = original_nrow,
is_cuda = self.is_cuda).output.squeeze(0)
print(idx_all.shape)
seg.view(1, -1)[:,idx_all] = cuda(torch.tensor(idx, dtype = torch.float), self.is_cuda)
#seg = seg.detach().cpu().numpy().astype(int)
return seg
def evaluate(self, task_idx):
# self.load_checkpoint()
self.set_mode('eval')
eval_acc = 0
test_loss = 0
with torch.no_grad():
if self.continual:
data_loader = self.data_loader['task{}'.format(
task_idx)]['test']
else:
data_loader = self.data_loader['test']
for i, (images, labels) in enumerate(data_loader):
images = cuda(images, self.cuda)
labels = cuda(labels, self.cuda)
outputs = self.C(images)
_, predicted = torch.max(outputs, 1)
total = labels.size(0)
correct = (predicted == labels).sum().item()
eval_acc += 100 * correct / total
test_loss += self.compute_loss(outputs, labels)
# env_name = self.args.env_name
# print("##### Env name: {} #####".format(env_name))
# print("Epoch: {}, iter: {}, test loss: {:.3f}, Test acc.: {:.3f}".format(self.epoch_i, self.global_iter, test_loss, eval_acc))
eval_acc = eval_acc / (i + 1)
test_loss = test_loss / (i + 1)
# reset model to train mode
self.set_mode('train')
return test_loss, eval_acc
def validation_binary(model: nn.Module,
criterion,
valid_loader,
num_classes=None):
with torch.no_grad():
model.eval()
losses = []
jaccard = []
for inputs, targets in valid_loader:
inputs = utils.cuda(inputs)
targets = utils.cuda(targets)
outputs = model(inputs)
loss = criterion(outputs, targets)
losses.append(loss.item())
jaccard += [get_jaccard(targets, (outputs > 0).float()).item()]
valid_loss = np.mean(losses) # type: float
valid_jaccard = np.mean(jaccard).astype(np.float64)
print('Valid loss: {:.5f}, jaccard: {:.5f}'.format(
valid_loss, valid_jaccard))
metrics = {'valid_loss': valid_loss, 'jaccard_loss': valid_jaccard}
return metrics
def _preprocess_batch(data):
incoming = Storage()
incoming.data = data = Storage(data)
data.batch_size = data.post.shape[0]
data.post = cuda(torch.LongTensor(data.post.transpose(1, 0)))
data.resp = cuda(torch.LongTensor(data.resp.transpose(1, 0)))
return incoming
def __init__(self, dataroot, sub_dirs, batch_sizes, workers, lr, betas,
gpu_ids, ckpt_dir, results_dir):
# prepare dataset
(trA, trB, teA, teB) = utils.create_gan_datasets(dataroot, sub_dirs)
# prepare loaders
(trA_l, trB_l, teA_l,
teB_l) = utils.create_gan_dataloaders(trA, trB, teA, teB, batch_sizes,
workers)
self.trA_l = trA_l
self.trB_l = trB_l
self.teA_l = teA_l
self.teB_l = teB_l
# define the models
self.Da = Discriminator()
self.Db = Discriminator()
# Generate x from y
self.Ga = Generator()
# Generate y from x
self.Gb = Generator()
# define the loss functions
self.MSE = nn.MSELoss()
self.L1 = nn.L1Loss()
# define the optimizers here
self.da_optimizer = optim.Adam(self.Da.parameters(),
lr=lr,
betas=betas)
self.db_optimizer = optim.Adam(self.Db.parameters(),
lr=lr,
betas=betas)
self.ga_optimizer = optim.Adam(self.Ga.parameters(),
lr=lr,
betas=betas)
self.gb_optimizer = optim.Adam(self.Gb.parameters(),
lr=lr,
betas=betas)
# GPU set up
print("gpu ids", gpu_ids)
utils.cuda_devices(gpu_ids)
utils.cuda([self.Da, self.Db, self.Ga, self.Gb])
# train!
self.a_real_test = Variable(iter(teA_l).next())
self.b_real_test = Variable(iter(teB_l).next())
self.a_real_test, self.b_real_test = utils.cuda(
[self.a_real_test, self.b_real_test])
self.a_fake_pool = ItemPool()
self.b_fake_pool = ItemPool()
self.start_epoch = 0
self.ckpt_dir = ckpt_dir
self.results_dir = results_dir
def _preprocess_batch(self, data):
incoming = Storage()
incoming.data = data = Storage(data)
data.batch_size = data.sent.shape[0]
data.sent = cuda(torch.LongTensor(data.sent.transpose(
1, 0))) # length * batch_size
data.label = cuda(torch.LongTensor(data.label))
return incoming
def forward(self, batch):
# Obtain masks and lengths for passage and question.
passage_mask = (batch['passages'] != self.pad_token_id
) # [batch_size, p_len]
question_mask = (batch['questions'] != self.pad_token_id
) # [batch_size, q_len]
passage_lengths = passage_mask.long().sum(-1) # [batch_size]
question_lengths = question_mask.long().sum(-1) # [batch_size]
# 1) ELMo Embedding Layer: Embed the passage and question.
passage_ids = cuda(self.args, batch_to_ids(batch['str_passages']))
passage_embeddings = self.elmo(passage_ids)['elmo_representations'][0]
question_ids = cuda(self.args, batch_to_ids(batch['str_questions']))
question_embeddings = self.elmo(
question_ids)['elmo_representations'][0]
# 2) Context2Query: Compute weighted sum of question embeddings for
# each passage word and concatenate with passage embeddings.
aligned_scores = self.aligned_att(
passage_embeddings, question_embeddings,
~question_mask) # [batch_size, p_len, q_len]
aligned_embeddings = aligned_scores.bmm(
question_embeddings) # [batch_size, p_len, q_dim]
passage_embeddings = cuda(
self.args,
torch.cat((passage_embeddings, aligned_embeddings), 2),
) # [batch_size, p_len, p_dim + q_dim]
# 3) Passage Encoder
passage_hidden = self.sorted_rnn(
passage_embeddings, passage_lengths,
self.passage_rnn) # [batch_size, p_len, p_hid]
passage_hidden = self.dropout(
passage_hidden) # [batch_size, p_len, p_hid]
# 4) Question Encoder: Encode question embeddings.
question_hidden = self.sorted_rnn(
question_embeddings, question_lengths,
self.question_rnn) # [batch_size, q_len, q_hid]
# 5) Question Attentive Sum: Compute weighted sum of question hidden
# vectors.
question_scores = self.question_att(question_hidden, ~question_mask)
question_vector = question_scores.unsqueeze(1).bmm(
question_hidden).squeeze(1)
question_vector = self.dropout(question_vector) # [batch_size, q_hid]
# 6) Start Position Pointer: Compute logits for start positions
start_logits = self.start_output(passage_hidden, question_vector,
~passage_mask) # [batch_size, p_len]
# 7) End Position Pointer: Compute logits for end positions
end_logits = self.end_output(passage_hidden, question_vector,
~passage_mask) # [batch_size, p_len]
return start_logits, end_logits # [batch_size, p_len], [batch_size, p_len]
def random_interpolation(self, n_step=10):
self.set_mode('eval')
z1 = self.sample_z(1)
z1 = Variable(cuda(z1, self.cuda))
z2 = self.sample_z(1)
z2 = Variable(cuda(z2, self.cuda))
self.interpolation(z1, z2, n_step)
self.set_mode('train')
def _preprocess_batch(self, data):
incoming = Storage()
incoming.data = data = Storage(data)
incoming.data.batch_size = data.post.shape[0]
#incoming.data.post = cuda(torch.LongTensor(data.post)) # length * batch_size
incoming.data.resp = cuda(torch.LongTensor(
data.resp)) # length * batch_size
incoming.data.atten = cuda(torch.LongTensor(data.atten))
incoming.data.wiki = cuda(torch.LongTensor(data.wiki))
return incoming
def prepare_text(text):
tokens = tokenizer.tokenize(text)[:args.seq_len - 2]
token_ids = tokenizer.encode(tokens, add_special_tokens=True)
token_ids_len = len(token_ids)
rspace = args.seq_len - token_ids_len # <= args.seq_len
token_ids = rpad(token_ids, rspace, tokenizer.pad_token_id)
return (
cuda(torch.tensor(token_ids)).long(),
cuda(torch.tensor(token_ids_len)).long(),
)
def universal(self, args):
self.set_mode('eval')
init = False
correct = 0
cost = 0
total = 0
data_loader = self.data_loader['test']
for e in range(100000):
for batch_idx, (images, labels) in enumerate(data_loader):
x = Variable(cuda(images, self.cuda))
y = Variable(cuda(labels, self.cuda))
if not init:
sz = x.size()[1:]
r = torch.zeros(sz)
r = Variable(cuda(r, self.cuda), requires_grad=True)
init = True
logit = self.net(x + r)
p_ygx = F.softmax(logit, dim=1)
H_ygx = (-p_ygx * torch.log(self.eps + p_ygx)).sum(1).mean(0)
prediction_cost = H_ygx
#prediction_cost = F.cross_entropy(logit,y)
#perceptual_cost = -F.l1_loss(x+r,x)
#perceptual_cost = -F.mse_loss(x+r,x)
#perceptual_cost = -F.mse_loss(x+r,x) -r.norm()
perceptual_cost = -F.mse_loss(x + r, x) - F.relu(r.norm() - 5)
#perceptual_cost = -F.relu(r.norm()-5.)
#if perceptual_cost.data[0] < 10: perceptual_cost.data.fill_(0)
cost = prediction_cost + perceptual_cost
#cost = prediction_cost
self.net.zero_grad()
if r.grad:
r.grad.fill_(0)
cost.backward()
#r = r + args.eps*r.grad.sign()
r = r + r.grad * 1e-1
r = Variable(cuda(r.data, self.cuda), requires_grad=True)
prediction = logit.max(1)[1]
correct = torch.eq(prediction, y).float().mean().data[0]
if batch_idx % 100 == 0:
if self.visdom:
self.vf.imshow_multi(x.add(r).data)
#self.vf.imshow_multi(r.unsqueeze(0).data,factor=4)
print(correct*100, prediction_cost.data[0], perceptual_cost.data[0],\
r.norm().data[0])
self.set_mode('train')
def __init__(self, args):
self.args = args
self.cuda = (args.cuda and torch.cuda.is_available())
self.epoch = args.epoch
self.batch_size = args.batch_size
self.lr = args.lr
self.eps = 1e-9
self.K = args.K
self.beta = args.beta
self.num_avg = args.num_avg
self.global_iter = 0
self.global_epoch = 0
# Network & Optimizer
self.toynet = cuda(ToyNet(self.K), self.cuda)
self.toynet.weight_init()
self.toynet_ema = Weight_EMA_Update(cuda(ToyNet(self.K), self.cuda),\
self.toynet.state_dict(), decay=0.999)
self.optim = optim.Adam(self.toynet.parameters(),
lr=self.lr,
betas=(0.5, 0.999))
self.scheduler = lr_scheduler.ExponentialLR(self.optim, gamma=0.97)
self.ckpt_dir = Path(args.ckpt_dir).joinpath(args.env_name)
if not self.ckpt_dir.exists():
self.ckpt_dir.mkdir(parents=True, exist_ok=True)
self.load_ckpt = args.load_ckpt
if self.load_ckpt != '': self.load_checkpoint(self.load_ckpt)
# History
self.history = dict()
self.history['avg_acc'] = 0.
self.history['info_loss'] = 0.
self.history['class_loss'] = 0.
self.history['total_loss'] = 0.
self.history['epoch'] = 0
self.history['iter'] = 0
# Tensorboard
self.tensorboard = args.tensorboard
if self.tensorboard:
self.env_name = args.env_name
self.summary_dir = Path(args.summary_dir).joinpath(args.env_name)
if not self.summary_dir.exists():
self.summary_dir.mkdir(parents=True, exist_ok=True)
self.tf = SummaryWriter(log_dir=self.summary_dir)
self.tf.add_text(tag='argument',
text_string=str(args),
global_step=self.global_epoch)
# Dataset
self.data_loader = return_data(args)
def __init__(self, args):
super().__init__()
self.args = args
self.pad_token_id = args.pad_token_id
# Initialize embedding layers (1)
self.word_embedding = nn.Embedding(args.vocab_size, args.embedding_dim)
self.pos_embedding = nn.Embedding(args.pos_size, args.embedding_dim)
self.dep_embedding = nn.Embedding(args.dep_size, args.embedding_dim)
dependency_embeddings = torch.zeros(
(args.dep_size, self.args.embedding_dim)).uniform_(-0.1, 0.1)
self.dep_embedding.weight.data = cuda(self.args, dependency_embeddings)
pos_embeddings = torch.zeros(
(args.pos_size, self.args.embedding_dim)).uniform_(-0.1, 0.1)
self.pos_embedding.weight.data = cuda(self.args, pos_embeddings)
# Initialize Context2Query (2)
self.aligned_att = AlignedAttention(args.embedding_dim * 3)
rnn_cell = nn.LSTM if args.rnn_cell_type == 'lstm' else nn.GRU
# Initialize passage encoder (3)
self.passage_rnn = rnn_cell(
args.embedding_dim * 6,
args.hidden_dim,
bidirectional=args.bidirectional,
batch_first=True,
)
# Initialize question encoder (4)
self.question_rnn = rnn_cell(
args.embedding_dim * 3,
args.hidden_dim,
bidirectional=args.bidirectional,
batch_first=True,
)
self.dropout = nn.Dropout(self.args.dropout)
# Adjust hidden dimension if bidirectional RNNs are used
_hidden_dim = (args.hidden_dim *
2 if args.bidirectional else args.hidden_dim)
# Initialize attention layer for question attentive sum (5)
self.question_att = SpanAttention(_hidden_dim)
# Initialize bilinear layer for start positions (6)
self.start_output = BilinearOutput(_hidden_dim, _hidden_dim)
# Initialize bilinear layer for end positions (7)
self.end_output = BilinearOutput(_hidden_dim, _hidden_dim)
def _preprocess_batch(self, data): incoming = Storage() incoming.data = data = Storage(data) # print(data) data.batch_size = data.post.shape[0] data.post = cuda(torch.LongTensor(data.post.transpose(1, 0))) # length * batch_size data.resp = cuda(torch.LongTensor(data.resp.transpose(1, 0))) # length * batch_size # data.post_bert = cuda(torch.LongTensor(data.post_bert.transpose(1, 0))) # length * batch_size # data.resp_bert = cuda(torch.LongTensor(data.resp_bert.transpose(1, 0))) # length * batch_size return incoming
def load_pretrained_embeddings(self, vocabulary, path):
"""
Loads GloVe vectors and initializes the embedding matrix.
Args:
vocabulary: `Vocabulary` object.
path: Embedding path, e.g. "glove/glove.6B.300d.txt".
"""
if self.args.embedding == 'glove':
embedding_map = load_cached_embeddings(path)
# Create embedding matrix. By default, embeddings are randomly
# initialized from Uniform(-0.1, 0.1).
embeddings = torch.zeros(
(len(vocabulary), self.args.embedding_dim)
).uniform_(-0.1, 0.1)
# Initialize pre-trained embeddings.
num_pretrained = 0
for (i, word) in enumerate(vocabulary.words):
if word in embedding_map:
#embeddings[i] = torch.tensor(embedding_map[word])
num_pretrained += 1
# Place embedding matrix on GPU.
self.embedding.weight.data = cuda(self.args, embeddings)
return num_pretrained
else:
#####################
# Loads Fasttext embeddings
embedding_map = load_fasttext_embeddings(path)
# Create embedding matrix. By default, embeddings are randomly
# initialized from Uniform(-0.1, 0.1).
embeddings = torch.zeros(
(len(vocabulary), self.args.embedding_dim)
).uniform_(-0.1, 0.1)
# Initialize pre-trained embeddings.
num_pretrained = 0
for (i, word) in enumerate(vocabulary.words):
embeddings[i] = torch.tensor(embedding_map.get_word_vector(word))
num_pretrained += 1
# Place embedding matrix on GPU.
self.embedding.weight.data = cuda(self.args, embeddings)
return num_pretrained
def test(args):
utils.cuda_devices([args.gpu_id])
transform = transforms.Compose(
[transforms.Resize((args.img_height,args.img_width)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])])
dataset_dirs = utils.get_testdata_link(args.dataset_dir)
a_test_data = dsets.ImageFolder(dataset_dirs['testA'], transform=transform)
b_test_data = dsets.ImageFolder(dataset_dirs['testB'], transform=transform)
a_test_loader = torch.utils.data.DataLoader(a_test_data, batch_size=args.batch_size, shuffle=False, num_workers=4)
b_test_loader = torch.utils.data.DataLoader(b_test_data, batch_size=args.batch_size, shuffle=False, num_workers=4)
Gab = model.Generator()
Gba = model.Generator()
utils.cuda([Gab, Gba])
try:
ckpt = utils.load_checkpoint('%s/latest.ckpt' % (args.checkpoint_dir))
Gab.load_state_dict(ckpt['Gab'])
Gba.load_state_dict(ckpt['Gba'])
except:
print(' [*] No checkpoint!')
""" run """
a_real_test = Variable(iter(a_test_loader).next()[0], requires_grad=True)
b_real_test = Variable(iter(b_test_loader).next()[0], requires_grad=True)
a_real_test, b_real_test = utils.cuda([a_real_test, b_real_test])
Gab.eval()
Gba.eval()
with torch.no_grad():
a_fake_test = Gab(b_real_test)
b_fake_test = Gba(a_real_test)
a_recon_test = Gab(b_fake_test)
b_recon_test = Gba(a_fake_test)
pic = (torch.cat([a_real_test, b_fake_test, a_recon_test, b_real_test, a_fake_test, b_recon_test], dim=0).data + 1) / 2.0
if not os.path.isdir(args.results_dir):
os.makedirs(args.results_dir)
torchvision.utils.save_image(pic, args.results_dir+'/sample.jpg', nrow=3)
def __init__(self, config):
self.config = config
self.vis_noise_len = config.vis_dim * config.vis_dim
if config.auxclas:
self.vis_noise_len = config.vis_dim
self.x_dim = config.vis_dim
self.y_dim = config.vis_dim
#init z
z = torch.FloatTensor(self.vis_noise_len, config.z_len)
sample_z(config.z_distribution, z)
#init c if necessary
if config.auxclas:
if config.dataname == "CelebA" and config.labeltype == "bool": #Todo: make up to date for multiple categories
c_len = 2
c = []
for n in range(c_len):
binary = bin(n)[2:].zfill(1) #unnecessarry
c += [[int(x) for x in binary]]
c = np.array(c, dtype=np.float32)
c = np.repeat(c, self.vis_noise_len, axis=0)
c_g_input = torch.from_numpy(c)
else:
c_len = 1
for cat in config.categories:
c_len *= cat
category = config.categories[0]
c = np.repeat(range(category), self.vis_noise_len)
c = torch.from_numpy(c).float().unsqueeze(1)
for category in config.categories[1:]:
new = np.repeat(range(category), len(c))
new = torch.from_numpy(new).float().unsqueeze(1)
c = torch.cat([c] * category, 0)
c = torch.cat([c, new], 1)
c_g_input = to_one_hot(config.categories, c)
z = z.repeat(c_len, 1)
#old self.x_dim = c_len
self.y_dim = c_len
#construct input
self.generator_input = (utils.cuda(Variable(z)), )
if config.auxclas:
self.generator_input += (utils.cuda(Variable(c_g_input)), )
if config.coupled:
self.generator_input += (utils.cuda(Variable(c_g_input)), )
def calc_gradient_penalty(self, real_data, fake_data):
alpha = torch.rand(self.current_batch_size, 1, 1, 1)
alpha = cuda(alpha, self.cuda)
interpolates = torch.mul(alpha, real_data) + torch.mul((1 - alpha), fake_data)
interpolates = cuda(interpolates, self.cuda)
interpolates = torch.autograd.Variable(interpolates, requires_grad=True)
disc_interpolates = self.D(interpolates)
gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolates,
grad_outputs=cuda(torch.ones(disc_interpolates.size()), self.cuda),
create_graph=True, retain_graph=True, only_inputs=True)[0]
gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean() * self.gp_lambda
return gradient_penalty
def model_init(self):
self.D = Discriminator(self.input_channel, residual=self.d_residual)
self.G = Generator(self.input_channel, residual=self.g_residual)
self.D.apply(weights_init)
self.G.apply(weights_init)
self.D_optim = optim.RMSprop(self.D.parameters(), lr=self.D_lr)
self.G_optim = optim.RMSprop(self.G.parameters(), lr=self.G_lr)
self.D = cuda(self.D, self.cuda)
self.G = cuda(self.G, self.cuda)
if self.multi_gpu:
self.D = nn.DataParallel(self.D).cuda()
self.G = nn.DataParallel(self.G).cuda()
def __init__(self, hidden_size, voc_size, padding_idx, init_idx, max_len, embeddings=None, embedding_dim=300):
super().__init__()
# Sizes
if embeddings is not None:
self.embedding_dim = embeddings.shape[1]
else:
self.embedding_dim = embedding_dim
self.hidden_size = hidden_size
self.voc_size = voc_size
self.max_len = max_len
# Indices
self.init_idx = init_idx
self.padding_idx = padding_idx
# Layers
if embeddings is not None:
self.embeddings = cuda(embeddings)
self.emb = nn.Embedding.from_pretrained(self.embeddings, freeze=True)
else:
self.emb = nn.Embedding(self.voc_size, self.embedding_dim)
self.enc = nn.LSTM(self.embedding_dim, self.hidden_size, batch_first=True)
self.dec = nn.LSTMCell(self.embedding_dim, self.hidden_size)
self.lin = nn.Linear(self.hidden_size, self.voc_size)
def data_labels(self,
text,
#fudged_text,
segments,
segments_data,
classifier_fn,
num_samples,
batch_size=10):
texts = []
#temp0 = copy.deepcopy(text).cpu().numpy()
for row in segments_data:
temp = copy.deepcopy(text).cpu().numpy()
zeros = np.where(row == 0)[0]
mask = np.zeros(segments.shape).astype(bool)
for z in zeros:
mask[segments == z] = True
temp[mask] = 0
#temp[mask] = fudged_text[mask]
texts.append(temp)
preds = classifier_fn(cuda(torch.Tensor(texts), self.is_cuda)).detach().cpu().numpy()
neighborhood_data = np.squeeze(np.mean(np.stack(texts, axis=0), axis = -1), axis = 1)
return np.array(preds), neighborhood_data
# augmentations.GaussianBlur(),
augmentations.Add(-5, 5, per_channel=True),
augmentations.ContrastNormalization(0.8, 1.2, per_channel=True),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
train_loader, valid_loader = data_loader.get_loaders(batch_size, train_transform=train_transform, fold=args.fold)
num_classes = 17
# model = get_model(num_classes, model_name)
# model = getattr(models, args.model)(num_classes=num_classes)
model = get_model(num_classes, model_name)
model = utils.cuda(model)
if utils.cuda_is_available:
if args.device_ids:
device_ids = list(map(int, args.device_ids.split(',')))
else:
device_ids = None
model = nn.DataParallel(model, device_ids=device_ids).cuda()
criterion = MultiLabelSoftMarginLoss()
train_kwargs = dict(
args=args,
model=model,
criterion=criterion,
