Keras

Compiles a single model definition to execute on JAX, TensorFlow, PyTorch, or OpenVINO by deferring all numerical operations to pluggable backend implementations. The architecture uses a symbolic execution path during model construction (compute_output_spec() for shape/dtype inference) and an eager execution path at runtime that dispatches to the active backend's kernel implementations. Backend selection occurs at import time via KERAS_BACKEND environment variable or ~/.keras/keras.json and cannot be changed after import, enabling compile-time optimization and dependency injection.

Provides two APIs for constructing neural networks: Sequential (linear stack of layers) and Functional (arbitrary directed acyclic graphs with multiple inputs/outputs). During model construction, each layer's compute_output_spec() method runs shape and dtype inference on KerasTensor objects without performing actual computation, enabling early error detection and automatic shape validation. The Functional API supports layer sharing, residual connections, and multi-branch architectures through explicit input/output tensor wiring.

Provides preprocessing layers (Normalization, Resizing, Rescaling, StringLookup, IntegerLookup) and augmentation layers (RandomFlip, RandomRotation, RandomZoom, MixUp) that integrate into the model graph. Preprocessing layers compute statistics (mean, std, vocabulary) from training data via adapt() and apply transformations during training and inference. Augmentation layers apply random transformations during training only (controlled by training flag). All layers are backend-agnostic and support batched processing.

Uses api_gen.py script to automatically generate keras/api/ directory from keras/src/ source code, ensuring the public API surface is always in sync with implementation. The script scans keras/src/ for public symbols (classes, functions, constants) and generates re-exports in keras/api/. This two-tier structure (src/ as source of truth, api/ as generated public surface) enables clean separation between internal implementation and public API, with version control tracking only the generated api/ directory.

Keras provides preprocessing layers (keras.layers.preprocessing.*) that transform input data during training and inference: normalization (Normalization), categorical encoding (StringLookup, IntegerLookup), image augmentation (RandomFlip, RandomRotation, RandomZoom), and text preprocessing (TextVectorization). Preprocessing layers are stateful — they learn statistics (mean, std, vocabulary) from training data via adapt() method, then apply transformations consistently. Layers can be composed into preprocessing pipelines and integrated into models via functional API. Preprocessing is backend-agnostic and automatically applied during model.fit() and model.predict().

Keras enables saving and loading trained models in multiple formats: Keras native format (HDF5 or SavedModel), ONNX, and LiteRT. Model serialization includes weights, architecture, training configuration, and custom objects (custom layers, loss functions, metrics). Deserialization reconstructs the model with identical architecture and weights. Custom objects are registered via custom_objects parameter in load_model() or keras.saving.register_keras_serializable() decorator. The framework automatically handles version compatibility and migration for models trained with older Keras versions.

Exposes a NumPy-like API (keras.ops.numpy.*) that maps to backend-specific implementations (JAX, TensorFlow, PyTorch) for operations like matmul, reshape, concatenate, and reduction. All operations are differentiable and integrate with the automatic differentiation system of the active backend. The ops layer abstracts backend differences (e.g., PyTorch's in-place operations vs JAX's functional style) through a unified interface, with backend-specific implementations in keras/src/backend/{jax,torch,tensorflow}/numpy.py.

Implements dtype policies that control computation and storage precision per layer or globally, enabling mixed-precision training (e.g., float32 weights, float16 computation). Each layer has a dtype_policy attribute that specifies compute_dtype (operations) and variable_dtype (weight storage). The training loop automatically casts inputs to compute_dtype, performs forward/backward passes, and scales gradients to prevent underflow in float16. Backend-specific implementations handle dtype casting and gradient scaling transparently.

Supports distributed training across multiple GPUs, TPUs, and machines via backend-specific distribution strategies (tf.distribute for TensorFlow, torch.distributed for PyTorch, jax.experimental.multihost for JAX). The training loop automatically synchronizes gradients across devices, handles batch splitting, and manages device placement. Users wrap their model with a distribution strategy (e.g., model = strategy.scope(model)) and the training loop handles the rest.

Exports trained Keras models to multiple deployment formats: TensorFlow SavedModel (for TensorFlow Serving), ONNX (for cross-framework inference), LiteRT (for mobile/embedded), and OpenVINO (for Intel hardware). Each export path converts the computational graph to the target format, quantizes weights if requested, and generates metadata for inference. Backend-specific exporters in keras/src/export/ handle format-specific optimizations (e.g., graph fusion, constant folding).

Supports both quantization-aware training (QAT, where quantization is simulated during training) and post-training quantization (PTQ, where weights are quantized after training). QAT uses fake quantization layers that simulate int8/int4 precision during forward/backward passes, allowing the optimizer to adapt weights to quantization. PTQ applies quantization statistics (min/max ranges) computed from calibration data to convert float weights to lower precision without retraining.

Provides a base Layer class that users subclass to implement custom layers. Each layer defines a build() method (allocates weights), call() method (forward pass), and optionally compute_output_spec() (shape/dtype inference). The framework automatically computes gradients via backend-specific autodiff (JAX's jax.grad, PyTorch's autograd, TensorFlow's GradientTape), handles weight tracking, and manages layer state. Layers are composable — they can be nested in Sequential/Functional models or used directly in custom training loops.

Implements a high-level fit() method that orchestrates training: iterates over batches, computes loss, backpropagates gradients, updates weights via optimizer, and tracks metrics. Callbacks (e.g., EarlyStopping, ModelCheckpoint, LearningRateScheduler) hook into training at specified points (epoch start/end, batch end) to implement custom logic. Metrics are computed on-the-fly and aggregated across batches. Loss scaling for mixed-precision training is applied automatically. The training loop is backend-agnostic — the same code runs on JAX, TensorFlow, and PyTorch.

Provides a collection of pre-trained models (ResNet, EfficientNet, BERT, GPT-2, etc.) with weights trained on standard datasets (ImageNet, COCO, Wikipedia). Models are loaded via keras.applications.* or keras.models.load_model(). Transfer learning is enabled by freezing early layers (model.trainable = False) and fine-tuning on new data. The model zoo includes preprocessing functions (e.g., keras.applications.resnet50.preprocess_input) that normalize inputs to match training data.