1. Keras Cheat Sheet

# TensorFlow 2.x includes Keras API
pip install tensorflow

# For GPU support (CUDA required)
pip install tensorflow-gpu

# Verify installation
python -c "import tensorflow as tf; print(tf.__version__)"

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models, optimizers
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

# Check GPU availability
print("Num GPUs Available:", len(tf.config.list_physical_devices('GPU')))

    ┌──────────────┐
    │ Load Data    │
    └──────┬───────┘
           ↓
    ┌──────────────────┐
    │ Preprocess Data  │
    └──────┬───────────┘
           ↓
    ┌──────────────────┐
    │  Build Model     │
    └──────┬───────────┘
           ↓
    ┌──────────────────┐
    │  Compile Model   │
    └──────┬───────────┘
           ↓
    ┌──────────────────┐
    │   Train Model    │──────┐
    └──────┬───────────┘      │
           ↓                  │
    ┌──────────────────┐      │
    │  Evaluate Model  │      │
    └──────┬───────────┘      │
           │                  │
           ↓ (Not Satisfactory)│
    ┌──────────────────┐      │
    │  Tune/Adjust     │──────┘
    └──────────────────┘
           │
           ↓ (Satisfactory)
    ┌──────────────────┐
    │   Deploy Model   │
    └──────────────────┘

Sequential API          Functional API          Model Subclassing
     │                       │                         │
     ├─ Simple              ├─ Flexible              ├─ Full Control
     ├─ Linear Stack        ├─ Multi-Input/Output   ├─ Custom Logic
     └─ Easy to Use         └─ Shared Layers        └─ Research-Oriented

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization

# Method 1: Layer list
model = Sequential([
    Dense(128, activation='relu', input_shape=(784,)),
    BatchNormalization(),
    Dropout(0.3),
    Dense(64, activation='relu'),
    Dropout(0.3),
    Dense(10, activation='softmax')
])

# Method 2: .add() approach
model = Sequential()
model.add(Dense(128, activation='relu', input_shape=(784,)))
model.add(BatchNormalization())
model.add(Dropout(0.3))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(10, activation='softmax'))

# View model architecture
model.summary()

from tensorflow.keras.layers import Input, Dense, Concatenate, Add
from tensorflow.keras import Model

# Single input/output
inputs = Input(shape=(784,), name='input_layer')
x = Dense(128, activation='relu', name='hidden_1')(inputs)
x = Dense(64, activation='relu', name='hidden_2')(x)
outputs = Dense(10, activation='softmax', name='output')(x)
model = Model(inputs=inputs, outputs=outputs, name='simple_mlp')

# Multi-input model
input_a = Input(shape=(32,), name='input_a')
input_b = Input(shape=(32,), name='input_b')
x_a = Dense(64, activation='relu')(input_a)
x_b = Dense(64, activation='relu')(input_b)
merged = Concatenate()([x_a, x_b])
output = Dense(10, activation='softmax')(merged)
model = Model(inputs=[input_a, input_b], outputs=output)

# Multi-output model
shared_input = Input(shape=(784,))
x = Dense(128, activation='relu')(shared_input)
output_a = Dense(10, activation='softmax', name='output_a')(x)
output_b = Dense(5, activation='softmax', name='output_b')(x)
model = Model(inputs=shared_input, outputs=[output_a, output_b])

# Residual connection (skip connection)
inputs = Input(shape=(32,))
x = Dense(32, activation='relu')(inputs)
x = Dense(32, activation='relu')(x)
outputs = Add()([x, inputs])  # Residual connection
model = Model(inputs=inputs, outputs=outputs)

import tensorflow as tf

class CustomModel(tf.keras.Model):
    """Custom model with flexible forward pass."""

    def __init__(self, num_classes=10):
        super(CustomModel, self).__init__()
        self.dense1 = tf.keras.layers.Dense(128, activation='relu')
        self.dropout1 = tf.keras.layers.Dropout(0.3)
        self.dense2 = tf.keras.layers.Dense(64, activation='relu')
        self.dropout2 = tf.keras.layers.Dropout(0.3)
        self.output_layer = tf.keras.layers.Dense(num_classes, activation='softmax')

    def call(self, inputs, training=False):
        """Forward pass with training-specific behavior."""
        x = self.dense1(inputs)
        x = self.dropout1(x, training=training)
        x = self.dense2(x)
        x = self.dropout2(x, training=training)
        return self.output_layer(x)

    def get_config(self):
        """Enable model serialization."""
        return {"num_classes": self.output_layer.units}

# Instantiate and build
model = CustomModel(num_classes=10)
model.build(input_shape=(None, 784))
model.summary()

from tensorflow.keras.layers import Dense, Activation, Dropout, Flatten, Input, Reshape

# Dense (Fully Connected)
Dense(128, activation='relu', kernel_initializer='he_normal')

# Activation
Activation('relu')  # Separate activation layer

# Dropout - prevents overfitting
Dropout(0.5)  # 50% dropout rate

# Flatten - converts multi-dimensional to 1D
Flatten()  # (None, 28, 28) -> (None, 784)

# Reshape
Reshape((7, 7, 64))  # Reshape to specific dimensions

# Input
Input(shape=(224, 224, 3), name='image_input')

from tensorflow.keras.layers import (Conv1D, Conv2D, Conv3D, 
                                      SeparableConv2D, Conv2DTranspose)

# 2D Convolution (most common for images)
Conv2D(32, kernel_size=(3, 3), strides=(1, 1), padding='same', 
       activation='relu', input_shape=(28, 28, 1))

# Separable Conv2D (efficient, fewer parameters)
SeparableConv2D(64, (3, 3), activation='relu', padding='same')

# Transposed Convolution (upsampling)
Conv2DTranspose(32, (3, 3), strides=(2, 2), padding='same')

# 1D Convolution (for sequences/time series)
Conv1D(64, kernel_size=3, activation='relu', padding='causal')

# 3D Convolution (for video/volumetric data)
Conv3D(32, kernel_size=(3, 3, 3), activation='relu')

Input Image (28×28×1)
        ↓
   Conv2D (32 filters)
        ↓
   MaxPooling2D
        ↓
   Conv2D (64 filters)
        ↓
   MaxPooling2D
        ↓
     Flatten
        ↓
   Dense (128)
        ↓
   Dropout (0.5)
        ↓
   Dense (10, softmax)

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

cnn_model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    Flatten(),
    Dense(128, activation='relu'),
    Dropout(0.5),
    Dense(10, activation='softmax')
])

from tensorflow.keras.layers import (MaxPooling2D, AveragePooling2D,
                                      GlobalMaxPooling2D, GlobalAveragePooling2D)

# Max Pooling (extracts maximum value)
MaxPooling2D(pool_size=(2, 2), strides=(2, 2))

# Average Pooling
AveragePooling2D(pool_size=(2, 2))

# Global Max Pooling (reduces to single value per channel)
GlobalMaxPooling2D()  # (None, 7, 7, 64) -> (None, 64)

# Global Average Pooling (commonly used before final classification)
GlobalAveragePooling2D()

from tensorflow.keras.layers import LSTM, GRU, SimpleRNN, Bidirectional

# LSTM (Long Short-Term Memory)
LSTM(128, return_sequences=True, dropout=0.2, recurrent_dropout=0.2)

# GRU (Gated Recurrent Unit - faster than LSTM)
GRU(64, return_sequences=False)

# Bidirectional (processes sequence in both directions)
Bidirectional(LSTM(64, return_sequences=True))

# SimpleRNN (basic recurrent layer)
SimpleRNN(32, activation='tanh')

# Stacked LSTM
model = Sequential([
    LSTM(128, return_sequences=True, input_shape=(timesteps, features)),
    LSTM(64, return_sequences=True),
    LSTM(32, return_sequences=False),
    Dense(10, activation='softmax')
])

Input Sequence
      ↓
 ┌────────────┐
 │ LSTM (128) │  return_sequences=True
 └─────┬──────┘
       ↓
 ┌────────────┐
 │  LSTM (64) │  return_sequences=False
 └─────┬──────┘
       ↓
 ┌────────────┐
 │  Dense     │
 └────────────┘

from tensorflow.keras.layers import BatchNormalization, LayerNormalization

# Batch Normalization (normalizes across batch dimension)
# Use before or after activation - debate exists
Conv2D(64, (3, 3), use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)

# Layer Normalization (normalizes across feature dimension)
# Common in Transformers
LayerNormalization(epsilon=1e-6)

from tensorflow.keras.layers import MultiHeadAttention, LayerNormalization

# Multi-Head Attention (Transformer building block)
attention_layer = MultiHeadAttention(
    num_heads=8, 
    key_dim=64,
    dropout=0.1
)

# Self-attention
output = attention_layer(query=x, value=x, key=x)

# Cross-attention
output = attention_layer(query=decoder_x, value=encoder_x, key=encoder_x)

from tensorflow.keras.layers import Embedding

# Convert token indices to dense vectors
# vocabulary_size: total unique tokens
# embedding_dim: vector size for each token
embedding = Embedding(
    input_dim=10000,  # vocabulary size
    output_dim=128,   # embedding dimension
    input_length=100  # sequence length (optional)
)

# Example: Word embeddings for text
model = Sequential([
    Embedding(10000, 128, input_length=100),
    LSTM(64),
    Dense(1, activation='sigmoid')
])

from tensorflow.keras.layers import Add, Multiply, Concatenate, Average, Maximum, Dot

# Add (element-wise addition) - Residual connections
Add()([x, shortcut])

# Concatenate (along specified axis)
Concatenate(axis=-1)([branch_a, branch_b])

# Multiply (element-wise multiplication)
Multiply()([x, attention_weights])

# Average (element-wise average)
Average()([output1, output2, output3])

# Maximum (element-wise maximum)
Maximum()([x1, x2])

# Dot (dot product)
Dot(axes=1)([vec_a, vec_b])

import tensorflow as tf

class CustomDenseLayer(tf.keras.layers.Layer):
    """Custom fully-connected layer with L2 regularization."""

    def __init__(self, units=32, l2_reg=0.01, **kwargs):
        super(CustomDenseLayer, self).__init__(**kwargs)
        self.units = units
        self.l2_reg = l2_reg

    def build(self, input_shape):
        # Initialize weights during first call
        self.w = self.add_weight(
            name='kernel',
            shape=(input_shape[-1], self.units),
            initializer='glorot_uniform',
            regularizer=tf.keras.regularizers.l2(self.l2_reg),
            trainable=True
        )
        self.b = self.add_weight(
            name='bias',
            shape=(self.units,),
            initializer='zeros',
            trainable=True
        )
        super(CustomDenseLayer, self).build(input_shape)

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    def get_config(self):
        # Enable serialization
        config = super(CustomDenseLayer, self).get_config()
        config.update({
            'units': self.units,
            'l2_reg': self.l2_reg
        })
        return config

# Usage
layer = CustomDenseLayer(64, l2_reg=0.01)

class CustomDropoutLayer(tf.keras.layers.Layer):
    """Custom dropout with configurable training behavior."""

    def __init__(self, rate=0.5, **kwargs):
        super(CustomDropoutLayer, self).__init__(**kwargs)
        self.rate = rate

    def call(self, inputs, training=None):
        if training:
            # Apply dropout during training
            return tf.nn.dropout(inputs, rate=self.rate)
        return inputs

    def get_config(self):
        config = super(CustomDropoutLayer, self).get_config()
        config.update({'rate': self.rate})
        return config

from tensorflow.keras.layers import Dense, Activation, LeakyReLU, PReLU, ELU

# ReLU - Most common for hidden layers
Dense(64, activation='relu')

# Sigmoid - Binary classification output
Dense(1, activation='sigmoid')  # Output: (0, 1)

# Softmax - Multi-class classification output
Dense(10, activation='softmax')  # Outputs sum to 1

# Tanh - Alternative to sigmoid
Dense(64, activation='tanh')  # Output: (-1, 1)

# Linear - Regression output
Dense(1, activation='linear')  # No activation

# ELU - Smooth variant of ReLU
Dense(64, activation='elu')

# SELU - Self-normalizing activation
Dense(64, activation='selu')

# LeakyReLU - Prevents dying ReLU problem
LeakyReLU(alpha=0.2)

# PReLU - Learnable LeakyReLU
PReLU()

# Swish/SiLU - Self-gated activation
Dense(64, activation='swish')

Task Type                → Recommended Activation
────────────────────────────────────────────────
Hidden Layers            → ReLU, LeakyReLU, ELU
Binary Classification    → Sigmoid
Multi-class (exclusive)  → Softmax
Multi-class (inclusive)  → Sigmoid (each output)
Regression               → Linear (no activation)
Negative Values Needed   → Tanh

Problem Type              → Loss Function
─────────────────────────────────────────────────
Binary Classification     → BinaryCrossentropy
Multi-class (one-hot)     → CategoricalCrossentropy
Multi-class (integers)    → SparseCategoricalCrossentropy
Regression                → MeanSquaredError (MSE)
Regression (outliers)     → MeanAbsoluteError (MAE), Huber
Multi-label               → BinaryCrossentropy

from tensorflow.keras.losses import (MeanSquaredError, MeanAbsoluteError,
                                      MeanAbsolutePercentageError, 
                                      MeanSquaredLogarithmicError, Huber)

# Mean Squared Error (sensitive to outliers)
loss = MeanSquaredError()
# or
model.compile(loss='mse', optimizer='adam')

# Mean Absolute Error (robust to outliers)
loss = MeanAbsoluteError()

# Mean Absolute Percentage Error
loss = MeanAbsolutePercentageError()

# Mean Squared Logarithmic Error (for exponential growth)
loss = MeanSquaredLogarithmicError()

# Huber Loss (combines MSE and MAE benefits)
loss = Huber(delta=1.0)  # Threshold for switching between MSE and MAE

from tensorflow.keras.losses import (BinaryCrossentropy, 
                                      CategoricalCrossentropy,
                                      SparseCategoricalCrossentropy)

# Binary Classification
loss = BinaryCrossentropy(from_logits=False)  # Use True if no sigmoid in model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Multi-class with one-hot encoded labels
# y_train shape: (samples, num_classes)
loss = CategoricalCrossentropy()
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# Multi-class with integer labels (more memory efficient)
# y_train shape: (samples,) with integer values
loss = SparseCategoricalCrossentropy()
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', 
              metrics=['accuracy'])

# Focal Loss (handles class imbalance)
from tensorflow.keras.losses import BinaryFocalCrossentropy
loss = BinaryFocalCrossentropy(gamma=2.0, alpha=0.25)

import tensorflow as tf

# Simple custom loss
def custom_mse(y_true, y_pred):
    """Custom mean squared error."""
    squared_diff = tf.square(y_true - y_pred)
    return tf.reduce_mean(squared_diff, axis=-1)

# Weighted loss
def weighted_binary_crossentropy(pos_weight=2.0):
    """Binary crossentropy with class weights."""
    def loss(y_true, y_pred):
        bce = tf.keras.losses.binary_crossentropy(y_true, y_pred)
        weight_vector = y_true * pos_weight + (1. - y_true) * 1.
        weighted_bce = weight_vector * bce
        return tf.reduce_mean(weighted_bce)
    return loss

# Combined loss (multi-task learning)
def combined_loss(y_true, y_pred):
    """Combination of MSE and MAE."""
    mse = tf.keras.losses.mean_squared_error(y_true, y_pred)
    mae = tf.keras.losses.mean_absolute_error(y_true, y_pred)
    return 0.5 * mse + 0.5 * mae

# Contrastive loss (for similarity learning)
def contrastive_loss(margin=1.0):
    """Contrastive loss for siamese networks."""
    def loss(y_true, y_pred):
        square_pred = tf.square(y_pred)
        margin_square = tf.square(tf.maximum(margin - y_pred, 0))
        return tf.reduce_mean(y_true * square_pred + (1 - y_true) * margin_square)
    return loss

# Usage
model.compile(optimizer='adam', loss=custom_mse)
model.compile(optimizer='adam', loss=weighted_binary_crossentropy(pos_weight=3.0))

class CustomLoss(tf.keras.losses.Loss):
    """Custom loss with state and configuration."""

    def __init__(self, weight=1.0, name='custom_loss'):
        super().__init__(name=name)
        self.weight = weight

    def call(self, y_true, y_pred):
        loss = tf.square(y_true - y_pred)
        return self.weight * tf.reduce_mean(loss)

    def get_config(self):
        return {'weight': self.weight}

# Usage
model.compile(optimizer='adam', loss=CustomLoss(weight=2.0))

Optimizer    Speed   Memory   Use Case
────────────────────────────────────────────────
Adam         Fast    High     General purpose, default choice
SGD          Slow    Low      Better generalization, needs tuning
RMSprop      Fast    Medium   RNNs, non-stationary objectives
AdamW        Fast    High     Better generalization than Adam

from tensorflow.keras.optimizers import (Adam, SGD, RMSprop, 
                                          AdamW, Nadam, Adagrad)

# Adam (most popular - adaptive learning rates)
optimizer = Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07)

# AdamW (Adam with decoupled weight decay - better generalization)
optimizer = AdamW(learning_rate=0.001, weight_decay=0.01)

# SGD with momentum
optimizer = SGD(learning_rate=0.01, momentum=0.9, nesterov=True)

# RMSprop (good for RNNs)
optimizer = RMSprop(learning_rate=0.001, rho=0.9)

# Nadam (Adam + Nesterov momentum)
optimizer = Nadam(learning_rate=0.001)

# Adagrad (adaptive learning rate per parameter)
optimizer = Adagrad(learning_rate=0.01)

from tensorflow.keras.optimizers.schedules import (ExponentialDecay, 
                                                     PiecewiseConstantDecay,
                                                     PolynomialDecay,
                                                     CosineDecay)

# Exponential decay
lr_schedule = ExponentialDecay(
    initial_learning_rate=0.1,
    decay_steps=10000,
    decay_rate=0.96,
    staircase=True
)
optimizer = Adam(learning_rate=lr_schedule)

# Piecewise constant (step decay)
boundaries = [10000, 20000, 30000]
values = [1e-3, 5e-4, 1e-4, 5e-5]
lr_schedule = PiecewiseConstantDecay(boundaries, values)

# Polynomial decay
lr_schedule = PolynomialDecay(
    initial_learning_rate=0.1,
    decay_steps=10000,
    end_learning_rate=0.001,
    power=1.0
)

# Cosine decay (common in modern architectures)
lr_schedule = CosineDecay(
    initial_learning_rate=0.1,
    decay_steps=10000
)

# Warm-up + Decay
class WarmUpCosineDecay(tf.keras.optimizers.schedules.LearningRateSchedule):
    def __init__(self, warmup_steps, total_steps, max_lr):
        self.warmup_steps = warmup_steps
        self.total_steps = total_steps
        self.max_lr = max_lr

    def __call__(self, step):
        # Linear warmup
        warmup_lr = self.max_lr * step / self.warmup_steps
        # Cosine decay
        cosine_decay = 0.5 * self.max_lr * (1 + tf.cos(
            np.pi * (step - self.warmup_steps) / (self.total_steps - self.warmup_steps)
        ))
        return tf.where(step < self.warmup_steps, warmup_lr, cosine_decay)

lr_schedule = WarmUpCosineDecay(warmup_steps=1000, total_steps=10000, max_lr=0.001)
optimizer = Adam(learning_rate=lr_schedule)

# Prevent exploding gradients
optimizer = Adam(learning_rate=0.001, clipnorm=1.0)  # Clip by norm
optimizer = Adam(learning_rate=0.001, clipvalue=0.5)  # Clip by value

# Global gradient clipping
optimizer = Adam(learning_rate=0.001, global_clipnorm=1.0)

from tensorflow.keras.metrics import (Accuracy, BinaryAccuracy, 
                                       CategoricalAccuracy, SparseCategoricalAccuracy,
                                       Precision, Recall, AUC, F1Score)

# Binary classification metrics
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=[
        'accuracy',
        Precision(name='precision'),
        Recall(name='recall'),
        AUC(name='auc')
    ]
)

# Multi-class classification
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=[
        'accuracy',
        SparseCategoricalAccuracy(name='categorical_accuracy'),
        tf.keras.metrics.TopKCategoricalAccuracy(k=3, name='top_3_accuracy')
    ]
)

# F1 Score (requires tensorflow-addons or custom implementation)
# pip install tensorflow-addons
import tensorflow_addons as tfa
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=[tfa.metrics.F1Score(num_classes=1, threshold=0.5)]
)

from tensorflow.keras.metrics import MeanSquaredError, MeanAbsoluteError, RootMeanSquaredError

model.compile(
    optimizer='adam',
    loss='mse',
    metrics=[
        MeanSquaredError(name='mse'),
        MeanAbsoluteError(name='mae'),
        RootMeanSquaredError(name='rmse')
    ]
)

import tensorflow as tf

# Simple custom metric function
def custom_accuracy(y_true, y_pred):
    """Custom accuracy calculation."""
    correct = tf.equal(tf.argmax(y_true, axis=-1), tf.argmax(y_pred, axis=-1))
    return tf.reduce_mean(tf.cast(correct, tf.float32))

# Custom metric as a class (stateful)
class F1Score(tf.keras.metrics.Metric):
    """F1 score metric."""

    def __init__(self, name='f1_score', **kwargs):
        super(F1Score, self).__init__(name=name, **kwargs)
        self.precision = tf.keras.metrics.Precision()
        self.recall = tf.keras.metrics.Recall()

    def update_state(self, y_true, y_pred, sample_weight=None):
        self.precision.update_state(y_true, y_pred, sample_weight)
        self.recall.update_state(y_true, y_pred, sample_weight)

    def result(self):
        p = self.precision.result()
        r = self.recall.result()
        return 2 * ((p * r) / (p + r + tf.keras.backend.epsilon()))

    def reset_state(self):
        self.precision.reset_state()
        self.recall.reset_state()

# Mean Absolute Percentage Error (custom)
class MAPE(tf.keras.metrics.Metric):
    """Mean Absolute Percentage Error."""

    def __init__(self, name='mape', **kwargs):
        super(MAPE, self).__init__(name=name, **kwargs)
        self.total = self.add_weight(name='total', initializer='zeros')
        self.count = self.add_weight(name='count', initializer='zeros')

    def update_state(self, y_true, y_pred, sample_weight=None):
        y_true = tf.cast(y_true, tf.float32)
        y_pred = tf.cast(y_pred, tf.float32)

        # Avoid division by zero
        epsilon = tf.keras.backend.epsilon()
        mape = tf.abs((y_true - y_pred) / (y_true + epsilon)) * 100.0

        self.total.assign_add(tf.reduce_sum(mape))
        self.count.assign_add(tf.cast(tf.size(y_true), tf.float32))

    def result(self):
        return self.total / self.count

    def reset_state(self):
        self.total.assign(0.0)
        self.count.assign(0.0)

# Usage
model.compile(
    optimizer='adam',
    loss='mse',
    metrics=[F1Score(), MAPE(), custom_accuracy]
)

# Different metrics for different outputs
model.compile(
    optimizer='adam',
    loss={
        'output_a': 'categorical_crossentropy',
        'output_b': 'mse'
    },
    metrics={
        'output_a': ['accuracy'],
        'output_b': ['mae', 'mse']
    }
)

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

# With custom optimizer configuration
from tensorflow.keras.optimizers import Adam
model.compile(
    optimizer=Adam(learning_rate=0.001),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Multiple metrics
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy', 'precision', 'recall', 'AUC']
)

# Different losses and metrics for each output
model.compile(
    optimizer='adam',
    loss={
        'output_a': 'categorical_crossentropy',
        'output_b': 'mse'
    },
    loss_weights={
        'output_a': 1.0,
        'output_b': 0.5
    },
    metrics={
        'output_a': ['accuracy'],
        'output_b': ['mae']
    }
)

from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import CategoricalCrossentropy

model.compile(
    optimizer=Adam(learning_rate=0.001, clipnorm=1.0),
    loss=CategoricalCrossentropy(label_smoothing=0.1),
    metrics=['accuracy', custom_metric],
    run_eagerly=False  # Set True for debugging
)

    ┌─────────────────┐
    │  Prepare Data   │
    └────────┬────────┘
             ↓
    ┌─────────────────┐
    │  Compile Model  │
    └────────┬────────┘
             ↓
    ┌─────────────────┐
    │   Train Model   │───┐
    │  (fit method)   │   │
    └────────┬────────┘   │
             ↓             │
    ┌─────────────────┐   │
    │   Validation    │   │
    └────────┬────────┘   │
             │             │
      ┌──────┴──────┐      │
      ↓             ↓      │
  (Good)      (Needs Work) │
      │             │      │
      ↓             └──────┘
  [Deploy]      [Adjust & Retrain]

import numpy as np
import tensorflow as tf

# Prepare data
x_train = np.random.random((1000, 784))
y_train = np.random.randint(10, size=(1000,))

# One-hot encoding (for categorical_crossentropy)
y_train_categorical = tf.keras.utils.to_categorical(y_train, num_classes=10)

# Train with one-hot labels
history = model.fit(
    x_train, 
    y_train_categorical,
    epochs=10,
    batch_size=32,
    verbose=1  # 0=silent, 1=progress bar, 2=one line per epoch
)

# Or use integer labels (for sparse_categorical_crossentropy)
history = model.fit(
    x_train,
    y_train,  # Integer labels
    epochs=10,
    batch_size=32
)

# Automatic validation split
history = model.fit(
    x_train, y_train,
    epochs=50,
    batch_size=32,
    validation_split=0.2,  # Use 20% of training data for validation
    verbose=1
)

# Separate validation data
x_val = np.random.random((200, 784))
y_val = np.random.randint(10, size=(200,))

history = model.fit(
    x_train, y_train,
    epochs=50,
    batch_size=32,
    validation_data=(x_val, y_val),
    verbose=1
)

import tensorflow as tf

# Create dataset from tensors
dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))

# Optimize dataset performance
dataset = dataset.shuffle(buffer_size=1024)  # Shuffle before batching
dataset = dataset.batch(32)
dataset = dataset.prefetch(tf.data.AUTOTUNE)  # Overlap data loading and training

# Validation dataset
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(32).prefetch(tf.data.AUTOTUNE)

# Train
history = model.fit(
    dataset,
    epochs=10,
    validation_data=val_dataset
)

# Complete pipeline with augmentation
def preprocess(image, label):
    """Preprocess and augment data."""
    image = tf.cast(image, tf.float32) / 255.0
    # Add augmentation here if needed
    return image, label

train_dataset = (
    tf.data.Dataset.from_tensor_slices((x_train, y_train))
    .shuffle(10000)
    .map(preprocess, num_parallel_calls=tf.data.AUTOTUNE)
    .batch(32)
    .prefetch(tf.data.AUTOTUNE)
)

val_dataset = (
    tf.data.Dataset.from_tensor_slices((x_val, y_val))
    .map(preprocess, num_parallel_calls=tf.data.AUTOTUNE)
    .batch(32)
    .prefetch(tf.data.AUTOTUNE)
)

history = model.fit(train_dataset, epochs=10, validation_data=val_dataset)

from tensorflow.keras.callbacks import (ModelCheckpoint, EarlyStopping, 
                                         TensorBoard, ReduceLROnPlateau,
                                         CSVLogger, LearningRateScheduler)

# ModelCheckpoint - Save best model
checkpoint = ModelCheckpoint(
    filepath='best_model.h5',
    monitor='val_loss',
    save_best_only=True,
    save_weights_only=False,
    mode='min',
    verbose=1
)

# EarlyStopping - Stop when no improvement
early_stop = EarlyStopping(
    monitor='val_loss',
    patience=10,
    restore_best_weights=True,
    verbose=1
)

# ReduceLROnPlateau - Reduce learning rate on plateau
reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.2,
    patience=5,
    min_lr=1e-7,
    verbose=1
)

# TensorBoard - Visualization
tensorboard = TensorBoard(
    log_dir='./logs',
    histogram_freq=1,
    write_graph=True,
    write_images=False,
    update_freq='epoch'
)

# CSVLogger - Log to CSV
csv_logger = CSVLogger('training_log.csv', append=True)

# Custom LR schedule
def lr_schedule(epoch, lr):
    """Decay learning rate every 10 epochs."""
    if epoch % 10 == 0 and epoch > 0:
        return lr * 0.9
    return lr

lr_scheduler = LearningRateScheduler(lr_schedule, verbose=1)

# Train with callbacks
history = model.fit(
    x_train, y_train,
    epochs=100,
    batch_size=32,
    validation_data=(x_val, y_val),
    callbacks=[checkpoint, early_stop, reduce_lr, tensorboard, csv_logger]
)

class CustomCallback(tf.keras.callbacks.Callback):
    """Custom callback for monitoring training."""

    def on_epoch_end(self, epoch, logs=None):
        """Called at the end of each epoch."""
        if logs.get('val_loss') < 0.3:
            print(f"\nReached target loss at epoch {epoch + 1}")
            self.model.stop_training = True

    def on_batch_end(self, batch, logs=None):
        """Called at the end of each batch."""
        if batch % 100 == 0:
            print(f"\nBatch {batch}: loss = {logs.get('loss'):.4f}")

    def on_train_begin(self, logs=None):
        """Called at beginning of training."""
        print("Starting training...")

    def on_train_end(self, logs=None):
        """Called at end of training."""
        print("Training completed!")

# Usage
history = model.fit(
    x_train, y_train,
    epochs=50,
    callbacks=[CustomCallback()]
)

import matplotlib.pyplot as plt

# Plot training history
def plot_history(history):
    """Visualize training metrics."""
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

    # Loss
    ax1.plot(history.history['loss'], label='Training Loss')
    ax1.plot(history.history['val_loss'], label='Validation Loss')
    ax1.set_title('Model Loss')
    ax1.set_xlabel('Epoch')
    ax1.set_ylabel('Loss')
    ax1.legend()
    ax1.grid(True)

    # Accuracy
    ax2.plot(history.history['accuracy'], label='Training Accuracy')
    ax2.plot(history.history['val_accuracy'], label='Validation Accuracy')
    ax2.set_title('Model Accuracy')
    ax2.set_xlabel('Epoch')
    ax2.set_ylabel('Accuracy')
    ax2.legend()
    ax2.grid(True)

    plt.tight_layout()
    plt.show()

plot_history(history)

# Access history values
print(f"Final training loss: {history.history['loss'][-1]:.4f}")
print(f"Final validation loss: {history.history['val_loss'][-1]:.4f}")
print(f"Best validation loss: {min(history.history['val_loss']):.4f}")

from sklearn.utils.class_weight import compute_class_weight
import numpy as np

# Compute class weights
class_weights = compute_class_weight(
    'balanced',
    classes=np.unique(y_train),
    y=y_train
)
class_weight_dict = dict(enumerate(class_weights))

# Train with class weights
history = model.fit(
    x_train, y_train,
    epochs=50,
    batch_size=32,
    class_weight=class_weight_dict,
    validation_data=(x_val, y_val)
)

# Or use sample weights
sample_weights = np.ones(len(y_train))
sample_weights[y_train == minority_class] = 2.0  # Increase weight for minority class

history = model.fit(
    x_train, y_train,
    sample_weight=sample_weights,
    epochs=50,
    batch_size=32,
    validation_data=(x_val, y_val)
)

import numpy as np

# Basic evaluation
loss, accuracy = model.evaluate(x_test, y_test, verbose=1)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy:.4f}')

# Evaluation with multiple metrics
results = model.evaluate(
    x_test, y_test,
    batch_size=32,
    verbose=1,
    return_dict=True  # Return as dictionary
)
print(f"Results: {results}")

# Evaluation with dataset
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
results = model.evaluate(test_dataset)

from sklearn.metrics import (classification_report, confusion_matrix, 
                              roc_auc_score, roc_curve)
import matplotlib.pyplot as plt
import seaborn as sns

# Get predictions
y_pred_proba = model.predict(x_test)
y_pred = np.argmax(y_pred_proba, axis=1)

# Classification report
print(classification_report(y_test, y_pred))

# Confusion matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.show()

# ROC-AUC for binary classification
if num_classes == 2:
    fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba[:, 1])
    auc_score = roc_auc_score(y_test, y_pred_proba[:, 1])

    plt.figure(figsize=(8, 6))
    plt.plot(fpr, tpr, label=f'AUC = {auc_score:.3f}')
    plt.plot([0, 1], [0, 1], 'k--', label='Random')
    plt.xlabel('False Positive Rate')
    plt.ylabel('True Positive Rate')
    plt.title('ROC Curve')
    plt.legend()
    plt.grid(True)
    plt.show()

import numpy as np

# Basic prediction
predictions = model.predict(x_test)

# For classification - get class probabilities
# Shape: (num_samples, num_classes)
print(predictions[0])  # [0.05, 0.10, 0.02, ..., 0.65]

# Get predicted class
predicted_classes = np.argmax(predictions, axis=1)

# With confidence threshold (binary classification)
threshold = 0.7
predictions_binary = (predictions > threshold).astype(int)

# Batch prediction for large datasets
def predict_in_batches(model, data, batch_size=32):
    """Predict in batches to save memory."""
    predictions = []
    for i in range(0, len(data), batch_size):
        batch = data[i:i + batch_size]
        pred = model.predict(batch, verbose=0)
        predictions.append(pred)
    return np.vstack(predictions)

predictions = predict_in_batches(model, x_test, batch_size=64)

# Predict with dataset
test_dataset = tf.data.Dataset.from_tensor_slices(x_test).batch(32)
predictions = model.predict(test_dataset)

# Top-K predictions
def get_top_k_predictions(predictions, k=3, class_names=None):
    """Get top-K predicted classes with probabilities."""
    top_k_indices = np.argsort(predictions, axis=1)[:, -k:][:, ::-1]
    top_k_probs = np.sort(predictions, axis=1)[:, -k:][:, ::-1]

    results = []
    for i in range(len(predictions)):
        sample_results = []
        for j in range(k):
            class_idx = top_k_indices[i, j]
            prob = top_k_probs[i, j]
            class_name = class_names[class_idx] if class_names else class_idx
            sample_results.append((class_name, prob))
        results.append(sample_results)
    return results

# Example
class_names = ['cat', 'dog', 'bird', 'fish', 'horse']
top_3 = get_top_k_predictions(predictions, k=3, class_names=class_names)
print(f"Top 3 predictions: {top_3[0]}")

# Monte Carlo Dropout for uncertainty estimation
def predict_with_uncertainty(model, x, n_iter=100):
    """Estimate prediction uncertainty using dropout."""
    predictions = []
    for _ in range(n_iter):
        # Enable dropout during prediction
        pred = model(x, training=True)
        predictions.append(pred)

    predictions = np.array(predictions)
    mean = predictions.mean(axis=0)
    std = predictions.std(axis=0)
    return mean, std

# Usage
x_sample = x_test[:10]
mean_pred, std_pred = predict_with_uncertainty(model, x_sample, n_iter=100)
print(f"Prediction: {mean_pred[0]}")
print(f"Uncertainty: {std_pred[0]}")

Format          Use Case                  Size    Portability
────────────────────────────────────────────────────────────
.keras          Recommended (TF 2.x)      Medium  TensorFlow
SavedModel      Production deployment     Large   Cross-platform
.h5 (HDF5)      Legacy format             Small   TensorFlow
Weights only    Transfer learning         Smallest TensorFlow

# Keras format (recommended for TF 2.x)
model.save('my_model.keras')

# SavedModel format (production)
model.save('saved_model/')

# HDF5 format (legacy)
model.save('my_model.h5')

# Include optimizer state
model.save('model_with_optimizer.keras', save_format='keras')

from tensorflow.keras.models import load_model

# Load Keras format
model = load_model('my_model.keras')

# Load SavedModel
model = load_model('saved_model/')

# Load HDF5
model = load_model('my_model.h5')

# Model with custom objects
model = load_model(
    'my_model.keras',
    custom_objects={'CustomLayer': CustomLayer, 'custom_loss': custom_loss}
)

# Verify loaded model
model.summary()
loaded_predictions = model.predict(x_test[:5])

# Save weights
model.save_weights('model_weights.h5')  # HDF5
model.save_weights('weights/')  # TensorFlow format

# Load weights (model architecture must exist)
model = create_model()  # Build model architecture first
model.load_weights('model_weights.h5')

# Load weights with checkpoint
checkpoint_path = "training/cp-{epoch:04d}.ckpt"
model.save_weights(checkpoint_path.format(epoch=0))
model.load_weights(checkpoint_path.format(epoch=0))

# Verify weights loaded correctly
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
loss, acc = model.evaluate(x_test, y_test)

# As JSON
json_config = model.to_json()
with open('model_architecture.json', 'w') as f:
    f.write(json_config)

# Load from JSON
from tensorflow.keras.models import model_from_json
with open('model_architecture.json', 'r') as f:
    json_config = f.read()
model = model_from_json(json_config)

# As YAML (requires pyyaml)
yaml_config = model.to_yaml()
with open('model_architecture.yaml', 'w') as f:
    f.write(yaml_config)

# Load from YAML
from tensorflow.keras.models import model_from_yaml
with open('model_architecture.yaml', 'r') as f:
    yaml_config = f.read()
model = model_from_yaml(yaml_config)

# Get config as dict
config = model.get_config()
model_from_config = tf.keras.Model.from_config(config)

# Export to SavedModel format
import time
export_path = f'./exported_models/{int(time.time())}'
model.save(export_path, save_format='tf')

# With signatures for serving
@tf.function
def serve_fn(inputs):
    return model(inputs)

# Save with serving signature
tf.saved_model.save(
    model,
    export_path,
    signatures={'serving_default': serve_fn.get_concrete_function(
        tf.TensorSpec(shape=[None, 784], dtype=tf.float32, name='inputs')
    )}
)

from tensorflow.keras.callbacks import ModelCheckpoint

# Save best model during training
checkpoint = ModelCheckpoint(
    filepath='best_model.keras',
    monitor='val_accuracy',
    mode='max',
    save_best_only=True,
    verbose=1
)

# Save at every epoch
checkpoint_all = ModelCheckpoint(
    filepath='model_epoch_{epoch:02d}_loss_{val_loss:.2f}.keras',
    save_freq='epoch',
    verbose=1
)

# Save weights only
checkpoint_weights = ModelCheckpoint(
    filepath='weights/cp-{epoch:04d}.ckpt',
    save_weights_only=True,
    save_freq='epoch'
)

history = model.fit(
    x_train, y_train,
    epochs=50,
    validation_data=(x_val, y_val),
    callbacks=[checkpoint, checkpoint_all]
)

import os
from datetime import datetime

def save_versioned_model(model, base_path='models'):
    """Save model with timestamp version."""
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    version_path = os.path.join(base_path, f'model_v{timestamp}')
    os.makedirs(version_path, exist_ok=True)

    # Save model
    model.save(os.path.join(version_path, 'model.keras'))

    # Save metadata
    metadata = {
        'version': timestamp,
        'metrics': history.history,
        'architecture': model.to_json()
    }

    import json
    with open(os.path.join(version_path, 'metadata.json'), 'w') as f:
        json.dump(metadata, f, indent=2)

    return version_path

# Usage
version_path = save_versioned_model(model)
print(f"Model saved to: {version_path}")

Technique               Effect              When to Use
────────────────────────────────────────────────────────────
L1 (Lasso)             Feature selection    Sparse features
L2 (Ridge)             Weight penalty       General overfitting
Dropout                Random deactivation  Deep networks
Batch Normalization    Stabilize training   Most architectures
Early Stopping         Stop at best         Always
Data Augmentation      More training data   Limited data

from tensorflow.keras import regularizers
from tensorflow.keras.layers import Dense

# L2 regularization (most common)
model = Sequential([
    Dense(128, activation='relu', input_shape=(784,),
          kernel_regularizer=regularizers.l2(0.01)),
    Dense(64, activation='relu',
          kernel_regularizer=regularizers.l2(0.01)),
    Dense(10, activation='softmax')
])

# L1 regularization (feature selection)
Dense(128, kernel_regularizer=regularizers.l1(0.01))

# L1 + L2 (Elastic Net)
Dense(128, kernel_regularizer=regularizers.l1_l2(l1=0.01, l2=0.01))

# Apply to bias as well
Dense(128, activation='relu',
      kernel_regularizer=regularizers.l2(0.01),
      bias_regularizer=regularizers.l2(0.01))

# Activity regularization (regularize layer output)
Dense(128, activation='relu',
      activity_regularizer=regularizers.l2(0.01))

from tensorflow.keras.layers import Dropout, SpatialDropout2D

# Standard dropout (randomly drops neurons)
model = Sequential([
    Dense(128, activation='relu', input_shape=(784,)),
    Dropout(0.5),  # 50% dropout rate
    Dense(64, activation='relu'),
    Dropout(0.3),  # 30% dropout rate
    Dense(10, activation='softmax')
])

# Spatial dropout for CNNs (drops entire feature maps)
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    SpatialDropout2D(0.2),  # Drop 20% of feature maps
    Conv2D(64, (3, 3), activation='relu'),
    SpatialDropout2D(0.2),
    Flatten(),
    Dense(10, activation='softmax')
])

# Dropout with RNNs
LSTM(64, dropout=0.2, recurrent_dropout=0.2)

# Monte Carlo Dropout (keep dropout during inference for uncertainty)
model = Sequential([
    Dense(128, activation='relu'),
    Dropout(0.5),
    Dense(10, activation='softmax')
])

# Predict with MC dropout
predictions = [model(x_test, training=True) for _ in range(100)]
mean_prediction = np.mean(predictions, axis=0)

from tensorflow.keras.layers import BatchNormalization

# After dense layer, before activation
model = Sequential([
    Dense(128, use_bias=False, input_shape=(784,)),
    BatchNormalization(),
    Activation('relu'),
    Dense(64, use_bias=False),
    BatchNormalization(),
    Activation('relu'),
    Dense(10, activation='softmax')
])

# Or after activation (both work, slight preference for before)
model = Sequential([
    Dense(128, activation='relu', input_shape=(784,)),
    BatchNormalization(),
    Dense(64, activation='relu'),
    BatchNormalization(),
    Dense(10, activation='softmax')
])

# Batch norm parameters
BatchNormalization(
    momentum=0.99,      # Exponential moving average factor
    epsilon=0.001,      # Small constant for numerical stability
    center=True,        # Use beta offset
    scale=True,         # Use gamma scaling
    beta_initializer='zeros',
    gamma_initializer='ones'
)

# For CNNs
model = Sequential([
    Conv2D(32, (3, 3), use_bias=False, input_shape=(28, 28, 1)),
    BatchNormalization(),
    Activation('relu'),
    Conv2D(64, (3, 3), use_bias=False),
    BatchNormalization(),
    Activation('relu'),
    Flatten(),
    Dense(10, activation='softmax')
])

from tensorflow.keras.layers import LayerNormalization

# Alternative to batch norm (better for RNNs/Transformers)
model = Sequential([
    Dense(128, activation='relu', input_shape=(784,)),
    LayerNormalization(),
    Dense(64, activation='relu'),
    LayerNormalization(),
    Dense(10, activation='softmax')
])

from tensorflow.keras.callbacks import EarlyStopping

# Stop training when validation loss stops improving
early_stop = EarlyStopping(
    monitor='val_loss',
    patience=10,              # Wait 10 epochs after last improvement
    restore_best_weights=True,  # Restore weights from best epoch
    mode='min',
    verbose=1
)

history = model.fit(
    x_train, y_train,
    epochs=100,
    validation_data=(x_val, y_val),
    callbacks=[early_stop]
)

from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Image augmentation
datagen = ImageDataGenerator(
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    zoom_range=0.2,
    shear_range=0.2,
    fill_mode='nearest'
)

# Train with augmented data
history = model.fit(
    datagen.flow(x_train, y_train, batch_size=32),
    epochs=50,
    validation_data=(x_val, y_val)
)

# Using tf.image (more modern approach)
def augment(image, label):
    """Augmentation function."""
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, max_delta=0.2)
    image = tf.image.random_contrast(image, lower=0.8, upper=1.2)
    image = tf.image.random_saturation(image, lower=0.8, upper=1.2)
    return image, label

# Apply to dataset
train_dataset = train_dataset.map(augment, num_parallel_calls=tf.data.AUTOTUNE)

from tensorflow.keras import Sequential, regularizers
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization

# Comprehensive regularization
model = Sequential([
    Dense(256, activation='relu', input_shape=(784,),
          kernel_regularizer=regularizers.l2(0.01)),
    BatchNormalization(),
    Dropout(0.5),

    Dense(128, activation='relu',
          kernel_regularizer=regularizers.l2(0.01)),
    BatchNormalization(),
    Dropout(0.4),

    Dense(64, activation='relu',
          kernel_regularizer=regularizers.l2(0.01)),
    BatchNormalization(),
    Dropout(0.3),

    Dense(10, activation='softmax')
])

# Train with early stopping
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau

callbacks = [
    EarlyStopping(monitor='val_loss', patience=15, restore_best_weights=True),
    ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5)
]

history = model.fit(
    x_train, y_train,
    epochs=100,
    batch_size=32,
    validation_data=(x_val, y_val),
    callbacks=callbacks
)

    ┌────────────────────┐
    │ Load Pretrained    │
    │   Base Model       │
    └─────────┬──────────┘
              ↓
    ┌────────────────────┐
    │  Freeze Layers     │
    └─────────┬──────────┘
              ↓
    ┌────────────────────┐
    │ Add Custom Layers  │
    └─────────┬──────────┘
              ↓
    ┌────────────────────┐
    │  Train (Feature    │
    │   Extraction)      │
    └─────────┬──────────┘
              ↓
         (Optional)
    ┌────────────────────┐
    │ Unfreeze Some      │
    │    Layers          │
    └─────────┬──────────┘
              ↓
    ┌────────────────────┐
    │  Fine-tune with    │
    │   Low LR           │
    └────────────────────┘

from tensorflow.keras.applications import (
    VGG16, VGG19,
    ResNet50, ResNet101, ResNet152,
    InceptionV3, InceptionResNetV2,
    MobileNet, MobileNetV2, MobileNetV3Small, MobileNetV3Large,
    DenseNet121, DenseNet169, DenseNet201,
    EfficientNetB0, EfficientNetB7,
    Xception, NASNetLarge, NASNetMobile
)

# All models support:
# - weights='imagenet' (pretrained on ImageNet)
# - include_top=False (exclude classification layer)
# - input_shape=(height, width, channels)

from tensorflow.keras.applications import ResNet50
from tensorflow.keras import layers, models

# Load pretrained model without top layer
base_model = ResNet50(
    weights='imagenet',
    include_top=False,
    input_shape=(224, 224, 3)
)

# Freeze base model
base_model.trainable = False

# Build complete model
model = models.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')  # 10 classes
])

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

model.summary()

# Train
history = model.fit(
    train_dataset,
    epochs=10,
    validation_data=val_dataset
)