Python torch.size() Examples
The following are 22
code examples of torch.size().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
torch
, or try the search function
.
Example #1
Source File: multibox_loss.py From yolact with MIT License | 6 votes |
def coeff_diversity_loss(self, coeffs, instance_t): """ coeffs should be size [num_pos, num_coeffs] instance_t should be size [num_pos] and be values from 0 to num_instances-1 """ num_pos = coeffs.size(0) instance_t = instance_t.view(-1) # juuuust to make sure coeffs_norm = F.normalize(coeffs, dim=1) cos_sim = coeffs_norm @ coeffs_norm.t() inst_eq = (instance_t[:, None].expand_as(cos_sim) == instance_t[None, :].expand_as(cos_sim)).float() # Rescale to be between 0 and 1 cos_sim = (cos_sim + 1) / 2 # If they're the same instance, use cosine distance, else use cosine similarity loss = (1 - cos_sim) * inst_eq + cos_sim * (1 - inst_eq) # Only divide by num_pos once because we're summing over a num_pos x num_pos tensor # and all the losses will be divided by num_pos at the end, so just one extra time. return cfg.mask_proto_coeff_diversity_alpha * loss.sum() / num_pos
Example #2
Source File: ntuple_experience_replay.py From categorical-dqn with MIT License | 6 votes |
def _batch2torch(self, batch, batch_size): """ List of transitions -> Batch of transitions -> pytorch tensors. Returns: states: torch.size([batch_size, hist_len, w, h]) a/r/d: torch.size([batch_size, 1]) """ # check-out pytorch dqn tutorial. # (t1, t2, ... tn) -> t((s1, s2, ..., sn), (a1, a2, ... an) ...) batch = BatchTransition(*zip(*batch)) # lists to tensors state_batch = torch.cat(batch.state, 0).type(self.dtype.FT) / 255 action_batch = self.dtype.LT(batch.action).unsqueeze(1) reward_batch = self.dtype.FT(batch.reward).unsqueeze(1) next_state_batch = torch.cat(batch.state_, 0).type(self.dtype.FT) / 255 # [False, False, True, False] -> [1, 1, 0, 1]::ByteTensor mask = 1 - self.dtype.BT(batch.done).unsqueeze(1) return [batch_size, state_batch, action_batch, reward_batch, next_state_batch, mask]
Example #3
Source File: refine_multibox_loss.py From SSD_Pytorch with MIT License | 6 votes |
def __init__(self, cfg, num_classes): super(RefineMultiBoxLoss, self).__init__() self.cfg = cfg self.size = cfg.MODEL.SIZE if self.size == '300': size_cfg = cfg.SMALL else: size_cfg = cfg.BIG self.variance = size_cfg.VARIANCE self.num_classes = num_classes self.threshold = cfg.TRAIN.OVERLAP self.OHEM = cfg.TRAIN.OHEM self.negpos_ratio = cfg.TRAIN.NEG_RATIO self.object_score = cfg.MODEL.OBJECT_SCORE self.variance = size_cfg.VARIANCE if cfg.TRAIN.FOCAL_LOSS: if cfg.TRAIN.FOCAL_LOSS_TYPE == 'SOFTMAX': self.focaloss = FocalLossSoftmax( self.num_classes, gamma=2, size_average=False) else: self.focaloss = FocalLossSigmoid()
Example #4
Source File: multibox_loss.py From SSD_Pytorch with MIT License | 6 votes |
def __init__(self, cfg): super(MultiBoxLoss, self).__init__() self.cfg = cfg self.size = cfg.MODEL.SIZE if self.size == '300': size_cfg = cfg.SMALL else: size_cfg = cfg.BIG self.variance = size_cfg.VARIANCE self.num_classes = cfg.MODEL.NUM_CLASSES self.threshold = cfg.TRAIN.OVERLAP self.OHEM = cfg.TRAIN.OHEM self.negpos_ratio = cfg.TRAIN.NEG_RATIO self.variance = size_cfg.VARIANCE if cfg.TRAIN.FOCAL_LOSS: if cfg.TRAIN.FOCAL_LOSS_TYPE == 'SOFTMAX': self.focaloss = FocalLossSoftmax( self.num_classes, gamma=2, size_average=False) else: self.focaloss = FocalLossSigmoid()
Example #5
Source File: multibox_loss.py From HSD with MIT License | 6 votes |
def __init__(self, cfg): super(MultiBoxLoss, self).__init__() self.cfg = cfg self.size = cfg.MODEL.SIZE if self.size == '300': size_cfg = cfg.SMALL else: size_cfg = cfg.BIG self.variance = size_cfg.VARIANCE self.num_classes = cfg.MODEL.NUM_CLASSES self.threshold = cfg.TRAIN.OVERLAP self.OHEM = cfg.TRAIN.OHEM self.negpos_ratio = cfg.TRAIN.NEG_RATIO self.variance = size_cfg.VARIANCE if cfg.TRAIN.FOCAL_LOSS: if cfg.TRAIN.FOCAL_LOSS_TYPE == 'SOFTMAX': self.focaloss = FocalLossSoftmax( self.num_classes, gamma=2, size_average=False) else: self.focaloss = FocalLossSigmoid()
Example #6
Source File: hsd_multibox_loss.py From HSD with MIT License | 6 votes |
def __init__(self, cfg, num_classes): super(HSDMultiBoxLoss, self).__init__() self.cfg = cfg self.size = cfg.MODEL.SIZE if self.size == '300': size_cfg = cfg.SMALL else: size_cfg = cfg.BIG self.variance = size_cfg.VARIANCE self.num_classes = num_classes self.threshold = cfg.TRAIN.OVERLAP self.OHEM = cfg.TRAIN.OHEM self.negpos_ratio = cfg.TRAIN.NEG_RATIO self.object_score = cfg.MODEL.OBJECT_SCORE self.variance = size_cfg.VARIANCE if cfg.TRAIN.FOCAL_LOSS: if cfg.TRAIN.FOCAL_LOSS_TYPE == 'SOFTMAX': self.focaloss = FocalLossSoftmax( self.num_classes, gamma=2, size_average=False) else: self.focaloss = FocalLossSigmoid()
Example #7
Source File: refinedet_multibox_loss.py From RefinedetLite.pytorch with MIT License | 6 votes |
def forward(self, inputs, targets): N = inputs.size(0) C = inputs.size(1) P = F.softmax(inputs, dim=1) class_mask = inputs.data.new(N, C).fill_(0) class_mask = Variable(class_mask) ids = targets.view(-1, 1) class_mask.scatter_(1, ids.data, 1.) if inputs.is_cuda and not self.alpha.is_cuda: self.alpha = self.alpha.cuda() alpha = self.alpha[ids.data.view(-1)] probs = (P * class_mask).sum(1).view(-1, 1) log_p = probs.log() batch_loss = -alpha * (torch.pow((1 - probs), self.gamma)) * log_p if self.size_average: loss = batch_loss.mean() else: loss = batch_loss.sum() return loss
Example #8
Source File: multibox_loss.py From yolact with MIT License | 6 votes |
def semantic_segmentation_loss(self, segment_data, mask_t, class_t, interpolation_mode='bilinear'): # Note num_classes here is without the background class so cfg.num_classes-1 batch_size, num_classes, mask_h, mask_w = segment_data.size() loss_s = 0 for idx in range(batch_size): cur_segment = segment_data[idx] cur_class_t = class_t[idx] with torch.no_grad(): downsampled_masks = F.interpolate(mask_t[idx].unsqueeze(0), (mask_h, mask_w), mode=interpolation_mode, align_corners=False).squeeze(0) downsampled_masks = downsampled_masks.gt(0.5).float() # Construct Semantic Segmentation segment_t = torch.zeros_like(cur_segment, requires_grad=False) for obj_idx in range(downsampled_masks.size(0)): segment_t[cur_class_t[obj_idx]] = torch.max(segment_t[cur_class_t[obj_idx]], downsampled_masks[obj_idx]) loss_s += F.binary_cross_entropy_with_logits(cur_segment, segment_t, reduction='sum') return loss_s / mask_h / mask_w * cfg.semantic_segmentation_alpha
Example #9
Source File: learning_to_learn.py From learning-to-learn-by-pytorch with MIT License | 6 votes |
def forward(self,input_gradients, prev_state): if USE_CUDA: input_gradients = input_gradients.cuda() #pytorch requires the `torch.nn.lstm`'s input as(1,batchsize,input_dim) # original gradient.size()=torch.size[5] ->[1,1,5] gradients = input_gradients.unsqueeze(0) if self.preprocess_flag == True: gradients = self.LogAndSign_Preprocess_Gradient(gradients) update , next_state = self.Output_Gradient_Increment_And_Update_LSTM_Hidden_State(gradients , prev_state) # Squeeze to make it a single batch again.[1,1,5]->[5] update = update.squeeze().squeeze() return update , next_state ################# 优化器模型参数 ############################## ################# Parameters of optimizer ##############################
Example #10
Source File: focal_loss.py From ssds.pytorch with MIT License | 6 votes |
def focal_loss(self, inputs, targets): '''Focal loss. mean of losses: L(x,c,l,g) = (Lconf(x, c) + αLloc(x,l,g)) / N ''' N = inputs.size(0) C = inputs.size(1) P = F.softmax(inputs) class_mask = inputs.data.new(N, C).fill_(0) class_mask = Variable(class_mask) ids = targets.view(-1, 1) class_mask.scatter_(1, ids.data, 1.) if inputs.is_cuda and not self.alpha.is_cuda: self.alpha = self.alpha.cuda() alpha = self.alpha[ids.data.view(-1)] probs = (P*class_mask).sum(1).view(-1,1) log_p = probs.log() batch_loss = -alpha*(torch.pow((1-probs), self.gamma))*log_p loss = batch_loss.mean() return loss
Example #11
Source File: multibox_loss.py From yolact with MIT License | 5 votes |
def focal_conf_loss(self, conf_data, conf_t): """ Focal loss as described in https://arxiv.org/pdf/1708.02002.pdf Adapted from https://github.com/clcarwin/focal_loss_pytorch/blob/master/focalloss.py Note that this uses softmax and not the original sigmoid from the paper. """ conf_t = conf_t.view(-1) # [batch_size*num_priors] conf_data = conf_data.view(-1, conf_data.size(-1)) # [batch_size*num_priors, num_classes] # Ignore neutral samples (class < 0) keep = (conf_t >= 0).float() conf_t[conf_t < 0] = 0 # so that gather doesn't drum up a fuss logpt = F.log_softmax(conf_data, dim=-1) logpt = logpt.gather(1, conf_t.unsqueeze(-1)) logpt = logpt.view(-1) pt = logpt.exp() # I adapted the alpha_t calculation here from # https://github.com/pytorch/pytorch/blob/master/modules/detectron/softmax_focal_loss_op.cu # You'd think you want all the alphas to sum to one, but in the original implementation they # just give background an alpha of 1-alpha and each forground an alpha of alpha. background = (conf_t == 0).float() at = (1 - cfg.focal_loss_alpha) * background + cfg.focal_loss_alpha * (1 - background) loss = -at * (1 - pt) ** cfg.focal_loss_gamma * logpt # See comment above for keep return cfg.conf_alpha * (loss * keep).sum()
Example #12
Source File: multibox_loss.py From yolact with MIT License | 5 votes |
def focal_conf_sigmoid_loss(self, conf_data, conf_t): """ Focal loss but using sigmoid like the original paper. Note: To make things mesh easier, the network still predicts 81 class confidences in this mode. Because retinanet originally only predicts 80, we simply just don't use conf_data[..., 0] """ num_classes = conf_data.size(-1) conf_t = conf_t.view(-1) # [batch_size*num_priors] conf_data = conf_data.view(-1, num_classes) # [batch_size*num_priors, num_classes] # Ignore neutral samples (class < 0) keep = (conf_t >= 0).float() conf_t[conf_t < 0] = 0 # can't mask with -1, so filter that out # Compute a one-hot embedding of conf_t # From https://github.com/kuangliu/pytorch-retinanet/blob/master/utils.py conf_one_t = torch.eye(num_classes, device=conf_t.get_device())[conf_t] conf_pm_t = conf_one_t * 2 - 1 # -1 if background, +1 if forground for specific class logpt = F.logsigmoid(conf_data * conf_pm_t) # note: 1 - sigmoid(x) = sigmoid(-x) pt = logpt.exp() at = cfg.focal_loss_alpha * conf_one_t + (1 - cfg.focal_loss_alpha) * (1 - conf_one_t) at[..., 0] = 0 # Set alpha for the background class to 0 because sigmoid focal loss doesn't use it loss = -at * (1 - pt) ** cfg.focal_loss_gamma * logpt loss = keep * loss.sum(dim=-1) return cfg.conf_alpha * loss.sum()
Example #13
Source File: multibox_loss.py From yolact with MIT License | 5 votes |
def focal_conf_objectness_loss(self, conf_data, conf_t): """ Instead of using softmax, use class[0] to be the objectness score and do sigmoid focal loss on that. Then for the rest of the classes, softmax them and apply CE for only the positive examples. If class[0] = 1 implies forground and class[0] = 0 implies background then you achieve something similar during test-time to softmax by setting class[1:] = softmax(class[1:]) * class[0] and invert class[0]. """ conf_t = conf_t.view(-1) # [batch_size*num_priors] conf_data = conf_data.view(-1, conf_data.size(-1)) # [batch_size*num_priors, num_classes] # Ignore neutral samples (class < 0) keep = (conf_t >= 0).float() conf_t[conf_t < 0] = 0 # so that gather doesn't drum up a fuss background = (conf_t == 0).float() at = (1 - cfg.focal_loss_alpha) * background + cfg.focal_loss_alpha * (1 - background) logpt = F.logsigmoid(conf_data[:, 0]) * (1 - background) + F.logsigmoid(-conf_data[:, 0]) * background pt = logpt.exp() obj_loss = -at * (1 - pt) ** cfg.focal_loss_gamma * logpt # All that was the objectiveness loss--now time for the class confidence loss pos_mask = conf_t > 0 conf_data_pos = (conf_data[:, 1:])[pos_mask] # Now this has just 80 classes conf_t_pos = conf_t[pos_mask] - 1 # So subtract 1 here class_loss = F.cross_entropy(conf_data_pos, conf_t_pos, reduction='sum') return cfg.conf_alpha * (class_loss + (obj_loss * keep).sum())
Example #14
Source File: trainer.py From fastNLP with Apache License 2.0 | 5 votes |
def _get_value_info(_dict): # given a dict value, return information about this dict's value. Return list of str strs = [] for key, value in _dict.items(): _str = '' if isinstance(value, torch.Tensor): _str += "\t{}: (1)type:torch.Tensor (2)dtype:{}, (3)shape:{} ".format(key, value.dtype, value.size()) elif isinstance(value, np.ndarray): _str += "\t{}: (1)type:numpy.ndarray (2)dtype:{}, (3)shape:{} ".format(key, value.dtype, value.shape) else: _str += "\t{}: type:{}".format(key, type(value)) strs.append(_str) return strs
Example #15
Source File: multibox_loss.py From pytorch-ssd with MIT License | 5 votes |
def __init__(self, num_classes, size, overlap_thresh, prior_for_matching, bkg_label, neg_mining, neg_pos, neg_overlap, encode_target, use_gpu=True): super(MultiBoxLoss, self).__init__() self.use_gpu = use_gpu self.num_classes = num_classes self.threshold = overlap_thresh self.background_label = bkg_label self.encode_target = encode_target self.use_prior_for_matching = prior_for_matching self.do_neg_mining = neg_mining self.negpos_ratio = neg_pos self.neg_overlap = neg_overlap cfg = v[str(size)] self.variance = cfg['variance']
Example #16
Source File: CoordinateWiseLSTM.py From learning-to-learn-by-pytorch with MIT License | 5 votes |
def forward(self,input_gradients, prev_state): if USE_CUDA: input_gradients = input_gradients.cuda() #LSTM的输入为梯度,pytorch要求torch.nn.lstm的输入为(1,batchsize,input_dim) #原gradient.size()=torch.size[5] ->[1,1,5] gradients = input_gradients.unsqueeze(0) if self.preprocess_flag == True: gradients = self.LogAndSign_Preprocess_Gradient(gradients) update , next_state = self.Output_Gradient_Increment_And_Update_LSTM_Hidden_State(gradients , prev_state) # Squeeze to make it a single batch again.[1,1,5]->[5] update = update.squeeze().squeeze() return update , next_state
Example #17
Source File: multitrident_multibox_loss.py From multitrident with Apache License 2.0 | 5 votes |
def computeCrossEntropy(self, loss_c_for_WHAT, num_batch, pos_for_WHAT, conf_data, conf_truth): num_pos = pos_for_WHAT.long().sum(1, keepdim=True) if num_pos.sum() == 0: c_loss_for_WHAT = 0 return c_loss_for_WHAT, num_pos loss_c_for_WHAT[pos_for_WHAT.view(-1, 1)] = 0 # filter out pos boxes for now loss_c_for_small = loss_c_for_WHAT.view(num_batch, -1) _, loss_idx = loss_c_for_small.sort(1, descending=True) _, idx_rank = loss_idx.sort(1) # num_pos = pos_for_WHAT.long().sum(1, keepdim=True) num_neg = torch.clamp(self.negpos_ratio * num_pos, max=pos_for_WHAT.size(1) - 1) neg = idx_rank < num_neg.expand_as(idx_rank) # neglong = neg.long() # print("==========================================") # print("pos-->", num_pos.data.sum(), "neg-->",num_neg.data.sum(), " ",neg.data.sum()) # Confidence Loss Including Positive and Negative Examples pos_idx = pos_for_WHAT.unsqueeze(2).expand_as(conf_data) neg_idx = neg.unsqueeze(2).expand_as(conf_data) """do hard negmining""" conf_p = conf_data[(pos_idx + neg_idx).gt(0)].view(-1, self.num_classes) targets_weighted = conf_truth[(pos_for_WHAT + neg).gt(0)] """do not do hard negmining""" # conf_p = conf_data[(pos_idx).gt(0)].view(-1, self.num_classes) # targets_weighted = conf_truth[(pos_for_WHAT).gt(0)] c_loss_for_WHAT = F.cross_entropy(conf_p, targets_weighted, reduction='sum') num_pos_for_WHAT = num_pos return c_loss_for_WHAT, num_pos_for_WHAT
Example #18
Source File: wrappers.py From categorical-dqn with MIT License | 5 votes |
def __init__(self, env, env_type, hist_len, state_dims, cuda=None): super(PreprocessFrames, self).__init__(env) self.env_type = env_type self.state_dims = state_dims self.hist_len = hist_len self.env_wh = self.env.observation_space.shape[0:2] self.env_ch = self.env.observation_space.shape[2] self.wxh = self.env_wh[0] * self.env_wh[1] # need to find a better way if self.env_type == "atari": self._preprocess = self._atari_preprocess elif self.env_type == "catch": self._preprocess = self._catch_preprocess print("[Preprocess Wrapper] for %s with state history of %d frames." % (self.env_type, hist_len)) self.cuda = False if cuda is None else cuda self.dtype = dtype = TorchTypes(self.cuda) self.rgb = dtype.FT([.2126, .7152, .0722]) # torch.size([1, 4, 24, 24]) """ self.hist_state = torch.FloatTensor(1, hist_len, *state_dims) self.hist_state.fill_(0) """ self.d = OrderedDict({i: torch.FloatTensor(1, 1, *state_dims).fill_(0) for i in range(hist_len)})
Example #19
Source File: multibox_loss.py From yolact with MIT License | 4 votes |
def direct_mask_loss(self, pos_idx, idx_t, loc_data, mask_data, priors, masks): """ Crops the gt masks using the predicted bboxes, scales them down, and outputs the BCE loss. """ loss_m = 0 for idx in range(mask_data.size(0)): with torch.no_grad(): cur_pos_idx = pos_idx[idx, :, :] cur_pos_idx_squeezed = cur_pos_idx[:, 1] # Shape: [num_priors, 4], decoded predicted bboxes pos_bboxes = decode(loc_data[idx, :, :], priors.data, cfg.use_yolo_regressors) pos_bboxes = pos_bboxes[cur_pos_idx].view(-1, 4).clamp(0, 1) pos_lookup = idx_t[idx, cur_pos_idx_squeezed] cur_masks = masks[idx] pos_masks = cur_masks[pos_lookup, :, :] # Convert bboxes to absolute coordinates num_pos, img_height, img_width = pos_masks.size() # Take care of all the bad behavior that can be caused by out of bounds coordinates x1, x2 = sanitize_coordinates(pos_bboxes[:, 0], pos_bboxes[:, 2], img_width) y1, y2 = sanitize_coordinates(pos_bboxes[:, 1], pos_bboxes[:, 3], img_height) # Crop each gt mask with the predicted bbox and rescale to the predicted mask size # Note that each bounding box crop is a different size so I don't think we can vectorize this scaled_masks = [] for jdx in range(num_pos): tmp_mask = pos_masks[jdx, y1[jdx]:y2[jdx], x1[jdx]:x2[jdx]] # Restore any dimensions we've left out because our bbox was 1px wide while tmp_mask.dim() < 2: tmp_mask = tmp_mask.unsqueeze(0) new_mask = F.adaptive_avg_pool2d(tmp_mask.unsqueeze(0), cfg.mask_size) scaled_masks.append(new_mask.view(1, -1)) mask_t = torch.cat(scaled_masks, 0).gt(0.5).float() # Threshold downsampled mask pos_mask_data = mask_data[idx, cur_pos_idx_squeezed, :] loss_m += F.binary_cross_entropy(torch.clamp(pos_mask_data, 0, 1), mask_t, reduction='sum') * cfg.mask_alpha return loss_m
Example #20
Source File: focal_loss.py From ssds.pytorch with MIT License | 4 votes |
def forward(self, predictions, targets): """Multibox Loss Args: predictions (tuple): A tuple containing loc preds, conf preds, and prior boxes from SSD net. conf shape: torch.size(batch_size,num_priors,num_classes) loc shape: torch.size(batch_size,num_priors,4) priors shape: torch.size(num_priors,4) ground_truth (tensor): Ground truth boxes and labels for a batch, shape: [batch_size,num_objs,5] (last idx is the label). """ loc_data, conf_data = predictions num = loc_data.size(0) priors = self.priors # priors = priors[:loc_data.size(1), :] num_priors = (priors.size(0)) # match priors (default boxes) and ground truth boxes loc_t = torch.Tensor(num, num_priors, 4) conf_t = torch.LongTensor(num, num_priors) for idx in range(num): truths = targets[idx][:,:-1].data labels = targets[idx][:,-1].data defaults = priors.data match(self.threshold,truths,defaults,self.variance,labels,loc_t,conf_t,idx) if self.use_gpu: loc_t = loc_t.cuda() conf_t = conf_t.cuda() # wrap targets loc_t = Variable(loc_t, requires_grad=False) conf_t = Variable(conf_t,requires_grad=False) pos = conf_t > 0 num_pos = pos.sum() # Localization Loss (Smooth L1) # Shape: [batch,num_priors,4] pos_idx = pos.unsqueeze(pos.dim()).expand_as(loc_data) loc_p = loc_data[pos_idx].view(-1,4) loc_t = loc_t[pos_idx].view(-1,4) loss_l = F.smooth_l1_loss(loc_p, loc_t, size_average=False) loss_l/=num_pos.data.sum() # Confidence Loss (Focal loss) # Shape: [batch,num_priors,1] loss_c = self.focal_loss(conf_data.view(-1, self.num_classes), conf_t.view(-1,1)) return loss_l,loss_c
Example #21
Source File: multibox_loss.py From yolact with MIT License | 4 votes |
def ohem_conf_loss(self, conf_data, conf_t, pos, num): # Compute max conf across batch for hard negative mining batch_conf = conf_data.view(-1, self.num_classes) if cfg.ohem_use_most_confident: # i.e. max(softmax) along classes > 0 batch_conf = F.softmax(batch_conf, dim=1) loss_c, _ = batch_conf[:, 1:].max(dim=1) else: # i.e. -softmax(class 0 confidence) loss_c = log_sum_exp(batch_conf) - batch_conf[:, 0] # Hard Negative Mining loss_c = loss_c.view(num, -1) loss_c[pos] = 0 # filter out pos boxes loss_c[conf_t < 0] = 0 # filter out neutrals (conf_t = -1) _, loss_idx = loss_c.sort(1, descending=True) _, idx_rank = loss_idx.sort(1) num_pos = pos.long().sum(1, keepdim=True) num_neg = torch.clamp(self.negpos_ratio*num_pos, max=pos.size(1)-1) neg = idx_rank < num_neg.expand_as(idx_rank) # Just in case there aren't enough negatives, don't start using positives as negatives neg[pos] = 0 neg[conf_t < 0] = 0 # Filter out neutrals # Confidence Loss Including Positive and Negative Examples pos_idx = pos.unsqueeze(2).expand_as(conf_data) neg_idx = neg.unsqueeze(2).expand_as(conf_data) conf_p = conf_data[(pos_idx+neg_idx).gt(0)].view(-1, self.num_classes) targets_weighted = conf_t[(pos+neg).gt(0)] loss_c = F.cross_entropy(conf_p, targets_weighted, reduction='none') if cfg.use_class_balanced_conf: # Lazy initialization if self.class_instances is None: self.class_instances = torch.zeros(self.num_classes, device=targets_weighted.device) classes, counts = targets_weighted.unique(return_counts=True) for _cls, _cnt in zip(classes.cpu().numpy(), counts.cpu().numpy()): self.class_instances[_cls] += _cnt self.total_instances += targets_weighted.size(0) weighting = 1 - (self.class_instances[targets_weighted] / self.total_instances) weighting = torch.clamp(weighting, min=1/self.num_classes) # If you do the math, the average weight of self.class_instances is this avg_weight = (self.num_classes - 1) / self.num_classes loss_c = (loss_c * weighting).sum() / avg_weight else: loss_c = loss_c.sum() return cfg.conf_alpha * loss_c
Example #22
Source File: parameter_constraints.py From botorch with MIT License | 4 votes |
def make_scipy_linear_constraints( shapeX: torch.Size, inequality_constraints: Optional[List[Tuple[Tensor, Tensor, float]]] = None, equality_constraints: Optional[List[Tuple[Tensor, Tensor, float]]] = None, ) -> List[ScipyConstraintDict]: r"""Generate scipy constraints from torch representation. Args: shapeX: The shape of the torch.Tensor to optimize over (i.e. `b x q x d`) inequality constraints: A list of tuples (indices, coefficients, rhs), with each tuple encoding an inequality constraint of the form `\sum_i (X[indices[i]] * coefficients[i]) >= rhs`, where `indices` is a single-dimensional index tensor (long dtype) containing indices into the last dimension of `X`, `coefficients` is a single-dimensional tensor of coefficients of the same length, and rhs is a scalar. equality constraints: A list of tuples (indices, coefficients, rhs), with each tuple encoding an inequality constraint of the form `\sum_i (X[indices[i]] * coefficients[i]) == rhs` (with `indices` and `coefficients` of the same form as in `inequality_constraints`). Returns: A list of dictionaries containing callables for constraint function values and Jacobians and a string indicating the associated constraint type ("eq", "ineq"), as expected by `scipy.minimize`. This function assumes that constraints are the same for each input batch, and broadcasts the constraints accordingly to the input batch shape. This function does support constraints across elements of a q-batch if the indices are a 2-d Tensor. Example: The following will enforce that `x[1] + 0.5 x[3] >= -0.1` for each `x` in both elements of the q-batch, and each of the 3 t-batches: >>> constraints = make_scipy_linear_constraints( >>> torch.Size([3, 2, 4]), >>> [(torch.tensor([1, 3]), torch.tensor([1.0, 0.5]), -0.1)], >>> ) The following will enforce that `x[0, 1] + 0.5 x[1, 3] >= -0.1` where x[0, :] is the first element of the q-batch and x[1, :] is the second element of the q-batch, for each of the 3 t-batches: >>> constraints = make_scipy_linear_constraints( >>> torch.size([3, 2, 4]) >>> [(torch.tensor([[0, 1], [1, 3]), torch.tensor([1.0, 0.5]), -0.1)], >>> ) """ constraints = [] if inequality_constraints is not None: for indcs, coeffs, rhs in inequality_constraints: constraints += _make_linear_constraints( indices=indcs, coefficients=coeffs, rhs=rhs, shapeX=shapeX, eq=False ) if equality_constraints is not None: for indcs, coeffs, rhs in equality_constraints: constraints += _make_linear_constraints( indices=indcs, coefficients=coeffs, rhs=rhs, shapeX=shapeX, eq=True ) return constraints