Python torch.nn.functional.normalize() Examples
The following are 30
code examples of torch.nn.functional.normalize().
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.nn.functional
, or try the search function
.
![](https://www.programcreek.com/common/static/images/search.png)
Example #1
Source File: lipschitz.py From residual-flows with MIT License | 7 votes |
def __init__( self, in_features, out_features, bias=True, coeff=0.97, n_iterations=None, atol=None, rtol=None, **unused_kwargs ): del unused_kwargs super(SpectralNormLinear, self).__init__() self.in_features = in_features self.out_features = out_features self.coeff = coeff self.n_iterations = n_iterations self.atol = atol self.rtol = rtol self.weight = nn.Parameter(torch.Tensor(out_features, in_features)) if bias: self.bias = nn.Parameter(torch.Tensor(out_features)) else: self.register_parameter('bias', None) self.reset_parameters() h, w = self.weight.shape self.register_buffer('scale', torch.tensor(0.)) self.register_buffer('u', F.normalize(self.weight.new_empty(h).normal_(0, 1), dim=0)) self.register_buffer('v', F.normalize(self.weight.new_empty(w).normal_(0, 1), dim=0)) self.compute_weight(True, 200)
Example #2
Source File: main.py From dgl with Apache License 2.0 | 6 votes |
def __init__(self, num_nodes, num_sampled, embedding_size): super(NSLoss, self).__init__() self.num_nodes = num_nodes self.num_sampled = num_sampled self.embedding_size = embedding_size self.weights = Parameter(torch.FloatTensor(num_nodes, embedding_size)) # [ (log(i+2) - log(i+1)) / log(num_nodes + 1)] self.sample_weights = F.normalize( torch.Tensor( [ (math.log(k + 2) - math.log(k + 1)) / math.log(num_nodes + 1) for k in range(num_nodes) ] ), dim=0, ) self.reset_parameters()
Example #3
Source File: signedsageconvolution.py From SGCN with GNU General Public License v3.0 | 6 votes |
def forward(self, x, edge_index): """ Forward propagation pass with features an indices. :param x: Feature matrix. :param edge_index: Indices. """ edge_index, _ = remove_self_loops(edge_index, None) row, col = edge_index if self.norm: out = scatter_mean(x[col], row, dim=0, dim_size=x.size(0)) else: out = scatter_add(x[col], row, dim=0, dim_size=x.size(0)) out = torch.cat((out, x), 1) out = torch.matmul(out, self.weight) if self.bias is not None: out = out + self.bias if self.norm_embed: out = F.normalize(out, p=2, dim=-1) return out
Example #4
Source File: so3.py From c3dpo_nrsfm with MIT License | 6 votes |
def rand_rot(N, dtype=None, max_rot_angle=float(math.pi), axes=(1, 1, 1), get_ss=False): rand_axis = torch.zeros((N, 3)).type(dtype).normal_() # apply the axes mask axes = torch.Tensor(axes).type(dtype) rand_axis = axes[None, :] * rand_axis rand_axis = Fu.normalize(rand_axis, dim=1, p=2) rand_angle = torch.ones(N).type(dtype).uniform_(0, max_rot_angle) R_ss_rand = rand_axis * rand_angle[:, None] R_rand = so3_exponential_map(R_ss_rand) if get_ss: return R_rand, R_ss_rand else: return R_rand
Example #5
Source File: common_layers.py From translate with BSD 3-Clause "New" or "Revised" License | 6 votes |
def __init__( self, num_embeddings, embedding_dim, padding_idx, freeze_embed=False, normalize_embed=False, normalize_decay_rate=0.99, ): super().__init__(num_embeddings, embedding_dim, padding_idx=padding_idx) nn.init.uniform_(self.weight, -0.1, 0.1) nn.init.constant_(self.weight[padding_idx], 0.0) if freeze_embed: self.weight.requires_grad = False assert 0.0 < normalize_decay_rate < 1.0 self.normalize = normalize_embed self.normalize_decay_rate = normalize_decay_rate self.mean = None self.var = None self.init_normalization_if_needed()
Example #6
Source File: mfb.py From openvqa with Apache License 2.0 | 6 votes |
def forward(self, img_feat, ques_feat, exp_in=1): ''' img_feat.size() -> (N, C, img_feat_size) C = 1 or 100 ques_feat.size() -> (N, 1, ques_feat_size) z.size() -> (N, C, MFB_O) exp_out.size() -> (N, C, K*O) ''' batch_size = img_feat.shape[0] img_feat = self.proj_i(img_feat) # (N, C, K*O) ques_feat = self.proj_q(ques_feat) # (N, 1, K*O) exp_out = img_feat * ques_feat # (N, C, K*O) exp_out = self.dropout(exp_out) if self.is_first else self.dropout(exp_out * exp_in) # (N, C, K*O) z = self.pool(exp_out) * self.__C.MFB_K # (N, C, O) z = torch.sqrt(F.relu(z)) - torch.sqrt(F.relu(-z)) z = F.normalize(z.view(batch_size, -1)) # (N, C*O) z = z.view(batch_size, -1, self.__C.MFB_O) # (N, C, O) return z, exp_out
Example #7
Source File: spatial_ocr_block.py From openseg.pytorch with MIT License | 6 votes |
def forward(self, feats, probs, gt_probs=None): if self.use_gt and gt_probs is not None: gt_probs = label_to_onehot(gt_probs.squeeze(1).type(torch.cuda.LongTensor), probs.size(1)) batch_size, c, h, w = gt_probs.size(0), gt_probs.size(1), gt_probs.size(2), gt_probs.size(3) gt_probs = gt_probs.view(batch_size, c, -1) feats = feats.view(batch_size, feats.size(1), -1) feats = feats.permute(0, 2, 1) # batch x hw x c gt_probs = F.normalize(gt_probs, p=1, dim=2)# batch x k x hw ocr_context = torch.matmul(gt_probs, feats).permute(0, 2, 1).unsqueeze(3)# batch x k x c return ocr_context else: batch_size, c, h, w = probs.size(0), probs.size(1), probs.size(2), probs.size(3) probs = probs.view(batch_size, c, -1) feats = feats.view(batch_size, feats.size(1), -1) feats = feats.permute(0, 2, 1) # batch x hw x c probs = F.softmax(self.scale * probs, dim=2)# batch x k x hw ocr_context = torch.matmul(probs, feats).permute(0, 2, 1).unsqueeze(3)# batch x k x c return ocr_context
Example #8
Source File: mulrel_ranker.py From mulrel-nel with Apache License 2.0 | 6 votes |
def loss(self, scores, true_pos, lamb=1e-7): loss = F.multi_margin_loss(scores, true_pos, margin=self.margin) if self.use_local_only: return loss # regularization X = F.normalize(self.rel_embs) diff = (X.view(self.n_rels, 1, -1) - X.view(1, self.n_rels, -1)).pow(2).sum(dim=2).add_(1e-5).sqrt() diff = diff * (diff < 1).float() loss -= torch.sum(diff).mul(lamb) X = F.normalize(self.ew_embs) diff = (X.view(self.n_rels, 1, -1) - X.view(1, self.n_rels, -1)).pow(2).sum(dim=2).add_(1e-5).sqrt() diff = diff * (diff < 1).float() loss -= torch.sum(diff).mul(lamb) return loss
Example #9
Source File: pairwise.py From pykg2vec with MIT License | 6 votes |
def forward(self, h, r, t): """Function to that performs semanting matching. Args: h (Tensor): Head entities ids. r (Tensor): Relation ids of the triple. t (Tensor): Tail ids of the triple. Returns: Tensors: Returns the semantic matchin score. """ h_e, r_e, t_e = self.embed(h, r, t) norm_h = F.normalize(h_e, p=2, dim=-1) norm_r = F.normalize(r_e, p=2, dim=-1) norm_t = F.normalize(t_e, p=2, dim=-1) return torch.sum(self._gu_bilinear(norm_h, norm_r) * self._gv_bilinear(norm_r, norm_t), -1)
Example #10
Source File: pairwise.py From pykg2vec with MIT License | 6 votes |
def forward(self, h, r, t): """Function to that performs semanting matching. Args: h (Tensor): Head entities ids. r (Tensor): Relation ids of the triple. t (Tensor): Tail ids of the triple. Returns: Tensors: Returns the semantic matchin score. """ h_e, r_e, t_e = self.embed(h, r, t) norm_h = F.normalize(h_e, p=2, dim=-1) norm_r = F.normalize(r_e, p=2, dim=-1) norm_t = F.normalize(t_e, p=2, dim=-1) return -torch.sum(self._gu_linear(norm_h, norm_r) * self._gv_linear(norm_r, norm_t), 1)
Example #11
Source File: mixed_lipschitz.py From residual-flows with MIT License | 6 votes |
def normalize_u(u, codomain, out=None): if not torch.is_tensor(codomain) and codomain == 2: u = F.normalize(u, p=2, dim=0, out=out) elif codomain == float('inf'): u = projmax_(u) else: uabs = torch.abs(u) uph = u / uabs uph[torch.isnan(uph)] = 1 uabs = uabs / torch.max(uabs) uabs = uabs**(codomain - 1) if codomain == 1: u = uph * uabs / vector_norm(uabs, float('inf')) else: u = uph * uabs / vector_norm(uabs, codomain / (codomain - 1)) return u
Example #12
Source File: pairwise.py From pykg2vec with MIT License | 6 votes |
def forward(self, h, r, t): """Function to get the embedding value. Args: h (Tensor): Head entities ids. r (Tensor): Relation ids. t (Tensor): Tail entity ids. Returns: Tensors: the scores of evaluationReturns head, relation and tail embedding Tensors. """ h_e, r_e, t_e = self.embed(h, r, t) norm_h_e = F.normalize(h_e, p=2, dim=-1) norm_r_e = F.normalize(r_e, p=2, dim=-1) norm_t_e = F.normalize(t_e, p=2, dim=-1) if self.l1_flag: return torch.norm(norm_h_e + norm_r_e - norm_t_e, p=1, dim=-1) else: return torch.norm(norm_h_e + norm_r_e - norm_t_e, p=2, dim=-1)
Example #13
Source File: generate_mesh_normals.py From pytorch_geometric with MIT License | 6 votes |
def __call__(self, data): assert 'face' in data pos, face = data.pos, data.face vec1 = pos[face[1]] - pos[face[0]] vec2 = pos[face[2]] - pos[face[0]] face_norm = F.normalize(vec1.cross(vec2), p=2, dim=-1) # [F, 3] idx = torch.cat([face[0], face[1], face[2]], dim=0) face_norm = face_norm.repeat(3, 1) norm = scatter_add(face_norm, idx, dim=0, dim_size=pos.size(0)) norm = F.normalize(norm, p=2, dim=-1) # [N, 3] data.norm = norm return data
Example #14
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 #15
Source File: fusions.py From block.bootstrap.pytorch with BSD 3-Clause "New" or "Revised" License | 6 votes |
def __init__(self, input_dims, output_dim, mm_dim=1200, activ_input='relu', activ_output='relu', normalize=False, dropout_input=0., dropout_pre_lin=0., dropout_output=0.): super(LinearSum, self).__init__() self.input_dims = input_dims self.output_dim = output_dim self.mm_dim = mm_dim self.activ_input = activ_input self.activ_output = activ_output self.normalize = normalize self.dropout_input = dropout_input self.dropout_pre_lin = dropout_pre_lin self.dropout_output = dropout_output # Modules self.linear0 = nn.Linear(input_dims[0], mm_dim) self.linear1 = nn.Linear(input_dims[1], mm_dim) self.linear_out = nn.Linear(mm_dim, output_dim) self.n_params = sum(p.numel() for p in self.parameters() if p.requires_grad)
Example #16
Source File: memory.py From LSH_Memory with Apache License 2.0 | 6 votes |
def predict(self, x): batch_size, dims = x.size() query = F.normalize(self.query_proj(x), dim=1) # Find the k-nearest neighbors of the query scores = torch.matmul(query, torch.t(self.keys_var)) cosine_similarity, topk_indices_var = torch.topk(scores, self.top_k, dim=1) # softmax of cosine similarities - embedding softmax_score = F.softmax(self.softmax_temperature * cosine_similarity) # retrive memory values - prediction y_hat_indices = topk_indices_var.data[:, 0] y_hat = self.values[y_hat_indices] return y_hat, softmax_score
Example #17
Source File: fusions.py From block.bootstrap.pytorch with BSD 3-Clause "New" or "Revised" License | 6 votes |
def __init__(self, input_dims, output_dim, mm_dim=1200, activ_input='relu', activ_output='relu', normalize=False, dropout_input=0., dropout_pre_lin=0., dropout_output=0.): super(MLB, self).__init__() self.input_dims = input_dims self.mm_dim = mm_dim self.output_dim = output_dim self.activ_input = activ_input self.activ_output = activ_output self.normalize = normalize self.dropout_input = dropout_input self.dropout_pre_lin = dropout_pre_lin self.dropout_output = dropout_output # Modules self.linear0 = nn.Linear(input_dims[0], mm_dim) self.linear1 = nn.Linear(input_dims[1], mm_dim) self.linear_out = nn.Linear(mm_dim, output_dim) self.n_params = sum(p.numel() for p in self.parameters() if p.requires_grad)
Example #18
Source File: fusions.py From block.bootstrap.pytorch with BSD 3-Clause "New" or "Revised" License | 6 votes |
def forward(self, x): x0 = self.linear0(x[0]) x1 = self.linear1(x[1]) if self.dropout_input > 0: x0 = F.dropout(x0, p=self.dropout_input, training=self.training) x1 = F.dropout(x1, p=self.dropout_input, training=self.training) m0 = self.merge_linear0(x0) m1 = self.merge_linear1(x1) m = m0 * m1 m = m.view(-1, self.rank, self.mm_dim) z = torch.sum(m, 1) if self.normalize: z = torch.sqrt(F.relu(z)) - torch.sqrt(F.relu(-z)) z = F.normalize(z, p=2) if self.dropout_pre_lin > 0: z = F.dropout(z, p=self.dropout_pre_lin, training=self.training) z = self.linear_out(z) if self.dropout_output > 0: z = F.dropout(z, p=self.dropout_output, training=self.training) return z
Example #19
Source File: pairwise.py From pykg2vec with MIT License | 6 votes |
def forward(self, h, r, t): """Function to get the embedding value. Args: h (Tensor): Head entities ids. r (Tensor): Relation ids. t (Tensor): Tail entity ids. Returns: Tensors: the scores of evaluationReturns head, relation and tail embedding Tensors. """ h_e, r_e, t_e = self.embed(h, r, t) norm_h_e = F.normalize(h_e, p=2, dim=-1) norm_r_e = F.normalize(r_e, p=2, dim=-1) norm_t_e = F.normalize(t_e, p=2, dim=-1) if self.l1_flag: return torch.norm(norm_h_e + norm_r_e - norm_t_e, p=1, dim=-1) else: return torch.norm(norm_h_e + norm_r_e - norm_t_e, p=2, dim=-1)
Example #20
Source File: pairwise.py From pykg2vec with MIT License | 6 votes |
def forward(self, h, r, t): """Function to get the embedding value. Args: h (Tensor): Head entities ids. r (Tensor): Relation ids. t (Tensor): Tail entity ids. Returns: Tensors: the scores of evaluationReturns head, relation and tail embedding Tensors. """ h_e, r_e, t_e = self.embed(h, r, t) norm_h_e = F.normalize(h_e, p=2, dim=-1) norm_r_e = F.normalize(r_e, p=2, dim=-1) norm_t_e = F.normalize(t_e, p=2, dim=-1) if self.l1_flag: return torch.norm(norm_h_e + norm_r_e - norm_t_e, p=1, dim=-1) else: return torch.norm(norm_h_e + norm_r_e - norm_t_e, p=2, dim=-1)
Example #21
Source File: sage_conv.py From pytorch_geometric with MIT License | 6 votes |
def __init__(self, in_channels: Union[int, Tuple[int, int]], out_channels: int, normalize: bool = False, bias: bool = True, **kwargs): # yapf: disable super(SAGEConv, self).__init__(aggr='mean', **kwargs) self.in_channels = in_channels self.out_channels = out_channels self.normalize = normalize if isinstance(in_channels, int): in_channels = (in_channels, in_channels) self.lin_l = Linear(in_channels[0], out_channels, bias=bias) self.lin_r = Linear(in_channels[1], out_channels, bias=False) self.reset_parameters()
Example #22
Source File: normalize_rotation.py From pytorch_geometric with MIT License | 6 votes |
def __call__(self, data): pos = data.pos if self.max_points > 0 and pos.size(0) > self.max_points: perm = torch.randperm(pos.size(0)) pos = pos[perm[:self.max_points]] pos = pos - pos.mean(dim=0, keepdim=True) C = torch.matmul(pos.t(), pos) e, v = torch.eig(C, eigenvectors=True) # v[:,j] is j-th eigenvector data.pos = torch.matmul(data.pos, v) if 'norm' in data: data.norm = F.normalize(torch.matmul(data.norm, v)) return data
Example #23
Source File: models.py From AMNRE with MIT License | 5 votes |
def Orth_con(self,wordsEn,NwordsEn,pos1En,pos2En,wordsZh,NwordsZh,pos1Zh,pos2Zh): share_en,share_zh=self.share_encoder(NwordsEn,pos1En,pos2En,NwordsZh,pos1Zh,pos2Zh) mono_en,mono_zh=self.monoRE.encoder(wordsEn,pos1En,pos2En,wordsZh,pos1Zh,pos2Zh) share=torch.cat((share_en,share_zh),0) mono=torch.cat((share_en,share_zh),0) share-=torch.mean(share,0) mono-=torch.mean(share,0) share=F.normalize(share,2,1) mono=F.normalize(share,2,1) correlation_mat=torch.matmul(share.transpose(0,1),mono) cost=torch.mean(correlation_mat*correlation_mat) return cost
Example #24
Source File: encoding.py From PyTorch-Encoding with MIT License | 5 votes |
def pairwise_cosine(X, C, normalize=False): r"""Pairwise Cosine Similarity or Dot-product Similarity Shape: - Input: :math:`X\in\mathcal{R}^{B\times N\times D}` :math:`C\in\mathcal{R}^{K\times D}` :math:`S\in \mathcal{R}^K` (where :math:`B` is batch, :math:`N` is total number of features, :math:`K` is number is codewords, :math:`D` is feature dimensions.) - Output: :math:`E\in\mathcal{R}^{B\times N\times K}` """ if normalize: X = F.normalize(X, dim=2, eps=1e-8) C = F.normalize(C, dim=1, eps=1e-8) return torch.matmul(X, C.t())
Example #25
Source File: memory.py From LSH_Memory with Apache License 2.0 | 5 votes |
def update(self, query, y, y_hat, y_hat_indices): batch_size, dims = query.size() # 1) Untouched: Increment memory by 1 self.age += 1 # Divide batch by correctness result = torch.squeeze(torch.eq(y_hat, torch.unsqueeze(y.data, dim=1))).float() incorrect_examples = torch.squeeze(torch.nonzero(1-result)) correct_examples = torch.squeeze(torch.nonzero(result)) incorrect = len(incorrect_examples.size()) > 0 correct = len(correct_examples.size()) > 0 # 2) Correct: if V[n1] = v # Update Key k[n1] <- normalize(q + K[n1]), Reset Age A[n1] <- 0 if correct: correct_indices = y_hat_indices[correct_examples] correct_keys = self.keys[correct_indices] correct_query = query.data[correct_examples] new_correct_keys = F.normalize(correct_keys + correct_query, dim=1) self.keys[correct_indices] = new_correct_keys self.age[correct_indices] = 0 # 3) Incorrect: if V[n1] != v # Select item with oldest age, Add random offset - n' = argmax_i(A[i]) + r_i # K[n'] <- q, V[n'] <- v, A[n'] <- 0 if incorrect: incorrect_size = incorrect_examples.size()[0] incorrect_query = query.data[incorrect_examples] incorrect_values = y.data[incorrect_examples] age_with_noise = self.age + random_uniform((self.memory_size, 1), -self.age_noise, self.age_noise, cuda=True) topk_values, topk_indices = torch.topk(age_with_noise, incorrect_size, dim=0) oldest_indices = torch.squeeze(topk_indices) self.keys[oldest_indices] = incorrect_query self.values[oldest_indices] = incorrect_values self.age[oldest_indices] = 0
Example #26
Source File: memory.py From LSH_Memory with Apache License 2.0 | 5 votes |
def build(self): self.keys = F.normalize(random_uniform((self.memory_size, self.key_dim), -0.001, 0.001, cuda=True), dim=1) self.keys_var = ag.Variable(self.keys, requires_grad=False) self.values = torch.zeros(self.memory_size, 1).long().cuda() self.age = torch.zeros(self.memory_size, 1).cuda()
Example #27
Source File: models.py From KernelGAT with MIT License | 5 votes |
def forward(self, inputs): inp_tensor, msk_tensor, seg_tensor = inputs msk_tensor = msk_tensor.view(-1, self.max_len) inp_tensor = inp_tensor.view(-1, self.max_len) seg_tensor = seg_tensor.view(-1, self.max_len) inputs_hiddens, inputs = self.pred_model(inp_tensor, msk_tensor, seg_tensor) mask_text = msk_tensor.view(-1, self.max_len).float() mask_text[:, 0] = 0.0 mask_claim = (1 - seg_tensor.float()) * mask_text mask_evidence = seg_tensor.float() * mask_text inputs_hiddens = inputs_hiddens.view(-1, self.max_len, self.bert_hidden_dim) inputs_hiddens_norm = F.normalize(inputs_hiddens, p=2, dim=2) log_pooling_sum = self.get_intersect_matrix(inputs_hiddens_norm, inputs_hiddens_norm, mask_claim, mask_evidence) log_pooling_sum = log_pooling_sum.view([-1, self.evi_num, 1]) select_prob = F.softmax(log_pooling_sum, dim=1) inputs = inputs.view([-1, self.evi_num, self.bert_hidden_dim]) inputs_hiddens = inputs_hiddens.view([-1, self.evi_num, self.max_len, self.bert_hidden_dim]) inputs_att_de = [] for i in range(self.evi_num): outputs, outputs_de = self.self_attention(inputs, inputs_hiddens, mask_text, mask_text, i) inputs_att_de.append(outputs_de) inputs_att = inputs.view([-1, self.evi_num, self.bert_hidden_dim]) inputs_att_de = torch.cat(inputs_att_de, dim=1) inputs_att_de = inputs_att_de.view([-1, self.evi_num, self.bert_hidden_dim]) inputs_att = torch.cat([inputs_att, inputs_att_de], -1) inference_feature = self.proj_inference_de(inputs_att) class_prob = F.softmax(inference_feature, dim=2) prob = torch.sum(select_prob * class_prob, 1) prob = torch.log(prob) return prob
Example #28
Source File: graphsage.py From dgl with Apache License 2.0 | 5 votes |
def forward(self, x, adj): if self.use_bn and not hasattr(self, 'bn'): self.bn = nn.BatchNorm1d(adj.size(1)).to(adj.device) if self.add_self: adj = adj + torch.eye(adj.size(0)).to(adj.device) if self.mean: adj = adj / adj.sum(1, keepdim=True) h_k_N = torch.matmul(adj, x) h_k = self.W(h_k_N) h_k = F.normalize(h_k, dim=2, p=2) h_k = F.relu(h_k) if self.use_bn: h_k = self.bn(h_k) return h_k
Example #29
Source File: common_layers.py From translate with BSD 3-Clause "New" or "Revised" License | 5 votes |
def forward(self, x): x = super().forward(x) if self.normalize: if self.training: self._update_normalize_params(x) x = (x - self.mean) / torch.sqrt(self.var + 1e-6) return x
Example #30
Source File: bundler.py From dgl with Apache License 2.0 | 5 votes |
def forward(self, node): h = node.data['h'] c = node.data['c'] bundle = self.concat(h, c) bundle = F.normalize(bundle, p=2, dim=1) if self.activation: bundle = self.activation(bundle) return {"h": bundle}