def forward(self, predicted, target): _assert_no_grad(target) diff = (predicted - target) ** 2 if not self.reduce: return diff loss = torch.sqrt(torch.mean(diff)) if self.size_average else torch.sqrt(torch.sum(diff)) return loss
def forward(self, input, trueDistributions): _assert_no_grad(trueDistributions) logSoftmaxesForAll = F.log_softmax(input) # elmentwise multiply every logsoft_max by the true distribution for its example to get # the cross-entropy unsumedCrossEntropy = logSoftmaxesForAll * trueDistributions # take negative and average across all examples return torch.sum(unsumedCrossEntropy) * -1 / input.size(0)
def forward(self, input, target): Moddy._assert_no_grad(target) zet = ((th.sqrt(th.sum(input * input, dim=-1) + 1))) inner = (th.sum(input * position[target.data], dim=-1)) return th.sum( self.ruler( th.clamp(zet * position_zet[target.data] - inner, min=1 + eps).to(device)))
def forward(self, input, target): _assert_no_grad(target) return dice_loss(input, target, weight=self.weight, smooth=self.smooth, size_average=self.size_average, reduce=self.reduce)
def forward(self, x, y, m, a): _assert_no_grad(y) return self._vague_loss(x, y, m, a, size_average=self.size_average, reduce=self.reduce)
def forward(self, input, target, weight): _assert_no_grad(target) """ Weighted binary classification loss + Dice coefficient loss """ loss1 = F.binary_cross_entropy(input, target, weight, self.size_average, self.reduce) loss2 = self.dice_loss(input, target) return loss1, loss2
def forward(self, x, target): _assert_no_grad(target) num_classes = x.size(1) expected_class = (F.softmax(x, dim=1) * torch.arange( end=num_classes, requires_grad=True).cuda()).sum(dim=1) return F.mse_loss(expected_class, target, size_average=self.size_average, reduce=self.reduce)
def forward(self, predicted, target): _assert_no_grad(target) first_log = torch.log(predicted + 1e-6) second_log = torch.log(target + 1e-6) log_term = torch.mean(torch.pow(first_log - second_log, 2)) sc_inv_term = torch.pow(torch.mean((first_log - second_log)), 2) loss = log_term - sc_inv_term return loss
def forward(self, scores, target): _assert_no_grad(target) if len(scores.size()) != 4: raise ValueError( "Scores should have 4 dimensions, but has {}: {}".format( len(scores.size()), scores.size())) _, c, _, _ = scores.size() scores = scores.permute(0, 2, 3, 1).contiguous().view(-1, c) target = target.view(-1) return F.cross_entropy(scores, target, self.weight, self.size_average, self.ignore_index, self.reduce)
def forward(self, input, target, level): Moddy._assert_no_grad(target) levy = categorize[level] zet = ((th.sqrt(th.sum(input * input, dim=-1) + 1))) inner = (th.sum(input * position_all[levy[target.data]], dim=-1)) return th.sum( self.ruler( th.clamp( zet * position_all_zet[categorize[level][target.data]] - inner, min=1 + eps).to(device)))
def forward(self, output, target): _assert_no_grad(target) delta_out = (output - output.mean(0, keepdim=True).expand_as(output)) delta_target = (target - target.mean(0, keepdim=True).expand_as(target)) var_out = delta_out.pow(2).mean(0, keepdim=True) var_target = delta_target.pow(2).mean(0, keepdim=True) corrs = (delta_out * delta_target).sum(0, keepdim=True) / ( (var_out + self.eps) * (var_target + self.eps)).sqrt() return corrs, delta_out.size(0)
def forward(self, input, target, weight): _assert_no_grad(target) """ Weighted Focal Loss """ if not (target.size() == input.size()): raise ValueError( "Target size ({}) must be the same as input size ({})".format( target.size(), input.size())) loss = self.focal_loss(input, target, weight) return loss
def forward(self, input, target): _assert_no_grad(target) if not (target.size() == input.size()): raise ValueError( "Target size ({}) must be the same as input size ({})".format( target.size(), input.size())) if self.reduce: loss = self.dice_loss(input, target) else: loss = self.dice_loss_batch(input, target) return loss
def forward(self, input, target): Moddy._assert_no_grad(target) fst = time.time() zet = ((th.sqrt(th.sum(input * input, dim=-1) + 1))) snd = time.time() inner = (th.sum(input * position[target.data], dim=-1)) trd = time.time() resulty = th.sum( self.ruler( th.clamp(zet * position_zet[target.data] - inner, min=1).cuda())) fth = time.time() return resulty, fst, snd, trd, fth
def forward(self, input, target, weight): _assert_no_grad(target) """ Weighted binary classification loss + Dice coefficient loss """ if not (target.size() == input.size()): raise ValueError( "Target size ({}) must be the same as input size ({})".format( target.size(), input.size())) loss1 = self.focal_loss(input, target, weight) loss2 = self.dice_loss(input, target) return loss1, loss2
def forward(self, input, target, size_average=True, reduce = True): _assert_no_grad(target) input = input.double() target = target.double() # self.weight_matrix = weight_matrix.double() l = torch.mm((input - target)**2, self.weight_matrix) if not self.reduce: return l return torch.mean(l) if self.size_average else torch.sum(l)
def forward(self, input, target, weights=None): _assert_no_grad(target) if weights is not None: out = F.mse_loss(input, target, size_average=self.size_average, reduce=self.average) if self.sum_weight: out = torch.sum( out * weights) / (torch.sum(weights * target) + .0001) return out else: out = F.mse_loss(input, target, size_average=self.size_average) return out
def forward(self, input, target): input = (input + 1) / 2.0 * 4095.0 target = (target + 1) / 2.0 * 4095.0 loss._assert_no_grad(target) abs_diff = torch.abs(target - input) relative_abs_diff = abs_diff / (target + np.finfo(float).eps) rel_mae = torch.mean(relative_abs_diff) #from eval: # compute MRAE # diff = gt - rc # abs_diff = np.abs(diff) # relative_abs_diff = np.divide(abs_diff, gt + np.finfo(float).eps) # added epsilon to avoid division by zero. # MRAEs[f] = np.mean(relative_abs_diff) return rel_mae
def forward(self, input, target, level): Moddy._assert_no_grad(target) levy = categorize[level] zet = ((th.sqrt(th.sum(input * input, dim=-1) + 1))) inner = (th.sum(input * position_all[levy[target.data]], dim=-1)) resulty = (self.ruler( th.clamp(zet * position_all_zet[categorize[level][target.data]] - inner, min=1 + eps)).cuda()) for i, tf in enumerate(th.isnan(resulty)): if tf: print 'Target : ' print position_all[levy[target.data[i]]] print 'Output : ' print input[i] return th.sum(resulty)
def forward(self, input, target): _assert_no_grad(target) # if a pixel's probability > 0.5, then assume it is true since labels might be noisy input = self.flatten_images(input) target = self.flatten_images(target) weights = torch.where( target > 0, torch.ones_like(target) * self.words_weight, # words are 1 torch.ones_like(target) * self.background_weight) bootstrap_target = self.beta * target + (1 - self.beta) * ( F.sigmoid(input) > 0.5).float() return F.binary_cross_entropy_with_logits( input, bootstrap_target, weight=weights, size_average=self.size_average, reduce=self.reduce)
def forward(self, input, target): loss._assert_no_grad(target) n = input.data.shape[0] representation_vector_length = input[0].data.shape[0] # we should sum up distances for all pairs of inputs result = 0.0 for i in range(n - 1): distances_i = self.get_distances_i(i, input, n, representation_vector_length) result = self.get_result_i(self, i, distances_i, target, result, n) #print('result ', result, 'i = ', i) if self.size_average: #result = torch.mean(result).cuda() result = torch.div(result, float(n)) return result
def forward(self, input, target): # LongTensor,FloatTensor=type(target.data),type(input) if torch.cuda.is_available(): LongTensor, FloatTensor = torch.cuda.LongTensor, torch.cuda.FloatTensor _assert_no_grad(target) # prob = F.softmax(input, dim=1) m = torch.distributions.Categorical(prob) sel2 = m.sample().type(LongTensor) # replacement = True rewards = ((target.view(sel2.size()) == sel2) > 0).type(FloatTensor) rewards[rewards == 1] = self.correct_reward rewards[rewards == 0] = self.incorrect_pentality if self.normalize == True: self.meanreward = rewards.mean() rewards = (rewards - self.meanreward) / ( rewards.std() + float(np.finfo(np.float32).eps)) loss = -m.log_prob(sel2) * rewards return loss.mean()
def forward(self, input, target): _assert_no_grad(target) fy = input[range(target.size()[0]), target] fj = input aj = fj - fy.view(-1, 1) if self.k != 1: aj[range(target.size()[0]), target] = np.inf #set positions where the target is to infinity to avoid select them among the smalles m-k components aj = aj.topk(aj.shape[1] - self.k, largest=False)[0] #select the smallest m-k components loss = torch.log(1 + torch.exp(aj).sum(1)) if self.reduce: if self.size_average: loss = loss.mean() else: loss = loss.sum() return loss
def forward(self, input, target, mask=None): _assert_no_grad(target) mean1 = F.conv2d(input, self.weight, padding=self.size, groups=self.in_channels) mean2 = F.conv2d(target, self.weight, padding=self.size, groups=self.in_channels) mean1_sq = mean1 * mean1 mean2_sq = mean2 * mean2 mean_12 = mean1 * mean2 sigma1_sq = F.conv2d(input * input, self.weight, padding=self.size, groups=self.in_channels) - mean1_sq sigma2_sq = F.conv2d(target * target, self.weight, padding=self.size, groups=self.in_channels) - mean2_sq sigma_12 = F.conv2d(input * target, self.weight, padding=self.size, groups=self.in_channels) - mean_12 C1 = 0.01**2 C2 = 0.03**2 ssim = ((2 * mean_12 + C1) * (2 * sigma_12 + C2)) / ((mean1_sq + mean2_sq + C1) * (sigma1_sq + sigma2_sq + C2)) if self.size_average: out = 1 - ssim.mean() else: out = 1 - ssim.view(ssim.size(0), -1).mean(1) return out
def my_warpctc(acts, labels, act_lens, label_lens, size_average=False): """Chainer like CTC Loss acts: Tensor of (seqLength x batch x outputDim) containing output from network labels: 1 dimensional Tensor containing all the targets of the batch in one sequence act_lens: Tensor of size (batch) containing size of each output sequence from the network act_lens: Tensor of (batch) containing label length of each example """ assert len(labels.size()) == 1 # labels must be 1 dimensional _assert_no_grad(labels) _assert_no_grad(act_lens) _assert_no_grad(label_lens) return _CTC.apply(acts, labels, act_lens, label_lens, size_average)
def forward(self, acts, labels, act_lens, label_lens): """ acts: Tensor of (seqLength x batch x outputDim) containing output from network labels: 1 dimensional Tensor containing all the targets of the batch in one sequence act_lens: Tensor of size (batch) containing size of each output sequence from the network act_lens: Tensor of (batch) containing label length of each example """ assert len(labels.size()) == 1 # labels must be 1 dimensional _assert_no_grad(labels) _assert_no_grad(act_lens) _assert_no_grad(label_lens) return self.ctc(acts, labels, act_lens, label_lens, self.size_average)
def chainer_like_ctc_loss(acts, labels, act_lens, label_lens): """Chainer like CTC Loss acts: Tensor of (seqLength x batch x outputDim) containing output from network labels: 1 dimensional Tensor containing all the targets of the batch in one sequence act_lens: Tensor of size (batch) containing size of each output sequence from the network act_lens: Tensor of (batch) containing label length of each example """ assert len(labels.size()) == 1 # labels must be 1 dimensional from torch.nn.modules.loss import _assert_no_grad _assert_no_grad(labels) _assert_no_grad(act_lens) _assert_no_grad(label_lens) return _ChainerLikeCTC.apply(acts, labels, act_lens, label_lens)
def forward(self, input, target, weight): _assert_no_grad(target) return F.binary_cross_entropy(input, target, weight, self.size_average, self.reduce)
def forward(self, input, target, weight): _assert_no_grad(target) return self.weighted_mse_loss(input, target, weight)
def forward(self, input, target, level): Moddy._assert_no_grad(target) diff = input - position_all[categorize[level][target.data]] return th.sum(diff * diff)
def forward(self, input, target): _assert_no_grad(target) return dice_coefficient(input, target, smooth=self.smooth)
def forward(self, input, target): _assert_no_grad(target) return dice_loss(input, target, optimize_bg=self.optimize_bg, weight=self.weight, smooth=self.smooth, size_average=self.size_average, reduce=self.reduce)
def forward(self, input, target, n_objects, max_n_objects): _assert_no_grad(target) return discriminative_loss(input, target, n_objects, max_n_objects, self.delta_var, self.delta_dist, self.norm, self.usegpu)