A Qt application for robustness verification of quantum classifiers, implemented in c++.

It provides a user-friendly GUI, visualizing both inputs and outputs and providing an intuitive way to verify the robustness of quantum machine learning algorithms with respect to a small disturbance of noises, derived from the surrounding environment.

Clone or download the tool VeriQR:

git clone https://github.com/Veri-Q/VeriQR.git

You can compile VeriQR on Unix and Linux. The following installation instruction is based on Ubuntu 22.04

# install cmake make gcc g++ clang llvm
sudo apt update -y
sudo apt-get install gcc g++

# install qt6-related dependencies
sudo apt install -y build-essential libgl1-mesa-dev gdb
sudo apt install -y pkg-config libssl-dev zlib1g-dev
sudo apt install -y libxkbcommon-dev
sudo apt install -y libvulkan-dev
sudo apt install -y wget vim bash curl git

# install qt6
sudo add-apt-repository universe
sudo apt install -y qt6*
sudo apt install -y libqt6*

1. Select Qt6 system-wide

1) vim ~/qt6.conf
   # Add the following information and save: 
   qtchooser -install qt6 $(which qmake6)
2) sudo mv ~/qt6.conf /usr/share/qtchooser/qt6.conf

2. Set Qt6 as default option

sudo mkdir -p /usr/lib/$(uname -p)-linux-gnu/qt-default/qtchooser
sudo rm /usr/lib/$(uname -p)-linux-gnu/qt-default/qtchooser/default.conf
sudo ln -n /usr/share/qtchooser/qt6.conf /usr/lib/$(uname -p)-linux-gnu/qt-default/qtchooser/default.conf
sudo rm /usr/bin/qmake
sudo ln -s /usr/bin/qmake6 /usr/bin/qmake

3. Select Qt6 as default (place in ~/.bashrc for persistence):

1) vim ~/.bashrc
   # Add the following information and save: 
   export QT_SELECT=qt6
2) source ~/.bashrc

1. Follow the instructions of Miniconda Installation to install Miniconda.
2. Execute the following commands:

sudo apt install -y libblas-dev liblapack-dev cmake python3-pip

cd VeriQR/py_module
conda create -n VeriQR python=3.9.0
conda activate VeriQR
chmod +x install.sh
./install.sh

1. Replace the code in the extra_params method in the /yourPathTo/miniconda3/envs/VeriQR/lib/python3.9/site-packages/mindquantum/io/qasm/openqasm.py file

   def extra_params(cmd, dtype=float):
       """Get gate parameters."""
       matches = re.findall(r'\((.*)\)', cmd)
       out = []
       for i in matches:
           for j in i.split(','):
               pr = j.strip()
               if dtype == str:
                   out.append(pr)
               else:
                   if '*' in pr:
                       pr = pr.replace('pi', str(np.pi)).replace('π', str(np.pi))
                       pr = [float(i.strip()) for i in pr.split('*')]
                       out.append(pr[0] * pr[1])
                   elif '/' in pr:
                       pr = pr.replace('pi', str(np.pi)).replace('π', str(np.pi))
                       pr = [float(i.strip()) for i in pr.split('/')]
                       out.append(pr[0] / pr[1])
                   else:
                       out.append(float(pr))
       return out

   with the following code:

   def extra_params(cmd, dtype=float):
       """Get gate parameters."""
       matches = re.findall(r'\((.*)\)', cmd)
       out = []
       for i in matches:
           for j in i.split(','):
               pr = j.strip()
               if dtype == str:
                   out.append(pr)
               else:
                   flag_1 = '*' in pr
                   flag_2 = '/' in pr
                   if flag_1:
                       pr = pr.replace('pi', str(np.pi)).replace('π', str(np.pi))
                       pr = [i.strip() for i in pr.split('*')]
                   if flag_2:
                       result = 1
                       if not flag_1:
                           pr = pr.replace('pi', str(np.pi)).replace('π', str(np.pi))
                           pr = [k.strip() for k in pr.split('/')]
                           r = float(pr[0])
                           for k in range(len(pr) - 1):
                               r = r / float(pr[k + 1])
                           result *= r
                       else:
                           for item in pr:
                               items = [k.strip() for k in item.split('/')]
                               r = float(items[0])
                               for k in range(len(items) - 1):
                                   r = r / float(items[k + 1])
                               result *= r
   
                       out.append(result)
                   else:
                       if dtype == float:
                           out.append(pr)
                       else:
                           out.append(float(pr))
       return out

2. Replace the code in __init__ method in class Power(NoneParamNonHermMat) in the /yourPathTo/miniconda3/envs/VeriQR/lib/python3.9/site-packages/mindquantum/core/gates/basicgate.py file:

   name = f'{gate}^{exponent}'

   with the following code:

   name = f'{gate}' + '^' + str(exponent)

cd VeriQR
mkdir build 
cd build
# If the 'VeriQR' env has been deactivated, you need to activate it again now: 
conda activate VeriQR
qmake ..
make -j8
./VeriQR

See veriqr_manual.pdf

VeriQR provides several labeled datasets, all of which are encoded into quantum data by different quantum encoders and trained on Mindspore or Tensorflow Quantum platforms to generate QML models for verification. In total, we verify the local-robustness of 50 quantum classifiers, including:

• The model $qubit$, used to identify the region of a quantum state in the X-Z plane of the Bloch sphere.
• The model $iris$, trained on the Iris dataset that is encoded into mixed states of 4 qubits via Instantaneous Quantum Polynomial (IQP) encoding, is used for classifying irises of different subgenera.
• The models $mnist$, trained on the well-known MNIST dataset that is encoded into pure states of 8 qubits using amplitude encoding, is used for classifying handwritten digits, which can be any two of numbers ranging from 0 to 9.
• The model $fashion$, trained on the well-known Fashion MNIST dataset that is encoded into pure states of 8 qubits via amplitude encoding, is used to classify images of two fashion products, T-shirts and ankle boots.
• The models $tfi$, trained on the data points of 4 qubits and of 8 qubits in the TFI_chain dataset respectively using the approach in the paper, are used for identifying the wavefunction at different phases in a quantum many-body system.

We conducted numerous experiments on different circuits for each model as outlined in the local_results table:

• The noiseless ideal QML model with quantum circuit $c_0$;
• Circuit $c_1$ created by introducing random noise at various random points in circuit $c_0$ to simulate noise effects on NISQ devices;
• Circuit $c_2$ modified by adding specific noise with a noise level $0 \leq p \leq 1$ of four types: depolarizing, phase flip, bit flip, and mixed (a combination of the three) noise (referred to as "noise_p" below $c_2$), applied to each qubit after the random noise manipulation on circuit $c_1$.

Where $RA$ indicates the robust accuracy of classifiers, and $VT$ is the verification time in seconds.

Here are some of the experimental results:

VeriQR empowers users with adversarial training capabilities, an extension of traditional machine learning. When the $\epsilon$-local robustness of $\rho$ with label $l$ is compromised, our robustness verification algorithms embedded in VeriQR automatically generate an adversarial example $\sigma$. By incorporating a number of states and their ground truth labels $(\sigma, l)$ into the training dataset, we retrained several QML model to enhance their local robustness against the adversarial examples. The results are shown as followed, demonstrating the effectiveness of adversarial training in boosting the local robustness of QMLs, where $NRN$ represents the number of non-robust states in the original dataset for each model. In particular, since most of our experimental models achieved 100% RA, we use "-" entries here to indicate that these models do not need adversarial training after initial validation.

For global-robustness, we also add different levels of noise to each quantum model. We tested 12 QML models on VeriQR, covering QCNN, Quantum Approximate Optimization Algorithms (QAOA), Variational Quantum Eigensolver (VQE) and other algorithms, including:

• The model $aci$, trained on the Adult-Income dataset for income prediction.
• The model $fct$, trained on a dataset that contains credit transactions made by European cardholders, used to detect fraudulent credit card transactions.
• The model $cr$, trained on the dataset for classifying people described by a set of attributes as good or bad credit risks.
• The models $ehc$ of 6, 8, 10, 12 qubits are obtained from the experiments in the paper, used for calculating the binding energy of hydrogen chains.
• The model named $qaoa$ is used for hardware grid problems in the paper.
• The models $iris$ and $fashion$ are same as the one in Local-robustness Verification.

The full experimental results are shown in the global_results table.

Here is an experimental comparison against a baseline implementation without tensors for global robustness verification, where "TN" and "Baseline" represent tensor-based and matrix-based implementation methods, respectively.