""" 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 """