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