CNN External

"""
Font Classification using CNN - Detailed Parameter Explanations
==============================================================

This script implements a Convolutional Neural Network (CNN) to classify
alphabetic characters (A-Z) from font images with comprehensive parameter explanations.
"""

# =============================================================================
# 1. IMPORT REQUIRED LIBRARIES
# =============================================================================

import tensorflow as tf
import numpy as np
from tensorflow import keras
from keras import Sequential
from keras.layers import Conv2D, MaxPooling2D, Dense, Dropout, Flatten
from keras.preprocessing import image

# Library Explanations:
# - tensorflow: Main deep learning framework
# - numpy: For numerical operations and array manipulations
# - keras: High-level neural network API (part of TensorFlow)
# - Sequential: Model type that allows stacking layers linearly
# - Conv2D: 2D convolution layer for feature extraction
# - MaxPooling2D: Pooling layer for dimension reduction
# - Dense: Fully connected layer for classification
# - Dropout: Regularization layer to prevent overfitting
# - Flatten: Converts 2D feature maps to 1D vector
# - image: Utilities for image loading and preprocessing

# =============================================================================
# 2. LOAD AND PREPARE DATASET
# =============================================================================

train_ds, val_ds = keras.utils.image_dataset_from_directory(
    "E:/Maroon/College/S9/DL/Fonts",  # directory: Path to dataset folder
                                       # PURPOSE: Location of image dataset with subdirectories as classes
                                       # WHEN TO CHANGE: Update path to your actual dataset location
                                       # STRUCTURE: Each subdirectory (A/, B/, C/, etc.) becomes a class

    color_mode="grayscale",           # color_mode: Image color format
                                      # PURPOSE: Determines number of color channels
                                      # OPTIONS: "grayscale" (1 channel), "rgb" (3 channels), "rgba" (4 channels)
                                      # WHEN TO CHANGE: Use "rgb" for colored images, "grayscale" for B&W

    subset="both",                    # subset: Which data splits to return
                                      # PURPOSE: Specifies training/validation split output
                                      # OPTIONS: "training", "validation", "both"
                                      # WHEN TO CHANGE: Use specific subset if you want only one split

    image_size=(28, 28),              # image_size: Target image dimensions (height, width)
                                      # PURPOSE: Resizes all images to this size
                                      # IMPACT: Affects model input shape and computational requirements
                                      # WHEN TO CHANGE: Larger (64x64, 224x224) for more detail, smaller for speed

    validation_split=0.2,             # validation_split: Fraction for validation set
                                      # PURPOSE: Percentage of data reserved for validation (20% here)
                                      # RANGE: 0.0 to 1.0 (typically 0.1 to 0.3)
                                      # WHEN TO CHANGE: 0.1-0.15 for large datasets, 0.2-0.3 for smaller datasets

    seed=1337                         # seed: Random seed for reproducible splits
                                      # PURPOSE: Ensures same train/val split across runs
                                      # WHEN TO CHANGE: Different values for different splits, remove for random
)

# =============================================================================
# 3. DATA NORMALIZATION
# =============================================================================

train_ds = train_ds.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y))
val_ds = val_ds.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y))

# Parameter Explanations:
#
# .map() function:
# - PURPOSE: Applies transformation to each batch in the dataset
# - lambda x, y: Anonymous function where x=images, y=labels
#
# tf.cast(x, tf.float32):
# - PURPOSE: Converts image data type from uint8 to float32
# - WHEN TO CHANGE: Use tf.float16 for memory savings, tf.float64 for precision
# - WHY NEEDED: Neural networks work better with floating-point numbers
#
# /255.0:
# - PURPOSE: Normalizes pixel values from [0,255] to [0,1]
# - WHY CRITICAL: Prevents gradient explosion, helps faster convergence
# - ALTERNATIVES: /127.5 - 1 for [-1,1] range, custom normalization for specific needs

# =============================================================================
# 4. BUILD CNN MODEL ARCHITECTURE
# =============================================================================

model = Sequential([
    Conv2D(32,                        # filters: Number of feature detectors (kernels)
                                      # PURPOSE: How many different features to detect
                                      # WHEN TO INCREASE: More complex datasets (64, 128, 256)
                                      # WHEN TO DECREASE: Simpler datasets or less computation (16, 8)

           (5, 5),                    # kernel_size: Size of convolution window (height, width)
                                      # PURPOSE: Defines the receptive field size
                                      # OPTIONS: (3,3) for fine details, (5,5) for broader features, (7,7) for large patterns
                                      # WHEN TO CHANGE: Smaller for detailed features, larger for global patterns

           activation="relu",         # activation: Non-linear activation function
                                      # PURPOSE: Introduces non-linearity for complex pattern learning
                                      # OPTIONS: "relu" (most common), "tanh", "sigmoid", "leaky_relu"
                                      # WHEN TO CHANGE: "leaky_relu" for dying ReLU, "tanh" for [-1,1] outputs

           padding="same",            # padding: Controls output size after convolution
                                      # PURPOSE: Determines spatial dimension preservation
                                      # OPTIONS: "same" (keeps size), "valid" (reduces size)
                                      # WHEN TO USE: "same" to preserve dimensions, "valid" to reduce them

           input_shape=(28, 28, 1)),  # input_shape: Input tensor dimensions (height, width, channels)
                                      # PURPOSE: Defines the expected input format
                                      # WHEN TO CHANGE: Must match your image dimensions and channels

    MaxPooling2D(padding="same"),     # MaxPooling2D: Downsampling layer
                                      # pool_size: Default (2,2) - size of pooling window
                                      # PURPOSE: Reduces spatial dimensions while retaining features
                                      # WHEN TO CHANGE: (3,3) for aggressive downsampling, (1,1) for minimal
                                      # padding: Same options as Conv2D

    Conv2D(64,                        # filters: Increased to 64 for more complex feature detection
                                      # PURPOSE: Detects combinations of basic features from previous layer
           (5, 5),
           activation="relu",
           padding="same"),

    MaxPooling2D(padding="same"),     # Second pooling layer for further dimension reduction

    Flatten(),                        # Flatten: Converts 2D feature maps to 1D vector
                                      # PURPOSE: Prepares data for dense layers
                                      # NO PARAMETERS: Automatically handles reshaping

    Dense(1024,                       # units: Number of neurons in dense layer
                                      # PURPOSE: Learning capacity of the layer
                                      # WHEN TO INCREASE: More complex patterns (2048, 4096)
                                      # WHEN TO DECREASE: Simpler datasets or prevent overfitting (512, 256)

          activation="relu"),         # activation: Activation function for dense layer
                                      # PURPOSE: Non-linearity for complex pattern learning
                                      # TYPICAL: "relu" for hidden layers

    Dropout(0.2),                     # rate: Fraction of neurons to randomly disable
                                      # PURPOSE: Prevents overfitting during training
                                      # RANGE: 0.0 to 0.8 (typically 0.2 to 0.5)
                                      # WHEN TO INCREASE: If overfitting (0.3, 0.4, 0.5)
                                      # WHEN TO DECREASE: If underfitting (0.1, 0.15)

    Dense(26,                         # units: 26 for output classes (A-Z letters)
                                      # PURPOSE: One neuron per class for classification
                                      # WHEN TO CHANGE: Match number of classes in your dataset

          activation="sigmoid")       # activation: Output layer activation
                                      # PURPOSE: Produces probability-like outputs
                                      # OPTIONS: "sigmoid" for multi-label, "softmax" for multi-class
                                      # NOTE: "softmax" might be more appropriate for single-class prediction
])

# =============================================================================
# 5. COMPILE AND TRAIN THE MODEL
# =============================================================================

model.compile(
    optimizer="adam",                 # optimizer: Weight update algorithm
                                      # PURPOSE: How the model learns from errors
                                      # OPTIONS: "adam" (adaptive), "sgd" (basic), "rmsprop" (RNN-friendly)
                                      # WHEN TO CHANGE: "sgd" with momentum for fine-tuning
                                      # CUSTOM: keras.optimizers.Adam(learning_rate=0.001) for custom LR

    loss="sparse_categorical_crossentropy",  # loss: Error measurement function
                                             # PURPOSE: Quantifies prediction errors
                                             # WHEN TO USE: Multi-class with integer labels (0,1,2,...)
                                             # ALTERNATIVES: "categorical_crossentropy" for one-hot,
                                             #               "binary_crossentropy" for binary classification

    metrics=["accuracy"]              # metrics: Additional monitoring metrics
                                      # PURPOSE: Track performance during training
                                      # OPTIONS: ["accuracy"], ["precision"], ["recall"], ["f1_score"]
                                      # WHEN TO ADD: Use precision/recall for imbalanced datasets
)

model.fit(
    train_ds,                         # x: Training data
                                      # PURPOSE: Data used to update model weights
                                      # FORMAT: tf.data.Dataset with (images, labels)

    epochs=20,                        # epochs: Number of complete training passes
                                      # PURPOSE: How many times to see entire dataset
                                      # WHEN TO INCREASE: If loss still decreasing (30, 50, 100)
                                      # WHEN TO DECREASE: If overfitting early (10, 15)
                                      # MONITORING: Watch validation loss to avoid overfitting

    validation_data=val_ds            # validation_data: Data for performance monitoring
                                      # PURPOSE: Evaluates model during training without affecting weights
                                      # WHY IMPORTANT: Detects overfitting, monitors generalization
                                      # WHEN TO SKIP: Only for very small datasets (not recommended)
)

# Additional useful parameters (not used but available):
# batch_size: Number of samples per weight update (default from dataset)
# callbacks: [EarlyStopping, ModelCheckpoint, ReduceLROnPlateau] for automation
# verbose: 0 (silent), 1 (progress bar), 2 (one line per epoch)

# =============================================================================
# 6. LOAD TEST IMAGE FOR PREDICTION
# =============================================================================

img = image.load_img(
    "E:/Maroon/College/S9/DL/Fonts/test1.png",  # path: File path to test image
                                                # PURPOSE: Location of image to classify
                                                # WHEN TO CHANGE: Test different images
                                                # FORMATS: PNG, JPG, JPEG, BMP, GIF supported

    target_size=(28, 28),             # target_size: Resize dimensions (height, width)
                                      # PURPOSE: Match model's expected input size
                                      # MUST MATCH: Model's input_shape requirements
                                      # WHEN TO CHANGE: Only if model input size changes

    color_mode="grayscale"            # color_mode: Color channel specification
                                      # PURPOSE: Match model's expected channels
                                      # OPTIONS: "grayscale" (1), "rgb" (3), "rgba" (4)
                                      # MUST MATCH: Model's input channel requirements
)

img_array = np.expand_dims(
    image.img_to_array(img)/255.0,    # array: Preprocessed image array
                                      # img_to_array(): PIL image → numpy array (28,28,1)
                                      # /255.0: Normalize to [0,1] (CRITICAL: match training preprocessing)

    axis=0                            # axis: Dimension to expand
                                      # PURPOSE: Add batch dimension for model input
                                      # RESULT: (28,28,1) → (1,28,28,1)
                                      # WHY NEEDED: Model expects batched input even for single image
                                      # OPTIONS: axis=0 (beginning), axis=-1 (end)
)

# =============================================================================
# 7. MAKE PREDICTION
# =============================================================================

pred = model.predict(
    img_array                         # x: Input data for prediction
                                      # PURPOSE: Preprocessed image ready for classification
                                      # EXPECTED SHAPE: (batch_size, height, width, channels)
                                      # DATA TYPE: Must be float32 and normalized
)

# Additional predict() parameters (not used but available):
# batch_size: Control memory usage for large datasets (32, 64, 128)
# verbose: 0 (silent), 1 (progress bar), 2 (one line per batch)
# steps: Number of batches (for generator inputs)

pred_class = np.argmax(
    pred,                             # a: Prediction array with probability scores
                                      # PURPOSE: Array of class probabilities
                                      # SHAPE: (1, 26) - 1 sample, 26 class probabilities

    axis=1                            # axis: Dimension for finding maximum
                                      # PURPOSE: Find class with highest probability
                                      # OPTIONS: axis=0 (across samples), axis=1 (across classes)
                                      # RESULT: Index of most confident prediction
)[0]                                  # [0]: Extract scalar from array
                                      # PURPOSE: Get single prediction from batch
                                      # WHY NEEDED: argmax returns shape (1,), we want scalar

# =============================================================================
# 8. DISPLAY PREDICTION RESULT
# =============================================================================

class_values = [chr(i) for i in range(65, 91)]  # Create A-Z mapping
# chr(): Converts ASCII code to character
# range(65, 91): ASCII codes for A(65) through Z(90)
# WHEN TO CHANGE: range(97, 123) for lowercase a-z
# ALTERNATIVES:
#   - import string; class_values = list(string.ascii_uppercase)
#   - Manual list: ['A', 'B', 'C', ..., 'Z']

print("Predicted values:", class_values[pred_class])
# print() parameters (not used but available):
# sep: Separator between arguments (default ' ')
# end: String at end (default '\n')
# file: Output destination (default stdout)

# =============================================================================
# SUMMARY OF KEY PARAMETER TUNING GUIDELINES
# =============================================================================

"""
COMMON PARAMETER ADJUSTMENTS:

1. OVERFITTING (High training accuracy, low validation accuracy):
   - Increase dropout rate (0.3, 0.4, 0.5)
   - Reduce model complexity (fewer filters, smaller dense layers)
   - Add more data augmentation
   - Reduce epochs

2. UNDERFITTING (Low training and validation accuracy):
   - Increase model complexity (more filters, larger dense layers)
   - Decrease dropout rate (0.1, 0.15)
   - Increase epochs
   - Adjust learning rate

3. SLOW TRAINING:
   - Increase batch_size (64, 128)
   - Use smaller image_size (16x16 instead of 28x28)
   - Reduce model complexity

4. MEMORY ISSUES:
   - Decrease batch_size (16, 8)
   - Use tf.float16 instead of tf.float32
   - Reduce image_size
   - Reduce model complexity

5. POOR ACCURACY:
   - Try different optimizers (sgd, rmsprop)
   - Adjust learning rate
   - Use data augmentation
   - Ensure proper data normalization
"""