Deep Learning Notes — Building a Convolutional Neural Network

import gzip
import numpy as np


def read_mnist(images_path, labels_path):
    with gzip.open("MNIST_data/" + labels_path, "rb") as labelsFile:
        y = np.frombuffer(labelsFile.read(), dtype=np.uint8, offset=8)

    with gzip.open("MNIST_data/" + images_path, "rb") as imagesFile:
        X = (
            np.frombuffer(imagesFile.read(), dtype=np.uint8, offset=16)
            .reshape(len(y), 784)
            .reshape(len(y), 28, 28, 1)
        )

    return X, y


train = {}
test = {}

train["X"], train["y"] = read_mnist(
    "train-images-idx3-ubyte.gz", "train-labels-idx1-ubyte.gz"
)
test["X"], test["y"] = read_mnist(
    "t10k-images-idx3-ubyte.gz", "t10k-labels-idx1-ubyte.gz"
)

train["X"].shape, train["y"].shape, test["X"].shape, test["y"].shape

((60000, 28, 28, 1), (60000,), (10000, 28, 28, 1), (10000,))

# gzip.open is a Python function for handling gzip-compressed files:

# Opens a gzip-compressed file and supports read/write operations.
# When reading, it automatically decompresses the content; when writing, it automatically compresses with gzip.
# Parameters are similar to open, with mode specifying the operation mode (e.g., "rb" for binary read).
# Commonly used for compressed log files or data archives.

# # --------------------------------------------------------------------

# The with statement in Python is used for context management of resources, ensuring they are acquired and released correctly:

# Simplifies resource management: automatically handles acquisition and release.
# Improves readability: makes code clearer and more concise.
# Guarantees resource cleanup: even if an exception occurs, resources are properly closed or released.
# The with statement is commonly used for file operations, database connections, network connections, and similar cases. The as keyword creates a temporary variable for the resource inside the block. For example:

# with open('file.txt', 'r') as file:
#     content = file.read()
    
# In this example, file represents the opened file object inside the with block. After the block finishes, the file is automatically closed.

# # --------------------------------------------------------------------

# labelsFile.read() reads the entire contents of the label file and returns a byte string (bytes type). Specifically:

# Read content: the read() method reads the entire file and returns a byte string.
# Byte string: this byte string contains all byte data in the file.
# In your code, np.frombuffer() converts this byte string into a NumPy array, where:

# dtype=np.uint8 specifies each element as an unsigned 8-bit integer.
# offset=8 skips the first 8 bytes (usually file header information).
# Therefore, labelsFile.read() reads all byte data from the label file, which is then parsed into a label array via np.frombuffer.

# # --------------------------------------------------------------------

# What reshape does:
# reshape is a NumPy method for changing array shape. Its role is as follows:

# Change shape: reshape the array to a specified new shape without changing the underlying data.
# Parameter explanation:
# First parameter len(y): specifies the size of the first dimension of the new array, i.e., the number of samples.
# Second parameter 784: specifies the size of the second dimension, flattening each sample into 784 pixels.
# Specifically, in this code:

# X is a one-dimensional array containing all image data.
# reshape(len(y), 784) converts X into a 2D array with shape (number of samples, 784).
# This step converts the original 1D array into a form where each sample corresponds to 784 pixels, making later processing easier.

# # --------------------------------------------------------------------

# train["X"] is a way to access a Python dictionary.

# Explanation
# train: a dictionary variable.
# "X": a key in the dictionary.
# This syntax accesses the value corresponding to the key "X" in the dictionary.

from matplotlib import pyplot as plt

%matplotlib inline

plt.imshow(train["X"][0].reshape(28, 28), cmap=plt.cm.gray_r)

# ---------------
# Display plots inline in Jupyter Notebook.
# Get the image data of the first sample from the training set train.
# Reshape the 1D array into a 28x28 2D image.
# Display the image using a grayscale colormap.

# Sample padding
X_train = np.pad(train["X"], ((0, 0), (2, 2), (2, 2), (0, 0)), "constant")
X_test = np.pad(test["X"], ((0, 0), (2, 2), (2, 2), (0, 0)), "constant")
# One-hot encoding for labels
y_train = np.eye(10)[train["y"].reshape(-1)]
y_test = np.eye(10)[test["y"].reshape(-1)]

X_train.shape, X_test.shape, y_train.shape, y_test.shape

# -------Explanation-----------
# np.pad is a NumPy method for padding array edges. Specifically:

# Parameters:

# array: the array to pad.
# pad_width: a tuple or iterable specifying padding width on each axis. Format: ((before_1, after_1), ... (before_N, after_N)), where N is the number of dimensions.
# mode: padding mode, e.g., "constant" means fill with a constant value.
# Other parameters vary depending on the mode.
# Purpose:

# Add extra data around array edges in the specified way, changing the array size.
# For example, np.pad(array, ((1, 2), (2, 1)), "constant") adds 1 column before and 2 columns after on the first dimension, and 2 rows before and 1 row after on the second dimension, filling the new regions with constant values.

# # -----------
# np.eye is a NumPy function for creating an identity matrix. Specifically:

# Parameters:

# N: size of the identity matrix (usually rows and columns).
# Optional parameter k: diagonal position, default 0 (main diagonal).
# Return value:

# An N×N identity matrix with 1s on the main diagonal and 0s elsewhere.

import tensorflow as tf

model = tf.keras.Sequential()  # Build a sequential model

# Convolutional layer: 6 5x5 kernels, stride 1, ReLU activation; first layer must specify input_shape
model.add(
    tf.keras.layers.Conv2D(
        filters=6,
        kernel_size=(5, 5),
        strides=(1, 1),
        activation="relu",
        input_shape=(32, 32, 1),
    )
)
# Average pooling with default pool size 2
model.add(tf.keras.layers.AveragePooling2D(pool_size=(2, 2), strides=2))
# Convolutional layer: 16 5x5 kernels, stride 1, ReLU activation
model.add(
    tf.keras.layers.Conv2D(
        filters=16, kernel_size=(5, 5), strides=(1, 1), activation="relu"
    )
)
# Average pooling with default pool size 2
model.add(tf.keras.layers.AveragePooling2D(pool_size=(2, 2), strides=2))
# Must flatten before connecting to fully connected layers
model.add(tf.keras.layers.Flatten())
# Fully connected layer, output 120, ReLU activation
model.add(tf.keras.layers.Dense(units=120, activation="relu"))
# Fully connected layer, output 84, ReLU activation
model.add(tf.keras.layers.Dense(units=84, activation="relu"))
# Fully connected layer, output 10, Softmax activation
model.add(tf.keras.layers.Dense(units=10, activation="softmax"))
# View network structure
model.summary()

# This Python snippet uses TensorFlow to build part of a neural network model:

# Create a sequential model named model.
# Add a convolutional layer: 6 kernels of size 5x5, stride 1, ReLU activation, input shape (32, 32, 1).

# -----

# Why use 6 convolution kernels?
# From the LeNet network diagram, its first convolutional layer uses 6 kernels.

# -----

# tf.keras.layers.Flatten() does the following:

# Converts a multi-dimensional input tensor into a 1D vector.
# Connects convolutional layers (or other multi-dimensional outputs) to flat fully connected (Dense) layers.
# Preserves all pixel information while changing only the data shape for downstream Dense layers.

# -----

# tf.keras.layers.Dense does the following:

# Implements a fully connected layer.
# units=120 means the output dimension is 120.
# activation="relu" uses the ReLU activation function to introduce nonlinearity and help the model learn more complex patterns.