Keras Tutorial: Learn Deep Learning API from Scratch (2026)
Keras was the first deep learning API that made me feel like I was writing Python instead of wrestling with a framework. Its philosophy of being user-friendly, modular, and extensible resonated with me from day one. Since becoming part of the TensorFlow ecosystem and then gaining standalone status again with Keras 3, it now supports multiple backends including JAX and PyTorch. In 2026, Keras is the most accessible entry point for anyone starting their deep learning journey.
Installing Keras and Choosing a Backend
Keras 3 supports three backends: TensorFlow, JAX, and PyTorch. You can install Keras standalone and set your preferred backend via environment variable. This multi-backend support means you can write your model once and run it on any framework. I usually default to JAX for research because of its XLA compilation speed.
The decision of which backend to choose depends on your ecosystem. If you are deploying to production, TensorFlow backend is safest. If you are doing research, JAX offers the fastest compile times. And if you want to leverage PyTorch's ecosystem, the PyTorch backend gives you the best of both worlds.
pip install keras
import os
os.environ['KERAS_BACKEND'] = 'jax'
import kerasBuilding Models with the Sequential API
The Sequential API is the simplest way to build models. You stack layers linearly, and each layer passes its output to the next. This is perfect for feedforward networks where the data flows in one direction. Keras provides all the standard layers: Dense, Conv2D, LSTM, Dropout, BatchNormalization, and more.
When I teach workshops, I always start with Sequential because it removes cognitive load. Students can focus on concepts like activation functions and layer sizes instead of worrying about complex wiring. The compile step configures the optimizer, loss function, and metrics, and fit handles the entire training loop.
model = keras.Sequential([
keras.layers.Dense(64, activation='relu', input_shape=(784,)),
keras.layers.Dropout(0.2),
keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])The Functional API for Complex Architectures
When your model has multiple inputs, multiple outputs, or shared layers, the Functional API is what you need. Instead of passing a list of layers, you explicitly define how tensors flow through your network. This enables branching, merging, and residual connections. Inception networks, ResNets, and siamese networks all use this approach.
I used the Functional API to build a multi-modal model that took both images and tabular metadata as inputs. The image path went through Conv2D layers while the metadata path went through Dense layers, and they merged before the final classification. The Functional API made this architecture explicit and readable.
inputs = keras.Input(shape=(784,))
x = keras.layers.Dense(64, activation='relu')(inputs)
x = keras.layers.Dense(32, activation='relu')(x)
outputs = keras.layers.Dense(10, activation='softmax')(x)
model = keras.Model(inputs=inputs, outputs=outputs)Custom Layers, Models, and Callbacks
Sometimes the built-in layers are not enough. Keras lets you create custom layers by subclassing Layer, and custom models by subclassing Model. You override the call method to define the forward pass. Callbacks let you inject behavior during training: model checkpointing, early stopping, learning rate scheduling, and custom logging.
One callback I use in every project is EarlyStopping with restore_best_weights=True. It monitors the validation loss and stops training when it stops improving, automatically reverting to the best weights. This single callback has saved me countless hours of overfitting and manual monitoring.
class MyLayer(keras.layers.Layer):
def __init__(self, units):
super().__init__()
self.dense = keras.layers.Dense(units)
def call(self, x):
return keras.activations.gelu(self.dense(x))Transfer Learning with Pretrained Models
Why train from scratch when you can leverage models that have been trained on millions of images for days? Keras applications provides pretrained models like ResNet50, EfficientNet, and MobileNet. You load the base model without the top classification layer, freeze its weights, and add your own classifier on top. This is transfer learning and it works remarkably well with small datasets.
I built a plant disease classifier with only 500 images per class by fine-tuning EfficientNet. The pretrained features from ImageNet gave me 94% accuracy compared to 72% training from scratch. The key is to first train only the new classifier head with the base frozen, then gradually unfreeze some base layers for fine-tuning.
base = keras.applications.EfficientNetV2B0(
include_top=False, weights='imagenet', input_shape=(224, 224, 3))
base.trainable = False
model = keras.Sequential([base, keras.layers.GlobalAvgPool2D(), keras.layers.Dense(10)])Model Deployment with Keras
Deploying a Keras model is straightforward. You can export to SavedModel for TensorFlow Serving, convert to TFLite for mobile, or use the new Keras API for serving via REST endpoints. Keras 3 also supports exporting to ONNX format for cross-framework deployment. The model.export() method bundles everything into a deployable package.
I deployed a Keras model to a Raspberry Pi for an edge computing project. The conversion to TFLite reduced the model size from 80 MB to 15 MB with minimal accuracy loss, and inference ran at 30 frames per second on the device. Keras's export pipeline handled all the quantization and optimization automatically.
model.export('my_model')
converter = keras.layers.TFSMLayer('my_model', call_endpoint='serving_default')
result = converter(tf.constant(input_data))Frequently Asked Questions
What is the difference between Keras 2 and Keras 3?
Keras 3 is a complete rewrite that supports multiple backends including TensorFlow, JAX, and PyTorch. Keras 2 was TensorFlow-only. Keras 3 also adds new features like the export API and improved performance.
Should I use Keras Sequential or Functional API?
Use Sequential for simple linear stacks of layers. Use Functional for models with multiple inputs/outputs, shared layers, or branching architectures. The Functional API is more verbose but more flexible.
How do I prevent overfitting in Keras?
Add Dropout layers between dense layers, use EarlyStopping callback, apply L1/L2 regularization via kernel_regularizer, reduce model complexity, and increase training data through augmentation.
Can Keras handle time series data?
Yes, Keras provides LSTM, GRU, and Conv1D layers for sequence modeling. Use the TimeseriesGenerator or tf.data for sliding window datasets. For large time series, consider the new Keras 3 Timeseries API.
Originally published on Ayodhyyya. Last updated June 1, 2026.