diff --git a/mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/evolution_cpu_kernel.cc b/mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/evolution_cpu_kernel.cc new file mode 100644 index 0000000000..0b434baec4 --- /dev/null +++ b/mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/evolution_cpu_kernel.cc @@ -0,0 +1,95 @@ +/** + * 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 +#include +#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(kernel_node, mindquantum::kNQubits); + param_names_ = AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kParamNames); + gate_names_ = AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kGateNames); + gate_matrix_ = + AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kGateMatrix); + gate_obj_qubits_ = AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kGateObjQubits); + gate_ctrl_qubits_ = + AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kGateCtrlQubits); + gate_params_names_ = + AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kGateParamsNames); + gate_coeff_ = AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kGateCoeff); + gate_requires_grad_ = + AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kGateRequiresGrad); + hams_pauli_coeff_ = + AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kHamsPauliCoeff); + hams_pauli_word_ = + AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kHamsPauliWord); + hams_pauli_qubit_ = + AnfAlgo::GetNodeAttr(kernel_node, mindquantum::kHamsPauliQubit); +} + +void EvolutionCPUKernel::InitKernel(const CNodePtr &kernel_node) { + MS_EXCEPTION_IF_NULL(kernel_node); + std::vector param_shape = AnfAlgo::GetInputDeviceShape(kernel_node, 0); + std::vector 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 &inputs, + const std::vector & /*workspace*/, + const std::vector &outputs) { + if (inputs.size() != 1 || outputs.size() != 1) { + MS_LOG(EXCEPTION) << "evolution error input output size!"; + } + auto param_data = reinterpret_cast(inputs[0]->addr); + auto output = reinterpret_cast(outputs[0]->addr); + MS_EXCEPTION_IF_NULL(param_data); + MS_EXCEPTION_IF_NULL(output); + 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_ != sim_.vec_.size()) { + MS_LOG(EXCEPTION) << "simulation error number of quantum qubit!"; + } + size_t poi = 0; + for (auto &v : sim_.vec_) { + output[poi++] = v.real(); + output[poi++] = v.imag(); + } + return true; +} +} // namespace kernel +} // namespace mindspore diff --git a/mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/evolution_cpu_kernel.h b/mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/evolution_cpu_kernel.h new file mode 100644 index 0000000000..4a553aa459 --- /dev/null +++ b/mindspore/ccsrc/backend/kernel_compiler/cpu/quantum/evolution_cpu_kernel.h @@ -0,0 +1,68 @@ +/** + * 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 +#include "backend/kernel_compiler/cpu/cpu_kernel.h" +#include "backend/kernel_compiler/cpu/cpu_kernel_factory.h" +#include "mindquantum/pqc_simulator.h" +#include "mindquantum/transformer.h" +#include "mindquantum/circuit.h" +#include "mindquantum/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 &inputs, const std::vector &workspace, + const std::vector &outputs) override; + + void InitPQCStructure(const CNodePtr &kernel_node); + + private: + int64_t n_qubits_; + size_t state_len_; + mindquantum::PQCSimulator sim_; + 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_ diff --git a/mindspore/ccsrc/mindquantum/utils.h b/mindspore/ccsrc/mindquantum/utils.h index 08849b6e47..326d32afa7 100644 --- a/mindspore/ccsrc/mindquantum/utils.h +++ b/mindspore/ccsrc/mindquantum/utils.h @@ -39,6 +39,7 @@ ComplexType ComplexInnerProductWithControl(const Simulator::StateVector &, const 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"; diff --git a/mindspore/ops/operations/__init__.py b/mindspore/ops/operations/__init__.py index ae3134358f..16631667ab 100644 --- a/mindspore/ops/operations/__init__.py +++ b/mindspore/ops/operations/__init__.py @@ -98,7 +98,7 @@ from .sparse_ops import SparseToDense from ._embedding_cache_ops import (CacheSwapHashmap, SearchCacheIdx, CacheSwapTable, UpdateCache, MapCacheIdx, SubAndFilter, MapUniform, DynamicAssign, PadAndShift) -from .quantum_ops import PQC +from .quantum_ops import PQC, Evolution from .sponge_ops import (BondForce, BondEnergy, BondAtomEnergy, BondForceWithAtomEnergy, BondForceWithAtomVirial, DihedralForce, DihedralEnergy, DihedralAtomEnergy, DihedralForceWithAtomEnergy, AngleForce, AngleEnergy, AngleAtomEnergy, AngleForceWithAtomEnergy) @@ -424,6 +424,7 @@ __all__ = [ "Range", "IndexAdd", "PQC", + "Evolution", "BondForce", "BondEnergy", "BondAtomEnergy", diff --git a/mindspore/ops/operations/quantum_ops.py b/mindspore/ops/operations/quantum_ops.py index 8eeca55244..485f86bb87 100644 --- a/mindspore/ops/operations/quantum_ops.py +++ b/mindspore/ops/operations/quantum_ops.py @@ -85,3 +85,54 @@ equal to 1, but got {}.".format(len(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 eqch 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 Evolutino""" + 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("PQC input param_data should have dimension size \ +equal to 1, but got {}.".format(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 diff --git a/tests/ut/python/ops/test_ops.py b/tests/ut/python/ops/test_ops.py index d525262046..5310e26b0d 100755 --- a/tests/ut/python/ops/test_ops.py +++ b/tests/ut/python/ops/test_ops.py @@ -2806,6 +2806,30 @@ test_case_quantum_ops = [ '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,