             strides: strides,
             padding: padding)
     }
-
-    /// Creates a `Conv2D` layer with the specified filter shape, strides, padding, and
-    /// element-wise activation function. The filter tensor is initialized using Glorot uniform
-    /// initialization. The bias vector is initialized with zeros.
-    init(
-        filterShape: (Int, Int, Int, Int),
-        strides: (Int, Int) = (1, 1),
-        padding: Padding = .valid,
-        activation: @escaping Activation = identity
-    ) {
-      self.init(filterShape: filterShape, strides: strides, padding: padding,
-                activation: activation,
-                generator: &PhiloxRandomNumberGenerator.global)
-    }
 }
 
 public extension Conv2D {
     /// Creates a `Conv2D` layer with the specified filter shape, strides, padding, and
     /// element-wise activation function. The filter tensor is initialized using Glorot uniform
     /// initialization with the specified seed. The bias vector is initialized with zeros.
+    ///
+    /// - Parameters:
+    ///   - filterShape: The shape of the filter, represented by a tuple of `4` integers.
+    ///   - strides: The strides.
+    ///   - padding: The padding.
+    ///   - activation: The activation function.
+    ///   - seed: The random seed for initialization. The default value is random.
+    ///
+    /// - Note: Use `init(filterShape:strides:padding:activation:seed:)` for faster random
+    ///   initialization.
     init(
         filterShape: (Int, Int, Int, Int),
         strides: (Int, Int) = (1, 1),

        return input
    }

    @differentiable(vjp: _vjpApplied(to:in:))
    public func applied(to input: Tensor<Scalar>, in context: Context) -> Tensor<Scalar> {
        switch context.learningPhase {

        return l4.applied(to: o3, in: context)
    }

    /// Returns the output computed by applying a sequence of layers to the previous layer's output,
    /// except that the first layer's input is `self`.
    ///
    /// - Parameters:
    ///   - context: The context that stores contextual information used for the application of
    ///     layers.
    ///   - l1: The first layer.
    ///   - l2: The second layer.
    ///   - l3: The third layer.
    ///   - l4: The third layer.
    ///   - l5: The fifth layer.
    /// - Returns: The final layer's output after sequential application.
    @differentiable
    func sequenced<L1: Layer, L2: Layer, L3: Layer, L4: Layer, L5: Layer>(
        in context: Context, through l1: L1, _ l2: L2, _ l3: L3, _ l4: L4, _ l5: L5)
