Project planning and milestones

[Travis-S-IBM]

Recap: Qiskit Mentorship Program

Note: The Github repo for the broader Qiskit Advocate Mentorship program is available here.

The purpose of this issue is to highlight the major project milestones and accomplishments.

Recall the timeline for the mentorship program is as follows (copied from the README in the program repo):

• Defining projects deliverables (Mar 1st - 7th, 2021) Mentors and mentees work together to refine the project ideas and define the deliverables based on mentees' commitment and skills level.
• Mentoring period (Mar 1st - Jun 1st, 2021) Mentees work on the project with guidance from mentors. Mentors should meet with mentees regularly (1 hour call every week) to check the progress and provide feedback.
• Mid-term review (Mid Apr, 2021) Mentees will share project ideas and current progress to other mentees in a group call to get feedback.
• Final showcase (Mid Jun, 2021) Mentess will present the final outcome of projects. Projects will be evaluated and highlighted in a series of Qiskit Medium blog post.

Project description

Our project involves replicating the work of this paper, Evaluation of Parameterized Quantum Circuits: on the relation between classification accuracy, expressibility and entangling capability, which I'll refer to as TH20 from here on out. This paper studies the relationship between the expressibility of a parameterized quantum circuit (PQC) and the accuracy attained by a simple quantum classifier based on that circuit. Here, expressibility is defined as in the case of Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum-classical algorithms, which I will refer to as Sim19 from here on out.

The key ideas in TH20 are:

• Defining a minimal embedding for 2-dimensional data (Figure 3) using 4 qubits
• Utilizing the PQCs of Sim19 as templates for doing classification (See Figure 2 of Sim19.)
• Defining a particular aggregation function (mapping from bitstrings to classification labels)
• Utilizing L1 and L2 loss to measure error in the classifier
• Looking at both Gradient Descent and Adam optimizers for optimizing the loss function
• Utilizing 9 particular datasets on which to evaluate the classifier (Figure 2).

TH20 utilizes the data already present in Sim19 regarding the expressibility and entangling capability of PQCs. We can do the same here.

The end result of our study should be:

• A replication of Figure 4 of TH20 using the statevector simulator
• A study of the results of Figure 4 in the presents of finite-sampling (shot) noise
• A study of the results of Figure 4 utilizing simulation of noisy hardware
• ["Hero result"] Actually doing Figure 4 on hardware

Milestones

• Code up circuits: Each circuit using in TH20 is composed of 2 pieces: the minimal embedding circuit (essentially, a tensor product of RX rotations), and then a parameterized quantum circuit from Sim19.
  • These could be coded up using the Qiskit TwoLocal object from the circuit library, though it might be easier to code them up by hand.
• Code up data sets: We need to figure out how to generate the datasets (Figure 2); I'm wondering if scikit-learn could be used for that.
• Figure out what aggregation function was used, and code that up.
  • This might involve the Qiskit-pyTorch integration, so that we can do training more easily. See this chapter in the Qiskit Textbook.
• Do numerical experiments to evaluate accuracy of the classifier. There are 4 I'd like us to do:
  • Utilize the statevector simulator for exact sampling.
  • Utilize the QASM simulator to do finite-statistics (shot noise) sampling. (We may end up skipping the statevector simulator and utilizing the QASM simulator, but with different numbers of shots.)
  • Utilize the QASM simulator to do noisy HW.
  • Utilize noisy HW directly. This might be more of a "hero task", and we might not get to it.

Timeframes

In terms of dates, I think this should be feasible:

• By late-March, the circuits and data sets are coded up.
• By the mid-term review, we have replicated Figure 1 using the QASM simulator.
• By mid-May, we have utilized noisy HW directly.

Repository organization

The repository should contain a few different pieces:

• A directory holding the data sets
• A file containing the circuits
• A directory for Jupyter notebooks

[Travis-S-IBM]

One thought about the aggregation function. This is the function $f$ that maps a bitstring x to a class label.

From TH20:

We use the Pauli Z as an observable on all four qubits. This results in a total of 16 possible states,of which we map the first four and last four to output class−1 and the other to output class 1. This balanced mapping aligns with the balance between the true and false data points in our dataset.

This makes me think $f$ is of the following form: $f(x) = -1 if x in {0000,0001,0010,0011, 1100, 1101, 1110,1111}$ $f(x) = 1 if x in {0100,0101,0110,0111,1000,1001,1010,1011}$

But this will need to be figured out a bit better.

[bagmk]

@Travis-S-IBM Can I copy some of your writing in the Readme file on the front page of the project?

[Travis-S-IBM]

@bagmk Yes