Skip to content

Google Summer of Code 2020

Jump to bottom
Nathan Shammah edited this page Feb 1, 2021 · 21 revisions

This is a list of project ideas for the 2020 Google Summer of Code program. This program has already happened, with three funded and completed projects.

You can look at 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

Projects

Summary

1 - Quantum Error Mitigation

2 - Abstraction of the Qobj class [Completed as a GSOC 2020 project]

3 - Modernize Distribution, Testing and Installation

4 - Fast and Flexible Quantum Circuits [Completed as a GSOC 2020 project]

5 - Machine Learning with QuTiP [Completed as a GSOC 2020 project]

1. Error mitigation 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.

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"
  • Add more devices defined in the qutip.qip.device module. 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, Ion trap system[6] 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. 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
  • Refactoring the circuit compiler to allow simple pulse scheduling, e.g. Restriction of pulses that can be turned on at the same time.
  • Features to perform error mitigation techniques in QuTiP, such as zero-error extrapolation.
  • APIs to allow import quantum circuits from other software packages or commonly used language e.g. through quantum assembly language (qasm), but without overlapping with project #4.
  • Tutorials implementing basic quantum error mitigation protocols

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] Häffner H, Roos C F, Blatt R, Quantum computing with trapped ions, Physics reports, 2008, 469(4): 155-203.

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

2. Abstraction of the quantum object class (qutip.qobj.Qobj) [Completed as a GSOC 2020 project]

QuTiP's Qobj class uses sparse matrices (csr) to store data by default. Recently, we have had some issues due to using int32 for the sparse matrix indices in QuTiP (see #845, #842, #828, #853). Also, in smaller problems, using a sparse matrix for storing data is not optimal, (see the detailed discussion by @agpitch in #437). Therefore there needs to be an abstraction of the quantum object class such that one can use any structure to store the underlying data. A starting point would be the possibility to switch between dense/sparse/int32/int64 and then to determine what other parts of the code are affected by this change. The disentangling of the matrix representation of the data has several benefits which can allow us to use other types of linear algebra tools (Numba, TensorFlow). This project would be challenging as the components are integral to the library and hence changes would have wide-reaching implications. Even beyond GSoC, the abstraction of the quantum object class can lead to some very interesting directions for QuTiP.

But as a first goal, enabling int32/int64 indices for sparse along with a switch for dense/sparse in a consistent manner should be within the timeline for GSoC 2019.

Read the relevant discussions -

Expected outcomes

  • An encapsulation of the quantum object class which can switch between dense/sparse matrices with the possibility of int32/int64 for indices
  • Updating of other parts of the code which assume default sparse behavior of Qobj
  • Performance analysis.

Skills

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

Mentors

Difficulty

Hard

3. Modernize distribution, testing and installation

QuTiP deployment is currently suffering from increasing issues arising in setup, platform-specific deployment, broken gcc compilation, and lacks novel interactive ways to reach out to the community.

Installation issues: 1.a) Fix MacOS freed object error https://github.com/qutip/qutip/issues/963 1.b) Overhaul of our setup.py and installation instructions. We believe that there could be a lot of redundant stuff in there. Related, but not exclusively https://github.com/qutip/qutip/pull/961, also compile flags https://github.com/qutip/qutip/issues/951 1.c) Automation of pip wheels https://github.com/qutip/qutip/issues/933 QuTiP users are experiencing broken installations on several MacOS and QuTiP versions. We would also like to update the setup procedure. Pypinfo data shows that over 8k users used “pip install qutip” in 2018. QuTiP does not currently support pip wheels, and this could be a key factor in smoothing out the installation process.

Testing issues: 2.a) Migrate tests to pytest or nose2 https://github.com/qutip/qutip/issues/958 2.b) Setup MS Windows CI tests https://github.com/qutip/qutip/issues/959 QuTiP prizes itself of implementing some of open-source best practices in code writing and deployment since its inception. Over time, some of the open-source software used for testing has been surpassed by newer standards and features. Nose for example, is not currently maintained. Switching to an actively maintained alternative, such as pytest, would be beneficial also for debugging during continuous integration. We would like to extend continuous integration to Windows, which is currently not officially supported even for installation. Data from pypinfo shows that over 25% of QuTiP users installing via pip are on Windows machines, a popularity also highlighted by threads on the Google Help group (177 posts, https://groups.google.com/forum/#!topic/qutip/DaxVxT8SWuI%5B1-25%5D, latest on March 28th, 2019).

Distribution enhancements: 3.a) Migrate docs to new Sphinx build https://github.com/qutip/qutip-doc/pull/70 3.b) Move example Jupyter notebooks to live server (updating MyBinder or using Colab, setting up a JupyterHub environment) This last point would greatly help enhance the engagement of the user community with QuTiP. Right now, building the documentation is clumsy due to the way Sphinx is built in QuTiP. An additional point of great benefit for the community would be to find interactive options for the over 60 Jupyter notebooks hosted at http://qutip.org/tutorials.html, a true treasure for the practitioners and students of quantum mechanics and in particular of open quantum systems.

Expected outcomes

  • More stable pip and conda release versions
  • Better documentation
  • Simpler pipeline for QuTiP releases

Skills

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

Mentors

Difficulty

Medium

4. Improve Quantum Circuits Efficiency and Portability [Completed as a GSOC 2020 project]

QuTiP has been downloaded on conda-forge 200k times, of which 150k only in the past year. The popularity of this quantum physics library, focused on quantum dynamics simulation, demands that its quantum circuit simulation capabilities get up to date with a new ecosystem that has emerged in open-source quantum computing.

The aim of this proposal is to enhance QuTiP features with regard to quantum information processing. While QuTiP core modules deal with dynamics simulation, there is a module for quantum circuits that has recently been enhanced in capabilities and features during one of the Google Summer of Code projects 2019 (GSoC).

Expected outcomes

  • Faster quantum circuits, benchmarking against other available solutions (e.g., yao.jl).

Import/export of quantum circuits to standard format and to other libraries:

  • Develop functions that allow to export objects of the qutip.QuantumCircuit class to an object that are compatible with other implementations intermediate representation of quantum circuits.
  • Write functions Quantum Assembly Language (QASM) an intermediate representation for quantum instructions.
  • Write specific functions and API to import and export circuits from Qiskit (IBM Research’s popular library that provides access to a quantum computer in the backend) and Cirq (Google Research’s quantum circuit library).
  • Further development the quantum information noise simulation module developed in GSoC 2019 project. Adding options for other noise models that QuTiP simulates.
  • Extend the quantum information processing and quantum circuit capabilities.

Skills

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

Mentors

Difficulty

Medium

5. Machine learning with QuTiP [Completed as a GSOC 2020 project]

QuTiP contains all the necessary tools for describing quantum systems and their evolution. In recent times, machine learning applications in quantum physics has led to very interesting ways to optimise parameterised quantum functions. Such ideas can be used for quantum state/Hamiltonian learning or to implement variational algorithms such as QAOA or quantum neural networks. Several libraries such as PennyLane, TensorFlow quantum or NetKet allow users to implement such algorithms. In this project we intend to take the first step to let QuTiP interface with optimisation and autodiff libraries such as JAX or TensorFlow to explore the potential of machine learning in solving quantum physics problems.

Expected outcomes

  • a way to apply optimisation algorithms to learn parameterised quantum functions (such as unitaries)
  • an interfacing of qutip to some automatic differentiation toolbox such as JAX or TensorFlow
  • reproducing a simple quantum state/hamiltonian learning example such as [1]
  • possible extension to non-unitary evolution

Skills

  • Git, python and familiarity with the Python scientific computing stack; basic knowledge about density matrices and quantum operators, unitary evolution

Mentors

Difficulty

Medium

[1] Kiani, Bobak, Reevu Maity, and Seth Lloyd. "Learning unitaries via gradient descent optimization." Bulletin of the American Physical Society (2020).

Clone this wiki locally