#!/usr/bin/env python

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import math

import numpy as np
import chainer.functions as F
from chainer import Variable
from chainer import cuda


def bilinear_interpolation_kernel(in_channels, out_channels, ksize):
    """calculate a bilinear interpolation kernel

    Args:
        in_channels (int): Number of channels of input arrays. If ``None``,
            parameter initialization will be deferred until the first forward
            data pass at which time the size will be determined.
        out_channels (int): Number of channels of output arrays.
        ksize (int): Size of filters (a.k.a. kernels).
    """

    factor = (ksize + 1) / 2
    if ksize % 2 == 1:
        center = factor - 1
    else:
        center = factor - 0.5
    og = np.ogrid[:ksize, :ksize]
    k = (1 - abs(og[0] - center) / factor) * (1 - abs(og[1] - center) / factor)
                                                                                
    W = np.zeros((in_channels, out_channels, ksize, ksize)).astype(np.float32)
    W[range(in_channels), range(out_channels), :, :] = k
    return W


def crop_to_target(x, target):
    """Crop variable to target shape.

    Args:
        x (~chainer.Variable): Input variable of shape :math:`(n, c_I, h, w)`.
        target (~chainer.Variable): Variable with target output shape
            :math:`(n, h, w)` or `(n, c_I, h, w)`.
    """

    if target.ndim==3:
        t_h, t_w = target.shape[1], target.shape[2]
    elif target.ndim==4:
        t_h, t_w = target.shape[2], target.shape[3]
    cr = int((x.shape[2] - t_h) / 2)
    cc = int((x.shape[3] - t_w) / 2)
    x_cropped = x[:, :, cr:cr + t_h, cc:cc + t_w]
    return x_cropped
            

def global_average_pooling_2d(x, use_cudnn=True):
    """Spatial global average pooling function.

    Args:
        x (~chainer.Variable): Input variable.
        use_cudnn (bool): If ``True`` and cuDNN is enabled, then this function
            uses cuDNN as the core implementation.
    """

    return F.average_pooling_2d(x, ksize=(x.shape[2], x.shape[3]), use_cudnn=use_cudnn)

71863177a0252afa5d83ee4675e9861ce7a48392
<mask token>


def global_average_pooling_2d(x, use_cudnn=True):
    """Spatial global average pooling function.

    Args:
        x (~chainer.Variable): Input variable.
        use_cudnn (bool): If ``True`` and cuDNN is enabled, then this function
            uses cuDNN as the core implementation.
    """
    return F.average_pooling_2d(x, ksize=(x.shape[2], x.shape[3]),
        use_cudnn=use_cudnn)

<mask token>


def crop_to_target(x, target):
    """Crop variable to target shape.

    Args:
        x (~chainer.Variable): Input variable of shape :math:`(n, c_I, h, w)`.
        target (~chainer.Variable): Variable with target output shape
            :math:`(n, h, w)` or `(n, c_I, h, w)`.
    """
    if target.ndim == 3:
        t_h, t_w = target.shape[1], target.shape[2]
    elif target.ndim == 4:
        t_h, t_w = target.shape[2], target.shape[3]
    cr = int((x.shape[2] - t_h) / 2)
    cc = int((x.shape[3] - t_w) / 2)
    x_cropped = x[:, :, cr:cr + t_h, cc:cc + t_w]
    return x_cropped


def global_average_pooling_2d(x, use_cudnn=True):
    """Spatial global average pooling function.

    Args:
        x (~chainer.Variable): Input variable.
        use_cudnn (bool): If ``True`` and cuDNN is enabled, then this function
            uses cuDNN as the core implementation.
    """
    return F.average_pooling_2d(x, ksize=(x.shape[2], x.shape[3]),
        use_cudnn=use_cudnn)

<mask token>


def bilinear_interpolation_kernel(in_channels, out_channels, ksize):
    """calculate a bilinear interpolation kernel

    Args:
        in_channels (int): Number of channels of input arrays. If ``None``,
            parameter initialization will be deferred until the first forward
            data pass at which time the size will be determined.
        out_channels (int): Number of channels of output arrays.
        ksize (int): Size of filters (a.k.a. kernels).
    """
    factor = (ksize + 1) / 2
    if ksize % 2 == 1:
        center = factor - 1
    else:
        center = factor - 0.5
    og = np.ogrid[:ksize, :ksize]
    k = (1 - abs(og[0] - center) / factor) * (1 - abs(og[1] - center) / factor)
    W = np.zeros((in_channels, out_channels, ksize, ksize)).astype(np.float32)
    W[range(in_channels), range(out_channels), :, :] = k
    return W


def crop_to_target(x, target):
    """Crop variable to target shape.

    Args:
        x (~chainer.Variable): Input variable of shape :math:`(n, c_I, h, w)`.
        target (~chainer.Variable): Variable with target output shape
            :math:`(n, h, w)` or `(n, c_I, h, w)`.
    """
    if target.ndim == 3:
        t_h, t_w = target.shape[1], target.shape[2]
    elif target.ndim == 4:
        t_h, t_w = target.shape[2], target.shape[3]
    cr = int((x.shape[2] - t_h) / 2)
    cc = int((x.shape[3] - t_w) / 2)
    x_cropped = x[:, :, cr:cr + t_h, cc:cc + t_w]
    return x_cropped


def global_average_pooling_2d(x, use_cudnn=True):
    """Spatial global average pooling function.

    Args:
        x (~chainer.Variable): Input variable.
        use_cudnn (bool): If ``True`` and cuDNN is enabled, then this function
            uses cuDNN as the core implementation.
    """
    return F.average_pooling_2d(x, ksize=(x.shape[2], x.shape[3]),
        use_cudnn=use_cudnn)

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import math
import numpy as np
import chainer.functions as F
from chainer import Variable
from chainer import cuda


def bilinear_interpolation_kernel(in_channels, out_channels, ksize):
    """calculate a bilinear interpolation kernel

    Args:
        in_channels (int): Number of channels of input arrays. If ``None``,
            parameter initialization will be deferred until the first forward
            data pass at which time the size will be determined.
        out_channels (int): Number of channels of output arrays.
        ksize (int): Size of filters (a.k.a. kernels).
    """
    factor = (ksize + 1) / 2
    if ksize % 2 == 1:
        center = factor - 1
    else:
        center = factor - 0.5
    og = np.ogrid[:ksize, :ksize]
    k = (1 - abs(og[0] - center) / factor) * (1 - abs(og[1] - center) / factor)
    W = np.zeros((in_channels, out_channels, ksize, ksize)).astype(np.float32)
    W[range(in_channels), range(out_channels), :, :] = k
    return W


def crop_to_target(x, target):
    """Crop variable to target shape.

    Args:
        x (~chainer.Variable): Input variable of shape :math:`(n, c_I, h, w)`.
        target (~chainer.Variable): Variable with target output shape
            :math:`(n, h, w)` or `(n, c_I, h, w)`.
    """
    if target.ndim == 3:
        t_h, t_w = target.shape[1], target.shape[2]
    elif target.ndim == 4:
        t_h, t_w = target.shape[2], target.shape[3]
    cr = int((x.shape[2] - t_h) / 2)
    cc = int((x.shape[3] - t_w) / 2)
    x_cropped = x[:, :, cr:cr + t_h, cc:cc + t_w]
    return x_cropped


def global_average_pooling_2d(x, use_cudnn=True):
    """Spatial global average pooling function.

    Args:
        x (~chainer.Variable): Input variable.
        use_cudnn (bool): If ``True`` and cuDNN is enabled, then this function
            uses cuDNN as the core implementation.
    """
    return F.average_pooling_2d(x, ksize=(x.shape[2], x.shape[3]),
        use_cudnn=use_cudnn)

#!/usr/bin/env python

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import math

import numpy as np
import chainer.functions as F
from chainer import Variable
from chainer import cuda


def bilinear_interpolation_kernel(in_channels, out_channels, ksize):
    """calculate a bilinear interpolation kernel

    Args:
        in_channels (int): Number of channels of input arrays. If ``None``,
            parameter initialization will be deferred until the first forward
            data pass at which time the size will be determined.
        out_channels (int): Number of channels of output arrays.
        ksize (int): Size of filters (a.k.a. kernels).
    """

    factor = (ksize + 1) / 2
    if ksize % 2 == 1:
        center = factor - 1
    else:
        center = factor - 0.5
    og = np.ogrid[:ksize, :ksize]
    k = (1 - abs(og[0] - center) / factor) * (1 - abs(og[1] - center) / factor)
                                                                                
    W = np.zeros((in_channels, out_channels, ksize, ksize)).astype(np.float32)
    W[range(in_channels), range(out_channels), :, :] = k
    return W


def crop_to_target(x, target):
    """Crop variable to target shape.

    Args:
        x (~chainer.Variable): Input variable of shape :math:`(n, c_I, h, w)`.
        target (~chainer.Variable): Variable with target output shape
            :math:`(n, h, w)` or `(n, c_I, h, w)`.
    """

    if target.ndim==3:
        t_h, t_w = target.shape[1], target.shape[2]
    elif target.ndim==4:
        t_h, t_w = target.shape[2], target.shape[3]
    cr = int((x.shape[2] - t_h) / 2)
    cc = int((x.shape[3] - t_w) / 2)
    x_cropped = x[:, :, cr:cr + t_h, cc:cc + t_w]
    return x_cropped
            

def global_average_pooling_2d(x, use_cudnn=True):
    """Spatial global average pooling function.

    Args:
        x (~chainer.Variable): Input variable.
        use_cudnn (bool): If ``True`` and cuDNN is enabled, then this function
            uses cuDNN as the core implementation.
    """

    return F.average_pooling_2d(x, ksize=(x.shape[2], x.shape[3]), use_cudnn=use_cudnn)
