2D Keras inplement
    https://gist.github.com/t-ae/6e1016cc188104d123676ccef3264981
    image.png

    1. from keras.utils import conv_utils
    2. from keras.engine.topology import Layer
    3. import keras.backend as K
    6. class PixelShuffler(Layer):
    7.     def __init__(self, size=(2, 2), data_format=None, **kwargs):
    8.         super(PixelShuffler, self).__init__(**kwargs)
    9.         self.data_format = conv_utils.normalize_data_format(data_format)
    10.         self.size = conv_utils.normalize_tuple(size, 2, 'size')
    12.     def call(self, inputs):
    14.         input_shape = K.int_shape(inputs)
    15.         if len(input_shape) != 4:
    16.             raise ValueError('Inputs should have rank ' +
    17.                              str(4) +
    18.                              '; Received input shape:', str(input_shape))
    20.         if self.data_format == 'channels_first':
    21.             batch_size, c, h, w = input_shape
    22.             if batch_size is None:
    23.                 batch_size = -1
    24.             rh, rw = self.size
    25.             oh, ow = h * rh, w * rw
    26.             oc = c // (rh * rw)
    28.             out = K.reshape(inputs, (batch_size, rh, rw, oc, h, w))
    29.             out = K.permute_dimensions(out, (0, 3, 4, 1, 5, 2))
    30.             out = K.reshape(out, (batch_size, oc, oh, ow))
    31.             return out
    33.         elif self.data_format == 'channels_last':
    34.             batch_size, h, w, c = input_shape
    35.             if batch_size is None:
    36.                 batch_size = -1
    37.             rh, rw = self.size
    38.             oh, ow = h * rh, w * rw
    39.             oc = c // (rh * rw)
    41.             out = K.reshape(inputs, (batch_size, h, w, rh, rw, oc))
    42.             out = K.permute_dimensions(out, (0, 1, 3, 2, 4, 5))
    43.             out = K.reshape(out, (batch_size, oh, ow, oc))
    44.             return out
    46.     def compute_output_shape(self, input_shape):
    48.         if len(input_shape) != 4:
    49.             raise ValueError('Inputs should have rank ' +
    50.                              str(4) +
    51.                              '; Received input shape:', str(input_shape))
    53.         if self.data_format == 'channels_first':
    54.             height = input_shape[2] * self.size[0] if input_shape[2] is not None else None
    55.             width = input_shape[3] * self.size[1] if input_shape[3] is not None else None
    56.             channels = input_shape[1] // self.size[0] // self.size[1]
    58.             if channels * self.size[0] * self.size[1] != input_shape[1]:
    59.                 raise ValueError('channels of input and size are incompatible')
    61.             return (input_shape[0],
    62.                     channels,
    63.                     height,
    64.                     width)
    66.         elif self.data_format == 'channels_last':
    67.             height = input_shape[1] * self.size[0] if input_shape[1] is not None else None
    68.             width = input_shape[2] * self.size[1] if input_shape[2] is not None else None
    69.             channels = input_shape[3] // self.size[0] // self.size[1]
    71.             if channels * self.size[0] * self.size[1] != input_shape[3]:
    72.                 raise ValueError('channels of input and size are incompatible')
    74.             return (input_shape[0],
    75.                     height,
    76.                     width,
    77.                     channels)
    79.     def get_config(self):
    80.         config = {'size': self.size,
    81.                   'data_format': self.data_format}
    82.         base_config = super(PixelShuffler, self).get_config()
    84.         return dict(list(base_config.items()) + list(config.items()))

    https://github.com/Nico-Curti/NumPyNet/blob/master/NumPyNet/layers/shuffler_layer.py

    3d pytorch implement

    1. class PixelShuffle3d(nn.Module):
    2.     '''
    3.     This class is a 3d version of pixelshuffle.
    4.     '''
    5.     def __init__(self, scale):
    6.         '''
    7.         :param scale: upsample scale
    8.         '''
    9.         super().__init__()
    10.         self.scale = scale
    12.     def forward(self, input):
    13.         batch_size, channels, in_depth, in_height, in_width = input.size()
    14.         nOut = channels // self.scale ** 3
    16.         out_depth = in_depth * self.scale
    17.         out_height = in_height * self.scale
    18.         out_width = in_width * self.scale
    20.         input_view = input.contiguous().view(batch_size, nOut, self.scale, self.scale, self.scale, in_depth, in_height, in_width)
    22.         output = input_view.permute(0, 1, 5, 2, 6, 3, 7, 4).contiguous()
    24.         return output.view(batch_size, nOut, out_depth, out_height, out_width)