Optimization_Interface.h

Go to the documentation of this file.

/*
Created on Fri Jun 26 14:13:26 2020
Copyright 2020 Peter Rakyta, Ph.D.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

@author: Peter Rakyta, Ph.D.
*/
#ifndef Optimization_Interface_H
#define Optimization_Interface_H

#include <atomic>

#include "Decomposition_Base.h"
#include "BFGS_Powell.h"
#include "Bayes_Opt.h"
#include "Powells_method.h"


#if defined __DFE__
    #include "common_DFE.h"
#elif defined __GROQ__
    #include "common_GROQ.h"
#endif



typedef enum cost_function_type {FROBENIUS_NORM, FROBENIUS_NORM_CORRECTION1, FROBENIUS_NORM_CORRECTION2,
    HILBERT_SCHMIDT_TEST, HILBERT_SCHMIDT_TEST_CORRECTION1, HILBERT_SCHMIDT_TEST_CORRECTION2,
    SUM_OF_SQUARES, VQE, GQML, INFIDELITY, OSR_ENTANGLEMENT} cost_function_type;



enum optimization_aglorithms{ ADAM, BFGS, BFGS2, ADAM_BATCHED, AGENTS, COSINE, AGENTS_COMBINED, GRAD_DESCEND, BAYES_OPT, BAYES_AGENTS, GRAD_DESCEND_PARAMETER_SHIFT_RULE};






class Optimization_Interface : public Decomposition_Base {


public:

    int max_inner_iterations;
    int random_shift_count_max;
    int id;
protected:


    bool optimize_layer_num;

    std::map<int,int> identical_blocks;
    optimization_aglorithms alg;
    cost_function_type cost_fnc;
    double prev_cost_fnv_val;
    double correction1_scale;
    double correction2_scale;    
    std::vector<std::vector<int>> use_cuts;
    int osr_rank = -1;
    bool use_softmax = false;
    

    std::atomic<int> number_of_iters;

    bool adaptive_eta;
    double radius;
    double randomization_rate;
    int accelerator_num;

    int trace_offset;


    double circuit_simulation_time;
    double CPU_time;    




public:

Optimization_Interface();

Optimization_Interface( const Optimization_Interface& other );



Optimization_Interface( Matrix Umtx_in, int qbit_num_in, bool optimize_layer_num_in, std::map<std::string, Config_Element>& config, guess_type initial_guess_in, int accelerator_num_in=0 );

Optimization_Interface( Matrix_float Umtx_in, int qbit_num_in, bool optimize_layer_num_in, std::map<std::string, Config_Element>& config, guess_type initial_guess_in, int accelerator_num_in=0 );



virtual ~Optimization_Interface();

Optimization_Interface& operator=( const Optimization_Interface& other );

void calc_decomposition_error(Matrix& decomposed_matrix );


virtual void add_finalyzing_layer();


void final_optimization();



void solve_layer_optimization_problem( int num_of_parameters, Matrix_real solution_guess);


void solve_layer_optimization_problem_COSINE( int num_of_parameters, Matrix_real& solution_guess);


void solve_layer_optimization_problem_GRAD_DESCEND_PARAMETER_SHIFT_RULE( int num_of_parameters, Matrix_real& solution_guess);


void solve_layer_optimization_problem_GRAD_DESCEND( int num_of_parameters, Matrix_real& solution_guess);


void solve_layer_optimization_problem_AGENTS( int num_of_parameters, Matrix_real& solution_guess);



void export_current_cost_fnc(double current_minimum );


virtual void export_current_cost_fnc(double current_minimum, Matrix_real& parameters );


static void export_current_cost_fnc(double current_minimum, Matrix_real& parameters, void* void_instance);


void solve_layer_optimization_problem_AGENTS_COMBINED( int num_of_parameters, Matrix_real& solution_guess);


void solve_layer_optimization_problem_BFGS( int num_of_parameters, Matrix_real& solution_guess);


void solve_layer_optimization_problem_BFGS2( int num_of_parameters, Matrix_real solution_guess);

void solve_layer_optimization_problem_BAYES_OPT( int num_of_parameters, Matrix_real& solution_guess);


void solve_layer_optimization_problem_BAYES_AGENTS( int num_of_parameters, Matrix_real& solution_guess);



void solve_layer_optimization_problem_ADAM_BATCHED( int num_of_parameters, Matrix_real& solution_guess_);

void solve_layer_optimization_problem_ADAM( int num_of_parameters, Matrix_real& solution_guess);

void randomize_parameters( Matrix_real& input, Matrix_real& output, const double f0 );


// Bring base class optimization_problem into scope to avoid hiding
using Decomposition_Base::optimization_problem;

double optimization_problem( double* parameters);


virtual double optimization_problem( Matrix_real& parameters);

double calculate_cost_function( Matrix& matrix_new, Matrix* ret_temp=NULL );

double calculate_cost_function( Matrix_float& matrix_new, Matrix_float* ret_temp=NULL );



#ifdef __DFE__

Matrix_real optimization_problem_batched_DFE( std::vector<Matrix_real>& parameters_vec);
#endif

#ifdef __GROQ__

virtual double optimization_problem_Groq( Matrix_real& parameters, int chosen_device);


Matrix_real optimization_problem_batched_Groq( std::vector<Matrix_real>& parameters_vec);
#endif


Matrix_real optimization_problem_batched( std::vector<Matrix_real>& parameters_vec);



double optimization_problem( Matrix_real parameters, void* void_instance, Matrix ret_temp);


static double optimization_problem( Matrix_real parameters, void* void_instance);


virtual double optimization_problem_non_static( Matrix_real parameters, void* void_instance);


static void optimization_problem_grad( Matrix_real parameters, void* void_instance, Matrix_real& grad );




static void optimization_problem_combined( Matrix_real parameters, void* void_instance, double* f0, Matrix_real& grad );


virtual void optimization_problem_combined_non_static( Matrix_real parameters, void* void_instance, double* f0, Matrix_real& grad );


virtual void optimization_problem_combined( Matrix_real parameters, double* f0, Matrix_real grad );


static void optimization_problem_combined_unitary( Matrix_real parameters, void* void_instance, Matrix& Umtx, std::vector<Matrix>& Umtx_deriv );

void optimization_problem_combined_unitary( Matrix_real parameters, Matrix& Umtx, std::vector<Matrix>& Umtx_deriv );


double optimization_problem_panelty( double* parameters, Gates_block* gates_block );


cost_function_type get_cost_function_variant();


double get_previous_cost_function_value();


void set_cost_function_variant( cost_function_type variant  );


double get_correction1_scale();





double get_correction2_scale();






void set_max_inner_iterations( int max_inner_iterations_in  );


void set_random_shift_count_max( int random_shift_count_max_in  );


void set_optimizer( optimization_aglorithms alg_in );


int get_trace_offset();

void set_trace_offset(int trace_offset_in);


int get_num_iters();

void increment_num_iters( int delta=1 );

void set_custom_gate_structure( Gates_block* gate_structure_in );


#ifdef __DFE__

void upload_Umtx_to_DFE();


#endif


int get_accelerator_num();

void set_osr_params( std::vector<std::vector<int>> use_cuts_in, int osr_rank_in, bool use_softmax_in );




};


#endif