Python torch.pow() Examples
The following are 30
code examples of torch.pow().
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: transforms.py From audio with BSD 2-Clause "Simplified" License | 6 votes |
def _fade_in(self, waveform_length: int) -> Tensor: fade = torch.linspace(0, 1, self.fade_in_len) ones = torch.ones(waveform_length - self.fade_in_len) if self.fade_shape == "linear": fade = fade if self.fade_shape == "exponential": fade = torch.pow(2, (fade - 1)) * fade if self.fade_shape == "logarithmic": fade = torch.log10(.1 + fade) + 1 if self.fade_shape == "quarter_sine": fade = torch.sin(fade * math.pi / 2) if self.fade_shape == "half_sine": fade = torch.sin(fade * math.pi - math.pi / 2) / 2 + 0.5 return torch.cat((fade, ones)).clamp_(0, 1)
Example #2
Source File: evaluators.py From Dispersion-based-Clustering with MIT License | 6 votes |
def pairwise_distance(features, query=None, gallery=None, metric=None): if query is None and gallery is None: n = len(features) x = torch.cat(list(features.values())) x = x.view(n, -1) if metric is not None: x = metric.transform(x) dist = torch.pow(x, 2).sum(dim=1, keepdim=True) * 2 dist = dist.expand(n, n) - 2 * torch.mm(x, x.t()) return dist x = torch.cat([features["".join(f)].unsqueeze(0) for f, _, _, _ in query], 0) y = torch.cat([features["".join(f)].unsqueeze(0) for f, _, _, _ in gallery], 0) m, n = x.size(0), y.size(0) x = x.view(m, -1) y = y.view(n, -1) if metric is not None: x = metric.transform(x) y = metric.transform(y) dist = torch.pow(x, 2).sum(dim=1, keepdim=True).expand(m, n) + \ torch.pow(y, 2).sum(dim=1, keepdim=True).expand(n, m).t() dist.addmm_(1, -2, x, y.t()) return dist
Example #3
Source File: utils.py From conv-social-pooling with MIT License | 6 votes |
def maskedNLL(y_pred, y_gt, mask): acc = torch.zeros_like(mask) muX = y_pred[:,:,0] muY = y_pred[:,:,1] sigX = y_pred[:,:,2] sigY = y_pred[:,:,3] rho = y_pred[:,:,4] ohr = torch.pow(1-torch.pow(rho,2),-0.5) x = y_gt[:,:, 0] y = y_gt[:,:, 1] # If we represent likelihood in feet^(-1): out = 0.5*torch.pow(ohr, 2)*(torch.pow(sigX, 2)*torch.pow(x-muX, 2) + torch.pow(sigY, 2)*torch.pow(y-muY, 2) - 2*rho*torch.pow(sigX, 1)*torch.pow(sigY, 1)*(x-muX)*(y-muY)) - torch.log(sigX*sigY*ohr) + 1.8379 # If we represent likelihood in m^(-1): # out = 0.5 * torch.pow(ohr, 2) * (torch.pow(sigX, 2) * torch.pow(x - muX, 2) + torch.pow(sigY, 2) * torch.pow(y - muY, 2) - 2 * rho * torch.pow(sigX, 1) * torch.pow(sigY, 1) * (x - muX) * (y - muY)) - torch.log(sigX * sigY * ohr) + 1.8379 - 0.5160 acc[:,:,0] = out acc[:,:,1] = out acc = acc*mask lossVal = torch.sum(acc)/torch.sum(mask) return lossVal ## NLL for sequence, outputs sequence of NLL values for each time-step, uses mask for variable output lengths, used for evaluation
Example #4
Source File: losses.py From EfficientDet-PyTorch with Apache License 2.0 | 6 votes |
def focal_loss(self, x, y): '''Focal loss. Args: x: (tensor) sized [N,D]. y: (tensor) sized [N,]. Return: (tensor) focal loss. ''' alpha = 0.25 gamma = 2 t = F.one_hot(y.data, 1+self.num_classes) # [N,21] t = t[:,1:] # exclude background t = Variable(t) p = x.sigmoid() pt = p*t + (1-p)*(1-t) # pt = p if t > 0 else 1-p w = alpha*t + (1-alpha)*(1-t) # w = alpha if t > 0 else 1-alpha w = w * (1-pt).pow(gamma) return F.binary_cross_entropy_with_logits(x, t, w, reduction='sum')
Example #5
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 #6
Source File: smooth_l1_loss.py From Parsing-R-CNN with MIT License | 6 votes |
def smooth_l1_loss_LW(bbox_pred, bbox_targets, bbox_inside_weights, bbox_outside_weights, beta=1.0): """ SmoothL1(x) = 0.5 * x^2 / beta if |x| < beta |x| - 0.5 * beta otherwise. 1 / N * sum_i alpha_out[i] * SmoothL1(alpha_in[i] * (y_hat[i] - y[i])). N is the number of batch elements in the input predictions """ box_diff = bbox_pred - bbox_targets in_box_diff = bbox_inside_weights * box_diff abs_in_box_diff = torch.abs(in_box_diff) smoothL1_sign = (abs_in_box_diff < beta).detach().float() in_loss_box = smoothL1_sign * 0.5 * torch.pow(in_box_diff, 2) / beta + \ (1 - smoothL1_sign) * (abs_in_box_diff - (0.5 * beta)) out_loss_box = bbox_outside_weights * in_loss_box loss_box = out_loss_box N = loss_box.size(0) # batch size loss_box = loss_box.view(-1).sum(0) / N return loss_box
Example #7
Source File: functional.py From audio with BSD 2-Clause "Simplified" License | 6 votes |
def DB_to_amplitude( x: Tensor, ref: float, power: float ) -> Tensor: r"""Turn a tensor from the decibel scale to the power/amplitude scale. Args: x (Tensor): Input tensor before being converted to power/amplitude scale. ref (float): Reference which the output will be scaled by. power (float): If power equals 1, will compute DB to power. If 0.5, will compute DB to amplitude. Returns: Tensor: Output tensor in power/amplitude scale. """ return ref * torch.pow(torch.pow(10.0, 0.1 * x), power)
Example #8
Source File: transforms.py From audio with BSD 2-Clause "Simplified" License | 6 votes |
def _fade_out(self, waveform_length: int) -> Tensor: fade = torch.linspace(0, 1, self.fade_out_len) ones = torch.ones(waveform_length - self.fade_out_len) if self.fade_shape == "linear": fade = - fade + 1 if self.fade_shape == "exponential": fade = torch.pow(2, - fade) * (1 - fade) if self.fade_shape == "logarithmic": fade = torch.log10(1.1 - fade) + 1 if self.fade_shape == "quarter_sine": fade = torch.sin(fade * math.pi / 2 + math.pi / 2) if self.fade_shape == "half_sine": fade = torch.sin(fade * math.pi + math.pi / 2) / 2 + 0.5 return torch.cat((ones, fade)).clamp_(0, 1)
Example #9
Source File: identifier.py From kaggle-humpback with BSD 2-Clause "Simplified" License | 6 votes |
def forward(self, inputs, labels): cos_th = F.linear(inputs, F.normalize(self.weight)) cos_th = cos_th.clamp(-1, 1) sin_th = torch.sqrt(1.0 - torch.pow(cos_th, 2)) cos_th_m = cos_th * self.cos_m - sin_th * self.sin_m cos_th_m = torch.where(cos_th > self.th, cos_th_m, cos_th - self.mm) cond_v = cos_th - self.th cond = cond_v <= 0 cos_th_m[cond] = (cos_th - self.mm)[cond] if labels.dim() == 1: labels = labels.unsqueeze(-1) onehot = torch.zeros(cos_th.size()).cuda() onehot.scatter_(1, labels, 1) outputs = onehot * cos_th_m + (1.0 - onehot) * cos_th outputs = outputs * self.s return outputs
Example #10
Source File: net_utils.py From cascade-rcnn_Pytorch with MIT License | 6 votes |
def _smooth_l1_loss(bbox_pred, bbox_targets, bbox_inside_weights, bbox_outside_weights, sigma=1.0, dim=[1]): sigma_2 = sigma ** 2 box_diff = bbox_pred - bbox_targets in_box_diff = bbox_inside_weights * box_diff abs_in_box_diff = torch.abs(in_box_diff) smoothL1_sign = (abs_in_box_diff < 1. / sigma_2).detach().float() in_loss_box = torch.pow(in_box_diff, 2) * (sigma_2 / 2.) * smoothL1_sign \ + (abs_in_box_diff - (0.5 / sigma_2)) * (1. - smoothL1_sign) out_loss_box = bbox_outside_weights * in_loss_box loss_box = out_loss_box s = loss_box.size(0) loss_box = loss_box.view(s, -1).sum(1).mean() # for i in sorted(dim, reverse=True): # loss_box = loss_box.sum(i) # loss_box = loss_box.mean() return loss_box
Example #11
Source File: utils.py From MusicTransformer-pytorch with MIT License | 6 votes |
def attention_image_summary(name, attn, step=0, writer=None): """Compute color image summary. Args: attn: a Tensor with shape [batch, num_heads, query_length, memory_length] image_shapes: optional tuple of integer scalars. If the query positions and memory positions represent the pixels of flattened images, then pass in their dimensions: (query_rows, query_cols, memory_rows, memory_cols). If the query positions and memory positions represent the pixels x channels of flattened images, then pass in their dimensions: (query_rows, query_cols, query_channels, memory_rows, memory_cols, memory_channels). """ num_heads = attn.size(1) # [batch, query_length, memory_length, num_heads] image = attn.permute(0, 2, 3, 1) image = torch.pow(image, 0.2) # for high-dynamic-range # Each head will correspond to one of RGB. # pad the heads to be a multiple of 3 image = F.pad(image, [0, -num_heads % 3, 0, 0, 0, 0, 0, 0,]) image = split_last_dimension(image, 3) image = image.max(dim=4).values grid_image = torchvision.utils.make_grid(image.permute(0, 3, 1, 2)) writer.add_image(name, grid_image, global_step=step, dataformats='CHW')
Example #12
Source File: losses.py From CornerNet-Lite-Pytorch with BSD 3-Clause "New" or "Revised" License | 6 votes |
def _focal_loss(preds, gt): pos_inds = gt.eq(1) neg_inds = gt.lt(1) neg_weights = torch.pow(1 - gt[neg_inds], 4) loss = 0 for pred in preds: pos_pred = pred[pos_inds] neg_pred = pred[neg_inds] pos_loss = torch.log(pos_pred) * torch.pow(1 - pos_pred, 2) neg_loss = torch.log(1 - neg_pred) * torch.pow(neg_pred, 2) * neg_weights num_pos = pos_inds.float().sum() pos_loss = pos_loss.sum() neg_loss = neg_loss.sum() if pos_pred.nelement() == 0: loss = loss - neg_loss else: loss = loss - (pos_loss + neg_loss) / num_pos return loss # 扫视的损失函数
Example #13
Source File: interaction.py From DeepCTR-Torch with Apache License 2.0 | 6 votes |
def __init__(self, field_size, conv_kernel_width, conv_filters, device='cpu'): super(ConvLayer, self).__init__() self.device = device module_list = [] n = int(field_size) l = len(conv_filters) filed_shape = n for i in range(1, l + 1): if i == 1: in_channels = 1 else: in_channels = conv_filters[i - 2] out_channels = conv_filters[i - 1] width = conv_kernel_width[i - 1] k = max(1, int((1 - pow(i / l, l - i)) * n)) if i < l else 3 module_list.append(Conv2dSame(in_channels=in_channels, out_channels=out_channels, kernel_size=(width, 1), stride=1).to(self.device)) module_list.append(torch.nn.Tanh().to(self.device)) # KMaxPooling, extract top_k, returns tensors values module_list.append(KMaxPooling(k=min(k, filed_shape), axis=2, device=self.device).to(self.device)) filed_shape = min(k, filed_shape) self.conv_layer = nn.Sequential(*module_list) self.to(device) self.filed_shape = filed_shape
Example #14
Source File: interaction.py From DeepCTR-Torch with Apache License 2.0 | 5 votes |
def forward(self, inputs): fm_input = inputs square_of_sum = torch.pow(torch.sum(fm_input, dim=1, keepdim=True), 2) sum_of_square = torch.sum(fm_input * fm_input, dim=1, keepdim=True) cross_term = square_of_sum - sum_of_square cross_term = 0.5 * torch.sum(cross_term, dim=2, keepdim=False) return cross_term
Example #15
Source File: modeling_bert.py From BERT-Relation-Extraction with Apache License 2.0 | 5 votes |
def gelu_new(x): """ Implementation of the gelu activation function currently in Google Bert repo (identical to OpenAI GPT). Also see https://arxiv.org/abs/1606.08415 """ return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))
Example #16
Source File: bert_models.py From G-Bert with MIT License | 5 votes |
def forward(self, x): u = x.mean(-1, keepdim=True) s = (x - u).pow(2).mean(-1, keepdim=True) x = (x - u) / torch.sqrt(s + self.variance_epsilon) return self.weight * x + self.bias
Example #17
Source File: siamese_network.py From atec-nlp with MIT License | 5 votes |
def forward(self, y, y_): # y, y_ must be same type float (*) loss = y * torch.pow(1-y_, 2) + (1 - y) * torch.pow(y_-self.margin, 2) loss = torch.sum(loss) / 2.0 / len(y) #y.size()[0] return loss
Example #18
Source File: bert_models.py From G-Bert with MIT License | 5 votes |
def gelu(x): return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))
Example #19
Source File: siamese_network.py From atec-nlp with MIT License | 5 votes |
def forward(self, x1, x2): out1 = self.embedding_net(x1) out2 = self.embedding_net(x2) # out1_norm = torch.sqrt(torch.sum(torch.pow(out1, 2), dim=1)) # out2_norm = torch.sqrt(torch.sum(torch.pow(out2, 2), dim=1)) # cosine = (out1*out2).sum(1) / (out1_norm*out2_norm) sim = F.cosine_similarity(out1, out2, dim=1) # pdist = F.pairwise_distance(out1, out2, p=2, eps=1e-06, keepdim=False) return out1, out2, sim
Example #20
Source File: losses.py From CornerNet-Lite-Pytorch with BSD 3-Clause "New" or "Revised" License | 5 votes |
def _ae_loss(tag0, tag1, mask): # squeeze去掉numpy数组里的shape中为1的维度 num = mask.sum(dim=1, keepdim=True).float() tag0 = tag0.squeeze() tag1 = tag1.squeeze() tag_mean = (tag0 + tag1) / 2 # 返回方差/n,再求和[得,我们得到了方差和] tag0 = torch.pow(tag0 - tag_mean, 2) / (num + 1e-4) tag0 = tag0[mask].sum() tag1 = torch.pow(tag1 - tag_mean, 2) / (num + 1e-4) tag1 = tag1[mask].sum() pull = tag0 + tag1 # 在第2维上[我们0开始应该是1]上增加一个维度 mask = mask.unsqueeze(1) + mask.unsqueeze(2) mask = mask.eq(2) num = num.unsqueeze(2) num2 = (num - 1) * num dist = tag_mean.unsqueeze(1) - tag_mean.unsqueeze(2) dist = 1 - torch.abs(dist) dist = nn.functional.relu(dist, inplace=True) dist = dist - 1 / (num + 1e-4) dist = dist / (num2 + 1e-4) dist = dist[mask] push = dist.sum() return pull, push
Example #21
Source File: loss.py From KAIR with MIT License | 5 votes |
def forward(self, x): batch_size = x.size()[0] h_x = x.size()[2] w_x = x.size()[3] count_h = self.tensor_size(x[:, :, 1:, :]) count_w = self.tensor_size(x[:, :, :, 1:]) h_tv = torch.pow((x[:, :, 1:, :] - x[:, :, :h_x - 1, :]), 2).sum() w_tv = torch.pow((x[:, :, :, 1:] - x[:, :, :, :w_x - 1]), 2).sum() return self.tv_loss_weight * 2 * (h_tv / count_h + w_tv / count_w) / batch_size
Example #22
Source File: network_usrnet.py From KAIR with MIT License | 5 votes |
def cabs(x): # modulus of a complex number return torch.pow(x[..., 0]**2+x[..., 1]**2, 0.5)
Example #23
Source File: utils_sisr.py From KAIR with MIT License | 5 votes |
def cabs(x): return torch.pow(x[..., 0]**2+x[..., 1]**2, 0.5)
Example #24
Source File: utils_deblur.py From KAIR with MIT License | 5 votes |
def cabs(x): return torch.pow(x[..., 0]**2+x[..., 1]**2, 0.5)
Example #25
Source File: focal_loss.py From pytorch-0.4-yolov3 with MIT License | 5 votes |
def forward(self, inputs, targets): N = inputs.size(0) print(N) C = inputs.size(1) P = F.softmax(inputs) class_mask = inputs.data.new(N, C).fill_(0) ids = targets.view(-1, 1) class_mask.scatter_(1, ids.data, 1.) #print(class_mask) 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() #print('probs size= {}'.format(probs.size())) #print(probs) batch_loss = -alpha*(torch.pow((1-probs), self.gamma))*log_p #print('-----bacth_loss------') #print(batch_loss) if self.size_average: loss = batch_loss.mean() else: loss = batch_loss.sum() return loss
Example #26
Source File: schnet.py From pytorch_geometric with MIT License | 5 votes |
def forward(self, dist): dist = dist.view(-1, 1) - self.offset.view(1, -1) return torch.exp(self.coeff * torch.pow(dist, 2))
Example #27
Source File: transformer.py From DISTRE with Apache License 2.0 | 5 votes |
def forward(self, x): u = x.mean(-1, keepdim=True) s = (x - u).pow(2).mean(-1, keepdim=True) x = (x - u) / torch.sqrt(s + self.e) return self.g * x + self.b
Example #28
Source File: transformer.py From DISTRE with Apache License 2.0 | 5 votes |
def gelu(x: torch.Tensor) -> torch.Tensor: return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))
Example #29
Source File: losses.py From CornerNet-Lite-Pytorch with BSD 3-Clause "New" or "Revised" License | 5 votes |
def _focal_loss_mask(preds, gt, mask): pos_inds = gt.eq(1) neg_inds = gt.lt(1) neg_weights = torch.pow(1 - gt[neg_inds], 4) pos_mask = mask[pos_inds] neg_mask = mask[neg_inds] loss = 0 for pred in preds: pos_pred = pred[pos_inds] neg_pred = pred[neg_inds] pos_loss = torch.log(pos_pred) * torch.pow(1 - pos_pred, 2) * pos_mask neg_loss = torch.log(1 - neg_pred) * torch.pow(neg_pred, 2) * neg_weights * neg_mask num_pos = pos_inds.float().sum() pos_loss = pos_loss.sum() neg_loss = neg_loss.sum() if pos_pred.nelement() == 0: loss = loss - neg_loss else: loss = loss - (pos_loss + neg_loss) / num_pos return loss
Example #30
Source File: scan.py From speaksee with BSD 3-Clause "New" or "Revised" License | 5 votes |
def l2norm(X, dim, eps=1e-8): """L2-normalize columns of X""" norm = (torch.pow(X, 2).sum(dim=dim, keepdim=True) + eps).sqrt() X = torch.div(X, norm) return X