def forward(self, x): out = F.relu(F.max_pool2d(self.conv1(x), 2)) out = F.relu(F.max_pool2d(self.conv2(out), 2)) out = out.view(-1, 320) out = F.relu(self.fc1(out)) out = self.fc2(out) return F.log_softmax(out, dim=1)
def forward(self, x): x = self.conv1(x) x = F.max_pool2d(x, 2) + F.avg_pool2d(x, 2) x = self.block1(x) x = self.group1(x) x = F.max_pool2d(x, 2) + F.avg_pool2d(x, 2) x = self.block2(x) x = self.group2(x) x = F.max_pool2d(x, 2) + F.avg_pool2d(x, 2) x = self.block3(x) x = self.group3(x) x = self.block4(x) x = self.group4(x) x = F.max_pool2d(x, 2) + F.avg_pool2d(x, 2) x = x.view(x.size(0), -1) fc = self.fc(x) x = F.dropout(fc, training=self.training) output = list() for name, fun in self.fc_dict.iteritems(): out = fun(x) output.append(out) return output, fc
def forward(self, x): x = F.max_pool2d(F.relu(self.conv1(x)), 2) x = F.max_pool2d(F.relu(self.conv2(x)), 2) x = x.view(-1, 64 * 7 * 7) # reshape Variable x = F.relu(self.fc1(x)) x = self.fc2(x) return F.log_softmax(x, dim=-1)
def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2)) x = x.view(-1, 320) x = F.relu(self.fc1(x)) x = F.dropout(x, training=self.training) return F.log_softmax(self.fc2(x))
def forward(self, X): h = F.relu(self.conv1_1(X), inplace=True) h = F.relu(self.conv1_2(h), inplace=True) # relu1_2 = h h = F.max_pool2d(h, kernel_size=2, stride=2) h = F.relu(self.conv2_1(h), inplace=True) h = F.relu(self.conv2_2(h), inplace=True) # relu2_2 = h h = F.max_pool2d(h, kernel_size=2, stride=2) h = F.relu(self.conv3_1(h), inplace=True) h = F.relu(self.conv3_2(h), inplace=True) h = F.relu(self.conv3_3(h), inplace=True) # relu3_3 = h h = F.max_pool2d(h, kernel_size=2, stride=2) h = F.relu(self.conv4_1(h), inplace=True) h = F.relu(self.conv4_2(h), inplace=True) h = F.relu(self.conv4_3(h), inplace=True) # relu4_3 = h h = F.relu(self.conv5_1(h), inplace=True) h = F.relu(self.conv5_2(h), inplace=True) h = F.relu(self.conv5_3(h), inplace=True) relu5_3 = h return relu5_3
def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(F.max_pool2d(self.conv2(x), 2)) x = x.view(-1, 320) x = F.relu(self.fc1(x)) x = self.fc2(x) return x
def forward(self, x): if self.transform_input: x = x.clone() x[:, 0] = x[:, 0] * (0.229 / 0.5) + (0.485 - 0.5) / 0.5 x[:, 1] = x[:, 1] * (0.224 / 0.5) + (0.456 - 0.5) / 0.5 x[:, 2] = x[:, 2] * (0.225 / 0.5) + (0.406 - 0.5) / 0.5 else: warn("Input isn't transformed") x = self.Conv2d_1a_3x3(x) x = self.Conv2d_2a_3x3(x) x = self.Conv2d_2b_3x3(x) x = F.max_pool2d(x, kernel_size=3, stride=2) x = self.Conv2d_3b_1x1(x) x = self.Conv2d_4a_3x3(x) x = F.max_pool2d(x, kernel_size=3, stride=2) x = self.Mixed_5b(x) x = self.Mixed_5c(x) x = self.Mixed_5d(x) x = self.Mixed_6a(x) x = self.Mixed_6b(x) x = self.Mixed_6c(x) x = self.Mixed_6d(x) x = self.Mixed_6e(x) x = self.Mixed_7a(x) x = self.Mixed_7b(x) x_for_attn = x = self.Mixed_7c(x) # 8 x 8 x 2048 x = F.avg_pool2d(x, kernel_size=8) # 1 x 1 x 2048 x_for_capt = x = x.view(x.size(0), -1) # 2048 x = self.fc(x) # 1000 (num_classes) return x_for_attn, x_for_capt, x
def forward(self, x): x1 = self.conv1(x) x1 = F.max_pool2d(x1, 3, stride=2) x2 = self.fire2(x1) x3 = self.fire3(x2) if self.bypass: x3 = x3 + x2 x4 = self.fire4(x3) x4 = F.max_pool2d(x4, 3, stride=2) x5 = self.fire5(x4) if self.bypass: x5 = x5 + x4 x6 = self.fire6(x5) x7 = self.fire7(x6) if self.bypass: x7 = x7 + x6 x8 = self.fire8(x7) x8 = F.max_pool2d(x8, 3, stride=2) x9 = self.fire9(x8) if self.bypass: x9 = x9 + x8 x9 = F.dropout(x9, training=self.training) x10 = F.relu(self.conv10(x9)) f = F.avg_pool2d(x10, x10.size()[2:]).view(x10.size(0), -1) if not self.training: return f if self.loss == {'xent'}: return f elif self.loss == {'xent', 'htri'}: return f, f else: raise KeyError("Unsupported loss: {}".format(self.loss))
def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(F.max_pool2d(self.conv2(x), 2)) x = x.view(-1, 7*7*64) x = F.relu(self.fc1(x)) x = F.dropout(x, 0.4) x = self.fc2(x) return F.log_softmax(x, dim=1)
def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(F.max_pool2d(self.conv2(x), 2)) x = x.view(-1, 1600) x = F.relu(self.fc1(x)) x = F.dropout(x, training=self.training) x = self.fc2(x) return th.abs(10 - x)
def forward(self, x): x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) # max pooling over a 2x2 window x = F.max_pool2d(F.relu(self.conv2(x)), 2) # square x can only specify single number x = x.view(-1, self.num_flat_features(x)) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x
def forward(self, x): steps=x.shape[0] batch=x.shape[1] x=x.view(x.shape[0]*x.shape[1],1,-1,11) out = F.max_pool2d(self.conv1(x), (2, 1)) out = F.max_pool2d(self.conv2(out), (2, 2)) out= out.view(steps,batch,-1) return out
def forward(self, x, y, z): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(F.max_pool2d(self.conv2(x), 2)) x = x.view(-1, 1600) x = F.relu(self.fc1(x)) x = F.dropout(x, training=self.training) x = self.fc2(x) return F.log_softmax(x), F.log_softmax(x), F.log_softmax(x)
def forward(self, x): x = F.max_pool2d(F.relu(self.convolution_0(x)), (2, 2)) x = F.max_pool2d(F.relu(self.convolution_1(x)), (2, 2)) x = x.view(-1, 32 * 5 * 5) x = F.relu(self.fully_connected_0(x)) x = F.relu(self.fully_connected_1(x)) x = self.fully_connected_2(x) return x
def forward(self,x): x = F.max_pool2d(F.relu(self.conv1(x)),(2,2)) x = F.max_pool2d(F.relu(self.conv2(x)),2) x = x.view(x.size()[0],-1) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x
def forward(self, x): x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) x = F.max_pool2d(F.relu(self.conv2(x)), 2) x = x.view(-1, self.num_flat_features(x)) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x
def forward(self, x): x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) x = F.max_pool2d(F.relu(self.conv2(x)), 2) # when shape is square, a single number is fine. x = x.view(-1, self.num_flat_features(x)) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x
def forward(self, x): x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) # Max pooling over a (2, 2) window x = F.max_pool2d(F.relu(self.conv2(x)), 2) # If the size is a square you can only specify a single number x = x.view(-1, self.num_flat_features(x)) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x
def siam(patch, params): o = conv2d(patch, params, 'conv0', stride=3) o = F.max_pool2d(F.relu(o), 2, 2) o = conv2d(o, params, 'conv1') o = F.max_pool2d(F.relu(o), 2, 2) o = conv2d(o, params, 'conv2') o = F.relu(o) return o.view(o.size(0), -1)
def deepcompare_2ch(input, params): o = conv2d(input, params, 'conv0', stride=3) o = F.max_pool2d(F.relu(o), 2, 2) o = conv2d(o, params, 'conv1') o = F.max_pool2d(F.relu(o), 2, 2) o = conv2d(o, params, 'conv2') o = F.relu(o).view(o.size(0), -1) return linear(o, params, 'fc')
def forward(self, x): x = F.relu(self.conv1(x)) x = F.max_pool2d(x, kernel_size=2, stride=2) x = F.relu(self.conv2(x)) x = F.max_pool2d(x, kernel_size=2, stride=2) x = x.view([-1, 21 * 21 * 64]) x = self.fc1(x) x = F.dropout(x, p=0.4, training=self.training) return F.softmax(self.fc2(x))
def forward(self, x): x = F.relu(self.conv1(x)) x = F.max_pool2d(x, 2, 2) x = F.relu(self.conv2(x)) x = F.max_pool2d(x, 2, 2) x = x.view(-1, 4 * 4 * 50) x = F.relu(self.fc1(x)) x = self.fc2(x) return F.log_softmax(x, dim=1)
def forward(self, x): if self.transform_input: x = x.clone() x[:, 0] = x[:, 0] * (0.229 / 0.5) + (0.485 - 0.5) / 0.5 x[:, 1] = x[:, 1] * (0.224 / 0.5) + (0.456 - 0.5) / 0.5 x[:, 2] = x[:, 2] * (0.225 / 0.5) + (0.406 - 0.5) / 0.5 # 299 x 299 x 3 x = self.Conv2d_1a_3x3(x) # 149 x 149 x 32 x = self.Conv2d_2a_3x3(x) # 147 x 147 x 32 x = self.Conv2d_2b_3x3(x) # 147 x 147 x 64 x = F.max_pool2d(x, kernel_size=3, stride=2) # 73 x 73 x 64 x = self.Conv2d_3b_1x1(x) # 73 x 73 x 80 x = self.Conv2d_4a_3x3(x) # 71 x 71 x 192 x = F.max_pool2d(x, kernel_size=3, stride=2) # 35 x 35 x 192 x = self.Mixed_5b(x) # 35 x 35 x 256 x = self.Mixed_5c(x) # 35 x 35 x 288 x = self.Mixed_5d(x) # 35 x 35 x 288 x = self.Mixed_6a(x) # 17 x 17 x 768 x = self.Mixed_6b(x) # 17 x 17 x 768 x = self.Mixed_6c(x) # 17 x 17 x 768 x = self.Mixed_6d(x) # 17 x 17 x 768 x = self.Mixed_6e(x) # 17 x 17 x 768 if self.training and self.aux_logits: aux = self.AuxLogits(x) # 17 x 17 x 768 x = self.Mixed_7a(x) # 8 x 8 x 1280 x = self.Mixed_7b(x) # 8 x 8 x 2048 x = self.Mixed_7c(x) # 8 x 8 x 2048 x = F.avg_pool2d(x, kernel_size=8) # 1 x 1 x 2048 x = F.dropout(x, training=self.training) # 1 x 1 x 2048 x = x.view(x.size(0), -1) # 2048 x = self.fc(x) # 1000 (num_classes) if self.training and self.aux_logits: return x, aux return x
def forward(self, x): x = F.relu(self.conv1(x)) x = F.max_pool2d(x, 2) x = F.relu(self.conv2(x)) x = F.max_pool2d(x, 2) out = x.view(x.size(0), -1) out = F.relu(self.fc1(out)) out = self.fc2(out) return out
def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2)) #x = x.view(-1, 320) x = x.view((x.size(0), -1)) x = F.relu(self.fc1(x)) #x = F.dropout(x, training=self.training) x = self.fc2(x) return x
def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 2)) x = F.relu(self.conv2(x)) x = F.relu(F.max_pool2d(self.conv3(x), 2)) x = F.relu(self.conv4(x)) x = x.view(-1, 4200) x = F.relu(self.fc1(x)) action_scores = self.fc2(x) return F.softmax(action_scores)
def forward(self, src, lengths=None): """See :func:`onmt.encoders.encoder.EncoderBase.forward()`""" batch_size = src.size(0) # (batch_size, 64, imgH, imgW) # layer 1 src = F.relu(self.layer1(src[:, :, :, :] - 0.5), True) # (batch_size, 64, imgH/2, imgW/2) src = F.max_pool2d(src, kernel_size=(2, 2), stride=(2, 2)) # (batch_size, 128, imgH/2, imgW/2) # layer 2 src = F.relu(self.layer2(src), True) # (batch_size, 128, imgH/2/2, imgW/2/2) src = F.max_pool2d(src, kernel_size=(2, 2), stride=(2, 2)) # (batch_size, 256, imgH/2/2, imgW/2/2) # layer 3 # batch norm 1 src = F.relu(self.batch_norm1(self.layer3(src)), True) # (batch_size, 256, imgH/2/2, imgW/2/2) # layer4 src = F.relu(self.layer4(src), True) # (batch_size, 256, imgH/2/2/2, imgW/2/2) src = F.max_pool2d(src, kernel_size=(1, 2), stride=(1, 2)) # (batch_size, 512, imgH/2/2/2, imgW/2/2) # layer 5 # batch norm 2 src = F.relu(self.batch_norm2(self.layer5(src)), True) # (batch_size, 512, imgH/2/2/2, imgW/2/2/2) src = F.max_pool2d(src, kernel_size=(2, 1), stride=(2, 1)) # (batch_size, 512, imgH/2/2/2, imgW/2/2/2) src = F.relu(self.batch_norm3(self.layer6(src)), True) # # (batch_size, 512, H, W) all_outputs = [] for row in range(src.size(2)): inp = src[:, :, row, :].transpose(0, 2) \ .transpose(1, 2) row_vec = torch.Tensor(batch_size).type_as(inp.data) \ .long().fill_(row) pos_emb = self.pos_lut(row_vec) with_pos = torch.cat( (pos_emb.view(1, pos_emb.size(0), pos_emb.size(1)), inp), 0) outputs, hidden_t = self.rnn(with_pos) all_outputs.append(outputs) out = torch.cat(all_outputs, 0) return hidden_t, out, lengths
def forward(self, input, lengths=None): "See :obj:`onmt.modules.EncoderBase.forward()`" batch_size = input.size(0) # (batch_size, 64, imgH, imgW) # layer 1 input = F.relu(self.layer1(input[:, :, :, :]-0.5), True) # (batch_size, 64, imgH/2, imgW/2) input = F.max_pool2d(input, kernel_size=(2, 2), stride=(2, 2)) # (batch_size, 128, imgH/2, imgW/2) # layer 2 input = F.relu(self.layer2(input), True) # (batch_size, 128, imgH/2/2, imgW/2/2) input = F.max_pool2d(input, kernel_size=(2, 2), stride=(2, 2)) # (batch_size, 256, imgH/2/2, imgW/2/2) # layer 3 # batch norm 1 input = F.relu(self.batch_norm1(self.layer3(input)), True) # (batch_size, 256, imgH/2/2, imgW/2/2) # layer4 input = F.relu(self.layer4(input), True) # (batch_size, 256, imgH/2/2/2, imgW/2/2) input = F.max_pool2d(input, kernel_size=(1, 2), stride=(1, 2)) # (batch_size, 512, imgH/2/2/2, imgW/2/2) # layer 5 # batch norm 2 input = F.relu(self.batch_norm2(self.layer5(input)), True) # (batch_size, 512, imgH/2/2/2, imgW/2/2/2) input = F.max_pool2d(input, kernel_size=(2, 1), stride=(2, 1)) # (batch_size, 512, imgH/2/2/2, imgW/2/2/2) input = F.relu(self.batch_norm3(self.layer6(input)), True) # # (batch_size, 512, H, W) all_outputs = [] for row in range(input.size(2)): inp = input[:, :, row, :].transpose(0, 2)\ .transpose(1, 2) row_vec = torch.Tensor(batch_size).type_as(inp.data)\ .long().fill_(row) pos_emb = self.pos_lut(Variable(row_vec)) with_pos = torch.cat( (pos_emb.view(1, pos_emb.size(0), pos_emb.size(1)), inp), 0) outputs, hidden_t = self.rnn(with_pos) all_outputs.append(outputs) out = torch.cat(all_outputs, 0) return hidden_t, out
def stream(input, name): o = conv2d(input, params, name + '.conv0') o = F.max_pool2d(F.relu(o), 2, 2) o = conv2d(o, params, name + '.conv1') o = F.max_pool2d(F.relu(o), 2, 2) o = conv2d(o, params, name + '.conv2') o = F.relu(o) o = conv2d(o, params, name + '.conv3') o = F.relu(o) return o.view(o.size(0), -1)
def forward(self, x): out = F.relu(self.conv1(x)) out = F.max_pool2d(out, 2) out = F.relu(self.conv2(out)) out = F.max_pool2d(out, 2) out = out.view(out.size(0), -1) out = F.relu(self.fc1(out)) out = F.relu(self.fc2(out)) out = self.fc3(out) return out
def count_neurons(self, image_dim): x = Variable(torch.rand(1, *image_dim)) x = F.relu(F.max_pool2d(self.convolution1(x), 3, 2)) x = F.relu(F.max_pool2d(self.convolution2(x), 3, 2)) x = F.relu(F.max_pool2d(self.convolution3(x), 3, 2)) return x.data.view(1, -1).size(1)
def ConvBlockFunction(x, w, b, w_bn, b_bn): x = F.conv2d(x, w, b, padding=1) x = F.batch_norm(x, running_mean=None, running_var=None, weight=w_bn, bias=b_bn, training=True) x = F.relu(x) x = F.max_pool2d(x, kernel_size=2, stride=2) return x
def forward(self, x, loc, label_class=None, label_box=None): ''' Param: x: FloatTensor(batch_num, 3, H, W) loc: FloatTensor(batch_num, 4) label_class: LongTensor(batch_num, N_max) or None label_box: FloatTensor(batch_num, N_max, 4) or None Return 1: loss: FloatTensor(batch_num) Return 2: cls_i_preds: LongTensor(batch_num, topk) cls_p_preds: FloatTensor(batch_num, topk) reg_preds: FloatTensor(batch_num, topk, 4) ''' w_2_in = self.w_relu(self.w_2_in) w_3_in = self.w_relu(self.w_3_in) w_2_in /= torch.sum(w_2_in, dim=0) + self.eps w_3_in /= torch.sum(w_3_in, dim=0) + self.eps C3, C4, C5 = self.backbone(x) D5 = self.bi1_prj1_5(C5) D5 = self.bi1_prj1_5bn(D5) D4 = self.bi1_prj1_4(C4) D4 = self.bi1_prj1_4bn(D4) D3 = self.bi1_prj1_3(C3) D3 = self.bi1_prj1_3bn(D3) E4 = self.bi1_prj2_4( (w_2_in[0][0] * D4 + w_2_in[1][0] * self.upsample(D5))) F3 = self.bi1_prj3_3( (w_2_in[0][1] * D3 + w_2_in[1][1] * self.upsample(E4))) F4 = self.bi1_prj3_4((w_3_in[0][0] * self.downsample(F3) + w_3_in[1][0] * E4 + w_3_in[2][0] * D4)) F5 = self.bi1_prj3_5( (w_2_in[0][2] * D5 + w_2_in[1][2] * self.downsample(F4))) G4 = self.bi2_prj2_4( (w_2_in[0][3] * F4 + w_2_in[1][3] * self.upsample(F5))) H3 = self.bi2_prj3_3( (w_2_in[0][4] * F3 + w_2_in[1][4] * self.upsample(G4))) H4 = self.bi2_prj3_4((w_3_in[0][1] * self.downsample(H3) + w_3_in[1][1] * G4 + w_3_in[2][1] * F4)) H5 = self.bi2_prj3_5( (w_2_in[0][5] * F5 + w_2_in[1][5] * self.downsample(H4))) P6 = self.conv_out6(C5) P7 = self.conv_out7(self.relu(P6)) P3, P4, P5, P6, P7 = H3, H4, H5, P6, P7 # log = [w_2_in.data.cpu().numpy(), w_3_in.data.cpu().numpy()] # np.save('./bifpn_weight/weight_log', log) # print('w_2_in = {0}, w_3_in={1}'.format(w_2_in.data.cpu().numpy(), w_3_in.data.cpu().numpy())) if self.balanced_fpn: # kernel_size, stride, padding, dilation, False, False P3 = F.max_pool2d(P3, 3, 2, 1, 1, False, False) P5 = self.upsample(P5) P4 = (P3 + P4 + P5) / 3.0 # kernel_size, stride, padding, False, False P5 = F.avg_pool2d(P4, 3, 2, 1, False, False) P3 = self.upsample(P4) pred_list = [P3, P4, P5, P6, P7] assert len(pred_list) == self.scales # assert len(pred_list) == len(self.scales) cls_out = [] reg_out = [] for item in pred_list: cls_i = self.conv_cls(item) reg_i = self.conv_reg(item) # cls_i: [b, an*classes, H, W] -> [b, H*W*an, classes] cls_i = cls_i.permute(0, 2, 3, 1).contiguous() cls_i = cls_i.view(cls_i.shape[0], -1, self.classes) # reg_i: [b, an*4, H, W] -> [b, H*W*an, 4] reg_i = reg_i.permute(0, 2, 3, 1).contiguous() reg_i = reg_i.view(reg_i.shape[0], -1, 4) cls_out.append(cls_i) reg_out.append(reg_i) # cls_out[b, hwan, classes] # reg_out[b, hwan, 4] cls_out = torch.cat(cls_out, dim=1) reg_out = torch.cat(reg_out, dim=1) if (label_class is not None) and (label_box is not None): targets_cls, targets_reg = self._encode( label_class, label_box, loc) # (b, hwan), (b, hwan, 4) mask_cls = targets_cls > -1 # (b, hwan) mask_reg = targets_cls > 0 # (b, hwan) num_pos = torch.sum(mask_reg, dim=1).clamp_(min=self.scales) # (b) # num_pos = torch.sum(mask_reg, dim=1).clamp_(min=len(self.scales)) # (b) loss = [] for b in range(targets_cls.shape[0]): cls_out_b = cls_out[b][mask_cls[b]] # (S+-, classes) reg_out_b = reg_out[b][mask_reg[b]] # (S+, 4) targets_cls_b = targets_cls[b][mask_cls[b]] # (S+-) targets_reg_b = targets_reg[b][mask_reg[b]] # # (S+, 4) loss_cls_b = sigmoid_focal_loss(cls_out_b, targets_cls_b, 2.0, 0.25).sum().view(1) loss_reg_b = smooth_l1_loss(reg_out_b, targets_reg_b, 0.11).sum().view(1) loss.append((loss_cls_b + loss_reg_b) / float(num_pos[b])) return torch.cat(loss, dim=0) # (b else: return self._decode(cls_out, reg_out, loc)
def forward(self, x): x = F.max_pool2d(F.pad(x, (0, 1, 0, 1), mode='replicate'), 2, stride=1) return x
def forward(self, x): if self.transform_input: x_ch0 = torch.unsqueeze(x[:, 0], 1) * (0.229 / 0.5) + (0.485 - 0.5) / 0.5 x_ch1 = torch.unsqueeze(x[:, 1], 1) * (0.224 / 0.5) + (0.456 - 0.5) / 0.5 x_ch2 = torch.unsqueeze(x[:, 2], 1) * (0.225 / 0.5) + (0.406 - 0.5) / 0.5 x = torch.cat((x_ch0, x_ch1, x_ch2), 1) # 299 x 299 x 3 x = self.Conv2d_1a_3x3(x) # 149 x 149 x 32 x = self.Conv2d_2a_3x3(x) # 147 x 147 x 32 x = self.Conv2d_2b_3x3(x) # 147 x 147 x 64 x = F.max_pool2d(x, kernel_size=3, stride=2) # 73 x 73 x 64 x = self.Conv2d_3b_1x1(x) # 73 x 73 x 80 x = self.Conv2d_4a_3x3(x) # 71 x 71 x 192 x = F.max_pool2d(x, kernel_size=3, stride=2) # 35 x 35 x 192 x = self.Mixed_5b(x) # 35 x 35 x 256 x = self.Mixed_5c(x) # 35 x 35 x 288 x = self.Mixed_5d(x) # 35 x 35 x 288 y = self.Mixed_6a(x) # 17 x 17 x 768 y = self.Mixed_6b(y) # 17 x 17 x 768 y = self.Mixed_6c(y) # 17 x 17 x 768 y = self.Mixed_6d(y) # 17 x 17 x 768 y = self.Mixed_6e(y) # 17 x 17 x 768 if self.training and self.aux_logits: aux = self.AuxLogits(y) # 17 x 17 x 768 z = self.Mixed_7a(y) # 8 x 8 x 1280 z = self.Mixed_7b(z) # 8 x 8 x 2048 z = self.Mixed_7c(z) # 8 x 8 x 2048 if self.is_fusion: return x, y, z z = F.avg_pool2d(z, kernel_size=8) # 1 x 1 x 2048 z = F.dropout(z, training=self.training) # 1 x 1 x 2048 z = z.view(z.size(0), -1) # 2048 z = self.fc_(z) # 1000 (num_classes) if self.training and self.aux_logits: return z, aux return z
def forward(self, x): out = F.relu( self.en1_bn(F.max_pool2d(self.en1(self.encoder1(x)), 2, 2))) out1 = F.relu( self.enf1_bn( F.interpolate(self.enf1(self.encoderf1(x)), scale_factor=(2, 2), mode='bilinear'))) tmp = out out = torch.add( out, F.interpolate(F.relu(self.inte1_1bn(self.intere1_1(out1))), scale_factor=(0.25, 0.25), mode='bilinear')) out1 = torch.add( out1, F.interpolate(F.relu(self.inte1_2bn(self.intere1_2(tmp))), scale_factor=(4, 4), mode='bilinear')) u1 = out o1 = out1 out = F.relu( self.en2_bn(F.max_pool2d(self.en2(self.encoder2(out)), 2, 2))) out1 = F.relu( self.enf2_bn( F.interpolate(self.enf2(self.encoderf2(out1)), scale_factor=(2, 2), mode='bilinear'))) tmp = out out = torch.add( out, F.interpolate(F.relu(self.inte2_1bn(self.intere2_1(out1))), scale_factor=(0.0625, 0.0625), mode='bilinear')) out1 = torch.add( out1, F.interpolate(F.relu(self.inte2_2bn(self.intere2_2(tmp))), scale_factor=(16, 16), mode='bilinear')) u2 = out o2 = out1 out = F.relu( self.en3_bn(F.max_pool2d(self.en3(self.encoder3(out)), 2, 2))) out1 = F.relu( self.enf3_bn( F.interpolate(self.enf3(self.encoderf3(out1)), scale_factor=(2, 2), mode='bilinear'))) tmp = out out = torch.add( out, F.interpolate(F.relu(self.inte3_1bn(self.intere3_1(out1))), scale_factor=(0.015625, 0.015625), mode='bilinear')) out1 = torch.add( out1, F.interpolate(F.relu(self.inte3_2bn(self.intere3_2(tmp))), scale_factor=(64, 64), mode='bilinear')) ### End of encoder block # print(out.shape,out1.shape) out = F.relu( self.de1_bn( F.interpolate(self.de1(self.decoder1(out)), scale_factor=(2, 2), mode='bilinear'))) out1 = F.relu( self.def1_bn(F.max_pool2d(self.def1(self.decoderf1(out1)), 2, 2))) tmp = out out = torch.add( out, F.interpolate(F.relu(self.intd1_1bn(self.interd1_1(out1))), scale_factor=(0.0625, 0.0625), mode='bilinear')) out1 = torch.add( out1, F.interpolate(F.relu(self.intd1_2bn(self.interd1_2(tmp))), scale_factor=(16, 16), mode='bilinear')) out = torch.add(out, u2) out1 = torch.add(out1, o2) out = F.relu( self.de2_bn( F.interpolate(self.de2(self.decoder2(out)), scale_factor=(2, 2), mode='bilinear'))) out1 = F.relu( self.def2_bn(F.max_pool2d(self.def2(self.decoderf2(out1)), 2, 2))) tmp = out out = torch.add( out, F.interpolate(F.relu(self.intd2_1bn(self.interd2_1(out1))), scale_factor=(0.25, 0.25), mode='bilinear')) out1 = torch.add( out1, F.interpolate(F.relu(self.intd2_2bn(self.interd2_2(tmp))), scale_factor=(4, 4), mode='bilinear')) out = torch.add(out, u1) out1 = torch.add(out1, o1) out = F.relu( self.de3_bn( F.interpolate(self.de3(self.decoder3(out)), scale_factor=(2, 2), mode='bilinear'))) out1 = F.relu( self.def3_bn(F.max_pool2d(self.def3(self.decoderf3(out1)), 2, 2))) out = torch.add(out, out1) out = F.relu(self.final(out)) # out = self.soft(out) # print(out.shape) return out
def forward(ctx, input, return_aggregation, win_size, peak_filter): ctx.num_flags = 4 # assert win_size % 2 == 1, 'Window size for peak finding must be odd.' # offset = (win_size - 1) // 2 # padding = torch.nn.ConstantPad2d(offset, float('-inf')) # padded_maps = padding(input) # batch_size, num_channels, h, w = padded_maps.size() # element_map = torch.arange(0, h * w).long().view(1, 1, h, w)[:, :, offset: -offset, offset: -offset] # element_map = element_map.to(input.device) # _, indices = F.max_pool2d( # padded_maps, # kernel_size=win_size, # stride=1, # return_indices=True) # peak_map = (indices == element_map) peak_map = None if type(win_size) == type([1, 2, 3]): for win in win_size: offset = (win - 1) // 2 padding = torch.nn.ConstantPad2d(offset, float('-inf')) padded_maps = padding(input) batch_size, num_channels, h, w = padded_maps.size() element_map = torch.arange(0, h * w).long().view( 1, 1, h, w)[:, :, offset:-offset, offset:-offset] element_map = element_map.to(input.device) _, indices = F.max_pool2d(padded_maps, kernel_size=win, stride=1, return_indices=True) if peak_map is None: peak_map = (indices == element_map) else: peak_map += peak_map else: offset = (win_size - 1) // 2 padding = torch.nn.ConstantPad2d(offset, float('-inf')) padded_maps = padding(input) batch_size, num_channels, h, w = padded_maps.size() element_map = torch.arange(0, h * w).long().view(1, 1, h, w)[:, :, offset:-offset, offset:-offset] element_map = element_map.to(input.device) _, indices = F.max_pool2d(padded_maps, kernel_size=win_size, stride=1, return_indices=True) peak_map = (indices == element_map) np_input_person = padded_maps.cpu().data.numpy()[0, 16, :, :] person_indices = indices.cpu().data.numpy()[0, 16, :, :] np_peak_map_person = peak_map.cpu().data.numpy()[0, 16, :, :] # peak filtering if peak_filter: mask = input >= peak_filter(input) peak_map = (peak_map * mask) peak_list = torch.nonzero(peak_map) ctx.mark_non_differentiable(peak_list) # peak aggregation if return_aggregation: peak_map = peak_map.float() ctx.save_for_backward(input, peak_map) return peak_list, (input * peak_map).view( batch_size, num_channels, -1).sum(2) / peak_map.view( batch_size, num_channels, -1).sum(2) else: return peak_list
def forward(self, x): out = self.conv(F.relu(self.bn(x))) out = F.max_pool2d(out, 2) return out
def forward(self, x): p = int(np.floor((self.kernel_size - 1) / 2)) p2d = (p, p, p, p) return F.max_pool2d(F.pad(x, p2d), self.kernel_size, stride=2)
def forward(self, x): # print('x',x.size()) y = self.encode(x) # y,x尺寸一致 # print('y',y.size()) y_small = F.max_pool2d(y, kernel_size=2, stride=2) return y, y_small
def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: out = self.layers(x) return out, F.max_pool2d(out, 2)
1000, ), ("matinv", MF.matinv, torch.inverse, [(10, 10)], [(30, 30)], True, 1000), ( "matmul", MF.matmul, torch.matmul, [(64, 32), (32, 64)], [(2048, 1024), (1024, 2048)], True, 1000, ), ( "max_pool2d", lambda x: MF.max_pool2d(x, 2), lambda x: TF.max_pool2d(x, 2), [(2, 32, 16, 16)], [(64, 512, 16, 16)], True, 1000, ), ( "normal", lambda x: mge.random.normal(0, 1, x.shape), lambda x: torch.randn(x.shape, device="cuda"), [(100, 100)], [(64, 512, 16, 16)], True, 1000, ), (
def forward(self, x): return [F.max_pool2d(x, 1, 2, 0)]
def forward(self, rgb_inputs, depth_inputs): ######## DEPTH ENCODER ######## # Stage 1 x = self.conv11d(depth_inputs) x_1 = self.CBR1_D(x) x, id1_d = F.max_pool2d(x_1, kernel_size=2, stride=2, return_indices=True) # Stage 2 x_2 = self.CBR2_D(x) x, id2_d = F.max_pool2d(x_2, kernel_size=2, stride=2, return_indices=True) # Stage 3 x_3 = self.CBR3_D(x) x, id3_d = F.max_pool2d(x_3, kernel_size=2, stride=2, return_indices=True) x = self.dropout3_d(x) # Stage 4 x_4 = self.CBR4_D(x) x, id4_d = F.max_pool2d(x_4, kernel_size=2, stride=2, return_indices=True) x = self.dropout4_d(x) # Stage 5 x_5 = self.CBR5_D(x) ######## RGB ENCODER ######## # Stage 1 y = self.CBR1_RGB(rgb_inputs) y = torch.add(y, x_1) y, id1 = F.max_pool2d(y, kernel_size=2, stride=2, return_indices=True) # Stage 2 y = self.CBR2_RGB(y) y = torch.add(y, x_2) y, id2 = F.max_pool2d(y, kernel_size=2, stride=2, return_indices=True) # Stage 3 y = self.CBR3_RGB(y) y = torch.add(y, x_3) y, id3 = F.max_pool2d(y, kernel_size=2, stride=2, return_indices=True) y = self.dropout3(y) # Stage 4 y = self.CBR4_RGB(y) y = torch.add(y, x_4) y, id4 = F.max_pool2d(y, kernel_size=2, stride=2, return_indices=True) y = self.dropout4(y) # Stage 5 y = self.CBR5_RGB(y) y = torch.add(y, x_5) y_size = y.size() y, id5 = F.max_pool2d(y, kernel_size=2, stride=2, return_indices=True) y = self.dropout5(y) ######## DECODER ######## # Stage 5 dec y = F.max_unpool2d(y, id5, kernel_size=2, stride=2, output_size=y_size) y = self.CBR5_Dec(y) # Stage 4 dec y = F.max_unpool2d(y, id4, kernel_size=2, stride=2) y = self.CBR4_Dec(y) # Stage 3 dec y = F.max_unpool2d(y, id3, kernel_size=2, stride=2) y = self.CBR3_Dec(y) # Stage 2 dec y = F.max_unpool2d(y, id2, kernel_size=2, stride=2) y = self.CBR2_Dec(y) # Stage 1 dec y = F.max_unpool2d(y, id1, kernel_size=2, stride=2) y = self.CBR1_Dec(y) return y
def forward(self, x): # Stage 1 x11 = F.relu(self.conv1_1(x)) x12 = F.relu(self.conv1_2(x11)) x1p, id1 = F.max_pool2d(x12, kernel_size=(2, 2), stride=(2, 2), return_indices=True) # Stage 2 x21 = F.relu(self.conv2_1(x1p)) x22 = F.relu(self.conv2_2(x21)) x2p, id2 = F.max_pool2d(x22, kernel_size=(2, 2), stride=(2, 2), return_indices=True) # Stage 3 x31 = F.relu(self.conv3_1(x2p)) x32 = F.relu(self.conv3_2(x31)) x33 = F.relu(self.conv3_3(x32)) x3p, id3 = F.max_pool2d(x33, kernel_size=(2, 2), stride=(2, 2), return_indices=True) # Stage 4 x41 = F.relu(self.conv4_1(x3p)) x42 = F.relu(self.conv4_2(x41)) x43 = F.relu(self.conv4_3(x42)) x4p, id4 = F.max_pool2d(x43, kernel_size=(2, 2), stride=(2, 2), return_indices=True) # Stage 5 x51 = F.relu(self.conv5_1(x4p)) x52 = F.relu(self.conv5_2(x51)) x53 = F.relu(self.conv5_3(x52)) x5p, id5 = F.max_pool2d(x53, kernel_size=(2, 2), stride=(2, 2), return_indices=True) # Stage 6 x61 = F.relu(self.conv6_1(x5p)) # Stage 6d x61d = F.relu(self.deconv6_1(x61)) # Stage 5d x5d = F.max_unpool2d(x61d, id5, kernel_size=2, stride=2) x51d = F.relu(self.deconv5_1(x5d)) # Stage 4d x4d = F.max_unpool2d(x51d, id4, kernel_size=2, stride=2) x41d = F.relu(self.deconv4_1(x4d)) # Stage 3d x3d = F.max_unpool2d(x41d, id3, kernel_size=2, stride=2) x31d = F.relu(self.deconv3_1(x3d)) # Stage 2d x2d = F.max_unpool2d(x31d, id2, kernel_size=2, stride=2) x21d = F.relu(self.deconv2_1(x2d)) # Stage 1d x1d = F.max_unpool2d(x21d, id1, kernel_size=2, stride=2) x12d = F.relu(self.deconv1_1(x1d)) # Should add sigmoid? github repo add so. raw_alpha = self.deconv1(x12d) pred_mattes = F.sigmoid(raw_alpha) if self.stage <= 1: return pred_mattes, 0 # Stage2 refine conv1 refine0 = torch.cat((x[:, :3, :, :], pred_mattes), 1) refine1 = F.relu(self.refine_conv1(refine0)) refine2 = F.relu(self.refine_conv2(refine1)) refine3 = F.relu(self.refine_conv3(refine2)) # Should add sigmoid? # sigmoid lead to refine result all converge to 0... #pred_refine = F.sigmoid(self.refine_pred(refine3)) pred_refine = self.refine_pred(refine3) pred_alpha = F.sigmoid(raw_alpha + pred_refine) #print(pred_mattes.mean(), pred_alpha.mean(), pred_refine.sum()) return pred_mattes, pred_alpha
def forward(self, im_data, im_info, gt_boxes, num_boxes): batch_size = im_data.size(0) im_info = im_info.data gt_boxes = gt_boxes.data num_boxes = num_boxes.data # feed image data to base model to obtain base feature map base_feat = self.RCNN_base(im_data) # feed base feature map tp RPN to obtain rois rois, rpn_loss_cls, rpn_loss_bbox = self.RCNN_rpn(base_feat, im_info, gt_boxes, num_boxes) # if it is training phrase, then use ground trubut bboxes for refining if self.training: roi_data = self.RCNN_proposal_target(rois, gt_boxes, num_boxes) rois, rois_label, rois_target, rois_inside_ws, rois_outside_ws = roi_data rois_label = Variable(rois_label.view(-1).long()) rois_target = Variable(rois_target.view(-1, rois_target.size(2))) rois_inside_ws = Variable(rois_inside_ws.view(-1, rois_inside_ws.size(2))) rois_outside_ws = Variable(rois_outside_ws.view(-1, rois_outside_ws.size(2))) else: rois_label = None rois_target = None rois_inside_ws = None rois_outside_ws = None rpn_loss_cls = torch.zeros(1) rpn_loss_bbox = torch.zeros(1) rois = Variable(rois) # do roi pooling based on predicted rois if cfg.POOLING_MODE == 'crop': # pdb.set_trace() # pooled_feat_anchor = _crop_pool_layer(base_feat, rois.view(-1, 5)) grid_xy = _affine_grid_gen(rois.view(-1, 5), base_feat.size()[2:], self.grid_size) grid_yx = torch.stack([grid_xy.data[:,:,:,1], grid_xy.data[:,:,:,0]], 3).contiguous() pooled_feat = self.RCNN_roi_crop(base_feat, Variable(grid_yx).detach()) if cfg.CROP_RESIZE_WITH_MAX_POOL: pooled_feat = F.max_pool2d(pooled_feat, 2, 2) elif cfg.POOLING_MODE == 'align': pooled_feat = self.RCNN_roi_align(base_feat, rois.view(-1, 5)) elif cfg.POOLING_MODE == 'pool': pooled_feat = self.RCNN_roi_pool(base_feat, rois.view(-1,5)) # feed pooled features to top model pooled_feat = self._head_to_tail(pooled_feat) # compute bbox offset bbox_pred = self.RCNN_bbox_pred(pooled_feat) if self.training and not self.class_agnostic: # select the corresponding columns according to roi labels bbox_pred_view = bbox_pred.view(bbox_pred.size(0), int(bbox_pred.size(1) / 4), 4) bbox_pred_select = torch.gather(bbox_pred_view, 1, rois_label.view(rois_label.size(0), 1, 1).expand(rois_label.size(0), 1, 4)) bbox_pred = bbox_pred_select.squeeze(1) # compute object classification probability cls_score = self.RCNN_cls_score(pooled_feat) cls_prob = F.softmax(cls_score, 1) RCNN_loss_cls = torch.zeros(1) RCNN_loss_bbox = torch.zeros(1) if self.training: # classification loss RCNN_loss_cls = F.cross_entropy(cls_score, rois_label) # bounding box regression L1 loss RCNN_loss_bbox = _smooth_l1_loss(bbox_pred, rois_target, rois_inside_ws, rois_outside_ws) cls_prob = cls_prob.view(batch_size, rois.size(1), -1) bbox_pred = bbox_pred.view(batch_size, rois.size(1), -1) # return rois, cls_prob, bbox_pred, rpn_loss_cls, rpn_loss_bbox, RCNN_loss_cls, RCNN_loss_bbox, rois_label return rois, cls_prob, bbox_pred
def forward(self, x): out = F.relu(self.en1_bn(F.max_pool2d(self.encoder1(x), 2, 2))) #U-Net branch out1 = F.relu( self.enf1_bn( F.interpolate(self.encoderf1(x), scale_factor=(2, 2), mode='bilinear'))) #Ki-Net branch tmp = out out = torch.add(out, F.interpolate(F.relu( self.inte1_1bn(self.intere1_1(out1))), scale_factor=(0.25, 0.25), mode='bilinear')) #CRFB out1 = torch.add(out1, F.interpolate(F.relu( self.inte1_2bn(self.intere1_2(tmp))), scale_factor=(4, 4), mode='bilinear')) #CRFB u1 = out #skip conn o1 = out1 #skip conn out = F.relu(self.en2_bn(F.max_pool2d(self.encoder2(out), 2, 2))) out1 = F.relu( self.enf2_bn( F.interpolate(self.encoderf2(out1), scale_factor=(2, 2), mode='bilinear'))) tmp = out out = torch.add( out, F.interpolate(F.relu(self.inte2_1bn(self.intere2_1(out1))), scale_factor=(0.0625, 0.0625), mode='bilinear')) out1 = torch.add( out1, F.interpolate(F.relu(self.inte2_2bn(self.intere2_2(tmp))), scale_factor=(16, 16), mode='bilinear')) u2 = out o2 = out1 out = F.relu(self.en3_bn(F.max_pool2d(self.encoder3(out), 2, 2))) out1 = F.relu( self.enf3_bn( F.interpolate(self.encoderf3(out1), scale_factor=(2, 2), mode='bilinear'))) tmp = out out = torch.add( out, F.interpolate(F.relu(self.inte3_1bn(self.intere3_1(out1))), scale_factor=(0.015625, 0.015625), mode='bilinear')) out1 = torch.add( out1, F.interpolate(F.relu(self.inte3_2bn(self.intere3_2(tmp))), scale_factor=(64, 64), mode='bilinear')) ### End of encoder block ### Start Decoder out = F.relu( self.de1_bn( F.interpolate(self.decoder1(out), scale_factor=(2, 2), mode='bilinear'))) #U-NET out1 = F.relu(self.def1_bn(F.max_pool2d(self.decoderf1(out1), 2, 2))) #Ki-NET tmp = out out = torch.add( out, F.interpolate(F.relu(self.intd1_1bn(self.interd1_1(out1))), scale_factor=(0.0625, 0.0625), mode='bilinear')) out1 = torch.add( out1, F.interpolate(F.relu(self.intd1_2bn(self.interd1_2(tmp))), scale_factor=(16, 16), mode='bilinear')) out = torch.add(out, u2) #skip conn out1 = torch.add(out1, o2) #skip conn out = F.relu( self.de2_bn( F.interpolate(self.decoder2(out), scale_factor=(2, 2), mode='bilinear'))) out1 = F.relu(self.def2_bn(F.max_pool2d(self.decoderf2(out1), 2, 2))) tmp = out out = torch.add( out, F.interpolate(F.relu(self.intd2_1bn(self.interd2_1(out1))), scale_factor=(0.25, 0.25), mode='bilinear')) out1 = torch.add( out1, F.interpolate(F.relu(self.intd2_2bn(self.interd2_2(tmp))), scale_factor=(4, 4), mode='bilinear')) out = torch.add(out, u1) out1 = torch.add(out1, o1) out = F.relu( self.de3_bn( F.interpolate(self.decoder3(out), scale_factor=(2, 2), mode='bilinear'))) out1 = F.relu(self.def3_bn(F.max_pool2d(self.decoderf3(out1), 2, 2))) out = torch.add(out, out1) # fusion of both branches out = F.relu(self.final(out)) #1*1 conv # out = self.soft(out) return out
def forward(self, x): return F.max_pool2d(x, (x.size(-2), x.size(-1)))
def net_forward(x, layer_by_layer=False, from_layer=0): x = x - nrms_mean # cannot be inplace x.div_(nrms_std) if not layer_by_layer: return net(x) cldr = list(net.children()) if args.model.startswith('resnet'): x = net.conv1(x) x = net.bn1(x) x = net.relu(x) x = net.maxpool(x) x = net.layer1(x) x = net.layer2(x) x = net.layer3(x) x = net.layer4(x) outputs = [net.avgpool(x)] flat_features = outputs[-1].view(x.size(0), -1) outputs.append(net.fc(flat_features)) elif args.model.startswith('inception'): # 299 x 299 x 3 x = net.Conv2d_1a_3x3(x) # 149 x 149 x 32 x = net.Conv2d_2a_3x3(x) # 147 x 147 x 32 x = net.Conv2d_2b_3x3(x) # 147 x 147 x 64 x = F.max_pool2d(x, kernel_size=3, stride=2) # 73 x 73 x 64 x = net.Conv2d_3b_1x1(x) # 73 x 73 x 80 x = net.Conv2d_4a_3x3(x) # 71 x 71 x 192 x = F.max_pool2d(x, kernel_size=3, stride=2) # 35 x 35 x 192 x = net.Mixed_5b(x) # 35 x 35 x 256 x = net.Mixed_5c(x) # 35 x 35 x 288 x = net.Mixed_5d(x) # 35 x 35 x 288 x = net.Mixed_6a(x) # 17 x 17 x 768 x = net.Mixed_6b(x) # 17 x 17 x 768 x = net.Mixed_6c(x) # 17 x 17 x 768 x = net.Mixed_6d(x) # 17 x 17 x 768 x = net.Mixed_6e(x) # 17 x 17 x 768 x = net.Mixed_7a(x) # 8 x 8 x 1280 x = net.Mixed_7b(x) # 8 x 8 x 2048 x = net.Mixed_7c(x) # 8 x 8 x 2048 x = F.avg_pool2d(x, kernel_size=8) # 1 x 1 x 2048 outputs = [F.dropout(x, training=net.training)] # 1 x 1 x 2048 flat_features = outputs[-1].view(x.size(0), -1) # 2048 outputs.append(net.fc(flat_features)) # 1000 (num_classes) else: outputs = [net.features(x)] for cidx, c in enumerate(net.classifier.children()): flat_features = outputs[-1].view(x.size(0), -1) outputs.append(c(flat_features)) return outputs
def forward(self, x): features = None # --> fixed-size input: batch x 3 x 299 x 299 x = nn.functional.interpolate(x, size=(299, 299), mode='bilinear', align_corners=False) #上采样或者下采样至给定size # 299 x 299 x 3 x = self.Conv2d_1a_3x3(x) # 149 x 149 x 32 x = self.Conv2d_2a_3x3(x) # 147 x 147 x 32 x = self.Conv2d_2b_3x3(x) # 147 x 147 x 64 x = F.max_pool2d(x, kernel_size=3, stride=2) # 73 x 73 x 64 x = self.Conv2d_3b_1x1(x) # 73 x 73 x 80 x = self.Conv2d_4a_3x3(x) # 71 x 71 x 192 x = F.max_pool2d(x, kernel_size=3, stride=2) # 35 x 35 x 192 x = self.Mixed_5b(x) # 35 x 35 x 256 x = self.Mixed_5c(x) # 35 x 35 x 288 x = self.Mixed_5d(x) # 35 x 35 x 288 x = self.Mixed_6a(x) # 17 x 17 x 768 x = self.Mixed_6b(x) # 17 x 17 x 768 x = self.Mixed_6c(x) # 17 x 17 x 768 x = self.Mixed_6d(x) # 17 x 17 x 768 x = self.Mixed_6e(x) # 17 x 17 x 768 # image region features # features = x # 17 x 17 x 768 x = self.Mixed_7a(x) # 8 x 8 x 1280 x = self.Mixed_7b(x) # 8 x 8 x 2048 x = self.Mixed_7c(x) # 8 x 8 x 2048 # x = F.avg_pool2d(x, kernel_size=8) # 1 x 1 x 2048 # x = F.dropout(x, training=self.training) # 1 x 1 x 2048 # x = x.view(x.size(0), -1) # for visual_feature_extraction.py use this as the output x = x.mean(dim=(2, 3)) # 2048 # global image features # cnn_code = self.emb_cnn_code(x) # 512 # if features is not None: # features = self.emb_features(features) return x #cnn_code #1024
def forward(self, x): #print (x.size()) x = self.init_conv1(x) x = self.init_bn1(x) x = F.relu(x, True) #conv_x1 = x x = self.init_res1(x) x = self.init_conv2(x) #print ("Skip", x.size()) #print ("Skip", conv_x.size()) x = self.init_bn2(x) x = F.relu(x, True) conv_x2 = x x = F.max_pool2d(x, 2) ### can be on 1x1 cov x = self.init_res2(x) x = self.init_res3(x) x = self.core_hourglass(x) #x = self.core_hourglass1(x) #x = self.core_hourglass2(x) x = self.tail_res0(x) x = self.tail_res00(x) x = self.tail_deconv1(x) x = self.tail_bn1(x) x = F.relu(x, True) #print ("Dce 1", x.size()) #split = x #print x.shape x = self.tail_res1(x) #x = self.tail_res1_1(x) ################### x = torch.cat((x, conv_x2),1) x= self.init_conv_union(x) x= self.init_bn_union(x) x = F.relu(x, True) ################### x = self.tail_resx(x) x = self.tail_deconv2(x) x = self.tail_bn2(x) x = F.relu(x, True) x = self.dropout(x) #print ("Dce 2", x.size()) #split = x x = self.tail_res2(x) #out1 = x ################### #x = torch.cat((x,split),1) #x= self.init_conv_union1(x) #x= self.init_bn_union1(x) #x = F.relu(x, True) ################### # Right tail #x = self.rtail_deconv2(split) #x = self.rtail_bn2(x) #x = F.relu(x, True) #x = self.rtail_res2(x) x = self.rtail_res2_2(x) #x = self.rtail_res2_3(x) #out2 = x #out = torch.cat((out1,out2),1) #out1 = self.init_conv3(out1) out2 = self.init_conv4(x) return out2
def forward(self, x): x = self.pre(x) x = F.max_pool2d(x, 2) return self.conv_bn2(self.conv_bn1(x)) + x
def non_maximum_suppression(a): ap = F.max_pool2d(a, 3, stride=1, padding=1) mask = (a == ap).float().clamp(min=0.0) return a * mask
def forward(self, x): x = F.relu(F.max_pool2d(self.conv1(x), 3)) x = x.view(-1, 192) x = self.fc(x) return F.log_softmax(x, dim=1)
def get_conv_output(self, x): # Layer 1: Convolutional + 3x3 Max Pooling + Batch Norm conv1_out = self.conv1(x) pool1_out = F.max_pool2d(conv1_out, 3) bn1_out = self.bn1(pool1_out) # Layer 2: Convolutional + Batch Norm conv2_out = self.conv2(bn1_out) bn2_out = self.bn2(conv2_out) # Layer 3: Convolutional + 2x2 Max Pooling + Batch Norm conv3_out = self.conv3(bn2_out) pool3_out = F.max_pool2d(conv3_out, 2) bn3_out = self.bn3(pool3_out) # Layer 4: Convolutional + Batch Norm conv4_out = self.conv4(bn3_out) bn4_out = self.bn4(conv4_out) # Layer 5: Convolutional + 2x2 Max Pooling + Batch Norm conv5_out = self.conv5(bn4_out) pool5_out = F.max_pool2d(conv5_out, 2) bn5_out = self.bn5(pool5_out) # Layer 6: Convolutional + Batch Norm conv6_out = self.conv6(bn5_out) bn6_out = self.bn6(conv6_out) # Layer 7: Convolutional + 2x2 Max Pooling + Batch Norm conv7_out = self.conv7(bn6_out) pool7_out = F.max_pool2d(conv7_out, 2) bn7_out = HF.modified_bn(self.bn7, pool7_out) # Layer 8: Convolutional + Batch Norm conv8_out = self.conv8(bn7_out) bn8_out = HF.modified_bn(self.bn8, conv8_out) # Build dictionary containing outputs of each layer conv_out = { self.CONV1: conv1_out, self.POOL1: pool1_out, self.BN1: bn1_out, self.CONV2: conv2_out, self.BN2: bn2_out, self.CONV3: conv3_out, self.POOL3: pool3_out, self.BN3: bn3_out, self.CONV4: conv4_out, self.BN4: bn4_out, self.CONV5: conv5_out, self.POOL5: pool5_out, self.BN5: bn5_out, self.CONV6: conv6_out, self.BN6: bn6_out, self.CONV7: conv7_out, self.POOL7: pool7_out, self.BN7: bn7_out, self.CONV8: conv8_out, self.BN8: bn8_out, } return conv_out
def forward(self, x): x = self.conv(x) x = F.max_pool2d(x, kernel_size=x.size()[2:]).squeeze() return self.fc(x)
def forward(self, x): nsample = x.size()[3] x = self.activation(self.bn_avg(self.conv_avg(x))) x = F.max_pool2d(x, kernel_size=(1, nsample)).squeeze(3) return x
def forward(self, x): x = self.static_padding(x) x = F.max_pool2d(x, self.kernel_size, self.stride, self.padding, self.dilation, self.ceil_mode, self.return_indices) return x
def max_pool2d(self, in_features, kernel_size, stride, padding): return F.max_pool2d(in_features, kernel_size=kernel_size, stride=stride, padding=padding)
def max_filter(img): assert img.dim() == 3 img = img.unsqueeze(0) img = tnf.max_pool2d(img, kernel_size=3, stride=1, padding=1) return img.squeeze(0)