PyPI - keras-hub-nightly - Versions diffs - 0.21.0.dev202505230409__tar.gz → 0.21.0.dev202505250413__tar.gz - Mend

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keras-hub-nightly
-Version: 0.21.0.dev202505230409
+Version: 0.21.0.dev202505250413
 Summary: Pretrained models for Keras.
 Author-email: Keras team <keras-users@googlegroups.com>
 License-Expression: Apache-2.0

@@ -0,0 +1,66 @@
+from keras_hub.src.models.seq_2_seq_lm import Seq2SeqLM
+class AudioToText(Seq2SeqLM):
+    """Base class for audio-to-text models.
+    `AudioToText` tasks wrap a `keras_hub.models.Backbone` (capable of
+    processing audio and text features) and a
+    `keras_hub.models.AudioToTextPreprocessor` to create a model for
+    audio-to-text tasks like speech recognition or audio transcription.
+    These models typically consist of an encoder that processes audio input
+    and a decoder that generates a textual representation.
+    `AudioToText` tasks provide a high-level `generate()` method for
+    auto-regressively generating text from audio input. An optional text
+    prompt can also be provided to the decoder to guide generation. The
+    sampling strategy for generation (e.g., greedy, top-k, top-p) can be
+    controlled via the `sampler` argument in the `compile()` method.
+    When calling `fit()`, inputs should consist of audio data and corresponding
+    target text transcriptions. The model is trained to predict the target text
+    token-by-token.
+    All `AudioToText` tasks include a `from_preset()` constructor which
+    can be used to load pre-trained configurations and weights for specific
+    audio-to-text models.
+    This constructor can also be called on the base `AudioToText` class,
+    which will automatically select the correct subclass based on the preset.
+    Examples:
+    ```python
+    # Load a Moonshine backbone with pre-trained weights.
+    # AudioToText is a base class. You will typically work with a specific
+    # implementation, such as `keras_hub.models.MoonshineAudioToText`.
+    # The following examples demonstrate common usage patterns.
+    # Initialize a model from a preset using the specific subclass.
+    audio_to_text = keras_hub.models.MoonshineAudioToText.from_preset(
+        "moonshine_base_en"
+    )
+    # Initialize a model from a preset using the base class.
+    audio_to_text_model_base = keras_hub.models.AudioToText.from_preset(
+        "moonshine_base_en"
+    )
+    # Generate text from an audio input.
+    audio_input_tensor = keras.random.normal((1, 16000, 1))
+    generated_output = audio_to_text_model.generate(
+        {"audio": audio_input_tensor}
+    )
+    # Generate conditioned on the `"The quick brown fox."` as an input sequence.
+    prompted_output = audio_to_text_model.generate(
+        {"audio": audio_input_tensor, "text": "The quick brown fox."}
+    )
+    # Use a different sampling strategy for generation.
+    audio_to_text_model.compile(sampler="greedy")
+    greedy_output = audio_to_text_model.generate(
+        {"audio": audio_input_tensor}
+    )
+    """
+    # TODO: Fill in once audio to text task model requirements are clearer.

@@ -0,0 +1,80 @@
+from keras_hub.src.models.seq_2_seq_lm_preprocessor import Seq2SeqLMPreprocessor
+class AudioToTextPreprocessor(Seq2SeqLMPreprocessor):
+    """Base class for audio-to-text preprocessing layers.
+    `AudioToTextPreprocessor` layers wrap an audio feature extractor (specific
+    to the subclass) and a `keras_hub.tokenizer.Tokenizer` to create a
+    preprocessing layer for audio-to-text tasks. It is intended to be
+    paired with a `keras_hub.models.AudioToText` task.
+    Subclasses are expected to handle the conversion of raw audio data into
+    numerical features suitable for an encoder, and raw text data into token IDs
+    for a decoder.
+    All `AudioToTextPreprocessor` layers take a dictionary as input,
+    typically with keys like `"audio"` (for audio data) and `"text"` (for
+    target transcriptions or decoder prompts).
+    This layer will always output a `(x, y, sample_weight)` tuple, where `x`
+    is a dictionary containing processed audio features for the encoder and
+    tokenized text inputs for the decoder. `y` contains the target token IDs
+    (decoder input tokens shifted by one position), and `sample_weight`
+    indicates padding in `y`. The exact keys and structure of features within
+    `x` will depend on the specific subclass and the paired `AudioToText` model.
+    An `AudioToTextPreprocessor` includes `generate_preprocess` and
+    `generate_postprocess` methods for use during inference with an
+    `AudioToText` model's `generate()` method.
+    All `AudioToTextPreprocessor` tasks include a `from_preset()` constructor
+    which can be used to load a pre-trained configuration, including tokenizer
+    vocabularies and audio feature extraction settings. Calling `from_preset()`
+    on this base class can instantiate the correct subclass registered for the
+    given preset.
+    Examples:
+    ```python
+    preprocessor = keras_hub.models.AudioToTextPreprocessor.from_preset(
+        "moonshine_base_en",
+        decoder_sequence_length=10
+    )
+    # Process a single audio-text pair.
+    x = {
+        "audio": keras.random.normal((1, 16000, 1)),
+        "text": ["the quick brown fox"]
+    }
+    x, y, sample_weight = preprocessor(x)
+    # Process a batch of audio-text pairs.
+    x = {
+        "audio": keras.random.normal((2, 16000, 1)),
+        "text": ["first sentence", "second sentence"]
+    }
+    x, y, sample_weight = preprocessor(x)
+    # With a `tf.data.Dataset`.
+    audio_tf = keras.ops.convert_to_tensor(batch_input["audio"])
+    text_tf = batch_input["text"] # List of strings
+    x = {"audio": audio_tf, "text": text_tf}
+    ds = tf.data.Dataset.from_tensor_slices(x)
+    ds = ds.map(preprocessor, num_parallel_calls=tf.data.AUTOTUNE)
+    ds = ds.batch(2) # Batching after map
+    # Generate preprocess and postprocess.
+    x = preprocessor.generate_preprocess({
+        "audio": keras.random.normal((1, 16000, 1)),
+        "text": ["optional prompt text"]
+    })
+    x = preprocessor.generate_postprocess({
+        "decoder_token_ids": keras.ops.array([[10, 20, 30, 2, 0]]),
+        "decoder_padding_mask": keras.ops.array([
+            [True, True, True, True, False]
+        ])
+    })
+    ```
+    """
+    # TODO: Fill in once audio to text task model requirements are clearer.

@@ -0,0 +1,5 @@
+from keras_hub.src.models.mixtral.mixtral_backbone import MixtralBackbone
+from keras_hub.src.models.mixtral.mixtral_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+register_presets(backbone_presets, MixtralBackbone)

@@ -0,0 +1,5 @@
+from keras_hub.src.models.moonshine.moonshine_backbone import MoonshineBackbone
+from keras_hub.src.models.moonshine.moonshine_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+register_presets(backbone_presets, MoonshineBackbone)

@@ -1,6 +1,7 @@
 import keras
 from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.audio_to_text import AudioToText
 from keras_hub.src.models.moonshine.moonshine_audio_to_text_preprocessor import (  # noqa: E501
     MoonshineAudioToTextPreprocessor,
 )
@@ -9,12 +10,11 @@ from keras_hub.src.models.moonshine.moonshine_backbone import MoonshineBackbone
 from keras_hub.src.models.moonshine.moonshine_backbone import (
     compute_output_lengths,
 )
-from keras_hub.src.models.seq_2_seq_lm import Seq2SeqLM
 from keras_hub.src.utils.tensor_utils import any_equal
 @keras_hub_export("keras_hub.models.MoonshineAudioToText")
-class MoonshineAudioToText(Seq2SeqLM):
+class MoonshineAudioToText(AudioToText):
     """An end-to-end Moonshine model for audio-to-text tasks.
     A Seq2Seq LM designed for audio-to-text tasks, such as speech recognition.

@@ -6,16 +6,18 @@ except ImportError:
     tf = None
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.layers.preprocessing.start_end_packer import StartEndPacker
+from keras_hub.src.models.audio_to_text_preprocessor import (
+    AudioToTextPreprocessor,
+)
 from keras_hub.src.models.moonshine.moonshine_backbone import MoonshineBackbone
 from keras_hub.src.models.moonshine.moonshine_tokenizer import (
     MoonshineTokenizer,
 )
-from keras_hub.src.models.seq_2_seq_lm_preprocessor import Seq2SeqLMPreprocessor
 from keras_hub.src.utils.tensor_utils import preprocessing_function
 @keras_hub_export("keras_hub.models.MoonshineAudioToTextPreprocessor")
-class MoonshineAudioToTextPreprocessor(Seq2SeqLMPreprocessor):
+class MoonshineAudioToTextPreprocessor(AudioToTextPreprocessor):
     """Moonshine Seq2Seq LM preprocessor for audio-to-text tasks.
     This preprocessor converts raw audio and text inputs into a format suitable
@@ -264,4 +266,7 @@ class MoonshineAudioToTextPreprocessor(Seq2SeqLMPreprocessor):
                 and 0 <= token < vocab_size
             ]
             processed_sequences.append(filtered_tokens)
+        processed_sequences = tf.ragged.constant(
+            processed_sequences, dtype=tf.int32
+        )
         return self.tokenizer.detokenize(processed_sequences)

@@ -0,0 +1,5 @@
+from keras_hub.src.models.qwen.qwen_backbone import QwenBackbone
+from keras_hub.src.models.qwen.qwen_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+register_presets(backbone_presets, QwenBackbone)

@@ -0,0 +1,5 @@
+from keras_hub.src.models.qwen_moe.qwen_moe_backbone import QwenMoeBackbone
+from keras_hub.src.models.qwen_moe.qwen_moe_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+register_presets(backbone_presets, QwenMoeBackbone)

@@ -1,7 +1,7 @@
 from keras_hub.src.api_export import keras_hub_export
 # Unique source of truth for the version number.
-__version__ = "0.21.0.dev202505230409"
+__version__ = "0.21.0.dev202505250413"
 @keras_hub_export("keras_hub.version")

@@ -45,6 +45,8 @@ keras_hub/src/metrics/rouge_base.py
 keras_hub/src/metrics/rouge_l.py
 keras_hub/src/metrics/rouge_n.py
 keras_hub/src/models/__init__.py
+keras_hub/src/models/audio_to_text.py
+keras_hub/src/models/audio_to_text_preprocessor.py
 keras_hub/src/models/backbone.py
 keras_hub/src/models/causal_lm.py
 keras_hub/src/models/causal_lm_preprocessor.py
@@ -254,6 +256,7 @@ keras_hub/src/models/mit/mit_image_classifier_preprocessor.py
 keras_hub/src/models/mit/mit_image_converter.py
 keras_hub/src/models/mit/mit_layers.py
 keras_hub/src/models/mit/mit_presets.py
+keras_hub/src/models/mixtral/__init__.py
 keras_hub/src/models/mixtral/mixtral_attention.py
 keras_hub/src/models/mixtral/mixtral_backbone.py
 keras_hub/src/models/mixtral/mixtral_causal_lm.py

	@@ -1 +0,0 @@
1	- from keras_hub.src.models.qwen.qwen_backbone import QwenBackbone

keras-hub-nightly 0.21.0.dev202505230409__tar.gz → 0.21.0.dev202505250413__tar.gz

keras-hub-nightly 0.21.0.dev202505230409tar.gz → 0.21.0.dev202505250413tar.gz