Python torch.sin() Examples
The following are 30
code examples of torch.sin().
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: pairwise.py From pykg2vec with MIT License | 6 votes |
def embed(self, h, r, t): """Function to get the embedding value. Args: h (Tensor): Head entities ids. r (Tensor): Relation ids of the triple. t (Tensor): Tail entity ids of the triple. Returns: Tensors: Returns real and imaginary values of head, relation and tail embedding. """ pi = 3.14159265358979323846 h_e_r = self.ent_embeddings(h) h_e_i = self.ent_embeddings_imag(h) r_e_r = self.rel_embeddings(r) t_e_r = self.ent_embeddings(t) t_e_i = self.ent_embeddings_imag(t) r_e_r = r_e_r / (self.embedding_range / pi) r_e_i = torch.sin(r_e_r) r_e_r = torch.cos(r_e_r) return h_e_r, h_e_i, r_e_r, r_e_i, t_e_r, t_e_i
Example #2
Source File: common.py From decaNLP with BSD 3-Clause "New" or "Revised" License | 6 votes |
def positional_encodings_like(x, t=None): if t is None: positions = torch.arange(0., x.size(1)) if x.is_cuda: positions = positions.cuda(x.get_device()) else: positions = t encodings = torch.zeros(*x.size()[1:]) if x.is_cuda: encodings = encodings.cuda(x.get_device()) for channel in range(x.size(-1)): if channel % 2 == 0: encodings[:, channel] = torch.sin( positions / 10000 ** (channel / x.size(2))) else: encodings[:, channel] = torch.cos( positions / 10000 ** ((channel - 1) / x.size(2))) return Variable(encodings) # torch.matmul can't do (4, 3, 2) @ (4, 2) -> (4, 3)
Example #3
Source File: sinusoidal_positional_embedding.py From crosentgec with GNU General Public License v3.0 | 6 votes |
def get_embedding(num_embeddings, embedding_dim, padding_idx=None): """Build sinusoidal embeddings. This matches the implementation in tensor2tensor, but differs slightly from the description in Section 3.5 of "Attention Is All You Need". """ half_dim = embedding_dim // 2 emb = math.log(10000) / (half_dim - 1) emb = torch.exp(torch.arange(half_dim, dtype=torch.float) * -emb) emb = torch.arange(num_embeddings, dtype=torch.float).unsqueeze(1) * emb.unsqueeze(0) emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1).view(num_embeddings, -1) if embedding_dim % 2 == 1: # zero pad emb = torch.cat([emb, torch.zeros(num_embeddings, 1)], dim=1) if padding_idx is not None: emb[padding_idx, :] = 0 return emb
Example #4
Source File: functional_cpu_test.py From audio with BSD 2-Clause "Simplified" License | 6 votes |
def _test_istft_of_sine(self, amplitude, L, n): # stft of amplitude*sin(2*pi/L*n*x) with the hop length and window size equaling L x = torch.arange(2 * L + 1, dtype=torch.get_default_dtype()) sound = amplitude * torch.sin(2 * math.pi / L * x * n) # stft = torch.stft(sound, L, hop_length=L, win_length=L, # window=torch.ones(L), center=False, normalized=False) stft = torch.zeros((L // 2 + 1, 2, 2)) stft_largest_val = (amplitude * L) / 2.0 if n < stft.size(0): stft[n, :, 1] = -stft_largest_val if 0 <= L - n < stft.size(0): # symmetric about L // 2 stft[L - n, :, 1] = stft_largest_val estimate = torchaudio.functional.istft(stft, L, hop_length=L, win_length=L, window=torch.ones(L), center=False, normalized=False) # There is a larger error due to the scaling of amplitude _compare_estimate(sound, estimate, atol=1e-3)
Example #5
Source File: test_compliance_kaldi.py From audio with BSD 2-Clause "Simplified" License | 6 votes |
def _create_data_set(self): # used to generate the dataset to test on. this is not used in testing (offline procedure) test_filepath = common_utils.get_asset_path('kaldi_file.wav') sr = 16000 x = torch.arange(0, 20).float() # between [-6,6] y = torch.cos(2 * math.pi * x) + 3 * torch.sin(math.pi * x) + 2 * torch.cos(x) # between [-2^30, 2^30] y = (y / 6 * (1 << 30)).long() # clear the last 16 bits because they aren't used anyways y = ((y >> 16) << 16).float() torchaudio.save(test_filepath, y, sr) sound, sample_rate = torchaudio.load(test_filepath, normalization=False) print(y >> 16) self.assertTrue(sample_rate == sr) torch.testing.assert_allclose(y, sound)
Example #6
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 #7
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 #8
Source File: Transformer.py From ConvLab with MIT License | 6 votes |
def get_sinusoid_encoding_table(n_position, d_hid, padding_idx=None): ''' Sinusoid position encoding table ''' def cal_angle(position, hid_idx): return position / np.power(10000, 2 * (hid_idx // 2) / d_hid) def get_posi_angle_vec(position): return [cal_angle(position, hid_j) for hid_j in range(d_hid)] sinusoid_table = np.array([get_posi_angle_vec(pos_i) for pos_i in range(n_position)]) sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2]) # dim 2i sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2]) # dim 2i+1 if padding_idx is not None: # zero vector for padding dimension sinusoid_table[padding_idx] = 0. return torch.FloatTensor(sinusoid_table)
Example #9
Source File: gridgen.py From cascade-rcnn_Pytorch with MIT License | 6 votes |
def __init__(self, height, width, lr = 1, aux_loss = False): super(Depth3DGridGen, self).__init__() self.height, self.width = height, width self.aux_loss = aux_loss self.lr = lr self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) self.grid[:,:,2] = np.ones([self.height, width]) self.grid = torch.from_numpy(self.grid.astype(np.float32)) self.theta = self.grid[:,:,0] * np.pi/2 + np.pi/2 self.phi = self.grid[:,:,1] * np.pi self.x = torch.sin(self.theta) * torch.cos(self.phi) self.y = torch.sin(self.theta) * torch.sin(self.phi) self.z = torch.cos(self.theta) self.grid3d = torch.from_numpy(np.zeros( [self.height, self.width, 4], dtype=np.float32)) self.grid3d[:,:,0] = self.x self.grid3d[:,:,1] = self.y self.grid3d[:,:,2] = self.z self.grid3d[:,:,3] = self.grid[:,:,2]
Example #10
Source File: gridgen.py From cascade-rcnn_Pytorch with MIT License | 6 votes |
def __init__(self, height, width, lr = 1, aux_loss = False): super(DenseAffine3DGridGen_rotate, self).__init__() self.height, self.width = height, width self.aux_loss = aux_loss self.lr = lr self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) self.grid[:,:,2] = np.ones([self.height, width]) self.grid = torch.from_numpy(self.grid.astype(np.float32)) self.theta = self.grid[:,:,0] * np.pi/2 + np.pi/2 self.phi = self.grid[:,:,1] * np.pi self.x = torch.sin(self.theta) * torch.cos(self.phi) self.y = torch.sin(self.theta) * torch.sin(self.phi) self.z = torch.cos(self.theta) self.grid3d = torch.from_numpy(np.zeros( [self.height, self.width, 4], dtype=np.float32)) self.grid3d[:,:,0] = self.x self.grid3d[:,:,1] = self.y self.grid3d[:,:,2] = self.z self.grid3d[:,:,3] = self.grid[:,:,2]
Example #11
Source File: gridgen.py From cascade-rcnn_Pytorch with MIT License | 6 votes |
def __init__(self, height, width, lr = 1, aux_loss = False): super(DenseAffine3DGridGen, self).__init__() self.height, self.width = height, width self.aux_loss = aux_loss self.lr = lr self.grid = np.zeros( [self.height, self.width, 3], dtype=np.float32) self.grid[:,:,0] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.height), 0), repeats = self.width, axis = 0).T, 0) self.grid[:,:,1] = np.expand_dims(np.repeat(np.expand_dims(np.arange(-1, 1, 2.0/self.width), 0), repeats = self.height, axis = 0), 0) self.grid[:,:,2] = np.ones([self.height, width]) self.grid = torch.from_numpy(self.grid.astype(np.float32)) self.theta = self.grid[:,:,0] * np.pi/2 + np.pi/2 self.phi = self.grid[:,:,1] * np.pi self.x = torch.sin(self.theta) * torch.cos(self.phi) self.y = torch.sin(self.theta) * torch.sin(self.phi) self.z = torch.cos(self.theta) self.grid3d = torch.from_numpy(np.zeros( [self.height, self.width, 4], dtype=np.float32)) self.grid3d[:,:,0] = self.x self.grid3d[:,:,1] = self.y self.grid3d[:,:,2] = self.z self.grid3d[:,:,3] = self.grid[:,:,2]
Example #12
Source File: sinusoidal_positional_embedding.py From fairseq with MIT License | 6 votes |
def get_embedding( num_embeddings: int, embedding_dim: int, padding_idx: Optional[int] = None ): """Build sinusoidal embeddings. This matches the implementation in tensor2tensor, but differs slightly from the description in Section 3.5 of "Attention Is All You Need". """ half_dim = embedding_dim // 2 emb = math.log(10000) / (half_dim - 1) emb = torch.exp(torch.arange(half_dim, dtype=torch.float) * -emb) emb = torch.arange(num_embeddings, dtype=torch.float).unsqueeze( 1 ) * emb.unsqueeze(0) emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1).view( num_embeddings, -1 ) if embedding_dim % 2 == 1: # zero pad emb = torch.cat([emb, torch.zeros(num_embeddings, 1)], dim=1) if padding_idx is not None: emb[padding_idx, :] = 0 return emb
Example #13
Source File: modules.py From pase with MIT License | 5 votes |
def sinc(band,t_right, cuda=False): y_right= torch.sin(2*math.pi*band*t_right)/(2*math.pi*band*t_right) y_left= flip(y_right,0) ones = torch.ones(1) if cuda: ones = ones.to('cuda') y=torch.cat([y_left, ones, y_right]) return y # Modified from https://github.com/mravanelli/SincNet
Example #14
Source File: neural_networks.py From pase with MIT License | 5 votes |
def sinc(self, x): # Numerically stable definition x_left=x[:,0:int((x.shape[1]-1)/2)] y_left=torch.sin(x_left) / x_left y_right= torch.flip(y_left,dims=[1]) sinc=torch.cat([y_left,torch.ones([x.shape[0],1]).to(x.device),y_right],dim=1) return sinc
Example #15
Source File: neural_networks.py From pase with MIT License | 5 votes |
def forward(self, waveforms): """ Parameters ---------- waveforms : `torch.Tensor` (batch_size, 1, n_samples) Batch of waveforms. Returns ------- features : `torch.Tensor` (batch_size, out_channels, n_samples_out) Batch of sinc filters activations. """ self.n_ = self.n_.to(waveforms.device) self.window_ = self.window_.to(waveforms.device) low = self.min_low_hz + torch.abs(self.low_hz_) high = torch.clamp(low + self.min_band_hz + torch.abs(self.band_hz_),self.min_low_hz,self.sample_rate/2) band=(high-low)[:,0] f_times_t_low = torch.matmul(low, self.n_) f_times_t_high = torch.matmul(high, self.n_) band_pass_left=((torch.sin(f_times_t_high)-torch.sin(f_times_t_low))/(self.n_/2))*self.window_ # Equivalent of Eq.4 of the reference paper (SPEAKER RECOGNITION FROM RAW WAVEFORM WITH SINCNET). I just have expanded the sinc and simplified the terms. This way I avoid several useless computations. band_pass_center = 2*band.view(-1,1) band_pass_right= torch.flip(band_pass_left,dims=[1]) band_pass=torch.cat([band_pass_left,band_pass_center,band_pass_right],dim=1) band_pass = band_pass / (2*band[:,None]) self.filters = (band_pass).view( self.out_channels, 1, self.kernel_size) return F.conv1d(waveforms, self.filters, stride=self.stride, padding=self.padding, dilation=self.dilation, bias=None, groups=1)
Example #16
Source File: neural_networks.py From pase with MIT License | 5 votes |
def sinc(self, x): # Numerically stable definition x_left=x[:,0:int((x.shape[1]-1)/2)] y_left=torch.sin(x_left) / x_left y_right= torch.flip(y_left,dims=[1]) sinc=torch.cat([y_left,torch.ones([x.shape[0],1]).to(x.device),y_right],dim=1) return sinc
Example #17
Source File: model2.py From controllable-text-attribute-transfer with Apache License 2.0 | 5 votes |
def __init__(self, d_model, dropout, max_len=5000): super(PositionalEncoding, self).__init__() self.dropout = nn.Dropout(p=dropout) # Compute the positional encodings once in log space. pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(0) self.register_buffer('pe', pe)
Example #18
Source File: Embeddings.py From video-caption-openNMT.pytorch with MIT License | 5 votes |
def __init__(self, dropout, dim, max_len=5000): pe = torch.zeros(max_len, dim) position = torch.arange(0, max_len).unsqueeze(1) div_term = torch.exp(torch.arange(0, dim, 2) * -(math.log(10000.0) / dim)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(1) super(PositionalEncoding, self).__init__() self.register_buffer('pe', pe) self.dropout = nn.Dropout(p=dropout) self.dim = dim
Example #19
Source File: sphere.py From geoopt with Apache License 2.0 | 5 votes |
def expmap(self, x: torch.Tensor, u: torch.Tensor) -> torch.Tensor: norm_u = u.norm(dim=-1, keepdim=True) exp = x * torch.cos(norm_u) + u * torch.sin(norm_u) / norm_u retr = self.projx(x + u) cond = norm_u > EPS[norm_u.dtype] return torch.where(cond, exp, retr)
Example #20
Source File: embedding.py From dgl with Apache License 2.0 | 5 votes |
def __init__(self, dim_model, dropout, max_len=5000): super(PositionalEncoding, self).__init__() self.dropout = nn.Dropout(p=dropout) # Compute the positional encodings once in log space. pe = th.zeros(max_len, dim_model, dtype=th.float) position = th.arange(0, max_len, dtype=th.float).unsqueeze(1) div_term = th.exp(th.arange(0, dim_model, 2, dtype=th.float) * -(np.log(10000.0) / dim_model)) pe[:, 0::2] = th.sin(position * div_term) pe[:, 1::2] = th.cos(position * div_term) pe = pe.unsqueeze(0) self.register_buffer('pe', pe) # Not a parameter but should be in state_dict
Example #21
Source File: plane.py From nsf with MIT License | 5 votes |
def _create_data(self): n = torch.sqrt(torch.rand(self.num_points // 2)) * 540 * (2 * np.pi) / 360 d1x = -torch.cos(n) * n + torch.rand(self.num_points // 2) * 0.5 d1y = torch.sin(n) * n + torch.rand(self.num_points // 2) * 0.5 x = torch.cat([torch.stack([d1x, d1y]).t(), torch.stack([-d1x, -d1y]).t()]) self.data = x / 3 + torch.randn_like(x) * 0.1
Example #22
Source File: plane.py From nsf with MIT License | 5 votes |
def create_circle(num_per_circle, std=0.1): u = torch.rand(num_per_circle) x1 = torch.cos(2 * np.pi * u) x2 = torch.sin(2 * np.pi * u) data = 2 * torch.stack((x1, x2)).t() data += std * torch.randn(data.shape) return data
Example #23
Source File: plane.py From nsf with MIT License | 5 votes |
def _create_data(self): x1 = torch.randn(self.num_points) x2_mean = torch.sin(5 * x1) x2_var = torch.exp(-2 * torch.ones(x1.shape)) x2 = x2_mean + x2_var ** 0.5 * torch.randn(self.num_points) self.data = torch.stack((x1, x2)).t()
Example #24
Source File: transforms_rbbox.py From AerialDetection with Apache License 2.0 | 5 votes |
def RotBox2Polys_torch(dboxes): """ :param dboxes: :return: """ cs = torch.cos(dboxes[:, 4]) ss = torch.sin(dboxes[:, 4]) w = dboxes[:, 2] - 1 h = dboxes[:, 3] - 1 x_ctr = dboxes[:, 0] y_ctr = dboxes[:, 1] x1 = x_ctr + cs * (w / 2.0) - ss * (-h / 2.0) x2 = x_ctr + cs * (w / 2.0) - ss * (h / 2.0) x3 = x_ctr + cs * (-w / 2.0) - ss * (h / 2.0) x4 = x_ctr + cs * (-w / 2.0) - ss * (-h / 2.0) y1 = y_ctr + ss * (w / 2.0) + cs * (-h / 2.0) y2 = y_ctr + ss * (w / 2.0) + cs * (h / 2.0) y3 = y_ctr + ss * (-w / 2.0) + cs * (h / 2.0) y4 = y_ctr + ss * (-w / 2.0) + cs * (-h / 2.0) polys = torch.cat((x1.unsqueeze(1), y1.unsqueeze(1), x2.unsqueeze(1), y2.unsqueeze(1), x3.unsqueeze(1), y3.unsqueeze(1), x4.unsqueeze(1), y4.unsqueeze(1)), 1) return polys
Example #25
Source File: transforms_rbbox.py From AerialDetection with Apache License 2.0 | 5 votes |
def RotBox2Polys(dboxes): """ :param dboxes: (x_ctr, y_ctr, w, h, angle) (numboxes, 5) :return: quadranlges: (numboxes, 8) """ cs = np.cos(dboxes[:, 4]) ss = np.sin(dboxes[:, 4]) w = dboxes[:, 2] - 1 h = dboxes[:, 3] - 1 ## change the order to be the initial definition x_ctr = dboxes[:, 0] y_ctr = dboxes[:, 1] x1 = x_ctr + cs * (w / 2.0) - ss * (-h / 2.0) x2 = x_ctr + cs * (w / 2.0) - ss * (h / 2.0) x3 = x_ctr + cs * (-w / 2.0) - ss * (h / 2.0) x4 = x_ctr + cs * (-w / 2.0) - ss * (-h / 2.0) y1 = y_ctr + ss * (w / 2.0) + cs * (-h / 2.0) y2 = y_ctr + ss * (w / 2.0) + cs * (h / 2.0) y3 = y_ctr + ss * (-w / 2.0) + cs * (h / 2.0) y4 = y_ctr + ss * (-w / 2.0) + cs * (-h / 2.0) x1 = x1[:, np.newaxis] y1 = y1[:, np.newaxis] x2 = x2[:, np.newaxis] y2 = y2[:, np.newaxis] x3 = x3[:, np.newaxis] y3 = y3[:, np.newaxis] x4 = x4[:, np.newaxis] y4 = y4[:, np.newaxis] polys = np.concatenate((x1, y1, x2, y2, x3, y3, x4, y4), axis=1) return polys
Example #26
Source File: transforms_rbbox.py From AerialDetection with Apache License 2.0 | 5 votes |
def dbbox2delta_v3(proposals, gt, means = [0, 0, 0, 0, 0], stds=[1, 1, 1, 1, 1]): """ This version removes the module operation :param proposals: (x_ctr, y_ctr, w, h, angle) shape (n, 5) :param gt: (x_ctr, y_ctr, w, h, angle) :param means: :param stds: :return: encoded targets: shape (n, 5) """ proposals = proposals.float() gt = gt.float() gt_widths = gt[..., 2] gt_heights = gt[..., 3] gt_angle = gt[..., 4] proposals_widths = proposals[..., 2] proposals_heights = proposals[..., 3] proposals_angle = proposals[..., 4] coord = gt[..., 0:2] - proposals[..., 0:2] dx = (torch.cos(proposals[..., 4]) * coord[..., 0] + torch.sin(proposals[..., 4]) * coord[..., 1]) / proposals_widths dy = (-torch.sin(proposals[..., 4]) * coord[..., 0] + torch.cos(proposals[..., 4]) * coord[..., 1]) / proposals_heights dw = torch.log(gt_widths / proposals_widths) dh = torch.log(gt_heights / proposals_heights) # import pdb # print('in dbbox2delta v3') # pdb.set_trace() # dangle = (gt_angle - proposals_angle) % (2 * math.pi) / (2 * math.pi) # TODO: debug for it, proposals_angle are -1.5708, gt_angle should close to -1.57, actully they close to 5.0153 dangle = gt_angle - proposals_angle deltas = torch.stack((dx, dy, dw, dh, dangle), -1) means = deltas.new_tensor(means).unsqueeze(0) stds = deltas.new_tensor(stds).unsqueeze(0) deltas = deltas.sub_(means).div_(stds) return deltas
Example #27
Source File: transforms_rbbox.py From AerialDetection with Apache License 2.0 | 5 votes |
def dbbox2delta(proposals, gt, means = [0, 0, 0, 0, 0], stds=[1, 1, 1, 1, 1]): """ :param proposals: (x_ctr, y_ctr, w, h, angle) shape (n, 5) :param gt: (x_ctr, y_ctr, w, h, angle) :param means: :param stds: :return: encoded targets: shape (n, 5) """ proposals = proposals.float() gt = gt.float() gt_widths = gt[..., 2] gt_heights = gt[..., 3] gt_angle = gt[..., 4] proposals_widths = proposals[..., 2] proposals_heights = proposals[..., 3] proposals_angle = proposals[..., 4] coord = gt[..., 0:2] - proposals[..., 0:2] dx = (torch.cos(proposals[..., 4]) * coord[..., 0] + torch.sin(proposals[..., 4]) * coord[..., 1]) / proposals_widths dy = (-torch.sin(proposals[..., 4]) * coord[..., 0] + torch.cos(proposals[..., 4]) * coord[..., 1]) / proposals_heights dw = torch.log(gt_widths / proposals_widths) dh = torch.log(gt_heights / proposals_heights) dangle = (gt_angle - proposals_angle) % (2 * math.pi) / (2 * math.pi) deltas = torch.stack((dx, dy, dw, dh, dangle), -1) means = deltas.new_tensor(means).unsqueeze(0) stds = deltas.new_tensor(stds).unsqueeze(0) deltas = deltas.sub_(means).div_(stds) # TODO: expand bbox regression return deltas
Example #28
Source File: utils.py From blow with Apache License 2.0 | 5 votes |
def get_timecode(dim,t,tframe,size=None,maxlen=10000,collapse=False): if size is None: size=tframe n=t.float().view(-1,1,1)+torch.linspace(0,tframe-1,steps=size).view(1,1,-1).to(t.device) f=(10**(torch.arange(1,dim+1).float()/dim)).view(1,-1,1).to(t.device) tc=torch.sin(TWOPI*f*n/maxlen) if collapse: tc=tc.mean(1).unsqueeze(1) return tc
Example #29
Source File: annotated_attention.py From Character-Level-Language-Modeling-with-Deeper-Self-Attention-pytorch with MIT License | 5 votes |
def __init__(self, d_model, dropout, max_len=5000): super(PositionalEncoding, self).__init__() self.dropout = nn.Dropout(p=dropout) # Compute the positional encodings once in log space. pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) pe = pe.unsqueeze(0) self.register_buffer('pe', pe)
Example #30
Source File: box_util.py From H3DNet with MIT License | 5 votes |
def rotz_batch_pytorch(t): """Rotation about the y-axis. t: (x1,x2,...xn) return: (x1,x2,...,xn,3,3) """ input_shape = t.shape output = torch.zeros(tuple(list(input_shape)+[3,3])).cuda() c = torch.cos(t) s = torch.sin(t) output[...,0,0] = c output[...,0,1] = -s output[...,1,0] = s output[...,1,1] = c output[...,2,2] = 1 return output