keras-hub-nightly 0.16.1.dev202409250340__py3-none-any.whl → 0.16.1.dev202409260340__py3-none-any.whl

keras_hub/src/models/text_to_image.py

@@ -0,0 +1,295 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import itertools
+from functools import partial
+
+import keras
+from keras import ops
+from keras import random
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.task import Task
+
+try:
+    import tensorflow as tf
+except ImportError:
+    tf = None
+
+
+@keras_hub_export("keras_hub.models.TextToImage")
+class TextToImage(Task):
+    """Base class for text-to-image tasks.
+
+    `TextToImage` tasks wrap a `keras_hub.models.Backbone` and
+    a `keras_hub.models.Preprocessor` to create a model that can be used for
+    generation and generative fine-tuning.
+
+    `TextToImage` tasks provide an additional, high-level `generate()` function
+    which can be used to generate image by token with a string in, image out
+    signature.
+
+    All `TextToImage` tasks include a `from_preset()` constructor which can be
+    used to load a pre-trained config and weights.
+
+    Example:
+
+    ```python
+    # Load a Stable Diffusion 3 backbone with pre-trained weights.
+    text_to_image = keras_hub.models.TextToImage.from_preset(
+        "stable_diffusion_3_medium",
+    )
+    text_to_image.generate(
+        "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
+    )
+
+    # Load a Stable Diffusion 3 backbone at bfloat16 precision.
+    text_to_image = keras_hub.models.TextToImage.from_preset(
+        "stable_diffusion_3_medium",
+        dtype="bfloat16",
+    )
+    text_to_image.generate(
+        "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
+    )
+    ```
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Default compilation.
+        self.compile()
+
+    @property
+    def latent_shape(self):
+        return tuple(self.backbone.latent_shape)
+
+    def compile(
+        self,
+        optimizer="auto",
+        loss="auto",
+        *,
+        metrics="auto",
+        **kwargs,
+    ):
+        """Configures the `TextToImage` task for training.
+
+        The `TextToImage` task extends the default compilation signature of
+        `keras.Model.compile` with defaults for `optimizer`, `loss`, and
+        `metrics`. To override these defaults, pass any value
+        to these arguments during compilation.
+
+        Args:
+            optimizer: `"auto"`, an optimizer name, or a `keras.Optimizer`
+                instance. Defaults to `"auto"`, which uses the default optimizer
+                for the given model and task. See `keras.Model.compile` and
+                `keras.optimizers` for more info on possible `optimizer` values.
+            loss: `"auto"`, a loss name, or a `keras.losses.Loss` instance.
+                Defaults to `"auto"`, where a
+                `keras.losses.MeanSquaredError` loss will be applied. See
+                `keras.Model.compile` and `keras.losses` for more info on
+                possible `loss` values.
+            metrics: `"auto"`, or a list of metrics to be evaluated by
+                the model during training and testing. Defaults to `"auto"`,
+                where a `keras.metrics.MeanSquaredError` will be applied to
+                track the loss of the model during training. See
+                `keras.Model.compile` and `keras.metrics` for more info on
+                possible `metrics` values.
+            **kwargs: See `keras.Model.compile` for a full list of arguments
+                supported by the compile method.
+        """
+        # Ref: https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image.py#L410-L414
+        if optimizer == "auto":
+            optimizer = keras.optimizers.AdamW(
+                1e-4, weight_decay=1e-2, epsilon=1e-8, clipnorm=1.0
+            )
+        if loss == "auto":
+            loss = keras.losses.MeanSquaredError()
+        if metrics == "auto":
+            metrics = [keras.metrics.MeanSquaredError()]
+        super().compile(
+            optimizer=optimizer,
+            loss=loss,
+            metrics=metrics,
+            **kwargs,
+        )
+        self.generate_function = None
+
+    def generate_step(self, *args, **kwargs):
+        """Run generation on batches of input."""
+        raise NotImplementedError
+
+    def make_generate_function(self):
+        """Create or return the compiled generation function."""
+        if self.generate_function is not None:
+            return self.generate_function
+
+        self.generate_function = self.generate_step
+        if keras.config.backend() == "torch":
+            import torch
+
+            def wrapped_function(*args, **kwargs):
+                with torch.no_grad():
+                    return self.generate_step(*args, **kwargs)
+
+            self.generate_function = wrapped_function
+        elif keras.config.backend() == "tensorflow" and not self.run_eagerly:
+            self.generate_function = tf.function(
+                self.generate_step, jit_compile=self.jit_compile
+            )
+        elif keras.config.backend() == "jax" and not self.run_eagerly:
+            import jax
+
+            @partial(jax.jit)
+            def compiled_function(state, *args, **kwargs):
+                (
+                    trainable_variables,
+                    non_trainable_variables,
+                ) = state
+                mapping = itertools.chain(
+                    zip(self.trainable_variables, trainable_variables),
+                    zip(self.non_trainable_variables, non_trainable_variables),
+                )
+
+                with keras.StatelessScope(state_mapping=mapping):
+                    outputs = self.generate_step(*args, **kwargs)
+                return outputs
+
+            def wrapped_function(*args, **kwargs):
+                # Create an explicit tuple of all variable state.
+                state = (
+                    # Use the explicit variable.value to preserve the
+                    # sharding spec of distribution.
+                    [v.value for v in self.trainable_variables],
+                    [v.value for v in self.non_trainable_variables],
+                )
+                outputs = compiled_function(state, *args, **kwargs)
+                return outputs
+
+            self.generate_function = wrapped_function
+        return self.generate_function
+
+    def _normalize_generate_inputs(self, inputs):
+        """Normalize user input to the generate function.
+
+        This function converts all inputs to tensors, adds a batch dimension if
+        necessary, and returns a iterable "dataset like" object (either an
+        actual `tf.data.Dataset` or a list with a single batch element).
+        """
+        if tf and isinstance(inputs, tf.data.Dataset):
+            return inputs.as_numpy_iterator(), False
+
+        def normalize(x):
+            if isinstance(x, str):
+                return [x], True
+            if tf and isinstance(x, tf.Tensor) and x.shape.rank == 0:
+                return x[tf.newaxis], True
+            return x, False
+
+        if isinstance(inputs, dict):
+            for key in inputs:
+                inputs[key], input_is_scalar = normalize(inputs[key])
+        else:
+            inputs, input_is_scalar = normalize(inputs)
+
+        return inputs, input_is_scalar
+
+    def _normalize_generate_outputs(self, outputs, input_is_scalar):
+        """Normalize user output from the generate function.
+
+        This function converts all output to numpy with a value range of
+        `[0, 255]`. If a batch dimension was added to the input, it is removed
+        from the output.
+        """
+
+        def normalize(x):
+            outputs = ops.clip(ops.divide(ops.add(x, 1.0), 2.0), 0.0, 1.0)
+            outputs = ops.cast(ops.round(ops.multiply(outputs, 255.0)), "uint8")
+            outputs = ops.convert_to_numpy(outputs)
+            if input_is_scalar:
+                outputs = outputs[0]
+            return outputs
+
+        if isinstance(outputs[0], dict):
+            normalized = {}
+            for key in outputs[0]:
+                normalized[key] = normalize([x[key] for x in outputs])
+            return normalized
+        return normalize([x for x in outputs])
+
+    def generate(
+        self,
+        inputs,
+        negative_inputs,
+        num_steps,
+        guidance_scale,
+        seed=None,
+    ):
+        """Generate image based on the provided `inputs` and `negative_inputs`.
+
+        If `inputs` are a `tf.data.Dataset`, outputs will be generated
+        "batch-by-batch" and concatenated. Otherwise, all inputs will be
+        processed as batches.
+
+        Args:
+            inputs: python data, tensor data, or a `tf.data.Dataset`.
+            negative_inputs: python data, tensor data, or a `tf.data.Dataset`.
+                Unlike `inputs`, these are used as negative inputs to guide the
+                generation. If not provided, it defaults to `""` for each input
+                in `inputs`.
+            num_steps: int. The number of diffusion steps to take.
+            guidance_scale: float. The classifier free guidance scale defined in
+                [Classifier-Free Diffusion Guidance](
+                https://arxiv.org/abs/2207.12598). A higher scale encourages
+                generating images more closely related to the prompts, typically
+                at the cost of lower image quality.
+            seed: optional int. Used as a random seed.
+        """
+        num_steps = ops.convert_to_tensor(num_steps, "int32")
+        guidance_scale = ops.convert_to_tensor(guidance_scale)
+
+        # Setup our three main passes.
+        # 1. Preprocessing strings to dense integer tensors.
+        # 2. Generate outputs via a compiled function on dense tensors.
+        # 3. Postprocess dense tensors to a value range of `[0, 255]`.
+        generate_function = self.make_generate_function()
+
+        def preprocess(x):
+            return self.preprocessor.generate_preprocess(x)
+
+        # Normalize and preprocess inputs.
+        inputs, input_is_scalar = self._normalize_generate_inputs(inputs)
+        if negative_inputs is None:
+            negative_inputs = [""] * len(inputs)
+        negative_inputs, _ = self._normalize_generate_inputs(negative_inputs)
+
+        if self.preprocessor is not None:
+            inputs = preprocess(inputs)
+            negative_inputs = preprocess(negative_inputs)
+        if isinstance(inputs, dict):
+            batch_size = len(inputs[list(inputs.keys())[0]])
+        else:
+            batch_size = len(inputs)
+
+        # Initialize random latents.
+        latent_shape = (batch_size,) + self.latent_shape[1:]
+        latents = random.normal(latent_shape, dtype="float32", seed=seed)
+
+        # Text-to-image.
+        outputs = generate_function(
+            latents,
+            inputs,
+            negative_inputs,
+            num_steps,
+            guidance_scale,
+        )
+        return self._normalize_generate_outputs(outputs, input_is_scalar)

keras_hub/src/utils/timm/convert_densenet.py

@@ -0,0 +1,107 @@
+# Copyright 2024 The KerasHUB Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import numpy as np
+
+from keras_hub.src.models.densenet.densenet_backbone import DenseNetBackbone
+
+backbone_cls = DenseNetBackbone
+
+
+def convert_backbone_config(timm_config):
+    timm_architecture = timm_config["architecture"]
+
+    if timm_architecture == "densenet121":
+        stackwise_num_repeats = [6, 12, 24, 16]
+    elif timm_architecture == "densenet169":
+        stackwise_num_repeats = [6, 12, 32, 32]
+    elif timm_architecture == "densenet201":
+        stackwise_num_repeats = [6, 12, 48, 32]
+    else:
+        raise ValueError(
+            f"Currently, the architecture {timm_architecture} is not supported."
+        )
+    return dict(
+        stackwise_num_repeats=stackwise_num_repeats,
+        compression_ratio=0.5,
+        growth_rate=32,
+    )
+
+
+def convert_weights(backbone, loader, timm_config):
+    def port_conv2d(keras_layer_name, hf_weight_prefix):
+        loader.port_weight(
+            backbone.get_layer(keras_layer_name).kernel,
+            hf_weight_key=f"{hf_weight_prefix}.weight",
+            hook_fn=lambda x, _: np.transpose(x, (2, 3, 1, 0)),
+        )
+
+    def port_batch_normalization(keras_layer_name, hf_weight_prefix):
+        loader.port_weight(
+            backbone.get_layer(keras_layer_name).gamma,
+            hf_weight_key=f"{hf_weight_prefix}.weight",
+        )
+        loader.port_weight(
+            backbone.get_layer(keras_layer_name).beta,
+            hf_weight_key=f"{hf_weight_prefix}.bias",
+        )
+        loader.port_weight(
+            backbone.get_layer(keras_layer_name).moving_mean,
+            hf_weight_key=f"{hf_weight_prefix}.running_mean",
+        )
+        loader.port_weight(
+            backbone.get_layer(keras_layer_name).moving_variance,
+            hf_weight_key=f"{hf_weight_prefix}.running_var",
+        )
+
+    # Stem
+    port_conv2d("conv1_conv", "features.conv0")
+    port_batch_normalization("conv1_bn", "features.norm0")
+
+    # Stages
+    num_stacks = len(backbone.stackwise_num_repeats)
+    for stack_index in range(num_stacks):
+        for block_idx in range(backbone.stackwise_num_repeats[stack_index]):
+            keras_name = f"stack{stack_index+1}_block{block_idx+1}"
+            hf_name = (
+                f"features.denseblock{stack_index+1}.denselayer{block_idx+1}"
+            )
+            port_batch_normalization(f"{keras_name}_1_bn", f"{hf_name}.norm1")
+            port_conv2d(f"{keras_name}_1_conv", f"{hf_name}.conv1")
+            port_batch_normalization(f"{keras_name}_2_bn", f"{hf_name}.norm2")
+            port_conv2d(f"{keras_name}_2_conv", f"{hf_name}.conv2")
+
+    for stack_index in range(num_stacks - 1):
+        keras_transition_name = f"transition{stack_index+1}"
+        hf_transition_name = f"features.transition{stack_index+1}"
+        port_batch_normalization(
+            f"{keras_transition_name}_bn", f"{hf_transition_name}.norm"
+        )
+        port_conv2d(
+            f"{keras_transition_name}_conv", f"{hf_transition_name}.conv"
+        )
+
+    # Post
+    port_batch_normalization("bn", "features.norm5")
+
+
+def convert_head(task, loader, timm_config):
+    loader.port_weight(
+        task.output_dense.kernel,
+        hf_weight_key="classifier.weight",
+        hook_fn=lambda x, _: np.transpose(np.squeeze(x)),
+    )
+    loader.port_weight(
+        task.output_dense.bias,
+        hf_weight_key="classifier.bias",
+    )

keras_hub/src/utils/timm/preset_loader.py

@@ -16,6 +16,7 @@
 from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.utils.preset_utils import PresetLoader
 from keras_hub.src.utils.preset_utils import jax_memory_cleanup
+from keras_hub.src.utils.timm import convert_densenet
 from keras_hub.src.utils.timm import convert_resnet
 from keras_hub.src.utils.transformers.safetensor_utils import SafetensorLoader
 
@@ -26,6 +27,8 @@ class TimmPresetLoader(PresetLoader):
         architecture = self.config["architecture"]
         if "resnet" in architecture:
             self.converter = convert_resnet
+        if "densenet" in architecture:
+            self.converter = convert_densenet
         else:
             raise ValueError(
                 "KerasHub has no converter for timm models "

keras_hub/src/version_utils.py

@@ -15,7 +15,7 @@
 from keras_hub.src.api_export import keras_hub_export
 
 # Unique source of truth for the version number.
-__version__ = "0.16.1.dev202409250340"
+__version__ = "0.16.1.dev202409260340"
 
 
 @keras_hub_export("keras_hub.version")

{keras_hub_nightly-0.16.1.dev202409250340.dist-info → keras_hub_nightly-0.16.1.dev202409260340.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: keras-hub-nightly
-Version: 0.16.1.dev202409250340
+Version: 0.16.1.dev202409260340
 Summary: Industry-strength Natural Language Processing extensions for Keras.
 Home-page: https://github.com/keras-team/keras-hub
 Author: Keras team

{keras_hub_nightly-0.16.1.dev202409250340.dist-info → keras_hub_nightly-0.16.1.dev202409260340.dist-info}/RECORD

@@ -1,15 +1,15 @@
 keras_hub/__init__.py,sha256=La-s5SQDd0312puWDSbPJ2XYxFXtg0jsCdUa2LMY-Z8,1440
 keras_hub/api/__init__.py,sha256=8EwhEBO-o-92lvGv6M5zOdkNL9Bd3xfutlfGNJ8QwBE,1109
 keras_hub/api/bounding_box/__init__.py,sha256=LNSVZLB1WJ9hMg0wxt7HTfFFd9uAFviH9x9CnfJYzBA,1682
-keras_hub/api/layers/__init__.py,sha256=q-W0iSlSnbanCmfeXEfnzeM2Z_akIf0o0wXGI9eoXK4,2742
+keras_hub/api/layers/__init__.py,sha256=40siZktbh1Xw7FjvdrPlW_srr0gNzB-a4N8_VdMh-WQ,2841
 keras_hub/api/metrics/__init__.py,sha256=tgQfooPHzlq6w34RHfro6vO8IUITLTf-jU2IWEBxxUM,966
-keras_hub/api/models/__init__.py,sha256=FzHm8wzz4zFS9o47h74wZqD543M-YBpJBbg0MxVXrPQ,13597
+keras_hub/api/models/__init__.py,sha256=BekXaBeF9KTcEEqLkYNCy-45nqpc6OkULiELb4FwUSo,14372
 keras_hub/api/samplers/__init__.py,sha256=l56H4y3h_HlRn_PpeMyZ6vC7228EH_BVFo4Caay-zQ8,1315
-keras_hub/api/tokenizers/__init__.py,sha256=nzMwKmxkMCOiYB35BIgxHNveCM9WoYRp7ChhmVK8MIM,3042
+keras_hub/api/tokenizers/__init__.py,sha256=skXkmjQrm-0BxT4V0bLO97FUXS1xdmC71RCO7yAZ3C0,3109
 keras_hub/api/utils/__init__.py,sha256=4IXDgmXqFzqrCK2MPgkih0Ye1s-8hrlBaUk-n5Kqwl4,800
 keras_hub/src/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
 keras_hub/src/api_export.py,sha256=82JzmDgnWTJR-PRJI9L_vjhW2Svz8gilbE1NMGZ2JgA,2085
-keras_hub/src/version_utils.py,sha256=DfqQUnCphubGoSlfFEJS5b7zQfHnTOCqwLSi0WgDvfI,808
+keras_hub/src/version_utils.py,sha256=VLABG9MV5PbD192g7QxqZpMVhvkPMYTB9JRjALW0Yeo,808
 keras_hub/src/bounding_box/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
 keras_hub/src/bounding_box/converters.py,sha256=V2ti6xPpaBgeLKbTpCsHsABdYOYASerIKX9oWqeOjHo,18450
 keras_hub/src/bounding_box/formats.py,sha256=5bbHO-n2ADsKIOBJDHMvIPCeNBaV1_mj-NVCgBKNiu8,4453
@@ -65,6 +65,7 @@ keras_hub/src/models/seq_2_seq_lm_preprocessor.py,sha256=fQv-zg7vvIpy3ucCbIkiey8
 keras_hub/src/models/task.py,sha256=elkNVXUAbUskRprIBmTDiJkFheLo1mLTX9lppelHucc,14432
 keras_hub/src/models/text_classifier.py,sha256=BhsLovKyIVslm4ibrzFqtxrqljyNehk1lTpQ-r3bq5k,4744
 keras_hub/src/models/text_classifier_preprocessor.py,sha256=6Mkypx3UUj4gUmLlocaLZBc2Addk_pshKPWwy7wb788,5307
+keras_hub/src/models/text_to_image.py,sha256=6cNGcbRAooBmMoDJzPUzbHGipAIW03GOxN0b93PGU_g,11377
 keras_hub/src/models/albert/__init__.py,sha256=RuIE1aGly5hA0OHBu_QA09XairoViM1kvS6K3kzVB3Q,843
 keras_hub/src/models/albert/albert_backbone.py,sha256=MNurFI3ansonMPJi8gmRf0dXwMwE38C-DJzqdkuLs9o,10659
 keras_hub/src/models/albert/albert_masked_lm.py,sha256=Y8N5HqQ3fUl4lUG4T_vbn_zI-Pink8oDFRKlxfGm6S8,4712
@@ -95,6 +96,11 @@ keras_hub/src/models/bloom/bloom_causal_lm_preprocessor.py,sha256=WVTWRUbQXUBlfC
 keras_hub/src/models/bloom/bloom_decoder.py,sha256=hSoeVnwRQvGbpVhYmf7-k8FB3Wg4auwZWdr2ubiNtxc,7157
 keras_hub/src/models/bloom/bloom_presets.py,sha256=7GiGFPmcXd_UraNsWGQffpzjKDRF-7nqIoUsic78xf0,4696
 keras_hub/src/models/bloom/bloom_tokenizer.py,sha256=ZMx8mHhw0D50zmmvYdmpg-Lk2GcvHz7pPlRpPlhS_2s,3161
+keras_hub/src/models/clip/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
+keras_hub/src/models/clip/clip_encoder_block.py,sha256=c6gyxHA6f23I_kZpaZkyercJCK7gkDWebiIbRUJyE88,3793
+keras_hub/src/models/clip/clip_preprocessor.py,sha256=e1c44Qy4ZIqhGBehpMokVzI7AtZaaFqrfrbNFSN2ad8,5337
+keras_hub/src/models/clip/clip_text_encoder.py,sha256=bvjUoJUunmEX-PMJWb2rZEA34_okoGCpChqZRBx5HE0,5912
+keras_hub/src/models/clip/clip_tokenizer.py,sha256=XYXUS5eyPMQr8OBDWHSvqyrUqluLaIXF62rrHRAqCNM,7671
 keras_hub/src/models/csp_darknet/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
 keras_hub/src/models/csp_darknet/csp_darknet_backbone.py,sha256=h0eua1EZP0vBV416uOVMmMP1JXy7cVoEj0JEO0OO_lc,14312
 keras_hub/src/models/csp_darknet/csp_darknet_image_classifier.py,sha256=qLav7bxuzB0oaNJLs8gIiQbQVFjAlteDT7WKRfKoSmk,4355
@@ -109,9 +115,12 @@ keras_hub/src/models/deberta_v3/deberta_v3_tokenizer.py,sha256=NLLkMvotpPZUdRELa
 keras_hub/src/models/deberta_v3/disentangled_attention_encoder.py,sha256=Zt10UPxYsr_x8isO_OrXeaquWVJbcE49raM6_BkDdEs,9142
 keras_hub/src/models/deberta_v3/disentangled_self_attention.py,sha256=MxpWy30h9JB8nlEk7V9_wETzP-tpv1Sd1Wiz_pHGpkI,13708
 keras_hub/src/models/deberta_v3/relative_embedding.py,sha256=QT5MAnheJ1wSKFeN49pdnZzWkztz5K2oYYuNEtB_5xM,3472
-keras_hub/src/models/densenet/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
-keras_hub/src/models/densenet/densenet_backbone.py,sha256=BbTecC7gfigSC3t4L-kGsZHS7pjj8DtDIztyMxo_AoI,7238
-keras_hub/src/models/densenet/densenet_image_classifier.py,sha256=eECPZKHycVHNbgFuBHyiZGPWBn0M_pBdLasjmroc95g,4303
+keras_hub/src/models/densenet/__init__.py,sha256=GV_UHqkQ4TOVBkKKUGioA63O7QWBbHBEQqdHuXyK0TA,855
+keras_hub/src/models/densenet/densenet_backbone.py,sha256=2M3g7xxLMXbMpIGTvUQs6Bg4W6HdKKUkmJC8ZFg5DJc,7308
+keras_hub/src/models/densenet/densenet_image_classifier.py,sha256=e92FdUitdYfxVlRK06Tpk18CGlQz1Sqzsz47yjnClwM,5327
+keras_hub/src/models/densenet/densenet_image_classifier_preprocessor.py,sha256=83OcsZp2RZ626YGQ99roR8RKArlink-6VsUqwlv7L_s,1148
+keras_hub/src/models/densenet/densenet_image_converter.py,sha256=oynHnALbasOWF0f4iYbJPyfYQ8_u0oSZAK8-zSdG7kM,973
+keras_hub/src/models/densenet/densenet_presets.py,sha256=RypneRdDz0OlsRidmjh03gWalre7MlrHNOce97PLEjw,2119
 keras_hub/src/models/distil_bert/__init__.py,sha256=EiJUA3y_b22rMacMbBD7jD0eBSzR-wbVtF73k2RsQow,889
 keras_hub/src/models/distil_bert/distil_bert_backbone.py,sha256=ZW2OgNlWXeRlfI5BrcJLYr4Oc2qNJZoDxjoL7-cGuIQ,7027
 keras_hub/src/models/distil_bert/distil_bert_masked_lm.py,sha256=1BFS1At_HYlLK21VWyhQPrPtActpmR52A8LJG2c6N8Y,4862
@@ -248,21 +257,19 @@ keras_hub/src/models/sam/sam_layers.py,sha256=6A4H2qiJSmpSUjp0xwaGzhQeAAUWi-lsET
 keras_hub/src/models/sam/sam_mask_decoder.py,sha256=Iwq9-YQYVXtFXg7fUnu0BRyUMS6D_56AV2IOCVdlGb8,10135
 keras_hub/src/models/sam/sam_prompt_encoder.py,sha256=rUinjN0yI8h6ewA_n0GWMJAg5FszS0x25ADdKiGAaBA,12387
 keras_hub/src/models/sam/sam_transformer.py,sha256=V3UfDYldxXVW2jngVUS9Klu7HXwKf5ROfpTm3fPEtOo,6316
-keras_hub/src/models/stable_diffusion_v3/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
-keras_hub/src/models/stable_diffusion_v3/clip_encoder_block.py,sha256=6-bOVTGHCSniDYf616UhKmDHM239y8J5wdjZATXgxig,3556
-keras_hub/src/models/stable_diffusion_v3/clip_preprocessor.py,sha256=90QYFvAlSk_F1HC80VG6IceVN0Q8paIHZQpbaG2pMec,3172
-keras_hub/src/models/stable_diffusion_v3/clip_text_encoder.py,sha256=hVL3DaoYOTYd3bi0PUoKcMJTFxvsMwQ905uS7Ol__DU,5233
-keras_hub/src/models/stable_diffusion_v3/clip_tokenizer.py,sha256=5CdplYY3L50tgEflJep2VjjVjlLz-JMmobGd6QnyI6I,6296
-keras_hub/src/models/stable_diffusion_v3/mmdit.py,sha256=wlH6x9bS6gL3SsuiTpF541_2bwtrCOnUQIdPPavXCV0,14596
-keras_hub/src/models/stable_diffusion_v3/mmdit_block.py,sha256=xY-iqzIHb_h_nzzuQKDbbjPi3738A8XlL3nIGc5Taas,10877
-keras_hub/src/models/stable_diffusion_v3/t5_xxl_preprocessor.py,sha256=Liu6yg4ipCoisx0MGhJZvJTpOedl12NxxeBZtgrc0vs,2645
-keras_hub/src/models/stable_diffusion_v3/t5_xxl_text_encoder.py,sha256=xiK82Z4ioTEpgJre8YQ_8GkrwFNsbyxYurmTUDCrweU,5735
-keras_hub/src/models/stable_diffusion_v3/vae_attention.py,sha256=YQpVu4NaySi2pgczD-lru_jUYHg6YBxjDZvyclJ4T1s,4189
-keras_hub/src/models/stable_diffusion_v3/vae_image_decoder.py,sha256=ww6s-h4YjNKdRhv9bv9Gx2UA1JYOjn54IDAWFtjLO1Y,5879
+keras_hub/src/models/stable_diffusion_3/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
+keras_hub/src/models/stable_diffusion_3/flow_match_euler_discrete_scheduler.py,sha256=6zxybuut0DNIAUdGO8CPoRn2iZyWrGjYtR6AkqNmWns,3412
+keras_hub/src/models/stable_diffusion_3/mmdit.py,sha256=aVXnQcRpiJ5XnGQxF9gHfIdKGkErmVPfmsNFnjVLm04,26296
+keras_hub/src/models/stable_diffusion_3/stable_diffusion_3_backbone.py,sha256=4mZoMDIX7Soy5EPgA-oY2HBy6_z1CjD4jclgsdGJkQY,22577
+keras_hub/src/models/stable_diffusion_3/stable_diffusion_3_text_to_image.py,sha256=pxS-JcF1eut6ufSrsXsJcE_74ELsEOeFKdbe_xDAhqk,5004
+keras_hub/src/models/stable_diffusion_3/stable_diffusion_3_text_to_image_preprocessor.py,sha256=3U-su-hUi5BP6biQdZs0MllxTPa1FLE6azCC0d3sA5E,2736
+keras_hub/src/models/stable_diffusion_3/t5_encoder.py,sha256=XlGkQrBThiPk6fCgONNYafIz68INeBlgOTuKKQWiyzk,5698
+keras_hub/src/models/stable_diffusion_3/vae_image_decoder.py,sha256=rmza741siiDXPE80pzdY4hPiUPoRu7sMj5OeI0t1lFo,10641
 keras_hub/src/models/t5/__init__.py,sha256=1XZ5_R-qymPE1M1IyTqyNAW6_sWn8viJGXjqzB61sFw,819
 keras_hub/src/models/t5/t5_backbone.py,sha256=y_gEISm9CxL_1goJLwR-moAxS-bzxNNcdL__w7e8Isw,10844
 keras_hub/src/models/t5/t5_layer_norm.py,sha256=lVP_6IajHf8kX0APzGNdSZa-8IkkzsiLy5VcKOGhtkg,1216
 keras_hub/src/models/t5/t5_multi_head_attention.py,sha256=ToRrHmJKiTJ2F8jF1HIgHCagme7MSxn9FIQGEXlH3Vo,12445
+keras_hub/src/models/t5/t5_preprocessor.py,sha256=r7dJslXSimw05Azyw6_3xXpMpIsvPn0yhXXowHlJTWM,2838
 keras_hub/src/models/t5/t5_presets.py,sha256=2RT_NuJcqDdSeAsoSJXh5O_ax2H-s4YKTAoYErVPwPQ,3590
 keras_hub/src/models/t5/t5_tokenizer.py,sha256=UnmZjiKhyb4AU7zALW3YAM_6_OGzYOVEGStBiw4ICvg,3103
 keras_hub/src/models/t5/t5_transformer_layer.py,sha256=wnu108InkHH9YMmFNTbmgIqcrKQQUxeJ7S1dcjUfBSY,5933
@@ -322,8 +329,9 @@ keras_hub/src/utils/tensor_utils.py,sha256=XpWORE8iUzHXv1E1akiYDep07ndZJRKvjsKVl
 keras_hub/src/utils/imagenet/__init__.py,sha256=AK2s8L-VARI5OmlT6G3vtlKIVyjwLfgVwXfxzhhSCq4,585
 keras_hub/src/utils/imagenet/imagenet_utils.py,sha256=0iHrAQbh5DCa9Dh7tJiQeJc7AGzNO7j0cFEWS2Of16w,39889
 keras_hub/src/utils/timm/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
+keras_hub/src/utils/timm/convert_densenet.py,sha256=RqPlE0J7iXgcjyAPEfLLMGIKvmGs3QJQlYNTFrhOLKM,3927
 keras_hub/src/utils/timm/convert_resnet.py,sha256=X2N9lk8sqRMzOMXkcIThAu6ZEtw8u8_Y4Kol82iTuW4,6417
-keras_hub/src/utils/timm/preset_loader.py,sha256=ac2PwGkfe-bikhQEFeIM25gDs3xk0E9SS5A1YEzZYQU,3602
+keras_hub/src/utils/timm/preset_loader.py,sha256=e3r25uoMqtMzSopLE9-NQvg97PYWW-8GvxmnC0Dinao,3741
 keras_hub/src/utils/transformers/__init__.py,sha256=lY7spwqXeGX_75qOHiSCff7FPvFCvRamJMF5ua9OWCg,585
 keras_hub/src/utils/transformers/convert_albert.py,sha256=7b9X1TLrWfHieoeX_K-EXTagkl4Rp9AfPjsPrwArBGY,8280
 keras_hub/src/utils/transformers/convert_bart.py,sha256=RXmPf_XUZrUyqDaOV9T7qVNEP4rAVR44oK1aRZI0v78,14996
@@ -336,7 +344,7 @@ keras_hub/src/utils/transformers/convert_mistral.py,sha256=4QStizMS6ESEPjSI-ls6j
 keras_hub/src/utils/transformers/convert_pali_gemma.py,sha256=BT5eX1QzbjCQCopbMstiejQQWQiB_N77bpD5FMUygEo,11234
 keras_hub/src/utils/transformers/preset_loader.py,sha256=9x9hLhDh_6PAHG5gay5rVoEVyt-gXTQGrnprjMLKvCM,3294
 keras_hub/src/utils/transformers/safetensor_utils.py,sha256=2O8lcCf9yIFt5xiRVOtF1ZkPb5pfhOfDJotBaanD9Zo,3547
-keras_hub_nightly-0.16.1.dev202409250340.dist-info/METADATA,sha256=I0qfaK-EcBkBLd3AKkbeGymIVDvZaufV75SvbuwSeOA,7061
-keras_hub_nightly-0.16.1.dev202409250340.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-keras_hub_nightly-0.16.1.dev202409250340.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
-keras_hub_nightly-0.16.1.dev202409250340.dist-info/RECORD,,
+keras_hub_nightly-0.16.1.dev202409260340.dist-info/METADATA,sha256=tbYq7M5h0GvH0R4O0viRypG59absfWlxXVZqZhTHwiE,7061
+keras_hub_nightly-0.16.1.dev202409260340.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+keras_hub_nightly-0.16.1.dev202409260340.dist-info/top_level.txt,sha256=N4J6piIWBKa38A4uV-CnIopnOEf8mHAbkNXafXm_CuA,10
+keras_hub_nightly-0.16.1.dev202409260340.dist-info/RECORD,,

keras_hub/src/models/stable_diffusion_v3/clip_preprocessor.py

@@ -1,93 +0,0 @@
-# Copyright 2024 The KerasHub Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import keras
-
-from keras_hub.src.layers.preprocessing.start_end_packer import StartEndPacker
-from keras_hub.src.models.preprocessor import Preprocessor
-from keras_hub.src.models.stable_diffusion_v3.clip_tokenizer import (
-    CLIPTokenizer,
-)
-from keras_hub.src.utils.tensor_utils import preprocessing_function
-
-try:
-    import tensorflow as tf
-except ImportError:
-    tf = None
-
-
-class CLIPPreprocessor(Preprocessor):
-    tokenizer_cls = CLIPTokenizer
-
-    def __init__(
-        self,
-        tokenizer,
-        sequence_length=77,
-        add_start_token=True,
-        add_end_token=False,
-        to_lower=True,
-        pad_with_end_token=True,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.tokenizer = tokenizer
-        self.sequence_length = sequence_length
-        self.add_start_token = add_start_token
-        self.add_end_token = add_end_token
-        self.to_lower = to_lower
-        self.pad_with_end_token = pad_with_end_token
-
-    def build(self, input_shape):
-        # Defer packer creation to `build()` so that we can be sure tokenizer
-        # assets have loaded when restoring a saved model.
-        pad_value = self.tokenizer.pad_token_id
-        if self.pad_with_end_token:
-            pad_value = self.tokenizer.end_token_id
-
-        self.packer = StartEndPacker(
-            start_value=self.tokenizer.start_token_id,
-            end_value=self.tokenizer.end_token_id,
-            pad_value=pad_value,
-            sequence_length=self.sequence_length,
-            return_padding_mask=True,
-        )
-        self.built = True
-
-    @preprocessing_function
-    def call(self, x, y=None, sample_weight=None, sequence_length=None):
-        if self.to_lower:
-            x = tf.strings.lower(x)
-        token_ids, padding_mask = self.packer(
-            self.tokenizer(x),
-            sequence_length=sequence_length or self.sequence_length,
-            add_start_value=self.add_start_token,
-            add_end_value=self.add_end_token,
-        )
-        x = {
-            "token_ids": token_ids,
-            "padding_mask": padding_mask,
-        }
-        return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)
-
-    def get_config(self):
-        config = super().get_config()
-        config.update(
-            {
-                "sequence_length": self.sequence_length,
-                "add_start_token": self.add_start_token,
-                "add_end_token": self.add_end_token,
-                "to_lower": self.to_lower,
-                "pad_with_end_token": self.pad_with_end_token,
-            }
-        )
-        return config