Early Days for Quantum Developers, But Serverless Coming
IBM is one of the leading companies in quantum computing hardware, with its roadmap targeting more than 1,000 qubits by the end of 2023. That’s the so-called “quantum advantage” level, when quantum computing will out-perform classical computing in certain use cases. So we know IBM is innovating on hardware, but is it as ambitious on the software side of quantum computing? And what does it look like to be a developer on IBM’s quantum platform?
To answer these questions, I spoke to Blake Johnson, Quantum Platform Lead at IBM Quantum, and Tushar Mittal, a product manager on the Qiskit Runtime team.
According to Johnson, executing quantum code is not just a matter of loading the code and hitting run. “We’ve built systems that allow us to do interactive execution between a runtime and the quantum system itself,” he said, adding that a current issue with quantum computing is “coping with and dealing with the fact that quantum systems are noisy.” He’s referring here to the physical operation of a quantum computer, which currently involves a lot of interference — which in turn introduces errors.
“Coping with the noise takes specialized knowledge,” he continued, “Knowledge that we can kind of bundle up [as] best practices for how to do that, and ways that present an easier to use experience for a developer.”
The Role of Qiskit Runtime in IBM’s Platform
When it comes to programming IBM’s quantum computers, the default platform is Qiskit — an open source software development kit (SDK) built with Python. Qiskit was developed by IBM and released in March 2017. Like many of the leading SDKs of its kind, Qiskit operates at the circuit level — meaning it is focused on constructing and compiling quantum circuits.
Last year, Qiskit Runtime was launched as an abstracted layer above Qiskit. Its primary goal was “changing the execution model from a service that executes circuits to one that executes programs.”
Mittal, a product manager for Qiskit Runtime, told me that his task is to make building workloads and iterating on them more efficient for developers. But he also clarified that Qiskit Runtime is not necessarily optimized for developing apps — unlike, say, Classiq’s abstraction layer. What Qiskit Runtime does is optimize the efficiency and performance of code execution.
“There are these two levels of decomposition that need to happen,” explained Mittal, referring to the process of breaking a complex software problem or system into parts. “One is application specific; and the other is working on the constraints of devices that you have available, and the types of protocols you can run.” Qiskit Runtime, then, is focused on the latter.
Last year, IBM released two Qiskit Runtime primitives — the first to optimize sampling operations, the second for estimating operations. The Sampler primitive, for example, “takes a user circuit as an input and generates an error-mitigated readout of quasiprobabilities.”
That sounds rather intimidating, so I asked if these primitives can be used by, say, Python developers? “In this current model, the user still needs to understand how to construct a circuit that they want to leverage,” replied Mittal. However, he added that “our goal with this is to continue to make it easier.”
Over time, IBM aims to relieve the developer of the burden of optimizing the performance of the quantum computer.
Johnson reiterated that it’s about “having methods that can cope with noise,” which is a primary goal for Qiskit Runtime. He pointed to a recent IBM blog post about how error mitigation techniques can reduce the impact of quantum noise.
“On the pipeline for the rest of this year is folding in these advanced techniques, which were research ideas even just one year ago,” he said, “and making them available directly in Qiskit Runtime primitives, with interfaces that hopefully make this accessible and easy.”
What kinds of use cases are developers using Qiskit Runtime and these primitives for, I asked?
“I think the primary focus in terms of an audience is algorithm developers,” replied Mittal. “And so a lot of the use cases are centered around variational algorithms.”
He said that the estimator primitive “maps really well to algorithms like Variational Quantum Eigensolver — which can be used in both chemistry and optimization problems.” As for the sampler primitive, use cases include “things like classification problems using quantum support vector machines.”
These sound like use cases that would involve an intimate knowledge of quantum circuits, so I asked if IBM is planning to make it easier for general developers to use quantum machines. For instance, Python developers bringing their machine learning use cases to Qiskit Runtime?
“Our team has various prototypes out there already,” said Johnson, “kind of within the broader Qiskit ecosystem — so-called Qiskit application modules, like Qiskit Nature and Qiskit Machine Learning, which attempt to do precisely this.”
The Qiskit documentation claims that the Qiskit Machine Learning application module is “very easy to use and allows users to rapidly prototype a first model without deep quantum computing knowledge.” Users can also integrate their quantum neural networks into PyTorch, a popular open source ML library.
However, Johnson emphasized that these are “purely prototypes” at this stage, and that they have more work to do to “marry those needs, those domains where people are comfortable working, with the capabilities of the [quantum] hardware.”
From a developer point of view, Qiskit Runtime is clearly very focused on optimizing the performance of a quantum computer — and so it is more suited, at this point, to developers who understand quantum circuits.
The development roadmap for Qiskit Runtime will continue to be geared towards its power users, however IBM will also be developing managed services for general developers.
Mittal said that IBM plans to extend its runtime and figure out “ways to offer an integration with elastic compute — and this is what we’re calling quantum serverless.”
He added that they will put more focus on “the ways users should think about building applications, given that they will have these [quantum] capabilities [and] managed experiences.”