p47068915
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!25479 delete mindquantum c++ simulator 

Merge pull request !25479 from donghufeng/master
This commit is contained in:
i-robot 2021-10-28 08:14:18 +00:00 committed by Gitee
parent ba0e1a810e 7a9a4d0515
commit 8758830723
73 changed files with 381 additions and 3872 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
cmake/external_libs/projectq.cmake
View File

@ -1,25 +0,0 @@
set(projectq_CXXFLAGS "-fopenmp -O2 -ffast-mast -mavx -DINTRIN")
set(projectq_CFLAGS "-fopenmp -O2 -ffast-mast -mavx -DINTRIN")
if(ENABLE_GITEE)
set(REQ_URL "https://gitee.com/mirrors/ProjectQ/repository/archive/v0.5.1.tar.gz")
set(MD5 "3756657d9acd712d0457c3fff13bab0a")
else()
set(REQ_URL "https://github.com/ProjectQ-Framework/ProjectQ/archive/v0.5.1.tar.gz ")
set(MD5 "13430199c253284df8b3d840f11d3560")
endif()
if(ENABLE_CPU AND ${CMAKE_SYSTEM_NAME} MATCHES "Linux"
AND ${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "x86_64")
message("Include projectq simulator")
mindspore_add_pkg(projectq
VER 0.5.1
HEAD_ONLY ./
URL ${REQ_URL}
MD5 ${MD5}
PATCHES ${CMAKE_SOURCE_DIR}/third_party/patch/projectq/projectq.patch001
)
include_directories(${projectq_INC})
else()
message("Quantum simulation only support x86_64 linux platform.")
endif()

6
cmake/mind_expression.cmake
View File

@ -46,12 +46,6 @@ if(ENABLE_CPU)
include(${CMAKE_SOURCE_DIR}/cmake/external_libs/mkl_dnn.cmake)
endif()
if(ENABLE_CPU AND ${CMAKE_SYSTEM_NAME} MATCHES "Linux"
AND ${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "x86_64")
message("Include projectq")
include(${CMAKE_SOURCE_DIR}/cmake/external_libs/projectq.cmake)
endif()
if(ENABLE_GPU)
if(ENABLE_MPI)
include(${CMAKE_SOURCE_DIR}/cmake/external_libs/nccl.cmake)

23
mindspore/ccsrc/backend/kernel_compiler/CMakeLists.txt
View File

@ -28,7 +28,6 @@ if(ENABLE_CPU)
"cpu/mkldnn/*.cc"
"cpu/fl/*.cc"
"cpu/ps/*.cc"
"cpu/quantum/*.cc"
"cpu/pyfunc/*.cc"
"cpu/rl/*.cc"
"cpu/custom/*.cc"
@ -40,26 +39,6 @@ if(ENABLE_CPU)
list(REMOVE_ITEM CPU_SRC_LIST "cpu/embedding_look_up_comm_grad_cpu_kernel.cc")
endif()
file(GLOB_RECURSE QUANTUM_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
"cpu/quantum/*.cc"
)
foreach(qcc ${QUANTUM_SRC_LIST})
list(REMOVE_ITEM CPU_SRC_LIST ${qcc})
endforeach()
if(${CMAKE_SYSTEM_NAME} MATCHES "Linux"
AND ${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "x86_64")
message("compiled quantum kernel_compiler")
set_property(SOURCE ${QUANTUM_SRC_LIST} PROPERTY COMPILE_DEFINITIONS
SUBMODULE_ID=mindspore::SubModuleId::SM_MINDQUANTUM)
set_property(SOURCE ${QUANTUM_SRC_LIST} PROPERTY COMPILE_DEFINITIONS INTRIN)
set_property(SOURCE ${QUANTUM_SRC_LIST} PROPERTY COMPILE_OPTIONS -fopenmp -mavx -ffast-math)
else()
message("not compiled quantum kernel_compiler")
set(QUANTUM_SRC_LIST "")
endif()
if(PLATFORM_ARM64)
add_compile_definitions(ENABLE_ARM)
endif()
@ -142,4 +121,4 @@ endif()
set_property(SOURCE ${KERNEL_SRC_LIST} ${CPU_SRC_LIST} ${GPU_SRC_LIST} ${D_SRC_LIST} ${AKG_SRC_LIST}
PROPERTY COMPILE_DEFINITIONS SUBMODULE_ID=mindspore::SubModuleId::SM_KERNEL)
add_library(_mindspore_backend_kernel_compiler_obj OBJECT ${KERNEL_SRC_LIST} ${CPU_SRC_LIST}
${GPU_SRC_LIST} ${D_SRC_LIST} ${AKG_SRC_LIST} ${QUANTUM_SRC_LIST})
${GPU_SRC_LIST} ${D_SRC_LIST} ${AKG_SRC_LIST})

94
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/evolution_cpu_kernel.cc
View File

@ -1,94 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/evolution_cpu_kernel.h"
#include <memory>
#include <algorithm>
#include "utils/ms_utils.h"
#include "runtime/device/cpu/cpu_device_address.h"
namespace mindspore {
namespace kernel {
void EvolutionCPUKernel::InitPQCStructure(const CNodePtr &kernel_node) {
n_qubits_ = AnfAlgo::GetNodeAttr<int64_t>(kernel_node, mindquantum::kNQubits);
param_names_ = AnfAlgo::GetNodeAttr<mindquantum::transformer::NamesType>(kernel_node, mindquantum::kParamNames);
gate_names_ = AnfAlgo::GetNodeAttr<mindquantum::transformer::NamesType>(kernel_node, mindquantum::kGateNames);
gate_matrix_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::ComplexMatrixsType>(kernel_node, mindquantum::kGateMatrix);
gate_obj_qubits_ = AnfAlgo::GetNodeAttr<mindquantum::transformer::Indexess>(kernel_node, mindquantum::kGateObjQubits);
gate_ctrl_qubits_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::Indexess>(kernel_node, mindquantum::kGateCtrlQubits);
gate_params_names_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::ParasNameType>(kernel_node, mindquantum::kGateParamsNames);
gate_coeff_ = AnfAlgo::GetNodeAttr<mindquantum::transformer::CoeffsType>(kernel_node, mindquantum::kGateCoeff);
gate_requires_grad_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::RequiresType>(kernel_node, mindquantum::kGateRequiresGrad);
hams_pauli_coeff_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::PaulisCoeffsType>(kernel_node, mindquantum::kHamsPauliCoeff);
hams_pauli_word_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::PaulisWordsType>(kernel_node, mindquantum::kHamsPauliWord);
hams_pauli_qubit_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::PaulisQubitsType>(kernel_node, mindquantum::kHamsPauliQubit);
}
void EvolutionCPUKernel::InitKernel(const CNodePtr &kernel_node) {
MS_EXCEPTION_IF_NULL(kernel_node);
std::vector<size_t> param_shape = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
std::vector<size_t> result_shape = AnfAlgo::GetOutputDeviceShape(kernel_node, 0);
if (param_shape.size() != 1 || result_shape.size() != 2) {
MS_LOG(EXCEPTION) << "evolution invalid input size";
}
state_len_ = result_shape[0];
InitPQCStructure(kernel_node);
auto circs = mindquantum::transformer::CircuitTransfor(gate_names_, gate_matrix_, gate_obj_qubits_, gate_ctrl_qubits_,
gate_params_names_, gate_coeff_, gate_requires_grad_);
circ_ = circs[0];
hams_ = mindquantum::transformer::HamiltoniansTransfor(hams_pauli_coeff_, hams_pauli_word_, hams_pauli_qubit_);
if (hams_.size() > 1) {
MS_LOG(EXCEPTION) << "evolution only work for single hamiltonian or no hamiltonian.";
}
}
bool EvolutionCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs, const std::vector<kernel::AddressPtr> &,
const std::vector<kernel::AddressPtr> &outputs) {
if (inputs.size() != 1 || outputs.size() != 1) {
MS_LOG(EXCEPTION) << "evolution error input output size!";
}
auto param_data = reinterpret_cast<float *>(inputs[0]->addr);
auto output = reinterpret_cast<float *>(outputs[0]->addr);
MS_EXCEPTION_IF_NULL(param_data);
MS_EXCEPTION_IF_NULL(output);
auto sim = mindquantum::PQCSimulator(1, n_qubits_);
mindquantum::ParameterResolver pr;
for (size_t i = 0; i < param_names_.size(); i++) {
pr.SetData(param_names_.at(i), param_data[i]);
}
sim.Evolution(circ_, pr);
if (hams_.size() == 1) {
sim.ApplyHamiltonian(hams_[0]);
}
if (state_len_ != (1UL << n_qubits_)) {
MS_LOG(EXCEPTION) << "simulation error number of quantum qubit!";
}
auto size = state_len_ * 2;
#pragma omp parallel for schedule(static)
for (size_t i = 0; i < size; i++) {
output[i] = sim.vec_[i];
}
return true;
}
} // namespace kernel
} // namespace mindspore

67
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/evolution_cpu_kernel.h
View File

@ -1,67 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_EVOLUTION_CPU_KERNEL_H_
#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_EVOLUTION_CPU_KERNEL_H_
#include <vector>
#include "backend/kernel_compiler/cpu/cpu_kernel.h"
#include "backend/kernel_compiler/cpu/cpu_kernel_factory.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/pqc_simulator.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/transformer.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/circuit.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/parameter_resolver.h"
namespace mindspore {
namespace kernel {
class EvolutionCPUKernel : public CPUKernel {
public:
EvolutionCPUKernel() = default;
~EvolutionCPUKernel() override = default;
void InitKernel(const CNodePtr &kernel_node) override;
bool Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &workspace,
const std::vector<AddressPtr> &outputs) override;
void InitPQCStructure(const CNodePtr &kernel_node);
private:
int64_t n_qubits_;
size_t state_len_;
mindquantum::BasicCircuit circ_;
mindquantum::transformer::Hamiltonians hams_;
mindquantum::transformer::NamesType param_names_;
// quantum circuit
mindquantum::transformer::NamesType gate_names_;
mindquantum::transformer::ComplexMatrixsType gate_matrix_;
mindquantum::transformer::Indexess gate_obj_qubits_;
mindquantum::transformer::Indexess gate_ctrl_qubits_;
mindquantum::transformer::ParasNameType gate_params_names_;
mindquantum::transformer::CoeffsType gate_coeff_;
mindquantum::transformer::RequiresType gate_requires_grad_;
// hamiltonian
mindquantum::transformer::PaulisCoeffsType hams_pauli_coeff_;
mindquantum::transformer::PaulisWordsType hams_pauli_word_;
mindquantum::transformer::PaulisQubitsType hams_pauli_qubit_;
};
MS_REG_CPU_KERNEL(Evolution, KernelAttr().AddInputAttr(kNumberTypeFloat32).AddOutputAttr(kNumberTypeFloat32),
EvolutionCPUKernel);
} // namespace kernel
} // namespace mindspore
#endif // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_EVOLUTION_CPU_KERNEL_H_

264
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/pqc_cpu_kernel.cc
View File

@ -1,264 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/pqc_cpu_kernel.h"
#include <omp.h>
#include <utility>
#include <thread>
#include <memory>
#include <algorithm>
#include "utils/ms_utils.h"
#include "runtime/device/cpu/cpu_device_address.h"
#include "common/thread_pool.h"
namespace mindspore {
namespace kernel {
namespace {
struct ComputeParam {
float *encoder_data_cp{nullptr};
float *ansatz_data_cp{nullptr};
float *output_cp{nullptr};
float *gradient_encoder_cp{nullptr};
float *gradient_ansatz_cp{nullptr};
mindquantum::BasicCircuit *circ_cp;
mindquantum::BasicCircuit *herm_circ_cp;
mindquantum::transformer::Hamiltonians *hams_cp;
mindquantum::transformer::Projectors *projectors_cp;
mindquantum::transformer::NamesType *encoder_params_names_cp;
mindquantum::transformer::NamesType *ansatz_params_names_cp;
std::vector<std::vector<std::shared_ptr<mindquantum::PQCSimulator>>> *tmp_sims_cp;
bool dummy_circuit_cp{false};
bool is_projector_cp{false};
size_t result_len_cp{0};
size_t encoder_g_len_cp{0};
size_t ansatz_g_len_cp{0};
};
void ComputerForwardBackward(const std::shared_ptr<ComputeParam> &input_params, size_t start, size_t end, size_t id) {
MS_EXCEPTION_IF_NULL(input_params);
MS_EXCEPTION_IF_NULL(input_params->encoder_data_cp);
MS_EXCEPTION_IF_NULL(input_params->ansatz_data_cp);
MS_EXCEPTION_IF_NULL(input_params->output_cp);
MS_EXCEPTION_IF_NULL(input_params->gradient_encoder_cp);
MS_EXCEPTION_IF_NULL(input_params->gradient_ansatz_cp);
auto encoder_data = input_params->encoder_data_cp;
auto ansatz_data = input_params->ansatz_data_cp;
auto output = input_params->output_cp;
auto gradient_encoder = input_params->gradient_encoder_cp;
auto gradient_ansatz = input_params->gradient_ansatz_cp;
auto circ = input_params->circ_cp;
auto herm_circ = input_params->herm_circ_cp;
auto hams = input_params->hams_cp;
auto projectors = input_params->projectors_cp;
auto is_projector = input_params->is_projector_cp;
auto encoder_params_names = input_params->encoder_params_names_cp;
auto ansatz_params_names = input_params->ansatz_params_names_cp;
auto tmp_sims = input_params->tmp_sims_cp;
auto dummy_circuit = input_params->dummy_circuit_cp;
auto result_len = input_params->result_len_cp;
auto encoder_g_len = input_params->encoder_g_len_cp;
auto ansatz_g_len = input_params->ansatz_g_len_cp;
MS_EXCEPTION_IF_NULL(hams);
MS_EXCEPTION_IF_NULL(encoder_params_names);
MS_EXCEPTION_IF_NULL(ansatz_params_names);
MS_EXCEPTION_IF_NULL(tmp_sims);
auto mea_size = hams->size();
if (is_projector) {
mea_size = projectors->size();
}
if (end * mea_size > result_len || end * encoder_params_names->size() * mea_size > encoder_g_len ||
end * ansatz_params_names->size() * mea_size > ansatz_g_len) {
MS_LOG(EXCEPTION) << "pqc error input size!";
}
mindquantum::ParameterResolver pr;
for (size_t i = 0; i < ansatz_params_names->size(); i++) {
pr.SetData(ansatz_params_names->at(i), ansatz_data[i]);
}
for (size_t n = start; n < end; ++n) {
for (size_t i = 0; i < encoder_params_names->size(); i++) {
pr.SetData(encoder_params_names->at(i), encoder_data[n * encoder_params_names->size() + i]);
}
auto sim = tmp_sims->at(id)[3];
sim->SetZeroState();
sim->Evolution(*circ, pr);
auto calc_gradient_param = std::make_shared<mindquantum::CalcGradientParam>();
calc_gradient_param->circuit_cp = circ;
calc_gradient_param->circuit_hermitian_cp = herm_circ;
calc_gradient_param->hamiltonians_cp = hams;
calc_gradient_param->projectors_cp = projectors;
calc_gradient_param->is_projector_cp = is_projector;
calc_gradient_param->paras_cp = &pr;
calc_gradient_param->encoder_params_names_cp = encoder_params_names;
calc_gradient_param->ansatz_params_names_cp = ansatz_params_names;
calc_gradient_param->dummy_circuit_cp = dummy_circuit;
auto e0_grad1_grad_2 =
sim->CalcGradient(calc_gradient_param, *tmp_sims->at(id)[0], *tmp_sims->at(id)[1], *tmp_sims->at(id)[2]);
auto energy = e0_grad1_grad_2[0];
auto grad_encoder = e0_grad1_grad_2[1];
auto grad_ansatz = e0_grad1_grad_2[2];
if (energy.size() != mea_size || grad_encoder.size() != encoder_params_names->size() * mea_size ||
grad_ansatz.size() != ansatz_params_names->size() * mea_size) {
MS_LOG(EXCEPTION) << "pqc error evolution or batch size!";
}
for (size_t poi = 0; poi < mea_size; poi++) {
output[n * mea_size + poi] = energy[poi];
}
for (size_t poi = 0; poi < encoder_params_names->size() * mea_size; poi++) {
gradient_encoder[n * mea_size * encoder_params_names->size() + poi] = grad_encoder[poi];
}
for (size_t poi = 0; poi < ansatz_params_names->size() * mea_size; poi++) {
gradient_ansatz[n * mea_size * ansatz_params_names->size() + poi] = grad_ansatz[poi];
}
}
}
} // namespace
void PQCCPUKernel::InitPQCStructure(const CNodePtr &kernel_node) {
n_threads_user_ = AnfAlgo::GetNodeAttr<int64_t>(kernel_node, mindquantum::kNThreads);
n_qubits_ = AnfAlgo::GetNodeAttr<int64_t>(kernel_node, mindquantum::kNQubits);
encoder_params_names_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::NamesType>(kernel_node, mindquantum::kEncoderParamsNames);
ansatz_params_names_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::NamesType>(kernel_node, mindquantum::kAnsatzParamsNames);
gate_names_ = AnfAlgo::GetNodeAttr<mindquantum::transformer::NamesType>(kernel_node, mindquantum::kGateNames);
gate_matrix_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::ComplexMatrixsType>(kernel_node, mindquantum::kGateMatrix);
gate_obj_qubits_ = AnfAlgo::GetNodeAttr<mindquantum::transformer::Indexess>(kernel_node, mindquantum::kGateObjQubits);
gate_ctrl_qubits_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::Indexess>(kernel_node, mindquantum::kGateCtrlQubits);
gate_params_names_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::ParasNameType>(kernel_node, mindquantum::kGateParamsNames);
gate_coeff_ = AnfAlgo::GetNodeAttr<mindquantum::transformer::CoeffsType>(kernel_node, mindquantum::kGateCoeff);
gate_requires_grad_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::RequiresType>(kernel_node, mindquantum::kGateRequiresGrad);
hams_pauli_coeff_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::PaulisCoeffsType>(kernel_node, mindquantum::kHamsPauliCoeff);
hams_pauli_word_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::PaulisWordsType>(kernel_node, mindquantum::kHamsPauliWord);
hams_pauli_qubit_ =
AnfAlgo::GetNodeAttr<mindquantum::transformer::PaulisQubitsType>(kernel_node, mindquantum::kHamsPauliQubit);
projector_strs_ = AnfAlgo::GetNodeAttr<mindquantum::transformer::NamesType>(kernel_node, mindquantum::kProjectors);
is_projector_ = AnfAlgo::GetNodeAttr<bool>(kernel_node, mindquantum::kIsProjector);
}
void PQCCPUKernel::InitKernel(const CNodePtr &kernel_node) {
MS_EXCEPTION_IF_NULL(kernel_node);
std::vector<size_t> encoder_shape = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
std::vector<size_t> ansatz_shape = AnfAlgo::GetInputDeviceShape(kernel_node, 1);
std::vector<size_t> result_shape = AnfAlgo::GetOutputDeviceShape(kernel_node, 0);
std::vector<size_t> encoder_g_shape = AnfAlgo::GetOutputDeviceShape(kernel_node, 1);
std::vector<size_t> ansatz_g_shape = AnfAlgo::GetOutputDeviceShape(kernel_node, 2);
if (encoder_shape.size() != 2 || ansatz_shape.size() != 1 || result_shape.size() != 2 ||
encoder_g_shape.size() != 3 || ansatz_g_shape.size() != 3) {
MS_LOG(EXCEPTION) << "pqc invalid input size";
}
result_len_ = result_shape[0] * result_shape[1];
encoder_g_len_ = encoder_g_shape[0] * encoder_g_shape[1] * encoder_g_shape[2];
ansatz_g_len_ = ansatz_g_shape[0] * ansatz_g_shape[1] * ansatz_g_shape[2];
n_samples_ = static_cast<unsigned>(encoder_shape[0]);
InitPQCStructure(kernel_node);
dummy_circuit_ = !std::any_of(gate_requires_grad_.begin(), gate_requires_grad_.end(),
[](const mindquantum::transformer::RequireType &rr) {
return std::any_of(rr.begin(), rr.end(), [](const bool &r) { return r; });
});
auto circs = mindquantum::transformer::CircuitTransfor(gate_names_, gate_matrix_, gate_obj_qubits_, gate_ctrl_qubits_,
gate_params_names_, gate_coeff_, gate_requires_grad_);
circ_ = circs[0];
herm_circ_ = circs[1];
hams_ = mindquantum::transformer::HamiltoniansTransfor(hams_pauli_coeff_, hams_pauli_word_, hams_pauli_qubit_);
projectors_ = mindquantum::transformer::ProjectorsTransfor(projector_strs_);
n_threads_user_ = std::min(n_threads_user_, common::ThreadPool::GetInstance().GetSyncRunThreadNum());
if (n_samples_ < n_threads_user_) {
n_threads_user_ = n_samples_;
}
}
bool PQCCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs, const std::vector<kernel::AddressPtr> &,
const std::vector<kernel::AddressPtr> &outputs) {
if (inputs.size() != 2 || outputs.size() != 3) {
MS_LOG(EXCEPTION) << "pqc error input output size!";
}
auto encoder_data = reinterpret_cast<float *>(inputs[0]->addr);
auto ansatz_data = reinterpret_cast<float *>(inputs[1]->addr);
auto output = reinterpret_cast<float *>(outputs[0]->addr);
auto gradient_encoder = reinterpret_cast<float *>(outputs[1]->addr);
auto gradient_ansatz = reinterpret_cast<float *>(outputs[2]->addr);
MS_EXCEPTION_IF_NULL(encoder_data);
MS_EXCEPTION_IF_NULL(ansatz_data);
MS_EXCEPTION_IF_NULL(output);
MS_EXCEPTION_IF_NULL(gradient_encoder);
MS_EXCEPTION_IF_NULL(gradient_ansatz);
std::vector<std::vector<std::shared_ptr<mindquantum::PQCSimulator>>> tmp_sims(
n_threads_user_, std::vector<std::shared_ptr<mindquantum::PQCSimulator>>(4, nullptr));
#pragma omp parallel for collapse(2) schedule(static)
for (size_t i = 0; i < n_threads_user_; i++) {
for (size_t j = 0; j < 4; j++) {
auto tmp = std::make_shared<mindquantum::PQCSimulator>(1, n_qubits_);
tmp_sims[i][j] = tmp;
}
}
std::vector<common::Task> tasks;
std::vector<std::shared_ptr<ComputeParam>> thread_params;
tasks.reserve(n_threads_user_);
size_t end = 0;
size_t offset = n_samples_ / n_threads_user_;
size_t left = n_samples_ % n_threads_user_;
for (size_t i = 0; i < n_threads_user_; ++i) {
auto params = std::make_shared<ComputeParam>();
params->encoder_data_cp = encoder_data;
params->ansatz_data_cp = ansatz_data;
params->output_cp = output;
params->gradient_encoder_cp = gradient_encoder;
params->gradient_ansatz_cp = gradient_ansatz;
params->circ_cp = &circ_;
params->herm_circ_cp = &herm_circ_;
params->hams_cp = &hams_;
params->projectors_cp = &projectors_;
params->is_projector_cp = is_projector_;
params->encoder_params_names_cp = &encoder_params_names_;
params->ansatz_params_names_cp = &ansatz_params_names_;
params->tmp_sims_cp = &tmp_sims;
params->dummy_circuit_cp = dummy_circuit_;
params->result_len_cp = result_len_;
params->encoder_g_len_cp = encoder_g_len_;
params->ansatz_g_len_cp = ansatz_g_len_;
size_t start = end;
end = start + offset;
if (i < left) {
end += 1;
}
auto task = [&params, start, end, i]() {
ComputerForwardBackward(params, start, end, i);
return common::SUCCESS;
};
(void)tasks.emplace_back(task);
(void)thread_params.emplace_back(params);
}
(void)common::ThreadPool::GetInstance().SyncRun(tasks);
return true;
}
} // namespace kernel
} // namespace mindspore

91
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/pqc_cpu_kernel.h
View File

@ -1,91 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_PQC_CPU_KERNEL_H_
#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_PQC_CPU_KERNEL_H_
#include <vector>
#include <memory>
#include <string>
#include "backend/kernel_compiler/cpu/cpu_kernel.h"
#include "backend/kernel_compiler/cpu/cpu_kernel_factory.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/pqc_simulator.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/transformer.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/circuit.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/parameter_resolver.h"
namespace mindspore {
namespace kernel {
class PQCCPUKernel : public CPUKernel {
public:
PQCCPUKernel() = default;
~PQCCPUKernel() override = default;
void InitKernel(const CNodePtr &kernel_node) override;
bool Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &workspace,
const std::vector<AddressPtr> &outputs) override;
void InitPQCStructure(const CNodePtr &kernel_node);
private:
size_t n_samples_;
size_t n_threads_user_;
bool dummy_circuit_;
size_t result_len_;
size_t encoder_g_len_;
size_t ansatz_g_len_;
int64_t n_qubits_;
mindquantum::BasicCircuit circ_;
mindquantum::BasicCircuit herm_circ_;
mindquantum::transformer::Hamiltonians hams_;
mindquantum::transformer::Projectors projectors_;
// parameters
mindquantum::transformer::NamesType encoder_params_names_;
mindquantum::transformer::NamesType ansatz_params_names_;
// quantum circuit
mindquantum::transformer::NamesType gate_names_;
mindquantum::transformer::ComplexMatrixsType gate_matrix_;
mindquantum::transformer::Indexess gate_obj_qubits_;
mindquantum::transformer::Indexess gate_ctrl_qubits_;
mindquantum::transformer::ParasNameType gate_params_names_;
mindquantum::transformer::CoeffsType gate_coeff_;
mindquantum::transformer::RequiresType gate_requires_grad_;
// hamiltonian
mindquantum::transformer::PaulisCoeffsType hams_pauli_coeff_;
mindquantum::transformer::PaulisWordsType hams_pauli_word_;
mindquantum::transformer::PaulisQubitsType hams_pauli_qubit_;
// subspace measurement ops
mindquantum::transformer::NamesType projector_strs_;
bool is_projector_;
};
MS_REG_CPU_KERNEL(PQC,
KernelAttr()
.AddInputAttr(kNumberTypeFloat32)
.AddInputAttr(kNumberTypeFloat32)
.AddOutputAttr(kNumberTypeFloat32)
.AddOutputAttr(kNumberTypeFloat32)
.AddOutputAttr(kNumberTypeFloat32),
PQCCPUKernel);
} // namespace kernel
} // namespace mindspore
#endif // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_PQC_CPU_KERNEL_H_

10
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/CMakeLists.txt
View File

@ -1,10 +0,0 @@
if(ENABLE_CPU AND ${CMAKE_SYSTEM_NAME} MATCHES "Linux"
AND ${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "x86_64")
message("compiled quantum simulator")
file(GLOB_RECURSE _MINDQUANTUM_SRC_LIST RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.cc")
set_property(SOURCE ${_MINDQUANTUM_SRC_LIST} PROPERTY COMPILE_DEFINITIONS
SUBMODULE_ID=mindspore::SubModuleId::SM_MINDQUANTUM)
add_library(_mindspore_mindquantum_obj OBJECT ${_MINDQUANTUM_SRC_LIST})
target_compile_options(_mindspore_mindquantum_obj PRIVATE -fopenmp -mavx -ffast-math)
target_compile_definitions(_mindspore_mindquantum_obj PRIVATE INTRIN)
endif()

59
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/circuit.cc
View File

@ -1,59 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/circuit.h"
namespace mindspore {
namespace mindquantum {
BasicCircuit::BasicCircuit() : gate_blocks_({}) {}
void BasicCircuit::AppendBlock() { gate_blocks_.push_back({}); }
void BasicCircuit::AppendNoneParameterGate(const std::string &name, Matrix m, Indexes obj_qubits, Indexes ctrl_qubits) {
auto npg = std::make_shared<NoneParameterGate>(name, m, obj_qubits, ctrl_qubits);
gate_blocks_.back().push_back(npg);
}
void BasicCircuit::AppendParameterGate(const std::string &name, Indexes obj_qubits, Indexes ctrl_qubits,
const ParameterResolver &paras) {
if (name == "RX") {
auto pg_rx = std::make_shared<RXGate>(obj_qubits, ctrl_qubits, paras);
gate_blocks_.back().push_back(pg_rx);
} else if (name == "RY") {
auto pg_ry = std::make_shared<RYGate>(obj_qubits, ctrl_qubits, paras);
gate_blocks_.back().push_back(pg_ry);
} else if (name == "RZ") {
auto pg_rz = std::make_shared<RZGate>(obj_qubits, ctrl_qubits, paras);
gate_blocks_.back().push_back(pg_rz);
} else if (name == "XX") {
auto pg_xx = std::make_shared<XXGate>(obj_qubits, ctrl_qubits, paras);
gate_blocks_.back().push_back(pg_xx);
} else if (name == "YY") {
auto pg_yy = std::make_shared<YYGate>(obj_qubits, ctrl_qubits, paras);
gate_blocks_.back().push_back(pg_yy);
} else if (name == "ZZ") {
auto pg_zz = std::make_shared<ZZGate>(obj_qubits, ctrl_qubits, paras);
gate_blocks_.back().push_back(pg_zz);
} else if (name == "PS") {
auto pg_ps = std::make_shared<PhaseShiftGate>(obj_qubits, ctrl_qubits, paras);
gate_blocks_.back().push_back(pg_ps);
} else {
}
}
const GateBlocks &BasicCircuit::GetGateBlocks() const { return gate_blocks_; }
} // namespace mindquantum
} // namespace mindspore

45
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/circuit.h
View File

@ -1,45 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_CCIRCUIT_H_
#define MINDQUANTUM_ENGINE_CCIRCUIT_H_
#include <vector>
#include <string>
#include <memory>
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/non_parameter_gate.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/gates.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
using GateBlock = std::vector<std::shared_ptr<BasicGate>>;
using GateBlocks = std::vector<GateBlock>;
class BasicCircuit {
private:
GateBlocks gate_blocks_;
public:
BasicCircuit();
void AppendBlock();
void AppendNoneParameterGate(const std::string &, Matrix, Indexes, Indexes);
void AppendParameterGate(const std::string &, Indexes, Indexes, const ParameterResolver &);
const GateBlocks &GetGateBlocks() const;
~BasicCircuit() {}
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_CCIRCUIT_H_

46
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/basic_gates.cc
View File

@ -1,46 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/basic_gates.h"
#include <string>
namespace mindspore {
namespace mindquantum {
BasicGate::BasicGate(const std::string &name, bool is_parameter, const Indexes &obj_qubits, const Indexes &ctrl_qubits,
const ParameterResolver &paras)
: name_(name), is_parameter_(is_parameter), obj_qubits_(obj_qubits), ctrl_qubits_(ctrl_qubits), paras_(paras) {}
Matrix BasicGate::GetMatrix(const ParameterResolver &paras_out) {
Matrix gate_matrix_tmp;
return gate_matrix_tmp;
}
Matrix BasicGate::GetDiffMatrix(const ParameterResolver &paras_out) {
Matrix gate_matrix_tmp;
return gate_matrix_tmp;
}
Matrix &BasicGate::GetBaseMatrix() { return gate_matrix_base_; }
const ParameterResolver &BasicGate::GetParameterResolver() const { return paras_; }
bool BasicGate::IsParameterGate() { return is_parameter_; }
Indexes BasicGate::GetObjQubits() { return obj_qubits_; }
Indexes BasicGate::GetCtrlQubits() { return ctrl_qubits_; }
} // namespace mindquantum
} // namespace mindspore

49
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/basic_gates.h
View File

@ -1,49 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_BASIC_GATES_H_
#define MINDQUANTUM_ENGINE_BASIC_GATES_H_
#include <string>
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/parameter_resolver.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
class BasicGate {
private:
std::string name_;
bool is_parameter_;
Matrix gate_matrix_base_;
Indexes obj_qubits_;
Indexes ctrl_qubits_;
ParameterResolver paras_;
public:
BasicGate();
BasicGate(const std::string &, bool, const Indexes &, const Indexes &,
const ParameterResolver &paras = ParameterResolver());
virtual Matrix GetMatrix(const ParameterResolver &);
virtual Matrix GetDiffMatrix(const ParameterResolver &);
virtual Matrix &GetBaseMatrix();
const ParameterResolver &GetParameterResolver() const;
bool IsParameterGate();
Indexes GetObjQubits();
Indexes GetCtrlQubits();
virtual ~BasicGate() {}
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_BASIC_GATES_H_

166
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/gates.cc
View File

@ -1,166 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/gates.h"
#include <cmath>
namespace mindspore {
namespace mindquantum {
RXGate::RXGate(const Indexes &obj_qubits, const Indexes &ctrl_qubits, const ParameterResolver &paras)
: IntrinsicOneParaGate("RX", obj_qubits, ctrl_qubits, paras) {}
RXGate::RXGate() : IntrinsicOneParaGate("RX", {}, {}, {}) {}
Matrix RXGate::GetIntrinsicMatrix(CalcType theta) {
Matrix result = {{{cos(theta / 2), 0}, {0, -sin(theta / 2)}}, {{0, -sin(theta / 2)}, {cos(theta / 2), 0}}};
return result;
}
Matrix RXGate::GetIntrinsicDiffMatrix(CalcType theta) {
Matrix result = {{{-sin(theta / 2) / 2, 0}, {0, -cos(theta / 2) / 2}},
{{0, -cos(theta / 2) / 2}, {-sin(theta / 2) / 2, 0}}};
return result;
}
RYGate::RYGate(const Indexes &obj_qubits, const Indexes &ctrl_qubits, const ParameterResolver &paras)
: IntrinsicOneParaGate("RY", obj_qubits, ctrl_qubits, paras) {}
RYGate::RYGate() : IntrinsicOneParaGate("RY", {}, {}, {}) {}
Matrix RYGate::GetIntrinsicMatrix(CalcType theta) {
Matrix result = {{{cos(theta / 2), 0}, {-sin(theta / 2), 0}}, {{sin(theta / 2), 0}, {cos(theta / 2), 0}}};
return result;
}
Matrix RYGate::GetIntrinsicDiffMatrix(CalcType theta) {
Matrix result = {{{-sin(theta / 2) / 2, 0}, {-cos(theta / 2) / 2, 0}},
{{cos(theta / 2) / 2, 0}, {-sin(theta / 2) / 2, 0}}};
return result;
}
RZGate::RZGate(const Indexes &obj_qubits, const Indexes &ctrl_qubits, const ParameterResolver &paras)
: IntrinsicOneParaGate("RZ", obj_qubits, ctrl_qubits, paras) {}
RZGate::RZGate() : IntrinsicOneParaGate("RZ", {}, {}, {}) {}
Matrix RZGate::GetIntrinsicMatrix(CalcType theta) {
Matrix result = {{{cos(theta / 2), -sin(theta / 2)}, {0, 0}}, {{0, 0}, {cos(theta / 2), sin(theta / 2)}}};
return result;
}
Matrix RZGate::GetIntrinsicDiffMatrix(CalcType theta) {
Matrix result = {{{-sin(theta / 2) / 2, -cos(theta / 2) / 2}, {0, 0}},
{{0, 0}, {-sin(theta / 2) / 2, cos(theta / 2) / 2}}};
return result;
}
PhaseShiftGate::PhaseShiftGate(const Indexes &obj_qubits, const Indexes &ctrl_qubits, const ParameterResolver &paras)
: IntrinsicOneParaGate("PS", obj_qubits, ctrl_qubits, paras) {}
PhaseShiftGate::PhaseShiftGate() : IntrinsicOneParaGate("PS", {}, {}, {}) {}
Matrix PhaseShiftGate::GetIntrinsicMatrix(CalcType theta) {
Matrix result = {{{1, 0}, {0, 0}}, {{0, 0}, {cos(theta), sin(theta)}}};
return result;
}
Matrix PhaseShiftGate::GetIntrinsicDiffMatrix(CalcType theta) {
Matrix result = {{{0, 0}, {0, 0}}, {{0, 0}, {-sin(theta), cos(theta)}}};
return result;
}
XXGate::XXGate(const Indexes &obj_qubits, const Indexes &ctrl_qubits, const ParameterResolver &paras)
: IntrinsicOneParaGate("XX", obj_qubits, ctrl_qubits, paras) {}
XXGate::XXGate() : IntrinsicOneParaGate("XX", {}, {}, {}) {}
Matrix XXGate::GetIntrinsicMatrix(CalcType theta) {
double c = cos(theta);
double s = sin(theta);
Matrix result = {{{c, 0}, {0, 0}, {0, 0}, {0, -s}},
{{0, 0}, {c, 0}, {0, -s}, {0, 0}},
{{0, 0}, {0, -s}, {c, 0}, {0, 0}},
{{0, -s}, {0, 0}, {0, 0}, {c, 0}}};
return result;
}
Matrix XXGate::GetIntrinsicDiffMatrix(CalcType theta) {
double c = cos(theta);
double s = sin(theta);
Matrix result = {{{-s, 0}, {0, 0}, {0, 0}, {0, -c}},
{{0, 0}, {-s, 0}, {0, -c}, {0, 0}},
{{0, 0}, {0, -c}, {-s, 0}, {0, 0}},
{{0, -c}, {0, 0}, {0, 0}, {-s, 0}}};
return result;
}
YYGate::YYGate(const Indexes &obj_qubits, const Indexes &ctrl_qubits, const ParameterResolver &paras)
: IntrinsicOneParaGate("YY", obj_qubits, ctrl_qubits, paras) {}
YYGate::YYGate() : IntrinsicOneParaGate("YY", {}, {}, {}) {}
Matrix YYGate::GetIntrinsicMatrix(CalcType theta) {
double c = cos(theta);
double s = sin(theta);
Matrix result = {{{c, 0}, {0, 0}, {0, 0}, {0, s}},
{{0, 0}, {c, 0}, {0, -s}, {0, 0}},
{{0, 0}, {0, -s}, {c, 0}, {0, 0}},
{{0, s}, {0, 0}, {0, 0}, {c, 0}}};
return result;
}
Matrix YYGate::GetIntrinsicDiffMatrix(CalcType theta) {
double c = cos(theta);
double s = sin(theta);
Matrix result = {{{-s, 0}, {0, 0}, {0, 0}, {0, c}},
{{0, 0}, {-s, 0}, {0, -c}, {0, 0}},
{{0, 0}, {0, -c}, {-s, 0}, {0, 0}},
{{0, c}, {0, 0}, {0, 0}, {-s, 0}}};
return result;
}
ZZGate::ZZGate(const Indexes &obj_qubits, const Indexes &ctrl_qubits, const ParameterResolver &paras)
: IntrinsicOneParaGate("ZZ", obj_qubits, ctrl_qubits, paras) {}
ZZGate::ZZGate() : IntrinsicOneParaGate("ZZ", {}, {}, {}) {}
Matrix ZZGate::GetIntrinsicMatrix(CalcType theta) {
double c = cos(theta);
double s = sin(theta);
Matrix result = {{{c, -s}, {0, 0}, {0, 0}, {0, 0}},
{{0, 0}, {c, s}, {0, 0}, {0, 0}},
{{0, 0}, {0, 0}, {c, s}, {0, 0}},
{{0, 0}, {0, 0}, {0, 0}, {c, -s}}};
return result;
}
Matrix ZZGate::GetIntrinsicDiffMatrix(CalcType theta) {
double c = cos(theta);
double s = sin(theta);
Matrix result = {{{-s, -c}, {0, 0}, {0, 0}, {0, 0}},
{{0, 0}, {-s, c}, {0, 0}, {0, 0}},
{{0, 0}, {0, 0}, {-s, c}, {0, 0}},
{{0, 0}, {0, 0}, {0, 0}, {-s, -c}}};
return result;
}
} // namespace mindquantum
} // namespace mindspore

95
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/gates.h
View File

@ -1,95 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_GATES_H_
#define MINDQUANTUM_ENGINE_GATES_H_
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/intrinsic_one_para_gate.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
class RXGate : public IntrinsicOneParaGate {
Matrix GetIntrinsicMatrix(CalcType) override;
Matrix GetIntrinsicDiffMatrix(CalcType) override;
public:
RXGate(const Indexes &, const Indexes &, const ParameterResolver &);
RXGate();
~RXGate() {}
};
class RYGate : public IntrinsicOneParaGate {
Matrix GetIntrinsicMatrix(CalcType) override;
Matrix GetIntrinsicDiffMatrix(CalcType) override;
public:
RYGate(const Indexes &, const Indexes &, const ParameterResolver &);
RYGate();
~RYGate() {}
};
class RZGate : public IntrinsicOneParaGate {
Matrix GetIntrinsicMatrix(CalcType) override;
Matrix GetIntrinsicDiffMatrix(CalcType) override;
public:
RZGate(const Indexes &, const Indexes &, const ParameterResolver &);
RZGate();
~RZGate() {}
};
class PhaseShiftGate : public IntrinsicOneParaGate {
Matrix GetIntrinsicMatrix(CalcType) override;
Matrix GetIntrinsicDiffMatrix(CalcType) override;
public:
PhaseShiftGate(const Indexes &, const Indexes &, const ParameterResolver &);
PhaseShiftGate();
~PhaseShiftGate() {}
};
class XXGate : public IntrinsicOneParaGate {
Matrix GetIntrinsicMatrix(CalcType) override;
Matrix GetIntrinsicDiffMatrix(CalcType) override;
public:
XXGate(const Indexes &, const Indexes &, const ParameterResolver &);
XXGate();
~XXGate() {}
};
class YYGate : public IntrinsicOneParaGate {
Matrix GetIntrinsicMatrix(CalcType) override;
Matrix GetIntrinsicDiffMatrix(CalcType) override;
public:
YYGate(const Indexes &, const Indexes &, const ParameterResolver &);
YYGate();
~YYGate() {}
};
class ZZGate : public IntrinsicOneParaGate {
Matrix GetIntrinsicMatrix(CalcType) override;
Matrix GetIntrinsicDiffMatrix(CalcType) override;
public:
ZZGate(const Indexes &, const Indexes &, const ParameterResolver &);
ZZGate();
~ZZGate() {}
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_GATES_H_

53
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/intrinsic_one_para_gate.cc
View File

@ -1,53 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/intrinsic_one_para_gate.h"
#include <string>
namespace mindspore {
namespace mindquantum {
Matrix IntrinsicOneParaGate::GetIntrinsicMatrix(CalcType theta) {
Matrix gate_matrix_tmp;
return gate_matrix_tmp;
}
Matrix IntrinsicOneParaGate::GetIntrinsicDiffMatrix(CalcType theta) {
Matrix gate_matrix_tmp;
return gate_matrix_tmp;
}
IntrinsicOneParaGate::IntrinsicOneParaGate(const std::string &name, const Indexes &obj_qubits,
const Indexes &ctrl_qubits, const ParameterResolver &paras)
: ParameterGate(name, obj_qubits, ctrl_qubits, paras) {}
CalcType IntrinsicOneParaGate::LinearCombination(const ParameterResolver &paras_in,
const ParameterResolver &paras_out) {
CalcType result = 0;
auto &paras_in_data = paras_in.GetData();
auto &paras_out_data = paras_out.GetData();
for (ParaType::const_iterator i = paras_in_data.begin(); i != paras_in_data.end(); ++i) {
result = result + paras_out_data.at(i->first) * (i->second);
}
return result;
}
Matrix IntrinsicOneParaGate::GetMatrix(const ParameterResolver &paras_out) {
return GetIntrinsicMatrix(LinearCombination(GetParameterResolver(), paras_out));
}
Matrix IntrinsicOneParaGate::GetDiffMatrix(const ParameterResolver &paras_out) {
return GetIntrinsicDiffMatrix(LinearCombination(GetParameterResolver(), paras_out));
}
} // namespace mindquantum
} // namespace mindspore

39
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/intrinsic_one_para_gate.h
View File

@ -1,39 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_INTRINSIC_ONE_PARAGATE_H_
#define MINDQUANTUM_ENGINE_INTRINSIC_ONE_PARAGATE_H_
#include <string>
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/parameter_gate.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
class IntrinsicOneParaGate : public ParameterGate {
virtual Matrix GetIntrinsicMatrix(CalcType);
virtual Matrix GetIntrinsicDiffMatrix(CalcType);
public:
IntrinsicOneParaGate();
IntrinsicOneParaGate(const std::string &, const Indexes &, const Indexes &, const ParameterResolver &);
CalcType LinearCombination(const ParameterResolver &, const ParameterResolver &);
Matrix GetMatrix(const ParameterResolver &) override;
Matrix GetDiffMatrix(const ParameterResolver &) override;
virtual ~IntrinsicOneParaGate() {}
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_INTRINSIC_ONE_PARAGATE_H_

28
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/non_parameter_gate.cc
View File

@ -1,28 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/non_parameter_gate.h"
#include <string>
namespace mindspore {
namespace mindquantum {
NoneParameterGate::NoneParameterGate(const std::string &name, const Matrix &gate_matrix, const Indexes &obj_qubits,
const Indexes &ctrl_qubits)
: BasicGate(name, false, obj_qubits, ctrl_qubits), gate_matrix_(gate_matrix) {}
Matrix &NoneParameterGate::GetBaseMatrix() { return gate_matrix_; }
} // namespace mindquantum
} // namespace mindspore

35
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/non_parameter_gate.h
View File

@ -1,35 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_NON_PARAMETER_GATE_H_
#define MINDQUANTUM_ENGINE_NON_PARAMETER_GATE_H_
#include <string>
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/basic_gates.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
class NoneParameterGate : public BasicGate {
private:
Matrix gate_matrix_;
public:
NoneParameterGate(const std::string &, const Matrix &, const Indexes &, const Indexes &);
Matrix &GetBaseMatrix() override;
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_NON_PARAMETER_GATE_H_

26
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/parameter_gate.cc
View File

@ -1,26 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/parameter_gate.h"
#include <string>
namespace mindspore {
namespace mindquantum {
ParameterGate::ParameterGate(const std::string &name, const Indexes &obj_qubits, const Indexes &ctrl_qubits,
const ParameterResolver &paras)
: BasicGate(name, true, obj_qubits, ctrl_qubits, paras) {}
} // namespace mindquantum
} // namespace mindspore

33
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/parameter_gate.h
View File

@ -1,33 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_PARAMETER_GATE_H_
#define MINDQUANTUM_ENGINE_PARAMETER_GATE_H_
#include <string>
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/basic_gates.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
class ParameterGate : public BasicGate {
public:
ParameterGate();
ParameterGate(const std::string &, const Indexes &, const Indexes &, const ParameterResolver &);
virtual ~ParameterGate() {}
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_PARAMETER_GATE_H_

79
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/hamiltonian.cc
View File

@ -1,79 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/hamiltonian.h"
#include <utility>
namespace mindspore {
namespace mindquantum {
Hamiltonian::Hamiltonian() {}
Hamiltonian::Hamiltonian(const sparse::GoodHamilt &ham, Index n) : ham_(ham), n_qubits_(n) {}
sparse::DequeSparseHam Hamiltonian::TransHamiltonianPhaseOne(int n_thread1, const sparse::GoodHamilt &ham, Index n) {
sparse::DequeSparseHam ham_sparse;
ham_sparse.resize(ham.size());
int step = 0;
#pragma omp parallel for schedule(static) num_threads(n_thread1)
for (Index i = 0; i < ham.size(); i++) {
auto &gt = ham.at(i);
if (gt.second[0].first.size() == 0) {
ham_sparse[i] = sparse::IdentitySparse(n) * gt.first.first * gt.second[0].second;
} else {
ham_sparse[i] = sparse::GoodTerm2Sparse(gt, n);
}
if ((++step) % 20 == 0) std::cout << "\r" << step << "\t/" << ham.size() << "\tfinshed" << std::flush;
}
std::cout << "\ncalculate hamiltonian phase1 finished\n";
return ham_sparse;
}
int Hamiltonian::TransHamiltonianPhaseTwo(sparse::DequeSparseHam &ham_sparse, int n_thread2, int n_split) {
int n = ham_sparse.size();
while (n > 1) {
int half = n / 2 + n % 2;
std::cout << "n: " << n << "\t, half: " << half << "\n";
if (n < n_split) {
break;
}
#pragma omp parallel for schedule(static) num_threads(half)
for (int i = half; i < n; i++) {
ham_sparse[i - half] += ham_sparse[i];
}
ham_sparse.erase(ham_sparse.end() - half + n % 2, ham_sparse.end());
n = half;
}
std::cout << "total: " << ham_sparse.size() << " phase2 finished\n";
return n;
}
void Hamiltonian::SparseHamiltonian(int n_thread1, int n_thread2, int n_split) {
ham_sparse_ = Hamiltonian::TransHamiltonianPhaseOne(n_thread1, ham_, n_qubits_);
final_size_ = Hamiltonian::TransHamiltonianPhaseTwo(ham_sparse_, n_thread2, n_split);
}
void Hamiltonian::SetTermsDict(Simulator::TermsDict const &d) {
td_ = d;
Simulator::ComplexTermsDict().swap(ctd_);
for (auto &term : td_) {
ComplexType coeff = {term.second, 0};
ctd_.push_back(std::make_pair(term.first, coeff));
}
}
void Hamiltonian::Sparsed(bool s) { ham_sparsed_ = s; }
const Simulator::ComplexTermsDict &Hamiltonian::GetCTD() const { return ctd_; }
const Simulator::TermsDict &Hamiltonian::GetTD() const { return td_; }
} // namespace mindquantum
} // namespace mindspore

50
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/hamiltonian.h
View File

@ -1,50 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_CHAMILTONIAN_H_
#define MINDQUANTUM_ENGINE_CHAMILTONIAN_H_
#include "projectq/backends/_sim/_cppkernels/simulator.hpp"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/basic_gates.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/sparse.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
class Hamiltonian {
private:
sparse::GoodHamilt ham_;
Index n_qubits_;
sparse::DequeSparseHam ham_sparse_;
Simulator::TermsDict td_;
Simulator::ComplexTermsDict ctd_;
int final_size_ = 1;
bool ham_sparsed_ = false;
public:
Hamiltonian();
Hamiltonian(const sparse::GoodHamilt &, Index);
sparse::DequeSparseHam TransHamiltonianPhaseOne(int, const sparse::GoodHamilt &, Index);
int TransHamiltonianPhaseTwo(sparse::DequeSparseHam &, int, int);
void SparseHamiltonian(int, int, int);
void SetTermsDict(Simulator::TermsDict const &);
void Sparsed(bool);
const Simulator::ComplexTermsDict &GetCTD() const;
const Simulator::TermsDict &GetTD() const;
~Hamiltonian() {}
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_CHAMILTONIAN_H_

33
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/parameter_resolver.cc
View File

@ -1,33 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/parameter_resolver.h"
namespace mindspore {
namespace mindquantum {
ParameterResolver::ParameterResolver() {}
ParameterResolver::ParameterResolver(const ParaType &data, const ParaSetType &no_grad_parameters,
const ParaSetType &requires_grad_parameters)
: data_(data), no_grad_parameters_(no_grad_parameters), requires_grad_parameters_(requires_grad_parameters) {}
const ParaType &ParameterResolver::GetData() const { return data_; }
const ParaSetType &ParameterResolver::GetRequiresGradParameters() const { return requires_grad_parameters_; }
void ParameterResolver::SetData(const std::string &name, const CalcType &value) { data_[name] = value; }
void ParameterResolver::InsertNoGrad(const std::string &name) { no_grad_parameters_.insert(name); }
void ParameterResolver::InsertRequiresGrad(const std::string &name) { requires_grad_parameters_.insert(name); }
} // namespace mindquantum
} // namespace mindspore

44
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/parameter_resolver.h
View File

@ -1,44 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_PARAMETER_RESOLVER_H_
#define MINDQUANTUM_ENGINE_PARAMETER_RESOLVER_H_
#include <map>
#include <string>
#include <set>
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
class ParameterResolver {
public:
ParameterResolver();
ParameterResolver(const ParaType &, const ParaSetType &, const ParaSetType &);
const ParaType &GetData() const;
const ParaSetType &GetRequiresGradParameters() const;
void SetData(const std::string &, const CalcType &);
void InsertNoGrad(const std::string &);
void InsertRequiresGrad(const std::string &);
~ParameterResolver() {}
private:
ParaType data_;
ParaSetType no_grad_parameters_;
ParaSetType requires_grad_parameters_;
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_PARAMETER_RESOLVER_H_

197
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/pqc_simulator.cc
View File

@ -1,197 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/pqc_simulator.h"
#include <omp.h>
#include <numeric>
namespace mindspore {
namespace mindquantum {
PQCSimulator::PQCSimulator() : Simulator(1, 1), n_qubits_(1) {
for (Index i = 0; i < n_qubits_; i++) {
ordering_.push_back(i);
}
len_ = (1UL << (n_qubits_ + 1));
}
PQCSimulator::PQCSimulator(Index seed = 1, Index N = 1) : Simulator(seed, N), n_qubits_(N) {
for (Index i = 0; i < n_qubits_; i++) {
ordering_.push_back(i);
}
len_ = (1UL << (n_qubits_ + 1));
}
void PQCSimulator::ApplyGate(std::shared_ptr<BasicGate> g, const ParameterResolver &paras, bool diff) {
if (g->IsParameterGate()) {
if (diff) {
PQCSimulator::apply_controlled_gate(g->GetDiffMatrix(paras), g->GetObjQubits(), g->GetCtrlQubits());
} else {
PQCSimulator::apply_controlled_gate(g->GetMatrix(paras), g->GetObjQubits(), g->GetCtrlQubits());
}
} else {
PQCSimulator::apply_controlled_gate(g->GetBaseMatrix(), g->GetObjQubits(), g->GetCtrlQubits());
}
}
void PQCSimulator::ApplyBlock(const GateBlock &b, const mindquantum::ParameterResolver &paras) {
for (auto &g : b) {
PQCSimulator::ApplyGate(g, paras, false);
}
PQCSimulator::run();
}
void PQCSimulator::ApplyBlocks(const GateBlocks &bs, const ParameterResolver &paras) {
for (auto &b : bs) {
PQCSimulator::ApplyBlock(b, paras);
}
}
void PQCSimulator::Evolution(BasicCircuit const &circuit, ParameterResolver const &paras) {
PQCSimulator::ApplyBlocks(circuit.GetGateBlocks(), paras);
}
CalcType PQCSimulator::Measure(const Indexes &masks, bool apply) {
CalcType out = 0;
#pragma omp parallel for reduction(+ : out) schedule(static)
for (unsigned i = 0; i < (1UL << n_qubits_); i++) {
if (((i & masks[0]) == masks[0]) && ((i | masks[1]) == masks[1])) {
out = out + vec_[2 * i] * vec_[2 * i] + vec_[2 * i + 1] * vec_[2 * i + 1];
} else if (apply) {
vec_[2 * i] = 0;
vec_[2 * i + 1] = 0;
}
}
return out;
}
std::vector<std::vector<float>> PQCSimulator::CalcGradient(const std::shared_ptr<CalcGradientParam> &input_params,
PQCSimulator &s_left, PQCSimulator &s_right,
PQCSimulator &s_right_tmp) {
// Suppose the simulator already evaluate the circuit.
auto circuit = input_params->circuit_cp;
auto circuit_hermitian = input_params->circuit_hermitian_cp;
auto hamiltonians = input_params->hamiltonians_cp;
auto projectors = input_params->projectors_cp;
auto is_projector = input_params->is_projector_cp;
auto paras = input_params->paras_cp;
auto encoder_params_names = input_params->encoder_params_names_cp;
auto ansatz_params_names = input_params->ansatz_params_names_cp;
auto dummy_circuit_ = input_params->dummy_circuit_cp;
auto &circ_gate_blocks = circuit->GetGateBlocks();
auto &circ_herm_gate_blocks = circuit_hermitian->GetGateBlocks();
std::map<std::string, size_t> poi;
for (size_t i = 0; i < encoder_params_names->size(); i++) {
poi[encoder_params_names->at(i)] = i;
}
for (size_t i = 0; i < ansatz_params_names->size(); i++) {
poi[ansatz_params_names->at(i)] = i + encoder_params_names->size();
}
if (circ_gate_blocks.size() == 0 || circ_herm_gate_blocks.size() == 0) {
MS_LOG(EXCEPTION) << "Empty quantum circuit!";
}
unsigned len = circ_gate_blocks.at(0).size();
size_t mea_size = 0;
if (is_projector) {
mea_size = projectors->size();
} else {
mea_size = hamiltonians->size();
}
std::vector<float> grad(mea_size * poi.size(), 0);
std::vector<float> e0(mea_size, 0);
// #pragma omp parallel for
for (size_t h_index = 0; h_index < mea_size; h_index++) {
s_right.set_wavefunction(vec_, ordering_);
s_left.set_wavefunction(s_right.vec_, ordering_);
if (is_projector) {
auto &proj = projectors->at(h_index);
e0[h_index] = s_left.Measure(proj.GetMasks(), true);
} else {
auto &hamiltonian = hamiltonians->at(h_index);
s_left.apply_qubit_operator(hamiltonian.GetCTD(), ordering_);
e0[h_index] = static_cast<float>(ComplexInnerProduct(vec_, s_left.vec_, len_).real());
}
if (dummy_circuit_) {
continue;
}
if (len > circ_herm_gate_blocks.at(0).size()) {
MS_LOG(EXCEPTION) << "hermitian circuit size error!";
}
for (unsigned i = 0; i < len; i++) {
if ((!circ_herm_gate_blocks.at(0)[i]->IsParameterGate()) ||
(circ_herm_gate_blocks.at(0)[i]->GetParameterResolver().GetRequiresGradParameters().size() == 0)) {
s_left.ApplyGate(circ_herm_gate_blocks.at(0)[i], *paras, false);
s_right.ApplyGate(circ_herm_gate_blocks.at(0)[i], *paras, false);
} else {
s_right.ApplyGate(circ_herm_gate_blocks.at(0)[i], *paras, false);
s_right.run();
s_right_tmp.set_wavefunction(s_right.vec_, ordering_);
s_right_tmp.ApplyGate(circ_gate_blocks.at(0)[len - 1 - i], *paras, true);
s_right_tmp.run();
s_left.run();
ComplexType gi = 0;
if (circ_herm_gate_blocks.at(0)[i]->GetCtrlQubits().size() == 0) {
gi = ComplexInnerProduct(s_left.vec_, s_right_tmp.vec_, len_);
} else {
gi = ComplexInnerProductWithControl(s_left.vec_, s_right_tmp.vec_, len_,
GetControlMask(circ_herm_gate_blocks.at(0)[i]->GetCtrlQubits()));
}
for (auto &it : circ_herm_gate_blocks.at(0)[i]->GetParameterResolver().GetRequiresGradParameters()) {
grad[h_index * poi.size() + poi[it]] -= static_cast<float>(
2 * circ_herm_gate_blocks.at(0)[i]->GetParameterResolver().GetData().at(it) * std::real(gi));
}
s_left.ApplyGate(circ_herm_gate_blocks.at(0)[i], *paras, false);
}
}
}
std::vector<float> grad1;
std::vector<float> grad2;
for (size_t i = 0; i < mea_size; i++) {
for (size_t j = 0; j < poi.size(); j++) {
if (j < encoder_params_names->size()) {
grad1.push_back(grad[i * poi.size() + j]);
} else {
grad2.push_back(grad[i * poi.size() + j]);
}
}
}
return {e0, grad1, grad2};
}
void PQCSimulator::SetState(const StateVector &wavefunction) { Simulator::set_wavefunction(wavefunction, ordering_); }
std::size_t PQCSimulator::GetControlMask(Indexes const &ctrls) {
std::size_t ctrlmask =
std::accumulate(ctrls.begin(), ctrls.end(), 0, [&](Index a, Index b) { return a | (1UL << ordering_[b]); });
return ctrlmask;
}
void PQCSimulator::ApplyHamiltonian(const Hamiltonian &ham) {
Simulator::apply_qubit_operator(ham.GetCTD(), ordering_);
}
CalcType PQCSimulator::GetExpectationValue(const Hamiltonian &ham) {
return Simulator::get_expectation_value(ham.GetTD(), ordering_);
}
void PQCSimulator::SetZeroState() {
#pragma omp parallel for schedule(static)
for (size_t i = 0; i < len_; i++) {
vec_[i] = 0;
}
vec_[0] = 1;
}
} // namespace mindquantum
} // namespace mindspore

70
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/pqc_simulator.h
View File

@ -1,70 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_PQC_SIMULATOR_H_
#define MINDQUANTUM_ENGINE_PQC_SIMULATOR_H_
#include <map>
#include <vector>
#include <string>
#include <memory>
#include "projectq/backends/_sim/_cppkernels/simulator.hpp"
#include "utils/log_adapter.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/basic_gates.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/parameter_resolver.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/circuit.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/hamiltonian.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/transformer.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/projector.h"
namespace mindspore {
namespace mindquantum {
struct CalcGradientParam {
BasicCircuit *circuit_cp;
BasicCircuit *circuit_hermitian_cp;
transformer::Hamiltonians *hamiltonians_cp;
transformer::Projectors *projectors_cp;
ParameterResolver *paras_cp;
transformer::NamesType *encoder_params_names_cp;
transformer::NamesType *ansatz_params_names_cp;
bool dummy_circuit_cp{false};
bool is_projector_cp{false};
};
class PQCSimulator : public Simulator {
private:
Index n_qubits_;
Indexes ordering_;
Index len_;
public:
PQCSimulator();
PQCSimulator(Index seed, Index N);
void ApplyGate(std::shared_ptr<BasicGate>, const ParameterResolver &, bool);
void ApplyBlock(const GateBlock &, const ParameterResolver &);
void ApplyBlocks(const GateBlocks &, const ParameterResolver &);
void Evolution(const BasicCircuit &, const ParameterResolver &);
CalcType Measure(const Indexes &, bool);
void ApplyHamiltonian(const Hamiltonian &);
CalcType GetExpectationValue(const Hamiltonian &);
std::vector<std::vector<float>> CalcGradient(const std::shared_ptr<CalcGradientParam> &, PQCSimulator &,
PQCSimulator &, PQCSimulator &);
void SetState(const StateVector &);
std::size_t GetControlMask(Indexes const &);
void SetZeroState();
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_PQC_SIMULATOR_H_

41
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/projector.cc
View File

@ -1,41 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/projector.h"
namespace mindspore {
namespace mindquantum {
Projector::Projector() {}
Projector::Projector(const NameType &proj_str) : proj_str_(proj_str), n_qubits_(proj_str.length()) {}
void Projector::HandleMask() {
mask1_ = 0;
mask2_ = 0;
for (auto i : proj_str_) {
if (i == '1') {
mask1_ = mask1_ * 2 + 1;
} else {
mask1_ = mask1_ * 2;
}
if (i == '0') {
mask2_ = mask2_ * 2;
} else {
mask2_ = mask2_ * 2 + 1;
}
}
}
Indexes Projector::GetMasks() { return {mask1_, mask2_}; }
} // namespace mindquantum
} // namespace mindspore

41
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/projector.h
View File

@ -1,41 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_PROJECTOR_H_
#define MINDQUANTUM_ENGINE_PROJECTOR_H_
#include <string>
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
using NameType = std::string;
class Projector {
public:
Projector();
explicit Projector(const NameType &);
void HandleMask();
Indexes GetMasks();
~Projector() {}
private:
NameType proj_str_;
Index n_qubits_;
Index mask1_;
Index mask2_;
};
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_PROJECTOR_H_

123
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/sparse.cc
View File

@ -1,123 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/sparse.h"
namespace mindspore {
namespace mindquantum {
namespace sparse {
SparseMatrix BasiGateSparse(char g) {
SparseMatrix out(2, 2);
out.reserve(VectorXi::Constant(2, 2));
switch (g) {
case 'X':
case 'x':
out.insert(0, 1) = 1;
out.insert(1, 0) = 1;
break;
case 'Y':
case 'y':
out.insert(0, 1) = {0, -1};
out.insert(1, 0) = {0, 1};
break;
case 'Z':
case 'z':
out.insert(0, 0) = 1;
out.insert(1, 1) = -1;
break;
case '0':
out.insert(0, 0) = 1;
break;
case '1':
out.insert(1, 1) = 1;
break;
default:
out.insert(0, 0) = 1;
out.insert(1, 1) = 1;
break;
}
out.makeCompressed();
return out;
}
SparseMatrix IdentitySparse(int n_qubit) {
if (n_qubit == 0) {
int dim = static_cast<int>(1UL << n_qubit);
SparseMatrix out(dim, dim);
out.reserve(VectorXi::Constant(dim, dim));
for (int i = 0; i < dim; i++) {
out.insert(i, i) = 1;
}
out.makeCompressed();
return out;
} else {
SparseMatrix out = BasiGateSparse('I');
for (int i = 1; i < n_qubit; i++) {
out = KroneckerProductSparse(out, BasiGateSparse('I')).eval();
}
return out;
}
}
SparseMatrix PauliTerm2Sparse(const PauliTerm &pt, Index _min, Index _max) {
int poi;
int n = pt.first.size();
SparseMatrix out;
if (pt.first[0].first == _min) {
out = BasiGateSparse(pt.first[0].second) * pt.second;
poi = 1;
} else {
out = BasiGateSparse('I') * pt.second;
poi = 0;
}
for (Index i = _min + 1; i <= _max; i++) {
if (poi == n) {
out = KroneckerProductSparse(IdentitySparse(_max - i + 1), out).eval();
break;
} else {
if (i == pt.first[poi].first) {
out = KroneckerProductSparse(BasiGateSparse(pt.first[poi++].second), out).eval();
} else {
out = KroneckerProductSparse(BasiGateSparse('I'), out).eval();
}
}
}
return out;
}
SparseMatrix GoodTerm2Sparse(const GoodTerm &gt, Index n_qubits) {
SparseMatrix out = PauliTerm2Sparse(gt.second[0], gt.first.second.first, gt.first.second.second);
for (Index i = 1; i < gt.second.size(); i++) {
out += PauliTerm2Sparse(gt.second[i], gt.first.second.first, gt.first.second.second);
}
out.prune({0.0, 0.0});
out *= gt.first.first;
out = KroneckerProductSparse(out, IdentitySparse(gt.first.second.first)).eval();
out = KroneckerProductSparse(IdentitySparse(n_qubits - gt.first.second.second - 1), out).eval();
return out;
}
} // namespace sparse
} // namespace mindquantum
} // namespace mindspore

48
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/sparse.h
View File

@ -1,48 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_SPARSE_H_
#define MINDQUANTUM_ENGINE_SPARSE_H_
#include <Eigen/Dense>
#include <Eigen/Sparse>
#include <unsupported/Eigen/KroneckerProduct>
#include <deque>
#include <complex>
#include <utility>
#include <iostream>
#include <vector>
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
namespace sparse {
using PauliWord = std::pair<Index, char>;
using PauliTerm = std::pair<std::vector<PauliWord>, int>;
using GoodTerm = std::pair<std::pair<CalcType, std::pair<Index, Index>>, std::vector<PauliTerm>>;
using GoodHamilt = std::vector<GoodTerm>;
using EigenComplexVector = Eigen::VectorXcd;
using Eigen::VectorXi;
using SparseMatrix = Eigen::SparseMatrix<ComplexType, Eigen::RowMajor, int64_t>;
using DequeSparseHam = std::deque<SparseMatrix>;
using KroneckerProductSparse = Eigen::KroneckerProductSparse<SparseMatrix, SparseMatrix>;
SparseMatrix BasiGateSparse(char);
SparseMatrix IdentitySparse(int);
SparseMatrix PauliTerm2Sparse(const PauliTerm &, Index, Index);
SparseMatrix GoodTerm2Sparse(const GoodTerm &, Index);
} // namespace sparse
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_SPARSE_H_

124
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/transformer.cc
View File

@ -1,124 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/transformer.h"
#include <algorithm>
#include <utility>
namespace mindspore {
namespace mindquantum {
namespace transformer {
Matrix MatrixConverter(const MatrixType &matrix_real, const MatrixType &matrix_imag, bool hermitian) {
Matrix out;
for (Index i = 0; i < matrix_real.size(); i++) {
out.push_back({});
for (Index j = 0; j < matrix_real.size(); j++) {
if (hermitian)
out.back().push_back({stod(matrix_real[j][i]), -stod(matrix_imag[j][i])});
else
out.back().push_back({stod(matrix_real[i][j]), stod(matrix_imag[i][j])});
}
}
return out;
}
ParameterResolver ParameterResolverConverter(const ParaNameType &para_name, const CoeffType &coeff,
const RequireType &require_grad, bool hermitian) {
ParameterResolver pr;
for (Index i = 0; i < para_name.size(); i++) {
auto name = para_name[i];
if (hermitian)
pr.SetData(name, -coeff[i]);
else
pr.SetData(name, coeff[i]);
if (require_grad[i])
pr.InsertRequiresGrad(name);
else
pr.InsertNoGrad(name);
}
return pr;
}
std::vector<BasicCircuit> CircuitTransfor(const NamesType &names, const ComplexMatrixsType &matrixs,
const Indexess &objs_qubits, const Indexess &ctrls_qubits,
const ParasNameType &paras_name, const CoeffsType &coeffs,
const RequiresType &requires_grad) {
BasicCircuit circuit = BasicCircuit();
BasicCircuit herm_circuit = BasicCircuit();
circuit.AppendBlock();
herm_circuit.AppendBlock();
for (Index n = 0; n < names.size(); n++) {
Indexes obj(objs_qubits[n].size());
Indexes ctrl(ctrls_qubits[n].size());
std::transform(objs_qubits[n].begin(), objs_qubits[n].end(), obj.begin(),
[](const int64_t &i) { return (Index)(i); });
std::transform(ctrls_qubits[n].begin(), ctrls_qubits[n].end(), ctrl.begin(),
[](const int64_t &i) { return (Index)(i); });
if (names[n] == "npg")
// non parameterize gate
circuit.AppendNoneParameterGate("npg", MatrixConverter(matrixs[n][0], matrixs[n][1], false), obj, ctrl);
else
circuit.AppendParameterGate(names[n], obj, ctrl,
ParameterResolverConverter(paras_name[n], coeffs[n], requires_grad[n], false));
}
for (Index n = 0; n < names.size(); n++) {
Index tail = names.size() - 1 - n;
Indexes obj(objs_qubits[tail].size());
Indexes ctrl(ctrls_qubits[tail].size());
std::transform(objs_qubits[tail].begin(), objs_qubits[tail].end(), obj.begin(),
[](const int64_t &i) { return (Index)(i); });
std::transform(ctrls_qubits[tail].begin(), ctrls_qubits[tail].end(), ctrl.begin(),
[](const int64_t &i) { return (Index)(i); });
if (names[tail] == "npg")
// non parameterize gate
herm_circuit.AppendNoneParameterGate("npg", MatrixConverter(matrixs[tail][0], matrixs[tail][1], true), obj, ctrl);
else
herm_circuit.AppendParameterGate(
names[tail], obj, ctrl, ParameterResolverConverter(paras_name[tail], coeffs[tail], requires_grad[tail], true));
}
return {circuit, herm_circuit};
}
Hamiltonians HamiltoniansTransfor(const PaulisCoeffsType &paulis_coeffs, const PaulisWordsType &paulis_words,
const PaulisQubitsType &paulis_qubits) {
Hamiltonians hams;
for (Index n = 0; n < paulis_coeffs.size(); n++) {
Hamiltonian ham;
Simulator::TermsDict td;
for (Index i = 0; i < paulis_coeffs[n].size(); i++) {
Simulator::Term term;
for (Index j = 0; j < paulis_words[n][i].size(); j++)
term.push_back(std::make_pair((Index)(paulis_qubits[n][i][j]), paulis_words[n][i][j].at(0)));
td.push_back(std::make_pair(term, paulis_coeffs[n][i]));
}
ham.SetTermsDict(td);
hams.push_back(ham);
}
return hams;
}
Projectors ProjectorsTransfor(const NamesType &proj_strs) {
Projectors projs;
for (Index n = 0; n < proj_strs.size(); n++) {
Projector proj = Projector(proj_strs[n]);
proj.HandleMask();
projs.push_back(proj);
}
return projs;
}
} // namespace transformer
} // namespace mindquantum
} // namespace mindspore

68
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/transformer.h
View File

@ -1,68 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_TRANSFORMER_H_
#define MINDQUANTUM_ENGINE_TRANSFORMER_H_
#include <vector>
#include <string>
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/gates/gates.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/circuit.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/parameter_resolver.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/hamiltonian.h"
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/projector.h"
namespace mindspore {
namespace mindquantum {
namespace transformer {
using NameType = std::string;
using MatrixColumnType = std::vector<std::string>;
using MatrixType = std::vector<MatrixColumnType>;
using ComplexMatrixType = std::vector<MatrixType>;
using ParaNameType = std::vector<std::string>;
using CoeffType = std::vector<float>;
using RequireType = std::vector<bool>;
using NamesType = std::vector<NameType>;
using ComplexMatrixsType = std::vector<ComplexMatrixType>;
using ParasNameType = std::vector<ParaNameType>;
using CoeffsType = std::vector<CoeffType>;
using RequiresType = std::vector<RequireType>;
using Indexess = std::vector<std::vector<int64_t>>;
using PauliCoeffsType = std::vector<float>;
using PaulisCoeffsType = std::vector<PauliCoeffsType>;
using PauliWordType = std::vector<std::string>;
using PauliWordsType = std::vector<PauliWordType>;
using PaulisWordsType = std::vector<PauliWordsType>;
using PauliQubitType = std::vector<int64_t>;
using PauliQubitsType = std::vector<PauliQubitType>;
using PaulisQubitsType = std::vector<PauliQubitsType>;
using Hamiltonians = std::vector<Hamiltonian>;
using Projectors = std::vector<Projector>;
Hamiltonians HamiltoniansTransfor(const PaulisCoeffsType &, const PaulisWordsType &, const PaulisQubitsType &);
std::vector<BasicCircuit> CircuitTransfor(const NamesType &, const ComplexMatrixsType &, const Indexess &,
const Indexess &, const ParasNameType &, const CoeffsType &,
const RequiresType &);
Matrix MatrixConverter(const MatrixType &, const MatrixType &, bool);
ParameterResolver ParameterResolverConverter(const ParaNameType &, const CoeffType &, const RequireType &, bool);
Projectors ProjectorsTransfor(const NamesType &);
} // namespace transformer
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_TRANSFORMER_H_

51
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.cc
View File

@ -1,51 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#include "backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h"
namespace mindspore {
namespace mindquantum {
ComplexType ComplexInnerProduct(const Simulator::StateVector &v1, const Simulator::StateVector &v2, unsigned len) {
CalcType real_part = 0;
CalcType imag_part = 0;
auto size = len / 2;
#pragma omp parallel for reduction(+ : real_part, imag_part)
for (Index i = 0; i < size; i++) {
real_part += v1[2 * i] * v2[2 * i] + v1[2 * i + 1] * v2[2 * i + 1];
imag_part += v1[2 * i] * v2[2 * i + 1] - v1[2 * i + 1] * v2[2 * i];
}
ComplexType result = {real_part, imag_part};
return result;
}
ComplexType ComplexInnerProductWithControl(const Simulator::StateVector &v1, const Simulator::StateVector &v2,
Index len, std::size_t ctrlmask) {
CalcType real_part = 0;
CalcType imag_part = 0;
auto size = len / 2;
#pragma omp parallel for reduction(+ : real_part, imag_part)
for (std::size_t i = 0; i < size; i++) {
if ((i & ctrlmask) == ctrlmask) {
real_part += v1[2 * i] * v2[2 * i] + v1[2 * i + 1] * v2[2 * i + 1];
imag_part += v1[2 * i] * v2[2 * i + 1] - v1[2 * i + 1] * v2[2 * i];
}
}
ComplexType result = {real_part, imag_part};
return result;
}
} // namespace mindquantum
} // namespace mindspore

59
mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/quantum_simulator/utils.h
View File

@ -1,59 +0,0 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* 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.
*/
#ifndef MINDQUANTUM_ENGINE_UTILS_H_
#define MINDQUANTUM_ENGINE_UTILS_H_
#include <string>
#include <complex>
#include <vector>
#include <map>
#include <set>
#include "projectq/backends/_sim/_cppkernels/intrin/alignedallocator.hpp"
#include "projectq/backends/_sim/_cppkernels/simulator.hpp"
namespace mindspore {
namespace mindquantum {
using CalcType = double;
using ComplexType = std::complex<CalcType>;
using ParaType = std::map<std::string, CalcType>;
using ParaSetType = std::set<std::string>;
using Matrix = std::vector<std::vector<ComplexType, aligned_allocator<ComplexType, 64>>>;
using Index = unsigned;
using Indexes = std::vector<Index>;
using ParaMapType = std::map<std::string, CalcType>;
ComplexType ComplexInnerProduct(const Simulator::StateVector &, const Simulator::StateVector &, Index);
ComplexType ComplexInnerProductWithControl(const Simulator::StateVector &, const Simulator::StateVector &, Index,
std::size_t);
const char kNThreads[] = "n_threads";
const char kNQubits[] = "n_qubits";
const char kParamNames[] = "param_names";
const char kEncoderParamsNames[] = "encoder_params_names";
const char kAnsatzParamsNames[] = "ansatz_params_names";
const char kGateNames[] = "gate_names";
const char kGateMatrix[] = "gate_matrix";
const char kGateObjQubits[] = "gate_obj_qubits";
const char kGateCtrlQubits[] = "gate_ctrl_qubits";
const char kGateParamsNames[] = "gate_params_names";
const char kGateCoeff[] = "gate_coeff";
const char kGateRequiresGrad[] = "gate_requires_grad";
const char kHamsPauliCoeff[] = "hams_pauli_coeff";
const char kHamsPauliWord[] = "hams_pauli_word";
const char kHamsPauliQubit[] = "hams_pauli_qubit";
const char kIsProjector[] = "is_projector";
const char kProjectors[] = "projectors";
} // namespace mindquantum
} // namespace mindspore
#endif // MINDQUANTUM_ENGINE_UTILS_H_

1
mindspore/core/gvar/log_adapter_common.cc
View File

@ -49,7 +49,6 @@ static const std::vector<std::string> sub_module_names = {
"LITE", // SM_LITE
"ARMOUR", // SM_ARMOUR
"HCCL_ADPT", // SM_HCCL_ADPT
"MINDQUANTUM", // SM_MINDQUANTUM
"RUNTIME_FRAMEWORK", // SM_RUNTIME_FRAMEWORK
"GE", // SM_GE
};

1
mindspore/core/utils/log_adapter.h
View File

@ -138,7 +138,6 @@ enum SubModuleId : int {
SM_LITE, // LITE
SM_ARMOUR, // ARMOUR
SM_HCCL_ADPT, // Hccl Adapter
SM_MINDQUANTUM, // MindQuantum
SM_RUNTIME_FRAMEWORK, // Runtime framework
SM_GE, // GraphEngine
NUM_SUBMODUES // number of submodules

19
mindspore/ops/_grad/grad_other_ops.py
View File

@ -16,7 +16,6 @@
"""Generate bprop for other ops"""
from .. import operations as P
from .. import composite as C
from ..operations import _grad_ops as G
from ..operations import _inner_ops as inner
from ..composite.multitype_ops.zeros_like_impl import zeros_like
@ -52,24 +51,6 @@ def get_bprop_iou(self):
return bprop
@bprop_getters.register(P.PQC)
def bprop_pqc(self):
"""Generate bprop for PQC"""
t = P.Transpose()
mul = P.Mul()
sum_ = P.ReduceSum()
def bprop(encoder_data, ansatz_data, out, dout):
dx = t(out[1], (2, 0, 1))
dx = mul(dout[0], dx)
dx = sum_(dx, 2)
dx = t(dx, (1, 0))
dy = C.tensor_dot(dout[0], out[2], ((0, 1), (0, 1)))
return dx, dy
return bprop
@bprop_getters.register(inner.SyncBatchNorm)
def get_bprop_sync_batch_norm(self):
"""Grad definition for `SyncBatchNorm` operation."""

26
mindspore/ops/bprop_mindir/ApproximateEqual_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.32:xbprop.32:[CNode]33:1bprop.32:[CNode]33:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op22
‹
bprop.12:xbprop.12:[CNode]:1bprop.12:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op22
‡
bprop.32:ybprop.32:[CNode]34:2bprop.32:[CNode]34:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op23
‰
bprop.32:[CNode]33:1
bprop.32:[CNode]34:2bprop.32:[CNode]35:3bprop.32:[CNode]35:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op24bprop.32*
bprop.12:ybprop.12:[CNode]:2bprop.12:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op23
<EFBFBD>
bprop.12:[CNode]:1
bprop.12:[CNode]:2bprop.12:[CNode]:3bprop.12:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op24bprop.12*
bprop.32:x*
bprop.12:x*
bprop.32:y*
bprop.32:out*
bprop.32:dout2
bprop.32:[CNode]35:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.12:y*
bprop.12:out*
bprop.12:dout2
bprop.12:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

20
mindspore/ops/bprop_mindir/Argmax_bprop.mindir
View File

@ -1,12 +1,10 @@
0.1.0 MindSpore*1.5.0:•
Š
bprop.13:xbprop.13:[CNode]14:1bprop.13:[CNode]14:1"!S-Prim-hyper_map[zeros_like_leaf]:-Default/S-Prim-hyper_map[zeros_like_leaf]-op9
s
bprop.13:[CNode]14:1bprop.13:[CNode]15:2bprop.13:[CNode]15:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op10bprop.13*
bprop.13:x*
bprop.13:out*
bprop.13:dout2
bprop.13:[CNode]15:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad
0.1.0 MindSpore*1.5.0.20211027:þ
ƒ
bprop.6:xbprop.6:[CNode]:1bprop.6:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:-Default/S-Prim-hyper_map[zeros_like_leaf]-op9
j
bprop.6:[CNode]:1bprop.6:[CNode]:2bprop.6:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op10bprop.6*
bprop.6:x*
bprop.6:out*
bprop.6:dout2
bprop.6:[CNode]:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad

20
mindspore/ops/bprop_mindir/Argmin_bprop.mindir
View File

@ -1,12 +1,10 @@
0.1.0 MindSpore*1.5.0:–
‹
bprop.16:xbprop.16:[CNode]17:1bprop.16:[CNode]17:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op11
s
bprop.16:[CNode]17:1bprop.16:[CNode]18:2bprop.16:[CNode]18:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op12bprop.16*
bprop.16:x*
bprop.16:out*
bprop.16:dout2
bprop.16:[CNode]18:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad
0.1.0 MindSpore*1.5.0.20211027:ÿ
„
bprop.7:xbprop.7:[CNode]:1bprop.7:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op11
j
bprop.7:[CNode]:1bprop.7:[CNode]:2bprop.7:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op12bprop.7*
bprop.7:x*
bprop.7:out*
bprop.7:dout2
bprop.7:[CNode]:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad

30
mindspore/ops/bprop_mindir/AssignAdd_bprop.mindir
View File

@ -1,18 +1,14 @@
0.1.0 MindSpore*1.5.0:É
‹
bprop.21:xbprop.21:[CNode]22:1bprop.21:[CNode]22:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op14
‹
bprop.21:ybprop.21:[CNode]23:2bprop.21:[CNode]23:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op15
‰
bprop.21:[CNode]22:1
bprop.21:[CNode]23:2bprop.21:[CNode]24:3bprop.21:[CNode]24:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op16bprop.21*
bprop.21:x*
bprop.21:y*
bprop.21:out*
bprop.21:dout2
bprop.21:[CNode]24:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
0.1.0 MindSpore*1.5.0.20211027:¦
„
bprop.9:xbprop.9:[CNode]:1bprop.9:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op14
„
bprop.9:ybprop.9:[CNode]:2bprop.9:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op15
}
bprop.9:[CNode]:1
bprop.9:[CNode]:2bprop.9:[CNode]:3bprop.9:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op16bprop.9*
bprop.9:x*
bprop.9:y*
bprop.9:out*
bprop.9:dout2
bprop.9:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

26
mindspore/ops/bprop_mindir/AssignSub_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.25:xbprop.25:[CNode]26:1bprop.25:[CNode]26:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op17
‹
bprop.10:xbprop.10:[CNode]:1bprop.10:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op17
‡
bprop.25:ybprop.25:[CNode]27:2bprop.25:[CNode]27:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op18
‰
bprop.25:[CNode]26:1
bprop.25:[CNode]27:2bprop.25:[CNode]28:3bprop.25:[CNode]28:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op19bprop.25*
bprop.10:ybprop.10:[CNode]:2bprop.10:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op18
<EFBFBD>
bprop.10:[CNode]:1
bprop.10:[CNode]:2bprop.10:[CNode]:3bprop.10:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op19bprop.10*
bprop.25:x*
bprop.10:x*
bprop.25:y*
bprop.25:out*
bprop.25:dout2
bprop.25:[CNode]28:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.10:y*
bprop.10:out*
bprop.10:dout2
bprop.10:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

22
mindspore/ops/bprop_mindir/Assign_bprop.mindir
View File

@ -1,15 +1,15 @@
0.1.0 MindSpore*1.5.0:´
‹
0.1.0 MindSpore*1.5.0.20211027:§
‡
bprop.60:ybprop.60:[CNode]61:1bprop.60:[CNode]61:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op43
‚
bprop.60:dout
bprop.60:[CNode]61:1bprop.60:[CNode]62:2bprop.60:[CNode]62:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op44bprop.60*
bprop.19:ybprop.19:[CNode]:1bprop.19:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op43
|
bprop.19:dout
bprop.19:[CNode]:1bprop.19:[CNode]:2bprop.19:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op44bprop.19*
bprop.60:x*
bprop.19:x*
bprop.60:y*
bprop.60:out*
bprop.60:dout2
bprop.60:[CNode]62:2:@ab258748286fc6d783abacce203dfc79d2fc31e23a427ce1f86e08777a687f71
bprop.19:y*
bprop.19:out*
bprop.19:dout2
bprop.19:[CNode]:2:@d600ac5742fbd8dc8b4b041517ce58e1beec6270a8d533616d7cfd5b4b178b15

18
mindspore/ops/bprop_mindir/BNTrainingReduce_bprop.mindir
View File

@ -1,12 +1,12 @@
0.1.0 MindSpore*1.5.0:–
‹
0.1.0 MindSpore*1.5.0.20211027:Š
‡
bprop.67:xbprop.67:[CNode]68:1bprop.67:[CNode]68:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op48
s
bprop.67:[CNode]68:1bprop.67:[CNode]69:2bprop.67:[CNode]69:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op49bprop.67*
bprop.21:xbprop.21:[CNode]:1bprop.21:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op48
m
bprop.21:[CNode]:1bprop.21:[CNode]:2bprop.21:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op49bprop.21*
bprop.67:x*
bprop.67:out*
bprop.67:dout2
bprop.67:[CNode]69:2:@565f906930f68ca2413e9ad958d105e129e717cd183b95d11d65a8b0b030fc0d
bprop.21:x*
bprop.21:out*
bprop.21:dout2
bprop.21:[CNode]:2:@565f906930f68ca2413e9ad958d105e129e717cd183b95d11d65a8b0b030fc0d

15
mindspore/ops/bprop_mindir/Broadcast_bprop.mindir
View File

@ -1,9 +1,8 @@
0.1.0 MindSpore*1.5.0:<3A>
l
bprop.19:doutbprop.19:[CNode]20:1bprop.19:[CNode]20:1"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op13bprop.19*
bprop.19:x*
bprop.19:out*
bprop.19:dout2
bprop.19:[CNode]20:1:@13f1e8534ff98b1256889fc50eb483e05dc629e575bb06330ae1f2238e2372e8
0.1.0 MindSpore*1.5.0.20211027:ó
e
bprop.8:doutbprop.8:[CNode]:1bprop.8:[CNode]:1"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op13bprop.8*
bprop.8:x*
bprop.8:out*
bprop.8:dout2
bprop.8:[CNode]:1:@13f1e8534ff98b1256889fc50eb483e05dc629e575bb06330ae1f2238e2372e8

40
mindspore/ops/bprop_mindir/DropoutDoMask_bprop.mindir
View File

@ -1,20 +1,24 @@
0.1.0 MindSpore*1.5.0:·
›
bprop.110:dout
bprop.110:y
bprop.110:keep_probbprop.110:[CNode]111:1bprop.110:[CNode]111:1"S-Prim-DropoutDoMask:!Default/S-Prim-DropoutDoMask-op80
0.1.0 MindSpore*1.5.0.20211027:ü
<EFBFBD>
bprop.110:ybprop.110:[CNode]112:2bprop.110:[CNode]112:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op81
˜
bprop.110:keep_probbprop.110:[CNode]113:3bprop.110:[CNode]113:3"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op82
©
bprop.110:[CNode]111:1
bprop.110:[CNode]112:2
bprop.110:[CNode]113:3bprop.110:[CNode]114:4bprop.110:[CNode]114:4"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op83 bprop.110*
bprop.110:x*
bprop.110:y*
bprop.110:keep_prob*
bprop.110:out*
bprop.110:dout2
bprop.110:[CNode]114:4:@5f6486474eab638624ee1777f9652b2edd3f5f2873c570e2992de1d8b0e87873
bprop.32:dout
bprop.32:y
bprop.32:keep_probbprop.32:[CNode]:1bprop.32:[CNode]:1"S-Prim-DropoutDoMask:!Default/S-Prim-DropoutDoMask-op80
‡
bprop.32:ybprop.32:[CNode]:2bprop.32:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op81
<EFBFBD>
bprop.32:keep_probbprop.32:[CNode]:3bprop.32:[CNode]:3"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op82
•
bprop.32:[CNode]:1
bprop.32:[CNode]:2
bprop.32:[CNode]:3bprop.32:[CNode]:4bprop.32:[CNode]:4"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op83bprop.32*
bprop.32:x*
bprop.32:y*
bprop.32:keep_prob*
bprop.32:out*
bprop.32:dout2
bprop.32:[CNode]:4:@5f6486474eab638624ee1777f9652b2edd3f5f2873c570e2992de1d8b0e87873

24
mindspore/ops/bprop_mindir/DropoutGenMask_bprop.mindir
View File

@ -1,14 +1,14 @@
0.1.0 MindSpore*1.5.0:á
0.1.0 MindSpore*1.5.0.20211027:Ï
‹
bprop.17:shapebprop.17:[CNode]:1bprop.17:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op35
<EFBFBD>
bprop.50:shapebprop.50:[CNode]51:1bprop.50:[CNode]51:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op35
“
bprop.50:keep_probbprop.50:[CNode]52:2bprop.50:[CNode]52:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op36
‰
bprop.50:[CNode]51:1
bprop.50:[CNode]52:2bprop.50:[CNode]53:3bprop.50:[CNode]53:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op37bprop.50*
bprop.50:shape*
bprop.50:keep_prob*
bprop.50:out*
bprop.50:dout2
bprop.50:[CNode]53:3:@5f6486474eab638624ee1777f9652b2edd3f5f2873c570e2992de1d8b0e87873
bprop.17:keep_probbprop.17:[CNode]:2bprop.17:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op36
<EFBFBD>
bprop.17:[CNode]:1
bprop.17:[CNode]:2bprop.17:[CNode]:3bprop.17:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op37bprop.17*
bprop.17:shape*
bprop.17:keep_prob*
bprop.17:out*
bprop.17:dout2
bprop.17:[CNode]:3:@5f6486474eab638624ee1777f9652b2edd3f5f2873c570e2992de1d8b0e87873

26
mindspore/ops/bprop_mindir/Equal_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.70:xbprop.70:[CNode]71:1bprop.70:[CNode]71:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op50
‹
bprop.22:xbprop.22:[CNode]:1bprop.22:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op50
‡
bprop.70:ybprop.70:[CNode]72:2bprop.70:[CNode]72:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op51
‰
bprop.70:[CNode]71:1
bprop.70:[CNode]72:2bprop.70:[CNode]73:3bprop.70:[CNode]73:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op52bprop.70*
bprop.22:ybprop.22:[CNode]:2bprop.22:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op51
<EFBFBD>
bprop.22:[CNode]:1
bprop.22:[CNode]:2bprop.22:[CNode]:3bprop.22:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op52bprop.22*
bprop.70:x*
bprop.22:x*
bprop.70:y*
bprop.70:out*
bprop.70:dout2
bprop.70:[CNode]73:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.22:y*
bprop.22:out*
bprop.22:dout2
bprop.22:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

26
mindspore/ops/bprop_mindir/GreaterEqual_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.82:xbprop.82:[CNode]83:1bprop.82:[CNode]83:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op59
‹
bprop.25:xbprop.25:[CNode]:1bprop.25:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op59
‡
bprop.82:ybprop.82:[CNode]84:2bprop.82:[CNode]84:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op60
‰
bprop.82:[CNode]83:1
bprop.82:[CNode]84:2bprop.82:[CNode]85:3bprop.82:[CNode]85:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op61bprop.82*
bprop.25:ybprop.25:[CNode]:2bprop.25:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op60
<EFBFBD>
bprop.25:[CNode]:1
bprop.25:[CNode]:2bprop.25:[CNode]:3bprop.25:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op61bprop.25*
bprop.82:x*
bprop.25:x*
bprop.82:y*
bprop.82:out*
bprop.82:dout2
bprop.82:[CNode]85:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.25:y*
bprop.25:out*
bprop.25:dout2
bprop.25:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

26
mindspore/ops/bprop_mindir/Greater_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.78:xbprop.78:[CNode]79:1bprop.78:[CNode]79:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op56
‹
bprop.24:xbprop.24:[CNode]:1bprop.24:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op56
‡
bprop.78:ybprop.78:[CNode]80:2bprop.78:[CNode]80:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op57
‰
bprop.78:[CNode]79:1
bprop.78:[CNode]80:2bprop.78:[CNode]81:3bprop.78:[CNode]81:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op58bprop.78*
bprop.24:ybprop.24:[CNode]:2bprop.24:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op57
<EFBFBD>
bprop.24:[CNode]:1
bprop.24:[CNode]:2bprop.24:[CNode]:3bprop.24:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op58bprop.24*
bprop.78:x*
bprop.24:x*
bprop.78:y*
bprop.78:out*
bprop.78:dout2
bprop.78:[CNode]81:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.24:y*
bprop.24:out*
bprop.24:dout2
bprop.24:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

26
mindspore/ops/bprop_mindir/IOU_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.63:xbprop.63:[CNode]64:1bprop.63:[CNode]64:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op45
‹
bprop.20:xbprop.20:[CNode]:1bprop.20:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op45
‡
bprop.63:ybprop.63:[CNode]65:2bprop.63:[CNode]65:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op46
‰
bprop.63:[CNode]64:1
bprop.63:[CNode]65:2bprop.63:[CNode]66:3bprop.63:[CNode]66:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op47bprop.63*
bprop.20:ybprop.20:[CNode]:2bprop.20:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op46
<EFBFBD>
bprop.20:[CNode]:1
bprop.20:[CNode]:2bprop.20:[CNode]:3bprop.20:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op47bprop.20*
bprop.63:x*
bprop.20:x*
bprop.63:y*
bprop.63:out*
bprop.63:dout2
bprop.63:[CNode]66:3:@ab258748286fc6d783abacce203dfc79d2fc31e23a427ce1f86e08777a687f71
bprop.20:y*
bprop.20:out*
bprop.20:dout2
bprop.20:[CNode]:3:@d600ac5742fbd8dc8b4b041517ce58e1beec6270a8d533616d7cfd5b4b178b15

10
mindspore/ops/bprop_mindir/Identity_bprop.mindir
View File

@ -1,8 +1,8 @@
0.1.0 MindSpore*1.5.0:õ
f
bprop.2:doutbprop.2:[CNode]3:1bprop.2:[CNode]3:1"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op2bprop.2*
0.1.0 MindSpore*1.5.0.20211027:ò
d
bprop.2:doutbprop.2:[CNode]:1bprop.2:[CNode]:1"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op2bprop.2*
bprop.2:x*
bprop.2:out*
bprop.2:dout2
bprop.2:[CNode]3:1:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad
bprop.2:dout2
bprop.2:[CNode]:1:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad

18
mindspore/ops/bprop_mindir/IsFinite_bprop.mindir
View File

@ -1,12 +1,12 @@
0.1.0 MindSpore*1.5.0:–
‹
0.1.0 MindSpore*1.5.0.20211027:Š
‡
bprop.29:xbprop.29:[CNode]30:1bprop.29:[CNode]30:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op20
s
bprop.29:[CNode]30:1bprop.29:[CNode]31:2bprop.29:[CNode]31:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op21bprop.29*
bprop.11:xbprop.11:[CNode]:1bprop.11:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op20
m
bprop.11:[CNode]:1bprop.11:[CNode]:2bprop.11:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op21bprop.11*
bprop.29:x*
bprop.29:out*
bprop.29:dout2
bprop.29:[CNode]31:2:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.11:x*
bprop.11:out*
bprop.11:dout2
bprop.11:[CNode]:2:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

26
mindspore/ops/bprop_mindir/LessEqual_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.90:xbprop.90:[CNode]91:1bprop.90:[CNode]91:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op65
‹
bprop.27:xbprop.27:[CNode]:1bprop.27:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op65
‡
bprop.90:ybprop.90:[CNode]92:2bprop.90:[CNode]92:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op66
‰
bprop.90:[CNode]91:1
bprop.90:[CNode]92:2bprop.90:[CNode]93:3bprop.90:[CNode]93:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op67bprop.90*
bprop.27:ybprop.27:[CNode]:2bprop.27:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op66
<EFBFBD>
bprop.27:[CNode]:1
bprop.27:[CNode]:2bprop.27:[CNode]:3bprop.27:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op67bprop.27*
bprop.90:x*
bprop.27:x*
bprop.90:y*
bprop.90:out*
bprop.90:dout2
bprop.90:[CNode]93:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.27:y*
bprop.27:out*
bprop.27:dout2
bprop.27:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

26
mindspore/ops/bprop_mindir/Less_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.86:xbprop.86:[CNode]87:1bprop.86:[CNode]87:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op62
‹
bprop.26:xbprop.26:[CNode]:1bprop.26:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op62
‡
bprop.86:ybprop.86:[CNode]88:2bprop.86:[CNode]88:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op63
‰
bprop.86:[CNode]87:1
bprop.86:[CNode]88:2bprop.86:[CNode]89:3bprop.86:[CNode]89:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op64bprop.86*
bprop.26:ybprop.26:[CNode]:2bprop.26:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op63
<EFBFBD>
bprop.26:[CNode]:1
bprop.26:[CNode]:2bprop.26:[CNode]:3bprop.26:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op64bprop.26*
bprop.86:x*
bprop.26:x*
bprop.86:y*
bprop.86:out*
bprop.86:dout2
bprop.86:[CNode]89:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.26:y*
bprop.26:out*
bprop.26:dout2
bprop.26:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

34
mindspore/ops/bprop_mindir/LinSpace_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:<3A>
<EFBFBD>
bprop.45:startbprop.45:[CNode]46:1bprop.45:[CNode]46:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op31
Ž
bprop.45:stopbprop.45:[CNode]47:2bprop.45:[CNode]47:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op32
<EFBFBD>
bprop.45:numbprop.45:[CNode]48:3bprop.45:[CNode]48:3"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op33
Ÿ
bprop.45:[CNode]46:1
bprop.45:[CNode]47:2
bprop.45:[CNode]48:3bprop.45:[CNode]49:4bprop.45:[CNode]49:4"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op34bprop.45*
bprop.45:start*
bprop.45:stop*
bprop.45:num*
bprop.45:out*
bprop.45:dout2
bprop.45:[CNode]49:4:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
0.1.0 MindSpore*1.5.0.20211027:õ
‹
bprop.16:startbprop.16:[CNode]:1bprop.16:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op31
Š
bprop.16:stopbprop.16:[CNode]:2bprop.16:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op32
‰
bprop.16:numbprop.16:[CNode]:3bprop.16:[CNode]:3"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op33
•
bprop.16:[CNode]:1
bprop.16:[CNode]:2
bprop.16:[CNode]:3bprop.16:[CNode]:4bprop.16:[CNode]:4"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op34bprop.16*
bprop.16:start*
bprop.16:stop*
bprop.16:num*
bprop.16:out*
bprop.16:dout2
bprop.16:[CNode]:4:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

26
mindspore/ops/bprop_mindir/LogicalAnd_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.94:xbprop.94:[CNode]95:1bprop.94:[CNode]95:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op68
‹
bprop.28:xbprop.28:[CNode]:1bprop.28:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op68
‡
bprop.94:ybprop.94:[CNode]96:2bprop.94:[CNode]96:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op69
‰
bprop.94:[CNode]95:1
bprop.94:[CNode]96:2bprop.94:[CNode]97:3bprop.94:[CNode]97:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op70bprop.94*
bprop.28:ybprop.28:[CNode]:2bprop.28:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op69
<EFBFBD>
bprop.28:[CNode]:1
bprop.28:[CNode]:2bprop.28:[CNode]:3bprop.28:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op70bprop.28*
bprop.94:x*
bprop.28:x*
bprop.94:y*
bprop.94:out*
bprop.94:dout2
bprop.94:[CNode]97:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.28:y*
bprop.28:out*
bprop.28:dout2
bprop.28:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

18
mindspore/ops/bprop_mindir/LogicalNot_bprop.mindir
View File

@ -1,12 +1,12 @@
0.1.0 MindSpore*1.5.0:–
‹
0.1.0 MindSpore*1.5.0.20211027:Š
‡
bprop.39:xbprop.39:[CNode]40:1bprop.39:[CNode]40:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op27
s
bprop.39:[CNode]40:1bprop.39:[CNode]41:2bprop.39:[CNode]41:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op28bprop.39*
bprop.14:xbprop.14:[CNode]:1bprop.14:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op27
m
bprop.14:[CNode]:1bprop.14:[CNode]:2bprop.14:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op28bprop.14*
bprop.39:x*
bprop.39:out*
bprop.39:dout2
bprop.39:[CNode]41:2:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.14:x*
bprop.14:out*
bprop.14:dout2
bprop.14:[CNode]:2:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

26
mindspore/ops/bprop_mindir/LogicalOr_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:Ï
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.98:xbprop.98:[CNode]99:1bprop.98:[CNode]99:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op71
<EFBFBD>
bprop.29:xbprop.29:[CNode]:1bprop.29:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op71
‡
bprop.98:ybprop.98:[CNode]100:2bprop.98:[CNode]100:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op72
Œ
bprop.98:[CNode]99:1
bprop.98:[CNode]100:2bprop.98:[CNode]101:3bprop.98:[CNode]101:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op73bprop.98*
bprop.29:ybprop.29:[CNode]:2bprop.29:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op72
<EFBFBD>
bprop.29:[CNode]:1
bprop.29:[CNode]:2bprop.29:[CNode]:3bprop.29:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op73bprop.29*
bprop.98:x*
bprop.29:x*
bprop.98:y*
bprop.98:out*
bprop.98:dout2
bprop.98:[CNode]101:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.29:y*
bprop.29:out*
bprop.29:dout2
bprop.29:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

26
mindspore/ops/bprop_mindir/NotEqual_bprop.mindir
View File

@ -1,18 +1,18 @@
0.1.0 MindSpore*1.5.0:É
‹
0.1.0 MindSpore*1.5.0.20211027:·
‡
bprop.74:xbprop.74:[CNode]75:1bprop.74:[CNode]75:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op53
‹
bprop.23:xbprop.23:[CNode]:1bprop.23:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op53
‡
bprop.74:ybprop.74:[CNode]76:2bprop.74:[CNode]76:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op54
‰
bprop.74:[CNode]75:1
bprop.74:[CNode]76:2bprop.74:[CNode]77:3bprop.74:[CNode]77:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op55bprop.74*
bprop.23:ybprop.23:[CNode]:2bprop.23:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op54
<EFBFBD>
bprop.23:[CNode]:1
bprop.23:[CNode]:2bprop.23:[CNode]:3bprop.23:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op55bprop.23*
bprop.74:x*
bprop.23:x*
bprop.74:y*
bprop.74:out*
bprop.74:dout2
bprop.74:[CNode]77:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.23:y*
bprop.23:out*
bprop.23:dout2
bprop.23:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

40
mindspore/ops/bprop_mindir/OneHot_bprop.mindir
View File

@ -1,22 +1,22 @@
0.1.0 MindSpore*1.5.0:ß
‘
bprop.54:indicesbprop.54:[CNode]55:1bprop.54:[CNode]55:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op38
0.1.0 MindSpore*1.5.0.20211027:Á
<EFBFBD>
bprop.18:indicesbprop.18:[CNode]:1bprop.18:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op38
‹
bprop.18:depthbprop.18:[CNode]:2bprop.18:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op39
Ž
bprop.18:on_valuebprop.18:[CNode]:3bprop.18:[CNode]:3"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op40
<EFBFBD>
bprop.54:depthbprop.54:[CNode]56:2bprop.54:[CNode]56:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op39
’
bprop.54:on_valuebprop.54:[CNode]57:3bprop.54:[CNode]57:3"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op40
“
bprop.54:off_valuebprop.54:[CNode]58:4bprop.54:[CNode]58:4"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op41
µ
bprop.54:[CNode]55:1
bprop.54:[CNode]56:2
bprop.54:[CNode]57:3
bprop.54:[CNode]58:4bprop.54:[CNode]59:5bprop.54:[CNode]59:5"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op42bprop.54*
bprop.54:indices*
bprop.54:depth*
bprop.54:on_value*
bprop.54:off_value*
bprop.54:out*
bprop.54:dout2
bprop.54:[CNode]59:5:@5f6486474eab638624ee1777f9652b2edd3f5f2873c570e2992de1d8b0e87873
bprop.18:off_valuebprop.18:[CNode]:4bprop.18:[CNode]:4"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op41
©
bprop.18:[CNode]:1
bprop.18:[CNode]:2
bprop.18:[CNode]:3
bprop.18:[CNode]:4bprop.18:[CNode]:5bprop.18:[CNode]:5"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op42bprop.18*
bprop.18:indices*
bprop.18:depth*
bprop.18:on_value*
bprop.18:off_value*
bprop.18:out*
bprop.18:dout2
bprop.18:[CNode]:5:@5f6486474eab638624ee1777f9652b2edd3f5f2873c570e2992de1d8b0e87873

18
mindspore/ops/bprop_mindir/OnesLike_bprop.mindir
View File

@ -1,10 +1,10 @@
0.1.0 MindSpore*1.5.0:ƒ
…
bprop.7:xbprop.7:[CNode]8:1bprop.7:[CNode]8:1"!S-Prim-hyper_map[zeros_like_leaf]:-Default/S-Prim-hyper_map[zeros_like_leaf]-op5
l
bprop.7:[CNode]8:1bprop.7:[CNode]9:2bprop.7:[CNode]9:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op6bprop.7*
bprop.7:x*
bprop.7:out*
bprop.7:dout2
bprop.7:[CNode]9:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad
0.1.0 MindSpore*1.5.0.20211027:ý
ƒ
bprop.4:xbprop.4:[CNode]:1bprop.4:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:-Default/S-Prim-hyper_map[zeros_like_leaf]-op5
i
bprop.4:[CNode]:1bprop.4:[CNode]:2bprop.4:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op6bprop.4*
bprop.4:x*
bprop.4:out*
bprop.4:dout2
bprop.4:[CNode]:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad

18
mindspore/ops/bprop_mindir/Range_bprop.mindir
View File

@ -1,10 +1,10 @@
0.1.0 MindSpore*1.5.0:ƒ
…
bprop.4:xbprop.4:[CNode]5:1bprop.4:[CNode]5:1"!S-Prim-hyper_map[zeros_like_leaf]:-Default/S-Prim-hyper_map[zeros_like_leaf]-op3
l
bprop.4:[CNode]5:1bprop.4:[CNode]6:2bprop.4:[CNode]6:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op4bprop.4*
bprop.4:x*
bprop.4:out*
bprop.4:dout2
bprop.4:[CNode]6:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad
0.1.0 MindSpore*1.5.0.20211027:ý
ƒ
bprop.3:xbprop.3:[CNode]:1bprop.3:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:-Default/S-Prim-hyper_map[zeros_like_leaf]-op3
i
bprop.3:[CNode]:1bprop.3:[CNode]:2bprop.3:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op4bprop.3*
bprop.3:x*
bprop.3:out*
bprop.3:dout2
bprop.3:[CNode]:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad

18
mindspore/ops/bprop_mindir/ReLU_bprop.mindir
View File

@ -1,11 +1,11 @@
0.1.0 MindSpore*1.5.0:Ü
0.1.0 MindSpore*1.5.0.20211027:Ù
e
bprop.0:dout
bprop.0:out bprop.0:dx:1 bprop.0:dx:1"S-Prim-ReluGrad:Default/S-Prim-ReluGrad-op0
f
bprop.0:dx:1bprop.0:[CNode]1:2bprop.0:[CNode]1:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op1bprop.0*
bprop.0:x*
bprop.0:out*
bprop.0:dout2
bprop.0:[CNode]1:2:@5f6486474eab638624ee1777f9652b2edd3f5f2873c570e2992de1d8b0e87873
bprop.1:dout
bprop.1:out bprop.1:dx:1 bprop.1:dx:1"S-Prim-ReluGrad:Default/S-Prim-ReluGrad-op0
d
bprop.1:dx:1bprop.1:[CNode]:2bprop.1:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op1bprop.1*
bprop.1:x*
bprop.1:out*
bprop.1:dout2
bprop.1:[CNode]:2:@5f6486474eab638624ee1777f9652b2edd3f5f2873c570e2992de1d8b0e87873

28
mindspore/ops/bprop_mindir/ReduceAll_bprop.mindir
View File

@ -1,14 +1,16 @@
0.1.0 MindSpore*1.5.0:è
<EFBFBD>
bprop.102:xbprop.102:[CNode]103:1bprop.102:[CNode]103:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op74
“
bprop.102:axisbprop.102:[CNode]104:2bprop.102:[CNode]104:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op75
‘
bprop.102:[CNode]103:1
bprop.102:[CNode]104:2bprop.102:[CNode]105:3bprop.102:[CNode]105:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op76 bprop.102*
bprop.102:x*
bprop.102:axis*
bprop.102:out*
bprop.102:dout2
bprop.102:[CNode]105:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
0.1.0 MindSpore*1.5.0.20211027:½
‡
bprop.30:xbprop.30:[CNode]:1bprop.30:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op74
Š
bprop.30:axisbprop.30:[CNode]:2bprop.30:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op75
<EFBFBD>
bprop.30:[CNode]:1
bprop.30:[CNode]:2bprop.30:[CNode]:3bprop.30:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op76bprop.30*
bprop.30:x*
bprop.30:axis*
bprop.30:out*
bprop.30:dout2
bprop.30:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

28
mindspore/ops/bprop_mindir/ReduceAny_bprop.mindir
View File

@ -1,14 +1,16 @@
0.1.0 MindSpore*1.5.0:è
<EFBFBD>
bprop.106:xbprop.106:[CNode]107:1bprop.106:[CNode]107:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op77
“
bprop.106:axisbprop.106:[CNode]108:2bprop.106:[CNode]108:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op78
‘
bprop.106:[CNode]107:1
bprop.106:[CNode]108:2bprop.106:[CNode]109:3bprop.106:[CNode]109:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op79 bprop.106*
bprop.106:x*
bprop.106:axis*
bprop.106:out*
bprop.106:dout2
bprop.106:[CNode]109:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
0.1.0 MindSpore*1.5.0.20211027:½
‡
bprop.31:xbprop.31:[CNode]:1bprop.31:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op77
Š
bprop.31:axisbprop.31:[CNode]:2bprop.31:[CNode]:2"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op78
<EFBFBD>
bprop.31:[CNode]:1
bprop.31:[CNode]:2bprop.31:[CNode]:3bprop.31:[CNode]:3"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op79bprop.31*
bprop.31:x*
bprop.31:axis*
bprop.31:out*
bprop.31:dout2
bprop.31:[CNode]:3:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

18
mindspore/ops/bprop_mindir/Round_bprop.mindir
View File

@ -1,12 +1,12 @@
0.1.0 MindSpore*1.5.0:–
‹
0.1.0 MindSpore*1.5.0.20211027:Š
‡
bprop.42:xbprop.42:[CNode]43:1bprop.42:[CNode]43:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op29
s
bprop.42:[CNode]43:1bprop.42:[CNode]44:2bprop.42:[CNode]44:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op30bprop.42*
bprop.15:xbprop.15:[CNode]:1bprop.15:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op29
m
bprop.15:[CNode]:1bprop.15:[CNode]:2bprop.15:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op30bprop.15*
bprop.42:x*
bprop.42:out*
bprop.42:dout2
bprop.42:[CNode]44:2:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.15:x*
bprop.15:out*
bprop.15:dout2
bprop.15:[CNode]:2:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

18
mindspore/ops/bprop_mindir/Sign_bprop.mindir
View File

@ -1,12 +1,12 @@
0.1.0 MindSpore*1.5.0:–
‹
0.1.0 MindSpore*1.5.0.20211027:Š
‡
bprop.36:xbprop.36:[CNode]37:1bprop.36:[CNode]37:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op25
s
bprop.36:[CNode]37:1bprop.36:[CNode]38:2bprop.36:[CNode]38:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op26bprop.36*
bprop.13:xbprop.13:[CNode]:1bprop.13:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:.Default/S-Prim-hyper_map[zeros_like_leaf]-op25
m
bprop.13:[CNode]:1bprop.13:[CNode]:2bprop.13:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op26bprop.13*
bprop.36:x*
bprop.36:out*
bprop.36:dout2
bprop.36:[CNode]38:2:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b
bprop.13:x*
bprop.13:out*
bprop.13:dout2
bprop.13:[CNode]:2:@1c03ee41e2ae73005664666a652e28787ff0c69916d109f77e40345be916e60b

20
mindspore/ops/bprop_mindir/ZerosLike_bprop.mindir
View File

@ -1,12 +1,10 @@
0.1.0 MindSpore*1.5.0:”
Š
bprop.10:xbprop.10:[CNode]11:1bprop.10:[CNode]11:1"!S-Prim-hyper_map[zeros_like_leaf]:-Default/S-Prim-hyper_map[zeros_like_leaf]-op7
r
bprop.10:[CNode]11:1bprop.10:[CNode]12:2bprop.10:[CNode]12:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op8bprop.10*
bprop.10:x*
bprop.10:out*
bprop.10:dout2
bprop.10:[CNode]12:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad
0.1.0 MindSpore*1.5.0.20211027:ý
ƒ
bprop.5:xbprop.5:[CNode]:1bprop.5:[CNode]:1"!S-Prim-hyper_map[zeros_like_leaf]:-Default/S-Prim-hyper_map[zeros_like_leaf]-op7
i
bprop.5:[CNode]:1bprop.5:[CNode]:2bprop.5:[CNode]:2"S-Prim-MakeTuple:Default/S-Prim-MakeTuple-op8bprop.5*
bprop.5:x*
bprop.5:out*
bprop.5:dout2
bprop.5:[CNode]:2:@dae47635340bc244097f692e3d086cc9ae28fd823d60946e421051e28dbccdad

3
mindspore/ops/operations/__init__.py
View File

@ -101,7 +101,6 @@ from ._thor_ops import (CusBatchMatMul, CusCholeskyTrsm, CusFusedAbsMax1, CusImg
from .sparse_ops import (SparseToDense, SparseTensorDenseMatmul)
from ._embedding_cache_ops import (CacheSwapTable, UpdateCache, MapCacheIdx, SubAndFilter,
MapUniform, DynamicAssign, PadAndShift)
from .quantum_ops import PQC, Evolution
from .sponge_ops import (BondForce, BondEnergy, BondAtomEnergy, BondForceWithAtomEnergy, BondForceWithAtomVirial,
DihedralForce, DihedralEnergy, DihedralAtomEnergy, DihedralForceWithAtomEnergy, AngleForce,
AngleEnergy, AngleAtomEnergy, AngleForceWithAtomEnergy, PMEReciprocalForce,
@ -466,8 +465,6 @@ __all__ = [
"Range",
"SearchSorted",
"IndexAdd",
"PQC",
"Evolution",
"AdaptiveAvgPool2D",
"TensorScatterMax",
"TensorScatterMin",

136
mindspore/ops/operations/quantum_ops.py
View File

@ -1,136 +0,0 @@
# Copyright 2021 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
"""Operators for quantum computing."""
from ..primitive import PrimitiveWithInfer, prim_attr_register
from ..._checkparam import Validator as validator
from ...common import dtype as mstype
class PQC(PrimitiveWithInfer):
r"""
Evaluate a parameterized quantum circuit and calculate the gradient of each parameters.
Inputs of this operation is generated by MindQuantum framework.
Inputs:
- **n_qubits** (int) - The qubit number of quantum simulator.
- **encoder_params_names** (List[str]) - The parameters names of encoder circuit.
- **ansatz_params_names** (List[str]) - The parameters names of ansatz circuit.
- **gate_names** (List[str]) - The name of each gate.
- **gate_matrix** (List[List[List[List[float]]]]) - Real part and image
part of the matrix of quantum gate.
- **gate_obj_qubits** (List[List[int]]) - Object qubits of each gate.
- **gate_ctrl_qubits** (List[List[int]]) - Control qubits of each gate.
- **gate_params_names** (List[List[str]]) - Parameter names of each gate.
- **gate_coeff** (List[List[float]]) - Coefficient of each parameter of each gate.
- **gate_requires_grad** (List[List[bool]]) - Whether to calculate gradient
of parameters of gates.
- **hams_pauli_coeff** (List[List[float]]) - Coefficient of pauli words.
- **hams_pauli_word** (List[List[List[str]]]) - Pauli words.
- **hams_pauli_qubit** (List[List[List[int]]]) - The qubit that pauli matrix act on.
- **n_threads** (int) - Thread to evaluate input data.
Outputs:
- **expected_value** (Tensor) - The expected value of hamiltonian.
- **g1** (Tensor) - Gradient of encode circuit parameters.
- **g2** (Tensor) - Gradient of ansatz circuit parameters.
Supported Platforms:
``CPU``
"""
@prim_attr_register
def __init__(self, n_qubits, encoder_params_names, ansatz_params_names,
gate_names, gate_matrix, gate_obj_qubits, gate_ctrl_qubits,
gate_params_names, gate_coeff, gate_requires_grad,
hams_pauli_coeff, hams_pauli_word, hams_pauli_qubit,
n_threads):
self.init_prim_io_names(
inputs=['encoder_data', 'ansatz_data'],
outputs=['results', 'encoder_gradient', 'ansatz_gradient'])
self.n_hams = len(hams_pauli_coeff)
def check_shape_size(self, encoder_data, ansatz_data):
if len(encoder_data) != 2:
raise ValueError(f"For '{self.name}', the dimension of 'encoder_data' should be 2, "
f"but got {len(encoder_data)}.")
if len(ansatz_data) != 1:
raise ValueError(f"For '{self.name}', the dimension of 'ansatz_data' should be 1, "
f"but got {len(ansatz_data)}.")
def infer_shape(self, encoder_data, ansatz_data):
self.check_shape_size(encoder_data, ansatz_data)
return [encoder_data[0], self.n_hams], [
encoder_data[0], self.n_hams,
len(self.encoder_params_names)
], [encoder_data[0], self.n_hams,
len(self.ansatz_params_names)]
def infer_dtype(self, encoder_data, ansatz_data):
args = {'encoder_data': encoder_data, 'ansatz_data': ansatz_data}
validator.check_tensors_dtypes_same_and_valid(args, mstype.float_type,
self.name)
return encoder_data, encoder_data, encoder_data
class Evolution(PrimitiveWithInfer):
r"""
Inputs of this operation is generated by MindQuantum framework.
Inputs:
- **n_qubits** (int) - The qubit number of quantum simulator.
- **param_names** (List[str]) - The parameters names.
- **gate_names** (List[str]) - The name of each gate.
- **gate_matrix** (List[List[List[List[float]]]]) - Real part and image
part of the matrix of quantum gate.
- **gate_obj_qubits** (List[List[int]]) - Object qubits of each gate.
- **gate_ctrl_qubits** (List[List[int]]) - Control qubits of each gate.
- **gate_params_names** (List[List[str]]) - Parameter names of each gate.
- **gate_coeff** (List[List[float]]) - Coefficient of each parameter of each gate.
- **gate_requires_grad** (List[List[bool]]) - Whether to calculate gradient
of parameters of gates.
- **hams_pauli_coeff** (List[List[float]]) - Coefficient of pauli words.
- **hams_pauli_word** (List[List[List[str]]]) - Pauli words.
- **hams_pauli_qubit** (List[List[List[int]]]) - The qubit that pauli matrix act on.
Outputs:
- **Quantum state** (Tensor) - The quantum state after evolution.
Supported Platforms:
``CPU``
"""
@prim_attr_register
def __init__(self, n_qubits, param_names, gate_names, gate_matrix,
gate_obj_qubits, gate_ctrl_qubits, gate_params_names,
gate_coeff, gate_requires_grad, hams_pauli_coeff,
hams_pauli_word, hams_pauli_qubit):
"""Initialize Evolution"""
self.init_prim_io_names(inputs=['param_data'], outputs=['state'])
self.n_qubits = n_qubits
def check_shape_size(self, param_data):
if len(param_data) != 1:
raise ValueError(f"For '{self.name}', the dimension of 'param_data' should be 1, "
f"but got {len(param_data)}.")
def infer_shape(self, param_data):
self.check_shape_size(param_data)
return [1 << self.n_qubits, 2]
def infer_dtype(self, param_data):
args = {'param_data': param_data}
validator.check_tensors_dtypes_same_and_valid(args, mstype.float_type,
self.name)
return param_data

81
tests/ut/python/ops/test_ops.py
View File

@ -2980,87 +2980,8 @@ test_case_quant_ops = [
'skip': ['backward']}),
]
test_case_quantum_ops = [
('PQC', {
'block': P.PQC(n_qubits=3,
encoder_params_names=['e0', 'e1', 'e2'],
ansatz_params_names=['a', 'b', 'c'],
gate_names=['RX', 'RX', 'RX', 'npg', 'npg',
'npg', 'RX', 'npg', 'npg', 'RZ',
'npg', 'npg', 'RY'],
gate_matrix=[[[['0.0', '0.0'], ['0.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.0', '0.0'], ['0.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.0', '0.0'], ['0.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.7071067811865475', '0.7071067811865475'],
['0.7071067811865475', '-0.7071067811865475']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.7071067811865475', '0.7071067811865475'],
['0.7071067811865475', '-0.7071067811865475']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.7071067811865475', '0.7071067811865475'],
['0.7071067811865475', '-0.7071067811865475']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.0', '0.0'], ['0.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.0', '1.0'], ['1.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.0', '-0.0'], ['0.0', '0.0']],
[['0.0', '-1.0'], ['1.0', '0.0']]],
[[['0.0', '0.0'], ['0.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.0', '1.0'], ['1.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['1.0', '0.0'], ['0.0', '-1.0']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.0', '0.0'], ['0.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]]],
gate_obj_qubits=[[0], [1], [2], [0], [1], [2],
[0], [1], [2], [1], [1], [0], [2]],
gate_ctrl_qubits=[[], [], [], [], [], [], [], [], [], [], [2], [], []],
gate_params_names=[['e0'], ['e1'], ['e2'], [], [], [], ['a'], [], [],
['b'], [], [], ['c']],
gate_coeff=[[1.0], [1.0], [1.0], [], [], [], [1.0], [], [], [1.0], [],
[], [1.0]],
gate_requires_grad=[[True], [True], [True], [], [], [], [True], [], [],
[True], [], [], [True]],
hams_pauli_coeff=[[1.0]],
hams_pauli_word=[[['X', 'Y', 'Z']]],
hams_pauli_qubit=[[[0, 1, 2]]],
n_threads=1),
'desc_inputs': [Tensor(np.array([[1.0, 2.0, 3.0]]).astype(np.float32)),
Tensor(np.array([2.0, 3.0, 4.0]).astype(np.float32))],
'skip': ['backward']}),
('Evolution', {
'block': P.Evolution(n_qubits=3,
param_names=['a'],
gate_names=['npg', 'npg', 'npg', 'RY'],
gate_matrix=[[[['0.7071067811865475', '0.7071067811865475'],
['0.7071067811865475', '-0.7071067811865475']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.7071067811865475', '0.7071067811865475'],
['0.7071067811865475', '-0.7071067811865475']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.0', '1.0'], ['1.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]],
[[['0.0', '0.0'], ['0.0', '0.0']],
[['0.0', '0.0'], ['0.0', '0.0']]]],
gate_obj_qubits=[[0], [1], [0], [0]],
gate_ctrl_qubits=[[], [], [1], []],
gate_params_names=[[], [], [], ['a']],
gate_coeff=[[], [], [], [1.0]],
gate_requires_grad=[[], [], [], [True]],
hams_pauli_coeff=[[1.0]],
hams_pauli_word=[[['Z']]],
hams_pauli_qubit=[[[0]]]),
'desc_inputs': [Tensor(np.array([0.5]).astype(np.float32))],
'skip': ['backward']}),
]
test_case_lists = [test_case_nn_ops, test_case_math_ops, test_case_array_ops,
test_case_other_ops, test_case_quant_ops, test_case_quantum_ops]
test_case_other_ops, test_case_quant_ops]
test_case = functools.reduce(lambda x, y: x + y, test_case_lists)
# use -k to select certain testcast
# pytest tests/python/ops/test_ops.py::test_backward -k LayerNorm

969
third_party/patch/projectq/projectq.patch001 vendored
View File

@ -1,969 +0,0 @@
diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel1.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel1.hpp
--- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel1.hpp 2020-06-05 21:07:57.000000000 +0800
+++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel1.hpp 2021-04-19 18:04:05.541802882 +0800
@@ -17,18 +17,18 @@
{
__m256d v[2];
- v[0] = load2(&psi[I]);
- v[1] = load2(&psi[I + d0]);
+ v[0] = load2(psi + 2 * I);
+ v[1] = load2(psi + 2 * (I + d0));
- _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(mul(v[0], m[0], mt[0]), mul(v[1], m[1], mt[1])));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(mul(v[0], m[0], mt[0]), mul(v[1], m[1], mt[1])));
}
// bit indices id[.] are given from high to low (e.g. control first for CNOT)
template <class V, class M>
-void kernel(V &psi, unsigned id0, M const& m, std::size_t ctrlmask)
+void kernel(V &psi, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)
{
- std::size_t n = psi.size();
+ std::size_t n = len;
std::size_t d0 = 1UL << id0;
__m256d mm[] = {load(&m[0][0], &m[1][0]), load(&m[0][1], &m[1][1])};
diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel2.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel2.hpp
--- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel2.hpp 2020-06-05 21:07:57.000000000 +0800
+++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel2.hpp 2021-04-19 18:04:05.541802882 +0800
@@ -17,21 +17,21 @@
{
__m256d v[4];
- v[0] = load2(&psi[I]);
- v[1] = load2(&psi[I + d0]);
- v[2] = load2(&psi[I + d1]);
- v[3] = load2(&psi[I + d0 + d1]);
+ v[0] = load2(psi + 2 * I);
+ v[1] = load2(psi + 2 * (I + d0));
+ v[2] = load2(psi + 2 * (I + d1));
+ v[3] = load2(psi + 2 * (I + d0 + d1));
- _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(mul(v[0], m[0], mt[0]), add(mul(v[1], m[1], mt[1]), add(mul(v[2], m[2], mt[2]), mul(v[3], m[3], mt[3])))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1], (double*)&psi[I + d1], add(mul(v[0], m[4], mt[4]), add(mul(v[1], m[5], mt[5]), add(mul(v[2], m[6], mt[6]), mul(v[3], m[7], mt[7])))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(mul(v[0], m[0], mt[0]), add(mul(v[1], m[1], mt[1]), add(mul(v[2], m[2], mt[2]), mul(v[3], m[3], mt[3])))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1), psi + 2 * (I + d1), add(mul(v[0], m[4], mt[4]), add(mul(v[1], m[5], mt[5]), add(mul(v[2], m[6], mt[6]), mul(v[3], m[7], mt[7])))));
}
// bit indices id[.] are given from high to low (e.g. control first for CNOT)
template <class V, class M>
-void kernel(V &psi, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask)
+void kernel(V &psi, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)
{
- std::size_t n = psi.size();
+ std::size_t n = len;
std::size_t d0 = 1UL << id0;
std::size_t d1 = 1UL << id1;
diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel3.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel3.hpp
--- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel3.hpp 2020-06-05 21:07:57.000000000 +0800
+++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel3.hpp 2021-04-19 18:04:05.541802882 +0800
@@ -17,10 +17,10 @@
{
__m256d v[4];
- v[0] = load2(&psi[I]);
- v[1] = load2(&psi[I + d0]);
- v[2] = load2(&psi[I + d1]);
- v[3] = load2(&psi[I + d0 + d1]);
+ v[0] = load2(psi + 2 * I);
+ v[1] = load2(psi + 2 * (I + d0));
+ v[2] = load2(psi + 2 * (I + d1));
+ v[3] = load2(psi + 2 * (I + d0 + d1));
__m256d tmp[4];
@@ -29,23 +29,23 @@
tmp[2] = add(mul(v[0], m[8], mt[8]), add(mul(v[1], m[9], mt[9]), add(mul(v[2], m[10], mt[10]), mul(v[3], m[11], mt[11]))));
tmp[3] = add(mul(v[0], m[12], mt[12]), add(mul(v[1], m[13], mt[13]), add(mul(v[2], m[14], mt[14]), mul(v[3], m[15], mt[15]))));
- v[0] = load2(&psi[I + d2]);
- v[1] = load2(&psi[I + d0 + d2]);
- v[2] = load2(&psi[I + d1 + d2]);
- v[3] = load2(&psi[I + d0 + d1 + d2]);
-
- _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(tmp[0], add(mul(v[0], m[16], mt[16]), add(mul(v[1], m[17], mt[17]), add(mul(v[2], m[18], mt[18]), mul(v[3], m[19], mt[19]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1], (double*)&psi[I + d1], add(tmp[1], add(mul(v[0], m[20], mt[20]), add(mul(v[1], m[21], mt[21]), add(mul(v[2], m[22], mt[22]), mul(v[3], m[23], mt[23]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d2], (double*)&psi[I + d2], add(tmp[2], add(mul(v[0], m[24], mt[24]), add(mul(v[1], m[25], mt[25]), add(mul(v[2], m[26], mt[26]), mul(v[3], m[27], mt[27]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2], (double*)&psi[I + d1 + d2], add(tmp[3], add(mul(v[0], m[28], mt[28]), add(mul(v[1], m[29], mt[29]), add(mul(v[2], m[30], mt[30]), mul(v[3], m[31], mt[31]))))));
+ v[0] = load2(psi + 2 * (I + d2));
+ v[1] = load2(psi + 2 * (I + d0 + d2));
+ v[2] = load2(psi + 2 * (I + d1 + d2));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d2));
+
+ _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(tmp[0], add(mul(v[0], m[16], mt[16]), add(mul(v[1], m[17], mt[17]), add(mul(v[2], m[18], mt[18]), mul(v[3], m[19], mt[19]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1), psi + 2 * (I + d1), add(tmp[1], add(mul(v[0], m[20], mt[20]), add(mul(v[1], m[21], mt[21]), add(mul(v[2], m[22], mt[22]), mul(v[3], m[23], mt[23]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2), psi + 2 * (I + d2), add(tmp[2], add(mul(v[0], m[24], mt[24]), add(mul(v[1], m[25], mt[25]), add(mul(v[2], m[26], mt[26]), mul(v[3], m[27], mt[27]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2), psi + 2 * (I + d1 + d2), add(tmp[3], add(mul(v[0], m[28], mt[28]), add(mul(v[1], m[29], mt[29]), add(mul(v[2], m[30], mt[30]), mul(v[3], m[31], mt[31]))))));
}
// bit indices id[.] are given from high to low (e.g. control first for CNOT)
template <class V, class M>
-void kernel(V &psi, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask)
+void kernel(V &psi, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)
{
- std::size_t n = psi.size();
+ std::size_t n = len;
std::size_t d0 = 1UL << id0;
std::size_t d1 = 1UL << id1;
std::size_t d2 = 1UL << id2;
diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel4.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel4.hpp
--- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel4.hpp 2020-06-05 21:07:57.000000000 +0800
+++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel4.hpp 2021-04-19 18:04:05.541802882 +0800
@@ -17,10 +17,10 @@
{
__m256d v[4];
- v[0] = load2(&psi[I]);
- v[1] = load2(&psi[I + d0]);
- v[2] = load2(&psi[I + d1]);
- v[3] = load2(&psi[I + d0 + d1]);
+ v[0] = load2(psi + 2 * I);
+ v[1] = load2(psi + 2 * (I + d0));
+ v[2] = load2(psi + 2 * (I + d1));
+ v[3] = load2(psi + 2 * (I + d0 + d1));
__m256d tmp[8];
@@ -33,10 +33,10 @@
tmp[6] = add(mul(v[0], m[24], mt[24]), add(mul(v[1], m[25], mt[25]), add(mul(v[2], m[26], mt[26]), mul(v[3], m[27], mt[27]))));
tmp[7] = add(mul(v[0], m[28], mt[28]), add(mul(v[1], m[29], mt[29]), add(mul(v[2], m[30], mt[30]), mul(v[3], m[31], mt[31]))));
- v[0] = load2(&psi[I + d2]);
- v[1] = load2(&psi[I + d0 + d2]);
- v[2] = load2(&psi[I + d1 + d2]);
- v[3] = load2(&psi[I + d0 + d1 + d2]);
+ v[0] = load2(psi + 2 * (I + d2));
+ v[1] = load2(psi + 2 * (I + d0 + d2));
+ v[2] = load2(psi + 2 * (I + d1 + d2));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d2));
tmp[0] = add(tmp[0], add(mul(v[0], m[32], mt[32]), add(mul(v[1], m[33], mt[33]), add(mul(v[2], m[34], mt[34]), mul(v[3], m[35], mt[35])))));
tmp[1] = add(tmp[1], add(mul(v[0], m[36], mt[36]), add(mul(v[1], m[37], mt[37]), add(mul(v[2], m[38], mt[38]), mul(v[3], m[39], mt[39])))));
@@ -47,10 +47,10 @@
tmp[6] = add(tmp[6], add(mul(v[0], m[56], mt[56]), add(mul(v[1], m[57], mt[57]), add(mul(v[2], m[58], mt[58]), mul(v[3], m[59], mt[59])))));
tmp[7] = add(tmp[7], add(mul(v[0], m[60], mt[60]), add(mul(v[1], m[61], mt[61]), add(mul(v[2], m[62], mt[62]), mul(v[3], m[63], mt[63])))));
- v[0] = load2(&psi[I + d3]);
- v[1] = load2(&psi[I + d0 + d3]);
- v[2] = load2(&psi[I + d1 + d3]);
- v[3] = load2(&psi[I + d0 + d1 + d3]);
+ v[0] = load2(psi + 2 * (I + d3));
+ v[1] = load2(psi + 2 * (I + d0 + d3));
+ v[2] = load2(psi + 2 * (I + d1 + d3));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d3));
tmp[0] = add(tmp[0], add(mul(v[0], m[64], mt[64]), add(mul(v[1], m[65], mt[65]), add(mul(v[2], m[66], mt[66]), mul(v[3], m[67], mt[67])))));
tmp[1] = add(tmp[1], add(mul(v[0], m[68], mt[68]), add(mul(v[1], m[69], mt[69]), add(mul(v[2], m[70], mt[70]), mul(v[3], m[71], mt[71])))));
@@ -61,27 +61,27 @@
tmp[6] = add(tmp[6], add(mul(v[0], m[88], mt[88]), add(mul(v[1], m[89], mt[89]), add(mul(v[2], m[90], mt[90]), mul(v[3], m[91], mt[91])))));
tmp[7] = add(tmp[7], add(mul(v[0], m[92], mt[92]), add(mul(v[1], m[93], mt[93]), add(mul(v[2], m[94], mt[94]), mul(v[3], m[95], mt[95])))));
- v[0] = load2(&psi[I + d2 + d3]);
- v[1] = load2(&psi[I + d0 + d2 + d3]);
- v[2] = load2(&psi[I + d1 + d2 + d3]);
- v[3] = load2(&psi[I + d0 + d1 + d2 + d3]);
-
- _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(tmp[0], add(mul(v[0], m[96], mt[96]), add(mul(v[1], m[97], mt[97]), add(mul(v[2], m[98], mt[98]), mul(v[3], m[99], mt[99]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1], (double*)&psi[I + d1], add(tmp[1], add(mul(v[0], m[100], mt[100]), add(mul(v[1], m[101], mt[101]), add(mul(v[2], m[102], mt[102]), mul(v[3], m[103], mt[103]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d2], (double*)&psi[I + d2], add(tmp[2], add(mul(v[0], m[104], mt[104]), add(mul(v[1], m[105], mt[105]), add(mul(v[2], m[106], mt[106]), mul(v[3], m[107], mt[107]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2], (double*)&psi[I + d1 + d2], add(tmp[3], add(mul(v[0], m[108], mt[108]), add(mul(v[1], m[109], mt[109]), add(mul(v[2], m[110], mt[110]), mul(v[3], m[111], mt[111]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d3], (double*)&psi[I + d3], add(tmp[4], add(mul(v[0], m[112], mt[112]), add(mul(v[1], m[113], mt[113]), add(mul(v[2], m[114], mt[114]), mul(v[3], m[115], mt[115]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d3], (double*)&psi[I + d1 + d3], add(tmp[5], add(mul(v[0], m[116], mt[116]), add(mul(v[1], m[117], mt[117]), add(mul(v[2], m[118], mt[118]), mul(v[3], m[119], mt[119]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d2 + d3], (double*)&psi[I + d2 + d3], add(tmp[6], add(mul(v[0], m[120], mt[120]), add(mul(v[1], m[121], mt[121]), add(mul(v[2], m[122], mt[122]), mul(v[3], m[123], mt[123]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2 + d3], (double*)&psi[I + d1 + d2 + d3], add(tmp[7], add(mul(v[0], m[124], mt[124]), add(mul(v[1], m[125], mt[125]), add(mul(v[2], m[126], mt[126]), mul(v[3], m[127], mt[127]))))));
+ v[0] = load2(psi + 2 * (I + d2 + d3));
+ v[1] = load2(psi + 2 * (I + d0 + d2 + d3));
+ v[2] = load2(psi + 2 * (I + d1 + d2 + d3));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d2 + d3));
+
+ _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(tmp[0], add(mul(v[0], m[96], mt[96]), add(mul(v[1], m[97], mt[97]), add(mul(v[2], m[98], mt[98]), mul(v[3], m[99], mt[99]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1), psi + 2 * (I + d1), add(tmp[1], add(mul(v[0], m[100], mt[100]), add(mul(v[1], m[101], mt[101]), add(mul(v[2], m[102], mt[102]), mul(v[3], m[103], mt[103]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2), psi + 2 * (I + d2), add(tmp[2], add(mul(v[0], m[104], mt[104]), add(mul(v[1], m[105], mt[105]), add(mul(v[2], m[106], mt[106]), mul(v[3], m[107], mt[107]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2), psi + 2 * (I + d1 + d2), add(tmp[3], add(mul(v[0], m[108], mt[108]), add(mul(v[1], m[109], mt[109]), add(mul(v[2], m[110], mt[110]), mul(v[3], m[111], mt[111]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d3), psi + 2 * (I + d3), add(tmp[4], add(mul(v[0], m[112], mt[112]), add(mul(v[1], m[113], mt[113]), add(mul(v[2], m[114], mt[114]), mul(v[3], m[115], mt[115]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d3), psi + 2 * (I + d1 + d3), add(tmp[5], add(mul(v[0], m[116], mt[116]), add(mul(v[1], m[117], mt[117]), add(mul(v[2], m[118], mt[118]), mul(v[3], m[119], mt[119]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2 + d3), psi + 2 * (I + d2 + d3), add(tmp[6], add(mul(v[0], m[120], mt[120]), add(mul(v[1], m[121], mt[121]), add(mul(v[2], m[122], mt[122]), mul(v[3], m[123], mt[123]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2 + d3), psi + 2 * (I + d1 + d2 + d3), add(tmp[7], add(mul(v[0], m[124], mt[124]), add(mul(v[1], m[125], mt[125]), add(mul(v[2], m[126], mt[126]), mul(v[3], m[127], mt[127]))))));
}
// bit indices id[.] are given from high to low (e.g. control first for CNOT)
template <class V, class M>
-void kernel(V &psi, unsigned id3, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask)
+void kernel(V &psi, unsigned id3, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)
{
- std::size_t n = psi.size();
+ std::size_t n = len;
std::size_t d0 = 1UL << id0;
std::size_t d1 = 1UL << id1;
std::size_t d2 = 1UL << id2;
diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel5.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel5.hpp
--- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel5.hpp 2020-06-05 21:07:57.000000000 +0800
+++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel5.hpp 2021-04-19 18:04:05.541802882 +0800
@@ -17,10 +17,10 @@
{
__m256d v[4];
- v[0] = load2(&psi[I]);
- v[1] = load2(&psi[I + d0]);
- v[2] = load2(&psi[I + d1]);
- v[3] = load2(&psi[I + d0 + d1]);
+ v[0] = load2(psi + 2 * I);
+ v[1] = load2(psi + 2 * (I + d0));
+ v[2] = load2(psi + 2 * (I + d1));
+ v[3] = load2(psi + 2 * (I + d0 + d1));
__m256d tmp[16];
@@ -41,10 +41,10 @@
tmp[14] = add(mul(v[0], m[56], mt[56]), add(mul(v[1], m[57], mt[57]), add(mul(v[2], m[58], mt[58]), mul(v[3], m[59], mt[59]))));
tmp[15] = add(mul(v[0], m[60], mt[60]), add(mul(v[1], m[61], mt[61]), add(mul(v[2], m[62], mt[62]), mul(v[3], m[63], mt[63]))));
- v[0] = load2(&psi[I + d2]);
- v[1] = load2(&psi[I + d0 + d2]);
- v[2] = load2(&psi[I + d1 + d2]);
- v[3] = load2(&psi[I + d0 + d1 + d2]);
+ v[0] = load2(psi + 2 * (I + d2));
+ v[1] = load2(psi + 2 * (I + d0 + d2));
+ v[2] = load2(psi + 2 * (I + d1 + d2));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d2));
tmp[0] = add(tmp[0], add(mul(v[0], m[64], mt[64]), add(mul(v[1], m[65], mt[65]), add(mul(v[2], m[66], mt[66]), mul(v[3], m[67], mt[67])))));
tmp[1] = add(tmp[1], add(mul(v[0], m[68], mt[68]), add(mul(v[1], m[69], mt[69]), add(mul(v[2], m[70], mt[70]), mul(v[3], m[71], mt[71])))));
@@ -63,10 +63,10 @@
tmp[14] = add(tmp[14], add(mul(v[0], m[120], mt[120]), add(mul(v[1], m[121], mt[121]), add(mul(v[2], m[122], mt[122]), mul(v[3], m[123], mt[123])))));
tmp[15] = add(tmp[15], add(mul(v[0], m[124], mt[124]), add(mul(v[1], m[125], mt[125]), add(mul(v[2], m[126], mt[126]), mul(v[3], m[127], mt[127])))));
- v[0] = load2(&psi[I + d3]);
- v[1] = load2(&psi[I + d0 + d3]);
- v[2] = load2(&psi[I + d1 + d3]);
- v[3] = load2(&psi[I + d0 + d1 + d3]);
+ v[0] = load2(psi + 2 * (I + d3));
+ v[1] = load2(psi + 2 * (I + d0 + d3));
+ v[2] = load2(psi + 2 * (I + d1 + d3));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d3));
tmp[0] = add(tmp[0], add(mul(v[0], m[128], mt[128]), add(mul(v[1], m[129], mt[129]), add(mul(v[2], m[130], mt[130]), mul(v[3], m[131], mt[131])))));
tmp[1] = add(tmp[1], add(mul(v[0], m[132], mt[132]), add(mul(v[1], m[133], mt[133]), add(mul(v[2], m[134], mt[134]), mul(v[3], m[135], mt[135])))));
@@ -85,10 +85,10 @@
tmp[14] = add(tmp[14], add(mul(v[0], m[184], mt[184]), add(mul(v[1], m[185], mt[185]), add(mul(v[2], m[186], mt[186]), mul(v[3], m[187], mt[187])))));
tmp[15] = add(tmp[15], add(mul(v[0], m[188], mt[188]), add(mul(v[1], m[189], mt[189]), add(mul(v[2], m[190], mt[190]), mul(v[3], m[191], mt[191])))));
- v[0] = load2(&psi[I + d2 + d3]);
- v[1] = load2(&psi[I + d0 + d2 + d3]);
- v[2] = load2(&psi[I + d1 + d2 + d3]);
- v[3] = load2(&psi[I + d0 + d1 + d2 + d3]);
+ v[0] = load2(psi + 2 * (I + d2 + d3));
+ v[1] = load2(psi + 2 * (I + d0 + d2 + d3));
+ v[2] = load2(psi + 2 * (I + d1 + d2 + d3));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d2 + d3));
tmp[0] = add(tmp[0], add(mul(v[0], m[192], mt[192]), add(mul(v[1], m[193], mt[193]), add(mul(v[2], m[194], mt[194]), mul(v[3], m[195], mt[195])))));
tmp[1] = add(tmp[1], add(mul(v[0], m[196], mt[196]), add(mul(v[1], m[197], mt[197]), add(mul(v[2], m[198], mt[198]), mul(v[3], m[199], mt[199])))));
@@ -107,10 +107,10 @@
tmp[14] = add(tmp[14], add(mul(v[0], m[248], mt[248]), add(mul(v[1], m[249], mt[249]), add(mul(v[2], m[250], mt[250]), mul(v[3], m[251], mt[251])))));
tmp[15] = add(tmp[15], add(mul(v[0], m[252], mt[252]), add(mul(v[1], m[253], mt[253]), add(mul(v[2], m[254], mt[254]), mul(v[3], m[255], mt[255])))));
- v[0] = load2(&psi[I + d4]);
- v[1] = load2(&psi[I + d0 + d4]);
- v[2] = load2(&psi[I + d1 + d4]);
- v[3] = load2(&psi[I + d0 + d1 + d4]);
+ v[0] = load2(psi + 2 * (I + d4));
+ v[1] = load2(psi + 2 * (I + d0 + d4));
+ v[2] = load2(psi + 2 * (I + d1 + d4));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d4));
tmp[0] = add(tmp[0], add(mul(v[0], m[256], mt[256]), add(mul(v[1], m[257], mt[257]), add(mul(v[2], m[258], mt[258]), mul(v[3], m[259], mt[259])))));
tmp[1] = add(tmp[1], add(mul(v[0], m[260], mt[260]), add(mul(v[1], m[261], mt[261]), add(mul(v[2], m[262], mt[262]), mul(v[3], m[263], mt[263])))));
@@ -129,10 +129,10 @@
tmp[14] = add(tmp[14], add(mul(v[0], m[312], mt[312]), add(mul(v[1], m[313], mt[313]), add(mul(v[2], m[314], mt[314]), mul(v[3], m[315], mt[315])))));
tmp[15] = add(tmp[15], add(mul(v[0], m[316], mt[316]), add(mul(v[1], m[317], mt[317]), add(mul(v[2], m[318], mt[318]), mul(v[3], m[319], mt[319])))));
- v[0] = load2(&psi[I + d2 + d4]);
- v[1] = load2(&psi[I + d0 + d2 + d4]);
- v[2] = load2(&psi[I + d1 + d2 + d4]);
- v[3] = load2(&psi[I + d0 + d1 + d2 + d4]);
+ v[0] = load2(psi + 2 * (I + d2 + d4));
+ v[1] = load2(psi + 2 * (I + d0 + d2 + d4));
+ v[2] = load2(psi + 2 * (I + d1 + d2 + d4));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d2 + d4));
tmp[0] = add(tmp[0], add(mul(v[0], m[320], mt[320]), add(mul(v[1], m[321], mt[321]), add(mul(v[2], m[322], mt[322]), mul(v[3], m[323], mt[323])))));
tmp[1] = add(tmp[1], add(mul(v[0], m[324], mt[324]), add(mul(v[1], m[325], mt[325]), add(mul(v[2], m[326], mt[326]), mul(v[3], m[327], mt[327])))));
@@ -151,10 +151,10 @@
tmp[14] = add(tmp[14], add(mul(v[0], m[376], mt[376]), add(mul(v[1], m[377], mt[377]), add(mul(v[2], m[378], mt[378]), mul(v[3], m[379], mt[379])))));
tmp[15] = add(tmp[15], add(mul(v[0], m[380], mt[380]), add(mul(v[1], m[381], mt[381]), add(mul(v[2], m[382], mt[382]), mul(v[3], m[383], mt[383])))));
- v[0] = load2(&psi[I + d3 + d4]);
- v[1] = load2(&psi[I + d0 + d3 + d4]);
- v[2] = load2(&psi[I + d1 + d3 + d4]);
- v[3] = load2(&psi[I + d0 + d1 + d3 + d4]);
+ v[0] = load2(psi + 2 * (I + d3 + d4));
+ v[1] = load2(psi + 2 * (I + d0 + d3 + d4));
+ v[2] = load2(psi + 2 * (I + d1 + d3 + d4));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d3 + d4));
tmp[0] = add(tmp[0], add(mul(v[0], m[384], mt[384]), add(mul(v[1], m[385], mt[385]), add(mul(v[2], m[386], mt[386]), mul(v[3], m[387], mt[387])))));
tmp[1] = add(tmp[1], add(mul(v[0], m[388], mt[388]), add(mul(v[1], m[389], mt[389]), add(mul(v[2], m[390], mt[390]), mul(v[3], m[391], mt[391])))));
@@ -173,35 +173,35 @@
tmp[14] = add(tmp[14], add(mul(v[0], m[440], mt[440]), add(mul(v[1], m[441], mt[441]), add(mul(v[2], m[442], mt[442]), mul(v[3], m[443], mt[443])))));
tmp[15] = add(tmp[15], add(mul(v[0], m[444], mt[444]), add(mul(v[1], m[445], mt[445]), add(mul(v[2], m[446], mt[446]), mul(v[3], m[447], mt[447])))));
- v[0] = load2(&psi[I + d2 + d3 + d4]);
- v[1] = load2(&psi[I + d0 + d2 + d3 + d4]);
- v[2] = load2(&psi[I + d1 + d2 + d3 + d4]);
- v[3] = load2(&psi[I + d0 + d1 + d2 + d3 + d4]);
-
- _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(tmp[0], add(mul(v[0], m[448], mt[448]), add(mul(v[1], m[449], mt[449]), add(mul(v[2], m[450], mt[450]), mul(v[3], m[451], mt[451]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1], (double*)&psi[I + d1], add(tmp[1], add(mul(v[0], m[452], mt[452]), add(mul(v[1], m[453], mt[453]), add(mul(v[2], m[454], mt[454]), mul(v[3], m[455], mt[455]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d2], (double*)&psi[I + d2], add(tmp[2], add(mul(v[0], m[456], mt[456]), add(mul(v[1], m[457], mt[457]), add(mul(v[2], m[458], mt[458]), mul(v[3], m[459], mt[459]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2], (double*)&psi[I + d1 + d2], add(tmp[3], add(mul(v[0], m[460], mt[460]), add(mul(v[1], m[461], mt[461]), add(mul(v[2], m[462], mt[462]), mul(v[3], m[463], mt[463]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d3], (double*)&psi[I + d3], add(tmp[4], add(mul(v[0], m[464], mt[464]), add(mul(v[1], m[465], mt[465]), add(mul(v[2], m[466], mt[466]), mul(v[3], m[467], mt[467]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d3], (double*)&psi[I + d1 + d3], add(tmp[5], add(mul(v[0], m[468], mt[468]), add(mul(v[1], m[469], mt[469]), add(mul(v[2], m[470], mt[470]), mul(v[3], m[471], mt[471]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d2 + d3], (double*)&psi[I + d2 + d3], add(tmp[6], add(mul(v[0], m[472], mt[472]), add(mul(v[1], m[473], mt[473]), add(mul(v[2], m[474], mt[474]), mul(v[3], m[475], mt[475]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2 + d3], (double*)&psi[I + d1 + d2 + d3], add(tmp[7], add(mul(v[0], m[476], mt[476]), add(mul(v[1], m[477], mt[477]), add(mul(v[2], m[478], mt[478]), mul(v[3], m[479], mt[479]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d4], (double*)&psi[I + d4], add(tmp[8], add(mul(v[0], m[480], mt[480]), add(mul(v[1], m[481], mt[481]), add(mul(v[2], m[482], mt[482]), mul(v[3], m[483], mt[483]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d4], (double*)&psi[I + d1 + d4], add(tmp[9], add(mul(v[0], m[484], mt[484]), add(mul(v[1], m[485], mt[485]), add(mul(v[2], m[486], mt[486]), mul(v[3], m[487], mt[487]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d2 + d4], (double*)&psi[I + d2 + d4], add(tmp[10], add(mul(v[0], m[488], mt[488]), add(mul(v[1], m[489], mt[489]), add(mul(v[2], m[490], mt[490]), mul(v[3], m[491], mt[491]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2 + d4], (double*)&psi[I + d1 + d2 + d4], add(tmp[11], add(mul(v[0], m[492], mt[492]), add(mul(v[1], m[493], mt[493]), add(mul(v[2], m[494], mt[494]), mul(v[3], m[495], mt[495]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d3 + d4], (double*)&psi[I + d3 + d4], add(tmp[12], add(mul(v[0], m[496], mt[496]), add(mul(v[1], m[497], mt[497]), add(mul(v[2], m[498], mt[498]), mul(v[3], m[499], mt[499]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d3 + d4], (double*)&psi[I + d1 + d3 + d4], add(tmp[13], add(mul(v[0], m[500], mt[500]), add(mul(v[1], m[501], mt[501]), add(mul(v[2], m[502], mt[502]), mul(v[3], m[503], mt[503]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d2 + d3 + d4], (double*)&psi[I + d2 + d3 + d4], add(tmp[14], add(mul(v[0], m[504], mt[504]), add(mul(v[1], m[505], mt[505]), add(mul(v[2], m[506], mt[506]), mul(v[3], m[507], mt[507]))))));
- _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2 + d3 + d4], (double*)&psi[I + d1 + d2 + d3 + d4], add(tmp[15], add(mul(v[0], m[508], mt[508]), add(mul(v[1], m[509], mt[509]), add(mul(v[2], m[510], mt[510]), mul(v[3], m[511], mt[511]))))));
+ v[0] = load2(psi + 2 * (I + d2 + d3 + d4));
+ v[1] = load2(psi + 2 * (I + d0 + d2 + d3 + d4));
+ v[2] = load2(psi + 2 * (I + d1 + d2 + d3 + d4));
+ v[3] = load2(psi + 2 * (I + d0 + d1 + d2 + d3 + d4));
+
+ _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(tmp[0], add(mul(v[0], m[448], mt[448]), add(mul(v[1], m[449], mt[449]), add(mul(v[2], m[450], mt[450]), mul(v[3], m[451], mt[451]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1), psi + 2 * (I + d1), add(tmp[1], add(mul(v[0], m[452], mt[452]), add(mul(v[1], m[453], mt[453]), add(mul(v[2], m[454], mt[454]), mul(v[3], m[455], mt[455]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2), psi + 2 * (I + d2), add(tmp[2], add(mul(v[0], m[456], mt[456]), add(mul(v[1], m[457], mt[457]), add(mul(v[2], m[458], mt[458]), mul(v[3], m[459], mt[459]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2), psi + 2 * (I + d1 + d2), add(tmp[3], add(mul(v[0], m[460], mt[460]), add(mul(v[1], m[461], mt[461]), add(mul(v[2], m[462], mt[462]), mul(v[3], m[463], mt[463]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d3), psi + 2 * (I + d3), add(tmp[4], add(mul(v[0], m[464], mt[464]), add(mul(v[1], m[465], mt[465]), add(mul(v[2], m[466], mt[466]), mul(v[3], m[467], mt[467]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d3), psi + 2 * (I + d1 + d3), add(tmp[5], add(mul(v[0], m[468], mt[468]), add(mul(v[1], m[469], mt[469]), add(mul(v[2], m[470], mt[470]), mul(v[3], m[471], mt[471]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2 + d3), psi + 2 * (I + d2 + d3), add(tmp[6], add(mul(v[0], m[472], mt[472]), add(mul(v[1], m[473], mt[473]), add(mul(v[2], m[474], mt[474]), mul(v[3], m[475], mt[475]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2 + d3), psi + 2 * (I + d1 + d2 + d3), add(tmp[7], add(mul(v[0], m[476], mt[476]), add(mul(v[1], m[477], mt[477]), add(mul(v[2], m[478], mt[478]), mul(v[3], m[479], mt[479]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d4), psi + 2 * (I + d4), add(tmp[8], add(mul(v[0], m[480], mt[480]), add(mul(v[1], m[481], mt[481]), add(mul(v[2], m[482], mt[482]), mul(v[3], m[483], mt[483]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d4), psi + 2 * (I + d1 + d4), add(tmp[9], add(mul(v[0], m[484], mt[484]), add(mul(v[1], m[485], mt[485]), add(mul(v[2], m[486], mt[486]), mul(v[3], m[487], mt[487]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2 + d4), psi + 2 * (I + d2 + d4), add(tmp[10], add(mul(v[0], m[488], mt[488]), add(mul(v[1], m[489], mt[489]), add(mul(v[2], m[490], mt[490]), mul(v[3], m[491], mt[491]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2 + d4), psi + 2 * (I + d1 + d2 + d4), add(tmp[11], add(mul(v[0], m[492], mt[492]), add(mul(v[1], m[493], mt[493]), add(mul(v[2], m[494], mt[494]), mul(v[3], m[495], mt[495]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d3 + d4), psi + 2 * (I + d3 + d4), add(tmp[12], add(mul(v[0], m[496], mt[496]), add(mul(v[1], m[497], mt[497]), add(mul(v[2], m[498], mt[498]), mul(v[3], m[499], mt[499]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d3 + d4), psi + 2 * (I + d1 + d3 + d4), add(tmp[13], add(mul(v[0], m[500], mt[500]), add(mul(v[1], m[501], mt[501]), add(mul(v[2], m[502], mt[502]), mul(v[3], m[503], mt[503]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2 + d3 + d4), psi + 2 * (I + d2 + d3 + d4), add(tmp[14], add(mul(v[0], m[504], mt[504]), add(mul(v[1], m[505], mt[505]), add(mul(v[2], m[506], mt[506]), mul(v[3], m[507], mt[507]))))));
+ _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2 + d3 + d4), psi + 2 * (I + d1 + d2 + d3 + d4), add(tmp[15], add(mul(v[0], m[508], mt[508]), add(mul(v[1], m[509], mt[509]), add(mul(v[2], m[510], mt[510]), mul(v[3], m[511], mt[511]))))));
}
// bit indices id[.] are given from high to low (e.g. control first for CNOT)
template <class V, class M>
-void kernel(V &psi, unsigned id4, unsigned id3, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask)
+void kernel(V &psi, unsigned id4, unsigned id3, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)
{
- std::size_t n = psi.size();
+ std::size_t n = len;
std::size_t d0 = 1UL << id0;
std::size_t d1 = 1UL << id1;
std::size_t d2 = 1UL << id2;
diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/simulator.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/simulator.hpp
--- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/simulator.hpp 2020-06-05 21:07:57.000000000 +0800
+++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/simulator.hpp 2021-04-20 11:46:27.115554725 +0800
@@ -18,11 +18,7 @@
#include <vector>
#include <complex>
-#if defined(NOINTRIN) || !defined(INTRIN)
-#include "nointrin/kernels.hpp"
-#else
#include "intrin/kernels.hpp"
-#endif
#include "intrin/alignedallocator.hpp"
#include "fusion.hpp"
@@ -32,173 +28,29 @@
#include <tuple>
#include <random>
#include <functional>
-
+#include <cstring>
class Simulator{
public:
using calc_type = double;
using complex_type = std::complex<calc_type>;
- using StateVector = std::vector<complex_type, aligned_allocator<complex_type,512>>;
+ using StateVector = calc_type *;
using Map = std::map<unsigned, unsigned>;
using RndEngine = std::mt19937;
using Term = std::vector<std::pair<unsigned, char>>;
using TermsDict = std::vector<std::pair<Term, calc_type>>;
using ComplexTermsDict = std::vector<std::pair<Term, complex_type>>;
+ StateVector vec_;
- Simulator(unsigned seed = 1) : N_(0), vec_(1,0.), fusion_qubits_min_(4),
+ Simulator(unsigned seed = 1, unsigned N = 0) : N_(N), fusion_qubits_min_(4),
fusion_qubits_max_(5), rnd_eng_(seed) {
+ len_ = 1UL << (N_ + 1);
+ vec_ = (StateVector)calloc(len_, sizeof(calc_type));
vec_[0]=1.; // all-zero initial state
std::uniform_real_distribution<double> dist(0., 1.);
rng_ = std::bind(dist, std::ref(rnd_eng_));
- }
-
- void allocate_qubit(unsigned id){
- if (map_.count(id) == 0){
- map_[id] = N_++;
- StateVector newvec; // avoid large memory allocations
- if( tmpBuff1_.capacity() >= (1UL << N_) )
- std::swap(newvec, tmpBuff1_);
- newvec.resize(1UL << N_);
-#pragma omp parallel for schedule(static)
- for (std::size_t i = 0; i < newvec.size(); ++i)
- newvec[i] = (i < vec_.size())?vec_[i]:0.;
- std::swap(vec_, newvec);
- // recycle large memory
- std::swap(tmpBuff1_, newvec);
- if( tmpBuff1_.capacity() < tmpBuff2_.capacity() )
- std::swap(tmpBuff1_, tmpBuff2_);
- }
- else
- throw(std::runtime_error(
- "AllocateQubit: ID already exists. Qubit IDs should be unique."));
- }
-
- bool get_classical_value(unsigned id, calc_type tol = 1.e-12){
- run();
- unsigned pos = map_[id];
- std::size_t delta = (1UL << pos);
-
- for (std::size_t i = 0; i < vec_.size(); i += 2*delta){
- for (std::size_t j = 0; j < delta; ++j){
- if (std::norm(vec_[i+j]) > tol)
- return false;
- if (std::norm(vec_[i+j+delta]) > tol)
- return true;
- }
- }
- assert(false); // this will never happen
- return false; // suppress 'control reaches end of non-void...'
- }
-
- bool is_classical(unsigned id, calc_type tol = 1.e-12){
- run();
- unsigned pos = map_[id];
- std::size_t delta = (1UL << pos);
-
- short up = 0, down = 0;
- #pragma omp parallel for schedule(static) reduction(|:up,down)
- for (std::size_t i = 0; i < vec_.size(); i += 2*delta){
- for (std::size_t j = 0; j < delta; ++j){
- up = up | ((std::norm(vec_[i+j]) > tol)&1);
- down = down | ((std::norm(vec_[i+j+delta]) > tol)&1);
- }
- }
-
- return 1 == (up^down);
- }
-
- void collapse_vector(unsigned id, bool value = false, bool shrink = false){
- run();
- unsigned pos = map_[id];
- std::size_t delta = (1UL << pos);
-
- if (!shrink){
- #pragma omp parallel for schedule(static)
- for (std::size_t i = 0; i < vec_.size(); i += 2*delta){
- for (std::size_t j = 0; j < delta; ++j)
- vec_[i+j+static_cast<std::size_t>(!value)*delta] = 0.;
- }
- }
- else{
- StateVector newvec; // avoid costly memory reallocations
- if( tmpBuff1_.capacity() >= (1UL << (N_-1)) )
- std::swap(tmpBuff1_, newvec);
- newvec.resize((1UL << (N_-1)));
- #pragma omp parallel for schedule(static) if(0)
- for (std::size_t i = 0; i < vec_.size(); i += 2*delta)
- std::copy_n(&vec_[i + static_cast<std::size_t>(value)*delta],
- delta, &newvec[i/2]);
- std::swap(vec_, newvec);
- std::swap(tmpBuff1_, newvec);
- if( tmpBuff1_.capacity() < tmpBuff2_.capacity() )
- std::swap(tmpBuff1_, tmpBuff2_);
-
- for (auto& p : map_){
- if (p.second > pos)
- p.second--;
- }
- map_.erase(id);
- N_--;
- }
- }
-
- void measure_qubits(std::vector<unsigned> const& ids, std::vector<bool> &res){
- run();
-
- std::vector<unsigned> positions(ids.size());
- for (unsigned i = 0; i < ids.size(); ++i)
- positions[i] = map_[ids[i]];
-
- calc_type P = 0.;
- calc_type rnd = rng_();
-
- // pick entry at random with probability |entry|^2
- std::size_t pick = 0;
- while (P < rnd && pick < vec_.size())
- P += std::norm(vec_[pick++]);
-
- pick--;
- // determine result vector (boolean values for each qubit)
- // and create mask to detect bad entries (i.e., entries that don't agree with measurement)
- res = std::vector<bool>(ids.size());
- std::size_t mask = 0;
- std::size_t val = 0;
- for (unsigned i = 0; i < ids.size(); ++i){
- bool r = ((pick >> positions[i]) & 1) == 1;
- res[i] = r;
- mask |= (1UL << positions[i]);
- val |= (static_cast<std::size_t>(r&1) << positions[i]);
- }
- // set bad entries to 0
- calc_type N = 0.;
- #pragma omp parallel for reduction(+:N) schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i){
- if ((i & mask) != val)
- vec_[i] = 0.;
- else
- N += std::norm(vec_[i]);
- }
- // re-normalize
- N = 1./std::sqrt(N);
- #pragma omp parallel for schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i)
- vec_[i] *= N;
- }
-
- std::vector<bool> measure_qubits_return(std::vector<unsigned> const& ids){
- std::vector<bool> ret;
- measure_qubits(ids, ret);
- return ret;
- }
-
- void deallocate_qubit(unsigned id){
- run();
- assert(map_.count(id) == 1);
- if (!is_classical(id))
- throw(std::runtime_error("Error: Qubit has not been measured / uncomputed! There is most likely a bug in your code."));
-
- bool value = get_classical_value(id);
- collapse_vector(id, value, true);
+ for (unsigned i = 0; i < N_; i++)
+ map_[i] = i;
}
template <class M>
@@ -221,84 +73,13 @@
fused_gates_ = fused_gates;
}
- template <class F, class QuReg>
- void emulate_math(F const& f, QuReg quregs, const std::vector<unsigned>& ctrl,
- bool parallelize = false){
- run();
- auto ctrlmask = get_control_mask(ctrl);
-
- for (unsigned i = 0; i < quregs.size(); ++i)
- for (unsigned j = 0; j < quregs[i].size(); ++j)
- quregs[i][j] = map_[quregs[i][j]];
-
- StateVector newvec; // avoid costly memory reallocations
- if( tmpBuff1_.capacity() >= vec_.size() )
- std::swap(newvec, tmpBuff1_);
- newvec.resize(vec_.size());
-#pragma omp parallel for schedule(static)
- for (std::size_t i = 0; i < vec_.size(); i++)
- newvec[i] = 0;
-
-//#pragma omp parallel reduction(+:newvec[:newvec.size()]) if(parallelize) // requires OpenMP 4.5
- {
- std::vector<int> res(quregs.size());
- //#pragma omp for schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i){
- if ((ctrlmask&i) == ctrlmask){
- for (unsigned qr_i = 0; qr_i < quregs.size(); ++qr_i){
- res[qr_i] = 0;
- for (unsigned qb_i = 0; qb_i < quregs[qr_i].size(); ++qb_i)
- res[qr_i] |= ((i >> quregs[qr_i][qb_i])&1) << qb_i;
- }
- f(res);
- auto new_i = i;
- for (unsigned qr_i = 0; qr_i < quregs.size(); ++qr_i){
- for (unsigned qb_i = 0; qb_i < quregs[qr_i].size(); ++qb_i){
- if (!(((new_i >> quregs[qr_i][qb_i])&1) == ((res[qr_i] >> qb_i)&1)))
- new_i ^= (1UL << quregs[qr_i][qb_i]);
- }
- }
- newvec[new_i] += vec_[i];
- }
- else
- newvec[i] += vec_[i];
- }
- }
- std::swap(vec_, newvec);
- std::swap(tmpBuff1_, newvec);
- }
-
- // faster version without calling python
- template<class QuReg>
- inline void emulate_math_addConstant(int a, const QuReg& quregs, const std::vector<unsigned>& ctrl)
- {
- emulate_math([a](std::vector<int> &res){for(auto& x: res) x = x + a;}, quregs, ctrl, true);
- }
-
- // faster version without calling python
- template<class QuReg>
- inline void emulate_math_addConstantModN(int a, int N, const QuReg& quregs, const std::vector<unsigned>& ctrl)
- {
- emulate_math([a,N](std::vector<int> &res){for(auto& x: res) x = (x + a) % N;}, quregs, ctrl, true);
- }
-
- // faster version without calling python
- template<class QuReg>
- inline void emulate_math_multiplyByConstantModN(int a, int N, const QuReg& quregs, const std::vector<unsigned>& ctrl)
- {
- emulate_math([a,N](std::vector<int> &res){for(auto& x: res) x = (x * a) % N;}, quregs, ctrl, true);
- }
-
calc_type get_expectation_value(TermsDict const& td, std::vector<unsigned> const& ids){
run();
calc_type expectation = 0.;
- StateVector current_state; // avoid costly memory reallocations
- if( tmpBuff1_.capacity() >= vec_.size() )
- std::swap(tmpBuff1_, current_state);
- current_state.resize(vec_.size());
+ StateVector current_state = (StateVector)malloc(len_ *sizeof(calc_type));
#pragma omp parallel for schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i)
+ for (std::size_t i = 0; i < len_; ++i)
current_state[i] = vec_[i];
for (auto const& term : td){
@@ -306,81 +87,53 @@
apply_term(term.first, ids, {});
calc_type delta = 0.;
#pragma omp parallel for reduction(+:delta) schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i){
- auto const a1 = std::real(current_state[i]);
- auto const b1 = -std::imag(current_state[i]);
- auto const a2 = std::real(vec_[i]);
- auto const b2 = std::imag(vec_[i]);
+ for (std::size_t i = 0; i < (len_ >> 1); ++i){
+ auto const a1 = current_state[2 * i];
+ auto const b1 = -current_state[2 * i + 1];
+ auto const a2 = vec_[2 * i];
+ auto const b2 = vec_[2 * i + 1];
delta += a1 * a2 - b1 * b2;
// reset vec_
- vec_[i] = current_state[i];
+ vec_[2 * i] = current_state[2 * i];
+ vec_[2 * i + 1] = current_state[2 * i + 1];
}
expectation += coefficient * delta;
}
- std::swap(current_state, tmpBuff1_);
+ if (NULL != current_state){
+ free(current_state);
+ current_state = NULL;
+ }
return expectation;
}
void apply_qubit_operator(ComplexTermsDict const& td, std::vector<unsigned> const& ids){
run();
- StateVector new_state, current_state; // avoid costly memory reallocations
- if( tmpBuff1_.capacity() >= vec_.size() )
- std::swap(tmpBuff1_, new_state);
- if( tmpBuff2_.capacity() >= vec_.size() )
- std::swap(tmpBuff2_, current_state);
- new_state.resize(vec_.size());
- current_state.resize(vec_.size());
+ StateVector new_state = (StateVector)calloc(len_, sizeof(calc_type));
+ StateVector current_state = (StateVector)malloc(len_ * sizeof(calc_type));
#pragma omp parallel for schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i){
- new_state[i] = 0;
+ for (std::size_t i = 0; i < len_; ++i){
current_state[i] = vec_[i];
}
for (auto const& term : td){
auto const& coefficient = term.second;
apply_term(term.first, ids, {});
#pragma omp parallel for schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i){
- new_state[i] += coefficient * vec_[i];
- vec_[i] = current_state[i];
+ for (std::size_t i = 0; i < (len_ >> 1); ++i){
+ new_state[2 * i] += coefficient.real() * vec_[2 * i] - coefficient.imag() * vec_[2 * i + 1];
+ new_state[2 * i + 1] += coefficient.real() * vec_[2 * i + 1] + coefficient.imag() * vec_[2 * i];
+ vec_[2 * i] = current_state[2 * i];
+ vec_[2 * i + 1] = current_state[2 * i + 1];
}
}
- std::swap(vec_, new_state);
- std::swap(tmpBuff1_, new_state);
- std::swap(tmpBuff2_, current_state);
- }
-
- calc_type get_probability(std::vector<bool> const& bit_string,
- std::vector<unsigned> const& ids){
- run();
- if (!check_ids(ids))
- throw(std::runtime_error("get_probability(): Unknown qubit id. Please make sure you have called eng.flush()."));
- std::size_t mask = 0, bit_str = 0;
- for (unsigned i = 0; i < ids.size(); ++i){
- mask |= 1UL << map_[ids[i]];
- bit_str |= (bit_string[i]?1UL:0UL) << map_[ids[i]];
- }
- calc_type probability = 0.;
- #pragma omp parallel for reduction(+:probability) schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i)
- if ((i & mask) == bit_str)
- probability += std::norm(vec_[i]);
- return probability;
- }
-
- complex_type const& get_amplitude(std::vector<bool> const& bit_string,
- std::vector<unsigned> const& ids){
- run();
- std::size_t chk = 0;
- std::size_t index = 0;
- for (unsigned i = 0; i < ids.size(); ++i){
- if (map_.count(ids[i]) == 0)
- break;
- chk |= 1UL << map_[ids[i]];
- index |= (bit_string[i]?1UL:0UL) << map_[ids[i]];
+ if (NULL != vec_)
+ free(vec_);
+ vec_ = new_state;
+ if (NULL != new_state)
+ new_state = NULL;
+ if (NULL != current_state){
+ free(current_state);
+ current_state = NULL;
}
- if (chk + 1 != vec_.size())
- throw(std::runtime_error("The second argument to get_amplitude() must be a permutation of all allocated qubits. Please make sure you have called eng.flush()."));
- return vec_[index];
}
void emulate_time_evolution(TermsDict const& tdict, calc_type const& time,
@@ -400,87 +153,71 @@
}
unsigned s = std::abs(time) * op_nrm + 1.;
complex_type correction = std::exp(-time * I * tr / (double)s);
- auto output_state = vec_;
+ auto output_state = copy(vec_, len_);
auto ctrlmask = get_control_mask(ctrl);
for (unsigned i = 0; i < s; ++i){
calc_type nrm_change = 1.;
for (unsigned k = 0; nrm_change > 1.e-12; ++k){
auto coeff = (-time * I) / double(s * (k + 1));
- auto current_state = vec_;
- auto update = StateVector(vec_.size(), 0.);
+ auto current_state = copy(vec_, len_);
+ auto update = (StateVector)calloc(len_, sizeof(calc_type));
for (auto const& tup : td){
apply_term(tup.first, ids, {});
#pragma omp parallel for schedule(static)
- for (std::size_t j = 0; j < vec_.size(); ++j){
+ for (std::size_t j = 0; j < len_; ++j){
update[j] += vec_[j] * tup.second;
vec_[j] = current_state[j];
}
}
nrm_change = 0.;
#pragma omp parallel for reduction(+:nrm_change) schedule(static)
- for (std::size_t j = 0; j < vec_.size(); ++j){
- update[j] *= coeff;
- vec_[j] = update[j];
+ for (std::size_t j = 0; j < (len_ >> 1); ++j){
+ complex_type tmp(update[2 * j], update[2 * j + 1]);
+ tmp *= coeff;
+ update[2 * j] *= std::real(tmp);
+ update[2 * j + 1] *= std::imag(tmp);
+ vec_[2 * j] = update[2 * j];
+ vec_[2 * j + 1] = update[2 * j + 1];
if ((j & ctrlmask) == ctrlmask){
- output_state[j] += update[j];
- nrm_change += std::norm(update[j]);
+ output_state[2 * j] += update[2 * j];
+ output_state[2 * j + 1] += update[2 * j + 1];
+ nrm_change += std::sqrt(update[2 * j] * update[2 * j] + update[2 * j + 1] * update[2 * j + 1]);
}
}
nrm_change = std::sqrt(nrm_change);
+ if (NULL != current_state){
+ free(current_state);
+ current_state = NULL;
+ }
+ if (NULL != update){
+ free(update);
+ update = NULL;
+ }
}
#pragma omp parallel for schedule(static)
- for (std::size_t j = 0; j < vec_.size(); ++j){
- if ((j & ctrlmask) == ctrlmask)
- output_state[j] *= correction;
- vec_[j] = output_state[j];
+ for (std::size_t j = 0; j < (len_ >>1); ++j){
+ if ((j & ctrlmask) == ctrlmask){
+ complex_type tmp(output_state[2 * j], output_state[2 * j + 1]);
+ tmp *= correction;
+ output_state[2 * j] = std::real(tmp);
+ output_state[2 * j + 1] =std::imag(tmp);
+ }
+ vec_[2 * j] = output_state[2 * j];
+ vec_[2 * j + 1] = output_state[2 * j + 1];
}
}
+ if (NULL != output_state){
+ free(output_state);
+ output_state = NULL;
+ }
}
void set_wavefunction(StateVector const& wavefunction, std::vector<unsigned> const& ordering){
run();
- // make sure there are 2^n amplitudes for n qubits
- assert(wavefunction.size() == (1UL << ordering.size()));
- // check that all qubits have been allocated previously
- if (map_.size() != ordering.size() || !check_ids(ordering))
- throw(std::runtime_error("set_wavefunction(): Invalid mapping provided. Please make sure all qubits have been allocated previously (call eng.flush())."));
-
- // set mapping and wavefunction
- for (unsigned i = 0; i < ordering.size(); ++i)
- map_[ordering[i]] = i;
- #pragma omp parallel for schedule(static)
- for (std::size_t i = 0; i < wavefunction.size(); ++i)
- vec_[i] = wavefunction[i];
- }
-
- void collapse_wavefunction(std::vector<unsigned> const& ids, std::vector<bool> const& values){
- run();
- assert(ids.size() == values.size());
- if (!check_ids(ids))
- throw(std::runtime_error("collapse_wavefunction(): Unknown qubit id(s) provided. Try calling eng.flush() before invoking this function."));
- std::size_t mask = 0, val = 0;
- for (unsigned i = 0; i < ids.size(); ++i){
- mask |= (1UL << map_[ids[i]]);
- val |= ((values[i]?1UL:0UL) << map_[ids[i]]);
- }
- // set bad entries to 0 and compute probability of outcome to renormalize
- calc_type N = 0.;
- #pragma omp parallel for reduction(+:N) schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i){
- if ((i & mask) == val)
- N += std::norm(vec_[i]);
- }
- if (N < 1.e-12)
- throw(std::runtime_error("collapse_wavefunction(): Invalid collapse! Probability is ~0."));
- // re-normalize (if possible)
- N = 1./std::sqrt(N);
- #pragma omp parallel for schedule(static)
- for (std::size_t i = 0; i < vec_.size(); ++i){
- if ((i & mask) != val)
- vec_[i] = 0.;
- else
- vec_[i] *= N;
+ if (NULL != vec_){
+ free(vec_);
}
+ vec_ = copy(wavefunction, len_);
}
void run(){
@@ -500,23 +237,23 @@
switch (ids.size()){
case 1:
#pragma omp parallel
- kernel(vec_, ids[0], m, ctrlmask);
+ kernel(vec_, ids[0], m, ctrlmask, len_ >> 1);
break;
case 2:
#pragma omp parallel
- kernel(vec_, ids[1], ids[0], m, ctrlmask);
+ kernel(vec_, ids[1], ids[0], m, ctrlmask, len_ >> 1);
break;
case 3:
#pragma omp parallel
- kernel(vec_, ids[2], ids[1], ids[0], m, ctrlmask);
+ kernel(vec_, ids[2], ids[1], ids[0], m, ctrlmask, len_ >> 1);
break;
case 4:
#pragma omp parallel
- kernel(vec_, ids[3], ids[2], ids[1], ids[0], m, ctrlmask);
+ kernel(vec_, ids[3], ids[2], ids[1], ids[0], m, ctrlmask, len_ >> 1);
break;
case 5:
#pragma omp parallel
- kernel(vec_, ids[4], ids[3], ids[2], ids[1], ids[0], m, ctrlmask);
+ kernel(vec_, ids[4], ids[3], ids[2], ids[1], ids[0], m, ctrlmask, len_ >> 1);
break;
default:
throw std::invalid_argument("Gates with more than 5 qubits are not supported!");
@@ -525,12 +262,27 @@
fused_gates_ = Fusion();
}
- std::tuple<Map, StateVector&> cheat(){
+ std::vector<complex_type> cheat(){
run();
- return make_tuple(map_, std::ref(vec_));
+ std::vector<complex_type> result;
+ for (unsigned int i = 0; i < (len_ >> 1); i++){
+ result.push_back({vec_[2 * i], vec_[2 * i + 1]});
+ }
+ return result;
+ }
+
+ inline StateVector copy(StateVector source, unsigned len){
+ StateVector result = (StateVector)malloc(len * sizeof(calc_type));
+#pragma omp parallel for schedule(static)
+ for (std::size_t i = 0; i < len; ++i) {
+ result[i] = source[i];
}
+ return result;
+}
~Simulator(){
+ if (NULL != vec_)
+ free(vec_);
}
private:
@@ -562,18 +314,13 @@
}
unsigned N_; // #qubits
- StateVector vec_;
+ unsigned len_;
Map map_;
Fusion fused_gates_;
unsigned fusion_qubits_min_, fusion_qubits_max_;
RndEngine rnd_eng_;
std::function<double()> rng_;
-
- // large array buffers to avoid costly reallocations
- static StateVector tmpBuff1_, tmpBuff2_;
};
-Simulator::StateVector Simulator::tmpBuff1_;
-Simulator::StateVector Simulator::tmpBuff2_;
#endif