DEV Community: Tanmay P. Tawade

🔍 Understanding Model Predictions with Grad-CAM

Tanmay P. Tawade — Wed, 19 Aug 2026 14:57:32 +0000

🧠 My Model Could Predict. But Could I Understand Why?

In my previous posts, I focused on building and improving my first CNN for brain tumor classification using MRI images.

The model could take an MRI image and predict one of four classes:

Glioma
Meningioma
Pituitary
No Tumor

But after getting the prediction, I started asking a different question:

Why did the model make this prediction?

A classification result such as:

Prediction: Glioma
Confidence: 91%

tells me what the model predicted.

It doesn't tell me which part of the MRI influenced that prediction.

That is where Grad-CAM became useful in my project.

🤔 Why Is Explainability Important?

For a normal image classification problem, seeing the predicted class might be enough for a basic demonstration.

But medical imaging is different.

If a model predicts that an MRI contains a tumor, I don't want to look only at the final class.

I also want to investigate:

Where was the model focusing?
Was it looking at a meaningful region?
Was it focusing on the suspected tumor area?
Could the model be using some irrelevant visual pattern?

This doesn't mean that an explanation automatically makes the model correct.

Instead, it gives us another way to inspect the model's behavior.

That became an important part of my project.

🔍 What Is Grad-CAM?

Grad-CAM (Gradient-weighted Class Activation Mapping) is a technique used to visualize the regions of an image that contributed to a CNN's prediction for a particular class.

Instead of only getting:

Input MRI → CNN → Prediction

we can visualize something closer to:

Input MRI
    ↓
CNN prediction
    ↓
Grad-CAM
    ↓
Important regions highlighted

The result is usually represented as a heatmap.

Regions with stronger activation are highlighted more strongly, allowing us to visually inspect where the model was focusing.

⚙️ How Grad-CAM Works — Conceptually

The mathematics behind Grad-CAM can become fairly detailed, but the basic idea is easier to understand as a sequence.

Step 1 — Give the MRI image to the CNN

The preprocessed MRI image is passed through the trained CNN.

MRI Image
    ↓
Preprocessing
    ↓
CNN

Step 2 — Get the model's prediction

The CNN produces probabilities for the different classes.

For example:

Glioma       → 0.91
Meningioma   → 0.04
Pituitary    → 0.03
No Tumor     → 0.02

The highest probability becomes the predicted class.

Step 3 — Select the target class

Grad-CAM focuses on the class we want to investigate.

For example:

Target class → Glioma

We then examine how the model's internal feature maps contributed to that class.

Step 4 — Calculate gradients

Grad-CAM uses the gradients of the target class with respect to the feature maps of a convolutional layer.

Conceptually:

Target class
     ↓
Gradients
     ↓
Feature maps

The gradients indicate how important different feature-map activations are for the selected prediction.

Step 5 — Create the heatmap

The feature maps are combined using their importance weights to produce a coarse spatial heatmap.

Feature Maps
      +
Gradient Weights
      ↓
Grad-CAM Heatmap

Step 6 — Overlay the heatmap

Finally, the heatmap can be resized and overlaid on the original MRI.

This gives us a visual representation of the regions that were important to the model's prediction.

🧩 The Complete Grad-CAM Pipeline

Here is the complete process I used conceptually in my project:

The important thing to remember is that Grad-CAM comes after the model has already learned and made a prediction.

It doesn't change the prediction.

It helps us investigate it.

🧠 Grad-CAM in My Brain MRI Project

I applied Grad-CAM to my trained CNN to visualize the regions that contributed to its predictions.

The basic workflow was:

MRI Image
    ↓
Preprocessing
    ↓
Trained CNN
    ↓
Predicted Class
    ↓
Gradients of Target Class
    ↓
Feature Maps
    ↓
Grad-CAM Heatmap
    ↓
Overlay on MRI

This allowed me to move from simply looking at the prediction to actually inspecting the model's focus.

🔬 Grad-CAM in Action

The following example shows the idea more clearly.

The original MRI is passed through the model.

The model produces a prediction, and Grad-CAM generates a heatmap showing the regions associated with that prediction.

The final overlay makes the explanation easier to interpret visually.

One important detail:

The highlighted region represents where the model was focusing for that prediction. It should not be interpreted as an exact tumor boundary.

This distinction is especially important in medical imaging.

🖼️ Example 1 — No-Tumor Prediction

Here is an example where the model predicted a no-tumor image.

The heatmap provides a visual indication of the regions that contributed to the prediction.

But it is important not to assume that every highlighted pixel has a direct medical meaning.

Grad-CAM is showing the model's learned visual associations—not a medically validated segmentation mask.

🧠 Example 2 — Tumor Prediction

Now consider an MRI containing a visible tumor region.

In this example, the strongest activation is around the visible abnormal region.

That is interesting because it suggests that the model was focusing on a region that appears relevant to the classification.

However, this should still be treated as model interpretation, not proof that the model has correctly identified the tumor.

That distinction matters.

💡 Why Explainability Matters

This changed how I looked at my CNN project.

Before using Grad-CAM, I mainly focused on:

Accuracy
Precision
Recall
F1-score
Prediction

After exploring explainability, I also started asking:

What is the model looking at?
Why might it be making this prediction?
Is the model focusing on a meaningful region?

Grad-CAM doesn't make a model automatically trustworthy.

Instead, it gives us another tool for examining model behavior and identifying potential problems.

⚠️ What Grad-CAM Can and Cannot Tell Us

This was probably the most important thing I learned.

✅ Grad-CAM can help us:

Visualize important regions for a prediction
Inspect what the CNN appears to focus on
Identify potentially suspicious model behavior
Compare model attention across different images
Make CNN predictions easier to investigate

❌ Grad-CAM cannot guarantee:

That the prediction is correct
That the highlighted region is the exact tumor boundary
That the model understands the medical meaning of the highlighted area
That the model is clinically reliable
That the explanation itself proves causation

In other words:

A heatmap is an explanation of model behavior, not a medical diagnosis.

🧪 What I Learned From Implementing Grad-CAM

Implementing Grad-CAM taught me something beyond the technique itself.

Earlier, I thought machine learning was mainly about improving metrics.

Now I see another important side:

Understanding why a model behaves the way it does is also part of building a good ML system.

The process also made me more careful about how I interpret model results.

A high-confidence prediction can still be wrong.

And a visually convincing heatmap does not automatically mean the model has learned the correct reasoning.

🧠 From Building a CNN to Understanding It

This four-part learning journey changed how I approached my first CNN project.

Part 1 — Building my first CNN

I learned what changes when CNN theory becomes actual code.

Part 2 — Mistakes

I learned that good-looking accuracy doesn't necessarily mean good model performance.

Part 3 — Building the model

I understood the basic workflow from preprocessing to training and evaluation.

Part 4 — Grad-CAM

I learned to look beyond the prediction and investigate where the model was focusing.

The bigger lesson for me was:

Building the model is only one part of machine learning. Understanding its behavior is another.

🚀 What's Next?

This project started as an academic exercise to understand CNN-based image classification.

It gradually became an opportunity to explore:

Data preprocessing
CNN architecture
Model evaluation
Multi-class classification
Explainable AI
Responsible interpretation of AI predictions

There is still a lot I want to improve, especially around model evaluation, dataset quality, explainability techniques, and making the overall system more robust.

🔗 Explore the Project

The complete implementation is available on GitHub:

👉 GitHub Repository

I also deployed a working demonstration using Streamlit:

👉 Live Streamlit Demo

The project includes the CNN-based classification workflow along with Grad-CAM-based visualization for model interpretation.

Important: This project is an academic decision-support prototype for learning and experimentation. It is not intended to replace professional medical diagnosis or clinical decision-making.

💬 Final Thought

My biggest takeaway from this project wasn't simply:

"I built a CNN."

It was:

"I started learning how to question what my model was doing."

That shift—from getting a prediction to investigating the prediction—was one of the most valuable things I learned while building this project.

👨🏻‍💻 Let's Connect

I'm continuing to learn and build projects around Java, web development, machine learning, and AI/ML.

If you're also learning CNNs, computer vision, or explainable AI, I'd be happy to hear about your experience.

What was the first thing you used to understand what your ML model was actually learning?

Let's connect and learn together. 🚀

👨🏻‍💻 About Me

I'm Tanmay P. Tawade, a Full Stack Developer focused on Java and web development, with an interest in AI/ML and practical software projects.

I write about what I learn while building projects, experimenting with technologies, and turning concepts into working software.

🔗 GitHub

🌐 Portfolio

💼 LinkedIn

⚙️ How I Built My First CNN for Brain Tumor Classification

Tanmay P. Tawade — Sun, 16 Aug 2026 05:49:20 +0000

🧠 From "I Know CNNs" to Actually Building One

In my previous two posts, I talked about what I learned and the mistakes I made while working on my first CNN project.

Now I want to show what I actually built.

The project is an MRI-based brain tumor detection and classification system using a custom Convolutional Neural Network (CNN).

The model classifies MRI images into four categories:

Glioma
Meningioma
Pituitary
No Tumor

The project also integrates Grad-CAM to visualize which regions of an MRI contributed most to a prediction.

The final system was then wrapped in a Streamlit web application so that the trained model could be used through an interactive interface.

This post focuses on the implementation pipeline rather than explaining CNN theory from scratch.

🗺️ The Overall Pipeline

The system can be thought of as a sequence:

MRI Image

↓

Image Preprocessing

↓

CNN Classification

↓

Softmax Probability Distribution

↓

Prediction + Confidence Analysis

↓

Grad-CAM Visualization

↓

Report Generation

↓

Streamlit Interface

This pipeline helped me understand that a machine learning project is much more than the model itself.

The model is one component inside a larger system.

📊 Step 1 — Understanding the Dataset

The project uses a publicly available brain MRI dataset containing four categories:

Class	Category
🧠	Glioma
🧠	Meningioma
🧠	Pituitary
🧠	No Tumor

Before training, the images were organized into training and testing data while maintaining class representation.

One of the lessons from my previous post became important here:

Don't start with the CNN. Start with the data.

Understanding the labels, class distribution, image quality, and visual characteristics of the dataset gave me a much better starting point.

🖼️ Step 2 — Preprocessing the MRI Images

Raw images are not automatically ready to be passed into a CNN.

The project uses a preprocessing pipeline to make the input more consistent.

The main steps are:

RGB image conversion
Brain region extraction
Contrast enhancement
Gaussian noise reduction
Image resizing
Pixel normalization

The final input size used by the model is:

224 × 224 pixels

The purpose wasn't to make the images "perfect."

It was to provide the model with a more consistent representation of the input data.

🔍 Why Preprocessing Matters

This was another area where implementation changed my understanding.

I initially thought of preprocessing as simply:

"Resize the image and normalize it."

But in an image-classification project, preprocessing can influence what information the model actually sees.

For this project, I wanted to reduce irrelevant variation while preserving useful visual information.

The preprocessing pipeline therefore became an important part of the overall model design.

🧠 Step 3 — Building the CNN

For the classification model, I used a custom CNN architecture.

The main components are:

Convolutional layers
ReLU activation
Max pooling
Dropout regularization
Fully connected dense layers
Softmax output layer

The basic idea is:

Input Image

↓

Convolution

↓

Feature Extraction

↓

Pooling

↓

Deeper Feature Extraction

↓

Dense Layers

↓

Softmax

↓

4-Class Prediction

The earlier convolutional layers learn lower-level visual patterns, while deeper layers can combine those patterns into more complex representations.

The final softmax layer produces probabilities across the four classes.

🔢 Step 4 — Why Softmax?

Because this is a four-class classification problem, the model needs to produce a probability distribution across all four possible classes.

For example, an output might look conceptually like:

Glioma       → 0.02
Meningioma   → 0.91
Pituitary    → 0.04
No Tumor     → 0.03

The class with the highest predicted probability becomes the model's predicted class.

But this is where I had to remember something from Part 2:

A high probability is not the same thing as certainty.

The probability output is useful for understanding the model's prediction, but it should always be interpreted in the context of the model's evaluation and limitations.

🧪 Step 5 — Training the Model

Once the preprocessing pipeline and CNN architecture were ready, the next step was training.

This is where the earlier mistakes started becoming useful.

Instead of treating training as:

Run → Get Accuracy → Done

I started paying attention to what was happening during training.

I looked at:

Training loss
Validation loss
Training accuracy
Validation accuracy
Precision
Recall
F1-score
Confusion matrix
Changes in performance across experiments

🔄 Training Wasn't Just "Press Run"

One of the biggest changes in my approach was that I stopped treating training as a single event.

A typical experiment became:

Choose configuration

↓

Train the model

↓

Monitor training and validation behavior

↓

Evaluate the results

↓

Identify problems

↓

Modify the configuration

↓

Train again

This made the process much more iterative.

For example, if training performance continued improving while validation performance stopped improving, that raised a question about overfitting.

Instead of simply celebrating the higher training accuracy, I had to look at what was happening on data the model wasn't directly learning from.

⚙️ What I Experimented With

During development, I experimented with model configuration and training choices such as:

Model architecture
Learning rate
Number of epochs
Batch size
Regularization
Data preprocessing

The important lesson wasn't that one particular value was "correct."

It was that these choices should be treated as experiments rather than magic numbers.

I wanted to understand:

What am I changing?

Why am I changing it?

What effect should I expect?

Did the result actually improve?

That mindset made training much more meaningful than simply trying different values until the accuracy increased.

📈 Step 6 — Evaluating the Model

The final evaluation wasn't based on accuracy alone.

The project evaluates the model using:

Accuracy
Precision
Recall
F1-score
Confusion matrix
Softmax probability distribution

The current project documentation reports an overall classification accuracy of approximately 91%.

But the number I found more interesting was not the accuracy itself.

It was being able to look at the model from multiple perspectives.

For example:

Which classes are being confused?

Is the model performing consistently across classes?

Are the predictions supported by reasonable confidence values?

Those questions provide much more context than a single accuracy number.

📊 Looking Beyond Accuracy

For a multi-class classifier, the confusion matrix can reveal patterns that overall accuracy hides.

For example, if the model correctly identifies most images from one class but frequently confuses another class with a similar category, the overall accuracy may not immediately communicate how important that problem is.

This connected directly to the lesson from Part 2:

A model should be evaluated by how it behaves across classes, not just by one overall number.

🔥 Step 7 — Adding Grad-CAM

After getting the classifier working, I wanted to answer another question:

What part of the MRI is influencing the prediction?

This is where Grad-CAM (Gradient-weighted Class Activation Mapping) became part of the project.

Grad-CAM generates a heatmap showing image regions that contribute most to the model's prediction.

The workflow becomes:

MRI Image

↓

CNN Prediction

↓

Target Class

↓

Grad-CAM

↓

Heatmap

This doesn't give me an exact tumor segmentation.

Instead, it provides a visual way to inspect the regions that were influential for the model's prediction.

That distinction is important.

Grad-CAM helps interpret model behavior; it does not prove that the highlighted region is the tumor.

🧩 Step 8 — Turning the Model Into an Application

A trained model sitting inside a notebook isn't very useful to someone who wants to interact with it.

So I built a Streamlit application around the model.

The application allows a user to:

Upload an MRI image
Run the trained CNN
View the predicted class
Inspect confidence and probability information
Generate a Grad-CAM visualization
Generate a downloadable PDF report

The application therefore connects the machine learning pipeline to an actual user interface.

This was an important step for me because it changed the project from:

"I trained a model."

into:

"I built an application around a trained model."

🌐 The Final Workflow

The complete system looks like this:

              MRI Image
                  │
                  ▼
          Image Preprocessing
                  │
                  ▼
            Custom CNN
                  │
                  ▼
        Softmax Probabilities
                  │
          ┌───────┴───────┐
          ▼               ▼
     Prediction      Confidence
          │               │
          └───────┬───────┘
                  ▼
              Grad-CAM
                  │
                  ▼
          Visual Explanation
                  │
                  ▼
            PDF Report

This was one of the most important things I learned from the project:

Building the model is only one part of building a machine learning application.

📂 How I Structured the Project

I also tried to keep the project separated into meaningful components rather than putting everything into one Python file.

The repository currently has areas for:

Explainable-Brain-Tumor-Detection/
│
├── assets/
├── dataset/
├── docs/
├── model/
├── utils/
│   ├── gradcam.py
│   ├── preprocess.py
│   └── report.py
│
├── app.py
├── requirements.txt
└── README.md

The separation helped me understand the difference between:

Model loading
Preprocessing
Explainability
Report generation
Application logic

That became increasingly important as the project grew.

🧠 What I Learned From Building the Entire Pipeline

After completing the project, I don't think the biggest lesson was:

"I know how to build a CNN."

It was more like:

"I understand how many different pieces have to work together for a CNN project to become an actual application."

I learned about:

Data

How important it is to understand and prepare the dataset before training.

Models

How architecture decisions affect what the network can learn.

Training

How training is an iterative process rather than simply running a model once and checking the accuracy.

Evaluation

Why accuracy alone isn't enough.

Explainability

How Grad-CAM can help inspect model behavior.

Deployment

How a trained model can be turned into an interactive application.

Engineering

How project structure becomes important once the codebase grows.

⚠️ Important Limitations

This project is an academic and learning project, not a clinical diagnostic system.

There are several limitations.

The model was trained on a limited publicly available dataset, so its performance may not generalize to real-world clinical data.

Performance can also depend on MRI image quality and differences between datasets.

Grad-CAM provides an interpretation of influential regions, but it is not a precise tumor segmentation method.

For these reasons, the application should not be used as a substitute for professional medical diagnosis.

These limitations are part of the project itself, not something I want to hide behind the model's accuracy.

🚀 What I Would Improve Next

If I continued developing this system, some areas I'd explore are:

Larger and more diverse datasets
Transfer learning with stronger architectures
More rigorous validation
3D MRI analysis
Tumor segmentation
Multi-modal MRI support
Better inference performance
More robust deployment architecture

The goal would not simply be to make the model bigger.

It would be to make the entire system more reliable, interpretable, and generalizable.

🔗 Try the Project

The complete implementation is available on GitHub:

👉 GitHub Repository

You can also try the deployed Streamlit application:

👉 Live Demo — Streamlit

Note: This application is intended for educational and research purposes only. It is not a medical diagnostic tool.

🔗 Part of My CNN Learning Series

This is the third post in my CNN learning series.

🧠 Part 1 — What My First CNN Project Taught Me

Read Part 1 →

⚠️ Part 2 — 5 Mistakes I Made in My First CNN Project

Read Part 2 →

⚙️ Part 3 — How I Built the CNN Model

You're reading this one.

🔍 Part 4 — Understanding Model Predictions with Grad-CAM

Coming next.

👋 Let's Connect

I'm continuing to learn by building practical software and machine learning projects.

If you're interested in CNNs, computer vision, deep learning, or building ML applications, I'd be happy to hear what you're working on.

🌐 Portfolio

💻 GitHub

💼 LinkedIn

🚀 5 Mistakes I Made in My First CNN Project (That Ruined My Results)

Tanmay P. Tawade — Mon, 23 Mar 2026 13:48:43 +0000

🚀 5 Mistakes I Made in My First CNN Project

machinelearning #deeplearning #cnn #ai

😅 I Thought My Model Was Working... Until I Looked Closer

When I built my first CNN model for brain tumor classification using MRI images, I initially felt pretty confident.

The code was running.

The model was training.

The accuracy looked reasonable.

And predictions were being generated.

The model was classifying images into:

Glioma
Meningioma
Pituitary
No Tumor

So I assumed everything was working.

Then I started looking beyond the overall accuracy.

That's when I realized:

A model can appear to work while still having important problems underneath.

Here are five mistakes that taught me more than simply getting the model to train.

❌ Mistake 1: Not Understanding Class Distribution

One of the first things I should have checked more carefully was the distribution of images across the four classes.

I should have asked:

How many images are available for each class?
Are the classes reasonably balanced?
Are some classes significantly underrepresented?
Could class distribution affect the metrics I'm seeing?

Instead, I focused on getting the CNN running.

What I learned

If one class has substantially more samples than another, overall accuracy may not tell the complete story.

A model can perform well overall while performing poorly on a less represented class.

Lesson

Understand the distribution of your data before interpreting your model's performance.

❌ Mistake 2: Increasing Model Complexity Without a Clear Reason

I initially had a simple assumption:

"More layers should give the model more ability to distinguish all four classes."

So I experimented with increasing the model's complexity.

The problem wasn't experimenting.

The problem was adding complexity without a clear hypothesis about what I was trying to improve.

What I observed

Training performance improved
Validation performance did not improve accordingly
The gap between training and validation became more noticeable

That was a sign that the model could fit the training data better without necessarily generalizing better.

Lesson

A more complex model isn't automatically a better model.

Architecture changes should have a reason behind them.

❌ Mistake 3: Trusting Overall Accuracy Too Much

This was probably one of my biggest mistakes.

When I saw a decent overall accuracy, my first reaction was:

"The model is working well."

But I wasn't asking enough questions about how that accuracy was achieved.

I needed to look at things such as:

Class-wise performance
Confusion matrix
Precision
Recall
F1-score
Which classes were being confused

For example, the model showed confusion between some of the tumor categories.

That made me realize that:

Overall accuracy is only one view of model performance.

Lesson

For a multi-class classification problem, don't stop at:

"What percentage did the model get correct?"

Also ask:

"Which classes is the model getting wrong, and how often?"

❌ Mistake 4: Choosing Hyperparameters Without Understanding Them

Another mistake was treating hyperparameters almost like fixed values that could simply be copied from another implementation.

I experimented with things such as:

Learning rate
Batch size
Number of epochs
Model architecture

But initially, I didn't understand enough about why I was choosing those values.

What changed

I started treating each experiment as something I should be able to explain.

Instead of:

"This configuration worked for someone else, so I'll use it."

I started thinking:

"What am I changing, why am I changing it, and what effect should I expect?"

Lesson

Don't copy hyperparameters blindly. Understand what you're changing and evaluate the result.

There isn't one universally correct learning rate, batch size, or number of epochs for every CNN project.

❌ Mistake 5: Not Visualizing the MRI Data Early Enough

This sounds simple, but it was one of the most useful lessons.

I should have spent more time looking at the actual images before focusing on the model.

I wanted the CNN to discover the patterns.

But first, I needed to understand the data myself.

I started looking more closely at:

Differences between classes
Image quality
Visual patterns
Tumor locations
Similarities between categories

🧠 What I Should Have Observed Earlier

Some categories can contain visually similar patterns.

That doesn't mean a human can simply look at an MRI and make the correct classification.

It means that the visual characteristics of the dataset matter when you're trying to understand where a model may struggle.

Lesson

Visualize your data before asking your model to learn from it.

🧠 What Changed After These Mistakes

The biggest change wasn't one particular model architecture.

It was my approach to experimentation.

I started doing more of this:

Understand → Experiment → Evaluate → Question → Improve

Instead of:

Build → Train → Check Accuracy → Done

I became more interested in questions like:

Why did validation performance change?
Which class is causing the problem?
Is the model overfitting?
Did the preprocessing actually help?
Did the architectural change improve generalization?
What does the confusion matrix tell me that accuracy doesn't?

🎯 My Biggest Takeaway

Multi-class classification isn't simply:

"Binary classification + more classes."

Each additional class introduces more opportunities for confusion and makes evaluation more important.

And perhaps the most useful lesson from this project was:

A model doesn't become reliable just because it trains successfully.

Training is only the beginning.

🔗 Part of My CNN Learning Series

This is the second post in my CNN learning series.

🧠 Part 1 — What My First CNN Project Taught Me

Read Part 1 →

⚠️ Part 2 — 5 Mistakes I Made in My First CNN Project

You're reading this one.

⚙️ Part 3 — How I Built the CNN Model

Coming next.

🔍 Part 4 — Understanding Model Predictions with Grad-CAM

Coming later.

🔗 Project Reference

The project discussed in this article is part of my brain tumor detection and classification project.

👉 GitHub Repository

👉 Live Demo — Streamlit

The project includes:

MRI image preprocessing
CNN-based classification
Binary and multi-class experiments
Model evaluation
Grad-CAM explainability
Streamlit interface

Note: This project is an academic/learning project and is not intended to replace professional medical diagnosis.

👋 Let's Connect

I'm continuing to learn machine learning by building practical projects and documenting what I learn along the way.

If you're also working with CNNs, computer vision, or deep learning, I'd be interested to hear about your experience.

🌐 Portfolio

💻 GitHub

💼 LinkedIn

Thanks for Reading!

🚀 What My First CNN Project Taught Me About Brain Tumor Detection

Tanmay P. Tawade — Fri, 16 Jan 2026 11:25:22 +0000

🧠 From Theory to Actually Building a CNN

My first real experience with a Convolutional Neural Network (CNN) came through a brain tumor detection and classification project using MRI images.

I had already studied the theory.

I knew what convolution, pooling, activation functions, epochs, loss, and accuracy meant.

At least, I thought I did.

Once I started implementing the model, I realized that understanding a concept theoretically and understanding how it behaves in a real project are two very different things.

This isn't a CNN tutorial.

Instead, I want to share some of the things that confused me, the mistakes I made, and what changed in my understanding after actually building the project.

🤔 Why I Chose This Project

I wanted a project that was:

Academically meaningful
Related to deep learning
Practical enough to connect theory with a real problem
Challenging enough to make me learn beyond the classroom

Medical image analysis stood out to me because it combines computer vision, deep learning, and a problem where model evaluation and interpretability matter.

That made it a good learning problem.

📊 The Dataset Was More Important Than I Expected

One of my first mistakes was focusing on the model before fully understanding the dataset.

I should have asked:

What exactly do the labels represent?
How many samples are available for each class?
Are the classes balanced?
How were the images collected?
Are the images already preprocessed?
Could there be differences between the training and evaluation data?

Instead, I was initially more interested in getting the CNN running.

That created problems later.

My biggest dataset lesson:

Before building the model, understand the data you're giving it.

A sophisticated model cannot compensate for poorly understood data.

🖼️ Looking at the Images Changed My Perspective

Visualizing sample MRI images before training might seem obvious now.

But doing it made me realize how much information can be missed when you immediately jump into code.

Even a basic inspection helped me think about:

Image dimensions
Visual differences between classes
Background information
Image quality
Preprocessing requirements
Possible sources of variation

That made the dataset feel less like a folder of files and more like actual data that needed to be understood.

⚙️ CNNs Made More Sense Once I Implemented One

I had studied CNN architecture before.

But implementing one changed how I thought about it.

I started understanding that:

Convolution layers learn spatial features from images
Pooling layers reduce spatial dimensions and can help make representations more compact
Activation functions introduce non-linearity
The architecture affects what patterns the model can learn
Adding more layers does not automatically mean better performance

One of my biggest realizations was:

Small architectural changes can have a noticeable effect on model behavior.

Reading about CNNs gave me the terminology.

Building one gave those concepts context.

🧩 A Simple CNN Structure

The diagrams made something that initially felt abstract much easier to reason about.

⚠️ The Part That Actually Challenged Me

Getting the model to train wasn't the difficult part.

Understanding whether it was actually learning something useful was.

Some of the challenges I encountered included:

Overfitting
Interpreting validation results
Choosing hyperparameters
Understanding why performance changed between experiments
Figuring out whether a change actually improved the model

At one point, I genuinely thought:

"If the accuracy is high, the model must be good."

That turned out to be an incomplete way of looking at model performance.

Accuracy is useful, but it doesn't tell the whole story.

Depending on the dataset and problem, metrics such as precision, recall, F1-score, confusion matrices, and ROC-AUC can provide additional information about model behavior.

That was an important shift in how I evaluated my experiments.

🔍 Why Explainability Became Important

As I worked more with the project, another question became interesting to me:

Why is the model making this prediction?

For an image classification model, getting a class prediction is only part of the story.

I started exploring Grad-CAM to visualize which regions of an image were contributing to a model's prediction.

This was particularly interesting in the context of medical imaging because it gave me a way to inspect the model's spatial focus instead of looking only at the final classification output.

🧠 Model Interpretation Example

Here are examples from my experiments:

The heatmaps made the predictions more interesting to investigate because I could visually examine which regions were highlighted by the model.

But this also taught me an important lesson:

An explanation visualization is a tool for interpreting model behavior, not proof that the model is correct.

That distinction is important, especially for sensitive applications such as medical imaging.

📈 What This Project Actually Taught Me

The biggest lessons weren't specific to CNNs.

They were about the process of building machine learning systems.

1. Machine learning is iterative

My first approach wasn't my final approach.

Training, evaluating, changing, and testing again became part of the process.

2. Debugging is part of learning

When something doesn't work, reading logs, checking inputs, inspecting outputs, and questioning assumptions are often more valuable than immediately searching for a solution.

3. Data deserves as much attention as the model

A model is only learning from the data you provide.

Understanding that data should come before obsessing over architecture.

4. Metrics need context

A single number doesn't completely describe model performance.

5. Implementation exposes gaps in understanding

I could explain CNN concepts on paper.

But building one showed me exactly which parts I actually understood and which parts I had only memorized.

And probably the biggest lesson was:

Copying a solution is easy. Understanding why it works is the real learning.

🔧 What I Want to Improve Next

This project also showed me where I need to improve.

My next areas of focus are:

Better evaluation and experiment tracking
Stronger understanding of model architecture
More rigorous dataset analysis
Improved project structure
Deeper exploration of explainable AI
Better understanding of how models behave outside controlled experiments

The goal isn't just to make the model produce a better number.

It's to understand why the system behaves the way it does.

🔗 Project Reference

You can explore the complete implementation and documentation here:

👉 GitHub Repository

You can also try the deployed Streamlit application:

👉 Live Demo - Streamlit

The repository includes:

CNN model implementation
MRI image preprocessing
Model evaluation
Grad-CAM explainability
Experimentation and results
Streamlit application

💬 Final Thought

This was one of those projects where I started with:

"I know how CNNs work."

and ended with:

"I understand how much more there is to learn."

And honestly, I think that's a good outcome.

Building the project exposed the gap between knowing a concept and being able to reason about it when things don't go as expected.

That's probably one of the most valuable things I've learned from working on machine learning projects.

If you've built your first CNN or machine learning project, what was the first thing that made more sense only after you actually implemented it?

👋 Let's Connect

I'm continuing to explore machine learning by building practical projects and sharing what I learn along the way.

If you're also learning CNNs, computer vision, or deep learning, feel free to connect or share what you're working on.

🌐 Portfolio

💻 GitHub

💼 LinkedIn

Thanks for reading!