CV on Mahanth Yalla

Pothole Detection UG Project

Tue, 01 Jul 2025 00:00:00 +0000

PHD_FYP

A web app for The Pot Hole Detection on images and open CV and TensorFlow.

The web app would include a way to upload the image that the user took of the pothole at certain location and our model would predict if there exist any pothole and then updates the database. So, that whenever Other person logs into the webpage, he will be notified that there is a pothole day by showing the marker over the location that the picture was taken.

By using this markers on the location one could easily find out that the road that they are taking Contains a pothole, so They can slow down the vehicle or if they really want to avoid such potholes and don’t, Make any damage to the vehicle, They could take another path which has the less potholes.

Testing custom images

extract the zip file into training_demo\ folder & then run

extract ’exported_models’ into training_demo\ folder. (be careful while extracting, it should not create ’exported_models’ folder 2 times)

install python-3.9.X ( prefer 3.9.12 ) go to the root folder of the project and run the command below (it is recommended to use a venv for testing the project)

Anaconda

install the anaconda to make the env creation easy Download Here!

setting up

open the Anaconda Command Prompt or Anaconda Powershell Prompt after installtion

Navigate to project dir

1

cd <PATH>\PHD_FYP

Creating v-env to run project

1
2


conda create --name phd_fyp python==3.9.12
conda activate phd_fyp

NOTE : POSSIBLE ERROR while running the app

The tensorflow usual throws an error as tf.gfile.GFile not found or tf has no attribute named gfile. check reslving techniques here in

simply , Replace tf.gfile.GFile to tf.io.gfile.GFile at line number 137

End User Product

Setup

the setup file is also included with requirements.txt, but I have wrote the script in such a way that it ensures all the dependencies are installed on FIRST TIME RUN , ALL AT ONCE and no more installing or configuring is required except for the mentioned above

Note : if one wants to delete entire database run python main.py, which deletes all the entries till now.

Web App

make sure you are in root directory i.e, PHD_FYP and extracted the zip file into training_demo\ so that the structure will be training_demo\exported-models\models\ (be careful since it might be the case that it extracts training_demo\exported-models\exported-models\models\ if it’s a windows OS)

1

python app.py

go to the web link it provides probably http://127.0.0.1:8080/ , or better open which flask provides dynamically

web app interface images

Running app

website walk through

Results - WEB app

Running app in mobile

website walk through in mobile

Demo	Images

Results and maps

WEB app in mobile	MAPS view in mobile

Running as a product for an image (CLI)

By running this python script it opens the Input image and the output image generated in separate window.

Note : Replace the <image_path> with the actual image path while running the Script.

1

python Main_CLI.py <image_path>

CLI app interface images

running cli app

Results - CLI

Running as a product for an image (GUI)

Select the image form the drop down and click Run.

1

python Main_GUI.py

GUI app interface images

running gui app

Results - GUI

Build your custom app using our model

Yes, you can integrate pothole detection system into any custom app which is already written as an API in the file named as phd_api.py.

just import as

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14



import phd_api

#create object
phd_run = PHD_API()

filepath = 'test.jpg'

# use the model
# saves output in /Dataset/Result folder
phd_run.run_phd_and_save_img(input_image_path=filepath)

# alternatively use this to not save result
phd_run.run_phd(input_image_path=filepath)

The Results

the Resulting image will be saved in Dataset\Result folder

Demo

Result for an image

Image

Result

Zero-Shot Class Unlearning in Deep Computer Vision Models

Mon, 05 May 2025 00:00:00 +0000

Zero-Shot Class Unlearning in Deep Computer Vision Models

Forgetting the Past: Targeted Unlearning in Pretrained Deep Networks for Computer Vision - Project Work for Course : DS265 Deep Learning for Computer Vision (DLCV 2025), IISc Bangalore

Project Overview

This project explores and implements methods for Machine Unlearning, specifically focusing on Zero-Shot Class Unlearning in deep learning models for computer vision tasks. The goal is to enable a pre-trained model to “forget” specific classes it was originally trained on, without requiring access to the original training data (the “zero-shot” constraint). This is increasingly important due to data privacy regulations (like GDPR’s “Right to be Forgotten”) and the need to remove outdated or sensitive information from deployed models efficiently.

The core approach leverages class impressions generated directly from the trained model’s parameters. These impressions act as data-free proxies for the classes to be forgotten or retained. An unlearning algorithm, inspired by gradient ascent/descent techniques (like NegGrad+) but adapted for the zero-shot setting using only these impressions, modifies the model’s weights to suppress information related to the “forget” classes while preserving knowledge of the “retain” classes.

This repository contains implementations for:

Training baseline models (LeNet5, KarpathyNet, AlexNet, ResNet) on relevant datasets (MNIST, CIFAR-10, ImageNet).
Training “Golden Standard” models (retrained from scratch without the forget classes) for comparison.
Performing zero-shot class unlearning using class impressions derived from the trained models.
Evaluating the effectiveness of unlearning through accuracy metrics and class-wise comparisons.

Project Structure

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


unlearning_project/
├── data/
│ ├── MNIST/ # MNIST dataset files (idx format)
│ │ └── ...
│ ├── cifar-10-batches-py/ # CIFAR-10 dataset files (python batches)
│ │ └── ...
│ └── ImageNet/ # ImageNet dataset files
│ │ └── ...
├── Learn_LeNet5_Script.py # Example training script (can be adapted)
├── Learn_KarpathyNet_Script.py # Example training script (can be adapted)
├── Learn_KarpathyNet_Golden_Script.py # Example golden standard training script
├── Unlearn_LNet_Script.py # Unlearning script for LeNet5
├── Unlearn_KNet_Script.py # Unlearning script for KarpathyNet
├── requirements.txt # Python package dependencies
└── README.md # This file

Setup Instructions

Prerequisites

Git
Conda (or Miniconda)
NVIDIA GPU with CUDA drivers (recommended for training larger models)

1. Clone the Repository

1
2


git clone https://github.com/Mahanth-Maha/ZeroShotUnlearning
cd ZeroShotUnlearning

2. Create Conda Environment

We recommend using Python 3.10 or later. Create a Conda environment using the provided requirements.txt file.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# Create the environment named 'unlearn_env' (or choose your own)
conda create --name unlearn_env python=3.10 -y

# Activate the environment
conda activate unlearn_env

# Install PyTorch with CUDA support (adjust cuda version if needed)
# Check PyTorch website (pytorch.org) for the correct command for your system/CUDA version
# Example for CUDA 11.8:
conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia

# Install other dependencies
pip install -r requirements.txt

3. Download and Prepare Datasets

MNIST: Download the IDX files (train-images-idx3-ubyte, train-labels-idx1-ubyte, t10k-images-idx3-ubyte, t10k-labels-idx1-ubyte) and place them in ./data/MNIST/.
CIFAR-10: Download the Python version batches (data_batch_1 to 5, test_batch, batches.meta) and place them in ./data/cifar-10-batches-py/.
ImageNet : Place your val, and test image files into ./data/ImageNet/.
- image net validation set used is from Kaggle, which can be downloaded from python script
1 2 3

import kagglehub path = kagglehub.dataset_download("titericz/imagenet1k-val") print("Path to dataset files:", path)

Note: The dataset files are not included in this repository due to size constraints. You can download them from their respective sources:

Usage

1. Training Original Models

LNet, KNet these are trained with the scripts Learn_LeNet5_Script.py and Learn_KarpathyNet_Script.py respectively. These scripts are designed to train the models on the specified datasets (MNIST, CIFAR-10) and save the trained models in the saved_models/ directory.
AlexNet and ResNet are pretrained models. You can use the torchvision library to load these models and fine-tune them on your dataset. The training scripts for these models are not provided in this repository, but you can adapt the existing scripts for your needs.
Unlearning works on any other model as long as you have the model architecture and the dataset ready.

2. Training Golden Standard Models (for Comparison)

These models are trained from scratch without the classes intended for forgetting. This provides a benchmark for the unlearning process.

Example (KarpathyNet without classes {3, 4, 8}):
- Note: The forget classes {3, 4, 8} are currently hardcoded in Learn_KarpathyNet_Golden_Script.py. You need to edit the script to change the Target_classes set if you want to forget different classes.
- Run the specific script:
  1
  
  python Learn_KarpathyNet_Golden_Script.py -n v1_golden_forget_348 -e 100 # Use a distinct version name
- Adapt or create similar scripts for other models/forget sets as needed. The output directory will be based on the --net_name and -n/--version_name arguments used in the script.

3. Performing Zero-Shot Unlearning

The unlearning scripts load a pre-trained model, generate or load class impressions, and then apply the zero-shot unlearning algorithm.

Notebooks (.ipynb):
- Files like Unlearn_LNet.ipynb and Unlearn_KNet.ipynb provide an interactive way to step through the unlearning process, generate class impressions, visualize results, and understand the core logic. Run these using Jupyter Notebook or Jupyter Lab within your activated conda environment.

Scripts (.py):

Files like Unlearn_LNet_Script.py and Unlearn_KNet_Script.py are designed to run the unlearning process non-interactively.
Modify the Scripts: You’ll need to edit these scripts to specify:
- net_name and version_name: To load the correct pre-trained model from saved_models.
- target_classes: A set of class indices to forget (e.g., {1, 2, 3, 4} or {3, 4, 8}).
- Hyperparameters like NUM_SAMPLES for impressions, LEARN_RATE for unlearning, epochs, etc.

Run the Script:

1
2
3
4
5


# Example for LeNet (after editing the script for desired target classes)
python Unlearn_LNet_Script.py

# Example for KarpathyNet (after editing the script)
python Unlearn_KNet_Script.py

Output: The scripts will typically:

Load the specified pre-trained model.
Determine the responsive layer (usually the last learnable one before the classifier).
Generate or load class impressions for all classes for that layer (saving them to unlearn/<model_name>_<version_name>/class_impressions/).
Create forget/retain datasets using the impressions.
Instantiate the ZeroShotUnlearner.
Run the unlearning optimization loop (modifying the model in memory).
Evaluate the unlearned model on the test set (overall, forget classes, retain classes).
Generate comparison plots (Original vs. Unlearned class-wise accuracy).

Note: The provided unlearning scripts primarily focus on executing the unlearning process and evaluating its effect immediately. They might not explicitly save the state of the unlearned model to a separate file. The u_model variable within the script holds the unlearned state. You could modify the scripts to save u_model.state_dict() if needed.

Evaluation

Training: The scripts starting with Learn (.py and .ipynb) evaluates on the validation set during training and saves logs/plots. Final evaluation on the test set (using the best model checkpoint) is performed at the end.
Unlearning: The unlearning scripts starting with Unlearn (.py and .ipynb) perform evaluation after the unlearning process:
- Prints overall accuracy.
- Prints accuracy specifically on the forget classes (should be close to 0%).
- Prints accuracy specifically on the retain classes (should be close to the original model’s accuracy on these classes, or the golden standard model’s accuracy).
- Generates bar plots comparing class-wise accuracies of the original model and the unlearned model.

Note :

The unlearning process is computationally intensive and may take time, especially for larger models and datasets. Ensure you have sufficient resources (GPU recommended).

Time complexity

class impressions generation: is the most time-consuming part of the unlearning process. but it is done only once for each class. The time complexity of generating class impressions is O(n * m), where n is the number of samples in the dataset and m is the number of classes. This is because we need to compute the class impression for each sample in the dataset for each class.

After generating the class impressions, it is straightforward to compute the forget and retain datasets, and no matter what the number of classes is, the time complexity of this step is O(n), where n is the number of samples in the dataset, for unlearning. The unlearning process itself is O(k * n), where k is the number of epochs and n is the number of samples in the dataset. This is because we need to compute the gradients for each sample in the dataset for each epoch.