def renew_everything(self):
# renew dataloader
self.img_size = int(pow(2, min(floor(self.resl), self.max_resl)))
self.batch_size = 8
self.dataset = load_dataset(self.experiment_name)
self.dataloader = DataLoader(self.dataset,
num_workers=0,
batch_size=self.batch_size,
shuffle=True,
drop_last=True)
# self.dataset = VideoFolder(video_root=self.train_data_root, video_ext=self.ext, nframes=self.nframes, loader=self.video_loader, transform=self.transform_video)
# self.dataloader = DataLoader(dataset=self.dataset, batch_size=self.batch_size, shuffle=True, num_workers=self.nworkers)
self.epoch_tick = int(ceil(self.datasize / self.batch_size))
# define tensors
self.real_label = Variable(
torch.FloatTensor(self.batch_size, 1).fill_(1))
self.fake_label = Variable(
torch.FloatTensor(self.batch_size, 1).fill_(0))
# wrapping autograd Variable.
self.z = Variable(
torch.FloatTensor(self.batch_size, self.nc, self.nframes_in,
self.img_size, self.img_size))
self.x = Variable(
torch.FloatTensor(self.batch_size, self.nc, self.nframes,
self.img_size, self.img_size))
self.x_gen = Variable(
torch.FloatTensor(self.batch_size, self.nc, self.nframes_pred,
self.img_size, self.img_size))
self.z_x_gen = Variable(
torch.FloatTensor(self.batch_size, self.nc, self.nframes,
self.img_size, self.img_size))
# enable cuda
if self.use_cuda:
self.z = self.z.cuda()
self.x = self.x.cuda()
self.x_gen = self.x_gen.cuda()
self.z_x_gen = self.z_x_gen.cuda()
self.real_label = self.real_label.cuda()
self.fake_label = self.fake_label.cuda()
torch.cuda.manual_seed(config.random_seed)
# ship new model to cuda.
if self.use_cuda:
self.G = self.G.cuda()
self.D = self.D.cuda()
# optimizer
betas = (self.config.beta1, self.config.beta2)
if self.optimizer == 'adam':
self.opt_g = Adam(filter(lambda p: p.requires_grad,
self.G.parameters()),
lr=self.lr,
betas=betas,
weight_decay=0.0)
self.opt_d = Adam(filter(lambda p: p.requires_grad,
self.D.parameters()),
lr=self.lr,
betas=betas,
weight_decay=0.0)
def translateBatch(self, batch, dataset):
beam_size = self.opt.beam_size
batch_size = batch.batch_size
# (1) Run the encoder on the src.
_, src_lengths = batch.src
src = onmt.IO.make_features(batch, 'src')
encStates, context = self.model.encoder(src, src_lengths) # return hidden_t, outputs
print(type(torch.autograd.Variable(torch.FloatTensor(encStates[0].data.shape).uniform_(-0.2, 0.2))))
print(type(encStates[0]))
newEncStates = (
encStates[0] + torch.autograd.Variable(torch.FloatTensor(encStates[0].data.shape).uniform_(-0.2, 0.2)).cuda(),
encStates[1] + torch.autograd.Variable(torch.FloatTensor(encStates[1].data.shape).uniform_(-0.2, 0.2).cuda())
)
if NOISE_TRANSELATE:
decStates = self.model.decoder.init_decoder_state(src, context, newEncStates)
else:
decStates = self.model.decoder.init_decoder_state(src, context, encStates)
# (1b) Initialize for the decoder.
def var(a): return Variable(a, volatile=True)
def rvar(a): return var(a.repeat(1, beam_size, 1))
# Repeat everything beam_size times.
context = rvar(context.data)
src = rvar(src.data)
srcMap = rvar(batch.src_map.data)
decStates.repeat_beam_size_times(beam_size)
scorer = None
# scorer=onmt.GNMTGlobalScorer(0.3, 0.4)
beam = [onmt.Beam(beam_size, n_best=self.opt.n_best,
cuda=self.opt.cuda,
vocab=self.fields["tgt"].vocab,
global_scorer=scorer)
for __ in range(batch_size)]
# (2) run the decoder to generate sentences, using beam search.
def bottle(m):
return m.view(batch_size * beam_size, -1)
def unbottle(m):
return m.view(beam_size, batch_size, -1)
for i in range(self.opt.max_sent_length):
if all((b.done() for b in beam)):
break
# Construct batch x beam_size nxt words.
# Get all the pending current beam words and arrange for forward.
inp = var(torch.stack([b.getCurrentState() for b in beam])
.t().contiguous().view(1, -1))
# Turn any copied words to UNKs
# 0 is unk
if self.copy_attn:
inp = inp.masked_fill(
inp.gt(len(self.fields["tgt"].vocab) - 1), 0)
# Temporary kludge solution to handle changed dim expectation
# in the decoder
inp = inp.unsqueeze(2)
# Run one step.
decOut, decStates, attn = \
self.model.decoder(inp, context, decStates)
decOut = decOut.squeeze(0)
# decOut: beam x rnn_size
# (b) Compute a vector of batch*beam word scores.
if not self.copy_attn:
out = self.model.generator.forward(decOut).data
out = unbottle(out)
# beam x tgt_vocab
else:
out = self.model.generator.forward(decOut,
attn["copy"].squeeze(0),
srcMap)
# beam x (tgt_vocab + extra_vocab)
out = dataset.collapse_copy_scores(
unbottle(out.data),
batch, self.fields["tgt"].vocab)
# beam x tgt_vocab
out = out.log()
# (c) Advance each beam.
for j, b in enumerate(beam):
b.advance(out[:, j], unbottle(attn["std"]).data[:, j])
decStates.beam_update(j, b.getCurrentOrigin(), beam_size)
if "tgt" in batch.__dict__:
allGold = self._runTarget(batch, dataset)
else:
allGold = [0] * batch_size
# (3) Package everything up.
allHyps, allScores, allAttn = [], [], []
for b in beam:
n_best = self.opt.n_best
scores, ks = b.sortFinished(minimum=n_best)
hyps, attn = [], []
for i, (times, k) in enumerate(ks[:n_best]):
hyp, att = b.getHyp(times, k)
hyps.append(hyp)
attn.append(att)
allHyps.append(hyps)
allScores.append(scores)
allAttn.append(attn)
return allHyps, allScores, allAttn, allGold
def forward(self, output, target):
batch_size = output.data.size(0)
height = output.data.size(2)
width = output.data.size(3)
# Get x,y,w,h,conf,cls
output = output.view(batch_size, self.num_anchors, -1, height * width)
coord = torch.zeros_like(output[:, :, :4, :])
coord[:, :, :2, :] = output[:, :, :2, :].sigmoid()
coord[:, :, 2:4, :] = output[:, :, 2:4, :]
conf = output[:, :, 4, :].sigmoid()
cls = (output[:, :, 5:, :].contiguous().view(
batch_size * self.num_anchors, self.num_classes,
height * width).transpose(1, 2).contiguous().view(
-1, self.num_classes))
# Create prediction boxes
pred_boxes = torch.FloatTensor(
batch_size * self.num_anchors * height * width, 4)
lin_x = torch.range(0, width - 1).repeat(height,
1).view(height * width)
lin_y = torch.range(0, height - 1).repeat(
width, 1).t().contiguous().view(height * width)
anchor_w = self.anchors[:, 0].contiguous().view(self.num_anchors, 1)
anchor_h = self.anchors[:, 1].contiguous().view(self.num_anchors, 1)
if torch.cuda.is_available():
pred_boxes = pred_boxes.cuda()
lin_x = lin_x.cuda()
lin_y = lin_y.cuda()
anchor_w = anchor_w.cuda()
anchor_h = anchor_h.cuda()
pred_boxes[:, 0] = (coord[:, :, 0].detach() + lin_x).view(-1)
pred_boxes[:, 1] = (coord[:, :, 1].detach() + lin_y).view(-1)
pred_boxes[:, 2] = (coord[:, :, 2].detach().exp() * anchor_w).view(-1)
pred_boxes[:, 3] = (coord[:, :, 3].detach().exp() * anchor_h).view(-1)
pred_boxes = pred_boxes.cpu()
# Get target values
coord_mask, conf_mask, cls_mask, tcoord, tconf, tcls = self.build_targets(
pred_boxes, target, height, width)
coord_mask = coord_mask.expand_as(tcoord)
tcls = tcls[cls_mask].view(-1).long()
cls_mask = cls_mask.view(-1, 1).repeat(1, self.num_classes)
if torch.cuda.is_available():
tcoord = tcoord.cuda()
tconf = tconf.cuda()
coord_mask = coord_mask.cuda()
conf_mask = conf_mask.cuda()
tcls = tcls.cuda()
cls_mask = cls_mask.cuda()
conf_mask = conf_mask.sqrt()
cls = cls[cls_mask].view(-1, self.num_classes)
# Compute losses
mse = nn.MSELoss(size_average=False)
ce = nn.CrossEntropyLoss(size_average=False)
self.loss_coord = self.coord_scale * mse(
coord * coord_mask, tcoord * coord_mask) / batch_size
self.loss_conf = mse(conf * conf_mask, tconf * conf_mask) / batch_size
self.loss_cls = self.class_scale * 2 * ce(cls, tcls) / batch_size
self.loss_tot = self.loss_coord + self.loss_conf + self.loss_cls
return self.loss_tot, self.loss_coord, self.loss_conf, self.loss_cls
def forward(self, x):
x = x[:, :, 0:8, :]
x = self.main(x)
x = x.view(x.size(0), x.size(1))
return x
if __name__ == '__main__':
# device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
# train_loader = data_loader('data/processed', 1)
# data_iter = iter(train_loader)
t = torch.rand([1,1,36,512])
l = torch.FloatTensor([[0,1,0,0]])
print(l.size())
# d1 = Down2d(1, 32, 1,1,1)
# print(d1(t).shape)
# u1 = Up2d(1,32,1,2,1)
# print(u1(t).shape)
# G = Generator()
# o1 = G(t, l)
# print(o1.shape)
D = Discriminator()
o2 = D(t, l)
print(o2.shape, o2)
# C = DomainClassifier()
def main(args):
SEED = 1234
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
train_data = p.load(open(args.train_data, 'rb'))
dev_data = p.load(open(args.tune_data, 'rb'))
test_data = p.load(open(args.test_data, 'rb'))
word_embeddings = p.load(open(args.word_embeddings, 'rb'))
vocab = p.load(open(args.vocab, 'rb'))
BATCH_SIZE = 64
INPUT_DIM = len(vocab)
EMBEDDING_DIM = len(word_embeddings[0])
HIDDEN_DIM = 100
OUTPUT_DIM = 1
N_LAYERS = 1
BIDIRECTIONAL = True
DROPOUT = 0.5
context_model = RNN(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, HIDDEN_DIM,
N_LAYERS, BIDIRECTIONAL, DROPOUT)
question_model = RNN(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, HIDDEN_DIM,
N_LAYERS, BIDIRECTIONAL, DROPOUT)
answer_model = RNN(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, HIDDEN_DIM,
N_LAYERS, BIDIRECTIONAL, DROPOUT)
utility_model = FeedForward(HIDDEN_DIM * 3, HIDDEN_DIM, OUTPUT_DIM)
criterion = nn.BCEWithLogitsLoss()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
utility_model = utility_model.to(device)
context_model = context_model.to(device)
question_model = question_model.to(device)
answer_model = answer_model.to(device)
criterion = criterion.to(device)
word_embeddings = autograd.Variable(
torch.FloatTensor(word_embeddings).cuda())
context_model.embedding.weight.data.copy_(word_embeddings)
question_model.embedding.weight.data.copy_(word_embeddings)
answer_model.embedding.weight.data.copy_(word_embeddings)
# Fix word embeddings
context_model.embedding.weight.requires_grad = False
question_model.embedding.weight.requires_grad = False
answer_model.embedding.weight.requires_grad = False
optimizer = optim.Adam(list([par for par in context_model.parameters() if par.requires_grad]) + \
list([par for par in question_model.parameters() if par.requires_grad]) + \
list([par for par in answer_model.parameters() if par.requires_grad]) + \
list([par for par in utility_model.parameters() if par.requires_grad]))
N_EPOCHS = 300
train_data = prepare_data(train_data, vocab, 'train', args.cuda)
dev_data = prepare_data(dev_data, vocab, 'dev', args.cuda)
test_data = prepare_data(test_data, vocab, 'test', args.cuda)
for epoch in range(N_EPOCHS):
train_loss, train_acc = train_fn(context_model, question_model, answer_model, utility_model, \
train_data, optimizer, criterion, BATCH_SIZE)
valid_loss, valid_acc = evaluate(context_model, question_model, answer_model, utility_model, \
dev_data, criterion, BATCH_SIZE)
#valid_loss, valid_acc = evaluate(context_model, question_model, answer_model, utility_model, \
# test_data, criterion, BATCH_SIZE)
print 'Epoch %d: Train Loss: %.3f, Train Acc: %.3f, Val Loss: %.3f, Val Acc: %.3f' % (
epoch, train_loss, train_acc, valid_loss, valid_acc)
def sample_action(self, state):
a = torch.FloatTensor(self.num_actions).uniform_(-1, 1)
_, mean, std = self.get_action(state, deterministic=True)
return self.action_range * a.numpy(), mean, std
def __init__(self,startState,device = ''):
if len(device)==0:
device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
self.currentState = torch.FloatTensor(startState).unsqueeze(0).to(device)
x = tr.autograd.Variable(tr.Tensor([2]),requires_grad=True)
y = tr.autograd.Variable(tr.Tensor([2]),requires_grad=True)
z = 5*x**4 + 3*y**3 + 7*x**2 + 9*x - 5
z.backward()
x.grad
y.grad
x = tr.autograd.Variable(tr.Tensor([1]),requires_grad=True)
y=3+x**2
import torch
from torch.autograd import Variable
tns = torch.FloatTensor([3])
x = Variable(tns, requires_grad=True)
opt = torch.optim.Adam([x], lr=.01, betas=(0.5, 0.999))
for i in range(30):
opt.zero_grad()
z = 4+x*x
z.backward() # Calculate gradients
opt.step()
print(x.grad)
def load_wav_to_torch(full_path):
sampling_rate, data = read(full_path)
return torch.FloatTensor(data.astype(np.float32)), sampling_rate
def forward(x):
self.counter += 1
return torch.FloatTensor(self.frame2box[str(object=self.counter)])
def detection(self, img):
img = torch.FloatTensor(img)
img = img.permute(2, 0, 1)[None]
box = self.model(img)
return box, roi_align(self.feature_map, [box], [3,3], 1.)
def main():
"""Create the model and start the training."""
device = torch.device("cuda" if not args.cpu else "cpu")
w, h = map(int, args.input_size.split(','))
input_size = (w, h)
w, h = map(int, args.input_size_target.split(','))
input_size_target = (w, h)
cudnn.enabled = True
# Create network
if args.model == 'DeepLab':
model = DeeplabMulti(num_classes=args.num_classes)
if args.restore_from[:4] == 'http' :
saved_state_dict = model_zoo.load_url(args.restore_from)
else:
saved_state_dict = torch.load(args.restore_from)
new_params = model.state_dict().copy()
for i in saved_state_dict:
# Scale.layer5.conv2d_list.3.weight
i_parts = i.split('.')
# print i_parts
if not args.num_classes == 19 or not i_parts[1] == 'layer5':
new_params['.'.join(i_parts[1:])] = saved_state_dict[i]
# print i_parts
model.load_state_dict(new_params)
model.train()
model.to(device)
cudnn.benchmark = True
# init D
model_D1 = FCDiscriminator(num_classes=args.num_classes).to(device)
model_D2 = FCDiscriminator(num_classes=args.num_classes).to(device)
model_D1.train()
model_D1.to(device)
model_D2.train()
model_D2.to(device)
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
trainloader = data.DataLoader(
GTA5DataSet(args.data_dir, args.data_list, max_iters=args.num_steps * args.iter_size * args.batch_size,
crop_size=input_size,
scale=args.random_scale, mirror=args.random_mirror, mean=IMG_MEAN),
batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, pin_memory=True)
trainloader_iter = enumerate(trainloader)
targetloader = data.DataLoader(cityscapesDataSet(args.data_dir_target, args.data_list_target,
max_iters=args.num_steps * args.iter_size * args.batch_size,
crop_size=input_size_target,
scale=False, mirror=args.random_mirror, mean=IMG_MEAN,
set=args.set),
batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers,
pin_memory=True)
targetloader_iter = enumerate(targetloader)
# implement model.optim_parameters(args) to handle different models' lr setting
optimizer = optim.SGD(model.optim_parameters(args),
lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay)
optimizer.zero_grad()
optimizer_D1 = optim.Adam(model_D1.parameters(), lr=args.learning_rate_D, betas=(0.9, 0.99))
optimizer_D1.zero_grad()
optimizer_D2 = optim.Adam(model_D2.parameters(), lr=args.learning_rate_D, betas=(0.9, 0.99))
optimizer_D2.zero_grad()
if args.gan == 'Vanilla':
bce_loss = torch.nn.BCEWithLogitsLoss()
elif args.gan == 'LS':
bce_loss = torch.nn.MSELoss()
seg_loss = torch.nn.CrossEntropyLoss(ignore_index=255)
interp = nn.Upsample(size=(input_size[1], input_size[0]), mode='bilinear', align_corners=True)
interp_target = nn.Upsample(size=(input_size_target[1], input_size_target[0]), mode='bilinear', align_corners=True)
# labels for adversarial training
source_label = 0
target_label = 1
# set up tensor board
if args.tensorboard:
if not os.path.exists(args.log_dir):
os.makedirs(args.log_dir)
writer = SummaryWriter(args.log_dir)
for i_iter in range(args.num_steps):
loss_seg_value1 = 0
loss_adv_target_value1 = 0
loss_D_value1 = 0
loss_seg_value2 = 0
loss_adv_target_value2 = 0
loss_D_value2 = 0
optimizer.zero_grad()
adjust_learning_rate(optimizer, i_iter)
optimizer_D1.zero_grad()
optimizer_D2.zero_grad()
adjust_learning_rate_D(optimizer_D1, i_iter)
adjust_learning_rate_D(optimizer_D2, i_iter)
for sub_i in range(args.iter_size):
# train G
# don't accumulate grads in D
for param in model_D1.parameters():
param.requires_grad = False
for param in model_D2.parameters():
param.requires_grad = False
# train with source
_, batch = trainloader_iter.__next__()
images, labels, _, _ = batch
images = images.to(device)
labels = labels.long().to(device)
pred1, pred2 = model(images)
pred1 = interp(pred1)
pred2 = interp(pred2)
loss_seg1 = seg_loss(pred1, labels)
loss_seg2 = seg_loss(pred2, labels)
loss = loss_seg2 + args.lambda_seg * loss_seg1
# proper normalization
loss = loss / args.iter_size
loss.backward()
loss_seg_value1 += loss_seg1.item() / args.iter_size
loss_seg_value2 += loss_seg2.item() / args.iter_size
# train with target
_, batch = targetloader_iter.__next__()
images, _, _ = batch
images = images.to(device)
pred_target1, pred_target2 = model(images)
pred_target1 = interp_target(pred_target1)
pred_target2 = interp_target(pred_target2)
D_out1 = model_D1(F.softmax(pred_target1))
D_out2 = model_D2(F.softmax(pred_target2))
loss_adv_target1 = bce_loss(D_out1, torch.FloatTensor(D_out1.data.size()).fill_(source_label).to(device))
loss_adv_target2 = bce_loss(D_out2, torch.FloatTensor(D_out2.data.size()).fill_(source_label).to(device))
loss = args.lambda_adv_target1 * loss_adv_target1 + args.lambda_adv_target2 * loss_adv_target2
loss = loss / args.iter_size
loss.backward()
loss_adv_target_value1 += loss_adv_target1.item() / args.iter_size
loss_adv_target_value2 += loss_adv_target2.item() / args.iter_size
# train D
# bring back requires_grad
for param in model_D1.parameters():
param.requires_grad = True
for param in model_D2.parameters():
param.requires_grad = True
# train with source
pred1 = pred1.detach()
pred2 = pred2.detach()
D_out1 = model_D1(F.softmax(pred1))
D_out2 = model_D2(F.softmax(pred2))
loss_D1 = bce_loss(D_out1, torch.FloatTensor(D_out1.data.size()).fill_(source_label).to(device))
loss_D2 = bce_loss(D_out2, torch.FloatTensor(D_out2.data.size()).fill_(source_label).to(device))
loss_D1 = loss_D1 / args.iter_size / 2
loss_D2 = loss_D2 / args.iter_size / 2
loss_D1.backward()
loss_D2.backward()
loss_D_value1 += loss_D1.item()
loss_D_value2 += loss_D2.item()
# train with target
pred_target1 = pred_target1.detach()
pred_target2 = pred_target2.detach()
D_out1 = model_D1(F.softmax(pred_target1))
D_out2 = model_D2(F.softmax(pred_target2))
loss_D1 = bce_loss(D_out1, torch.FloatTensor(D_out1.data.size()).fill_(target_label).to(device))
loss_D2 = bce_loss(D_out2, torch.FloatTensor(D_out2.data.size()).fill_(target_label).to(device))
loss_D1 = loss_D1 / args.iter_size / 2
loss_D2 = loss_D2 / args.iter_size / 2
loss_D1.backward()
loss_D2.backward()
loss_D_value1 += loss_D1.item()
loss_D_value2 += loss_D2.item()
optimizer.step()
optimizer_D1.step()
optimizer_D2.step()
if args.tensorboard:
scalar_info = {
'loss_seg1': loss_seg_value1,
'loss_seg2': loss_seg_value2,
'loss_adv_target1': loss_adv_target_value1,
'loss_adv_target2': loss_adv_target_value2,
'loss_D1': loss_D_value1,
'loss_D2': loss_D_value2,
}
if i_iter % 10 == 0:
for key, val in scalar_info.items():
writer.add_scalar(key, val, i_iter)
print('exp = {}'.format(args.snapshot_dir))
print(
'iter = {0:8d}/{1:8d}, loss_seg1 = {2:.3f} loss_seg2 = {3:.3f} loss_adv1 = {4:.3f}, loss_adv2 = {5:.3f} loss_D1 = {6:.3f} loss_D2 = {7:.3f}'.format(
i_iter, args.num_steps, loss_seg_value1, loss_seg_value2, loss_adv_target_value1, loss_adv_target_value2, loss_D_value1, loss_D_value2))
if i_iter >= args.num_steps_stop - 1:
print('save model ...')
torch.save(model.state_dict(), osp.join(args.snapshot_dir, 'GTA5_' + str(args.num_steps_stop) + '.pth'))
torch.save(model_D1.state_dict(), osp.join(args.snapshot_dir, 'GTA5_' + str(args.num_steps_stop) + '_D1.pth'))
torch.save(model_D2.state_dict(), osp.join(args.snapshot_dir, 'GTA5_' + str(args.num_steps_stop) + '_D2.pth'))
break
if i_iter % args.save_pred_every == 0 and i_iter != 0:
print('taking snapshot ...')
torch.save(model.state_dict(), osp.join(args.snapshot_dir, 'GTA5_' + str(i_iter) + '.pth'))
torch.save(model_D1.state_dict(), osp.join(args.snapshot_dir, 'GTA5_' + str(i_iter) + '_D1.pth'))
torch.save(model_D2.state_dict(), osp.join(args.snapshot_dir, 'GTA5_' + str(i_iter) + '_D2.pth'))
if args.tensorboard:
writer.close()
def get_target(self, target, anchors, in_w, in_h, ignore_threshold):
# 计算一共有多少张图片
bs = len(target)
# 获得先验框
anchor_index = [[0, 1, 2], [3, 4, 5],
[6, 7, 8]][self.feature_length.index(in_w)]
subtract_index = [0, 3, 6][self.feature_length.index(in_w)]
# 创建全是0或者全是1的阵列
mask = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
requires_grad=False)
noobj_mask = torch.ones(bs,
int(self.num_anchors / 3),
in_h,
in_w,
requires_grad=False)
tx = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
requires_grad=False)
ty = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
requires_grad=False)
tw = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
requires_grad=False)
th = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
requires_grad=False)
t_box = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
4,
requires_grad=False)
tconf = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
requires_grad=False)
tcls = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
self.num_classes,
requires_grad=False)
box_loss_scale_x = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
requires_grad=False)
box_loss_scale_y = torch.zeros(bs,
int(self.num_anchors / 3),
in_h,
in_w,
requires_grad=False)
for b in range(bs):
if len(target[b]) == 0:
continue
# 计算出在特征层上的点位
gxs = target[b][:, 0:1] * in_w
gys = target[b][:, 1:2] * in_h
gws = target[b][:, 2:3] * in_w
ghs = target[b][:, 3:4] * in_h
# 计算出属于哪个网格
gis = torch.floor(gxs)
gjs = torch.floor(gys)
# 计算真实框的位置
gt_box = torch.FloatTensor(
torch.cat(
[torch.zeros_like(gws),
torch.zeros_like(ghs), gws, ghs], 1))
# 计算出所有先验框的位置
anchor_shapes = torch.FloatTensor(
torch.cat((torch.zeros(
(self.num_anchors, 2)), torch.FloatTensor(anchors)), 1))
# 计算重合程度
anch_ious = jaccard(gt_box, anchor_shapes)
# Find the best matching anchor box
best_ns = torch.argmax(anch_ious, dim=-1)
for i, best_n in enumerate(best_ns):
if best_n not in anchor_index:
continue
# Masks
gi = gis[i].long()
gj = gjs[i].long()
gx = gxs[i]
gy = gys[i]
gw = gws[i]
gh = ghs[i]
if (gj < in_h) and (gi < in_w):
best_n = best_n - subtract_index
# 判定哪些先验框内部真实的存在物体
noobj_mask[b, best_n, gj, gi] = 0
mask[b, best_n, gj, gi] = 1
# 计算先验框中心调整参数
tx[b, best_n, gj, gi] = gx
ty[b, best_n, gj, gi] = gy
# 计算先验框宽高调整参数
tw[b, best_n, gj, gi] = gw
th[b, best_n, gj, gi] = gh
# 用于获得xywh的比例
box_loss_scale_x[b, best_n, gj, gi] = target[b][i, 2]
box_loss_scale_y[b, best_n, gj, gi] = target[b][i, 3]
# 物体置信度
tconf[b, best_n, gj, gi] = 1
# 种类
tcls[b, best_n, gj, gi, target[b][i, 4].long()] = 1
else:
print('Step {0} out of bound'.format(b))
print('gj: {0}, height: {1} | gi: {2}, width: {3}'.format(
gj, in_h, gi, in_w))
continue
t_box[..., 0] = tx
t_box[..., 1] = ty
t_box[..., 2] = tw
t_box[..., 3] = th
return mask, noobj_mask, t_box, tconf, tcls, box_loss_scale_x, box_loss_scale_y
def train(loaders, dist, args):
# use checkpoint model if given
if args.m is None:
checkpoint = torch.load(args.checkpoint)
model_name = checkpoint['name']
model = Model(model_name)
model.load_state_dict(checkpoint['model_state_dict'])
else: # else init model
model_name = args.m
model = Model(model_name)
# loss and device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
dist = torch.FloatTensor(dist).to(
device
) # no epsilon needs to be added, each category has at least one sample
if args.wl:
criterion = nn.CrossEntropyLoss()
else:
criterion = nn.CrossEntropyLoss(weight=1 / dist)
data_parallel = False
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
data_parallel = True
model.to(device)
path_to_best_model = ""
# learning rate
optimizer = optimizer = optim.Adadelta(model.parameters(),
lr=args.lr,
rho=0.95,
eps=1e-08)
best_loss = sys.maxsize
early_stop = False
# epochs
iternum = 1
for epoch in range(args.epoch_num):
epoch_loss = 0
num_corrects = 0
tbar = tqdm(loaders['train'])
# iterate through images
for i, (imgs, labels) in enumerate(tbar):
model.train()
imgs, labels = imgs.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(imgs)
_, preds = torch.max(outputs, 1)
num_corrects += torch.sum(preds == labels.data)
loss = criterion(outputs, labels)
epoch_loss += loss.item()
loss.backward()
optimizer.step()
# current training accuracy of epoch
epoch_acc = num_corrects.double() / ((i + 1) * args.batch_size)
tbar.set_description(
'Epoch: [{}/{}], Epoch_loss: {:.5f}, Epoch_acc: {:.5f}'.format(
epoch + 1, args.epoch_num, epoch_loss / (i + 1),
epoch_acc))
# early stopping
if iternum % args.num_iter_to_validate == 0:
print("Validating model ...")
if epoch > args.num_iter_to_validate:
print('Best validation loss: {}'.format(best_loss))
val_loss, val_acc = validate(loaders['val'], model, device)
# if we have the best model so far
if val_loss < best_loss:
best_loss = val_loss
path_to_checkpoint = os.path.abspath(
os.path.join(args.checkpoint,
f'model_{model_name}_epoch_{epoch}.pth'))
if path_to_best_model:
os.remove(path_to_best_model)
path_to_best_model = path_to_checkpoint
num_checks = 0
state_dict = model.module.state_dict(
) if data_parallel else model.state_dict()
torch.save(
{
'model_state_dict': state_dict,
'model_name': model_name
}, path_to_checkpoint)
else: # else we increase patience, if patience reaches the limit we stop
num_checks += 1
if num_checks >= args.patience:
print("Early stopping ...")
early_stop = True
print(
'Validation loss: {}\n Validation acc: {}'.format(
val_loss, val_acc),
'Number of checks: {}'.format(num_checks))
if early_stop:
break
iternum += 1
return model
# created by lampson.song @ 2020-7-27
# yolov5s network
import sys
sys.path.append('.')
import torch
import torch.nn as nn
import collections
from net.yolo_layer import YOLOLayer
anchors = torch.FloatTensor([[10., 13], [16, 30], [33, 23], [30, 61], [62, 45],
[59, 119], [116, 90], [156, 198], [373, 326]])
class Conv(nn.Module):
def __init__(self,
input_channels,
output_channels,
kernel_size=3,
stride=1,
groups=1,
act=True):
super(Conv, self).__init__()
padding = (kernel_size - 1) // 2
self.conv = nn.Conv2d(input_channels,
output_channels,
kernel_size,
stride,
padding,
groups=groups,
bias=False)
return output
netG = Generator()
netD = Discriminator()
print(netG)
print(netD)
use_cuda = torch.cuda.is_available()
if use_cuda:
gpu = 0
if use_cuda:
netD = netD.cuda(gpu)
netG = netG.cuda(gpu)
one = torch.FloatTensor([1])
mone = one * -1
if use_cuda:
one = one.cuda(gpu)
mone = mone.cuda(gpu)
optimizerD = optim.Adam(netD.parameters(), lr=1e-4, betas=(0.5, 0.9))
optimizerG = optim.Adam(netG.parameters(), lr=1e-4, betas=(0.5, 0.9))
def calc_gradient_penalty(netD, real_data, fake_data):
# print "real_data: ", real_data.size(), fake_data.size()
alpha = torch.rand(BATCH_SIZE, 1)
alpha = alpha.expand(BATCH_SIZE,
real_data.nelement() // BATCH_SIZE).view(
BATCH_SIZE, 3, 32, 32)
def caption_image_beam_search(encoder, decoder, image_path, word_map,
beam_size, device):
"""
Reads an image and captions it with beam search.
:param encoder: encoder model
:param decoder: decoder model
:param image_path: path to image
:param word_map: word map
:param beam_size: number of sequences to consider at each decode-step
:return: caption, weights for visualization
"""
k = beam_size
vocab_size = len(word_map)
# Read image and process
img = imread(image_path)
if len(img.shape) == 2:
img = img[:, :, np.newaxis]
img = np.concatenate([img, img, img], axis=2)
img = imresize(img, (256, 256))
img = img.transpose(2, 0, 1)
img = img / 255.
img = torch.FloatTensor(img).to(device)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([normalize])
image = transform(img) # (3, 256, 256)
# Encode
image = image.unsqueeze(0) # (1, 3, 256, 256)
encoder_out = encoder(
image) # (1, enc_image_size, enc_image_size, encoder_dim)
enc_image_size = encoder_out.size(1)
encoder_dim = encoder_out.size(3)
# Flatten encoding
encoder_out = encoder_out.view(1, -1,
encoder_dim) # (1, num_pixels, encoder_dim)
num_pixels = encoder_out.size(1)
# We'll treat the problem as having a batch size of k
encoder_out = encoder_out.expand(
k, num_pixels, encoder_dim) # (k, num_pixels, encoder_dim)
# Tensor to store top k previous words at each step; now they're just <start>
k_prev_words = torch.LongTensor([[word_map['<start>']]] * k).to(
device) # (k, 1)
# Tensor to store top k sequences; now they're just <start>
seqs = k_prev_words # (k, 1)
# Tensor to store top k sequences' scores; now they're just 0
top_k_scores = torch.zeros(k, 1).to(device) # (k, 1)
# Tensor to store top k sequences' alphas; now they're just 1s
seqs_alpha = torch.ones(k, 1, enc_image_size, enc_image_size).to(
device) # (k, 1, enc_image_size, enc_image_size)
# Lists to store completed sequences, their alphas and scores
complete_seqs = list()
complete_seqs_alpha = list()
complete_seqs_scores = list()
# Start decoding
step = 1
h, c = decoder.init_hidden_state(encoder_out)
# s is a number less than or equal to k, because sequences are removed from this process once they hit <end>
while True:
embeddings = decoder.embedding(k_prev_words).squeeze(
1) # (s, embed_dim)
awe, alpha = decoder.attention(encoder_out,
h) # (s, encoder_dim), (s, num_pixels)
alpha = alpha.view(
-1, enc_image_size,
enc_image_size) # (s, enc_image_size, enc_image_size)
gate = decoder.sigmoid(
decoder.f_beta(h)) # gating scalar, (s, encoder_dim)
awe = gate * awe
h, c = decoder.decode_step(torch.cat([embeddings, awe], dim=1),
(h, c)) # (s, decoder_dim)
scores = decoder.fc(h) # (s, vocab_size)
scores = F.log_softmax(scores, dim=1)
# Add
scores = top_k_scores.expand_as(scores) + scores # (s, vocab_size)
# For the first step, all k points will have the same scores (since same k previous words, h, c)
if step == 1:
top_k_scores, top_k_words = scores[0].topk(k, 0, True, True) # (s)
else:
# Unroll and find top scores, and their unrolled indices
top_k_scores, top_k_words = scores.view(-1).topk(k, 0, True,
True) # (s)
# Convert unrolled indices to actual indices of scores
prev_word_inds = top_k_words / vocab_size # (s)
next_word_inds = top_k_words % vocab_size # (s)
# Add new words to sequences, alphas
seqs = torch.cat([seqs[prev_word_inds],
next_word_inds.unsqueeze(1)],
dim=1) # (s, step+1)
seqs_alpha = torch.cat(
[seqs_alpha[prev_word_inds], alpha[prev_word_inds].unsqueeze(1)],
dim=1) # (s, step+1, enc_image_size, enc_image_size)
# Which sequences are incomplete (didn't reach <end>)?
incomplete_inds = [
ind for ind, next_word in enumerate(next_word_inds)
if next_word != word_map['<end>']
]
complete_inds = list(
set(range(len(next_word_inds))) - set(incomplete_inds))
# Set aside complete sequences
if len(complete_inds) > 0:
complete_seqs.extend(seqs[complete_inds].tolist())
complete_seqs_alpha.extend(seqs_alpha[complete_inds].tolist())
complete_seqs_scores.extend(top_k_scores[complete_inds])
k -= len(complete_inds) # reduce beam length accordingly
# Proceed with incomplete sequences
if k == 0:
break
seqs = seqs[incomplete_inds]
seqs_alpha = seqs_alpha[incomplete_inds]
h = h[prev_word_inds[incomplete_inds]]
c = c[prev_word_inds[incomplete_inds]]
encoder_out = encoder_out[prev_word_inds[incomplete_inds]]
top_k_scores = top_k_scores[incomplete_inds].unsqueeze(1)
k_prev_words = next_word_inds[incomplete_inds].unsqueeze(1)
# Break if things have been going on too long
if step > 50:
break
step += 1
i = complete_seqs_scores.index(max(complete_seqs_scores))
seq = complete_seqs[i]
alphas = complete_seqs_alpha[i]
return seq, alphas
def train(self, examples, writer=None):
"""
examples: list of examples, each example is of form (board, pi, v)
writer: optional tensorboardX writer
"""
optimizer = self.args.optimizer(self.nnet.parameters(), lr=self.args.lr, **self.args.optimizer_kwargs)
scheduler = self.args.lr_scheduler(optimizer, **self.args.lr_scheduler_kwargs)
# If no writer, create unusable writer
if writer is None: writer = WriterTensorboardX(None, None, False)
epoch_bar = tqdm(desc="Training Epoch", total=self.args.epochs)
for epoch in range(self.args.epochs):
self.nnet.train()
scheduler.step()
pi_losses = AverageMeter()
v_losses = AverageMeter()
total_losses = AverageMeter()
num_batches = int(len(examples)/self.args.batch_size)
bar = tqdm(desc='Batch', total=num_batches)
batch_idx = 0
while batch_idx < num_batches:
writer.set_step((self.train_iteration * self.args.epochs * num_batches) + (epoch * num_batches) + batch_idx)
sample_ids = np.random.randint(len(examples), size=self.args.batch_size)
boards, pis, vs = list(zip(*[examples[i] for i in sample_ids]))
boards = torch.FloatTensor(np.array(boards).astype(np.float64))
target_pis = torch.FloatTensor(np.array(pis))
target_vs = torch.FloatTensor(np.array(vs).astype(np.float64))
# predict
if self.args.cuda:
boards, target_pis, target_vs = boards.contiguous().cuda(), target_pis.contiguous().cuda(), target_vs.contiguous().cuda()
# compute output
out_pi, out_v = self.nnet(boards)
l_pi = self.loss_pi(target_pis, out_pi)
l_v = self.loss_v(target_vs, out_v)
total_loss = l_pi + l_v
pi_losses.update(l_pi.item(), boards.size(0))
v_losses.update(l_v.item(), boards.size(0))
total_losses.update(total_loss.item(), boards.size(0))
# record loss
writer.add_scalar('pi_loss', l_pi.item())
writer.add_scalar('v_loss', l_v.item())
writer.add_scalar('loss', total_loss.item())
# compute gradient and do SGD step
optimizer.zero_grad()
total_loss.backward()
optimizer.step()
# measure elapsed time
batch_idx += 1
# plot progress
bar.set_postfix(
lpi=l_pi.item(),
lv=l_v.item(),
loss=total_loss.item()
)
bar.update()
bar.close()
writer.set_step((self.train_iteration * self.args.epochs) + epoch, 'train_epoch')
writer.add_scalar('epoch_pi_loss', pi_losses.avg)
writer.add_scalar('epoch_v_loss', v_losses.avg)
writer.add_scalar('epoch_loss', total_losses.avg)
epoch_bar.set_postfix(
avg_lpi=pi_losses.avg,
avg_lv=v_losses.avg,
avg_l=total_losses.avg
)
epoch_bar.update()
epoch_bar.close()
self.train_iteration += 1
def update(self,
batch_size,
reward_scale=10.,
auto_entropy=True,
target_entropy=-2,
gamma=0.99,
soft_tau=1e-2):
state, action, reward, next_state, done = self.replay_buffer.sample(
batch_size)
# print('sample:', state, action, reward, done)
state = torch.FloatTensor(state).cuda()
next_state = torch.FloatTensor(next_state).cuda()
action = torch.FloatTensor(action).cuda()
# reward is single value, unsqueeze() to add one dim to be [reward] at the sample dim;
reward = torch.FloatTensor(reward).unsqueeze(1).cuda()
done = torch.FloatTensor(np.float32(done)).unsqueeze(1).cuda()
predicted_q_value1 = self.soft_q_net1(state, action)
predicted_q_value2 = self.soft_q_net2(state, action)
new_action, log_prob, z, mean, log_std = self.policy_net.evaluate(
state)
new_next_action, next_log_prob, _, _, _ = self.policy_net.evaluate(
next_state)
reward = reward_scale * (reward - reward.mean(dim=0)) / (
reward.std(dim=0) + 1e-6
) # normalize with batch mean and std; plus a small number to prevent numerical problem
# Updating alpha wrt entropy
# alpha = 0.0
# trade-off between exploration (max entropy) and exploitation (max Q)
if auto_entropy is True:
# self.log_alpha as forward function to get value
alpha_loss = -(self.log_alpha() *
(log_prob - 1.0 * self.action_dim).detach()).mean()
# print('alpha loss: ',alpha_loss)
self.alpha_optimizer.zero_grad()
alpha_loss.backward()
self.alpha_optimizer.step()
self.alpha = self.log_alpha().exp()
else:
self.alpha = 1.
alpha_loss = 0
# print(self.alpha)
# Training Q Function
target_q_min = torch.min(
self.target_soft_q_net1(next_state, new_next_action),
self.target_soft_q_net2(
next_state, new_next_action)) - self.alpha * next_log_prob
target_q_value = reward + (
1 - done) * gamma * target_q_min # if done==1, only reward
q_value_loss1 = self.soft_q_criterion1(
predicted_q_value1,
target_q_value.detach()) # detach: no gradients for the variable
q_value_loss2 = self.soft_q_criterion2(predicted_q_value2,
target_q_value.detach())
self.soft_q_optimizer1.zero_grad()
q_value_loss1.backward()
self.soft_q_optimizer1.step()
self.soft_q_optimizer2.zero_grad()
q_value_loss2.backward()
self.soft_q_optimizer2.step()
# Training Policy Function
predicted_new_q_value = torch.min(self.soft_q_net1(state, new_action),
self.soft_q_net2(state, new_action))
policy_loss = (self.alpha * log_prob - predicted_new_q_value).mean()
self.policy_optimizer.zero_grad()
policy_loss.backward()
self.policy_optimizer.step()
# print('q loss: ', q_value_loss1, q_value_loss2)
# print('policy loss: ', policy_loss )
# Soft update the target value net
for target_param, param in zip(self.target_soft_q_net1.parameters(),
self.soft_q_net1.parameters()):
target_param.data.copy_( # copy data value into target parameters
target_param.data * (1.0 - soft_tau) + param.data * soft_tau)
for target_param, param in zip(self.target_soft_q_net2.parameters(),
self.soft_q_net2.parameters()):
target_param.data.copy_( # copy data value into target parameters
target_param.data * (1.0 - soft_tau) + param.data * soft_tau)
# return predicted_new_q_value.mean()
q1_, q2_, po_ = q_value_loss1.detach(), q_value_loss2.detach(
), policy_loss.detach()
return 0, q1_.item(), q2_.item(), po_.item()
import numpy as np
import torch
from torch.autograd import Variable
from pytorch2keras.converter import pytorch_to_keras
import torchvision
if __name__ == '__main__':
max_error = 0
for i in range(10):
model = torchvision.models.DenseNet()
for m in model.modules():
m.training = False
input_np = np.random.uniform(0, 1, (1, 3, 224, 224))
input_var = Variable(torch.FloatTensor(input_np))
output = model(input_var)
k_model = pytorch_to_keras(model,
input_var, (
3,
224,
224,
),
verbose=True)
pytorch_output = output.data.numpy()
keras_output = k_model.predict(input_np)
error = np.max(pytorch_output - keras_output)
print(error)
if max_error < error:
os.makedirs(output_dir)
sampler_batch = sampler(train_size, args.batch_size)
sampler_batch_t = sampler(train_size_t, args.batch_size)
dataset_s = roibatchLoader(roidb, ratio_list, ratio_index, args.batch_size, \
imdb.num_classes, training=True, target=False)
dataloader_s = torch.utils.data.DataLoader(dataset_s, batch_size=args.batch_size,
sampler=sampler_batch, num_workers=args.num_workers)
dataset_t = roibatchLoader(roidb_t, ratio_list_t, ratio_index_t, args.batch_size, \
imdb.num_classes, training=True, target=True)
dataloader_t = torch.utils.data.DataLoader(dataset_t, batch_size=args.batch_size,
sampler=sampler_batch_t, num_workers=args.num_workers)
# initilize the tensor holder here.
im_data = torch.FloatTensor(1)
s = torch.FloatTensor(1)
t = torch.FloatTensor(1)
im_info = torch.FloatTensor(1)
num_boxes = torch.LongTensor(1)
gt_boxes = torch.FloatTensor(1)
aux_label = torch.FloatTensor(1)
# ship to cuda
if args.cuda:
im_data = im_data.cuda()
s = s.cuda()
t = t.cuda()
im_info = im_info.cuda()
num_boxes = num_boxes.cuda()
gt_boxes = gt_boxes.cuda()
aux_label = aux_label.cuda()
import torch
import numpy as np
np_data = np.arange(6).reshape((2, 3))
tt = torch.from_numpy(np_data)
print(np_data)
print(tt)
print(tt.numpy())
#=======================
data = [-1, -2, 1, 2]
tt1 = torch.FloatTensor(data) # 32bit float
print('\nnumpy: ', np.mean(data), '\ntorch: ', torch.mean(tt1))
#=======================
import torch
import numpy as np
data2 = [[1, 2], [3, 4]]
tt2 = torch.FloatTensor(data2) # 32-bit floating point
# multiply
print('\nnumpy', np.matmul(data2, data2), '\ntorch', torch.mm(tt2, tt2))
def transition(self, z, temperature, step):
#print ('z', np.isnan(z.data.cpu().numpy()).any())
# print z.requires_grad
h1 = self.act(self.bn7_list[step](self.fc_trans_1(z)))
#print h1
h2 = self.act(self.bn8_list[step](self.fc_trans_1_1(h1)))
#print h2
h3 = self.act(self.bn9_list[step](self.fc_trans_1_2(h2)))
h4 = self.act(self.bn9_1_list[step](self.fc_trans_1_3(h3)))
h5 = self.act(self.bn9_2_list[step](self.fc_trans_1_4(h4)))
#print h3
h5 = torch.clamp(h3, min=0, max=5)
#print h3
mu = self.bn5_list[step](
self.fc_z_mu(h3)) #### why not non-linearity applied here
#print mu
sigma = self.bn6_list[step](self.fc_z_sigma(h3))
#print sigma
#print ('mu', np.isnan(mu.data.cpu().numpy()).any())
#print ('sigma', np.isnan(sigma.data.cpu().numpy()).any())
eps = Variable(mu.data.new(mu.size()).normal_())
#print ('eps', np.isnan(eps.data.cpu().numpy()).any())
#print eps
#z_new = mu + T.sqrt(args.sigma * temperature) * T.exp(0.5 * sigma) * eps
#z_new = (z_new - T.mean(z_new, axis=0, keepdims=True)) / (0.001 + T.std(z_new, axis=0, keepdims=True))
if args.cuda:
sigma_ = Variable(
torch.sqrt(
torch.FloatTensor(1).fill_(args.sigma *
temperature)).cuda())
#print ('sigma_', np.isnan(sigma_.data.cpu().numpy()).any())
else:
sigma_ = Variable(
torch.sqrt(
torch.FloatTensor(1).fill_(args.sigma * temperature)))
z_new = eps.mul(sigma.mul(0.5).exp_()).mul(sigma_).add_(mu)
#print ('z_new', np.isnan(z_new.data.cpu().numpy()).any())
z_new = (z_new - z_new.mean(0)) / (0.001 + z_new.std(0))
#print ('z_new_mean', np.isnan(z_new.mean(0).data.cpu().numpy()).any())
#print ('z_new_std', np.isnan(z_new.std(0).data.cpu().numpy()).any())
#print ('z_new', np.isnan(z_new.data.cpu().numpy()).any())
if args.cuda:
sigma_ = Variable(
torch.log(
torch.FloatTensor(1).fill_(
args.sigma * temperature)).cuda()) + sigma
#print ('sigma2', np.isnan(sigma_.data.cpu().numpy()).any())
else:
sigma_ = Variable(
torch.log(
torch.FloatTensor(1).fill_(
args.sigma * temperature))) + sigma
log_p_reverse = log_normal2(z, mu, sigma_, eps=1e-6).mean()
#print ('z', np.isnan(z.data.cpu().numpy()).any())
#print ('log_p_reverse', log_p_reverse)
z_new = torch.clamp(z_new, min=-4, max=4)
#print z_new
return z_new, log_p_reverse, mu, sigma
def update(self,
batch_size,
deterministic,
eval_noise_scale,
reward_scale=10.,
gamma=0.9,
soft_tau=1e-2):
hidden_in, hidden_out, state, action, last_action, reward, next_state, done = self.replay_buffer.sample(
batch_size)
# print('sample:', state, action, reward, done)
state = torch.FloatTensor(state).to(device)
next_state = torch.FloatTensor(next_state).to(device)
action = torch.FloatTensor(action).to(device)
last_action = torch.FloatTensor(last_action).to(device)
reward = torch.FloatTensor(reward).unsqueeze(-1).to(device)
done = torch.FloatTensor(np.float32(done)).unsqueeze(-1).to(device)
predicted_q_value1, _ = self.q_net1(state, action, last_action,
hidden_in)
predicted_q_value2, _ = self.q_net2(state, action, last_action,
hidden_in)
new_action, _ = self.policy_net.evaluate(
state, last_action, hidden_in,
noise_scale=0.0) # no noise, deterministic policy gradients
new_next_action, _ = self.target_policy_net.evaluate(
next_state, action, hidden_out,
noise_scale=eval_noise_scale) # clipped normal noise
# reward = reward_scale * (reward - reward.mean(dim=0)) / (reward.std(dim=0) + 1e-6) # normalize with batch mean and std; plus a small number to prevent numerical problem
# Training Q Function
predicted_target_q1, _ = self.target_q_net1(next_state,
new_next_action, action,
hidden_out)
predicted_target_q2, _ = self.target_q_net2(next_state,
new_next_action, action,
hidden_out)
target_q_min = torch.min(predicted_target_q1, predicted_target_q2)
target_q_value = reward + (
1 - done) * gamma * target_q_min # if done==1, only reward
q_value_loss1 = ((predicted_q_value1 - target_q_value.detach())**2
).mean() # detach: no gradients for the variable
q_value_loss2 = ((predicted_q_value2 -
target_q_value.detach())**2).mean()
self.q_optimizer1.zero_grad()
q_value_loss1.backward()
self.q_optimizer1.step()
self.q_optimizer2.zero_grad()
q_value_loss2.backward()
self.q_optimizer2.step()
if self.update_cnt % self.policy_target_update_interval == 0:
# Training Policy Function
''' implementation 1 '''
# predicted_new_q_value = torch.min(self.q_net1(state, new_action),self.q_net2(state, new_action))
''' implementation 2 '''
predicted_new_q_value, _ = self.q_net1(state, new_action,
last_action, hidden_in)
policy_loss = -predicted_new_q_value.mean()
self.policy_optimizer.zero_grad()
policy_loss.backward()
self.policy_optimizer.step()
# Soft update the target nets
self.target_q_net1 = self.target_soft_update(
self.q_net1, self.target_q_net1, soft_tau)
self.target_q_net2 = self.target_soft_update(
self.q_net2, self.target_q_net2, soft_tau)
self.target_policy_net = self.target_soft_update(
self.policy_net, self.target_policy_net, soft_tau)
self.update_cnt += 1
return predicted_q_value1.mean() # for debug
else:
output = self.main(input)
return output.view(-1, 1).squeeze(1)
netD = _netD(ngpu).to(device)
netD.apply(weights_init)
if opt.netD != '':
netD.load_state_dict(torch.load(opt.netD))
print(netD)
criterion = nn.BCELoss()
# input = torch.FloatTensor(opt.batchSize, 3, opt.imageSize, opt.imageSize)
noise = torch.FloatTensor(opt.batchSize, nz, 1, 1)
fixed_noise = torch.FloatTensor(opt.batchSize, nz, 1, 1).normal_(0, 1)
label = torch.FloatTensor(opt.batchSize)
real_label = 1
fake_label = 0
# if opt.cuda:
# netD.cuda()
# netG.cuda()
# criterion.cuda()
# input, label = input.cuda(), label.cuda()
# noise, fixed_noise = noise.cuda(), fixed_noise.cuda()
# setup optimizer
optimizerD = optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))
def forward(self, x):
x1 = self.inc(x)
x2 = self.down1(x1)
x3 = self.down2(x2)
x4 = self.down3(x3)
x5 = self.down4(x4)
x6 = self.down5(x5)
x= self.up1(x6, x5)
x = self.up2(x, x4)
#print("after up1, before up2: ",x.shape)
x = self.up3(x, x3)
x = self.up4(x, x2)
#print(x.shape)
x = self.up5(x, x1)
#print(x.shape)
x = self.outc(x)
return x
'''
if __name__ == "__main__":
"""
testing
"""
model = Unet(3, 1).cuda()
x = Variable(torch.FloatTensor(np.random.random((1, 3, 512, 512)))).cuda()
out = model(x)
loss = torch.sum(out)
loss.backward()
def __init__(self, in_features, hidden_dim=50):
super(TypeLevelAttention, self).__init__()
self.linear = torch.nn.Linear(in_features, hidden_dim)
self.a = Parameter(torch.FloatTensor(hidden_dim, 1))
self.tanh = nn.Tanh()
self.reset_parameters()
D_pre_losses = []
num_samples_pre = 1000
num_bins_pre = 100
for epoch in range(num_epochs_pre):
# Generate samples
d = data.sample(num_samples_pre)
histc, edges = np.histogram(d, num_bins_pre, density=True)
# Estimate pdf
max_histc = np.max(histc)
min_histc = np.min(histc)
y_ = (histc - min_histc) / (max_histc - min_histc)
x_ = edges[1:]
x_ = Variable(torch.FloatTensor(np.reshape(x_, [num_bins_pre, input_dim])))
y_ = Variable(torch.FloatTensor(np.reshape(y_, [num_bins_pre, output_dim])))
# Train model
optimizer.zero_grad()
D_pre_decision = D(x_)
D_pre_loss = criterion(D_pre_decision, y_)
D_pre_loss.backward()
optimizer.step()
# Save loss values for plot
D_pre_losses.append(D_pre_loss[0].data.numpy())
if epoch % 100 == 0:
print(epoch, D_pre_loss.data.numpy())
def convert2cpu(gpu_matrix):
return torch.FloatTensor(gpu_matrix.size()).copy_(gpu_matrix)
def main():
inp_size = 34
hidden_size = 30
numClasses = 2
batch_size = 5
epochs = 2000
lr = 0.01
seed = 1
log_interval = 10
use_cuda = True
rho = 0.5
thresh = 0.1
param = {
'inp_size': inp_size,
'hidden_size': hidden_size,
'batch_size': batch_size,
'numClasses': numClasses,
'epochs': epochs,
'lr': lr,
'rho': rho,
'thresh': thresh
}
sparsity_param = torch.FloatTensor([rho for _ in range(hidden_size)
]).unsqueeze(0)
# torch.manual_seed(seed)
########## Choosing GPU or CPU ######################
device = torch.device("cuda" if use_cuda else "cpu")
############# Data Loader ##############
kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
####Training
###########################################################
filename = '/data/ionosphere.txt'
dataset, label = getData(filename)
x_train, y_train, x_test, y_test = split_data(dataset, label)
print('==============Training================')
print('number of class 1: ', y_train.count(0))
print('number of class 2: ', y_train.count(1))
print('==============Testing================')
print('number of class 1: ', y_test.count(0))
print('number of class 2: ', y_test.count(1))
train_loader, test_loader = convert2Tensor(x_train, y_train, x_test,
y_test, batch_size, kwargs)
#############################################################
############# Instantiate Model #############################
model = AutoEncoder(inp_size, hidden_size).to(device)
print(model)
classifier = Classifier(hidden_size, numClasses).to(device)
print(classifier)
######################### Define optimization #####################
optimizer = optim.SGD(model.parameters(), lr=lr)
optimizer_classifier = optim.SGD(classifier.parameters(), lr=lr)
###################################################################
### Epoch training
loss_train_arr = []
loss_test_arr = []
sensors_train = []
sensors_test = []
test_acc = []
train_acc = []
for epoch in range(1, epochs + 1):
loss_train, no_sensors_train, acc_train = train(
model, classifier, device, train_loader, optimizer,
optimizer_classifier, epoch, log_interval, sparsity_param, thresh,
inp_size, batch_size)
loss_test, no_sensors_test, acc = test(model, classifier, device,
test_loader, thresh, inp_size)
## Store Metrics
loss_train_arr.append(loss_train)
loss_test_arr.append(loss_test)
sensors_train.append(no_sensors_train)
sensors_test.append(no_sensors_test)
test_acc.append(acc)
train_acc.append(acc_train)
return loss_train_arr, loss_test_arr, sensors_train, sensors_test, train_acc, test_acc
