Method get_object_feature

main.py:34–106

(self, segSize, img_resized_list, batch_data)

        logging.info(self.classifier)

    def get_object_feature(self, segSize, img_resized_list, batch_data):
        segmentation_module = self.seg_model
        args = self.args
        cfg = self.cfg

        # Upload object features from local file instead of calculating the online
        if args.local_object:
            object_feature = get_obj_onehot_vector(batch_data['info'], args.local_object)
            object_feature = torch.FloatTensor([object_feature]).cuda().view(1,1024,150,1)
            return object_feature

        with torch.no_grad():
            scores = torch.zeros(1, cfg.DATASET.num_class, segSize[0], segSize[1]).cuda()
            feature = torch.zeros(1, 1024, segSize[0], segSize[1]).cuda()
            channels = feature.shape[1]

            for img in img_resized_list:
                feed_dict = batch_data.copy()
                feed_dict['img_data'] = img.cuda()
                del feed_dict['img_ori']
                del feed_dict['info']
                pred_tmp, pred_tmp_feature_map = segmentation_module(feed_dict, segSize=segSize)
                feature = feature + pred_tmp_feature_map / len(cfg.DATASET.imgSizes)
                scores = scores + pred_tmp / len(cfg.DATASET.imgSizes)
            
            # Uncomment the following codes to verify the correctness of following codes.
            # scores = torch.Tensor([[[[1, 0], [1, 0]], [[0, 1], [0, 0]], [[0, 0], [0, 1]]]])
            # feature = torch.Tensor([[[[0.5, 1], [0.5, 2]], [[0.5, 1], [0.5, 2]], [[0.5, 1], [0.5, 2]], [[0.5, 1], [0.5, 2]], [[0.5, 1], [0.5, 2]]]])
            # channels = 5
            # cfg.DATASET.num_class = 3


            # ***Open trigger will double the whole inference speed.****
            # ***However, this trigger will also slightly influence the object feature value** 
            # This inconsistency issue is stemmed from ***Pytorch***, not our method.
            # Even the object feature value will slightly changed, our model is still stable.
            trigger = True
            # Object Feature Aggregation
            if trigger:
                scores = scores.view(cfg.DATASET.num_class, -1)
                s, pred = torch.max(scores, dim=0)
                object_feature = torch.zeros(cfg.DATASET.num_class, channels)
                feature = feature.view(channels, -1).permute((1, 0))
                for i in range(cfg.DATASET.num_class):
                    idx = torch.where(pred == i)
                    score = s[idx]
                    total_score = score.sum()
                    if total_score <= 0:
                        continue
                    chosen = feature[idx]
                    vec = torch.sum(chosen * score.view(-1, 1), dim=0) / total_score
                    object_feature[i] = vec
                object_feature = as_numpy(object_feature)
            else:
                s, pred = torch.max(scores, dim=1)
                object_feature = torch.zeros(cfg.DATASET.num_class, channels).cuda()
                pred_vec = pred.view(1, -1)
                pred_mat = pred_vec.repeat(channels, 1)