class Sample(object): def __init__(self, obs, dists, values=[], pos=None, is_pad=False, is_end=False): self.dists = dists self.values = Tensor(values) # direction self.obs = Tensor(obs) # observed features self.is_pad = is_pad self.is_end = is_end if pos is not None: self.pos = Tensor(pos) self.rnn_input = None self.rnn_output = None def cuda(self, device=None): for i in range(len(self.dists)): if 'loc' in self.dists[i].__dict__: self.dists[i].loc = self.dists[i].loc.cuda(device) if 'scale' in self.dists[i].__dict__: self.dists[i].scale = self.dists[i].scale.cuda(device) if 'prob' in self.dists[i].__dict__: self.dists[i].prob = self.dists[i].prob.cuda(device) self.values = self.values.cuda(device) self.obs = self.obs.cuda(device) if self.pos is not None: self.pos = self.pos.cuda(device) def cpu(self): for i in range(len(self.values)): if 'loc' in self.dists[i].__dict__: self.dists[i].loc = self.dists[i].loc.cpu() if 'scale' in self.dists[i].__dict__: self.dists[i].scale = self.dists[i].scale.cpu() if 'prob' in self.dists[i].__dict__: self.dists[i].prob = self.dists[i].prob.cpu() self.values = self.values.cpu() self.obs = self.obs.cpu() if self.pos is not None: self.pos = self.pos.cpu()
def predict(self, X): self.model.eval() X_batch = X X_0 = FloatTensor(X_batch[:, 0]) X_1 = FloatTensor(X_batch[:, 1]) if self.cuda: X_0, X_1 = X_0.cuda(), X_1.cuda() X_0, X_1 = Variable(X_0), Variable(X_1) output1, output2 = self.model(X_0, X_1) return torch.sum(torch.pow(output1 - output2, 2), 1).cpu().data.numpy()
def train_epoch(self, optimizer, training_data, epoch_id='unknown'): epoch_time = time.time() accumulated_loss = 0 average_losses = [] training_data_length = len(training_data) percent_done = 0 for index, data in enumerate(training_data): sample, target = FloatTensor([[data[0]]]), FloatTensor([data[1]]) if torch.cuda.is_available(): sample, target = sample.cuda(0), target.cuda(0) sample, target = Variable(sample), Variable(target) optimizer.zero_grad() output = self(sample) loss = self.criterion(output, target) loss.backward() optimizer.step() accumulated_loss += loss.data[0] if percent_done - 100 * index // training_data_length != 0: percent_done = 100 * index // training_data_length average_losses.append(accumulated_loss/(index+1)) print('Finished %s%% of epoch %s | average loss: %s' % (percent_done, epoch_id+1, accumulated_loss/(index+1))) print "Successively trained %s epochs (epoch timer: %s)" % (epoch_id+1, DataHandler.format_time(time.time() - epoch_time)) return average_losses
def weighted_loss(self, prediction, target): weights_npy = np.array([self.weights[int(t[0])] for t in target.data]) weights_tensor = FloatTensor(weights_npy) if self.use_gpu: weights_tensor = weights_tensor.cuda() return F.binary_cross_entropy_with_logits( prediction, target, weight=Variable(weights_tensor))
def evaluate_board(self, board, color, other_player): sample = FloatTensor([[board.get_representation(color)]]) if torch.cuda.is_available(): sample = sample.cuda(0) sample = Variable(sample) return self.model(sample)
def evaluate_each_level(self, level, mode, threshold=0): if mode == "train": evaluated_data = self.dataset if level > 0 and os.path.isdir('data/%s/output' % self.data_name): shutil.rmtree('data/%s/output' % self.data_name) elif mode == "validate": evaluated_data = self.dataset_validate elif mode == "test": evaluated_data = self.dataset_test number_of_class = self.classifier[level].number_of_class initial_tp = FloatTensor([0] * number_of_class) initial_pcp = FloatTensor([0] * number_of_class) initial_cp = FloatTensor([0] * number_of_class) if torch.cuda.is_available(): initial_tp = initial_tp.cuda() initial_pcp = initial_pcp.cuda() initial_cp = initial_cp.cuda() all_tp = Variable(initial_tp) all_pcp = Variable(initial_pcp) all_cp = Variable(initial_cp) number_of_batch = 0 for datas, labels in evaluated_data.generate_batch( level, self.get_batch_size(level)): number_of_batch = number_of_batch + 1 datas_in = self.input_classifier(datas, level, number_of_batch, mode) if torch.cuda.is_available(): datas_in = datas_in.cuda() labels = labels.cuda() datas_in = Variable(datas_in, volatile=True) labels_in = Variable(labels, volatile=True) tp, pcp, cp = self.classifier[level].evaluate_tp_pcp( datas_in, labels_in, threshold) all_tp = all_tp + tp all_pcp = all_pcp + pcp all_cp = all_cp + cp f1_macro, f1_micro = f1_from_tp_pcp(all_tp, all_pcp, all_cp, number_of_class) f1_macro = f1_macro.data.cpu().numpy()[0] f1_micro = f1_micro.data.cpu().numpy()[0] return f1_macro, f1_micro
def next_target(self, mode, cuda, device_id): if mode == TRAIN_MODE: target_id = self.train.next_items(1)[0] elif mode == DEV_MODE: target_id = self.dev.next_items(1)[0] elif mode == TEST_MODE: target_id = self.test.next_items(1)[0] _1d_feature, _2d_feature = get_features(target_id) contact_map = read_contact_map(target_id) # Convert to FloatTensors _1d_feature = FloatTensor(np.expand_dims(_1d_feature, 0)) _2d_feature = FloatTensor(np.expand_dims(_2d_feature, 0)) contact_map = LongTensor(np.expand_dims(contact_map, 0)) if cuda: _1d_feature = _1d_feature.cuda(device_id) _2d_feature = _2d_feature.cuda(device_id) contact_map = contact_map.cuda(device_id) return target_id, _1d_feature, _2d_feature, contact_map
def __predict_move__(self, move): board = deepcopy(self.current_board) board.apply_move(move, self.color) sample = FloatTensor([[board.get_representation(self.color)]]) if torch.cuda.is_available(): sample = sample.cuda(0) sample = Variable(sample) return self.model(sample)
def fit_batch(self, X_batch, y_batch): if not (X_batch.shape[3] == X_batch.shape[4] == RESNET_INPUT_SIZE): raise ValueError( f'Shape {X_batch.shape} is incompatible.\n' f'Dimensions 3 and 4 should be {RESNET_INPUT_SIZE}') self.optimizer.zero_grad() self.model.train() X_0 = FloatTensor(X_batch[:, 0]) X_1 = FloatTensor(X_batch[:, 1]) labels = FloatTensor(y_batch) if self.cuda: X_0, X_1, labels = X_0.cuda(), X_1.cuda(), labels.cuda() X_0, X_1, labels = Variable(X_0), Variable(X_1), Variable(labels) output1, output2 = self.model(X_0, X_1) loss = self.criterion(output1, output2, labels) self.train_history.append({'loss': loss.data[0]}) loss.backward() self.optimizer.step() self.model.eval()
def normalize_image(image, forward=True, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)): mean = list(mean) std = list(std) im_size = image.size() mean = FloatTensor(mean).unsqueeze(1).unsqueeze(2) std = FloatTensor(std).unsqueeze(1).unsqueeze(2) if image.is_cuda: mean = mean.cuda() std = std.cuda() if isinstance(image, Variable): mean = Variable(mean, requires_grad=False) std = Variable(std, requires_grad=False) if forward: if len(im_size) == 3: result = image.sub(mean.expand(im_size)).div(std.expand(im_size)) elif len(im_size) == 4: result = image.sub(mean.unsqueeze(0).expand(im_size)).div( std.unsqueeze(0).expand(im_size)) else: raise TypeError("Couldn't read image due to an unexpected format") else: if len(im_size) == 3: result = image.mul(std.expand(im_size)).add(mean.expand(im_size)) elif len(im_size) == 4: result = image.mul(std.unsqueeze(0).expand(im_size)).add( mean.unsqueeze(0).expand(im_size)) else: raise TypeError("Couldn't read image due to an unexpected format") return result
def predict(self, X_eval: torch.FloatTensor) -> list: #check dimensions of input data X_eval = self.x_to_tensor(X_eval) if X_eval.size()[1] != self.model._input_dim: raise AttributeError( "input dataset should have the same dimensions as the expected input dimensions of the model." ) #get class probabilities for each input in dataset if torch.cuda.is_available(): X_eval = X_eval.cuda() if not isinstance(X_eval, Variable): X_eval = Variable(X_eval) probs = self.model(X_eval) #predict a class for each input from these probabilties values, labels = probs.max(1) return [self._classes[l] for l in labels.data]
def forward(self, iword, owords): batch_size = iword.size()[0] context_size = owords.size()[1] if self.weights is not None: nwords = t.multinomial(self.weights, batch_size * context_size * self.n_negs, replacement=True).view(batch_size, -1) else: nwords = FT(batch_size, context_size * self.n_negs).uniform_(0, self.vocab_size - 1).long() ivectors = self.embedding.forward_i(iword).unsqueeze(2) ovectors = self.embedding.forward_o(owords) non_pad = FT((owords != self.pad).float()) non_pad = non_pad.cuda() if self.embedding.ovectors.weight.is_cuda else non_pad N = non_pad.sum() nvectors = self.embedding.forward_o(nwords).neg() #oloss = t.bmm(ovectors, ivectors).squeeze().sigmoid().log().mean(1) oloss = t.sum(ls(t.bmm(ovectors, ivectors).squeeze()) * non_pad) / N nloss = ls(t.bmm(nvectors, ivectors).squeeze()).view(-1, context_size, self.n_negs).sum(2).mean(1) return -(oloss + nloss).mean()
def forward(self, emb_batch: torch.FloatTensor, length_batch: torch.LongTensor, features_batch: List[np.ndarray] = None) -> torch.Tensor: """ :param emb_batch: (batch_size, seq_len, embed_size) :param length_batch: (batch_size, ) :param features_batch: (batch_size, feat_size) :return: """ batch_size = emb_batch.size(0) emb_batch = self.dropout(emb_batch) if torch.cuda.is_available(): emb_batch = emb_batch.cuda() output, (final_hidden_state, final_cell_state) = self.lstm(emb_batch) final_hidden_state = final_hidden_state.view(batch_size, -1) return torch.mean(output, dim=1)
def train_epoch(self, optimizer, batch_size): training_data = DataHandler.get_training_data(batch_size=batch_size) for data in training_data: sample, target = FloatTensor([[data[0]]]), FloatTensor([data[1]]) if torch.cuda.is_available(): sample, target = sample.cuda(), target.cuda() sample, target = Variable(sample), Variable(target) optimizer.zero_grad() output = self(sample) #Negative Log-Likelihood loss criterion = nn.MSELoss() loss = criterion(output, target) loss.backward() optimizer.step()
def auc_test(self): testpos = self.datastore.test.sample(SAMPLES_PER_ITERATION) testneg = self.datastore.df.sample(SAMPLES_PER_ITERATION) batch = [] for ind in tqdm(range(0, len(testpos))): pos = testpos.iloc[ind].tolist() neg = testneg.iloc[ind].tolist() if pos[1] == neg[1]: neg = self.datastore.sample(pos[1]).iloc[0].tolist() batch.append(pos + neg) batch = FloatTensor(batch) if CUDA: batch = batch.cuda() users = Variable(batch[:, 1]).long() pos_items = Variable(batch[:, 5:14]).long() neg_items = Variable(batch[:, 19:]).long() pos_preds = self(users, pos_items) neg_preds = self(users, neg_items) auc = 0.0 for i in range(0, len(pos_preds)): sp = pos_preds[i] sn = neg_preds[i] if CUDA: sp = sp.data.cpu().numpy()[0] sn = sn.data.cpu().numpy()[0] if sp > sn: auc += 1.0 elif sp == sn: auc += 0.5 return auc / len(testpos)
def child_based_correction(self, y): if type(y) != np.ndarray: num_test = y.cpu().numpy() else: num_test = y for k in num_test: for n in range(-1 * (self.dataset.number_of_level() - 1), 0): n = n * -1 start_index = self.dataset.level[n] last_index = self.dataset.level[n + 1] for i in range(start_index, last_index): for p in self.dataset.parent_of[i]: if k[i]: k[p] = 1 num_test = num_test.astype(float) correct_test = FloatTensor(num_test) if torch.cuda.is_available(): correct_test = correct_test.cuda() return correct_test
def update(self, model=None, do_forward=True): super(PassageState, self).update() if model is None: return # init variables based on number of models self.init_model_params(model) if do_forward or self.parent.proposal is None: feature = self.extract_feature() if self.parent is None: rel_pos = np.zeros(self.ss.dim) else: # update root if self.parent.proposal is None: rel_pos = np.zeros(self.ss.dim) feature = self.parent.extract_feature() self.parent.sample = Sample(Tensor(feature), prior_dist(), pos=rel_pos) self.parent.init_model_params(model) self.parent.proposal, self.parent.hidden_state = \ model.forward(self.parent.sample, prev_hidden_state=self.parent.hidden_state) # update else prior_vec = [1, 0] if self.parent.parent is not None: prior_vec = np.asarray([ self.parent.value[0] - self.parent.parent.value[0], self.parent.value[1] - self.parent.parent.value[1] ]) new_vec = np.asarray([ self.value[0] - self.parent.value[0], self.value[1] - self.parent.value[1] ]) move = theta_from_vecs(prior_vec, new_vec) rel_pos = self.value - self.parent.value val = Tensor([move]) if model.on_cuda: val = val.cuda() self.log_prob = self.parent.proposal[0].log_prob(val).item() if do_forward: self.sample = Sample(Tensor(feature), prior_dist(), pos=rel_pos) hidden = None if self.parent is None else self.parent.hidden_state self.proposal, self.hidden_state = \ model.forward(self.sample, prev_hidden_state=hidden)
def batch_sample(self): batch = [] testpos = self.train.sample(SAMPLES_PER_ITERATION) testneg = self.train.sample(SAMPLES_PER_ITERATION) for ind in range(0, len(testpos)): pos = testpos.iloc[ind].tolist() neg = testneg.iloc[ind].tolist() if pos[1] == neg[1]: neg = self.sample(pos[1]).iloc[0].tolist() batch.append(pos + neg) batch = FloatTensor(batch) if CUDA: batch = batch.cuda() return torch.utils.data.DataLoader(batch, batch_size=BATCH_SIZE, shuffle=True)
def evaluate(self, mode, correction=True, mandatory_leaf=False): if mode == "train": evaluated_data = self.dataset elif mode == "validate": evaluated_data = self.dataset_validate elif mode == "test": evaluated_data = self.dataset_test number_of_batch = 0 number_of_class = self.dataset.number_of_classes() all_tp = FloatTensor([0] * number_of_class) all_pcp = FloatTensor([0] * number_of_class) all_cp = FloatTensor([0] * number_of_class) if torch.cuda.is_available(): all_tp = all_tp.cuda() all_pcp = all_pcp.cuda() all_cp = all_cp.cuda() for datas, labels in evaluated_data.generate_batch( -1, self.get_batch_size(-1)): number_of_batch = number_of_batch + 1 all_labels = FloatTensor([]) if mandatory_leaf: all_pred = FloatTensor([]) else: all_pred = ByteTensor([]) if torch.cuda.is_available(): all_labels = all_labels.cuda() all_pred = all_pred.cuda() for level in range(self.dataset.number_of_level()): datas_in = self.input_classifier(datas, level, number_of_batch, mode) datas_in = Variable(datas_in, volatile=True) each_level = labels[:, self.dataset.level[level]:self.dataset. level[level + 1]] if torch.cuda.is_available(): datas_in = datas_in.cuda() each_level = each_level.cuda() if mandatory_leaf: pred = self.classifier[level](datas_in).data else: pred = self.classifier[level].output_with_threshold( datas_in).data all_labels = torch.cat((all_labels, each_level), 1) all_pred = torch.cat((all_pred, pred), 1) if mandatory_leaf: all_pred = self.get_leaf_node(all_pred) all_pred = self.to_one_hot(all_pred) if correction: all_pred = self.child_based_correction(all_pred) tp, pcp, cp = tp_pcp(all_labels, all_pred, use_threshold=False) all_tp = all_tp + tp all_pcp = all_pcp + pcp all_cp = all_cp + cp f1_macro, f1_micro = f1_from_tp_pcp(all_tp, all_pcp, all_cp, self.dataset.number_of_classes()) f1_each_level = [] for level in range(self.dataset.number_of_level()): each_tp = all_tp[self.dataset.level[level]:self.dataset.level[level + 1]] each_pcp = all_pcp[self.dataset.level[level]:self.dataset. level[level + 1]] each_cp = all_cp[self.dataset.level[level]:self.dataset.level[level + 1]] each_f1_macro, each_f1_micro = f1_from_tp_pcp( each_tp, each_pcp, each_cp, self.classifier[level].number_of_class) f1_each_level.append((each_f1_macro, each_f1_micro)) return f1_macro, f1_micro, f1_each_level
def export_result(self, mode, correction=True, mandatory_leaf=False, file_name=""): if mode == "train": evaluated_data = self.dataset elif mode == "validate": evaluated_data = self.dataset_validate elif mode == "test": evaluated_data = self.dataset_test if file_name == "": file_name = mode if not os.path.exists("export/%s/prediction" % (self.data_name)): os.makedirs("export/%s/prediction" % (self.data_name)) if not os.path.exists("export/%s/probability_prediction" % (self.data_name)): os.makedirs("export/%s/probability_prediction" % (self.data_name)) np_all_name = np.array(self.dataset.all_name) f = open("export/%s/prediction/%s.txt" % (self.data_name, file_name), 'w') f2 = open( "export/%s/probability_prediction/%s.txt" % (self.data_name, file_name), 'w') number_of_batch = 0 for datas, labels in evaluated_data.generate_batch( -1, self.get_batch_size(-1)): number_of_batch = number_of_batch + 1 all_labels = FloatTensor([]) if not mandatory_leaf: all_pred = ByteTensor([]) all_prob = FloatTensor([]) if torch.cuda.is_available(): all_labels = all_labels.cuda() all_prob = all_prob.cuda() if not mandatory_leaf: all_pred = all_pred.cuda() for level in range(self.dataset.number_of_level()): datas_in = self.input_classifier(datas, level, number_of_batch, mode) datas_in = Variable(datas_in, volatile=True) each_level = labels[:, self.dataset.level[level]:self.dataset. level[level + 1]] if torch.cuda.is_available(): datas_in = datas_in.cuda() each_level = each_level.cuda() prob = self.classifier[level](datas_in).data all_prob = torch.cat((all_prob, prob), 1) all_labels = torch.cat((all_labels, each_level), 1) if not mandatory_leaf: pred = self.classifier[level].output_with_threshold( datas_in).data all_pred = torch.cat((all_pred, pred), 1) if mandatory_leaf: all_pred = self.get_leaf_node(all_prob) else: all_pred = self.child_based_correction(all_pred) all_pred = self.select_deepest_label(all_pred) for p in all_pred: f.write(" ".join(np_all_name[p]) + "\n") for p in F.sigmoid(all_prob).cpu().numpy(): f2.write(" ".join(map(str, p)) + "\n") f.close() f2.close()
class EachLevelClassifier(nn.Module): def __init__(self, input_size, number_of_class, use_dropout=True, learning_rate=0.001): super(EachLevelClassifier, self).__init__() self.input_size = input_size self.number_of_class = number_of_class self.use_dropout = use_dropout self.learning_rate = learning_rate self.best_threshold = 0.5 self.change_ratio = 1 self.initial_structure() self.optimizer = optim.Adam(self.parameters(), lr=self.learning_rate) def initial_structure(self): raise NotImplementedError def forward(self, x): raise NotImplementedError def train_model(self, x, y): self.train() self.optimizer.zero_grad() output = self(x) loss = self.loss_function(output, y) loss.backward() self.optimizer.step() output_loss = loss.data.cpu().numpy()[0] return output_loss def initial_weight(self, number_of_data, count): weight = [] for i, c in enumerate(count): try: w = number_of_data / c weight.append(w) except ZeroDivisionError: weight.append(10000) self.pos_weight = FloatTensor(weight) if torch.cuda.is_available(): self.pos_weight = self.pos_weight.cuda() self.loss_function = nn.MultiLabelSoftMarginLoss( size_average=True, weight=self.pos_weight) def evaluate(self, x, y): self.eval() output = self(x) f1_macro, f1_micro = f1_score(y, output, self.number_of_class, use_threshold=True, threshold=self.best_threshold) f1_macro = f1_macro.data.cpu().numpy()[0] f1_micro = f1_micro.data.cpu().numpy()[0] return f1_macro, f1_micro def evaluate_tp_pcp(self, x, y, threshold): self.eval() output = self(x) if threshold == 0: threshold = self.best_threshold tp, pcp, cp = tp_pcp( y, output, use_threshold=True, threshold=threshold) return tp, pcp, cp def output_with_threshold(self, x): return F.sigmoid(self(x)) > self.best_threshold
def get_saliency( self, x: torch.FloatTensor, target_class: str, guide_backprop: bool = False, ) -> torch.FloatTensor: '''Compute the saliency of a target class on an input vector `x`. Parameters ---------- x : torch.FloatTensor [1, Genes] vector of gene expression. target_class : str class in `.class_names` for which to compute gradients. guide_backprop : bool perform "guided backpropogation" by clamping gradients to only positive values at each ReLU. see: https://arxiv.org/pdf/1412.6806.pdf Returns ------- salience : torch.FloatTensor gradients on `target_class` with respect to `x`. ''' if target_class not in self.class_names: msg = f'{target_class} is not in `.class_names`' raise ValueError(msg) target_idx = np.where( target_class == self.class_names )[0].astype(np.int) target_idx = int(target_idx) self.model.zero_grad() if guide_backprop: self.rectified_outputs = [] self.store_rectified_grad = [] self._guided_backprop_hooks() # store gradients on the input if torch.cuda.is_available(): x = x.cuda() x.requires_grad = True # module hook will record gradients here self.gradients = torch.zeros_like(x) # forward pass output = self.model(x) # create a [N, C] tensor to store gradients target = torch.zeros_like(output) # set the target class to `1`, creating a one-hot # of the target class target[:, target_idx] = 1 # compute gradients with backprop output.backward( gradient=target, ) # detach from the graph and move to main memory target = target.detach().cpu() return self.gradients
def prepare_batch(self, batch, istest=False): volatile = True if istest else False # logging.info("istest is %s and volatile is %s", istest, volatile) l_batch, l_lengths, \ r_batch, r_lengths, \ doc_bow_batch, \ truewid_descvec_batch, \ types_batch, \ coherence_batch, \ wids_batch, wid_cprobs_batch, nocands_mask_batch = batch # Do not mess with type casting here. torch.from_numpy is SLOW l_batch = MyTensor(l_batch) l_lengths = torch.LongTensor(l_lengths) r_batch = MyTensor(r_batch) r_lengths = torch.LongTensor(r_lengths) wids_batch = torch.LongTensor(wids_batch) # nocands_mask_batch = MyTensor(nocands_mask_batch) if self.args["usecoh"]: batch_rcs, batch_vals, shape = coherence_batch batch_rcs = torch.LongTensor(batch_rcs) batch_vals = MyTensor(batch_vals) coherence_batch = MySparseTensor(batch_rcs.t(), batch_vals, torch.Size(shape)) if self.args["usedesc"]: truewid_descvec_batch = MyTensor(truewid_descvec_batch) if self.args["usetype"]: types_batch = MyTensor(types_batch) if self.args["cuda"]: devid = self.args["device_id"] l_batch = l_batch.cuda(device=devid) l_lengths = l_lengths.cuda(device=devid) r_batch = r_batch.cuda(device=devid) r_lengths = r_lengths.cuda(device=devid) wids_batch = wids_batch.cuda(device=devid) # nocands_mask_batch = nocands_mask_batch.cuda(device=devid) if self.args["usecoh"]: coherence_batch = coherence_batch.cuda(device=devid) if self.args["usedesc"]: truewid_descvec_batch = truewid_descvec_batch.cuda( device=devid) if self.args["usetype"]: types_batch = types_batch.cuda(device=devid) l_batch, l_lengths = V(l_batch, volatile=volatile), V(l_lengths, volatile=volatile) r_batch, r_lengths = V(r_batch, volatile=volatile), V(r_lengths, volatile=volatile) wids_batch = V(wids_batch, volatile=volatile) # nocands_mask_batch = V(nocands_mask_batch) if self.args["usecoh"]: coherence_batch = V(coherence_batch, volatile=volatile) if self.args["usedesc"]: truewid_descvec_batch = V(truewid_descvec_batch, volatile=volatile) if self.args["usetype"]: types_batch = V(types_batch, volatile=volatile) batch = l_batch, l_lengths, \ r_batch, r_lengths, \ truewid_descvec_batch, \ types_batch, \ coherence_batch, \ wids_batch, wid_cprobs_batch, nocands_mask_batch return batch
def choose_action(obs: torch.FloatTensor, network: network_conv) -> int: return torch.argmax(network(obs.cuda())).item()
def _var(self, x: torch.FloatTensor) -> Variable: return Variable(x.cuda() if self.on_gpu else x)