We are excited to announce the 1st Open Quantum Collective Knowledge (QCK) Challenge! In this challenge, you are invited to find the closest approximation to the ground state energy of a chemical molecule by running the hybrid (quantum+classical) VQE algorithm on either a physical device or a software simulator. Please read our engaging VQE and You guide for more information on VQE.
In each experiment, you can select the target quantum device to run the experiment on, the molecule to work with (the task), the optimizer method (the classical component of VQE), the ansatz function (the quantum component of VQE), and tune some parameters of the above.
Once your experiment is completed, you can check the Time-To-Solution evaluation metric (the lower the better), upload your results to the QCK server and finally view them on the interactive QCK dashboard!
Importantly, via the dashboard you can quickly check solutions contributed by others and draw inspiration for further improvements. For example, you may notice that someone else has made significant progress by using an interesting quantum ansatz. You are invited, indeed encouraged, to combine that ansatz with your own ideas e.g. on designing a classical optimizer! That's what we mean by Quantum Collective Knowledge! (Please just provide a reference if you build upon another solution.)
To the best of our knowledge, the 1st QCK Challenge is indeed the first
challenge of its kind. Therefore, please treat it as work in progress, where
all comments and contributions are very welcome and valuable! If anything at
all is unclear or you spot a clear opportunity for improvement, please (please!
please!!) open a GitHub issue, or
join our CK Slack workspace
#quantum channel) and ask your question there!
We are thrilled about collaboratively solving this and future challenges, and thus making practical and scalable Quantum Computing a reality. Thank you so much for joining us and... best of luck!
At the moment we are collaborating with IBM and Rigetti to provide access to their hardware and software platforms for your experiments. As the challenge goes on, we may be able to support more providers.
|IBM Quantum Experience||Rigetti Forest|
|Sign up and copy your API token from the "Advanced" tab (click on the "Regenerate" button first).||Download the Forest SDK.|
|Follow CK-Qiskit instructions to complete and test your setup.||Follow CK-Rigetti instructions to complete and test your setup. Once you are done, do not kill the local QVM server - you will need it during VQE experiments as well!|
|Choice||IBM Quantum Experience||Rigetti Forest|
The problem to be solved (Hydrogen or Helium) is defined by a Hamiltonian plugin, implemented as a standard CK environment. You can pre-install one or both of them. If more than one is pre-installed, CK will interactively ask you to resolve the ambiguity when launching the experiments.
Check which Hamiltonians are installed:
$ ck show env --tags=quantum,hamiltonian
To install a Hamiltonian, run:
$ ck detect soft --tags=quantum,hamiltonian
and interactively select from the menu.
Remove a Hamiltonian (Helium in this case):
$ ck clean env --tags=quantum,hamiltonian.helium
NB: Separate tags with commas, not spaces. Use dot in
hamiltoniam.helium (a sigle tag).
In order to run VQE we'll need point the system to one optimizer plugin and one ansatz plugin. While the optimizer (being a classical component of VQE) is provider-neutral, the ansatz function has to be written with a specific provider in mind.
Here is how to do deploy one plugin of each kind to get VQE running:
$ ck deploy_ansatz vqe --provider=<provider> --value=<ansatz> $ ck deploy_optimizer vqe --value=<optimizer>
Then, launch VQE with the deployed optimizer and ansatz:
$ ck run vqe --provider=<provider> --device=<device> --repetitions=1
For example, to run VQE on Rigetti's local simulator, try:
$ ck deploy_optimizer vqe --value=cobyla $ ck deploy_ansatz vqe --provider=rigetti --value=tiny2 $ ck run vqe --provider=rigetti --device=QVM --repetitions=1
You can start exploring VQE by varying one or more of the following parameters:
$ ck run vqe \ --provider=<provider> \ --device=<device> \ --sample_size=<sample_size> \ --max_iterations=<max_iterations> \ --start_param_value=<start_param_value> \ --repetitions=<repetitions>
- consult the table above for the supported values of
<sample_size>: the number of times to evaluate the Hamiltonian function on the quantum device ("sampling resolution") per optimizer iteration; by default,
<max_iterations>: the maximum number of optimizer iterations ("iteration limit"); by default,
<start_param_value>: the starting value of each optimizer's parameter (can be a float number or the word
random); by default,
<repetitions>: the number of times to repeat the experiment with the same parameters; by default,
TODO: We will soon provide instructions on how to launch the dashboard locally on your collected experimental data.
To monitor the convergence process, run an ASCII-graphics program in a separate terminal window:
$ ck run program:visualize-convergence --env.VQE_QUANTUM_PROVIDER=<provider>
The goal of the challenge is to minimize the Time-To-Solution metric (TTS).
As TTS is proportional to
sample_size, exploring lower values of
sample_size may be sensible.
At the same time, a low number of
repetitions may make it hard to demonstrate solution convergence with a high probability.
For experiments to be uploaded, we recommend using at least 10 repetitions on the simulators and 3-5 repetitions on the hardware.
Run the following and select an experiment entry to compute TTS for:
$ ck time_to_solution vqe --delta=0.015 --prob=0.95
To compute TTS for a particular experiment, supply its entry name e.g.:
$ ck time_to_solution vqe --delta=0.015 --prob=0.8 \ local:experiment:anton-2018_10_05T12_18_19-local_qasm_simulator-ansatz.universal4-optimizer.cobyla-samples.100-repetitions.1
Congratulations if you have reached this point in the challenge! Now that you know the basic mechanics, you may wish to design your own classical optimizer or quantum ansatz circuit! For this, you will need to learn a bit how to work with plugins in general, and then with optimizer plugins and/or ansatz plugins, depending on your interests and available time.
$ ck search --tags=deployed
$ ck cleanup vqe
$ ck cleanup vqe --type=optimizer
$ ck cleanup vqe --type=ansatz
$ ck cleanup vqe --type=ansatz --provider=<provider>
$ ck deploy_optimizer vqe
$ ck plugin_path vqe --type=optimizer $ vi `ck plugin_path vqe --type=optimizer`
NB: The optimizer plugin is written in Python. It is expected to contain only one top-level function. If you need more, please define them within the top-level one.
$ ck deploy_ansatz vqe
$ ck plugin_path vqe --type=ansatz $ vi `ck plugin_path vqe --type=ansatz`
NB: The ansatz plugin is written in Python. It is expected to contain only one top-level function. If you need more, please define them within the top-level one.
TODO: The ansatz plugin is vendor-specific. We will shortly provide IBM- and Rigetti-specific circuit templates.
NB: Currently only supported for IBM-compatible ansatz circuits.
NB: If unsure about the image viewer, try
eom on Linux,
open on macOS.
$ ck run program:visualize-ansatz $ display `ck find program:visualize-ansatz`/ansatz_circuit.png
You can list all your experimental entries and locate them on disk as follows:
$ ck search local:experiment:* --tags=qck $ ck find local:experiment:*
When you have an experiment you would like to share, run:
$ ck upload vqe --team=schroedinger-cat-herders
and select the experiment from the list. We recommend uploading all experiments on the hardware and most successful experiments on the simulators.
Alternatively, upload one or more experiments by using their entries e.g.:
$ ck upload vqe --team=bell-state-ringers \ local:experiment:my_experiment_5 local:experiment:my_experiment_13