mindquantum.core.parameterresolver.ParameterResolver

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

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

参数：

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

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

• dtype (mindquantum.dtype) - 改参数解析器的数据类型。默认： None。

• internal (bool) - 第一个参数是否时参数解析器的c++对象。默认： False。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver
>>> pr = ParameterResolver({'a': 0.3})
>>> pr['b'] = 0.5
>>> pr.no_grad_part('a')
ParameterResolver(dtype: float64,
data: [
        a: 0.300000,
        b: 0.500000
],
const: 0.000000,
no grad parameters: {a, }
)
>>> pr *= 2
>>> pr
ParameterResolver(dtype: float64,
data: [
        a: 0.600000,
        b: 1.000000
],
const: 0.000000,
no grad parameters: {a, }
)
>>> pr.expression()
'0.6*a + b'
>>> pr.const = 0.5
>>> pr.expression()
'0.6*a + b + 1/2'
>>> pr.no_grad_parameters
['a']
>>> ParameterResolver(3)
ParameterResolver(dtype: float64, const: 3.000000)
>>> ParameterResolver('a')
ParameterResolver(dtype: float64,
data: [
        a: 1.000000
],
const: 0.000000
)

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
['b', 'a']

astype(dtype)

将参数解析器转变为其他数据类型。

参数：

• dtype (mindquantum.dtype) - 参数解析器的新的数据类型。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver
>>> a = ParameterResolver('a')
>>> a
ParameterResolver(dtype: float64,
data: [
        a: 1.000000
],
const: 0.000000
)
>>> import mindquantum as mq
>>> a.astype(mq.complex128)
ParameterResolver(dtype: complex128,
data: [
        a: (1.000000, 0.000000)
],
const: (0.000000, 0.000000)
)

combination(other: Union[Dict[str, numbers.Number], 'ParameterResolver'])

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

参数：

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

返回：

numbers.Number，组合结果。

样例：

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

conjugate()

获取参数解析器的共轭。

返回：

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

样例：

>>> import mindquantum as mq
>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR({'a' : 1, 'b': 1j}, dtype=mq.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

property dtype

获取参数解析器的数据类型。

dumps(indent=4)

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

说明

由于float32类型的数据不能够序列化，因此 mindquantum.float32 和 mindquantum.complex64 类型的参数解析器也不能够被序列化。

参数：

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

返回：

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

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2}, const=3 + 4j)
>>> 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": "mindquantum.complex128",
    "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
['b', 'a']

encoder_part(*names)

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

参数：

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

返回：

ParameterResolver，参数解析器本身。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.encoder_part('a')
ParameterResolver(dtype: float64,
data: [
        a: 1.000000,
        b: 2.000000
],
const: 0.000000,
encoder parameters: {a, }
)
>>> 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'

property imag

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

返回：

ParameterResolver，参数解析器的虚部。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> pr = PR('a', 3) + 1j * PR('a', 4)
>>> pr
ParameterResolver(dtype: complex128,
data: [
        a: (1.000000, 1.000000)
],
const: (3.000000, 4.000000)
)
>>> pr.imag
ParameterResolver(dtype: float64,
data: [
        a: 1.000000
],
const: 4.000000
)

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

property 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: str)

将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 + 2*b + 3*c + 4*d
>>> 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()
ParameterResolver(dtype: float64,
data: [
        a: 1.000000,
        b: 2.000000
],
const: 0.000000,
no grad parameters: {a, b}
)
>>> pr.requires_grad_parameters
[]

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
['b', 'a']

no_grad_part(*names)

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

参数：

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

返回：

ParameterResolver，参数解析器本身。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.no_grad_part('a')
ParameterResolver(dtype: float64,
data: [
        a: 1.000000,
        b: 2.000000
],
const: 0.000000,
no grad parameters: {a, }
)
>>> pr.requires_grad_parameters
['b']

property params_name

获取参数名称。

返回：

list，参数名称的列表。

样例：

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

property params_value

获取参数值。

返回：

list，参数值的列表。

样例：

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

pop(v: str)

弹出参数。

参数：

• 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
ParameterResolver(dtype: complex128,
data: [
        a: (1.000000, 1.000000)
],
const: (3.000000, 4.000000)
)
>>> pr.real
ParameterResolver(dtype: float64,
data: [
        a: 1.000000
],
const: 3.000000
)

requires_grad()

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

返回：

ParameterResolver，参数解析器本身。

样例：

>>> from mindquantum import ParameterResolver
>>> pr = ParameterResolver({'a': 1, 'b': 2})
>>> pr.no_grad_part('a')
ParameterResolver(dtype: float64,
data: [
        a: 1.000000,
        b: 2.000000
],
const: 0.000000,
no grad parameters: {a, }
)
>>> pr.requires_grad()
ParameterResolver(dtype: float64,
data: [
        a: 1.000000,
        b: 2.000000
],
const: 0.000000
)
>>> 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()
ParameterResolver(dtype: float64,
data: [
        a: 1.000000,
        b: 2.000000
],
const: 0.000000,
no grad parameters: {a, b}
)
>>> pr.requires_grad_part('a')
ParameterResolver(dtype: float64,
data: [
        a: 1.000000,
        b: 2.000000
],
const: 0.000000,
no grad parameters: {b, }
)
>>> pr.requires_grad_parameters
['a']

subs(other: Union['ParameterResolver', Dict[str, numbers.Number]])

将变量的参数值带入参数解析器。

参数：

• other (Union[ParameterResolver, Dict[str, numbers.Number]]) - 参数解析器中的变量的值。

样例：

>>> from mindquantum.core.parameterresolver import ParameterResolver as PR
>>> a = PR({'a': 1.2, 'b': 2}, 3.4)
>>> a.expression()
'1.2*a + 2*b + 3.4'
>>> a.subs({'a': 0.3})
>>> a.expression()
'2*b + 3.76'

to_real_obj()

转化为实数类型。

update(other: 'ParameterResolver')

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

参数：

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

异常：

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

样例：

>>> from mindquantum import ParameterResolver
>>> pr1 = ParameterResolver({'a': 1})
>>> pr2 = ParameterResolver({'b': 2})
>>> pr2.no_grad()
ParameterResolver(dtype: float64,
data: [
        b: 2.000000
],
const: 0.000000,
no grad parameters: {b}
)
>>> pr1.update(pr2)
>>> pr1
ParameterResolver(dtype: float64,
data: [
        a: 1.000000,
        b: 2.000000
],
const: 0.000000,
no grad parameters: {b, }
)
>>> 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]