Keras API

https://keras.io/api
Admin
The Keras API documentation provides comprehensive details on models, layers, callbacks, and other...
Tokens:587,392
Snippets:4,248
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### diag setup example

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

Initial setup for diagonal operation examples.

```python
>>> from keras.src import ops
>>> x = ops.arange(9).reshape((3, 3))
>>> x
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
```

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

### einsum setup

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

Initializes tensors for Einstein summation 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)
```

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

### Example of Compiling a Model

Source: https://keras.io/api/models/model_training_apis

Demonstrates how to compile a Keras model with a specific optimizer, loss function, and metrics. This setup is typical for binary classification tasks.

```python
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss=keras.losses.BinaryCrossentropy(),
    metrics=[
        keras.metrics.BinaryAccuracy(),
        keras.metrics.FalseNegatives(),
    ],
)

```

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

### Initialize Distribution System (Example 1: Direct Arguments)

Source: https://keras.io/api/distribution/distribution_utils

Example of initializing the distribution system using direct arguments for `job_addresses`, `num_processes`, and `process_id`.

```python
keras.distribute.initialize(
    job_addresses="10.0.0.1:1234,10.0.0.2:2345",
    num_processes=2,
    process_id=0)

```

```python
keras.distribute.initialize(
    job_addresses="10.0.0.1:1234,10.0.0.2:2345",
    num_processes=2,
    process_id=1)

```

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

### Initialize Distribution System (Example 2: Environment Variables)

Source: https://keras.io/api/distribution/distribution_utils

Example of initializing the distribution system by setting environment variables for `KERAS_DISTRIBUTION_JOB_ADDRESSES`, `KERAS_DISTRIBUTION_NUM_PROCESSES`, and `KERAS_DISTRIBUTION_PROCESS_ID`.

```python
os.environ[
    "KERAS_DISTRIBUTION_JOB_ADDRESSES"] = "10.0.0.1:1234,10.0.0.2:2345"
os.environ["KERAS_DISTRIBUTION_NUM_PROCESSES"] = "2"
os.environ["KERAS_DISTRIBUTION_PROCESS_ID"] = "0"
keras.distribute.initialize()

```

```python
os.environ[
    "KERAS_DISTRIBUTION_JOB_ADDRESSES"] = "10.0.0.1:1234,10.0.0.2:2345"
os.environ["KERAS_DISTRIBUTION_NUM_PROCESSES"] = "2"
os.environ["KERAS_DISTRIBUTION_PROCESS_ID"] = "1"
keras.distribute.initialize()

```

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

### diag construction example

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

Example showing how to construct a diagonal matrix.

```python
>>> ops.diag(ops.diag(x)))
array([[0, 0, 0],
       [0, 4, 0],
       [0, 0, 8]])
```

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

### Example Usage: CosineDecay Without Warmup

Source: https://keras.io/api/optimizers/learning_rate_schedules/cosine_decay

Demonstrates how to instantiate the CosineDecay schedule for a standard cosine decay without a warmup phase. This is useful when a gradual increase is not needed at the start of training.

```python
decay_steps = 1000
initial_learning_rate = 0.1
lr_decayed_fn = keras.optimizers.schedules.CosineDecay(
    initial_learning_rate, decay_steps)

```

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

### smart_resize usage example

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

Example of using smart_resize to maintain aspect ratio while resizing images to a target size.

```python
size = (200, 200)
ds = ds.map(lambda img: smart_resize(img, size))
```

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

### adaptive_max_pool usage examples

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

Examples demonstrating adaptive max pooling with specific output dimensions and variable input sizes.

```python
>>> x = np.random.rand(2, 64, 64, 3)
>>> y = keras.ops.adaptive_max_pool(x, output_size=(32, 32))
>>> y.shape
(2, 32, 32, 3)
```

```python
>>> # Works with any input size
>>> x = np.random.rand(2, 100, 80, 3)
>>> y = keras.ops.adaptive_max_pool(x, output_size=7)
>>> y.shape
(2, 7, 7, 3)
```

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

### Example Usage of CosineSimilarity

Source: https://keras.io/api/metrics/regression_metrics

Demonstrates how to use the CosineSimilarity metric with update_state and result methods. Includes an example with sample weights.

```python
>>> # l2_norm(y_true) = [[0., 1.], [1./1.414, 1./1.414]]
>>> # l2_norm(y_pred) = [[1., 0.], [1./1.414, 1./1.414]]
>>> # l2_norm(y_true) . l2_norm(y_pred) = [[0., 0.], [0.5, 0.5]]
>>> # result = mean(sum(l2_norm(y_true) . l2_norm(y_pred), axis=1))
>>> #        = ((0. + 0.) +  (0.5 + 0.5)) / 2
>>> m = keras.metrics.CosineSimilarity(axis=1)
>>> m.update_state([[0., 1.], [1., 1.]], [[1., 0.], [1., 1.]])
>>> m.result()
0.49999997
```

```python
>>> m.reset_state()
>>> m.update_state([[0., 1.], [1., 1.]], [[1., 0.], [1., 1.]],
...                sample_weight=[0.3, 0.7])
>>> m.result()
0.6999999
```

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

### nanmin usage examples

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

Examples demonstrating nanmin on a 2D array, including axis reduction and dimension preservation.

```python
>>> import numpy as np
>>> from keras import ops
>>> x = np.array([[1.0, np.nan, 3.0],
...               [np.nan, 2.0, 1.0]])
>>> ops.nanmin(x)
1.0
```

```python
>>> ops.nanmin(x, axis=1)
array([1., 1.])
```

```python
>>> ops.nanmin(x, axis=1, keepdims=True)
array([[1.],
       [1.]])
```

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

### Cropping3D Layer Example

Source: https://keras.io/api/layers/reshaping_layers/cropping3d

Demonstrates how to use the Cropping3D layer to crop a 5D input tensor. The example shows the input shape and the resulting output shape after cropping.

```python
>>> input_shape = (2, 28, 28, 10, 3)
>>> x = np.arange(np.prod(input_shape)).reshape(input_shape)
>>> y = keras.layers.Cropping3D(cropping=(2, 4, 2))(x)
>>> y.shape
(2, 24, 20, 6, 3)
```

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

### adaptive_average_pool usage examples

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

Examples demonstrating adaptive average pooling with specific output dimensions and variable input sizes.

```python
>>> x = np.random.rand(2, 64, 64, 3)
>>> y = keras.ops.adaptive_average_pool(x, output_size=(32, 32))
>>> y.shape
(2, 32, 32, 3)
```

```python
>>> # Works with any input size
>>> x = np.random.rand(2, 100, 80, 3)
>>> y = keras.ops.adaptive_average_pool(x, output_size=7)
>>> y.shape
(2, 7, 7, 3)
```

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

### Get Keras Version

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

Retrieves the installed Keras version.

```python
keras.version()
```

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

### Example: Training with Interruption and Restore

Source: https://keras.io/api/callbacks/backup_and_restore

Demonstrates using BackupAndRestore to handle training interruptions. The model is trained, an interruption is simulated, and then training is resumed from the saved state.

```python
class InterruptingCallback(keras.callbacks.Callback):
  def on_epoch_begin(self, epoch, logs=None):
    if epoch == 4:
      raise RuntimeError('Interrupting!')
callback = keras.callbacks.BackupAndRestore(backup_dir="/tmp/backup")
model = keras.models.Sequential([keras.layers.Dense(10)])
model.compile(keras.optimizers.SGD(), loss='mse')
model.build(input_shape=(None, 20))
try:
  model.fit(np.arange(100).reshape(5, 20), np.zeros(5), epochs=10,
            batch_size=1, callbacks=[callback, InterruptingCallback()],
            verbose=0)
except:
  pass
history = model.fit(np.arange(100).reshape(5, 20), np.zeros(5),
                    epochs=10, batch_size=1, callbacks=[callback],
                    verbose=0)
# Only 6 more epochs are run, since first training got interrupted at
# zero-indexed epoch 4, second training will continue from 4 to 9.
len(history.history['loss'])
```

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

### Instantiate FlaxLayer with Default __call__ Method

Source: https://keras.io/api/layers/backend_specific_layers/flax_layer

Example of creating a FlaxLayer using a Flax Module with its default __call__ method. No special setup is required for the module's signature.

```python
class MyFlaxModule(flax.linen.Module):
    @flax.linen.compact
    def __call__(self, inputs):
        x = inputs
        x = flax.linen.Conv(features=32, kernel_size=(3, 3))(x)
        x = flax.linen.relu(x)
        x = flax.linen.avg_pool(x, window_shape=(2, 2), strides=(2, 2))
        x = x.reshape((x.shape[0], -1))  # flatten
        x = flax.linen.Dense(features=200)(x)
        x = flax.linen.relu(x)
        x = flax.linen.Dense(features=10)(x)
        x = flax.linen.softmax(x)
        return x

flax_module = MyFlaxModule()
keras_layer = FlaxLayer(flax_module)
```

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

### Using StackedRNNCells with RNN Layer

Source: https://keras.io/api/layers/recurrent_layers/stacked_rnn_cell

Demonstrates how to use StackedRNNCells to create a stacked LSTM layer within a Keras RNN layer. This example shows the setup and application of the stacked cells.

```python
batch_size = 3
sentence_length = 5
num_features = 2
new_shape = (batch_size, sentence_length, num_features)
x = np.reshape(np.arange(30), new_shape)

rnn_cells = [keras.layers.LSTMCell(128) for _ in range(2)]
stacked_lstm = keras.layers.StackedRNNCells(rnn_cells)
lstm_layer = keras.layers.RNN(stacked_lstm)

result = lstm_layer(x)
```

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

### Initialize Distribution System (Multi-Host/Process)

Source: https://keras.io/api/distribution/distribution_utils

Prepares the distribution system for multi-host or multi-process execution on GPUs or TPUs. This should be called before any computations. Parameters can also be set via environment variables.

```python
keras.distribution.initialize(
    job_addresses=None, num_processes=None, process_id=None
)
```

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

### Constructing and Using ModelParallel

Source: https://keras.io/api/distribution/model_parallel

Example demonstrating how to construct a DeviceMesh, LayoutMap, and ModelParallel distribution, then apply it to a model.

```python
devices = list_devices()    # Assume there are 8 devices.

# Create a mesh with 2 devices for data parallelism and 4 devices for
# model parallelism.
device_mesh = DeviceMesh(shape=(2, 4), axis_names=('batch', 'model'),
                         devices=devices)
# Create a layout map that shard the `Dense` layer and `Conv2D`
# layer variables on the last dimension.
# Based on the `device_mesh`, this means the variables
# will be split across 4 devices. Any other variable that doesn't
# match any key in the layout map will be fully replicated.
layout_map = LayoutMap(device_mesh)
layout_map['.*dense.*kernel'] = (None, 'model')
layout_map['.*dense.*bias'] = ('model',)
layout_map['.*conv2d.*kernel'] = (None, None, None, 'model')
layout_map['.*conv2d.*bias'] = ('model',)

distribution = ModelParallel(
    layout_map=layout_map,
    batch_dim_name='batch',
)

# Set the global distribution, or via `with distribution.scope():`
set_distribution(distribution)

model = model_creation()
model.compile()
model.fit(data)

```

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

### Update and Get Result for BinaryCrossentropy

Source: https://keras.io/api/metrics/probabilistic_metrics

Updates the state of the BinaryCrossentropy metric with true labels and predictions, then returns the computed metric result. This example shows basic usage without sample weights.

```python
>>> m = keras.metrics.BinaryCrossentropy()
>>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]])
>>> m.result()
0.81492424
```

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

### Create and Modify Config

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

Demonstrates how to create a `Config` object using constructor arguments and modify it using attribute-style and dict-style access.

```python
config = Config("learning_rate"=0.1, "momentum"=0.9)

# Then keep adding to it via attribute-style setting
config.use_ema = True
config.ema_overwrite_frequency = 100

# You can also add attributes via dict-like access
config["seed"] = 123

# You can retrieve entries both via attribute-style
# access and dict-style access
assert config.seed == 100
assert config["learning_rate"] == 0.1
```

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

### Instantiate and Use a Dense Layer

Source: https://keras.io/api/layers

Demonstrates how to instantiate a `Dense` layer with a specified number of units and activation function, and then apply it to input data.

```python
import keras
from keras import layers

layer = layers.Dense(32, activation='relu')
inputs = keras.random.uniform(shape=(10, 20))
outputs = layer(inputs)
```

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

### Get Reuters Word Index

Source: https://keras.io/api/datasets/reuters

Retrieves a dictionary mapping words to their corresponding indices in the Reuters dataset. Note that actual word indices in the data are offset by 3 due to reserved indices for padding, start, and out-of-vocabulary characters.

```python
keras.datasets.reuters.get_word_index(path="reuters_word_index.json")

```

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

### Using TorchModuleWrapper with PyTorch Modules in Keras

Source: https://keras.io/api/layers/backend_specific_layers/torch_module_wrapper

Demonstrates how to wrap PyTorch nn.Module instances with TorchModuleWrapper to create a Keras Model. This example shows integrating convolutional, pooling, dropout, and linear layers from PyTorch into a Keras classifier. Ensure PyTorch is installed and configured as the backend.

```python
import torch
import torch.nn as nn
import torch.nn.functional as F

import keras
from keras.layers import TorchModuleWrapper

class Classifier(keras.Model):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        # Wrap `torch.nn.Module`s with `TorchModuleWrapper`
        # if they contain parameters
        self.conv1 = TorchModuleWrapper(
            nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(3, 3))
        )
        self.conv2 = TorchModuleWrapper(
            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(3, 3))
        )
        self.pool = nn.MaxPool2d(kernel_size=(2, 2))
        self.flatten = nn.Flatten()
        self.dropout = nn.Dropout(p=0.5)
        self.fc = TorchModuleWrapper(nn.Linear(1600, 10))

    def call(self, inputs):
        x = F.relu(self.conv1(inputs))
        x = self.pool(x)
        x = F.relu(self.conv2(x))
        x = self.pool(x)
        x = self.flatten(x)
        x = self.dropout(x)
        x = self.fc(x)
        return F.softmax(x, dim=1)


model = Classifier()
model.build((1, 28, 28))
print("# Output shape", model(torch.ones(1, 1, 28, 28).to("cuda")).shape)

model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer="adam",
    metrics=["accuracy"]
)
model.fit(train_loader, epochs=5)

```

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

### Instantiate Input and Build a Model

Source: https://keras.io/api/layers/core_layers/input

Example demonstrating how to use the `Input` object to define the input shape and then build a simple Keras model using `Dense` and `Model`.

```python
# This is a logistic regression in Keras
x = Input(shape=(32,))
y = Dense(16, activation='softmax')(x)
model = Model(x, y)
```

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

### Distillation with Multiple Losses and Custom Weights

Source: https://keras.io/api/models/distillation/distiller

Illustrates configuring a Distiller with multiple distillation losses and their corresponding weights. The distiller is then compiled with custom settings.

```python
# Multiple distillation losses
distiller = Distiller(
    teacher=teacher,
    student=student,
    distillation_losses=[
        LogitsDistillation(temperature=3.0),
        FeatureDistillation(
            teacher_layer_name="dense_1",
            student_layer_name="dense_1"
        )
    ],
    distillation_loss_weights=[1.0, 0.5],
)

# Compile with custom settings
distiller.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

```

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

### sinc function example

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

Example usage of the sinc function.

```python
>>> x = keras.ops.convert_to_tensor([0.0, 1.0, 2.0])
>>> keras.ops.sinc(x)
array([1., 0., 0.], dtype=float32)
```

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

### Basic Metric Usage Example

Source: https://keras.io/api/metrics/base_metric

Demonstrates the typical lifecycle of a metric: initialization, updating state with data, and retrieving the final result.

```python
m = SomeMetric(...)
for input in ...:
    m.update_state(input)
print('Final result: ', m.result())
```

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

### deg2rad usage examples

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

Examples showing conversion of degrees to radians.

```python
>>> from keras import ops
>>> ops.deg2rad(180.0)
3.141592653589793
>>> ops.deg2rad([0.0, 90.0, 180.0])
array([0., 1.57079633, 3.14159265])
```

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

### Configure a loss class instance

Source: https://keras.io/api/losses

Example of passing configuration arguments during the instantiation of a loss class.

```python
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
```

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

### Example: Hashing Layer with FarmHash64

Source: https://keras.io/api/layers/preprocessing_layers/categorical/hashing

Demonstrates the basic usage of the Hashing layer with the default FarmHash64 algorithm. It hashes string inputs into integer bins.

```python
>>> layer = keras.layers.Hashing(num_bins=3)
>>> inp = [['A'], ['B'], ['C'], ['D'], ['E']]
>>> layer(inp)
array([[1],
        [0],
        [1],
        [1],
        [2]])>
```

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

### blackman usage example

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

Example usage of the blackman window function.

```python
>>> keras.ops.blackman(x)
array([-1.4901161e-08,  3.4000003e-01,  9.9999994e-01,  3.3999997e-01,
   -1.4901161e-08], dtype=float32)
```

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

### Example: Hashing Layer with SipHash64 Salt

Source: https://keras.io/api/layers/preprocessing_layers/categorical/hashing

Demonstrates using the SipHash64 algorithm with a salt for obfuscated hashing. The salt value is provided as a list of integers.

```python
>>> layer = keras.layers.Hashing(num_bins=3, salt=[133, 137])
>>> inp = [['A'], ['B'], ['C'], ['D'], ['E']]
>>> layer(inp)
array([[1],
        [2],
        [1],
        [0],
        [2]])
```

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

### keras.ops.angle example

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

Example showing the calculation of the angle for a complex tensor.

```python
>>> x = keras.ops.convert_to_tensor([[1 + 3j, 2 - 5j], [4 - 3j, 3 + 2j]])
>>> keras.ops.angle(x)
array([[ 1.2490457, -1.19029  ],
   [-0.6435011,  0.5880026]], dtype=float32)
```

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

### select function example

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

Example usage of the select function with conditions and choices.

```python
from keras import ops

x = ops.arange(6)
condlist = [x<3, x>3]
choicelist = [x, x**2]
ops.select(condlist, choicelist, 42)
# # Returns tensor([0,  1,  2, 42, 16, 25])
```

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

### diag extraction examples

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

Examples showing how to extract diagonals with different offsets.

```python
>>> ops.diag(x)
array([0, 4, 8])
>>> ops.diag(x, k=1)
array([1, 5])
>>> ops.diag(x, k=-1)
array([3, 7])
```

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

### Softmax Layer Usage Example

Source: https://keras.io/api/layers/activation_layers/softmax

Demonstrates how to instantiate and use the Softmax layer with a sample input array. The output represents a probability distribution.

```python
>>> softmax_layer = keras.layers.Softmax()
>>> input = np.array([1.0, 2.0, 1.0])
>>> result = softmax_layer(input)
>>> result
[0.21194157, 0.5761169, 0.21194157]
```

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

### CIFAR10PyDataset implementation example

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

An example implementation of PyDataset for loading and resizing images in batches.

```python
from skimage.io import imread
from skimage.transform import resize
import numpy as np
import math

# Here, `x_set` is list of path to the images
# and `y_set` are the associated classes.

class CIFAR10PyDataset(keras.utils.PyDataset):

    def __init__(self, x_set, y_set, batch_size, **kwargs):
        super().__init__(**kwargs)
        self.x, self.y = x_set, y_set
        self.batch_size = batch_size

    def __len__(self):
        # Return number of batches.
        return math.ceil(len(self.x) / self.batch_size)

    def __getitem__(self, idx):
        # Return x, y for batch idx.
        low = idx * self.batch_size
        # Cap upper bound at array length; the last batch may be smaller
        # if the total number of items is not a multiple of batch size.
        high = min(low + self.batch_size, len(self.x))
        batch_x = self.x[low:high]
        batch_y = self.y[low:high]

        return np.array([
            resize(imread(file_name), (200, 200))
               for file_name in batch_x]), np.array(batch_y)
```

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

### Listing Model Variable Paths

Source: https://keras.io/api/distribution/model_parallel

Example demonstrating how to list all model variable paths to help define layout mapping rules.

```python
model = create_model()
for v in model.variables:
    print(v.path)

```

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

### rot90 3D array example

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

Example of rotating a 3D array using specific axes.

```python
>>> m = np.arange(8).reshape((2, 2, 2))
>>> rotated = ops.rot90(m, k=1, axes=(1, 2))
>>> rotated
array([[[1, 3],
        [0, 2]],
       [[5, 7],
        [4, 6]]])
```

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

### bincount usage examples

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

Demonstrates basic counting, weighted counting, and using the minlength argument.

```python
>>> x = keras.ops.array([1, 2, 2, 3], dtype="uint8")
>>> keras.ops.bincount(x)
array([0, 1, 2, 1], dtype=int32)
>>> weights = x / 2
>>> weights
array([0.5, 1., 1., 1.5], dtype=float64)
>>> keras.ops.bincount(x, weights=weights)
array([0., 0.5, 2., 1.5], dtype=float64)
>>> minlength = (keras.ops.max(x).numpy() + 1) + 2 # 6
>>> keras.ops.bincount(x, minlength=minlength)
array([0, 1, 2, 1, 0, 0], dtype=int32)
```

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

### IoU Metric Calculation Example

Source: https://keras.io/api/metrics/segmentation_metrics

Demonstrates how to instantiate and use the IoU metric with update_state and result methods. Assumes sparse labels.

```python
>>> # cm = [[1, 1],
>>> #        [1, 1]]
>>> # sum_row = [2, 2], sum_col = [2, 2], true_positives = [1, 1]
>>> # iou = true_positives / (sum_row + sum_col - true_positives))
>>> # iou = [0.33, 0.33]
>>> m = keras.metrics.IoU(num_classes=2, target_class_ids=[0])
>>> m.update_state([0, 0, 1, 1], [0, 1, 0, 1])
>>> m.result()
0.33333334
```

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

### rot90 2D array example

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

Example of rotating a 2D array using the default axes.

```python
>>> import numpy as np
>>> from keras import ops
>>> m = np.array([[1, 2], [3, 4]])
>>> rotated = ops.rot90(m)
>>> rotated
array([[2, 4],
       [1, 3]])
```

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

### keras.ops.any examples

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

Examples demonstrating logical OR reduction, including axis specification and keepdims usage.

```python
>>> x = keras.ops.convert_to_tensor([True, False])
>>> keras.ops.any(x)
array(True, shape=(), dtype=bool)
```

```python
>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.any(x, axis=0)
array([ True  True], shape=(2,), dtype=bool)
```

```python
>>> x = keras.ops.convert_to_tensor([[True, False], [True, True]])
>>> keras.ops.all(x, keepdims=True)
array([[False]], shape=(1, 1), dtype=bool)
```

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

### Example Usage: CosineDecay With Warmup

Source: https://keras.io/api/optimizers/learning_rate_schedules/cosine_decay

Shows how to configure the CosineDecay schedule to include a linear warmup phase, gradually increasing the learning rate before applying the cosine decay. This is beneficial for stabilizing early training.

```python
decay_steps = 1000
initial_learning_rate = 0
warmup_steps = 1000
target_learning_rate = 0.1
lr_warmup_decayed_fn = keras.optimizers.schedules.CosineDecay(
    initial_learning_rate, decay_steps, warmup_target=target_learning_rate,
    warmup_steps=warmup_steps
)

```

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

### Resuming Training from Weight-Only Checkpoints

Source: https://keras.io/api/callbacks/model_checkpoint

Demonstrates how to correctly resume training from a weight-only checkpoint. It's crucial to compile the model *before* loading the weights to restore the optimizer state, especially for learning rate schedules.

```python
# Define a learning rate schedule
initial_learning_rate = 0.1
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate,
    decay_steps=100000,
    decay_rate=0.96,
    staircase=True,
)

# 1. Create a fresh model instance
model = get_model()

# 2. Compile the model *before* loading weights
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=lr_schedule),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

# 3. Load weights (optimizer state is restored automatically)
model.load_weights(checkpoint_filepath)

# 4. Continue training
model.fit(x_train, y_train, epochs=10)
```

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

### celu usage example

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

Example demonstrating the application of the CELU activation function on an input array.

```python
>>> x = np.array([-1., 0., 1.])
>>> x_celu = keras.ops.celu(x)
>>> print(x_celu)
array([-0.63212056, 0. , 1. ], shape=(3,), dtype=float64)
```

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

### Example of setting mixed_float16 policy

Source: https://keras.io/api/mixed_precision/policy

An example demonstrating how to set the global dtype policy to mixed_float16.

```python
>>> keras.config.set_dtype_policy("mixed_float16")
```

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

### GlorotUniform Initializer Usage

Source: https://keras.io/api/layers/initializers

Demonstrates how to use the GlorotUniform initializer standalone to generate weight values.

```python
keras.initializers.GlorotUniform(seed=None, input_axes=None, output_axes=None)


```

```python
>>> # Standalone usage:
>>> initializer = GlorotUniform()
>>> values = initializer(shape=(2, 2))
```

```python
>>> # Usage in a Keras layer:
>>> initializer = GlorotUniform()
>>> layer = Dense(3, kernel_initializer=initializer)
```

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

### Load and Verify MNIST Dataset

Source: https://keras.io/api/datasets/mnist

This example demonstrates how to load the MNIST dataset and verify the shapes of the returned training and testing data arrays. Ensure the dataset is downloaded and accessible.

```python
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
assert x_train.shape == (60000, 28, 28)
assert x_test.shape == (10000, 28, 28)
assert y_train.shape == (60000,)
assert y_test.shape == (10000,)
```

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

### keras.ops.amin examples

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

Examples demonstrating finding the minimum value in an array, along an axis, and with keepdims enabled.

```python
>>> x = keras.ops.convert_to_tensor([1, 3, 5, 2, 3, 6])
>>> keras.ops.amin(x)
array(1, dtype=int32)
```

```python
>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [7, 5, 3]])
>>> keras.ops.amin(x, axis=0)
array([1,5,3], dtype=int32)
```

```python
>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [7, 5, 3]])
>>> keras.ops.amin(x, axis=1, keepdims=True)
array([[1],[3]], dtype=int32)
```

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

### keras.ops.amax examples

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

Examples demonstrating finding the maximum value in an array, along an axis, and with keepdims enabled.

```python
>>> x = keras.ops.convert_to_tensor([[1, 3, 5], [2, 3, 6]])
>>> keras.ops.amax(x)
array(6, dtype=int32)
```

```python
>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [1, 5, 2]])
>>> keras.ops.amax(x, axis=0)
array([1, 6, 8], dtype=int32)
```

```python
>>> x = keras.ops.convert_to_tensor([[1, 6, 8], [1, 5, 2]])
>>> keras.ops.amax(x, axis=1, keepdims=True)
array([[8], [5]], dtype=int32)
```

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

### Cropping2D Layer Example

Source: https://keras.io/api/layers/reshaping_layers/cropping2d

Demonstrates how to use the Cropping2D layer with a sample input tensor. It shows the input shape and the resulting output shape after applying cropping.

```python
input_shape = (2, 28, 28, 3)
x = np.arange(np.prod(input_shape)).reshape(input_shape)
y = keras.layers.Cropping2D(cropping=((2, 2), (4, 4)))(x)
y.shape
```

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

### Directory Structure Example

Source: https://keras.io/api/data_loading

Illustrates the expected directory structure for image classification datasets when using `image_dataset_from_directory`.

```text
training_data/
...class_a/
......a_image_1.jpg
......a_image_2.jpg
...class_b/
......b_image_1.jpg
......b_image_2.jpg
etc.

```

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

### categorical_crossentropy usage example

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

Example demonstrating the computation of categorical cross-entropy loss between target and output tensors.

```python
>>> target = keras.ops.convert_to_tensor(
... [[1, 0, 0],
...  [0, 1, 0],
...  [0, 0, 1]])
>>> output = keras.ops.convert_to_tensor(
... [[0.9, 0.05, 0.05],
...  [0.1, 0.8, 0.1],
...  [0.2, 0.3, 0.5]])
>>> categorical_crossentropy(target, output)
array([0.10536054 0.22314355 0.6931472 ], shape=(3,), dtype=float32)
```

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

### Basic TensorBoard Callback Usage

Source: https://keras.io/api/callbacks/tensorboard

Example of how to instantiate and use the TensorBoard callback during model training.

```python
tensorboard_callback = keras.callbacks.TensorBoard(log_dir="./logs")
model.fit(x_train, y_train, epochs=2, callbacks=[tensorboard_callback])
# Then run the tensorboard command to view the visualizations.
```

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

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

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

Example demonstrating how to crop bounding boxes using specific offsets and dimensions.

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

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

### Prepare Image for Model Prediction

Source: https://keras.io/api/data_loading/image

This example demonstrates a common workflow: loading an image, converting it to a NumPy array, and then reshaping it into a batch for model prediction.

```python
image = keras.utils.load_img(image_path)
input_arr = keras.utils.img_to_array(image)
input_arr = np.array([input_arr])  # Convert single image to a batch.
predictions = model.predict(input_arr)
```

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

### percentile function examples

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

Examples demonstrating how to compute percentiles for single values, sequences, and across specific axes.

```python
>>> import keras
>>> from keras import ops
>>> x = keras.ops.array([1., 2., 3., 4.])
>>> keras.ops.percentile(x, 50)
2.5
>>> x = keras.ops.array([1., 2., 3., 4.])
>>> keras.ops.percentile(x, [25, 75])
array([1.75, 3.25])
>>> x = keras.ops.array([[1., 2., 3.],
...                      [4., 5., 6.]])
>>> keras.ops.percentile(x, 50, axis=1)
array([2., 5.])
```

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

### Basic Distillation with KerasHub Models

Source: https://keras.io/api/models/distillation/distiller

Demonstrates setting up and compiling a Distiller with a single distillation loss using KerasHub models. The trained student model can be accessed after training.

```python
# Basic distillation with KerasHub models
import keras_hub as hub

teacher = hub.models.CausalLM.from_preset("gemma_2b_en")
student = hub.models.CausalLM.from_preset(
    "gemma_1.1_2b_en", load_weights=False
)

# Single distillation loss
distiller = Distiller(
    teacher=teacher,
    student=student,
    distillation_losses=LogitsDistillation(temperature=3.0),
)

# Compile the distiller (like any Keras model)
distiller.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Train the distiller
distiller.fit(x_train, y_train, epochs=10)

# Access the trained student model
trained_student = distiller.student

```

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

### nanprod usage examples

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

Examples demonstrating nanprod on a 2D array, including axis reduction and dimension preservation.

```python
>>> import numpy as np
>>> from keras import ops
>>> x = np.array([[1.0, np.nan, 3.0],
...               [np.nan, 2.0, 1.0]])
>>> ops.nanprod(x)
6.0
```

```python
>>> ops.nanprod(x, axis=1)
array([3., 2.])
```

```python
>>> ops.nanprod(x, axis=1, keepdims=True)
array([[3.],
       [2.]])
```

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

### nanpercentile usage examples

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

Examples showing percentile calculation with and without NaNs, using sequences, and specifying axes.

```python
>>> import keras
>>> from keras import ops
>>> x = keras.ops.array([1., 2., 3., 4.])
>>> keras.ops.nanpercentile(x, 50)
2.5
>>> x = keras.ops.array([1., 2., float("nan"), 4.])
>>> keras.ops.nanpercentile(x, 50)
2.0
>>> x = keras.ops.array([1., 2., 3., 4.])
>>> keras.ops.nanpercentile(x, [25, 75])
array([1.75, 3.25])
>>> x = keras.ops.array([[1., 2., float("nan")],
...                      [4., 5., 6.]])
>>> keras.ops.nanpercentile(x, 50, axis=1)
array([1.5, 5.0])
```

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

### Launching TensorBoard from Command Line

Source: https://keras.io/api/callbacks/tensorboard

Command to launch TensorBoard to view saved log files. Ensure TensorFlow is installed.

```bash
tensorboard --logdir=path_to_your_logs
```

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

### Practical example of keras.device for preprocessing and training

Source: https://keras.io/api/scope/context_managers

Illustrates a practical use case of `keras.device` for preprocessing data on CPU and then training a model on GPU.

```python
# Create dummy data and model
x_raw = np.random.rand(128, 784)
y_train = np.random.randint(0, 10, size=(128,))
model = keras.Sequential([
    keras.Input(shape=(784,)),
    keras.layers.Dense(10)
])
model.compile(
    optimizer="adam",
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True)
)

# Preprocess data on CPU
with keras.device("cpu:0"):
    x_processed = keras.ops.cast(x_raw, "float32")

# Train on GPU (if available)
with keras.device("gpu:0"):
    model.fit(x_processed, y_train, epochs=2)

```

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

### SimpleRNN Usage Example

Source: https://keras.io/api/layers/recurrent_layers/simple_rnn

Demonstrates basic and advanced usage of the SimpleRNN layer, including returning the full sequence and final state.

```python
inputs = np.random.random((32, 10, 8))
simple_rnn = keras.layers.SimpleRNN(4)
output = simple_rnn(inputs)  # The output has shape `(32, 4)`.
simple_rnn = keras.layers.SimpleRNN(
    4, return_sequences=True, return_state=True
)
# whole_sequence_output has shape `(32, 10, 4)`.
# final_state has shape `(32, 4)`.
whole_sequence_output, final_state = simple_rnn(inputs)

```

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

### count_nonzero usage examples

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

Examples showing how to count non-zero values in a tensor globally or along specific axes.

```python
>>> x = keras.ops.array([[0, 1, 7, 0], [3, 0, 2, 19]])
>>> keras.ops.count_nonzero(x)
5
>>> keras.ops.count_nonzero(x, axis=0)
array([1, 1, 2, 1], dtype=int64)
>>> keras.ops.count_nonzero(x, axis=1)
array([2, 3], dtype=int64)
```
Tokens:
Raw