mindquantum.core.parameterresolver

参数解析器模块，用于声明MindSpore Quantum中所使用到的参数。

class mindquantum.core.parameterresolver.ParameterResolver(data=None, const=None)

ParameterResolver可以设置参数化量子门或参数化量子线路的参数。

参数：

• data (Union[dict, numbers.Number, str, ParameterResolver]) - 初始参数名称及其值。如果数据是dict，则键将是参数名称，值将是参数值。如果数据是数字，则此数字将是此参数解析器的常量值。如果数据是字符串，则此字符串将是系数为1的唯一参数。默认值：None。

• const (number.Number) - 此参数解析器的常量部分。默认值：None。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver
>>> pr = ParameterResolver({'a': 0.3})
>>> pr['b'] = 0.5
>>> pr.no_grad_part('a')
{'a': 0.3, 'b': 0.5}, const: 0.0
>>> pr *= 2
>>> pr
{'a': 0.6, 'b': 1.0}, const: 0.0
>>> pr.expression()
'3/5*a + b'
>>> pr.const = 0.5
>>> pr.expression()
'3/5*a + b + 1/2'
>>> pr.no_grad_parameters
{'a'}
>>> ParameterResolver(3)
{}, const: 3.0
>>> ParameterResolver('a')
{'a': 1.0}, const: 0.0

property ansatz_parameters

获取参数，该参数是一个ansatz参数。

返回：

set，ansatz参数的集合。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> a = PR({'a': 1, 'b': 2})
>>> a.ansatz_parameters
{'a', 'b'}

ansatz_part(*names)

设置哪个部分是ansatz参数。

参数：

• names (tuple[str]) - 作为一个ansatz参数。

返回：

ParameterResolver，参数解析器本身。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.as_encoder()
>>> pr.ansatz_part('a')
>>> pr.ansatz_parameters
{'a'}

as_ansatz()

将所有参数设置为ansatz。

返回：

ParameterResolver，参数解析器。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR({'a': 1, 'b': 2})
>>> pr.as_encoder()
>>> pr.as_ansatz()
>>> pr.ansatz_parameters
{'a', 'b'}

as_encoder()

将所有参数设置为编码器。

返回：

ParameterResolver，参数解析器。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR({'a': 1, 'b': 2})
>>> pr.as_encoder()
>>> pr.encoder_parameters
{'a', 'b'}

combination(other)

将该参数解析器与输入的参数解析器进行线性组合。

参数：

• other (Union[dict, ParameterResolver]) - 需要做线性组合的参数解析器。

返回：

numbers.Number，组合结果。

样例：

>>> from mindquantum import ParameterResolver
>>> pr1 = ParameterResolver({'a': 1, 'b': 2})
>>> pr2 = ParameterResolver({'a': 2, 'b': 3})
>>> pr1.combination(pr2)
{}, const: 8.0

conjugate()

获取参数解析器的共轭。

返回：

ParameterResolver，参数解析器的共轭版本。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> import numpy as np
>>> pr = PR({'a' : 1, 'b': 1j}, dtype=np.complex128)
>>> pr.conjugate().expression()
'a + (-1j)*b'

property const

获取此参数解析器的常量部分。

返回：

numbers.Number，此参数解析器的常量部分。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR({'a': 1}, 2.5)
>>> pr.const
2.5

dumps(indent=4)

将参数解析器转储到JSON（JavaScript对象表示法）。

参数：

• indent (int) - 打印JSON数据时的缩进级别，利用缩进会使打印效果更加美观。默认值：4。

返回：

string(JSON)，参数解析器的JSON。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2}, const=3 + 4j, dtype=complex)
>>> pr.no_grad_part('a', 'b')
>>> print(pr.dumps())
{
    "pr_data": {
        "a": [
            1.0,
            0.0
        ],
        "b": [
            2.0,
            0.0
        ]
    },
    "const": [
        3.0,
        4.0
    ],
    "dtype": "complex",
    "no_grad_parameters": [
        "b",
        "a"
    ],
    "encoder_parameters": []
}

property encoder_parameters

获取所有encoder参数。

返回：

set，encoder参数构成的集合。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> a = PR({'a': 1, 'b': 2})
>>> a.as_encoder()
>>> a.encoder_parameters
{'a', 'b'}

encoder_part(*names)

设置哪一部分是编码器参数。

参数：

• names (tuple[str]) - 用作编码器的参数。

返回：

ParameterResolver，参数解析器本身。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.encoder_part('a')
{'a': 1.0, 'b': 2.0}, const: 0.0
>>> pr.encoder_parameters
{'a'}

expression()

获取此参数解析器的表达式字符串。

返回：

str，此参数解析器的字符串表达式。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> import numpy as np
>>> pr = PR({'a': np.pi}, np.sqrt(2))
>>> pr.expression()
'π*a + √2'

get_cpp_obj()

返回此参数解析器的c++对象。

property imag

获取每个参数值的虚部构成的参数解析器。

返回：

ParameterResolver，参数解析器的虚部。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR('a', 3) + 1j * PR('a', 4)
>>> pr
{'a': (1+1j)}, const: (3+4j)
>>> pr.imag
{'a': 1.0}, const: 4.0

is_anti_hermitian()

检查该参数解析器的参数值是否为反厄米。

返回：

bool，参数解析器是否为反厄米。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR({'a': 1})
>>> pr.is_anti_hermitian()
False
>>> (pr + 3).is_anti_hermitian()
False
>>> (pr*1j).is_anti_hermitian()
True

is_complex()

返回此参数解析器实例当前是否正在使用复数系数。

is_const()

检查此参数解析器是否表示常量，这意味着此参数解析器中没有具有非零系数的参数。

返回：

bool，此参数解析器是否表示常量。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR(1.0)
>>> pr.is_const()
True

is_hermitian()

检查该参数解析器的参数值是否为厄米的。

返回：

bool，参数解析器是否为厄米的。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR({'a': 1})
>>> pr.is_hermitian()
True
>>> (pr + 3).is_hermitian()
True
>>> (pr * 1j).is_hermitian()
False

items()

生成所有参数的名称和值的迭代器。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> a = PR({'a': 0, 'b': 1})
>>> list(a.items())
[('a', 0.0), ('b', 1.0)]

keys()

生成所有参数名称的迭代器。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> a = PR({'a': 0, 'b': 1})
>>> list(a.keys())
['a', 'b']

static loads(strs)

将JSON（JavaScript对象表示法）加载到FermionOperator中。

参数：

• strs (str) - 转储参数解析器字符串。

返回：

FermionOperator，从字符串加载的FermionOperator。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver
>>> ori = ParameterResolver({'a': 1, 'b': 2, 'c': 3, 'd': 4})
>>> ori.no_grad_part('a', 'b')
>>> string = ori.dumps()
>>> obj = ParameterResolver.loads(string)
>>> print(obj)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}, const: 0
>>> print('requires_grad_parameters is:', obj.requires_grad_parameters)
requires_grad_parameters is: {'c', 'd'}
>>> print('no_grad_parameters is :', obj.no_grad_parameters)
no_grad_parameters is : {'b', 'a'}

no_grad()

将所有参数设置为不需要计算梯度。该操作为原地操作。

返回：

ParameterResolver，参数解析器本身。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.no_grad()
{'a': 1.0, 'b': 2.0}, const: 0.0
>>> pr.requires_grad_parameters
set()

property no_grad_parameters

获取不需要计算梯度的参数。

返回：

set，不需要计算梯度的参数集合。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> a = PR({'a': 1, 'b': 2})
>>> a.no_grad()
>>> a.no_grad_parameters
{'a', 'b'}

no_grad_part(*names)

设置不需要梯度的部分参数。

参数：

• names (tuple[str]) - 不需要计算梯度的参数。

返回：

ParameterResolver，参数解析器本身。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.no_grad_part('a')
{'a': 1.0, 'b': 2.0}, const: 0.0
>>> pr.requires_grad_parameters
{'b'}

property para_value

获取参数值。

返回：

list，参数值的列表。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.para_value
[1, 2]

property params_name

获取参数名称。

返回：

list，参数名称的列表。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.params_name
['a', 'b']

pop(v)

弹出参数。

参数：

• v (str) - 想要弹出的参数名称。

返回：

numbers.Number，弹出的参数值。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> a = PR({'a': 1, 'b': 2})
>>> a.pop('a')
1.0

property real

获取每个参数值的实部。

返回：

ParameterResolver，参数值的实部。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR('a', 3) + 1j * PR('a', 4)
>>> pr
{'a': (1+1j)}, const: (3+4j)
>>> pr.real
{'a': 1.0}, const: 3.0

requires_grad()

将此参数解析器的所有参数设置为需要进行梯度计算。该操作为原地操作。

返回：

ParameterResolver，参数解析器本身。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.no_grad_part('a')
{'a': 1.0, 'b': 2.0}, const: 0.0
>>> pr.requires_grad()
{'a': 1.0, 'b': 2.0}, const: 0.0
>>> pr.requires_grad_parameters
{'a', 'b'}

property requires_grad_parameters

获取需要梯度的参数。

返回：

set，需要计算梯度的参数集合。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> a = PR({'a': 1, 'b': 2})
>>> a.requires_grad_parameters
{'a', 'b'}

requires_grad_part(*names)

设置部分需要计算梯度的参数。该操作为原地操作。

参数：

• names (tuple[str]) - 需要梯度的参数。

返回：

ParameterResolver，参数解析器本身。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.no_grad()
{'a': 1.0, 'b': 2.0}, const: 0.0
>>> pr.requires_grad_part('a')
{'a': 1.0, 'b': 2.0}, const: 0.0
>>> pr.requires_grad_parameters
{'a'}

to_real_obj()

转化为实数类型。

update(other)

使用其它参数解析器更新此参数解析器。

参数：

• other (ParameterResolver) - 其它参数解析器。

异常：

• ValueError - 如果某些参数需要grad而在其它参数解析器中不需要grad，反之亦然，某些参数是编码器参数而在其它参数解析器中不是编码器。

样例：

>>> from mindquantum import ParameterResolver
>>> pr1 = ParameterResolver({'a': 1})
>>> pr2 = ParameterResolver({'b': 2})
>>> pr2.no_grad()
{'b': 2.0}, const: 0.0
>>> pr1.update(pr2)
>>> pr1
{'a': 1.0, 'b': 2.0}, const: 0.0
>>> pr1.no_grad_parameters
{'b'}

values()

生成所有参数值的迭代器。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> a = PR({'a': 0, 'b': 1})
>>> list(a.values())
[0.0, 1.0]