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

Work on simple qpu-lambda w/ obj func 



Testing w/ explicit
args_translator

Signed-off-by: default avatarThien Nguyen <nguyentm@ornl.gov>
parent aac487e0

examples/qpu_lambda/deuteron_vqe_obj_func.cpp

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



int main() {

  // Create the Hamiltonian

  auto H = -2.1433 * X(0) * X(1) - 2.1433 * Y(0) * Y(1) + .21829 * Z(0) -

           6.125 * Z(1) + 5.907;



  auto ansatz = qpu_lambda([](qreg q, double x) {

    X(q[0]);

    Ry(q[1], x);

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

  });



  auto q = qalloc(2);

  auto args_translator = std::make_shared<ArgsTranslator<qreg, double>>(

      [&](const std::vector<double> x) { return std::make_tuple(q, x[0]); });

  auto objective = createObjectiveFunction(ansatz, args_translator, H, q, 1);



  // Create a qcor Optimizer

  auto optimizer = createOptimizer("nlopt");



  // Optimize the above function

  auto [optval, opt_params] = optimizer->optimize(*objective.get());

}
 
 No newline at end of file

runtime/objectives/objective_function.hpp

+67 −2
Original line number Diff line number Diff line
@@ -130,6 +130,10 @@ class ObjectiveFunctionImpl : public ObjectiveFunction { 
  std::shared_ptr<LocalArgsTranslator> args_translator;

  std::shared_ptr<ObjectiveFunction> helper;

  xacc::internal_compiler::qreg qreg;

  // Kernel evaluator from qpu_lambda

  std::optional<

      std::function<std::shared_ptr<CompositeInstruction>(std::vector<double>)>>

      lambda_kernel_evaluator;



public:

  ObjectiveFunctionImpl(void *k_ptr, std::shared_ptr<Observable> obs,
@@ -168,6 +172,49 @@ class ObjectiveFunctionImpl : public ObjectiveFunction { 
    helper->set_options(options);

  }



  ObjectiveFunctionImpl(

      std::function<void(std::shared_ptr<CompositeInstruction>, KernelArgs...)>

          &funtor,

      std::shared_ptr<Observable> obs, xacc::internal_compiler::qreg &qq,

      std::shared_ptr<LocalArgsTranslator> translator,

      std::shared_ptr<ObjectiveFunction> obj_helper, const int dim,

      HeterogeneousMap opts)

      : qreg(qq) {

    std::cout << "Constructed from lambda\n";

    observable = obs;

    args_translator = translator;

    helper = obj_helper;

    _dim = dim;

    _function = *this;

    options = opts;

    options.insert("observable", observable);

    helper->update_observable(observable);

    helper->set_options(options);

    std::cout << "set lambda_kernel_evaluator\n";

    lambda_kernel_evaluator =

        [&](std::vector<double> x) -> std::shared_ptr<CompositeInstruction> {

      std::cout << "HOWDY:\n";

      // Create a new CompositeInstruction, and create a tuple

      // from it so we can concatenate with the tuple args

      auto m_kernel = create_new_composite();

      auto kernel_composite_tuple = std::make_tuple(m_kernel);



      // Translate x parameters into kernel args (represented as a tuple)

      auto translated_tuple = (*args_translator)(x);



      // Concatenate the two to make the args list (kernel, args...)

      auto concatenated =

          std::tuple_cat(kernel_composite_tuple, translated_tuple);



      // Call the functor with those arguments

      // qcor::__internal__::evaluate_function_with_tuple_args(kernel_functor,

      //                                                       concatenated);

      std::apply(funtor, concatenated);

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

      return m_kernel;

    };

  }



  void set_options(HeterogeneousMap &opts) override {

    options = opts;

    helper->set_options(opts);
@@ -198,7 +245,9 @@ class ObjectiveFunctionImpl : public ObjectiveFunction { 
    // Turn kernel evaluation into a functor that we can use here

    // and share with the helper ObjectiveFunction for gradient evaluation

    std::function<std::shared_ptr<CompositeInstruction>(std::vector<double>)>

        kernel_evaluator = [&](std::vector<double> x)

        kernel_evaluator = lambda_kernel_evaluator.has_value()

                               ? lambda_kernel_evaluator.value()

                               : [&](std::vector<double> x)

        -> std::shared_ptr<CompositeInstruction> {

      // Create a new CompositeInstruction, and create a tuple

      // from it so we can concatenate with the tuple args
@@ -503,4 +552,20 @@ std::shared_ptr<ObjectiveFunction> createObjectiveFunction( 
      options);

}



template <typename... CaptureArgs, typename... Args>

std::shared_ptr<ObjectiveFunction> createObjectiveFunction(

    _qpu_lambda<CaptureArgs...> &lambda,

    std::shared_ptr<ArgsTranslator<Args...>> args_translator,

    Observable &observable, qreg &q, const int nParams,

    HeterogeneousMap &&options = {}) {

  auto helper = qcor::__internal__::get_objective("vqe");

  std::function<void(std::shared_ptr<CompositeInstruction>, Args...)> kernel_fn =

      [&lambda](std::shared_ptr<CompositeInstruction> comp, Args... args) -> void {

        return lambda.eval_with_parent(comp, args...);

      };



  return std::make_shared<ObjectiveFunctionImpl<Args...>>(

      kernel_fn, __internal__::qcor_as_shared(&observable), q,

      args_translator, helper, nParams, options);

}

}  // namespace qcor
 
 No newline at end of file