Python torch.tensor() Examples
The following are 30
code examples of torch.tensor().
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: utils.py From deep-learning-note with MIT License | 6 votes |
def predict_rnn_pytorch(prefix, num_chars, model, vocab_size, device, idx_to_char, char_to_idx): state = None output = [char_to_idx[prefix[0]]] # output会记录prefix加上输出 for t in range(num_chars + len(prefix) - 1): X = torch.tensor([output[-1]], device=device).view(1, 1) if state is not None: if isinstance(state, tuple): # LSTM, state:(h, c) state = (state[0].to(device), state[1].to(device)) else: state = state.to(device) (Y, state) = model(X, state) # 前向计算不需要传入模型参数 if t < len(prefix) - 1: output.append(char_to_idx[prefix[t + 1]]) else: output.append(int(Y.argmax(dim=1).item())) return ''.join([idx_to_char[i] for i in output])
Example #2
Source File: data_loader.py From OpenNRE with MIT License | 6 votes |
def collate_fn(data): data = list(zip(*data)) label, bag_name, count = data[:3] seqs = data[3:] for i in range(len(seqs)): seqs[i] = torch.cat(seqs[i], 0) # (sumn, L) seqs[i] = seqs[i].expand((torch.cuda.device_count() if torch.cuda.device_count() > 0 else 1, ) + seqs[i].size()) scope = [] # (B, 2) start = 0 for c in count: scope.append((start, start + c)) start += c assert(start == seqs[0].size(1)) scope = torch.tensor(scope).long() label = torch.tensor(label).long() # (B) return [label, bag_name, scope] + seqs
Example #3
Source File: graphML.py From graph-neural-networks with GNU General Public License v3.0 | 6 votes |
def addGSO(self, S): # Every S has 3 dimensions. assert len(S.shape) == 3 # S is of shape E x N x N self.N = S.shape[1] assert S.shape[2] == self.N self.S = S # Change tensor S to numpy now that we have saved it as tensor in self.S S = S.cpu().numpy() # The neighborhood matrix has to be a tensor of shape # nOutputNodes x maxNeighborhoodSize neighborhood = [] maxNeighborhoodSizes = [] for k in range(1,self.K+1): # For each hop (0,1,...) in the range K thisNeighborhood = graphTools.computeNeighborhood(S, k, outputType='matrix') # compute the k-hop neighborhood neighborhood.append(torch.tensor(thisNeighborhood).to(self.S.device)) maxNeighborhoodSizes.append(thisNeighborhood.shape[1]) self.maxNeighborhoodSizes = maxNeighborhoodSizes self.neighborhood = neighborhood
Example #4
Source File: graphML.py From graph-neural-networks with GNU General Public License v3.0 | 6 votes |
def forward(self, x): # x is of shape: batchSize x dimInFeatures x numberNodesIn B = x.shape[0] F = x.shape[1] Nin = x.shape[2] # If we have less filter coefficients than the required ones, we need # to use the copying scheme if self.M == self.N: self.h = self.weight else: self.h = torch.index_select(self.weight, 4, self.copyNodes) # And now we add the zero padding if Nin < self.N: zeroPad = torch.zeros(B, F, self.N-Nin).type(x.dtype).to(x.device) x = torch.cat((x, zeroPad), dim = 2) # Compute the filter output u = NVGF(self.h, self.S, x, self.bias) # So far, u is of shape batchSize x dimOutFeatures x numberNodes # And we want to return a tensor of shape # batchSize x dimOutFeatures x numberNodesIn # since the nodes between numberNodesIn and numberNodes are not required if Nin < self.N: u = torch.index_select(u, 2, torch.arange(Nin).to(u.device)) return u
Example #5
Source File: graphML.py From graph-neural-networks with GNU General Public License v3.0 | 6 votes |
def addGSO(self, S): # Every S has 3 dimensions. assert len(S.shape) == 3 # S is of shape E x N x N self.N = S.shape[1] assert S.shape[2] == self.N self.S = S # Change tensor S to numpy now that we have saved it as tensor in self.S S = S.cpu().numpy() # The neighborhood matrix has to be a tensor of shape # nOutputNodes x maxNeighborhoodSize neighborhood = [] for k in range(1,self.K+1): # For each hop (0,1,...) in the range K thisNeighborhood = graphTools.computeNeighborhood(S, k, outputType='list') # compute the k-hop neighborhood neighborhood.append(thisNeighborhood) self.neighborhood = neighborhood
Example #6
Source File: graphML.py From graph-neural-networks with GNU General Public License v3.0 | 6 votes |
def forward(self, x): # x is of shape: batchSize x dimInFeatures x numberNodesIn B = x.shape[0] F = x.shape[1] Nin = x.shape[2] # And now we add the zero padding if Nin < self.N: x = torch.cat((x, torch.zeros(B, F, self.N-Nin)\ .type(x.dtype).to(x.device) ), dim = 2) # Compute the filter output u = jARMA(self.inverseWeight, self.directWeight, self.filterWeight, self.S, x, b = self.bias, tMax = self.tMax) # So far, u is of shape batchSize x dimOutFeatures x numberNodes # And we want to return a tensor of shape # batchSize x dimOutFeatures x numberNodesIn # since the nodes between numberNodesIn and numberNodes are not required if Nin < self.N: u = torch.index_select(u, 2, torch.arange(Nin).to(u.device)) return u
Example #7
Source File: 53_machine_translation.py From deep-learning-note with MIT License | 6 votes |
def translate(encoder, decoder, input_seq, max_seq_len): in_tokens = input_seq.split(' ') in_tokens += [EOS] + [PAD] * (max_seq_len - len(in_tokens) - 1) enc_input = torch.tensor([[in_vocab.stoi[tk] for tk in in_tokens]]) # batch=1 enc_state = encoder.begin_state() enc_output, enc_state = encoder(enc_input, enc_state) dec_input = torch.tensor([out_vocab.stoi[BOS]]) dec_state = decoder.begin_state(enc_state) output_tokens = [] for _ in range(max_seq_len): dec_output, dec_state = decoder(dec_input, dec_state, enc_output) pred = dec_output.argmax(dim=1) pred_token = out_vocab.itos[int(pred.item())] if pred_token == EOS: # 当任一时间步搜索出EOS时,输出序列即完成 break else: output_tokens.append(pred_token) dec_input = pred return output_tokens
Example #8
Source File: 53_machine_translation.py From deep-learning-note with MIT License | 6 votes |
def batch_loss(encoder, decoder, X, Y, loss): batch_size = X.shape[0] enc_state = encoder.begin_state() enc_outputs, enc_state = encoder(X, enc_state) # 初始化解码器的隐藏状态 dec_state = decoder.begin_state(enc_state) # 解码器在最初时间步的输入是BOS dec_input = torch.tensor([out_vocab.stoi[BOS]] * batch_size) # 我们将使用掩码变量mask来忽略掉标签为填充项PAD的损失 mask, num_not_pad_tokens = torch.ones(batch_size,), 0 l = torch.tensor([0.0]) for y in Y.permute(1,0): # Y shape: (batch, seq_len) dec_output, dec_state = decoder(dec_input, dec_state, enc_outputs) l = l + (mask * loss(dec_output, y)).sum() dec_input = y # 使用强制教学 num_not_pad_tokens += mask.sum().item() # 将PAD对应位置的掩码设成0, 原文这里是 y != out_vocab.stoi[EOS], 感觉有误 mask = mask * (y != out_vocab.stoi[PAD]).float() return l / num_not_pad_tokens
Example #9
Source File: atss_head.py From mmdetection with Apache License 2.0 | 6 votes |
def forward(self, feats): """Forward features from the upstream network. Args: feats (tuple[Tensor]): Features from the upstream network, each is a 4D-tensor. Returns: tuple: Usually a tuple of classification scores and bbox prediction cls_scores (list[Tensor]): Classification scores for all scale levels, each is a 4D-tensor, the channels number is num_anchors * num_classes. bbox_preds (list[Tensor]): Box energies / deltas for all scale levels, each is a 4D-tensor, the channels number is num_anchors * 4. """ return multi_apply(self.forward_single, feats, self.scales)
Example #10
Source File: point_sample.py From mmdetection with Apache License 2.0 | 6 votes |
def generate_grid(num_grid, size, device): """Generate regular square grid of points in [0, 1] x [0, 1] coordinate space. Args: num_grid (int): The number of grids to sample, one for each region. size (tuple(int, int)): The side size of the regular grid. device (torch.device): Desired device of returned tensor. Returns: (torch.Tensor): A tensor of shape (num_grid, size[0]*size[1], 2) that contains coordinates for the regular grids. """ affine_trans = torch.tensor([[[1., 0., 0.], [0., 1., 0.]]], device=device) grid = F.affine_grid( affine_trans, torch.Size((1, 1, *size)), align_corners=False) grid = normalize(grid) return grid.view(1, -1, 2).expand(num_grid, -1, -1)
Example #11
Source File: score_hlr_sampler.py From mmdetection with Apache License 2.0 | 6 votes |
def random_choice(gallery, num): """Randomly select some elements from the gallery. If `gallery` is a Tensor, the returned indices will be a Tensor; If `gallery` is a ndarray or list, the returned indices will be a ndarray. Args: gallery (Tensor | ndarray | list): indices pool. num (int): expected sample num. Returns: Tensor or ndarray: sampled indices. """ assert len(gallery) >= num is_tensor = isinstance(gallery, torch.Tensor) if not is_tensor: gallery = torch.tensor( gallery, dtype=torch.long, device=torch.cuda.current_device()) perm = torch.randperm(gallery.numel(), device=gallery.device)[:num] rand_inds = gallery[perm] if not is_tensor: rand_inds = rand_inds.cpu().numpy() return rand_inds
Example #12
Source File: gfl_head.py From mmdetection with Apache License 2.0 | 6 votes |
def forward(self, feats): """Forward features from the upstream network. Args: feats (tuple[Tensor]): Features from the upstream network, each is a 4D-tensor. Returns: tuple: Usually a tuple of classification scores and bbox prediction cls_scores (list[Tensor]): Classification and quality (IoU) joint scores for all scale levels, each is a 4D-tensor, the channel number is num_classes. bbox_preds (list[Tensor]): Box distribution logits for all scale levels, each is a 4D-tensor, the channel number is 4*(n+1), n is max value of integral set. """ return multi_apply(self.forward_single, feats, self.scales)
Example #13
Source File: utils.py From deep-learning-note with MIT License | 6 votes |
def data_iter_random(corpus_indices, batch_size, num_steps, device=None): # 减1是因为输出的索引x是相应输入的索引y加1 num_examples = (len(corpus_indices) - 1) // num_steps epoch_size = num_examples // batch_size example_indices = list(range(num_examples)) random.shuffle(example_indices) # 返回从pos开始的长为num_steps的序列 def _data(pos): return corpus_indices[pos: pos + num_steps] if device is None: device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') for i in range(epoch_size): # 每次读取batch_size个随机样本 i = i * batch_size batch_indices = example_indices[i: i + batch_size] X = [_data(j * num_steps) for j in batch_indices] Y = [_data(j * num_steps + 1) for j in batch_indices] yield torch.tensor(X, dtype=torch.float32, device=device), torch.tensor(Y, dtype=torch.float32, device=device)
Example #14
Source File: 33_gru_raw.py From deep-learning-note with MIT License | 6 votes |
def get_params(): def _one(shape): ts = torch.tensor(np.random.normal(0, 0.01, size=shape), device=device, dtype=torch.float32) return torch.nn.Parameter(ts, requires_grad=True) def _three(): return (_one((num_inputs, num_hiddens)), _one((num_hiddens, num_hiddens)), torch.nn.Parameter(torch.zeros(num_hiddens, device=device, dtype=torch.float32), requires_grad=True)) W_xz, W_hz, b_z = _three() # 更新门参数 W_xr, W_hr, b_r = _three() # 重置门参数 W_xh, W_hh, b_h = _three() # 候选隐藏层参数 # 输出层参数 W_hq = _one((num_hiddens, num_outputs)) b_q = torch.nn.Parameter(torch.zeros(num_outputs, device=device, dtype=torch.float32), requires_grad=True) return nn.ParameterList([W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q])
Example #15
Source File: model.py From models with MIT License | 6 votes |
def process_embedding(self, embedding, residue_reduction=True, protein_reduction=False): ''' Direct output of ELMo has shape (3,L,1024), with L being the protein's length, 3 being the number of layers used to train SeqVec (1 CharCNN, 2 LSTMs) and 1024 being a hyperparameter chosen to describe each amino acid. When a representation on residue level is required, you can sum over the first dimension, resulting in a tensor of size (L,1024). If you want to reduce each protein to a fixed-size vector, regardless of its length, you can average over dimension L. ''' embedding = torch.tensor(embedding) if residue_reduction: embedding = embedding.sum(dim=0) elif protein_reduction: embedding = embedding.sum(dim=0).mean(dim=0) return embedding.cpu().detach().numpy()
Example #16
Source File: dataset.py From subword-qac with MIT License | 6 votes |
def collate_fn(queries, tokenizer, sample, max_seq_len=None): token_id_seqs = [[1] + tokenizer(x, **sample) + [2] for x in queries] length = [len(x) - 1 for x in token_id_seqs] if max_seq_len is None or max_seq_len > max(length) + 1: max_seq_len = max(length) + 1 padded = [] mask = [] for x in token_id_seqs: x = x[:max_seq_len] pad_length = max_seq_len - len(x) padded.append(x + [0] * pad_length) mask.append([1] * (len(x) - 1) + [0] * pad_length) padded = torch.tensor(padded).t().contiguous() length = torch.tensor(length) mask = torch.tensor(mask).t().contiguous() return padded[:-1], padded[1:], length, mask
Example #17
Source File: test_losses.py From mmdetection with Apache License 2.0 | 6 votes |
def test_ce_loss(): # use_mask and use_sigmoid cannot be true at the same time with pytest.raises(AssertionError): loss_cfg = dict( type='CrossEntropyLoss', use_mask=True, use_sigmoid=True, loss_weight=1.0) build_loss(loss_cfg) # test loss with class weights loss_cls_cfg = dict( type='CrossEntropyLoss', use_sigmoid=False, class_weight=[0.8, 0.2], loss_weight=1.0) loss_cls = build_loss(loss_cls_cfg) fake_pred = torch.Tensor([[100, -100]]) fake_label = torch.Tensor([1]).long() assert torch.allclose(loss_cls(fake_pred, fake_label), torch.tensor(40.)) loss_cls_cfg = dict( type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0) loss_cls = build_loss(loss_cls_cfg) assert torch.allclose(loss_cls(fake_pred, fake_label), torch.tensor(200.))
Example #18
Source File: test_anchor.py From mmdetection with Apache License 2.0 | 6 votes |
def test_strides(): from mmdet.core import AnchorGenerator # Square strides self = AnchorGenerator([10], [1.], [1.], [10]) anchors = self.grid_anchors([(2, 2)], device='cpu') expected_anchors = torch.tensor([[-5., -5., 5., 5.], [5., -5., 15., 5.], [-5., 5., 5., 15.], [5., 5., 15., 15.]]) assert torch.equal(anchors[0], expected_anchors) # Different strides in x and y direction self = AnchorGenerator([(10, 20)], [1.], [1.], [10]) anchors = self.grid_anchors([(2, 2)], device='cpu') expected_anchors = torch.tensor([[-5., -5., 5., 5.], [5., -5., 15., 5.], [-5., 15., 5., 25.], [5., 15., 15., 25.]]) assert torch.equal(anchors[0], expected_anchors)
Example #19
Source File: 3_linear_regression_raw.py From deep-learning-note with MIT License | 6 votes |
def generate_dataset(true_w, true_b): num_examples = 1000 features = torch.tensor(np.random.normal(0, 1, (num_examples, num_inputs)), dtype=torch.float) # 真实 label labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b # 添加噪声 labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()), dtype=torch.float) # 展示下分布 plt.scatter(features[:, 1].numpy(), labels.numpy(), 1) plt.show() return features, labels # batch 读取数据集
Example #20
Source File: 31_char_rnn_raw.py From deep-learning-note with MIT License | 5 votes |
def grad_clipping(params, theta, device): norm = torch.tensor([0.0], device=device) for param in params: norm += (param.grad.data ** 2).sum() norm = norm.sqrt().item() if norm > theta: for param in params: param.grad.data *= (theta / norm)
Example #21
Source File: graphML.py From graph-neural-networks with GNU General Public License v3.0 | 5 votes |
def forward(self, x): # x should be of shape batchSize x dimNodeSignals x N batchSize = x.shape[0] dimNodeSignals = x.shape[1] assert x.shape[2] == self.N xK = x # xK is a tensor aggregating the 0-hop (x), 1-hop, ..., K-hop # max's # It is initialized with the 0-hop neigh. (x itself) xK = xK.unsqueeze(3) # extra dimension added for concatenation ahead #x = x.unsqueeze(3) # B x F x N x 1 for k in range(1,self.K+1): kHopNeighborhood = self.neighborhood[k-1] # Fetching k-hop neighborhoods of all nodes kHopMedian = torch.empty(0).to(x.device) # Initializing the vector that will contain the k-hop median for # every node for n in range(self.N): # Iterating over the nodes # This step is necessary because here the neighborhoods are # lists of lists. It is impossible to pad them and feed them as # a matrix, as this would impact the outcome of the median # operation nodeNeighborhood = torch.tensor(np.array(kHopNeighborhood[n])) neighborhoodLen = len(nodeNeighborhood) gatherNode = nodeNeighborhood.reshape([1, 1, neighborhoodLen]) gatherNode = gatherNode.repeat([batchSize, dimNodeSignals, 1]) # Reshaping the node neighborhood for the gather operation xNodeNeighbors=torch.gather(x,2,gatherNode.long().to(x.device)) # Gathering signal values in the node neighborhood nodeMedian,_ = torch.median(xNodeNeighbors, dim = 2, keepdim=True) # Computing the median in the neighborhood kHopMedian = torch.cat([kHopMedian,nodeMedian],2) # Concatenating k-hop medians node by node kHopMedian = kHopMedian.unsqueeze(3) # Extra dimension for # concatenation with the previous (k-1)-hop median tensor xK = torch.cat([xK,kHopMedian],3) out = torch.matmul(xK,self.weight.unsqueeze(2)) # Multiplying each k-hop median by corresponding trainable weight out = out.reshape([batchSize,dimNodeSignals,self.N]) return out
Example #22
Source File: 4_linear_regression_torch.py From deep-learning-note with MIT License | 5 votes |
def generate_dataset(true_w, true_b): num_examples = 1000 features = torch.tensor(np.random.normal(0, 1, (num_examples, num_inputs)), dtype=torch.float) # 真实 label labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b # 添加噪声 labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()), dtype=torch.float) # 展示下分布 plt.scatter(features[:, 1].numpy(), labels.numpy(), 1) plt.show() return features, labels
Example #23
Source File: graphML.py From graph-neural-networks with GNU General Public License v3.0 | 5 votes |
def addGSO(self, S): # Every S has 3 dimensions. assert len(S.shape) == 3 # S is of shape E x N x N (And I don't care about E, because the # computeNeighborhood function takes care of it) self.N = S.shape[1] assert S.shape[2] == self.N # Get the device (before operating with S and losing it, it's cheaper # to store the device now, than to duplicate S -i.e. keep a numpy and a # tensor copy of S) device = S.device # Move the GSO to cpu and to np.array so it can be handled by the # computeNeighborhood function S = np.array(S.cpu()) # Compute neighborhood neighborhood = graphTools.computeNeighborhood(S, self.nHops, self.nOutputNodes, self.nInputNodes,'matrix') # And move the neighborhood back to a tensor neighborhood = torch.tensor(neighborhood).to(device) # The neighborhood matrix has to be a tensor of shape # nOutputNodes x maxNeighborhoodSize assert neighborhood.shape[0] == self.nOutputNodes assert neighborhood.max() <= self.nInputNodes # Store all the relevant information self.maxNeighborhoodSize = neighborhood.shape[1] self.neighborhood = neighborhood
Example #24
Source File: 30_series_sampling.py From deep-learning-note with MIT License | 5 votes |
def data_iter_consecutive(corpus_indices, batch_size, num_steps, device=None): if device is None: device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') corpus_indices = torch.tensor(corpus_indices, dtype=torch.float32, device=device) data_len = len(corpus_indices) batch_len = data_len // batch_size indices = corpus_indices[0: batch_size *batch_len].view(batch_size, batch_len) epoch_size = (batch_len - 1) // num_steps for i in range(epoch_size): i = i * num_steps X = indices[:, i: i + num_steps] Y = indices[:, i + 1: i + num_steps + 1] yield X, Y
Example #25
Source File: utils.py From deep-learning-note with MIT License | 5 votes |
def preprocess_imdb(data, vocab): max_l = 500 # 将每条评论通过截断或者补0,使得长度变成500 def pad(x): return x[:max_l] if len(x) > max_l else x + [0] * (max_l - len(x)) tokenized_data = get_tokenized_imdb(data) features = torch.tensor([pad([vocab.stoi[word] for word in words]) for words in tokenized_data]) labels = torch.tensor([score for _, score in data]) return features, labels
Example #26
Source File: utils.py From deep-learning-note with MIT License | 5 votes |
def get_nasa_data(): data = np.genfromtxt('data/NASA/airfoil_self_noise.dat') data = (data - data.mean(axis=0)) / data.std(axis=0) return torch.tensor(data[:1500, :-1], dtype=torch.float32), torch.tensor(data[:1500, -1], dtype=torch.float32)
Example #27
Source File: utils.py From deep-learning-note with MIT License | 5 votes |
def train_opt(optimizer_fn, states, hyperparams, features, labels, batch_size=10, num_epochs=2): # 初始化模型 net, loss = linreg, squared_loss w = torch.nn.Parameter(torch.tensor(np.random.normal(0, 0.01, size=(features.shape[1], 1)), dtype=torch.float32), requires_grad=True) b = torch.nn.Parameter(torch.zeros(1, dtype=torch.float32), requires_grad=True) def eval_loss(): return loss(net(features, w, b), labels).mean().item() ls = [eval_loss()] data_iter = torch.utils.data.DataLoader( torch.utils.data.TensorDataset(features, labels), batch_size, shuffle=True) for _ in range(num_epochs): start = time.time() for batch_i, (X, y) in enumerate(data_iter): l = loss(net(X, w, b), y).mean() # 使用平均损失 # 梯度清零 if w.grad is not None: w.grad.data.zero_() b.grad.data.zero_() l.backward() optimizer_fn([w, b], states, hyperparams) # 迭代模型参数 if (batch_i + 1) * batch_size % 100 == 0: ls.append(eval_loss()) # 每100个样本记录下当前训练误差 # 打印结果和作图 print('loss: %f, %f sec per epoch' % (ls[-1], time.time() - start)) plt.plot(np.linspace(0, num_epochs, len(ls)), ls) plt.xlabel('epoch') plt.ylabel('loss') plt.show() # 本函数与原书不同的是这里第一个参数优化器函数而不是优化器的名字 # 例如: optimizer_fn=torch.optim.SGD, optimizer_hyperparams={"lr": 0.05}
Example #28
Source File: graphML.py From graph-neural-networks with GNU General Public License v3.0 | 5 votes |
def forward(self, x): # x is of shape: batchSize x dimInFeatures x numberNodesIn B = x.shape[0] F = x.shape[1] Nin = x.shape[2] # Mask the parameters self.Phi = self.weightEV * self.sparsityPatternFull # And now we add the zero padding if Nin < self.N: zeroPad = torch.zeros(B, F, self.N-Nin).type(x.dtype).to(x.device) x = torch.cat((x, zeroPad), dim = 2) # Compute the filter output for the EV part uEV = EVGF(self.Phi, x, self.bias) # Check if we need an LSI part if self.M < self.N: # Compute the filter output for the LSI part uLSI = LSIGF(self.weightLSI, self.S, x, self.bias) else: # If we don't, just add zero uLSI = torch.tensor(0., dtype = uEV.dtype).to(uEV.device) # Add both u = uEV + uLSI # So far, u is of shape batchSize x dimOutFeatures x numberNodes # And we want to return a tensor of shape # batchSize x dimOutFeatures x numberNodesIn # since the nodes between numberNodesIn and numberNodes are not required if Nin < self.N: u = torch.index_select(u, 2, torch.arange(Nin).to(u.device)) return u
Example #29
Source File: utils.py From deep-learning-note with MIT License | 5 votes |
def predict_sentiment(net, vocab, sentence): """sentence是词语的列表""" device = list(net.parameters())[0].device sentence = torch.tensor([vocab.stoi[word] for word in sentence], device=device) label = torch.argmax(net(sentence.view((1, -1))), dim=1) return 'positive' if label.item() == 1 else 'negative'
Example #30
Source File: graphML.py From graph-neural-networks with GNU General Public License v3.0 | 5 votes |
def forward(self, x): # x is of shape: batchSize x dimInFeatures x numberNodesIn B = x.shape[0] F = x.shape[1] Nin = x.shape[2] # Check if we have enough spectral filter coefficients as needed, or if # we need to fill out the rest using the spline kernel. if self.M == self.N: self.h = self.weight # F x E x G x N (because N = M) else: # Adjust dimensions for proper algebraic matrix multiplication splineKernel = self.splineKernel.reshape([1,self.E,self.N,self.M]) # We will multiply a 1 x E x N x M matrix with a F x E x M x G # matrix to get the proper F x E x N x G coefficients self.h = torch.matmul(splineKernel, self.weight.permute(0,1,3,2)) # And now we rearrange it to the same shape that the function takes self.h = self.h.permute(0,1,3,2) # F x E x G x N # And now we add the zero padding (if this comes from a pooling # operation) if Nin < self.N: zeroPad = torch.zeros(B, F, self.N-Nin).type(x.dtype).to(x.device) x = torch.cat((x, zeroPad), dim = 2) # Compute the filter output u = spectralGF(self.h, self.V, self.VH, x, self.bias) # So far, u is of shape batchSize x dimOutFeatures x numberNodes # And we want to return a tensor of shape # batchSize x dimOutFeatures x numberNodesIn # since the nodes between numberNodesIn and numberNodes are not required if Nin < self.N: u = torch.index_select(u, 2, torch.arange(Nin).to(u.device)) return u