Skip to content

Google Summer of Code 2021

Jump to bottom
Shahnawaz Ahmed edited this page Jun 7, 2021 · 22 revisions

We are participating in Google Summer of Code (GSoC) 2021 under the NumFocus umbrella. The three selected projects for GSoC 2021 are:

  • GPU (CuPy) backend for QuTip by Felipe Bivort Haiek.
  • TensorFlow data backend for QuTiP by Asier Galicia.
  • Quantum Gate Decomposition for QuTiP by Purva Thakre.

For future applications, please read 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.

You can look at the 2019 and 2020 students blogs projects to get an idea of the work:

Learn 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

Applications

In order to demonstrate your communication, technical skills, and or, scientific knowledge, please complete one or more of these tasks before applying. Be sure to refer to them clearly in your application. Note that we have three other associated repositories.

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-admins@googlegroups.com if potentially interested.

Past proposals and draft

This is some proposal draft for the student applications, https://google.github.io/gsocguides/student/proposal-example-1 Here you can find an archive of past projects, including QuTiP's https://summerofcode.withgoogle.com/archive/

Tasks before applying

  • 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

Projects

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-doc: just open a pull request or email the admin team at qutip-admins@googlegroups.com if you'd like to propose a new idea.

Summary

1 - QuTiP Interactive

2 - TensorFlow Backend

3 - GPU implementation of the Hierarchical Equations of Motion

4 - Pulse level description of quantum circuits

5 - Quantum Error Mitigation and Correction

QuTiP Interactive

QuTiP is pretty simple to use at an entry level for anyone with basic Python skills. However, some Python skills are necessary. A graphical user interface (GUI) for some parts of qutip could help make qutip more accessible. This could be particularly helpful in education, for teachers and learners.

Ideally, interactive components could be embedded in web pages. Including, but not limited to, Jupyter notebooks.

The scope for this is broad and flexible. Ideas including, but not limited to:

Interactive Bloch sphere

QuTiP has a Bloch sphere virtualisation for qubit states. This could be made interactive through sliders, radio buttons, cmd buttons etc. An interactive Bloch sphere could have sliders for qubit state angles. Buttons to add states, toggle state evolution path. Potential for recording animations. Matplotlib has some interactive features (sliders, radio buttons, cmd buttons) that can be used to control parameters. that could potentially be used.

Interactive solvers

Options to configure dynamics generators (Lindbladian / Hamiltonian args etc) and expectation operators. Then run solver and view state evolution.

Animated circuits

QIP circuits could be animated. Status lights showing evolution of states during the processing. Animated Bloch spheres for qubits.

Expected outcomes

  • Interactive graphical components for demonstrating quantum dynamics
  • Web pages for qutip.org or Jupyter notebooks introducing quantum dynamics using the new components

Skills

  • Git, Python and familiarity with the Python scientific computing stack
  • elementary understanding of quantum dynamics

Mentors

TensorFlow Data Backend

QuTiP's data layer provides the mathematical operations needed to work with quantum states and operators, i.e. `Qobj`s, inside QuTiP. As part of Google Summer of Code 2020, the data layer was rewritten to allow new backends to be added more easily and for different backends to interoperate with each other. Backends using in-memory spares and dense matrices already exist, and we would like to add a backend that implements the necessary operations using TensorFlow^1.

Why a TensorFlow backend?

TensorFlow supports distributing matrix operations across multiple GPUs and multiple machines, and abstracts away some of the complexities of doing so efficiently. We hope that by using TensorFlow we might enable QuTiP to scale to bigger quantum systems (e.g. more qubits) and decrease the time taken to simulate them.

There is particular interest in trying the new backend with the BoFiN HEOM (Hierarchical Equations of Motion) solver^2.

Challenges

TensorFlow is a very different kind of computational framework to the existing dense and sparse matrix backends. It uses flow graphs to describe operations, and to work efficiently. Ideally large graphs of operations need to be executed together in order to efficiently compute results.

The QuTiP data layer might need to be adjusted to accommodate these differences, and it is possible that this will prove challenging or even that we will not find a reasonable way to achieve the desired performance.

Expected outcomes

  • Add a [qutip.core.data.tensorflow]{.title-ref} data type.
  • Implement specialisations for some important operations (e.g. [add]{.title-ref}, [mul]{.title-ref}, [matmul]{.title-ref}, [eigen]{.title-ref}, etc).
  • Write a small benchmark to show how [Qobj]{.title-ref} operations scale on the new backend in comparison to the existing backends. Run the benchmark both with and without using a GPU.
  • Implement enough for a solver to run on top of the new TensorFlow data backend and benchmark that (stretch goal).

Skills

  • Git, Python and familiarity with the Python scientific computing stack
  • Familiarity with TensorFlow (beneficial, but not required)
  • Familiarity with Cython (beneficial, but not required)

Difficulty

  • Medium

Mentors

References

GPU implementation of the Hierarchical Equations of Motion

The Hierarchical Equations of Motion (HEOM) method is a non-perturbative approach to simulate the evolution of the density matrix of dissipative quantum systems. The underlying equations are a system of coupled ODEs which can be run on a GPU. This will allow the study of larger systems as discussed in [1]. The goal of this project would be to extend QuTiP's HEOM method [2] and implement it on a GPU.

Since the method is related to simulating large, coupled ODEs, it can also be quite general and extended to other solvers.

Expected outcomes

  • A version of HEOM which runs on a GPU.
  • Performance comparison with the CPU version.
  • Implement dynamic scaling.

Skills

  • Git, python and familiarity with the Python scientific computing stack
  • CUDA and OpenCL knowledge

Mentors

Difficulty

Hard

References

[1] https://pubs.acs.org/doi/abs/10.1021/ct200126d?src=recsys&journalCode=jctcce [2] https://arxiv.org/abs/2010.10806

Pulse level description of quantum circuits

The aim of this proposal is to enhance QuTiP quantum-circuit compilation features with regard to quantum information processing. While QuTiP core modules deal with dynamics simulation, there is also a module for quantum circuits simulation. The two subsequent Google Summer of Code projects, in 2019 and 2020, enhanced them in capabilities and features, allowing the simulation both at the level of gates and at the level of time evolution. To connect them, a compiler is implemented to compile quantum gates into the Hamiltonian model. We would like to further enhance this feature in QuTiP and the connection with other libraries.

Expected outcomes

  • APIs to import and export pulses to other libraries. Quantum compiler is a current research topic in quantum engineering. Although QuTiP has a simple compiler, many may want to try their own compiler which is more compatible with their quantum device. Allowing importation and exportation of control pulses will make this much easier. This will include a study of existing libraries, such as qiskit.pulse and OpenPulse[1], comparing them with qutip.qip.pulse module and building a more general and comprehensive description of the pulse.

  • More examples of quantum system in the qutip.qip.device module. The circuit simulation and compilation depend strongly on the physical system. At the moment, we have two models: spin chain and cavity QED. We would like to include some other commonly used planform such as Superconducting system[2], Ion trap system[3] or silicon system. Each model will need a new set of control Hamiltonian and a compiler that finds the control pulse of a quantum gate. More involved noise models can also be added based on the physical system. This part is going to involve some physics and study of commonly used hardware platforms. The related code can be found in qutip.qip.device and qutip.qip.compiler.

[1] McKay D C, Alexander T, Bello L, et al. Qiskit backend specifications for openqasm and openpulse experiments[J]. arXiv preprint arXiv:1809.03452, 2018.

[2] Häffner H, Roos C F, Blatt R, Quantum computing with trapped ions, Physics reports, 2008, 469(4): 155-203.

[3] Krantz P, Kjaergaard M, Yan F, et al. A quantum engineer's guide to superconducting qubits, Applied Physics Reviews, 2019, 6(2): 021318.

Skills

  • Git, python and familiarity with the Python scientific computing stack; quantum information processing and quantum computing (quantum circuit formalism)

Mentors

Difficulty

Medium

Error mitigation and Correction in QuTiP

From the QuTiP 4.5 release, the qutip.qip module now contains the noisy quantum circuit simulator (which was a GSoC project) providing enhanced features for a pulse-level description of quantum circuits and noise models. A new class Processor and several subclasses are added to represent different platforms for quantum computing. They can transfer a quantum circuit into the corresponding control sequence and simulate the dynamics with QuTiP solvers. Different noise models can be added to qutip.qip.noise to simulate noise in a quantum device.

This module is still young and many features can be improved, including new device models, new noise models and integration with the existing general framework for quantum circuits (qutip.qip.circuit). There are also possible applications such as error mitigation techniques [1-3].

The tutorial notebooks can be found at http://qutip.org/tutorials.html#nisq. A recent presentation on the FOSDEM conference may help you get an overview (https://fosdem.org/2020/schedule/event/quantum_qutip/). See also the Github Project page for a collection of related issues and ongoing Pull Requests.

A different approach can involve the use of symmetry-based techniques for quantum errror mitigation and also for quantum error correction, such as based on the stabilizer formalism for error correction and more recent techniques for error mitigation (subspace expansion, symmetry verification, virtual distillation).

Expected outcomes

  • Make an overview of existing libraries and features in error mitigation, similarly to a literature survey for a research article, but for a code project (starting from Refs. [4,5]). This is done in order to best integrate the features in QuTiP with existing libraries and avoid "reinventing the wheel"
  • Features to perform error mitigation techniques in QuTiP, such as zero-noise extrapolation by pulse stretching or symmetry-based techniques.
  • Tutorials implementing basic quantum error mitigation protocols
  • Possible integration with Mitiq [6]
  • Possible simulation of quantum error correction codes, such as with the stabilizer formalism

Skills

  • Background in quantum physics and quantum circuits.
  • Git, python and familiarity with the Python scientific computing stack

Mentors

Difficulty

Medium

References

[1] Kristan Temme, Sergey Bravyi, Jay M. Gambetta, Error mitigation for short-depth quantum circuits, Phys. Rev. Lett. 119, 180509 (2017)

[2] Abhinav Kandala, Kristan Temme, Antonio D. Corcoles, Antonio Mezzacapo, Jerry M. Chow, Jay M. Gambetta, Extending the computational reach of a noisy superconducting quantum processor, Nature 567, 491 (2019)

[3] S. Endo, S.C. Benjamin, Y. Li, Practical quantum error mitigation for near-future applications, Physical Review X 8, 031027 (2018)

[4] Boxi Li's blog on the GSoC 2019 project on pulse-level control, https://gsoc2019-boxili.blogspot.com/

[5] Video of a recent talk on the GSoC 2019 project, https://fosdem.org/2020/schedule/event/quantum_qutip/

[6] Mitiq

Clone this wiki locally