Explore Projects

<p>The goal of this project is to extract Cancer Genomic data available from NCI's Genomic Data Commons and transform them according to the file formats required by cBioPortal. There is currently no ET pipeline existing to import data from NCI data repository and this project will add this feature to cBioPortal. The user will simply need to run a Batch that will transform genomic data from GDC into accepted file formats.</p>

<p>GrimoireLab is a powerful open-source platform that provides support for monitoring and in-depth analysis of software projects. It produces a rich set of dashboards, which can be easily inspected by decision-makers to help them understand the evolution and health of their projects. Despite the large set of dashboards available in GrimoireLab, comparing projects between each other is not straightforward since it requires navigating and drilling down the data in different dashboards.</p> <p>Prosoul is a web application that empowers decision-makers with the means to create and manage their own quality models, which are useful means to evaluate and compare software projects. This project idea is about supporting the definition of Quality Models using GrimoireLab data and Prosoul.</p> <p>The main aim of the project is to design an approach to shape the GrimoireLab data in a format that can easily be consumed by Prosoul and implement it on the data obtained from a few data sources like git, github and mailing list repositories to obtain simple quality models.</p>

This proposal aims to increase code coverage on the DRM core helpers with meaningful tests. Unfortunately, it is impractical to have 100% coverage on all core helpers in such a small time frame, so I will focus on the drm_format_helper.c, which makes the conversion between color formats. Parallel with developing the tests, I will improve the kernel-doc when needed, create blog posts about the process, and study the DRM subsystem. Moreover, with the knowledge gained, I will improve the xfrm functions to work with multi-plane formats.

<p>In forested mountain landscapes wood can significantly increment the total flow volume during a flooding event. The presence of large wood on river sides has positive effects on hydrogeomorphological diversity of habitats and represents a source of organic nutrients in the water. Therefore a compromise should be reached in the management of vegetation (within river corridors and on connected unstable slopes) aiming to reduce flood hazard while preserving its function of large wood supply for river ecosystems. The idea of the project is to develop in gvSIG a model for the evaluation of the hazard derived from large wood transportation during flooding events. The simplified GIS model should consider:</p> <ul> <li>the effective presence and characteristics of the vegetation in the inundable river corridors for the log requirement</li> <li>the characteristics of the flow in the stream network for the transportation of the logs downstream. With this model the user will be able to make an analysis of the hazard and risk related to the transport of wood during flooding events on a complete river stream with known and commonly used/available GIS data, using directly in a GIS for displaying input and outputs.</li> </ul>

WasmEdge is a lightweight inference runtime for AI and LLM applications. We want to build specialized and finetuned models for WasmEdge community. The model should be supported by WasmEdge and its applications should benefit the WasmEdge community. In this project, we will build and compare two finetuned model for Rust coding assistance. A code review model. It aims to be a new backend for the PR review bot (https://github.com/flows-network/github-pr-summary/) we currently use in the community. A QA model. It should be able to answer user questions about the Rust language and provide explanations. Our goal is to provide an alternative to our Learn Rust app (https://flows.network/learn-rust). Expected Outcome: Two finetuned models based on Llama3-8b for Rust code review and QA.

<p>Constraint-Based Reconstruction and Analysis (COBRA) methods for Genome-wide Metabolic Networks (GEMs) have proven to be essential for the varied applications of metabolic modelling, from predicting growth rate of an organism to production of antibiotics and lethality analysis to name a few. FBA or, Flux Balance Analysis is the earliest COBRA method and the most widely used. But, currently, we have sub-divisions of metabolic modelling strategies which are uncovering the flaws of FBA. To fix these flaws, we have been developing multiple methods which are also being backed by experimental data. So, now we are integrating data from experiments in the models and developing methods for a much better understanding of the metabolic pathways and functionalities of the organisms. The data-driven approaches provide more information about the models and hence provide us with a deeper understanding of the networks.</p>

Beam's Python SDK is increasingly the first choice for ML and data-intensive pipelines, making robust native streaming APIs more important than ever. However, two essential streaming primitives, UnboundedSource (Issue #19137) and Watch (Issue #21521), remain unavailable in Python despite being long established in the Java SDK. Today, Python developers who need these capabilities either pull in cross-language transforms that add Java dependencies and gRPC overhead, or wrestle with low-level RestrictionTracker internals. This project solves the problem by porting both primitives natively to Python on top of Beam's existing SDF framework. The UnboundedSource wrapper adapts the legacy reader API into a Splittable DoFn that handles checkpointing, watermark progression, deduplication, and splitting. The Watch transform adds periodic polling with composable termination conditions and stable dedup behavior. Porting both primitives natively abstracts away that complexity behind clean and Pythonic interfaces. It also unlocks native enhancements, such as updating fileio.MatchContinuously, without leaving the Python ecosystem. The planned deliverables are: (D1) a Python UnboundedSource API with its SDF-based wrapper, (D2) a native Watch transform with PollFn and TerminationConditions, (D3) a test suite spanning DirectRunner and Dataflow, and (D4) supporting documentation including docstrings, programming-guide updates, and migration notes.

THE PROBLEM: Solving partial differential equations (PDEs) for parametrical studies is a fundamental part of scientific research, but traditional many-query Finite Element simulations are highly computationally expensive and suffer from performance bottlenecks. THE SOLUTION: This project aims to drastically reduce simulation times by integrating modern machine learning into the Gridap.jl ecosystem. The plan is to augment GridapROMs.jl with nonlinear neural operators. The work plan is split into three phases: 1. Benchmarking: Generating high-fidelity training data from 1D test cases to evaluate and compare external neural operators (via NeuralOperators.jl) against standard linear Reduced Order Models (ROMs). 2. Implementation: Integrating the best-performing neural architectures to solve more complex, real-world physics problems, such as heat equations with nonlinear coefficients and turbulent fluid dynamics. 3. API Extension: Extending the GridapROMs.jl API to unify traditional linear models and the new nonlinear neural operators under a single interface. DELIVERABLES: - A public repository containing data generation scripts, training loops, and a comparative performance report of the tested models. - Validation scripts showing the core implementation works on complex physics problems. - A final Pull Request to GridapROMs.jl containing the extended API, unit tests, documentation, and user tutorials demonstrating the end-to-end workflow.

This proposal highlights some key points and expected results of the project. The project proposes developing an open-source Graphical User Interface (GUI) that integrates with various foundational models for image segmentation tasks. A key strength lies in its ability to leverage multiple models, empowering users to tackle diverse image segmentation challenges. I propose completing this project in three phases: First, we will determine the range of image segmentation domains covered by our application. Then, we will select frameworks to design the GUI's frontend and backend sides. Lastly, We will test the GUI for user-friendliness and prepare it for open-source release, along with the complete documentation

As interest in large language models continues to grow, many open-source implementations exist across various frameworks—but accessible, modular, and well-documented implementations in Flax, built on JAX, remain limited. This lack of resources makes it more difficult for developers and researchers to understand, experiment with, and extend LLMs in the JAX ecosystem. This project addresses that gap by implementing one or more open LLM architectures in Flax. The goal is to provide reference models that are easy to read, modify, and build upon. The project will also include a comprehensive test suite to ensure reliability, and an interactive educational notebook that explains the architecture, shows how to load pretrained weights, and demonstrates how to run inference.

Backward bounded model checking is a technique for program analysis that aims to solve the error location reachability problem by searching for execution paths from an error location to the initial location and determining their feasibility, whereas regular forward techniques search for paths from the initial location to an error location. The main aim of this project will be to formulate the backward bounded model checking algorithm within the framework of CPA and develop an implementation in CPAchecker. This will also require figuring out which components already provide support for backward analysis in CPAchecker and developing support where it does not already exist. Once backward analysis is supported and the algorithm is implemented, it can be tested and benchmarked on a set of programs to evaluate its performance.

<p>In this proposal, I propose a solution for using openEASE as a knowledge bridge between robots. For this, I aim to implement a module in openEASE called openEASEclient (oeClient). This module will make robots connect to openEASE using web sockets and services without a need of web front-end. This module will, also, offer SWI-Prolog predicates as API so that robots that have KnowRob available can easily interface. After the implementation and testing of oeClient, I will try to exchange static ontologies between PR2s. Then, I conductsome grasp learning experimentusing EULisp. The data gained from these experiments will be used to train models using learning modules in KnowRob. After validation of learned models, these models will be transferred to PR2 in Bremen using oeClient. Finally, I will test the learned models with PR2 in Bremen and validate the success of the implemented methodology.</p>

In this project, I propose to create NLP examples using transformer implementations from the Hugging Face Library; by developing easy-to-use and easy-to-understand Deep Learning pipelines for solving various NLP tasks. In the recent past, transformers have achieved state-of-the-art results in tasks like Question Answering, Machine Translation, etc. and the goal of my finished result is to develop additional code examples and Jupyter notebooks similar to Keras Examples that can be used by new-comers and other people at various stages of their learning journey to easily understand various deep learning workflows for complicated tasks. My proposed tasks include Speech Commands Classification, Abstractive, and Extractive text summarization, and Automatic Speech Recognition.

Scrum Helper is a Chrome extension that helps developers automatically generate scrum reports from their source control activity. Today, it works exclusively with GitHub, leaving out a large portion of development teams who rely on GitLab, Gitea, or Bitbucket for their daily workflows. This project extends Scrum Helper into a true multi-platform tool. By introducing a clean plugin-based adapter architecture, each SCM platform gets its own isolated integration while the core reporting logic stays platform-agnostic. The result is a more maintainable codebase that any future contributor can extend with minimal effort. By the end of this project, developers on GitHub, GitLab, Gitea, and Bitbucket will all be able to generate automated scrum reports from a single extension, without changing how they work.

<p>I listed three potential projects, the main directions are implement MLCV research papers with GPU CUDA accelerating and distributing API, and code examples with tutorials on Colab. I would like to do any one direction (implement more) or two directions (which works can be supplement and adjusted models for more improvement). ; For CUDA C++ accelerating, my current ideas are concurrency improvement (on host) and parallel and shared memory improvement (on device), and I open for urgent project of Eigen's Module. For develop core code examples, my current ideas are implement the most popular models such as Mask R-CNN, Fast R-CNN, YOLO etc, include example code and visualization tool), and also interested in development the GPU accelerating distributing API. For the TF model garden, my current ideas are implement the models listed in the Project2 or other new research paper by TF on Colab notebook.</p>

Alaskan communities face the frontline impacts of climate change. Accurately predicting coastal changes is crucial for adaptation, but current methods overlook dynamic factors like declining sea ice and variations in tidal, temperature, and energy wave data. To enhance coastal modeling, more digitized coastlines are needed due to the inefficiency of manual interpretation. The project aims to develop an automated system for extracting coastlines from PlanetLab images by using techniques like Normalized Difference Water Index (NDWI) thresholding and DeepWaterMap algorithms. The main challenge is developing the NDWI index, a method for image labeling for the training data, specifically the thresholding value for the label. While also considering other preprocessing algorithms for atmospheric correction, mosaicking, etc. Additionally, devising a robust validation method that considers temporal variation is crucial. The project aims to have a model that automatically extracts a vectorized coastline representation from PlanetLabs satellite imagery with high accuracy.

The primary goal of this project is to enhance and validate LiveHD's power modeling flow, a critical feature for estimating power consumption in modern hardware designs. The existing flow requires further refinement to ensure its stability, accuracy, compatibility with a wider range of netlists and VCD files, and overall performance. To address these challenges, the project will focus on methodically debugging the current implementation, establishing a comprehensive validation methodology for verifying the accuracy of power estimates, and optimizing the flow to handle larger netlists and VCD files efficiently. Additionally, the project aims to improve existing documentation by providing detailed explanations, examples, and tutorials to facilitate user adoption and understanding. Upon successful completion, the project will deliver a more reliable, accurate, and efficient power modeling flow within LiveHD, contributing to the development of energy-efficient hardware designs. This refined flow will not only enhance the capabilities of LiveHD but also encourage wider adoption and utilization by the hardware design community, fostering innovation in the field of energy-efficient devices and systems.

This project aims to develop a multi-modal foundation model training pipeline for end-to-end particle reconstruction in the CMS experiment. Building on last year's LorentzParT hybrid architecture (L-GATr + ParT) and its track-level masked autoencoder pretraining, I will design a unified tokenization scheme encoding particle kinematics and interaction features as distinct modality streams, and pretrain the shared encoder using a novel Cross-Modal JEPA objective that predicts masked token embeddings across modalities in latent space — combining, for the first time, JEPA-style self-supervision with Lorentz-equivariant representations. The pretrained encoder will be fine-tuned and benchmarked on multiple downstream tasks including event/jet classification and mass regression, with conditional generation as a stretch goal. Deliverables include the complete CM-JEPA pretraining pipeline, a multi-modal tokenizer, multi-task fine-tuning scripts, systematic ablation studies across pretraining methods and masking strategies, trained model checkpoints, and an open-source repository with documentation and a blog post.

Alaska's Arctic coastline is eroding rapidly, and tracking these changes at scale requires automated coastline extraction from satellite imagery. Manual digitization is too slow, and the existing pipeline has several gaps: training data includes cloud-affected and artifact-contaminated pixels, the dataset covers only 2017-2019, the model underperforms near coastal bluffs and in shadowed regions, and the pipeline outputs binary raster masks rather than the GIS-ready vectorized coastlines needed for erosion modeling. To address this, I have already studied the codebase end-to-end, fixed the bugs that were preventing the pipeline from running, and replaced the baseline U-Net with an Attention ResUNet - a pretrained ResNet-34 encoder with attention-gated skip connections and a combined BCE + Dice loss - achieving a Dice score of 0.941 and IoU of 0.921 on the current dataset. During GSoC, I will close the remaining gaps: integrate PlanetLabs Usable Data Masks to exclude bad pixels from training; expand the dataset to cover 2020 onward; improve segmentation in cliff and shadow regions; investigate SWIR and elevation data as additional inputs; and produce vectorized coastline outputs with per-transect erosion rates. The result will be a pipeline that runs from raw PlanetLabs imagery to quantified shoreline change, ready to apply across Alaska.

Implementation of a direct integration between SimNIBS and InVesalius to enable subject-specific head model generation and TMS electric field (E-field) simulations within InVesalius. Currently, head modeling and E-field simulations require external workflows and manual data handling. This project will integrate the full pipeline into InVesalius, allowing users to generate MRI-based head models, position and orient TMS coils using existing neuronavigation tools, configure simulation parameters, execute simulations internally, and visualize E-field magnitude (|E|) directly on 3D anatomical models. The activity will focus on implementing a Python-based interface to SimNIBS, aligning coordinate systems, handling simulation inputs/outputs robustly, and integrating results into the InVesalius visualization environment. Deliverables: Integrated MRI-based head modeling pipeline. Python interface module connecting InVesalius to SimNIBS. UI panel for head modeling and simulation configuration. Execution of TMS E-field simulations within InVesalius. 3D visualization of E-field magnitude (|E|). Technical documentation.

Enhance Meshery's existing orchestration capabilities to include support for kro ResourceGraphDefinitions (RGDs) as first-class Meshery Models (https://docs.meshery.io/concepts/logical/models). This involves enabling Meshery to manage and orchestrate RGDs, similar to how it handles other Kubernetes resources. The project will also include generating support for ResourceGraphDefinition in Meshery's Model generator. Expected Outcome: Meshery will be able to orchestrate and manage kro RGDs. This includes the ability to deploy, configure, and manage the lifecycle of RGDs through Meshery. The Meshery Model generator will be updated to automatically generate models for kro RGDs, simplifying their integration and management within Meshery. This will be an officially supported feature of Meshery.

<p>Click models are algorithmic approaches which help in the ​understanding relevance of documents over a given query by modeling the search queries in a particular fashion. Currently, Wikimedia Search uses Dynamic Bayesian Network[DBN] which is based on the probabilistic graphical model. An algorithmic model, Neural Click Model [NCM] has been proposed, which is not only more accurate than DBN but also provides a way to input semantic features apart from click data. This project is about implementing, testing and analyzing NCM verify if it provides any computational or prediction benefits to the current model and finally integrating with the Mjolnir library.</p>

<p>There is a long history of neuronal simulator-specific modelling in the fields of theoretical neuroscience and neuroinformatics. As a result, most of the single cell and neural network models have low RAPT (reproducibility, accessibility, portability and transparency). This has slowed the progress of using biophysically and anatomically detailed neural network models in understanding the brain function in health and disease. In a period of three months during the GSoC placement, I would like to contribute to the Open Source Brain (OSB) Initiative which aims to increase the RAPT of single cell and neural network models. The project will extend the initial work by the OSB on converting the thalamocortical network model by Traub et al. (2005) to the simulator-independent model format, NeuroML2. Firstly, I propose to annotate and implement the tests for spiking behaviour of Traub model cells which are converted to the NeuroML2 format. Secondly, I propose to create a generic Python-based package which can generate different configurations of cortical networks in the NeuroML2 format and combine unique network components from different cortical network projects.</p>