Symbolic tensor -- encapsulates a shape and a dtype. You can use `KerasTensor` instances to build computation graphs of Keras operations, suc

`Sequential` groups a linear stack of layers into a `Model`. Examples: ```python model = keras.Sequential() model.add(keras.Input(sh

Specifies the rank, dtype and shape of every input to a layer. Layers can expose (if appropriate) an `input_spec` attribute: an instance of `

A `Functional` model is a `Model` defined as a directed graph of layers. Three types of `Model` exist: subclassed `Model`, `Functional` model,

A model grouping layers into an object with training/inference features. There are three ways to instantiate a `Model`: ## With the "Functio

Configuration class for the GPTQ (Gradient-based Post-Training Quantization) algorithm. GPTQ is a post-training quantization method that quan

Generates variable seeds upon each call to a function generating random numbers. In Keras, all random number generators (such as `keras.r

A dtype policy for a Keras layer. A dtype policy determines a layer's computation and variable dtypes. Each layer has a policy. Policies can

Gradient descent (with momentum) optimizer. Update rule for parameter `w` with gradient `g` when `momentum` is 0: ```python w = w - lear

Keras Layer that wraps a JAX model. This layer enables the use of JAX components within Keras when using JAX as the backend for Keras. #

An optimizer that dynamically scales the loss to prevent underflow. Loss scaling is a technique to prevent numeric underflow in intermediate

Distillation model for transferring knowledge from teacher to student. Knowledge distillation transfers knowledge from a large, complex model

Dict-like object mapping layer paths to `DTypePolicy` instances. `DTypePolicyMap` can be used in `get_config` in layers and subclasses to sup

r"""Optimizer that implements the FTRL algorithm. "Follow The Regularized Leader" (FTRL) is an optimization algorithm developed at Google for

A mock tokenizer that mimics the real API for testing.

A context manager for enabling rematerialization in Keras. Rematerialization (gradient checkpointing) trades memory for computation by recomp

Scope to prevent any update to Keras Variables. The values of variables to be used inside the scope should be passed via the `state_mapping`

Optimizer that implements the Adam algorithm. Adam optimization is a stochastic gradient descent method that is based on adaptive estimation

Numerical variable store backed by HDF5. Args: path_or_io: `str`, `pathlib.Path` or `io.BytesIO` object. The path where to sa

Optimizer that implements the Lion algorithm. The Lion optimizer is a stochastic-gradient-descent method that uses the sign operator to contr

Optimizer that implements the Adafactor algorithm. Adafactor is commonly used in NLP tasks, and has the advantage of taking less memory becau

Optimizer that implements the AdamW algorithm. AdamW optimization is a stochastic gradient descent method that is based on adaptive estimatio

Distillation loss that transfers knowledge from final model outputs. This distillation loss applies temperature scaling to the teacher's logits

Optimizer that implements the Muon algorithm. Note that this optimizer should not be used in the following layers: 1. Embedding layer 2.

Optimizer that implements the Nadam algorithm. Much like Adam is essentially RMSprop with momentum, Nadam is Adam with Nesterov momentum.

A `Node` describes an operation `__call__()` event. A Keras Function is a DAG with `Node` instances as nodes, and `KerasTensor` instances as

Optimizer that implements the Adadelta algorithm. Adadelta optimization is a stochastic gradient descent method that is based on adaptive lea

Optimizer that implements the Adagrad algorithm. Adagrad is an optimizer with parameter-specific learning rates, which are adapted relative t

Optimizer that implements the Adamax algorithm. Adamax, a variant of Adam based on the infinity norm, is a first-order gradient-based optimiz

Optimizer that implements the Lamb algorithm. Lamb is a stochastic gradient descent method that uses layer-wise adaptive moments to adjusts t

Mock remat by returning a wrapper Mock calling the original function

Optimizer that implements the RMSprop algorithm. The gist of RMSprop is to: - Maintain a moving (discounted) average of the square of gradie

Utility to inspect, edit, and resave Keras weights files. You will find this class useful when adapting an old saved weights file after havin

Simple teacher model for testing.

Scope to indicate the symbolic stage.

A layout to apply to a tensor. This API is aligned with `jax.sharding.NamedSharding` and `tf.dtensor.Layout`. See more details in [jax.s

Adapter that handles `torch.utils.data.DataLoader`.

Torch module wrapper layer. `TorchModuleWrapper` is a wrapper class that can turn any `torch.nn.Module` into a Keras layer, in particular by

Just your regular densely-connected NN layer. `Dense` implements the operation: `output = activation(dot(input, kernel) + bias)` where `a

Asset store backed by disk storage. If `archive` is specified, then `root_path` refers to the filename inside the archive. If `archive`

Simple student model for testing.

Creates a sub-namespace for variable paths. Args: name: Name of the current scope (string). caller: Optional ID of a caller objec

A cluster of computation devices for distributed computation. This API is aligned with `jax.sharding.Mesh` and `tf.dtensor.Mesh`, which repre

A layer that uses `einsum` as the backing computation. This layer can perform einsum calculations of arbitrary dimensionality. Args:

ExportArchive is used to write SavedModel artifacts (e.g. for inference). If you have a Keras model or layer that you want to export as SavedMode

Feature distillation loss. Feature distillation transfers knowledge from intermediate layers of the teacher model to corresponding layers of

A callback to intentionally interrupt training.

The default shared object loading scope. It does nothing. Created to simplify serialization code that doesn't care about shared objects (e.g.