Qiskit: I implemented VQE

I implemented VQE with Qiskit.

This time, we will implement VQE (Variational Quantum Eigen solver) using the open source framework for quantum computers provided by IBM. This algorithm is expected to be applied to quantum chemistry. Please refer to Quantum Native Dojo for a theoretical explanation. I think there are multiple VQE implementation articles, but most of the Japanese articles are written using Qulacs and Blueqat, so I tried to implement them with Qiskit this time. I have written articles on QAOA and QCL in the past, so please take a look. Implementation of QAOA without Qiskit Aqua Implementation of Quantum Circuit Learning

Implementation

Library import

python


from qiskit import Aer, execute
from qiskit import QuantumCircuit
from qiskit.aqua.utils import tensorproduct
from qiskit.quantum_info.analysis import average_data

from scipy.optimize import minimize
import numpy as np

Initialize

python


class VQE:

    def __init__(self, n_qubits, observable, layer, backend):
        self.n_qubits = n_qubits
        self.OBS = observable
        self.Layer = layer
        self.backend = backend

This time, Hamiltonian is also treated as input.

Creating a circuit

python


    def make_circuit(self, Params):

        def make_U_circuit(circ, params):
            for n in range(self.n_qubits):
                param = params[3*n:3*(n+1)]
                circ.rz(param[0], n)
                circ.rx(param[1], n)
                circ.rz(param[2], n)
            return circ

        def make_Ent(circ):
            for n in range(self.n_qubits-1):
                circ.cx(n, n+1)
            return circ

        #Set up the circuit
        circ = QuantumCircuit(self.n_qubits, self.n_qubits)

        for l in range(self.Layer):
            #Creating a parameter circuit
            params = Params[3*self.n_qubits*l:3*self.n_qubits*(l+1)]
            #Creating entanglement
            make_U_circuit(circ, params)
            #Number of layers-Because it has to be 1
            if l != self.Layer-1:
                make_Ent(circ)

        #Measurement
        circ.measure(circ.qregs[0], circ.cregs[0])

        return circ

VQE execution phase

python


    def outputlayer(self, params):
        circ = self.make_circuit(params)
        counts = execute(circ, backend=self.backend, shots=8192).result().get_counts()
        return average_data(counts, self.OBS)

    def initial_params(self):
        #Creating initial parameters
        init = [0.1 for _ in range(3 * self.Layer * self.n_qubits)]
        return np.array(init)

    def minimize(self):
        initial_params = self.initial_params()
        #Perform optimization
        opt_params, opt_cost = classica_minimize(self.outputlayer, initial_params, options={'maxiter':500})
        circ = self.make_circuit(opt_params)
        counts = execute(circ, backend=self.backend, shots=8192).result().get_counts()
        ans = sorted(counts.items(), key=lambda x: x[1], reverse=True)
        print(ans)
        return opt_cost

In addition, unlike other articles, layer is used. This is in reference [1]. I will explain briefly. When $ \ theta = (\ theta_1, \ theta_2, \ cdots, \ theta_d) $ is a set of parameters, the circuit

python


U(\theta) = U_d(\theta_d)U_{ENT} \cdots U_1(\theta_1)U_{ENT}U_0(\theta_0)

Can be written. At this time, $ d $ is the number of layers. By setting $ d = 2 $, it is possible to create the same circuit as other articles.

Run

This time, I will use the formula that Hamiltonian deals with in other articles. Supplementary Information

python


def sample_hamiltonian():
    '''
    https://dojo.qulacs.org/ja/latest/notebooks/5.1_variational_quantum_eigensolver.html
Hamiltonian is used.
    '''
    I_mat = np.array([[1, 0], [0, 1]])
    X_mat = np.array([[0, 1], [1, 0]])
    Z_mat = np.array([[1, 0], [0, -1]])
    obs = np.zeros((4, 4))
    obs += -3.8505 * tensorproduct(I_mat, I_mat)
    obs += -0.2288 * tensorproduct(I_mat, X_mat)
    obs += -1.0466 * tensorproduct(I_mat, Z_mat)
    obs += 0.2613 * tensorproduct(X_mat, X_mat)
    obs += 0.2288 * tensorproduct(X_mat, Z_mat)
    obs += -1.0466 * tensorproduct(Z_mat, I_mat)
    obs += 0.2288 * tensorproduct(Z_mat, X_mat)
    obs += 0.2356 * tensorproduct(Z_mat, Z_mat)
    return obs / 2

I also use the functions I use in other articles I write for classical optimization.

python


def classica_minimize(cost_func, initial_params, options, method='powell'):
    print('classical minimize is starting now... ')
    result = minimize(cost_func, initial_params, options=options, method=method)
    print('opt_cost: {}'.format(result.fun))
    print('opt_params: {}'.format(result.x))
    return result.x, result.fun

It is execution.

python


if __name__ == '__main__':
    backend = Aer.get_backend('qasm_simulator')
    obs = sample_hamiltonian()
    vqe = VQE(2, obs, 2, backend)
    vqe.minimize()

Execution result

-2.85405 #vqe result
-2.8626207640766816 #Minimum eigenvalue

Compared to other articles, the accuracy is lower, but is it a success ...?

Summary

I implemented VQE using Qiskit. To be honest, I prefer QAOA, which is suitable for classical problems, to VQE, so I wrote this article for the purpose of complete implementation. Please do your own theory ...

References

[1] Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets [2] Quantum Native Dojo

Recommended Posts

Qiskit: I implemented VQE
I implemented VQE with Blueqat
I implemented CycleGAN (1)
I implemented ResNet!
I implemented Python Logging
I implemented Extreme learning machine
I tried to implement Deep VQE
[Python] I implemented peripheral Gibbs sampling
I implemented Attention Seq2Seq with PyTorch
I compared Qiskit and Blueqat (beginner)
I implemented a two-layer neural network
I implemented ChangeFinder (change point detection)
I implemented the K-means method (clustering method)
I implemented Shake-Shake Regularization (ShakeNet) with PyTorch
[Reinforcement learning] I implemented / explained R2D3 (Keras-RL)
I implemented Cousera's logistic regression in Python
I implemented NSGA-II, a multi-objective optimization problem.
CheckIO (Python)> Non-unique Elements> I implemented it
Implemented DQN in TensorFlow (I wanted to ...)