Explore Projects

<p>Implementation of mid-level features - specifically routing, load-balancing, cookie/session handling, and authentication.</p>

<p>Machine learning models are being used to assess loan and job applications, in bail, sentencing and parole decisions, and in an increasing number of impactful decisions. Unfortunately, due to both bias in the training data and training methods, machine learning models can unfairly discriminate against individuals or groups. While there are many statistical methods to alleviate unfairness, there’s a growing awareness that any account of fairness must take causality into account. This project aims to implement causality-based tools for checking and forcing fairness into the Julia ecosystem of machine learning tools. Specifically, we intend to extend the packages Fairness.jl and MLJ.jl to include methods that implement counterfactual fairness, a recent definition of fairness. We will do so building upon principles of causal graphical models and causal probabilistic programming, as implemented in languages such as Omega.jl and CausalInference.jl.</p>

This proposal intends to implement a distributed array for the Dagger.jl package, loosely inspired on DistributedArrays.jl and improving on the current baseline implementation of the Dagger.jl distributed array object, possibly via a complete overhaul, including support for the MPI subpackage, as well as known factorization algorithms and schemes such as QR, LQ, LU with partial pivoting, and SVD. The basic array operations will take as a basis the Basic Linear Algebra Subprograms, using julia native implementations. The main products of this will be a basic but very functional and helpful set of distributed operations for high performance algebra and array manipulations in conjunction with the finished implementation for the MPI subpackage of Dagger.jl.

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.

<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>

<p>This proposal consists of the design of an API for Iterative methods in Julia and the set up of benchmarks and a regression tracker.</p>

<p><a href="http://zxcalculus.com" target="_blank">ZX-calculus</a> is a graphical language that can characterize quantum circuits. It is a powerful tool that is usually used for quantum circuit simplification. <code>ZXCalculus.jl</code> will implement quantum circuit simplification algorithms based on ZX-calculus in pure Julia. Also, it will provide interfaces to import and export quantum circuits to the form of YaoIR, an intermediate representation for quantum programs in the <a href="https://github.com/QuantumBFS/Yao.jl" target="_blank"><code>Yao.jl</code></a>. So that one can get quantum circuits with higher performance automatically when designing quantum programs with <code>Yao.jl</code>.</p>

<p>We will create a wrapper for the FEniCS toolbox in Julia, using PyCall.jl , to allow Julia users direct access to the FEniCS functionality. This will allow existing users to access more features in Julia. Furthermore, it will help with the adoption of Julia across the scientific community, as more packages and libraries will be on offer, making it an attractive option to them.</p>

<p>This proposal is about implementing HTTP/2 for HTTPServer.jl and Requests.jl, as well as implementing a heuristic for Mux.jl for HTTP/2’s “server push”. In the end, It is expected that Mux.jl, HTTPServer.jl and Request.jl users can seamlessly transit to HTTP/2 with little changes on their sides.</p> <p>Here are some expected outcomes of this project.</p> <ol> <li>A new, unified version of the HTTPServer module and Requests module for both HTTP/1.1 and HTTP/2. The API "disables" certain methods and options for a HTTP/1.1 connection.</li> <li>Extensions such as Alternative Services and Opportunistic TLS will be implemented in HTTPServer.jl and Requests.jl.</li> <li>Specifically for HTTPServer.jl, expose a nice “server push” API that allows other libraries to specify what other resources to push along with the requested resources.</li> <li>In Mux.jl, build a middleware for HTML and CSS to extract resources to be “server pushed”. Good documentation and tests for those middlewares.</li> </ol>

<p>JuliaGaussianProcesses is an effort to build a robust Gaussian Processes framework in the Julia ecosystem. We would like to start off by adding the capabilities of Prof Rasmussen’s GPML to it. The whole project would be done keeping simpler maintenance, extensibility and existing well maintained Julia packages in mind to avoid repeated efforts both now and in the future.</p>

<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>

My proposal is to bring in core changes to Javis' Object - Action mechanism for making animations . As of now Javis does not store drawing information as a data-structure but a function at compute time. The Object is drawn to the canvas by a function call at render time. The proposal has 3 parts. First - pre-compute the polygons/paths that an Object will place on the canvas, and have that information as a field in the Object. This part involves hacking into functions in Luxor.jl to store/return the information of drawn paths somewhere. Second - Bring in the ability to partially draw an object with the above paths at hand. Also implement functions to animate the "creation" of the object being shown. For example if the Object were a circle , the creation animation would draw an arc increasing its angle from 0 to 2Pi . Third - Bring in the ability to morph an Object into another. For example turn a square into a circle. The current implementation of Morphing in Javis has certain limitations, with the proposal implemented any arbitrary Object would be morph-able into another Object

<p>Bridge the gap between Python community and the Julia community for the state of the art natural language processing models.</p>

Graph Neural Networks (GNNs) are powerful tools for processing graph-structured data, with applications spanning social networks, recommendation systems, molecular modeling, and beyond. The Julia package GraphNeuralNetworks.jl, based on Flux.jl, provides access to common graph convolutional layers, offering a flexible framework for building GNN models. Sparse computations are essential for the efficient implementation of GNNs, since many operations, such as propagating node features, can be expressed as the multiplication of a sparse adjacency matrix with a dense feature matrix. Improving these operations through enhanced GPU kernels and fused operations is critical to reducing memory overhead and increasing the overall performance. This project aims to address these limitations by enhancing CUDA.jl’s sparse matrix support and integrating these improvements into GraphNeuralNetworks.jl, ultimately enabling faster and more scalable GNN computations in Julia.

ConformalPrediction.jl is a package for Predictive Uncertainty Quantification through Conformal Prediction for Machine Learning models trained in MLJ. This project aims to enhance ConformalPrediction.jl by adding support for the Conformal(ized) Bayes technique. The conformalized Bayes technique integrates conformal prediction with Bayesian inference to create prediction intervals that have the desired frequentist coverage properties while still being informed by the Bayesian posterior distribution. The integration will be carried out while maintaining consistency with the existing codebase, ensuring seamless incorporation of new functionalities. In addition to this primary objective, new methods for assessing the quality of probabilistic estimates and new recalibration method will be integrated into LaplaceRedux.jl, which is a library written in pure Julia that can be used for effortless Bayesian Deep Learning through Laplace Approximation (LA).

<p>The goal of this project is to implement the <a href="https://deepmind.com/blog/article/muzero-mastering-go-chess-shogi-and-atari-without-rules" target="_blank">MuZero</a> algorithm in Julia, with the following expected benefits:</p> <ul> <li>attract people from the model-based RL community to Julia</li> <li>showcase Julia in an ambitious project that leverages its greatest strengths, and which could not be achieved using another language (with the same level of performances vs flexibility and simplicity)</li> <li>make another step towards a generic and flexible RL framework by implementing MuZero on top of <a href="https://github.com/jonathan-laurent/AlphaZero.jl" target="_blank">AlphaZero.jl</a>, reusing as much code as possible and creating new abstractions if necessary</li> </ul>

<p>Environments are a crucial component of <a href="https://en.wikipedia.org/wiki/Reinforcement_learning" target="_blank">reinforcement learning (RL)</a>. Grid worlds are a broad class of tile-based games that are easy to create, and are quite popular for testing and comparing various RL algorithms. They are highly versatile and provide immense flexibility in terms of creating custom environments that can test for specific properties like safe exploration, for example. <a href="https://github.com/JuliaReinforcementLearning/GridWorlds.jl" target="_blank">GridWorlds.jl</a> is a <a href="https://julialang.org/" target="_blank">Julia</a> package that provides a suite of grid world environments along with useful primitives that aid in creating custom environments.</p> <p>This project redesigns GridWorlds.jl in a way that makes it simpler, easy to understand, and more performant (in some cases) than the previous version (v0.4.0). The new version (v0.5.0) also decouples itself significantly from the API of <a href="https://github.com/JuliaReinforcementLearning/ReinforcementLearning.jl" target="_blank">ReinforcementLearning.jl</a>, which makes it easy to create entry points from other reinforcement learning frameworks. It also becomes possible to programmatically record, replay, and analyze an agent’s behavior at any point during training, which proves handy while performing reinforcement learning experiments. Moreover, one can directly play the games from GridWorlds.jl inside the Julia REPL.</p>

<p>I want to write code to translate the syntax supported by Query.jl into SQL. Then, the queries can be sent to a variety of database softwares. I can take inspiration from implementations in other programming languages (notably LINQ). This work will benefit any user who works with tabular data in Julia. The process to translate code to work optimally with columns might overlap with the process of translating code into SQL. If I am successful translating to SQL code, I will start working on column-based optimizations afterwards</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.

This project aims to further enhance the performance and usability of tensor network tools in Julia. There are three main goals of the project: 1) extending the optimization methods in OMEinsumContractionOrders.jl with the state of art contraction order optimization algorithms; 2) implementing a hyper-graph visualization tool for tensor networks as a standalone package; 3) porting the contraction order optimization algorithms in OMEinsumContractionOrders.jl to the TensorOperations.jl package as a backend. Testing and documentation will also be done for all implemented methods, and the code will be open-sourced and published to the Julia community.

<p>The main goal of the project is to port capability from​ sktime​ (Machine learning for time series) to MLJ universe &amp; develop data container to handle time series data in modular, composable way.</p>

<p>DifferentialEquations.jl is the state of the art differential equations solver that exists right now. Being written purely in Julia and having a huge number of algorithms - this package provides both complete and easy interface for users. Being said that, to maintain this state of the art performance, we need to keep updating the code and always need to have a right check in terms of performance. This project aims to do the same. The project aims to - reduce the memory consumption of the solvers, increase the speed (step optimizations), increased number of options for optional optimizations and improved benchmarking techniques.</p>

GPU computing provides substantial performance gains over CPU-based methods for computationally demanding tasks. Trixi.jl, a Julia numerical simulation framework for hyperbolic conservation laws, currently lacks native GPU support. This project aims to accelerate PDE discretization in Trixi.jl using GPUs via CUDA. Key subtasks include developing a simple 1D CPU code, extending it to 2D and 3D, porting it to GPUs, prototyping GPU implementations of existing Trixi.jl kernels, optimizing data transfer, and expanding GPU support for more complex methods and GPU types. The final deliverable will offer high-performance PDE solvers on GPUs, showcasing the benefits of GPU acceleration in Trixi.jl.