def set_size(self, model_complexity, model_depth=20, input_channels=1):
        """
        Set the architecture parameters for the UNet model based on specified complexity and depth.

        This method configures the encoder and decoder layers of the UNet by setting the number of channels, 
        kernel sizes, strides, and paddings for each layer according to the provided model complexity 
        and depth. 

        Args:
            model_complexity (int): Base number of channels for the model.
            model_depth (int, optional): Depth of the UNet model, determining the number of encoder/decoder pairs.
                                          Default is 20.
            input_channels (int, optional): Number of input channels to the model. Default is 1.
        
        Raises:
            ValueError: If an unknown model depth is provided.
        """

        # Configuration for model depth of 14
        if model_depth == 14:
            # Set encoder channels for model depth of 14
            self.enc_channels = [input_channels,
                                 128,
                                 128,
                                 128,
                                 128,
                                 128,
                                 128,
                                 128]
            
            # Define kernel sizes for encoder layers
            self.enc_kernel_sizes = [(5, 2),
                                     (5, 2),
                                     (5, 2),
                                     (5, 2),
                                     (5, 2),
                                     (5, 2),
                                     (2, 2)]
            
            # Define strides for encoder layers
            self.enc_strides = [(2, 1),
                                (2, 1),
                                (2, 1),
                                (2, 1),
                                (2, 1),
                                (2, 1),
                                (2, 1)]
            
            # Define paddings for encoder layers
            self.enc_paddings = [(0, 1),
                                 (0, 1),
                                 (0, 1),
                                 (0, 1),
                                 (0, 1),
                                 (0, 1),
                                 (0, 1)]

            # Set decoder channels for model depth of 14
            self.dec_channels = [64,
                                 128,
                                 128,
                                 128,
                                 128,
                                 128,
                                 128,
                                 1]
            
            # Define kernel sizes for decoder layers
            self.dec_kernel_sizes = [(2, 2),
                                     (5, 2),
                                     (5, 2),
                                     (5, 2),
                                     (6, 2),
                                     (5, 2),
                                     (5, 2)]

            # Define strides for decoder layers
            self.dec_strides = [(2, 1),
                                (2, 1),
                                (2, 1),
                                (2, 1),
                                (2, 1),
                                (2, 1),
                                (2, 1)]

            # Define paddings for decoder layers
            self.dec_paddings = [(0, 1),
                                 (0, 1),
                                 (0, 1),
                                 (0, 1),
                                 (0, 1),
                                 (0, 1),
                                 (0, 1)]

        # Configuration for model depth of 20
        elif model_depth == 20:
            # Set encoder channels for model depth of 20
            self.enc_channels = [input_channels,
                                 model_complexity,
                                 model_complexity,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 128]

            # Define kernel sizes for encoder layers
            self.enc_kernel_sizes = [(7, 1),
                                     (1, 7),
                                     (6, 4),
                                     (7, 5),
                                     (5, 3),
                                     (5, 3),
                                     (5, 3),
                                     (5, 3),
                                     (5, 3),
                                     (5, 3)]

            # Define strides for encoder layers
            self.enc_strides = [(1, 1),
                                (1, 1),
                                (2, 2),
                                (2, 1),
                                (2, 2),
                                (2, 1),
                                (2, 2),
                                (2, 1),
                                (2, 2),
                                (2, 1)]

            # Define paddings for encoder layers
            self.enc_paddings = [(3, 0),
                                 (0, 3),
                                 None,  # None padding for certain layers
                                 None,
                                 None,  # Adjusted padding based on layer requirements
                                 None,
                                 None,
                                 None,
                                 None,
                                 None]

            # Set decoder channels for model depth of 20
            self.dec_channels = [0,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2,
                                 model_complexity * 2]

            # Define kernel sizes for decoder layers
            self.dec_kernel_sizes = [(4, 3),
                                     (4, 2),
                                     (4, 3),
                                     (4, 2),
                                     (4, 3),
                                     (4, 2),
                                     (6, 3),
                                     (7, 4),
                                     (1, 7),
                                     (7, 1)]

            # Define strides for decoder layers
            self.dec_strides = [(2, 1),
                                (2, 2),
                                (2, 1),
                                (2, 2),
                                (2, 1),
                                (2, 2),
                                (2, 1),
                                (2, 2),
                                (1, 1),
                                (1, 1)]

            # Define paddings for decoder layers
            self.dec_paddings = [(1, 1),
                                 (1, 0),
                                 (1, 1),
                                 (1, 0),
                                 (1, 1),
                                 (1, 0),
                                 (2, 1),
                                 (2, 1),
                                 (0, 3),
                                 (3, 0)]
        else:
            # Raise an error if an unknown model depth is specified
            raise ValueError("Unknown model depth : {}".format(model_depth))

        Set the architecture parameters for the UNet model based on specified complexity and depth.

        This method configures the encoder and decoder layers of the UNet by setting the number of channels, 
        kernel sizes, strides, and paddings for each layer according to the provided model complexity 
        and depth. 

        Args:
            model_complexity (int): Base number of channels for the model.
            model_depth (int, optional): Depth of the UNet model, determining the number of encoder/decoder pairs.
                                          Default is 20.
            input_channels (int, optional): Number of input channels to the model. Default is 1.
        
        Raises:
            ValueError: If an unknown model depth is provided.
        
clearvoice/clearvoice/models/frcrn_se/unet.py