Commit dd623238 authored by Nguyen, Thien Minh's avatar Nguyen, Thien Minh
Browse files

Fixed a clunky example 



Also, removed the QAOA unit test since it's really not necessary.

Signed-off-by: default avatarNguyen, Thien <nguyentm@ornl.gov>
parent f1c64cf6

examples/qrt/qaoa-builtin-circuit.cpp

+4 −6
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ 
#include <qalloc>

#include "qcor.hpp"



__qpu__ void qaoa_ansatz(qreg q, int n, std::vector<double> betas, std::vector<double> gammas, std::shared_ptr<xacc::Observable> costHamiltonian, std::shared_ptr<xacc::Observable> refHamiltonian) {

__qpu__ void qaoa_ansatz(qreg q, int n, std::vector<double> betas, std::vector<double> gammas, qcor::PauliOperator& costHamiltonian, qcor::PauliOperator& refHamiltonian) {

  // Just use the built-in qaoa circuit

  qaoa(q, n, betas, gammas, costHamiltonian, refHamiltonian);

}
@@ -16,11 +16,9 @@ int main(int argc, char **argv) { 
  auto buffer = qalloc(2);

  auto optimizer = qcor::createOptimizer("nlopt");

  // Cost Hamiltonian

  auto costHam = 5.907-2.1433*qcor::X(0)*qcor::X(1)-2.1433*qcor::Y(0)*qcor::Y(1)+0.21829*qcor::Z(0)-6.125*qcor::Z(1);

  std::shared_ptr<qcor::Observable> observable = std::make_shared<qcor::PauliOperator>(costHam);

  auto observable = 5.907-2.1433*qcor::X(0)*qcor::X(1)-2.1433*qcor::Y(0)*qcor::Y(1)+0.21829*qcor::Z(0)-6.125*qcor::Z(1);

  // Mixer Hamiltonian

  auto refH = qcor::X(0) + qcor::X(1);

  std::shared_ptr<qcor::Observable> refHamiltonian = std::make_shared<qcor::PauliOperator>(refH);

  auto refHamiltonian = qcor::X(0) + qcor::X(1);



  // VQE objective function

  auto vqe = qcor::createObjectiveFunction("vqe", qaoa_ansatz, observable);

runtime/objectives/vqe/tests/VQETester.cpp

+0 −59
Original line number Diff line number Diff line
@@ -25,12 +25,6 @@ const std::string rucc = R"rucc(__qpu__ void f(qbit q, double t0) { 
    H(q[3]);

})rucc";



const std::string qaoa_ansatz_src = R"##(

  __qpu__ void qaoa_ansatz(qreg q, int n, std::vector<double> betas, std::vector<double> gammas, std::shared_ptr<xacc::Observable> costHamiltonian, std::shared_ptr<xacc::Observable> refHamiltonian) {

    // Call the qaoa circuit

    qaoa(q,n,betas,gammas,costHamiltonian,refHamiltonian); 

  })##";



TEST(VQETester, checkSimple) {



  xacc::internal_compiler::compiler_InitializeXACC("qpp");
@@ -67,59 +61,6 @@ TEST(VQETester, checkSimple) { 
  EXPECT_NEAR(-1.13717, results.first, 1e-4);

}



TEST(VQETester, checkQaoa) {

  xacc::internal_compiler::compiler_InitializeXACC("qpp");

  auto buffer = qalloc(2);

  auto qaoaCirc = xacc::getService<xacc::Compiler>("xasm")

                  ->compile(qaoa_ansatz_src, nullptr)

                  ->getComposite("qaoa_ansatz");

                  

  auto optimizer = qcor::createOptimizer("nlopt");

  std::shared_ptr<Observable> observable = xacc::quantum::getObservable(

      "pauli",

      std::string(

          "5.907 - 2.1433 X0X1 "

          "- 2.1433 Y0Y1"

          "+ .21829 Z0 - 6.125 Z1"));



  std::shared_ptr<Observable> refHamiltonian = xacc::quantum::getObservable(

      "pauli",

      std::string("1.0 X0 + 1.0 X1")

  );



  auto vqe = xacc::getService<qcor::ObjectiveFunction>("vqe");

  vqe->initialize(observable, qaoaCirc);

  vqe->set_qreg(buffer);



  const int nbSteps = 2;

  const int nbParamsPerStep = 2 /*beta (mixer)*/ + 4 /*gamma (cost)*/;

  const int totalParams = nbSteps * nbParamsPerStep;

  int iterCount = 0;



  qcor::OptFunction f(

      [&](const std::vector<double> x, std::vector<double> &grad) {

        std::vector<double> betas;

        std::vector<double> gammas;

        // Unpack nlopt params

        // Beta: nbSteps * number qubits

        for (int i = 0; i < nbSteps * buffer.size(); ++i) {

          betas.emplace_back(x[i]);

        }



        for (int i = betas.size(); i < x.size(); ++i) {

          gammas.emplace_back(x[i]);

        }



        const double costVal = (*vqe)(buffer, buffer.size(), betas, gammas, observable.get(), refHamiltonian.get());

        std::cout << "Iter " << iterCount << ": Cost = " << costVal << "\n";

        iterCount++;

        return costVal;

      },

      totalParams);

  auto results = optimizer->optimize(f);

  std::cout << "Final cost: " << results.first << "\n";

}



int main(int argc, char **argv) {

  ::testing::InitGoogleTest(&argc, argv);

  auto ret = RUN_ALL_TESTS();