Commit 4327355d authored by Mccaskey, Alex's avatar Mccaskey, Alex
Browse files

implemented taskInitiate no optimizer 



Signed-off-by: Mccaskey, Alex's avatarAlex McCaskey <mccaskeyaj@ornl.gov>
parent f1d9153a

examples/task_initiate_no_optimizer.cpp

0 → 100644
+39 −0
Original line number Diff line number Diff line 
#include "qcor.hpp"



template <typename T> std::vector<T> linspace(T a, T b, size_t N) {

  T h = (b - a) / static_cast<T>(N - 1);

  std::vector<T> xs(N);

  typename std::vector<T>::iterator x;

  T val;

  for (x = xs.begin(), val = a; x != xs.end(); ++x, val += h)

    *x = val;

  return xs;

}



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



  qcor::Initialize(argc, argv);



  auto ansatz = [&](qbit q, std::vector<double> t) {

    X(q[0]);

    Ry(q[1], t[0]);

    CNOT(q[1], q[0]);

  };



  auto observable =

      qcor::getObservable("pauli", std::string("5.907 - 2.1433 X0X1 "

                                               "- 2.1433 Y0Y1"

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



  std::vector<double> all_params =

      linspace(-xacc::constants::pi, xacc::constants::pi, 10);

  for (auto p : all_params) {

    std::vector<double> pv{p};

    auto handle = qcor::taskInitiate(ansatz, "vqe", observable,

                                     pv);

    auto results = qcor::sync(handle);



    // std::cout << results->getInformation("opt-val").as<double>() << "\n";

  }

  qcor::Finalize();

}

runtime/qcor.hpp

+42 −10
Original line number Diff line number Diff line
@@ -193,7 +193,8 @@ add(QuantumKernelA &qka, QuantumKernelB &qkb, Args... args) { 
      qcor::__internal::constructInitialParameters(tmp, args...);

      std::vector<double> params =

          tmp.get<std::vector<double>>("initial-parameters");

      auto accelerator = xacc::getAccelerator(function1->accelerator_signature());

      auto accelerator =

          xacc::getAccelerator(function1->accelerator_signature());

      auto evaled = function1->operator()(params);

      accelerator->execute(q, evaled);

    }
@@ -292,7 +293,20 @@ public: 


    options.insert("ansatz", function);

    options.insert("accelerator", accelerator);

    auto algo = xacc::getAlgorithm(algorithm);

    options.insert("initial-parameters", std::vector<double>{});

    options.insert("__internal_n_vars", function->nVariables());

    __internal::constructInitialParameters(options, args...);

    options.insert("parameters",

                   options.get<std::vector<double>>("initial-parameters"));



    std::shared_ptr<Algorithm> algo;

    if (algorithm == "vqe" &&

        !options.keyExists<std::shared_ptr<Optimizer>>("optimizer")) {

      algo = xacc::getAlgorithm("vqe-energy");

    } else {

      algo = xacc::getAlgorithm(algorithm);

    }



    bool success = algo->initialize(options);

    if (!success) {

      xacc::error("Error initializing " + algorithm + " algorithm.");
@@ -349,7 +363,6 @@ Handle taskInitiate(QuantumKernel &&kernel, 
      allZsObsStr += "Z" + std::to_string(i) + " ";

    }

    auto observable = getObservable("pauli", allZsObsStr);

    std::cout << "Obs:\n" << observable->toString() << "\n";

    HeterogeneousMap m{std::make_pair("observable", observable),

                       std::make_pair("optimizer", optimizer),

                       std::make_pair("accelerator", accelerator),
@@ -358,18 +371,38 @@ Handle taskInitiate(QuantumKernel &&kernel, 
  });

}



// using ObjectiveFunction = xacc::OptFunction;

// No optimizer, evaluate at given initial args

template <typename QuantumKernel, typename... InitialArgs>

Handle

taskInitiate(QuantumKernel &&kernel, const std::string objectiveFunctionName,

             std::shared_ptr<Observable> observable, InitialArgs... args) {

  auto function = qcor::__internal::getCompositeInstruction(kernel, args...);



  HeterogeneousMap tmp;

  tmp.insert("initial-parameters", std::vector<double>{});

  tmp.insert("__internal_n_vars", function->nVariables());

  __internal::constructInitialParameters(tmp, args...);

  std::vector<double> parameters = tmp.get<std::vector<double>>("initial-parameters");



  return qcor::submit([&, parameters](qcor::qpu_handler &q) {

    HeterogeneousMap m{

        std::make_pair("observable", observable),

    };

    q.execute(objectiveFunctionName, kernel, m, parameters);

  });

}



// using ObjectiveFunction = xacc::OptFunction;



// // Custom objective function

// template <typename QuantumKernel, typename... InitialArgs>

// Handle taskInitiate(QuantumKernel &&kernel, ObjectiveFunction &objFunction,

//                     std::shared_ptr<Optimizer> optimizer, InitialArgs... args) {

//                     std::shared_ptr<Optimizer> optimizer, InitialArgs...

//                     args) {

//   return qcor::submit([&](qcor::qpu_handler &q) {

//     auto function = qcor::__internal::getCompositeInstruction(kernel, args...);

//     auto nLogicalBits = function->nLogicalBits();

//     auto accelerator = xacc::getAccelerator();

//     auto buffer = xacc::qalloc(nLogicalBits);

//     auto function = qcor::__internal::getCompositeInstruction(kernel,

//     args...); auto nLogicalBits = function->nLogicalBits(); auto accelerator

//     = xacc::getAccelerator(); auto buffer = xacc::qalloc(nLogicalBits);

//     HeterogeneousMap optParams;



//     optParams.insert("initial-parameters", std::vector<double>{});
@@ -436,7 +469,6 @@ Handle taskInitiate(QuantumKernel &&kernel, 
//   return taskInitiate(kernel, obj, optimizer, args...);

// }





} // namespace qcor



#endif