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

Int4 quantization config. Args: weight_quantizer: Quantizer for weights. activation_quantizer: Quantizer for activations. If "def

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

Configuration class for AWQ (Activation-aware Weight Quantization). AWQ is a post-training quantization method that identifies and protects s

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

Int8 quantization config. Args: weight_quantizer: Quantizer for weights. activation_quantizer: Quantizer for activations. If "def

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. #

Callback to save and load model state using Orbax with a similar API to ModelCheckpoint. This callback saves the model's weights and optimize

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

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

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

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

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.

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 Schedule-Free AdamW algorithm. Schedule-Free learning is a method that avoids the need for a learning rate sche

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

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

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

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

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

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

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

A layout to apply to a tensor. This API is aligned with `jax.sharding.NamedSharding`. See more details in [jax.sharding.NamedSharding](

Callback that terminates training when a NaN loss is encountered. This callback monitors the loss value during training and terminates traini

Context manager that enables the autocasting of float variables. Under this context manager, float `Variables`s will be cast to `dtype` (note

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.

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

AWQ quantizer for a single layer. This class accumulates activation statistics during calibration and performs AWQ quantization on layer weig

Quantized dtype policy for AWQ quantization. This policy helps propagate quantization settings for AWQ when loading an AWQ quantized model in

A cluster of computation devices for distributed computation. This API is aligned with `jax.sharding.Mesh`, which represents the computation

Simple student model for testing.

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

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