1. TensorFlow Cheat Sheet

relu:     f(x) = max(0, x)         → Most common, fast
sigmoid:  f(x) = 1/(1+e^(-x))      → Binary classification output
tanh:     f(x) = (e^x-e^(-x))/(e^x+e^(-x)) → Range [-1,1]
softmax:  f(x) = e^xi / Σe^xj      → Multi-class classification
elu:      f(x) = x if x>0 else α(e^x-1) → Smooth approximation
swish:    f(x) = x * sigmoid(x)    → Self-gated, smooth

Binary Classification:    binary_crossentropy
Multi-class (one-hot):    categorical_crossentropy  
Multi-class (integers):   sparse_categorical_crossentropy
Regression:               mean_squared_error, mean_absolute_error
Ranking/Metric Learning:  hinge, triplet_loss

Adam:     Adaptive learning, momentum → Default choice
SGD:      Simple, stable → Fine-tuning, convergence
RMSprop:  Adaptive learning → RNNs, non-stationary
Adagrad:  Adaptive per-parameter → Sparse data

# Install TensorFlow (CPU and GPU support included)
pip install tensorflow

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

import tensorflow as tf
import numpy as np

# Check TensorFlow version
print(f"TensorFlow version: {tf.__version__}")

# Check GPU availability
gpus = tf.config.list_physical_devices('GPU')
print(f"Num GPUs Available: {len(gpus)}")

# Enable memory growth for GPUs (prevents OOM errors)
if gpus:
    try:
        for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
        print(f"Memory growth enabled for {len(gpus)} GPU(s)")
    except RuntimeError as e:
        print(e)

# Set random seeds for reproducibility
tf.random.set_seed(42)
np.random.seed(42)

    ┌──────────────────┐
    │   Load Data      │
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │  Preprocess      │───→ tf.data pipeline
    │  & Augment       │     (map, batch, prefetch)
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │  Build Model     │───→ Sequential, Functional,
    │                  │     or Subclassing API
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │  Compile Model   │───→ optimizer, loss, metrics
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │  Train Model     │───→ model.fit() or custom loop
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │  Evaluate        │───→ model.evaluate()
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │  Predict         │───→ model.predict()
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │  Save Model      │───→ SavedModel or HDF5
    └──────────────────┘

    TensorFlow Tensors
           │
    ┌──────┴──────┐
    ↓             ↓
Constant      Variable
(Immutable)   (Mutable)
    │             │
    └──────┬──────┘
           ↓
    GPU/CPU Memory

# Constant tensors
a = tf.constant([[1, 2], [3, 4]])                    # From list
b = tf.zeros((2, 3))                                  # All zeros
c = tf.ones((3, 2))                                   # All ones
d = tf.eye(3)                                         # Identity matrix
e = tf.fill((2, 3), 9)                               # Fill with specific value

# Random tensors
f = tf.random.normal((2, 2), mean=0.0, stddev=1.0)   # Normal distribution
g = tf.random.uniform((2, 2), minval=0, maxval=10)   # Uniform distribution
h = tf.random.truncated_normal((2, 2))               # Truncated normal

# From NumPy arrays
arr = np.array([[1, 2], [3, 4]])
tensor_from_np = tf.convert_to_tensor(arr)

# Sequences
range_tensor = tf.range(start=0, limit=10, delta=2)  # [0, 2, 4, 6, 8]
linspace_tensor = tf.linspace(0.0, 1.0, num=5)       # [0.0, 0.25, 0.5, 0.75, 1.0]

# One-hot encoding
labels = tf.constant([0, 1, 2, 0])
one_hot = tf.one_hot(labels, depth=3)                # Shape: (4, 3)

tensor = tf.constant([[1, 2], [3, 4]])
print(tensor.shape)       # Shape of the tensor
print(tensor.dtype)       # Data type of the tensor
print(tensor.device)      # Device where the tensor is stored (CPU or GPU)
print(tensor.numpy())     # Convert to a NumPy array

a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
b = tf.constant([[5.0, 6.0], [7.0, 8.0]])

# Element-wise operations
add_result = a + b                    # [[6, 8], [10, 12]]
sub_result = a - b                    # [[-4, -4], [-4, -4]]
mul_result = a * b                    # [[5, 12], [21, 32]]
div_result = a / b                    # [[0.2, 0.33], [0.43, 0.5]]
pow_result = tf.pow(a, 2)            # [[1, 4], [9, 16]]

# Matrix operations
matmul_result = tf.matmul(a, b)      # [[19, 22], [43, 50]]
transpose_result = tf.transpose(a)    # [[1, 3], [2, 4]]
determinant = tf.linalg.det(a)       # -2.0
inverse = tf.linalg.inv(a)           # [[-2, 1], [1.5, -0.5]]

# Shape operations
reshape_result = tf.reshape(a, [1, 4])         # [[1, 2, 3, 4]]
squeeze_result = tf.squeeze([[[1], [2]]])      # [1, 2]
expand_result = tf.expand_dims([1, 2], axis=0) # [[1, 2]]

# Concatenation and stacking
concat_result = tf.concat([a, b], axis=0)      # Shape: (4, 2)
stack_result = tf.stack([a, b], axis=0)        # Shape: (2, 2, 2)

# Reduction operations
sum_all = tf.reduce_sum(a)                     # 10.0
sum_axis0 = tf.reduce_sum(a, axis=0)          # [4, 6]
mean_all = tf.reduce_mean(a)                   # 2.5
max_val = tf.reduce_max(a)                     # 4.0
min_val = tf.reduce_min(a)                     # 1.0

# Argmax and Argmin
argmax_axis1 = tf.argmax(a, axis=1)           # [1, 1] (indices)
argmin_axis0 = tf.argmin(a, axis=0)           # [0, 0] (indices)

# Comparison operations
greater = tf.greater(a, 2.0)                  # [[False, False], [True, True]]
equal = tf.equal(a, b)                        # [[False, False], [False, False]]

# Clipping
clipped = tf.clip_by_value(a, 2.0, 3.0)      # [[2, 2], [3, 3]]

# Casting
float_tensor = tf.cast(tf.constant([1, 2, 3]), tf.float32)
int_tensor = tf.cast(tf.constant([1.5, 2.8]), tf.int32)  # [1, 2]

    Input Tensors (a, b)
           │
    ┌──────┴──────┐
    ↓             ↓
Element-wise    Matrix Ops
Operations      (matmul)
    │             │
    ├─→ +, -, *, / │
    ├─→ pow, sqrt  │
    └─→ log, exp   ↓
           │    Transpose,
           │    Inverse
           ↓
    Reduction Ops
    (sum, mean, max)
           │
           ↓
    Output Tensor

tensor = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(tensor[0])       # First row
print(tensor[:, 1])     # Second column
print(tensor[0:2, 1:3]) # Slicing

# Create a variable
var = tf.Variable([1.0, 2.0], name='my_variable')

# Assign new values
var.assign([3.0, 4.0])          # Replace entire value
var.assign_add([1.0, 1.0])      # Add to current value: [4.0, 5.0]
var.assign_sub([0.5, 0.5])      # Subtract from current value: [3.5, 4.5]

# Accessing properties
print(var.numpy())               # Convert to NumPy array
print(var.shape)                 # Shape of the variable
print(var.dtype)                 # Data type
print(var.trainable)             # Whether variable is trainable

# Non-trainable variables (e.g., for batch norm moving averages)
non_trainable_var = tf.Variable([1.0, 2.0], trainable=False)

# Initialize variables
initial_value = tf.random.normal((3, 3))
weight_var = tf.Variable(initial_value, name='weights')

    Create Variable
           │
           ↓
    ┌──────────────┐
    │ Initialize   │
    └──────┬───────┘
           ↓
    ┌──────────────┐
    │   Training   │◄──┐
    │   Updates    │   │
    └──────┬───────┘   │
           │           │
           ├───────────┘ (Multiple epochs)
           ↓
    ┌──────────────┐
    │    Save      │
    │  Checkpoint  │
    └──────────────┘

    Forward Pass
         │
    ┌────▼────┐
    │ Record  │───→ GradientTape
    │  Ops    │     (stores computation graph)
    └────┬────┘
         ↓
    Loss Value
         │
         ↓
    ┌────────────┐
    │  Compute   │───→ tape.gradient()
    │ Gradients  │
    └────┬───────┘
         ↓
    Update Weights

# Simple gradient
x = tf.Variable(3.0)

with tf.GradientTape() as tape:
    y = x**2  # y = 9.0

dy_dx = tape.gradient(y, x)  # dy/dx = 2*x = 6.0
print(f"Gradient: {dy_dx.numpy()}")

x = tf.Variable(3.0)

with tf.GradientTape(persistent=True) as tape:
    y = x**2          # y = 9.0
    z = y * 2         # z = 18.0

dy_dx = tape.gradient(y, x)  # dy/dx = 2*x = 6.0
dz_dx = tape.gradient(z, x)  # dz/dx = 4*x = 12.0

print(f"dy/dx: {dy_dx.numpy()}")
print(f"dz/dx: {dz_dx.numpy()}")

del tape  # Clean up persistent tape

# Constants aren't watched by default
x = tf.constant(3.0)

with tf.GradientTape() as tape:
    tape.watch(x)  # Explicitly watch the constant
    y = x**2

dy_dx = tape.gradient(y, x)
print(f"Gradient: {dy_dx.numpy()}")

x = tf.Variable(2.0)
y = tf.Variable(3.0)

with tf.GradientTape() as tape:
    z = x**2 + y**2  # z = 4 + 9 = 13

# Compute gradients for both variables
gradients = tape.gradient(z, [x, y])  # [dz/dx, dz/dy] = [4.0, 6.0]
print(f"dz/dx: {gradients[0].numpy()}")
print(f"dz/dy: {gradients[1].numpy()}")

x = tf.Variable(3.0)

with tf.GradientTape() as outer_tape:
    with tf.GradientTape() as inner_tape:
        y = x**3  # y = 27

    # First derivative: dy/dx = 3*x^2
    dy_dx = inner_tape.gradient(y, x)

# Second derivative: d²y/dx² = 6*x
d2y_dx2 = outer_tape.gradient(dy_dx, x)

print(f"First derivative: {dy_dx.numpy()}")   # 27.0
print(f"Second derivative: {d2y_dx2.numpy()}") # 18.0

                Model Building APIs
                       │
        ┌──────────────┼──────────────┐
        ↓              ↓              ↓
   Sequential    Functional API   Subclassing
   (Simplest)     (Flexible)     (Most Control)
        │              │              │
        ├─→ Linear     ├─→ Multiple   ├─→ Custom
        │   stack      │   inputs/    │   logic
        │              │   outputs    │
        └─→ Quick      ├─→ Shared     └─→ Dynamic
            prototypes │   layers         graphs
                       └─→ Complex
                           topologies

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

# Method 1: Pass layers as list
model = Sequential([
    Dense(128, activation='relu', input_shape=(784,)),
    Dropout(0.2),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

# Method 2: Add layers incrementally
model = Sequential()
model.add(Dense(128, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))

# View model architecture
model.summary()

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

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

# Multiple inputs
input1 = Input(shape=(64,), name='input1')
input2 = Input(shape=(32,), name='input2')

x1 = Dense(32, activation='relu')(input1)
x2 = Dense(32, activation='relu')(input2)

# Merge branches
merged = Concatenate()([x1, x2])
output = Dense(10, activation='softmax')(merged)

model = Model(inputs=[input1, input2], outputs=output)

import tensorflow as tf

class MyModel(tf.keras.Model):
    def __init__(self, num_classes=10):
        super(MyModel, self).__init__()
        self.dense1 = tf.keras.layers.Dense(128, activation='relu')
        self.dropout = tf.keras.layers.Dropout(0.2)
        self.dense2 = tf.keras.layers.Dense(64, activation='relu')
        self.classifier = tf.keras.layers.Dense(num_classes, activation='softmax')

    def call(self, inputs, training=None):
        x = self.dense1(inputs)
        if training:
            x = self.dropout(x, training=training)
        x = self.dense2(x)
        return self.classifier(x)

model = MyModel(num_classes=10)

# Build model by calling it
_ = model(tf.zeros((1, 784)))
model.summary()

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

inputs = Input(shape=(64,))
x = Dense(64, activation='relu')(inputs)
x = Dense(64, activation='relu')(x)

# Skip connection
outputs = Add()([inputs, x])

model = Model(inputs=inputs, outputs=outputs)

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

# Dense (Fully Connected) Layer
dense = Dense(units=64, activation='relu', use_bias=True,
              kernel_initializer='glorot_uniform',
              bias_initializer='zeros')

# Activation Layer
activation = Activation('relu')  # or use directly in Dense

# Dropout (regularization)
dropout = Dropout(rate=0.5)  # Drops 50% of inputs during training

# Flatten (convert 2D/3D to 1D)
flatten = Flatten()  # (batch, height, width, channels) → (batch, features)

from tensorflow.keras.layers import Conv2D, MaxPooling2D, AveragePooling2D

# 2D Convolution
conv2d = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1),
                padding='same', activation='relu')

# Max Pooling
maxpool = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')

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

# Global Pooling (reduces to 1 value per channel)
from tensorflow.keras.layers import GlobalAveragePooling2D, GlobalMaxPooling2D
gap = GlobalAveragePooling2D()
gmp = GlobalMaxPooling2D()

Input Image (224×224×3)
        │
        ↓
    ┌─────────────┐
    │  Conv2D     │ filters=32, kernel=3×3
    │  + ReLU     │
    └──────┬──────┘
           ↓
    ┌─────────────┐
    │ MaxPool2D   │ pool=2×2 → (112×112×32)
    └──────┬──────┘
           ↓
    ┌─────────────┐
    │  Conv2D     │ filters=64, kernel=3×3
    │  + ReLU     │
    └──────┬──────┘
           ↓
    ┌─────────────┐
    │   Flatten   │
    └──────┬──────┘
           ↓
    ┌─────────────┐
    │   Dense     │ units=128
    └──────┬──────┘
           ↓
    ┌─────────────┐
    │   Output    │ units=10 (classes)
    └─────────────┘

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

# LSTM Layer
lstm = LSTM(units=128, return_sequences=True,  # Return full sequence
            return_state=False,                 # Don't return hidden states
            dropout=0.2, recurrent_dropout=0.2)

# GRU Layer
gru = GRU(units=64, return_sequences=False)

# Bidirectional wrapper
bilstm = Bidirectional(LSTM(64, return_sequences=True))

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

from tensorflow.keras.layers import BatchNormalization, LayerNormalization

# Batch Normalization (normalize across batch)
batchnorm = BatchNormalization(momentum=0.99, epsilon=0.001)

# Layer Normalization (normalize across features)
layernorm = LayerNormalization()

# Usage in model
model = Sequential([
    Dense(64),
    BatchNormalization(),
    Activation('relu')
])

from tensorflow.keras.layers import Embedding

# For text/categorical data
embedding = Embedding(input_dim=10000,      # Vocabulary size
                     output_dim=128,        # Embedding dimension
                     input_length=100)      # Sequence length

# Example usage
model = Sequential([
    Embedding(10000, 128, input_length=100),
    LSTM(64),
    Dense(1, activation='sigmoid')
])

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

# Add (element-wise sum)
add_layer = Add()([tensor1, tensor2])

# Multiply (element-wise product)
multiply_layer = Multiply()([tensor1, tensor2])

# Concatenate (along axis)
concat_layer = Concatenate(axis=-1)([tensor1, tensor2])

# Average
avg_layer = Average()([tensor1, tensor2])

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

    Data Loading
         │
         ↓
    Preprocessing
         │
         ↓
    ┌────────────┐
    │  Epoch 1   │
    └─────┬──────┘
          ↓
    ┌──────────────────┐
    │  Forward Pass    │───→ Compute predictions
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │  Compute Loss    │───→ Loss function
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │  Backward Pass   │───→ Compute gradients
    └────────┬─────────┘
             ↓
    ┌──────────────────┐
    │ Update Weights   │───→ Optimizer step
    └────────┬─────────┘
             │
             └──→ Repeat for all batches

# Prepare data
data = np.random.random((1000, 784))
labels = np.random.randint(10, size=(1000,))
one_hot_labels = tf.keras.utils.to_categorical(labels, num_classes=10)

# Split into train and validation
from sklearn.model_selection import train_test_split
X_train, X_val, y_train, y_val = train_test_split(
    data, one_hot_labels, test_size=0.2, random_state=42
)

# Train the model
history = model.fit(
    X_train, y_train,
    batch_size=32,
    epochs=10,
    validation_data=(X_val, y_val),
    verbose=1  # 0=silent, 1=progress bar, 2=one line per epoch
)

# Access training history
print(f"Training accuracy: {history.history['accuracy']}")
print(f"Validation loss: {history.history['val_loss']}")

# Train with validation split (alternative)
history = model.fit(
    data, one_hot_labels,
    batch_size=32,
    epochs=10,
    validation_split=0.2,  # Use 20% of data for validation
    shuffle=True
)

# Evaluate on test data
test_loss, test_accuracy = model.evaluate(X_val, y_val, verbose=0)
print(f'Test Loss: {test_loss:.4f}')
print(f'Test Accuracy: {test_accuracy:.4f}')

# Evaluate with multiple metrics
test_loss, test_acc, test_precision = model.evaluate(
    X_val, y_val, verbose=0
)

# Batch-wise evaluation
for batch_data, batch_labels in test_dataset:
    loss, acc = model.evaluate(batch_data, batch_labels, verbose=0)

# Make predictions
predictions = model.predict(X_val)  # Returns probabilities
print(f"Prediction shape: {predictions.shape}")  # (samples, classes)

# Get predicted classes
predicted_classes = np.argmax(predictions, axis=1)
print(f"Predicted classes: {predicted_classes[:10]}")

# Get prediction confidence
confidence = np.max(predictions, axis=1)
print(f"Confidence scores: {confidence[:10]}")

# Predict single sample
single_sample = X_val[0:1]  # Keep batch dimension
prediction = model.predict(single_sample, verbose=0)
predicted_class = np.argmax(prediction)

# Batch prediction
batch_predictions = model.predict(X_val[:100], batch_size=32)

    Trained Model
         │
    ┌────┴────────┐
    ↓             ↓
SavedModel     HDF5
(TF native)   (.h5)
    │             │
    ├─→ Better    ├─→ Keras only
    │   for       │   Single file
    │   serving   │   Legacy
    │             │
    └──────┬──────┘
           ↓
    Load & Use
    (Inference/
     Fine-tuning)

# Save entire model (architecture + weights + optimizer state)
model.save('saved_model/my_model')

# Load model
loaded_model = tf.keras.models.load_model('saved_model/my_model')

# Verify loaded model
predictions = loaded_model.predict(X_test[:5])

# SavedModel contains:
# - saved_model.pb (architecture + graph)
# - variables/ (weights)
# - assets/ (additional files)

# Save entire model to HDF5
model.save('my_model.h5')

# Load from HDF5
loaded_model = tf.keras.models.load_model('my_model.h5')

# Save only weights
model.save_weights('weights.h5')

# Load only weights (model architecture must exist)
model.load_weights('weights.h5')

# Save weights in TensorFlow checkpoint format
model.save_weights('./checkpoints/model_checkpoint')

# Creates:
# - model_checkpoint.index
# - model_checkpoint.data-00000-of-00001

# Load weights
model.load_weights('./checkpoints/model_checkpoint')

# Transfer learning: load specific layers
pretrained_model = tf.keras.applications.VGG16(weights='imagenet')
new_model = tf.keras.Sequential([
    pretrained_model,
    Dense(10, activation='softmax')
])

# Save architecture to JSON
model_json = model.to_json()
with open('model_architecture.json', 'w') as json_file:
    json_file.write(model_json)

# Load architecture
with open('model_architecture.json', 'r') as json_file:
    loaded_model_json = json_file.read()
loaded_model = tf.keras.models.model_from_json(loaded_model_json)

# Then load weights separately
loaded_model.load_weights('weights.h5')
loaded_model.compile(optimizer='adam', loss='categorical_crossentropy')

# If model has custom layers/functions
class CustomLayer(tf.keras.layers.Layer):
    pass

# Save with custom objects
model.save('custom_model.h5')

# Load with custom objects
loaded_model = tf.keras.models.load_model(
    'custom_model.h5',
    custom_objects={'CustomLayer': CustomLayer}
)

# Create checkpoint manager
checkpoint_dir = './training_checkpoints'
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")

checkpoint = tf.train.Checkpoint(
    optimizer=optimizer,
    model=model
)

manager = tf.train.CheckpointManager(
    checkpoint, 
    checkpoint_dir, 
    max_to_keep=3  # Keep only 3 latest checkpoints
)

# Save checkpoint during training
for epoch in range(10):
    # ... training code ...
    save_path = manager.save()
    print(f"Saved checkpoint: {save_path}")

# Restore latest checkpoint
checkpoint.restore(manager.latest_checkpoint)
if manager.latest_checkpoint:
    print(f"Restored from {manager.latest_checkpoint}")

    Training Start
         │
         ↓
    on_train_begin()
         │
    ┌────▼────────┐
    │   Epoch     │◄──────────┐
    │   Start     │           │
    └────┬────────┘           │
         ↓                    │
    on_epoch_begin()          │
         │                    │
    ┌────▼────────┐           │
    │   Batch     │◄─────┐    │
    │   Start     │      │    │
    └────┬────────┘      │    │
         ↓               │    │
    on_batch_begin()     │    │
         ↓               │    │
    Forward + Backward   │    │
         ↓               │    │
    on_batch_end()       │    │
         │               │    │
         └───────────────┘    │
         (more batches)       │
         ↓                    │
    on_epoch_end()            │
         │                    │
         ├─→ Check metrics    │
         ├─→ Save checkpoint  │
         ├─→ Adjust LR        │
         │                    │
         └────────────────────┘
         (more epochs or early stop)
         ↓
    on_train_end()

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

# ModelCheckpoint: Save model during training
checkpoint_callback = ModelCheckpoint(
    filepath='./checkpoints/model-{epoch:02d}-{val_loss:.2f}.h5',
    save_best_only=True,           # Only save when val_loss improves
    monitor='val_loss',             # Metric to monitor
    mode='min',                     # 'min' for loss, 'max' for accuracy
    verbose=1,
    save_weights_only=False        # Save entire model
)

# EarlyStopping: Stop training when metric stops improving
early_stopping_callback = EarlyStopping(
    monitor='val_loss',
    patience=5,                     # Stop after 5 epochs without improvement
    restore_best_weights=True,      # Restore weights from best epoch
    verbose=1,
    min_delta=0.001                # Minimum change to qualify as improvement
)

# TensorBoard: Visualize training metrics
tensorboard_callback = TensorBoard(
    log_dir='./logs',
    histogram_freq=1,               # Frequency for weight histograms
    write_graph=True,
    update_freq='epoch',            # Update frequency
    profile_batch='10,20'          # Profile batches 10-20
)

# ReduceLROnPlateau: Reduce learning rate when metric plateaus
reduce_lr_callback = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.5,                     # Reduce LR by half
    patience=3,                     # Wait 3 epochs before reducing
    min_lr=1e-7,                    # Minimum learning rate
    verbose=1
)

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

# LearningRateScheduler: Custom learning rate schedule
def scheduler(epoch, lr):
    if epoch < 10:
        return lr
    else:
        return lr * tf.math.exp(-0.1)

lr_scheduler = LearningRateScheduler(scheduler, verbose=1)

# Use callbacks in training
history = model.fit(
    X_train, y_train,
    epochs=50,
    batch_size=32,
    validation_data=(X_val, y_val),
    callbacks=[
        checkpoint_callback,
        early_stopping_callback,
        tensorboard_callback,
        reduce_lr_callback,
        csv_logger
    ]
)

import time

class CustomCallback(tf.keras.callbacks.Callback):
    def on_train_begin(self, logs=None):
        print("Starting training...")
        self.train_start_time = time.time()

    def on_epoch_begin(self, epoch, logs=None):
        print(f"\nStarting epoch {epoch + 1}")
        self.epoch_start_time = time.time()

    def on_epoch_end(self, epoch, logs=None):
        epoch_time = time.time() - self.epoch_start_time
        print(f"Epoch {epoch + 1} completed in {epoch_time:.2f}s")
        print(f"Loss: {logs['loss']:.4f}, Accuracy: {logs['accuracy']:.4f}")

        # Custom logic: Save model if accuracy > threshold
        if logs['accuracy'] > 0.95:
            print("High accuracy achieved! Saving model...")
            self.model.save(f'high_acc_model_epoch_{epoch + 1}.h5')

    def on_train_batch_end(self, batch, logs=None):
        # Print every 100 batches
        if batch % 100 == 0:
            print(f"Batch {batch}, Loss: {logs['loss']:.4f}")

    def on_train_end(self, logs=None):
        total_time = time.time() - self.train_start_time
        print(f"\nTraining completed in {total_time:.2f}s")

# Use custom callback
model.fit(
    X_train, y_train,
    epochs=10,
    callbacks=[CustomCallback()]
)

# Start TensorBoard server
tensorboard --logdir=./logs --port=6006

# Open in browser: http://localhost:6006

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

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

import tensorflow as tf

class MyCustomLayer(tf.keras.layers.Layer):
    def __init__(self, units=32):
        super(MyCustomLayer, self).__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(shape=(input_shape[-1], self.units),
                                 initializer='random_normal',
                                 trainable=True)
        self.b = self.add_weight(shape=(self.units,),
                                 initializer='zeros',
                                 trainable=True)

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

import tensorflow as tf

def my_custom_loss(y_true, y_pred):
    squared_difference = tf.square(y_true - y_pred)
    return tf.reduce_mean(squared_difference, axis=-1)

import tensorflow as tf

class MyCustomMetric(tf.keras.metrics.Metric):
    def __init__(self, name='my_custom_metric', **kwargs):
        super(MyCustomMetric, self).__init__(name=name, **kwargs)
        self.sum = self.add_weight(name='sum', initializer='zeros')
        self.count = self.add_weight(name='count', initializer='zeros')

    def update_state(self, y_true, y_pred, sample_weight=None):
        values = tf.abs(y_true - y_pred)
        if sample_weight is not None:
            sample_weight = tf.cast(sample_weight, self.dtype)
            values = tf.multiply(values, sample_weight)
        self.sum.assign_add(tf.reduce_sum(values))
        self.count.assign_add(tf.cast(tf.size(y_true), self.dtype))

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

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

    Initialize
    (optimizer, loss, metrics)
         │
         ↓
    ┌────────────┐
    │  Epoch     │◄──────────┐
    └──────┬─────┘           │
           ↓                 │
    ┌────────────┐           │
    │  Get Batch │◄─────┐    │
    └──────┬─────┘      │    │
           ↓            │    │
    ┌────────────────┐  │    │
    │ Forward Pass   │  │    │
    │ (GradientTape) │  │    │
    └────────┬───────┘  │    │
             ↓          │    │
    ┌────────────────┐  │    │
    │ Compute Loss   │  │    │
    └────────┬───────┘  │    │
             ↓          │    │
    ┌────────────────┐  │    │
    │ Compute        │  │    │
    │ Gradients      │  │    │
    └────────┬───────┘  │    │
             ↓          │    │
    ┌────────────────┐  │    │
    │ Apply          │  │    │
    │ Gradients      │  │    │
    └────────┬───────┘  │    │
             ↓          │    │
    ┌────────────────┐  │    │
    │ Update Metrics │  │    │
    └────────┬───────┘  │    │
             │          │    │
             ├──────────┘    │
             │ (more batches)│
             ↓               │
    ┌────────────────┐       │
    │ Log Results    │       │
    └────────┬───────┘       │
             │               │
             └───────────────┘
             (more epochs)

import tensorflow as tf

# Initialize components
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy()
train_acc_metric = tf.keras.metrics.SparseCategoricalAccuracy()
val_acc_metric = tf.keras.metrics.SparseCategoricalAccuracy()

@tf.function
def train_step(images, labels):
    with tf.GradientTape() as tape:
        predictions = model(images, training=True)
        loss = loss_fn(labels, predictions)

    # Compute gradients
    gradients = tape.gradient(loss, model.trainable_variables)

    # Update weights
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

    # Update metrics
    train_acc_metric.update_state(labels, predictions)

    return loss

@tf.function
def val_step(images, labels):
    predictions = model(images, training=False)
    loss = loss_fn(labels, predictions)
    val_acc_metric.update_state(labels, predictions)
    return loss

# Training loop
epochs = 10
for epoch in range(epochs):
    print(f"\nEpoch {epoch + 1}/{epochs}")

    # Training phase
    train_losses = []
    for batch, (images, labels) in enumerate(train_dataset):
        loss = train_step(images, labels)
        train_losses.append(loss.numpy())

        if batch % 100 == 0:
            print(f"Batch {batch}, Loss: {loss.numpy():.4f}")

    # Validation phase
    val_losses = []
    for images, labels in val_dataset:
        val_loss = val_step(images, labels)
        val_losses.append(val_loss.numpy())

    # Print epoch results
    train_acc = train_acc_metric.result()
    val_acc = val_acc_metric.result()

    print(f"Train Loss: {np.mean(train_losses):.4f}, Train Acc: {train_acc:.4f}")
    print(f"Val Loss: {np.mean(val_losses):.4f}, Val Acc: {val_acc:.4f}")

    # Reset metrics
    train_acc_metric.reset_states()
    val_acc_metric.reset_states()

@tf.function
def train_step_with_regularization(images, labels):
    with tf.GradientTape() as tape:
        predictions = model(images, training=True)

        # Main loss
        loss = loss_fn(labels, predictions)

        # Add L2 regularization
        l2_loss = tf.add_n([tf.nn.l2_loss(v) for v in model.trainable_variables 
                           if 'bias' not in v.name])
        total_loss = loss + 0.001 * l2_loss

    gradients = tape.gradient(total_loss, model.trainable_variables)

    # Gradient clipping
    gradients, _ = tf.clip_by_global_norm(gradients, 1.0)

    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    train_acc_metric.update_state(labels, predictions)

    return loss, total_loss

# Training with logging
for epoch in range(epochs):
    for images, labels in train_dataset:
        loss, total_loss = train_step_with_regularization(images, labels)

# Define learning rate schedule
initial_lr = 0.001
decay_steps = 1000
decay_rate = 0.96

lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate=initial_lr,
    decay_steps=decay_steps,
    decay_rate=decay_rate
)

optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

# Or manual learning rate adjustment
for epoch in range(epochs):
    # Adjust learning rate manually
    if epoch > 0 and epoch % 5 == 0:
        new_lr = optimizer.learning_rate * 0.5
        optimizer.learning_rate.assign(new_lr)
        print(f"Learning rate adjusted to: {new_lr.numpy()}")

    for images, labels in train_dataset:
        loss = train_step(images, labels)

    Raw Data
        │
        ↓
    ┌───────────┐
    │  Create   │───→ from_tensor_slices
    │  Dataset  │     from_generator
    └─────┬─────┘     list_files
          ↓
    ┌───────────┐
    │  Shuffle  │───→ Randomize order
    └─────┬─────┘
          ↓
    ┌───────────┐
    │    Map    │───→ Preprocess
    │           │     Augment
    └─────┬─────┘
          ↓
    ┌───────────┐
    │   Cache   │───→ Store in memory/disk
    └─────┬─────┘
          ↓
    ┌───────────┐
    │   Batch   │───→ Create batches
    └─────┬─────┘
          ↓
    ┌───────────┐
    │ Prefetch  │───→ Prepare next batch
    └─────┬─────┘
          ↓
      Training

import tensorflow as tf
import numpy as np

# From NumPy arrays
X = np.random.random((1000, 28, 28, 1))
y = np.random.randint(10, size=(1000,))
dataset = tf.data.Dataset.from_tensor_slices((X, y))

# From tensors
tensor_x = tf.constant([[1, 2], [3, 4]])
tensor_y = tf.constant([0, 1])
dataset = tf.data.Dataset.from_tensor_slices((tensor_x, tensor_y))

# From list of files
file_dataset = tf.data.Dataset.list_files("path/to/data/*.jpg")

# From CSV
dataset = tf.data.experimental.make_csv_dataset(
    "data.csv",
    batch_size=32,
    label_name="target",
    num_epochs=1
)

# From generator
def data_generator():
    for i in range(1000):
        yield (i, i**2)

dataset = tf.data.Dataset.from_generator(
    data_generator,
    output_signature=(
        tf.TensorSpec(shape=(), dtype=tf.int32),
        tf.TensorSpec(shape=(), dtype=tf.int32)
    )
)

# Range dataset
range_dataset = tf.data.Dataset.range(100)

# Create a dataset
dataset = tf.data.Dataset.from_tensor_slices((X, y))

# Shuffle: Randomize order (buffer_size should be >= dataset size for full shuffle)
dataset = dataset.shuffle(buffer_size=1000, seed=42)

# Map: Apply preprocessing function
def preprocess(image, label):
    image = tf.cast(image, tf.float32) / 255.0  # Normalize
    return image, label

dataset = dataset.map(preprocess, num_parallel_calls=tf.data.AUTOTUNE)

# Filter: Keep only certain elements
dataset = dataset.filter(lambda x, y: y < 5)  # Keep only classes 0-4

# Batch: Create batches
dataset = dataset.batch(32, drop_remainder=False)

# Repeat: Repeat dataset (for multiple epochs)
dataset = dataset.repeat(count=10)  # Repeat 10 times

# Cache: Store dataset in memory or disk
dataset = dataset.cache()  # In-memory
# dataset = dataset.cache("/path/to/cache")  # On disk

# Prefetch: Prepare next batches while training current batch
dataset = dataset.prefetch(buffer_size=tf.data.AUTOTUNE)

# Take: Get first N elements
small_dataset = dataset.take(100)

# Skip: Skip first N elements
remaining_dataset = dataset.skip(100)

def create_dataset(X, y, batch_size=32, shuffle=True, augment=False):
    """Create an optimized tf.data pipeline"""
    dataset = tf.data.Dataset.from_tensor_slices((X, y))

    if shuffle:
        dataset = dataset.shuffle(buffer_size=len(X))

    # Preprocessing
    def preprocess(image, label):
        image = tf.cast(image, tf.float32) / 255.0
        if augment:
            # Data augmentation
            image = tf.image.random_flip_left_right(image)
            image = tf.image.random_brightness(image, max_delta=0.1)
        return image, label

    dataset = dataset.map(preprocess, num_parallel_calls=tf.data.AUTOTUNE)
    dataset = dataset.cache()  # Cache after preprocessing
    dataset = dataset.batch(batch_size)
    dataset = dataset.prefetch(tf.data.AUTOTUNE)

    return dataset

# Usage
train_dataset = create_dataset(X_train, y_train, batch_size=64, augment=True)
val_dataset = create_dataset(X_val, y_val, batch_size=64, shuffle=False)

# Zip: Combine multiple datasets
dataset1 = tf.data.Dataset.range(5)
dataset2 = tf.data.Dataset.range(5, 10)
zipped = tf.data.Dataset.zip((dataset1, dataset2))

# FlatMap: Map and flatten
dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3])
dataset = dataset.flat_map(
    lambda x: tf.data.Dataset.from_tensor_slices([x, x*2, x*3])
)

# Interleave: Parallel processing of multiple files
files = tf.data.Dataset.list_files("data/*.csv")
dataset = files.interleave(
    lambda x: tf.data.TextLineDataset(x),
    cycle_length=4,  # Process 4 files in parallel
    num_parallel_calls=tf.data.AUTOTUNE
)

# Window: Create sliding windows
dataset = tf.data.Dataset.range(10)
dataset = dataset.window(size=3, shift=1, drop_remainder=True)
dataset = dataset.flat_map(lambda x: x.batch(3))

raw_dataset = tf.data.TFRecordDataset("my_data.tfrecord")

# Define a feature description
feature_description = {
    'feature0': tf.io.FixedLenFeature([], tf.int64),
    'feature1': tf.io.FixedLenFeature([], tf.string),
    'feature2': tf.io.FixedLenFeature([10], tf.float32),
}

def _parse_function(example_proto):
  # Parse the input tf.train.Example proto using the feature description.
  return tf.io.parse_single_example(example_proto, feature_description)

parsed_dataset = raw_dataset.map(_parse_function)

    Distribution Strategies
            │
    ┌───────┴───────┬─────────────┬──────────────┐
    ↓               ↓             ↓              ↓
Mirrored      MultiWorker    Parameter      TPU
Strategy      Mirrored       Server         Strategy
    │         Strategy       Strategy
    │             │             │              │
Single        Multiple      Multiple       Cloud
Machine       Machines      Machines       TPUs
Multiple      Multiple      PS + Workers
GPUs          GPUs

import tensorflow as tf

# Create strategy
strategy = tf.distribute.MirroredStrategy()

print(f"Number of devices: {strategy.num_replicas_in_sync}")

# Build and compile model inside strategy scope
with strategy.scope():
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10, activation='softmax')
    ])

    model.compile(
        optimizer=tf.keras.optimizers.Adam(0.001),
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )

# Prepare dataset
BATCH_SIZE_PER_REPLICA = 64
GLOBAL_BATCH_SIZE = BATCH_SIZE_PER_REPLICA * strategy.num_replicas_in_sync

train_dataset = tf.data.Dataset.from_tensor_slices((X_train, y_train))
train_dataset = train_dataset.shuffle(10000).batch(GLOBAL_BATCH_SIZE)

# Train (distributed automatically)
model.fit(train_dataset, epochs=10)

with strategy.scope():
    model = create_model()
    optimizer = tf.keras.optimizers.Adam()
    loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(
        reduction=tf.keras.losses.Reduction.NONE
    )

def compute_loss(labels, predictions):
    per_example_loss = loss_fn(labels, predictions)
    return tf.nn.compute_average_loss(per_example_loss, 
                                     global_batch_size=GLOBAL_BATCH_SIZE)

@tf.function
def train_step(inputs):
    images, labels = inputs

    with tf.GradientTape() as tape:
        predictions = model(images, training=True)
        loss = compute_loss(labels, predictions)

    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss

@tf.function
def distributed_train_step(dataset_inputs):
    per_replica_losses = strategy.run(train_step, args=(dataset_inputs,))
    return strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_losses, axis=None)

# Training loop
for epoch in range(10):
    total_loss = 0.0
    num_batches = 0

    for batch in train_dataset:
        loss = distributed_train_step(batch)
        total_loss += loss
        num_batches += 1

    print(f"Epoch {epoch + 1}, Loss: {total_loss / num_batches:.4f}")

import os, json

os.environ['TF_CONFIG'] = json.dumps({
    'cluster': {
        'worker': ["localhost:12345", "localhost:23456"]
    },
    'task': {'type': 'worker', 'index': 0}
})

strategy = tf.distribute.MultiWorkerMirroredStrategy()

with strategy.scope():
    # ... build and compile model ...

import os, json
os.environ['TF_CONFIG'] = json.dumps({
    'cluster': {
        'worker': ["localhost:12345", "localhost:23456"],
        'ps': ["localhost:34567"]
    },
    'task': {'type': 'worker', 'index': 0}
})

strategy = tf.distribute.experimental.ParameterServerStrategy()

with strategy.scope():
    # ... build and compile model ...

resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')
tf.config.experimental_connect_to_cluster(resolver)
tf.tpu.experimental.initialize_tpu_system(resolver)
strategy = tf.distribute.TPUStrategy(resolver)

with strategy.scope():
    # ... build and compile model ...

    Original Image
         │
    ┌────┴────┬────────┬────────┬─────────┐
    ↓         ↓        ↓        ↓         ↓
  Flip    Rotation  Zoom   Brightness  Contrast
    │         │        │        │         │
    └────┬────┴────────┴────────┴─────────┘
         ↓
   Augmented Images
   (More training data)

# Create augmentation layers (applied during training)
data_augmentation = tf.keras.Sequential([
    tf.keras.layers.RandomFlip("horizontal"),
    tf.keras.layers.RandomRotation(0.2),  # ±20% = ±72 degrees
    tf.keras.layers.RandomZoom(0.2),      # ±20% zoom
    tf.keras.layers.RandomTranslation(0.1, 0.1),  # 10% shift
    tf.keras.layers.RandomContrast(0.2),
])

# Build model with augmentation
model = tf.keras.Sequential([
    data_augmentation,  # Only active during training
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Conv2D(64, 3, activation='relu'),
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(10, activation='softmax')
])

def augment_image(image, label):
    """Custom augmentation function"""
    # Random flip
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_flip_up_down(image)

    # Random brightness
    image = tf.image.random_brightness(image, max_delta=0.2)

    # Random contrast
    image = tf.image.random_contrast(image, lower=0.8, upper=1.2)

    # Random saturation (for color images)
    image = tf.image.random_saturation(image, lower=0.8, upper=1.2)

    # Random hue (for color images)
    image = tf.image.random_hue(image, max_delta=0.1)

    # Random crop
    image = tf.image.random_crop(image, size=[224, 224, 3])

    # Clip values to [0, 1]
    image = tf.clip_by_value(image, 0.0, 1.0)

    return image, label

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

def mixup(image1, label1, image2, label2, alpha=0.2):
    """MixUp augmentation"""
    # Sample mixing coefficient
    lambda_val = tf.random.uniform([], 0, 1)
    lambda_val = tf.maximum(lambda_val, 1 - lambda_val)

    # Mix images
    mixed_image = lambda_val * image1 + (1 - lambda_val) * image2

    # Mix labels
    mixed_label = lambda_val * label1 + (1 - lambda_val) * label2

    return mixed_image, mixed_label

def cutmix(image1, label1, image2, label2, alpha=1.0):
    """CutMix augmentation"""
    # Sample cutting area
    lambda_val = tf.random.uniform([], 0, 1)

    # Get image size
    h, w = tf.shape(image1)[0], tf.shape(image1)[1]

    # Calculate cut size
    cut_h = tf.cast(tf.cast(h, tf.float32) * tf.sqrt(1 - lambda_val), tf.int32)
    cut_w = tf.cast(tf.cast(w, tf.float32) * tf.sqrt(1 - lambda_val), tf.int32)

    # Random position
    cx = tf.random.uniform([], 0, w, dtype=tf.int32)
    cy = tf.random.uniform([], 0, h, dtype=tf.int32)

    # Calculate boundaries
    x1 = tf.clip_by_value(cx - cut_w // 2, 0, w)
    y1 = tf.clip_by_value(cy - cut_h // 2, 0, h)
    x2 = tf.clip_by_value(cx + cut_w // 2, 0, w)
    y2 = tf.clip_by_value(cy + cut_h // 2, 0, h)

    # Create mask
    mask = tf.ones([h, w, 3])
    mask = tf.tensor_scatter_nd_update(
        mask,
        [[y1, x1], [y2, x2]],
        [tf.zeros([y2-y1, x2-x1, 3])]
    )

    # Apply cutmix
    mixed_image = image1 * mask + image2 * (1 - mask)

    # Mix labels based on area
    lambda_val = 1 - ((x2 - x1) * (y2 - y1)) / (h * w)
    mixed_label = lambda_val * label1 + (1 - lambda_val) * label2

    return mixed_image, mixed_label

# Normalization
def normalize_image(image):
    """Normalize image to [0, 1] or [-1, 1]"""
    # To [0, 1]
    image = tf.cast(image, tf.float32) / 255.0

    # Or to [-1, 1]
    # image = (tf.cast(image, tf.float32) - 127.5) / 127.5

    return image

# Standardization (ImageNet mean/std)
def standardize_image(image):
    """Standardize using ImageNet statistics"""
    mean = tf.constant([0.485, 0.456, 0.406])
    std = tf.constant([0.229, 0.224, 0.225])

    image = tf.cast(image, tf.float32) / 255.0
    image = (image - mean) / std

    return image

# Resize and crop
def resize_and_crop(image, size=224):
    """Resize and center crop"""
    # Resize to slightly larger
    image = tf.image.resize(image, [size + 32, size + 32])

    # Center crop
    image = tf.image.resize_with_crop_or_pad(image, size, size)

    return image

# Combined preprocessing
def preprocess_pipeline(image, label, training=False):
    """Complete preprocessing pipeline"""
    # Decode if needed
    if image.dtype == tf.string:
        image = tf.image.decode_jpeg(image, channels=3)

    # Resize
    image = tf.image.resize(image, [224, 224])

    if training:
        # Augmentation for training
        image = tf.image.random_flip_left_right(image)
        image = tf.image.random_brightness(image, max_delta=0.1)
        image = tf.image.random_contrast(image, lower=0.9, upper=1.1)

    # Normalize
    image = tf.cast(image, tf.float32) / 255.0

    return image, label

import tensorflow_hub as hub

# Method 1: As a layer
model = tf.keras.Sequential([
    hub.KerasLayer(
        "https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4",
        trainable=False,  # Freeze weights
        input_shape=(224, 224, 3)
    ),
    tf.keras.layers.Dense(10, activation='softmax')
])

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

# Method 2: Load as a model
embedding_model = hub.load("https://tfhub.dev/google/universal-sentence-encoder/4")

# Use for embeddings
sentences = ["Hello world", "Machine learning is great"]
embeddings = embedding_model(sentences)

# Method 3: KerasLayer with trainable=True for fine-tuning
feature_extractor = hub.KerasLayer(
    "https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4",
    trainable=True,  # Fine-tune
    input_shape=(224, 224, 3)
)

model = tf.keras.Sequential([
    feature_extractor,
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(10, activation='softmax')
])

    Trained Model
         │
         ↓
    ┌──────────────┐
    │   Convert    │───→ TFLite Converter
    │   to .tflite│
    └──────┬───────┘
           ↓
    ┌──────────────┐
    │  Optimize    │───→ Quantization
    │  (Optional)  │     Pruning
    └──────┬───────┘
           ↓
    .tflite Model
    (Smaller, Faster)
           │
           ↓
    ┌──────────────┐
    │   Deploy to  │───→ Mobile (Android/iOS)
    │   Device     │     IoT (Raspberry Pi)
    └──────────────┘     Microcontrollers

# Convert from Keras model
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

# Save to file
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

# Convert from SavedModel
converter = tf.lite.TFLiteConverter.from_saved_model('saved_model/my_model')
tflite_model = converter.convert()

# Convert from concrete function
converter = tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])
tflite_model = converter.convert()

# Dynamic range quantization (weights only)
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()

# Full integer quantization (weights + activations)
def representative_dataset():
    for i in range(100):
        # Use representative data samples
        yield [np.random.random((1, 224, 224, 3)).astype(np.float32)]

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8
tflite_quant_model = converter.convert()

# Float16 quantization
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_float16_model = converter.convert()