def __init__(self, image_size, n_chan, n_hidden, ngpu): super(Discriminator, self).__init__() assert image_size % 16 == 0, "Image size should be a multiple of 16" self.image_size = image_size self.n_chan = n_chan self.n_hidden = n_hidden self.ngpu = ngpu self.discriminator = nn.Sequential() discriminator_layers = [] discriminator_layers = make_conv_layer(discriminator_layers, n_chan, n_hidden, back_conv=False, batch_norm=False, activation='LeakyReLU') cur_size = image_size // 2 while cur_size > 4: discriminator_layers = make_conv_layer(discriminator_layers, n_hidden, n_hidden * 2, back_conv=False, activation='LeakyReLU') cur_size = cur_size // 2 n_hidden = n_hidden * 2 trial = V(t.randn(1, n_chan, image_size, image_size)) for layer in discriminator_layers: trial = layer(trial) self.fc_in = trial.size(1) * trial.size(2) * trial.size(3) self.fc_out = 512 for i, layer in enumerate(discriminator_layers): self.discriminator.add_module('component_{0}'.format(i + 1), layer) self.discriminator_lth = nn.Sequential() self.discriminator_lth.add_module('component_1', nn.Linear(self.fc_in, self.fc_out)) self.discriminator_lth.add_module('component_2', nn.BatchNorm1d(self.fc_out)) self.discriminator_lth.add_module('component_3', nn.LeakyReLU(0.2, inplace=True)) self.discriminator_last = nn.Sequential() self.discriminator_last.add_module('component_1', nn.Linear(self.fc_out, 1)) self.discriminator_last.add_module('component_2', nn.Sigmoid())
def Parameterizer(input, ngpu): pass_ = input means = pass_[0] logcovs = pass_[1] std = logcovs.mul(0.5).exp_() if ngpu > 0: epsilon = t.cuda.FloatTensor(std.size()).normal_() else: epsilon = t.FloatTensor(std.size()).normal_() epsilon = V(epsilon) epsilon = epsilon.mul(std).add_(means) return epsilon.view(epsilon.size(0), -1, 1, 1)
def predict(frame): """ predict scnene in the frame :param frame: input image as numpy array :return: class name of scene of the frame """ model, image_transformer, classes = SceneClassifier.load_files() # convert to PIL image frame = Image.fromarray(frame.astype('uint8'), 'RGB') frame = V(image_transformer(frame).unsqueeze(0)) forward_pass = model.forward(frame) eval = F.softmax(forward_pass, 1).data.squeeze() probability, idx = eval.sort(0, True) return classes[idx[0]].replace('_', ' ')
def predict_image_from_bytes(bytes): img = Image.open(BytesIO(bytes)) input_img = V(centre_crop(img).unsqueeze(0)) logits = model.forward(input_img) h_x = F.softmax(logits, 1).data.squeeze() probs, idx = h_x.sort(0, True) out = OrderedDict() for i in range(0, 5): label = classes[idx[i]] lvl2_label = list(scene_hierarchy_lvl2.loc[label][scene_hierarchy_lvl2.loc[label] == 1].index) out_label = f'{label}, {lvl2_label}' out[out_label] = np.round(probs[i].detach().item(), 3) # print(out) return JSONResponse(out)
def forward(self, x, y, r): z = np.random.uniform(-1.0, 1.0, size=(1, self.z_dim)).astype(np.float32) z_scaled = V( torch.from_numpy( np.matmul(np.ones((self.x_dim * self.y_dim, 1)), z)).float()) U = self.linear1(z_scaled) + self.linear2(x) + self.linear3( y) + self.linear4(r) result = self.lin_seq(U) return result
def batch2(self, path): #print(2) img = cv2.imread(path) img90 = np.array(np.rot90(img)) img1 = np.concatenate([img[None],img90[None]]) img2 = np.array(img1)[:,::-1] img3 = np.concatenate([img1,img2]) img4 = np.array(img3)[:,:,::-1] img5 = img3.transpose(0,3,1,2) img5 = np.array(img5, np.float32)/255.0 img5 = V(torch.Tensor(img5).cuda()) img6 = img4.transpose(0,3,1,2) img6 = np.array(img6, np.float32)/255.0 img6 = V(torch.Tensor(img6).cuda()) maska = self.net.forward(img5).squeeze().cpu().data.numpy()#.squeeze(1) maskb = self.net.forward(img6).squeeze().cpu().data.numpy() mask1 = maska + maskb[:,:,::-1] mask2 = mask1[:2] + mask1[2:,::-1] mask3 = mask2[0] + np.rot90(mask2[1])[::-1,::-1] return mask3
def function5(): input = V(t.randn(2, 3)) linear = nn.Linear(3, 4) h = linear(input) # 4channel 初始化标准误差为4,均值为0 bn = nn.BatchNorm1d(4) bn.weight.data = t.ones(4) * 4 bn.bias.data = t.zeros(4) bn_out = bn(h) dropout = nn.Dropout(0.5) o = dropout(bn_out) print(o) """
def LayerNormGRUCellTest(): torch.manual_seed(1234) ninp = 50 nhid = 50 nsep = 100 nbatch = 2 x = V(torch.rand(nsep, nbatch, ninp), requires_grad=True) hidden = V(torch.rand(1, nbatch, nhid), requires_grad=True) ref = nn.GRUCell(ninp, nhid, bias=True) # under_test = LayerNormGRUCell(5, 5, bias=True, layer_norm=False) under_test = LayerNormGRUCellModule(ninp, nhid, bias=True, layer_norm=False) # Make ref and cur same parameters: val = torch.rand(1)[0] for c in under_test.parameters(): c.data.fill_(val) # val = torch.rand(1)[0] for r in ref.parameters(): r.data.fill_(val) objective = V(torch.zeros(nbatch, nhid)) i, j = x.clone(), hidden.clone().squeeze(0) g, h = x.clone(), hidden.clone().squeeze(0) for index in range(nsep): j = ref(i[index], j) h = under_test(g[index], h) err = torch.sum((j - h) ** 2) print(err.item()) assert (err.item() < 1e-1) # assert (torch.equal(j.data, h.data)) ref_loss = torch.sum((i - objective) ** 2) cus_loss = torch.sum((g - objective) ** 2) ref_loss.backward() cus_loss.backward() # print('LayerNormGRUCell Test Passed') print('LayerNormGRUCellModule Test Passed')
def fit(self, x, y=None): # transform to torch tensor if not isinstance(x, V): x = V(x, requires_grad=False) _, col = x.size() if not isinstance(y, V): y = V(y, requires_grad=False) # optimization optim = self.optim(self.model.parameters(), lr=self.lr) # if use CUDA acc if self.ctx == 'GPU' and tc.cuda.is_available(): self.model.cuda() x = x.cuda() y = y.cuda() # train loss = None for t in range(self.epochs): pre_y = self.model(x) loss = self.loss_func(pre_y, y) optim.zero_grad() loss.backward() optim.step() if self.verbose and t % self.verbose == 0: print('at step: {}, Loss={:.4f}'.format(t, loss.data[0])) if self.checkstep > 0 and t % self.checkstep == 0: self.checkpoint(epochs=t, loss=loss.data[0]) self.trained = True if self.checkstep > 0: self.checkpoint.save(self.save_snap, self.save_model) print('Loss={:.4f}'.format(loss.data[0])) return self
def interactive(model, indx2candid, cands_tensor, word_idx, sentence_size, memory_size, cuda=False): context = [] u = None r = None nid = 1 while True: line = input('--> ').strip().lower() if line == 'exit': break if line == 'restart': context = [] nid = 1 print("clear memory") continue u = tokenize(line) data = [(context, u, -1)] s, q, a, entity_dict = vectorize_data(data, word_idx, sentence_size, memory_size) memory = V(torch.from_numpy(np.stack(s))) utter = V(torch.from_numpy(np.stack(q))) if cuda: memory = transfer_to_gpu(memory) utter = transfer_to_gpu(utter) context_, cand_ = model(utter, memory, cands_tensor) preds = model.predict(context_, cand_) r = indx2candid[preds.data[0]] print(r) r = tokenize(r) u.append('$u') u.append('#' + str(nid)) r.append('$r') r.append('#' + str(nid)) context.append(u) context.append(r) nid += 1
def train_epoch(model, training_data, optimizer): ''' Epoch operation in training phase''' AP.reset() mAP.reset() Loss_meter.reset() model.train() for batch_idx, (data, target) in enumerate(training_data): data = data.cuda() target = target.cuda() data = V(data) target = V(target) #forward optimizer.zero_grad() pred = model(data) pred = F.softmax(pred, 1) #backward loss = F.cross_entropy(pred, target) Loss_meter.add(loss.detach().item()) #转化为了numpy类型 loss.backward() #optimize optimizer.step() #calculate acc one_hot = torch.zeros_like(pred).cuda().scatter( 1, target.view(-1, 1), 1) AP.add(pred.detach(), one_hot) mAP.add(pred.detach(), one_hot) return Loss_meter.value()[0], mAP.value()
def train(**kwargs:dict) -> None: for k, v in kwargs.items(): setattr(opt, k, v) #vis = Visdom(env=opt.env) #data get data, word2ix, ix2word = get_data(opt) data = t.from_numpy(data) dataloader = t.utils.data.DataLoader( data, batch_size=opt.batch_size, shuffle = True, ) model = PoetryModel(len(word2ix), 2, 2) optimizer = t.optim.Adam(model.parameters(), lr=opt.lr) criterion = nn.CrossEntropyLoss() if opt.model_path: model.load_state_dict(t.load(opt.model_path)) if opt.user_gpu: model.cuda() criterion.cuda() for epoch in range(opt.epoch): for ii, data_ in tqdm.tqdm(enumerate(dataloader)): data_ = data.long().transpose(1, 0).contiguous() if opt.user_gpu : data_ = data_.cuda() optimizer.zero_grad() input_, target = V(data_[:-1, :]), V(data[1:, :]) ouput, _ = model(input_) loss = criterion(ouput, target.view(-1)) loss.backward() optimizer.step()
def eval_epoch(model, baseline, validation_data): model.eval() AP.reset() mAP.reset() top3.reset() Loss_meter.reset() for batch_idx, (boxes, data, target) in enumerate(validation_data): data = V(data.cuda()) target = V(target.cuda()) allrois = [] for ii in range(boxes.shape[0]): box = boxes[ii] l, f = box.shape idx = ii * torch.ones(l, 1) rois = torch.cat((idx, box), 1) assert rois.shape[1] == 5 allrois.append(rois) allrois = torch.cat(allrois, 0).cuda() #print(allrois.shape) result, context = model(data, allrois) #result2 = baseline(data) #result = result + result2 #result = model(data) visualize_func(result) loss = F.cross_entropy(result, target) # record pred = result Loss_meter.add(loss.detach().item()) one_hot = torch.zeros_like(pred).cuda().scatter( 1, target.view(-1, 1), 1) AP.add(pred.detach(), one_hot) mAP.add(pred.detach(), one_hot) top3.add(pred.detach(), target) print("top3 : {}".format(top3.value())) return Loss_meter.value()[0], mAP.value()
def experience_replay(self): if self.buffer.tree.filled_size() < batch_size: return out, we, idxes = self.buffer.select(batch_size) s1 = [arr[0] for arr in out] a1 = [arr[1] for arr in out] r1 = [arr[2] for arr in out] s2 = [arr[3] for arr in out] s1 = V(torch.Tensor(s1)) a1 = V(torch.Tensor(a1)) r1 = V(torch.Tensor(r1)) s2 = V(torch.Tensor(s2)) #update critic a2 = self.target_actor.forward(s2).detach() next_q = torch.squeeze(self.target_critic.forward(s2, a2).detach()) y_expected = torch.squeeze(r1) + gamma * next_q y_predicted = torch.squeeze(self.critic.forward(s1, a1)) # print(y_expected.shape) loss_c = F.smooth_l1_loss(y_predicted, y_expected) self.critic_optimizer.zero_grad() loss_c.backward() self.critic_optimizer.step() #update actor a = self.actor.forward(s1) loss_a = -1 * torch.sum(self.critic.forward(s1, a)) self.actor_optimizer.zero_grad() loss_a.backward() self.actor_optimizer.step() soft_update(self.target_actor, self.actor, tau) soft_update(self.target_critic, self.critic, tau) #update priority priority = self.calculate_priority(out) priority = [arr.item() for arr in priority] self.buffer.priority_update(idxes, priority)
def forward(self, img: Image) -> List[str]: attributes = [ 'clouds', 'biking', 'swimming', 'driving', 'sunny', 'leaves', 'snow', 'trees', 'climbing', 'hiking', 'rugged', 'ocean', 'scene' ] # load the model tokens = [] # get the softmax weight params = list(self.model.parameters()) weight_softmax = params[-2].data.numpy() weight_softmax[weight_softmax < 0] = 0 input_img = V(self.tf(img).unsqueeze(0)) # forward pass logit = self.model.forward(input_img) h_x = F.softmax(logit, 1).data.squeeze() probs, idx = h_x.sort(0, True) probs = probs.numpy() idx = idx.numpy() # output the IO prediction io_image = np.mean( self.labels_IO[idx[:10]]) # vote for the indoor or outdoor if io_image < 0.5: tokens.append('indoor') else: tokens.append('outdoor') # output the prediction of scene category for i in range(0, 5): if probs[i] > 0.25: tokens.append(self.classes[idx[i]]) # output the scene attributes responses_attribute = self.W_attribute.dot(self.features_blobs[1]) self.features_blobs = [] idx_a = np.argsort(responses_attribute) for i in range(-1, -10, -1): t = self.labels_attribute[idx_a[i]] if t in attributes: tokens.append(self.labels_attribute[idx_a[i]]) result = [] for token in tokens: for t in re.split('[, /_-]+', token): result.append(t) return list(set(result))
def scene_detection(img_url): # th architecture to use arch = "resnet18" # load the pre-trained weights model_file = "%s_places365.pth.tar" % arch if not os.access(model_file, os.W_OK): weight_url = "http://places2.csail.mit.edu/models_places365/" + model_file os.system("wget " + weight_url) model = models.__dict__[arch](num_classes=365) checkpoint = torch.load(model_file, map_location=lambda storage, loc: storage) state_dict = { str.replace(k, "module.", ""): v for k, v in checkpoint["state_dict"].items() } model.load_state_dict(state_dict) model.eval() # load the image transformer centre_crop = trn.Compose([ trn.Resize((256, 256)), trn.CenterCrop(224), trn.ToTensor(), trn.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) # load the class label file_name = "categories_places365.txt" if not os.access(file_name, os.W_OK): synset_url = "https://raw.githubusercontent.com/csailvision/places365/master/categories_places365.txt" os.system("wget " + synset_url) classes = list() with open(file_name) as class_file: for line in class_file: classes.append(line.strip().split(" ")[0][3:]) classes = tuple(classes) img = Image.open(urlopen(img_url)) input_img = V(centre_crop(img).unsqueeze(0)) # forward pass logit = model.forward(input_img) h_x = F.softmax(logit, 1).data.squeeze() probs, idx = h_x.sort(0, True) return classes[idx[0]]
def test_one_img_from_path_4(self, path): img = cv2.imread(path) #.transpose(2,0,1)[None] img90 = np.array(np.rot90(img)) img1 = np.concatenate([img[None], img90[None]]) img2 = np.array(img1)[:, ::-1] img3 = np.array(img1)[:, :, ::-1] img4 = np.array(img2)[:, :, ::-1] img1 = img1.transpose(0, 3, 1, 2) img2 = img2.transpose(0, 3, 1, 2) img3 = img3.transpose(0, 3, 1, 2) img4 = img4.transpose(0, 3, 1, 2) img1 = V( torch.Tensor(np.array(img1, np.float32) / 255.0 * 3.2 - 1.6).cuda()) img2 = V( torch.Tensor(np.array(img2, np.float32) / 255.0 * 3.2 - 1.6).cuda()) img3 = V( torch.Tensor(np.array(img3, np.float32) / 255.0 * 3.2 - 1.6).cuda()) img4 = V( torch.Tensor(np.array(img4, np.float32) / 255.0 * 3.2 - 1.6).cuda()) maska = self.net.forward(img1).squeeze().cpu().data.numpy() maskb = self.net.forward(img2).squeeze().cpu().data.numpy() maskc = self.net.forward(img3).squeeze().cpu().data.numpy() maskd = self.net.forward(img4).squeeze().cpu().data.numpy() mask1 = maska + maskb[:, ::-1] + maskc[:, :, ::-1] + maskd[:, ::-1, :: -1] mask2 = mask1[0] + np.rot90(mask1[1])[::-1, ::-1] return mask2
def forward(self, input): if self.binarize: output = V(torch.FloatTensor(input.size(1))) for j in range(input.size(1)): tokens = V( torch.cuda.LongTensor(list(set( input[:, j].tolist()))).cuda(args.gpu)) hidden = torch.cat( [self.lut(tokens).sum(0), self.static_lut(tokens).sum(0)], -1) output[j] = self.proj(hidden) return output if self.average: hidden = torch.cat( [self.lut(input).sum(0), self.static_lut(input).mean(0)], -1) else: hidden = torch.cat( [self.lut(input).sum(0), self.static_lut(input).sum(0)], -1) if self.dropout: hidden = self.dropout(hidden) return self.proj(hidden).squeeze(-1)
def predict(models, dataset, arg, cuda=False): prediction_file = open('save/predictions.txt', 'w') batcher = dataset.get_batcher(shuffle=False, augment=False) for b, (x, _) in enumerate(batcher, 1): x = V(th.from_numpy(x).float()).cuda() # Ensemble average logit = None for model, _ in models: model.eval() logit = model(x) if logit is None else logit + model(x) logit = th.div(logit, len(models)) prediction = logit.cpu().data[0][0] prediction_file.write('%s\n' % prediction) if arg.verbose and b % 100 == 0: print('[predict] [b]:%s - prediction: %s' % (b, prediction))
def predict(self, images): self.model.eval() # Wrap the tensor as a variable images = V(images) if self.HAS_CUDA: images = images.cuda() pred = self.model(images) if self.HAS_CUDA: pred = pred.cpu() pred = F.softmax(pred, dim=1) # Note = could apply a softmax here to give probabilities but not strictly necessary to identify # most probable classes return pred.data
def generate(model, words, temperature, corpus): model.train(False) number_tokens = len(corpus.dictionary) hidden = model.init_hidden(1) input = V(torch.rand(1,1).mul(number_tokens).type(LongType), volatile=True) for i in range(words): output , hidden = model(input, hidden) words_weights = output.squeeze().data.div(temperature).exp().cpu() word_idx = torch.multinomial(words_weights, 1)[0] input.data.fill_(word_idx) word = corpus.dictionary.idx2word[word_idx] word = word.replace('<eos>','\n') # if ':' in word: # word = '\n\n' + word print("%s "%(word), end='')
def function2(): input = V(t.arange(0, 12).view(3, 4)) model = nn.Dropout() output = model(input) #在训练阶段,dropout会生效,一半左右会变成0,默认training=true print(output) """ tensor([[ 0., 0., 0., 6.], [ 8., 0., 0., 0.], [ 0., 18., 0., 0.]]) """ model.training = False output2 = model(input) print(output2) """
def forward(self, noise_dim, raw_attack, attack_category, POS_NONFUNCTIONAL_FEATURES): ''' Generate Aversarial Attack Traffic that kept functional features. ''' if attack_category != 'DOS' and attack_category != 'U2R_AND_R2L': raise ValueError("Preprocess Data Fail: Invalid Attack Category") batch_size = len(raw_attack) pos_nonfunctional_feature = POS_NONFUNCTIONAL_FEATURES[attack_category] noise = V(th.Tensor(np.random.uniform(0,1,(batch_size, noise_dim)))).to(device) generator_out = self.layer(noise) # Keep the functional features adversarial_attack = raw_attack.clone().type(torch.FloatTensor).to(device) #.detach() to remove operation history; .clone() to make a copy for idx in range(batch_size): adversarial_attack[idx][pos_nonfunctional_feature] = generator_out[idx] return th.clamp(adversarial_attack,0.,1.).to(device)
def random(model, gpu=False, num_samples=20): if not os.path.isdir('results'): os.mkdir('results') if not os.path.isdir('results/random'): os.mkdir('results/random') for i, idol in enumerate(idols): hot = np.zeros((num_samples, len(idols))) hot[:, i] = 1 c = V(FT(hot), requires_grad=False) c = c.cuda() if gpu else c x_ = model.predict(c) x_ = x_.cpu() if gpu else x_ for j in range(num_samples): imsave('results/random/{}_{}.jpg'.format(idol, j + 1), denormalize(x_.data[j].numpy()))
def interpolate(model, gpu=False, num_samples=20, num_lim=10): if not os.path.isdir('results'): os.mkdir('results') if not os.path.isdir('results/interpolate'): os.mkdir('results/interpolate') dataset = SchoolIdolFestival('all') idx = lambda idol: idols.index(idol) pairs = [ (idx('Yoshiko'), idx('Riko')), (idx('Maki'), idx('Nico')), (idx('Ruby'), idx('Dia')), (idx('Hanayo'), idx('Rin')), (idx('Maki'), idx('Yoshiko')), ] for source, target in pairs: for i in range(num_samples): hot = np.zeros((num_lim + 1, len(idols))) for lim in range(num_lim + 1): hot[lim, source] = 1 - 0.1 * lim hot[lim, target] = 0.1 * lim c = V(FT(hot), requires_grad=False) c = c.cuda() if gpu else c mu = V(torch.zeros(1, 1024), requires_grad=False) ls = V(torch.zeros(1, 1024), requires_grad=False) mu = mu.cuda() if gpu else mu ls = ls.cuda() if gpu else ls z = model.sample(mu, ls).repeat(num_lim + 1, 1) x_ = model.decoder(z, c) x_ = x_.cpu() if gpu else x_ canvas = np.zeros((64, 64 * (num_lim + 1), 3)) for lim in range(num_lim + 1): canvas[:, lim * 64:(lim + 1) * 64, :] = denormalize( x_.data[lim].numpy()) imsave( 'results/interpolate/{}_{}_{}.jpg'.format( idols[source], idols[target], i), canvas)
def makeContoursFromMNumpy(M, radius, delta_un=None): n = M.shape[0] cont = V(torch.zeros(n, 6).float()) xylabel = V(torch.from_numpy(M[:, 0:3]).float()) if type(radius) is float: r = radius * V(torch.ones(n, 1).float()) if type(radius) is torch.autograd.Variable: idxs = np.unique(M[:, 2]) num_conts = len(idxs) assert (radius.size(0) == num_conts) or (radius.size(0) == n) #you can provide radius per contour or per point if radius.size(0) == n: r = radius else: r = V(torch.ones(n, 1).float()) for i in idxs: cur_idxs = xylabel[:, 2] == int(i) r[cur_idxs] = cur_idxs * radius[i] if delta_un is not None: assert delta_un.size(0) == n and delta_un.size(1) == 2 un = delta_un else: un = V(torch.zeros(n, 2).float()) return torch.cat([xylabel, un, r], dim=1)
def calculate_priority(self, data): # s1 = V(torch.unsqueeze(torch.Tensor(data[0]),0)) # a1 = V(torch.unsqueeze(torch.Tensor(data[1]),0)) # r1 = V(torch.unsqueeze(torch.Tensor([data[2]]),0)) # s2 = V(torch.unsqueeze(torch.Tensor(data[3]),0)) # #data = V(torch.Tensor(data)) # s1 = data[:,0] # a1 = data[:,1] # r1 = data[:,2] # s2 = data[:,3] s1 = [arr[0] for arr in data] a1 = [arr[1] for arr in data] r1 = [arr[2] for arr in data] s2 = [arr[3] for arr in data] s1 = V(torch.Tensor(s1)) a1 = V(torch.Tensor(a1)) r1 = V(torch.Tensor(r1)) s2 = V(torch.Tensor(s2)) a2 = self.target_actor.forward(s2).detach() next_q = torch.squeeze(self.target_critic.forward(s2, a2).detach()) y_expected = torch.squeeze(r1) + gamma * next_q y_predicted = torch.squeeze(self.critic.forward(s1, a1).detach()) # a2 = self.target_actor.forward(s2).detach() # next_q = torch.squeeze(self.target_critic.forward(s2,a2).detach()) # y_expected = r1 + gamma * next_q # y_predicted = torch.squeeze(self.critic.forward(s1,a1).detach()) #print(y_predicted) TD_error = y_expected - y_predicted # TD_error = torch.squeeze(TD_error) TD_error = abs(TD_error) return TD_error
def get_action(self, state, noise=True): state = V(torch.Tensor(state)) self.actor.eval() self.critic.eval() self.actor.training = False action = self.actor.forward(state).detach() if noise: new_action = action.data.numpy() + (self.noise.sample() * a_max) else: new_action = action.data.numpy() self.actor.training = True self.actor.train() self.critic.train() #print(new_action) return new_action
def set_param(self, name, param, copy=False): if '.' in name: n = name.split('.') module_name = n[0] rest = '.'.join(n[1:]) for name, mod in self.named_submodules(): if module_name == name: mod.set_param(rest, param, copy=copy) break else: if copy is True: setattr(self, name, V(param.data.clone(), requires_grad=True)) else: assert hasattr(self, name) setattr(self, name, param)
def _multi_emb(self, input, input_char, pretr_w_embedding=None, flags=None): batch_size, seq_len, word_len = input_char.data.shape if pretr_w_embedding is not None: pretr_w_embedding = self._find_embedding(input, pretr_w_embedding) if self.mode == 'train': self.fix_w_embedding = V(pretr_w_embedding, requires_grad = False).float() else: with t.no_grad(): self.fix_w_embedding = V(pretr_w_embedding).float() if self.use_gpu: self.fix_w_embedding = self.fix_w_embedding.cuda() tr_w_embedding = self.tr_w_embedding(input).float() if self.tr_w_emb_dim_flag != 0: tr_w_embedding1 = self.tr_w_embedding1(input).float() tr_w_embedding_flags = t.mul(tr_w_embedding1, flags) # print('tr_w_embedding_flags:', tr_w_embedding_flags.shape) input_char = input_char.view([batch_size, seq_len*word_len]) c_embedding = self.c_embedding(input_char) # input_char:[batch_size, seq_len*word_len] c_embedding = c_embedding.view([batch_size, seq_len, word_len, -1]) c_embedding = F.max_pool2d(c_embedding, kernel_size=(c_embedding.size()[-2], 1), stride=1) c_embedding = c_embedding.squeeze() # c_embedding:[batch_size, seq_len, char_dim] multi_embedding = t.cat([tr_w_embedding, c_embedding, flags], 2) if self.tr_w_emb_dim_flag != 0: multi_embedding = t.cat([tr_w_embedding, tr_w_embedding_flags, c_embedding, flags], 2) return multi_embedding