我们从Python开源项目中，提取了以下17个代码示例，用于说明如何使用torch.masked_select()。
def __call__(self, image, pose, visibility): _, height, width = image.size() shape = (width, height) visible_pose = torch.masked_select(pose, visibility.byte()).view(-1, 2) p_min = visible_pose.min(0)[0].squeeze() p_max = visible_pose.max(0)[0].squeeze() p_c = (p_min + p_max)/2 crop_shape = [0, 0, 0, 0] # crop on a joint center for i in range(2): if self.data_augmentation: crop_shape[2*i] = random.randint(0, int(min(p_min[i], shape[i] - self.crop_size))) else: crop_shape[2*i] = max(0, int(p_c[i] - float(self.crop_size)/2)) crop_shape[2*i + 1] = min(shape[i], crop_shape[2*i] + self.crop_size) crop_shape[2*i] -= self.crop_size - (crop_shape[2*i + 1] - crop_shape[2*i]) transformed_image = image[:, crop_shape[2]:crop_shape[3], crop_shape[0]:crop_shape[1]] p_0 = torch.Tensor((crop_shape[0], crop_shape[2])).view(1, 2).expand_as(pose) transformed_pose = pose - p_0 return transformed_image, transformed_pose, visibility
def forward(self, prob, target): """ Args: prob: (N, C) target : (N, ) """ N = target.size(0) C = prob.size(1) weight = Variable(self.weight).view((1, -1)) weight = weight.expand(N, C) # (N, C) if prob.is_cuda: weight = weight.cuda() prob = weight * prob one_hot = torch.zeros((N, C)) if prob.is_cuda: one_hot = one_hot.cuda() one_hot.scatter_(1, target.data.view((-1,1)), 1) one_hot = one_hot.type(torch.ByteTensor) one_hot = Variable(one_hot) if prob.is_cuda: one_hot = one_hot.cuda() loss = torch.masked_select(prob, one_hot) return -torch.sum(loss)
def forward(self, prob, target, reward): """ Args: prob: (N, C), torch Variable target : (N, ), torch Variable reward : (N, ), torch Variable """ N = target.size(0) C = prob.size(1) one_hot = torch.zeros((N, C)) if prob.is_cuda: one_hot = one_hot.cuda() one_hot.scatter_(1, target.data.view((-1,1)), 1) one_hot = one_hot.type(torch.ByteTensor) one_hot = Variable(one_hot) if prob.is_cuda: one_hot = one_hot.cuda() loss = torch.masked_select(prob, one_hot) loss = loss * reward loss = -torch.sum(loss) return loss
def updateOutput(self, input): input, mask = input torch.masked_select(self.output, input, mask) return self.output
def updateGradInput(self, input, gradOutput): input, mask = input if input.type() == 'torch.cuda.FloatTensor': torch.range(self._maskIndexBufferCPU, 0, mask.nelement()-1).resize_(mask.size()) self._maskIndexBuffer.resize_(self._maskIndexBufferCPU.size()).copy_(self._maskIndexBufferCPU) else: torch.range(self._maskIndexBuffer, 0, mask.nelement()-1).resize_(mask.size()) torch.masked_select(self._maskIndices, self._maskIndexBuffer, mask) self._gradBuffer.resize_(input.nelement()).zero_() self._gradBuffer.scatter_(0, self._maskIndices, gradOutput) self._gradBuffer.resize_(input.size()) self.gradInput = [self._gradBuffer, self._gradMask.resize_(mask.size()).fill_(0)] return self.gradInput
def forward(self, input): """ x should be [seq_len][batch_size] """ seq_len = input.size()[0] batch_size = input.size()[1] # we reuse initial_state and initial_cell, if they havent changed # since last time. if self.initial_state is None or self.initial_state.size()[1] != batch_size: self.initial_state = autograd.Variable(torch.zeros( self.num_layers * 2, batch_size, self.num_hidden )) self.initial_cell = autograd.Variable(torch.zeros( self.num_layers * 2, batch_size, self.num_hidden )) if input.is_cuda: self.initial_state = self.initial_state.cuda() self.initial_cell = self.initial_cell.cuda() x = self.embedding(input) x, _ = self.lstm(x, (self.initial_state, self.initial_cell)) x = self.linear(x) x = F.sigmoid(x) rationale_selected_node = torch.bernoulli(x) rationale_selected = rationale_selected_node.view(seq_len, batch_size) rationale_lengths = rationale_selected.sum(dim=0).int() max_rationale_length = rationale_lengths.max() # if self.rationales is None or self.rationales.shape[1] != batch_size: rationales = torch.LongTensor(max_rationale_length.data[0], batch_size) if input.is_cuda: rationales = rationales.cuda() rationales.fill_(self.pad_id) for n in range(batch_size): this_len = rationale_lengths[n].data[0] rationales[:this_len, n] = torch.masked_select( input[:, n].data, rationale_selected[:, n].data.byte() ) return rationale_selected_node, rationale_selected, rationales, rationale_lengths
def updateOutput(self, input): input, mask = input torch.masked_select(input, mask, out=self.output) return self.output
def updateGradInput(self, input, gradOutput): input, mask = input if input.type() == 'torch.cuda.FloatTensor': torch.arange(0, mask.nelement(), out=self._maskIndexBufferCPU).resize_(mask.size()) self._maskIndexBuffer.resize_(self._maskIndexBufferCPU.size()).copy_(self._maskIndexBufferCPU) else: torch.arange(0, mask.nelement(), out=self._maskIndexBuffer).resize_(mask.size()) torch.masked_select(self._maskIndexBuffer, mask, out=self._maskIndices) self._gradBuffer.resize_(input.nelement()).zero_() self._gradBuffer.scatter_(0, self._maskIndices, gradOutput) self._gradBuffer.resize_(input.size()) self.gradInput = [self._gradBuffer, self._gradMask.resize_(mask.size()).fill_(0)] return self.gradInput
def test_net(save_folder, net, cuda, dataset, transform, top_k, im_size=300, thresh=0.05): """Test a Fast R-CNN network on an image database.""" num_images = len(dataset) # all detections are collected into: # all_boxes[cls][image] = N x 5 array of detections in # (x1, y1, x2, y2, score) all_boxes = [[[] for _ in range(num_images)] for _ in range(len(labelmap)+1)] # timers _t = {'im_detect': Timer(), 'misc': Timer()} output_dir = get_output_dir('ssd300_120000', set_type) det_file = os.path.join(output_dir, 'detections.pkl') for i in range(num_images): im, gt, h, w = dataset.pull_item(i) x = Variable(im.unsqueeze(0)) if args.cuda: x = x.cuda() _t['im_detect'].tic() detections = net(x).data detect_time = _t['im_detect'].toc(average=False) # skip j = 0, because it's the background class for j in range(1, detections.size(1)): dets = detections[0, j, :] mask = dets[:, 0].gt(0.).expand(5, dets.size(0)).t() dets = torch.masked_select(dets, mask).view(-1, 5) if dets.dim() == 0: continue boxes = dets[:, 1:] boxes[:, 0] *= w boxes[:, 2] *= w boxes[:, 1] *= h boxes[:, 3] *= h scores = dets[:, 0].cpu().numpy() cls_dets = np.hstack((boxes.cpu().numpy(), scores[:, np.newaxis])) \ .astype(np.float32, copy=False) all_boxes[j][i] = cls_dets print('im_detect: {:d}/{:d} {:.3f}s'.format(i + 1, num_images, detect_time)) with open(det_file, 'wb') as f: pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL) print('Evaluating detections') evaluate_detections(all_boxes, output_dir, dataset)
def train_multilabel(features, targets, classes, train_split, test_split, C=1.0, ignore_hard_examples=True, after_ReLU=False, normalize_L2=False): print('\nHyperparameters:\n - C: {}\n - after_ReLU: {}\n - normL2: {}'.format(C, after_ReLU, normalize_L2)) train_APs = [] test_APs = [] for class_id in range(len(classes)): classifier = SVC(C=C, kernel='linear') # http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html if ignore_hard_examples: train_masks = (targets[train_split][:,class_id] != 0).view(-1, 1) train_features = torch.masked_select(features[train_split], train_masks.expand_as(features[train_split])).view(-1,features[train_split].size(1)) train_targets = torch.masked_select(targets[train_split], train_masks.expand_as(targets[train_split])).view(-1,targets[train_split].size(1)) test_masks = (targets[test_split][:,class_id] != 0).view(-1, 1) test_features = torch.masked_select(features[test_split], test_masks.expand_as(features[test_split])).view(-1,features[test_split].size(1)) test_targets = torch.masked_select(targets[test_split], test_masks.expand_as(targets[test_split])).view(-1,targets[test_split].size(1)) else: train_features = features[train_split] train_targets = targets[train_split] test_features = features[test_split] test_targets = features[test_split] if after_ReLU: train_features[train_features < 0] = 0 test_features[test_features < 0] = 0 if normalize_L2: train_norm = torch.norm(train_features, p=2, dim=1).unsqueeze(1) train_features = train_features.div(train_norm.expand_as(train_features)) test_norm = torch.norm(test_features, p=2, dim=1).unsqueeze(1) test_features = test_features.div(test_norm.expand_as(test_features)) train_X = train_features.numpy() train_y = (train_targets[:,class_id] != -1).numpy() # uses hard examples if not ignored test_X = test_features.numpy() test_y = (test_targets[:,class_id] != -1).numpy() classifier.fit(train_X, train_y) # train parameters of the classifier train_preds = classifier.predict(train_X) train_acc = accuracy_score(train_y, train_preds) * 100 train_AP = average_precision_score(train_y, train_preds) * 100 train_APs.append(train_AP) test_preds = classifier.predict(test_X) test_acc = accuracy_score(test_y, test_preds) * 100 test_AP = average_precision_score(test_y, test_preds) * 100 test_APs.append(test_AP) print('class "{}" ({}/{}):'.format(classes[class_id], test_y.sum(), test_y.shape[0])) print(' - {:8}: acc {:.2f}, AP {:.2f}'.format(train_split, train_acc, train_AP)) print(' - {:8}: acc {:.2f}, AP {:.2f}'.format(test_split, test_acc, test_AP)) print('all classes:') print(' - {:8}: mAP {:.4f}'.format(train_split, sum(train_APs)/len(classes))) print(' - {:8}: mAP {:.4f}'.format(test_split, sum(test_APs)/len(classes))) ########################################################################## # main ##########################################################################
