python source code of bilinear_interpolation2d

Project: Parsing-R-CNN (GitHub Link)

Parsing-R-CNN-master
- utils
  - checkpointer.py
  - lr_scheduler.py
  - optimizer.py
  - misc.py
  - comm.py
  - image.py
  - measure.py
  - vis.py
  - collections.py
  - logger.py
  - registry.py
  - net.py
  - data
    - datasets
      - coco.py
      - concat_dataset.py
      - __init__.py
    - structures
      - bounding_box.py
      - keypoint.py
      - parsing.py
      - segmentation_mask.py
      - __init__.py
      - densepose_uv.py
      - boxlist_ops.py
      - image_list.py
    - dataset_catalog.py
    - evaluation
      - densepose_methods.py
      - densepose_cocoeval.py
      - parsing_eval.py
    - collate_batch.py
    - __init__.py
    - samplers
      - distributed.py
      - repeat_factor.py
      - iteration_based_batch_sampler.py
      - grouped_batch_sampler.py
      - __init__.py
      - range_sampler.py
    - transforms
      - __init__.py
      - transforms.py
  - colormap.py
  - subprocess.py
  - __init__.py
  - timer.py
- rcnn
  - datasets
    - evaluation.py
    - transform.py
    - dataset_catalog.py
    - __init__.py
    - dataset.py
  - utils
    - misc.py
    - balanced_positive_negative_sampler.py
    - matcher.py
    - poolers.py
    - box_coder.py
    - __init__.py
  - modeling
    - uv_rcnn
      - outputs.py
      - loss.py
      - heads
        convx_heads.py
        gce_heads.py
        __init__.py
      - inference.py
      - uv_rcnn.py
    - mask_rcnn
      - outputs.py
      - loss.py
      - heads
        convx_heads.py
        __init__.py
      - __init__.py
      - inference.py
      - mask_rcnn.py
    - keypoint_rcnn
      - outputs.py
      - loss.py
      - heads
        convx_heads.py
        gce_heads.py
        __init__.py
      - __init__.py
      - keypoint_rcnn.py
      - inference.py
    - fpn
      - HRFPN.py
      - FPN.py
      - __init__.py
    - backbone
      - ResNet.py
      - MobileNet_v1.py
      - HRNet.py
      - MobileNet_v2.py
      - ResNeXt.py
      - MobileNet_v3.py
      - __init__.py
      - VoVNet.py
    - registry.py
    - parsing_rcnn
      - outputs.py
      - loss.py
      - parsing_rcnn.py
      - heads
        convx_heads.py
        gce_heads.py
        __init__.py
      - __init__.py
      - inference.py
    - fast_rcnn
      - outputs.py
      - fast_rcnn.py
      - loss.py
      - heads
        mlp_heads.py
        convfc_heads.py
        __init__.py
      - __init__.py
      - inference.py
    - cascade_rcnn
      - outputs.py
      - loss.py
      - cascade_rcnn.py
      - heads
        mlp_heads.py
        convfc_heads.py
        __init__.py
      - __init__.py
      - inference.py
    - rpn
      - rpn.py
      - loss.py
      - __init__.py
      - inference.py
      - anchor_generator.py
    - model_builder.py
  - __init__.py
  - ops
    - roi_align.py
    - roi_pool.py
    - deform_pool.py
    - __init__.py
  - core
    - config.py
    - test_engine.py
    - __init__.py
    - test.py
- weights
  - README.md
- LICENSE
- models
  - __init__.py
  - ops
    - pool_points_interp.py
    - mixture_batchnorm.py
    - dropblock.py
    - misc.py
    - scale.py
    - conv2d_samepadding.py
    - l2_loss.py
    - batch_norm.py
    - cython_nms.pyx
    - nonlocal2d.py
    - setup_rcnn.py
    - bilinear_interpolation2d.py
    - dcn
      - deform_conv_func.py
      - deform_conv_module.py
      - deform_pool_func.py
      - deform_pool_module.py
      - __init__.py
    - smooth_l1_loss.py
    - conv2d_ws.py
    - adjust_smooth_l1_loss.py
    - cython_bbox.pyx
    - boxes.py
    - squeeze_excitation.py
    - label_smoothing.py
    - affine.py
    - __init__.py
    - l2norm.py
    - csrc
      - PoolPointsInterp.h
      - ROIAlign.h
      - deform_pool.h
      - cuda
        deform_pool_kernel_cuda.cu
        ROIPool_cuda.cu
        SigmoidFocalLoss_cuda.cu
        ROIAlign_cuda.cu
        ml_nms.cu
        vision.h
        nms.cu
        PoolPointsInterp_cuda.cu
        deform_pool_cuda.cu
        deform_conv_cuda.cu
        deform_conv_kernel_cuda.cu
      - ROIPool.h
      - ml_nms.h
      - cpu
        vision.h
        ROIAlign_cpu.cpp
        nms_cpu.cpp
      - SigmoidFocalLoss.h
      - deform_conv.h
      - vision.cpp
      - nms.h
    - sigmoid_focal_loss.py
    - context_block.py
    - setup_ssd.py
    - lovasz_hinge_loss.py
    - nms.py
    - iou_loss.py
  - imagenet
    - hrnet.py
    - mobilenet_v1.py
    - mobilenet_v2.py
    - resnet.py
    - __init__.py
    - utils.py
    - resnext.py
    - mobilenet_v3.py
    - vovnet.py
- ckpts
  - README.md
- data
- README.md
- tools
  - _init_paths.py
  - test_net.py
  - train_net.py
- requirements.txt
- INSTALL.md
- make.sh
- cfgs
  - MHP-v2
    - e2e_parsing_rcnn_R-50-FPN_1x_ms.yaml
    - e2e_parsing_rcnn_R-50-FPN_3x_ms.yaml
  - CIHP
    - e2e_parsing_rcnn_R-50-FPN_1x_ms.yaml
    - e2e_parsing_rcnn_R-50-FPN_3x_ms.yaml
  - DensePose_COCO
    - e2e_parsing_rcnn_R-50-FPN_s1x_ms.yaml

import numpy as np

import torch
import torch.nn as nn
import torch.nn.functional as F


class BilinearInterpolation2d(nn.Module):
    """Bilinear interpolation in space of scale.

    Takes input of NxKxHxW and outputs NxKx(sH)x(sW), where s:= up_scale

    Adapted from the CVPR'15 FCN code.
    See: https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py
    """
    def __init__(self, in_channels, out_channels, up_scale):
        super().__init__()
        assert in_channels == out_channels
        assert up_scale % 2 == 0, 'Scale should be even'
        self.in_channes = in_channels
        self.out_channels = out_channels
        self.up_scale = int(up_scale)
        self.padding = up_scale // 2

        def upsample_filt(size):
            factor = (size + 1) // 2
            if size % 2 == 1:
                center = factor - 1
            else:
                center = factor - 0.5
            og = np.ogrid[:size, :size]
            return ((1 - abs(og[0] - center) / factor) *
                    (1 - abs(og[1] - center) / factor))

        kernel_size = up_scale * 2
        bil_filt = upsample_filt(kernel_size)

        kernel = np.zeros(
            (in_channels, out_channels, kernel_size, kernel_size), dtype=np.float32
        )
        kernel[range(in_channels), range(out_channels), :, :] = bil_filt

        self.upconv = nn.ConvTranspose2d(in_channels, out_channels, kernel_size,
                                         stride=self.up_scale, padding=self.padding)

        self.upconv.weight.data.copy_(torch.from_numpy(kernel))
        self.upconv.bias.data.fill_(0)
        self.upconv.weight.requires_grad = False
        self.upconv.bias.requires_grad = False

    def forward(self, x):
        return self.upconv(x)