A high-level deep learning API built on top of TensorFlow (primary), JAX, and PyTorch (multi-backend support) is the Python-based Keras library.

• Models
• Layers
• Optimizers
• Losses
• Metrics
• Callbacks

pip install tensorflow

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Check version
tf.__version__

• Load Data
• Preprocess
• Build Model
• Compile
• Train
• Evaluate
• Predict
• Save Model

• Sequential
• Functional
• Subclassing

• Simple stack of layers
• Linear pipelines

model = keras.Sequential([
    layers.Dense(128, activation='relu'),
    layers.Dense(10, activation='softmax')
])

• Complex architectures
• Multi-input/output
• Residual connections

inputs = keras.Input(shape=(784,))
x = layers.Dense(128, activation='relu')(inputs)
outputs = layers.Dense(10, activation='softmax')(x)

model = keras.Model(inputs, outputs)

• Custom logic
• Research models

class MyModel(keras.Model):
    def __init__(self):
        super().__init__()
        self.dense1 = layers.Dense(128, activation='relu')

    def call(self, inputs):
        return self.dense1(inputs)

• units
• activation
• use_bias
• kernel_regularizer

layers.Conv2D(
    filters=32,
    kernel_size=(3,3),
    strides=1,
    padding='same',
    activation='relu'
)

# Pooling
layers.MaxPooling2D((2,2))

• LSTM: layers.LSTM(128, return_sequences=True)
• GRU: layers.GRU(64)

layers.Embedding(
    input_dim=10000,
    output_dim=128
)
# Transforms: Word index → dense vector

metrics=['accuracy']
# Custom metric: keras.metrics.Precision()

model.compile(
    optimizer='adam',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

model.fit(
    x_train,
    y_train,
    batch_size=32,
    epochs=10,
    validation_split=0.2
)

model.evaluate(x_test, y_test)
model.predict(x_new)

callbacks=[
    keras.callbacks.EarlyStopping(patience=3),
    keras.callbacks.ModelCheckpoint('model.h5')
]

layers.Dense(64, kernel_regularizer
    =keras.regularizers.l2(0.01))

layers.BatchNormalization()
# Benefits: Faster training, Stable gradients

layers.Dropout(0.5)
# Prevents overfitting

tf.data.Dataset.from_tensor_slices(data)
    .shuffle(1000)
    .batch(32)

keras.preprocessing.image_dataset_from_directory(
    'data/',
    image_size=(224,224)
)

layers.TextVectorization(max_tokens=10000)

keras.preprocessing.timeseries_dataset_from_array()

def custom_loss(y_true, y_pred):
    return tf.reduce_mean((y_true - y_pred)**2)

class MyLayer(layers.Layer):
    def call(self, inputs):
        return inputs * 2

with tf.GradientTape() as tape:
    loss = loss_fn(y, model(x))

model.save('model.keras')
model = keras.models.load_model('model.keras')

• base_model.trainable = False
• base_model.trainable = True (Lower learning rate required)

• KerasTuner
• Grid Search
• Random Search

• Mixed precision
• XLA compilation
• Batch size tuning

• Check shapes
• Print model.summary()
• Overfit on small batch

• Normalize data
• Start simple
• Monitor validation loss
• Save best model
• Use callbacks