{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":3004,"databundleVersionId":861823,"sourceType":"competition"}],"dockerImageVersionId":30746,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Kaggle Competition: Digit Recognizer\n----\n\nMNIST (\"Modified National Institute of Standards and Technology\") is the de facto “hello world” dataset of computer vision. Since its release in 1999, this classic dataset of handwritten images has served as the basis for benchmarking classification algorithms. As new machine learning techniques emerge, MNIST remains a reliable resource for researchers and learners alike.\n\nIn this competition, our goal is to correctly identify digits from a dataset of tens of thousands of handwritten images. The competition details can be found [here](https://www.kaggle.com/competitions/digit-recognizer).\n\n# Table of Contents\n\n1. [Import Libraries](#1-import-libraries)\n2. [Load Data](#2-load-data)\n3. [Visualize Data](#3-visualize-data)\n4. [Preprocess Data](#4-preprocess-data)\n5. [Implementation of **LeNet-5**](#5-implementation-of-lenet-5)\n6. [Modified LeNet-5 Model: **LeNet5_v1**](#6-modified-lenet-5-model-lenet5_v1)\n7. [Create **LeNet5_v1** Model](#7-create-lenet5_v1-model)\n8. [Data Augmentation](#8-data-augmentation)\n9. [Compile & Train Model](#9-compile--train-model)\n10. [Evaluation Plots for Loss & Accuracy](#10-evaluation-plots-for-loss--accuracy)\n11. [Create Submission File](#11-create-submission-file)\n12. [Visualize Predictions](#12-visualize-predictions)\n","metadata":{}},{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_kg_hide-input":true,"execution":{"iopub.status.busy":"2024-07-31T04:13:00.022875Z","iopub.execute_input":"2024-07-31T04:13:00.023682Z","iopub.status.idle":"2024-07-31T04:13:00.467469Z","shell.execute_reply.started":"2024-07-31T04:13:00.023634Z","shell.execute_reply":"2024-07-31T04:13:00.466411Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# from IPython.core.display import HTML\n# HTML(\"<style>.jp-Notebook { background-color: #ffe4d9; }</style>\")","metadata":{"_kg_hide-input":true,"execution":{"iopub.status.busy":"2024-07-31T04:13:00.469205Z","iopub.execute_input":"2024-07-31T04:13:00.469653Z","iopub.status.idle":"2024-07-31T04:13:00.473755Z","shell.execute_reply.started":"2024-07-31T04:13:00.469616Z","shell.execute_reply":"2024-07-31T04:13:00.472786Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='1-import-libraries'></a>\n# 1. Import Libraries","metadata":{}},{"cell_type":"code","source":"# Ignore warnings :\nimport warnings\nwarnings.filterwarnings('ignore')","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:00.474795Z","iopub.execute_input":"2024-07-31T04:13:00.475132Z","iopub.status.idle":"2024-07-31T04:13:00.491276Z","shell.execute_reply.started":"2024-07-31T04:13:00.475103Z","shell.execute_reply":"2024-07-31T04:13:00.490219Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import tensorflow as tf\nfrom tensorflow.python.client import device_lib\nfrom tensorflow import keras\n\nfrom keras.datasets import mnist\nfrom keras.layers import Input, Conv2D, AveragePooling2D, MaxPooling2D, Dense, Flatten, Dropout, Activation, BatchNormalization\nfrom keras.models import Model, Sequential\nfrom keras.optimizers import Adam\nfrom keras.utils import to_categorical\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\nfrom keras.regularizers import l2\nfrom keras.callbacks import Callback, ReduceLROnPlateau\n\nfrom sklearn.model_selection import train_test_split\n\nimport matplotlib.image  as mpimg\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nimport pandas as pd\nimport numpy as np\nimport math\nimport time\nimport torch","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:00.493850Z","iopub.execute_input":"2024-07-31T04:13:00.494413Z","iopub.status.idle":"2024-07-31T04:13:06.791236Z","shell.execute_reply.started":"2024-07-31T04:13:00.494378Z","shell.execute_reply":"2024-07-31T04:13:06.790021Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='2-load-data'></a>\n# 2. Load Data","metadata":{}},{"cell_type":"code","source":"train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')\ntest = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')\nsample_submission = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv')","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:06.792734Z","iopub.execute_input":"2024-07-31T04:13:06.793598Z","iopub.status.idle":"2024-07-31T04:13:11.847375Z","shell.execute_reply.started":"2024-07-31T04:13:06.793563Z","shell.execute_reply":"2024-07-31T04:13:11.846454Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train.head()","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:11.848715Z","iopub.execute_input":"2024-07-31T04:13:11.849157Z","iopub.status.idle":"2024-07-31T04:13:11.880383Z","shell.execute_reply.started":"2024-07-31T04:13:11.849114Z","shell.execute_reply":"2024-07-31T04:13:11.879273Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train.label.value_counts()","metadata":{"_kg_hide-input":true,"_kg_hide-output":true,"execution":{"iopub.status.busy":"2024-07-31T04:13:11.881598Z","iopub.execute_input":"2024-07-31T04:13:11.881939Z","iopub.status.idle":"2024-07-31T04:13:11.898058Z","shell.execute_reply.started":"2024-07-31T04:13:11.881912Z","shell.execute_reply":"2024-07-31T04:13:11.896923Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train.shape, test.shape","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:11.899282Z","iopub.execute_input":"2024-07-31T04:13:11.899580Z","iopub.status.idle":"2024-07-31T04:13:11.907479Z","shell.execute_reply.started":"2024-07-31T04:13:11.899554Z","shell.execute_reply":"2024-07-31T04:13:11.906471Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='3-visualize-data'></a>\n# 3. Visualize Data","metadata":{}},{"cell_type":"code","source":"X = train.drop('label', axis=1)\ny = train.label","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:11.908833Z","iopub.execute_input":"2024-07-31T04:13:11.909169Z","iopub.status.idle":"2024-07-31T04:13:12.000606Z","shell.execute_reply.started":"2024-07-31T04:13:11.909119Z","shell.execute_reply":"2024-07-31T04:13:11.999543Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"random_idx = np.random.choice(X.shape[0], 15, replace=False)\nfor i, idx in enumerate(random_idx):\n    plt.subplot(3, 5, i+1)\n    plt.imshow(X.to_numpy().reshape(-1, 28, 28)[idx, :, :])\n    plt.xticks([])  # Remove coordinates from axes\n    plt.yticks([])\n    plt.title(y[idx])","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:12.004874Z","iopub.execute_input":"2024-07-31T04:13:12.005143Z","iopub.status.idle":"2024-07-31T04:13:12.919006Z","shell.execute_reply.started":"2024-07-31T04:13:12.005120Z","shell.execute_reply":"2024-07-31T04:13:12.917926Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"random_idx = np.random.choice(X.shape[0], 15, replace=False)\nfor i, idx in enumerate(random_idx):\n    plt.subplot(3, 5, i+1)\n    plt.imshow(X.to_numpy().reshape(-1, 28, 28, 1)[idx, :, :, 0])\n    plt.xticks([])  # Remove coordinates from axes\n    plt.yticks([])\n    plt.title(y[idx])","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:12.920259Z","iopub.execute_input":"2024-07-31T04:13:12.920598Z","iopub.status.idle":"2024-07-31T04:13:14.031995Z","shell.execute_reply.started":"2024-07-31T04:13:12.920568Z","shell.execute_reply":"2024-07-31T04:13:14.030678Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='4-preprocess-data'></a>\n# 4. Preprocess Data\n----\n\nFunctions:\n* `preprocess_data`\n","metadata":{}},{"cell_type":"code","source":"def preprocess_data(train, test, split_ratio=0.1, num_classes=10, random_seed=42, preprocess_type='normalize'):\n    \"\"\"\n    Preprocess MNIST data with specified method and return TensorFlow datasets.\n\n    Args:\n        train: DataFrame, training data with 785 columns (1st column: label, remaining columns: 784 pixel values for image (28x28))\n        test: DataFrame, test data (no labels) with 784 columns (columns: 784 pixels for each image (28x28))\n        split_ratio: Float, the ratio of the training data to use for validation.\n        num_classes: Integer, number of classes/labels (10 digits) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n        random_seed: Integer, the seed for shuffling the data.\n        preprocess_type: String, 'normalize' or 'standardize' for data preprocessing method.\n\n    Returns:\n        Tuple of datasets array: (train_images, train_labels, val_images, val_labels, test_images)\n    \"\"\"\n    # Extract training data images and label\n    train_labels = train.label\n    train_images = train.drop('label', axis=1)\n    test_images = test\n\n    # Split the original training data into training and validation sets\n    num_val_samples = int(split_ratio * len(train_images))\n    X_tr, X_val, y_tr, y_val = train_test_split(train_images, train_labels, test_size=split_ratio, random_state=random_seed)\n\n    # Reshape the input data to include a channel dimension (for grayscale images) (shape: num_samples, 28, 28, 1)\n    X_tr = X_tr.to_numpy().reshape(-1, 28, 28, 1)\n    X_val = X_val.to_numpy().reshape(-1, 28, 28, 1)\n    test_images = test_images.to_numpy().reshape(-1, 28, 28, 1)\n\n    # Resize images to 32x32 and add channel dimension\n    X_tr = tf.image.resize(X_tr, [32, 32]).numpy()\n    X_val = tf.image.resize(X_val, [32, 32]).numpy()\n    test_images = tf.image.resize(test_images, [32, 32]).numpy()\n\n    if preprocess_type == 'normalize':\n        # Normalize pixel values to [0, 1]\n        X_tr = X_tr.astype('float32') / 255.0\n        X_val = X_val.astype('float32') / 255.0\n        test_images = test_images.astype('float32') / 255.0\n    elif preprocess_type == 'standardize':\n        # Standardize pixel values (mean 0, std 1)\n        mean_px_tr = X_tr.mean().astype('float32')\n        std_px_tr = X_tr.std().astype('float32')\n        X_tr = (X_tr.astype('float32') - mean_px_tr) / std_px_tr\n        \n        mean_px_val = X_val.mean().astype('float32')\n        std_px_val = X_val.std().astype('float32')\n        X_val = (X_val.astype('float32') - mean_px_val) / std_px_val\n        \n        mean_px_te = test_images.mean().astype('float32')\n        std_px_te = test_images.std().astype('float32')\n        test_images = (test_images.astype('float32') - mean_px_te) / std_px_te\n    else:\n        raise ValueError(\"Invalid preprocess_type. Choose 'normalize' or 'standardize'.\")\n\n    # Convert labels to one-hot encoding\n    y_tr = to_categorical(y_tr, num_classes=num_classes)\n    y_val = to_categorical(y_val, num_classes=num_classes)\n\n    return X_tr, y_tr, X_val, y_val, test_images\n\n# Example usage\n# train_images, train_labels, val_images, val_labels, test_images = preprocess_data(train_data, test_data)\n","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:14.034310Z","iopub.execute_input":"2024-07-31T04:13:14.035075Z","iopub.status.idle":"2024-07-31T04:13:14.054599Z","shell.execute_reply.started":"2024-07-31T04:13:14.035018Z","shell.execute_reply":"2024-07-31T04:13:14.053381Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train, y_train, X_val, y_val, X_test = preprocess_data(\n    train,\n    test,\n    split_ratio=0.1,\n    num_classes=10,\n    random_seed=42,\n    preprocess_type='normalize'  # or 'standardize'\n)\n\n# Print out the shapes\nprint(\"Train Images Shape:\", X_train.shape)\nprint(\"Train Labels Shape:\", y_train.shape)\nprint(\"Validation Images Shape:\", X_val.shape)\nprint(\"Validation Labels Shape:\", y_val.shape)\nprint(\"Test Images Shape:\", X_test.shape)","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:14.055862Z","iopub.execute_input":"2024-07-31T04:13:14.056153Z","iopub.status.idle":"2024-07-31T04:13:16.767550Z","shell.execute_reply.started":"2024-07-31T04:13:14.056128Z","shell.execute_reply":"2024-07-31T04:13:16.766461Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The original MNIST datset has **60,000 training images** and **10,000 test images.**\n\n----","metadata":{}},{"cell_type":"markdown","source":"<a id='5-implementation-of-lenet-5'></a>\n# 5. Implementation of LeNet-5\n---\n\n\n\n**LeNet-5** is a classic convolutional neural network employing the use of convolutions, pooling and fully connected layers that was developed in 1998 by _Yann Lecun, Leon Bottou, Yoshua Bengio & Patrick Haffner._ It was designed for handwritten digit recognition using the MNIST (Modified National Institute of Standards and Technology) dataset. <u>Animated demonstrations</u> of LeNet-5 can be found [here](https://yann.lecun.com/exdb/lenet/index.html). The original LeNet-5 paper, _**\"Gradient Based Learning Applied to Document Recognition,\"**_ can be found [here](http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf) or [here](https://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf). According to Yann Lecun, on his LeNet5 [demo](https://yann.lecun.com/exdb/lenet/index.html) page:\n>Convolutional Neural Networks are are a special kind of multi-layer neural networks. Like almost every other neural networks they are trained with a version of the back-propagation algorithm. Where they differ is in the architecture.\n>  \n>Convolutional Neural Networks are designed to recognize visual patterns directly from pixel images with minimal preprocessing. They can recognize patterns with extreme variability (such as handwritten characters), and with robustness to distortions and simple geometric transformations.\n>\n>LeNet-5 is our latest convolutional network designed for handwritten and machine-printed character recognition.\n\nThe MNIST dataset is basically the _\"Hello World\"_ of computer vision in deep learning. Currently, most deep learning implementations attain $\\textbf{~98%}$ accuracy in correct classification of the handwritten digits. The MNIST database can be found [here](https://yann.lecun.com/exdb/mnist/).\n\nThe goal is to implement a modified version of the LeNet-5 model [1] in tensorflow as seen in the 1998 paper and apply it to MNIST digit classification. The original LeNet5 model architecture is shown below:\n\n![LeNet-5.png](attachment:dfbfebc0-c6e8-419c-b34a-34f4406d64bc.png)\n\nLeNet-5 is commonly regarded as the pioneer of convolutional neural networks, consisting of a very simple architecture (by modern standards). **The LeNet-5 architecture primarily consists of three major layer constructs:**\n* Convolutional layers, `C1, C3, C5`\n* Sub-sampling layers (pooling), `S2, S4`\n* Fully-connected layers (FC), `F6`\n\nIn the figure above, convolutional layers are labeled $Cx$, sub-sampling layers are labeled $Sx$, and fully-connected layers are labeled $Fx$, where $x$ is the layer index. In total, LeNet-5 consists of only $7$ layers. $3$ out of these $7$ layers are convolutional layers ($C1, C3, C5$), which are connected by two average pooling layers ($S2, S4$). The penultimate layer is a fully connected layer ($F6$), which is followed by the final output layer. The additional details are summarized below:\n```\nModel:                   Input --> [  C1  ] -> [  S2  ] -> [  C3  ] -> [  S4  ] -----------> [  C5/F5  ] -> [  F6  ] -> Output\nShape:                   32x32       28x28       14x14       10x10        5x5                    1x1          84          10\nFeature Maps:              -           6           6          16          16                     120          -           -\nTrainable Params:          -          156                    2,416                              48,120       10,164       850\n\nImplementation:                    ConvNet -> Avg. Pool -> ConvNet -> Avg. Pool -> (Flatten) ---> FC -------> FC -----> Softmax\n```\n\n- The input size is $32\\times32$; here, we rescale the MNIST images from $28\\times28$ to $32\\times32$ to match this input dimension.\n- All convolutional layers use $5\\times5$ kernels with stride $1$.\n- The two average pooling (subsampling) layers are $2\\times2$ pixels wide with stride $2$.\n- The output layer uses $10$ custom `Euclidean Radial Basis Function (RBF)` neurons for the output layer. (**In this notebook, we replace these with `softmax` activations**).\n\n### References\n\n- [1] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, november 1998.","metadata":{},"attachments":{"dfbfebc0-c6e8-419c-b34a-34f4406d64bc.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"<a id='6-modified-lenet-5-model-lenet5_v1'></a>\n# 6. Modified LeNet-5 Model: **LeNet5_v1**\n----\n\n\nFunctions:\n* `LeNet5v1`\n\n---\nOriginal version: \n>C1 &rarr; S2 &rarr; C3 &rarr; S4 &rarr; (Flatten) &rarr; FC5 &rarr; FC6 &rarr; Softmax\n- The input size is $32\\times32$; here, we rescale the MNIST images from $28\\times28$ to $32\\times32$ to match this input dimension.\n- All convolutional layers use $5\\times5$ kernels with stride $1$.\n- The two average pooling (subsampling) layers are $2\\times2$ pixels wide with stride $2$.\n- The output layer uses $10$ custom `Euclidean Radial Basis Function (RBF)` neurons for the output layer. (**In this notebook, I replace these with `softmax` activations**).\n\nFor the modified version below, this is the starting point below (rename layers from original version for simplicity):\n>C1 &rarr; S1 &rarr; C2 &rarr; S2 &rarr; (Flatten) &rarr; FC1 &rarr; FC2 &rarr; Softmax\n\nBelow is the modified LeNet-5 model architecture:\n1. **<u>`LeNet5v1`</u>:** \n>C1 &rarr; **C3** &rarr; **BN1** &rarr; S1 (**Max_Pool**) &rarr; **D1** &rarr; C2 &rarr; **C4** &rarr; **BN2** &rarr; S2 (**Max_Pool**) &rarr; **D2** &rarr; (Flatten) &rarr; **FC3** &rarr; **BN3** &rarr; FC1 &rarr; **BN4** &rarr; FC2 &rarr; **BN5** &rarr; **D3** &rarr; Softmax\n>\n><u>_More detailed:_</u>\n>ConvNet &rarr; _ConvNet_ &rarr; **BatchNorm** &rarr; Max. Pool &rarr; _Dropout_ &rarr; ConvNet &rarr; **ConvNet** &rarr; **BatchNorm** &rarr; Max. Pool &rarr; _Dropout_ &rarr; (Flatten) &rarr; **FC** &rarr; **BatchNorm** &rarr; FC &rarr; **BatchNorm** &rarr; FC &rarr; **BatchNorm** &rarr; **Dropout** &rarr; Softmax\n- Replace all the instances of **`tanh`** activation functions with **`ReLU`** activation functions in baseline original model from 1998 paper.\n- Replace all the instances ($S1, S2$) of **`average pooling`** layers with **`max pooling`** layers.\n- Add a **Convolutional layer, $\\textbf{C3}$** directly after $C1$ and before $S1$.\n- Add **dropout layers, $\\textbf{D1, D2}$** (`dropout` = $0.25$) directly after both pooling layers.\n- Add a **`BatchNorm`, $\\textbf{BN1}$** layer directly before $S1$.\n- Add a **`ConvNet`**, $\\textbf{C4}$ & then a **`BatchNorm`** layer, $\\textbf{BN2}$ directly after $C2$.\n- Add a **`FC`** layer, $\\textbf{FC3}$ & then a **`BatchNorm`** layer, $\\textbf{BN3}$ directly after $\\textbf{flatten}$ layer.\n- Add 2 **`BatchNorm`** layers, $\\textbf{BN4}$ directly before and $\\textbf{BN5}$ directly after $FC2$.\n- Add a **Dropout** layer, $\\textbf{D3}$ right before the output ($\\textbf{softmax}$) layer.\n- Increase number of filter channels (feature maps) for `Convnet` layers ($C1, C3, C2, C4$) consecutively to $32, 32, 64, 64$.\n- Set number of hidden units in $\\textbf{FC3}$ (directly after flatten layer) and $\\textbf{FC2}$ (sandwiched with `BatchNorms`) to $256$ and $128$ respectively.\n- The use of `BatchNorm` handles `bias` so we can set bias to `False` or $0$ in layers right before all the `BatchNorm` layers.\n- Add **L2 regularization** (`reg_L2` = $0.0005$) in $\\textbf{C1}$, and $\\textbf{C2}$ layers to reduce overfitting.","metadata":{}},{"cell_type":"code","source":"def LeNet5v1(input_shape=(32, 32, 1), num_classes=10, l2_reg=0.0005, activation='relu'):\n\n    \"\"\"\n    Builds a modified LeNet-5 model using the Sequential API.\n    Architecture summary: ConvNet → ConvNet → [BatchNorm] → Max. Pool → Dropout → ConvNet → [ConvNet] → [BatchNorm] → Max. Pool →\n                          Dropout → (Flatten) → [FC] → [BatchNorm] → FC → [BatchNorm] → FC → [BatchNorm] → [Dropout] → Softmax\n\n    Arguments:\n    input_shape -- tuple, shape of the input images (height, width, channels). Default is (32, 32, 1).\n    num_classes -- integer, number of classes for the output layer. Default is 10.\n\n    Returns:\n    model -- a Keras Sequential model instance with the defined architecture.\n    \"\"\"\n    model = Sequential([\n      # Input layer\n      Input(shape=input_shape, name='input_layer'),\n        \n      # Layer 1: C1_L2regularized\n      Conv2D(filters=32, kernel_size=5, strides=1, activation=activation, padding='valid', kernel_regularizer=l2(l2_reg), name='conv_1'),\n\n      # Layer 2: C2_no_bias + BN3 + S4 + D5\n      Conv2D(filters=32, kernel_size=5, strides=1, activation=activation, padding='valid', use_bias=False, name='conv_2'),\n      BatchNormalization(name='batch_norm_1'),\n      Activation(activation),\n      MaxPooling2D(pool_size=2, strides=2, name='max_pool_1'),\n      Dropout(rate=0.25, name='dropout_1'),\n\n      # Layer 3: C6_L2regularized\n      Conv2D(filters=64, kernel_size=3, strides=1, activation=activation, padding='valid', kernel_regularizer=l2(l2_reg), name='conv_3'),\n\n      # Layer 4: C7_no_bias + BN8 + S9 + D10\n      Conv2D(filters=64, kernel_size=3, strides=1, activation=activation, padding='valid', use_bias=False, name='conv_4'),\n      BatchNormalization(name='batch_norm_2'),\n      MaxPooling2D(pool_size=2, strides=2, name='max_pool_2'),\n      Dropout(rate=0.25, name='dropout_2'),\n\n      # Layer 5: Flatten + F11_no_bias + BN12\n      Flatten(name='flatten'),\n      Dense(units=256, activation=activation, use_bias=False, name='fully_connected_1'),\n      BatchNormalization(name='batch_norm_3'),\n      Activation(activation),\n\n      # Layer 6: F13_no_bias + BN14\n      Dense(units=128, activation=activation, use_bias=False, name='fully_connected_2'),\n      BatchNormalization(name='batch_norm_4'),\n      Activation(activation),\n\n      # Layer 7: F15_no_bias + BN16 + D17\n      Dense(units=84, activation=activation, use_bias=False, name='fully_connected_3'),\n      BatchNormalization(name='batch_norm_5'),\n      Activation(activation),\n      Dropout(rate=0.25, name='dropout_3'),\n\n      # Layer 8: Output\n      Dense(units=num_classes, activation='softmax', name='output')\n\n    ])\n\n    model._name = 'LeNet5v1'\n\n    return model\n","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:16.768896Z","iopub.execute_input":"2024-07-31T04:13:16.769227Z","iopub.status.idle":"2024-07-31T04:13:16.783845Z","shell.execute_reply.started":"2024-07-31T04:13:16.769198Z","shell.execute_reply":"2024-07-31T04:13:16.782469Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='7-create-lenet5_v1-model'></a>\n# 7. Create **LeNet5_v1** Model","metadata":{}},{"cell_type":"code","source":"##########################\n### SETTINGS\n##########################\n\n# Hyperparameters\n# RANDOM_SEED = 42\n# LEARNING_RATE = 0.001\nBATCH_SIZE = 64\nNUM_EPOCHS = 30\n\n\n# Architecture\nINPUT_SHAPE = (32, 32, 1)\nNUM_CLASSES = 10\n\n# Learning Rate\nLR_FACTOR = 0.2\nPATIENCE = 2","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:16.785229Z","iopub.execute_input":"2024-07-31T04:13:16.785545Z","iopub.status.idle":"2024-07-31T04:13:16.802119Z","shell.execute_reply.started":"2024-07-31T04:13:16.785518Z","shell.execute_reply":"2024-07-31T04:13:16.800824Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(device_lib.list_local_devices())","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:16.803510Z","iopub.execute_input":"2024-07-31T04:13:16.803927Z","iopub.status.idle":"2024-07-31T04:13:16.817932Z","shell.execute_reply.started":"2024-07-31T04:13:16.803888Z","shell.execute_reply":"2024-07-31T04:13:16.816738Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Check if GPU is available\ngpus = tf.config.list_physical_devices('GPU')\nif gpus:\n    print(\"Num GPUs Available: \", len(gpus))\n    for gpu in gpus:\n        print(f\"GPU: {gpu}\")\nelse:\n    print(\"No GPU available.\")\n    \n    \n#------------------------------------------------------------------------------------------------------------------------\n# Verify TensorFlow is using GPU\nif tf.test.gpu_device_name():\n    print('GPU found: {}'.format(tf.test.gpu_device_name()))\nelse:\n    print(\"GPU not found.\")","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:16.819060Z","iopub.execute_input":"2024-07-31T04:13:16.819327Z","iopub.status.idle":"2024-07-31T04:13:16.834533Z","shell.execute_reply.started":"2024-07-31T04:13:16.819304Z","shell.execute_reply":"2024-07-31T04:13:16.833535Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Create model\nmodel = LeNet5v1(input_shape=INPUT_SHAPE, num_classes=NUM_CLASSES)\n\n# Print model summary\nmodel.summary()","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:16.836040Z","iopub.execute_input":"2024-07-31T04:13:16.836357Z","iopub.status.idle":"2024-07-31T04:13:17.070583Z","shell.execute_reply.started":"2024-07-31T04:13:16.836332Z","shell.execute_reply":"2024-07-31T04:13:17.069518Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='8-data-augmentation'></a>\n# 8. Data Augmentation\n---\n\nData augmentation is a technique to artificially increase the size of a training dataset by creating modified versions of images in the dataset. This can help improve the performance and generalization of machine learning models by providing more diverse training examples.\n\nThe code below uses the `ImageDataGenerator` class from Keras to perform data augmentation on the training images. Here's a breakdown of what each parameter does in the `ImageDataGenerator`:\n\n- **featurewise_center**: If set to `True`, it will set the mean of the dataset to 0 by subtracting the mean of the entire dataset from each image. In this case, it is set to `False`.\n\n- **samplewise_center**: If set to `True`, it will set the mean of each individual image to 0 by subtracting the mean of the image from itself. In this case, it is set to `False`.\n\n- **featurewise_std_normalization**: If set to `True`, it will divide each image by the standard deviation of the entire dataset. In this case, it is set to `False`.\n\n- **samplewise_std_normalization**: If set to `True`, it will divide each image by its own standard deviation. In this case, it is set to `False`.\n\n- **zca_whitening**: If set to `True`, it will apply ZCA (Zero Component Analysis) whitening to the images, which decorrelates the features in the images. In this case, it is set to `False`.\n\n- <u>**rotation_range**:</u> Specifies a range of degrees (0 to 180) within which to randomly rotate images. Here it is set to **10 degrees.**\n\n- <u>**zoom_range**:</u> Specifies a range for random zoom. Here it is set to **0.1,** meaning the image can be zoomed in or out by up to 10%.\n\n- <u>**width_shift_range**:</u> Specifies a fraction of the total width within which to randomly shift images horizontally. Here it is set to **0.1,** meaning the image can be shifted horizontally by up to 10% of its width.\n\n- <u>**height_shift_range**:</u> Specifies a fraction of the total height within which to randomly shift images vertically. Here it is set to **0.1,** meaning the image can be shifted vertically by up to 10% of its height.\n\n- **horizontal_flip**: If set to `True`, it will randomly flip images horizontally. In this case, it is set to `False`.\n\n- **vertical_flip**: If set to `True`, it will randomly flip images vertically. In this case, it is set to `False`.\n\n### Purpose\n\nThe main purpose of this setup is to augment the training data by applying random transformations to the images. This can help prevent overfitting and improve the model's ability to generalize to new, unseen data. \n\n### Usage\n\nBy calling `datagen.fit(X_train)`, you compute any required statistics (like the mean and standard deviation) on the training data `X_train`. This step is particularly useful when you use feature-wise normalization or ZCA whitening.\n\n### Example in Training\n\nHere is how you can use this `datagen` in your training process:\n\n```python\n# Create an instance of the ImageDataGenerator\ndatagen = ImageDataGenerator(\n        featurewise_center = False,\n        samplewise_center = False,\n        featurewise_std_normalization = False,\n        samplewise_std_normalization = False,\n        zca_whitening = False,\n        rotation_range = 10,\n        zoom_range = 0.1,\n        width_shift_range = 0.1,\n        height_shift_range = 0.1,\n        horizontal_flip = False,\n        vertical_flip = False)\n\n# Compute the internal data stats related to the dataset\ndatagen.fit(X_train)\n\n# Fit the model on the batches generated by datagen.flow()\nmodel.fit(datagen.flow(X_train, y_train, batch_size=32),\n          epochs=NUM_EPOCHS,\n          validation_data=(X_val, y_val),\n          callbacks=[LogMetrics(), reduce_lr, LearningRateLogger()])\n```\n\nIn this example, `datagen.flow(X_train, y_train, batch_size=32)` generates batches of augmented data and labels on the fly, and the model is trained using these augmented data batches.","metadata":{}},{"cell_type":"code","source":"# By using the image generator, we are not generating new data. We are only replacing the exisiting images. \n\ndatagen = ImageDataGenerator(\n        featurewise_center = False,  # set input mean to 0 over the dataset\n        samplewise_center = False,  # set each sample mean to 0\n        featurewise_std_normalization = False,  # divide inputs by std of the dataset\n        samplewise_std_normalization = False,  # divide each input by its std\n        zca_whitening = False,  # apply ZCA whitening\n        rotation_range = 10,  # randomly rotate images in the range (degrees, 0 to 180)\n        zoom_range = 0.1, # Randomly zoom image \n        width_shift_range = 0.1,  # randomly shift images horizontally (fraction of total width)\n        height_shift_range = 0.1,  # randomly shift images vertically (fraction of total height)\n        horizontal_flip = False,  # randomly flip images\n        vertical_flip = False)  # randomly flip images\n\ndatagen.fit(X_train)","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:17.071761Z","iopub.execute_input":"2024-07-31T04:13:17.072100Z","iopub.status.idle":"2024-07-31T04:13:17.140377Z","shell.execute_reply.started":"2024-07-31T04:13:17.072072Z","shell.execute_reply":"2024-07-31T04:13:17.139161Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='9-compile--train-model'></a>\n# 9. Compile & Train Model\n---\n\n Functions:\n* `train_model`","metadata":{}},{"cell_type":"code","source":"def train_model(model, X_train, y_train, X_val, y_val, num_epochs, lr_factor, patience, batch_size=64):\n    \"\"\"\n    Train the model and log metrics including training and validation loss, accuracy, and learning rate.\n\n    Args:\n        model: Keras model instance to be trained.\n        X_train: Training images.\n        y_train: Training labels.\n        X_val: Validation images.\n        y_val: Validation labels.\n        num_epochs: Number of epochs to train.\n        lr_factor: Factor by which the learning rate will be reduced.\n        patience: Number of epochs with no improvement after which learning rate will be reduced.\n        batch_size: Batch size for training.\n\n    Returns:\n        model: Trained Keras model instance.\n        history: Training history object.\n        log_metrics: Custom callback instance for logging metrics.\n        variable_lr: ReduceLROnPlateau callback instance.\n    \"\"\"\n\n    # Define the custom callback to log metrics\n    class LogMetrics(Callback):\n        def on_train_begin(self, logs=None):\n            self.lrs = []\n\n        def on_epoch_end(self, epoch, logs=None):\n            val_logs = self.model.evaluate(X_val, y_val, verbose=0)\n            lr = self.model.optimizer.learning_rate.numpy()\n            self.lrs.append(lr)\n            print(f'Epoch {epoch + 1}/{num_epochs} | '\n                  f'Train Loss: {logs[\"loss\"]:.5f}, '\n                  f'Train Accuracy: {logs[\"accuracy\"]:.4f} | '\n                  f'Val Loss: {val_logs[0]:.4f}, '\n                  f'Val Accuracy: {val_logs[1]:.4f} | '\n                  f'Learning Rate: {lr:.8f}')\n\n    # Define the ReduceLROnPlateau callback\n    variable_lr = ReduceLROnPlateau(\n        monitor='val_loss',\n        factor=lr_factor,\n        patience=patience\n    )\n\n    # Create an instance of the LogMetrics callback\n    log_metrics = LogMetrics()\n\n    # Compile the model\n    model.compile(optimizer='adam',\n                  loss='categorical_crossentropy',\n                  metrics=['accuracy'])\n\n\n    # Train & Fit the model on the batches generated by datagen.flow()\n    start_time = time.time()\n    history = model.fit(datagen.flow(X_train, y_train, batch_size=BATCH_SIZE),\n                        epochs=num_epochs,\n                        validation_data=(X_val, y_val),\n                        callbacks=[log_metrics, variable_lr],\n                        verbose=0)\n\n    print('Total Training Time: %.2f min' % ((time.time() - start_time) / 60))\n\n    return model, history, log_metrics, variable_lr","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:17.142242Z","iopub.execute_input":"2024-07-31T04:13:17.142665Z","iopub.status.idle":"2024-07-31T04:13:17.154601Z","shell.execute_reply.started":"2024-07-31T04:13:17.142622Z","shell.execute_reply":"2024-07-31T04:13:17.153640Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# model.compile(optimizer='adam',\n#               loss='categorical_crossentropy',\n#               metrics=['accuracy'])\n# variable_learning_rate = ReduceLROnPlateau(monitor='val_loss', factor = LR_FACTOR, patience = PATIENCE)\n# history = model.fit(X_train, y_train, epochs = NUM_EPOCHS, batch_size = BATCH_SIZE,\n#                     callbacks = [variable_learning_rate], validation_data = (X_val,y_val))","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:17.156198Z","iopub.execute_input":"2024-07-31T04:13:17.156536Z","iopub.status.idle":"2024-07-31T04:13:17.172419Z","shell.execute_reply.started":"2024-07-31T04:13:17.156498Z","shell.execute_reply":"2024-07-31T04:13:17.171407Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Example usage\ntrained_model, history, log_metrics, variable_lr = train_model(\n    model,\n    X_train,\n    y_train,\n    X_val,\n    y_val,\n    batch_size=BATCH_SIZE,\n    num_epochs=NUM_EPOCHS,\n    lr_factor=LR_FACTOR,\n    patience=PATIENCE\n)","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:13:17.173793Z","iopub.execute_input":"2024-07-31T04:13:17.175118Z","iopub.status.idle":"2024-07-31T04:20:50.746216Z","shell.execute_reply.started":"2024-07-31T04:13:17.175089Z","shell.execute_reply":"2024-07-31T04:20:50.745190Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='10-evaluation-plots-for-loss--accuracy'></a>\n# 10. Evaluation Plots for Loss & Accuracy\n---\n\n Functions:\n* `plot_history`","metadata":{}},{"cell_type":"code","source":"def plot_history(history, log_metrics):  \n    \"\"\"\n    Plot the training and validation loss, accuracy, and learning rate.\n\n    Args:\n        history: Training history object returned by the fit method.\n        log_metrics: Custom callback instance that logged learning rates.\n    \"\"\"\n    \n    epochs = range(1, len(history.history['loss']) + 1)\n\n    # Plot training & validation loss values\n    plt.figure(figsize=(12, 4))\n    plt.subplot(1, 3, 1)\n    plt.plot(epochs, history.history['loss'], label='Train Loss')\n    plt.plot(epochs, history.history['val_loss'], label='Val Loss')\n    plt.title('Training and Validation Loss')\n    plt.xlabel('Epochs')\n    plt.ylabel('Loss')\n    plt.legend()\n\n    # Plot training & validation accuracy values\n    plt.subplot(1, 3, 2)\n    plt.plot(epochs, history.history['accuracy'], label='Train Accuracy')\n    plt.plot(epochs, history.history['val_accuracy'], label='Val Accuracy')\n    plt.title('Training and Validation Accuracy')\n    plt.xlabel('Epochs')\n    plt.ylabel('Accuracy')\n    plt.legend()\n\n    # Plot learning rate values\n    plt.subplot(1, 3, 3)\n    plt.plot(epochs, log_metrics.lrs, label='Learning Rate')\n    plt.title('Learning Rate Over Epochs')\n    plt.xlabel('Epochs')\n    plt.ylabel('Learning Rate')\n    plt.legend()\n\n    plt.tight_layout()\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:20:50.747860Z","iopub.execute_input":"2024-07-31T04:20:50.748606Z","iopub.status.idle":"2024-07-31T04:20:50.759027Z","shell.execute_reply.started":"2024-07-31T04:20:50.748566Z","shell.execute_reply":"2024-07-31T04:20:50.758102Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Example usage (after training the model)\nplot_history(history, log_metrics)","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:20:50.760310Z","iopub.execute_input":"2024-07-31T04:20:50.760770Z","iopub.status.idle":"2024-07-31T04:20:51.680221Z","shell.execute_reply.started":"2024-07-31T04:20:50.760739Z","shell.execute_reply":"2024-07-31T04:20:51.679236Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='11-create-submission-file'></a>\n# 11. Create Submission File\n---\n","metadata":{}},{"cell_type":"code","source":"sample_submission.head()","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:20:51.681679Z","iopub.execute_input":"2024-07-31T04:20:51.682131Z","iopub.status.idle":"2024-07-31T04:20:51.692555Z","shell.execute_reply.started":"2024-07-31T04:20:51.682087Z","shell.execute_reply":"2024-07-31T04:20:51.691407Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"predictions = model.predict(X_test)\npredicted_labels = np.argmax(predictions, axis=1)","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:20:51.694225Z","iopub.execute_input":"2024-07-31T04:20:51.694617Z","iopub.status.idle":"2024-07-31T04:20:54.624466Z","shell.execute_reply.started":"2024-07-31T04:20:51.694584Z","shell.execute_reply":"2024-07-31T04:20:54.623124Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission = pd.DataFrame({\n    'ImageId': range(1, len(predicted_labels) + 1), \n    'Label': predicted_labels\n})\nsubmission.head()","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:20:54.626146Z","iopub.execute_input":"2024-07-31T04:20:54.626539Z","iopub.status.idle":"2024-07-31T04:20:54.638848Z","shell.execute_reply.started":"2024-07-31T04:20:54.626505Z","shell.execute_reply":"2024-07-31T04:20:54.637757Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission.to_csv('submission.csv', index=False)\nprint(\"Submission file created.\")","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:20:54.644662Z","iopub.execute_input":"2024-07-31T04:20:54.645017Z","iopub.status.idle":"2024-07-31T04:20:54.690201Z","shell.execute_reply.started":"2024-07-31T04:20:54.644988Z","shell.execute_reply":"2024-07-31T04:20:54.689132Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!head submission.csv","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:20:54.691792Z","iopub.execute_input":"2024-07-31T04:20:54.692252Z","iopub.status.idle":"2024-07-31T04:20:55.827465Z","shell.execute_reply.started":"2024-07-31T04:20:54.692214Z","shell.execute_reply":"2024-07-31T04:20:55.826220Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nif os.path.exists('submission.csv'):\n    print(\"File created successfully.\")\nelse:\n    print(\"File not found.\")","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:20:55.829149Z","iopub.execute_input":"2024-07-31T04:20:55.829506Z","iopub.status.idle":"2024-07-31T04:20:55.836268Z","shell.execute_reply.started":"2024-07-31T04:20:55.829470Z","shell.execute_reply":"2024-07-31T04:20:55.835062Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"<a id='12-visualize-predictions'></a>\n# 12. Visualize Predictions\n---\n","metadata":{}},{"cell_type":"code","source":"random_idx = np.random.choice(X_test.shape[0], 15, replace=False)\nfor i, idx in enumerate(random_idx):\n    plt.subplot(3, 5, i+1)\n    plt.imshow(X_test[idx, :, :, 0])\n    plt.xticks([])  # Remove coordinates from axes\n    plt.yticks([])\n    plt.title(submission.Label[idx])","metadata":{"execution":{"iopub.status.busy":"2024-07-31T04:20:55.837747Z","iopub.execute_input":"2024-07-31T04:20:55.838126Z","iopub.status.idle":"2024-07-31T04:20:56.780541Z","shell.execute_reply.started":"2024-07-31T04:20:55.838093Z","shell.execute_reply":"2024-07-31T04:20:56.779405Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}