Add files using upload-large-folder tool

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

@@ -0,0 +1,166 @@
+from keras.src.api_export import keras_export
+from keras.src.backend import KerasTensor
+from keras.src.layers.preprocessing.tf_data_layer import TFDataLayer
+from keras.src.utils import backend_utils
+from keras.src.utils import numerical_utils
+
+
+@keras_export("keras.layers.CategoryEncoding")
+class CategoryEncoding(TFDataLayer):
+    """A preprocessing layer which encodes integer features.
+
+    This layer provides options for condensing data into a categorical encoding
+    when the total number of tokens are known in advance. It accepts integer
+    values as inputs, and it outputs a dense or sparse representation of those
+    inputs. For integer inputs where the total number of tokens is not known,
+    use `keras.layers.IntegerLookup` instead.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    Examples:
+
+    **One-hot encoding data**
+
+    >>> layer = keras.layers.CategoryEncoding(
+    ...           num_tokens=4, output_mode="one_hot")
+    >>> layer([3, 2, 0, 1])
+    array([[0., 0., 0., 1.],
+            [0., 0., 1., 0.],
+            [1., 0., 0., 0.],
+            [0., 1., 0., 0.]]>
+
+    **Multi-hot encoding data**
+
+    >>> layer = keras.layers.CategoryEncoding(
+    ...           num_tokens=4, output_mode="multi_hot")
+    >>> layer([[0, 1], [0, 0], [1, 2], [3, 1]])
+    array([[1., 1., 0., 0.],
+            [1., 0., 0., 0.],
+            [0., 1., 1., 0.],
+            [0., 1., 0., 1.]]>
+
+    **Using weighted inputs in `"count"` mode**
+
+    >>> layer = keras.layers.CategoryEncoding(
+    ...           num_tokens=4, output_mode="count")
+    >>> count_weights = np.array([[.1, .2], [.1, .1], [.2, .3], [.4, .2]])
+    >>> layer([[0, 1], [0, 0], [1, 2], [3, 1]], count_weights=count_weights)
+      array([[0.1, 0.2, 0. , 0. ],
+             [0.2, 0. , 0. , 0. ],
+             [0. , 0.2, 0.3, 0. ],
+             [0. , 0.2, 0. , 0.4]]>
+
+    Args:
+        num_tokens: The total number of tokens the layer should support. All
+            inputs to the layer must integers in the range `0 <= value <
+            num_tokens`, or an error will be thrown.
+        output_mode: Specification for the output of the layer.
+            Values can be `"one_hot"`, `"multi_hot"` or `"count"`,
+            configuring the layer as follows:
+                - `"one_hot"`: Encodes each individual element in the input
+                    into an array of `num_tokens` size, containing a 1 at the
+                    element index. If the last dimension is size 1, will encode
+                    on that dimension. If the last dimension is not size 1,
+                    will append a new dimension for the encoded output.
+                - `"multi_hot"`: Encodes each sample in the input into a single
+                    array of `num_tokens` size, containing a 1 for each
+                    vocabulary term present in the sample. Treats the last
+                    dimension as the sample dimension, if input shape is
+                    `(..., sample_length)`, output shape will be
+                    `(..., num_tokens)`.
+                - `"count"`: Like `"multi_hot"`, but the int array contains a
+                    count of the number of times the token at that index
+                    appeared in the sample.
+            For all output modes, currently only output up to rank 2 is
+            supported.
+            Defaults to `"multi_hot"`.
+        sparse: Whether to return a sparse tensor; for backends that support
+            sparse tensors.
+
+    Call arguments:
+        inputs: A 1D or 2D tensor of integer inputs.
+        count_weights: A tensor in the same shape as `inputs` indicating the
+            weight for each sample value when summing up in `count` mode.
+            Not used in `"multi_hot"` or `"one_hot"` modes.
+    """
+
+    def __init__(
+        self, num_tokens=None, output_mode="multi_hot", sparse=False, **kwargs
+    ):
+        super().__init__(**kwargs)
+
+        # Support deprecated names for output_modes.
+        if output_mode == "binary":
+            output_mode = "multi_hot"
+
+        # 'output_mode' must be one of ("count", "one_hot", "multi_hot")
+        if output_mode not in ("count", "one_hot", "multi_hot"):
+            raise ValueError(f"Unknown arg for output_mode: {output_mode}")
+
+        if num_tokens is None:
+            raise ValueError(
+                "num_tokens must be set to use this layer. If the "
+                "number of tokens is not known beforehand, use the "
+                "IntegerLookup layer instead."
+            )
+        if num_tokens < 1:
+            raise ValueError(
+                f"`num_tokens` must be >= 1. Received: num_tokens={num_tokens}."
+            )
+        self.num_tokens = num_tokens
+        self.output_mode = output_mode
+        self.sparse = sparse
+        self._allow_non_tensor_positional_args = True
+        self._convert_input_args = False
+
+    def _encode(self, inputs, count_weights=None):
+        inputs = self.backend.core.convert_to_tensor(inputs)
+        return numerical_utils.encode_categorical_inputs(
+            inputs,
+            output_mode=self.output_mode,
+            depth=self.num_tokens,
+            dtype=self.dtype,
+            sparse=self.sparse,
+            count_weights=count_weights,
+            backend_module=self.backend,
+        )
+
+    def compute_output_shape(self, input_shape):
+        if (input_shape is not None) & (len(input_shape) == 0):
+            return (self.num_tokens,)
+        if self.output_mode == "one_hot":
+            if input_shape[-1] != 1:
+                return tuple(input_shape) + (self.num_tokens,)
+            elif len(input_shape) == 1:
+                return tuple(input_shape) + (self.num_tokens,)
+            else:
+                return tuple(input_shape[:-1]) + (self.num_tokens,)
+        return tuple(input_shape[:-1]) + (self.num_tokens,)
+
+    def compute_output_spec(self, inputs, count_weights=None):
+        output_shape = self.compute_output_shape(inputs.shape)
+        return KerasTensor(
+            output_shape, dtype=self.compute_dtype, sparse=self.sparse
+        )
+
+    def get_config(self):
+        config = {
+            "num_tokens": self.num_tokens,
+            "output_mode": self.output_mode,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}
+
+    def call(self, inputs, count_weights=None):
+        if count_weights is not None:
+            if self.output_mode != "count":
+                raise ValueError(
+                    "`count_weights` is not used when `output_mode` is not "
+                    "`'count'`. Received `count_weights={count_weights}`."
+                )
+            count_weights = self.backend.convert_to_tensor(
+                count_weights, dtype=self.compute_dtype
+            )
+        outputs = self._encode(inputs, count_weights)
+        return backend_utils.convert_tf_tensor(outputs)

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

@@ -0,0 +1,337 @@
+import numpy as np
+
+from keras.src import backend
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.tf_data_layer import TFDataLayer
+from keras.src.utils import argument_validation
+from keras.src.utils import numerical_utils
+from keras.src.utils.module_utils import tensorflow as tf
+
+
+@keras_export("keras.layers.Discretization")
+class Discretization(TFDataLayer):
+    """A preprocessing layer which buckets continuous features by ranges.
+
+    This layer will place each element of its input data into one of several
+    contiguous ranges and output an integer index indicating which range each
+    element was placed in.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    Input shape:
+        Any array of dimension 2 or higher.
+
+    Output shape:
+        Same as input shape.
+
+    Arguments:
+        bin_boundaries: A list of bin boundaries.
+            The leftmost and rightmost bins
+            will always extend to `-inf` and `inf`,
+            so `bin_boundaries=[0., 1., 2.]`
+            generates bins `(-inf, 0.)`, `[0., 1.)`, `[1., 2.)`,
+            and `[2., +inf)`.
+            If this option is set, `adapt()` should not be called.
+        num_bins: The integer number of bins to compute.
+            If this option is set,
+            `adapt()` should be called to learn the bin boundaries.
+        epsilon: Error tolerance, typically a small fraction
+            close to zero (e.g. 0.01). Higher values of epsilon increase
+            the quantile approximation, and hence result in more
+            unequal buckets, but could improve performance
+            and resource consumption.
+        output_mode: Specification for the output of the layer.
+            Values can be `"int"`, `"one_hot"`, `"multi_hot"`, or
+            `"count"` configuring the layer as follows:
+            - `"int"`: Return the discretized bin indices directly.
+            - `"one_hot"`: Encodes each individual element in the
+                input into an array the same size as `num_bins`,
+                containing a 1 at the input's bin
+                index. If the last dimension is size 1, will encode on that
+                dimension.  If the last dimension is not size 1,
+                will append a new dimension for the encoded output.
+            - `"multi_hot"`: Encodes each sample in the input into a
+                single array the same size as `num_bins`,
+                containing a 1 for each bin index
+                index present in the sample.
+                Treats the last dimension as the sample
+                dimension, if input shape is `(..., sample_length)`,
+                output shape will be `(..., num_tokens)`.
+            - `"count"`: As `"multi_hot"`, but the int array contains
+                a count of the number of times the bin index appeared
+                in the sample.
+            Defaults to `"int"`.
+        sparse: Boolean. Only applicable to `"one_hot"`, `"multi_hot"`,
+            and `"count"` output modes. Only supported with TensorFlow
+            backend. If `True`, returns a `SparseTensor` instead of
+            a dense `Tensor`. Defaults to `False`.
+
+    Examples:
+
+    Discretize float values based on provided buckets.
+    >>> input = np.array([[-1.5, 1.0, 3.4, .5], [0.0, 3.0, 1.3, 0.0]])
+    >>> layer = Discretization(bin_boundaries=[0., 1., 2.])
+    >>> layer(input)
+    array([[0, 2, 3, 1],
+           [1, 3, 2, 1]])
+
+    Discretize float values based on a number of buckets to compute.
+    >>> input = np.array([[-1.5, 1.0, 3.4, .5], [0.0, 3.0, 1.3, 0.0]])
+    >>> layer = Discretization(num_bins=4, epsilon=0.01)
+    >>> layer.adapt(input)
+    >>> layer(input)
+    array([[0, 2, 3, 2],
+           [1, 3, 3, 1]])
+    """
+
+    def __init__(
+        self,
+        bin_boundaries=None,
+        num_bins=None,
+        epsilon=0.01,
+        output_mode="int",
+        sparse=False,
+        dtype=None,
+        name=None,
+    ):
+        if dtype is None:
+            dtype = "int64" if output_mode == "int" else backend.floatx()
+
+        super().__init__(name=name, dtype=dtype)
+
+        if sparse and not backend.SUPPORTS_SPARSE_TENSORS:
+            raise ValueError(
+                f"`sparse=True` cannot be used with backend {backend.backend()}"
+            )
+        if sparse and output_mode == "int":
+            raise ValueError(
+                "`sparse=True` may only be used if `output_mode` is "
+                "`'one_hot'`, `'multi_hot'`, or `'count'`. "
+                f"Received: sparse={sparse} and "
+                f"output_mode={output_mode}"
+            )
+
+        argument_validation.validate_string_arg(
+            output_mode,
+            allowable_strings=(
+                "int",
+                "one_hot",
+                "multi_hot",
+                "count",
+            ),
+            caller_name=self.__class__.__name__,
+            arg_name="output_mode",
+        )
+
+        if num_bins is not None and num_bins < 0:
+            raise ValueError(
+                "`num_bins` must be greater than or equal to 0. "
+                f"Received: `num_bins={num_bins}`"
+            )
+        if num_bins is not None and bin_boundaries is not None:
+            if len(bin_boundaries) != num_bins - 1:
+                raise ValueError(
+                    "Both `num_bins` and `bin_boundaries` should not be "
+                    f"set. Received: `num_bins={num_bins}` and "
+                    f"`bin_boundaries={bin_boundaries}`"
+                )
+
+        self.input_bin_boundaries = bin_boundaries
+        self.bin_boundaries = (
+            bin_boundaries if bin_boundaries is not None else []
+        )
+        self.num_bins = num_bins
+        self.epsilon = epsilon
+        self.output_mode = output_mode
+        self.sparse = sparse
+
+        if self.bin_boundaries:
+            self.summary = None
+        else:
+            self.summary = np.array([[], []], dtype="float32")
+
+    def build(self, input_shape=None):
+        self.built = True
+
+    @property
+    def input_dtype(self):
+        return backend.floatx()
+
+    def adapt(self, data, steps=None):
+        """Computes bin boundaries from quantiles in a input dataset.
+
+        Calling `adapt()` on a `Discretization` layer is an alternative to
+        passing in a `bin_boundaries` argument during construction. A
+        `Discretization` layer should always be either adapted over a dataset or
+        passed `bin_boundaries`.
+
+        During `adapt()`, the layer will estimate the quantile boundaries of the
+        input dataset. The number of quantiles can be controlled via the
+        `num_bins` argument, and the error tolerance for quantile boundaries can
+        be controlled via the `epsilon` argument.
+
+        Arguments:
+            data: The data to train on. It can be passed either as a
+                batched `tf.data.Dataset`,
+                or as a NumPy array.
+            steps: Integer or `None`.
+                Total number of steps (batches of samples) to process.
+                If `data` is a `tf.data.Dataset`, and `steps` is `None`,
+                `adapt()` will run until the input dataset is exhausted.
+                When passing an infinitely
+                repeating dataset, you must specify the `steps` argument. This
+                argument is not supported with array inputs or list inputs.
+        """
+        if self.input_bin_boundaries is not None:
+            raise ValueError(
+                "Cannot adapt a Discretization layer that has been initialized "
+                "with `bin_boundaries`, use `num_bins` instead."
+            )
+        self.reset_state()
+        if isinstance(data, tf.data.Dataset):
+            if steps is not None:
+                data = data.take(steps)
+            for batch in data:
+                self.update_state(batch)
+        else:
+            self.update_state(data)
+        self.finalize_state()
+
+    def update_state(self, data):
+        data = np.array(data).astype("float32")
+        summary = summarize(data, self.epsilon)
+        self.summary = merge_summaries(summary, self.summary, self.epsilon)
+
+    def finalize_state(self):
+        if self.input_bin_boundaries is not None:
+            return
+        self.bin_boundaries = get_bin_boundaries(
+            self.summary, self.num_bins
+        ).tolist()
+
+    def reset_state(self):
+        if self.input_bin_boundaries is not None:
+            return
+        self.summary = np.array([[], []], dtype="float32")
+
+    def compute_output_spec(self, inputs):
+        return backend.KerasTensor(shape=inputs.shape, dtype=self.compute_dtype)
+
+    def load_own_variables(self, store):
+        if len(store) == 1:
+            # Legacy format case
+            self.summary = store["0"]
+        return
+
+    def call(self, inputs):
+        indices = self.backend.numpy.digitize(inputs, self.bin_boundaries)
+        return numerical_utils.encode_categorical_inputs(
+            indices,
+            output_mode=self.output_mode,
+            depth=len(self.bin_boundaries) + 1,
+            dtype=self.compute_dtype,
+            sparse=self.sparse,
+            backend_module=self.backend,
+        )
+
+    def get_config(self):
+        return {
+            "bin_boundaries": self.bin_boundaries,
+            "num_bins": self.num_bins,
+            "epsilon": self.epsilon,
+            "output_mode": self.output_mode,
+            "sparse": self.sparse,
+            "name": self.name,
+            "dtype": self.dtype,
+        }
+
+
+def summarize(values, epsilon):
+    """Reduce a 1D sequence of values to a summary.
+
+    This algorithm is based on numpy.quantiles but modified to allow for
+    intermediate steps between multiple data sets. It first finds the target
+    number of bins as the reciprocal of epsilon and then takes the individual
+    values spaced at appropriate intervals to arrive at that target.
+    The final step is to return the corresponding counts between those values
+    If the target num_bins is larger than the size of values, the whole array is
+    returned (with weights of 1).
+
+    Args:
+        values: 1D `np.ndarray` to be summarized.
+        epsilon: A `'float32'` that determines the approximate desired
+        precision.
+
+    Returns:
+        A 2D `np.ndarray` that is a summary of the inputs. First column is the
+        interpolated partition values, the second is the weights (counts).
+    """
+    values = np.reshape(values, [-1])
+    values = np.sort(values)
+    elements = np.size(values)
+    num_buckets = 1.0 / epsilon
+    increment = elements / num_buckets
+    start = increment
+    step = max(increment, 1)
+    boundaries = values[int(start) :: int(step)]
+    weights = np.ones_like(boundaries)
+    weights = weights * step
+    return np.stack([boundaries, weights])
+
+
+def merge_summaries(prev_summary, next_summary, epsilon):
+    """Weighted merge sort of summaries.
+
+    Given two summaries of distinct data, this function merges (and compresses)
+    them to stay within `epsilon` error tolerance.
+
+    Args:
+        prev_summary: 2D `np.ndarray` summary to be merged with `next_summary`.
+        next_summary: 2D `np.ndarray` summary to be merged with `prev_summary`.
+        epsilon: A float that determines the approximate desired precision.
+
+    Returns:
+        A 2-D `np.ndarray` that is a merged summary. First column is the
+        interpolated partition values, the second is the weights (counts).
+    """
+    merged = np.concatenate((prev_summary, next_summary), axis=1)
+    merged = np.take(merged, np.argsort(merged[0]), axis=1)
+    return compress_summary(merged, epsilon)
+
+
+def get_bin_boundaries(summary, num_bins):
+    return compress_summary(summary, 1.0 / num_bins)[0, :-1]
+
+
+def compress_summary(summary, epsilon):
+    """Compress a summary to within `epsilon` accuracy.
+
+    The compression step is needed to keep the summary sizes small after
+    merging, and also used to return the final target boundaries. It finds the
+    new bins based on interpolating cumulative weight percentages from the large
+    summary.  Taking the difference of the cumulative weights from the previous
+    bin's cumulative weight will give the new weight for that bin.
+
+    Args:
+        summary: 2D `np.ndarray` summary to be compressed.
+        epsilon: A `'float32'` that determines the approximate desired
+        precision.
+
+    Returns:
+        A 2D `np.ndarray` that is a compressed summary. First column is the
+        interpolated partition values, the second is the weights (counts).
+    """
+    if summary.shape[1] * epsilon < 1:
+        return summary
+
+    percents = epsilon + np.arange(0.0, 1.0, epsilon)
+    cum_weights = summary[1].cumsum()
+    cum_weight_percents = cum_weights / cum_weights[-1]
+    new_bins = np.interp(percents, cum_weight_percents, summary[0])
+    cum_weights = np.interp(percents, cum_weight_percents, cum_weights)
+    new_weights = cum_weights - np.concatenate(
+        (np.array([0]), cum_weights[:-1])
+    )
+    summary = np.stack((new_bins, new_weights))
+    return summary.astype("float32")

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

@@ -0,0 +1,815 @@
+from keras.src import backend
+from keras.src import layers
+from keras.src import tree
+from keras.src.api_export import keras_export
+from keras.src.layers.layer import Layer
+from keras.src.layers.preprocessing.tf_data_layer import TFDataLayer
+from keras.src.saving import saving_lib
+from keras.src.saving import serialization_lib
+from keras.src.utils import backend_utils
+from keras.src.utils.module_utils import tensorflow as tf
+from keras.src.utils.naming import auto_name
+
+
+class Cross:
+    def __init__(self, feature_names, crossing_dim, output_mode="one_hot"):
+        if output_mode not in {"int", "one_hot"}:
+            raise ValueError(
+                "Invalid value for argument `output_mode`. "
+                "Expected one of {'int', 'one_hot'}. "
+                f"Received: output_mode={output_mode}"
+            )
+        self.feature_names = tuple(feature_names)
+        self.crossing_dim = crossing_dim
+        self.output_mode = output_mode
+
+    @property
+    def name(self):
+        return "_X_".join(self.feature_names)
+
+    def get_config(self):
+        return {
+            "feature_names": self.feature_names,
+            "crossing_dim": self.crossing_dim,
+            "output_mode": self.output_mode,
+        }
+
+    @classmethod
+    def from_config(cls, config):
+        return cls(**config)
+
+
+class Feature:
+    def __init__(self, dtype, preprocessor, output_mode):
+        if output_mode not in {"int", "one_hot", "float"}:
+            raise ValueError(
+                "Invalid value for argument `output_mode`. "
+                "Expected one of {'int', 'one_hot', 'float'}. "
+                f"Received: output_mode={output_mode}"
+            )
+        self.dtype = dtype
+        if isinstance(preprocessor, dict):
+            preprocessor = serialization_lib.deserialize_keras_object(
+                preprocessor
+            )
+        self.preprocessor = preprocessor
+        self.output_mode = output_mode
+
+    def get_config(self):
+        return {
+            "dtype": self.dtype,
+            "preprocessor": serialization_lib.serialize_keras_object(
+                self.preprocessor
+            ),
+            "output_mode": self.output_mode,
+        }
+
+    @classmethod
+    def from_config(cls, config):
+        return cls(**config)
+
+
+@keras_export("keras.utils.FeatureSpace")
+class FeatureSpace(Layer):
+    """One-stop utility for preprocessing and encoding structured data.
+
+    Arguments:
+        feature_names: Dict mapping the names of your features to their
+            type specification, e.g. `{"my_feature": "integer_categorical"}`
+            or `{"my_feature": FeatureSpace.integer_categorical()}`.
+            For a complete list of all supported types, see
+            "Available feature types" paragraph below.
+        output_mode: One of `"concat"` or `"dict"`. In concat mode, all
+            features get concatenated together into a single vector.
+            In dict mode, the FeatureSpace returns a dict of individually
+            encoded features (with the same keys as the input dict keys).
+        crosses: List of features to be crossed together, e.g.
+            `crosses=[("feature_1", "feature_2")]`. The features will be
+            "crossed" by hashing their combined value into
+            a fixed-length vector.
+        crossing_dim: Default vector size for hashing crossed features.
+            Defaults to `32`.
+        hashing_dim: Default vector size for hashing features of type
+            `"integer_hashed"` and `"string_hashed"`. Defaults to `32`.
+        num_discretization_bins: Default number of bins to be used for
+            discretizing features of type `"float_discretized"`.
+            Defaults to `32`.
+
+    **Available feature types:**
+
+    Note that all features can be referred to by their string name,
+    e.g. `"integer_categorical"`. When using the string name, the default
+    argument values are used.
+
+    ```python
+    # Plain float values.
+    FeatureSpace.float(name=None)
+
+    # Float values to be preprocessed via featurewise standardization
+    # (i.e. via a `keras.layers.Normalization` layer).
+    FeatureSpace.float_normalized(name=None)
+
+    # Float values to be preprocessed via linear rescaling
+    # (i.e. via a `keras.layers.Rescaling` layer).
+    FeatureSpace.float_rescaled(scale=1., offset=0., name=None)
+
+    # Float values to be discretized. By default, the discrete
+    # representation will then be one-hot encoded.
+    FeatureSpace.float_discretized(
+        num_bins, bin_boundaries=None, output_mode="one_hot", name=None)
+
+    # Integer values to be indexed. By default, the discrete
+    # representation will then be one-hot encoded.
+    FeatureSpace.integer_categorical(
+        max_tokens=None, num_oov_indices=1, output_mode="one_hot", name=None)
+
+    # String values to be indexed. By default, the discrete
+    # representation will then be one-hot encoded.
+    FeatureSpace.string_categorical(
+        max_tokens=None, num_oov_indices=1, output_mode="one_hot", name=None)
+
+    # Integer values to be hashed into a fixed number of bins.
+    # By default, the discrete representation will then be one-hot encoded.
+    FeatureSpace.integer_hashed(num_bins, output_mode="one_hot", name=None)
+
+    # String values to be hashed into a fixed number of bins.
+    # By default, the discrete representation will then be one-hot encoded.
+    FeatureSpace.string_hashed(num_bins, output_mode="one_hot", name=None)
+    ```
+
+    Examples:
+
+    **Basic usage with a dict of input data:**
+
+    ```python
+    raw_data = {
+        "float_values": [0.0, 0.1, 0.2, 0.3],
+        "string_values": ["zero", "one", "two", "three"],
+        "int_values": [0, 1, 2, 3],
+    }
+    dataset = tf.data.Dataset.from_tensor_slices(raw_data)
+
+    feature_space = FeatureSpace(
+        features={
+            "float_values": "float_normalized",
+            "string_values": "string_categorical",
+            "int_values": "integer_categorical",
+        },
+        crosses=[("string_values", "int_values")],
+        output_mode="concat",
+    )
+    # Before you start using the FeatureSpace,
+    # you must `adapt()` it on some data.
+    feature_space.adapt(dataset)
+
+    # You can call the FeatureSpace on a dict of data (batched or unbatched).
+    output_vector = feature_space(raw_data)
+    ```
+
+    **Basic usage with `tf.data`:**
+
+    ```python
+    # Unlabeled data
+    preprocessed_ds = unlabeled_dataset.map(feature_space)
+
+    # Labeled data
+    preprocessed_ds = labeled_dataset.map(lambda x, y: (feature_space(x), y))
+    ```
+
+    **Basic usage with the Keras Functional API:**
+
+    ```python
+    # Retrieve a dict Keras Input objects
+    inputs = feature_space.get_inputs()
+    # Retrieve the corresponding encoded Keras tensors
+    encoded_features = feature_space.get_encoded_features()
+    # Build a Functional model
+    outputs = keras.layers.Dense(1, activation="sigmoid")(encoded_features)
+    model = keras.Model(inputs, outputs)
+    ```
+
+    **Customizing each feature or feature cross:**
+
+    ```python
+    feature_space = FeatureSpace(
+        features={
+            "float_values": FeatureSpace.float_normalized(),
+            "string_values": FeatureSpace.string_categorical(max_tokens=10),
+            "int_values": FeatureSpace.integer_categorical(max_tokens=10),
+        },
+        crosses=[
+            FeatureSpace.cross(("string_values", "int_values"), crossing_dim=32)
+        ],
+        output_mode="concat",
+    )
+    ```
+
+    **Returning a dict of integer-encoded features:**
+
+    ```python
+    feature_space = FeatureSpace(
+        features={
+            "string_values": FeatureSpace.string_categorical(output_mode="int"),
+            "int_values": FeatureSpace.integer_categorical(output_mode="int"),
+        },
+        crosses=[
+            FeatureSpace.cross(
+                feature_names=("string_values", "int_values"),
+                crossing_dim=32,
+                output_mode="int",
+            )
+        ],
+        output_mode="dict",
+    )
+    ```
+
+    **Specifying your own Keras preprocessing layer:**
+
+    ```python
+    # Let's say that one of the features is a short text paragraph that
+    # we want to encode as a vector (one vector per paragraph) via TF-IDF.
+    data = {
+        "text": ["1st string", "2nd string", "3rd string"],
+    }
+
+    # There's a Keras layer for this: TextVectorization.
+    custom_layer = layers.TextVectorization(output_mode="tf_idf")
+
+    # We can use FeatureSpace.feature to create a custom feature
+    # that will use our preprocessing layer.
+    feature_space = FeatureSpace(
+        features={
+            "text": FeatureSpace.feature(
+                preprocessor=custom_layer, dtype="string", output_mode="float"
+            ),
+        },
+        output_mode="concat",
+    )
+    feature_space.adapt(tf.data.Dataset.from_tensor_slices(data))
+    output_vector = feature_space(data)
+    ```
+
+    **Retrieving the underlying Keras preprocessing layers:**
+
+    ```python
+    # The preprocessing layer of each feature is available in `.preprocessors`.
+    preprocessing_layer = feature_space.preprocessors["feature1"]
+
+    # The crossing layer of each feature cross is available in `.crossers`.
+    # It's an instance of keras.layers.HashedCrossing.
+    crossing_layer = feature_space.crossers["feature1_X_feature2"]
+    ```
+
+    **Saving and reloading a FeatureSpace:**
+
+    ```python
+    feature_space.save("featurespace.keras")
+    reloaded_feature_space = keras.models.load_model("featurespace.keras")
+    ```
+    """
+
+    @classmethod
+    def cross(cls, feature_names, crossing_dim, output_mode="one_hot"):
+        return Cross(feature_names, crossing_dim, output_mode=output_mode)
+
+    @classmethod
+    def feature(cls, dtype, preprocessor, output_mode):
+        return Feature(dtype, preprocessor, output_mode)
+
+    @classmethod
+    def float(cls, name=None):
+        name = name or auto_name("float")
+        preprocessor = TFDIdentity(dtype="float32", name=f"{name}_preprocessor")
+        return Feature(
+            dtype="float32", preprocessor=preprocessor, output_mode="float"
+        )
+
+    @classmethod
+    def float_rescaled(cls, scale=1.0, offset=0.0, name=None):
+        name = name or auto_name("float_rescaled")
+        preprocessor = layers.Rescaling(
+            scale=scale, offset=offset, name=f"{name}_preprocessor"
+        )
+        return Feature(
+            dtype="float32", preprocessor=preprocessor, output_mode="float"
+        )
+
+    @classmethod
+    def float_normalized(cls, name=None):
+        name = name or auto_name("float_normalized")
+        preprocessor = layers.Normalization(
+            axis=-1, name=f"{name}_preprocessor"
+        )
+        return Feature(
+            dtype="float32", preprocessor=preprocessor, output_mode="float"
+        )
+
+    @classmethod
+    def float_discretized(
+        cls, num_bins, bin_boundaries=None, output_mode="one_hot", name=None
+    ):
+        name = name or auto_name("float_discretized")
+        preprocessor = layers.Discretization(
+            num_bins=num_bins,
+            bin_boundaries=bin_boundaries,
+            name=f"{name}_preprocessor",
+        )
+        return Feature(
+            dtype="float32", preprocessor=preprocessor, output_mode=output_mode
+        )
+
+    @classmethod
+    def integer_categorical(
+        cls,
+        max_tokens=None,
+        num_oov_indices=1,
+        output_mode="one_hot",
+        name=None,
+    ):
+        name = name or auto_name("integer_categorical")
+        preprocessor = layers.IntegerLookup(
+            name=f"{name}_preprocessor",
+            max_tokens=max_tokens,
+            num_oov_indices=num_oov_indices,
+        )
+        return Feature(
+            dtype="int32", preprocessor=preprocessor, output_mode=output_mode
+        )
+
+    @classmethod
+    def string_categorical(
+        cls,
+        max_tokens=None,
+        num_oov_indices=1,
+        output_mode="one_hot",
+        name=None,
+    ):
+        name = name or auto_name("string_categorical")
+        preprocessor = layers.StringLookup(
+            name=f"{name}_preprocessor",
+            max_tokens=max_tokens,
+            num_oov_indices=num_oov_indices,
+        )
+        return Feature(
+            dtype="string", preprocessor=preprocessor, output_mode=output_mode
+        )
+
+    @classmethod
+    def string_hashed(cls, num_bins, output_mode="one_hot", name=None):
+        name = name or auto_name("string_hashed")
+        preprocessor = layers.Hashing(
+            name=f"{name}_preprocessor", num_bins=num_bins
+        )
+        return Feature(
+            dtype="string", preprocessor=preprocessor, output_mode=output_mode
+        )
+
+    @classmethod
+    def integer_hashed(cls, num_bins, output_mode="one_hot", name=None):
+        name = name or auto_name("integer_hashed")
+        preprocessor = layers.Hashing(
+            name=f"{name}_preprocessor", num_bins=num_bins
+        )
+        return Feature(
+            dtype="int32", preprocessor=preprocessor, output_mode=output_mode
+        )
+
+    def __init__(
+        self,
+        features,
+        output_mode="concat",
+        crosses=None,
+        crossing_dim=32,
+        hashing_dim=32,
+        num_discretization_bins=32,
+        name=None,
+    ):
+        super().__init__(name=name)
+        if not features:
+            raise ValueError("The `features` argument cannot be None or empty.")
+        self.crossing_dim = crossing_dim
+        self.hashing_dim = hashing_dim
+        self.num_discretization_bins = num_discretization_bins
+        self.features = {
+            name: self._standardize_feature(name, value)
+            for name, value in features.items()
+        }
+        self.crosses = []
+        if crosses:
+            feature_set = set(features.keys())
+            for cross in crosses:
+                if isinstance(cross, dict):
+                    cross = serialization_lib.deserialize_keras_object(cross)
+                if isinstance(cross, Cross):
+                    self.crosses.append(cross)
+                else:
+                    if not crossing_dim:
+                        raise ValueError(
+                            "When specifying `crosses`, the argument "
+                            "`crossing_dim` "
+                            "(dimensionality of the crossing space) "
+                            "should be specified as well."
+                        )
+                    for key in cross:
+                        if key not in feature_set:
+                            raise ValueError(
+                                "All features referenced "
+                                "in the `crosses` argument "
+                                "should be present in the `features` dict. "
+                                f"Received unknown features: {cross}"
+                            )
+                    self.crosses.append(Cross(cross, crossing_dim=crossing_dim))
+        self.crosses_by_name = {cross.name: cross for cross in self.crosses}
+
+        if output_mode not in {"dict", "concat"}:
+            raise ValueError(
+                "Invalid value for argument `output_mode`. "
+                "Expected one of {'dict', 'concat'}. "
+                f"Received: output_mode={output_mode}"
+            )
+        self.output_mode = output_mode
+
+        self.inputs = {
+            name: self._feature_to_input(name, value)
+            for name, value in self.features.items()
+        }
+        self.preprocessors = {
+            name: value.preprocessor for name, value in self.features.items()
+        }
+        self.encoded_features = None
+        self.crossers = {
+            cross.name: self._cross_to_crosser(cross) for cross in self.crosses
+        }
+        self.one_hot_encoders = {}
+        self._is_adapted = False
+        self.concat = None
+        self._preprocessed_features_names = None
+        self._crossed_features_names = None
+        self._sublayers_built = False
+
+    def _feature_to_input(self, name, feature):
+        return layers.Input(shape=(1,), dtype=feature.dtype, name=name)
+
+    def _standardize_feature(self, name, feature):
+        if isinstance(feature, Feature):
+            return feature
+
+        if isinstance(feature, dict):
+            return serialization_lib.deserialize_keras_object(feature)
+
+        if feature == "float":
+            return self.float(name=name)
+        elif feature == "float_normalized":
+            return self.float_normalized(name=name)
+        elif feature == "float_rescaled":
+            return self.float_rescaled(name=name)
+        elif feature == "float_discretized":
+            return self.float_discretized(
+                name=name, num_bins=self.num_discretization_bins
+            )
+        elif feature == "integer_categorical":
+            return self.integer_categorical(name=name)
+        elif feature == "string_categorical":
+            return self.string_categorical(name=name)
+        elif feature == "integer_hashed":
+            return self.integer_hashed(self.hashing_dim, name=name)
+        elif feature == "string_hashed":
+            return self.string_hashed(self.hashing_dim, name=name)
+        else:
+            raise ValueError(f"Invalid feature type: {feature}")
+
+    def _cross_to_crosser(self, cross):
+        return layers.HashedCrossing(cross.crossing_dim, name=cross.name)
+
+    def _list_adaptable_preprocessors(self):
+        adaptable_preprocessors = []
+        for name in self.features.keys():
+            preprocessor = self.preprocessors[name]
+            # Special case: a Normalization layer with preset mean/variance.
+            # Not adaptable.
+            if isinstance(preprocessor, layers.Normalization):
+                if preprocessor.input_mean is not None:
+                    continue
+            # Special case: a TextVectorization layer with provided vocabulary.
+            elif isinstance(preprocessor, layers.TextVectorization):
+                if preprocessor._has_input_vocabulary:
+                    continue
+            if hasattr(preprocessor, "adapt"):
+                adaptable_preprocessors.append(name)
+        return adaptable_preprocessors
+
+    def adapt(self, dataset):
+        if not isinstance(dataset, tf.data.Dataset):
+            raise ValueError(
+                "`adapt()` can only be called on a tf.data.Dataset. "
+                f"Received instead: {dataset} (of type {type(dataset)})"
+            )
+
+        for name in self._list_adaptable_preprocessors():
+            # Call adapt() on each individual adaptable layer.
+
+            # TODO: consider rewriting this to instead iterate on the
+            # dataset once, split each batch into individual features,
+            # and call the layer's `_adapt_function` on each batch
+            # to simulate the behavior of adapt() in a more performant fashion.
+
+            feature_dataset = dataset.map(lambda x: x[name])
+            preprocessor = self.preprocessors[name]
+            # TODO: consider adding an adapt progress bar.
+            # Sample 1 element to check the rank
+            x = next(iter(feature_dataset))
+            if len(x.shape) == 0:
+                # The dataset yields unbatched scalars; batch it.
+                feature_dataset = feature_dataset.batch(32)
+            if len(x.shape) in {0, 1}:
+                # If the rank is 1, add a dimension
+                # so we can reduce on axis=-1.
+                # Note: if rank was previously 0, it is now 1.
+                feature_dataset = feature_dataset.map(
+                    lambda x: tf.expand_dims(x, -1)
+                )
+            preprocessor.adapt(feature_dataset)
+        self._is_adapted = True
+        self.get_encoded_features()  # Finish building the layer
+        self.built = True
+        self._sublayers_built = True
+
+    def get_inputs(self):
+        self._check_if_built()
+        return self.inputs
+
+    def get_encoded_features(self):
+        self._check_if_adapted()
+
+        if self.encoded_features is None:
+            preprocessed_features = self._preprocess_features(self.inputs)
+            crossed_features = self._cross_features(preprocessed_features)
+            merged_features = self._merge_features(
+                preprocessed_features, crossed_features
+            )
+            self.encoded_features = merged_features
+        return self.encoded_features
+
+    def _preprocess_features(self, features):
+        return {
+            name: self.preprocessors[name](features[name])
+            for name in features.keys()
+        }
+
+    def _cross_features(self, features):
+        all_outputs = {}
+        for cross in self.crosses:
+            inputs = [features[name] for name in cross.feature_names]
+            outputs = self.crossers[cross.name](inputs)
+            all_outputs[cross.name] = outputs
+        return all_outputs
+
+    def _merge_features(self, preprocessed_features, crossed_features):
+        if not self._preprocessed_features_names:
+            self._preprocessed_features_names = sorted(
+                preprocessed_features.keys()
+            )
+            self._crossed_features_names = sorted(crossed_features.keys())
+
+        all_names = (
+            self._preprocessed_features_names + self._crossed_features_names
+        )
+        all_features = [
+            preprocessed_features[name]
+            for name in self._preprocessed_features_names
+        ] + [crossed_features[name] for name in self._crossed_features_names]
+
+        if self.output_mode == "dict":
+            output_dict = {}
+        else:
+            features_to_concat = []
+
+        if self._sublayers_built:
+            # Fast mode.
+            for name, feature in zip(all_names, all_features):
+                encoder = self.one_hot_encoders.get(name, None)
+                if encoder:
+                    feature = encoder(feature)
+                if self.output_mode == "dict":
+                    output_dict[name] = feature
+                else:
+                    features_to_concat.append(feature)
+            if self.output_mode == "dict":
+                return output_dict
+            else:
+                return self.concat(features_to_concat)
+
+        # If the object isn't built,
+        # we create the encoder and concat layers below
+        all_specs = [
+            self.features[name] for name in self._preprocessed_features_names
+        ] + [
+            self.crosses_by_name[name] for name in self._crossed_features_names
+        ]
+
+        for name, feature, spec in zip(all_names, all_features, all_specs):
+            if tree.is_nested(feature):
+                dtype = tree.flatten(feature)[0].dtype
+            else:
+                dtype = feature.dtype
+            dtype = backend.standardize_dtype(dtype)
+
+            if spec.output_mode == "one_hot":
+                preprocessor = self.preprocessors.get(
+                    name
+                ) or self.crossers.get(name)
+
+                cardinality = None
+                if not dtype.startswith("int"):
+                    raise ValueError(
+                        f"Feature '{name}' has `output_mode='one_hot'`. "
+                        "Thus its preprocessor should return an integer dtype. "
+                        f"Instead it returns a {dtype} dtype."
+                    )
+
+                if isinstance(
+                    preprocessor, (layers.IntegerLookup, layers.StringLookup)
+                ):
+                    cardinality = preprocessor.vocabulary_size()
+                elif isinstance(preprocessor, layers.CategoryEncoding):
+                    cardinality = preprocessor.num_tokens
+                elif isinstance(preprocessor, layers.Discretization):
+                    cardinality = preprocessor.num_bins
+                elif isinstance(
+                    preprocessor, (layers.HashedCrossing, layers.Hashing)
+                ):
+                    cardinality = preprocessor.num_bins
+                else:
+                    raise ValueError(
+                        f"Feature '{name}' has `output_mode='one_hot'`. "
+                        "However it isn't a standard feature and the "
+                        "dimensionality of its output space is not known, "
+                        "thus it cannot be one-hot encoded. "
+                        "Try using `output_mode='int'`."
+                    )
+                if cardinality is not None:
+                    encoder = layers.CategoryEncoding(
+                        num_tokens=cardinality, output_mode="multi_hot"
+                    )
+                    self.one_hot_encoders[name] = encoder
+                    feature = encoder(feature)
+
+            if self.output_mode == "concat":
+                dtype = feature.dtype
+                if dtype.startswith("int") or dtype == "string":
+                    raise ValueError(
+                        f"Cannot concatenate features because feature '{name}' "
+                        f"has not been encoded (it has dtype {dtype}). "
+                        "Consider using `output_mode='dict'`."
+                    )
+                features_to_concat.append(feature)
+            else:
+                output_dict[name] = feature
+
+        if self.output_mode == "concat":
+            self.concat = TFDConcat(axis=-1)
+            return self.concat(features_to_concat)
+        else:
+            return output_dict
+
+    def _check_if_adapted(self):
+        if not self._is_adapted:
+            if not self._list_adaptable_preprocessors():
+                self._is_adapted = True
+            else:
+                raise ValueError(
+                    "You need to call `.adapt(dataset)` on the FeatureSpace "
+                    "before you can start using it."
+                )
+
+    def _check_if_built(self):
+        if not self._sublayers_built:
+            self._check_if_adapted()
+            # Finishes building
+            self.get_encoded_features()
+            self._sublayers_built = True
+
+    def _convert_input(self, x):
+        if not isinstance(x, (tf.Tensor, tf.SparseTensor, tf.RaggedTensor)):
+            if not isinstance(x, (list, tuple, int, float)):
+                x = backend.convert_to_numpy(x)
+            x = tf.convert_to_tensor(x)
+        return x
+
+    def __call__(self, data):
+        self._check_if_built()
+        if not isinstance(data, dict):
+            raise ValueError(
+                "A FeatureSpace can only be called with a dict. "
+                f"Received: data={data} (of type {type(data)}"
+            )
+
+        # Many preprocessing layers support all backends but many do not.
+        # Switch to TF to make FeatureSpace work universally.
+        data = {key: self._convert_input(value) for key, value in data.items()}
+        rebatched = False
+        for name, x in data.items():
+            if len(x.shape) == 0:
+                data[name] = tf.reshape(x, (1, 1))
+                rebatched = True
+            elif len(x.shape) == 1:
+                data[name] = tf.expand_dims(x, -1)
+
+        with backend_utils.TFGraphScope():
+            # This scope is to make sure that inner TFDataLayers
+            # will not convert outputs back to backend-native --
+            # they should be TF tensors throughout
+            preprocessed_data = self._preprocess_features(data)
+            preprocessed_data = tree.map_structure(
+                lambda x: self._convert_input(x), preprocessed_data
+            )
+
+            crossed_data = self._cross_features(preprocessed_data)
+            crossed_data = tree.map_structure(
+                lambda x: self._convert_input(x), crossed_data
+            )
+
+            merged_data = self._merge_features(preprocessed_data, crossed_data)
+
+        if rebatched:
+            if self.output_mode == "concat":
+                assert merged_data.shape[0] == 1
+                if (
+                    backend.backend() != "tensorflow"
+                    and not backend_utils.in_tf_graph()
+                ):
+                    merged_data = backend.convert_to_numpy(merged_data)
+                merged_data = tf.squeeze(merged_data, axis=0)
+            else:
+                for name, x in merged_data.items():
+                    if len(x.shape) == 2 and x.shape[0] == 1:
+                        merged_data[name] = tf.squeeze(x, axis=0)
+
+        if (
+            backend.backend() != "tensorflow"
+            and not backend_utils.in_tf_graph()
+        ):
+            merged_data = tree.map_structure(
+                lambda x: backend.convert_to_tensor(x, dtype=x.dtype),
+                merged_data,
+            )
+        return merged_data
+
+    def get_config(self):
+        return {
+            "features": serialization_lib.serialize_keras_object(self.features),
+            "output_mode": self.output_mode,
+            "crosses": serialization_lib.serialize_keras_object(self.crosses),
+            "crossing_dim": self.crossing_dim,
+            "hashing_dim": self.hashing_dim,
+            "num_discretization_bins": self.num_discretization_bins,
+        }
+
+    @classmethod
+    def from_config(cls, config):
+        return cls(**config)
+
+    def get_build_config(self):
+        return {
+            name: feature.preprocessor.get_build_config()
+            for name, feature in self.features.items()
+        }
+
+    def build_from_config(self, config):
+        for name in config.keys():
+            preprocessor = self.features[name].preprocessor
+            if not preprocessor.built:
+                preprocessor.build_from_config(config[name])
+        self._is_adapted = True
+
+    def save(self, filepath):
+        """Save the `FeatureSpace` instance to a `.keras` file.
+
+        You can reload it via `keras.models.load_model()`:
+
+        ```python
+        feature_space.save("featurespace.keras")
+        reloaded_fs = keras.models.load_model("featurespace.keras")
+        ```
+        """
+        saving_lib.save_model(self, filepath)
+
+    def save_own_variables(self, store):
+        return
+
+    def load_own_variables(self, store):
+        return
+
+
+class TFDConcat(TFDataLayer):
+    def __init__(self, axis, **kwargs):
+        super().__init__(**kwargs)
+        self.axis = axis
+
+    def call(self, xs):
+        return self.backend.numpy.concatenate(xs, axis=self.axis)
+
+
+class TFDIdentity(TFDataLayer):
+    def call(self, x):
+        return x

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

@@ -0,0 +1,227 @@
+from keras.src import backend
+from keras.src.api_export import keras_export
+from keras.src.layers.layer import Layer
+from keras.src.utils import argument_validation
+from keras.src.utils import backend_utils
+from keras.src.utils import numerical_utils
+from keras.src.utils import tf_utils
+from keras.src.utils.module_utils import tensorflow as tf
+
+
+@keras_export("keras.layers.HashedCrossing")
+class HashedCrossing(Layer):
+    """A preprocessing layer which crosses features using the "hashing trick".
+
+    This layer performs crosses of categorical features using the "hashing
+    trick". Conceptually, the transformation can be thought of as:
+    `hash(concatenate(features)) % num_bins`.
+
+    This layer currently only performs crosses of scalar inputs and batches of
+    scalar inputs. Valid input shapes are `(batch_size, 1)`, `(batch_size,)` and
+    `()`.
+
+    **Note:** This layer wraps `tf.keras.layers.HashedCrossing`. It cannot
+    be used as part of the compiled computation graph of a model with
+    any backend other than TensorFlow.
+    It can however be used with any backend when running eagerly.
+    It can also always be used as part of an input preprocessing pipeline
+    with any backend (outside the model itself), which is how we recommend
+    to use this layer.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    Args:
+        num_bins: Number of hash bins.
+        output_mode: Specification for the output of the layer. Values can be
+            `"int"`, or `"one_hot"` configuring the layer as follows:
+            - `"int"`: Return the integer bin indices directly.
+            - `"one_hot"`: Encodes each individual element in the input into an
+                array the same size as `num_bins`, containing a 1 at the input's
+                bin index. Defaults to `"int"`.
+        sparse: Boolean. Only applicable to `"one_hot"` mode and only valid
+            when using the TensorFlow backend. If `True`, returns
+            a `SparseTensor` instead of a dense `Tensor`. Defaults to `False`.
+        **kwargs: Keyword arguments to construct a layer.
+
+    Examples:
+
+    **Crossing two scalar features.**
+
+    >>> layer = keras.layers.HashedCrossing(
+    ...     num_bins=5)
+    >>> feat1 = np.array(['A', 'B', 'A', 'B', 'A'])
+    >>> feat2 = np.array([101, 101, 101, 102, 102])
+    >>> layer((feat1, feat2))
+    array([1, 4, 1, 1, 3])
+
+    **Crossing and one-hotting two scalar features.**
+
+    >>> layer = keras.layers.HashedCrossing(
+    ...     num_bins=5, output_mode='one_hot')
+    >>> feat1 = np.array(['A', 'B', 'A', 'B', 'A'])
+    >>> feat2 = np.array([101, 101, 101, 102, 102])
+    >>> layer((feat1, feat2))
+    array([[0., 1., 0., 0., 0.],
+            [0., 0., 0., 0., 1.],
+            [0., 1., 0., 0., 0.],
+            [0., 1., 0., 0., 0.],
+            [0., 0., 0., 1., 0.]], dtype=float32)
+    """
+
+    def __init__(
+        self,
+        num_bins,
+        output_mode="int",
+        sparse=False,
+        name=None,
+        dtype=None,
+        **kwargs,
+    ):
+        if not tf.available:
+            raise ImportError(
+                "Layer HashedCrossing requires TensorFlow. "
+                "Install it via `pip install tensorflow`."
+            )
+
+        if output_mode == "int" and dtype is None:
+            dtype = "int64"
+
+        super().__init__(name=name, dtype=dtype)
+        if sparse and backend.backend() != "tensorflow":
+            raise ValueError(
+                "`sparse=True` can only be used with the " "TensorFlow backend."
+            )
+
+        argument_validation.validate_string_arg(
+            output_mode,
+            allowable_strings=("int", "one_hot"),
+            caller_name=self.__class__.__name__,
+            arg_name="output_mode",
+        )
+
+        self.num_bins = num_bins
+        self.output_mode = output_mode
+        self.sparse = sparse
+        self._allow_non_tensor_positional_args = True
+        self._convert_input_args = False
+        self.supports_jit = False
+
+    def compute_output_shape(self, input_shape):
+        if (
+            not len(input_shape) == 2
+            or not isinstance(input_shape[0], tuple)
+            or not isinstance(input_shape[1], tuple)
+        ):
+            raise ValueError(
+                "Expected as input a list/tuple of 2 tensors. "
+                f"Received input_shape={input_shape}"
+            )
+        if input_shape[0][-1] != input_shape[1][-1]:
+            raise ValueError(
+                "Expected the two input tensors to have identical shapes. "
+                f"Received input_shape={input_shape}"
+            )
+
+        if not input_shape:
+            if self.output_mode == "int":
+                return ()
+            return (self.num_bins,)
+        if self.output_mode == "int":
+            return input_shape[0]
+
+        if self.output_mode == "one_hot" and input_shape[0][-1] != 1:
+            return tuple(input_shape[0]) + (self.num_bins,)
+
+        return tuple(input_shape[0])[:-1] + (self.num_bins,)
+
+    def call(self, inputs):
+        from keras.src.backend import tensorflow as tf_backend
+
+        self._check_at_least_two_inputs(inputs)
+        inputs = [tf_utils.ensure_tensor(x) for x in inputs]
+        self._check_input_shape_and_type(inputs)
+
+        # Uprank to rank 2 for the cross_hashed op.
+        rank = len(inputs[0].shape)
+        if rank < 2:
+            inputs = [tf_backend.numpy.expand_dims(x, -1) for x in inputs]
+        if rank < 1:
+            inputs = [tf_backend.numpy.expand_dims(x, -1) for x in inputs]
+
+        # Perform the cross and convert to dense
+        outputs = tf.sparse.cross_hashed(inputs, self.num_bins)
+        outputs = tf.sparse.to_dense(outputs)
+
+        # Fix output shape and downrank to match input rank.
+        if rank == 2:
+            # tf.sparse.cross_hashed output shape will always be None on the
+            # last dimension. Given our input shape restrictions, we want to
+            # force shape 1 instead.
+            outputs = tf.reshape(outputs, [-1, 1])
+        elif rank == 1:
+            outputs = tf.reshape(outputs, [-1])
+        elif rank == 0:
+            outputs = tf.reshape(outputs, [])
+
+        # Encode outputs.
+        outputs = numerical_utils.encode_categorical_inputs(
+            outputs,
+            output_mode=self.output_mode,
+            depth=self.num_bins,
+            sparse=self.sparse,
+            dtype=self.compute_dtype,
+            backend_module=tf_backend,
+        )
+        return backend_utils.convert_tf_tensor(outputs, dtype=self.dtype)
+
+    def get_config(self):
+        return {
+            "num_bins": self.num_bins,
+            "output_mode": self.output_mode,
+            "sparse": self.sparse,
+            "name": self.name,
+            "dtype": self.dtype,
+        }
+
+    def _check_at_least_two_inputs(self, inputs):
+        if not isinstance(inputs, (list, tuple)):
+            raise ValueError(
+                "`HashedCrossing` should be called on a list or tuple of "
+                f"inputs. Received: inputs={inputs}"
+            )
+        if len(inputs) < 2:
+            raise ValueError(
+                "`HashedCrossing` should be called on at least two inputs. "
+                f"Received: inputs={inputs}"
+            )
+
+    def _check_input_shape_and_type(self, inputs):
+        first_shape = tuple(inputs[0].shape)
+        rank = len(first_shape)
+        if rank > 2 or (rank == 2 and first_shape[-1] != 1):
+            raise ValueError(
+                "All `HashedCrossing` inputs should have shape `()`, "
+                "`(batch_size)` or `(batch_size, 1)`. "
+                f"Received: inputs={inputs}"
+            )
+        if not all(tuple(x.shape) == first_shape for x in inputs[1:]):
+            raise ValueError(
+                "All `HashedCrossing` inputs should have equal shape. "
+                f"Received: inputs={inputs}"
+            )
+        if any(
+            isinstance(x, (tf.RaggedTensor, tf.SparseTensor)) for x in inputs
+        ):
+            raise ValueError(
+                "All `HashedCrossing` inputs should be dense tensors. "
+                f"Received: inputs={inputs}"
+            )
+        if not all(
+            tf.as_dtype(x.dtype).is_integer or x.dtype == tf.string
+            for x in inputs
+        ):
+            raise ValueError(
+                "All `HashedCrossing` inputs should have an integer or "
+                f"string dtype. Received: inputs={inputs}"
+            )

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

@@ -0,0 +1,287 @@
+from keras.src import backend
+from keras.src.api_export import keras_export
+from keras.src.layers.layer import Layer
+from keras.src.utils import backend_utils
+from keras.src.utils import numerical_utils
+from keras.src.utils import tf_utils
+from keras.src.utils.module_utils import tensorflow as tf
+
+
+@keras_export("keras.layers.Hashing")
+class Hashing(Layer):
+    """A preprocessing layer which hashes and bins categorical features.
+
+    This layer transforms categorical inputs to hashed output. It element-wise
+    converts a ints or strings to ints in a fixed range. The stable hash
+    function uses `tensorflow::ops::Fingerprint` to produce the same output
+    consistently across all platforms.
+
+    This layer uses [FarmHash64](https://github.com/google/farmhash) by default,
+    which provides a consistent hashed output across different platforms and is
+    stable across invocations, regardless of device and context, by mixing the
+    input bits thoroughly.
+
+    If you want to obfuscate the hashed output, you can also pass a random
+    `salt` argument in the constructor. In that case, the layer will use the
+    [SipHash64](https://github.com/google/highwayhash) hash function, with
+    the `salt` value serving as additional input to the hash function.
+
+    **Note:** This layer internally uses TensorFlow. It cannot
+    be used as part of the compiled computation graph of a model with
+    any backend other than TensorFlow.
+    It can however be used with any backend when running eagerly.
+    It can also always be used as part of an input preprocessing pipeline
+    with any backend (outside the model itself), which is how we recommend
+    to use this layer.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    **Example (FarmHash64)**
+
+    >>> layer = keras.layers.Hashing(num_bins=3)
+    >>> inp = [['A'], ['B'], ['C'], ['D'], ['E']]
+    >>> layer(inp)
+    array([[1],
+            [0],
+            [1],
+            [1],
+            [2]])>
+
+    **Example (FarmHash64) with a mask value**
+
+    >>> layer = keras.layers.Hashing(num_bins=3, mask_value='')
+    >>> inp = [['A'], ['B'], [''], ['C'], ['D']]
+    >>> layer(inp)
+    array([[1],
+            [1],
+            [0],
+            [2],
+            [2]])
+
+    **Example (SipHash64)**
+
+    >>> layer = keras.layers.Hashing(num_bins=3, salt=[133, 137])
+    >>> inp = [['A'], ['B'], ['C'], ['D'], ['E']]
+    >>> layer(inp)
+    array([[1],
+            [2],
+            [1],
+            [0],
+            [2]])
+
+    **Example (Siphash64 with a single integer, same as `salt=[133, 133]`)**
+
+    >>> layer = keras.layers.Hashing(num_bins=3, salt=133)
+    >>> inp = [['A'], ['B'], ['C'], ['D'], ['E']]
+    >>> layer(inp)
+    array([[0],
+            [0],
+            [2],
+            [1],
+            [0]])
+
+    Args:
+        num_bins: Number of hash bins. Note that this includes the `mask_value`
+            bin, so the effective number of bins is `(num_bins - 1)`
+            if `mask_value` is set.
+        mask_value: A value that represents masked inputs, which are mapped to
+            index 0. `None` means no mask term will be added and the
+            hashing will start at index 0. Defaults to `None`.
+        salt: A single unsigned integer or None.
+            If passed, the hash function used will be SipHash64,
+            with these values used as an additional input
+            (known as a "salt" in cryptography).
+            These should be non-zero. If `None`, uses the FarmHash64 hash
+            function. It also supports tuple/list of 2 unsigned
+            integer numbers, see reference paper for details.
+            Defaults to `None`.
+        output_mode: Specification for the output of the layer. Values can be
+            `"int"`, `"one_hot"`, `"multi_hot"`, or
+            `"count"` configuring the layer as follows:
+            - `"int"`: Return the integer bin indices directly.
+            - `"one_hot"`: Encodes each individual element in the input into an
+                array the same size as `num_bins`, containing a 1
+                at the input's bin index. If the last dimension is size 1,
+                will encode on that dimension.
+                If the last dimension is not size 1, will append a new
+                dimension for the encoded output.
+            - `"multi_hot"`: Encodes each sample in the input into a
+                single array the same size as `num_bins`,
+                containing a 1 for each bin index
+                index present in the sample. Treats the last dimension
+                as the sample dimension, if input shape is
+                `(..., sample_length)`, output shape will be
+                `(..., num_tokens)`.
+            - `"count"`: As `"multi_hot"`, but the int array contains a count of
+                the number of times the bin index appeared in the sample.
+            Defaults to `"int"`.
+        sparse: Boolean. Only applicable to `"one_hot"`, `"multi_hot"`,
+            and `"count"` output modes. Only supported with TensorFlow
+            backend. If `True`, returns a `SparseTensor` instead of
+            a dense `Tensor`. Defaults to `False`.
+        **kwargs: Keyword arguments to construct a layer.
+
+    Input shape:
+        A single string, a list of strings, or an `int32` or `int64` tensor
+        of shape `(batch_size, ...,)`.
+
+    Output shape:
+        An `int32` tensor of shape `(batch_size, ...)`.
+
+    Reference:
+
+    - [SipHash with salt](https://www.131002.net/siphash/siphash.pdf)
+    """
+
+    def __init__(
+        self,
+        num_bins,
+        mask_value=None,
+        salt=None,
+        output_mode="int",
+        sparse=False,
+        **kwargs,
+    ):
+        if not tf.available:
+            raise ImportError(
+                "Layer Hashing requires TensorFlow. "
+                "Install it via `pip install tensorflow`."
+            )
+
+        # By default, output int32 when output_mode='int' and floats otherwise.
+        if "dtype" not in kwargs or kwargs["dtype"] is None:
+            kwargs["dtype"] = (
+                "int64" if output_mode == "int" else backend.floatx()
+            )
+
+        super().__init__(**kwargs)
+
+        if num_bins is None or num_bins <= 0:
+            raise ValueError(
+                "The `num_bins` for `Hashing` cannot be `None` or "
+                f"non-positive values. Received: num_bins={num_bins}."
+            )
+
+        if output_mode == "int" and (
+            self.dtype_policy.name not in ("int32", "int64")
+        ):
+            raise ValueError(
+                'When `output_mode="int"`, `dtype` should be an integer '
+                f"type, 'int32' or 'in64'. Received: dtype={kwargs['dtype']}"
+            )
+
+        # 'output_mode' must be one of (INT, ONE_HOT, MULTI_HOT, COUNT)
+        accepted_output_modes = ("int", "one_hot", "multi_hot", "count")
+        if output_mode not in accepted_output_modes:
+            raise ValueError(
+                "Invalid value for argument `output_mode`. "
+                f"Expected one of {accepted_output_modes}. "
+                f"Received: output_mode={output_mode}"
+            )
+
+        if sparse and output_mode == "int":
+            raise ValueError(
+                "`sparse` may only be true if `output_mode` is "
+                '`"one_hot"`, `"multi_hot"`, or `"count"`. '
+                f"Received: sparse={sparse} and "
+                f"output_mode={output_mode}"
+            )
+
+        self.num_bins = num_bins
+        self.mask_value = mask_value
+        self.strong_hash = True if salt is not None else False
+        self.output_mode = output_mode
+        self.sparse = sparse
+        self.salt = None
+        if salt is not None:
+            if isinstance(salt, (tuple, list)) and len(salt) == 2:
+                self.salt = list(salt)
+            elif isinstance(salt, int):
+                self.salt = [salt, salt]
+            else:
+                raise ValueError(
+                    "The `salt` argument for `Hashing` can only be a tuple of "
+                    "size 2 integers, or a single integer. "
+                    f"Received: salt={salt}."
+                )
+        self._convert_input_args = False
+        self._allow_non_tensor_positional_args = True
+        self.supports_jit = False
+
+    def call(self, inputs):
+        from keras.src.backend import tensorflow as tf_backend
+
+        inputs = tf_utils.ensure_tensor(inputs)
+        if self.output_mode == "one_hot" and inputs.shape[-1] == 1:
+            # One hot only unpranks if the final dimension is not 1.
+            inputs = tf_backend.numpy.squeeze(inputs, axis=-1)
+        if isinstance(inputs, tf.SparseTensor):
+            indices = tf.SparseTensor(
+                indices=inputs.indices,
+                values=self._hash_values_to_bins(inputs.values),
+                dense_shape=inputs.dense_shape,
+            )
+        else:
+            indices = self._hash_values_to_bins(inputs)
+        outputs = numerical_utils.encode_categorical_inputs(
+            indices,
+            output_mode=self.output_mode,
+            depth=self.num_bins,
+            sparse=self.sparse,
+            dtype=self.dtype,
+            backend_module=tf_backend,
+        )
+        return backend_utils.convert_tf_tensor(outputs)
+
+    def _hash_values_to_bins(self, values):
+        """Converts a non-sparse tensor of values to bin indices."""
+        hash_bins = self.num_bins
+        mask = None
+        # If mask_value is set, the zeroth bin is reserved for it.
+        if self.mask_value is not None and hash_bins > 1:
+            hash_bins -= 1
+            mask = tf.equal(values, self.mask_value)
+        # Convert all values to strings before hashing.
+        # Floats are first normalized to int64.
+        if values.dtype.is_floating:
+            values = tf.cast(values, dtype="int64")
+        if values.dtype != tf.string:
+            values = tf.as_string(values)
+        # Hash the strings.
+        if self.strong_hash:
+            values = tf.strings.to_hash_bucket_strong(
+                values, hash_bins, name="hash", key=self.salt
+            )
+        else:
+            values = tf.strings.to_hash_bucket_fast(
+                values, hash_bins, name="hash"
+            )
+        if mask is not None:
+            values = tf.add(values, tf.ones_like(values))
+            values = tf.where(mask, tf.zeros_like(values), values)
+        return values
+
+    def compute_output_spec(self, inputs):
+        if self.output_mode == "int":
+            return backend.KerasTensor(shape=inputs.shape, dtype=self.dtype)
+        if len(inputs.shape) >= 1:
+            base_shape = tuple(inputs.shape)[:-1]
+        else:
+            base_shape = ()
+        return backend.KerasTensor(
+            shape=base_shape + (self.num_bins,), dtype=self.dtype
+        )
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "num_bins": self.num_bins,
+                "salt": self.salt,
+                "mask_value": self.mask_value,
+                "output_mode": self.output_mode,
+                "sparse": self.sparse,
+            }
+        )
+        return config

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/auto_contrast.py

@@ -0,0 +1,109 @@
+from keras.src import backend
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.ops.core import _saturate_cast
+
+
+@keras_export("keras.layers.AutoContrast")
+class AutoContrast(BaseImagePreprocessingLayer):
+    """Performs the auto-contrast operation on an image.
+
+    Auto contrast stretches the values of an image across the entire available
+    `value_range`. This makes differences between pixels more obvious. An
+    example of this is if an image only has values `[0, 1]` out of the range
+    `[0, 255]`, auto contrast will change the `1` values to be `255`.
+
+    This layer is active at both training and inference time.
+
+    Args:
+        value_range: Range of values the incoming images will have.
+            Represented as a two number tuple written `(low, high)`.
+            This is typically either `(0, 1)` or `(0, 255)` depending
+            on how your preprocessing pipeline is set up.
+            Defaults to `(0, 255)`.
+    """
+
+    _USE_BASE_FACTOR = False
+    _VALUE_RANGE_VALIDATION_ERROR = (
+        "The `value_range` argument should be a list of two numbers. "
+    )
+
+    def __init__(
+        self,
+        value_range=(0, 255),
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self._set_value_range(value_range)
+
+    def _set_value_range(self, value_range):
+        if not isinstance(value_range, (tuple, list)):
+            raise ValueError(
+                self._VALUE_RANGE_VALIDATION_ERROR
+                + f"Received: value_range={value_range}"
+            )
+        if len(value_range) != 2:
+            raise ValueError(
+                self._VALUE_RANGE_VALIDATION_ERROR
+                + f"Received: value_range={value_range}"
+            )
+        self.value_range = sorted(value_range)
+
+    def transform_images(self, images, transformation=None, training=True):
+        original_images = images
+        images = self._transform_value_range(
+            images,
+            original_range=self.value_range,
+            target_range=(0, 255),
+            dtype=self.compute_dtype,
+        )
+
+        images = self.backend.cast(images, self.compute_dtype)
+        low = self.backend.numpy.min(images, axis=(1, 2), keepdims=True)
+        high = self.backend.numpy.max(images, axis=(1, 2), keepdims=True)
+        scale = 255.0 / (high - low)
+        offset = -low * scale
+
+        images = images * scale + offset
+        results = self.backend.numpy.clip(images, 0.0, 255.0)
+        results = self._transform_value_range(
+            results,
+            original_range=(0, 255),
+            target_range=self.value_range,
+            dtype=self.compute_dtype,
+        )
+        # don't process NaN channels
+        results = self.backend.numpy.where(
+            self.backend.numpy.isnan(results), original_images, results
+        )
+        if results.dtype == images.dtype:
+            return results
+        if backend.is_int_dtype(images.dtype):
+            results = self.backend.numpy.round(results)
+        return _saturate_cast(results, images.dtype, self.backend)
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return segmentation_masks
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({"value_range": self.value_range})
+        return config
+
+    def compute_output_shape(self, input_shape):
+        return input_shape

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/base_image_preprocessing_layer.py

@@ -0,0 +1,385 @@
+import math
+
+from keras.src.backend import config as backend_config
+from keras.src.layers.preprocessing.image_preprocessing.bounding_boxes.validation import (  # noqa: E501
+    densify_bounding_boxes,
+)
+from keras.src.layers.preprocessing.tf_data_layer import TFDataLayer
+
+
+class BaseImagePreprocessingLayer(TFDataLayer):
+    _USE_BASE_FACTOR = True
+    _FACTOR_BOUNDS = (-1, 1)
+
+    def __init__(
+        self, factor=None, bounding_box_format=None, data_format=None, **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.bounding_box_format = bounding_box_format
+        self.data_format = backend_config.standardize_data_format(data_format)
+        if self._USE_BASE_FACTOR:
+            factor = factor or 0.0
+            self._set_factor(factor)
+        elif factor is not None:
+            raise ValueError(
+                f"Layer {self.__class__.__name__} does not take "
+                f"a `factor` argument. Received: factor={factor}"
+            )
+
+    def _set_factor(self, factor):
+        error_msg = (
+            "The `factor` argument should be a number "
+            "(or a list of two numbers) "
+            "in the range "
+            f"[{self._FACTOR_BOUNDS[0]}, {self._FACTOR_BOUNDS[1]}]. "
+            f"Received: factor={factor}"
+        )
+        if isinstance(factor, (tuple, list)):
+            if len(factor) != 2:
+                raise ValueError(error_msg)
+            if (
+                factor[0] > self._FACTOR_BOUNDS[1]
+                or factor[1] < self._FACTOR_BOUNDS[0]
+            ):
+                raise ValueError(error_msg)
+            lower, upper = sorted(factor)
+        elif isinstance(factor, (int, float)):
+            if (
+                factor < self._FACTOR_BOUNDS[0]
+                or factor > self._FACTOR_BOUNDS[1]
+            ):
+                raise ValueError(error_msg)
+            factor = abs(factor)
+            lower, upper = [max(-factor, self._FACTOR_BOUNDS[0]), factor]
+        else:
+            raise ValueError(error_msg)
+        self.factor = lower, upper
+
+    def get_random_transformation(self, data, training=True, seed=None):
+        return None
+
+    def transform_images(self, images, transformation, training=True):
+        raise NotImplementedError()
+
+    def transform_labels(self, labels, transformation, training=True):
+        raise NotImplementedError()
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        raise NotImplementedError()
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        raise NotImplementedError()
+
+    def transform_single_image(self, image, transformation, training=True):
+        images = self.backend.numpy.expand_dims(image, axis=0)
+        outputs = self.transform_images(
+            images, transformation=transformation, training=training
+        )
+        return self.backend.numpy.squeeze(outputs, axis=0)
+
+    def transform_single_label(self, label, transformation, training=True):
+        labels = self.backend.numpy.expand_dims(label, axis=0)
+        outputs = self.transform_labels(
+            labels, transformation=transformation, training=training
+        )
+        return self.backend.numpy.squeeze(outputs, axis=0)
+
+    def transform_single_bounding_box(
+        self,
+        bounding_box,
+        transformation,
+        training=True,
+    ):
+        bounding_boxes = self._format_single_input_bounding_box(bounding_box)
+        outputs = self.transform_bounding_boxes(
+            bounding_boxes,
+            transformation=transformation,
+            training=training,
+        )
+        bounding_box = self._format_single_output_bounding_box(outputs)
+        return bounding_box
+
+    def transform_single_segmentation_mask(
+        self, segmentation_mask, transformation, training=True
+    ):
+        segmentation_masks = self.backend.numpy.expand_dims(
+            segmentation_mask, axis=0
+        )
+        outputs = self.transform_segmentation_masks(
+            segmentation_masks, transformation=transformation, training=training
+        )
+        return self.backend.numpy.squeeze(outputs, axis=0)
+
+    def _is_batched(self, maybe_image_batch):
+        shape = self.backend.core.shape(maybe_image_batch)
+        if len(shape) == 3:
+            return False
+        if len(shape) == 4:
+            return True
+        raise ValueError(
+            "Expected image tensor to have rank 3 (single image) "
+            f"or 4 (batch of images). Received: data.shape={shape}"
+        )
+
+    def call(self, data, training=True):
+        transformation = self.get_random_transformation(data, training=training)
+        if isinstance(data, dict):
+            is_batched = self._is_batched(data["images"])
+            if is_batched:
+                data["images"] = self.transform_images(
+                    self.backend.convert_to_tensor(data["images"]),
+                    transformation=transformation,
+                    training=training,
+                )
+            else:
+                data["images"] = self.transform_single_image(
+                    self.backend.convert_to_tensor(data["images"]),
+                    transformation=transformation,
+                    training=training,
+                )
+            if "bounding_boxes" in data:
+                if not self.bounding_box_format:
+                    raise ValueError(
+                        "You passed an input with a 'bounding_boxes' key, "
+                        "but you didn't specify a bounding box format. "
+                        "Pass a `bounding_box_format` argument to your "
+                        f"{self.__class__.__name__} layer, e.g. "
+                        "`bounding_box_format='xyxy'`."
+                    )
+                bounding_boxes = densify_bounding_boxes(
+                    data["bounding_boxes"],
+                    is_batched=is_batched,
+                    backend=self.backend,
+                )
+
+                if is_batched:
+                    data["bounding_boxes"] = self.transform_bounding_boxes(
+                        bounding_boxes,
+                        transformation=transformation,
+                        training=training,
+                    )
+                else:
+                    data["bounding_boxes"] = self.transform_single_bounding_box(
+                        bounding_boxes,
+                        transformation=transformation,
+                        training=training,
+                    )
+            if "labels" in data:
+                if is_batched:
+                    data["labels"] = self.transform_labels(
+                        self.backend.convert_to_tensor(data["labels"]),
+                        transformation=transformation,
+                        training=training,
+                    )
+                else:
+                    data["labels"] = self.transform_single_label(
+                        self.backend.convert_to_tensor(data["labels"]),
+                        transformation=transformation,
+                        training=training,
+                    )
+            if "segmentation_masks" in data:
+                if is_batched:
+                    data["segmentation_masks"] = (
+                        self.transform_segmentation_masks(
+                            data["segmentation_masks"],
+                            transformation=transformation,
+                            training=training,
+                        )
+                    )
+                else:
+                    data["segmentation_masks"] = (
+                        self.transform_single_segmentation_mask(
+                            data["segmentation_masks"],
+                            transformation=transformation,
+                            training=training,
+                        )
+                    )
+            return data
+
+        # `data` is just images.
+        if self._is_batched(data):
+            return self.transform_images(
+                self.backend.convert_to_tensor(data),
+                transformation=transformation,
+                training=training,
+            )
+        return self.transform_single_image(
+            self.backend.convert_to_tensor(data),
+            transformation=transformation,
+            training=training,
+        )
+
+    def _format_single_input_bounding_box(self, bounding_box):
+        for key in bounding_box:
+            if key == "labels":
+                bounding_box[key] = self.backend.numpy.expand_dims(
+                    bounding_box[key], axis=0
+                )
+            if key == "boxes":
+                bounding_box[key] = self.backend.numpy.expand_dims(
+                    bounding_box[key], axis=0
+                )
+
+        return bounding_box
+
+    def _format_single_output_bounding_box(self, bounding_boxes):
+        for key in bounding_boxes:
+            if key == "labels":
+                bounding_boxes[key] = self.backend.numpy.squeeze(
+                    bounding_boxes[key], axis=0
+                )
+            if key == "boxes":
+                bounding_boxes[key] = self.backend.numpy.squeeze(
+                    bounding_boxes[key], axis=0
+                )
+
+        return bounding_boxes
+
+    def get_config(self):
+        config = super().get_config()
+        if self.bounding_box_format is not None:
+            config.update(
+                {
+                    "bounding_box_format": self.bounding_box_format,
+                }
+            )
+        return config
+
+    def _transform_value_range(
+        self, images, original_range, target_range, dtype="float32"
+    ):
+        """Convert input values from `original_range` to `target_range`.
+
+        This function is intended to be used in preprocessing layers that
+        rely upon color values. This allows us to assume internally that
+        the input tensor is always in the range `(0, 255)`.
+
+        Args:
+            images: the set of images to transform to the target range.
+            original_range: the value range to transform from.
+            target_range: the value range to transform to.
+            dtype: the dtype to compute the conversion with,
+                defaults to "float32".
+
+        Returns:
+            a new Tensor with values in the target range.
+
+        Example:
+
+        ```python
+        original_range = [0, 1]
+        target_range = [0, 255]
+        images = layer.preprocessing.transform_value_range(
+            images,
+            original_range,
+            target_range
+        )
+        images = ops.minimum(images + 10, 255)
+        images = layer.preprocessing.transform_value_range(
+            images,
+            target_range,
+            original_range
+        )
+        ```
+        """
+        if (
+            original_range[0] == target_range[0]
+            and original_range[1] == target_range[1]
+        ):
+            return images
+
+        images = self.backend.cast(images, dtype=dtype)
+        original_min_value, original_max_value = self._unwrap_value_range(
+            original_range, dtype=dtype
+        )
+        target_min_value, target_max_value = self._unwrap_value_range(
+            target_range, dtype=dtype
+        )
+
+        # images in the [0, 1] scale
+        images = (images - original_min_value) / (
+            original_max_value - original_min_value
+        )
+
+        scale_factor = target_max_value - target_min_value
+        return (images * scale_factor) + target_min_value
+
+    def _unwrap_value_range(self, value_range, dtype="float32"):
+        min_value, max_value = value_range
+        min_value = self.backend.cast(min_value, dtype=dtype)
+        max_value = self.backend.cast(max_value, dtype=dtype)
+        return min_value, max_value
+
+    def _compute_affine_matrix(
+        self,
+        center_x,
+        center_y,
+        angle,
+        translate_x,
+        translate_y,
+        scale,
+        shear_x,
+        shear_y,
+        height,
+        width,
+    ):
+        """
+        #       Scaling          Shear           Rotation
+        #     [sx  0   0]    [1   shx  0]   [cos(θ)  -sin(θ)  0]
+        # M = [0   sy  0] *  [shy  1   0] * [sin(θ)   cos(θ)  0]
+        #     [0   0   1]    [0    0   1]   [0        0       1]
+
+        # a0 = sx * (cos(θ) + shx * sin(θ))
+        # a1 = sx * (-sin(θ) + shx * cos(θ))
+        # a2 = tx + cx - cx * a0 - cy * a1
+        # b0 = sy * (shy * cos(θ) + sin(θ))
+        # b1 = sy * (shy * -sin(θ) + cos(θ))
+        # b2 = ty + cy - cx * b0 - cy * b1
+        """
+        ops = self.backend
+
+        degree_to_radian_factor = ops.convert_to_tensor(math.pi / 180.0)
+
+        angle = angle * degree_to_radian_factor
+        shear_x = shear_x * degree_to_radian_factor
+        shear_y = shear_y * degree_to_radian_factor
+
+        batch_size = ops.shape(angle)[0]
+        dtype = angle.dtype
+        width = ops.cast(width, dtype)
+        height = ops.cast(height, dtype)
+        cx = center_x * (width - 1)
+        cy = center_y * (height - 1)
+
+        cos_theta = ops.numpy.cos(angle)
+        sin_theta = ops.numpy.sin(angle)
+        shear_x = ops.numpy.tan(shear_x)
+        shear_y = ops.numpy.tan(shear_y)
+
+        a0 = scale * (cos_theta + shear_x * sin_theta)
+        a1 = scale * (-sin_theta + shear_x * cos_theta)
+        a2 = translate_x + cx - cx * a0 - cy * a1
+        b0 = scale * (shear_y * cos_theta + sin_theta)
+        b1 = scale * (shear_y * -sin_theta + cos_theta)
+        b2 = translate_y + cy - cx * b0 - cy * b1
+        affine_matrix = ops.numpy.concatenate(
+            [
+                a0[:, None],
+                a1[:, None],
+                a2[:, None],
+                b0[:, None],
+                b1[:, None],
+                b2[:, None],
+                ops.numpy.zeros((batch_size, 2)),
+            ],
+            axis=1,
+        )
+
+        return affine_matrix

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/center_crop.py

@@ -0,0 +1,273 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.layers.preprocessing.image_preprocessing.bounding_boxes.converters import (  # noqa: E501
+    clip_to_image_size,
+)
+from keras.src.layers.preprocessing.image_preprocessing.bounding_boxes.converters import (  # noqa: E501
+    convert_format,
+)
+from keras.src.utils import image_utils
+
+
+@keras_export("keras.layers.CenterCrop")
+class CenterCrop(BaseImagePreprocessingLayer):
+    """A preprocessing layer which crops images.
+
+    This layers crops the central portion of the images to a target size. If an
+    image is smaller than the target size, it will be resized and cropped
+    so as to return the largest possible window in the image that matches
+    the target aspect ratio.
+
+    Input pixel values can be of any range (e.g. `[0., 1.)` or `[0, 255]`).
+
+    Input shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., height, width, channels)`, in `"channels_last"` format,
+        or `(..., channels, height, width)`, in `"channels_first"` format.
+
+    Output shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., target_height, target_width, channels)`,
+        or `(..., channels, target_height, target_width)`,
+        in `"channels_first"` format.
+
+    If the input height/width is even and the target height/width is odd (or
+    inversely), the input image is left-padded by 1 pixel.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    Args:
+        height: Integer, the height of the output shape.
+        width: Integer, the width of the output shape.
+        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"`.
+    """
+
+    _USE_BASE_FACTOR = False
+
+    def __init__(self, height, width, data_format=None, **kwargs):
+        super().__init__(data_format=data_format, **kwargs)
+        self.height = height
+        self.width = width
+
+    def get_random_transformation(self, data, training=True, seed=None):
+        if isinstance(data, dict):
+            images = data["images"]
+        else:
+            images = data
+        shape = self.backend.core.shape(images)
+        return {"input_shape": shape}
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_bounding_boxes(
+        self, bounding_boxes, transformation, training=True
+    ):
+        def _get_height_width(input_shape):
+            if self.data_format == "channels_first":
+                input_height = input_shape[-2]
+                input_width = input_shape[-1]
+            else:
+                input_height = input_shape[-3]
+                input_width = input_shape[-2]
+            return input_height, input_width
+
+        def _get_clipped_bbox(bounding_boxes, h_end, h_start, w_end, w_start):
+            bboxes = bounding_boxes["boxes"]
+            x1, y1, x2, y2 = self.backend.numpy.split(bboxes, 4, axis=-1)
+            x1 = self.backend.numpy.clip(x1, w_start, w_end) - w_start
+            y1 = self.backend.numpy.clip(y1, h_start, h_end) - h_start
+            x2 = self.backend.numpy.clip(x2, w_start, w_end) - w_start
+            y2 = self.backend.numpy.clip(y2, h_start, h_end) - h_start
+            bounding_boxes["boxes"] = self.backend.numpy.concatenate(
+                [x1, y1, x2, y2], axis=-1
+            )
+            return bounding_boxes
+
+        input_shape = transformation["input_shape"]
+
+        init_height, init_width = _get_height_width(input_shape)
+
+        bounding_boxes = convert_format(
+            bounding_boxes,
+            source=self.bounding_box_format,
+            target="xyxy",
+            height=init_height,
+            width=init_width,
+        )
+
+        h_diff = init_height - self.height
+        w_diff = init_width - self.width
+
+        if h_diff >= 0 and w_diff >= 0:
+            h_start = int(h_diff / 2)
+            w_start = int(w_diff / 2)
+
+            h_end = h_start + self.height
+            w_end = w_start + self.width
+
+            bounding_boxes = _get_clipped_bbox(
+                bounding_boxes, h_end, h_start, w_end, w_start
+            )
+        else:
+            width = init_width
+            height = init_height
+            target_height = self.height
+            target_width = self.width
+
+            crop_height = int(float(width * target_height) / target_width)
+            crop_height = max(min(height, crop_height), 1)
+            crop_width = int(float(height * target_width) / target_height)
+            crop_width = max(min(width, crop_width), 1)
+            crop_box_hstart = int(float(height - crop_height) / 2)
+            crop_box_wstart = int(float(width - crop_width) / 2)
+
+            h_start = crop_box_hstart
+            w_start = crop_box_wstart
+
+            h_end = crop_box_hstart + crop_height
+            w_end = crop_box_wstart + crop_width
+            bounding_boxes = _get_clipped_bbox(
+                bounding_boxes, h_end, h_start, w_end, w_start
+            )
+
+            bounding_boxes = convert_format(
+                bounding_boxes,
+                source="xyxy",
+                target="rel_xyxy",
+                height=crop_height,
+                width=crop_width,
+            )
+
+            bounding_boxes = convert_format(
+                bounding_boxes,
+                source="rel_xyxy",
+                target="xyxy",
+                height=self.height,
+                width=self.width,
+            )
+
+        bounding_boxes = clip_to_image_size(
+            bounding_boxes=bounding_boxes,
+            height=self.height,
+            width=self.width,
+            bounding_box_format="xyxy",
+        )
+
+        bounding_boxes = convert_format(
+            bounding_boxes,
+            source="xyxy",
+            target=self.bounding_box_format,
+            height=self.height,
+            width=self.width,
+        )
+
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return self.transform_images(
+            segmentation_masks, transformation, training=training
+        )
+
+    def transform_images(self, images, transformation=None, training=True):
+        inputs = self.backend.cast(images, self.compute_dtype)
+        if self.data_format == "channels_first":
+            init_height = inputs.shape[-2]
+            init_width = inputs.shape[-1]
+        else:
+            init_height = inputs.shape[-3]
+            init_width = inputs.shape[-2]
+
+        if init_height is None or init_width is None:
+            # Dynamic size case. TODO.
+            raise ValueError(
+                "At this time, CenterCrop can only "
+                "process images with a static spatial "
+                f"shape. Received: inputs.shape={inputs.shape}"
+            )
+
+        h_diff = init_height - self.height
+        w_diff = init_width - self.width
+
+        h_start = int(h_diff / 2)
+        w_start = int(w_diff / 2)
+
+        if h_diff >= 0 and w_diff >= 0:
+            if len(inputs.shape) == 4:
+                if self.data_format == "channels_first":
+                    return inputs[
+                        :,
+                        :,
+                        h_start : h_start + self.height,
+                        w_start : w_start + self.width,
+                    ]
+                return inputs[
+                    :,
+                    h_start : h_start + self.height,
+                    w_start : w_start + self.width,
+                    :,
+                ]
+            elif len(inputs.shape) == 3:
+                if self.data_format == "channels_first":
+                    return inputs[
+                        :,
+                        h_start : h_start + self.height,
+                        w_start : w_start + self.width,
+                    ]
+                return inputs[
+                    h_start : h_start + self.height,
+                    w_start : w_start + self.width,
+                    :,
+                ]
+        return image_utils.smart_resize(
+            inputs,
+            [self.height, self.width],
+            data_format=self.data_format,
+            backend_module=self.backend,
+        )
+
+    def compute_output_shape(self, input_shape):
+        input_shape = list(input_shape)
+        if isinstance(input_shape[0], (list, tuple)) or len(
+            input_shape
+        ) not in (3, 4):
+            raise ValueError(
+                "`input_shape` must be a non-nested tuple or list "
+                "of rank-1 with size 3 (unbatched) or 4 (batched). "
+            )
+        if len(input_shape) == 4:
+            if self.data_format == "channels_last":
+                input_shape[1] = self.height
+                input_shape[2] = self.width
+            else:
+                input_shape[2] = self.height
+                input_shape[3] = self.width
+        else:
+            if self.data_format == "channels_last":
+                input_shape[0] = self.height
+                input_shape[1] = self.width
+            else:
+                input_shape[1] = self.height
+                input_shape[2] = self.width
+        return tuple(input_shape)
+
+    def get_config(self):
+        base_config = super().get_config()
+        config = {
+            "height": self.height,
+            "width": self.width,
+            "data_format": self.data_format,
+        }
+        return {**base_config, **config}

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/equalization.py

@@ -0,0 +1,224 @@
+from keras.src import backend
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+
+
+@keras_export("keras.layers.Equalization")
+class Equalization(BaseImagePreprocessingLayer):
+    """Preprocessing layer for histogram equalization on image channels.
+
+    Histogram equalization is a technique to adjust image intensities to
+    enhance contrast by effectively spreading out the most frequent
+    intensity values. This layer applies equalization on a channel-wise
+    basis, which can improve the visibility of details in images.
+
+    This layer works with both grayscale and color images, performing
+    equalization independently on each color channel. At inference time,
+    the equalization is consistently applied.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    Args:
+        value_range: Optional list/tuple of 2 floats specifying the lower
+            and upper limits of the input data values. Defaults to `[0, 255]`.
+            If the input image has been scaled, use the appropriate range
+            (e.g., `[0.0, 1.0]`). The equalization will be scaled to this
+            range, and output values will be clipped accordingly.
+        bins: Integer specifying the number of histogram bins to use for
+            equalization. Defaults to 256, which is suitable for 8-bit images.
+            Larger values can provide more granular intensity redistribution.
+
+    Input shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., height, width, channels)`, in `"channels_last"` format,
+        or `(..., channels, height, width)`, in `"channels_first"` format.
+
+    Output shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., target_height, target_width, channels)`,
+        or `(..., channels, target_height, target_width)`,
+        in `"channels_first"` format.
+
+    Example:
+
+    ```python
+    # Create an equalization layer for standard 8-bit images
+    equalizer = keras.layers.Equalization()
+
+    # An image with uneven intensity distribution
+    image = [...] # your input image
+
+    # Apply histogram equalization
+    equalized_image = equalizer(image)
+
+    # For images with custom value range
+    custom_equalizer = keras.layers.Equalization(
+        value_range=[0.0, 1.0],  # for normalized images
+        bins=128  # fewer bins for more subtle equalization
+    )
+    custom_equalized = custom_equalizer(normalized_image)
+    ```
+    """
+
+    def __init__(
+        self, value_range=(0, 255), bins=256, data_format=None, **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.bins = bins
+        self._set_value_range(value_range)
+        self.data_format = backend.standardize_data_format(data_format)
+
+    def _set_value_range(self, value_range):
+        if not isinstance(value_range, (tuple, list)):
+            raise ValueError(
+                self._VALUE_RANGE_VALIDATION_ERROR
+                + f"Received: value_range={value_range}"
+            )
+        if len(value_range) != 2:
+            raise ValueError(
+                self._VALUE_RANGE_VALIDATION_ERROR
+                + f"Received: value_range={value_range}"
+            )
+        self.value_range = sorted(value_range)
+
+    def _custom_histogram_fixed_width(self, values, value_range, nbins):
+        values = self.backend.cast(values, "float32")
+        value_min, value_max = value_range
+        value_min = self.backend.cast(value_min, "float32")
+        value_max = self.backend.cast(value_max, "float32")
+
+        scaled = (values - value_min) * (nbins - 1) / (value_max - value_min)
+        indices = self.backend.cast(scaled, "int32")
+        indices = self.backend.numpy.clip(indices, 0, nbins - 1)
+        flat_indices = self.backend.numpy.reshape(indices, [-1])
+
+        if backend.backend() == "jax":
+            # for JAX bincount is never jittable because of output shape
+            histogram = self.backend.numpy.zeros(nbins, dtype="int32")
+            for i in range(nbins):
+                matches = self.backend.cast(
+                    self.backend.numpy.equal(flat_indices, i), "int32"
+                )
+                bin_count = self.backend.numpy.sum(matches)
+                one_hot = self.backend.cast(
+                    self.backend.numpy.arange(nbins) == i, "int32"
+                )
+                histogram = histogram + (bin_count * one_hot)
+            return histogram
+        else:
+            # TensorFlow/PyTorch/NumPy implementation using bincount
+            return self.backend.numpy.bincount(
+                flat_indices,
+                minlength=nbins,
+            )
+
+    def _scale_values(self, values, source_range, target_range):
+        source_min, source_max = source_range
+        target_min, target_max = target_range
+        scale = (target_max - target_min) / (source_max - source_min)
+        offset = target_min - source_min * scale
+        return values * scale + offset
+
+    def _equalize_channel(self, channel, value_range):
+        if value_range != (0, 255):
+            channel = self._scale_values(channel, value_range, (0, 255))
+
+        hist = self._custom_histogram_fixed_width(
+            channel, value_range=(0, 255), nbins=self.bins
+        )
+
+        nonzero_bins = self.backend.numpy.count_nonzero(hist)
+        equalized = self.backend.numpy.where(
+            nonzero_bins <= 1, channel, self._apply_equalization(channel, hist)
+        )
+
+        if value_range != (0, 255):
+            equalized = self._scale_values(equalized, (0, 255), value_range)
+
+        return equalized
+
+    def _apply_equalization(self, channel, hist):
+        cdf = self.backend.numpy.cumsum(hist)
+
+        if self.backend.name == "jax":
+            mask = cdf > 0
+            first_nonzero_idx = self.backend.numpy.argmax(mask)
+            cdf_min = self.backend.numpy.take(cdf, first_nonzero_idx)
+        else:
+            cdf_min = self.backend.numpy.take(
+                cdf, self.backend.numpy.nonzero(cdf)[0][0]
+            )
+
+        denominator = cdf[-1] - cdf_min
+        denominator = self.backend.numpy.where(
+            denominator == 0,
+            self.backend.numpy.ones_like(1, dtype=denominator.dtype),
+            denominator,
+        )
+
+        lookup_table = ((cdf - cdf_min) * 255) / denominator
+        lookup_table = self.backend.numpy.clip(
+            self.backend.numpy.round(lookup_table), 0, 255
+        )
+
+        scaled_channel = (channel / 255.0) * (self.bins - 1)
+        indices = self.backend.cast(
+            self.backend.numpy.clip(scaled_channel, 0, self.bins - 1), "int32"
+        )
+        return self.backend.numpy.take(lookup_table, indices)
+
+    def transform_images(self, images, transformation, training=True):
+        if training:
+            images = self.backend.cast(images, self.compute_dtype)
+
+            if self.data_format == "channels_first":
+                channels = []
+                for i in range(self.backend.core.shape(images)[-3]):
+                    channel = images[..., i, :, :]
+                    equalized = self._equalize_channel(
+                        channel, self.value_range
+                    )
+                    channels.append(equalized)
+                equalized_images = self.backend.numpy.stack(channels, axis=-3)
+            else:
+                channels = []
+                for i in range(self.backend.core.shape(images)[-1]):
+                    channel = images[..., i]
+                    equalized = self._equalize_channel(
+                        channel, self.value_range
+                    )
+                    channels.append(equalized)
+                equalized_images = self.backend.numpy.stack(channels, axis=-1)
+
+            return self.backend.cast(equalized_images, self.compute_dtype)
+        return images
+
+    def compute_output_shape(self, input_shape):
+        return input_shape
+
+    def compute_output_spec(self, inputs, **kwargs):
+        return inputs
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        return bounding_boxes
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return segmentation_masks
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({"bins": self.bins, "value_range": self.value_range})
+        return config

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/max_num_bounding_box.py

@@ -0,0 +1,89 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+
+
+@keras_export("keras.layers.MaxNumBoundingBoxes")
+class MaxNumBoundingBoxes(BaseImagePreprocessingLayer):
+    """Ensure the maximum number of bounding boxes.
+
+    Args:
+        max_number: Desired output number of bounding boxes.
+        padding_value: The padding value of the `boxes` and `labels` in
+            `bounding_boxes`. Defaults to `-1`.
+    """
+
+    def __init__(self, max_number, fill_value=-1, **kwargs):
+        super().__init__(**kwargs)
+        self.max_number = int(max_number)
+        self.fill_value = int(fill_value)
+
+    def transform_images(self, images, transformation=None, training=True):
+        return images
+
+    def transform_labels(self, labels, transformation=None, training=True):
+        return labels
+
+    def transform_bounding_boxes(
+        self, bounding_boxes, transformation, training=True
+    ):
+        ops = self.backend
+        boxes = bounding_boxes["boxes"]
+        labels = bounding_boxes["labels"]
+        boxes_shape = ops.shape(boxes)
+        batch_size = boxes_shape[0]
+        num_boxes = boxes_shape[1]
+
+        # Get pad size
+        pad_size = ops.numpy.maximum(
+            ops.numpy.subtract(self.max_number, num_boxes), 0
+        )
+        boxes = boxes[:, : self.max_number, ...]
+        boxes = ops.numpy.pad(
+            boxes,
+            [[0, 0], [0, pad_size], [0, 0]],
+            constant_values=self.fill_value,
+        )
+        labels = labels[:, : self.max_number]
+        labels = ops.numpy.pad(
+            labels, [[0, 0], [0, pad_size]], constant_values=self.fill_value
+        )
+
+        # Ensure shape
+        boxes = ops.numpy.reshape(boxes, [batch_size, self.max_number, 4])
+        labels = ops.numpy.reshape(labels, [batch_size, self.max_number])
+
+        bounding_boxes = bounding_boxes.copy()
+        bounding_boxes["boxes"] = boxes
+        bounding_boxes["labels"] = labels
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation=None, training=True
+    ):
+        return self.transform_images(segmentation_masks)
+
+    def compute_output_shape(self, input_shape):
+        if isinstance(input_shape, dict) and "bounding_boxes" in input_shape:
+            input_keys = set(input_shape["bounding_boxes"].keys())
+            extra_keys = input_keys - set(("boxes", "labels"))
+            if extra_keys:
+                raise KeyError(
+                    "There are unsupported keys in `bounding_boxes`: "
+                    f"{list(extra_keys)}. "
+                    "Only `boxes` and `labels` are supported."
+                )
+
+            boxes_shape = list(input_shape["bounding_boxes"]["boxes"])
+            boxes_shape[1] = self.max_number
+            labels_shape = list(input_shape["bounding_boxes"]["labels"])
+            labels_shape[1] = self.max_number
+            input_shape["bounding_boxes"]["boxes"] = boxes_shape
+            input_shape["bounding_boxes"]["labels"] = labels_shape
+        return input_shape
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({"max_number": self.max_number})
+        return config

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/mix_up.py

@@ -0,0 +1,180 @@
+from keras.src import ops
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.random import SeedGenerator
+from keras.src.utils import backend_utils
+
+
+@keras_export("keras.layers.MixUp")
+class MixUp(BaseImagePreprocessingLayer):
+    """MixUp implements the MixUp data augmentation technique.
+
+    Args:
+        alpha: Float between 0 and 1. Controls the blending strength.
+               Smaller values mean less mixing, while larger values allow
+               for more  blending between images. Defaults to 0.2,
+               recommended for ImageNet1k classification.
+        seed: Integer. Used to create a random seed.
+
+    References:
+        - [MixUp paper](https://arxiv.org/abs/1710.09412).
+        - [MixUp for Object Detection paper](https://arxiv.org/pdf/1902.04103).
+
+    Example:
+    ```python
+    (images, labels), _ = keras.datasets.cifar10.load_data()
+    images, labels = images[:8], labels[:8]
+    labels = keras.ops.cast(keras.ops.one_hot(labels.flatten(), 10), "float32")
+    mix_up = keras.layers.MixUp(alpha=0.2)
+    output = mix_up({"images": images, "labels": labels})
+    ```
+    """
+
+    def __init__(self, alpha=0.2, data_format=None, seed=None, **kwargs):
+        super().__init__(data_format=data_format, **kwargs)
+        self.alpha = alpha
+        self.seed = seed
+        self.generator = SeedGenerator(seed)
+
+    def get_random_transformation(self, data, training=True, seed=None):
+        if isinstance(data, dict):
+            images = data["images"]
+        else:
+            images = data
+
+        images_shape = self.backend.shape(images)
+
+        if len(images_shape) == 3:
+            batch_size = 1
+        else:
+            batch_size = self.backend.shape(images)[0]
+
+        if seed is None:
+            seed = self._get_seed_generator(self.backend._backend)
+
+        permutation_order = self.backend.random.shuffle(
+            self.backend.numpy.arange(0, batch_size, dtype="int64"),
+            seed=seed,
+        )
+
+        mix_weight = self.backend.random.beta(
+            (batch_size,), self.alpha, self.alpha, seed=seed
+        )
+        return {
+            "mix_weight": mix_weight,
+            "permutation_order": permutation_order,
+        }
+
+    def transform_images(self, images, transformation=None, training=True):
+        def _mix_up_input(images, transformation):
+            images = self.backend.cast(images, self.compute_dtype)
+            mix_weight = transformation["mix_weight"]
+            permutation_order = transformation["permutation_order"]
+            mix_weight = self.backend.cast(
+                self.backend.numpy.reshape(mix_weight, [-1, 1, 1, 1]),
+                dtype=self.compute_dtype,
+            )
+            mix_up_images = self.backend.cast(
+                self.backend.numpy.take(images, permutation_order, axis=0),
+                dtype=self.compute_dtype,
+            )
+            images = mix_weight * images + (1.0 - mix_weight) * mix_up_images
+            return images
+
+        if training:
+            images = _mix_up_input(images, transformation)
+        return images
+
+    def transform_labels(self, labels, transformation, training=True):
+        def _mix_up_labels(labels, transformation):
+            mix_weight = transformation["mix_weight"]
+            permutation_order = transformation["permutation_order"]
+            labels_for_mix_up = self.backend.numpy.take(
+                labels, permutation_order, axis=0
+            )
+            mix_weight = self.backend.numpy.reshape(mix_weight, [-1, 1])
+            labels = (
+                mix_weight * labels + (1.0 - mix_weight) * labels_for_mix_up
+            )
+            return labels
+
+        if training:
+            labels = _mix_up_labels(labels, transformation)
+        return labels
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        def _mix_up_bounding_boxes(bounding_boxes, transformation):
+            if backend_utils.in_tf_graph():
+                self.backend.set_backend("tensorflow")
+
+            permutation_order = transformation["permutation_order"]
+            # Make sure we are on cpu for torch tensors.
+            permutation_order = ops.convert_to_numpy(permutation_order)
+
+            boxes, labels = bounding_boxes["boxes"], bounding_boxes["labels"]
+            boxes_for_mix_up = self.backend.numpy.take(
+                boxes, permutation_order, axis=0
+            )
+
+            labels_for_mix_up = self.backend.numpy.take(
+                labels, permutation_order, axis=0
+            )
+            boxes = self.backend.numpy.concatenate(
+                [boxes, boxes_for_mix_up], axis=1
+            )
+
+            labels = self.backend.numpy.concatenate(
+                [labels, labels_for_mix_up], axis=0
+            )
+
+            self.backend.reset()
+
+            return {"boxes": boxes, "labels": labels}
+
+        if training:
+            bounding_boxes = _mix_up_bounding_boxes(
+                bounding_boxes, transformation
+            )
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        def _mix_up_segmentation_masks(segmentation_masks, transformation):
+            mix_weight = transformation["mix_weight"]
+            # Make sure we are on cpu for torch tensors.
+            mix_weight = ops.convert_to_numpy(mix_weight)
+            permutation_order = transformation["permutation_order"]
+            mix_weight = self.backend.numpy.reshape(mix_weight, [-1, 1, 1, 1])
+            segmentation_masks_for_mix_up = self.backend.numpy.take(
+                segmentation_masks, permutation_order
+            )
+            segmentation_masks = (
+                mix_weight * segmentation_masks
+                + (1.0 - mix_weight) * segmentation_masks_for_mix_up
+            )
+            return segmentation_masks
+
+        if training:
+            segmentation_masks = _mix_up_segmentation_masks(
+                segmentation_masks, transformation
+            )
+        return segmentation_masks
+
+    def compute_output_shape(self, input_shape):
+        return input_shape
+
+    def get_config(self):
+        config = {
+            "alpha": self.alpha,
+            "seed": self.seed,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/rand_augment.py

@@ -0,0 +1,235 @@
+import random
+
+import keras.src.layers as layers
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.random import SeedGenerator
+from keras.src.utils import backend_utils
+
+
+@keras_export("keras.layers.RandAugment")
+class RandAugment(BaseImagePreprocessingLayer):
+    """RandAugment performs the Rand Augment operation on input images.
+
+    This layer can be thought of as an all-in-one image augmentation layer. The
+    policy implemented by this layer has been benchmarked extensively and is
+    effective on a wide variety of datasets.
+
+    References:
+        - [RandAugment](https://arxiv.org/abs/1909.13719)
+
+    Args:
+        value_range: The range of values the input image can take.
+            Default is `(0, 255)`. Typically, this would be `(0, 1)`
+            for normalized images or `(0, 255)` for raw images.
+        num_ops: The number of augmentation operations to apply sequentially
+            to each image. Default is 2.
+        factor: The strength of the augmentation as a normalized value
+            between 0 and 1. Default is 0.5.
+        interpolation: The interpolation method to use for resizing operations.
+            Options include `nearest`, `bilinear`. Default is `bilinear`.
+        seed: Integer. Used to create a random seed.
+
+    """
+
+    _USE_BASE_FACTOR = False
+    _FACTOR_BOUNDS = (0, 1)
+
+    _AUGMENT_LAYERS = [
+        "random_shear",
+        "random_translation",
+        "random_rotation",
+        "random_brightness",
+        "random_color_degeneration",
+        "random_contrast",
+        "random_sharpness",
+        "random_posterization",
+        "solarization",
+        "auto_contrast",
+        "equalization",
+    ]
+
+    def __init__(
+        self,
+        value_range=(0, 255),
+        num_ops=2,
+        factor=0.5,
+        interpolation="bilinear",
+        seed=None,
+        data_format=None,
+        **kwargs,
+    ):
+        super().__init__(data_format=data_format, **kwargs)
+
+        self.value_range = value_range
+        self.num_ops = num_ops
+        self._set_factor(factor)
+        self.interpolation = interpolation
+        self.seed = seed
+        self.generator = SeedGenerator(seed)
+
+        self.random_shear = layers.RandomShear(
+            x_factor=self.factor,
+            y_factor=self.factor,
+            interpolation=interpolation,
+            seed=self.seed,
+            data_format=data_format,
+            **kwargs,
+        )
+
+        self.random_translation = layers.RandomTranslation(
+            height_factor=self.factor,
+            width_factor=self.factor,
+            interpolation=interpolation,
+            seed=self.seed,
+            data_format=data_format,
+            **kwargs,
+        )
+
+        self.random_rotation = layers.RandomRotation(
+            factor=self.factor,
+            interpolation=interpolation,
+            seed=self.seed,
+            data_format=data_format,
+            **kwargs,
+        )
+
+        self.random_brightness = layers.RandomBrightness(
+            factor=self.factor,
+            value_range=self.value_range,
+            seed=self.seed,
+            data_format=data_format,
+            **kwargs,
+        )
+
+        self.random_color_degeneration = layers.RandomColorDegeneration(
+            factor=self.factor,
+            value_range=self.value_range,
+            seed=self.seed,
+            data_format=data_format,
+            **kwargs,
+        )
+
+        self.random_contrast = layers.RandomContrast(
+            factor=self.factor,
+            value_range=self.value_range,
+            seed=self.seed,
+            data_format=data_format,
+            **kwargs,
+        )
+
+        self.random_sharpness = layers.RandomSharpness(
+            factor=self.factor,
+            value_range=self.value_range,
+            seed=self.seed,
+            data_format=data_format,
+            **kwargs,
+        )
+
+        self.solarization = layers.Solarization(
+            addition_factor=self.factor,
+            threshold_factor=self.factor,
+            value_range=self.value_range,
+            seed=self.seed,
+            data_format=data_format,
+            **kwargs,
+        )
+
+        self.random_posterization = layers.RandomPosterization(
+            factor=max(1, int(8 * self.factor[1])),
+            value_range=self.value_range,
+            seed=self.seed,
+            data_format=data_format,
+            **kwargs,
+        )
+
+        self.auto_contrast = layers.AutoContrast(
+            value_range=self.value_range, data_format=data_format, **kwargs
+        )
+
+        self.equalization = layers.Equalization(
+            value_range=self.value_range, data_format=data_format, **kwargs
+        )
+
+    def build(self, input_shape):
+        for layer_name in self._AUGMENT_LAYERS:
+            augmentation_layer = getattr(self, layer_name)
+            augmentation_layer.build(input_shape)
+
+    def get_random_transformation(self, data, training=True, seed=None):
+        if not training:
+            return None
+
+        if backend_utils.in_tf_graph():
+            self.backend.set_backend("tensorflow")
+
+            for layer_name in self._AUGMENT_LAYERS:
+                augmentation_layer = getattr(self, layer_name)
+                augmentation_layer.backend.set_backend("tensorflow")
+
+        transformation = {}
+        random.shuffle(self._AUGMENT_LAYERS)
+        for layer_name in self._AUGMENT_LAYERS[: self.num_ops]:
+            augmentation_layer = getattr(self, layer_name)
+            transformation[layer_name] = (
+                augmentation_layer.get_random_transformation(
+                    data,
+                    training=training,
+                    seed=self._get_seed_generator(self.backend._backend),
+                )
+            )
+
+        return transformation
+
+    def transform_images(self, images, transformation, training=True):
+        if training:
+            images = self.backend.cast(images, self.compute_dtype)
+
+            for layer_name, transformation_value in transformation.items():
+                augmentation_layer = getattr(self, layer_name)
+                images = augmentation_layer.transform_images(
+                    images, transformation_value
+                )
+
+        images = self.backend.cast(images, self.compute_dtype)
+        return images
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        if training:
+            for layer_name, transformation_value in transformation.items():
+                augmentation_layer = getattr(self, layer_name)
+                bounding_boxes = augmentation_layer.transform_bounding_boxes(
+                    bounding_boxes, transformation_value, training=training
+                )
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return self.transform_images(
+            segmentation_masks, transformation, training=training
+        )
+
+    def compute_output_shape(self, input_shape):
+        return input_shape
+
+    def get_config(self):
+        config = {
+            "value_range": self.value_range,
+            "num_ops": self.num_ops,
+            "factor": self.factor,
+            "interpolation": self.interpolation,
+            "seed": self.seed,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/random_brightness.py

@@ -0,0 +1,158 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.random.seed_generator import SeedGenerator
+
+
+@keras_export("keras.layers.RandomBrightness")
+class RandomBrightness(BaseImagePreprocessingLayer):
+    """A preprocessing layer which randomly adjusts brightness during training.
+
+    This layer will randomly increase/reduce the brightness for the input RGB
+    images. At inference time, the output will be identical to the input.
+    Call the layer with `training=True` to adjust the brightness of the input.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    Args:
+        factor: Float or a list/tuple of 2 floats between -1.0 and 1.0. The
+            factor is used to determine the lower bound and upper bound of the
+            brightness adjustment. A float value will be chosen randomly between
+            the limits. When -1.0 is chosen, the output image will be black, and
+            when 1.0 is chosen, the image will be fully white.
+            When only one float is provided, eg, 0.2,
+            then -0.2 will be used for lower bound and 0.2
+            will be used for upper bound.
+        value_range: Optional list/tuple of 2 floats
+            for the lower and upper limit
+            of the values of the input data.
+            To make no change, use `[0.0, 1.0]`, e.g., if the image input
+            has been scaled before this layer. Defaults to `[0.0, 255.0]`.
+            The brightness adjustment will be scaled to this range, and the
+            output values will be clipped to this range.
+        seed: optional integer, for fixed RNG behavior.
+
+    Inputs: 3D (HWC) or 4D (NHWC) tensor, with float or int dtype. Input pixel
+        values can be of any range (e.g. `[0., 1.)` or `[0, 255]`)
+
+    Output: 3D (HWC) or 4D (NHWC) tensor with brightness adjusted based on the
+        `factor`. By default, the layer will output floats.
+        The output value will be clipped to the range `[0, 255]`,
+        the valid range of RGB colors, and
+        rescaled based on the `value_range` if needed.
+
+    Example:
+
+    ```python
+    random_bright = keras.layers.RandomBrightness(factor=0.2)
+
+    # An image with shape [2, 2, 3]
+    image = [[[1, 2, 3], [4 ,5 ,6]], [[7, 8, 9], [10, 11, 12]]]
+
+    # Assume we randomly select the factor to be 0.1, then it will apply
+    # 0.1 * 255 to all the channel
+    output = random_bright(image, training=True)
+
+    # output will be int64 with 25.5 added to each channel and round down.
+    >>> array([[[26.5, 27.5, 28.5]
+                [29.5, 30.5, 31.5]]
+               [[32.5, 33.5, 34.5]
+                [35.5, 36.5, 37.5]]],
+              shape=(2, 2, 3), dtype=int64)
+    ```
+    """
+
+    _VALUE_RANGE_VALIDATION_ERROR = (
+        "The `value_range` argument should be a list of two numbers. "
+    )
+
+    def __init__(self, factor, value_range=(0, 255), seed=None, **kwargs):
+        super().__init__(factor=factor, **kwargs)
+        self.seed = seed
+        self.generator = SeedGenerator(seed)
+        self._set_value_range(value_range)
+
+    def _set_value_range(self, value_range):
+        if not isinstance(value_range, (tuple, list)):
+            raise ValueError(
+                self._VALUE_RANGE_VALIDATION_ERROR
+                + f"Received: value_range={value_range}"
+            )
+        if len(value_range) != 2:
+            raise ValueError(
+                self._VALUE_RANGE_VALIDATION_ERROR
+                + f"Received: value_range={value_range}"
+            )
+        self.value_range = sorted(value_range)
+
+    def get_random_transformation(self, data, training=True, seed=None):
+        if isinstance(data, dict):
+            images = data["images"]
+        else:
+            images = data
+        images_shape = self.backend.shape(images)
+        rank = len(images_shape)
+        if rank == 3:
+            rgb_delta_shape = (1, 1, 1)
+        elif rank == 4:
+            # Keep only the batch dim. This will ensure to have same adjustment
+            # with in one image, but different across the images.
+            rgb_delta_shape = [images_shape[0], 1, 1, 1]
+        else:
+            raise ValueError(
+                "Expected the input image to be rank 3 or 4. Received "
+                f"inputs.shape={images_shape}"
+            )
+        if not training:
+            return {"rgb_delta": self.backend.numpy.zeros(rgb_delta_shape)}
+
+        if seed is None:
+            seed = self._get_seed_generator(self.backend._backend)
+        rgb_delta = self.backend.random.uniform(
+            minval=self.factor[0],
+            maxval=self.factor[1],
+            shape=rgb_delta_shape,
+            seed=seed,
+        )
+        rgb_delta = rgb_delta * (self.value_range[1] - self.value_range[0])
+        return {"rgb_delta": rgb_delta}
+
+    def transform_images(self, images, transformation, training=True):
+        if training:
+            rgb_delta = transformation["rgb_delta"]
+            rgb_delta = self.backend.cast(rgb_delta, images.dtype)
+            images += rgb_delta
+            return self.backend.numpy.clip(
+                images, self.value_range[0], self.value_range[1]
+            )
+        return images
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return segmentation_masks
+
+    def compute_output_shape(self, input_shape):
+        return input_shape
+
+    def get_config(self):
+        config = {
+            "factor": self.factor,
+            "value_range": self.value_range,
+            "seed": self.seed,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/random_color_degeneration.py

@@ -0,0 +1,132 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.random import SeedGenerator
+
+
+@keras_export("keras.layers.RandomColorDegeneration")
+class RandomColorDegeneration(BaseImagePreprocessingLayer):
+    """Randomly performs the color degeneration operation on given images.
+
+    The sharpness operation first converts an image to gray scale, then back to
+    color. It then takes a weighted average between original image and the
+    degenerated image. This makes colors appear more dull.
+
+    Args:
+        factor: A tuple of two floats or a single float.
+            `factor` controls the extent to which the
+            image sharpness is impacted. `factor=0.0` makes this layer perform a
+            no-op operation, while a value of 1.0 uses the degenerated result
+            entirely. Values between 0 and 1 result in linear interpolation
+            between the original image and the sharpened image.
+            Values should be between `0.0` and `1.0`. If a tuple is used, a
+            `factor` is sampled between the two values for every image
+            augmented. If a single float is used, a value between `0.0` and the
+            passed float is sampled. In order to ensure the value is always the
+            same, please pass a tuple with two identical floats: `(0.5, 0.5)`.
+        seed: Integer. Used to create a random seed.
+    """
+
+    _VALUE_RANGE_VALIDATION_ERROR = (
+        "The `value_range` argument should be a list of two numbers. "
+    )
+
+    def __init__(
+        self,
+        factor,
+        value_range=(0, 255),
+        data_format=None,
+        seed=None,
+        **kwargs,
+    ):
+        super().__init__(data_format=data_format, **kwargs)
+        self._set_factor(factor)
+        self._set_value_range(value_range)
+        self.seed = seed
+        self.generator = SeedGenerator(seed)
+
+    def _set_value_range(self, value_range):
+        if not isinstance(value_range, (tuple, list)):
+            raise ValueError(
+                self._VALUE_RANGE_VALIDATION_ERROR
+                + f"Received: value_range={value_range}"
+            )
+        if len(value_range) != 2:
+            raise ValueError(
+                self._VALUE_RANGE_VALIDATION_ERROR
+                + f"Received: value_range={value_range}"
+            )
+        self.value_range = sorted(value_range)
+
+    def get_random_transformation(self, data, training=True, seed=None):
+        if isinstance(data, dict):
+            images = data["images"]
+        else:
+            images = data
+        images_shape = self.backend.shape(images)
+        rank = len(images_shape)
+        if rank == 3:
+            batch_size = 1
+        elif rank == 4:
+            batch_size = images_shape[0]
+        else:
+            raise ValueError(
+                "Expected the input image to be rank 3 or 4. Received: "
+                f"inputs.shape={images_shape}"
+            )
+
+        if seed is None:
+            seed = self._get_seed_generator(self.backend._backend)
+
+        factor = self.backend.random.uniform(
+            (batch_size, 1, 1, 1),
+            minval=self.factor[0],
+            maxval=self.factor[1],
+            seed=seed,
+        )
+        factor = factor
+        return {"factor": factor}
+
+    def transform_images(self, images, transformation=None, training=True):
+        if training:
+            images = self.backend.cast(images, self.compute_dtype)
+            factor = self.backend.cast(
+                transformation["factor"], self.compute_dtype
+            )
+            degenerates = self.backend.image.rgb_to_grayscale(
+                images, data_format=self.data_format
+            )
+            images = images + factor * (degenerates - images)
+            images = self.backend.numpy.clip(
+                images, self.value_range[0], self.value_range[1]
+            )
+            images = self.backend.cast(images, self.compute_dtype)
+        return images
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return segmentation_masks
+
+    def transform_bounding_boxes(
+        self, bounding_boxes, transformation, training=True
+    ):
+        return bounding_boxes
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "factor": self.factor,
+                "value_range": self.value_range,
+                "seed": self.seed,
+            }
+        )
+        return config
+
+    def compute_output_shape(self, input_shape):
+        return input_shape

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/random_color_jitter.py

@@ -0,0 +1,210 @@
+import keras.src.layers.preprocessing.image_preprocessing.random_brightness as random_brightness  # noqa: E501
+import keras.src.layers.preprocessing.image_preprocessing.random_contrast as random_contrast  # noqa: E501
+import keras.src.layers.preprocessing.image_preprocessing.random_hue as random_hue  # noqa: E501
+import keras.src.layers.preprocessing.image_preprocessing.random_saturation as random_saturation  # noqa: E501
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.random.seed_generator import SeedGenerator
+from keras.src.utils import backend_utils
+
+
+@keras_export("keras.layers.RandomColorJitter")
+class RandomColorJitter(BaseImagePreprocessingLayer):
+    """RandomColorJitter class randomly apply brightness, contrast, saturation
+    and hue image processing operation sequentially and randomly on the
+    input.
+
+    Args:
+        value_range: the range of values the incoming images will have.
+            Represented as a two number tuple written [low, high].
+            This is typically either `[0, 1]` or `[0, 255]` depending
+            on how your preprocessing pipeline is set up.
+        brightness_factor: Float or a list/tuple of 2 floats between -1.0
+            and 1.0. The factor is used to determine the lower bound and
+            upper bound of the brightness adjustment. A float value will
+            be chosen randomly between the limits. When -1.0 is chosen,
+            the output image will be black, and when 1.0 is chosen, the
+            image will be fully white. When only one float is provided,
+            eg, 0.2, then -0.2 will be used for lower bound and 0.2 will
+            be used for upper bound.
+        contrast_factor: a positive float represented as fraction of value,
+            or a tuple of size 2 representing lower and upper bound. When
+            represented as a single float, lower = upper. The contrast
+            factor will be randomly picked between `[1.0 - lower, 1.0 +
+            upper]`. For any pixel x in the channel, the output will be
+            `(x - mean) * factor + mean` where `mean` is the mean value
+            of the channel.
+        saturation_factor: A tuple of two floats or a single float. `factor`
+            controls the extent to which the image saturation is impacted.
+            `factor=0.5` makes this layer perform a no-op operation.
+            `factor=0.0` makes the image fully grayscale. `factor=1.0`
+            makes the image fully saturated. Values should be between
+            `0.0` and `1.0`. If a tuple is used, a `factor` is sampled
+            between the two values for every image augmented. If a single
+            float is used, a value between `0.0` and the passed float is
+            sampled. To ensure the value is always the same, pass a tuple
+            with two identical floats: `(0.5, 0.5)`.
+        hue_factor: A single float or a tuple of two floats. `factor`
+            controls the extent to which the image hue is impacted.
+            `factor=0.0` makes this layer perform a no-op operation,
+            while a value of `1.0` performs the most aggressive contrast
+            adjustment available. If a tuple is used, a `factor` is
+            sampled between the two values for every image augmented.
+            If a single float is used, a value between `0.0` and the
+            passed float is sampled. In order to ensure the value is
+            always the same, please pass a tuple with two identical
+            floats: `(0.5, 0.5)`.
+        seed: Integer. Used to create a random seed.
+    """
+
+    def __init__(
+        self,
+        value_range=(0, 255),
+        brightness_factor=None,
+        contrast_factor=None,
+        saturation_factor=None,
+        hue_factor=None,
+        seed=None,
+        data_format=None,
+        **kwargs,
+    ):
+        super().__init__(data_format=data_format, **kwargs)
+        self.value_range = value_range
+        self.brightness_factor = brightness_factor
+        self.contrast_factor = contrast_factor
+        self.saturation_factor = saturation_factor
+        self.hue_factor = hue_factor
+        self.seed = seed
+        self.generator = SeedGenerator(seed)
+
+        self.random_brightness = None
+        self.random_contrast = None
+        self.random_saturation = None
+        self.random_hue = None
+
+        if self.brightness_factor is not None:
+            self.random_brightness = random_brightness.RandomBrightness(
+                factor=self.brightness_factor,
+                value_range=self.value_range,
+                seed=self.seed,
+            )
+
+        if self.contrast_factor is not None:
+            self.random_contrast = random_contrast.RandomContrast(
+                factor=self.contrast_factor,
+                value_range=self.value_range,
+                seed=self.seed,
+            )
+
+        if self.saturation_factor is not None:
+            self.random_saturation = random_saturation.RandomSaturation(
+                factor=self.saturation_factor,
+                value_range=self.value_range,
+                seed=self.seed,
+            )
+
+        if self.hue_factor is not None:
+            self.random_hue = random_hue.RandomHue(
+                factor=self.hue_factor,
+                value_range=self.value_range,
+                seed=self.seed,
+            )
+
+    def build(self, input_shape):
+        if self.brightness_factor is not None:
+            self.random_brightness.build(input_shape)
+
+        if self.contrast_factor is not None:
+            self.random_contrast.build(input_shape)
+
+        if self.saturation_factor is not None:
+            self.random_saturation.build(input_shape)
+
+        if self.hue_factor is not None:
+            self.random_hue.build(input_shape)
+
+    def transform_images(self, images, transformation, training=True):
+        if training:
+            if backend_utils.in_tf_graph():
+                self.backend.set_backend("tensorflow")
+            images = self.backend.cast(images, self.compute_dtype)
+            if self.brightness_factor is not None:
+                if backend_utils.in_tf_graph():
+                    self.random_brightness.backend.set_backend("tensorflow")
+                transformation = (
+                    self.random_brightness.get_random_transformation(
+                        images,
+                        seed=self._get_seed_generator(self.backend._backend),
+                    )
+                )
+                images = self.random_brightness.transform_images(
+                    images, transformation
+                )
+            if self.contrast_factor is not None:
+                if backend_utils.in_tf_graph():
+                    self.random_contrast.backend.set_backend("tensorflow")
+                transformation = self.random_contrast.get_random_transformation(
+                    images, seed=self._get_seed_generator(self.backend._backend)
+                )
+                transformation["contrast_factor"] = self.backend.cast(
+                    transformation["contrast_factor"], dtype=self.compute_dtype
+                )
+                images = self.random_contrast.transform_images(
+                    images, transformation
+                )
+            if self.saturation_factor is not None:
+                if backend_utils.in_tf_graph():
+                    self.random_saturation.backend.set_backend("tensorflow")
+                transformation = (
+                    self.random_saturation.get_random_transformation(
+                        images,
+                        seed=self._get_seed_generator(self.backend._backend),
+                    )
+                )
+                images = self.random_saturation.transform_images(
+                    images, transformation
+                )
+            if self.hue_factor is not None:
+                if backend_utils.in_tf_graph():
+                    self.random_hue.backend.set_backend("tensorflow")
+                transformation = self.random_hue.get_random_transformation(
+                    images, seed=self._get_seed_generator(self.backend._backend)
+                )
+                images = self.random_hue.transform_images(
+                    images, transformation
+                )
+            images = self.backend.cast(images, self.compute_dtype)
+        return images
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return segmentation_masks
+
+    def compute_output_shape(self, input_shape):
+        return input_shape
+
+    def get_config(self):
+        config = {
+            "value_range": self.value_range,
+            "brightness_factor": self.brightness_factor,
+            "contrast_factor": self.contrast_factor,
+            "saturation_factor": self.saturation_factor,
+            "hue_factor": self.hue_factor,
+            "seed": self.seed,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/random_contrast.py

@@ -0,0 +1,149 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.random.seed_generator import SeedGenerator
+
+
+@keras_export("keras.layers.RandomContrast")
+class RandomContrast(BaseImagePreprocessingLayer):
+    """A preprocessing layer which randomly adjusts contrast during training.
+
+    This layer will randomly adjust the contrast of an image or images
+    by a random factor. Contrast is adjusted independently
+    for each channel of each image during training.
+
+    For each channel, this layer computes the mean of the image pixels in the
+    channel and then adjusts each component `x` of each pixel to
+    `(x - mean) * contrast_factor + mean`.
+
+    Input pixel values can be of any range (e.g. `[0., 1.)` or `[0, 255]`) and
+    in integer or floating point dtype.
+    By default, the layer will output floats.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    Input shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., height, width, channels)`, in `"channels_last"` format.
+
+    Output shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., height, width, channels)`, in `"channels_last"` format.
+
+    Args:
+        factor: a positive float represented as fraction of value, or a tuple of
+            size 2 representing lower and upper bound.
+            When represented as a single float, lower = upper.
+            The contrast factor will be randomly picked between
+            `[1.0 - lower, 1.0 + upper]`. For any pixel x in the channel,
+            the output will be `(x - mean) * factor + mean`
+            where `mean` is the mean value of the channel.
+        value_range: the range of values the incoming images will have.
+            Represented as a two-number tuple written `[low, high]`. This is
+            typically either `[0, 1]` or `[0, 255]` depending on how your
+            preprocessing pipeline is set up.
+        seed: Integer. Used to create a random seed.
+    """
+
+    _FACTOR_BOUNDS = (0, 1)
+
+    def __init__(self, factor, value_range=(0, 255), seed=None, **kwargs):
+        super().__init__(**kwargs)
+        self._set_factor(factor)
+        self.value_range = value_range
+        self.seed = seed
+        self.generator = SeedGenerator(seed)
+
+    def get_random_transformation(self, data, training=True, seed=None):
+        if isinstance(data, dict):
+            images = data["images"]
+        else:
+            images = data
+        images_shape = self.backend.shape(images)
+        rank = len(images_shape)
+        if rank == 3:
+            factor_shape = (1, 1, 1)
+        elif rank == 4:
+            # Keep only the batch dim. This will ensure to have same adjustment
+            # with in one image, but different across the images.
+            factor_shape = [images_shape[0], 1, 1, 1]
+        else:
+            raise ValueError(
+                "Expected the input image to be rank 3 or 4. Received "
+                f"inputs.shape={images_shape}"
+            )
+
+        if not training:
+            return {"contrast_factor": self.backend.numpy.zeros(factor_shape)}
+
+        if seed is None:
+            seed = self._get_seed_generator(self.backend._backend)
+
+        factor = self.backend.random.uniform(
+            shape=factor_shape,
+            minval=1.0 - self.factor[0],
+            maxval=1.0 + self.factor[1],
+            seed=seed,
+            dtype=self.compute_dtype,
+        )
+        return {"contrast_factor": factor}
+
+    def transform_images(self, images, transformation, training=True):
+        if training:
+            constrast_factor = transformation["contrast_factor"]
+            outputs = self._adjust_constrast(images, constrast_factor)
+            outputs = self.backend.numpy.clip(
+                outputs, self.value_range[0], self.value_range[1]
+            )
+            self.backend.numpy.reshape(outputs, self.backend.shape(images))
+            return outputs
+        return images
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return segmentation_masks
+
+    def _adjust_constrast(self, inputs, contrast_factor):
+        if self.data_format == "channels_first":
+            height_axis = -2
+            width_axis = -1
+        else:
+            height_axis = -3
+            width_axis = -2
+        # reduce mean on height
+        inp_mean = self.backend.numpy.mean(
+            inputs, axis=height_axis, keepdims=True
+        )
+        # reduce mean on width
+        inp_mean = self.backend.numpy.mean(
+            inp_mean, axis=width_axis, keepdims=True
+        )
+
+        outputs = (inputs - inp_mean) * contrast_factor + inp_mean
+        return outputs
+
+    def compute_output_shape(self, input_shape):
+        return input_shape
+
+    def get_config(self):
+        config = {
+            "factor": self.factor,
+            "value_range": self.value_range,
+            "seed": self.seed,
+        }
+        base_config = super().get_config()
+        return {**base_config, **config}

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/random_crop.py

@@ -0,0 +1,276 @@
+from keras.src import backend
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.layers.preprocessing.image_preprocessing.bounding_boxes.converters import (  # noqa: E501
+    convert_format,
+)
+from keras.src.layers.preprocessing.image_preprocessing.bounding_boxes.validation import (  # noqa: E501
+    densify_bounding_boxes,
+)
+from keras.src.random.seed_generator import SeedGenerator
+
+
+@keras_export("keras.layers.RandomCrop")
+class RandomCrop(BaseImagePreprocessingLayer):
+    """A preprocessing layer which randomly crops images during training.
+
+    During training, this layer will randomly choose a location to crop images
+    down to a target size. The layer will crop all the images in the same batch
+    to the same cropping location.
+
+    At inference time, and during training if an input image is smaller than the
+    target size, the input will be resized and cropped so as to return the
+    largest possible window in the image that matches the target aspect ratio.
+    If you need to apply random cropping at inference time, set `training` to
+    True when calling the layer.
+
+    Input pixel values can be of any range (e.g. `[0., 1.)` or `[0, 255]`) and
+    of integer or floating point dtype. By default, the layer will output
+    floats.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    Input shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., height, width, channels)`, in `"channels_last"` format.
+
+    Output shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., target_height, target_width, channels)`.
+
+    Args:
+        height: Integer, the height of the output shape.
+        width: Integer, the width of the output shape.
+        seed: Integer. Used to create a random seed.
+        **kwargs: Base layer keyword arguments, such as
+            `name` and `dtype`.
+    """
+
+    def __init__(
+        self, height, width, seed=None, data_format=None, name=None, **kwargs
+    ):
+        super().__init__(name=name, **kwargs)
+        self.height = height
+        self.width = width
+        self.seed = (
+            seed if seed is not None else backend.random.make_default_seed()
+        )
+        self.generator = SeedGenerator(seed)
+        self.data_format = backend.standardize_data_format(data_format)
+
+        if self.data_format == "channels_first":
+            self.height_axis = -2
+            self.width_axis = -1
+        elif self.data_format == "channels_last":
+            self.height_axis = -3
+            self.width_axis = -2
+
+        self.supports_masking = False
+        self.supports_jit = False
+        self._convert_input_args = False
+        self._allow_non_tensor_positional_args = True
+
+    def get_random_transformation(self, data, training=True, seed=None):
+        if seed is None:
+            seed = self._get_seed_generator(self.backend._backend)
+
+        if isinstance(data, dict):
+            input_shape = self.backend.shape(data["images"])
+        else:
+            input_shape = self.backend.shape(data)
+
+        input_height, input_width = (
+            input_shape[self.height_axis],
+            input_shape[self.width_axis],
+        )
+        if input_height is None or input_width is None:
+            raise ValueError(
+                "RandomCrop requires the input to have a fully defined "
+                f"height and width. Received: images.shape={input_shape}"
+            )
+
+        if training and input_height > self.height and input_width > self.width:
+            h_start = self.backend.cast(
+                self.backend.random.uniform(
+                    (),
+                    0,
+                    maxval=float(input_height - self.height + 1),
+                    seed=seed,
+                ),
+                "int32",
+            )
+            w_start = self.backend.cast(
+                self.backend.random.uniform(
+                    (),
+                    0,
+                    maxval=float(input_width - self.width + 1),
+                    seed=seed,
+                ),
+                "int32",
+            )
+        else:
+            crop_height = int(float(input_width * self.height) / self.width)
+            crop_height = max(min(input_height, crop_height), 1)
+            crop_width = int(float(input_height * self.width) / self.height)
+            crop_width = max(min(input_width, crop_width), 1)
+            h_start = int(float(input_height - crop_height) / 2)
+            w_start = int(float(input_width - crop_width) / 2)
+
+        return h_start, w_start
+
+    def transform_images(self, images, transformation, training=True):
+        if training:
+            images = self.backend.cast(images, self.compute_dtype)
+            crop_box_hstart, crop_box_wstart = transformation
+            crop_height = self.height
+            crop_width = self.width
+
+            if self.data_format == "channels_last":
+                if len(images.shape) == 4:
+                    images = images[
+                        :,
+                        crop_box_hstart : crop_box_hstart + crop_height,
+                        crop_box_wstart : crop_box_wstart + crop_width,
+                        :,
+                    ]
+                else:
+                    images = images[
+                        crop_box_hstart : crop_box_hstart + crop_height,
+                        crop_box_wstart : crop_box_wstart + crop_width,
+                        :,
+                    ]
+            else:
+                if len(images.shape) == 4:
+                    images = images[
+                        :,
+                        :,
+                        crop_box_hstart : crop_box_hstart + crop_height,
+                        crop_box_wstart : crop_box_wstart + crop_width,
+                    ]
+                else:
+                    images = images[
+                        :,
+                        crop_box_hstart : crop_box_hstart + crop_height,
+                        crop_box_wstart : crop_box_wstart + crop_width,
+                    ]
+
+            shape = self.backend.shape(images)
+            new_height = shape[self.height_axis]
+            new_width = shape[self.width_axis]
+            if (
+                not isinstance(new_height, int)
+                or not isinstance(new_width, int)
+                or new_height != self.height
+                or new_width != self.width
+            ):
+                # Resize images if size mismatch or
+                # if size mismatch cannot be determined
+                # (in the case of a TF dynamic shape).
+                images = self.backend.image.resize(
+                    images,
+                    size=(self.height, self.width),
+                    data_format=self.data_format,
+                )
+                # Resize may have upcasted the outputs
+                images = self.backend.cast(images, self.compute_dtype)
+        return images
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        """
+        bounding_boxes = {
+            "boxes": (batch, num_boxes, 4),  # left-top-right-bottom (xyxy)
+            "labels": (batch, num_boxes, num_classes),
+        }
+        or
+        bounding_boxes = {
+            "boxes": (num_boxes, 4),
+            "labels": (num_boxes, num_classes),
+        }
+        """
+
+        if training:
+            h_start, w_start = transformation
+            if not self.backend.is_tensor(bounding_boxes["boxes"]):
+                bounding_boxes = densify_bounding_boxes(
+                    bounding_boxes, backend=self.backend
+                )
+            boxes = bounding_boxes["boxes"]
+            # Convert to a standard xyxy as operations are done xyxy by default.
+            boxes = convert_format(
+                boxes=boxes,
+                source=self.bounding_box_format,
+                target="xyxy",
+                height=self.height,
+                width=self.width,
+            )
+            h_start = self.backend.cast(h_start, boxes.dtype)
+            w_start = self.backend.cast(w_start, boxes.dtype)
+            if len(self.backend.shape(boxes)) == 3:
+                boxes = self.backend.numpy.stack(
+                    [
+                        self.backend.numpy.maximum(boxes[:, :, 0] - h_start, 0),
+                        self.backend.numpy.maximum(boxes[:, :, 1] - w_start, 0),
+                        self.backend.numpy.maximum(boxes[:, :, 2] - h_start, 0),
+                        self.backend.numpy.maximum(boxes[:, :, 3] - w_start, 0),
+                    ],
+                    axis=-1,
+                )
+            else:
+                boxes = self.backend.numpy.stack(
+                    [
+                        self.backend.numpy.maximum(boxes[:, 0] - h_start, 0),
+                        self.backend.numpy.maximum(boxes[:, 1] - w_start, 0),
+                        self.backend.numpy.maximum(boxes[:, 2] - h_start, 0),
+                        self.backend.numpy.maximum(boxes[:, 3] - w_start, 0),
+                    ],
+                    axis=-1,
+                )
+
+            # Convert to user defined bounding box format
+            boxes = convert_format(
+                boxes=boxes,
+                source="xyxy",
+                target=self.bounding_box_format,
+                height=self.height,
+                width=self.width,
+            )
+
+            return {
+                "boxes": boxes,
+                "labels": bounding_boxes["labels"],
+            }
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return self.transform_images(segmentation_masks, transformation)
+
+    def compute_output_shape(self, input_shape, *args, **kwargs):
+        input_shape = list(input_shape)
+        input_shape[self.height_axis] = self.height
+        input_shape[self.width_axis] = self.width
+        return tuple(input_shape)
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "height": self.height,
+                "width": self.width,
+                "seed": self.seed,
+                "data_format": self.data_format,
+            }
+        )
+        return config

SwarmUI/dlbackend/ComfyUI/venv/lib/python3.10/site-packages/keras/src/layers/preprocessing/image_preprocessing/random_flip.py

@@ -0,0 +1,236 @@
+from keras.src.api_export import keras_export
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    BaseImagePreprocessingLayer,
+)
+from keras.src.layers.preprocessing.image_preprocessing.bounding_boxes.converters import (  # noqa: E501
+    clip_to_image_size,
+)
+from keras.src.layers.preprocessing.image_preprocessing.bounding_boxes.converters import (  # noqa: E501
+    convert_format,
+)
+from keras.src.random.seed_generator import SeedGenerator
+from keras.src.utils import backend_utils
+
+HORIZONTAL = "horizontal"
+VERTICAL = "vertical"
+HORIZONTAL_AND_VERTICAL = "horizontal_and_vertical"
+
+
+@keras_export("keras.layers.RandomFlip")
+class RandomFlip(BaseImagePreprocessingLayer):
+    """A preprocessing layer which randomly flips images during training.
+
+    This layer will flip the images horizontally and or vertically based on the
+    `mode` attribute. During inference time, the output will be identical to
+    input. Call the layer with `training=True` to flip the input.
+    Input pixel values can be of any range (e.g. `[0., 1.)` or `[0, 255]`) and
+    of integer or floating point dtype.
+    By default, the layer will output floats.
+
+    **Note:** This layer is safe to use inside a `tf.data` pipeline
+    (independently of which backend you're using).
+
+    Input shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., height, width, channels)`, in `"channels_last"` format.
+
+    Output shape:
+        3D (unbatched) or 4D (batched) tensor with shape:
+        `(..., height, width, channels)`, in `"channels_last"` format.
+
+    Args:
+        mode: String indicating which flip mode to use. Can be `"horizontal"`,
+            `"vertical"`, or `"horizontal_and_vertical"`. `"horizontal"` is a
+            left-right flip and `"vertical"` is a top-bottom flip. Defaults to
+            `"horizontal_and_vertical"`
+        seed: Integer. Used to create a random seed.
+        **kwargs: Base layer keyword arguments, such as
+            `name` and `dtype`.
+    """
+
+    _USE_BASE_FACTOR = False
+
+    def __init__(
+        self,
+        mode=HORIZONTAL_AND_VERTICAL,
+        seed=None,
+        data_format=None,
+        **kwargs,
+    ):
+        super().__init__(data_format=data_format, **kwargs)
+        self.seed = seed
+        self.generator = SeedGenerator(seed)
+        self.mode = mode
+        self._convert_input_args = False
+        self._allow_non_tensor_positional_args = True
+
+    def get_random_transformation(self, data, training=True, seed=None):
+        if not training:
+            return None
+
+        if isinstance(data, dict):
+            images = data["images"]
+        else:
+            images = data
+        shape = self.backend.core.shape(images)
+        if len(shape) == 3:
+            flips_shape = (1, 1, 1)
+        else:
+            flips_shape = (shape[0], 1, 1, 1)
+
+        if seed is None:
+            seed = self._get_seed_generator(self.backend._backend)
+
+        flips = self.backend.numpy.less_equal(
+            self.backend.random.uniform(shape=flips_shape, seed=seed), 0.5
+        )
+        return {"flips": flips, "input_shape": shape}
+
+    def transform_images(self, images, transformation, training=True):
+        images = self.backend.cast(images, self.compute_dtype)
+        if training:
+            return self._flip_inputs(images, transformation)
+        return images
+
+    def transform_labels(self, labels, transformation, training=True):
+        return labels
+
+    def transform_bounding_boxes(
+        self,
+        bounding_boxes,
+        transformation,
+        training=True,
+    ):
+        def _flip_boxes_horizontal(boxes):
+            x1, x2, x3, x4 = self.backend.numpy.split(boxes, 4, axis=-1)
+            outputs = self.backend.numpy.concatenate(
+                [1 - x3, x2, 1 - x1, x4], axis=-1
+            )
+            return outputs
+
+        def _flip_boxes_vertical(boxes):
+            x1, x2, x3, x4 = self.backend.numpy.split(boxes, 4, axis=-1)
+            outputs = self.backend.numpy.concatenate(
+                [x1, 1 - x4, x3, 1 - x2], axis=-1
+            )
+            return outputs
+
+        def _transform_xyxy(boxes, box_flips):
+            bboxes = boxes["boxes"]
+            if self.mode in {HORIZONTAL, HORIZONTAL_AND_VERTICAL}:
+                bboxes = self.backend.numpy.where(
+                    box_flips,
+                    _flip_boxes_horizontal(bboxes),
+                    bboxes,
+                )
+            if self.mode in {VERTICAL, HORIZONTAL_AND_VERTICAL}:
+                bboxes = self.backend.numpy.where(
+                    box_flips,
+                    _flip_boxes_vertical(bboxes),
+                    bboxes,
+                )
+            return bboxes
+
+        if training:
+            if backend_utils.in_tf_graph():
+                self.backend.set_backend("tensorflow")
+
+            flips = self.backend.numpy.squeeze(transformation["flips"], axis=-1)
+
+            if self.data_format == "channels_first":
+                height_axis = -2
+                width_axis = -1
+            else:
+                height_axis = -3
+                width_axis = -2
+
+            input_height, input_width = (
+                transformation["input_shape"][height_axis],
+                transformation["input_shape"][width_axis],
+            )
+
+            bounding_boxes = convert_format(
+                bounding_boxes,
+                source=self.bounding_box_format,
+                target="rel_xyxy",
+                height=input_height,
+                width=input_width,
+            )
+
+            bounding_boxes["boxes"] = _transform_xyxy(bounding_boxes, flips)
+
+            bounding_boxes = clip_to_image_size(
+                bounding_boxes=bounding_boxes,
+                height=input_height,
+                width=input_width,
+                bounding_box_format="xyxy",
+            )
+
+            bounding_boxes = convert_format(
+                bounding_boxes,
+                source="rel_xyxy",
+                target=self.bounding_box_format,
+                height=input_height,
+                width=input_width,
+            )
+
+            self.backend.reset()
+
+        return bounding_boxes
+
+    def transform_segmentation_masks(
+        self, segmentation_masks, transformation, training=True
+    ):
+        return self.transform_images(
+            segmentation_masks, transformation, training=training
+        )
+
+    def _flip_inputs(self, inputs, transformation):
+        if transformation is None:
+            return inputs
+
+        flips = transformation["flips"]
+        inputs_shape = self.backend.shape(inputs)
+        unbatched = len(inputs_shape) == 3
+        if unbatched:
+            inputs = self.backend.numpy.expand_dims(inputs, axis=0)
+
+        flipped_outputs = inputs
+        if self.data_format == "channels_last":
+            horizontal_axis = -2
+            vertical_axis = -3
+        else:
+            horizontal_axis = -1
+            vertical_axis = -2
+
+        if self.mode == HORIZONTAL or self.mode == HORIZONTAL_AND_VERTICAL:
+            flipped_outputs = self.backend.numpy.where(
+                flips,
+                self.backend.numpy.flip(flipped_outputs, axis=horizontal_axis),
+                flipped_outputs,
+            )
+        if self.mode == VERTICAL or self.mode == HORIZONTAL_AND_VERTICAL:
+            flipped_outputs = self.backend.numpy.where(
+                flips,
+                self.backend.numpy.flip(flipped_outputs, axis=vertical_axis),
+                flipped_outputs,
+            )
+        if unbatched:
+            flipped_outputs = self.backend.numpy.squeeze(
+                flipped_outputs, axis=0
+            )
+        return flipped_outputs
+
+    def compute_output_shape(self, input_shape):
+        return input_shape
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "seed": self.seed,
+                "mode": self.mode,
+                "data_format": self.data_format,
+            }
+        )
+        return config