text: import math
  
  import torch
  import torch.nn as nn
  import torch.nn.functional as F
  
  from torch.autograd import Variable
  cuda=True
  def default_conv(in_channels, out_channels, kernel_size, bias=True):
      return nn.Conv2d(
          in_channels, out_channels, kernel_size,
          padding=(kernel_size//2), bias=bias)
  
  class MeanShift(nn.Conv2d):
      def __init__(self, rgb_range, rgb_mean, rgb_std, sign=-1):
          super(MeanShift, self).__init__(3, 3, kernel_size=1)
          if cuda:
              std = torch.Tensor(rgb_std).cuda()
              self.weight.data = torch.eye(3).view(3, 3, 1, 1).cuda()
          else:
              std = torch.Tensor(rgb_std)
              self.weight.data = torch.eye(3).view(3, 3, 1, 1)
          self.weight.data.div_(std.view(3, 1, 1, 1)).half()
          self.bias.data = (sign * rgb_range * rgb_mean)
          self.bias.data.div_(std)
          self.requires_grad = False
  
  class BasicBlock(nn.Sequential):
      def __init__(
          self, in_channels, out_channels, kernel_size, stride=1, bias=False,
          bn=True, act=nn.ReLU(True)):
  
          m = [nn.Conv2d(
              in_channels, out_channels, kernel_size,
              padding=(kernel_size//2), stride=stride, bias=bias)
          ]
          if bn: m.append(nn.BatchNorm2d(out_channels))
          if act is not None: m.append(act)
          super(BasicBlock, self).__init__(*m)
  
  class ResBlock(nn.Module):
      def __init__(
          self, conv, n_feats, kernel_size,
          bias=True, bn=False, act=nn.ReLU(True), res_scale=1):
  
          super(ResBlock, self).__init__()
          m = []
          for i in range(2):
              m.append(conv(n_feats, n_feats, kernel_size, bias=bias))
              if bn: m.append(nn.BatchNorm2d(n_feats))
              if i == 0: m.append(act)
  
          self.body = nn.Sequential(*m)
          self.res_scale = res_scale
  
      def forward(self, x):
          res = self.body(x).mul(self.res_scale)
          res += x
  
          return res
  
  class Upsampler_part1(nn.Sequential):
      def __init__(self, conv, scale, n_feats, bn=False, act=False, bias=True):
  
          m = []
          if (scale & (scale - 1)) == 0:    # Is scale = 2^n?
              for _ in range(int(math.log(scale, 2))):
                  m.append(conv(n_feats, 4 * n_feats, 3, bias))
  
          elif scale == 3:
              m.append(conv(n_feats, 9 * n_feats, 3, bias))
  
          else:
              raise NotImplementedError
  
          super(Upsampler_part1, self).__init__(*m)
  
  class Upsampler_part2(nn.Sequential):
      def __init__(self, conv, scale, n_feats, bn=False, act=False, bias=True):
  
          m = []
          if (scale & (scale - 1)) == 0:    # Is scale = 2^n?
              for _ in range(int(math.log(scale, 2))):
                  m.append(nn.PixelShuffle(2))
                  if bn: m.append(nn.BatchNorm2d(n_feats))
  
                  if act == 'relu':
                      m.append(nn.ReLU(True))
                  elif act == 'prelu':
                      m.append(nn.PReLU(n_feats))
  
          elif scale == 3:
              m.append(nn.PixelShuffle(3))
              if bn: m.append(nn.BatchNorm2d(n_feats))
  
              if act == 'relu':
                  m.append(nn.ReLU(True))
              elif act == 'prelu':
                  m.append(nn.PReLU(n_feats))
          else:
              raise NotImplementedError
  
          super(Upsampler_part2, self).__init__(*m)
  class Upsampler(nn.Sequential):
      def __init__(self, conv, scale, n_feats, bn=False, act=False, bias=True):
  
          m = []
          if (scale & (scale - 1)) == 0:    # Is scale = 2^n?
              for _ in range(int(math.log(scale, 2))):
                  m.append(conv(n_feats, 4 * n_feats, 3, bias))
                  m.append(nn.PixelShuffle(2))
                  if bn: m.append(nn.BatchNorm2d(n_feats))
  
                  if act == 'relu':
                      m.append(nn.ReLU(True))
                  elif act == 'prelu':
                      m.append(nn.PReLU(n_feats))
  
          elif scale == 3:
              m.append(conv(n_feats, 9 * n_feats, 3, bias))
              m.append(nn.PixelShuffle(3))
              if bn: m.append(nn.BatchNorm2d(n_feats))
  
              if act == 'relu':
                  m.append(nn.ReLU(True))
              elif act == 'prelu':
                  m.append(nn.PReLU(n_feats))
          else:
              raise NotImplementedError
  
          super(Upsampler, self).__init__(*m)