def deconvnet(self, filter_sizes, output_channels, strides=None, padding=None, activation_fn=None, b_value=None,
                  s_value=None, bn=None, trainable=True):
        '''
        Shortcut for creating a 2D Deconvolutional Neural Network in one line
        Stacks multiple deconv2d layers, with arguments for each layer defined in a list.
        If an argument is left as None, then the conv2d defaults are kept
        :param filter_sizes: int. assumes square filter
        :param output_channels: int
        :param stride: int
        :param padding: 'VALID' or 'SAME'
        :param activation_fn: tf.nn function
        :param b_value: float
        :param s_value: float
        '''
        # Number of layers to stack
        depth = len(filter_sizes)

        # Default arguments where None was passed in
        if strides is None:
            strides = np.ones(depth)
        if padding is None:
            padding = ['SAME'] * depth
        if activation_fn is None:
            activation_fn = [tf.nn.relu] * depth
        if b_value is None:
            b_value = np.zeros(depth)
        if s_value is None:
            s_value = np.ones(depth)
        if bn is None:
            bn = [True] * depth

            # Make sure that number of layers is consistent
        assert len(output_channels) == depth
        assert len(strides) == depth
        assert len(padding) == depth
        assert len(activation_fn) == depth
        assert len(b_value) == depth
        assert len(s_value) == depth
        assert len(bn) == depth

        # Stack convolutional layers
        for l in range(depth):
            self.deconv2d(filter_size=filter_sizes[l], output_channels=output_channels[l], stride=strides[l],
                          padding=padding[l], activation_fn=activation_fn[l], b_value=b_value[l], s_value=s_value[l],
                          bn=bn[l], trainable=trainable)