Explore Projects

This project tackles the challenge of learning hidden symmetries in complex, high-dimensional physics data using modern machine learning techniques. In particular, we aim to discover symmetries directly from raw CMS calorimeter data using a semi-supervised learning pipeline—without relying on pre-defined augmentation strategies or prior knowledge of symmetry transformations. We will build on recent advances in symmetry discovery such as adversarial learning, Lie algebra-based models, and general equivariant MLP construction. The proposed approach begins with a supervised baseline using known augmentations to validate the pipeline, followed by implementing a GAN-based or contrastive method to infer latent group actions and conserved quantities. Discovered symmetries will then be used to construct equivariant neural networks that are robust, interpretable, and data-efficient. By the end of the project, we aim to deliver a fully working, open-source pipeline for symmetry discovery and equivariant modeling on CMS data—benchmarking its performance and generalization against traditional models. This work will contribute to the broader mission of physics-aware machine learning and enable more principled modeling of detector data in high-energy physics.

This proposal presents a plan to develop hybrid quantum-classical models for classifying dark matter substructure from strong gravitational lensing images, as part of the ML4SCI DeepLense project. The classification task involves three classes: no substructure, CDM subhalo substructure, and vortex substructure from axion/fuzzy dark matter. I propose two complementary approaches: Projected Quantum Kernels (PQK), which encode CNN-extracted image features into quantum states and ompute kernel matrices for SVM classification, and Quantum Convolutional Neural Networks (QCNN), which use parameterized quantum circuits as trainable convolutional filters in a hybrid pipeline. Both methods will be benchmarked against classical baselines on the DeepLense Model I/II/III datasets and evaluated under realistic NISQ noise conditions using depolarizing and devicecalibrated noise models, with error mitigation techniques such as ZNE and PEC. Beyond the standard implementations, I also propose using a GPT-2-based autoregressive Transformer to automatically generate task-optimized quantum circuits for both PQK feature maps and QCNN layers, replacing hand-designed circuit templates. Additional experiments include data-efficiency analysis on small training subsets, hybrid kernel fusion combining classical RBF with PQK, and transfer learning evaluation across different dark matter model datasets.

This projects's aim is to implement the VC-2 decoder for FFmpeg in vulkan. VC-2 is a low-latency video codec that uses wavelet transforms and entropy coding. It can be readily implemented in hardware or software at very high bit rates. It can also be efficiently implmented on GPU hardware. To this, end, an encoder and a decoder must be implemented and tested with the VC-2 conformance software. The encoder requires a wavelet transform, quantization, etropy coding and writing back the result in a proper format and bitstream coding. The decoder, in turn, reuires: bitstream parsing, entropy decoding, dequantization and another wavelet transform.

<p>Polly can perform classical loop transformations, exploit OpenMP level parallelism, expose SIMDization opportunities. However, due to the lack of a machine-specific performance model and missing optimizations, these transformations sometimes lead to compile and execution time regressions, and the generated code is at least one order of magnitude off in comparison to the corresponding vendor implementations. The goal of the project is to reduce such influence through implementation of optimizations aimed to produce code compatible with the best implementations of BLAS and an attempt to avoid vectorization of loops, when it is not profitable for the target architecture. It could be a step in transformation of Polly into an optimization pass used in standard -O3 optimizations.</p>

A number of tools exist for identifying repeat features, but it remains a problem that the DNA sequence of some genes can be identified as being a repeat sequence. If such sequences are used to mask the genome, genes may be missed in the downstream annotation. Assuming that gene sequences have various signatures relating to their function and that repeats have different signatures including the repetitive nature of the signal itself, we want to train a classifier to separate the repeat sequences from the gene sequences. We are inspired by DETR, an object detection model, this proposal will use transformer structure to complete the identify repeat sequence task, our model will unify segmentation and classification into one like the object detection model.

Because of its cylindrical shape, the Compact Muon Solenoid (CMS) detector has intrinsic rotational symmetries. Data analysis can be greatly improved by taking advantage of these symmetries, especially in semi-supervised learning situations where labeled data is hard to come by. Using learnable rotation matrices conditioned on class labels or contextual information, this study aims to create a novel generative model that learns and applies rotational symmetry transformations to CMS data. Our goal is to find and utilize rotational symmetries by including this model into a GAN-like framework with a trained classifier. This will enhance data augmentation and model performance in semi-supervised CMS data processing.

The aim is to build the textual portions of the FastAI.jl package, inspired by the fastai Python library, which will provide high-level components that can quickly and easily provide state-of-the-art results for all kinds of tasks, and provide low-level components that can be mixed and matched to build new approaches. This will include handling textual data, performing transformations on it, creating a model using best practices (inspired from fastai), being able to train the created model, and interpreting and visualizing the results of the model. All this will be done without compromising on ease of use, flexibility, or performance, due to the benefits Julia provides, along with the well-designed three-layered architecture.

This project aims to implement state-of-the-art protein design models, RFDiffusion and RFDiffusion-2, within the DeepChem framework using a clean, end-to-end PyTorch pipeline. The goal is to make advanced generative protein modeling accessible through standardized DeepChem abstractions such as TorchModel, Dataset, and Featurizer, facilitating integration with existing deepchem workflows. The model leverages diffusion-based generative techniques to transform random noise into realistic protein structures, built on a RoseTTAFold inspired architecture that jointly captures sequence, pairwise interactions, and 3D geometry. By incorporating SE(3)-equivariant operations, the system ensures physically consistent predictions while maintaining modularity through the use of existing equivariant libraries.

The torch ecosystem is rapidly growing in R, but it still lacks support for several key computer vision capabilities available in Python's torchvision package. This proposal aims to close the gap by implementing a wide range of torchvision datasets and models directly in R. Specifically, the project will: Implement all torchvision datasets. Add support for 5 key computer vision tasks: Object Detection, Instance Segmentation, Keypoint Detection, Semantic Segmentation, and Quantized Models. Provide native R implementations that don't rely on Python bindings, making it easier to install and use. Deliverables include tested R implementations of datasets and models, documented APIs, and example use cases. This will make R a more viable option for computer vision research and production.

PreliZ is a Python package aimed at helping practitioners choose prior distributions by offering a set of tools for various facets of prior elicitation. The main objective of this project is to expand these features and make them more robust, transforming PreliZ into a tool that easily integrates with other libraries such as PyMC, Bambi, and PyStan, while remaining agnostic to Probability Programming Languages (PPLs). The key outcomes of this project include generalizing Bambi's parsers, integrating PyMC for interoperability, establishing a common infrastructure for future PPLs, extending the `predictive_explorer` function to handle multiple inputs and outputs from various PPLs for comprehensive prior predictive distribution plotting, enhancing the `ppa` function to support models from PreliZ, PyMC, or Bambi for interactive prior updates, and improving the handling of PyMC models within PreliZ's `ppe` function while extending support to PreliZ and Bambi models.

<p>Real-world data generating processes often don't produce normally-distributed data, in particular the skewness/kurtosis/tail index parameters are inconsistent with a Gaussian random variable. If we can "Gaussianize" data from such processes in a meaningful way, then we can make better inferences. We can solve this problem generally by applying a Lambert W transform (Goerg, 2014), which assumes the observed data is distributed as Lambert W x F_X, where F_X is the distribution of the latent input (Goerg , 2011). To apply this transform, we need to estimate parameters of the Lambert W x F_X distribution and also support the inverse transform, so that we can make inferences about the latent input. With this project, we want to support Lambert W x F_X distribution in Stan in an inferential setting, which means: users can build Gaussian models over non-normal data in a transparent way.</p>

The rise of sophisticated web attacks poses significant challenges to current detection mechanisms, often relying on traditional regex-based approaches that struggle with accuracy and latency. This project proposes the integration of a Machine Learning (ML) classifier into TANNER, a renowned tool for detecting web-based attacks. By leveraging advanced ML algorithms, including Convolutional Neural Networks (CNNs) and Transformer-based models like BERT for text classification, the project aims to significantly improve TANNER’s efficiency in real-time attack analysis. The deliverables include a detailed project plan, a data preprocessing tool, baseline and enhanced ML models, integration prototypes, comprehensive documentation, and a final presentation. The project is structured around key milestones spanning from initial dataset analysis and model development to final integration and testing. This approach not only promises to advance TANNER's capabilities but also contributes to the broader cybersecurity community by offering a scalable and effective solution to web attack detection.

This project aims to automate metadata harmonization for cBioPortal, a widely used platform for cancer genomics research. Currently, metadata from different studies often uses inconsistent terms, limiting cross-study analysis and making it harder to apply AI/ML models effectively, while manual harmonization is time-consuming and not scalable. To address this, I propose building an automated metadata harmonization tool using fine-tuned biomedical sentence transformer models to semantically match and standardize metadata terms. The pipeline will include data preprocessing, semantic matching, low-confidence flagging, and expert validation, with interfaces to support expert review. The key deliverables are a fully functional metadata harmonization pipeline, semantic similarity models fine-tuned on curated biomedical data, a persistent vector database for scalable and reproducible retrieval, and documentation with testing coverage. This tool will reduce manual curation time by over 70%, improve metadata consistency, and enhance the platform’s readiness for AI-driven research.

This project is about extending the gamboostLSS package by flexible copula regression via gradient boosting. Currently the framework only supports univariate responses, but there is a need to model two correlated outcomes with arbitrary marginal distributions (continuous, discrete, binary or mixed) and their dependence structure modelled through the copula. At the core of this project stands the CopulaFamilies() constructor that combines any two existing gamboostLSS family objects with a copula of the user's choice (Gaussian, Clayton, Gumbel or Frank). The constructor automatically detects the marginal types of the input and computes the appropriate joint log-likelihood, as well as the gradients via chain rule. This computation and its results integrate seamlessly into the already existing interface of gamboostLSS(), extending the cvrisk() for multi-dimensional tuning of the stopping hyperparameter and adding a transformation of the dependence parameter to the Kendall's Tau measure for summary() and plot() to establish interpretable dependence estimates. The deliverables for this project include the CopulaFamilies() constructor with automatic full marginal type detection, gradient stabilization for a method of choice (MAD, L2), model selection on the basis of predictive risk minimization, a predict() method for the evaluation of joint cumulative distribution functions and a vignette to demonstrate the full workflow on a real dataset.

This project explores Quantum Kolmogorov–Arnold Networks (QKANs) as a novel and interpretable architecture for analyzing collider data from the High-Luminosity LHC. Inspired by the Kolmogorov–Arnold theorem, QKANs decompose complex multivariate functions into compositions of univariate ones—translated into quantum models using parameterized circuits and Chebyshev-based activations. QKANs leverage quantum singular value transformation (QSVT), block-encoding, and variational unitaries to efficiently model high-dimensional, nonlinear relationships in jet physics tasks like quark-gluon tagging. The goal is to develop scalable and NISQ-compatible QKAN layers using the Pennylane framework and benchmark them against classical MLPs and spline-based KANs on realistic HEP datasets. This includes implementing quantum-friendly activation functions, evaluating noise robustness, and integrating hybrid QKAN layers selectively across high-impact features. The final deliverables will include a modular, open-source codebase, training pipelines, evaluation reports, and insights into symbolic function discovery in collider physics. This project contributes to building transparent, compact, and hardware-efficient quantum models for the next generation of scientific discovery at the LHC.

Background: Current flows from RISC-V Sail specification to downstream implementations have manual steps which are time-consuming and can introduce errors.A lack of familiarity with Sail and OCaml presents a barrier to adoption of Sail as the basis for automated downstream implementations: emulators, simulators, compilers, assemblers, disassemblers, instruction stream tools, documentation, etc. Proposal: - Create an accessible Sail backend. - Extract salient information. - Transform it into an accessible database (JSON). - Survey projects dependent on RISC-V ISA for how that dependency is realized. - Utilize JSON to directly and automatically generate downstream source that is currently generated by hand. - Create a React-based interactive RISC-V ISA reference by directly importing the JSON database. Benefits: The backend can serve as a model for creation of additional Sail backends. The JSON database itself may be sufficient for many downstream uses. Creating downstream source shows feasibility, and a process for a fully-automated downstream flow. Additional collaboration with the effort to transform Sail into documentation is warranted. Much of the effort to transform Sail into JSON is complete, but there is still significant effort ahead: - enhanced parsing - enhancing the RISC-V Sail specification itself with more required content Much of the effort in creating an interactive web site is complete, but there is work to support the incorporation, display, and filtering.

Understanding the architecture of planetary systems is crucial for insights into their formation and evolution. This project aims to leverage the power of equivariant vision networks to predict the number of planets and their orbital configurations within observed systems. Equivariant networks are uniquely suited for this task due to their inherent ability to handle the rotational and reflectional symmetries common in astronomical images, thus maintaining predictive accuracy regardless of orientation changes in spatial data. The project will unfold over 175 hours, meticulously planned across several phases to ensure a thorough approach from conceptualization to deployment. Starting with a comprehensive review of current equivariant neural network architectures and their potential application in analyzing astronomical data, the project will proceed to curate a dataset from existing astronomical surveys. This dataset will include systems with known numbers of planets to serve as a foundation for model training and validation. By developing a model that can accurately regress on the number of planets in a system, this project seeks to create a robust tool capable of adapting to the complexities inherent in observational data, such as direct images, transit data, and radial velocity measurements. The ultimate goal is to provide astronomers with a novel method for analyzing the spatial configurations of planetary systems, thereby enriching our understanding of the universe's myriad worlds. Expected outcomes include a highly accurate equivariant computer vision model, comprehensive performance evaluation, and extensive documentation to support further research and potential real-world applications in exoplanet discovery and characterization. Through this endeavor, we aim to not only advance the field of astrophysics but also to demonstrate the transformative potential of machine learning in uncovering the secrets of the cosmos.

Currently, Beam has code completion plugins for Python and Golang SDKs in JetBrains IDEs. For example, Pycharm has a plugin called Alabaster that suggests beam transforms after typing a pipe character. However, IntelliJ IDEA does not have code completion for the Beam Java SDK. In this project, I will implement an IntelliJ Plugin to auto-complete beam transforms for Java SDK users using a Starcoder Language Model.

This project transforms TensorMap into a complete neural network design studio by introducing a data driven layer registry, expanding support to 15 layer types, enabling real time training visualization, model export in industry standard formats, post training interpretability tools and automated hyperparameter tuning. The system will improve scalability, usability and developer productivity while allowing users to design, train, analyze and optimize models visually.

The aim of this project is to improve the robustness and functionality of the already existing exercises on Robotics Academy: Digit Classification and Human Detection. The frontend of these exercises will be migrated to React, and the appearance of these exercises will be enhanced. The project will also implement ONNX tools like model quantization and graph optimization to reduce computational costs during model execution. In the end, the necessary documentation will be updated to include these changes and guide students to learn better.

There are so many projects generated in Music Blocks We will be creating a lesson plan for these projects using LLMs. we will be using Quantized Ollama2 models to solve this problem. We will be fine-tuning the model using the guide of the Music Blocks and converting the JSON files of the project to the script files so that the LLM can understand and create a GUI such that it can store all previous conversations and first there will be a little bit conversation about the project between the user and the LLM, based on this the LLM will be generating a Lesson Plan.

<p>The TripPy architecture brings transformer models to Goal-oriented Chatbots. While setting new SoTA results on MultiWOZ among others, TripPy also simplifies the previous standard architecture. A better + simpler solution is what we strive for in all fields. This project implements TripPy in DeepPavlov to allow anybody to build fully functional Dialog Bots on top of TripPy leveraging the DeepPavlov ecosystem. Further, the project includes a simple demo in the form of a WeatherBot as well as a more complex chatbot demo built on the new model in DeepPavlov.</p>

This project intends to develop cutting-edge machine-learning tools for spectral analysis to characterize the atmospheres of exoplanets. The project will explore various state-of-the-art and recent techniques to build a robust and general model with strong regressional properties. The resultant models from our study will be benchmarked against pre-existing baselines based on the principles of statistics and atmospheric sciences. Additionally, relevant tutorials and documentation will be provided, keeping future developments in mind. We propose simulation-based inference, causal representation learning and domain-adapted transformers for atmospheric retrievals.