Single Qubit Transition Visualization

[welien]

Summary

This new function allows users to visualize what is happening to a single qubit when a sequence of gates are applied to it.

Details and comments

It uses matplotlib to create an animation which is presented in GUI when called from terminal. If user wants to use it in jupyter notebook, they should pass jupyter=True as argument and the animation will be converted into a video which then can be shown in the notebook. User can also save the video in desired location on their disk. The only downside is that converting the animation into video takes a bit longer.

Also, only X, Y, Z, S, SDG, H and T gates supported.

I am not including any tests since, as far as I know, there is no straightforward way to test visualization.

Documentation has been updated, I added a release note and I read the CONTRIBUTING document.

[claassistantio]

All committers have signed the CLA.

[mtreinish]

This import needs to be moved into the the try block before HAS_MATPLOTLIB, or alternatively needs to be inside an if HAS_MATPLOTLIB block. Normally what I suggest is just use the HAS_MATPLOTLIB variable from another module, like:

from qiskit.visualization.matplotlib import HAS_MATPLOTLIB

if HAS_MATPLOTLIB:
    from matplotlib import pyplot as plt
    from matplotlib import animation
    from mpl_toolkits.mplot3d import Axes3D
    from qiskit.visualization.bloch import Bloch

The test failure you're hitting is caused by matplotlib's default backend for osx does not work on every osx installation of python, which includes the CI nodes. So when pyplot gets imported it raises an exception. This is the main reason why we have all the visualization code and dependencies as optional features of terra and why all the other matplotlib imports are in try blocks or if blocks to make sure we don't unconditionally import matplotlib at the module level.

[welien]

Thank you for your help.

I tried to use what you suggested,

from qiskit.visualization.matplotlib import HAS_MATPLOTLIB

if HAS_MATPLOTLIB:
    from matplotlib import pyplot as plt
    from matplotlib import animation
    from mpl_toolkits.mplot3d import Axes3D
    from qiskit.visualization.bloch import Bloch

The thing is, if I import matplotlib from the package visualization, it means I won't be able to import the actual package matplotlib which contains subpackage animation. I could make it so visualization/matplotlib.py includes animation but I'm not sure if it's okay.

Also with this approach the imports from qiskit.visualization.matplotlib import HAS_MATPLOTLIB and from qiskit.visualization.bloch import Bloch makes pylint complain that they're ungrouped.

And so my code is

try:
    from matplotlib import pyplot as plt
    from matplotlib import animation
    from mpl_toolkits.mplot3d import Axes3D
    from qiskit.visualization.bloch import Bloch
    from qiskit.visualization.exceptions import VisualizationError
    HAS_MATPLOTLIB = True

And pylint is happy.

Is it okay or should I rather do as you suggest and import visualization/matplotlib.py and change it so that it includes animation subpackage too even if it means imports will be ungrouped and pylint will be unhappy?

[ajavadia]

Thanks for your contribution.

It looks like one needs ffmpeg installed for this to work. Can you add that to the optional dependencies of visualization?

This takes a few minutes to generate the animation for me. Is it the same for you?

Can you use the same lower-case notation for gates as used in qiskit?
X, Y, Z, S, SDG, H and T -> x, y, z, s, sdg, h, t

Based on the gates that you support, it should be straightforward to also support rx, ry, rz (partial rotations about the X, Y, Z axis), as well as u1 (same as rz). These all take a single parameter. But then it would be awkward to parse the strings. Can this method just take a single-qubit circuit, rather than a list of gate names?

[kdk]

Hi @welien , any update on this?

[welien]

Okay so:

The tool was changed to take QuantumCircuit as the first argument instead of a list of strings. As long as it is a single-qubit circuit, the result will be an animation.

Now it supports h, x, y, z, rx, ry, rz, s, sdg, t, tdg, u1 gates.

I didn't add ffmpeg as dependency in the file as you recommended, it's not a python library, it's a system library. Often video codecs are already installed on systems and Matplotlib automatically picks whichever suits it the best. If not, it will give user an error from Matplotlib saying that it doesn't have ffmpeg. It can be easily installed following instructions here: FFMPEG

Concerning performance issues, there are no issues when the code is run from terminal - tkinter GUI is ok. The only problem is jupyter and that's because the animation must be converted into images and the images together into a video - that's why the video codec is required. I couldn't find any other way to do this.

What I did however, was that I added two more arguments to the function, fpg (frames per gate) and spg (seconds per gate) which can be tuned for faster rendering in jupyter. Default is 100 frames per gate and in jupyter it is really slow. But try fpg=20 and spg=2, rendering is much faster and it's still OK as an animation. With high fpg the animation is smooth while low fpg makes it less useful as a visualization tool.

I also changed it so that in jupyter it returns a javascript video utility instead of a HTML video. Makes it more interactive.

[ajavadia]

Cool, this is working well. Just two minor comments below, let me know if you agree and would like to work on them as enhancements. Regardless, I'll approve this.

1- Instead of having an explicit jupyter=True arg, you can probably just infer the environment. This is already done in some visualization tools in Qiskit: https://github.com/Qiskit/qiskit-terra/blob/97895e7002d873af1eadc71f327a1ac36a327b32/qiskit/visualization/dag_visualization.py#L122

2- For the trace option I think it would be nice to do dotted lines on the surface of the sphere and keep the entire history. That way the entire trajectory is clear, and one could also use the final image to show the trajectory statically. Right now it shows arrows, and erases earlier history as it goes along:

[welien]

@ajavadia @maddy-tod

1. Done, the function now determines on its own whether to use jupyter-compatible animation or not.

2. Traces are now dots which remain on the bloch sphere for the rest of the animation. It was a good suggestion, it looks much prettier now.

[ajavadia]

@welien Awesome thanks for the good work.