Explore Projects

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

<h3>Parallel Graph development</h3> <p>I am interested in working on parallel graph algorithms and an efficient data structure to represent Graphs, which take advantage of Julia’s parallel environment. The data structure would be based on LightGraphs and all algorithms that I intend to code would be an addition to LightGraphs.jl . The algorithms would be Implementation of various research papers published and data structure would be such that it minimises overheads in parallel computations .</p>

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

<p>Support parallelism in Bio.jl based on Dagger.jl</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>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>

The main points of my proposal are as follows: 1. Add more and more datasets: To enrich MLDatasets.jl with relevant Graph Datasets. 2. Build a tight integration with GraphNeuralNetworks.jl The graph datasets are built to be used with libraries like GraphNeuralNetworks.jl(still in it’s beta stage), we can build the MLDatasets.jl graph datasets to be first class compatible(usable without little to alterations). 3. Consistent Structure The data for MLDatasets are sourced from different websites, who in turn use their own variable names and specifications. Currently MLDatasets does-not enforce any fixed api for data-access, so an end-user needs to refer to the docs for each dataset. Maintaining a fixed API for a dataset will make the repository more usable. 4. Loading of Large models: Most of the modern day datasets does not fit into [personal] computer memory. The dataset needs to chunked before it can be loaded into memory. MLDatasets.jl currently lacks methods for chunking, so developing methods for loading large [Graph] Models in memory necessary.

<p>The goal of this project is to implement the IntervalLinearAlgebra.jl package within the JuliaIntervals organisation and have the first release at the end of the programme. JuliaIntervals develops packages related to interval arithmetic, a mathematical framework to perform rigorous computations, treating all quantities as intervals and producing as output of computations an interval guaranteed to contain the true result. Traditional linear algebra routines, such as solving systems of polynomial equations or even just computing the cube of a matrix have been proved to be computationally challenging and designing efficient algorithms for interval matrix computations has been an active research question for a few decades. During this project, state-of-the-art algorithms for interval linear algebra will be reviewed and implemented. As linear algebra is central in practically all numerical applications, the successful completion of the project will allow to expand interval arithmetic methods also to other domains, such as reachability analysis, optimisation and differential equations solvers.</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>I propose to</p> <ol> <li><p>Add a package for image segmentation as a part of JuliaImages with the following algorithms</p> <pre><code> * Thresholding - Otsu’s method and Adaptive thresholding * K-means clustering * Mean shift segmentation * Watershed segmentation * Felzenszwalb's efficient region merging algorithm * Shi and Malik’s normalized graph-cut based segmentation </code></pre> </li> <li><p>Add Histogram of Oriented Gradient feature to ImageFeatures.jl</p> </li> </ol>

<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>To realise the full potential of probabilistic programming languages (PPLs), it is essential to automate the inference of latent variables in the model, conditioned on the observed data. Hence PPLs usually come with built-in algorithms to perform Bayesian inference on such models automatically. However, due to the expressiveness of PPLs, it is very challenging to design general purpose inference algorithms for models specified in Turing-complete PPLs. Applications tend to build their own custom inference machines, which is time consuming and labour intensive. This proposal puts forward a recently introduced framework—the involutive Markov chain Monte Carlo (iMCMC), as a candidate for inference in a PPL, namely Turing. Such a framework would enable the automation of an implementation of a correct inference algorithm from user specifications in Turing. Moreover, Turing readily supports differentiable programming (in their HMC implementation) which is the main technical requirement of iMCMC. Early iMCMC developments in Gen show promising results compared to standard black box styled inferences. Hence, it would be desirable to have an implementation in Turing.</p>

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.

The proposal aims to integrate the Julia package Agents.jl (for agent-based modeling) with ReinforcementLearning.jl or Crux.jl, enabling intelligent agents in simulations to learn optimal policies via reinforcement learning. The integration will allow for dynamic, reward-based behaviors rather than static rule-based actions. The project involves updating the chosen RL library for compatibility with the latest Julia version, building a lightweight interface (ABMEnv) to connect it with Agents.jl, and showcasing the integration through example applications like herding, civil violence, and predator-prey models. This work will expand the capabilities of Julia’s ecosystem for researchers in fields such as economics, social sciences, and robotics, while offering a standardized and accessible way to combine RL and ABM.

<p>DifferentialEquations.jl comprises of leading-edge methods for solving Differential Equations and an extensive benchmark suite written purely in Julia. Many methods have state-of-the-art performances, but still, some of them can be accelerated for high-performance returns. This project aims to maintain the same standards and improve benchmark performances of various solvers. In essence, the project will emphasize increasing the speed through iterative optimizations, bug fixes and improvements, reduce redundant memory allocation and improved benchmarking.</p>

The crate cargo-semver-checks provides feedback to user based on what possible breaking changes they may have made, which as per semantic versioning may require that the user accordingly update the semantic version of their library. This ensures that major breaking changes do not occur without notice. However, the feedback from cargo-semver-checks is not always the easiest to understand, in that whatever problem may actually be present is not always obvious. Additionally, cargo-semver-checks sometimes suffers from false-positive, where it detects a breaking change where there is none. This project proposes to remedy many of these issues by leveraging the existing lint data to implement so-called "witness programs", which are designed to demonstrate the breaking change by compiling successfully on a baseline version of the crate being tested, but failing to compile on the new version, due to the error caused by the breaking change. The plan is, following some research at the start, to implement a basic witness system that allows for additional internal queries and generation of a witness program from a template. Following that, implement automated testing of these witness programs to verify they do fail when expected. In the event of an unexpected behaviour, the system should be designed to provide the user with diagnostic information and an easy way to submit an issue to the cargo-semver-checks team. Lastly, these witness program templates then need to be written en masse, utilizing the now created system to provide these witness programs to as many lints as possible. Ideally, by the end of the Google Summer of Code program, 80% of the current lints should have witness program templates. Additionally, it is planned to continuously engage with the Rust community so as to both inform members of the progress of this proposal, but also to encourage accountability over the process of developing this project.

<p>I want to extend the tutorial offered by LabLua for the Ceu language. As it is, when you write code on their website and press submit, the code is sent to their server, compiled and the result is sent back. The problem with this, is that it doesn't show the entire capabilities of the language. For instance if you write a program that prints a message every second for 10 seconds, it will return that message printed ten times in an instant. What I want to do by using Emscripten is to have a real time tutorial, so that after the server sends back the result, it will actually print the message every one second, for ten seconds. I will also want to create a second tutorial that implements SDL as well. SDL is a language that can create shapes and interacts with keyboard inputs and the mouse. There already is compatibility between Ceu and SDL and there is also compatibility between SDL and Emscripten. The challenge is to create a synergy with all three languages. I believe this to be feasible, because you can transform a Ceu program into a C program that can then be compiled with Emscripten.</p>

<p>Halide is a programming language that facilitates writing high-performance image processing pipelines. Its compiler internally uses a Term Rewriting System (TRS) in order to simplify complex expressions, which comprises over a thousand handwritten rewrite rules added by human compiler engineers. In order to strengthen the TRS by finding new rules that can rewrite input expressions that the TRS currently fails to simplify, a synthesizer was used to automatically generate 4127 verifiably sound rules. Experiments have shown that adding these rules lowers peak memory usage by up to 50%, while having relatively insignificant impact on runtime performance. However, adding every such rule increases compile-time and compiler code size. This project aims to address this problem by incrementally testing and assessing each rule and subsets of the rules, while adding them to the compiler only if they necessarily contribute to the peak memory reductions shown in the experiment or other improvements in performance.</p>

<p>I've been personally using Riot and Matrix daily for months at this point and have seen many issues thrown around in the development rooms between the core developers. I have made it my task to alleviate some of these, Analytics for one, the devs have been driving blind as far as how people use the app so providing fully anonymous analytics is very important. Discoverability is currently another issue, Riot is a completely frontend application so spidering it is near-impossible, this can be solved through making a read-only server generated view for spiders to work on. Time permitted I will also touch on making a slightly more involved bridging library and look forward until federation stabilises so that I can make an S-S bridge (no HS needed)</p>

This project aims to implement a debug draw mode for texel density of lightmaps and enhance the GPU Lightmapper by adding support for soft shadows and multi-image atlases.

<p>The project aims at implementing support for pseudo-localization in Godot. Pseudo-localization is an important tool for internationalization. It offers the developers a way to check if the project is internationalized properly without actually translating the project. For example, the <a href="https://en.wikipedia.org/wiki/Pseudolocalization" target="_blank">wikipedia article</a> on pseudo-localization gives an example on how pseudo-localization would translate <code>Account Settings</code> to <code>[!!! Àççôûñţ Šéţţîñĝš !!!]</code>. Thus, Pseudo-localization involves replacing all characters in localizable strings by some special characters along with adding some constant padding to check whether the UI is robust enough to handle changes due to change in locales.</p>

<p>Adding end-to-end encryption to libqmatrixclient for future support in Qt/libqmatrixclient-based client like Quaternion.</p>

<p>Integrated script editor in Godot lacks features found in editors like VS Code, Sublime, Emacs, etc. These editors are also more popular among developers and therefore are better to switch for usability. However, to implement core functionalities such as - Diagnosis, Registering custom symbols, jump to definition, etc a Language Server structure has to be adopted. For example, the client (say vs code) will communicate the godot language server to give desired result.</p> <p>Microsoft's Language Server Protocol (LSP) is flexible and powerful to implement these functionalities. It also supports many editors - VS Code, Atom, Sublime, etc. Hence, instead of writing complete extensions for each editor (client) using LSP servers can be reused while the client which is an editor extension has to be only re-written.</p>