Keras

https://keras.io/
Admin
Keras is a deep learning API designed for human beings that provides a user-friendly interface for...
Tokens:3,823,442
Snippets:18,303
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### einsum setup example

Source: https://keras.io/api/ops/numpy

Setup for einsum examples, creating tensors a, b, and c used in subsequent examples.

```python
>>> from keras.src import ops
>>> a = ops.arange(25).reshape(5, 5)
>>> b = ops.arange(5)
>>> c = ops.arange(6).reshape(2, 3)

```

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

### Install dependencies

Source: https://keras.io/examples/vision/adamatch

Install the required libraries for the example.

```bash
pip install scipy pillow
```

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

### Install required packages for GCViT example

Source: https://keras.io/examples/vision/image_classification_using_global_context_vision_transformer

Install the necessary packages: keras_cv, tensorflow, and keras. This is the first step in setting up the environment for the example.

```bash
!pip install --upgrade keras_cv tensorflow
!pip install --upgrade keras

```

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

### Setup: Import required libraries

Source: https://keras.io/examples/vision/super_resolution_sub_pixel

Imports Keras, TensorFlow (for data preprocessing), and other necessary modules. This is the initial setup for the super-resolution example.

```python
import keras
from keras import layers
from keras import ops
from keras.utils import load_img
from keras.utils import array_to_img
from keras.utils import img_to_array
from keras.preprocessing import image_dataset_from_directory
import tensorflow as tf  #  only for data preprocessing

import os
import math
import numpy as np

from IPython.display import display

```

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

### Example: Setting up model parallel distribution with GemmaBackbone.get_layout_map

Source: https://keras.io/keras_hub/api/models/gemma/gemma_backbone

Example showing how to create a DeviceMesh, get a layout map, and use it with ModelParallel distribution to load a GemmaCausalLM model from a preset.

```python
# Feel free to change the mesh shape to balance data and model
# parallelism
mesh = keras.distribution.DeviceMesh(
    shape=(1, 8), axis_names=('batch', 'model'),
    devices=keras.distribution.list_devices())
layout_map = GemmaBackbone.get_layout_map(
    mesh, model_parallel_dim_name="model")

distribution = keras.distribution.ModelParallel(
    layout_map=layout_map, batch_dim_name='batch')
with distribution.scope():
   gemma_model = keras_hub.models.GemmaCausalLM.from_preset()

```

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

### Setup: Warning and Error Logs

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

Example of warning and error log messages that may appear during setup, indicating issues with cuDNN, cuBLAS, and computation placer registration.

```text
WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
E0000 00:00:1752300506.075074    4066 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
E0000 00:00:1752300506.079536    4066 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
W0000 00:00:1752300506.090992    4066 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.
W0000 00:00:1752300506.091002    4066 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.
W0000 00:00:1752300506.091004    4066 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.
W0000 00:00:1752300506.091005    4066 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.
```

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

### Setup imports for saving and loading

Source: https://keras.io/guides/serialization_and_saving

Imports numpy, keras, and keras.ops for the examples in this guide.

```python
import numpy as np
import keras
from keras import ops

```

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

### Setup and Model Loading

Source: https://keras.io/examples/vision/integrated_gradients

Initializes the environment by importing necessary libraries, defining image dimensions, and loading the pre-trained Xception model.

```python
import numpy as np
import matplotlib.pyplot as plt
from scipy import ndimage
from IPython.display import Image, display

import tensorflow as tf
import keras
from keras import layers
from keras.applications import xception


# Size of the input image
img_size = (299, 299, 3)

# Load Xception model with imagenet weights
model = xception.Xception(weights="imagenet")

# The local path to our target image
img_path = keras.utils.get_file("elephant.jpg", "https://i.imgur.com/Bvro0YD.png")
display(Image(img_path))
```

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

### Setup imports for CutMix example

Source: https://keras.io/examples/vision/cutmix

Imports numpy, keras, and matplotlib.pyplot for the CutMix augmentation example. This is the initial setup block for the notebook.

```python
import numpy as np
import keras
import matplotlib.pyplot as plt
```

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

### Setup environment and variables

Source: https://keras.io/examples/keras_recipes/sample_size_estimate

Initializes the Keras backend, imports necessary libraries, and sets a random seed for reproducibility.

```python
import os

os.environ["KERAS_BACKEND"] = "tensorflow"

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
import keras
from keras import layers
import tensorflow_datasets as tfds

# Define seed and fixed variables
seed = 42
keras.utils.set_random_seed(seed)
AUTO = tf.data.AUTOTUNE
```

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

### keras.ops.arange example with start and stop

Source: https://keras.io/api/ops/numpy

Generates values from start to stop (exclusive).

```python
>>> keras.ops.arange(3, 7)
array([3, 4, 5, 6], dtype=int32)
```

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

### Qwen3Backbone usage examples

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

Demonstrates loading a pretrained Qwen3 model with from_preset and creating a randomly initialized model with custom configuration, then calling the model on input data.

```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)
```

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

### Image conversion examples

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

Examples demonstrating how to initialize the converter for custom resizing and scaling, or by using a preset for a specific model.

```python
# Resize raw images and scale them to [0, 1].
converter = keras_hub.layers.ImageConverter(
    image_size=(128, 128),
    scale=1. / 255,
)
converter(np.random.randint(0, 256, size=(2, 512, 512, 3)))

# Resize images to the specific size needed for a PaliGemma preset.
converter = keras_hub.layers.ImageConverter.from_preset(
    "pali_gemma_3b_224"
)
converter(np.random.randint(0, 256, size=(2, 512, 512, 3)))
```

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

### Training Output Example 1

Source: https://keras.io/examples/vision/nerf

Example output from the start of the training process.

```text
Epoch 1/20
  1/16 ━[37m━━━━━━━━━━━━━━━━━━━  3:54 16s/step - loss: 0.0948 - psnr: 10.6234

WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
I0000 00:00:1699908753.457905   65271 device_compiler.h:187] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.

 1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 924ms/step
```

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

### Install KerasRS

Source: https://keras.io/keras_rs/examples/dcn

Install the KerasRS library to begin working with the recommender system examples.

```bash
!pip install -q keras-rs
```

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

### Setup environment and imports

Source: https://keras.io/examples/vision/learnable_resizer

Initializes the Keras backend and imports necessary libraries for data processing and visualization.

```python
import os

os.environ["KERAS_BACKEND"] = "tensorflow"
import keras
from keras import ops
from keras import layers
import tensorflow as tf

import tensorflow_datasets as tfds

tfds.disable_progress_bar()

import matplotlib.pyplot as plt
import numpy as np
```

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

### Install TensorFlow Docs

Source: https://keras.io/examples/generative/conditional_gan

Install the TensorFlow Docs package, which is required for this example. The command uses pip to install the package directly from the GitHub repository.

```bash
!pip install -q git+https://github.com/tensorflow/docs

```

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

### Setup and imports

Source: https://keras.io/examples/nlp/nl_image_search

Import necessary libraries and configure the environment for the dual encoder model.

```python
import os
import collections
import json
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import tensorflow_hub as hub
import tensorflow_text as text
import tensorflow_addons as tfa
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from tqdm import tqdm

# Suppressing tf.hub warnings
tf.get_logger().setLevel("ERROR")
```

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

### Install tensorflow-addons

Source: https://keras.io/examples/vision/barlow_twins

Installs the TensorFlow Addons package, which provides the LAMB optimizer and gaussian_blur_2d function used in the example.

```bash
!pip install tensorflow-addons

```

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

### RWKV7CausalLM initialization and generation example

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

Example of initializing the tokenizer, preprocessor, and model, loading from a preset, and generating text with a greedy sampler. Note the prompts list is split across two code blocks in the source.

```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

```python", "Hello World

```

```python
"]

    causal_lm.compile(sampler="greedy")

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

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

### Install networkx package

Source: https://keras.io/examples/graph/node2vec_movielens

Install the required networkx package using pip. This is a prerequisite for running the node2vec example.

```bash
pip install networkx

```

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

### Install dependencies and download demo images

Source: https://keras.io/guides/keras_cv/generate_images_with_stable_diffusion

Install Keras and KerasHub, then download sample images for the 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

```

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

### Import Libraries for KerasHub Quickstart

Source: https://keras.io/keras_hub

Imports Keras, KerasHub, NumPy, and TensorFlow Datasets for use in the quickstart examples.

```python
import keras
import keras_hub
import numpy as np
import tensorflow_datasets as tfds

```

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

### Install TensorFlow Similarity via pip

Source: https://keras.io/examples/vision/metric_learning_tf_similarity

Install the TensorFlow Similarity library using pip. This is a prerequisite for running the example.

```bash
pip -q install tensorflow_similarity

```

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

### T5GemmaSeq2SeqLMPreprocessor usage examples

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

Shows how to load the preprocessor from a preset, tokenize strings, use a dictionary with encoder/decoder text, apply to a tf.data.Dataset, and prepare for generation.

```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 imgaug library

Source: https://keras.io/examples/vision/keypoint_detection

Installs the imgaug library, required for data augmentation in this example. Requires TensorFlow 2.4 or higher.

```bash
!pip install -q -U imgaug

```

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

### keras.utils.bounding_boxes.crop usage example

Source: https://keras.io/api/utils/bounding_boxes

Example demonstrating how to crop a 30x40 region starting at (20, 10) from a set of bounding boxes.

```python
boxes = np.array([[10, 20, 50, 60], [70, 80, 100, 120]])  # xyxy format
cropped_boxes = keras.utils.bounding_boxes.crop(
    boxes, bounding_box_format="xyxy", top=10, left=20, height=40, width=30
)  # Cropping a 30x40 region starting at (20, 10)
print(cropped_boxes)
```

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

### from_preset usage examples

Source: https://keras.io/keras_hub/api/models/blip2/blip2_image_converter

Shows how to instantiate an ImageConverter from different presets and process image batches.

```python
batch = np.random.randint(0, 256, size=(2, 512, 512, 3))

# Resize images for "pali_gemma_3b_224".
converter = keras_hub.layers.ImageConverter.from_preset(
    "pali_gemma_3b_224"
)
converter(batch) # # Output shape (2, 224, 224, 3)

# Resize images for "pali_gemma_3b_448" without cropping.
converter = keras_hub.layers.ImageConverter.from_preset(
    "pali_gemma_3b_448",
    crop_to_aspect_ratio=False,
)
converter(batch) # # Output shape (2, 448, 448, 3)
```

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

### BLIP2Seq2SeqLMPreprocessor usage examples

Source: https://keras.io/keras_hub/api/models/blip2/blip2_seq_2_seq_lm_preprocessor

Demonstrates initializing the preprocessor from a preset, processing image and text inputs for training, and preparing inputs for generation.

```python
preprocessor = keras_hub.models.BLIP2Seq2SeqLMPreprocessor.from_preset(
    "blip2_flan_t5_xl"
)

# Image + text input.
preprocessor({
    "images": np.random.randint(0, 256, (2, 224, 224, 3)),
    "encoder_text": ["a photo of a cat", "a photo of a dog"],
    "decoder_text": ["a cat sitting", "a running dog"],
})

# Prepare an image and prompt for generation.
preprocessor.generate_preprocess({
    "images": np.random.randint(0, 256, (224, 224, 3)),
    "encoder_text": "a photo of",
})
```

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

### Install TensorFlow Text with pip

Source: https://keras.io/examples/nlp/multimodal_entailment

Installs the tensorflow_text package, required for the BERT model in this example. Run this command before importing the libraries.

```bash
!pip install -q tensorflow_text

```

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

### OPTTokenizer usage examples

Source: https://keras.io/keras_hub/api/models/opt/opt_tokenizer

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

```python
# Unbatched input.
tokenizer = keras_hub.models.OPTTokenizer.from_preset(
    "opt_125m_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 = {"<pad>": 1, "</s>": 2, "Ġquick": 4, "Ġfox": 5}
merges = ["Ġ q", "u i", "c k", "ui ck", "Ġq uick"]
merges += ["Ġ f", "o x", "Ġf ox"]
tokenizer = keras_hub.models.OPTTokenizer(vocabulary=vocab, merges=merges)
tokenizer("The quick brown fox jumped.")
```

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

### Install TensorFlow Addons

Source: https://keras.io/examples/keras_recipes/better_knowledge_distillation

Install TensorFlow Addons, required for the knowledge distillation recipes in this example. Requires TensorFlow 2.5 or higher.

```bash
!pip install -q tensorflow-addons

```

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

### Import libraries for the DNDF example

Source: https://keras.io/examples/structured_data/deep_neural_decision_forests

Import required Keras, TensorFlow data, NumPy, Pandas, and math libraries before starting the example.

```python
import keras
from keras import layers
from keras.layers import StringLookup
from keras import ops


from tensorflow import data as tf_data
import numpy as np
import pandas as pd

import math

```

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

### QwenBackbone usage examples

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

Demonstrates how to use the QwenBackbone model with input data. The first example loads a pretrained model using from_preset, and the second creates a randomly initialized model with a custom configuration. Both are called with the same input_data.

```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)
```

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

### Setup: Import Libraries and Configure Environment

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

Imports required libraries, sets the Keras backend to JAX, configures bfloat16 dtype policy, and includes commented instructions for Kaggle authentication.

```python
import os
import json
import random
import string
import re
import ast
import io
import sys
import contextlib

# Set backend before importing Keras
os.environ["KERAS_BACKEND"] = "jax"

import keras
import keras_hub
import kagglehub
import numpy as np

# Constants
USD_TO_EUR_RATE = 0.85

# Set the default dtype policy to bfloat16 for improved performance and reduced memory usage on supported hardware (e.g., TPUs, some GPUs)
keras.config.set_dtype_policy("bfloat16")

# Authenticate with Kaggle
# In Google Colab, you can set KAGGLE_USERNAME and KAGGLE_KEY as secrets,
# and kagglehub.login() will automatically detect and use them:
# kagglehub.login()
```

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

### Install KerasHub and Keras

Source: https://keras.io/examples/generative/text_generation_gpt

Install the latest versions of KerasHub and Keras (upgrading to Keras 3) using pip. This is required before running the example.

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

```

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

### SigLIPPreprocessor usage examples

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

Demonstrates loading the preprocessor from a preset and using it to preprocess a single input and a batch of inputs. The first example shows a single prompt and image, while the second shows a batch of prompts and images.

```python
# Load the preprocessor from a preset.
preprocessor = keras_hub.models.SigLIPPreprocessor.from_preset(
    "siglip_base_patch16_224"
)

# Tokenize the sentence and preprocess the image.
preprocessor(
    {
        "prompts": "The quick brown fox jumped.",
        "images": np.ones(shape=(123, 123, 3)),
    }
)

# Tokenize a batch of sentences and preprocess a batch of images.
preprocessor(
    {
        "prompts": ["The quick brown fox jumped.", "The fox slept."],
        "images": np.ones(shape=(2, 123, 123, 3)),
    }
)
```

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

### Install TensorFlow Addons and TensorFlow I/O

Source: https://keras.io/examples/audio/melgan_spectrogram_inversion

Installs the required packages for the example: tensorflow_addons and tensorflow-io. Uses pip with quiet mode to suppress output.

```bash
!pip install -qqq tensorflow_addons
!pip install -qqq tensorflow-io

```
Tokens:
Raw