def forward(self, x): N, C, T, V, M = x.size() x = x.permute(0, 4, 3, 1, 2).contiguous().view(N, M * V * C, T) if self.use_data_bn: x = self.data_bn(x) x = self.conv0(x) x = self.unit1(x) x = self.unit2(x) x = self.unit3(x) x = self.unit4(x) x = self.unit5(x) x = self.unit6(x) x = self.unit7(x) x = self.unit8(x) x = self.unit9(x) x = self.bn(x) x = self.relu(x) x = F.avg_pool1d(x, kernel_size=x.size()[2]) x = self.fcn(x) x = x.view(-1, self.num_class) return x
def avg_pool1d(x, seq_lens): # shape is same as below out = [] for index, t in enumerate(x): t = t[:seq_lens[index], :] t = torch.t(t).unsqueeze(0) out.append(F.avg_pool1d(t, t.size(2))) out = torch.cat(out).squeeze(2) return out
def avg_pool1d(self, x, seq_lens): # x:[N,L,O_in] out = [] for index, t in enumerate(x): t = t[:seq_lens[index], :] t = torch.t(t).unsqueeze(0) out.append(F.avg_pool1d(t, t.size(2))) out = torch.cat(out).squeeze(2) return out
def forward(self, q1, q2): q1 = self.embed(q1) q1 = q1.unsqueeze(1) # (N, Ci, W, D) q1 = [F.tanh(conv(q1)).squeeze(3) for conv in self.convs1] # [(N, Co, W), ...]*len(Ks) q1 = [i.size(2) * F.avg_pool1d(i, i.size(2)).squeeze(2) for i in q1] # [(N, Co), ...]*len(Ks) q1 = [F.tanh(i) for i in q1] q1 = torch.cat(q1, 1) # 64 * 300 q2 = self.embed(q2) q2 = q2.unsqueeze(1) # (N, Ci, W, D) q2 = [F.tanh(conv(q2)).squeeze(3) for conv in self.convs1] # [(N, Co, W), ...]*len(Ks) q2 = [i.size(2) * F.avg_pool1d(i, i.size(2)).squeeze(2) for i in q2] # [(N, Co), ...]*len(Ks) q2 = [F.tanh(i) for i in q2] q2 = torch.cat(q2, 1) cos_ans = F.cosine_similarity(q1, q2) # cos_ans = F.sigmoid(cos_ans) return cos_ans
def agg_channel(self, x, pool="max"): b, c, h, w = x.size() x = x.view(b, c, h * w) x = x.permute(0, 2, 1) if pool == "max": x = F.max_pool1d(x, c) elif pool == "avg": x = F.avg_pool1d(x, c) x = x.permute(0, 2, 1) x = x.view(b, 1, h, w) return x
def forward(self, x): dropout = nn.Dropout(p=0) out = self.cv0(x) res1 = out out = dropout(self.cv1_1(F.relu(self.bn1_1(out)))) out = self.cv1_2(F.relu(self.bn1_2(out))) res2 = out + res1 out = dropout(self.cv1_3(F.relu(self.bn1_3(res2)))) out = self.cv1_4(F.relu(self.bn1_4(out))) res3 = out + res2 out = dropout(self.cv1_5(F.relu(self.bn1_5(res3)))) out = self.cv1_6(F.relu(self.bn1_6(out))) res4 = out + res3 out = dropout(self.cv1_7(F.relu(self.bn1_7(res4)))) out = self.cv1_8(F.relu(self.bn1_8(out))) res4_1 = res4 + out res4_2 = self.res_cv1to2(res4_1) # Residual link down sampled out = dropout(self.cv2_1(F.relu(self.bn2_1(res4_1)))) out = self.cv2_2(F.relu(self.bn2_2(out))) res5 = out + res4_2 out = dropout(self.cv2_3(F.relu(self.bn2_3(res5)))) out = self.cv2_4(F.relu(self.bn2_4(out))) res6 = out + res5 out = dropout(self.cv2_5(F.relu(self.bn2_5(res6)))) out = self.cv2_6(F.relu(self.bn2_6(out))) res7 = out + res6 out = dropout(self.cv2_7(F.relu(self.bn2_7(res7)))) out = self.cv2_8(F.relu(self.bn2_8(out))) res8 = out + res7 res8_2 = self.res_cv2to3(res8) # Residual link down sampled out = dropout(self.cv3_1(F.relu(self.bn3_1(res8)))) out = self.cv3_2(F.relu(self.bn3_2(out))) res9 = out + res8_2 out = dropout(self.cv3_3(F.relu(self.bn3_3(res9)))) out = self.cv3_4(F.relu(self.bn3_4(out))) res10 = out + res9 out = dropout(self.cv3_5(F.relu(self.bn3_5(res10)))) out = self.cv3_6(F.relu(self.bn3_6(out))) res11 = out + res10 out = dropout(self.cv3_7(F.relu(self.bn3_7(res11)))) out = self.cv3_8(F.relu(self.bn3_8(out))) res12 = out + res11 out = F.relu(self.bn4(res12)) out = F.avg_pool1d(out, kernel_size=out.shape[2], stride=1, padding=0) out = self.conv4(out) out = out.view(out.size(0), -1) return F.log_softmax(out, dim=1)
def forward(self, x, **kwargs): if self.mode == 'rand': x = self.embed(x) # (batch, sent_len, embed_dim) elif self.mode == 'static': x = self.static_embed(x) # (batch, sent_len, embed_dim) elif self.mode == 'non-static': x = self.non_static_embed(x) # (batch, sent_len, embed_dim) x = F.avg_pool1d(x.transpose(1, 2), x.shape[1]).squeeze(2) # (batch, embed_dim) logit = self.fc1(x) # (batch, target_size) return logit
def channel_avg_pool0d(self, x, face): assert self.ndim(x) == 2 in_channels = self.shape(x)[1] assert 0 <= face <= in_channels assert in_channels % face == 0 x = self.expand_dims(x, 1) pool_face = face pool_stride = pool_face pool_padding = 0 x = F.avg_pool1d(x, pool_face, pool_stride, pool_padding) return self.squeeze(x, 1)
def feature(self, x): x = F.max_pool2d(self.conv1(x), 2) x = F.max_pool2d((self.conv2(x)), 2) x = F.avg_pool2d(x, 2) # print x.size() x = x.view(-1, 1, 80) x = F.avg_pool1d(x, kernel_size=38, stride=1) # print x.size() x = x.view(-1, 43) return x
def mean_std(self, mode='bm'): mean = torch.mean(self.buffer[self.start:self.end]).item() if mode == 'bm': # batch mean variance b_n = int(math.floor(math.sqrt(self.count))) Yks = F.avg_pool1d(self.buffer[self.start:self.end].unsqueeze(0).unsqueeze(0), kernel_size=b_n, stride=b_n).view(-1) diffs = Yks - mean std = math.sqrt(b_n /(len(Yks)-1))*torch.norm(diffs).item() dof = b_n - 1 elif mode == 'olbm': # overlapping batch mean b_n = int(math.floor(math.sqrt(self.count))) Yks = F.avg_pool1d(self.buffer[self.start:self.end].unsqueeze(0).unsqueeze(0), kernel_size=b_n, stride=1).view(-1) diffs = Yks - mean std = math.sqrt(b_n*self.count/(len(Yks)*(len(Yks)-1)))*torch.norm(diffs).item() dof = self.count - b_n else: # otherwise use mode == 'iid' std = torch.std(self.buffer[self.start:self.end]).item() dof = self.count - 1 return mean, std, dof
def forward(self, x, cond): residual = self.skip_conv(x) # [B, input_dim, T] -> [B, output_dim, T] residual = F.avg_pool1d( residual, kernel_size=self.scale ) if self.scale != 1 else residual # [B, output_dim, T] -> [B, output_dim, T/x] x = F.avg_pool1d( x, kernel_size=self.scale ) if self.scale != 1 else x # [B, input_dim, T] -> [B, input_dim, x*T] for i, resblock in enumerate( self.resblocks): # [B, input_dim, T] -> [B, output_dim, x*T] x = resblock(x.clone()) if i == self.cond_block_id and hasattr(self, 'cond_conv'): cond = self.cond_conv( cond) # [B, cond_dim, T] -> [B, output_dim, T] if cond.shape[2] != x.shape[2]: cond = F.interpolate(cond, size=x.shape[2], mode='linear') x = x + cond return x + residual
def forward(self, x, z=None, output_lengths=None): # [B, in_dim, T] if hasattr(self, 'bn'): x = self.bn(x, z) x = self.act_func(x) if hasattr(self, 'scale'): if self.downsample: F.avg_pool1d(x, kernel_size=self.scale) else: x = F.interpolate( x, scale_factor=self.scale, mode='linear') # [B, in_dim, T] -> [B, in_dim, x*T] if output_lengths is not None: scale_factor = x.shape[2] / output_lengths.sum().max() if scale_factor != 1.0: output_lengths = (output_lengths.float() * (scale_factor)).long() mask = get_mask_from_lengths(output_lengths).unsqueeze(1) x.masked_fill_(~mask, 0.0) x = self.conv(x) # [B, in_dim, x*T] -> [B, out_dim, x*T] return x # [B, out_dim, x*T]
def forward(self, input): x = input # (batch_size, 1, time_steps, mel_bins) frames_num = x.shape[2] x = x.transpose(1, 3) x = self.bn0(x) x = x.transpose(1, 3) if self.training: if random.random() < 0.25: x = self.spec_augmenter(x) x = x.transpose(2, 3) # (batch_size, channels, freq, frames) x = self.encoder(x) # (batch_size, channels, frames) x = torch.mean(x, dim=2) # channel smoothing x1 = F.max_pool1d(x, kernel_size=3, stride=1, padding=1) x2 = F.avg_pool1d(x, kernel_size=3, stride=1, padding=1) x = x1 + x2 x = F.dropout(x, p=0.5, training=self.training) x = x.transpose(1, 2) x = F.relu_(self.fc1(x)) x = x.transpose(1, 2) x = F.dropout(x, p=0.5, training=self.training) (clipwise_output, norm_att, segmentwise_output) = self.att_block(x) logit = torch.sum(norm_att * self.att_block.cla(x), dim=2) segmentwise_logit = self.att_block.cla(x).transpose(1, 2) segmentwise_output = segmentwise_output.transpose(1, 2) interpolate_ratio = frames_num // segmentwise_output.size(1) # Get framewise output framewise_output = interpolate(segmentwise_output, interpolate_ratio) framewise_output = pad_framewise_output(framewise_output, frames_num) framewise_logit = interpolate(segmentwise_logit, interpolate_ratio) framewise_logit = pad_framewise_output(framewise_logit, frames_num) output_dict = { "framewise_output": framewise_output, "segmentwise_output": segmentwise_output, "logit": logit, "framewise_logit": framewise_logit, "clipwise_output": clipwise_output } return output_dict
def forward(self, embeddings, mask): #embeddings = [batch, emb dim, seq len] #mask = [batch, seq len] _, _, seq_len = embeddings.shape mask = mask.unsqueeze(1) #mask = [batch, 1, seq len] if self.pool_mode == 'mean': embeddings = embeddings.masked_fill(mask == 0, 0) pooled = F.avg_pool1d(embeddings, kernel_size=seq_len) elif self.pool_mode == 'max': embeddings = embeddings.masked_fill(mask == 0, -1e10) pooled = F.max_pool1d(embeddings, kernel_size=seq_len) elif self.pool_mode == 'weighted_mean': _embeddings = embeddings.permute(0, 2, 1) #_embeddings = [batch, seq len, emb dim] weights = torch.sigmoid(self.fc(_embeddings)) #weighs = [batch, seq len, 1] weights = weights.permute(0, 2, 1) #weights = [batch, 1, seq len] weighted = embeddings * weights weighted = weighted.masked_fill(mask == 0, 0) #weighted = [batch, emb dim, seq len] pooled = F.avg_pool1d(weighted, kernel_size=seq_len) else: raise ValueError(f'Unknown pool mode: {self.pool_mode}') #pooled = [batch size, emb dim, 1] pooled = pooled.squeeze(-1) #pooled = [batch size, emb dim] return pooled
def forward(self, x): N, C, T, V, M = x.size() # data bn if self.use_data_bn: if self.M_dim_bn: x = x.permute(0, 4, 3, 1, 2).contiguous().view(N, M * V * C, T) else: x = x.permute(0, 4, 3, 1, 2).contiguous().view(N * M, V * C, T) x = self.data_bn(x) # to (N*M, C, T, V) x = x.view(N, M, V, C, T).permute(0, 1, 3, 4, 2).contiguous().view(N * M, C, T, V) else: # from (N, C, T, V, M) to (N*M, C, T, V) x = x.permute(0, 4, 1, 2, 3).contiguous().view(N * M, C, T, V) # model x = self.gcn0(x) x = self.tcn0(x) for m in self.backbone: x = m(x) # V pooling x = F.avg_pool2d(x, kernel_size=(1, V)) # M pooling x = x.view(N, M, x.size(1), x.size(2)) x = x.mean(dim=1) # T pooling x = F.avg_pool1d(x, kernel_size=x.size()[2]) # C fcn x = self.fcn(x) x = F.avg_pool1d(x, x.size()[2:]) x = x.view(N, self.num_class) return x
def forward(self, xs: torch.Tensor, x_masks: Optional[torch.Tensor] = None ) -> torch.Tensor: for f in self.conv: xs = f(xs) # (B, C, Tmax) # NOTE: calculate in log domain xs = F.avg_pool1d(xs, xs.size(-1)) # (B, C, 1) return xs
def forward(self, x): # create lists for both outputs and attentions out_list = [] att_list = [] # the resnet backbone x = self.conv1(x) x = self.bn1(x) x = self.relu(x) x = self.maxpool(x) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) # grouping module upon the feature maps outputed by the backbone region_feature, assign = self.grouping(x) region_feature = region_feature.contiguous().unsqueeze(3) # generate attention for i in range(self.num_classes): att = self.attconv[i](region_feature) att = F.softmax(att, dim=2) att_list.append(att) # non-linear layers over the region features region_feature = self.post_block(region_feature) # attention-based classification for i in range(self.num_classes): # apply the attention on the features out = region_feature.clone() * att_list[i] out = out.contiguous().squeeze(3) # average all region features into one vector based on the attention out = F.avg_pool1d(out, self.n_parts) * self.n_parts out = out.contiguous().unsqueeze(3) # final batchnorm out = self.groupingbn(out) # nonlinear block for each head out = self.nonlinear[i](out) # linear classifier out = out.contiguous().view(out.size(0), -1) out = self.mylinear[i](out) # append the output out_list.append(out) return out_list, att_list, assign
def forward(self, q1, q2): mask1, mask2 = q1.eq(0), q2.eq(0) res = [[], []] q1_encode = self.embed(q1) q2_encode = self.embed(q2) # eg: s1 => res[0] # (batch_size, seq_len, dim) => (batch_size, dim) # if num_layer == 0 res[0].append(F.avg_pool1d(q1_encode.transpose(1, 2), kernel_size=q1_encode.size(1)).squeeze(-1)) res[1].append(F.avg_pool1d(q2_encode.transpose(1, 2), kernel_size=q2_encode.size(1)).squeeze(-1)) for i, conv in enumerate(self.conv): o1, o2 = conv(q1_encode, q2_encode, mask1, mask2) res[0].append(F.avg_pool1d(o1.transpose(1, 2), kernel_size=o1.size(1)).squeeze(-1)) res[1].append(F.avg_pool1d(o2.transpose(1, 2), kernel_size=o2.size(1)).squeeze(-1)) o1, o2 = attention_avg_pooling(o1, o2, mask1, mask2) q1_encode, q2_encode = o1 + q1_encode, o2 + q2_encode # batch_size * (dim*(1+num_layer)*2) => batch_size * linear_size x = torch.cat([torch.cat(res[0], 1), torch.cat(res[1], 1)], 1) sim = self.fc(x) probabilities = nn.functional.softmax(sim, dim=-1) return sim, probabilities
def forward(self, x): # x: [token, last_token, user] tokens = self.vocab_embedding(x[:, :2]) users = self.user_embedding(x[:, 2]).unsqueeze(1) x = torch.cat([tokens, users], dim=1) x = self.conv1(x) x = self.dropout(x) x = F.avg_pool1d(x, x.size(2)).squeeze(2) x = self.out(x) return x
def forward(self, x, self_idx=-1, mask=None): x, self_x = self.embedding(x, self_idx) for i in range(self._attn_N): x = self.layers[i](x, mask) x = self.norm(x) if self._use_average_pool: x = torch.transpose(x, 1, 2) x = F.avg_pool1d(x, kernel_size=x.size(-1)).view(x.size(0), -1) if self._cat_self: x = torch.cat((x, self_x), dim=-1) x = x.view(x.size(0), -1) return x
def forward(self, text): """ :param text: result of text being mapped to numebr :return: tensor of same size of number of classes for classification """ embedded = self.embedding(text) c = embedded.size(0) // BATCH_SIZE embedded = embedded[:BATCH_SIZE * c] embedded = embedded.transpose(1, 0).unsqueeze(0) embedded = f.avg_pool1d(embedded, kernel_size=c) out = self.fc2(f.relu(self.fc1(embedded[0].transpose(1, 0)))) return out
def forward(self, x, target, desc_data=None, get_attention=False): #get embeddings and apply dropout x = self.embed(x) x = self.embed_drop(x) x = x.transpose(1, 2) if self.pool == 'max': x = F.max_pool1d(x) else: x = F.avg_pool1d(x) logits = torch.sigmoid(self.final(x)) loss = self._get_loss(logits, target, diffs) return yhat, loss, None
def apply_pooling(self, input): """ 在seq——len的维度进行池化 :param input: batch_size,seq_len,hidden_size :return: """ avg_output = F.avg_pool1d(input.transpose( 1, 2), input.size(1)).squeeze(-1) #[batch_size,hidden_size] max_output = F.max_pool1d(input.transpose(1, 2), input.size(1)).squeeze(-1) return torch.cat([avg_output, max_output], dim=-1) #[batch_size,hidden_size*2]
def forward(self,x , mode = 'train'): out = self.prelayer(x) out = self.layer1(out) out = self.layer2(out) out = self.layer3(out) out = self.layer4(out) out = F.avg_pool1d(out,7) out = out.view(out.size(0),-1) out = self.fc(out) if(mode == 'eval'): out = self.softmax(out) return out
def conv_block(self, x, conv_layers, norm_layers, res=True): out = x for layer in conv_layers: out = pad_layer(out, layer) out = F.leaky_relu(out, negative_slope=self.ns) for layer in norm_layers: out = layer(out) if res: x_pad = F.pad(x, pad=(0, x.size(2) % 2), mode='reflect') x_down = F.avg_pool1d(x_pad, kernel_size=2) out = x_down + out return out
def forward_rnn(self, inputs, state, seq_lens): horizon = self.horizon worker_states = state[:2] manager_states = state[2:2 + horizon * 3] horizon_goals = state[2 + horizon * 3:] self.z = inputs latent_state, goal, manager_states = self.manager( inputs, manager_states) if inputs.shape[1] == 1: random_select = torch.rand(goal.shape[0], device=goal.device) > -1 random_goal = torch.normal(goal.clone().detach().fill_(0), goal.clone().detach().fill_(1)) random_goal = random_goal / random_goal.norm(dim=-1, keepdim=True) random_goal = random_goal * ~random_select.unsqueeze(-1).unsqueeze( -1) goal = goal * random_select.unsqueeze(-1).unsqueeze(-1) goal += random_goal self.random_select = random_select self.random_goal = random_goal else: goal = goal * self.random_select.unsqueeze(-1) goal += self.random_goal self.latent_state = latent_state self.goal = goal # Sample Batch if inputs.shape[1] == 1: # Update horizon like a queue for i in range(horizon - 1): horizon_goals[i] = horizon_goals[i + 1] horizon_goals[-1] = goal.detach() # Pool goal over past horizon horizon_goal = torch.sum(torch.stack(horizon_goals), dim=0) # Train Batch else: # Pool goal over past horizon # 1) Concat past goal horizon with goals # 2) Run 1D sum pooling to pool goals horizon_goal = torch.cat( (torch.cat(horizon_goals[1:], dim=1), goal.detach()), dim=1) horizon_goal = horizon_goal.permute(0, 2, 1) horizon_goal = F.avg_pool1d(horizon_goal, horizon, 1) * horizon horizon_goal = horizon_goal.permute(0, 2, 1) action, worker_states = self.worker(inputs, horizon_goal, worker_states) return action, worker_states + manager_states + horizon_goals
def forward(self, x: torch.Tensor) -> torch.Tensor: """ Embeddes the input signal into a latent vector """ if self.downsample: if x.ndim == 3: x = F.avg_pool1d(x, self.downsample, self.downsample) else: x = F.avg_pool2d(x, self.downsample, self.downsample) x = self.conv(x) x = x.reshape(-1, self.reshape_) return self.fc(x)
def forward(self, features): ''' :param features: N,n,in_features :return: ''' lay1 = self.linear1( F.avg_pool1d(features, features.size(2)).squeeze(dim=2)) lay1 = F.tanh(lay1) coeffi = F.softmax(self.linear2(lay1), dim=1) # coeffi = F.sigmoid(self.linear2(lay1)) return (coeffi.unsqueeze(dim=-1) * features).sum(dim=1)
def forward(self, send, recv): x = torch.cat((send, recv), dim=-1) x = x.permute(0, 2, 1) x = self.conv1(x) x = F.relu(x) x = F.avg_pool1d(x, 2) x = self.conv2(x) x = F.relu(x) x = torch.mean(x, -1) x = self.fc(x) x = F.tanh(x) return x
def forward(self, x): x = self.conv1(x) x = self.conv2(x) x = self.conv3(x) x = self.conv4(x) x = self.conv5(x) x = F.avg_pool1d(x, 175) x = x.view( x.size(0), -1) # flatten the output of conv2 to (batch_size, 32 * 7 * 7) output = self.out(x) return output
def forward(self, x, z): b = x.size(0) t = x.size(1) bd = z.size(0) bd = z.size(1) #RGB x = x.view(b * t, x.size(2), x.size(3), x.size(4)) x = self.base(x) x = F.avg_pool2d(x, x.size()[2:]) x = x.view(b, t, -1) output, (h_n, c_n) = self.lstm(x) output = output.permute(0, 2, 1) f = F.avg_pool1d(output, t) f = f.view(b, self.hidden_dim) #Depth z = z.view(bd * td, z.size(2), z.size(3), z.size(4)) z = self.base(z) z = F.avg_pool2d(z, z.size()[2:]) z = z.view(bd, td, -1) outputd, (h_n, c_n) = self.lstm(z) outputd = outputd.permute(0, 2, 1) fd = F.avg_pool1d(outputd, td) fd = fd.view(bd, self.hidden_dim) if not self.training: return f, fd y = self.bilinear(f, fd) #Uniamo #riaggiustiamo dimensioni f = f.view(16, -1) fd = fd.view(16, -1) y = y.view(16, -1) if self.loss == {'xent'}: return y elif self.loss == {'xent', 'htri'}: return y, f, fd elif self.loss == {'cent'}: return y, f, fd else: raise KeyError("Unsupported loss: {}".format(self.loss))
def forward(self, inputs): # import pdb; pdb.set_trace() input_p, input_h = inputs[0], inputs[1] batch_size = len(inputs[0]) # Input Encoding xp = self.emb(input_p) xh = self.emb(input_h) # Sentence embedding op, _ = self.input_encoding(xp) # (batch, sentence_len, embedding_dim) oh, _ = self.input_encoding(xh) # Local Inference Modeling (with soft-align attention) E_ph = torch.matmul(op, oh.transpose( -1, -2)) # We calculate the similarity matrix of op and oh wp = torch.matmul(F.softmax(E_ph, dim=2), oh) wh = torch.matmul(F.softmax(E_ph, dim=1).transpose(-1, -2), op) # Enhancement of local inference information mp = torch.cat([op, wp, op - wp, op * wp], dim=1) mh = torch.cat([oh, wh, oh - wh, oh * wh], dim=1) # Pooling embedding_dim = mp.size(-1) vp_a = F.avg_pool1d(mp.transpose(-1, -2), embedding_dim).view(batch_size, -1) vp_m = F.max_pool1d(mp.transpose(-1, -2), embedding_dim).view(batch_size, -1) vh_a = F.avg_pool1d(mh.transpose(-1, -2), embedding_dim).view(batch_size, -1) vh_m = F.max_pool1d(mh.transpose(-1, -2), embedding_dim).view(batch_size, -1) v = torch.cat([vp_a, vp_m, vh_a, vh_m], dim=1) y_p = self.nn(v) return y_p
def avg_pool1d(self, x, seq_lens): # x:[N,L,O_in] out = [] for index, t in enumerate(x): t = t[:seq_lens[index], :] #[L,O_in] t = torch.t(t).unsqueeze(0) #[1,O,L] out.append(F.avg_pool1d( t, t.size(2))) #list các tensor 3 chiều : [1,O,1] out = torch.cat(out).squeeze( 2 ) #cắt chiều ngoài cùng và cat lại theo hàng thành 1 tensor 3 chiều return out #=> [N,O_in]
def forward(self, x_in, apply_softmax=False): x_embedded = self.emb(x_in).permute(0, 2, 1) features = self.convnet(x_embedded) remaining_size = features.size(dim=2) features = F.avg_pool1d(features, remaining_size).squeeze(dim=2) features = F.dropout(features, p=self._dropout_p) intermediate_vector = F.relu(F.dropout(self.fc1(features), p=self._dropout_p)) prediction_vector = self.fc2(intermediate_vector) if apply_softmax: prediction_vector = F.softmax(prediction_vector, dim=1) return prediction_vector
def forward(self,tree,block_texts): all_blocks = [] nb_blocks=0 if True: for block_text in block_texts: block_len=len(block_text) if len(block_text)==0: all_blocks.append(self.zero_var) continue block_embs = self.emb(block_text) block_rep = torch.max(block_embs,0)[0] #print(type(block_rep)) #print(block_rep.size()) #block_rep = torch.mean(block_embs,dim=0) all_blocks.append(block_rep.unsqueeze(0)) nb_blocks=len(all_blocks) all_blocks=torch.cat(all_blocks).unsqueeze(0).transpose(1,2) else: for block_text in block_texts: block_len=len(block_text) if len(block_text)<3: continue block_embs = self.emb(block_text) block_embs=block_embs.transpose(0,1).unsqueeze(0) #block_rep = torch.mean(block_embs,dim=0) #all_blocks.append(block_rep.unsqueeze(0)) cs = [] for i in range(len(self.filter_frames_block)): ci = F.relu(self.conv_models_block[i](block_embs)) ci = F.avg_pool1d(ci,block_len -self.filter_frames_block[i]+1).view(-1, self.filter_dims_block[i]) cs.append(ci) cs = torch.cat(cs, 1) all_blocks.append(cs) nb_blocks=len(all_blocks) if nb_blocks<3: return None all_blocks=torch.cat(all_blocks).unsqueeze(0).transpose(1,2) #print(all_blocks.size()) cs = [] for i in range(len(self.filter_frames)): ci = F.relu(self.conv_models[i](all_blocks)) ci = F.avg_pool1d(ci,nb_blocks -self.filter_frames[i]+1).view(-1, self.filter_dims[i]) cs.append(ci) cs = torch.cat(cs, 1) output = self.output(cs) return output if self.mean_only: mean_rep=torch.mean(all_blocks,dim=0) mean_rep=mean_rep.unsqueeze(0) output = self.output(mean_rep) else: self.childsumtreelstm.clear_states() state, hidden = self.childsumtreelstm(tree, all_blocks) hidden_states=self.childsumtreelstm.get_states() hidden_states=torch.cat(hidden_states) output = self.output(state) return output
def temporal_pooling(self, x, kernel_size, stride): x = F.avg_pool1d(x, kernel_size, stride, padding=kernel_size // 2) return x
def forward(self, input_tensor): return functional.avg_pool1d(input_tensor, input_tensor.size()[2:]).view(input_tensor.size()[:2])