# Keras — Deep Learning for Humans

> Keras is the most user-friendly deep learning API. It runs on top of TensorFlow, JAX, or PyTorch, providing a consistent high-level interface for building, training, and deploying neural networks with minimal code and maximum readability.

## Install

Save in your project root:

# Keras — Deep Learning for Humans

## Quick Use
```bash
# Install Keras 3 (multi-backend)
pip install keras

# Set backend (JAX, TensorFlow, or PyTorch)
export KERAS_BACKEND=jax  # or tensorflow, torch

# Quick model
python3 -c "
import keras
from keras import layers

model = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(784,)),
    layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.summary()
"
```

## Introduction
Keras is the high-level deep learning API designed for human beings, not machines. Created by Francois Chollet at Google, it prioritizes developer experience — enabling fast experimentation with minimal code. Keras 3 is framework-agnostic, running on TensorFlow, JAX, or PyTorch backends.

With over 64,000 GitHub stars, Keras is the most widely used deep learning API. Its Sequential and Functional APIs make neural network development accessible to beginners while remaining powerful enough for cutting-edge research.

## What Keras Does
Keras provides a clean, consistent API for defining neural network architectures, compiling them with loss functions and optimizers, training on data, evaluating performance, and exporting for deployment. It abstracts away the complexity of the underlying framework while preserving access to low-level operations when needed.

## Architecture Overview
```
[Keras 3 API]
Sequential, Functional, Subclassing
        |
   [Backend Abstraction Layer]
        |
+-------+-------+-------+
|       |       |       |
[JAX]   [TensorFlow] [PyTorch]
Google  Google       Meta
XLA     tf.function  torch.compile
TPU     TF Serving   ExecuTorch
        |
   [Keras Ecosystem]
   KerasNLP — NLP models
   KerasCV — Vision models
   KerasTuner — Hyperparameter search
   KerasHub — Pre-trained models
```

## Self-Hosting & Configuration
```python
import keras
from keras import layers, callbacks

# Functional API for complex architectures
inputs = keras.Input(shape=(224, 224, 3))
x = layers.Conv2D(32, 3, activation="relu")(inputs)
x = layers.MaxPooling2D()(x)
x = layers.Conv2D(64, 3, activation="relu")(x)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(128, activation="relu")(x)
x = layers.Dropout(0.5)(x)
outputs = layers.Dense(10, activation="softmax")(x)

model = keras.Model(inputs, outputs)
model.compile(
    optimizer=keras.optimizers.Adam(1e-3),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"]
)

# Training with callbacks
model.fit(
    train_dataset,
    epochs=20,
    validation_data=val_dataset,
    callbacks=[
        callbacks.EarlyStopping(patience=3),
        callbacks.ModelCheckpoint("best_model.keras"),
        callbacks.ReduceLROnPlateau(factor=0.5)
    ]
)

# Export
model.export("serving_model")  # TF SavedModel
```

## Key Features
- **Multi-Backend** — run on JAX, TensorFlow, or PyTorch with the same code
- **Sequential API** — stack layers linearly for simple models
- **Functional API** — build complex architectures with shared layers and branches
- **Pre-built Layers** — Conv2D, LSTM, Transformer, Attention, and 100+ more
- **Callbacks** — EarlyStopping, ModelCheckpoint, LearningRateScheduler
- **KerasNLP/CV** — domain-specific libraries for NLP and computer vision
- **Mixed Precision** — automatic float16 training for faster GPU utilization
- **Model Export** — save to TF SavedModel, ONNX, or TF Lite formats

## Comparison with Similar Tools
| Feature | Keras | PyTorch Lightning | Fastai | Flax (JAX) |
|---|---|---|---|---|
| Abstraction Level | High | High | Very High | Low-Medium |
| Backend Support | JAX, TF, PyTorch | PyTorch only | PyTorch only | JAX only |
| Learning Curve | Very Low | Low | Very Low | Moderate |
| Customization | Good | Excellent | Limited | Excellent |
| Production Deploy | Excellent | Good | Limited | Limited |
| Research Use | Good | High | Moderate | High |

## FAQ
**Q: Is Keras the same as TensorFlow?**
A: No. Keras 3 is a standalone library that can use TensorFlow, JAX, or PyTorch as its backend. Previously (Keras 2), it was tightly coupled to TensorFlow. Keras 3 is fully framework-agnostic.

**Q: Should I learn Keras or PyTorch?**
A: Learn both. Keras is excellent for rapid prototyping and production. PyTorch gives more control for research. With Keras 3, you can use the Keras API on top of PyTorch — getting the best of both worlds.

**Q: What is the difference between Sequential and Functional API?**
A: Sequential is for simple stack-of-layers models. Functional API supports complex architectures: multi-input/output, shared layers, skip connections, and branches.

**Q: How do I use pre-trained models?**
A: Use KerasHub (formerly KerasNLP/KerasCV) for pre-trained models like BERT, GPT-2, ResNet, EfficientNet. One-line loading with automatic weight download.

## Sources
- GitHub: https://github.com/keras-team/keras
- Documentation: https://keras.io
- Created by Francois Chollet (Google)
- License: Apache-2.0

---
Source: https://tokrepo.com/en/workflows/35111360-3701-11f1-9bc6-00163e2b0d79
Author: AI Open Source