CNN architecture for image classification in TensorFlow - Model Pipeline Trace

Model Pipeline - CNN architecture for image classification

This pipeline uses a Convolutional Neural Network (CNN) to learn patterns from images and classify them into categories. It starts with raw images, processes them through layers that detect features, trains the model to improve accuracy, and finally predicts the class of new images.

Data Flow - 9 Stages

1Input Images

1000 images x 64 x 64 x 3→Raw color images of size 64x64 pixels with 3 color channels (RGB)→1000 images x 64 x 64 x 3

Image of a cat represented as a 64x64 grid with red, green, blue values

↓

2Normalization

1000 images x 64 x 64 x 3→Scale pixel values from 0-255 to 0-1→1000 images x 64 x 64 x 3

Pixel value 128 becomes 0.5

↓

3Convolutional Layer 1

1000 images x 64 x 64 x 3→Apply 32 filters of size 3x3 to detect edges and textures→1000 images x 62 x 62 x 32

Feature map highlighting edges in the image

↓

4Max Pooling Layer 1

1000 images x 62 x 62 x 32→Reduce spatial size by taking max over 2x2 regions→1000 images x 31 x 31 x 32

Smaller feature map keeping strongest features

↓

5Convolutional Layer 2

1000 images x 31 x 31 x 32→Apply 64 filters of size 3x3 to detect more complex features→1000 images x 29 x 29 x 64

Feature map showing shapes and patterns

↓

6Max Pooling Layer 2

1000 images x 29 x 29 x 64→Reduce spatial size by 2x2 max pooling→1000 images x 14 x 14 x 64

Smaller feature map with important features

↓

7Flatten Layer

1000 images x 14 x 14 x 64→Convert 3D feature maps into 1D feature vectors→1000 images x 12544

Vector of length 12544 representing image features

↓

8Dense Layer

1000 images x 12544→Fully connected layer with 128 neurons and ReLU activation→1000 images x 128

Vector representing learned abstract features

↓

9Output Layer

1000 images x 128→Fully connected layer with 10 neurons and softmax activation for 10 classes→1000 images x 10

Probability distribution over 10 classes, e.g. [0.1, 0.05, ..., 0.6]

Training Trace - Epoch by Epoch

Loss
1.9 |*        
1.6 | **      
1.3 |  ***    
1.0 |    **** 
0.7 |      ****
0.4 |        ***
0.1 |         **
     ----------------
      1 2 3 4 5 6 7 8 9 10
      Epochs

Epoch	Loss ↓	Accuracy ↑	Observation
1	1.85	0.35	Model starts learning, loss high and accuracy low
2	1.20	0.55	Loss decreases, accuracy improves as model learns features
3	0.85	0.70	Model captures more patterns, better predictions
4	0.65	0.78	Loss continues to drop, accuracy rises steadily
5	0.50	0.83	Model converging, good balance of loss and accuracy
6	0.42	0.87	Further improvement, model generalizes well
7	0.37	0.89	Loss decreases slowly, accuracy nearing plateau
8	0.33	0.90	Model stabilizes with high accuracy
9	0.30	0.91	Minor improvements, model well trained
10	0.28	0.92	Training complete with good performance

Prediction Trace - 8 Layers

Layer 1: Input Image

Layer 2: Conv Layer 1

Layer 3: Max Pooling 1

Layer 4: Conv Layer 2

Layer 5: Max Pooling 2

Layer 6: Flatten

Layer 7: Dense Layer

Layer 8: Output Layer

Model Quiz - 3 Questions

What is the main purpose of the convolutional layers in this CNN?

A To reduce the size of the images

B To convert images into 1D vectors

C To detect features like edges and shapes in images

D To output the final class probabilities

Key Insight

This CNN model learns to recognize image features step-by-step, starting from simple edges to complex shapes, improving its predictions as training progresses. The combination of convolution, pooling, and dense layers enables effective image classification.

Practice

1. What is the main role of the Conv2D layer in a CNN for image classification?

easy

A. To reduce the size of the image by pooling

B. To decide the final class of the image

C. To flatten the image into a 1D array

D. To detect patterns like edges and shapes in small parts of the image

Solution

1. Step 1: Understand the function of Conv2D

   The Conv2D layer scans small parts of the image to find patterns such as edges and textures.

2. Step 2: Compare with other layers

   Pooling layers reduce size, flatten layers reshape data, and dense layers classify. Conv2D focuses on pattern detection.

3. Final Answer:

   To detect patterns like edges and shapes in small parts of the image -> Option D

4. Quick Check:

   Conv2D = pattern detection [OK]

Hint: Conv2D finds patterns; pooling shrinks images [OK]

Common Mistakes:

• Confusing Conv2D with pooling layers
• Thinking Conv2D flattens the image
• Believing Conv2D decides the final class

2. Which of the following is the correct way to add a MaxPooling2D layer in TensorFlow Keras?

easy

A. tf.keras.layers.MaxPooling2D(pool_size=(2, 2))

B. tf.keras.layers.MaxPooling(pool=(2, 2))

C. tf.keras.layers.MaxPool2D(size=(2, 2))

D. tf.keras.layers.Pooling2D(pool_size=2)

Solution

1. Step 1: Recall correct TensorFlow layer syntax

   The correct class name is MaxPooling2D and it uses the argument pool_size to set the window size.

2. Step 2: Check each option

   tf.keras.layers.MaxPooling2D(pool_size=(2, 2)) uses correct class and argument. Others have wrong class names or argument names.

3. Final Answer:

   tf.keras.layers.MaxPooling2D(pool_size=(2, 2)) -> Option A

4. Quick Check:

   MaxPooling2D with pool_size=(2,2) is correct [OK]

Hint: MaxPooling2D uses pool_size, not pool or size [OK]

Common Mistakes:

• Using wrong layer class names
• Using incorrect argument names like pool or size
• Omitting parentheses or tuple for pool_size

3. What will be the output shape after applying this CNN block on an input image of shape (64, 64, 3)?

model = tf.keras.Sequential([
  tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(64,64,3)),
  tf.keras.layers.MaxPooling2D(pool_size=(2,2))
])
output_shape = model.output_shape

medium

A. (None, 32, 32, 32)

B. (None, 62, 62, 32)

C. (None, 31, 31, 32)

D. (None, 64, 64, 32)

Solution

1. Step 1: Calculate Conv2D output shape

   Conv2D with kernel size 3x3 and default padding='valid' reduces each spatial dimension by 2: 64 - 3 + 1 = 62, so output shape is (62, 62, 32).

2. Step 2: Calculate MaxPooling2D output shape

   MaxPooling2D with pool size 2x2 halves each spatial dimension: 62 / 2 = 31, so output shape is (31, 31, 32).

3. Final Answer:

   (None, 31, 31, 32) -> Option C

4. Quick Check:

   Conv2D valid padding reduces size; pooling halves it [OK]

Hint: Conv2D valid padding shrinks; pooling halves size [OK]

Common Mistakes:

• Assuming padding='same' by default
• Forgetting spatial dimension reduction by Conv2D
• Misapplying pooling size effect

4. Identify the error in this CNN model code snippet:

model = tf.keras.Sequential([
  tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(28,28,1)),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Dense(10, activation='softmax')
])

medium

A. Missing Flatten layer before Dense

B. Wrong input_shape format

C. MaxPooling2D pool_size should be a tuple

D. Dense layer should have no activation

Solution

1. Step 1: Check layer order and compatibility

   Conv2D and MaxPooling2D output 3D tensors, but Dense expects 1D input.

2. Step 2: Identify missing layer

   A Flatten layer is needed to convert 3D output to 1D before Dense.

3. Final Answer:

   Missing Flatten layer before Dense -> Option A

4. Quick Check:

   Dense needs 1D input; add Flatten [OK]

Hint: Add Flatten before Dense after Conv/Pooling [OK]

Common Mistakes:

• Skipping Flatten layer before Dense
• Assuming Dense accepts 3D input
• Confusing pool_size tuple requirement

5. You want to build a CNN to classify 100x100 RGB images into 5 classes. Which architecture below is best suited for this task?

hard

A. Dense(128, relu) -> Dense(64, relu) -> Dense(5, softmax)

B. Conv2D(16, (3,3)) -> MaxPooling2D(2,2) -> Conv2D(32, (3,3)) -> MaxPooling2D(2,2) -> Flatten -> Dense(5, softmax)

C. Conv2D(64, (5,5), padding='same') -> Flatten -> Dense(5, softmax)

D. Conv2D(32, (3,3)) -> Conv2D(32, (3,3)) -> Dense(5, softmax)

Solution

1. Step 1: Analyze each architecture's suitability

   Conv2D(16, (3,3)) -> MaxPooling2D(2,2) -> Conv2D(32, (3,3)) -> MaxPooling2D(2,2) -> Flatten -> Dense(5, softmax) uses multiple Conv2D and MaxPooling layers to extract features and reduce size, then flattens before classification. This is a standard CNN design.

2. Step 2: Identify issues in other options

   Dense(128, relu) -> Dense(64, relu) -> Dense(5, softmax) uses only Dense layers, ignoring spatial info. Conv2D(64, (5,5), padding='same') -> Flatten -> Dense(5, softmax) lacks pooling, risking large feature maps. Conv2D(32, (3,3)) -> Conv2D(32, (3,3)) -> Dense(5, softmax) misses Flatten and pooling, causing shape errors.

3. Final Answer:

   Conv2D(16, (3,3)) -> MaxPooling2D(2,2) -> Conv2D(32, (3,3)) -> MaxPooling2D(2,2) -> Flatten -> Dense(5, softmax) -> Option B

4. Quick Check:

   Multiple Conv+Pooling layers + Flatten + Dense = best CNN [OK]

Hint: Use Conv + Pooling layers before Flatten and Dense [OK]

Common Mistakes:

• Using only Dense layers for images
• Skipping pooling layers
• Missing Flatten before Dense