import tensorflow as tf
from tensorflow.keras import layers

# ===========================
# Conv2D — SETIAP parameter dijelaskan
# ===========================
conv = layers.Conv2D(
    filters=32,           # Jumlah filter output (= output channels)
                          # Lebih banyak filters = lebih banyak fitur
                          # Pattern: 32 → 64 → 128 → 256

    kernel_size=(3, 3),   # Ukuran filter: 3×3 (paling umum)
                          # Alternatif: (1,1) untuk channel mixing
                          #             (5,5) untuk receptive field besar
                          #             (7,7) hanya di layer pertama

    strides=(1, 1),       # Geser 1 pixel per step (default)
                          # strides=(2,2) → downsample 2× (replacement MaxPool)

    padding='same',        # 'same': output size = input size (add padding)
                          # 'valid': no padding → output shrinks
                          # Formula: output = (input - kernel + 2*pad) / stride + 1

    activation='relu',     # Activation function (or None + separate layer)

    use_bias=True,         # Add bias per filter (default True)

    kernel_initializer='glorot_uniform',  # He init better for ReLU:
    # kernel_initializer='he_normal',     # recommended with ReLU

    input_shape=(32, 32, 3)  # H, W, C — ONLY in first layer!
)

# ===========================
# Output Shape Calculation
# ===========================
# Input:  (batch, 32, 32, 3)    → 32×32 RGB image
# Conv2D(32, (3,3), padding='same', strides=(1,1))
# Output: (batch, 32, 32, 32)   → 32 feature maps, same spatial size

# Conv2D(64, (3,3), padding='valid', strides=(1,1))
# Output: (batch, 30, 30, 64)   → shrinks by (kernel-1) = 2 per side

# Conv2D(64, (3,3), padding='same', strides=(2,2))
# Output: (batch, 16, 16, 64)   → halved spatial size (like MaxPool!)

# ===========================
# Parameter Count — WHY CNN IS EFFICIENT
# ===========================
# Dense layer: 32×32×3 → 128 neurons
# Params = 3072 × 128 + 128 = 393,344 ← HUGE!

# Conv2D: 32 filters, 3×3, 3 input channels
# Params = (3 × 3 × 3 + 1) × 32 = 896 ← TINY!

# That's 438× fewer parameters!
# Secret: WEIGHT SHARING — same filter applied everywhere

model_demo = tf.keras.Sequential([
    layers.Conv2D(32, (3,3), padding='same', input_shape=(32,32,3)),
    layers.Conv2D(64, (3,3), padding='same'),
    layers.Conv2D(128, (3,3), padding='same'),
])
model_demo.summary()
# Layer 1: (3×3×3+1)×32   =     896 params
# Layer 2: (3×3×32+1)×64  =  18,496 params
# Layer 3: (3×3×64+1)×128 =  73,856 params
# Total: 93,248 — compare Dense equivalent: MILLIONS

from tensorflow.keras import layers
import tensorflow as tf

# ===========================
# 1. MaxPooling2D — classic downsampling
# ===========================
pool = layers.MaxPooling2D(
    pool_size=(2, 2),     # 2×2 window
    strides=(2, 2),       # non-overlapping (default = pool_size)
    padding='valid'        # no padding (default)
)
# Input:  (batch, 32, 32, 64)
# Output: (batch, 16, 16, 64)  → spatial halved, channels same
# Params: 0 (no learnable parameters!)
# Takes MAX value from each 2×2 window → keeps strongest activation

# Contoh visual:
# [[1, 3],    MaxPool 2×2
#  [2, 4]] → output = 4 (maximum)

# ===========================
# 2. AveragePooling2D — alternative
# ===========================
avg_pool = layers.AveragePooling2D((2, 2))
# Same as MaxPool but takes AVERAGE instead of MAX
# Less commonly used — MaxPool usually works better

# ===========================
# 3. GlobalAveragePooling2D — MODERN replacement for Flatten
# ===========================
gap = layers.GlobalAveragePooling2D()
# Input:  (batch, 8, 8, 128)  → 128 feature maps, each 8×8
# Output: (batch, 128)         → average each map to ONE number
# Params: 0

# Compare with Flatten + Dense:
# Flatten: (8,8,128) → (8192,)  → Dense(256): 8192×256 = 2,097,408 params!
# GAP:     (8,8,128) → (128,)   → Dense(256): 128×256  = 32,896 params!
# That's 63× fewer parameters → less overfitting, faster training!

# ===========================
# 4. Modern pattern: Strided Conv instead of MaxPool
# ===========================
# Instead of: Conv → MaxPool
# Modern:     Conv(strides=2)  ← learnable downsampling!
strided = layers.Conv2D(64, (3,3), strides=(2,2), padding='same')
# Output halved, but the downsampling is LEARNED (has params)
# Used in ResNet, EfficientNet, modern architectures

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

# ===========================
# 1. LOAD & PREPROCESS
# ===========================
(X_train, y_train), (X_test, y_test) = keras.datasets.cifar10.load_data()
X_train = X_train.astype('float32') / 255.0  # normalize [0,1]
X_test = X_test.astype('float32') / 255.0
print(f"Train: {X_train.shape}, Test: {X_test.shape}")
# Train: (50000, 32, 32, 3), Test: (10000, 32, 32, 3)

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
               'dog', 'frog', 'horse', 'ship', 'truck']

# ===========================
# 2. BUILD CNN — 3 Conv Blocks
# Pattern: Conv → BN → ReLU → Conv → BN → ReLU → MaxPool → Dropout
# ===========================
model = keras.Sequential([
    # ── Block 1: 32 filters ──
    layers.Conv2D(32, (3,3), padding='same', kernel_initializer='he_normal',
                  input_shape=(32,32,3)),
    layers.BatchNormalization(),
    layers.Activation('relu'),
    layers.Conv2D(32, (3,3), padding='same', kernel_initializer='he_normal'),
    layers.BatchNormalization(),
    layers.Activation('relu'),
    layers.MaxPooling2D((2,2)),      # 32×32 → 16×16
    layers.Dropout(0.25),

    # ── Block 2: 64 filters ──
    layers.Conv2D(64, (3,3), padding='same', kernel_initializer='he_normal'),
    layers.BatchNormalization(),
    layers.Activation('relu'),
    layers.Conv2D(64, (3,3), padding='same', kernel_initializer='he_normal'),
    layers.BatchNormalization(),
    layers.Activation('relu'),
    layers.MaxPooling2D((2,2)),      # 16×16 → 8×8
    layers.Dropout(0.25),

    # ── Block 3: 128 filters ──
    layers.Conv2D(128, (3,3), padding='same', kernel_initializer='he_normal'),
    layers.BatchNormalization(),
    layers.Activation('relu'),
    layers.Conv2D(128, (3,3), padding='same', kernel_initializer='he_normal'),
    layers.BatchNormalization(),
    layers.Activation('relu'),
    layers.MaxPooling2D((2,2)),      # 8×8 → 4×4
    layers.Dropout(0.25),

    # ── Classifier Head ──
    layers.GlobalAveragePooling2D(), # (4,4,128) → (128)
    layers.Dense(256, activation='relu', kernel_initializer='he_normal'),
    layers.BatchNormalization(),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

model.summary()
# Total params: ~430k (bandingkan: VGG16 = 138M, ResNet50 = 25.6M)

# ===========================
# 3. COMPILE
# ===========================
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# ===========================
# 4. TRAIN with callbacks
# ===========================
callbacks = [
    keras.callbacks.EarlyStopping(
        monitor='val_loss', patience=10, restore_best_weights=True),
    keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss', factor=0.5, patience=5, min_lr=1e-6),
]

history = model.fit(
    X_train, y_train,
    epochs=100,              # EarlyStopping will stop early
    batch_size=64,
    validation_split=0.1,   # 10% for validation
    callbacks=callbacks,
    verbose=1
)

# ===========================
# 5. EVALUATE
# ===========================
test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)
print(f"\n🎯 Test Accuracy: {test_acc:.1%}")
# 🎯 Test Accuracy: 88.3%
# With augmentation (Section 5): ~92%
# With transfer learning (Section 6): ~95%+

# ===========================
# 6. Per-class accuracy
# ===========================
y_pred = np.argmax(model.predict(X_test), axis=1)
for i, name in enumerate(class_names):
    mask = y_test.flatten() == i
    acc = (y_pred[mask] == i).mean()
    print(f"  {name:12s}: {acc:.1%}")
# airplane    : 90.2%
# cat         : 76.1%  ← hardest! (looks like dog/deer)
# truck       : 93.4%  ← easiest

import tensorflow as tf
from tensorflow.keras import layers

# ===========================
# METODE 1: Keras Preprocessing Layers (RECOMMENDED)
# Augmentation INSIDE the model — portable & clean!
# ===========================
data_augmentation = tf.keras.Sequential([
    layers.RandomFlip("horizontal"),            # flip kiri-kanan (50% chance)
    # layers.RandomFlip("horizontal_and_vertical"),  # juga atas-bawah
    layers.RandomRotation(0.1),                # rotate ±10% (±36°)
    layers.RandomZoom(0.1),                    # zoom ±10%
    layers.RandomTranslation(0.1, 0.1),        # shift ±10% H and W
    layers.RandomContrast(0.1),                # contrast ±10%
    layers.RandomBrightness(0.1),              # brightness ±10%
    # layers.RandomCrop(28, 28),                # random crop (if larger)
], name="augmentation")

# Integrate into model (BEST approach)
model_with_aug = tf.keras.Sequential([
    data_augmentation,                          # ← augmentation first!
    layers.Conv2D(32, 3, padding='same', activation='relu',
                  input_shape=(32,32,3)),
    layers.BatchNormalization(),
    layers.MaxPooling2D(),
    # ... rest of CNN
])
# IMPORTANT: Augmentation ONLY runs during training=True!
# During model.predict() and model.evaluate(): skipped automatically.

# ===========================
# METODE 2: tf.image (in tf.data pipeline)
# More control, custom augmentations
# ===========================
def augment_image(image, label):
    # Random flip
    image = tf.image.random_flip_left_right(image)

    # Random brightness & contrast
    image = tf.image.random_brightness(image, max_delta=0.1)
    image = tf.image.random_contrast(image, lower=0.9, upper=1.1)
    image = tf.image.random_saturation(image, lower=0.9, upper=1.1)
    image = tf.image.random_hue(image, max_delta=0.05)

    # Random crop (resize slightly larger, then crop back)
    image = tf.image.resize(image, [36, 36])
    image = tf.image.random_crop(image, size=[32, 32, 3])

    # Clip to valid range
    image = tf.clip_by_value(image, 0.0, 1.0)
    return image, label

# Apply in tf.data pipeline:
# train_ds = (dataset
#     .map(augment_image, num_parallel_calls=AUTOTUNE)
#     .batch(64).prefetch(AUTOTUNE))

# ===========================
# METODE 3: CutMix & MixUp (advanced)
# State-of-the-art augmentation techniques
# ===========================
def cutmix(images, labels, alpha=1.0):
    """CutMix: cut rectangle from one image, paste into another"""
    batch_size = tf.shape(images)[0]
    indices = tf.random.shuffle(tf.range(batch_size))
    shuffled_images = tf.gather(images, indices)
    shuffled_labels = tf.gather(labels, indices)

    lam = tf.random.uniform([], 0, alpha)
    # ... (calculate random box, blend images and labels)
    return mixed_images, mixed_labels

# CutMix + MixUp can add another 1-2% accuracy boost!

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

# ===========================
# 1. Load pre-trained backbone (TANPA classifier head)
# ===========================
base_model = keras.applications.MobileNetV2(
    input_shape=(96, 96, 3),   # MobileNet needs >= 32×32
    include_top=False,          # REMOVE ImageNet classifier (1000 classes)
    weights='imagenet'           # load pre-trained weights!
)

# FREEZE all layers — don't update weights!
base_model.trainable = False

print(f"Backbone: {base_model.name}")
print(f"Params: {base_model.count_params():,} (ALL frozen)")
print(f"Output shape: {base_model.output_shape}")
# Backbone: mobilenetv2_1.00_96
# Params: 2,257,984 (ALL frozen)
# Output shape: (None, 3, 3, 1280) — feature maps

# ===========================
# 2. Add preprocessing + custom classifier
# ===========================
model = keras.Sequential([
    # Preprocessing
    layers.Resizing(96, 96),                     # resize 32→96
    layers.Rescaling(1./127.5, offset=-1),       # normalize to [-1, 1]
    # Each model has its own preprocessing!
    # MobileNet: [-1, 1]
    # EfficientNet: [0, 255] (built-in preprocessing)
    # ResNet: caffe-style (BGR, mean subtraction)

    # Frozen feature extractor
    base_model,

    # New classifier head (THIS is what we train)
    layers.GlobalAveragePooling2D(),          # (3,3,1280) → (1280)
    layers.Dropout(0.3),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')     # 10 CIFAR classes
])

# ===========================
# 3. Compile with HIGHER learning rate
# (backbone frozen → only head learns → LR can be aggressive)
# ===========================
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# ===========================
# 4. Train Phase 1
# ===========================
history_p1 = model.fit(
    X_train, y_train,
    epochs=10,
    batch_size=64,
    validation_split=0.1
)
# ≈90% accuracy in just 10 epochs! Backbone features are powerful.

print(f"Phase 1 Val Accuracy: {history_p1.history['val_accuracy'][-1]:.1%}")

# ===========================
# Phase 2: Unfreeze top layers of backbone
# ===========================

# Unfreeze backbone
base_model.trainable = True

# But freeze all EXCEPT the last 30 layers
print(f"Total layers: {len(base_model.layers)}")  # ~155 layers
for layer in base_model.layers[:-30]:
    layer.trainable = False

# Count trainable vs frozen
trainable = sum(1 for l in base_model.layers if l.trainable)
frozen = sum(1 for l in base_model.layers if not l.trainable)
print(f"Trainable: {trainable}, Frozen: {frozen}")

# CRITICAL: Recompile with MUCH LOWER learning rate!
# If LR is too high → destroys pre-trained weights
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-5),  # 100× lower!
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Train Phase 2
history_p2 = model.fit(
    X_train, y_train,
    epochs=20,
    batch_size=64,
    validation_split=0.1,
    callbacks=[
        keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
        keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=3, min_lr=1e-7)
    ]
)
# ≈95%+ accuracy! Fine-tuning adapts backbone features to your domain.

# ===========================
# Alternative: Gradual Unfreezing (even better for small datasets)
# ===========================
# Step 1: Train head (Phase 1) — 10 epochs, LR=1e-3
# Step 2: Unfreeze last 10 layers — 5 epochs, LR=1e-5
# Step 3: Unfreeze last 30 layers — 5 epochs, LR=5e-6
# Step 4: Unfreeze all — 5 epochs, LR=1e-6
# This gives the model time to adapt gradually, less risk of forgetting.

import tensorflow as tf

# ===========================
# Folder Structure (PENTING!):
# data/
#   train/
#     cats/       ← folder name = class label
#       cat001.jpg
#       cat002.jpg
#     dogs/
#       dog001.jpg
#     birds/
#       bird001.jpg
#   test/
#     cats/
#     dogs/
#     birds/
# ===========================

# Load with automatic train/val split
train_ds = tf.keras.utils.image_dataset_from_directory(
    "data/train",
    image_size=(224, 224),     # auto-resize ALL images to this
    batch_size=32,
    label_mode='int',           # integer labels: 0=birds, 1=cats, 2=dogs
    # label_mode='categorical'  # one-hot: [1,0,0], [0,1,0], [0,0,1]
    shuffle=True,
    seed=42,
    validation_split=0.2,       # 80% train, 20% val
    subset='training'
)

val_ds = tf.keras.utils.image_dataset_from_directory(
    "data/train",
    image_size=(224, 224),
    batch_size=32,
    label_mode='int',
    seed=42,
    validation_split=0.2,
    subset='validation'
)

print(f"Classes: {train_ds.class_names}")  # ['birds', 'cats', 'dogs']
print(f"Num classes: {len(train_ds.class_names)}")

# ===========================
# Optimize pipeline (CRITICAL for performance!)
# See Page 4 for deep dive on tf.data
# ===========================
AUTOTUNE = tf.data.AUTOTUNE

train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
# cache() → store in RAM after first epoch
# prefetch() → prepare next batch while GPU trains current

# Now use exactly like built-in dataset:
# model.fit(train_ds, validation_data=val_ds, epochs=20)

# ===========================
# Handle imbalanced classes
# ===========================
import numpy as np
# Count per class
# cats: 5000, dogs: 5000, birds: 500 ← imbalanced!
class_weights = {0: 1.0, 1: 1.0, 2: 10.0}  # upweight rare class
# model.fit(train_ds, class_weight=class_weights)

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# ===========================
# 1. Extract Feature Maps
# ===========================
# Build a model that outputs intermediate layer activations
conv_outputs = [l.output for l in model.layers if 'conv2d' in l.name]
feature_model = tf.keras.Model(inputs=model.input, outputs=conv_outputs)

# Pass one image through
img = X_test[0:1]  # shape: (1, 32, 32, 3)
all_features = feature_model.predict(img)

# Visualize feature maps from each conv layer
for layer_idx, features in enumerate(all_features[:3]):
    fig, axes = plt.subplots(4, 8, figsize=(16, 8))
    for i, ax in enumerate(axes.flat):
        if i < features.shape[-1]:
            ax.imshow(features[0, :, :, i], cmap='viridis')
        ax.axis('off')
    plt.suptitle(f'Feature Maps — Conv Layer {layer_idx+1}')
    plt.tight_layout()
    plt.show()

# ===========================
# 2. Visualize Learned Filters
# ===========================
filters, biases = model.layers[0].get_weights()
print(f"Filter shape: {filters.shape}")  # (3, 3, 3, 32)

# Normalize filters for visualization
f_min, f_max = filters.min(), filters.max()
filters_norm = (filters - f_min) / (f_max - f_min)

fig, axes = plt.subplots(4, 8, figsize=(12, 6))
for i, ax in enumerate(axes.flat):
    ax.imshow(filters_norm[:, :, :, i])  # 3×3×3 RGB filter
    ax.axis('off')
plt.suptitle('Learned 3×3 Filters (Conv Layer 1)')
plt.show()

# ===========================
# 3. Grad-CAM — where is the model looking?
# ===========================
def grad_cam(model, image, class_idx, last_conv_layer_name):
    """Generate Grad-CAM heatmap"""
    grad_model = tf.keras.Model(
        model.inputs,
        [model.get_layer(last_conv_layer_name).output, model.output]
    )

    with tf.GradientTape() as tape:
        conv_output, predictions = grad_model(image)
        loss = predictions[:, class_idx]

    grads = tape.gradient(loss, conv_output)
    weights = tf.reduce_mean(grads, axis=(1, 2))  # global avg pool gradients
    cam = tf.reduce_sum(weights[:, tf.newaxis, tf.newaxis, :] * conv_output, axis=-1)
    cam = tf.nn.relu(cam)  # only positive contributions
    cam = cam / (tf.reduce_max(cam) + 1e-8)  # normalize
    return cam.numpy()[0]

# Usage:
# heatmap = grad_cam(model, img, class_idx=3, last_conv_layer_name='conv2d_5')
# plt.imshow(img[0]); plt.imshow(heatmap, alpha=0.4, cmap='jet')
# → Shows WHERE the model focuses to make its prediction!

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

# ═══════════════════════════════════════
# 🏆 PRODUCTION IMAGE CLASSIFIER TEMPLATE
# Ganti folder & NUM_CLASSES → done!
# ═══════════════════════════════════════

# 1. CONFIG
IMG_SIZE = (224, 224)
BATCH_SIZE = 32

# 2. LOAD DATA
train_ds = keras.utils.image_dataset_from_directory(
    "data/train", image_size=IMG_SIZE, batch_size=BATCH_SIZE,
    validation_split=0.2, subset="training", seed=42)
val_ds = keras.utils.image_dataset_from_directory(
    "data/train", image_size=IMG_SIZE, batch_size=BATCH_SIZE,
    validation_split=0.2, subset="validation", seed=42)

NUM_CLASSES = len(train_ds.class_names)
print(f"🏷 Classes: {train_ds.class_names} ({NUM_CLASSES})")

# 3. OPTIMIZE PIPELINE
AUTOTUNE = tf.data.AUTOTUNE
train_ds = train_ds.cache().prefetch(AUTOTUNE)
val_ds = val_ds.cache().prefetch(AUTOTUNE)

# 4. AUGMENTATION
augmentation = keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.15),
    layers.RandomZoom(0.1),
    layers.RandomContrast(0.1),
])

# 5. MODEL: EfficientNetB0 backbone
base = keras.applications.EfficientNetB0(
    input_shape=(*IMG_SIZE, 3), include_top=False, weights="imagenet")
base.trainable = False

model = keras.Sequential([
    augmentation,
    layers.Rescaling(1./255),
    base,
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.3),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(NUM_CLASSES, activation='softmax')
])

# 6. PHASE 1: Train head
model.compile(
    optimizer=keras.optimizers.Adam(1e-3),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"])

model.fit(train_ds, validation_data=val_ds, epochs=15,
          callbacks=[keras.callbacks.EarlyStopping(patience=5,
                     restore_best_weights=True)])

# 7. PHASE 2: Fine-tune
base.trainable = True
for layer in base.layers[:-20]:
    layer.trainable = False

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

model.fit(train_ds, validation_data=val_ds, epochs=10,
          callbacks=[
              keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True),
              keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=2)])

# 8. SAVE
model.save("production_classifier.keras")
print("🏆 Production classifier ready! Typically 95%+ accuracy.")