### StartEndPacker Usage Examples

Source: https://keras.io/keras_hub/api/preprocessing_layers/start_end_packer

Examples demonstrating the use of StartEndPacker with various input types including unbatched/batched integers and strings, as well as multiple start tokens.

```python
>>> inputs = [5, 6, 7]
>>> start_end_packer = keras_hub.layers.StartEndPacker(
...     sequence_length=7, start_value=1, end_value=2,
... )
>>> outputs = start_end_packer(inputs)
>>> np.array(outputs)
array([1, 5, 6, 7, 2, 0, 0], dtype=int32)
```

```python
>>> inputs = [[5, 6, 7], [8, 9, 10, 11, 12, 13, 14]]
>>> start_end_packer = keras_hub.layers.StartEndPacker(
...     sequence_length=6, start_value=1, end_value=2,
... )
>>> outputs = start_end_packer(inputs)
>>> np.array(outputs)
array([[ 1,  5,  6,  7,  2,  0],
       [ 1,  8,  9, 10, 11,  2]], dtype=int32)
```

```python
>>> inputs = tf.constant(["this", "is", "fun"])
>>> start_end_packer = keras_hub.layers.StartEndPacker(
...     sequence_length=6, start_value="<s>", end_value="</s>",
...     pad_value="<pad>"
... )
>>> outputs = start_end_packer(inputs)
>>> np.array(outputs).astype("U")
array(['<s>', 'this', 'is', 'fun', '</s>', '<pad>'], dtype='<U5')
```

```python
>>> inputs = tf.ragged.constant([["this", "is", "fun"], ["awesome"]])
>>> start_end_packer = keras_hub.layers.StartEndPacker(
...     sequence_length=6, start_value="<s>", end_value="</s>",
...     pad_value="<pad>"
... )
>>> outputs = start_end_packer(inputs)
>>> np.array(outputs).astype("U")
array([['<s>', 'this', 'is', 'fun', '</s>', '<pad>'],
       ['<s>', 'awesome', '</s>', '<pad>', '<pad>', '<pad>']], dtype='<U7')
```

```python
>>> inputs = tf.ragged.constant([["this", "is", "fun"], ["awesome"]])
>>> start_end_packer = keras_hub.layers.StartEndPacker(
...     sequence_length=6, start_value=["</s>", "<s>"], end_value="</s>",
...     pad_value="<pad>"
... )
>>> outputs = start_end_packer(inputs)
>>> np.array(outputs).astype("U")
array([['</s>', '<s>', 'this', 'is', 'fun', '</s>'],
       ['</s>', '<s>', 'awesome', '</s>', '<pad>', '<pad>']], dtype='<U7')
```

--------------------------------

### Install Dependencies

Source: https://keras.io/keras_hub/guides/object_detection_retinanet

Installs the required packages for the tutorial: keras-hub, keras, and opencv-python. Use this to set up your environment.

```bash
!pip install -q --upgrade keras-hub
!pip install -q --upgrade keras
!pip install -q opencv-python

```

--------------------------------

### Qwen3MoeBackbone Usage Examples

Source: https://keras.io/keras_hub/api/models/qwen3_moe/qwen3_moe_backbone

Examples demonstrating how to load a pre-trained Qwen MoE model and how to initialize a custom model configuration.

```python
input_data = {
    "token_ids": np.ones(shape=(1, 12), dtype="int32"),
    "padding_mask": np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]]),
}

model = keras_hub.models.Qwen3MoeBackbone.from_preset("qwen3_moe_a2_7b")
model(input_data)
```

```python
model = keras_hub.models.Qwen3MoeBackbone(
    vocabulary_size=151936,
    num_layers=28,
    num_query_heads=16,
    num_key_value_heads=8,
    hidden_dim=2048,
    intermediate_dim=4096,
    moe_intermediate_dim=128,
    num_experts=60,
    top_k=4,
    head_dim=128,
    max_sequence_length=4096,
)
model(input_data)
```

--------------------------------

### Initialize QwenMoeBackbone from preset

Source: https://keras.io/keras_hub/api/models/qwen_moe/qwen_moe_backbone

Load a pretrained Qwen MoE backbone model using a preset architecture and weights. This is the recommended way to get started with pretrained models.

```python
input_data = {
    "token_ids": np.ones(shape=(1, 12), dtype="int32"),
    "padding_mask": np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]])
}

model = keras_hub.models.QwenMoeBackbone.from_preset("qwen_moe_a2_7b")
model(input_data)
```

--------------------------------

### Install Dependencies and Download Assets

Source: https://keras.io/keras_hub/guides/stable_diffusion_3_in_keras_hub

Installs necessary libraries and downloads sample images for the Stable Diffusion 3 demo.

```bash
!pip install -Uq keras
!pip install -Uq git+https://github.com/keras-team/keras-hub.git
!wget -O mountain_dog.png https://raw.githubusercontent.com/keras-team/keras-io/master/guides/img/stable_diffusion_3_in_keras_hub/mountain_dog.png
!wget -O mountain_dog_mask.png https://raw.githubusercontent.com/keras-team/keras-io/master/guides/img/stable_diffusion_3_in_keras_hub/mountain_dog_mask.png
```

--------------------------------

### Usage Examples for DINOV2Backbone

Source: https://keras.io/keras_hub/api/models/dinov2/dinov2_backbone

Examples demonstrating how to load pre-trained models, customize image shapes, and initialize a model with custom configuration.

```python
# Pretrained DINOV2 model.
input_data = {
    "images": np.ones(shape=(1, 518, 518, 3), dtype="float32"),
}
model = keras_hub.models.DINOV2Backbone.from_preset(
    "dinov2_base"
)
model(input_data)

# Pretrained DINOV2 model with custom image shape.
input_data = {
    "images": np.ones(shape=(1, 224, 224, 3), dtype="float32"),
}
model = keras_hub.models.DINOV2Backbone.from_preset(
    "dinov2_base", image_shape=(224, 224, 3)
)
model(input_data)

# Randomly initialized DINOV2 model with custom config.
model = keras_hub.models.DINOV2Backbone(
    patch_size=14,
    num_layers=2,
    hidden_dim=32,
    num_heads=2,
    intermediate_dim=128,
    image_shape=(224, 224, 3),
    position_embedding_shape=(518, 518),
)
model(input_data)
```

--------------------------------

### Install Keras and KerasHub

Source: https://keras.io/keras_hub/guides/segment_anything_in_keras_hub

Install the necessary libraries for KerasHub and Keras. Use the `-Uq` flags for an upgrade and quiet installation.

```bash
!!pip install -Uq git+https://github.com/keras-team/keras-hub.git
!!pip install -Uq keras

```

--------------------------------

### Examples of from_preset Usage

Source: https://keras.io/keras_hub/api/base_classes/backbone

Demonstrates loading models with and without pre-trained weights.

```python
# Load a Gemma backbone with pre-trained weights.
model = keras_hub.models.Backbone.from_preset(
    "gemma_2b_en",
)

# Load a Bert backbone with a pre-trained config and random weights.
model = keras_hub.models.Backbone.from_preset(
    "bert_base_en",
    load_weights=False,
)
```

--------------------------------

### Load and use a preset tokenizer

Source: https://keras.io/keras_hub/api/models/bert/bert_tokenizer

Example of loading a tokenizer from a preset and performing tokenization.

```python
# Load a preset tokenizer.
tokenizer = keras_hub.tokenizer.Tokenizer.from_preset("bert_base_en")

# Tokenize some input.
tokenizer("The quick brown fox tripped.")
```

--------------------------------

### Load AudioConverter from Preset

Source: https://keras.io/keras_hub/api/preprocessing_layers/audio_converter

Alternative example of loading an audio converter using the from_preset method.

```python
# Load an audio converter from a preset.
converter = keras_hub.layers.AudioConverter.from_preset(
    "whisper_base_en"
)
```

--------------------------------

### Use FalconBackbone Examples

Source: https://keras.io/keras_hub/api/models/falcon/falcon_backbone

Demonstrates loading a pretrained Falcon model and initializing a custom configuration from scratch.

```python
input_data = {
    "token_ids": np.ones(shape=(1, 12), dtype="int32"),
    "padding_mask": np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]]),
}

# Pretrained Falcon decoder.
# TODO: Update the preset.
model = keras_hub.models.FalconBackbone.from_preset("falcon_preset")
model(input_data)

# Randomly initialized Falcon decoder with a custom config.
model = keras_hub.models.FalconBackbone(
    vocabulary_size=10,
    num_layers=2,
    num_attention_heads=2,
    hidden_dim=32,
    intermediate_dim=32*4,
    layer_norm_epsilon=1e-5,
    attention_dropout_rate=0,
    feedforward_dropout_rate=0,
    dtype="float32",
)
model(input_data)
```

--------------------------------

### Install KerasHub and Keras

Source: https://keras.io/keras_hub/guides/classification_with_keras_hub

Install the necessary packages to get started with KerasHub and Keras 3.

```bash
!!pip install -q --upgrade keras-hub
!!pip install -q --upgrade keras  # Upgrade to Keras 3.
```

--------------------------------

### Use ViTDetBackbone with presets and custom configurations

Source: https://keras.io/keras_hub/api/models/vit_det/ViTDetBackbone

Examples showing how to load a pretrained ViTDetBackbone or initialize one with custom parameters.

```python
input_data = np.ones((2, 224, 224, 3), dtype="float32")

# Pretrained ViTDetBackbone backbone.
model = keras_hub.models.ViTDetBackbone.from_preset("vit_det")
model(input_data)

# Randomly initialized ViTDetBackbone backbone with a custom config.
model = keras_hub.models.ViTDetBackbone(
        image_shape = (16, 16, 3),
        patch_size = 2,
        hidden_size = 4,
        num_layers = 2,
        global_attention_layer_indices = [2, 5, 8, 11],
        intermediate_dim = 4 * 4,
        num_heads = 2,
        num_output_channels = 2,
        window_size = 2,
)
model(input_data)
```

--------------------------------

### Initialize MistralCausalLMPreprocessor from Preset

Source: https://keras.io/keras_hub/api/models/mistral/mistral_causal_lm_preprocessor

Load the MistralCausalLMPreprocessor from a preset identifier. This is the recommended way to get started with the preprocessor.

```python
preprocessor = keras_hub.models.MistralCausalLMPreprocessor.from_preset(
    "mistral_base_en"
)
```

--------------------------------

### Use RWKV7CausalLMPreprocessor for training and generation

Source: https://keras.io/keras_hub/api/models/rwkv7/rwkv7_causal_lm_preprocessor

Example showing how to initialize the tokenizer, create the preprocessor, and perform preprocessing for training and generation.

```python
# Initialize the tokenizer and load assets from a local path.
tokenizer = RWKVTokenizer()
tokenizer.load_assets(rwkv_path)

# Create a preprocessor with a sequence length of 8.
preprocessor = RWKV7CausalLMPreprocessor(tokenizer, sequence_length=8)

# Tokenize and pack a batch of sentences.
preprocessor(["Bubble sort", "Hello World"])

    # Preprocess inputs for generation with a maximum generation length of 16.
    preprocessor.generate_preprocess(
        ["Bubble sort", "Hello World"], 16
    )
```

--------------------------------

### Initialize GPT2CausalLM from preset

Source: https://keras.io/keras_hub/api/models/gpt2/gpt2_causal_lm

Instantiate a GPT2CausalLM model using a preset configuration. This is the recommended way to get started with the model.

```python
gpt2_lm = keras_hub.models.GPT2CausalLM.from_preset("gpt2_base_en")
```

--------------------------------

### Instantiate and run SAM3PromptableConceptBackbone

Source: https://keras.io/keras_hub/api/models/sam3/sam3_pc_backbone

Example showing the initialization of all required sub-components and a forward pass with dummy input data.

```python
import numpy as np
import keras_hub

vision_encoder = keras_hub.layers.SAM3VisionEncoder(
    image_shape=(224, 224, 3),
    patch_size=14,
    num_layers=2,
    hidden_dim=32,
    intermediate_dim=128,
    num_heads=2,
    fpn_hidden_dim=32,
    fpn_scale_factors=[4.0, 2.0, 1.0, 0.5],
    pretrain_image_shape=(112, 112, 3),
    window_size=2,
    global_attn_indexes=[1, 2],
)
text_encoder = keras_hub.layers.SAM3TextEncoder(
    vocabulary_size=1024,
    embedding_dim=32,
    hidden_dim=32,
    num_layers=2,
    num_heads=2,
    intermediate_dim=128,
)
geometry_encoder = keras_hub.layers.SAM3GeometryEncoder(
    num_layers=3,
    hidden_dim=32,
    intermediate_dim=128,
    num_heads=2,
    roi_size=7,
)
detr_encoder = keras_hub.layers.SAM3DetrEncoder(
    num_layers=3,
    hidden_dim=32,
    intermediate_dim=128,
    num_heads=2,
)
detr_decoder = keras_hub.layers.SAM3DetrDecoder(
    image_shape=(224, 224, 3),
    patch_size=14,
    num_layers=2,
    hidden_dim=32,
    intermediate_dim=128,
    num_heads=2,
    num_queries=100,
)
mask_decoder = keras_hub.layers.SAM3MaskDecoder(
    num_upsampling_stages=3,
    hidden_dim=32,
    num_heads=2,
)
backbone = keras_hub.models.SAM3PromptableConceptBackbone(
    vision_encoder=vision_encoder,
    text_encoder=text_encoder,
    geometry_encoder=geometry_encoder,
    detr_encoder=detr_encoder,
    detr_decoder=detr_decoder,
    mask_decoder=mask_decoder,
)
input_data = {
    "pixel_values": np.ones((2, 224, 224, 3), dtype="float32"),
    "token_ids": np.ones((2, 32), dtype="int32"),
    "padding_mask": np.ones((2, 32), dtype="bool"),
    "boxes": np.zeros((2, 1, 5), dtype="float32"),
    "box_labels": np.zeros((2, 1), dtype="int32"),
}
outputs = backbone(input_data)
```

--------------------------------

### Instantiate T5Gemma2Backbone

Source: https://keras.io/keras_hub/api/models/t5gemma2/t5gemma2_backbone

Instantiates the T5Gemma2 backbone model with specified encoder and decoder configurations. This example shows a basic setup for text-only input.

```python
import numpy as np
from keras_hub.models import T5Gemma2Backbone

input_data = {
    "encoder_token_ids": np.ones(shape=(1, 12), dtype="int32"),
    "encoder_padding_mask": np.array(
        [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]], dtype="int32"
    ),
    "decoder_token_ids": np.ones(shape=(1, 8), dtype="int32"),
    "decoder_padding_mask": np.array(
        [[1, 1, 1, 1, 1, 1, 1, 1]], dtype="int32"
    ),
}

model = T5Gemma2Backbone(
    vocabulary_size=32000,
    encoder_hidden_dim=256,
    encoder_intermediate_dim=512,
    encoder_num_layers=4,
    encoder_num_attention_heads=4,
    encoder_num_key_value_heads=2,
    encoder_head_dim=64,
```

--------------------------------

### Instantiate FalconCausalLM from Preset

Source: https://keras.io/keras_hub/api/models/falcon/falcon_causal_lm

Instantiates an end-to-end Falcon model for causal language modeling using a preset configuration. This is the recommended way to get started.

```python
falcon_lm = keras_hub.models.FalconCausalLM.from_preset(
    "falcon_refinedweb_1b_en"
)
```

--------------------------------

### Instantiate SigLIPBackbone with Pretrained Weights

Source: https://keras.io/keras_hub/api/models/siglip/siglip_backbone

Load a pretrained SigLIP base model using the from_preset constructor. This is useful for quickly getting started with a SigLIP model with established weights.

```python
input_data = {
    "images": np.ones(shape=(1, 224, 224, 3), dtype="float32"),
    "token_ids": np.ones(shape=(1, 64), dtype="int32"),
}

# Pretrained SigLIP model.
model = keras_hub.models.SigLIPBackbone.from_preset(
    "siglip_base_patch16_224"
)
model(input_data)
```

--------------------------------

### Instantiate and Use QwenBackbone

Source: https://keras.io/keras_hub/api/models/qwen/qwen_backbone

Demonstrates how to instantiate and use the QwenBackbone model. Shows loading a preset model and initializing a custom model with specific configurations. Requires numpy and keras_hub.

```python
input_data = {
    "token_ids": np.ones(shape=(1, 12), dtype="int32"),
    "padding_mask": np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]])
}

# Pretrained Qwen decoder.
model = keras_hub.models.QwenBackbone.from_preset("qwen2.5_0.5b_en")
model(input_data)

# Randomly initialized Qwen decoder with custom config.
model = keras_hub.models.QwenBackbone(
    vocabulary_size=10,
    hidden_dim=512,
    num_layers=2,
    num_query_heads=32,
    num_key_value_heads=8,
    intermediate_dim=1024,
    layer_norm_epsilon=1e-6,
    dtype="float32"
)
model(input_data)

```

--------------------------------

### Instantiate BASNetImageSegmenter Model

Source: https://keras.io/keras_hub/api/models/basnet/basnet_image_segmenter

Instantiate the BASNetImageSegmenter model with a specified backbone and optional preprocessor. Use this for image segmentation tasks. The example demonstrates model evaluation and training setup.

```python
import keras_hub

images = np.ones(shape=(1, 288, 288, 3))
labels = np.zeros(shape=(1, 288, 288, 1))

image_encoder = keras_hub.models.ResNetBackbone.from_preset(
    "resnet_18_imagenet",
    load_weights=False
)
backbone = keras_hub.models.BASNetBackbone(
    image_encoder,
    num_classes=1,
    image_shape=[288, 288, 3]
)
model = keras_hub.models.BASNetImageSegmenter(backbone)

# Evaluate the model
pred_labels = model(images)

# Train the model
model.compile(
    optimizer="adam",
    loss=keras.losses.BinaryCrossentropy(from_logits=False),
    metrics=["accuracy"],
)
model.fit(images, labels, epochs=3)

```

--------------------------------

### Instantiate and Use TransformerDecoder Layer

Source: https://keras.io/keras_hub/api/modeling_layers/transformer_decoder

Demonstrates how to create a TransformerDecoder layer, build a Keras model with it, and call the model with sample input data. This example shows an encoder-decoder setup.

```python
# Create a single transformer decoder layer.
declared_decoder = keras_hub.layers.TransformerDecoder(
    intermediate_dim=64, num_heads=8)

# Create a simple model containing the decoder.
declared_decoder_input = keras.Input(shape=(10, 64))
encoder_input = keras.Input(shape=(10, 64))
declared_output = declared_decoder(declared_decoder_input, encoder_input)
model = keras.Model(
    inputs=(declared_decoder_input, encoder_input),
    outputs=declared_output,
)

# Call decoder on the inputs.
declared_decoder_input_data = np.random.uniform(size=(2, 10, 64))
encoder_input_data = np.random.uniform(size=(2, 10, 64))
declared_decoder_output = model((declared_decoder_input_data, encoder_input_data))

```

--------------------------------

### Use ElectraBackbone with Presets and Custom Initialization

Source: https://keras.io/keras_hub/api/models/electra/electra_backbone

Demonstrates loading a pre-trained ELECTRA model and initializing a custom backbone from scratch.

```python
input_data = {
"token_ids": np.ones(shape=(1, 12), dtype="int32"),
"segment_ids": np.array([[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0]]),
"padding_mask": np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]]),
}

# Pre-trained ELECTRA encoder.
model = keras_hub.models.ElectraBackbone.from_preset(
    "electra_base_discriminator_en"
)
model(input_data)

# Randomly initialized Electra encoder
backbone = keras_hub.models.ElectraBackbone(
    vocabulary_size=1000,
    num_layers=2,
    num_heads=2,
    hidden_dim=32,
    intermediate_dim=64,
    dropout=0.1,
    max_sequence_length=512,
    )
# Returns sequence and pooled outputs.
sequence_output, pooled_output = backbone(input_data)
```

--------------------------------

### Instantiating a MobileNetBackbone Model

Source: https://keras.io/keras_hub/api/models/mobilenet/mobilenet_backbone

Example showing how to initialize a MobileNetBackbone with a custom configuration and pass input data through it.

```python
input_data = tf.ones(shape=(8, 224, 224, 3))

# Randomly initialized backbone with a custom config
model = MobileNetBackbone(
    stackwise_expansion=[
            [40, 56],
            [64, 144, 144],
            [72, 72],
            [144, 288, 288],
        ],
        stackwise_num_blocks=[2, 3, 2, 3],
        stackwise_num_filters=[
            [16, 16],
            [24, 24, 24],
            [24, 24],
            [48, 48, 48],
        ],
        stackwise_kernel_size=[[3, 3], [5, 5, 5], [5, 5], [5, 5, 5]],
        stackwise_num_strides=[[2, 1], [2, 1, 1], [1, 1], [2, 1, 1]],
        stackwise_se_ratio=[
            [None, None],
            [0.25, 0.25, 0.25],
            [0.3, 0.3],
            [0.3, 0.25, 0.25],
        ],
        stackwise_activation=[
            ["relu", "relu"],
            ["hard_swish", "hard_swish", "hard_swish"],
            ["hard_swish", "hard_swish"],
            ["hard_swish", "hard_swish", "hard_swish"],
        ],
        output_num_filters=288,
        input_activation="hard_swish",
        output_activation="hard_swish",
        input_num_filters=16,
        image_shape=(224, 224, 3),
        depthwise_filters=8,
        squeeze_and_excite=0.5,

)
output = model(input_data)
```

--------------------------------

### Install KerasHub

Source: https://keras.io/keras_hub

Commands to install the stable or nightly versions of the KerasHub library.

```bash
pip install --upgrade keras-hub
```

```bash
pip install --upgrade keras-hub-nightly
```

--------------------------------

### Install KerasHub dependencies

Source: https://keras.io/keras_hub/guides/semantic_segmentation_deeplab_v3

Install the required Keras and KerasHub packages to run the tutorial.

```bash
!pip install -q --upgrade keras-hub
!pip install -q --upgrade keras
```

--------------------------------

### Initialize and use MoonshineAudioToTextPreprocessor

Source: https://keras.io/keras_hub/api/models/moonshine/moonshine_audio_to_text_preprocessor

Demonstrates creating a preprocessor instance with an audio converter and tokenizer, then processing inputs for training and generation.

```python
import keras
from keras_hub.layers import MoonshineAudioConverter
from keras_hub.models import MoonshineTokenizer

# Create audio converter and tokenizer instances.
audio_converter = MoonshineAudioConverter()
tokenizer = MoonshineTokenizer.from_preset("moonshine_base")

# Initialize the preprocessor.
preprocessor = keras_hub.models.MoonshineAudioToTextPreprocessor(
    audio_converter=audio_converter,
    tokenizer=tokenizer,
    decoder_sequence_length=8
)

# Prepare input data (audio tensor and text).
inputs = {
    "audio": keras.random.normal((1, 16000)),
    "text": ["the quick brown fox"]
}

# Process the inputs for training.
x, y, sample_weight = preprocessor(inputs)

# Check output keys and shapes (shapes depend on padding/truncation).
print(x.keys())
# dict_keys(['encoder_input_values', 'encoder_padding_mask',
# 'decoder_token_ids', 'decoder_padding_mask']).
print(x["encoder_input_values"].shape) # e.g., (1, 16000, 1) / padded length
print(x["encoder_padding_mask"].shape) # e.g., (1, 16000) or padded length
print(x["decoder_token_ids"].shape) # (1, 8)
print(x["decoder_padding_mask"].shape) # (1, 8)
print(y.shape) # (1, 8) - Labels
print(sample_weight.shape) # (1, 8) - Sample weights

# Process inputs for generation.
gen_inputs = preprocessor.generate_preprocess(inputs)
print(gen_inputs.keys())
# dict_keys(['encoder_input_values', 'encoder_padding_mask',
# 'decoder_token_ids', 'decoder_padding_mask']).
```

--------------------------------

### Install Grounding DINO dependencies

Source: https://keras.io/keras_hub/guides/segment_anything_in_keras_hub

Install the required groundingdino package from the official repository.

```bash
pip install -U git+https://github.com/IDEA-Research/GroundingDINO.git
```

```bash
!!pip install -U git+https://github.com/IDEA-Research/GroundingDINO.git
```

--------------------------------

### VGGImageClassifier Usage Examples

Source: https://keras.io/keras_hub/api/models/vgg/vgg_image_classifier

Examples demonstrating how to load, predict with, and train the VGGImageClassifier model.

```APIDOC
### Examples

#### Call `predict()` to run inference.

```python
# Load preset and train
images = np.random.randint(0, 256, size=(2, 224, 224, 3))
classifier = keras_hub.models.VGGImageClassifier.from_preset(
    "vgg_16_imagenet"
)
classifier.predict(images)
```

#### Call `fit()` on a single batch.

```python
# Load preset and train
images = np.random.randint(0, 256, size=(2, 224, 224, 3))
labels = [0, 3]
classifier = keras_hub.models.VGGImageClassifier.from_preset(
    "vgg_16_imagenet"
)
classifier.fit(x=images, y=labels, batch_size=2)
```

#### Call `fit()` with custom loss, optimizer and backbone.

```python
classifier = keras_hub.models.VGGImageClassifier.from_preset(
    "vgg_16_imagenet"
)
classifier.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    optimizer=keras.optimizers.Adam(5e-5),
)
classifier.backbone.trainable = False
classifier.fit(x=images, y=labels, batch_size=2)
```

#### Custom backbone.

```python
images = np.random.randint(0, 256, size=(2, 224, 224, 3))
labels = [0, 3]
backbone = keras_hub.models.VGGBackbone(
    stackwise_num_repeats = [2, 2, 3, 3, 3],
    stackwise_num_filters = [64, 128, 256, 512, 512],
    image_shape = (224, 224, 3),
)
classifier = keras_hub.models.VGGImageClassifier(
    backbone=backbone,
    num_classes=4,
)
classifier.fit(x=images, y=labels, batch_size=2)
```
```

--------------------------------

### Instantiate Model from Preset

Source: https://keras.io/keras_hub/api/models/sam3/sam3_pc_image_segmenter

Shows the method signature and usage examples for loading pre-trained models using presets.

```python
SAM3PromptableConceptImageSegmenter.from_preset(preset, load_weights=True, **kwargs)
```

```python
# Load a Gemma generative task.
causal_lm = keras_hub.models.CausalLM.from_preset(
    "gemma_2b_en",
)

# Load a Bert classification task.
model = keras_hub.models.TextClassifier.from_preset(
    "bert_base_en",
    num_classes=2,
)
```

--------------------------------

### Generate text with RWKV7CausalLM

Source: https://keras.io/keras_hub/api/models/rwkv7/rwkv7_causal_lm

Example showing how to initialize the model, configure the sampler, and generate text from prompts.

```python
# Initialize the tokenizer and load assets from a local path.
tokenizer = RWKVTokenizer()
tokenizer.load_assets(rwkv_path)

# Create a preprocessor with a sequence length of 8.
preprocessor = RWKV7CausalLMPreprocessor(tokenizer, sequence_length=8)

# Initialize the model with a backbone and preprocessor.
causal_lm = RWKV7CausalLM(backbone, preprocessor)

# you also can load model by from_preset
rwkv_path = "RWKV7_G1a_0.1B"
tokenizer = RWKVTokenizer.from_preset(rwkv_path)
causal_lm = RWKV7CausalLM.from_preset(rwkv_path)

prompts = ["Bubble sort\n\n```python", "Hello World"]

    causal_lm.compile(sampler="greedy")

    outputs = causal_lm.generate(prompts, max_length=128)
    for out in outputs:
        print(out)
        print("-" * 100)
```

--------------------------------

### Initialize and Use CLIPBackbone

Source: https://keras.io/keras_hub/api/models/clip/clip_backbone

Demonstrates initializing a CLIPBackbone from a preset and using it with input data. Also shows initializing a model with custom encoders.

```python
input_data = {
    "images": np.ones(shape=(1, 224, 224, 3), dtype="float32"),
    "token_ids": np.ones(shape=(1, 12), dtype="int32"),
}

# Pretrained CLIP model.
model = keras_hub.models.CLIPBackbone.from_preset("clip_vit_base_patch32")
model(input_data)

# Randomly initialized CLIP model with custom config.
vision_encoder = keras_hub.models.CLIPVisionEncoder(
    patch_size=32,
    hidden_dim=768,
    num_layers=8,
    num_heads=8,
    intermediate_dim=2048,
    image_shape=(384, 384, 3),
)
text_encoder = keras_hub.models.CLIPTextEncoder(
    vocabulary_size=49408,
    embedding_dim=768,
    hidden_dim=768,
    num_layers=8,
    num_heads=8,
    intermediate_dim=2048,
)
model = keras_hub.models.CLIPBackbone(
    vision_encoder=vision_encoder,
    text_encoder=text_encoder,
    projection_dim=256,
)
model(input_data)

```

--------------------------------

### WhitespaceSplitterTokenizer Example

Source: https://keras.io/keras_hub/api/tokenizers/tokenizer

Example of subclassing Tokenizer to create a simple whitespace splitter. Implements tokenize and detokenize methods.

```python
class WhitespaceSplitterTokenizer(keras_hub.tokenizers.Tokenizer):
    def tokenize(self, inputs):
        return tf.strings.split(inputs)

    def detokenize(self, inputs):
        return tf.strings.reduce_join(inputs, separator=" ", axis=-1)

tokenizer = WhitespaceSplitterTokenizer()

# Tokenize some inputs.
tokenizer.tokenize("This is a test")

# Shorthard for `tokenize()`.
tokenizer("This is a test")

# Detokenize some outputs.
tokenizer.detokenize(["This", "is", "a", "test"])
```

--------------------------------

### Initialize Qwen3Backbone with presets or custom config

Source: https://keras.io/keras_hub/api/models/qwen3/qwen3_backbone

Use `from_preset` to load a pre-trained Qwen3 backbone. Alternatively, initialize a randomly configured Qwen3 backbone by providing all necessary hyperparameters.

```python
input_data = {
    "token_ids": np.ones(shape=(1, 12), dtype="int32"),
    "padding_mask": np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]])
}

# Pretrained Qwen3 decoder.
model = keras_hub.models.Qwen3Backbone.from_preset("qwen32.5_0.5b_en")
model(input_data)

# Randomly initialized Qwen3 decoder with custom config.
model = keras_hub.models.Qwen3Backbone(
    vocabulary_size=10,
    hidden_dim=512,
    num_layers=2,
    num_query_heads=32,
    num_key_value_heads=8,
    intermediate_dim=1024,
    layer_norm_epsilon=1e-6,
    dtype="float32"
)
model(input_data)
```

--------------------------------

### BartTokenizer Usage Examples

Source: https://keras.io/keras_hub/api/models/bart/bart_tokenizer

Examples demonstrating unbatched and batched input tokenization, detokenization, and custom vocabulary initialization.

```python
# Unbatched input.
tokenizer = keras_hub.models.BartTokenizer.from_preset(
    "bart_base_en",
)
tokenizer("The quick brown fox jumped.")

# Batched input.
tokenizer(["The quick brown fox jumped.", "The fox slept."])

# Detokenization.
tokenizer.detokenize(tokenizer("The quick brown fox jumped."))

# Custom vocabulary.
vocab = {"<s>": 0, "<pad>": 1, "</s>": 2, "<mask>": 3}
vocab = {**vocab, "a": 4, "Ġquick": 5, "Ġfox": 6}
merges = ["Ġ q", "u i", "c k", "ui ck", "Ġq uick"]
merges += ["Ġ f", "o x", "Ġf ox"]
tokenizer = keras_hub.models.BartTokenizer(
    vocabulary=vocab,
    merges=merges,
)
tokenizer("The quick brown fox jumped.")
```

--------------------------------

### T5GemmaSeq2SeqLMPreprocessor Usage Examples

Source: https://keras.io/keras_hub/api/models/t5gemma/t5gemma_seq_2_seq_lm_preprocessor

Demonstrates loading from a preset, processing input strings and dictionaries, mapping over tf.data.Dataset, and handling generation preprocessing and postprocessing.

```python
import tensorflow as tf
import numpy as np

# Load the preprocessor from a preset.
preprocessor = keras_hub.models.T5GemmaSeq2SeqLMPreprocessor.from_preset(
    "t5gemma_b_b_prefixlm_it"
)

# For example usage, see the dictionary example below which provides
# both encoder and decoder text.
# Tokenize a batch of sentences.
preprocessor(["The quick brown fox jumped.", "Call me Ishmael."])
# Tokenize a dictionary with separate encoder and decoder inputs.
preprocessor({
    "encoder_text": "The quick brown fox jumped.",
    "decoder_text": "The fast fox."
})

# Apply tokenization to a [`tf.data.Dataset`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset).
encoder_features = tf.constant(["The quick brown fox.", "Call me Ishmael."])
decoder_features = tf.constant(["The fast fox.", "I am Ishmael."])
ds = tf.data.Dataset.from_tensor_slices(
    {"encoder_text": encoder_features, "decoder_text": decoder_features}
)
ds = ds.map(preprocessor, num_parallel_calls=tf.data.AUTOTUNE)

# Prepare tokens for generation.
preprocessor.generate_preprocess({
    "encoder_text": "The quick brown fox jumped.",
    "decoder_text": "The fast fox."
})

# Map generation outputs back to strings.
preprocessor.generate_postprocess({
    'decoder_token_ids': np.array([[2, 714, 4320, 8426, 25341, 1, 0, 0]]),
    'decoder_padding_mask': np.array([[1, 1, 1, 1, 1, 1, 0, 0]]),
})
```

--------------------------------

### Install Keras-Hub and Keras

Source: https://keras.io/keras_hub/getting_started

Install the keras-hub and keras libraries using pip. Ensure you have the latest versions for optimal performance.

```bash
!pip install --upgrade --quiet keras-hub keras

```

--------------------------------

### Install KerasHub and related libraries

Source: https://keras.io/keras_hub/guides/upload

Installs the necessary libraries for using KerasHub, Hugging Face Hub, and Kaggle Hub.

```bash
!pip install -q --upgrade keras-hub huggingface-hub kagglehub

```

--------------------------------

### Usage Examples for SmolLM3Backbone

Source: https://keras.io/keras_hub/api/models/smollm3/smollm3_backbone

Demonstrates loading a pre-trained model from a preset and initializing a custom model from scratch.

```python
input_data = {
    "token_ids": np.ones(shape=(1, 12), dtype="int32"),
    "padding_mask": np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]]),
}

# Pretrained SmolLM3 decoder.
model = keras_hub.models.SmolLM3Backbone.from_preset(
    "hf://HuggingFaceTB/SmolLM3-3B"
)
model(input_data)

# Randomly initialized SmolLM3 decoder with custom config.
model = keras_hub.models.SmolLM3Backbone(
    vocabulary_size=49152,
    hidden_dim=576,
    intermediate_dim=1536,
    num_layers=30,
    num_attention_heads=9,
    num_key_value_heads=3,
    attention_bias=False,
    attention_dropout=0.0,
    rope_layer_enabled_list=[True] * 30,
    layer_types=["attention"] * 30,
    mlp_bias=False,
    layer_norm_epsilon=1e-5,
    max_position_embeddings=2048,
    rope_theta=10000.0,
    partial_rotary_factor=1.0,
)
model(input_data)
```

--------------------------------

### Initialize and use DFineBackbone

Source: https://keras.io/keras_hub/api/models/d_fine/d_fine_backbone

Demonstrates basic model initialization without denoising and advanced initialization with contrastive denoising training.

```python
import keras
import numpy as np
from keras_hub.models import DFineBackbone
from keras_hub.models import HGNetV2Backbone

# Example 1: Basic usage without denoising.
# First, build the `HGNetV2Backbone` instance.
hgnetv2 = HGNetV2Backbone(
    stem_channels=[3, 16, 16],
    stackwise_stage_filters=[
        [16, 16, 64, 1, 3, 3],
        [64, 32, 256, 1, 3, 3],
        [256, 64, 512, 2, 3, 5],
        [512, 128, 1024, 1, 3, 5],
    ],
    apply_downsample=[False, True, True, True],
    use_lightweight_conv_block=[False, False, True, True],
    depths=[1, 1, 2, 1],
    hidden_sizes=[64, 256, 512, 1024],
    embedding_size=16,
    use_learnable_affine_block=True,
    hidden_act="relu",
    image_shape=(None, None, 3),
    out_features=["stage3", "stage4"],
    data_format="channels_last",
)

# Then, pass the backbone instance to `DFineBackbone`.
backbone = DFineBackbone(
    backbone=hgnetv2,
    decoder_in_channels=[128, 128],
    encoder_hidden_dim=128,
    num_denoising=0,  # Disable denoising
    num_labels=80,
    hidden_dim=128,
    learn_initial_query=False,
    num_queries=300,
    anchor_image_size=(256, 256),
    feat_strides=[16, 32],
    num_feature_levels=2,
    encoder_in_channels=[512, 1024],
    encode_proj_layers=[1],
    num_attention_heads=8,
    encoder_ffn_dim=512,
    num_encoder_layers=1,
    hidden_expansion=0.34,
    depth_multiplier=0.5,
    eval_idx=-1,
    num_decoder_layers=3,
    decoder_attention_heads=8,
    decoder_ffn_dim=512,
    decoder_n_points=[6, 6],
    lqe_hidden_dim=64,
    num_lqe_layers=2,
    out_features=["stage3", "stage4"],
    image_shape=(None, None, 3),
    data_format="channels_last",
    seed=0,
)

# Prepare input data.
input_data = keras.random.uniform((2, 256, 256, 3))

# Forward pass.
outputs = backbone(input_data)

# Example 2: With contrastive denoising training.
labels = [
    {
        "boxes": np.array([[0.5, 0.5, 0.2, 0.2], [0.4, 0.4, 0.1, 0.1]]),
        "labels": np.array([1, 10]),
    },
    {
        "boxes": np.array([[0.6, 0.6, 0.3, 0.3]]),
        "labels": np.array([20]),
    },
]

# Pass the `HGNetV2Backbone` instance to `DFineBackbone`.
backbone_with_denoising = DFineBackbone(
    backbone=hgnetv2,
    decoder_in_channels=[128, 128],
    encoder_hidden_dim=128,
    num_denoising=100,  # Enable denoising
    num_labels=80,
    hidden_dim=128,
    learn_initial_query=False,
    num_queries=300,
    anchor_image_size=(256, 256),
    feat_strides=[16, 32],
    num_feature_levels=2,
    encoder_in_channels=[512, 1024],
    encode_proj_layers=[1],
    num_attention_heads=8,
    encoder_ffn_dim=512,
    num_encoder_layers=1,
    hidden_expansion=0.34,
    depth_multiplier=0.5,
    eval_idx=-1,
    num_decoder_layers=3,
    decoder_attention_heads=8,
    decoder_ffn_dim=512,
    decoder_n_points=[6, 6],
    lqe_hidden_dim=64,
    num_lqe_layers=2,
    out_features=["stage3", "stage4"],
    image_shape=(None, None, 3),
    seed=0,
    labels=labels,
)

# Forward pass with denoising.
outputs_with_denoising = backbone_with_denoising(input_data)
```

--------------------------------

### RobertaTextClassifier Examples

Source: https://keras.io/keras_hub/api/models/roberta/roberta_text_classifier

Examples demonstrating how to use the RobertaTextClassifier with raw string data, preprocessed integer data, and custom backbones.

```APIDOC
### Examples

Raw string data.
```python
features = ["The quick brown fox jumped.", "I forgot my homework."]
labels = [0, 3]

# Pretrained classifier.
classifier = keras_hub.models.RobertaTextClassifier.from_preset(
    "roberta_base_en",
    num_classes=4,
)
classifier.fit(x=features, y=labels, batch_size=2)
classifier.predict(x=features, batch_size=2)

# Re-compile (e.g., with a new learning rate).
classifier.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    optimizer=keras.optimizers.Adam(5e-5),
    jit_compile=True,
)
# Access backbone programmatically (e.g., to change `trainable`).
classifier.backbone.trainable = False
# Fit again.
classifier.fit(x=features, y=labels, batch_size=2)

```

Preprocessed integer data.
```python
features = {
    "token_ids": np.ones(shape=(2, 12), dtype="int32"),
    "padding_mask": np.array([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]] * 2),
}
labels = [0, 3]

# Pretrained classifier without preprocessing.
classifier = keras_hub.models.RobertaTextClassifier.from_preset(
    "roberta_base_en",
    num_classes=4,
    preprocessor=None,
)
classifier.fit(x=features, y=labels, batch_size=2)

```

Custom backbone and vocabulary.
```python
features = ["a quick fox", "a fox quick"]
labels = [0, 3]

vocab = {"<s>": 0, "<pad>": 1, "</s>": 2, "<mask>": 3}
vocab = {**vocab, "a": 4, "Ġquick": 5, "Ġfox": 6}
merges = ["Ġ q", "u i", "c k", "ui ck", "Ġq uick"]
merges += ["Ġ f", "o x", "Ġf ox"]
tokenizer = keras_hub.models.RobertaTokenizer(
    vocabulary=vocab,
    merges=merges
)
preprocessor = keras_hub.models.RobertaTextClassifierPreprocessor(
    tokenizer=tokenizer,
    sequence_length=128,
)
backbone = keras_hub.models.RobertaBackbone(
    vocabulary_size=20,
    num_layers=4,
    num_heads=4,
    hidden_dim=256,
    intermediate_dim=512,
    max_sequence_length=128
)
classifier = keras_hub.models.RobertaTextClassifier(
    backbone=backbone,
    preprocessor=preprocessor,
    num_classes=4,
)
classifier.fit(x=features, y=labels, batch_size=2)

```
```

--------------------------------

### Initialize and run MoonshineBackbone

Source: https://keras.io/keras_hub/api/models/moonshine/moonshine_backbone

Demonstrates how to instantiate the MoonshineBackbone with custom parameters and perform a forward pass using dummy audio and token data.

```python
import numpy as np
import keras
from keras_hub.models import MoonshineBackbone

# Create random input data for demonstration.
# Input is now raw-ish audio features (e.g., from MoonshineAudioConverter).
encoder_raw_input_values = np.random.rand(1, 16000, 1).astype("float32")
# Mask corresponding to the raw input time dimension
encoder_padding_mask = np.ones((1, 16000), dtype="bool")
decoder_token_ids = np.random.randint(
    0, 1000, size=(1, 20), dtype="int32"
)
decoder_padding_mask = np.ones((1, 20), dtype="bool")

# Initialize the Moonshine backbone with specific parameters.
backbone = MoonshineBackbone(
    vocabulary_size=10000,
    filter_dim=256,
    encoder_num_layers=6,
    decoder_num_layers=6,
    hidden_dim=256,
    intermediate_dim=512,
    encoder_num_heads=8,
    decoder_num_heads=8,
    feedforward_expansion_factor=4,
    decoder_use_swiglu_activation=True,
    encoder_use_swiglu_activation=False,
)

# Forward pass through the model.
outputs = backbone(
    {
        "encoder_input_values": encoder_raw_input_values,
        "encoder_padding_mask": encoder_padding_mask,
        "decoder_token_ids": decoder_token_ids,
        "decoder_padding_mask": decoder_padding_mask,
    }
)
```