Keras Nightly

3.15.0.dev2026041504 · active · verified Thu Apr 16

Keras 3 is a multi-backend deep learning framework that supports JAX, TensorFlow, PyTorch, and OpenVINO (for inference-only). The `keras-nightly` package provides daily development builds of Keras, offering access to the latest features and bug fixes. It focuses on accelerated model development and state-of-the-art performance by leveraging backend-specific optimizations.

Common errors

```
ImportError: cannot import name 'type_spec_registry' from 'tensorflow.python.framework'
```
cause Version incompatibility between TensorFlow and Keras. This error often occurs when an older TensorFlow version is installed with a newer Keras, or vice-versa, that expects a specific internal structure.

fix Ensure that your TensorFlow and Keras installations are compatible. Upgrade TensorFlow to a recent version (e.g., 2.16.1+ for Keras 3). It is recommended to install Keras first, then its chosen backend.
```
Import "tensorflow.keras" could not be resolved
```
cause Attempting to import Keras components from the `tensorflow.keras` namespace with Keras 3.x installed, which uses the standalone `keras` package.

fix Replace `from tensorflow.keras import ...` with `from keras import ...` and `tf.keras.` prefixes with `keras.`.
```
ValueError: Invalid filepath extension for saving. Please add either a `.keras` extension for the native Keras format (recommended) or a `.h5` extension. Use `model.export(filepath)` if you want to export a SavedModel for use with TFLite/TFServing/etc.
```
cause Attempting to save a Keras 3 model using `model.save()` with an unsupported file extension (e.g., no extension or `.tf`).

fix When using `model.save()`, use `.keras` (recommended) or `.h5` extensions. If you specifically need to export to the TensorFlow SavedModel format, use `model.export(filepath)` instead.

ValueError: A KerasTensor cannot be used as input to a TensorFlow function. A KerasTensor is a symbolic placeholder for a shape and dtype, used when constructing Keras Functional models or Keras Functions. You can only use it as input to a Keras layer or a Keras operation (from the namespaces `keras.layers` and `keras.operations`).

cause Mixing Keras symbolic tensors (KerasTensors) directly with native TensorFlow operations outside of the `keras.ops` namespace in functional models.

fix

Replace native TensorFlow operations (`tf.*`) with their equivalent functions from `keras.ops` (e.g., `keras.ops.matmul` instead of `tf.linalg.matmul`).

```
ValueError: Only instances of `keras.Layer` can be added to a Sequential model. Received: <tensorflow_hub.keras_layer.KerasLayer object ...>
```
cause This typically occurs in environments where both Keras 3 (standalone) and TensorFlow's bundled Keras 2 (`tf.keras`) are present, leading to a type mismatch when trying to add a layer instantiated from one Keras version into a model from another.

fix Ensure consistency in your Keras imports. If using Keras 3, all layers and models should come from the `keras` namespace. Avoid mixing `tf.keras` and `keras` objects. Consider using virtual environments to isolate dependencies.

Warnings

breaking Keras 3.13.0 and newer versions require Python 3.11 or higher. Using older Python versions will result in installation or runtime errors.
Fix: Upgrade your Python environment to 3.11 or newer.
breaking The `tensorflow.keras` namespace is deprecated for Keras 3.x. All imports should be directly from `keras` (e.g., `import keras`, `from keras import layers`).
Fix: Update all `from tensorflow.keras import ...` statements to `from keras import ...` and `tf.keras.` prefixes to `keras.`.
breaking Saving models to the TensorFlow SavedModel format via `model.save()` is no longer supported in Keras 3. Loading TensorFlow SavedModels via `keras.models.load_model()` is also not supported.
Fix: For saving, use the native Keras format (`.keras` extension) with `model.save()`. For SavedModel export, use `model.export(filepath)`. For loading existing TensorFlow SavedModels for inference in Keras 3, use `keras.layers.TFSMLayer(saved_model_path, call_endpoint='serving_default')`.
gotcha Keras-nightly builds are development versions and may contain bugs, incomplete features, or unstable APIs. They are not recommended for production environments.
Fix: For stable production applications, use the `keras` package (stable release) instead of `keras-nightly`.
gotcha The Keras backend (TensorFlow, JAX, or PyTorch) must be configured *before* the first `import keras` statement in your application. Changing the backend after import is not supported.
Fix: Set the `KERAS_BACKEND` environment variable (e.g., `os.environ["KERAS_BACKEND"] = "tensorflow"`) or edit the `~/.keras/keras.json` config file before importing `keras`.
gotcha When using the TensorFlow backend with Keras 3 on GPU, `jit_compile` for `Model` is `True` by default. This can cause XLA-related errors if your custom layers or models use TensorFlow operations not supported by XLA.
Fix: If you encounter XLA errors with custom components, set `jit_compile=False` in your `Model` constructor: `model = keras.Model(..., jit_compile=False)`.

Install

pip install keras-nightly Install Keras Nightly
pip install tensorflow Install TensorFlow backend (example)
pip install jax[cuda12_pip] -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html Install JAX backend (example for CUDA 12)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 Install PyTorch backend (example for CUDA 12.1)

Imports

keras
wrong:
```
from tensorflow import keras
```
correct:
```
import keras
```
Keras 3.x is a standalone library. Direct import is 'import keras'. The `tensorflow.keras` namespace refers to Keras 2.x bundled with TensorFlow versions prior to 2.16.
layers
wrong:
```
from tensorflow.keras import layers
```
correct:
```
from keras import layers
```
For Keras 3, all components are imported directly from the `keras` namespace.

Quickstart

This quickstart demonstrates how to set a Keras backend, load data, build a sequential convolutional neural network, compile it, and train it using Keras 3. Ensure a backend (e.g., TensorFlow) is installed and the `KERAS_BACKEND` environment variable is set before importing `keras`.

import os
import keras
import numpy as np

# Configure the Keras backend (e.g., 'tensorflow', 'jax', 'torch')
os.environ["KERAS_BACKEND"] = "tensorflow" 

# Load a dataset
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)

# Build a simple model
model = keras.Sequential(
    [
        keras.layers.Input(shape=(28, 28, 1)),
        keras.layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
        keras.layers.MaxPooling2D(pool_size=(2, 2)),
        keras.layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        keras.layers.MaxPooling2D(pool_size=(2, 2)),
        keras.layers.Flatten(),
        keras.layers.Dropout(0.5),
        keras.layers.Dense(10, activation="softmax"),
    ]
)

# Compile the model
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])

# Train the model
model.fit(x_train, y_train, batch_size=128, epochs=5, validation_split=0.1)

# Evaluate the model
loss, accuracy = model.evaluate(x_test, y_test)
print(f"Test accuracy: {accuracy:.4f}")

view raw JSON →