How to Use EigenCAM for YOLOv5 Object Detection

Last Updated on 20/11/2025 by Eran Feit

Understanding EigenCAM in Deep Learning

EigenCAM is a visualization technique that helps you see where a neural network is focusing when it makes a decision. Instead of treating a deep model as a black box, EigenCAM uses the internal activations of a convolutional neural network (CNN) to create a heatmap that highlights the most influential regions in the input image. These heatmaps are overlaid on the original image and make it much easier to interpret why the model predicted a certain object or responded to a specific area.

Unlike traditional gradient-based methods, EigenCAM works directly on the feature maps without relying on backpropagated gradients. It uses a principal component analysis (PCA) over the activations to extract the most dominant patterns in a given layer. The resulting component is reshaped into a two-dimensional map and visualized as a heatmap. This makes EigenCAM robust, relatively simple to apply, and suitable even when computing gradients is difficult or unstable.

EigenCAM is particularly useful in applications where explainability matters just as much as accuracy. In fields like medical imaging, autonomous driving, or financial document analysis, it is crucial to understand not only that the model detected something, but also where it looked and how confident it was in different regions. By applying EigenCAM to intermediate layers, you can quickly see whether the network is attending to meaningful parts of the image or being misled by background noise and artifacts.

Because EigenCAM is model-agnostic at the architecture level, it integrates well with modern object detection models such as YOLOv5. You can keep your original model intact, run normal inference to get bounding boxes and class labels, and then use EigenCAM on selected layers to generate heatmaps over the same input image. The combination of precise detections and intuitive visual explanations turns EigenCAM into a powerful tool for debugging, teaching, and building trust in computer vision systems.

If you are just starting with detections, you might first enjoy my YOLOv5 object detection tutorial in 15 minutes and then come back here to see how EigenCAM explains those predictions.

How EigenCAM Fits into YOLOv5 Object Detection

When you combine EigenCAM with YOLOv5 object detection, you get both bounding boxes and an explanation of why those boxes exist in the first place. YOLOv5 is designed to be fast and accurate, predicting multiple objects in a single forward pass. EigenCAM adds an extra interpretability layer on top of this pipeline by showing which regions in the image contribute most to the internal feature representations that drive those predictions. The result is an image where you can see both the detected objects and the underlying attention patterns that guided the model.

In practice, the workflow starts by loading a pretrained YOLOv5 model and running inference on an input image, such as a photo of cows in a field. YOLOv5 outputs bounding boxes, class labels, and confidences for each detected object. At the same time, you choose a target layer near the end of the network, where the feature maps still retain spatial structure but already encode high-level semantic information. EigenCAM then processes the activations of that layer, performs PCA, and produces a heatmap that reflects the most dominant activation pattern over the whole image.

Overlaying this EigenCAM heatmap on the original image makes the detection results feel much more transparent. You can check whether the model focuses on the actual objects inside the bounding boxes, or if it is influenced by irrelevant areas such as shadows, textures, or background structures. If you see that the heatmap aligns well with the objects, it increases your confidence that YOLOv5 is learning meaningful features. If it does not, the visualization can point you toward labeling issues, dataset biases, or architectural limitations.

This approach is also extremely helpful when you are tuning thresholds, augmentations, or training strategies. For example, if the model consistently highlights the wrong regions for a certain class, you might decide to collect more training examples, adjust your augmentations, or refine your class definitions. EigenCAM gives you direct visual feedback on these experiments instead of relying solely on aggregate metrics like mAP or accuracy. That feedback loop speeds up debugging and helps you converge on a more reliable object detection system.

Finally, using EigenCAM with YOLOv5 makes your project more accessible to non-technical stakeholders. Instead of presenting only numbers and bounding boxes, you can show intuitive heatmaps that communicate how the model “sees” the scene. This is valuable in presentations, documentation, and educational content, where you want to explain the behavior of your object detector in a clear and engaging way while still staying grounded in the underlying deep learning mechanics.

Once you are comfortable running basic YOLOv5 inference, you can deepen your skills with this step-by-step guide on training YOLOv5 on a custom dataset so you can apply EigenCAM explanations to your own images and classes.

Walking Through the EigenCAM YOLOv5 Tutorial Code

This tutorial walks step by step through a practical Python script that combines YOLOv5 object detection with EigenCAM visualization. The goal of the code is to load a pretrained YOLOv5 model, detect objects in an image, and then use EigenCAM to highlight the regions that most influence those detections. Instead of just seeing bounding boxes and labels, the script produces an additional heatmap overlay so it becomes clear where the model is actually “looking” in the image.

The code starts by importing the essential deep learning and computer vision libraries: PyTorch for the model, OpenCV for image handling and display, NumPy for numerical operations, and torchvision.transforms for preparing the image tensor. It also imports the EigenCAM class and the show_cam_on_image helper from the pytorch-grad-cam package. Together, these tools build a full pipeline that goes from a raw JPEG file, through YOLOv5 inference, and all the way to an interpretable EigenCAM heatmap on top of the original picture.

Next, the script defines two helper functions: parse_detections and draw_detections. parse_detections takes YOLOv5’s pandas-style output, filters out low-confidence predictions, and extracts clean bounding box coordinates, colors, and class names. draw_detections then uses OpenCV to draw those boxes and labels on a copy of the image. These functions keep the logic organized: one part of the code deals with interpreting the detection results, and another part focuses on visualization for the user.

The central part of the code shows the main workflow of the tutorial. It loads an image of cows, resizes it to the expected input size, normalizes the pixel values, and converts it into a PyTorch tensor. A pretrained YOLOv5s model is loaded from the Ultralytics hub, and inference is run to obtain object detections. Once the boxes and class names are parsed and drawn, the script moves the model to the GPU, sets up EigenCAM with a chosen target layer, and computes a grayscale CAM for the same input tensor. The show_cam_on_image function overlays this EigenCAM heatmap on the original image, creating an intuitive visualization of model focus that is displayed side by side with the normal detection output.

Overall, the target of the code is to provide a complete, runnable example of how to integrate EigenCAM into a real YOLOv5 object detection workflow. It not only demonstrates how to call the right APIs and prepare tensors, but also shows how to choose a meaningful layer for EigenCAM, how to process YOLOv5 detections, and how to present the final results in a way that is easy to understand for anyone learning about explainable AI in computer vision.

Link for the video tutorial : https://youtu.be/pcgvcIJuKnI

You can download the code here : https://eranfeit.lemonsqueezy.com/buy/7cf52aaa-3eea-4456-8567-beb2604b4296

or here : https://ko-fi.com/s/538fc343b8

Link for Medium users : https://medium.com/object-detection-tutorials/how-to-use-eigencam-for-yolov5-object-detection-07e4a386e567

You can follow my blog here : https://eranfeit.net/blog/

 Want to get started with Computer Vision or take your skills to the next level ?

If you’re just beginning, I recommend this step-by-step course designed to introduce you to the foundations of Computer Vision – Complete Computer Vision Bootcamp With PyTorch & TensorFlow

If you’re already experienced and looking for more advanced techniques, check out this deep-dive course – Modern Computer Vision GPT, PyTorch, Keras, OpenCV4

Understanding EigenCAM for YOLOv5 Object Detection

EigenCAM is a class activation map technique that helps you see where a deep neural network is focusing when it makes a prediction.
Instead of treating YOLOv5 as a black box, EigenCAM projects the strongest activation patterns from an internal layer back onto the input image.
The result is a colorful heatmap that highlights the regions that most influence the model’s decision for object detection.

Unlike gradient-based methods, EigenCAM works directly on the feature maps and uses principal component analysis to find the dominant activation pattern.
This makes EigenCAM gradient-free, stable, and easier to plug into different architectures without worrying about complex backpropagation paths.
For YOLOv5, that means we can keep the normal forward pass for detection and then run EigenCAM on the same image and layer to obtain an explanation.

When you overlay the EigenCAM heatmap on top of the YOLOv5 detections, you get a much richer understanding of your model.
You can visually confirm whether the network is attending to the objects inside each bounding box, or if it is distracted by background textures and noise.
This is especially helpful when debugging strange detections, evaluating dataset quality, or presenting results to non-technical stakeholders.

In this tutorial, we will walk through a complete Python script that combines YOLOv5 object detection with EigenCAM visualization.
You will see how to prepare the image, load a pretrained YOLOv5 model, parse detections, draw bounding boxes, and finally apply EigenCAM to visualize model focus.
By the end, you will have a working pipeline that not only detects objects but also explains them using EigenCAM.

Walking through the EigenCAM YOLOv5 tutorial code

The goal of this EigenCAM tutorial code is to take a single image, run YOLOv5 object detection on it, and then visualize where the model is focusing using an EigenCAM heatmap.
The same script handles everything from importing libraries to displaying the final result in OpenCV.
This keeps the workflow easy to copy, modify, and extend to your own images.

The script begins with imports for PyTorch, OpenCV, NumPy, and the pytorch-grad-cam package.
These tools work together to load the YOLOv5 model, handle image preprocessing, and generate the EigenCAM heatmap.
You also define a color palette for drawing bounding boxes later in the pipeline.

Next, the code defines helper functions that clean up YOLOv5’s detection output and draw boxes with labels on the image.
This makes the main logic easier to read, because the parsing and drawing steps are encapsulated in small, focused functions.
Once the helpers are in place, the script loads the image, resizes and normalizes it, and creates a tensor ready for PyTorch.

Finally, the model is loaded from the Torch Hub, detections are computed, and EigenCAM is created on top of a chosen target layer.
The script then produces two visual outputs.
One window shows the original YOLOv5 detections with bounding boxes, and the second window shows the EigenCAM heatmap overlay, so you can directly compare detection and explanation side by side.

Getting the environment and EigenCAM imports ready

This first part prepares the environment, imports the libraries, and sets up a color map for drawing YOLOv5 detections.
It also makes sure you have the grad-cam package that provides the EigenCAM implementation used later in the script.

### Install the pytorch-grad-cam package that contains EigenCAM and other CAM methods. # pip install grad-cam   ### Import PyTorch to load the YOLOv5 model and run all tensor operations. import torch   ### Import OpenCV for image loading, drawing bounding boxes, and opening display windows. import cv2   ### Import NumPy to handle numerical arrays and random color generation for detections. import numpy as np   ### Import torchvision transforms to convert the NumPy image into a PyTorch tensor. import torchvision.transforms as trasforms  ### Import the EigenCAM class from pytorch-grad-cam to generate class activation maps without gradients. from pytorch_grad_cam import EigenCAM   ### Import the helper function that overlays the EigenCAM heatmap on top of the original image. from pytorch_grad_cam.utils.image import show_cam_on_image  ### Create a random color table for up to 80 classes so each detection can have a distinct bounding box color. COLORS = np.random.uniform(0, 255 , size=(80,3)) 

This section ensures your Python environment has all the tools needed for EigenCAM and YOLOv5.
You end up with clean imports and a convenient color map to visually distinguish different object classes.

Parsing YOLOv5 detections into clean boxes and labels

Here you define a helper function that turns YOLOv5’s Pandas output into Python lists of bounding boxes, colors, and class names.
The function also filters out low-confidence detections so your visualization stays clean and focused.

### Define a function to convert YOLOv5 results into simple Python lists of boxes, colors, and class names. def parse_detections(results):     ### Extract the first predictions table from YOLOv5 as a Pandas DataFrame.     detections = results.pandas().xyxy[0]     ### Convert the DataFrame to a dictionary so we can iterate over columns easily.     detections = detections.to_dict()      ### Initialize empty lists for bounding boxes, their colors, and their class names.     boxes , colors , names = [] , [], []       ### Loop over every detected object in the results.     for i in range(len(detections["xmin"])):         ### Read the confidence score for the current detection.         confidence = detections["confidence"][i]         ### Skip this detection if the confidence is below our threshold of 0.4.         if confidence < 0.4:             continue          ### Extract the left coordinate of the bounding box and cast it to an integer.         xmin = int(detections["xmin"][i])         ### Extract the top coordinate of the bounding box and cast it to an integer.         ymin = int(detections["ymin"][i])         ### Extract the right coordinate of the bounding box and cast it to an integer.         xmax = int(detections["xmax"][i])         ### Extract the bottom coordinate of the bounding box and cast it to an integer.         ymax = int(detections["ymax"][i])          ### Grab the class name predicted by YOLOv5 for this detection.         name = detections["name"][i]         ### Grab the numeric class index and convert it to an integer.         category = int(detections["class"][i])         ### Use the class index to pick a color from our COLORS table.         color = COLORS[category]          ### Store the bounding box coordinates as a tuple.         boxes.append((xmin , ymin, xmax, ymax))         ### Store the color associated with this detection.         colors.append(color)         ### Store the class name so we can draw it later.         names.append(name)      ### Return the lists of boxes, colors, and names for further processing.     return boxes, colors, names 

This function cleans up YOLOv5’s raw output into simple Python structures that are easy to use later for both drawing and EigenCAM interpretation.
Filtering by confidence helps keep only the most reliable detections in your visualization.

Drawing YOLOv5 detections on the image

This part defines a second helper function that uses OpenCV to draw bounding boxes and labels on the original RGB image.
It gives you a clear visual baseline of what YOLOv5 has detected before you add the EigenCAM explanation on top.

### Define a function that draws bounding boxes and class labels on the image using OpenCV. def draw_detections(boxes, colors, names, img):     ### Loop through each detection and its associated color and name at the same time.     for box, color, name in zip(boxes, colors, names) :         ### Unpack the bounding box coordinates into separate variables.         xmin , ymin , xmax , ymax = box           ### Draw the rectangle around the detected object with the chosen color and line thickness of 2.         cv2.rectangle(img , (xmin , ymin), (xmax, ymax), color , 2)         ### Put the class name text just above the top-left corner of the bounding box.         cv2.putText(img, name , (xmin , ymin-5), cv2.FONT_HERSHEY_SIMPLEX, 0.8 , color, 2, lineType=cv2.LINE_AA)      ### Return the image with all YOLOv5 detections drawn on it.     return img  

Once this function is defined, you have an easy way to generate a detection image that shows what YOLOv5 found.
Later you will compare this to the EigenCAM heatmap overlay to understand model focus.

Running YOLOv5 detection and visualizing the results

This section loads the input image, prepares a tensor for PyTorch, loads the pretrained YOLOv5 model, and runs object detection.
It then uses the helper functions to parse the detections and draw bounding boxes so you can see the raw predictions before applying EigenCAM.

Here is the test image : Cows.jpg

### Define the path to the input image that we want to analyze with YOLOv5 and EigenCAM. imgPath = "images/cows.jpg" ### Read the image from disk using OpenCV in BGR format. img = cv2.imread(imgPath) ### Resize the image to 640x640 pixels so it matches the expected YOLOv5 input size. img = cv2.resize(img , (640, 640)) ### Keep a copy of the original resized image in RGB order for YOLOv5 inference and visualization. rgb_img = img.copy() ### Convert the image data to float32 and scale pixel values to the range [0, 1]. img = np.float32(img) / 255 ### Create a torchvision transform that converts a NumPy image into a PyTorch tensor. transform = trasforms.ToTensor() ### Apply the transform and add a batch dimension so the shape is [1, C, H, W]. tensor = transform(img).unsqueeze(0)  ### Load a pretrained YOLOv5s model from the Ultralytics Torch Hub. model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)  ### Optionally print the model in evaluation mode for debugging or inspection. # print(model.eval()) ### Optionally print the CPU version of the model for debugging device issues. # print(model.cpu())  ### Select the target layer from the YOLOv5 model that will be used by EigenCAM for generating the heatmap. target_layers = [model.model.model.model[-2]]  ### Run YOLOv5 inference on the original RGB image inside a list to match the model’s expected input format. results = model([rgb_img])  ### Optionally print the full detection results object for inspection or debugging. # print(results)  ### Parse YOLOv5 results into lists of bounding boxes, colors, and class names. boxes , colors , names = parse_detections(results)  ### Print the list of bounding boxes to the console for quick checking. print(boxes) ### Print the list of class names to the console to see what YOLOv5 detected. print(names)  ### Draw the parsed detections on a copy of the original image using our helper function. detections = draw_detections(boxes, colors, names, rgb_img.copy())  ### Display the YOLOv5 detections window so we can visually confirm bounding boxes and labels. cv2.imshow("Detections", detections) 

At this point you already have a working YOLOv5 object detection pipeline that shows bounding boxes on the image.
The next step is to add EigenCAM so you can visualize where the model is focusing when it makes those detections.

Applying EigenCAM and visualizing the heatmap

The final part of the script moves the model to GPU, constructs the EigenCAM object, runs it on the input tensor, and overlays the resulting heatmap on the original image.
This produces a second visualization window that reveals the most influential regions for YOLOv5’s detections.

### Move the YOLOv5 model to the CUDA device so EigenCAM computations run on the GPU. model.to('cuda')  ### Create an EigenCAM instance using the YOLOv5 model and the selected target layers. cam = EigenCAM(model, target_layers) ### Run EigenCAM on the input tensor and take the first heatmap in the batch. grayscale_cam = cam(tensor)[0, : , : ] ### Overlay the EigenCAM heatmap on top of the original normalized image to create a colorful explanation. cam_image = show_cam_on_image(img , grayscale_cam, use_rgb=True)  ### Display the EigenCAM visualization window so we can see where YOLOv5 is focusing. cv2.imshow("cam image", cam_image)  ### Wait indefinitely for a key press to keep both the detection and EigenCAM windows open. cv2.waitKey(0) 

This final block turns your YOLOv5 detector into an explainable model by combining detections with EigenCAM.
You can now inspect both the bounding boxes and the corresponding heatmap to understand how YOLOv5 “sees” the scene.

EigenCAM : The result

FAQ about EigenCAM and YOLOv5 Object Detection

Conclusion

EigenCAM transforms YOLOv5 from a pure prediction engine into an explainable object detector that you can truly understand and trust.
By projecting the dominant activation patterns of a deep layer back onto the input image, EigenCAM produces intuitive heatmaps that show where the model is focusing when it draws each bounding box.

In this tutorial you built a complete, end-to-end pipeline that loads a pretrained YOLOv5 model, parses detections, draws bounding boxes, and overlays an EigenCAM heatmap on the same image.
Along the way you saw how helper functions like parse_detections and draw_detections keep the code clean, and how a single target layer and a few lines of EigenCAM code are enough to add powerful visual explanations.

You can now extend this script in many directions.
You might run EigenCAM on your own custom YOLOv5 models, process entire video streams, or export heatmaps for reports and presentations.
Combining strong detectors with clear visual explanations is a key step toward deploying computer vision systems that are both accurate and transparent, whether you are working on research projects, real-world applications, or educational content.

If you would like to explore more modern detectors and segmentation workflows after EigenCAM, check out my YOLOX object detection tutorial , my quick YOLOv5 segmentation guide , and the Segment Anything tutorial with YOLOv8 masks to see how different models can be combined with explainability tools.

Connect :

☕ Buy me a coffee — https://ko-fi.com/eranfeit

🖥️ Email : feitgemel@gmail.com

🌐 https://eranfeit.net

🤝 Fiverr : https://www.fiverr.com/s/mB3Pbb

Enjoy,

Eran