Add files using upload-large-folder tool

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/merging/add.py

@@ -0,0 +1,69 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.merging.base_merge import Merge
+
+
+@keras_export("keras.layers.Add")
+class Add(Merge):
+    """Performs elementwise addition operation.
+
+    It takes as input a list of tensors, all of the same shape,
+    and returns a single tensor (also of the same shape).
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.Add()([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> # equivalent to `added = keras.layers.add([x1, x2])`
+    >>> added = keras.layers.Add()([x1, x2])
+    >>> out = keras.layers.Dense(4)(added)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+
+    def _merge_function(self, inputs):
+        output = inputs[0]
+        for i in range(1, len(inputs)):
+            output = ops.add(output, inputs[i])
+        return output
+
+
+@keras_export("keras.layers.add")
+def add(inputs, **kwargs):
+    """Functional interface to the `keras.layers.Add` layer.
+
+    Args:
+        inputs: A list of input tensors with the same shape.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor as the sum of the inputs. It has the same shape as the inputs.
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.add([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> added = keras.layers.add([x1, x2])
+    >>> out = keras.layers.Dense(4)(added)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+    return Add(**kwargs)(inputs)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/merging/average.py

@@ -0,0 +1,70 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.merging.base_merge import Merge
+
+
+@keras_export("keras.layers.Average")
+class Average(Merge):
+    """Averages a list of inputs element-wise..
+
+    It takes as input a list of tensors, all of the same shape,
+    and returns a single tensor (also of the same shape).
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.Average()([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> # equivalent to `y = keras.layers.average([x1, x2])`
+    >>> y = keras.layers.Average()([x1, x2])
+    >>> out = keras.layers.Dense(4)(y)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+
+    def _merge_function(self, inputs):
+        output = inputs[0]
+        for i in range(1, len(inputs)):
+            output = ops.add(output, inputs[i])
+        return output / len(inputs)
+
+
+@keras_export("keras.layers.average")
+def average(inputs, **kwargs):
+    """Functional interface to the `keras.layers.Average` layer.
+
+    Args:
+        inputs: A list of input tensors , all of the same shape.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor as the element-wise product of the inputs with the same
+        shape as the inputs.
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.average([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> y = keras.layers.average([x1, x2])
+    >>> out = keras.layers.Dense(4)(y)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+    return Average(**kwargs)(inputs)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/merging/base_merge.py

@@ -0,0 +1,281 @@
+from keras.src import backend
+from keras.src import ops
+from keras.src.backend.common.keras_tensor import KerasTensor
+from keras.src.layers.layer import Layer
+
+
+class Merge(Layer):
+    """Generic merge layer for elementwise merge functions.
+
+    Used to implement `Sum`, `Average`, etc.
+
+    Args:
+        **kwargs: standard layer keyword arguments.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.supports_masking = True
+
+    def _merge_function(self, inputs):
+        raise NotImplementedError
+
+    def _apply_merge_op_and_or_mask(self, op_fn, inputs):
+        """Merge a set of inputs by applying `op_fn` and ORing the masks.
+
+        We use this for `Minimum` and `Maximum` as it handles the fact that
+        there is no identity element. If applicable, the mask obtained by ORing
+        all masks is set on the output.
+
+        Args:
+            op_fn: binary operation to apply to tensor pair.
+            inputs: array of tensors to apply operation on.
+        """
+        output = None
+        output_mask = None
+
+        for x in inputs:
+            mask = backend.get_keras_mask(x)
+            if mask is not None:
+                mask = ops.broadcast_to(ops.expand_dims(mask, -1), ops.shape(x))
+            if output is None:
+                output = x
+                output_mask = mask
+                continue
+            if mask is not None:
+                x = ops.where(mask, x, output)
+            if output_mask is not None:
+                output = ops.where(output_mask, output, x)
+            if mask is not None and output_mask is not None:
+                output_mask = ops.logical_or(output_mask, mask)
+            else:
+                output_mask = None
+            output = op_fn(output, x)
+
+        if output_mask is not None:
+            output_mask = ops.any(output_mask, axis=-1, keepdims=False)
+            backend.set_keras_mask(output, output_mask)
+        return output
+
+    def _compute_elemwise_op_output_shape(self, shape1, shape2):
+        """Computes the shape of the resultant of an elementwise operation.
+
+        Args:
+            shape1: Tuple or None. Shape of the first tensor
+            shape2: Tuple or None. Shape of the second tensor
+
+        Returns:
+            Expected output shape when an element-wise operation is
+            carried out on 2 tensors with shapes shape1 and shape2.
+            tuple or None.
+
+        Raises:
+            ValueError: If shape1 and shape2 are not compatible for
+                element-wise operations.
+        """
+
+        if None in [shape1, shape2]:
+            return None
+        elif len(shape1) < len(shape2):
+            return self._compute_elemwise_op_output_shape(shape2, shape1)
+        elif not shape2:
+            return shape1
+        output_shape = list(shape1[: -len(shape2)])
+        for i, j in zip(shape1[-len(shape2) :], shape2):
+            if i is None or j is None:
+                output_shape.append(None)
+            elif i == 1:
+                output_shape.append(j)
+            elif j == 1:
+                output_shape.append(i)
+            else:
+                if i != j:
+                    raise ValueError(
+                        "Inputs have incompatible shapes. "
+                        f"Received shapes {shape1} and {shape2}"
+                    )
+                output_shape.append(i)
+        return tuple(output_shape)
+
+    def build(self, input_shape):
+        # Used purely for shape validation.
+        if not isinstance(input_shape[0], (tuple, list)):
+            raise ValueError(
+                "A merge layer should be called on a list of inputs. "
+                f"Received: input_shape={input_shape} (not a list of shapes)"
+            )
+        if len(input_shape) < 1:
+            raise ValueError(
+                "A merge layer should be called "
+                "on a list of at least 1 input. "
+                f"Received {len(input_shape)} inputs. "
+                f"Full input_shape received: {input_shape}"
+            )
+
+        batch_sizes = {s[0] for s in input_shape if s} - {None}
+        if len(batch_sizes) > 1:
+            raise ValueError(
+                "Cannot merge tensors with different batch sizes. "
+                f"Received tensors with shapes {input_shape}"
+            )
+
+        if input_shape[0] is None:
+            output_shape = None
+        else:
+            output_shape = input_shape[0][1:]
+
+        for i in range(1, len(input_shape)):
+            if input_shape[i] is None:
+                shape = None
+            else:
+                shape = input_shape[i][1:]
+            output_shape = self._compute_elemwise_op_output_shape(
+                output_shape, shape
+            )
+
+        # If the inputs have different ranks, we have to reshape them
+        # to make them broadcastable.
+        if None not in input_shape and len(set(map(len, input_shape))) == 1:
+            self._reshape_required = False
+        else:
+            self._reshape_required = True
+        self.built = True
+
+    def call(self, inputs):
+        if not isinstance(inputs, (list, tuple)):
+            raise ValueError(
+                "A merge layer should be called on a list of inputs. "
+                f"Received: inputs={inputs} (not a list of tensors)"
+            )
+        if self._reshape_required:
+            reshaped_inputs = []
+            input_ndims = list(map(ops.ndim, inputs))
+            if None not in input_ndims:
+                # If ranks of all inputs are available,
+                # we simply expand each of them at axis=1
+                # until all of them have the same rank.
+                max_ndim = max(input_ndims)
+                for x in inputs:
+                    x_ndim = ops.ndim(x)
+                    for _ in range(max_ndim - x_ndim):
+                        x = ops.expand_dims(x, axis=1)
+                    reshaped_inputs.append(x)
+                return self._merge_function(reshaped_inputs)
+            else:
+                # Transpose all inputs so that batch size is the last dimension.
+                # (batch_size, dim1, dim2, ... ) -> (dim1, dim2, ... ,
+                # batch_size)
+                transposed = False
+                for x in inputs:
+                    x_ndim = ops.ndim(x)
+
+                    if x_ndim is None:
+                        x_shape = ops.shape(x)
+                        batch_size = x_shape[0]
+
+                        new_shape = backend.concatenate(
+                            [x_shape[1:], ops.expand_dims(batch_size, axis=-1)]
+                        )
+                        x_transposed = ops.reshape(
+                            x,
+                            ops.stack(
+                                [batch_size, ops.prod(x_shape[1:])],
+                                axis=0,
+                            ),
+                        )
+                        x_transposed = ops.transpose(x_transposed, perm=(1, 0))
+                        x_transposed = ops.reshape(x_transposed, new_shape)
+
+                        reshaped_inputs.append(x_transposed)
+                        transposed = True
+
+                    elif x_ndim > 1:
+                        dims = list(range(1, x_ndim)) + [0]
+                        reshaped_inputs.append(ops.transpose(x, perm=dims))
+                        print(dims)
+                        transposed = True
+                    else:
+                        # We don't transpose inputs if they are 1D vectors or
+                        # scalars.
+                        reshaped_inputs.append(x)
+
+                y = self._merge_function(reshaped_inputs)
+                y_ndim = ops.ndim(y)
+
+                if transposed:
+                    # If inputs have been transposed, we have to transpose the
+                    # output too.
+                    if y_ndim is None:
+                        y_shape = ops.shape(y)
+                        y_ndim = ops.shape(y_shape)[0]
+                        batch_size = y_shape[y_ndim - 1]
+                        new_shape = ops.concatenate(
+                            [
+                                ops.expand_dims(batch_size, axis=-1),
+                                y_shape[: y_ndim - 1],
+                            ]
+                        )
+                        y = ops.reshape(y, (-1, batch_size))
+                        y = ops.transpose(y, perm=(1, 0))
+                        y = ops.reshape(y, new_shape)
+                    elif y_ndim > 1:
+                        dims = [y_ndim - 1] + list(range(y_ndim - 1))
+                        y = ops.transpose(y, perm=dims)
+                return y
+        else:
+            return self._merge_function(inputs)
+
+    def compute_output_shape(self, input_shape):
+        if input_shape[0] is None:
+            output_shape = None
+        else:
+            output_shape = input_shape[0][1:]
+
+        for i in range(1, len(input_shape)):
+            if input_shape[i] is None:
+                shape = None
+            else:
+                shape = input_shape[i][1:]
+            output_shape = self._compute_elemwise_op_output_shape(
+                output_shape, shape
+            )
+        batch_sizes = {s[0] for s in input_shape if s is not None} - {None}
+        if len(batch_sizes) == 1:
+            output_shape = (list(batch_sizes)[0],) + output_shape
+        else:
+            output_shape = (None,) + output_shape
+        return output_shape
+
+    def compute_output_spec(self, inputs):
+        output_shape = self.compute_output_shape([x.shape for x in inputs])
+        output_sparse = all(x.sparse for x in inputs)
+        return KerasTensor(
+            output_shape, dtype=self.compute_dtype, sparse=output_sparse
+        )
+
+    def compute_mask(self, inputs, mask=None):
+        if mask is None:
+            return None
+        if not isinstance(mask, (tuple, list)):
+            raise ValueError(f"`mask` should be a list. Received: mask={mask}")
+        if not isinstance(inputs, (tuple, list)):
+            raise ValueError(
+                f"`inputs` should be a list. Received: inputs={inputs}"
+            )
+        if len(mask) != len(inputs):
+            raise ValueError(
+                "The lists `inputs` and `mask` should have the same length. "
+                f"Received: inputs={inputs} of length {len(inputs)}, and "
+                f"mask={mask} of length {len(mask)}"
+            )
+        # Default implementation does an OR between the masks, which works
+        # for `Add`, `Subtract`, `Average`, `Maximum`, `Minimum`, `Multiply`.
+        if any(m is None for m in mask):
+            return None
+        output_mask = mask[0]
+        for m in mask[1:]:
+            output_mask = ops.logical_or(output_mask, m)
+        return output_mask
+
+    def get_config(self):
+        return super().get_config()

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/merging/concatenate.py

@@ -0,0 +1,178 @@
+import copy
+
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.merging.base_merge import Merge
+
+
+@keras_export("keras.layers.Concatenate")
+class Concatenate(Merge):
+    """Concatenates a list of inputs.
+
+    It takes as input a list of tensors, all of the same shape except
+    for the concatenation axis, and returns a single tensor that is the
+    concatenation of all inputs.
+
+    Examples:
+
+    >>> x = np.arange(20).reshape(2, 2, 5)
+    >>> y = np.arange(20, 30).reshape(2, 1, 5)
+    >>> keras.layers.Concatenate(axis=1)([x, y])
+
+    Usage in a Keras model:
+
+    >>> x1 = keras.layers.Dense(8)(np.arange(10).reshape(5, 2))
+    >>> x2 = keras.layers.Dense(8)(np.arange(10, 20).reshape(5, 2))
+    >>> y = keras.layers.Concatenate()([x1, x2])
+
+    Args:
+        axis: Axis along which to concatenate.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor, the concatenation of the inputs alongside axis `axis`.
+    """
+
+    def __init__(self, axis=-1, **kwargs):
+        super().__init__(**kwargs)
+        self.axis = axis
+        self.supports_masking = True
+        self._reshape_required = False
+
+    def build(self, input_shape):
+        # Used purely for shape validation.
+        if len(input_shape) < 1 or not isinstance(
+            input_shape[0], (tuple, list)
+        ):
+            raise ValueError(
+                "A `Concatenate` layer should be called on a list of "
+                f"at least 1 input. Received: input_shape={input_shape}"
+            )
+        if all(shape is None for shape in input_shape):
+            return
+
+        reduced_inputs_shapes = [list(shape) for shape in input_shape]
+        reduced_inputs_shapes_copy = copy.copy(reduced_inputs_shapes)
+        shape_set = set()
+        for i in range(len(reduced_inputs_shapes_copy)):
+            # Convert self.axis to positive axis for each input
+            # in case self.axis is a negative number
+            concat_axis = self.axis % len(reduced_inputs_shapes_copy[i])
+            #  Skip batch axis.
+            for axis, axis_value in enumerate(
+                reduced_inputs_shapes_copy, start=1
+            ):
+                # Remove squeezable axes (axes with value of 1)
+                # if not in the axis that will be used for concatenation
+                # otherwise leave it.
+                # This approach allows building the layer,
+                # but if tensor shapes are not the same when
+                # calling, an exception will be raised.
+                if axis != concat_axis and axis_value == 1:
+                    del reduced_inputs_shapes[i][axis]
+
+            if len(reduced_inputs_shapes[i]) > self.axis:
+                del reduced_inputs_shapes[i][self.axis]
+            shape_set.add(tuple(reduced_inputs_shapes[i]))
+
+        if len(shape_set) != 1:
+            err_msg = (
+                "A `Concatenate` layer requires inputs with matching shapes "
+                "except for the concatenation axis. "
+                f"Received: input_shape={input_shape}"
+            )
+            # Make sure all the shapes have same ranks.
+            ranks = set(len(shape) for shape in shape_set)
+            if len(ranks) != 1:
+                raise ValueError(err_msg)
+            # Get the only rank for the set.
+            (rank,) = ranks
+            for axis in range(rank):
+                # Skip the Nones in the shape since they are dynamic, also the
+                # axis for concat has been removed above.
+                unique_dims = set(
+                    shape[axis]
+                    for shape in shape_set
+                    if shape[axis] is not None
+                )
+                if len(unique_dims) > 1:
+                    raise ValueError(err_msg)
+        self.built = True
+
+    def _merge_function(self, inputs):
+        return ops.concatenate(inputs, axis=self.axis)
+
+    def compute_output_shape(self, input_shape):
+        if (not isinstance(input_shape, (tuple, list))) or (
+            not isinstance(input_shape[0], (tuple, list))
+        ):
+            raise ValueError(
+                "A `Concatenate` layer should be called on a list of inputs. "
+                f"Received: input_shape={input_shape}"
+            )
+        input_shapes = input_shape
+        output_shape = list(input_shapes[0])
+
+        for shape in input_shapes[1:]:
+            if output_shape[self.axis] is None or shape[self.axis] is None:
+                output_shape[self.axis] = None
+                break
+            output_shape[self.axis] += shape[self.axis]
+        return tuple(output_shape)
+
+    def compute_mask(self, inputs, mask=None):
+        if mask is None:
+            return None
+        if not isinstance(mask, (tuple, list)):
+            raise ValueError(f"`mask` should be a list. Received mask={mask}")
+        if not isinstance(inputs, (tuple, list)):
+            raise ValueError(
+                f"`inputs` should be a list. Received: inputs={inputs}"
+            )
+        if len(mask) != len(inputs):
+            raise ValueError(
+                "The lists `inputs` and `mask` should have the same length. "
+                f"Received: inputs={inputs} of length {len(inputs)}, and "
+                f"mask={mask} of length {len(mask)}"
+            )
+        if all(m is None for m in mask):
+            return None
+        # Make a list of masks while making sure
+        # the dimensionality of each mask
+        # is the same as the corresponding input.
+        masks = []
+        for input_i, mask_i in zip(inputs, mask):
+            if mask_i is None:
+                # Input is unmasked. Append all 1s to masks,
+                masks.append(ops.ones_like(input_i, dtype="bool"))
+            elif mask_i.ndim < input_i.ndim:
+                # Mask is smaller than the input, expand it
+                masks.append(
+                    ops.broadcast_to(
+                        ops.expand_dims(mask_i, axis=-1), ops.shape(input_i)
+                    )
+                )
+            else:
+                masks.append(mask_i)
+        concatenated = ops.concatenate(masks, axis=self.axis)
+        return ops.any(concatenated, axis=-1, keepdims=False)
+
+    def get_config(self):
+        config = {"axis": self.axis}
+        base_config = super().get_config()
+        return dict(list(base_config.items()) + list(config.items()))
+
+
+@keras_export("keras.layers.concatenate")
+def concatenate(inputs, axis=-1, **kwargs):
+    """Functional interface to the `Concatenate` layer.
+
+    Args:
+        inputs: A list of input tensors.
+        axis: Concatenation axis.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor, the concatenation of the inputs alongside axis `axis`.
+    """
+    return Concatenate(axis=axis, **kwargs)(inputs)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/merging/dot.py

@@ -0,0 +1,376 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.merging.base_merge import Merge
+from keras.src.utils.numerical_utils import normalize
+
+
+def batch_dot(x, y, axes=None):
+    """Batchwise dot product.
+
+    `batch_dot` is used to compute dot product of `x` and `y` when
+    `x` and `y` are data in batch, i.e. in a shape of `(batch_size, :)`.
+    `batch_dot` results in a tensor or variable with less dimensions
+    than the input. If the number of dimensions is reduced to 1,
+    we use `expand_dims` to make sure that ndim is at least 2.
+
+    Shape inference:
+
+    Let `x`'s shape be `(100, 20)` and `y`'s shape be `(100, 30, 20)`.
+    If `axes` is (1, 2), to find the output shape of resultant tensor,
+    loop through each dimension in `x`'s shape and `y`'s shape:
+
+    * `x.shape[0]` : 100 : append to output shape
+    * `x.shape[1]` : 20 : do not append to output shape, dimension 1 of
+        `x` has been summed over. (`dot_axes[0]` = 1)
+    * `y.shape[0]` : 100 : do not append to output shape, always ignore
+        first dimension of `y`
+    * `y.shape[1]` : 30 : append to output shape
+    * `y.shape[2]` : 20 : do not append to output shape, dimension 2 of
+        `y` has been summed over.
+        (`dot_axes[1]` = 2) `output_shape` = `(100, 30)`
+
+    Example:
+
+    >>> x_batch = np.ones(shape=(32, 20, 1))
+    >>> y_batch = np.ones(shape=(32, 30, 20))
+    >>> xy_batch_dot = batch_dot(x_batch, y_batch, axes=(1, 2))
+
+    Args:
+        x: Keras tensor or variable with `ndim >= 2`.
+        y: Keras tensor or variable with `ndim >= 2`.
+        axes: Tuple or list of integers with target dimensions, or single
+            integer. The sizes of `x.shape[axes[0]]` and `y.shape[axes[1]]`
+            should be equal.
+
+    Returns:
+        A tensor with shape equal to the concatenation of `x`'s shape
+        (less the dimension that was summed over) and `y`'s shape (less the
+        batch dimension and the dimension that was summed over). If the final
+        rank is 1, we reshape it to `(batch_size, 1)`.
+    """
+
+    x_shape = x.shape
+    y_shape = y.shape
+
+    x_ndim = len(x_shape)
+    y_ndim = len(y_shape)
+
+    if x_ndim < 2 or y_ndim < 2:
+        raise ValueError(
+            f"Cannot do batch_dot on inputs "
+            f"with rank < 2. "
+            f"Received inputs with shapes "
+            f"{x_shape} and {y_shape}."
+        )
+
+    x_batch_size = x_shape[0]
+    y_batch_size = y_shape[0]
+
+    if x_batch_size is not None and y_batch_size is not None:
+        if x_batch_size != y_batch_size:
+            raise ValueError(
+                f"Cannot do batch_dot on inputs "
+                f"with different batch sizes. "
+                f"Received inputs with shapes "
+                f"{x_shape} and {y_shape}."
+            )
+    if isinstance(axes, int):
+        axes = [axes, axes]
+
+    if axes is None:
+        if y_ndim == 2:
+            axes = [x_ndim - 1, y_ndim - 1]
+        else:
+            axes = [x_ndim - 1, y_ndim - 2]
+
+    if any(isinstance(a, (list, tuple)) for a in axes):
+        raise ValueError(
+            f"Multiple target dimensions are not supported. "
+            f"Expected: None, int, (int, int), "
+            f"Provided: {axes} "
+        )
+
+    # if tuple, convert to list.
+    axes = list(axes)
+
+    # convert negative indices.
+    if axes[0] < 0:
+        axes[0] += x_ndim
+    if axes[1] < 0:
+        axes[1] += y_ndim
+
+    # sanity checks
+    if 0 in axes:
+        raise ValueError(
+            "Cannot perform batch_dot over axis 0. "
+            "If your inputs are not batched, "
+            "add a dummy batch dimension to your "
+            "inputs using keras.ops.expand_dims(x, 0)"
+        )
+    a0, a1 = axes
+    d1 = x_shape[a0]
+    d2 = y_shape[a1]
+
+    if d1 is not None and d2 is not None and d1 != d2:
+        raise ValueError(
+            f"Cannot do batch_dot on inputs with shapes "
+            f"{x_shape} and {y_shape} with axes={axes}. "
+            f"x.shape[{axes[0]}] != y.shape[{axes[1]}] ({d1} != {d2})."
+        )
+
+    # backup ndims. Need them later.
+    orig_x_ndim = x_ndim
+    orig_y_ndim = y_ndim
+
+    # if rank is 2, expand to 3.
+    if x_ndim == 2:
+        x = ops.expand_dims(x, 1)
+        a0 += 1
+        x_ndim += 1
+    if y_ndim == 2:
+        y = ops.expand_dims(y, 2)
+        y_ndim += 1
+
+    # bring x's dimension to be reduced to last axis.
+    if a0 != x_ndim - 1:
+        pattern = list(range(x_ndim))
+        for i in range(a0, x_ndim - 1):
+            pattern[i] = pattern[i + 1]
+        pattern[-1] = a0
+        x = ops.transpose(x, pattern)
+
+    # bring y's dimension to be reduced to axis 1.
+    if a1 != 1:
+        pattern = list(range(y_ndim))
+        for i in range(a1, 1, -1):
+            pattern[i] = pattern[i - 1]
+        pattern[1] = a1
+        y = ops.transpose(y, pattern)
+
+    # normalize both inputs to rank 3.
+    if x_ndim > 3:
+        # squash middle dimensions of x.
+        x_shape = ops.shape(x)
+        x_mid_dims = x_shape[1:-1]
+        x_squashed_shape = (x_shape[0], -1, x_shape[-1])
+        x = ops.reshape(x, x_squashed_shape)
+        x_squashed = True
+    else:
+        x_squashed = False
+
+    if y_ndim > 3:
+        # squash trailing dimensions of y.
+        y_shape = ops.shape(y)
+        y_trail_dims = y_shape[2:]
+        y_squashed_shape = (y_shape[0], y_shape[1], -1)
+        y = ops.reshape(y, y_squashed_shape)
+        y_squashed = True
+    else:
+        y_squashed = False
+
+    result = ops.matmul(x, y)
+
+    # if inputs were squashed, we have to reshape the matmul output.
+    output_shape = ops.shape(result)
+    do_reshape = False
+
+    if x_squashed:
+        output_shape = output_shape[:1] + x_mid_dims + output_shape[-1:]
+        do_reshape = True
+
+    if y_squashed:
+        output_shape = output_shape[:-1] + y_trail_dims
+        do_reshape = True
+
+    if do_reshape:
+        result = ops.reshape(result, output_shape)
+
+    # if the inputs were originally rank 2, we remove the added 1 dim.
+    if orig_x_ndim == 2:
+        result = ops.squeeze(result, 1)
+    elif orig_y_ndim == 2:
+        result = ops.squeeze(result, -1)
+
+    return result
+
+
+@keras_export("keras.layers.Dot")
+class Dot(Merge):
+    """Computes element-wise dot product of two tensors.
+
+    It takes a list of inputs of size 2, and the axes
+    corresponding to each input along with the dot product
+    is to be performed.
+
+    Let's say `x` and `y` are the two input tensors with shapes
+    `(2, 3, 5)` and `(2, 10, 3)`. The batch dimension should be
+    of same size for both the inputs, and `axes` should correspond
+    to the dimensions that have the same size in the corresponding
+    inputs. e.g. with `axes=(1, 2)`, the dot product of `x`, and `y`
+    will result in a tensor with shape `(2, 5, 10)`
+
+    Example:
+
+    >>> x = np.arange(10).reshape(1, 5, 2)
+    >>> y = np.arange(10, 20).reshape(1, 2, 5)
+    >>> keras.layers.Dot(axes=(1, 2))([x, y])
+
+    Usage in a Keras model:
+
+    >>> x1 = keras.layers.Dense(8)(np.arange(10).reshape(5, 2))
+    >>> x2 = keras.layers.Dense(8)(np.arange(10, 20).reshape(5, 2))
+    >>> y = keras.layers.Dot(axes=1)([x1, x2])
+
+    Args:
+        axes: Integer or tuple of integers, axis or axes along which to
+            take the dot product. If a tuple, should be two integers
+            corresponding to the desired axis from the first input and the
+            desired axis from the second input, respectively. Note that the
+            size of the two selected axes must match.
+        normalize: Whether to L2-normalize samples along the dot product axis
+            before taking the dot product. If set to `True`, then
+            the output of the dot product is the cosine proximity
+            between the two samples.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor, the dot product of the samples from the inputs.
+    """
+
+    def __init__(self, axes, normalize=False, **kwargs):
+        super().__init__(**kwargs)
+        if not isinstance(axes, int):
+            if not isinstance(axes, (list, tuple)):
+                raise TypeError(
+                    f"Invalid type for argument `axes`: it should be "
+                    f"a list or an int. Received: axes={axes}"
+                )
+            if len(axes) != 2:
+                raise ValueError(
+                    f"Invalid format for argument `axes`: it should contain "
+                    f"two elements. Received: axes={axes}"
+                )
+            if not isinstance(axes[0], int) or not isinstance(axes[1], int):
+                raise ValueError(
+                    f"Invalid format for argument `axes`: list elements should "
+                    f"be integers. Received: axes={axes}"
+                )
+        self.axes = axes
+        self.normalize = normalize
+        self.supports_masking = True
+        self._reshape_required = False
+
+    def build(self, input_shape):
+        # Used purely for shape validation.
+        if (
+            not isinstance(input_shape[0], (tuple, list))
+            or len(input_shape) != 2
+        ):
+            raise ValueError(
+                f"A `Dot` layer should be called on a list of 2 inputs. "
+                f"Received: input_shape={input_shape}"
+            )
+        shape1 = input_shape[0]
+        shape2 = input_shape[1]
+        if shape1 is None or shape2 is None:
+            return
+        if isinstance(self.axes, int):
+            if self.axes < 0:
+                axes = [self.axes % len(shape1), self.axes % len(shape2)]
+            else:
+                axes = [self.axes] * 2
+        else:
+            axes = self.axes
+        if shape1[axes[0]] != shape2[axes[1]]:
+            raise ValueError(
+                f"Incompatible input shapes: "
+                f"axis values {shape1[axes[0]]} (at axis {axes[0]}) != "
+                f"{shape2[axes[1]]} (at axis {axes[1]}). "
+                f"Full input shapes: {shape1}, {shape2}"
+            )
+        self.built = True
+
+    def _merge_function(self, inputs):
+        if len(inputs) != 2:
+            raise ValueError(
+                f"A `Dot` layer should be called on exactly 2 inputs. "
+                f"Received: inputs={inputs}"
+            )
+        x1 = inputs[0]
+        x2 = inputs[1]
+
+        if isinstance(self.axes, int):
+            if self.axes < 0:
+                axes = [
+                    self.axes % len(x1.shape),
+                    self.axes % len(x2.shape),
+                ]
+            else:
+                axes = [self.axes] * 2
+        else:
+            axes = []
+            for i in range(len(self.axes)):
+                if self.axes[i] < 0:
+                    axes.append(self.axes[i] % len(inputs[i].shape))
+                else:
+                    axes.append(self.axes[i])
+
+        if self.normalize:
+            x1 = normalize(x1, axis=axes[0])
+            x2 = normalize(x2, axis=axes[1])
+        output = batch_dot(x1, x2, axes)
+        return output
+
+    def compute_output_shape(self, input_shape):
+        if not isinstance(input_shape, (tuple, list)) or len(input_shape) != 2:
+            raise ValueError(
+                f"A `Dot` layer should be called on a list of 2 inputs. "
+                f"Received: input_shape={input_shape}"
+            )
+        shape1 = list(input_shape[0])
+        shape2 = list(input_shape[1])
+        if isinstance(self.axes, int):
+            if self.axes < 0:
+                axes = [self.axes % len(shape1), self.axes % len(shape2)]
+            else:
+                axes = [self.axes] * 2
+        else:
+            axes = self.axes
+        shape1.pop(axes[0])
+        shape2.pop(axes[1])
+        shape2.pop(0)
+        output_shape = shape1 + shape2
+        if len(output_shape) == 1:
+            output_shape += [1]
+        return tuple(output_shape)
+
+    def compute_mask(self, inputs, mask=None):
+        return None
+
+    def get_config(self):
+        config = {
+            "axes": self.axes,
+            "normalize": self.normalize,
+        }
+        base_config = super().get_config()
+        return dict(list(base_config.items()) + list(config.items()))
+
+
+@keras_export("keras.layers.dot")
+def dot(inputs, axes=-1, **kwargs):
+    """Functional interface to the `Dot` layer.
+
+    Args:
+        inputs: A list of input tensors (at least 2).
+        axes: Integer or tuple of integers,
+            axis or axes along which to take the dot product.
+        normalize: Whether to L2-normalize samples along the
+            dot product axis before taking the dot product.
+            If set to `True`, then the output of the dot product
+            is the cosine proximity between the two samples.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor, the dot product of the samples from the inputs.
+    """
+    return Dot(axes=axes, **kwargs)(inputs)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/merging/maximum.py

@@ -0,0 +1,67 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.merging.base_merge import Merge
+
+
+@keras_export("keras.layers.Maximum")
+class Maximum(Merge):
+    """Computes element-wise maximum on a list of inputs.
+
+    It takes as input a list of tensors, all of the same shape,
+    and returns a single tensor (also of the same shape).
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.Maximum()([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> # equivalent to `y = keras.layers.maximum([x1, x2])`
+    >>> y = keras.layers.Maximum()([x1, x2])
+    >>> out = keras.layers.Dense(4)(y)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+
+    def _merge_function(self, inputs):
+        return self._apply_merge_op_and_or_mask(ops.maximum, inputs)
+
+
+@keras_export("keras.layers.maximum")
+def maximum(inputs, **kwargs):
+    """Functional interface to the `keras.layers.Maximum` layer.
+
+    Args:
+        inputs: A list of input tensors , all of the same shape.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor as the element-wise product of the inputs with the same
+        shape as the inputs.
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.maximum([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> y = keras.layers.maximum([x1, x2])
+    >>> out = keras.layers.Dense(4)(y)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+    return Maximum(**kwargs)(inputs)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/merging/minimum.py

@@ -0,0 +1,67 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.merging.base_merge import Merge
+
+
+@keras_export("keras.layers.Minimum")
+class Minimum(Merge):
+    """Computes elementwise minimum on a list of inputs.
+
+    It takes as input a list of tensors, all of the same shape,
+    and returns a single tensor (also of the same shape).
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.Minimum()([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> # equivalent to `y = keras.layers.minimum([x1, x2])`
+    >>> y = keras.layers.Minimum()([x1, x2])
+    >>> out = keras.layers.Dense(4)(y)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+
+    def _merge_function(self, inputs):
+        return self._apply_merge_op_and_or_mask(ops.minimum, inputs)
+
+
+@keras_export("keras.layers.minimum")
+def minimum(inputs, **kwargs):
+    """Functional interface to the `keras.layers.Minimum` layer.
+
+    Args:
+        inputs: A list of input tensors , all of the same shape.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor as the elementwise product of the inputs with the same
+        shape as the inputs.
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.minimum([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> y = keras.layers.minimum([x1, x2])
+    >>> out = keras.layers.Dense(4)(y)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+    return Minimum(**kwargs)(inputs)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/merging/multiply.py

@@ -0,0 +1,91 @@
+from keras.src import backend
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.merging.base_merge import Merge
+
+
+@keras_export("keras.layers.Multiply")
+class Multiply(Merge):
+    """Performs elementwise multiplication.
+
+    It takes as input a list of tensors, all of the same shape,
+    and returns a single tensor (also of the same shape).
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.Multiply()([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> # equivalent to `y = keras.layers.multiply([x1, x2])`
+    >>> y = keras.layers.Multiply()([x1, x2])
+    >>> out = keras.layers.Dense(4)(y)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+
+    def _merge_function(self, inputs):
+        masks = [backend.get_keras_mask(x) for x in inputs]
+        has_output_mask = all(mask is not None for mask in masks)
+        output = None
+        output_mask = None
+
+        for x, mask in zip(inputs, masks):
+            if mask is not None:
+                mask = ops.broadcast_to(ops.expand_dims(mask, -1), ops.shape(x))
+                # Replace 0s with 1s outside of mask.
+                x = ops.where(mask, x, ops.cast(1, x.dtype))
+                if has_output_mask:
+                    output_mask = (
+                        mask
+                        if output_mask is None
+                        else ops.logical_or(output_mask, mask)
+                    )
+            output = x if output is None else ops.multiply(output, x)
+
+        if has_output_mask:
+            # Replace 1s with 0s outside of mask per standard masking rules.
+            output = ops.where(output_mask, output, ops.cast(0, output.dtype))
+            output_mask = ops.any(output_mask, axis=-1, keepdims=False)
+            backend.set_keras_mask(output, output_mask)
+        return output
+
+
+@keras_export("keras.layers.multiply")
+def multiply(inputs, **kwargs):
+    """Functional interface to the `keras.layers.Multiply` layer.
+
+    Args:
+        inputs: A list of input tensors , all of the same shape.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor as the elementwise product of the inputs with the same
+        shape as the inputs.
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.multiply([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> y = keras.layers.multiply([x1, x2])
+    >>> out = keras.layers.Dense(4)(y)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+    return Multiply(**kwargs)(inputs)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/merging/subtract.py

@@ -0,0 +1,82 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.merging.base_merge import Merge
+
+
+@keras_export("keras.layers.Subtract")
+class Subtract(Merge):
+    """Performs elementwise subtraction.
+
+    It takes as input a list of tensors of size 2 both of the
+    same shape, and returns a single tensor (inputs[0] - inputs[1])
+    of same shape.
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.Subtract()([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> # equivalent to `subtracted = keras.layers.subtract([x1, x2])`
+    >>> subtracted = keras.layers.Subtract()([x1, x2])
+    >>> out = keras.layers.Dense(4)(subtracted)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+
+    def build(self, input_shape):
+        super().build(input_shape)
+        if len(input_shape) != 2:
+            raise ValueError(
+                "A `Subtract` layer should be called on exactly 2 inputs. "
+                f"Received: input_shape={input_shape}"
+            )
+
+    def _merge_function(self, inputs):
+        if len(inputs) != 2:
+            raise ValueError(
+                "A `Subtract` layer should be called on exactly 2 inputs. "
+                f"Received: inputs={inputs}"
+            )
+        return ops.subtract(inputs[0], inputs[1])
+
+
+@keras_export("keras.layers.subtract")
+def subtract(inputs, **kwargs):
+    """Functional interface to the `keras.layers.Subtract` layer.
+
+    Args:
+        inputs: A list of input tensors of size 2, each tensor of
+            the same shape.
+        **kwargs: Standard layer keyword arguments.
+
+    Returns:
+        A tensor as the difference of the inputs. It has the same shape
+        as the inputs.
+
+    Examples:
+
+    >>> input_shape = (2, 3, 4)
+    >>> x1 = np.random.rand(*input_shape)
+    >>> x2 = np.random.rand(*input_shape)
+    >>> y = keras.layers.subtract([x1, x2])
+
+    Usage in a Keras model:
+
+    >>> input1 = keras.layers.Input(shape=(16,))
+    >>> x1 = keras.layers.Dense(8, activation='relu')(input1)
+    >>> input2 = keras.layers.Input(shape=(32,))
+    >>> x2 = keras.layers.Dense(8, activation='relu')(input2)
+    >>> subtracted = keras.layers.subtract([x1, x2])
+    >>> out = keras.layers.Dense(4)(subtracted)
+    >>> model = keras.models.Model(inputs=[input1, input2], outputs=out)
+
+    """
+    return Subtract(**kwargs)(inputs)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/normalization/batch_normalization.py

@@ -0,0 +1,352 @@
+from keras.src import backend
+from keras.src import constraints
+from keras.src import initializers
+from keras.src import ops
+from keras.src import regularizers
+from keras.src.api_export import keras_export
+from keras.src.layers.input_spec import InputSpec
+from keras.src.layers.layer import Layer
+
+
+@keras_export("keras.layers.BatchNormalization")
+class BatchNormalization(Layer):
+    """Layer that normalizes its inputs.
+
+    Batch normalization applies a transformation that maintains the mean output
+    close to 0 and the output standard deviation close to 1.
+
+    Importantly, batch normalization works differently during training and
+    during inference.
+
+    **During training** (i.e. when using `fit()` or when calling the layer/model
+    with the argument `training=True`), the layer normalizes its output using
+    the mean and standard deviation of the current batch of inputs. That is to
+    say, for each channel being normalized, the layer returns
+    `gamma * (batch - mean(batch)) / sqrt(var(batch) + epsilon) + beta`, where:
+
+    - `epsilon` is small constant (configurable as part of the constructor
+    arguments)
+    - `gamma` is a learned scaling factor (initialized as 1), which
+    can be disabled by passing `scale=False` to the constructor.
+    - `beta` is a learned offset factor (initialized as 0), which
+    can be disabled by passing `center=False` to the constructor.
+
+    **During inference** (i.e. when using `evaluate()` or `predict()` or when
+    calling the layer/model with the argument `training=False` (which is the
+    default), the layer normalizes its output using a moving average of the
+    mean and standard deviation of the batches it has seen during training. That
+    is to say, it returns
+    `gamma * (batch - self.moving_mean) / sqrt(self.moving_var+epsilon) + beta`.
+
+    `self.moving_mean` and `self.moving_var` are non-trainable variables that
+    are updated each time the layer in called in training mode, as such:
+
+    - `moving_mean = moving_mean * momentum + mean(batch) * (1 - momentum)`
+    - `moving_var = moving_var * momentum + var(batch) * (1 - momentum)`
+
+    As such, the layer will only normalize its inputs during inference
+    *after having been trained on data that has similar statistics as the
+    inference data*.
+
+    Args:
+        axis: Integer, the axis that should be normalized
+            (typically the features axis). For instance, after a `Conv2D` layer
+            with `data_format="channels_first"`, use `axis=1`.
+        momentum: Momentum for the moving average.
+        epsilon: Small float added to variance to avoid dividing by zero.
+        center: If `True`, add offset of `beta` to normalized tensor.
+            If `False`, `beta` is ignored.
+        scale: If `True`, multiply by `gamma`. If `False`, `gamma` is not used.
+            When the next layer is linear this can be disabled
+            since the scaling will be done by the next layer.
+        beta_initializer: Initializer for the beta weight.
+        gamma_initializer: Initializer for the gamma weight.
+        moving_mean_initializer: Initializer for the moving mean.
+        moving_variance_initializer: Initializer for the moving variance.
+        beta_regularizer: Optional regularizer for the beta weight.
+        gamma_regularizer: Optional regularizer for the gamma weight.
+        beta_constraint: Optional constraint for the beta weight.
+        gamma_constraint: Optional constraint for the gamma weight.
+        synchronized: Only applicable with the TensorFlow backend.
+            If `True`, synchronizes the global batch statistics (mean and
+            variance) for the layer across all devices at each training step
+            in a distributed training strategy.
+            If `False`, each replica uses its own local batch statistics.
+        **kwargs: Base layer keyword arguments (e.g. `name` and `dtype`).
+
+    Call arguments:
+        inputs: Input tensor (of any rank).
+        training: Python boolean indicating whether the layer should behave in
+            training mode or in inference mode.
+            - `training=True`: The layer will normalize its inputs using
+            the mean and variance of the current batch of inputs.
+            - `training=False`: The layer will normalize its inputs using
+            the mean and variance of its moving statistics, learned during
+            training.
+        mask: Binary tensor of shape broadcastable to `inputs` tensor, with
+            `True` values indicating the positions for which mean and variance
+            should be computed. Masked elements of the current inputs are not
+            taken into account for mean and variance computation during
+            training. Any prior unmasked element values will be taken into
+            account until their momentum expires.
+
+    Reference:
+
+    - [Ioffe and Szegedy, 2015](https://arxiv.org/abs/1502.03167).
+
+    **About setting `layer.trainable = False` on a `BatchNormalization` layer:**
+
+    The meaning of setting `layer.trainable = False` is to freeze the layer,
+    i.e. its internal state will not change during training:
+    its trainable weights will not be updated
+    during `fit()` or `train_on_batch()`, and its state updates will not be run.
+
+    Usually, this does not necessarily mean that the layer is run in inference
+    mode (which is normally controlled by the `training` argument that can
+    be passed when calling a layer). "Frozen state" and "inference mode"
+    are two separate concepts.
+
+    However, in the case of the `BatchNormalization` layer, **setting
+    `trainable = False` on the layer means that the layer will be
+    subsequently run in inference mode** (meaning that it will use
+    the moving mean and the moving variance to normalize the current batch,
+    rather than using the mean and variance of the current batch).
+
+    Note that:
+
+    - Setting `trainable` on an model containing other layers will recursively
+        set the `trainable` value of all inner layers.
+    - If the value of the `trainable` attribute is changed after calling
+        `compile()` on a model, the new value doesn't take effect for this model
+        until `compile()` is called again.
+    """
+
+    def __init__(
+        self,
+        axis=-1,
+        momentum=0.99,
+        epsilon=1e-3,
+        center=True,
+        scale=True,
+        beta_initializer="zeros",
+        gamma_initializer="ones",
+        moving_mean_initializer="zeros",
+        moving_variance_initializer="ones",
+        beta_regularizer=None,
+        gamma_regularizer=None,
+        beta_constraint=None,
+        gamma_constraint=None,
+        synchronized=False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.axis = int(axis)
+
+        if synchronized and backend.backend() != "tensorflow":
+            raise ValueError(
+                "Argument synchronized=True is only supported "
+                "with the TensorFlow backend."
+            )
+        self.synchronized = synchronized
+
+        self.momentum = float(momentum)
+        self.epsilon = float(epsilon)
+        self.center = center
+        self.scale = scale
+        self.beta_initializer = initializers.get(beta_initializer)
+        self.gamma_initializer = initializers.get(gamma_initializer)
+        self.moving_mean_initializer = initializers.get(moving_mean_initializer)
+        self.moving_variance_initializer = initializers.get(
+            moving_variance_initializer
+        )
+        self.beta_regularizer = regularizers.get(beta_regularizer)
+        self.gamma_regularizer = regularizers.get(gamma_regularizer)
+        self.beta_constraint = constraints.get(beta_constraint)
+        self.gamma_constraint = constraints.get(gamma_constraint)
+        self.supports_masking = True
+
+        self.gamma = None
+        self.beta = None
+        self.moving_mean = None
+        self.moving_variance = None
+        self._reduction_axes = None
+
+    def build(self, input_shape):
+        shape = (input_shape[self.axis],)
+        if self.scale:
+            self.gamma = self.add_weight(
+                shape=shape,
+                name="gamma",
+                initializer=self.gamma_initializer,
+                regularizer=self.gamma_regularizer,
+                constraint=self.gamma_constraint,
+                trainable=True,
+                autocast=False,
+            )
+        if self.center:
+            self.beta = self.add_weight(
+                shape=shape,
+                name="beta",
+                initializer=self.beta_initializer,
+                regularizer=self.beta_regularizer,
+                constraint=self.beta_constraint,
+                trainable=True,
+                autocast=False,
+            )
+        self.moving_mean = self.add_weight(
+            shape=shape,
+            name="moving_mean",
+            initializer=self.moving_mean_initializer,
+            trainable=False,
+            autocast=False,
+        )
+        self.moving_variance = self.add_weight(
+            shape=shape,
+            name="moving_variance",
+            initializer=self.moving_variance_initializer,
+            trainable=False,
+            autocast=False,
+        )
+
+        self.input_spec = InputSpec(
+            ndim=len(input_shape), axes={self.axis: input_shape[self.axis]}
+        )
+
+        reduction_axes = list(range(len(input_shape)))
+        del reduction_axes[self.axis]
+        self._reduction_axes = reduction_axes
+        self.built = True
+
+    def compute_output_shape(self, input_shape):
+        if isinstance(self.axis, int):
+            axes = [self.axis]
+        else:
+            axes = self.axis
+
+        for axis in axes:
+            if axis >= len(input_shape) or axis < -len(input_shape):
+                raise ValueError(
+                    f"Axis {axis} is out of bounds for "
+                    f"input shape {input_shape}. "
+                    f"Received: axis={self.axis}"
+                )
+        return input_shape
+
+    def call(self, inputs, training=None, mask=None):
+        # Check if the mask has one less dimension than the inputs.
+        if mask is not None:
+            if len(mask.shape) != len(inputs.shape) - 1:
+                # Raise a value error
+                raise ValueError(
+                    "The mask provided should be one dimension less "
+                    "than the inputs. Received: "
+                    f"mask.shape={mask.shape}, inputs.shape={inputs.shape}"
+                )
+
+        compute_dtype = backend.result_type(inputs.dtype, "float32")
+        # BN is prone to overflow with float16/bfloat16 inputs, so we upcast to
+        # float32 for the subsequent computations.
+        inputs = ops.cast(inputs, compute_dtype)
+
+        moving_mean = ops.cast(self.moving_mean, inputs.dtype)
+        moving_variance = ops.cast(self.moving_variance, inputs.dtype)
+
+        if training and self.trainable:
+            mean, variance = self._moments(inputs, mask)
+
+            self.moving_mean.assign(
+                moving_mean * self.momentum + mean * (1.0 - self.momentum)
+            )
+            self.moving_variance.assign(
+                moving_variance * self.momentum
+                + variance * (1.0 - self.momentum)
+            )
+        else:
+            mean = moving_mean
+            variance = moving_variance
+
+        if self.scale:
+            gamma = ops.cast(self.gamma, inputs.dtype)
+        else:
+            gamma = None
+
+        if self.center:
+            beta = ops.cast(self.beta, inputs.dtype)
+        else:
+            beta = None
+
+        outputs = ops.batch_normalization(
+            x=inputs,
+            mean=mean,
+            variance=variance,
+            axis=self.axis,
+            offset=beta,
+            scale=gamma,
+            epsilon=self.epsilon,
+        )
+        return ops.cast(outputs, self.compute_dtype)
+
+    def get_config(self):
+        base_config = super().get_config()
+        config = {
+            "axis": self.axis,
+            "momentum": self.momentum,
+            "epsilon": self.epsilon,
+            "center": self.center,
+            "scale": self.scale,
+            "beta_initializer": initializers.serialize(self.beta_initializer),
+            "gamma_initializer": initializers.serialize(self.gamma_initializer),
+            "moving_mean_initializer": initializers.serialize(
+                self.moving_mean_initializer
+            ),
+            "moving_variance_initializer": initializers.serialize(
+                self.moving_variance_initializer
+            ),
+            "beta_regularizer": regularizers.serialize(self.beta_regularizer),
+            "gamma_regularizer": regularizers.serialize(self.gamma_regularizer),
+            "beta_constraint": constraints.serialize(self.beta_constraint),
+            "gamma_constraint": constraints.serialize(self.gamma_constraint),
+            "synchronized": self.synchronized,
+        }
+        return {**base_config, **config}
+
+    def _moments(self, inputs, mask):
+        if mask is None:
+            return ops.moments(
+                inputs,
+                axes=self._reduction_axes,
+                synchronized=self.synchronized,
+            )
+
+        mask_weights = ops.cast(
+            mask,
+            inputs.dtype,
+        )
+        mask_weights_broadcasted = ops.expand_dims(
+            mask_weights,
+            axis=-1,
+        )
+        weighted_inputs = mask_weights_broadcasted * inputs
+
+        weighted_input_sum = ops.sum(
+            weighted_inputs,
+            self._reduction_axes,
+            keepdims=True,
+        )
+        sum_of_weights = ops.sum(
+            mask_weights_broadcasted,
+            self._reduction_axes,
+            keepdims=True,
+        )
+        mean = weighted_input_sum / (sum_of_weights + backend.config.epsilon())
+
+        difference = weighted_inputs - mean
+        squared_difference = ops.square(difference)
+        weighted_distsq = ops.sum(
+            mask_weights_broadcasted * squared_difference,
+            self._reduction_axes,
+            keepdims=True,
+        )
+        variance = weighted_distsq / (sum_of_weights + backend.config.epsilon())
+
+        return ops.squeeze(mean), ops.squeeze(variance)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/normalization/group_normalization.py

@@ -0,0 +1,240 @@
+from keras.src import backend
+from keras.src import constraints
+from keras.src import initializers
+from keras.src import ops
+from keras.src import regularizers
+from keras.src.api_export import keras_export
+from keras.src.layers.input_spec import InputSpec
+from keras.src.layers.layer import Layer
+
+
+@keras_export("keras.layers.GroupNormalization")
+class GroupNormalization(Layer):
+    """Group normalization layer.
+
+    Group Normalization divides the channels into groups and computes
+    within each group the mean and variance for normalization.
+    Empirically, its accuracy is more stable than batch norm in a wide
+    range of small batch sizes, if learning rate is adjusted linearly
+    with batch sizes.
+
+    Relation to Layer Normalization:
+    If the number of groups is set to 1, then this operation becomes nearly
+    identical to Layer Normalization (see Layer Normalization docs for details).
+
+    Relation to Instance Normalization:
+    If the number of groups is set to the input dimension (number of groups is
+    equal to number of channels), then this operation becomes identical to
+    Instance Normalization. You can achieve this via `groups=-1`.
+
+    Args:
+        groups: Integer, the number of groups for Group Normalization. Can be in
+            the range `[1, N]` where N is the input dimension. The input
+            dimension must be divisible by the number of groups.
+            Defaults to 32.
+        axis: Integer or List/Tuple. The axis or axes to normalize across.
+            Typically, this is the features axis/axes. The left-out axes are
+            typically the batch axis/axes. -1 is the last dimension in the
+            input. Defaults to `-1`.
+        epsilon: Small float added to variance to avoid dividing by zero.
+            Defaults to 1e-3.
+        center: If `True`, add offset of `beta` to normalized tensor.
+            If `False`, `beta` is ignored. Defaults to `True`.
+        scale: If `True`, multiply by `gamma`. If `False`, `gamma` is not used.
+            When the next layer is linear (also e.g. `relu`), this can be
+            disabled since the scaling will be done by the next layer.
+            Defaults to `True`.
+        beta_initializer: Initializer for the beta weight. Defaults to zeros.
+        gamma_initializer: Initializer for the gamma weight. Defaults to ones.
+        beta_regularizer: Optional regularizer for the beta weight. None by
+            default.
+        gamma_regularizer: Optional regularizer for the gamma weight. None by
+            default.
+        beta_constraint: Optional constraint for the beta weight.
+            None by default.
+        gamma_constraint: Optional constraint for the gamma weight. None by
+            default.  Input shape: Arbitrary. Use the keyword argument
+            `input_shape` (tuple of integers, does not include the samples
+            axis) when using this layer as the first layer in a model.
+            Output shape: Same shape as input.
+        **kwargs: Base layer keyword arguments (e.g. `name` and `dtype`).
+
+    Reference:
+
+    - [Yuxin Wu & Kaiming He, 2018](https://arxiv.org/abs/1803.08494)
+    """
+
+    def __init__(
+        self,
+        groups=32,
+        axis=-1,
+        epsilon=1e-3,
+        center=True,
+        scale=True,
+        beta_initializer="zeros",
+        gamma_initializer="ones",
+        beta_regularizer=None,
+        gamma_regularizer=None,
+        beta_constraint=None,
+        gamma_constraint=None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.supports_masking = True
+        self.groups = groups
+        self.axis = axis
+        self.epsilon = epsilon
+        self.center = center
+        self.scale = scale
+        self.beta_initializer = initializers.get(beta_initializer)
+        self.gamma_initializer = initializers.get(gamma_initializer)
+        self.beta_regularizer = regularizers.get(beta_regularizer)
+        self.gamma_regularizer = regularizers.get(gamma_regularizer)
+        self.beta_constraint = constraints.get(beta_constraint)
+        self.gamma_constraint = constraints.get(gamma_constraint)
+
+    def build(self, input_shape):
+        dim = input_shape[self.axis]
+
+        if dim is None:
+            raise ValueError(
+                f"Axis {self.axis} of input tensor should have a defined "
+                "dimension but the layer received an input with shape "
+                f"{input_shape}."
+            )
+
+        if self.groups == -1:
+            self.groups = dim
+
+        if dim < self.groups:
+            raise ValueError(
+                f"Number of groups ({self.groups}) cannot be more than the "
+                f"number of channels ({dim})."
+            )
+
+        if dim % self.groups != 0:
+            raise ValueError(
+                f"Number of groups ({self.groups}) must be a multiple "
+                f"of the number of channels ({dim})."
+            )
+
+        self.input_spec = InputSpec(
+            ndim=len(input_shape), axes={self.axis: dim}
+        )
+
+        if self.scale:
+            self.gamma = self.add_weight(
+                shape=(dim,),
+                name="gamma",
+                initializer=self.gamma_initializer,
+                regularizer=self.gamma_regularizer,
+                constraint=self.gamma_constraint,
+            )
+        else:
+            self.gamma = None
+
+        if self.center:
+            self.beta = self.add_weight(
+                shape=(dim,),
+                name="beta",
+                initializer=self.beta_initializer,
+                regularizer=self.beta_regularizer,
+                constraint=self.beta_constraint,
+            )
+        else:
+            self.beta = None
+
+        super().build(input_shape)
+
+    def call(self, inputs):
+        reshaped_inputs = self._reshape_into_groups(inputs)
+        normalized_inputs = self._apply_normalization(
+            reshaped_inputs, inputs.shape
+        )
+        return ops.reshape(normalized_inputs, ops.shape(inputs))
+
+    def _reshape_into_groups(self, inputs):
+        input_shape = ops.shape(inputs)
+        group_shape = list(inputs.shape)
+        group_shape[0] = -1
+        for i, e in enumerate(group_shape[1:]):
+            if e is None:
+                group_shape[i + 1] = input_shape[i + 1]
+
+        group_shape[self.axis] = input_shape[self.axis] // self.groups
+        group_shape.insert(self.axis, self.groups)
+        reshaped_inputs = ops.reshape(inputs, group_shape)
+        return reshaped_inputs
+
+    def _apply_normalization(self, reshaped_inputs, input_shape):
+        inputs_dtype = reshaped_inputs.dtype
+        compute_dtype = backend.result_type(inputs_dtype, "float32")
+        # GN is prone to overflow with float16/bfloat16 inputs, so we upcast to
+        # float32 for the subsequent computations.
+        reshaped_inputs = ops.cast(reshaped_inputs, compute_dtype)
+
+        group_reduction_axes = list(range(1, len(reshaped_inputs.shape)))
+
+        axis = -2 if self.axis == -1 else self.axis - 1
+        group_reduction_axes.pop(axis)
+
+        broadcast_shape = self._create_broadcast_shape(input_shape)
+        mean, variance = ops.moments(
+            reshaped_inputs, axes=group_reduction_axes, keepdims=True
+        )
+
+        # Compute the batch normalization.
+        inv = ops.rsqrt(variance + self.epsilon)
+        if self.scale:
+            gamma = ops.reshape(self.gamma, broadcast_shape)
+            gamma = ops.cast(gamma, reshaped_inputs.dtype)
+            inv = inv * gamma
+
+        res = -mean * inv
+        if self.center:
+            beta = ops.reshape(self.beta, broadcast_shape)
+            beta = ops.cast(beta, reshaped_inputs.dtype)
+            res = res + beta
+
+        normalized_inputs = reshaped_inputs * inv + res
+        normalized_inputs = ops.cast(normalized_inputs, inputs_dtype)
+
+        return normalized_inputs
+
+    def _create_broadcast_shape(self, input_shape):
+        broadcast_shape = [1] * len(input_shape)
+        broadcast_shape[self.axis] = input_shape[self.axis] // self.groups
+        broadcast_shape.insert(self.axis, self.groups)
+        return broadcast_shape
+
+    def compute_output_shape(self, input_shape):
+        if isinstance(self.axis, int):
+            axes = [self.axis]
+        else:
+            axes = self.axis
+
+        for axis in axes:
+            if axis >= len(input_shape) or axis < -len(input_shape):
+                raise ValueError(
+                    f"Axis {axis} is out of bounds for "
+                    f"input shape {input_shape}. "
+                    f"Received: axis={self.axis}"
+                )
+        return input_shape
+
+    def get_config(self):
+        config = {
+            "groups": self.groups,
+            "axis": self.axis,
+            "epsilon": self.epsilon,
+            "center": self.center,
+            "scale": self.scale,
+            "beta_initializer": initializers.serialize(self.beta_initializer),
+            "gamma_initializer": initializers.serialize(self.gamma_initializer),
+            "beta_regularizer": regularizers.serialize(self.beta_regularizer),
+            "gamma_regularizer": regularizers.serialize(self.gamma_regularizer),
+            "beta_constraint": constraints.serialize(self.beta_constraint),
+            "gamma_constraint": constraints.serialize(self.gamma_constraint),
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/normalization/layer_normalization.py

@@ -0,0 +1,265 @@
+from keras.src import backend
+from keras.src import constraints
+from keras.src import initializers
+from keras.src import ops
+from keras.src import regularizers
+from keras.src.api_export import keras_export
+from keras.src.layers.layer import Layer
+
+
+@keras_export("keras.layers.LayerNormalization")
+class LayerNormalization(Layer):
+    """Layer normalization layer (Ba et al., 2016).
+
+    Normalize the activations of the previous layer for each given example in a
+    batch independently, rather than across a batch like Batch Normalization.
+    i.e. applies a transformation that maintains the mean activation within each
+    example close to 0 and the activation standard deviation close to 1.
+
+    If `scale` or `center` are enabled, the layer will scale the normalized
+    outputs by broadcasting them with a trainable variable `gamma`, and center
+    the outputs by broadcasting with a trainable variable `beta`. `gamma` will
+    default to a ones tensor and `beta` will default to a zeros tensor, so that
+    centering and scaling are no-ops before training has begun.
+
+    So, with scaling and centering enabled the normalization equations
+    are as follows:
+
+    Let the intermediate activations for a mini-batch to be the `inputs`.
+
+    For each sample `x_i` in `inputs` with `k` features, we compute the mean and
+    variance of the sample:
+
+    ```python
+    mean_i = sum(x_i[j] for j in range(k)) / k
+    var_i = sum((x_i[j] - mean_i) ** 2 for j in range(k)) / k
+    ```
+
+    and then compute a normalized `x_i_normalized`, including a small factor
+    `epsilon` for numerical stability.
+
+    ```python
+    x_i_normalized = (x_i - mean_i) / sqrt(var_i + epsilon)
+    ```
+
+    And finally `x_i_normalized ` is linearly transformed by `gamma` and `beta`,
+    which are learned parameters:
+
+    ```python
+    output_i = x_i_normalized * gamma + beta
+    ```
+
+    `gamma` and `beta` will span the axes of `inputs` specified in `axis`, and
+    this part of the inputs' shape must be fully defined.
+
+    For example:
+
+    >>> layer = keras.layers.LayerNormalization(axis=[1, 2, 3])
+    >>> layer.build([5, 20, 30, 40])
+    >>> print(layer.beta.shape)
+    (20, 30, 40)
+    >>> print(layer.gamma.shape)
+    (20, 30, 40)
+
+    Note that other implementations of layer normalization may choose to define
+    `gamma` and `beta` over a separate set of axes from the axes being
+    normalized across. For example, Group Normalization
+    ([Wu et al. 2018](https://arxiv.org/abs/1803.08494)) with group size of 1
+    corresponds to a Layer Normalization that normalizes across height, width,
+    and channel and has `gamma` and `beta` span only the channel dimension.
+    So, this Layer Normalization implementation will not match a Group
+    Normalization layer with group size set to 1.
+
+    Args:
+        axis: Integer or List/Tuple. The axis or axes to normalize across.
+            Typically, this is the features axis/axes. The left-out axes are
+            typically the batch axis/axes. `-1` is the last dimension in the
+            input. Defaults to `-1`.
+        epsilon: Small float added to variance to avoid dividing by zero.
+            Defaults to 1e-3.
+        center: If True, add offset of `beta` to normalized tensor. If False,
+            `beta` is ignored. Defaults to `True`.
+        scale: If True, multiply by `gamma`. If False, `gamma` is not used.
+            When the next layer is linear (also e.g. `nn.relu`), this can be
+            disabled since the scaling will be done by the next layer.
+            Defaults to `True`.
+        rms_scaling: If True, `center` and `scale` are ignored, and the
+            inputs are scaled by `gamma` and the inverse square root
+            of the square of all inputs. This is an approximate and faster
+            approach that avoids ever computing the mean of the input.
+        beta_initializer: Initializer for the beta weight. Defaults to zeros.
+        gamma_initializer: Initializer for the gamma weight. Defaults to ones.
+        beta_regularizer: Optional regularizer for the beta weight.
+            None by default.
+        gamma_regularizer: Optional regularizer for the gamma weight.
+            None by default.
+        beta_constraint: Optional constraint for the beta weight.
+            None by default.
+        gamma_constraint: Optional constraint for the gamma weight.
+            None by default.
+        **kwargs: Base layer keyword arguments (e.g. `name` and `dtype`).
+
+
+    Reference:
+
+    - [Lei Ba et al., 2016](https://arxiv.org/abs/1607.06450).
+    """
+
+    def __init__(
+        self,
+        axis=-1,
+        epsilon=1e-3,
+        center=True,
+        scale=True,
+        rms_scaling=False,
+        beta_initializer="zeros",
+        gamma_initializer="ones",
+        beta_regularizer=None,
+        gamma_regularizer=None,
+        beta_constraint=None,
+        gamma_constraint=None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        if isinstance(axis, (list, tuple)):
+            self.axis = list(axis)
+        elif isinstance(axis, int):
+            self.axis = axis
+        else:
+            raise TypeError(
+                "Expected an int or a list/tuple of ints for the "
+                "argument 'axis', but received: %r" % axis
+            )
+
+        self.epsilon = epsilon
+        self.center = center
+        self.scale = scale
+        self.rms_scaling = rms_scaling
+        self.beta_initializer = initializers.get(beta_initializer)
+        self.gamma_initializer = initializers.get(gamma_initializer)
+        self.beta_regularizer = regularizers.get(beta_regularizer)
+        self.gamma_regularizer = regularizers.get(gamma_regularizer)
+        self.beta_constraint = constraints.get(beta_constraint)
+        self.gamma_constraint = constraints.get(gamma_constraint)
+
+        self.supports_masking = True
+        self.autocast = False
+
+    def build(self, input_shape):
+        if isinstance(self.axis, list):
+            shape = tuple([input_shape[dim] for dim in self.axis])
+        else:
+            shape = (input_shape[self.axis],)
+            self.axis = [self.axis]
+        if self.scale or self.rms_scaling:
+            self.gamma = self.add_weight(
+                name="gamma",
+                shape=shape,
+                initializer=self.gamma_initializer,
+                regularizer=self.gamma_regularizer,
+                constraint=self.gamma_constraint,
+                trainable=True,
+                autocast=False,
+            )
+        else:
+            self.gamma = None
+
+        if self.center and not self.rms_scaling:
+            self.beta = self.add_weight(
+                name="beta",
+                shape=shape,
+                initializer=self.beta_initializer,
+                regularizer=self.beta_regularizer,
+                constraint=self.beta_constraint,
+                trainable=True,
+                autocast=False,
+            )
+        else:
+            self.beta = None
+
+        self.built = True
+
+    def call(self, inputs):
+        # Compute the axes along which to reduce the mean / variance
+        input_shape = inputs.shape
+        ndims = len(input_shape)
+
+        # Broadcasting only necessary for norm when the axis is not just
+        # the last dimension
+        broadcast_shape = [1] * ndims
+        for dim in self.axis:
+            broadcast_shape[dim] = input_shape[dim]
+
+        def _broadcast(v):
+            if (
+                v is not None
+                and len(v.shape) != ndims
+                and self.axis != [ndims - 1]
+            ):
+                return ops.reshape(v, broadcast_shape)
+            return v
+
+        compute_dtype = backend.result_type(inputs.dtype, "float32")
+        # LN is prone to overflow with float16/bfloat16 inputs, so we upcast to
+        # float32 for the subsequent computations.
+        inputs = ops.cast(inputs, compute_dtype)
+
+        if self.rms_scaling:
+            # Calculate outputs with only variance and gamma if rms scaling
+            # is enabled
+            # Calculate the variance along self.axis (layer activations).
+            variance = ops.var(inputs, axis=self.axis, keepdims=True)
+            inv = ops.rsqrt(variance + self.epsilon)
+
+            outputs = (
+                inputs * inv * ops.cast(_broadcast(self.gamma), inputs.dtype)
+            )
+        else:
+            # Calculate the mean & variance along self.axis (layer activations).
+            mean, variance = ops.moments(inputs, axes=self.axis, keepdims=True)
+            gamma, beta = _broadcast(self.gamma), _broadcast(self.beta)
+
+            inv = ops.rsqrt(variance + self.epsilon)
+            if gamma is not None:
+                gamma = ops.cast(gamma, inputs.dtype)
+                inv = inv * gamma
+
+            res = -mean * inv
+            if beta is not None:
+                beta = ops.cast(beta, inputs.dtype)
+                res = res + beta
+
+            outputs = inputs * inv + res
+        return ops.cast(outputs, self.compute_dtype)
+
+    def compute_output_shape(self, input_shape):
+        if isinstance(self.axis, int):
+            axes = [self.axis]
+        else:
+            axes = self.axis
+
+        for axis in axes:
+            if axis >= len(input_shape) or axis < -len(input_shape):
+                raise ValueError(
+                    f"Axis {axis} is out of bounds for "
+                    f"input shape {input_shape}. "
+                    f"Received: axis={self.axis}"
+                )
+        return input_shape
+
+    def get_config(self):
+        config = {
+            "axis": self.axis,
+            "epsilon": self.epsilon,
+            "center": self.center,
+            "scale": self.scale,
+            "rms_scaling": self.rms_scaling,
+            "beta_initializer": initializers.serialize(self.beta_initializer),
+            "gamma_initializer": initializers.serialize(self.gamma_initializer),
+            "beta_regularizer": regularizers.serialize(self.beta_regularizer),
+            "gamma_regularizer": regularizers.serialize(self.gamma_regularizer),
+            "beta_constraint": constraints.serialize(self.beta_constraint),
+            "gamma_constraint": constraints.serialize(self.gamma_constraint),
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/normalization/spectral_normalization.py

@@ -0,0 +1,121 @@
+from keras.src import initializers
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers import Wrapper
+from keras.src.layers.input_spec import InputSpec
+from keras.src.utils.numerical_utils import normalize
+
+
+@keras_export("keras.layers.SpectralNormalization")
+class SpectralNormalization(Wrapper):
+    """Performs spectral normalization on the weights of a target layer.
+
+    This wrapper controls the Lipschitz constant of the weights of a layer by
+    constraining their spectral norm, which can stabilize the training of GANs.
+
+    Args:
+        layer: A `keras.layers.Layer` instance that
+            has either a `kernel` (e.g. `Conv2D`, `Dense`...)
+            or an `embeddings` attribute (`Embedding` layer).
+        power_iterations: int, the number of iterations during normalization.
+        **kwargs: Base wrapper keyword arguments.
+
+    Examples:
+
+    Wrap `keras.layers.Conv2D`:
+    >>> x = np.random.rand(1, 10, 10, 1)
+    >>> conv2d = SpectralNormalization(keras.layers.Conv2D(2, 2))
+    >>> y = conv2d(x)
+    >>> y.shape
+    (1, 9, 9, 2)
+
+    Wrap `keras.layers.Dense`:
+    >>> x = np.random.rand(1, 10, 10, 1)
+    >>> dense = SpectralNormalization(keras.layers.Dense(10))
+    >>> y = dense(x)
+    >>> y.shape
+    (1, 10, 10, 10)
+
+    Reference:
+
+    - [Spectral Normalization for GAN](https://arxiv.org/abs/1802.05957).
+    """
+
+    def __init__(self, layer, power_iterations=1, **kwargs):
+        super().__init__(layer, **kwargs)
+        if power_iterations <= 0:
+            raise ValueError(
+                "`power_iterations` should be greater than zero. Received: "
+                f"`power_iterations={power_iterations}`"
+            )
+        self.power_iterations = power_iterations
+
+    def build(self, input_shape):
+        super().build(input_shape)
+        self.input_spec = InputSpec(shape=[None] + list(input_shape[1:]))
+
+        if hasattr(self.layer, "kernel"):
+            self.kernel = self.layer.kernel
+        elif hasattr(self.layer, "embeddings"):
+            self.kernel = self.layer.embeddings
+        else:
+            raise ValueError(
+                f"{type(self.layer).__name__} object has no attribute 'kernel' "
+                "nor 'embeddings'"
+            )
+
+        self.kernel_shape = self.kernel.shape
+
+        self.vector_u = self.add_weight(
+            shape=(1, self.kernel_shape[-1]),
+            initializer=initializers.TruncatedNormal(stddev=0.02),
+            trainable=False,
+            name="vector_u",
+            dtype=self.kernel.dtype,
+        )
+
+    def call(self, inputs, training=False):
+        if training:
+            new_vector_u, new_kernel = ops.cond(
+                ops.all(ops.equal(self.kernel.value, 0)),
+                lambda: (self.vector_u.value, self.kernel.value),
+                self.normalized_weights,
+            )
+            self.vector_u.assign(new_vector_u)
+            self.kernel.assign(new_kernel)
+
+        output = self.layer(inputs)
+        return ops.cast(output, inputs.dtype)
+
+    def compute_output_shape(self, input_shape):
+        return self.layer.compute_output_shape(input_shape)
+
+    def normalized_weights(self):
+        """Generate spectral normalized weights.
+
+        This method returns the updated value for `self.kernel` with the
+        spectral normalized value, so that the layer is ready for `call()`.
+        """
+
+        weights = ops.reshape(self.kernel, [-1, self.kernel_shape[-1]])
+        vector_u = self.vector_u.value
+
+        for _ in range(self.power_iterations):
+            vector_v = normalize(
+                ops.matmul(vector_u, ops.transpose(weights)), axis=None
+            )
+            vector_u = normalize(ops.matmul(vector_v, weights), axis=None)
+        vector_u = ops.stop_gradient(vector_u)
+        vector_v = ops.stop_gradient(vector_v)
+        sigma = ops.matmul(
+            ops.matmul(vector_v, weights), ops.transpose(vector_u)
+        )
+        kernel = ops.reshape(ops.divide(self.kernel, sigma), self.kernel_shape)
+        return ops.cast(vector_u, self.vector_u.dtype), ops.cast(
+            kernel, self.kernel.dtype
+        )
+
+    def get_config(self):
+        config = {"power_iterations": self.power_iterations}
+        base_config = super().get_config()
+        return {**base_config, **config}

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/normalization/unit_normalization.py

@@ -0,0 +1,63 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.layer import Layer
+
+
+@keras_export("keras.layers.UnitNormalization")
+class UnitNormalization(Layer):
+    """Unit normalization layer.
+
+    Normalize a batch of inputs so that each input in the batch has a L2 norm
+    equal to 1 (across the axes specified in `axis`).
+
+    Example:
+
+    >>> data = np.arange(6).reshape(2, 3)
+    >>> normalized_data = keras.layers.UnitNormalization()(data)
+    >>> np.sum(normalized_data[0, :] ** 2)
+    1.0
+
+    Args:
+        axis: Integer or list/tuple. The axis or axes to normalize across.
+            Typically, this is the features axis or axes. The left-out axes are
+            typically the batch axis or axes. `-1` is the last dimension
+            in the input. Defaults to `-1`.
+    """
+
+    def __init__(self, axis=-1, **kwargs):
+        super().__init__(**kwargs)
+        if isinstance(axis, (list, tuple)):
+            self.axis = list(axis)
+        elif isinstance(axis, int):
+            self.axis = axis
+        else:
+            raise TypeError(
+                "Invalid value for `axis` argument: "
+                "expected an int or a list/tuple of ints. "
+                f"Received: axis={axis}"
+            )
+        self.supports_masking = True
+        self.built = True
+
+    def call(self, inputs):
+        return ops.normalize(inputs, axis=self.axis, order=2, epsilon=1e-12)
+
+    def compute_output_shape(self, input_shape):
+        # Ensure axis is always treated as a list
+        if isinstance(self.axis, int):
+            axes = [self.axis]
+        else:
+            axes = self.axis
+
+        for axis in axes:
+            if axis >= len(input_shape) or axis < -len(input_shape):
+                raise ValueError(
+                    f"Axis {self.axis} is out of bounds for "
+                    f"input shape {input_shape}."
+                )
+        return input_shape
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({"axis": self.axis})
+        return config

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/average_pooling1d.py

@@ -0,0 +1,92 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_pooling import BasePooling
+
+
+@keras_export(["keras.layers.AveragePooling1D", "keras.layers.AvgPool1D"])
+class AveragePooling1D(BasePooling):
+    """Average pooling for temporal data.
+
+    Downsamples the input representation by taking the average value over the
+    window defined by `pool_size`. The window is shifted by `strides`.  The
+    resulting output when using "valid" padding option has a shape of:
+    `output_shape = (input_shape - pool_size + 1) / strides)`
+
+    The resulting output shape when using the "same" padding option is:
+    `output_shape = input_shape / strides`
+
+    Args:
+        pool_size: int, size of the max pooling window.
+        strides: int or None. Specifies how much the pooling window moves
+            for each pooling step. If None, it will default to `pool_size`.
+        padding: string, either `"valid"` or `"same"` (case-insensitive).
+            `"valid"` means no padding. `"same"` results in padding evenly to
+            the left/right or up/down of the input such that output has the same
+            height/width dimension as the input.
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape `(batch, steps, features)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, features, steps)`. It defaults to the `image_data_format`
+            value found in your Keras config file at `~/.keras/keras.json`.
+            If you never set it, then it will be `"channels_last"`.
+
+    Input shape:
+
+    - If `data_format="channels_last"`:
+        3D tensor with shape `(batch_size, steps, features)`.
+    - If `data_format="channels_first"`:
+        3D tensor with shape `(batch_size, features, steps)`.
+
+    Output shape:
+
+    - If `data_format="channels_last"`:
+        3D tensor with shape `(batch_size, downsampled_steps, features)`.
+    - If `data_format="channels_first"`:
+        3D tensor with shape `(batch_size, features, downsampled_steps)`.
+
+    Examples:
+
+    `strides=1` and `padding="valid"`:
+
+    >>> x = np.array([1., 2., 3., 4., 5.])
+    >>> x = np.reshape(x, [1, 5, 1])
+    >>> avg_pool_1d = keras.layers.AveragePooling1D(pool_size=2,
+    ...    strides=1, padding="valid")
+    >>> avg_pool_1d(x)
+
+    `strides=2` and `padding="valid"`:
+
+    >>> x = np.array([1., 2., 3., 4., 5.])
+    >>> x = np.reshape(x, [1, 5, 1])
+    >>> avg_pool_1d = keras.layers.AveragePooling1D(pool_size=2,
+    ...    strides=2, padding="valid")
+    >>> avg_pool_1d(x)
+
+    `strides=1` and `padding="same"`:
+
+    >>> x = np.array([1., 2., 3., 4., 5.])
+    >>> x = np.reshape(x, [1, 5, 1])
+    >>> avg_pool_1d = keras.layers.AveragePooling1D(pool_size=2,
+    ...    strides=1, padding="same")
+    >>> avg_pool_1d(x)
+    """
+
+    def __init__(
+        self,
+        pool_size,
+        strides=None,
+        padding="valid",
+        data_format=None,
+        name=None,
+        **kwargs,
+    ):
+        super().__init__(
+            pool_size,
+            strides,
+            pool_dimensions=1,
+            pool_mode="average",
+            padding=padding,
+            data_format=data_format,
+            name=name,
+            **kwargs,
+        )

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/average_pooling2d.py

@@ -0,0 +1,109 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_pooling import BasePooling
+
+
+@keras_export(["keras.layers.AveragePooling2D", "keras.layers.AvgPool2D"])
+class AveragePooling2D(BasePooling):
+    """Average pooling operation for 2D spatial data.
+
+    Downsamples the input along its spatial dimensions (height and width)
+    by taking the average value over an input window
+    (of size defined by `pool_size`) for each channel of the input.
+    The window is shifted by `strides` along each dimension.
+
+    The resulting output when using the `"valid"` padding option has a spatial
+    shape (number of rows or columns) of:
+    `output_shape = math.floor((input_shape - pool_size) / strides) + 1`
+    (when `input_shape >= pool_size`)
+
+    The resulting output shape when using the `"same"` padding option is:
+    `output_shape = math.floor((input_shape - 1) / strides) + 1`
+
+    Args:
+        pool_size: int or tuple of 2 integers, factors by which to downscale
+            (dim1, dim2). If only one integer is specified, the same
+            window length will be used for all dimensions.
+        strides: int or tuple of 2 integers, or None. Strides values. If None,
+            it will default to `pool_size`. If only one int is specified, the
+            same stride size will be used for all dimensions.
+        padding: string, either `"valid"` or `"same"` (case-insensitive).
+            `"valid"` means no padding. `"same"` results in padding evenly to
+            the left/right or up/down of the input such that output has the same
+            height/width dimension as the input.
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape `(batch, height, width, channels)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, height, width)`. It defaults to the
+            `image_data_format` value found in your Keras config file at
+            `~/.keras/keras.json`. If you never set it, then it will be
+            `"channels_last"`.
+
+    Input shape:
+
+    - If `data_format="channels_last"`:
+        4D tensor with shape `(batch_size, height, width, channels)`.
+    - If `data_format="channels_first"`:
+        4D tensor with shape `(batch_size, channels, height, width)`.
+
+    Output shape:
+
+    - If `data_format="channels_last"`:
+        4D tensor with shape
+        `(batch_size, pooled_height, pooled_width, channels)`.
+    - If `data_format="channels_first"`:
+        4D tensor with shape
+        `(batch_size, channels, pooled_height, pooled_width)`.
+
+    Examples:
+
+    `strides=(1, 1)` and `padding="valid"`:
+
+    >>> x = np.array([[1., 2., 3.],
+    ...               [4., 5., 6.],
+    ...               [7., 8., 9.]])
+    >>> x = np.reshape(x, [1, 3, 3, 1])
+    >>> avg_pool_2d = keras.layers.AveragePooling2D(pool_size=(2, 2),
+    ...    strides=(1, 1), padding="valid")
+    >>> avg_pool_2d(x)
+
+    `strides=(2, 2)` and `padding="valid"`:
+
+    >>> x = np.array([[1., 2., 3., 4.],
+    ...              [5., 6., 7., 8.],
+    ...              [9., 10., 11., 12.]])
+    >>> x = np.reshape(x, [1, 3, 4, 1])
+    >>> avg_pool_2d = keras.layers.AveragePooling2D(pool_size=(2, 2),
+    ...    strides=(2, 2), padding="valid")
+    >>> avg_pool_2d(x)
+
+    `stride=(1, 1)` and `padding="same"`:
+
+    >>> x = np.array([[1., 2., 3.],
+    ...                  [4., 5., 6.],
+    ...                  [7., 8., 9.]])
+    >>> x = np.reshape(x, [1, 3, 3, 1])
+    >>> avg_pool_2d = keras.layers.AveragePooling2D(pool_size=(2, 2),
+    ...    strides=(1, 1), padding="same")
+    >>> avg_pool_2d(x)
+    """
+
+    def __init__(
+        self,
+        pool_size,
+        strides=None,
+        padding="valid",
+        data_format=None,
+        name=None,
+        **kwargs,
+    ):
+        super().__init__(
+            pool_size,
+            strides,
+            pool_dimensions=2,
+            pool_mode="average",
+            padding=padding,
+            data_format=data_format,
+            name=name,
+            **kwargs,
+        )

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/average_pooling3d.py

@@ -0,0 +1,85 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_pooling import BasePooling
+
+
+@keras_export(["keras.layers.AveragePooling3D", "keras.layers.AvgPool3D"])
+class AveragePooling3D(BasePooling):
+    """Average pooling operation for 3D data (spatial or spatio-temporal).
+
+    Downsamples the input along its spatial dimensions (depth, height, and
+    width) by taking the average value over an input window (of size defined by
+    `pool_size`) for each channel of the input. The window is shifted by
+    `strides` along each dimension.
+
+    Args:
+        pool_size: int or tuple of 3 integers, factors by which to downscale
+            (dim1, dim2, dim3). If only one integer is specified, the same
+            window length will be used for all dimensions.
+        strides: int or tuple of 3 integers, or None. Strides values. If None,
+            it will default to `pool_size`. If only one int is specified, the
+            same stride size will be used for all dimensions.
+        padding: string, either `"valid"` or `"same"` (case-insensitive).
+            `"valid"` means no padding. `"same"` results in padding evenly to
+            the left/right or up/down of the input such that output has the same
+            height/width dimension as the input.
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape
+            `(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels)` while
+            `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)`.
+            It defaults to the `image_data_format` value found in your Keras
+            config file at `~/.keras/keras.json`. If you never set it, then it
+            will be `"channels_last"`.
+
+    Input shape:
+
+    - If `data_format="channels_last"`:
+        5D tensor with shape:
+        `(batch_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)`
+    - If `data_format="channels_first"`:
+        5D tensor with shape:
+        `(batch_size, channels, spatial_dim1, spatial_dim2, spatial_dim3)`
+
+    Output shape:
+
+    - If `data_format="channels_last"`:
+        5D tensor with shape:
+        `(batch_size, pooled_dim1, pooled_dim2, pooled_dim3, channels)`
+    - If `data_format="channels_first"`:
+        5D tensor with shape:
+        `(batch_size, channels, pooled_dim1, pooled_dim2, pooled_dim3)`
+
+    Example:
+
+    ```python
+    depth = 30
+    height = 30
+    width = 30
+    channels = 3
+
+    inputs = keras.layers.Input(shape=(depth, height, width, channels))
+    layer = keras.layers.AveragePooling3D(pool_size=3)
+    outputs = layer(inputs)  # Shape: (batch_size, 10, 10, 10, 3)
+    ```
+    """
+
+    def __init__(
+        self,
+        pool_size,
+        strides=None,
+        padding="valid",
+        data_format=None,
+        name=None,
+        **kwargs,
+    ):
+        super().__init__(
+            pool_size,
+            strides,
+            pool_dimensions=3,
+            pool_mode="average",
+            padding=padding,
+            data_format=data_format,
+            name=name,
+            **kwargs,
+        )

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/base_global_pooling.py

@@ -0,0 +1,49 @@
+from keras.src import backend
+from keras.src.layers.input_spec import InputSpec
+from keras.src.layers.layer import Layer
+
+
+class BaseGlobalPooling(Layer):
+    """Base global pooling layer."""
+
+    def __init__(
+        self, pool_dimensions, data_format=None, keepdims=False, **kwargs
+    ):
+        super().__init__(**kwargs)
+
+        self.data_format = backend.standardize_data_format(data_format)
+        self.keepdims = keepdims
+        self.input_spec = InputSpec(ndim=pool_dimensions + 2)
+        self.built = True
+
+    def call(self, inputs):
+        raise NotImplementedError
+
+    def compute_output_shape(self, input_shape):
+        num_spatial_dims = len(input_shape) - 2
+        if self.data_format == "channels_last":
+            if self.keepdims:
+                return (
+                    (input_shape[0],)
+                    + (1,) * num_spatial_dims
+                    + (input_shape[-1],)
+                )
+            else:
+                return (input_shape[0],) + (input_shape[-1],)
+        else:
+            if self.keepdims:
+                return (input_shape[0], input_shape[1]) + (
+                    1,
+                ) * num_spatial_dims
+            else:
+                return (input_shape[0], input_shape[1])
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "data_format": self.data_format,
+                "keepdims": self.keepdims,
+            }
+        )
+        return config

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/base_pooling.py

@@ -0,0 +1,81 @@
+from keras.src import backend
+from keras.src import ops
+from keras.src.layers.input_spec import InputSpec
+from keras.src.layers.layer import Layer
+from keras.src.ops.operation_utils import compute_pooling_output_shape
+from keras.src.utils import argument_validation
+
+
+class BasePooling(Layer):
+    """Base pooling layer."""
+
+    def __init__(
+        self,
+        pool_size,
+        strides,
+        pool_dimensions,
+        pool_mode="max",
+        padding="valid",
+        data_format=None,
+        name=None,
+        **kwargs,
+    ):
+        super().__init__(name=name, **kwargs)
+
+        self.pool_size = argument_validation.standardize_tuple(
+            pool_size, pool_dimensions, "pool_size"
+        )
+        strides = pool_size if strides is None else strides
+        self.strides = argument_validation.standardize_tuple(
+            strides, pool_dimensions, "strides", allow_zero=True
+        )
+        self.pool_mode = pool_mode
+        self.padding = padding
+        self.data_format = backend.standardize_data_format(data_format)
+
+        self.input_spec = InputSpec(ndim=pool_dimensions + 2)
+        self.built = True
+
+    def call(self, inputs):
+        if self.pool_mode == "max":
+            return ops.max_pool(
+                inputs,
+                pool_size=self.pool_size,
+                strides=self.strides,
+                padding=self.padding,
+                data_format=self.data_format,
+            )
+        elif self.pool_mode == "average":
+            return ops.average_pool(
+                inputs,
+                pool_size=self.pool_size,
+                strides=self.strides,
+                padding=self.padding,
+                data_format=self.data_format,
+            )
+        else:
+            raise ValueError(
+                "`pool_mode` must be either 'max' or 'average'. Received: "
+                f"{self.pool_mode}."
+            )
+
+    def compute_output_shape(self, input_shape):
+        return compute_pooling_output_shape(
+            input_shape,
+            self.pool_size,
+            self.strides,
+            self.padding,
+            self.data_format,
+        )
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "pool_size": self.pool_size,
+                "padding": self.padding,
+                "strides": self.strides,
+                "data_format": self.data_format,
+            }
+        )
+        return config

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/global_average_pooling1d.py

@@ -0,0 +1,86 @@
+from keras.src import backend
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_global_pooling import BaseGlobalPooling
+
+
+@keras_export(
+    [
+        "keras.layers.GlobalAveragePooling1D",
+        "keras.layers.GlobalAvgPool1D",
+    ]
+)
+class GlobalAveragePooling1D(BaseGlobalPooling):
+    """Global average pooling operation for temporal data.
+
+    Args:
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape `(batch, steps, features)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, features, steps)`. It defaults to the `image_data_format`
+            value found in your Keras config file at `~/.keras/keras.json`.
+            If you never set it, then it will be `"channels_last"`.
+        keepdims: A boolean, whether to keep the temporal dimension or not.
+            If `keepdims` is `False` (default), the rank of the tensor is
+            reduced for spatial dimensions. If `keepdims` is `True`, the
+            temporal dimension are retained with length 1.
+            The behavior is the same as for `tf.reduce_mean` or `np.mean`.
+
+    Call arguments:
+        inputs: A 3D tensor.
+        mask: Binary tensor of shape `(batch_size, steps)` indicating whether
+            a given step should be masked (excluded from the average).
+
+    Input shape:
+
+    - If `data_format='channels_last'`:
+        3D tensor with shape:
+        `(batch_size, steps, features)`
+    - If `data_format='channels_first'`:
+        3D tensor with shape:
+        `(batch_size, features, steps)`
+
+    Output shape:
+
+    - If `keepdims=False`:
+        2D tensor with shape `(batch_size, features)`.
+    - If `keepdims=True`:
+        - If `data_format="channels_last"`:
+            3D tensor with shape `(batch_size, 1, features)`
+        - If `data_format="channels_first"`:
+            3D tensor with shape `(batch_size, features, 1)`
+
+    Example:
+
+    >>> x = np.random.rand(2, 3, 4)
+    >>> y = keras.layers.GlobalAveragePooling1D()(x)
+    >>> y.shape
+    (2, 4)
+    """
+
+    def __init__(self, data_format=None, keepdims=False, **kwargs):
+        super().__init__(
+            pool_dimensions=1,
+            data_format=data_format,
+            keepdims=keepdims,
+            **kwargs,
+        )
+        self.supports_masking = True
+
+    def call(self, inputs, mask=None):
+        steps_axis = 1 if self.data_format == "channels_last" else 2
+        if mask is not None:
+            mask = backend.cast(mask, inputs[0].dtype)
+            mask = ops.expand_dims(
+                mask, 2 if self.data_format == "channels_last" else 1
+            )
+            inputs *= mask
+            return ops.sum(
+                inputs, axis=steps_axis, keepdims=self.keepdims
+            ) / ops.sum(mask, axis=steps_axis, keepdims=self.keepdims)
+        else:
+            return ops.mean(inputs, axis=steps_axis, keepdims=self.keepdims)
+
+    def compute_mask(self, inputs, mask=None):
+        return None

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/global_average_pooling2d.py

@@ -0,0 +1,68 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_global_pooling import BaseGlobalPooling
+
+
+@keras_export(
+    [
+        "keras.layers.GlobalAveragePooling2D",
+        "keras.layers.GlobalAvgPool2D",
+    ]
+)
+class GlobalAveragePooling2D(BaseGlobalPooling):
+    """Global average pooling operation for 2D data.
+
+    Args:
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape `(batch, height, width, channels)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, features, height, weight)`. It defaults to the
+            `image_data_format` value found in your Keras config file at
+            `~/.keras/keras.json`. If you never set it, then it will be
+            `"channels_last"`.
+        keepdims: A boolean, whether to keep the temporal dimension or not.
+            If `keepdims` is `False` (default), the rank of the tensor is
+            reduced for spatial dimensions. If `keepdims` is `True`, the
+            spatial dimension are retained with length 1.
+            The behavior is the same as for `tf.reduce_mean` or `np.mean`.
+
+    Input shape:
+
+    - If `data_format='channels_last'`:
+        4D tensor with shape:
+        `(batch_size, height, width, channels)`
+    - If `data_format='channels_first'`:
+        4D tensor with shape:
+        `(batch_size, channels, height, width)`
+
+    Output shape:
+
+    - If `keepdims=False`:
+        2D tensor with shape `(batch_size, channels)`.
+    - If `keepdims=True`:
+        - If `data_format="channels_last"`:
+            4D tensor with shape `(batch_size, 1, 1, channels)`
+        - If `data_format="channels_first"`:
+            4D tensor with shape `(batch_size, channels, 1, 1)`
+
+    Example:
+
+    >>> x = np.random.rand(2, 4, 5, 3)
+    >>> y = keras.layers.GlobalAveragePooling2D()(x)
+    >>> y.shape
+    (2, 3)
+    """
+
+    def __init__(self, data_format=None, keepdims=False, **kwargs):
+        super().__init__(
+            pool_dimensions=2,
+            data_format=data_format,
+            keepdims=keepdims,
+            **kwargs,
+        )
+
+    def call(self, inputs):
+        if self.data_format == "channels_last":
+            return ops.mean(inputs, axis=[1, 2], keepdims=self.keepdims)
+        return ops.mean(inputs, axis=[2, 3], keepdims=self.keepdims)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/global_average_pooling3d.py

@@ -0,0 +1,69 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_global_pooling import BaseGlobalPooling
+
+
+@keras_export(
+    [
+        "keras.layers.GlobalAveragePooling3D",
+        "keras.layers.GlobalAvgPool3D",
+    ]
+)
+class GlobalAveragePooling3D(BaseGlobalPooling):
+    """Global average pooling operation for 3D data.
+
+    Args:
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape
+            `(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)`.
+            It defaults to the `image_data_format` value found in your Keras
+            config file at `~/.keras/keras.json`. If you never set it, then it
+            will be `"channels_last"`.
+        keepdims: A boolean, whether to keep the temporal dimension or not.
+            If `keepdims` is `False` (default), the rank of the tensor is
+            reduced for spatial dimensions. If `keepdims` is `True`, the
+            spatial dimension are retained with length 1.
+            The behavior is the same as for `tf.reduce_mean` or `np.mean`.
+
+    Input shape:
+
+    - If `data_format='channels_last'`:
+        5D tensor with shape:
+        `(batch_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)`
+    - If `data_format='channels_first'`:
+        5D tensor with shape:
+        `(batch_size, channels, spatial_dim1, spatial_dim2, spatial_dim3)`
+
+    Output shape:
+
+    - If `keepdims=False`:
+        2D tensor with shape `(batch_size, channels)`.
+    - If `keepdims=True`:
+        - If `data_format="channels_last"`:
+            5D tensor with shape `(batch_size, 1, 1, 1, channels)`
+        - If `data_format="channels_first"`:
+            5D tensor with shape `(batch_size, channels, 1, 1, 1)`
+
+    Example:
+
+    >>> x = np.random.rand(2, 4, 5, 4, 3)
+    >>> y = keras.layers.GlobalAveragePooling3D()(x)
+    >>> y.shape
+    (2, 3)
+    """
+
+    def __init__(self, data_format=None, keepdims=False, **kwargs):
+        super().__init__(
+            pool_dimensions=3,
+            data_format=data_format,
+            keepdims=keepdims,
+            **kwargs,
+        )
+
+    def call(self, inputs):
+        if self.data_format == "channels_last":
+            return ops.mean(inputs, axis=[1, 2, 3], keepdims=self.keepdims)
+        return ops.mean(inputs, axis=[2, 3, 4], keepdims=self.keepdims)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/global_max_pooling1d.py

@@ -0,0 +1,66 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_global_pooling import BaseGlobalPooling
+
+
+@keras_export(
+    [
+        "keras.layers.GlobalMaxPooling1D",
+        "keras.layers.GlobalMaxPool1D",
+    ]
+)
+class GlobalMaxPooling1D(BaseGlobalPooling):
+    """Global max pooling operation for temporal data.
+
+    Args:
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape `(batch, steps, features)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, features, steps)`. It defaults to the `image_data_format`
+            value found in your Keras config file at `~/.keras/keras.json`.
+            If you never set it, then it will be `"channels_last"`.
+        keepdims: A boolean, whether to keep the temporal dimension or not.
+            If `keepdims` is `False` (default), the rank of the tensor is
+            reduced for spatial dimensions. If `keepdims` is `True`, the
+            temporal dimension are retained with length 1.
+            The behavior is the same as for `tf.reduce_mean` or `np.mean`.
+
+    Input shape:
+
+    - If `data_format='channels_last'`:
+        3D tensor with shape:
+        `(batch_size, steps, features)`
+    - If `data_format='channels_first'`:
+        3D tensor with shape:
+        `(batch_size, features, steps)`
+
+    Output shape:
+
+    - If `keepdims=False`:
+        2D tensor with shape `(batch_size, features)`.
+    - If `keepdims=True`:
+        - If `data_format="channels_last"`:
+            3D tensor with shape `(batch_size, 1, features)`
+        - If `data_format="channels_first"`:
+            3D tensor with shape `(batch_size, features, 1)`
+
+    Example:
+
+    >>> x = np.random.rand(2, 3, 4)
+    >>> y = keras.layers.GlobalMaxPooling1D()(x)
+    >>> y.shape
+    (2, 4)
+    """
+
+    def __init__(self, data_format=None, keepdims=False, **kwargs):
+        super().__init__(
+            pool_dimensions=1,
+            data_format=data_format,
+            keepdims=keepdims,
+            **kwargs,
+        )
+
+    def call(self, inputs):
+        steps_axis = 1 if self.data_format == "channels_last" else 2
+        return ops.max(inputs, axis=steps_axis, keepdims=self.keepdims)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/global_max_pooling2d.py

@@ -0,0 +1,68 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_global_pooling import BaseGlobalPooling
+
+
+@keras_export(
+    [
+        "keras.layers.GlobalMaxPooling2D",
+        "keras.layers.GlobalMaxPool2D",
+    ]
+)
+class GlobalMaxPooling2D(BaseGlobalPooling):
+    """Global max pooling operation for 2D data.
+
+    Args:
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape `(batch, height, width, channels)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, features, height, weight)`. It defaults to the
+            `image_data_format` value found in your Keras config file at
+            `~/.keras/keras.json`. If you never set it, then it will be
+            `"channels_last"`.
+        keepdims: A boolean, whether to keep the temporal dimension or not.
+            If `keepdims` is `False` (default), the rank of the tensor is
+            reduced for spatial dimensions. If `keepdims` is `True`, the
+            spatial dimension are retained with length 1.
+            The behavior is the same as for `tf.reduce_mean` or `np.mean`.
+
+    Input shape:
+
+    - If `data_format='channels_last'`:
+        4D tensor with shape:
+        `(batch_size, height, width, channels)`
+    - If `data_format='channels_first'`:
+        4D tensor with shape:
+        `(batch_size, channels, height, width)`
+
+    Output shape:
+
+    - If `keepdims=False`:
+        2D tensor with shape `(batch_size, channels)`.
+    - If `keepdims=True`:
+        - If `data_format="channels_last"`:
+            4D tensor with shape `(batch_size, 1, 1, channels)`
+        - If `data_format="channels_first"`:
+            4D tensor with shape `(batch_size, channels, 1, 1)`
+
+    Example:
+
+    >>> x = np.random.rand(2, 4, 5, 3)
+    >>> y = keras.layers.GlobalMaxPooling2D()(x)
+    >>> y.shape
+    (2, 3)
+    """
+
+    def __init__(self, data_format=None, keepdims=False, **kwargs):
+        super().__init__(
+            pool_dimensions=2,
+            data_format=data_format,
+            keepdims=keepdims,
+            **kwargs,
+        )
+
+    def call(self, inputs):
+        if self.data_format == "channels_last":
+            return ops.max(inputs, axis=[1, 2], keepdims=self.keepdims)
+        return ops.max(inputs, axis=[2, 3], keepdims=self.keepdims)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/global_max_pooling3d.py

@@ -0,0 +1,69 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_global_pooling import BaseGlobalPooling
+
+
+@keras_export(
+    [
+        "keras.layers.GlobalMaxPooling3D",
+        "keras.layers.GlobalMaxPool3D",
+    ]
+)
+class GlobalMaxPooling3D(BaseGlobalPooling):
+    """Global max pooling operation for 3D data.
+
+    Args:
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape
+            `(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)`.
+            It defaults to the `image_data_format` value found in your Keras
+            config file at `~/.keras/keras.json`. If you never set it, then it
+            will be `"channels_last"`.
+        keepdims: A boolean, whether to keep the temporal dimension or not.
+            If `keepdims` is `False` (default), the rank of the tensor is
+            reduced for spatial dimensions. If `keepdims` is `True`, the
+            spatial dimension are retained with length 1.
+            The behavior is the same as for `tf.reduce_mean` or `np.mean`.
+
+    Input shape:
+
+    - If `data_format='channels_last'`:
+        5D tensor with shape:
+        `(batch_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)`
+    - If `data_format='channels_first'`:
+        5D tensor with shape:
+        `(batch_size, channels, spatial_dim1, spatial_dim2, spatial_dim3)`
+
+    Output shape:
+
+    - If `keepdims=False`:
+        2D tensor with shape `(batch_size, channels)`.
+    - If `keepdims=True`:
+        - If `data_format="channels_last"`:
+            5D tensor with shape `(batch_size, 1, 1, 1, channels)`
+        - If `data_format="channels_first"`:
+            5D tensor with shape `(batch_size, channels, 1, 1, 1)`
+
+    Example:
+
+    >>> x = np.random.rand(2, 4, 5, 4, 3)
+    >>> y = keras.layers.GlobalMaxPooling3D()(x)
+    >>> y.shape
+    (2, 3)
+    """
+
+    def __init__(self, data_format=None, keepdims=False, **kwargs):
+        super().__init__(
+            pool_dimensions=3,
+            data_format=data_format,
+            keepdims=keepdims,
+            **kwargs,
+        )
+
+    def call(self, inputs):
+        if self.data_format == "channels_last":
+            return ops.max(inputs, axis=[1, 2, 3], keepdims=self.keepdims)
+        return ops.max(inputs, axis=[2, 3, 4], keepdims=self.keepdims)

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/pooling/max_pooling1d.py

@@ -0,0 +1,93 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.pooling.base_pooling import BasePooling
+
+
+@keras_export(["keras.layers.MaxPooling1D", "keras.layers.MaxPool1D"])
+class MaxPooling1D(BasePooling):
+    """Max pooling operation for 1D temporal data.
+
+    Downsamples the input representation by taking the maximum value over a
+    spatial window of size `pool_size`. The window is shifted by `strides`.
+
+    The resulting output when using the `"valid"` padding option has a shape of:
+    `output_shape = (input_shape - pool_size + 1) / strides)`.
+
+    The resulting output shape when using the `"same"` padding option is:
+    `output_shape = input_shape / strides`
+
+    Args:
+        pool_size: int, size of the max pooling window.
+        strides: int or None. Specifies how much the pooling window moves
+            for each pooling step. If None, it will default to `pool_size`.
+        padding: string, either `"valid"` or `"same"` (case-insensitive).
+            `"valid"` means no padding. `"same"` results in padding evenly to
+            the left/right or up/down of the input such that output has the same
+            height/width dimension as the input.
+        data_format: string, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape `(batch, steps, features)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, features, steps)`. It defaults to the `image_data_format`
+            value found in your Keras config file at `~/.keras/keras.json`.
+            If you never set it, then it will be `"channels_last"`.
+
+    Input shape:
+
+    - If `data_format="channels_last"`:
+        3D tensor with shape `(batch_size, steps, features)`.
+    - If `data_format="channels_first"`:
+        3D tensor with shape `(batch_size, features, steps)`.
+
+    Output shape:
+
+    - If `data_format="channels_last"`:
+        3D tensor with shape `(batch_size, downsampled_steps, features)`.
+    - If `data_format="channels_first"`:
+        3D tensor with shape `(batch_size, features, downsampled_steps)`.
+
+    Examples:
+
+    `strides=1` and `padding="valid"`:
+
+    >>> x = np.array([1., 2., 3., 4., 5.])
+    >>> x = np.reshape(x, [1, 5, 1])
+    >>> max_pool_1d = keras.layers.MaxPooling1D(pool_size=2,
+    ...    strides=1, padding="valid")
+    >>> max_pool_1d(x)
+
+    `strides=2` and `padding="valid"`:
+
+    >>> x = np.array([1., 2., 3., 4., 5.])
+    >>> x = np.reshape(x, [1, 5, 1])
+    >>> max_pool_1d = keras.layers.MaxPooling1D(pool_size=2,
+    ...    strides=2, padding="valid")
+    >>> max_pool_1d(x)
+
+    `strides=1` and `padding="same"`:
+
+    >>> x = np.array([1., 2., 3., 4., 5.])
+    >>> x = np.reshape(x, [1, 5, 1])
+    >>> max_pool_1d = keras.layers.MaxPooling1D(pool_size=2,
+    ...    strides=1, padding="same")
+    >>> max_pool_1d(x)
+    """
+
+    def __init__(
+        self,
+        pool_size=2,
+        strides=None,
+        padding="valid",
+        data_format=None,
+        name=None,
+        **kwargs,
+    ):
+        super().__init__(
+            pool_size,
+            strides,
+            pool_dimensions=1,
+            pool_mode="max",
+            padding=padding,
+            data_format=data_format,
+            name=name,
+            **kwargs,
+        )