def new(cls,
            layer_sizes,
            activation_funcs,
            pre_corruptors,
            post_corruptors,
            layer_samplers,
            tied=True):
        """
        An easy (and recommended) way to initialize a GSN.

        Parameters
        ----------
        layer_sizes : list
            A list of integers. The i_th element in the list is the size of
            the i_th layer of the network, and the network will have
            len(layer_sizes) layers.
        activation_funcs : list
            activation_funcs must be a list of the same length as layer_sizes
            where the i_th element is the activation function for the i_th
            layer. Each component of the list must refer to an activation
            function in such a way that the Autoencoder class recognizes the
            function. Valid values include a callable (which takes a symbolic
            tensor), a string that refers to a Theano activation function, or
            None (which gives the identity function).
        preact_corruptors : list
            preact_corruptors follows exactly the same format as the
            activations_func argument.
        postact_corruptors : list
            postact_corruptors follows exactly the same format as the
            activations_func argument.
        layer_samplers : list
            layer_samplers follows exactly the same format as the
            activations_func argument.
        tied : bool
            Indicates whether the network should use tied weights.

        Notes
        -----
        The GSN classes applies functions in the following order:
          - pre-activation corruption
          - activation
          - clamping applied
          - sampling
          - post-activation corruption

        All setting and returning of values occurs after applying the
        activation function (or clamping if clamping is used) but before
        applying sampling.
        """
        args = [layer_sizes, pre_corruptors, post_corruptors, layer_samplers]
        if not all(isinstance(arg, list) for arg in args):
            raise TypeError("All arguments except for tied must be lists")
        if not all(len(arg) == len(args[0]) for arg in args):
            lengths = map(len, args)
            raise ValueError("All list arguments must be of the same length. " +
                             "Current lengths are %s" % lengths)

        aes = cls._make_aes(layer_sizes, activation_funcs, tied=tied)

        return cls(aes,
                   preact_cors=pre_corruptors,
                   postact_cors=post_corruptors,
                   layer_samplers=layer_samplers)