class_docstr: Implementation of the Residual in Residual Dense Network for image super-scaling.
  
  The network is the one described in https://arxiv.org/abs/1809.00219 (Wang et al. 2018).
  
  Args:
      arch_params: dictionary, contains the network parameters C, D, G, G0, T, x.
      patch_size: integer or None, determines the input size. Only needed at
          training time, for prediction is set to None.
      beta: float <= 1, scaling parameter for the residual connections.
      c_dim: integer, number of channels of the input image.
      kernel_size: integer, common kernel size for convolutions.
      upscaling: string, 'ups' or 'shuffle', determines which implementation
          of the upscaling layer to use.
      init_val: extreme values for the RandomUniform initializer.
      weights: string, if not empty, download and load pre-trained weights.
          Overrides other parameters.
  
  Attributes:
      C: integer, number of conv layer inside each residual dense blocks (RDB).
      D: integer, number of RDBs inside each Residual in Residual Dense Block (RRDB).
      T: integer, number or RRDBs.
      G: integer, number of convolution output filters inside the RDBs.
      G0: integer, number of output filters of each RDB.
      x: integer, the scaling factor.
      model: Keras model of the RRDN.
      name: name used to identify what upscaling network is used during training.
      model._name: identifies this network as the generator network
          in the compound model built by the trainer class.
code: def __init__(
      self,
      arch_params={},
      patch_size=None,
      beta=0.2,
      c_dim=3,
      kernel_size=3,
      init_val=0.05,
      weights="",
  ):
      if weights:
          arch_params, c_dim, kernel_size, url, fname = get_network(
              weights
          )
  
      self.params = arch_params
      self.beta = beta
      self.c_dim = c_dim
      self.C = self.params["C"]
      self.D = self.params["D"]
      self.G = self.params["G"]
      self.G0 = self.params["G0"]
      self.T = self.params["T"]
      self.scale = self.params["x"]
      self.initializer = RandomUniform(
          minval=-init_val, maxval=init_val, seed=None
      )
      self.kernel_size = kernel_size
      self.patch_size = patch_size
      self.model = self._build_rdn()
      self.model._name = "generator"
      self.name = "rrdn"
      if weights:
          weights_path = tf.keras.utils.get_file(
              fname=fname, origin=url
          )
          self.model.load_weights(weights_path)
  
imports: import tensorflow
  from tensorflow.keras.initializers import RandomUniform
  from tensorflow.keras.layers import concatenate, Input, Activation, Add, Conv2D, Lambda
  from tensorflow.keras.models import Model
  from ISR.models.imagemodel import ImageModel
label_desc: Use image node_id 1 to create a new RRDN object from inherited base classes: ImageModel with example: obj = RRDN(arch_params, patch_size, beta, c_dim, kernel_size, init_val, weights)