def new_conv(self, name: str, kernel_size: tuple, channels_output: int,
                 stride_size: tuple, padding: str='SAME',
                 group: int=1, biased: bool=True, relu: bool=True, input_layer_name: str=None):
        """
        Creates a convolution layer for the network.
        :param name: name for the layer
        :param kernel_size: tuple containing the size of the kernel (Width, Height)
        :param channels_output: ¿? Perhaps number of channels in the output? it is used as the bias size.
        :param stride_size: tuple containing the size of the stride (Width, Height)
        :param padding: Type of padding. Available values are: ('SAME', 'VALID')
        :param group: groups for the kernel operation. More info required.
        :param biased: boolean flag to set if biased or not.
        :param relu: boolean flag to set if ReLu should be applied at the end of the layer or not.
        :param input_layer_name: name of the input layer for this layer. If None, it will take the last added layer of
        the network.
        """

        # Verify that the padding is acceptable
        self.__validate_padding(padding)

        input_layer = self.__network.get_layer(input_layer_name)

        # Get the number of channels in the input
        channels_input = int(input_layer.get_shape()[-1])

        # Verify that the grouping parameter is valid
        self.__validate_grouping(channels_input, channels_output, group)

        # Convolution for a given input and kernel
        convolve = lambda input_val, kernel: tf.nn.conv2d(input_val, kernel, [1, stride_size[1], stride_size[0], 1],
                                                          padding=padding)

        with tf.variable_scope(name) as scope:
            kernel = self.__make_var('weights', shape=[kernel_size[1], kernel_size[0], channels_input // group, channels_output])

            output = convolve(input_layer, kernel)

            # Add the biases, if required
            if biased:
                biases = self.__make_var('biases', [channels_output])
                output = tf.nn.bias_add(output, biases)

            # Apply ReLU non-linearity, if required
            if relu:
                output = tf.nn.relu(output, name=scope.name)


        self.__network.add_layer(name, layer_output=output)