def forward(self, input): x = self.DownBlock(input) gap = F.adaptive_avg_pool2d(x, 1) gap_logit = self.gap_fc(gap.reshape([x.shape[0], -1])) gap_weight = list(self.gap_fc.parameters())[0].transpose([1, 0]) gap = x * gap_weight.unsqueeze(2).unsqueeze(3) gmp = F.adaptive_max_pool2d(x, 1) gmp_logit = self.gmp_fc(gmp.reshape([x.shape[0], -1])) gmp_weight = list(self.gmp_fc.parameters())[0].transpose([1, 0]) gmp = x * gmp_weight.unsqueeze(2).unsqueeze(3) cam_logit = paddle.concat([gap_logit, gmp_logit], 1) x = paddle.concat([gap, gmp], 1) x = self.relu(self.conv1x1(x)) heatmap = paddle.sum(x, axis=1, keepdim=True) if self.light: x_ = F.adaptive_avg_pool2d(x, 1) x_ = self.FC(x_.reshape([x_.shape[0], -1])) else: x_ = self.FC(x.reshape([x.shape[0], -1])) gamma, beta = self.gamma(x_), self.beta(x_) for i in range(self.n_blocks): x = getattr(self, 'UpBlock1_' + str(i + 1))(x, gamma, beta) out = self.UpBlock2(x) return out, cam_logit, heatmap
def forward(self, inputs, drop_connect_rate=None): """ :param inputs: input tensor :param drop_connect_rate: drop connect rate (float, between 0 and 1) :return: output of block """ # Expansion and Depthwise Convolution x = inputs if self._block_args.expand_ratio != 1: x = self._swish(self._bn0(self._expand_conv(inputs))) x = self._swish(self._bn1(self._depthwise_conv(x))) # Squeeze and Excitation if self.has_se: x_squeezed = F.adaptive_avg_pool2d(x, 1) x_squeezed = self._se_expand( self._swish(self._se_reduce(x_squeezed))) x = F.sigmoid(x_squeezed) * x x = self._bn2(self._project_conv(x)) # Skip connection and drop connect input_filters, output_filters = self._block_args.input_filters, self._block_args.output_filters if self.id_skip and self._block_args.stride == 1 and input_filters == output_filters: if drop_connect_rate: x = drop_connect(x, prob=drop_connect_rate, training=self.training) x = x + inputs # skip connection return x
def forward(self, body_feats=None, rois=None, rois_num=None, inputs=None): """ body_feats (list[Tensor]): rois (Tensor): rois_num (Tensor): inputs (dict{Tensor}): """ if self.training: rois, rois_num, _, targets = self.bbox_assigner( rois, rois_num, inputs) self.assigned_rois = (rois, rois_num) self.assigned_targets = targets rois_feat = self.roi_extractor(body_feats, rois, rois_num) bbox_feat = self.head(rois_feat) if self.with_pool: feat = F.adaptive_avg_pool2d(bbox_feat, output_size=1) feat = paddle.squeeze(feat, axis=[2, 3]) else: feat = bbox_feat scores = self.bbox_score(feat) deltas = self.bbox_delta(feat) if self.training: loss = self.get_loss(scores, deltas, targets, rois) return loss, bbox_feat else: pred = self.get_prediction(scores, deltas) return pred, self.head
def forward(self, body_feats=None, rois=None, rois_num=None, inputs=None): """ body_feats (list[Tensor]): Feature maps from backbone rois (list[Tensor]): RoIs generated from RPN module rois_num (Tensor): The number of RoIs in each image inputs (dict{Tensor}): The ground-truth of image """ if self.training: rois, rois_num, targets = self.bbox_assigner(rois, rois_num, inputs) self.assigned_rois = (rois, rois_num) self.assigned_targets = targets rois_feat = self.roi_extractor(body_feats, rois, rois_num) bbox_feat = self.head(rois_feat) if self.with_pool: feat = F.adaptive_avg_pool2d(bbox_feat, output_size=1) feat = paddle.squeeze(feat, axis=[2, 3]) else: feat = bbox_feat scores = self.bbox_score(feat) deltas = self.bbox_delta(feat) if self.training: loss = self.get_loss(scores, deltas, targets, rois, self.bbox_weight) return loss, bbox_feat else: pred = self.get_prediction(scores, deltas) return pred, self.head
def forward(self, feats): assert len(feats) == len(self.fpn_strides), \ "The size of feats is not equal to size of fpn_strides" anchors, anchor_points, num_anchors_list, stride_tensor =\ generate_anchors_for_grid_cell( feats, self.fpn_strides, self.grid_cell_scale, self.grid_cell_offset) anchor_centers_split = paddle.split(anchor_points / stride_tensor, num_anchors_list) cls_score_list, bbox_pred_list = [], [] for feat, scale_reg, anchor_centers, stride in zip( feats, self.scales_regs, anchor_centers_split, self.fpn_strides): b, _, h, w = get_static_shape(feat) inter_feats = [] for inter_conv in self.inter_convs: feat = F.relu(inter_conv(feat)) inter_feats.append(feat) feat = paddle.concat(inter_feats, axis=1) # task decomposition avg_feat = F.adaptive_avg_pool2d(feat, (1, 1)) cls_feat = self.cls_decomp(feat, avg_feat) reg_feat = self.reg_decomp(feat, avg_feat) # cls prediction and alignment cls_logits = self.tood_cls(cls_feat) if self.use_align_head: cls_prob = F.relu(self.cls_prob_conv1(feat)) cls_prob = F.sigmoid(self.cls_prob_conv2(cls_prob)) cls_score = (F.sigmoid(cls_logits) * cls_prob).sqrt() else: cls_score = F.sigmoid(cls_logits) cls_score_list.append(cls_score.flatten(2).transpose([0, 2, 1])) # reg prediction and alignment reg_dist = scale_reg(self.tood_reg(reg_feat).exp()) reg_dist = reg_dist.flatten(2).transpose([0, 2, 1]) reg_bbox = batch_distance2bbox(anchor_centers.unsqueeze(0), reg_dist) if self.use_align_head: reg_offset = F.relu(self.reg_offset_conv1(feat)) reg_offset = self.reg_offset_conv2(reg_offset) reg_bbox = reg_bbox.transpose([0, 2, 1]).reshape([b, 4, h, w]) anchor_centers = anchor_centers.reshape([1, h, w, 2]) bbox_pred = self._reg_grid_sample(reg_bbox, reg_offset, anchor_centers) bbox_pred = bbox_pred.flatten(2).transpose([0, 2, 1]) else: bbox_pred = reg_bbox if not self.training: bbox_pred *= stride bbox_pred_list.append(bbox_pred) cls_score_list = paddle.concat(cls_score_list, axis=1) bbox_pred_list = paddle.concat(bbox_pred_list, axis=1) return cls_score_list, bbox_pred_list, anchors, num_anchors_list, stride_tensor
def forward(self, x): feat = self.conv(x) atten = F.adaptive_avg_pool2d(feat, 1) atten = self.conv_atten(atten) atten = self.bn_atten(atten) atten = self.sigmoid_atten(atten) out = paddle.multiply(feat, atten) return out
def forward(self, feats): assert len(feats) == len(self.fpn_strides), \ "The size of feats is not equal to size of fpn_strides" anchors, num_anchors_list, stride_tensor_list = self._generate_anchors( feats) cls_score_list, bbox_pred_list = [], [] for feat, scale_reg, anchor, stride in zip(feats, self.scales_regs, anchors, self.fpn_strides): b, _, h, w = feat.shape inter_feats = [] for inter_conv in self.inter_convs: feat = F.relu(inter_conv(feat)) inter_feats.append(feat) feat = paddle.concat(inter_feats, axis=1) # task decomposition avg_feat = F.adaptive_avg_pool2d(feat, (1, 1)) cls_feat = self.cls_decomp(feat, avg_feat) reg_feat = self.reg_decomp(feat, avg_feat) # cls prediction and alignment cls_logits = self.tood_cls(cls_feat) if self.use_align_head: cls_prob = F.relu(self.cls_prob_conv1(feat)) cls_prob = F.sigmoid(self.cls_prob_conv2(cls_prob)) cls_score = (F.sigmoid(cls_logits) * cls_prob).sqrt() else: cls_score = F.sigmoid(cls_logits) cls_score_list.append(cls_score.flatten(2).transpose([0, 2, 1])) # reg prediction and alignment reg_dist = scale_reg(self.tood_reg(reg_feat).exp()) reg_dist = reg_dist.transpose([0, 2, 3, 1]).reshape([b, -1, 4]) anchor_centers = bbox_center(anchor).unsqueeze(0) / stride reg_bbox = self._batch_distance2bbox( anchor_centers.tile([b, 1, 1]), reg_dist) if self.use_align_head: reg_bbox = reg_bbox.reshape([b, h, w, 4]).transpose([0, 3, 1, 2]) reg_offset = F.relu(self.reg_offset_conv1(feat)) reg_offset = self.reg_offset_conv2(reg_offset) bbox_pred = self._deform_sampling(reg_bbox, reg_offset) bbox_pred = bbox_pred.flatten(2).transpose([0, 2, 1]) else: bbox_pred = reg_bbox if not self.training: bbox_pred *= stride bbox_pred_list.append(bbox_pred) cls_score_list = paddle.concat(cls_score_list, axis=1) bbox_pred_list = paddle.concat(bbox_pred_list, axis=1) anchors = paddle.concat(anchors) anchors.stop_gradient = True stride_tensor_list = paddle.concat(stride_tensor_list).unsqueeze(0) stride_tensor_list.stop_gradient = True return cls_score_list, bbox_pred_list, anchors, num_anchors_list, stride_tensor_list
def _pp_module(x, psp_size): n, c, h, w = x.shape priors = [] for size in psp_size: feat = F.adaptive_avg_pool2d(x, size) feat = paddle.reshape(feat, shape=(0, c, -1)) priors.append(feat) center = paddle.concat(priors, axis=-1) return center
def forward(self, fsp, fcp): fcat = paddle.concat([fsp, fcp], axis=1) feat = self.convblk(fcat) atten = F.adaptive_avg_pool2d(feat, 1) atten = self.conv1(atten) atten = self.relu(atten) atten = self.conv2(atten) atten = self.sigmoid(atten) feat_atten = paddle.multiply(feat, atten) feat_out = feat_atten + feat return feat_out
def forward(self, x): f1 = self.level1(x) down2 = F.adaptive_avg_pool2d(x, output_size=f1.shape[2:]) feat1 = paddle.concat([f1, down2], axis=1) feat1 = self.br1(feat1) p1 = self.proj1(feat1) f2_res = self.level2_0(feat1) f2 = self.level2(f2_res) down4 = F.adaptive_avg_pool2d(x, output_size=f2.shape[2:]) feat2 = paddle.concat([f2, f2_res, down4], axis=1) feat2 = self.br2(feat2) p2 = self.proj2(feat2) f3_res = self.level3_0(feat2) f3 = self.level3(f3_res) feat3 = paddle.concat([f3, f3_res], axis=1) feat3 = self.br3(feat3) p3 = self.proj3(feat3) return p1, p2, p3
def forward(self, x): mini_size = x[-1].shape[-2:] out = [F.adaptive_avg_pool2d(s, mini_size) for s in x[:-1]] + [x[-1]] out = paddle.concat(out, 1) out = self.conv1(out) out = self.conv2(out) out = paddle.split(out, self.channels, 1) out = [ s * F.interpolate(a, s.shape[-2:], mode='nearest') for s, a in zip(x, out) ] return out
def forward(self, x): bs = x.shape[0] x = self.DownBlock(x) content_features = [] for i in range(self.n_blocks): x = getattr(self, 'EncodeBlock' + str(i + 1))(x) content_features.append( F.adaptive_avg_pool2d(x, 1).reshape([bs, -1])) gap = F.adaptive_avg_pool2d(x, 1) gap_logit = self.gap_fc(gap.reshape([bs, -1])) gap_weight = list(self.gap_fc.parameters())[0].transpose([1, 0]) gap = x * gap_weight.unsqueeze(2).unsqueeze(3) gmp = F.adaptive_max_pool2d(x, 1) gmp_logit = self.gmp_fc(gmp.reshape([bs, -1])) gmp_weight = list(self.gmp_fc.parameters())[0].transpose([1, 0]) gmp = x * gmp_weight.unsqueeze(2).unsqueeze(3) cam_logit = paddle.concat([gap_logit, gmp_logit], 1) x = paddle.concat([gap, gmp], 1) x = self.relu(self.conv1x1(x)) heatmap = paddle.sum(x, axis=1, keepdim=True) if self.light: x_ = F.adaptive_avg_pool2d(x, 1) style_features = self.FC(x_.reshape([bs, -1])) else: style_features = self.FC(x.reshape([bs, -1])) for i in range(self.n_blocks): x = getattr(self, 'DecodeBlock' + str(i + 1))( x, content_features[4 - i - 1], style_features) out = self.UpBlock(x) return out, cam_logit, heatmap
def forward(self, body_feats, rois, spatial_scale, stage=0): bbox_feat, head_feat_func = self.bbox_feat(body_feats, rois, spatial_scale, stage) bbox_head_out = [] if self.with_pool: bbox_feat_ = F.adaptive_avg_pool2d(bbox_feat, output_size=1) bbox_feat_ = paddle.squeeze(bbox_feat_, axis=[2, 3]) scores = self.bbox_score_list[stage](bbox_feat_) deltas = self.bbox_delta_list[stage](bbox_feat_) else: scores = self.bbox_score_list[stage](bbox_feat) deltas = self.bbox_delta_list[stage](bbox_feat) bbox_head_out.append((scores, deltas)) return bbox_feat, bbox_head_out, head_feat_func
def forward(self, fpn_feat, stage_idx): assert stage_idx < len(self.cls_convs) cls_feat = fpn_feat reg_feat = fpn_feat for i in range(len(self.cls_convs[stage_idx])): cls_feat = self.act_func(self.cls_convs[stage_idx][i](cls_feat)) reg_feat = cls_feat if not self.share_cls_reg: reg_feat = self.act_func(self.reg_convs[stage_idx][i](reg_feat)) if self.use_se: avg_feat = F.adaptive_avg_pool2d(cls_feat, (1, 1)) se_feat = self.act_func(self.se[stage_idx](cls_feat, avg_feat)) return cls_feat, se_feat return cls_feat, reg_feat
def forward(self, inputs): y = paddle.reshape( inputs, [-1, inputs.shape[2], inputs.shape[3], inputs.shape[4]]) y = self.conv(y) y = F.max_pool2d(y, kernel_size=3, stride=2, padding=1) for bottleneck_block in self.bottleneck_block_list: y = bottleneck_block(y) y = F.adaptive_avg_pool2d(y, output_size=1) y = F.dropout(y, p=0.5) y = paddle.reshape(y, [-1, self.seg_num, y.shape[1]]) y = paddle.mean(y, axis=1) y = paddle.reshape(y, shape=[-1, 2048]) y = self.out(y) return y
def forward(self, fstudent, fteacher): loss_all = 0.0 for fs, ft in zip(fstudent, fteacher): h = fs.shape[2] loss = F.mse_loss(fs, ft) cnt = 1.0 tot = 1.0 for l in [4, 2, 1]: if l >= h: continue if self.mode == "max": tmpfs = F.adaptive_max_pool2d(fs, (l, l)) tmpft = F.adaptive_max_pool2d(ft, (l, l)) else: tmpfs = F.adaptive_avg_pool2d(fs, (l, l)) tmpft = F.adaptive_avg_pool2d(ft, (l, l)) cnt /= 2.0 loss += F.mse_loss(tmpfs, tmpft) * cnt tot += cnt loss = loss / tot loss_all = loss_all + loss return loss_all
def forward(self, x): # N x 768 x 17 x 17 x = F.avg_pool2d(x, kernel_size=5, stride=3) # N x 768 x 5 x 5 x = self.conv0(x) # N x 128 x 5 x 5 x = self.conv1(x) # N x 768 x 1 x 1 # Adaptive average pooling x = F.adaptive_avg_pool2d(x, (1, 1)) # N x 768 x 1 x 1 x = paddle.flatten(x, 1) # N x 768 x = self.fc(x) # N x 1000 return x
def forward(self, feat, avg_feat=None): b, _, h, w = feat.shape if avg_feat is None: avg_feat = F.adaptive_avg_pool2d(feat, (1, 1)) weight = F.relu(self.la_conv1(avg_feat)) weight = F.sigmoid(self.la_conv2(weight)) # here new_conv_weight = layer_attention_weight * conv_weight # in order to save memory and FLOPs. conv_weight = weight.reshape([b, 1, self.stacked_convs, 1]) * \ self.reduction_conv.conv.weight.reshape( [1, self.feat_channels, self.stacked_convs, self.feat_channels]) conv_weight = conv_weight.reshape( [b, self.feat_channels, self.in_channels]) feat = feat.reshape([b, self.in_channels, h * w]) feat = paddle.bmm(conv_weight, feat).reshape([b, self.feat_channels, h, w]) if self.norm_type is not None: feat = self.reduction_conv.norm(feat) feat = F.relu(feat) return feat
def forward(self, x): feat2, feat4, feat8, feat16, feat32 = self.backbone(x) feat8_hw = paddle.shape(feat8)[2:] feat16_hw = paddle.shape(feat16)[2:] feat32_hw = paddle.shape(feat32)[2:] avg = F.adaptive_avg_pool2d(feat32, 1) avg = self.conv_avg(avg) avg_up = F.interpolate(avg, feat32_hw, mode='nearest') feat32_arm = self.arm32(feat32) feat32_sum = feat32_arm + avg_up feat32_up = F.interpolate(feat32_sum, feat16_hw, mode='nearest') feat32_up = self.conv_head32(feat32_up) feat16_arm = self.arm16(feat16) feat16_sum = feat16_arm + feat32_up feat16_up = F.interpolate(feat16_sum, feat8_hw, mode='nearest') feat16_up = self.conv_head16(feat16_up) return feat2, feat4, feat8, feat16, feat16_up, feat32_up # x8, x16
def forward(self, body_feats=None, rois=None, spatial_scale=None, stage=0, roi_stage=-1): if rois is not None: rois_feat, bbox_feat = self.bbox_feat(body_feats, rois, spatial_scale, stage) self.roi_feat_list[stage] = rois_feat else: rois_feat = self.roi_feat_list[roi_stage] bbox_feat = self.bbox_feat.head_feat(rois_feat, stage) if self.with_pool: bbox_feat_ = F.adaptive_avg_pool2d(bbox_feat, output_size=1) bbox_feat_ = paddle.squeeze(bbox_feat_, axis=[2, 3]) scores = self.bbox_score_list[stage](bbox_feat_) deltas = self.bbox_delta_list[stage](bbox_feat_) else: scores = self.bbox_score_list[stage](bbox_feat) deltas = self.bbox_delta_list[stage](bbox_feat) bbox_head_out = (scores, deltas) return bbox_feat, bbox_head_out, self.bbox_feat.head_feat
def forward(self, x): x = self.model(x) gap = F.adaptive_avg_pool2d(x, 1) gap_logit = self.gap_fc(gap.reshape([x.shape[0], -1])) gap_weight = list(self.gap_fc.parameters())[0].transpose([1, 0]) gap = x * gap_weight.unsqueeze(2).unsqueeze(3) gmp = F.adaptive_max_pool2d(x, 1) gmp_logit = self.gmp_fc(gmp.reshape([x.shape[0], -1])) gmp_weight = list(self.gmp_fc.parameters())[0].transpose([1, 0]) gmp = x * gmp_weight.unsqueeze(2).unsqueeze(3) cam_logit = paddle.concat([gap_logit, gmp_logit], 1) x = paddle.concat([gap, gmp], 1) x = self.leaky_relu(self.conv1x1(x)) heatmap = paddle.sum(x, axis=1, keepdim=True) x = self.pad(x) out = self.conv(x) return out, cam_logit, heatmap
def search_mobilenetv2_block(config, args, image_size): image_shape = [3, image_size, image_size] transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])]) if args.data == 'cifar10': train_dataset = paddle.vision.datasets.Cifar10(mode='train', transform=transform, backend='cv2') val_dataset = paddle.vision.datasets.Cifar10(mode='test', transform=transform, backend='cv2') elif args.data == 'imagenet': train_dataset = imagenet_reader.ImageNetDataset(mode='train') val_dataset = imagenet_reader.ImageNetDataset(mode='val') places = static.cuda_places() if args.use_gpu else static.cpu_places() place = places[0] if args.is_server: sa_nas = SANAS(config, server_addr=(args.server_address, args.port), search_steps=args.search_steps, is_server=True) else: sa_nas = SANAS(config, server_addr=(args.server_address, args.port), search_steps=args.search_steps, is_server=False) for step in range(args.search_steps): archs = sa_nas.next_archs()[0] train_program = static.Program() test_program = static.Program() startup_program = static.Program() with static.program_guard(train_program, startup_program): data_shape = [None] + image_shape data = static.data(name='data', shape=data_shape, dtype='float32') label = static.data(name='label', shape=[None, 1], dtype='int64') if args.data == 'cifar10': paddle.assign(paddle.reshape(label, [-1, 1]), label) train_loader = paddle.io.DataLoader(train_dataset, places=places, feed_list=[data, label], drop_last=True, batch_size=args.batch_size, return_list=False, shuffle=True, use_shared_memory=True, num_workers=4) val_loader = paddle.io.DataLoader(val_dataset, places=place, feed_list=[data, label], drop_last=False, batch_size=args.batch_size, return_list=False, shuffle=False) data = conv_bn_layer(input=data, num_filters=32, filter_size=3, stride=2, padding='SAME', act='relu6', name='mobilenetv2_conv1') data = archs(data)[0] data = conv_bn_layer(input=data, num_filters=1280, filter_size=1, stride=1, padding='SAME', act='relu6', name='mobilenetv2_last_conv') data = F.adaptive_avg_pool2d(data, output_size=[1, 1], name='mobilenetv2_last_pool') output = static.nn.fc( x=data, size=args.class_dim, weight_attr=ParamAttr(name='mobilenetv2_fc_weights'), bias_attr=ParamAttr(name='mobilenetv2_fc_offset')) softmax_out = F.softmax(output) cost = F.cross_entropy(softmax_out, label=label) avg_cost = paddle.mean(cost) acc_top1 = paddle.metric.accuracy(input=softmax_out, label=label, k=1) acc_top5 = paddle.metric.accuracy(input=softmax_out, label=label, k=5) test_program = train_program.clone(for_test=True) optimizer = paddle.optimizer.Momentum( learning_rate=0.1, momentum=0.9, weight_decay=paddle.regularizer.L2Decay(1e-4)) optimizer.minimize(avg_cost) current_flops = flops(train_program) print('step: {}, current_flops: {}'.format(step, current_flops)) if current_flops > int(321208544): continue exe = static.Executor(place) exe.run(startup_program) build_strategy = static.BuildStrategy() train_compiled_program = static.CompiledProgram( train_program).with_data_parallel(loss_name=avg_cost.name, build_strategy=build_strategy) for epoch_id in range(args.retain_epoch): for batch_id, data in enumerate(train_loader()): fetches = [avg_cost.name] s_time = time.time() outs = exe.run(train_compiled_program, feed=data, fetch_list=fetches)[0] batch_time = time.time() - s_time if batch_id % 10 == 0: _logger.info( 'TRAIN: steps: {}, epoch: {}, batch: {}, cost: {}, batch_time: {}ms' .format(step, epoch_id, batch_id, outs[0], batch_time)) reward = [] for batch_id, data in enumerate(val_loader()): test_fetches = [avg_cost.name, acc_top1.name, acc_top5.name] batch_reward = exe.run(test_program, feed=data, fetch_list=test_fetches) reward_avg = np.mean(np.array(batch_reward), axis=1) reward.append(reward_avg) _logger.info( 'TEST: step: {}, batch: {}, avg_cost: {}, acc_top1: {}, acc_top5: {}' .format(step, batch_id, batch_reward[0], batch_reward[1], batch_reward[2])) finally_reward = np.mean(np.array(reward), axis=0) _logger.info( 'FINAL TEST: avg_cost: {}, acc_top1: {}, acc_top5: {}'.format( finally_reward[0], finally_reward[1], finally_reward[2])) sa_nas.reward(float(finally_reward[1]))
def _scale(self, input, inplace): scale = F.adaptive_avg_pool2d(input, 1) scale = self.fc1(scale) scale = self.relu(scale) scale = self.fc2(scale) return F.hardsigmoid(scale, inplace=inplace)