Skip to content

Google Summer of Code 2024

Jump to bottom
Alexander Pitchford edited this page Feb 5, 2024 · 8 revisions

QuTiP has participated very successfully in Google Summer of Code for the last four years, and we are once again participating in Google Summer of Code (GSoC) 2024 under the NumFocus umbrella.

Current project ideas

See here.

Past projects

You can look at the 2020, 2021, 2022 and 2023 student project blogs to get an idea of the kinds of projects we've offered and the experience of working on them:

Learning about QuTiP

The best way to learn about QuTiP is to study the lectures and tutorials on our website. If you need help, then look first in the documentation, then the Help Group - post a message if you need to.

Other resources to learn about QuTiP are:

How to apply

QuTiP participates in GSoC via NumFocus, so start by reading the NumFocus guidelines for students.

You will need to register on the Google Summer of Code website - https://summerofcode.withgoogle.com/ and make a final proposal before the deadline. You can add your draft and contact respective mentors so that we can provide feedback before the deadline.

Application deadline: March 18 - April 2

In order to demonstrate your communication, technical skills, and or, scientific knowledge, we encourage applicants to complete one or more small tasks before applying. Suitable tasks might include making a small improvement to any part of QuTiP (documentation, tutorials, the code itself, the QuTiP web site), reviewing open pull requests, debugging issues, replying to questions on the mailing list. There is no specific task checklist, but some examples are:

  • Submit a pull request in QuTiP solving some issue from the issues page.
  • Make some helpful suggestion of how to resolve some issue or enhance the toolkit. The more specific the better.
  • Help some user who is having technical or usage problems on the Help Group

If you do complete one or more tasks, be sure to refer to them clearly in your application.

Note that there are multiple QuTiP GitHub repositories where contributions might be made:

All have open issues. Those labelled 'help wanted' and 'good first issue' are a good place to look.

Understanding of quantum dynamics, technical (programming) skills, and being helpful to users, are all highly valued by QuTiP.

Make sure to read the Contributing to QuTiP Development guidelines if you are submitting a Pull Request.

We encourage prospective students to email the admin team at qutip-admin@googlegroups.com and introduce themselves.

There is a template proposal from NumFOCUS for the student application at https://github.com/numfocus/gsoc/blob/master/templates/proposal.md and an archive of past projects, including QuTiP's, at https://summerofcode.withgoogle.com/archive/. You are welcome to deviate from the proposal template if you wish.

Project ideas

Here are some project ideas that have been proposed by our core development team. Note that you are welcome to submit a proposal for a project idea of your own devising that you believe fits within our organization. This could be an addition to one of our existing packages or a new complementary package. A list of project ideas can be found in qutip: just open a pull request or email the admin team at qutip-admin@googlegroups.com if you'd like to propose a new idea.

Summary

1 - QuTiP Control ML Optimization

2 - Enhanced Quantum Circuit Diagrams

3 - qutip-jax solver enhancement

1 - QuTiP Control ML Optimization

The control package inside of qutip has been refactored and extended in the last 6 months. It will soon be released as a new package 'QuTiP QOC'. The new developments include global optimization methods, such as basin hopping. The aim of this project is to add machine learning (ML) based global optimization, using methods such as deep and reinforcement learning.

In practice, finding a set of control functions that maximize the desired outcome (typical fidelity of the quantum operation) becomes increasing difficult as the complexity of the system grows. For instance, as we increase the number of qubit systems in a register, finding the pulse functions to drive a computation becomes a very difficult problem. ML algorithms can learn something of the control optimization landscape such that efficiency in finding such sets of optimal functions will become more efficient.

Project size:

  • 350 hours

Difficulty:

  • Hard

Deliverables:

  • ML optimization module(s) that can used within qutip packages
  • Integration of ML modules with the qutip-qoc package

Skills:

  • Familiar with Python
  • Familiar with Git
  • Familiar with ML methods
  • Some understanding of quantum dynamics (helpful)
  • A basic understand of control theory (helpful)

Mentors:

2 - Enhanced Quantum Circuit Diagrams

QuTiP QIP includes the ability to render quantum circuits in Jupyter notebooks using LaTeX. However, installing and rendering LaTeX is an onerously additional task for novice, and even experienced, users.

The primary goal of this project is to replace QuTiP QIP's circuit rendering with a pluggable framework and to implement both text-only and Matplotlib based renderers. The text-only rendererer should allow circuits to be rendered in terminal Python consoles and Jupyter notebooks without requiring any dependencies not included by default. The Matplotlib renderer should allow circuits to be rendered beautifully in Jupyter notebooks with only Matplotlib required as an additional dependency. The existing LaTeX renderer should be ported to the new pluggable framework and there should be a means to select the rendering backend and an intelligent, but not too intelligent, selection of a default renderer.

A secondary but important goal is to render the circuits beautifully. The existing renderer is functional, but it would be better to have circuits that users would be proud to include in their documentation, academic papers and presentations. Specific improvements which could be made include a better ability to label wires, better distinguishing of classical and quantum wires, the ability to display sub-circuits and organize the gates in the rendering, better default font choices, more useful rendering of custom gates, the addition of colour, the ability to render barriers between sets of gates, and the option to style the plot in useful ways.

The addition of the text-only and Matplotlib renderers should also enable the rendering of circuits in Try QuTiP, a version of QuTiP that runs entirely in the browser when LaTeX is not available.

Implementations in other projects:

Project size:

  • 350 hours

Difficulty:

  • Medium

Deliverables:

  • a pluggable framework for rendering quantum circuits
  • a port of the current LaTeX renderer to the new framework
  • a new text-only circuit renderer
  • a new Matplotlib-based circuit renderer
  • a means to select the renderer and intelligent selection of the default renderer
  • unit tests for all of the above
  • documentation for all of the above
  • example notebooks for all of the above

Skills:

  • Familiar with Python, Jupyter, git and GitHub.
  • Familiar with the basics of quantum circuit diagrams.
  • Willing to learn a lot.
  • Excited about beautiful diagrams!

Mentors:

3 - qutip-jax enhancement

QuTiP has recently improved its solver module to extend its flexibility and allow different Integrator (ODE solvers). Integrator in qutip are the classes responsible for the low level computation of the evolution of a Quantum state. These are used in the QuTiP's solvers (see sesolve, mesolve, smesolve) to provide a user friendly interface for the computation of the time dynamics of a wide variety of systems. QuTiP also includes a data layer to represent its main class, Qobj, using different array interfaces. The data layer has been extended in previous projects (some of them GSoC) giving birth to a family of packages (TensorFlow, CuPy and Jax) that allow, among other things, GPU operation and auto-differentiation of QuTiP's Qobj. Those data-layers open new avenues for quantum control applications in QuTiP, where the auto-differentiation of a system evolution may provide and improvement in performance.

A first step to extend the auto-differentiation capabilities of qutip has recently been carried out on qutip-jax implementing an Integrator (DiffraxIntegrator). This allows sesolve and mesolve to support auto-differentiation. However many other qutip's functions still do not support this feature due to the use of numpy or cython.

Your task as part of the GSoC project will be to implement a user friendly interface to include derivatives int the result object from the solvers, add support for jax.grad in qutip.metrics and create example notebook for these features, possibly in the context of quantum control.

Project size:

  • 350 hours

Difficulty:

  • Medium

Deliverables:

  • Design and implement a user friendly interface to use solvers together with jax.grad .
  • Add documentation showing examples of use for jax.jit and jax.grad in the context of Qobj operations and solvers.
  • Create example notebooks. such as converting the following notebook from qgrad:

Skills:

  • Familiar with Python and Git
  • Understand the concepts of Python closures and decorators (which are used widely in JAX function transformations).
  • Familiar with JAX (beneficial, but not required)

Mentors:

Clone this wiki locally