Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
<p>A leap forward in the accuracy of forecasting problems in chaotic time series has been recently obtained using Echo State Networks (ESN). This is a novel kind of recurrent neural network with a randomly connected hidden layer, called the reservoir, and an adaptable output layer trained using a simple regression algorithm. This architecture has the advantage of faster computation and presents less parameter tuning then a standard neural network. Since their inception there has been a lot of effort towards the improvement of the model and applications have been found in several fields of study: anomaly detections in geophysics , short term predictions in astrophysics and reconstruction of chaotic attractors among others.</p> <p>This project aims to build a comprehensive Julia package in which are implemented the majority of the variations of the ESNs presented in the literature. Such an effort would represent the first attempt to create a library for this kind of models in any programming language, and would reap benefits not only for the consequent simplicity of application, but also for showing the actual state of the art in a family of models that has yet to go mainstream.</p>
<p><a href="https://github.com/JuliaText" target="_blank">JuliaText</a> is the JuliaLang organization that provides with packages to work with text. It currently lacks support for basic problems like Named Entity Recognition, Part-of-Speech Tagging, Dependency Parsing etc. which help serves as the basis for various language processing problems and analysing text.</p> <p>I propose to implement practical models for Named Entity Recognition and Part-of-Speech Tagging in Julia and extensively test and validate them. Robust and well-tested APIs for these two tasks will be written.</p>
<p>I hope to develop a package, ParallelGraphs, that enables the analysis and manipulation of massive graphs in a distributed environment. The package will adhere to two separate computing models; The first being the vertex centric Pregel model that relies on Bulk Synchronous Parallel infrastructure. The second model is a combinatorial approach that involves matrix operations such multiplication and vector indexing on distributed sparse matrices. ParallelGraphs will enable users to process graphs using sequential algorithms on smaller graphs. This will be accomplished by providing compatibility with LightGraphs.jl. The package will also experiment will CPU/GPU parallel algorithms with an aim of unifying all graph computation models in a single package.</p>
The purpose of this project is to add Temporal Graph Neural Networks (TGNNs) to GraphNeuralNetworks.jl. The first part of the project will be dedicated to creating a temporal graph type and providing it with all the accessory functions. After that, new layers will be added to the package to build models that fall under the category of STGNNs. Thus, new datasets of temporal graphs will be included in MLDatasets.jl to be used for training the models. Finally, tutorials will be produced to complete the project, introducing the new temporal graph type and showing how to perform temporal graph tasks using the added data, model and features.
<p>My Proposal is to develop a feature detection and extraction package for Julia, ImageFeatures.jl. Alongwith feature detection and extraction, I will work on adding exposure correcting functions to <a href="https://github.com/timholy/Images.jl" target="_blank">Images.jl</a>. I plan to add the following functions over the course of the coding period :</p> <ul> <li>BRISK Descriptors</li> <li>FREAK Descriptors</li> <li>ORB Descriptors</li> <li>GLCM</li> <li>LBP</li> <li>BRIEF Descriptor</li> <li>CENSURE Keypoint Detector</li> <li>FAST Keypoint Detector</li> <li>Histogram Matching</li> <li>Histogram Equalisation</li> <li>Gamma Correction</li> <li>CLAHE Algorithm</li> </ul>
This projects aims to bring the well known ColBERTv2.0 information retrieval system to Julia! In this project, we aim to implement various components of the ColBERT model, with the major focus on indexing and search. Being a late-interaction retrieval system, ColBERT isolates all the computations between the queries and documents to enable pre-computing the document embeddings offline. Combined with a RAG pipeline as an embedding and retrieval backend, ColBERT can make the usage of existing AI tools really powerful. As part of the project, we also aim to apply this model to Julia's own extensive documentation (over thousands of packages), and integrate ColBERT with AIHelpMe.jl and PromptingTools.jl. Combine this with a locally hosted LLM, all Julia users get a powerful, modular, and easily hackable local AI assistant, allowing them to integrate ColBERT with their own RAG pipelines. The main deliverable of the project will be a new package (called ColBERT.jl), with the implementation design inspired from the original Python implementation of ColBERTv2.0 (i.e the centroids + residuals compression method). The project will also have an extensive number of addons, including, but not limited to, implementing the training module for this package, which will allow users to train their own ColBERT models instead of relying on pretrained checkpoints, and distributed training (using existing art like DaggerFlux.jl).
This project is aimed at advancing the capabilities of heterogeneous computing environments in Julia through Dagger.jl. We propose to implement a series of enhancements for significantly improving task execution efficiency, data transfer speed and robustness of distributed parallel computing systems. We place special emphasis on further development of streaming data processing for distributed heterogeneous systems with Dagger.jl. Heterogeneous computing environments leverage a combination of resources - such as CPUs, GPUs, DPUs - and face challenges in optimizing task execution and data streaming. Data transfer mechanisms are often inefficient or may lack robustness against system slowdowns or failures. The project will be supporting ongoing radio astronomy and ionospheric RADAR work at MIT and its Haystack Observatory — bringing about real-world impact in the short-term.
<p>The main goal of the project is to port capability from sktime (Machine learning for time series) to MLJ universe & develop data container to handle time series data in modular, composable way.</p>
<p>General-purpose statistical modeling tools such as OpenBugs and Stan allow using easy-to-build modular likelihood models to fit models to data through MCMC or other techniques. Crucial to the efficiency of such tools, especially as parameter dimensions increase, are tools like HMC, which allow use differentiation and/or conjugacy for continuous parameters, so that fitting is not solely a matter of getting lucky with random Metropolis-Hastings proposals. Yet some models, especially nonparametric ones, also require discrete parameters and/or hand-written jump steps; and existing tools for HMC generally don't play well with discrete parameters. My project is intended to generally improve the Julia toolchain for MCMC when there is a mix of continuous and discrete parameters. My work will be based on Mamba.jl; though when I can make something that will be useful to Klara.jl too, even better. To make that plan concrete, I'll be implementing CrossCat, a general-purpose nonparametric model for "medium-size" tabular data including missingness and various data types. (Roughly speaking, "medium-size" might mean p<1e3, n<1e5).</p>
<p>The aim of this project is to enrich Flux Model Zoo with unsupervised deep learning models, in particular variants of Generative Adversarial Networks. I propose to add the following models : 1) Spatial Transformer Networks 2) StarGAN for facial expression synthesis 3) VAE-GAN 4) Energy Based GAN 5) Gated Recurrent Convolutional Neural Network</p>
KomaMRI.jl is a Julia package for Magnetic Resonance Imaging (MRI) simulation focused on speed and extensibility. Like other MRI simulators, it solves the Bloch equations, for which the solution can be parallelized due to the independent spin property of the system. Although KomaMRI currently has built-in support for GPU and CPU parallelization, GPU support is CUDA-based and could be extended to work with different GPU backends. In addition, writing GPU kernels tailored for the solution implementation could significantly improve performance compared with the current array-based approach. The goals for this project are to update the KomaMRI.jl package to support Metal, AMD, and OneAPI-based GPU backends, and create a new BlochKernel simulation method which is fully kernel-based and optimized. If time permits, the use of MPI.jl and Distributed.jl to run MRI simulations across multiple nodes and GPUs will also be explored.
Working with the OMOP CDM (Observational Medical Outcomes Partnership Common Data Model) involves handling large datasets that require a set of tools for extracting the necessary data efficiently. The first part of the project focuses on improving JuliaHealth's infrastructure by increasing the range of tools available to users. This involves enabling connections to various databases, and working with observational health data. Our second goal is to leverage the capacity built in the previous phase to develop a comprehensive framework for patient-level prediction. This framework will predict patient cohort outcomes with given treatments and will be tested on the mimic iii data, and potentially on real aggregated and anonymized patient data.
<p>This project aims to get the GraphBLAS API working from Julia by connecting it to the SuiteSparse GraphBLAS implementation and creating a graph type backed by the methods provided in the library.</p>
<p>Support parallelism in Bio.jl based on Dagger.jl</p>
This project aims to significantly enhance the search experience within documentation generated by Documenter.jl. The current client-side search encounters difficulties accurately indexing and retrieving results for Julia-specific syntax, leading to suboptimal relevance. Furthermore, issues like unnecessarily large search indices and repeated listing of the same location hinder usability. This proposal outlines a plan to address these shortcomings by: 1) Implementing search performance benchmarks (relevance, precision/recall, index size) to measure and guide improvements. 2) Developing and integrating an improved, Julia-aware tokenizer within the search JavaScript. 3) Optimizing the index by investigating and removing redundant data, ensuring unique location entries are stored, and adding warnings for potentially problematic large indices. 4) Creating comprehensive developer documentation for the enhanced search system. The outcome will be a more robust, accurate, and efficient search capability for users navigating Julia package documentation.
<p>Flux.jl is a high-level neural network library in Julia, which has an intuitive API, easy to debug, and performant. One of the key features of Flux.jl is that it allows user to define a layer in Julia, using most Julia Array operations, while not to worry about size inference, grad calculations, etc. Unlike Knet.jl, a promising competitor of Flux.jl, which do all the tensor calculations from scratch with a lot of magics, Flux.jl simply transcompile the computation graph to mature backends like MXNet and TensorFlow. Thus, it can take the benefits of those advanced technologies and get a cutting-edge performance.</p> <p>Flux.jl is in alpha and lacks a lot of features before being actually useful. One of the problems is currently it only supports SGD optimizer without decay and momentum. It also only shows the progress during training, while saving checkpoints or doing custom evaluations once a while can help users to build a better model.</p> <p>After this program finished, Flux.jl will be able to:</p> <ul> <li>train a model with most popular optimizers like Adagrad, Adam, etc.</li> <li>hook functions at specific time point, such as after every 100 batches</li> </ul>
Pluto uses the Distributed module (part of Julia's stdlib) to create worker processes and to send Julia data structures between them. These worker processes cannot create other processes themselves, meaning that —in practice— Pluto notebooks cannot use Distributed. This project aims to solve this problem by replacing Distributed in the Pluto codebase with a new package for inter-processes communication, so that Pluto notebooks can use Distributed without any issues.
Currently, Symbolics.jl has a Groebner basis implementation which is able to convert a myriad of symbolic expressions into multi-variate polynomials. This can be incredibly useful for solving functions for their roots, but to do so, a root finder for these generated polynomials must be implemented. Moreover, multiple users of Symbolics.jl have requested a symbolic nonlinear solver. As such, the project aims to complete the following: 1- Solve single variable polynomials (even high degree ones n ≥ 4) and multi-variable polynomials (over 2 dimensions or more) 2- Solve transcendental / other types of non-linear equations (highly requested: issues #961, #468, and #866) 3- Ensure that the implementation is well tested and well documented to make it more user-friendly and help out future contributors of the project.
The state of Julia GPU support ranges from “very good” (CUDA.jl) to “on the way” (Metal.jl). Recently, the shared high-level interface GPUArrays.jl added support for KernelAbstractions.jl, which defines a common interface that can be used to write optimized kernel implementations once for all the downstream vendor-specific GPU packages such as CUDA.jl, AMDGPU.jl, Metal.jl, and oneAPI.jl. However, most optimized kernel implementations still live in the vendor-specific package they were written for, leaving the other packages to either reimplement their own version, use the current unoptimized fallback implementation from GPUArrays.jl, or in many cases, the operation is not supported. This project aims to rewrite these optimized operations in GPUArrays.jl using the KernelAbstractions interface to improve performance and functionality for all GPU backends at once. The end result being that users of the less mature backends will benefit from more functionality, as well as increasing the impact of future contributions for all users of the JuliaGPU ecosystem.
<p>The purpose of this project is to develop a flexible library of NN solvers (<strong>NeuralNetDiffEq.jl</strong>) which are able to utilize parallelization, and plugs into the <strong>DifferentialEquations.jl</strong> ecosystem giving user an easy option to switch to these methods. The problem to be solved and advantages of the proposed approach are discussed in the <strong>Introduction</strong> of the proposal. The library will implement as much of DE solver interface features we have in julia along with some integration with other related packages. The goals and timeline for the project are also discussed in the proposal. I have a single ODE solver as a prototype and code can be checked <a href="https://github.com/JuliaDiffEq/NeuralNetDiffEq.jl/blob/master/src/proto/DE-NN-Knet.jl" target="_blank">here</a>.</p>
<p>Virtually all properties of interest arise from electronic interactions between the atoms of a crystal.</p> <p>The work I propose aims to develop a physics-informed graph convolutional neural network architecture, inspired by the <a href="https://en.wikipedia.org/wiki/Tight_binding" target="_blank">Tight-Binding model</a> formalism. This would help us initialise weights with information from the Slater-Koster tables made available as a priori, which would theoretically help derive a more realistic, accurate and data-efficient representation.</p> <p>In addition to this, I also aim to help design and develop essential parts of <a href="https://github.com/Chemellia" target="_blank">Chemellia</a>; primarily <a href="https://github.com/Chemellia/ChemistryFeaturization.jl" target="_blank">ChemistryFeaturization.jl</a>.</p>
<p>Many problems in applied sciences are posed as convex optimization problems over the complex field such as MaxCut, Phase retrieval from sparse signals, designing a FIR filter given desired frequency response.</p> <p>The present approach is to manually convert the complex-domain problems to real-domain problems, then use domain specific languages like Convex.jl, cvx or cvxpy to get the solution of the corresponding real-domain problem and finally combine the solution from these languages to get the complex-domain solution. This process can be time-consuming and non-intuitive sometimes. The correct approach to such problems is to make our existing packages deal with complex-domain problems directly.</p> <p>The aim of the project is to add the support for solving complex-domain linear programs, second order conic programs as well as complex semidefinite programs (SDP) in Convex.jl (a Julia package for Disciplined Convex Programming).</p>
QuantumClifford.jl enables efficient simulation of Clifford circuits acting on stabilizer states using the (de)stabilizer formalism, with complexity O(𝑛²), where 𝑛 is the number of qubits. For sparse stabilizer states—those with a qubit connectivity of O(log 𝑛)—an alternative algorithm based on graph states achieves improved complexity of O(𝑛 log 𝑛). This project aims to implement this graph-states-based simulator as an alternative backend in `QuantumClifford.jl`. Specifically, the project will: support the simulation of generator gates {𝐻, 𝑆, Λ𝑍}, enable the decomposition of arbitrary Clifford gates into these three generators, and implement single-qubit Pauli measurements on graph states. The goal is to provide a seamless transition to the graph-based simulator through compatibility with existing `apply!` and `project!` APIs in `QuantumClifford.jl`.
MLFlowClient.jl lacks of updates regarding new features coming from the original Python package. Some effort is needed to ensure new version methods. My plan is to implement that novel features using pure Julia, increasing compatibility; and also new functionality to allow communication with MLJ.