Sukrut Rao

DisParQ: Self-Supervised Part Concepts for Interpretable Vision Foundation Models

Wed, 07 Oct 2026 08:24:07 +0100

AnyBottle: A Recipe to Only Keep the Concepts You Really Need

Tue, 06 Oct 2026 08:24:07 +0100

CFM: Language-aligned Concept Foundation Model for Vision

Mon, 01 Jun 2026 08:24:07 +0100

Align Once to Explain: Feature Alignment for Scalable B-cosification of Foundational Vision Transformers

Fri, 01 May 2026 08:24:07 +0100

TEVI: Text-Conditioned Editing of Visual Representations via Sparse Autoencoders for Improved Vision-Language Alignment

Thu, 01 Jan 2026 08:24:07 +0100

FaCT: Faithful Concept Traces for Explaining Neural Network Decisions

Mon, 01 Dec 2025 08:24:07 +0100

B-cos LM: Efficiently Transforming Pre-trained Language Models for Improved Explainability

Wed, 19 Feb 2025 08:24:07 +0100

B-cosification: Transforming Deep Neural Networks to be Inherently Interpretable

Wed, 23 Oct 2024 08:24:07 +0100

Discover-then-Name: Task-Agnostic Concept Bottlenecks via Automated Concept Discovery

Fri, 05 Jul 2024 08:24:07 +0100

Good Teachers Explain: Explanation-Enhanced Knowledge Distillation

Mon, 05 Feb 2024 08:24:07 +0100

Better Understanding Differences in Attribution Methods via Systematic Evaluations

Mon, 01 Jan 2024 08:17:46 +0100

Studying How to Efficiently and Effectively Guide Models with Explanations

Sun, 01 Oct 2023 08:24:07 +0100

Towards Better Understanding Attribution Methods

Wed, 01 Jun 2022 00:00:00 +0000

Adversarial Training against Location-Optimized Adversarial Patches

Fri, 28 Aug 2020 00:00:00 +0000

Adversarial Patch Training

Sun, 23 Aug 2020 05:39:01 +0200

In this project, we explored the use of adversarial training to defend against adversarial patch attacks on image classification networks. Unlike imperceptible attacks, adversarial patches involve clearly visible contiguous perturbations covering a small area of an image that cause the network to misclassify the image. They are easier to use in practice since the patch can be printed out as a sticker and can be placed on an object or a the camera lens, causing subsequent automated analysis of the image to fail. An example where such an attack could be critical is the classification of stop signs by autonomous vehicles.

Approach

Adversarial training improves a network’s robustness to adversarial examples by training it to correctly classify them. The training process of the network then involves alternating between training the network to classify against strong adversarial examples, and generating strong adversarial examples that can fool the current iteration of the network. Consequently, it is desirable to using a stronger attack to generate adversarial examples would result in a more robust network.

To defend against adversarial patches, we make the following choices on the nature of the patches to get a strong attack, and then perform adversarial training against it:

Image-Specific: A separate patch is generated for each image, which is more effective against that particular image as compared to a universal patch intended to work on any image of that class.
Untargeted: The patch only needs to cause the network to misclassify the image, but does not require it to classify it as any specific alternative class. This is done by optimizing for patch values that maximize the network’s classification loss for each image.
Location-Optimized: The patch values and location are jointly optimized. We use two location optimization strategies to approximately find the optimal location of the image to place the patch that results in the strongest attack.

Experimental Results

We evaluate on the CIFAR10 and GTSRB datasets on the ResNet-20 architecture. On a high level, the experimental evaluation shows that:

Location optimization makes the attack stronger.
Adversarial training against adversarial patches improves network robustness. Adversarial training against location-optimized adversarial patches improves it further.
The accuracy of the network against non-adversarial examples does not decrease.
Visualization of successful attack suggests that adversarial training reduces the area on an image where an adversarial patch attack can succeed.

Further details can be found in the paper. A visualization of the approach can be found in the slides.

Open-WBO-Inc: Approximation Strategies for Incomplete Weighted MaxSAT

Sun, 01 Sep 2019 00:00:00 +0000

Open-WBO-Inc in MaxSAT Evaluation 2019

Thu, 01 Aug 2019 00:00:00 +0000

Fast Dawid-Skene

Thu, 01 Nov 2018 00:00:00 +0000

Fast Dawid-Skene (FDS) is an algorithm for crowdsourced vote aggregation. Given a dataset with labels for each data point annotated by a group of people (the crowd), the algorithm aggregates the responses to predict the true labels. Fast Dawid-Skene is based on the well-known Dawid-Skene (DS) algorithm, and improves upon it by providing aggregated labels in much fewer iterations with comparable accuracy. This allows it to be usable for real-time, online applications. While the algorithm has been shown to be useful for sentiment classification, it can also be applied to any other domain.

Motivation

The motivation for the problem stems from the need for large, labeled, training datasets for effective supervised learning, which can often be difficult to obtain. Moreover, in today’s world, problems such as sentiment classification need quick, real-time decisions, such as identifying hate speech on social media platforms. Such problems could be solved by obtaining labels (out of a set of labels) from viewers of such platforms, and aggregating them to make decisions.

Existing Approaches

One of the simplest vote aggregation algorithms is the Majority Voting algorithm. In this algorithm, the aggregated label for each data point is simply the label that appears most among the crowd annotations for that data point. However, this fails to take into account potentially useful information: the reliabilities of the annotators vary. Some of the annotators might be domain experts, with very high accuracy, while some might have answered randomly. Others might not be sufficiently trained to accurately provide a label, or might be spammers. The majority voting algorithm does not take these differences into account. It would be useful to identify the experts and give their labels more weight during aggregation.

Many other aggregation algorithms have been proposed, that overcome the shortcomings of majority voting. One of the well-known approaches, and among the state-of-the-art, is the Dawid-Skene algorithm. It is an EM-based algorithm, which in the E-step estimates the proposed true labels given parameters, and in the M-step estimates parameters maximizing the likelihood. This results in expert annotators getting more weight. This algorithm has been effective, and has become the baseline on which newer approaches are based. However, we found that the convergence of Dawid-Skene would often be slow, which would prevent it from being usable for real-time applications. To overcome this, we proposed an algorithm based on the Dawid-Skene approach, called Fast Dawid-Skene (FDS), that could provide comparable accuracy to Dawid-Skene in much fewer iterations.

Fast Dawid-Skene: Approach

The key idea of Fast Dawid-Skene is to binarize the proposed labels at each EM iteration. In Dawid-Skene, the proposed answer sheet at each iteration is a probability distribution. Our approach fixes the labels to be 0 or 1 at each step. The idea can be perceived as a ‘hard’ version of Dawid-Skene. We then showed theoretical convergence guarantees for our approach. We also proposed a few variants of our approach:

Hybrid algorithm: It was observed that the while Fast Dawid-Skene would quickly converge, the likelihood values attained by Dawid-Skene would be better, due to the use of softer marginals. To achieve the best of both worlds, the Hybrid variant starts with the Dawid-Skene algorithm, and switches to Fast-Dawid Skene after the sum of the absolute values of the differences of class marginals falls below a certain threshold. While this helped achieve better likelihood values, it did not necessarily perform better than FDS.
Online Vote Aggregation: It is often the case that data is available in a stream, where newer data arrives with time. In such a situation, it would be expensive, wasteful, and perhaps prohibitive to repeat aggregation on the entire dataset from scratch. This variant of Fast Dawid-Skene allows using the information from past iterations to perform aggregation of new data points as they arrive.
Multiple-Answer Correct setting: One of the assumptions made was that for any data point, only one label was the true label. This variant relaxes the assumption by allowing multiple true labels. This is done by interpreting each question-label pair as a binary classification problem, and then applying the Fast-Dawid Skene algorithm.

An example run of the Fast Dawid-Skene algorithm can be found here.

Experimental Evaluation

The algorithms were evaluated over seven datasets, most of them corresponding to sentiment analysis. They were compared against Dawid-Skene, and two other existing approaches: GLAD and IWMV. It was found that on most of the datasets, the Fast-Dawid Skene and the Hybrid algorithms had similar accuracies to Dawid-Skene. However, FDA converged up to 8x faster than DS on some datasets, and up to 6x faster than IWMV, which is reported to be a fast algorithm. As expected, the Hybrid algorithm converged to better likelihoods, but in more time, though it was still faster than DS and mostly faster than IWMV.

For online vote aggregation, FDS and Hybrid again converged faster than DS with similar accuracy. In the multiple-answer setting, FDS performed 7x better than DS, and outperformed previously reported state-of-the-art results on that setting.

Further details about the algorithm and the experimental results can be found in the paper.

Open-WBO-Inc Incomplete MaxSAT Solver

Thu, 01 Nov 2018 00:00:00 +0000

Open-WBO-Inc is a MaxSAT solver tailored to the incomplete MaxSAT problem. In incomplete MaxSAT, the goal is to find an approximate solution to a given MaxSAT formula in very little time. Open-WBO-Inc uses various approximation techniques, such as those that reduce encoding sizes, to find a solution close to the optimal in much lesser time than would otherwise be needed. Open-WBO-Inc is based on Open-WBO, a state-of-the-art MaxSAT solver, and has been implemented in C++.

Motivation

In the weighted MaxSAT problem, the input consists of a set of clauses and positive integral weights associated with each clause. The goal is to obtain an assignment of variables that minimizes the cost (sum of unsatisfied weights) of the formula. The weighted MaxSAT problem typically involves encoding a pseudo-boolean (PB) constraint in the CNF form to constrain the number of clauses that may be unsatisfied in a given iteration of the solution search process. The number of clauses added for this encoding could often be a large fraction of the resulting formula size. As a result, having a large encoding increases the time needed to find the solution. One of the best performing encodings, GTE, can generate an exponential number of clauses in the size of the PB constraint in the worst case, which is when the number of unique weights are very high. However, for many applications, it might be sufficient to obtain an approximate solution while greatly speeding up the search.

Approach

We proposed two approximation algorithms:

apx-weight (Open-WBO-Inc-Cluster)

This algorithm aims to reduce the size of the encoding, thus reducing the search time. A key observation is that the size of the GTE encoding increases based on the number of distinct weights in the formula. If this could be reduced, the encoding size would also reduce. We achieve this by clustering the weights to a small number of clusters using divisive hierarchical clustering. In each cluster, all the weights are replaced by a representative weight, such as their mean. As a result, the number of unique weights now reduces to the number of clusters. Clustering $n$ weights to $k$ clusters can be done in $\mathcal O(nk)$ time, which was observed to be negligible compared to the total time taken by the solver.

apx-subprob (Open-WBO-Inc-BMO)

This extends the ideas in apx-weight. Once the clusters are obtained, the clauses in the formula are arranged in the descending order of their weights. Then, iterating from the largest representative weight to the smallest, the formula in each cluster is solved. Once an optimum is obtained for any cluster, it is fixed, and no further relaxation is made when operating over subsequent clusters. This breaks the problem into multiple subproblems, effectively enforcing the boolean multilevel optimization (BMO) condition. This can often be an effective strategy because many real-world MaxSAT formulae might have weights that satisfy the BMO assumption.

Results

Both algorithms outperformed most of the existing state-of-the-art incomplete MaxSAT solvers. In particular, apx-subprob outperformed maxroster, which was the best performing solver in the MaxSAT Evaluation 2017.

In the MaxSAT Evaluation 2018, apx-subprob in Open-WBO-Inc secured the first position in the 60 seconds category and the second position in the 300 seconds category in the weighted incomplete MaxSAT track. apx-weight secured the fourth position in both these categories.

Timetabler

Thu, 01 Nov 2018 00:00:00 +0000

A timetabling program for educational institutions. Given a set of courses along with their details (class strength, instructors, relevant programs, and so on) as input, and a list of resources available (instructors, classrooms, time slots, etc.), the program generates a feasible timetable, if it exists. Custom constraints can also be given with the input. Each constraint can also be specified weights to signify their importance. The program also has the capability to list soft constraints that could not be satisfied, and to suggest changes in the parameters to make the problem satisfiable. Moreover, it can also complete an existing partial timetable.

Timetabler continues to be developed, and is currently being used for timetabling at IIT Hyderabad.

Visual Relationship Detection

Thu, 01 Nov 2018 00:00:00 +0000

The Visual Relationship Detection (VRD) task involves detecting relationships between pairs of objects in an image. An example of such relationships might be “Man kicks Ball”, for which the VRD task would involve detecting the bounding boxes and object class labels for both the man and the ball, and the relationship class “kicks” for the pair, in the image. The goal of this project was to improve on existing Visual Relationship Detection techniques, and test our methods against other participants in the Google AI Open Images Challenge 2018 in the Visual Relationship Detection track. The Open Images V4 dataset was used by the challenge. Our team finished sixth out of 232 teams, and a poster on our method was presented at the Open Images Challenge Workshop at ECCV 2018.

Detecting Diabetic Retinopathy from Fundus Images

Sat, 01 Sep 2018 00:00:00 +0000

Diabetic Retinopathy (DR) is a condition to the eye caused by diabetes, and can cause blindness. If detected early, effective countermeasures can be taken. For this purpose, Bosch has developed a hand-held device to automatically detect diabetic retinopathy from images of the fundus of the eye. This project’s goal was to improve the accuracy of the detection process.

My work consisted of three components:

Quality Assessment: Designing and implementing a quality assessment network to judge the suitability of an image for diagnosis.
DR-Healthy Binary Classification: Improving the accuracy of the existing network that performed binary classification based on the presence or absence of the disease.
Five-stage Classification: Designing and implementing a pipeline that would enable an image to be classified among one of the five grades of diabetic retinopathy.

Approximation Strategies for Incomplete MaxSAT

Wed, 29 Aug 2018 00:00:00 +0000

Fast Dawid-Skene: A Fast Vote Aggregation Scheme for Sentiment Classification

Mon, 20 Aug 2018 00:00:00 +0000

IntervalAI

Fri, 10 Aug 2018 00:00:00 +0000

An abstract interpreter for an integer interval domain supporting basic operations. IntervalAI can verify a C program for correctness against a given specification, provided using assertions. During verification, it treats the domain of each variable as an interval, and performs arithmetic operations, joins, and meets on intervals. It works for a restricted set of C programs consisting only of integer variables.

IntervalAI uses CBMC to convert the C program to a Goto program. It then verifies the Goto program. IntervalAI has been implemented in C++.

Second Order Momentum

Fri, 10 Aug 2018 00:00:00 +0000

In this project, we explored the effects of applying momentum and Nesterov’s accelerated gradient, in their usual formulations, to second order methods. We applied these acceleration techniques Newton’s method and quasi-Newton methods such as BFGS and cubic regularization. We then compared the empirical rate of convergence of first and second order methods, with and without momentum, on a set of benchmark optimization problems.

COOL Compiler

Wed, 01 Aug 2018 00:00:00 +0000

A compiler for the COOL programming language. It accepts a COOL program, and outputs equivalent LLVM IR. This project implements a parser, semantic analyzer and a code generator. An implementation of a lexical analyzer for COOL can be found here. The compiler has been implemented in Java.

Parser: Converts tokens provided by the lexical analyzer into an abstract syntax tree (AST), in accordance to the grammar rules of COOL. Flags errors if any grammar rule is violated.
Semantic Analyzer: Type checks the parsed program according to the type rules of COOL, and annotates each AST node with a type. Flags errors if any semantic or type rules are violated, for example, the case where the input program calls non-existent methods or performs an invalid type conversion.
Code Generator: Converts the annotated AST into LLVM intermediate representation (IR). At some points, code might be inserted to handle run-time errors. The LLVM IR can then be converted to machine code by clang, the LLVM frontend, and executed.

The compiler implements a restricted version of COOL, i.e., some of the constructs in the language specification are not covered.

DeepAgg

Wed, 01 Aug 2018 00:00:00 +0000

An implementation of the crowdsourced aggregation network proposed in the paper

“Alex Gaunt, Diana Borsa, and Yoram Bachrach. 2016. Training deep neural nets to aggregate crowdsourced responses. In Proceedings of the Thirty-Second Conference on Uncertainty in Artificial Intelligence (UAI'16), Alexander Ihler and Dominik Janzing (Eds.). AUAI Press, Arlington, Virginia, United States, 242-251.”

The implementation also contains an extension to the proposed model, by adding a third dimension to account for the multiple-correct answer scenario.

This was used for experimenting in the initial stages for the Fast Dawid-Skene project.

This implementation is written in Python.

Extreme Classification

Wed, 01 Aug 2018 00:00:00 +0000

This project explored methods to effectively perform multi-label classification from a very large set of labels.

Open-WBO-Inc in MaxSAT Evaluation 2018

Mon, 09 Jul 2018 00:00:00 +0000

Crowdsourced Data Simulator

Sun, 01 Jul 2018 00:00:00 +0000

A program to simulate a synthetic dataset of annotations from a crowd to a set of multiple-choice questions. It accepts a configuration of indicators on the crowd, such as fraction of people with high accuracy, and the fraction of malicious labelers, and generates responses. Both single answer and multiple answer questions are supported. It can be used for experimenting with crowdsourced aggregation algorithms, such as the Dawid-Skene algorithm.

The program accepts classes of people, each having two parameters - (1) their percentage in the population, and (2) their range of probabilities of getting the answer to any question correctly. For example, one can specify that 20% of the population gets the answer correctly with probability between 0.6 and 0.7. The input also includes the number of questions to simulate, the number of options per question, the number of annotators to simulate, and whether the setting is single-answer or multiple-answer. It then provides simulated crowd labels and ground truths.

Instructions on setup, usage, and examples can be found on GitHub.

The program does not account for the difficulty of questions, and the simulated labels might be sometimes unnatural because of the predictable nature of the annotators. However, it could still be very useful to quickly generate synthetic data for testing aggregation algorithms.

This program was used for experimenting in the initial stages for the Fast Dawid-Skene project.

This program has been implemented in Python.

Load Balancer

Sun, 01 Jul 2018 00:00:00 +0000

This project implements a plug-and-play load balancer, in GoLang. The setup consists of a master node, that receives requests, and a set of slave nodes, that can execute the requests. The master node allocated tasks to slave nodes depending on the expected load of the task and the current load of each slave, using a load balancing algorithm. A few simple load balancing algorithms have been implemented in this project.

The entire setup is plug-and-play, where slaves can enter and leave at any time. No intervention is needed to add a new slave to the pool of slaves, or to handle tasks left incomplete by disconnected slaves. The load balancer is tested using each algorithm on a few simple tasks. The effectiveness of load balancing is monitored using Prometheus and visualized using Grafana.

CDCL SAT Solver

Tue, 01 May 2018 00:00:00 +0000

A SAT solver that implements the Conflict-Driven Clause Learning (CDCL) algorithm. The solver is implemented in C++.

DPLL SAT Solver

Tue, 01 May 2018 00:00:00 +0000

A SAT solver that implements the Davis-Putnam-Logemann-Loveland (DPLL) algorithm. The solver is implemented in C++.

MaxSAT Solver

Tue, 01 May 2018 00:00:00 +0000

This project implements a partial unweighted MaxSAT solver. It uses the Minisat SAT solver as its backbone. It uses sequential encoding to encode pseudo-boolean constraints in the conjunctive normal form (CNF). The LUS search algorithm is used to find the optimal solution.

This solver is implemented in C++.

Artillery Game

Sun, 01 Apr 2018 00:00:00 +0000

A turn-based, three-player game written in Haskell. Each player controls a tank, with a set of weapons, and the objective is to destroy the tanks of the other players.

The project implements all game physics from scratch, by implementing the equations for gravity and kinematics. Tracking and movement of projectiles (weapons), tanks, and their turrets is handled by these equations, along with detection of collisions and their magnitude of impact. The GLUT library has been used for graphics. The game map internally consists of a highly granular grid of points, with all operations happening at various coordinates on the grid.

The game, along with the code and rules to play, can be found on GitHub.

MIPS Simulator

Sun, 01 Apr 2018 00:00:00 +0000

A program to simulate execution of programs written in the MIPS assembly language. It can simulate a subset of instructions in the MIPS instruction set. There are two modes available:

Step-by-Step Mode: To execute one instruction at a time, and to display the state of the registers and memory after each step.
Execution Mode: To execute the entire program.

An additional instruction, halt, is defined to specify the end of the program.

The simulator has been implemented in C++.

Platform Game

Sun, 01 Apr 2018 00:00:00 +0000

A multiplayer platformer that can be played on a local network. Each player controls a character, with the goal of reaching the door at the other end of the map while collecting as many gems as possible and avoiding zombies and fire. Players are ranked according to their score, determined by the number of gems collected, and the time taken to reach the door.

The game is written in C++ and uses Qt libraries. It creates multiple threads to efficiently manage tasks and respond to events. A single server is created to maintain game state, and each player runs a client that connects to the server.