经典神经网络模块¶
基本例子¶
CPU下模型训练¶
以下的经典神经网络模块均支持自动反向传播计算。当您运行前传函数以后,再执行反向函数就可以计算梯度。一个卷积层的简单例子如下:
from pyvqnet.tensor import arange
from pyvqnet import kfloat32
from pyvqnet.nn import Conv2D
# an image feed into two dimension convolution layer
b = 2 # batch size
ic = 2 # input channels
oc = 2 # output channels
hw = 4 # input width and heights
# two dimension convolution layer
test_conv = Conv2D(ic,oc,(2,2),(2,2),"same")
# input of shape [b,ic,hw,hw]
x0 = arange(1,b*ic*hw*hw+1,requires_grad=True,dtype=kfloat32)
x1 = x0.reshape([b,ic,hw,hw])
#forward function
y = test_conv(x1)
#backward function with autograd
y.backward()
print(x0.grad)
# [-0.0008376 -0.2780731 -0.0008376 -0.2780731 0.1125833 0.2805848
# 0.1125833 0.2805848 -0.0008376 -0.2780731 -0.0008376 -0.2780731
# 0.1125833 0.2805848 0.1125833 0.2805848 0.5759128 -0.057339
# 0.5759128 -0.057339 -0.342508 -0.4853693 -0.342508 -0.4853693
# 0.5759128 -0.057339 0.5759128 -0.057339 -0.342508 -0.4853693
# -0.342508 -0.4853693 -0.0008376 -0.2780731 -0.0008376 -0.2780731
# 0.1125833 0.2805848 0.1125833 0.2805848 -0.0008376 -0.2780731
# -0.0008376 -0.2780731 0.1125833 0.2805848 0.1125833 0.2805848
# 0.5759128 -0.057339 0.5759128 -0.057339 -0.342508 -0.4853693
# -0.342508 -0.4853693 0.5759128 -0.057339 0.5759128 -0.057339
# -0.342508 -0.4853693 -0.342508 -0.4853693]
GPU下模型训练¶
您需要安装linux版本下的pyvqnet才能使用GPU。需要保证数据QTensor以及Module均在GPU上。可使用 toGPU 转移数据或者 gpu 创建副本,或者在数据创建函数中使用device指定。
请参考以下例子:
from pyvqnet.tensor import arange
from pyvqnet import kfloat32,DEV_GPU_0
from pyvqnet.nn import Conv2D
b = 2 # batch size
ic = 2 # input channels
oc = 2 # output channels
hw = 4 # input width and heights
test_conv = Conv2D(ic,oc,(2,2),(2,2),"same")
#复制到gpu上DEV_GPU_0
test_conv.toGPU(DEV_GPU_0)
# input of shape [b,ic,hw,hw]
x0 = arange(1,b*ic*hw*hw+1,requires_grad=True,dtype=kfloat32).reshape([b,ic,hw,hw])
#使用gpu 复制数据到DEV_GPU_0,亦可以在函数内指定ID,也可以使用相关tensor接口的device进行指定
x0 = x0.GPU(DEV_GPU_0)
x0.requires_grad = True
#forward function
x = test_conv(x0)
#backward function with autograd
x.backward()
print(x0.grad)
Module类¶
abstract calculation module
Module¶
- class pyvqnet.nn.module.Module¶
所有神经网络模块的基类,包括量子模块或经典模块。您的模型也应该是此类的子类,用于 autograd 计算。 模块还可以包含其他Module类,允许将它们嵌套在树状结构。 您可以将子模块分配为常规属性:
class Model(Module): def __init__(self): super(Model, self).__init__() self.conv1 = pyvqnet.nn.Conv2d(1, 20, (5,5)) self.conv2 = pyvqnet.nn.Conv2d(20, 20, (5,5)) def forward(self, x): x = pyvqnet.nn.activation.relu(self.conv1(x)) return pyvqnet.nn.activation.relu(self.conv2(x))
以这种方式分配的子模块将被注册。
forward¶
- pyvqnet.nn.module.Module.forward(x, *args, **kwargs)¶
Module类抽象前向计算函数
- Parameters:
x – 输入QTensor。
*args – 非关键字可变参数。
**kwargs – 关键字可变参数。
- Returns:
模型输出。
Example:
import numpy as np from pyvqnet.tensor import QTensor import pyvqnet as vq from pyvqnet.nn import Conv2D b = 2 ic = 3 oc = 2 test_conv = Conv2D(ic, oc, (3, 3), (2, 2), "same") x0 = QTensor(np.arange(1, b * ic * 5 * 5 + 1).reshape([b, ic, 5, 5]), requires_grad=True, dtype=vq.kfloat32) x = test_conv.forward(x0) print(x) # [ # [[[4.3995643, 3.9317808, -2.0707254], # [20.1951981, 21.6946659, 14.2591858], # [38.4702759, 31.9730244, 24.5977650]], # [[-17.0607567, -31.5377998, -7.5618000], # [-22.5664024, -40.3876266, -15.1564388], # [-3.1080279, -18.5986233, -8.0648050]]], # [[[6.6493244, -13.4840755, -20.2554188], # [54.4235802, 34.4462433, 26.8171902], # [90.2827682, 62.9092331, 51.6892929]], # [[-22.3385429, -45.2448578, 5.7101378], # [-32.9464149, -60.9557228, -10.4994345], # [5.9029331, -20.5480480, -0.9379558]]] # ]
state_dict¶
- pyvqnet.nn.module.Module.state_dict(destination=None, prefix='')¶
返回包含模块整个状态的字典:包括参数和缓存值。 键是对应的参数和缓存值名称。
- Parameters:
destination – 返回保存模型内部模块,参数的字典。
prefix – 使用的参数和缓存值的命名前缀。
- Returns:
包含模块整个状态的字典。
Example:
from pyvqnet.nn import Conv2D test_conv = Conv2D(2,3,(3,3),(2,2),"same") print(test_conv.state_dict().keys()) #odict_keys(['weights', 'bias'])
toGPU¶
- pyvqnet.nn.module.Module.toGPU(device: int = DEV_GPU_0)¶
将模块和其子模块的参数和缓冲数据移动到指定的 GPU 设备中。
device 指定存储其内部数据的设备。 当device >= DEV_GPU_0时,数据存储在GPU上。如果您的计算机有多个GPU, 则可以指定不同的设备来存储数据。例如device = DEV_GPU_1 , DEV_GPU_2, DEV_GPU_3, … 表示存储在不同序列号的GPU上。
Note
Module在不同GPU上无法进行计算。 如果您尝试在 ID 超过验证 GPU 最大数量的 GPU 上创建 QTensor,将引发 Cuda 错误。
- Parameters:
device – 当前保存QTensor的设备,默认=DEV_GPU_0。device= pyvqnet.DEV_GPU_0,存储在第一个 GPU 中,devcie = DEV_GPU_1,存储在第二个 GPU 中,依此类推
- Returns:
Module 移动到 GPU 设备。
Examples:
from pyvqnet.nn.conv import ConvT2D test_conv = ConvT2D(3, 2, [4,4], [2, 2], "same") test_conv = test_conv.toGPU() print(test_conv.backend) #1000
toCPU¶
- pyvqnet.nn.module.Module.toCPU()¶
将模块和其子模块的参数和缓冲数据移动到特定的 CPU 设备中。
- Returns:
Module 移动到 CPU 设备。
Examples:
from pyvqnet.nn.conv import ConvT2D test_conv = ConvT2D(3, 2, [4,4], [2, 2], "same") test_conv = test_conv.toCPU() print(test_conv.backend) #0
模型参数保存和载入¶
以下接口可以进行模型参数保存到文件中,或从文件中读取参数文件。但请注意,文件中不保存模型结构,需要用户手动构建模型结构。
save_parameters¶
- pyvqnet.utils.storage.save_parameters(obj, f)¶
保存模型参数的字典到一个文件。
- Parameters:
obj – 需要保存的字典。
f – 保存参数的文件名。
- Returns:
无。
Example:
from pyvqnet.nn import Module,Conv2D import pyvqnet class Net(Module): def __init__(self): super(Net, self).__init__() self.conv1 = Conv2D(input_channels=1, output_channels=6, kernel_size=(5, 5), stride=(1, 1), padding="valid") def forward(self, x): return super().forward(x) model = Net() pyvqnet.utils.storage.save_parameters(model.state_dict(),"tmp.model")
load_parameters¶
- pyvqnet.utils.storage.load_parameters(f)¶
从文件中载入参数到一个字典中。
- Parameters:
f – 保存参数的文件名。
- Returns:
保存参数的字典。
Example:
from pyvqnet.nn import Module, Conv2D import pyvqnet class Net(Module): def __init__(self): super(Net, self).__init__() self.conv1 = Conv2D(input_channels=1, output_channels=6, kernel_size=(5, 5), stride=(1, 1), padding="valid") def forward(self, x): return super().forward(x) model = Net() model1 = Net() # another Module object pyvqnet.utils.storage.save_parameters(model.state_dict(), "tmp.model") model_para = pyvqnet.utils.storage.load_parameters("tmp.model") model1.load_state_dict(model_para)
ModuleList¶
- class pyvqnet.nn.module.ModuleList([pyvqnet.nn.module.Module])¶
将子模块保存在列表中。 ModuleList 可以像普通的 Python 列表一样被索引, 它包含的Module的内部参数等可以被保存起来。
- Parameters:
modules – nn.Modules 列表
- Returns:
一个模块列表
Example:
from pyvqnet.tensor import * from pyvqnet.nn import Module,Linear,ModuleList from pyvqnet.qnn import ProbsMeasure,QuantumLayer import pyqpanda as pq def pqctest (input,param,qubits,cubits,m_machine): circuit = pq.QCircuit() circuit.insert(pq.H(qubits[0])) circuit.insert(pq.H(qubits[1])) circuit.insert(pq.H(qubits[2])) circuit.insert(pq.H(qubits[3])) circuit.insert(pq.RZ(qubits[0],input[0])) circuit.insert(pq.RZ(qubits[1],input[1])) circuit.insert(pq.RZ(qubits[2],input[2])) circuit.insert(pq.RZ(qubits[3],input[3])) circuit.insert(pq.CNOT(qubits[0],qubits[1])) circuit.insert(pq.RZ(qubits[1],param[0])) circuit.insert(pq.CNOT(qubits[0],qubits[1])) circuit.insert(pq.CNOT(qubits[1],qubits[2])) circuit.insert(pq.RZ(qubits[2],param[1])) circuit.insert(pq.CNOT(qubits[1],qubits[2])) circuit.insert(pq.CNOT(qubits[2],qubits[3])) circuit.insert(pq.RZ(qubits[3],param[2])) circuit.insert(pq.CNOT(qubits[2],qubits[3])) #print(circuit) prog = pq.QProg() prog.insert(circuit) rlt_prob = ProbsMeasure([0,2],prog,m_machine,qubits) return rlt_prob class M(Module): def __init__(self): super(M, self).__init__() self.pqc2 = ModuleList([QuantumLayer(pqctest,3,"cpu",4,1), Linear(4,1) ]) def forward(self, x, *args, **kwargs): y = self.pqc2[0](x) + self.pqc2[1](x) return y mm = M() print(mm.state_dict().keys()) #odict_keys(['pqc2.0.m_para', 'pqc2.1.weights', 'pqc2.1.bias'])
ParameterList¶
- class pyvqnet.nn.module.ParameterList([pyvqnet.nn.module.Module])¶
将参数保存在列表中, ParameterList 可以像普通的 Python 列表一样被索引, 它包含的Parameter的内部参数等可以被保存起来。
- Parameters:
modules – nn.Parameter 列表
- Returns:
一个参数列表
Example:
from pyvqnet import nn class MyModule(nn.Module): def __init__(self): super().__init__() self.params = nn.ParameterList([nn.Parameter((10, 10)) for i in range(10)]) def forward(self, x): # ParameterList can act as an iterable, or be indexed using ints for i, p in enumerate(self.params): x = self.params[i // 2] * x + p * x return x model = MyModule() print(model.state_dict().keys())
Sequential¶
- class pyvqnet.nn.module.Sequential([pyvqnet.nn.module.Module])¶
模块将按照传递的顺序添加模块。或者,也可以将模块的
OrderedDict
传入。Sequential
的forward()
方法接受任何输入,并将其转发给它的第一个模块。 然后将输出依次 “链 “到其后每个模块的输入、最后返回最后一个模块的输出。- Parameters:
modules – 添加的Module
- Returns:
Sequential
Example:
from pyvqnet import nn from collections import OrderedDict # 使用Sequential创建一个小模型 model = nn.Sequential( nn.Conv2D(1,20,(5, 5)), nn.ReLu(), nn.Conv2D(20,64,(5, 5)), nn.ReLu() ) print(model.state_dict().keys()) # 基于OrderedDict来使用Sequential, 代码如下 model = nn.Sequential(OrderedDict([ ('conv1', nn.Conv2D(1,20,(5, 5))), ('relu1', nn.ReLu()), ('conv2', nn.Conv2D(20,64,(5, 5))), ('relu2', nn.ReLu()) ])) print(model.state_dict().keys())
经典神经网络层¶
以下实现了一些经典神经网络层:卷积,转置卷积,池化,归一化,循环神经网络等。
Conv1D¶
- class pyvqnet.nn.Conv1D(input_channels: int, output_channels: int, kernel_size: int, stride: int = 1, padding='valid', use_bias: bool = True, kernel_initializer=None, bias_initializer=None, dilation_rate: int = 1, group: int = 1, dtype=None, name='')¶
在输入上进行一维卷积运算。 Conv1D模块的输入具有形状(batch_size、input_channels、in_height)。
- Parameters:
input_channels – int - 输入数据的通道数。
output_channels – int - 输出数据的通道数。
kernel_size – int - 卷积核的尺寸. 卷积核形状 = [output_channels,input_channels/group,kernel_size,1]。
stride – int - 步长, 默认为1。
padding – str|int - 填充选项, 它可以是一个字符串 {‘valid’, ‘same’} 或一个整数,给出应用在输入上的填充量。 默认 “valid”。
use_bias – bool - 是否使用偏置项, 默认使用。
kernel_initializer – callable - 卷积核初始化方法。默认为空,使用kaiming_uniform。
bias_initializer – callable - 偏置初始化方法。默认为空,使用kaiming_uniform。
dilation_rate – int - 空洞大小,defaults: 1。
group – int - 分组卷积的分组数. Default: 1。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 模块的名字,default:””。
- Returns:
一维卷积实例。
Note
padding='valid'
不进行填充。padding='same'
补零填充输入,输出的out_height 为 = ceil(in_height / stride)。Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn import Conv1D import pyvqnet b= 2 ic =3 oc = 2 test_conv = Conv1D(ic,oc,3,2,"same") x0 = QTensor(np.arange(1,b*ic*5*5 +1).reshape([b,ic,25]),requires_grad=True,dtype=pyvqnet.kfloat32) x = test_conv.forward(x0) print(x) # [ # [[12.4438553, 14.8618164, 15.5595102, 16.2572021, 16.9548950, 17.6525879, 18.3502808, 19.0479736, 19.7456665, 20.4433594, 21.1410522, 21.8387432, 10.5725441], # [-13.7539215, 1.0263026, 1.2747254, 1.5231485, 1.7715728, 2.0199962, 2.2684195, 2.5168428, 2.7652662, 3.0136888, 3.2621140, 3.5105357, 14.0515862]], # [[47.4924164, 41.0252953, 41.7229881, 42.4206772, 43.1183739, 43.8160667, 44.5137596, 45.2114487, 45.9091415, 46.6068344, 47.3045311, 48.0022240, 18.3216572], # [-47.2381554, 10.3421783, 10.5906038, 10.8390274, 11.0874519, 11.3358765, 11.5842953, 11.8327246, 12.0811434, 12.3295631, 12.5779924, 12.8264122, 39.4719162]] # ]
Conv2D¶
- class pyvqnet.nn.Conv2D(input_channels: int, output_channels: int, kernel_size: tuple, stride: tuple = (1, 1), padding='valid', use_bias=True, kernel_initializer=None, bias_initializer=None, dilation_rate: int = 1, group: int = 1, dtype=None, name='')¶
在输入上进行二维卷积运算。 Conv2D模块的输入具有形状(batch_size, input_channels, height, width)。
- Parameters:
input_channels – int - 输入数据的通道数。
output_channels – int - 输出数据的通道数。
kernel_size – tuple|list - 卷积核的尺寸. 卷积核形状 = [output_channels,input_channels/group,kernel_size,kernel_size]。
stride – tuple|list - 步长, 默认为 (1, 1)|[1,1]。
padding – str|tuple - 填充选项, 它可以是一个字符串 {‘valid’, ‘same’} 或一个整数元组,给出在两边应用的隐式填充量。 默认 “valid”。
use_bias – bool - 是否使用偏置项, 默认使用。
kernel_initializer – callable - 卷积核初始化方法。默认为空,使用kaiming_uniform。
bias_initializer – callable - 偏置初始化方法。默认为空,使用kaiming_uniform。
dilation_rate – int - 空洞大小,defaults: 1。
group – int - 分组卷积的分组数. Default: 1。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 模块的名字,default:””。
- Returns:
二维卷积实例。
Note
padding='valid'
不进行填充。padding='same'
补零填充输入,输出的height 为 = ceil(height / stride), 输出的width 为 = ceil(width / stride)。Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn import Conv2D import pyvqnet b= 2 ic =3 oc = 2 test_conv = Conv2D(ic,oc,(3,3),(2,2),"same") x0 = QTensor(np.arange(1,b*ic*5*5+1).reshape([b,ic,5,5]),requires_grad=True,dtype=pyvqnet.kfloat32) x = test_conv.forward(x0) print(x) # [ # [[[-0.1256833, 23.8978596, 26.7449780], # [-7.2959919, 33.4023743, 42.1283913], # [-8.7684336, 25.2698975, 40.4024887]], # [[33.0653763, 40.3120155, 27.3781891], # [39.2921371, 45.8685760, 38.1885109], # [23.1873779, 12.0480318, 12.7278290]]], # [[[-0.9730744, 61.3967094, 79.0511856], # [-29.3652401, 75.0349350, 112.7325439], # [-26.4682808, 59.0924797, 104.2572098]], # [[66.8064194, 96.0953140, 72.9157486], # [90.9154129, 110.7232437, 91.2616043], # [56.8825951, 34.6904907, 30.1957760]]] # ]
ConvT2D¶
- class pyvqnet.nn.ConvT2D(input_channels, output_channels, kernel_size, stride=[1, 1], padding='valid', use_bias='True', kernel_initializer=None, bias_initializer=None, dilation_rate: int = 1, group: int = 1, dtype=None, name='')¶
在输入上进行二维转置卷积运算。 Conv2D模块的输入具有形状(batch_size, input_channels, height, width)。
- Parameters:
input_channels – int - 输入数据的通道数。
output_channels – int - 输出数据的通道数。
kernel_size – tuple|list - 卷积核的尺寸,卷积核形状 = [input_channels,output_channels/group,kernel_size,kernel_size]。
stride – tuple|list - 步长, 默认为 (1, 1)|[1,1]。
padding – str|tuple - 填充选项, 它可以是一个字符串 {‘valid’, ‘same’} 或一个整数元组,给出在两边应用的隐式填充量。 默认 “valid”。
use_bias – bool - 是否使用偏置项, 默认使用。
kernel_initializer – callable - 卷积核初始化方法。默认为空,使用kaiming_uniform。
bias_initializer – callable - 偏置项初始化方法。默认为空,使用kaiming_uniform。
dilation_rate – int - 空洞大小,defaults: 1。
group – int - 分组卷积的分组数. Default: 1。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 模块的名字,default:””。
- Returns:
二维转置卷积实例。
Note
padding='valid'
不进行填充。padding='same'
补零填充输入,输出的height 为 = ceil(height / stride)。Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn import ConvT2D import pyvqnet test_conv = ConvT2D(3, 2, (3, 3), (1, 1), "valid") x = QTensor(np.arange(1, 1 * 3 * 5 * 5+1).reshape([1, 3, 5, 5]), requires_grad=True,dtype=pyvqnet.kfloat32) y = test_conv.forward(x) print(y) # [ # [[[-3.3675897, 4.8476148, 14.2448473, 14.8897810, 15.5347166, 20.0420666, 10.9831696], # [-14.0110836, -3.2500827, 6.4022207, 6.5149083, 6.6275964, 23.7946320, 12.1828709], # [-22.2661152, -3.5112300, 12.9493723, 13.5486069, 14.1478367, 39.6327629, 18.8349991], # [-24.4063797, -3.0093837, 15.9455290, 16.5447617, 17.1439915, 44.7691879, 21.3293095], # [-26.5466480, -2.5075383, 18.9416828, 19.5409145, 20.1401463, 49.9056053, 23.8236179], # [-24.7624626, -13.7395811, -7.9510674, -7.9967723, -8.0424776, 19.2783546, 7.0562835], # [-3.5170188, 10.2280807, 16.1939259, 16.6804695, 17.1670132, 21.2262039, 6.2889833]], # [[-2.0570512, -9.5056667, -25.0429192, -25.9464111, -26.8499031, -24.7305946, -16.9881954], # [-0.7620960, -18.3383904, -49.8948288, -51.2528229, -52.6108208, -52.2179604, -34.3664169], # [-11.7121849, -27.1864738, -62.2154846, -63.6433640, -65.0712280, -52.6787071, -38.4497032], # [-13.3643141, -29.0211792, -69.3548126, -70.7826691, -72.2105408, -58.1659012, -43.7543182], # [-15.0164423, -30.8558884, -76.4941254, -77.9219971, -79.3498535, -63.6530838, -49.0589256], # [-11.6070204, -14.1940546, -35.5471687, -36.0715408, -36.5959129, -23.9147663, -22.8668022], # [-14.4390459, -4.9011412, -6.4719801, -6.5418491, -6.6117167, 9.3329525, -1.7254852]]] # ]
AvgPool1D¶
- class pyvqnet.nn.AvgPool1D(kernel, stride, padding='valid', name='')¶
对一维输入进行平均池化。输入具有形状(batch_size, input_channels, in_height)。
- Parameters:
kernel – 平均池化的窗口大小。
strides – 窗口移动的步长。
padding – 填充选项, “valid” or “same” 或者整数指定填充长度。 默认 “valid”。
name – 模块的名字,default:””。
- Returns:
一维平均池化层实例。
Note
padding='valid'
不进行填充。padding='same'
补零填充输入,输出的out_height 为 = ceil(in_height / stride)。Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn import AvgPool1D test_mp = AvgPool1D([3],[2],"same") x= QTensor(np.array([0, 1, 0, 4, 5, 2, 3, 2, 1, 3, 4, 4, 0, 4, 3, 2, 5, 2, 6, 4, 1, 0, 0, 5, 7],dtype=float).reshape([1,5,5]),requires_grad=True) y= test_mp.forward(x) print(y) # [ # [[0.3333333, 1.6666666, 3.], # [1.6666666, 2., 1.3333334], # [2.6666667, 2.6666667, 2.3333333], # [2.3333333, 4.3333335, 3.3333333], # [0.3333333, 1.6666666, 4.]] # ]
MaxPool1D¶
- class pyvqnet.nn.MaxPool1D(kernel, stride, padding='valid', name='')¶
对一维输入进行最大池化。输入具有形状(batch_size, input_channels, in_height)。
- Parameters:
kernel – 最大池化的窗口大小。
strides – 窗口移动的步长。
padding – 填充选项, “valid” or “same” 或者整数指定填充长度。 默认 “valid”。
name – 命名,默认为””。
- Returns:
一维最大池化层实例。
Note
padding='valid'
不进行填充。padding='same'
补零填充输入,输出的out_height 为 = ceil(in_height / stride)。Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn import MaxPool1D test_mp = MaxPool1D([3],[2],"same") x= QTensor(np.array([0, 1, 0, 4, 5, 2, 3, 2, 1, 3, 4, 4, 0, 4, 3, 2, 5, 2, 6, 4, 1, 0, 0, 5, 7],dtype=float).reshape([1,5,5]),requires_grad=True) y= test_mp.forward(x) print(y) #[[[1. 4. 5.] # [3. 3. 3.] # [4. 4. 4.] # [5. 6. 6.] # [1. 5. 7.]]]
AvgPool2D¶
- class pyvqnet.nn.AvgPool2D(kernel, stride, padding='valid', name='')¶
对二维输入进行平均池化。输入具有形状(batch_size, input_channels, height, width)。
- Parameters:
kernel – 平均池化的窗口大小。
strides – 窗口移动的步长。
padding – 填充选项, “valid” or “same” 或包含2个整数的元组,整数为两个维度上的填充长度。 默认 “valid”。
name – 命名,默认为””。
- Returns:
二维平均池化层实例。
Note
padding='valid'
不进行填充。padding='same'
补零填充输入,输出的height 为 = ceil(height / stride), 输出的width 为 = ceil(width / stride)。Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn import AvgPool2D test_mp = AvgPool2D([2,2],[2,2],"valid") x= QTensor(np.array([0, 1, 0, 4, 5, 2, 3, 2, 1, 3, 4, 4, 0, 4, 3, 2, 5, 2, 6, 4, 1, 0, 0, 5, 7],dtype=float).reshape([1,1,5,5]),requires_grad=True) y= test_mp.forward(x) print(y) #[[[[1.5 1.75] # [3.75 3. ]]]]
MaxPool2D¶
- class pyvqnet.nn.MaxPool2D(kernel, stride, padding='valid', name='')¶
对二维输入进行最大池化。输入具有形状(batch_size, input_channels, height, width)。
- Parameters:
kernel – 最大池化的窗口大小。
strides – 窗口移动的步长。
padding – 填充选项, “valid” or “same” 或包含2个整数的元组,整数为两个维度上的填充长度。 默认 “valid”。
name – 命名,默认为””。
- Returns:
二维最大池化层实例。
Note
padding='valid'
不进行填充。padding='same'
补零填充输入,输出的height 为 = ceil(height / stride), 输出的width 为 = ceil(width / stride)。Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn import MaxPool2D test_mp = MaxPool2D([2,2],[2,2],"valid") x= QTensor(np.array([0, 1, 0, 4, 5, 2, 3, 2, 1, 3, 4, 4, 0, 4, 3, 2, 5, 2, 6, 4, 1, 0, 0, 5, 7],dtype=float).reshape([1,1,5,5]),requires_grad=True) y= test_mp.forward(x) print(y) # [[[[3. 4.] # [5. 6.]]]]
Embedding¶
- class pyvqnet.nn.embedding.Embedding(num_embeddings, embedding_dim, weight_initializer=xavier_normal, dtype=None, name: str = '')¶
该模块通常用于存储词嵌入并使用索引检索它们。模块的输入是索引列表,输出是对应的词嵌入。 该层的输入应该是kint64。
- Parameters:
num_embeddings – int - 嵌入字典的大小。
embedding_dim – int - 每个嵌入向量的大小
weight_initializer – callable - 参数初始化方式,默认正态分布。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 嵌入层的命名,默认为””。
- Returns:
a Embedding 实例。
Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn.embedding import Embedding import pyvqnet vlayer = Embedding(30,3) x = QTensor(np.arange(1,25).reshape([2,3,2,2]),dtype= pyvqnet.kint64) y = vlayer(x) print(y) # [ # [[[[-0.3168081, 0.0329394, -0.2934906], # [0.1057295, -0.2844988, -0.1687456]], # [[-0.2382513, -0.3642318, -0.2257225], # [0.1563180, 0.1567665, 0.3038477]]], # [[[-0.4131152, -0.0564500, -0.2804018], # [-0.2955172, -0.0009581, -0.1641144]], # [[0.0692555, 0.1094901, 0.4099118], # [0.4348361, 0.0304361, -0.0061203]]], # [[[-0.3310401, -0.1836129, 0.1098949], # [-0.1840732, 0.0332474, -0.0261806]], # [[-0.1489778, 0.2519453, 0.3299376], # [-0.1942692, -0.1540277, -0.2335350]]]], # [[[[-0.2620637, -0.3181309, -0.1857461], # [-0.0878164, -0.4180320, -0.1831555]], # [[-0.0738970, -0.1888980, -0.3034399], # [0.1955448, -0.0409723, 0.3023460]]], # [[[0.2430045, 0.0880465, 0.4309453], # [-0.1796514, -0.1432367, -0.1253638]], # [[-0.5266719, 0.2386262, -0.0329155], # [0.1033449, -0.3442690, -0.0471130]]], # [[[-0.5336705, -0.1939755, -0.3000667], # [0.0059001, 0.5567381, 0.1926173]], # [[-0.2385869, -0.3910453, 0.2521235], # [-0.0246447, -0.0241158, -0.1402829]]]] # ]
BatchNorm2d¶
- class pyvqnet.nn.BatchNorm2d(channel_num: int, momentum: float = 0.1, epsilon: float = 1e-05, beta_initializer=zeros, gamma_initializer=ones, dtype=None, name='')¶
在 4D 输入(B、C、H、W)上应用批归一化。参照论文 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 。
\[y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta\]其中 \(\gamma\) 和 \(\beta\) 为待训练参数。此外,默认情况下,在训练期间,该层会继续运行估计其计算的均值和方差,然后在评估期间用于归一化。平均方差均值保持默认动量 0.1。
- Parameters:
channel_num – int - 输入通道数。
momentum – float - 计算指数加权平均时的动量,默认为 0.1。
beta_initializer – callable - beta的初始化方式,默认全零初始化。
gamma_initializer – callable - gamma的的初始化方式,默认全一初始化。
epsilon – float - 数值稳定参数, 默认 1e-5。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 批归一化层命名,默认为””。
- Returns:
二维批归一化层实例。
Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn import BatchNorm2d import pyvqnet b = 2 ic = 2 test_conv = BatchNorm2d(ic) x = QTensor(np.arange(1, 17).reshape([b, ic, 4, 1]), requires_grad=True, dtype=pyvqnet.kfloat32) y = test_conv.forward(x) print(y) # [ # [[[-1.3242440], # [-1.0834724], # [-0.8427007], # [-0.6019291]], # [[-1.3242440], # [-1.0834724], # [-0.8427007], # [-0.6019291]]], # [[[0.6019291], # [0.8427007], # [1.0834724], # [1.3242440]], # [[0.6019291], # [0.8427007], # [1.0834724], # [1.3242440]]] # ]
BatchNorm1d¶
- class pyvqnet.nn.BatchNorm1d(channel_num: int, momentum: float = 0.1, epsilon: float = 1e-05, beta_initializer=zeros, gamma_initializer=ones, dtype=None, name='')¶
在 2D 输入 (B,C) 上进行批归一化操作。 参照论文 Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift 。
\[y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta\]其中 \(\gamma\) 和 \(\beta\) 为待训练参数。此外,默认情况下,在训练期间,该层会继续运行估计其计算的均值和方差,然后在评估期间用于归一化。平均方差均值保持默认动量 0.1。
- Parameters:
channel_num – int - 输入通道数。
momentum – float - 计算指数加权平均时的动量,默认为 0.1。
beta_initializer – callable - beta的初始化方式,默认全零初始化。
gamma_initializer – callable - gamma的的初始化方式,默认全一初始化。
epsilon – float - 数值稳定性常数,默认为 1e-5。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 批归一化层命名,默认为””。
- Returns:
一维批归一化层实例。
Example:
import numpy as np from pyvqnet.tensor import QTensor from pyvqnet.nn import BatchNorm1d import pyvqnet test_conv = BatchNorm1d(4) x = QTensor(np.arange(1, 17).reshape([4, 4]), requires_grad=True, dtype=pyvqnet.kfloat32) y = test_conv.forward(x) print(y) # [ # [-1.3416405, -1.3416405, -1.3416405, -1.3416405], # [-0.4472135, -0.4472135, -0.4472135, -0.4472135], # [0.4472135, 0.4472135, 0.4472135, 0.4472135], # [1.3416405, 1.3416405, 1.3416405, 1.3416405] # ]
LayerNormNd¶
- class pyvqnet.nn.layer_norm.LayerNormNd(normalized_shape: list, epsilon: float = 1e-05, affine: bool = True, dtype=None, name='')¶
在任意输入的后D个维度上进行层归一化。具体方式如论文所述: Layer Normalization。
\[y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta\]对于像 (B,C,H,W,D) 这样的输入,
norm_shape
可以是 [C,H,W,D],[H,W,D],[W,D] 或 [D] .- Parameters:
norm_shape – float - 标准化形状。
epsilon – float - 数值稳定性常数,默认为 1e-5。
affine – bool - 是否使用应用仿射变换,默认为 True。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 这个模块的名字, 默认为””。
- Returns:
一个 LayerNormNd 类
Example:
import numpy as np from pyvqnet.tensor import QTensor,kfloat32 from pyvqnet.nn.layer_norm import LayerNormNd ic = 4 test_conv = LayerNormNd([2,2]) x = QTensor(np.arange(1,17).reshape([2,2,2,2]),requires_grad=True,dtype=kfloat32) y = test_conv.forward(x) print(y) # [ # [[[-1.3416355, -0.4472118], # [0.4472118, 1.3416355]], # [[-1.3416355, -0.4472118], # [0.4472118, 1.3416355]]], # [[[-1.3416355, -0.4472118], # [0.4472118, 1.3416355]], # [[-1.3416355, -0.4472118], # [0.4472118, 1.3416355]]] # ]
LayerNorm2d¶
- class pyvqnet.nn.layer_norm.LayerNorm2d(norm_size: int, epsilon: float = 1e-05, affine: bool = True, dtype=None, name='')¶
在 4D 输入上进行层归一化。具体方式如论文所述: Layer Normalization。
\[y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta\]平均值和标准差是在除去第一个维度以外的剩余维度数据上计算的。对于像 (B,C,H,W) 这样的输入,
norm_size
应该等于 C * H * W。- Parameters:
norm_size – float - 归一化大小,应该等于 C * H * W。
epsilon – float - 数值稳定性常数,默认为 1e-5。
affine – bool - 是否使用应用仿射变换,默认为 True。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 这个模块的名字, 默认为””。
- Returns:
二维层归一化实例。
Example:
import numpy as np import pyvqnet from pyvqnet.tensor import QTensor from pyvqnet.nn.layer_norm import LayerNorm2d ic = 4 test_conv = LayerNorm2d(8) x = QTensor(np.arange(1,17).reshape([2,2,4,1]),requires_grad=True,dtype=pyvqnet.kfloat32) y = test_conv.forward(x) print(y) # [ # [[[-1.5275238], # [-1.0910884], # [-0.6546531], # [-0.2182177]], # [[0.2182177], # [0.6546531], # [1.0910884], # [1.5275238]]], # [[[-1.5275238], # [-1.0910884], # [-0.6546531], # [-0.2182177]], # [[0.2182177], # [0.6546531], # [1.0910884], # [1.5275238]]] # ]
LayerNorm1d¶
- class pyvqnet.nn.layer_norm.LayerNorm1d(norm_size: int, epsilon: float = 1e-05, affine: bool = True, dtype=None, name='')¶
在 2D 输入上进行层归一化。具体方式如论文所述: Layer Normalization。
\[y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta\]均值和标准差是在最后一个维度大小上计算的,其中“norm_size” 是
norm_size
的值。- Parameters:
norm_size – float - 归一化大小,应该等于最后一维大小。
epsilon – float - 数值稳定性常数,默认为 1e-5。
affine – bool - 是否使用应用仿射变换,默认为 True。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 这个模块的名字, 默认为””。
- Returns:
一维层归一化实例。
Example:
import numpy as np import pyvqnet from pyvqnet.tensor import QTensor from pyvqnet.nn.layer_norm import LayerNorm1d test_conv = LayerNorm1d(4) x = QTensor(np.arange(1,17).reshape([4,4]),requires_grad=True,dtype=pyvqnet.kfloat32) y = test_conv.forward(x) print(y) # [ # [-1.3416355, -0.4472118, 0.4472118, 1.3416355], # [-1.3416355, -0.4472118, 0.4472118, 1.3416355], # [-1.3416355, -0.4472118, 0.4472118, 1.3416355], # [-1.3416355, -0.4472118, 0.4472118, 1.3416355] # ]
Linear¶
- class pyvqnet.nn.Linear(input_channels, output_channels, weight_initializer=None, bias_initializer=None, use_bias=True, dtype=None, name: str = '')¶
线性模块(全连接层)。 \(y = Ax + b\)
- Parameters:
input_channels – int - 输入数据通道数。
output_channels – int - 输出数据通道数。
weight_initializer – callable - 权重初始化函数,默认为空,使用he_uniform。
bias_initializer – callable - 偏置初始化参数,默认为空,使用he_uniform。
use_bias – bool - 是否使用偏置项, 默认使用。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 线性层的命名,默认为””。
- Returns:
线性层实例。
Example:
import numpy as np import pyvqnet from pyvqnet.tensor import QTensor from pyvqnet.nn import Linear c1 =2 c2 = 3 cin = 7 cout = 5 n = Linear(cin,cout) input = QTensor(np.arange(1,c1*c2*cin+1).reshape((c1,c2,cin)),requires_grad=True,dtype=pyvqnet.kfloat32) y = n.forward(input) print(y) # [ # [[4.3084583, -1.9228780, -0.3428757, 1.2840536, -0.5865945], # [9.8339605, -5.5135884, -3.1228657, 4.3025794, -4.1492314], # [15.3594627, -9.1042995, -5.9028554, 7.3211040, -7.7118683]], # [[20.8849659, -12.6950111, -8.6828451, 10.3396301, -11.2745066], # [26.4104652, -16.2857227, -11.4628344, 13.3581581, -14.8371439], # [31.9359703, -19.8764324, -14.2428246, 16.3766804, -18.3997803]] # ]
Dropout¶
- class pyvqnet.nn.dropout.Dropout(dropout_rate=0.5)¶
Dropout 模块。dropout 模块将一些单元的输出随机设置为零,同时根据给定的 dropout_rate 概率升级其他单元。
- Parameters:
dropout_rate – float - 神经元被设置为零的概率。
name – 这个模块的名字, 默认为””。
- Returns:
Dropout实例。
Example:
import numpy as np from pyvqnet.nn.dropout import Dropout from pyvqnet.tensor import QTensor b = 2 ic = 2 x = QTensor(np.arange(-1 * ic * 2 * 2, (b - 1) * ic * 2 * 2).reshape([b, ic, 2, 2]), requires_grad=True) droplayer = Dropout(0.5) droplayer.train() y = droplayer(x) print(y) # [ # [[[-16., -14.], # [-0., -0.]], # [[-8., -6.], # [-4., -2.]]], # [[[0., 2.], # [4., 6.]], # [[8., 10.], # [0., 14.]]] # ]
Pixel_Shuffle¶
- class pyvqnet.nn.pixel_shuffle.Pixel_Shuffle(upscale_factors, name='')¶
重新排列形状为:(, C * r^2, H, W) 的张量 到形状为 (, C, H * r, W * r) 的张量,其中 r 是尺度变换因子。
- Parameters:
upscale_factors – 增加尺度变换的因子
name – 这个模块的名字, 默认为””。
- Returns:
Pixel_Shuffle 模块
Example:
from pyvqnet.nn import Pixel_Shuffle from pyvqnet.tensor import tensor ps = Pixel_Shuffle(3) inx = tensor.ones([5,2,3,18,4,4]) inx.requires_grad= True y = ps(inx) print(y.shape) #[5, 2, 3, 2, 12, 12]
Pixel_Unshuffle¶
- class pyvqnet.nn.pixel_shuffle.Pixel_Unshuffle(downscale_factors, name='')¶
通过重新排列元素来反转 Pixel_Shuffle 操作. 将 (, C, H * r, W * r) 形状的张量变化为 (, C * r^2, H, W) ,其中 r 是缩小因子。
- Parameters:
downscale_factors – 增加尺度变换的因子
name – 这个模块的名字, 默认为””。
- Returns:
Pixel_Unshuffle 模块
Example:
from pyvqnet.nn import Pixel_Unshuffle from pyvqnet.tensor import tensor ps = Pixel_Unshuffle(3) inx = tensor.ones([5, 2, 3, 2, 12, 12]) inx.requires_grad = True y = ps(inx) print(y.shape) #[5, 2, 3, 18, 4, 4]
GRU¶
- class pyvqnet.nn.gru.GRU(input_size, hidden_size, num_layers=1, nonlinearity='tanh', batch_first=True, use_bias=True, bidirectional=False, dtype=None, name: str = '')¶
门控循环单元 (GRU) 模块。支持多层堆叠,双向配置。单层单向GRU的计算公式如下:
\[\begin{split}\begin{array}{ll} r_t = \sigma(W_{ir} x_t + b_{ir} + W_{hr} h_{(t-1)} + b_{hr}) \\ z_t = \sigma(W_{iz} x_t + b_{iz} + W_{hz} h_{(t-1)} + b_{hz}) \\ n_t = \tanh(W_{in} x_t + b_{in} + r_t * (W_{hn} h_{(t-1)}+ b_{hn})) \\ h_t = (1 - z_t) * n_t + z_t * h_{(t-1)} \end{array}\end{split}\]- Parameters:
input_size – 输入特征维度。
hidden_size – 隐藏特征维度。
num_layers – 堆叠GRU层数, 默认: 1。
batch_first – 如果为 True, 则输入形状为 [batch_size,seq_len,feature_dim], 如果为 False, 则输入形状为 [seq_len,batch_size,feature_dim],默认为 True。
use_bias – 如果为 False,该模块不适用偏置项,默认: True。
bidirectional – 如果为 True, 变为双向GRU, 默认: False。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 这个模块的名字, 默认为””。
- Returns:
GRU 实例
Example:
from pyvqnet.nn import GRU from pyvqnet.tensor import tensor rnn2 = GRU(4, 6, 2, batch_first=False, bidirectional=True) input = tensor.ones([5, 3, 4]) h0 = tensor.ones([4, 3, 6]) output, hn = rnn2(input, h0) print(output) print(hn) # [ # [[0.2815045, 0.2056844, 0.0750246, 0.5802019, 0.3536537, 0.8136684, -0.0034523, 0.1634004, 0.6099871, 0.8451654, -0.2833570, 0.7294812], # [0.2815045, 0.2056844, 0.0750246, 0.5802019, 0.3536537, 0.8136684, -0.0034523, 0.1634004, 0.6099871, 0.8451654, -0.2833570, 0.7294812], # [0.2815045, 0.2056844, 0.0750246, 0.5802019, 0.3536537, 0.8136684, -0.0034523, 0.1634004, 0.6099871, 0.8451654, -0.2833570, 0.7294812]], # [[0.0490867, 0.0115325, -0.2797680, 0.4711050, -0.0687061, 0.7216146, 0.0258964, 0.0619203, 0.6341010, 0.8445141, -0.4164453, 0.7409840], # [0.0490867, 0.0115325, -0.2797680, 0.4711050, -0.0687061, 0.7216146, 0.0258964, 0.0619203, 0.6341010, 0.8445141, -0.4164453, 0.7409840], # [0.0490867, 0.0115325, -0.2797680, 0.4711050, -0.0687061, 0.7216146, 0.0258964, 0.0619203, 0.6341010, 0.8445141, -0.4164453, 0.7409840]], # [[0.0182974, -0.0536071, -0.4478674, 0.4315647, -0.2191887, 0.6492687, 0.1572548, 0.0839213, 0.6707115, 0.8444533, -0.3811499, 0.7448123], # [0.0182974, -0.0536071, -0.4478674, 0.4315647, -0.2191887, 0.6492687, 0.1572548, 0.0839213, 0.6707115, 0.8444533, -0.3811499, 0.7448123], # [0.0182974, -0.0536071, -0.4478674, 0.4315647, -0.2191887, 0.6492687, 0.1572548, 0.0839213, 0.6707115, 0.8444533, -0.3811499, 0.7448123]], # [[0.0722285, -0.0636698, -0.5457084, 0.3817562, -0.1890205, 0.5696942, 0.3855782, 0.2057217, 0.7370453, 0.8646453, -0.1967214, 0.7630759], # [0.0722285, -0.0636698, -0.5457084, 0.3817562, -0.1890205, 0.5696942, 0.3855782, 0.2057217, 0.7370453, 0.8646453, -0.1967214, 0.7630759], # [0.0722285, -0.0636698, -0.5457084, 0.3817562, -0.1890205, 0.5696942, 0.3855782, 0.2057217, 0.7370453, 0.8646453, -0.1967214, 0.7630759]], # [[0.1834545, -0.0489200, -0.6343678, 0.3061281, -0.0449328, 0.4901535, 0.6941375, 0.4570828, 0.8433002, 0.9152645, 0.2342478, 0.8299093], # [0.1834545, -0.0489200, -0.6343678, 0.3061281, -0.0449328, 0.4901535, 0.6941375, 0.4570828, 0.8433002, 0.9152645, 0.2342478, 0.8299093], # [0.1834545, -0.0489200, -0.6343678, 0.3061281, -0.0449328, 0.4901535, 0.6941375, 0.4570828, 0.8433002, 0.9152645, 0.2342478, 0.8299093]] # ] # [ # [[-0.8070476, -0.5560303, 0.7575479, -0.2368367, 0.4228620, -0.2573725], # [-0.8070476, -0.5560303, 0.7575479, -0.2368367, 0.4228620, -0.2573725], # [-0.8070476, -0.5560303, 0.7575479, -0.2368367, 0.4228620, -0.2573725]], # [[-0.3857390, -0.3195596, 0.0281313, 0.8734715, -0.4499536, 0.2270730], # [-0.3857390, -0.3195596, 0.0281313, 0.8734715, -0.4499536, 0.2270730], # [-0.3857390, -0.3195596, 0.0281313, 0.8734715, -0.4499536, 0.2270730]], # [[0.1834545, -0.0489200, -0.6343678, 0.3061281, -0.0449328, 0.4901535], # [0.1834545, -0.0489200, -0.6343678, 0.3061281, -0.0449328, 0.4901535], # [0.1834545, -0.0489200, -0.6343678, 0.3061281, -0.0449328, 0.4901535]], # [[-0.0034523, 0.1634004, 0.6099871, 0.8451654, -0.2833570, 0.7294812], # [-0.0034523, 0.1634004, 0.6099871, 0.8451654, -0.2833570, 0.7294812], # [-0.0034523, 0.1634004, 0.6099871, 0.8451654, -0.2833570, 0.7294812]] # ]
RNN¶
- class pyvqnet.nn.rnn.RNN(input_size, hidden_size, num_layers=1, nonlinearity='tanh', batch_first=True, use_bias=True, bidirectional=False, dtype=None, name: str = '')¶
循环神经网络(RNN)模块,使用 \(\tanh\) 或 \(\text{ReLU}\) 作为激活函数。支持双向,多层配置。 单层单向RNN计算公式如下:
\[h_t = \tanh(W_{ih} x_t + b_{ih} + W_{hh} h_{(t-1)} + b_{hh})\]如果
nonlinearity
是'relu'
, 则 \(\text{ReLU}\) 将替代 \(\tanh\)。- Parameters:
input_size – 输入特征维度。
hidden_size – 隐藏特征维度。
num_layers – 堆叠RNN层数, 默认: 1。
nonlinearity – 非线性激活函数,默认为
'tanh'
。batch_first – 如果为 True, 则输入形状为 [batch_size,seq_len,feature_dim], 如果为 False, 则输入形状为 [seq_len,batch_size,feature_dim],默认为 True。
use_bias – 如果为 False, 该模块不适用偏置项,默认: True。
bidirectional – 如果为 True,变为双向RNN,默认: False。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 这个模块的名字, 默认为””。
- Returns:
RNN 实例
Example:
from pyvqnet.nn import RNN from pyvqnet.tensor import tensor rnn2 = RNN(4, 6, 2, batch_first=False, bidirectional = True) input = tensor.ones([5, 3, 4]) h0 = tensor.ones([4, 3, 6]) output, hn = rnn2(input, h0) print(output) print(hn) # [[[-0.413501 -0.4584284 -0.7530673 0.017902 0.5038776 0.6589128 # -0.3040171 0.6689512 -0.5059364 -0.4492912 -0.1206206 -0.3208488] # [-0.413501 -0.4584284 -0.7530673 0.017902 0.5038776 0.6589128 # -0.3040171 0.6689512 -0.5059364 -0.4492912 -0.1206206 -0.3208488] # [-0.413501 -0.4584284 -0.7530673 0.017902 0.5038776 0.6589128 # -0.3040171 0.6689512 -0.5059364 -0.4492912 -0.1206206 -0.3208488]] # [[ 0.2127696 -0.6644132 -0.3884572 -0.0344413 0.35414 0.5639224 # -0.2358238 0.7706838 -0.3650029 -0.54729 -0.2392456 -0.3285939] # [ 0.2127696 -0.6644132 -0.3884572 -0.0344413 0.35414 0.5639224 # -0.2358238 0.7706838 -0.3650029 -0.54729 -0.2392456 -0.3285939] # [ 0.2127696 -0.6644132 -0.3884572 -0.0344413 0.35414 0.5639224 # -0.2358238 0.7706838 -0.3650029 -0.54729 -0.2392456 -0.3285939]] # [[ 0.0432173 -0.3811357 -0.4611054 -0.255436 0.4998702 0.6649145 # -0.3132874 0.5965794 -0.5760088 -0.5618317 -0.2404964 -0.4669401] # [ 0.0432173 -0.3811357 -0.4611054 -0.255436 0.4998702 0.6649145 # -0.3132874 0.5965794 -0.5760088 -0.5618317 -0.2404964 -0.4669401] # [ 0.0432173 -0.3811357 -0.4611054 -0.255436 0.4998702 0.6649145 # -0.3132874 0.5965794 -0.5760088 -0.5618317 -0.2404964 -0.4669401]] # [[ 0.1083845 -0.4397578 -0.4745184 -0.2148822 0.3674186 0.6907974 # -0.061549 0.452508 -0.5262724 -0.3184315 -0.4691838 -0.0438465] # [ 0.1083845 -0.4397578 -0.4745184 -0.2148822 0.3674186 0.6907974 # -0.061549 0.452508 -0.5262724 -0.3184315 -0.4691838 -0.0438465] # [ 0.1083845 -0.4397578 -0.4745184 -0.2148822 0.3674186 0.6907974 # -0.061549 0.452508 -0.5262724 -0.3184315 -0.4691838 -0.0438465]] # [[-0.1835401 -0.6232781 -0.3571274 0.2283377 0.5426646 0.6719067 # -0.8672301 0.0971878 -0.7561615 -0.5063094 0.5117968 -0.0985391] # [-0.1835401 -0.6232781 -0.3571274 0.2283377 0.5426646 0.6719067 # -0.8672301 0.0971878 -0.7561615 -0.5063094 0.5117968 -0.0985391] # [-0.1835401 -0.6232781 -0.3571274 0.2283377 0.5426646 0.6719067 # -0.8672301 0.0971878 -0.7561615 -0.5063094 0.5117968 -0.0985391]]] # [[[ 0.2451548 0.9127097 -0.6998036 0.6434992 0.1046313 0.6530996] # [ 0.2451548 0.9127097 -0.6998036 0.6434992 0.1046313 0.6530996] # [ 0.2451548 0.9127097 -0.6998036 0.6434992 0.1046313 0.6530996]] # [[-0.1760802 -0.546555 0.7547818 0.8418489 -0.2011115 0.1687339] # [-0.1760802 -0.546555 0.7547818 0.8418489 -0.2011115 0.1687339] # [-0.1760802 -0.546555 0.7547818 0.8418489 -0.2011115 0.1687339]] # [[-0.1835401 -0.6232781 -0.3571274 0.2283377 0.5426646 0.6719067] # [-0.1835401 -0.6232781 -0.3571274 0.2283377 0.5426646 0.6719067] # [-0.1835401 -0.6232781 -0.3571274 0.2283377 0.5426646 0.6719067]] # [[-0.3040171 0.6689512 -0.5059364 -0.4492912 -0.1206206 -0.3208488] # [-0.3040171 0.6689512 -0.5059364 -0.4492912 -0.1206206 -0.3208488] # [-0.3040171 0.6689512 -0.5059364 -0.4492912 -0.1206206 -0.3208488]]]
LSTM¶
- class pyvqnet.nn.lstm.LSTM(input_size, hidden_size, num_layers=1, batch_first=True, use_bias=True, bidirectional=False, dtype=None, name: str = '')¶
长短期记忆(LSTM)模块。支持双向LSTM, 堆叠多层LSTM等配置。单层单向LSTM计算公式如下:
\[\begin{split}\begin{array}{ll} \\ i_t = \sigma(W_{ii} x_t + b_{ii} + W_{hi} h_{t-1} + b_{hi}) \\ f_t = \sigma(W_{if} x_t + b_{if} + W_{hf} h_{t-1} + b_{hf}) \\ g_t = \tanh(W_{ig} x_t + b_{ig} + W_{hg} h_{t-1} + b_{hg}) \\ o_t = \sigma(W_{io} x_t + b_{io} + W_{ho} h_{t-1} + b_{ho}) \\ c_t = f_t \odot c_{t-1} + i_t \odot g_t \\ h_t = o_t \odot \tanh(c_t) \\ \end{array}\end{split}\]- Parameters:
input_size – 输入特征维度。
hidden_size – 隐藏特征维度。
num_layers – 堆叠LSTM层数,默认: 1。
batch_first – 如果为 True,则输入形状为 [batch_size,seq_len,feature_dim], 如果为 False, 则输入形状为 [seq_len,batch_size,feature_dim],默认为 True。
use_bias – 如果为 False,该模块不适用偏置项, 默认: True。
bidirectional – 如果为 True,变为双向LSTM, 默认: False。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 这个模块的名字, 默认为””。
- Returns:
LSTM 实例
Example:
from pyvqnet.nn import LSTM from pyvqnet.tensor import tensor rnn2 = LSTM(4, 6, 2, batch_first=False, bidirectional = True) input = tensor.ones([5, 3, 4]) h0 = tensor.ones([4, 3, 6]) c0 = tensor.ones([4, 3, 6]) output, (hn, cn) = rnn2(input, (h0, c0)) print(output) print(hn) print(cn) # [[[ 0.2732482 0.1701475 0.1449948 0.0736707 0.1340735 0.1299259 # 0.0551452 0.2563322 0.040974 0.1358014 -0.1953781 -0.061493 ] # [ 0.2732482 0.1701475 0.1449948 0.0736707 0.1340735 0.1299259 # 0.0551452 0.2563322 0.040974 0.1358014 -0.1953781 -0.061493 ] # [ 0.2732482 0.1701475 0.1449948 0.0736707 0.1340735 0.1299259 # 0.0551452 0.2563322 0.040974 0.1358014 -0.1953781 -0.061493 ]] # [[ 0.0973835 0.2728153 0.0826659 0.1486651 0.001023 -0.0002572 # 0.0662036 0.2953667 0.0374205 0.1520839 -0.1803852 -0.0302957] # [ 0.0973835 0.2728153 0.0826659 0.1486651 0.001023 -0.0002572 # 0.0662036 0.2953667 0.0374205 0.1520839 -0.1803852 -0.0302957] # [ 0.0973835 0.2728153 0.0826659 0.1486651 0.001023 -0.0002572 # 0.0662036 0.2953667 0.0374205 0.1520839 -0.1803852 -0.0302957]] # [[ 0.0228571 0.1898227 0.0312898 0.1559544 -0.0909701 -0.0543313 # 0.0921322 0.3542943 0.0323457 0.1877485 -0.1509136 0.0398105] # [ 0.0228571 0.1898227 0.0312898 0.1559544 -0.0909701 -0.0543313 # 0.0921322 0.3542943 0.0323457 0.1877485 -0.1509136 0.0398105] # [ 0.0228571 0.1898227 0.0312898 0.1559544 -0.0909701 -0.0543313 # 0.0921322 0.3542943 0.0323457 0.1877485 -0.1509136 0.0398105]] # [[-0.0164866 0.1411722 -0.002618 0.1457977 -0.1280925 -0.0702658 # 0.1419625 0.4266106 0.0363048 0.2426503 -0.0849762 0.1489675] # [-0.0164866 0.1411722 -0.002618 0.1457977 -0.1280925 -0.0702658 # 0.1419625 0.4266106 0.0363048 0.2426503 -0.0849762 0.1489675] # [-0.0164866 0.1411722 -0.002618 0.1457977 -0.1280925 -0.0702658 # 0.1419625 0.4266106 0.0363048 0.2426503 -0.0849762 0.1489675]] # [[-0.0223669 0.1591602 -0.0311901 0.0958475 -0.122227 -0.0682742 # 0.2645994 0.4319879 0.0528811 0.3815826 0.1058483 0.1233259] # [-0.0223669 0.1591602 -0.0311901 0.0958475 -0.122227 -0.0682742 # 0.2645994 0.4319879 0.0528811 0.3815826 0.1058483 0.1233259] # [-0.0223669 0.1591602 -0.0311901 0.0958475 -0.122227 -0.0682742 # 0.2645994 0.4319879 0.0528811 0.3815826 0.1058483 0.1233259]]] # [[[ 0.1752738 -0.0356635 0.2989266 0.20517 -0.0896036 0.5098922] # [ 0.1752738 -0.0356635 0.2989266 0.20517 -0.0896036 0.5098922] # [ 0.1752738 -0.0356635 0.2989266 0.20517 -0.0896036 0.5098922]] # [[-0.2443907 -0.0827548 -0.1557958 0.1731217 -0.0342197 -0.1101249] # [-0.2443907 -0.0827548 -0.1557958 0.1731217 -0.0342197 -0.1101249] # [-0.2443907 -0.0827548 -0.1557958 0.1731217 -0.0342197 -0.1101249]] # [[-0.0223669 0.1591602 -0.0311901 0.0958475 -0.122227 -0.0682742] # [-0.0223669 0.1591602 -0.0311901 0.0958475 -0.122227 -0.0682742] # [-0.0223669 0.1591602 -0.0311901 0.0958475 -0.122227 -0.0682742]] # [[ 0.0551452 0.2563322 0.040974 0.1358014 -0.1953781 -0.061493 ] # [ 0.0551452 0.2563322 0.040974 0.1358014 -0.1953781 -0.061493 ] # [ 0.0551452 0.2563322 0.040974 0.1358014 -0.1953781 -0.061493 ]]] # [[[ 0.3543518 -0.1842273 0.8745036 0.6013567 -0.1227313 1.0065726] # [ 0.3543518 -0.1842273 0.8745036 0.6013567 -0.1227313 1.0065726] # [ 0.3543518 -0.1842273 0.8745036 0.6013567 -0.1227313 1.0065726]] # [[-0.5912023 -0.2058601 -0.4632604 0.3671726 -0.0673411 -0.327456 ] # [-0.5912023 -0.2058601 -0.4632604 0.3671726 -0.0673411 -0.327456 ] # [-0.5912023 -0.2058601 -0.4632604 0.3671726 -0.0673411 -0.327456 ]] # [[-0.0393696 0.301177 -0.0757513 0.196299 -0.3163165 -0.1804099] # [-0.0393696 0.301177 -0.0757513 0.196299 -0.3163165 -0.1804099] # [-0.0393696 0.301177 -0.0757513 0.196299 -0.3163165 -0.1804099]] # [[ 0.1547394 0.4916601 0.1061193 0.2582704 -0.3499697 -0.1048216] # [ 0.1547394 0.4916601 0.1061193 0.2582704 -0.3499697 -0.1048216] # [ 0.1547394 0.4916601 0.1061193 0.2582704 -0.3499697 -0.1048216]]]
Dynamic_GRU¶
- class pyvqnet.nn.gru.Dynamic_GRU(input_size, hidden_size, num_layers=1, batch_first=True, use_bias=True, bidirectional=False, dtype=None, name: str = '')¶
将多层门控循环单元 (GRU) RNN 应用于动态长度输入序列。
第一个输入应该是定义了可变长度的批处理序列输入 通过
tensor.PackedSequence
类。tensor.PackedSequence
类可以构造为 连续调用下一个函数:pad_sequence
、pack_pad_sequence
。Dynamic_GRU 的第一个输出也是一个
tensor.PackedSequence
类, 可以使用tensor.pad_pack_sequence
将其解压缩为普通 QTensor。对于输入序列中的每个元素,每一层计算以下公式:
\[\begin{split}\begin{array}{ll} r_t = \sigma(W_{ir} x_t + b_{ir} + W_{hr} h_{(t-1)} + b_{hr}) \\ z_t = \sigma(W_{iz} x_t + b_{iz} + W_{hz} h_{(t-1)} + b_{hz}) \\ n_t = \tanh(W_{in} x_t + b_{in} + r_t * (W_{hn} h_{(t-1)}+ b_{hn})) \\ h_t = (1 - z_t) * n_t + z_t * h_{(t-1)} \end{array}\end{split}\]- Parameters:
input_size – 输入特征维度。
hidden_size – 隐藏的特征维度。
num_layers – 循环层数。 默认值:1
batch_first – 如果为 True,输入形状提供为 [批大小,序列长度,特征维度]。如果为 False,输入形状提供为 [序列长度,批大小,特征维度],默认为 True。
use_bias – 如果为False,则该层不使用偏置权重b_ih和b_hh。 默认值:True。
bidirectional – 如果为真,则成为双向 GRU。 默认值:False。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 这个模块的名字, 默认为””。
- Returns:
一个 Dynamic_GRU 类
Example:
from pyvqnet.nn import Dynamic_GRU from pyvqnet.tensor import tensor seq_len = [4,1,2] input_size = 4 batch_size =3 hidden_size = 2 ml = 2 rnn2 = Dynamic_GRU(input_size, hidden_size=2, num_layers=2, batch_first=False, bidirectional=True) a = tensor.arange(1, seq_len[0] * input_size + 1).reshape( [seq_len[0], input_size]) b = tensor.arange(1, seq_len[1] * input_size + 1).reshape( [seq_len[1], input_size]) c = tensor.arange(1, seq_len[2] * input_size + 1).reshape( [seq_len[2], input_size]) y = tensor.pad_sequence([a, b, c], False) input = tensor.pack_pad_sequence(y, seq_len, batch_first=False, enforce_sorted=False) h0 = tensor.ones([ml * 2, batch_size, hidden_size]) output, hn = rnn2(input, h0) seq_unpacked, lens_unpacked = \ tensor.pad_packed_sequence(output, batch_first=False) print(seq_unpacked) print(lens_unpacked) # [ # [[-0.3918380, 0.0056273, 0.9018179, 0.9006662], # [-0.3715909, 0.0307644, 0.9756137, 0.9705784], # [-0.3917399, 0.0057521, 0.9507942, 0.9456232]], # [[-0.6348240, -0.0603764, 0.9014163, 0.8903066], # [0., 0., 0., 0.], # [-0.6333261, -0.0592172, 0.9660671, 0.9580816]], # [[-0.4571511, 0.0210018, 0.9151242, 0.9011748], # [0., 0., 0., 0.], # [0., 0., 0., 0.]], # [[-0.3585358, 0.0918219, 0.9496037, 0.9391552], # [0., 0., 0., 0.], # [0., 0., 0., 0.]] # ] # [4 1 2]
Dynamic_RNN¶
- class pyvqnet.nn.rnn.Dynamic_RNN(input_size, hidden_size, num_layers=1, nonlinearity='tanh', batch_first=True, use_bias=True, bidirectional=False, dtype=None, name: str = '')¶
将循环神经网络 RNN 应用于动态长度输入序列。
第一个输入应该是定义了可变长度的批处理序列输入 通过
tensor.PackedSequence
类。tensor.PackedSequence
类可以构造为 连续调用下一个函数:pad_sequence
、pack_pad_sequence
。Dynamic_RNN 的第一个输出也是一个
tensor.PackedSequence
类, 可以使用tensor.pad_pack_sequence
将其解压缩为普通 QTensor。循环神经网络(RNN)模块,使用 \(\tanh\) 或 \(\text{ReLU}\) 作为激活函数。支持双向,多层配置。 单层单向RNN计算公式如下:
\[h_t = \tanh(W_{ih} x_t + b_{ih} + W_{hh} h_{(t-1)} + b_{hh})\]如果
nonlinearity
是'relu'
, 则 \(\text{ReLU}\) 将替代 \(\tanh\)。- Parameters:
input_size – 输入特征维度。
hidden_size – 隐藏特征维度。
num_layers – 堆叠RNN层数, 默认: 1。
nonlinearity – 非线性激活函数,默认为
'tanh'
。batch_first – 如果为 True, 则输入形状为 [批大小,序列长度,特征维度], 如果为 False, 则输入形状为 [序列长度,批大小,特征维度],默认为 True。
use_bias – 如果为 False, 该模块不适用偏置项,默认: True。
bidirectional – 如果为 True,变为双向RNN,默认: False。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 这个模块的名字, 默认为””。
- Returns:
Dynamic_RNN 实例
Example:
from pyvqnet.nn import Dynamic_RNN from pyvqnet.tensor import tensor seq_len = [4,1,2] input_size = 4 batch_size =3 hidden_size = 2 ml = 2 rnn2 = Dynamic_RNN(input_size, hidden_size=2, num_layers=2, batch_first=False, bidirectional=True, nonlinearity='relu') a = tensor.arange(1, seq_len[0] * input_size + 1).reshape( [seq_len[0], input_size]) b = tensor.arange(1, seq_len[1] * input_size + 1).reshape( [seq_len[1], input_size]) c = tensor.arange(1, seq_len[2] * input_size + 1).reshape( [seq_len[2], input_size]) y = tensor.pad_sequence([a, b, c], False) input = tensor.pack_pad_sequence(y, seq_len, batch_first=False, enforce_sorted=False) h0 = tensor.ones([ml * 2, batch_size, hidden_size]) output, hn = rnn2(input, h0) seq_unpacked, lens_unpacked = \ tensor.pad_packed_sequence(output, batch_first=False) print(seq_unpacked) print(lens_unpacked) # [ # [[1.2980951, 0., 0., 0.], # [1.5040692, 0., 0., 0.], # [1.4927036, 0., 0., 0.1065927]], # [[2.6561704, 0., 0., 0.2532321], # [0., 0., 0., 0.], # [3.1472805, 0., 0., 0.]], # [[5.1231661, 0., 0., 0.7596353], # [0., 0., 0., 0.], # [0., 0., 0., 0.]], # [[8.4954977, 0., 0., 0.8191229], # [0., 0., 0., 0.], # [0., 0., 0., 0.]] # ] # [4 1 2]
Dynamic_LSTM¶
- class pyvqnet.nn.lstm.Dynamic_LSTM(input_size, hidden_size, num_layers=1, batch_first=True, use_bias=True, bidirectional=False, dtype=None, name: str = '')¶
将长短期记忆(LSTM) RNN 应用于动态长度输入序列。
第一个输入应该是定义了可变长度的批处理序列输入 通过
tensor.PackedSequence
类。tensor.PackedSequence
类可以构造为 连续调用下一个函数:pad_sequence
、pack_pad_sequence
。Dynamic_LSTM 的第一个输出也是一个
tensor.PackedSequence
类, 可以使用tensor.pad_pack_sequence
将其解压缩为普通 QTensor。循环神经网络(RNN)模块,使用 \(\tanh\) 或 \(\text{ReLU}\) 作为激活函数。支持双向,多层配置。 单层单向RNN计算公式如下:
\[\begin{split}\begin{array}{ll} \\ i_t = \sigma(W_{ii} x_t + b_{ii} + W_{hi} h_{t-1} + b_{hi}) \\ f_t = \sigma(W_{if} x_t + b_{if} + W_{hf} h_{t-1} + b_{hf}) \\ g_t = \tanh(W_{ig} x_t + b_{ig} + W_{hg} h_{t-1} + b_{hg}) \\ o_t = \sigma(W_{io} x_t + b_{io} + W_{ho} h_{t-1} + b_{ho}) \\ c_t = f_t \odot c_{t-1} + i_t \odot g_t \\ h_t = o_t \odot \tanh(c_t) \\ \end{array}\end{split}\]- Parameters:
input_size – 输入特征维度。
hidden_size – 隐藏特征维度。
num_layers – 堆叠LSTM层数,默认: 1。
batch_first – 如果为 True,则输入形状为 [批大小,序列长度,特征维度], 如果为 False, 则输入形状为 [序列长度,批大小,特征维度],默认为 True。
use_bias – 如果为 False,该模块不适用偏置项, 默认: True。
bidirectional – 如果为 True,变为双向LSTM, 默认: False。
dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。
name – 这个模块的名字, 默认为””。
- Returns:
Dynamic_LSTM 实例
Example:
from pyvqnet.nn import Dynamic_LSTM from pyvqnet.tensor import tensor input_size = 2 hidden_size = 2 ml = 2 seq_len = [3, 4, 1] batch_size = 3 rnn2 = Dynamic_LSTM(input_size, hidden_size=hidden_size, num_layers=ml, batch_first=False, bidirectional=True) a = tensor.arange(1, seq_len[0] * input_size + 1).reshape( [seq_len[0], input_size]) b = tensor.arange(1, seq_len[1] * input_size + 1).reshape( [seq_len[1], input_size]) c = tensor.arange(1, seq_len[2] * input_size + 1).reshape( [seq_len[2], input_size]) a.requires_grad = True b.requires_grad = True c.requires_grad = True y = tensor.pad_sequence([a, b, c], False) input = tensor.pack_pad_sequence(y, seq_len, batch_first=False, enforce_sorted=False) h0 = tensor.ones([ml * 2, batch_size, hidden_size]) c0 = tensor.ones([ml * 2, batch_size, hidden_size]) output, (hn, cn) = rnn2(input, (h0, c0)) seq_unpacked, lens_unpacked = \ tensor.pad_packed_sequence(output, batch_first=False) print(seq_unpacked) print(lens_unpacked) # [ # [[0.2038177, 0.1139005, 0.2312966, -0.1140076], # [0.1992285, 0.1221137, 0.2277344, -0.3147154], # [0.2293468, 0.0681745, 0.2426863, 0.2572871]], # [[0.1398094, -0.0150359, 0.2513067, 0.0783743], # [0.1328388, -0.0031956, 0.2324090, -0.1962151], # [0., 0., 0., 0.]], # [[0.0898260, -0.0706460, 0.2396922, 0.2323916], # [0.0817787, -0.0449937, 0.2388873, -0.0000469], # [0., 0., 0., 0.]], # [[0., 0., 0., 0.], # [0.0532839, -0.0870574, 0.2397324, 0.2103822], # [0., 0., 0., 0.]] # ] # [3 4 1]
损失函数层¶
以下为神经网络常用的损失层。
Note
请注意,跟pytorch等框架不同的是,以下loss函数的前向函数中,第一个参数为标签,第二个参数为预测值。
MeanSquaredError¶
- class pyvqnet.nn.MeanSquaredError(name='')¶
计算输入 \(x\) 和目标值 \(y\) 之间的均方根误差。
若平方根误差可由如下函数描述:
\[\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad l_n = \left( x_n - y_n \right)^2,\]\(x\) 和 \(y\) 是任意形状的 QTensor , 总 \(n\) 个元素的均方根误差由下式计算。
\[\ell(x, y) = \operatorname{mean}(L)\]- Parameters:
name – 这个模块的名字, 默认为””。
- Returns:
一个均方根误差实例。
均方根误差前向计算函数的所需参数:
x: \((N, *)\) 预测值,其中 \(*\) 表示任意维度。
y: \((N, *)\), 目标值, 和输入一样维度的 QTensor 。
Note
请注意,跟pytorch等框架不同的是,以下MeanSquaredError函数的前向函数中,第一个参数为目标值,第二个参数为预测值。
Example:
from pyvqnet.tensor import QTensor, kfloat64 from pyvqnet.nn import MeanSquaredError y = QTensor([[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]], requires_grad=False, dtype=kfloat64) x = QTensor([[0.1, 0.05, 0.7, 0, 0.05, 0.1, 0, 0, 0, 0]], requires_grad=True, dtype=kfloat64) loss_result = MeanSquaredError() result = loss_result(y, x) print(result) # [0.0115000]
BinaryCrossEntropy¶
- class pyvqnet.nn.BinaryCrossEntropy(name='')¶
测量目标和输入之间的平均二元交叉熵损失。
未做平均运算的二元交叉熵如下式:
\[\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad l_n = - w_n \left[ y_n \cdot \log x_n + (1 - y_n) \cdot \log (1 - x_n) \right],\]若 \(N\) 为批的大小,则平均二元交叉熵.
\[\ell(x, y) = \operatorname{mean}(L)\]- Parameters:
name – 这个模块的名字, 默认为””。
- Returns:
一个平均二元交叉熵实例。
平均二元交叉熵误差前向计算函数的所需参数:
x: \((N, *)\) 预测值,其中 \(*\) 表示任意维度。
y: \((N, *)\), 目标值,和输入一样维度的 QTensor 。
Note
请注意,跟pytorch等框架不同的是,BinaryCrossEntropy函数的前向函数中,第一个参数为目标值,第二个参数为预测值。
Example:
from pyvqnet.tensor import QTensor from pyvqnet.nn import BinaryCrossEntropy x = QTensor([[0.3, 0.7, 0.2], [0.2, 0.3, 0.1]], requires_grad=True) y = QTensor([[0.0, 1.0, 0], [0.0, 0, 1]], requires_grad=False) loss_result = BinaryCrossEntropy() result = loss_result(y, x) result.backward() print(result) # [0.6364825]
CategoricalCrossEntropy¶
- class pyvqnet.nn.CategoricalCrossEntropy(name='')¶
该损失函数将 LogSoftmax 和 NLLLoss 同时计算的平均分类交叉熵。
损失函数计算方式如下,其中 class 为目标值的对应分类标签:
\[\text{loss}(x, y) = -\log\left(\frac{\exp(x[class])}{\sum_j \exp(x[j])}\right) = -x[class] + \log\left(\sum_j \exp(x[j])\right)\]- Parameters:
name – 这个模块的名字, 默认为””。
- Returns:
平均分类交叉熵实例。
误差前向计算函数的所需参数:
x: \((N, *)\) 预测值,其中 \(*\) 表示任意维度。
y: \((N, *)\), 目标值,和输入一样维度的 QTensor 。必须为64位整数,kint64。
Note
请注意,跟pytorch等框架不同的是,CategoricalCrossEntropy函数的前向函数中,第一个参数为目标值,第二个参数为预测值。
Example:
from pyvqnet.tensor import QTensor,kfloat32,kint64 from pyvqnet.nn import CategoricalCrossEntropy x = QTensor([[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]], requires_grad=True,dtype=kfloat32) y = QTensor([[0, 1, 0, 0, 0], [0, 1, 0, 0, 0], [1, 0, 0, 0, 0]], requires_grad=False,dtype=kint64) loss_result = CategoricalCrossEntropy() result = loss_result(y, x) print(result) # [3.7852428]
SoftmaxCrossEntropy¶
- class pyvqnet.nn.SoftmaxCrossEntropy(name='')¶
该损失函数将 LogSoftmax 和 NLLLoss 同时计算的平均分类交叉熵,并具有更高的数值稳定性。
损失函数计算方式如下,其中 class 为目标值的对应分类标签:
\[\text{loss}(x, y) = -\log\left(\frac{\exp(x[class])}{\sum_j \exp(x[j])}\right) = -x[class] + \log\left(\sum_j \exp(x[j])\right)\]- Parameters:
name – 这个模块的名字, 默认为””。
- Returns:
一个Softmax交叉熵损失函数实例
误差前向计算函数的所需参数:
x: \((N, *)\) 预测值,其中 \(*\) 表示任意维度。
y: \((N, *)\), 目标值,和输入一样维度的 QTensor 。必须为64位整数,kint64。
Note
请注意,跟pytorch等框架不同的是,SoftmaxCrossEntropy函数的前向函数中,第一个参数为目标值,第二个参数为预测值。
Example:
from pyvqnet.tensor import QTensor, kfloat32, kint64 from pyvqnet.nn import SoftmaxCrossEntropy x = QTensor([[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]], requires_grad=True, dtype=kfloat32) y = QTensor([[0, 1, 0, 0, 0], [0, 1, 0, 0, 0], [1, 0, 0, 0, 0]], requires_grad=False, dtype=kint64) loss_result = SoftmaxCrossEntropy() result = loss_result(y, x) result.backward() print(result) # [3.7852478]
NLL_Loss¶
- class pyvqnet.nn.NLL_Loss(name='')¶
平均负对数似然损失。 对C个类别的分类问题很有用。
x 是模型给出的概率形式的似然量。其尺寸可以是 \((N, C)\) or \((N, C, d_1, d_2, ..., d_K)\) 。 y 是损失函数期望的真值,包含 \([0, C-1]\) 的类别索引。
\[\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad l_n = - \sum_{n=1}^N \frac{1}{N}x_{n,y_n} \quad\]- Parameters:
name – 这个模块的名字, 默认为””。
- Returns:
一个NLL_Loss损失函数实例
误差前向计算函数的所需参数:
x: \((N, *)\),损失函数的输出预测值,可以为多维变量。
y: \((N, *)\),损失函数目标值。必须为64位整数,kint64。
Note
请注意,跟pytorch等框架不同的是,NLL_Loss函数的前向函数中,第一个参数为目标值,第二个参数为预测值。
Example:
from pyvqnet.tensor import QTensor, kint64 from pyvqnet.nn import NLL_Loss x = QTensor([ 0.9476322568516703, 0.226547421131723, 0.5944201443911326, 0.42830868492969476, 0.76414068655387, 0.00286059168094277, 0.3574236812873617, 0.9096948856639084, 0.4560809854582528, 0.9818027091583286, 0.8673569904602182, 0.9860275114020933, 0.9232667066664217, 0.303693313961628, 0.8461034903175555 ]) x.reshape_([1, 3, 1, 5]) x.requires_grad = True y = QTensor([[[2, 1, 0, 0, 2]]], dtype=kint64) loss_result = NLL_Loss() result = loss_result(y, x) print(result) #[-0.6187226]
CrossEntropyLoss¶
- class pyvqnet.nn.CrossEntropyLoss(name='')¶
该函数计算LogSoftmax以及NLL_Loss在一起的损失。
x 是包含未做归一化的输出.它的尺寸可以为 \((C)\) , \((N, C)\) 二维或 \((N, C, d_1, d_2, ..., d_K)\) 多维。
损失函数的公式如下,其中 class 为目标值的对应分类标签:
\[\text{loss}(x, y) = -\log\left(\frac{\exp(x[class])}{\sum_j \exp(x[j])}\right) = -x[class] + \log\left(\sum_j \exp(x[j])\right)\]- Parameters:
name – 这个模块的名字, 默认为””。
- Returns:
一个CrossEntropyLoss损失函数实例
误差前向计算函数的所需参数:
x: \((N, *)\),损失函数的输出,可以为多维变量。
y: \((N, *)\),损失函数期望的真值。必须为64位整数,kint64。
Note
请注意,跟pytorch等框架不同的是,CrossEntropyLoss函数的前向函数中,第一个参数为目标值,第二个参数为预测值。
Example:
from pyvqnet.tensor import QTensor, kint64 from pyvqnet.nn import CrossEntropyLoss x = QTensor([ 0.9476322568516703, 0.226547421131723, 0.5944201443911326, 0.42830868492969476, 0.76414068655387, 0.00286059168094277, 0.3574236812873617, 0.9096948856639084, 0.4560809854582528, 0.9818027091583286, 0.8673569904602182, 0.9860275114020933, 0.9232667066664217, 0.303693313961628, 0.8461034903175555 ]) x.reshape_([1, 3, 1, 5]) x.requires_grad = True y = QTensor([[[2, 1, 0, 0, 2]]], dtype=kint64) loss_result = CrossEntropyLoss() result = loss_result(y, x) print(result) #[1.1508200]
激活函数¶
Activation¶
- class pyvqnet.nn.activation.Activation¶
激活的基类。 特定的激活函数继承了这个类。
Sigmoid¶
- class pyvqnet.nn.Sigmoid(name: str = '')¶
Sigmoid激活函数层。
\[\text{Sigmoid}(x) = \frac{1}{1 + \exp(-x)}\]- Parameters:
name – 激活函数层的命名,默认为””。
- Returns:
一个Sigmoid激活函数层实例。
Examples:
from pyvqnet.nn import Sigmoid from pyvqnet.tensor import QTensor layer = Sigmoid() y = layer(QTensor([1.0, 2.0, 3.0, 4.0])) print(y) # [0.7310586, 0.8807970, 0.9525741, 0.9820138]
Softplus¶
- class pyvqnet.nn.Softplus(name: str = '')¶
Softplus激活函数层。
\[\text{Softplus}(x) = \log(1 + \exp(x))\]- Parameters:
name – 激活函数层的命名,默认为””。
- Returns:
一个Softplus激活函数层实例。
Examples:
from pyvqnet.nn import Softplus from pyvqnet.tensor import QTensor layer = Softplus() y = layer(QTensor([1.0, 2.0, 3.0, 4.0])) print(y) # [1.3132616, 2.1269281, 3.0485873, 4.0181499]
Softsign¶
- class pyvqnet.nn.Softsign(name: str = '')¶
Softsign 激活函数层。
\[\text{SoftSign}(x) = \frac{x}{ 1 + |x|}\]- Parameters:
name – 激活函数层的命名,默认为””。
- Returns:
一个Softsign 激活函数层实例。
Examples:
from pyvqnet.nn import Softsign from pyvqnet.tensor import QTensor layer = Softsign() y = layer(QTensor([1.0, 2.0, 3.0, 4.0])) print(y) # [0.5000000, 0.6666667, 0.7500000, 0.8000000]
Softmax¶
- class pyvqnet.nn.Softmax(axis: int = -1, name: str = '')¶
Softmax 激活函数层。
\[\text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}\]- Parameters:
axis – 计算的维度(最后一个轴为-1),默认值 = -1。
name – 激活函数层的命名,默认为””。
- Returns:
一个Softmax 激活函数层实例。
Examples:
from pyvqnet.nn import Softmax from pyvqnet.tensor import QTensor layer = Softmax() y = layer(QTensor([1.0, 2.0, 3.0, 4.0])) print(y) # [0.0320586, 0.0871443, 0.2368828, 0.6439142]
HardSigmoid¶
- class pyvqnet.nn.HardSigmoid(name: str = '')¶
HardSigmoid 激活函数层。
\[\begin{split}\text{Hardsigmoid}(x) = \begin{cases} 0 & \text{ if } x \le -3, \\ 1 & \text{ if } x \ge +3, \\ x / 6 + 1 / 2 & \text{otherwise} \end{cases}\end{split}\]- Parameters:
name – 激活函数层的命名,默认为””。
- Returns:
一个HardSigmoid 激活函数层实例。
Examples:
from pyvqnet.nn import HardSigmoid from pyvqnet.tensor import QTensor layer = HardSigmoid() y = layer(QTensor([1.0, 2.0, 3.0, 4.0])) print(y) # [0.6666667, 0.8333334, 1., 1.]
ReLu¶
- class pyvqnet.nn.ReLu(name: str = '')¶
ReLu 整流线性单元激活函数层。
\[\begin{split}\text{ReLu}(x) = \begin{cases} x, & \text{ if } x > 0\\ 0, & \text{ if } x \leq 0 \end{cases}\end{split}\]- Parameters:
name – 激活函数层的命名,默认为””。
- Returns:
一个ReLu 激活函数层实例。
Examples:
from pyvqnet.nn import ReLu from pyvqnet.tensor import QTensor layer = ReLu() y = layer(QTensor([-1, 2.0, -3, 4.0])) print(y) # [0., 2., 0., 4.]
LeakyReLu¶
- class pyvqnet.nn.LeakyReLu(alpha: float = 0.01, name: str = '')¶
LeakyReLu 带泄露的修正线性单元激活函数层。
\[\begin{split}\text{LeakyRelu}(x) = \begin{cases} x, & \text{ if } x \geq 0 \\ \alpha * x, & \text{ otherwise } \end{cases}\end{split}\]- Parameters:
alpha – LeakyRelu 系数,默认:0.01。
name – 激活函数层的命名,默认为””。
- Returns:
一个LeakyReLu 激活函数层实例。
Examples:
from pyvqnet.nn import LeakyReLu from pyvqnet.tensor import QTensor layer = LeakyReLu() y = layer(QTensor([-1, 2.0, -3, 4.0])) print(y) # [-0.0100000, 2., -0.0300000, 4.]
ELU¶
- class pyvqnet.nn.ELU(alpha: float = 1, name: str = '')¶
ELU 指数线性单位激活函数层。
\[\begin{split}\text{ELU}(x) = \begin{cases} x, & \text{ if } x > 0\\ \alpha * (\exp(x) - 1), & \text{ if } x \leq 0 \end{cases}\end{split}\]- Parameters:
alpha – ELU 系数,默认:1。
name – 激活函数层的命名,默认为””。
- Returns:
ELU 激活函数层实例。
Examples:
from pyvqnet.nn import ELU from pyvqnet.tensor import QTensor layer = ELU() y = layer(QTensor([-1, 2.0, -3, 4.0])) print(y) # [-0.6321205, 2., -0.9502130, 4.]
Tanh¶
- class pyvqnet.nn.Tanh(name: str = '')¶
Tanh双曲正切激活函数.
\[\text{Tanh}(x) = \frac{\exp(x) - \exp(-x)} {\exp(x) + \exp(-x)}\]- Parameters:
name – 激活函数层的命名,默认为””。
- Returns:
Tanh 激活函数层实例。
Examples:
from pyvqnet.nn import Tanh from pyvqnet.tensor import QTensor layer = Tanh() y = layer(QTensor([-1, 2.0, -3, 4.0])) print(y) # [-0.7615942, 0.9640276, -0.9950548, 0.9993293]
优化器模块¶
Optimizer¶
- class pyvqnet.optim.optimizer.Optimizer(params, lr=0.01)¶
所有优化器的基类。
- Parameters:
params – 需要优化的模型参数。
lr – 学习率,默认值:0.01。
Adadelta¶
- class pyvqnet.optim.adadelta.Adadelta(params, lr=0.01, beta=0.99, epsilon=1e-08)¶
ADADELTA: An Adaptive Learning Rate Method。
参考:https://arxiv.org/abs/1212.5701。
\[\begin{split}E(g_t^2) &= \beta * E(g_{t-1}^2) + (1-\beta) * g^2\\ Square\_avg &= \sqrt{ ( E(dx_{t-1}^2) + \epsilon ) / ( E(g_t^2) + \epsilon ) }\\ E(dx_t^2) &= \beta * E(dx_{t-1}^2) + (1-\beta) * (-g*square\_avg)^2 \\ param\_new &= param - lr * Square\_avg\end{split}\]- Parameters:
params – 需要优化的模型参数。
lr – 学习率(默认值:0.01)。
beta – 用于计算平方梯度的运行平均值(默认值:0.99)。
epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。
- Returns:
一个 Adadelta 优化器。
Example:
import numpy as np from pyvqnet.optim import adadelta from pyvqnet.tensor import QTensor w = np.arange(24).reshape(1, 2, 3, 4).astype(np.float64) param = QTensor(w) param.grad = QTensor(np.arange(24).reshape(1, 2, 3, 4).astype(np.float64)) params = [param] opti = adadelta.Adadelta(params) for i in range(1, 3): opti._step() print(param) # [ # [[[0., 0.9999900, 1.9999900, 2.9999900], # [3.9999900, 4.9999900, 5.9999900, 6.9999900], # [7.9999900, 8.9999905, 9.9999905, 10.9999905]], # [[11.9999905, 12.9999905, 13.9999905, 14.9999905], # [15.9999905, 16.9999905, 17.9999905, 18.9999905], # [19.9999905, 20.9999905, 21.9999905, 22.9999905]]] # ] # [ # [[[0., 0.9999800, 1.9999800, 2.9999800], # [3.9999800, 4.9999800, 5.9999800, 6.9999800], # [7.9999800, 8.9999800, 9.9999800, 10.9999800]], # [[11.9999800, 12.9999800, 13.9999800, 14.9999800], # [15.9999800, 16.9999809, 17.9999809, 18.9999809], # [19.9999809, 20.9999809, 21.9999809, 22.9999809]]] # ]
Adagrad¶
- class pyvqnet.optim.adagrad.Adagrad(params, lr=0.01, epsilon=1e-08)¶
Adagrad自适应梯度优化器。
参考:https://databricks.com/glossary/adagrad。
\[\begin{split}\begin{align} moment\_new &= moment + g * g\\param\_new &= param - \frac{lr * g}{\sqrt{moment\_new} + \epsilon} \end{align}\end{split}\]- Parameters:
params – 需要优化的模型参数。
lr – 学习率(默认值:0.01)。
epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。
- Returns:
一个 Adagrad 优化器。
Example:
import numpy as np from pyvqnet.optim import adagrad from pyvqnet.tensor import QTensor w = np.arange(24).reshape(1,2,3,4).astype(np.float64) param = QTensor(w) param.grad = QTensor(np.arange(24).reshape(1,2,3,4).astype(np.float64)) params = [param] opti = adagrad.Adagrad(params) for i in range(1,3): opti._step() print(param) # [ # [[[0., 0.9900000, 1.9900000, 2.9900000], # [3.9900000, 4.9899998, 5.9899998, 6.9899998], # [7.9899998, 8.9899998, 9.9899998, 10.9899998]], # [[11.9899998, 12.9899998, 13.9899998, 14.9899998], # [15.9899998, 16.9899998, 17.9899998, 18.9899998], # [19.9899998, 20.9899998, 21.9899998, 22.9899998]]] # ] # [ # [[[0., 0.9829289, 1.9829290, 2.9829290], # [3.9829290, 4.9829288, 5.9829288, 6.9829288], # [7.9829288, 8.9829283, 9.9829283, 10.9829283]], # [[11.9829283, 12.9829283, 13.9829283, 14.9829283], # [15.9829283, 16.9829292, 17.9829292, 18.9829292], # [19.9829292, 20.9829292, 21.9829292, 22.9829292]]] # ]
Adam¶
- class pyvqnet.optim.adam.Adam(params, lr=0.01, beta1=0.9, beta2=0.999, epsilon=1e-08, amsgrad: bool = False)¶
Adam优化器,它可以使用一阶矩估计动态调整每个参数的学习率和梯度的二阶矩估计。
参考:https://arxiv.org/abs/1412.6980。
\[t = t + 1\]\[moment\_1\_new=\beta1∗moment\_1+(1−\beta1)g\]\[moment\_2\_new=\beta2∗moment\_2+(1−\beta2)g*g\]\[lr = lr*\frac{\sqrt{1-\beta2^t}}{1-\beta1^t}\]如果参数 amsgrad 为 True
\[moment\_2\_max = max(moment\_2\_max,moment\_2)\]\[param\_new=param-lr*\frac{moment\_1}{\sqrt{moment\_2\_max}+\epsilon}\]否则
\[param\_new=param-lr*\frac{moment\_1}{\sqrt{moment\_2}+\epsilon}\]- Parameters:
params – 需要优化的模型参数。
lr – 学习率(默认值:0.01)。
beta1 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.9)。
beta2 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.999)。
epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。
amsgrad – 是否使用该算法的 AMSGrad 变体(默认值:False)。
- Returns:
一个 Adam 优化器。
Example:
import numpy as np from pyvqnet.optim import adam from pyvqnet.tensor import QTensor w = np.arange(24).reshape(1,2,3,4).astype(np.float64) param = QTensor(w) param.grad = QTensor(np.arange(24).reshape(1,2,3,4).astype(np.float64)) params = [param] opti = adam.Adam(params) for i in range(1,3): opti._step() print(param) # [ # [[[0., 0.9900000, 1.9900000, 2.9900000], # [3.9900000, 4.9899998, 5.9899998, 6.9899998], # [7.9899998, 8.9899998, 9.9899998, 10.9899998]], # [[11.9899998, 12.9899998, 13.9899998, 14.9899998], # [15.9899998, 16.9899998, 17.9899998, 18.9899998], # [19.9899998, 20.9899998, 21.9899998, 22.9899998]]] # ] # [ # [[[0., 0.9800000, 1.9800000, 2.9800000], # [3.9800000, 4.9799995, 5.9799995, 6.9799995], # [7.9799995, 8.9799995, 9.9799995, 10.9799995]], # [[11.9799995, 12.9799995, 13.9799995, 14.9799995], # [15.9799995, 16.9799995, 17.9799995, 18.9799995], # [19.9799995, 20.9799995, 21.9799995, 22.9799995]]] # ]
Adamax¶
- class pyvqnet.optim.adamax.Adamax(params, lr=0.01, beta1=0.9, beta2=0.999, epsilon=1e-08)¶
实现 Adamax 优化器(基于无穷范数的 Adam 变体)。
参考:https://arxiv.org/abs/1412.6980。
\[\begin{split}\\t = t + 1\end{split}\]\[moment\_new=\beta1∗moment+(1−\beta1)g\]\[norm\_new = \max{(\beta1∗norm+\epsilon, \left|g\right|)}\]\[lr = \frac{lr}{1-\beta1^t}\]\[\begin{split}param\_new = param − lr*\frac{moment\_new}{norm\_new}\\\end{split}\]- Parameters:
params – 需要优化的模型参数。
lr – 学习率(默认值:0.01)。
beta1 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.9)。
beta2 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.999)。
epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。
- Returns:
一个 Adamax 优化器。
Example:
import numpy as np from pyvqnet.optim import adamax from pyvqnet.tensor import QTensor w = np.arange(24).reshape(1,2,3,4).astype(np.float64) param = QTensor(w) param.grad = QTensor(np.arange(24).reshape(1,2,3,4).astype(np.float64)) params = [param] opti = adamax.Adamax(params) for i in range(1,3): opti._step() print(param) # [ # [[[0., 0.9900000, 1.9900000, 2.9900000], # [3.9900000, 4.9899998, 5.9899998, 6.9899998], # [7.9899998, 8.9899998, 9.9899998, 10.9899998]], # [[11.9899998, 12.9899998, 13.9899998, 14.9899998], # [15.9899998, 16.9899998, 17.9899998, 18.9899998], # [19.9899998, 20.9899998, 21.9899998, 22.9899998]]] # ] # [ # [[[0., 0.9800000, 1.9800000, 2.9800000], # [3.9800000, 4.9799995, 5.9799995, 6.9799995], # [7.9799995, 8.9799995, 9.9799995, 10.9799995]], # [[11.9799995, 12.9799995, 13.9799995, 14.9799995], # [15.9799995, 16.9799995, 17.9799995, 18.9799995], # [19.9799995, 20.9799995, 21.9799995, 22.9799995]]] # ]
RMSProp¶
- class pyvqnet.optim.rmsprop.RMSProp(params, lr=0.01, beta=0.99, epsilon=1e-08)¶
RMSprop 均方根传播算法优化器。
参考:https://arxiv.org/pdf/1308.0850v5.pdf。
\[s_{t+1} = s_{t} + (1 - \beta)*(g)^2\]\[param_new = param - \frac{g}{\sqrt{s_{t+1}} + epsilon}\]- Parameters:
params – 需要优化的模型参数。
lr – 学习率(默认值:0.01)。
beta – 用于计算梯度及其平方的运行平均值的系数(默认值:0.99)。
epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。
- Returns:
一个 RMSProp 优化器。
Example:
import numpy as np from pyvqnet.optim import rmsprop from pyvqnet.tensor import QTensor w = np.arange(24).reshape(1,2,3,4).astype(np.float64) param = QTensor(w) param.grad = QTensor(np.arange(24).reshape(1,2,3,4).astype(np.float64)) params = [param] opti = rmsprop.RMSProp(params) for i in range(1,3): opti._step() print(param) # [ # [[[0., 0.9000000, 1.9000000, 2.8999999], # [3.8999999, 4.9000001, 5.9000001, 6.9000001], # [7.9000001, 8.8999996, 9.8999996, 10.8999996]], # [[11.8999996, 12.8999996, 13.8999996, 14.8999996], # [15.8999996, 16.8999996, 17.8999996, 18.8999996], # [19.8999996, 20.8999996, 21.8999996, 22.8999996]]] # ] # [ # [[[0., 0.8291118, 1.8291118, 2.8291118], # [3.8291118, 4.8291121, 5.8291121, 6.8291121], # [7.8291121, 8.8291111, 9.8291111, 10.8291111]], # [[11.8291111, 12.8291111, 13.8291111, 14.8291111], # [15.8291111, 16.8291111, 17.8291111, 18.8291111], # [19.8291111, 20.8291111, 21.8291111, 22.8291111]]] # ]
SGD¶
- class pyvqnet.optim.sgd.SGD(params, lr=0.01, momentum=0, nesterov=False)¶
随机梯度下降优化器。
参考:https://en.wikipedia.org/wiki/Stochastic_gradient_descent。
\[\begin{split}\\param\_new=param-lr*g\\\end{split}\]- Parameters:
params – 需要优化的模型参数。
lr – 学习率(默认值:0.01)。
momentum – 动量因子(默认值:0)。
nesterov – 启用 Nesterov 动量 (默认: False)。
- Returns:
一个 SGD 优化器。
Example:
import numpy as np from pyvqnet.optim import sgd from pyvqnet.tensor import QTensor w = np.arange(24).reshape(1,2,3,4).astype(np.float64) param = QTensor(w) param.grad = QTensor(np.arange(24).reshape(1,2,3,4).astype(np.float64)) params = [param] opti = sgd.SGD(params) for i in range(1,3): opti._step() print(param) # [ # [[[0., 0.9900000, 1.9800000, 2.9700000], # [3.9600000, 4.9499998, 5.9400001, 6.9299998], # [7.9200001, 8.9099998, 9.8999996, 10.8900003]], # [[11.8800001, 12.8699999, 13.8599997, 14.8500004], # [15.8400002, 16.8299999, 17.8199997, 18.8099995], # [19.7999992, 20.7900009, 21.7800007, 22.7700005]]] # ] # [ # [[[0., 0.9800000, 1.9600000, 2.9400001], # [3.9200001, 4.8999996, 5.8800001, 6.8599997], # [7.8400002, 8.8199997, 9.7999992, 10.7800007]], # [[11.7600002, 12.7399998, 13.7199993, 14.7000008], # [15.6800003, 16.6599998, 17.6399994, 18.6199989], # [19.5999985, 20.5800018, 21.5600014, 22.5400009]]] # ]
Rotosolve¶
Rotosolve算法它允许相对于其他参数的固定值直接跳转到单个参数的最佳值,直接找到量子线路最佳参数的优化算法。
- class pyvqnet.optim.rotosolve.Rotosolve(max_iter=50)¶
Rotosolve:可以使用 rotosolve 算法来最小化线性组合的量子测量期望值。 请参阅以下论文:
https://arxiv.org/abs/1903.12166, Ken M. Nakanishi。
https://arxiv.org/abs/1905.09692, Mateusz Ostaszewski。
- Parameters:
max_iter – rotosolve 更新的最大迭代次数。
- Returns:
一个 Rotosolve 优化器。
Example:
from pyvqnet.optim.rotosolve import Rotosolve import pyqpanda as pq from pyvqnet.tensor import QTensor,kfloat64 from pyvqnet.qnn.measure import expval machine = pq.CPUQVM() machine.init_qvm() nqbits = machine.qAlloc_many(2) def gen(param, generators, qbits, circuit): if generators == "X": circuit.insert(pq.RX(qbits, param)) elif generators == "Y": circuit.insert(pq.RY(qbits, param)) else: circuit.insert(pq.RZ(qbits, param)) def circuits(params, generators, circuit): gen(params[0], generators[0], nqbits[0], circuit) gen(params[1], generators[1], nqbits[1], circuit) circuit.insert(pq.CNOT(nqbits[0], nqbits[1])) prog = pq.QProg() prog.insert(circuit) return prog def ansatz1(params: QTensor, generators): circuit = pq.QCircuit() params = params.getdata() prog = circuits(params, generators, circuit) return expval(machine, prog, {"Z0": 1}, nqbits), expval(machine, prog, {"Y1": 1}, nqbits) def ansatz2(params: QTensor, generators): circuit = pq.QCircuit() params = params.getdata() prog = circuits(params, generators, circuit) return expval(machine, prog, {"X0": 1}, nqbits) def loss(params): Z, Y = ansatz1(params, ["X", "Y"]) X = ansatz2(params, ["X", "Y"]) return 0.5 * Y + 0.8 * Z - 0.2 * X t = QTensor([0.3, 0.25],dtype=kfloat64) opt = Rotosolve(max_iter=5) costs_rotosolve = opt.minimize(t, loss) print(costs_rotosolve) #[0.7642691884821847, -0.799999999999997, -0.799999999999997, -0.799999999999997, -0.799999999999997]
指标模块¶
MSE¶
- class pyvqnet.utils.metrics.MSE(y_true_Qtensor, y_pred_Qtensor)¶
计算均方误差 (Mean Squared Error, MSE)。
- Parameters:
y_true_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,真实目标值。
y_pred_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,估计目标值。
- Returns:
输出float结果。
Example:
import numpy as np from pyvqnet.tensor import tensor from pyvqnet.utils import metrics as vqnet_metrics from pyvqnet import _core _vqnet = _core.vqnet y_true_Qtensor = tensor.arange(1, 12) y_pred_Qtensor = tensor.arange(4, 15) result = vqnet_metrics.MSE(y_true_Qtensor, y_pred_Qtensor) print(result) # 9.0 y_true_Qtensor = tensor.arange(1, 13).reshape([3, 4]) y_pred_Qtensor = tensor.arange(4, 16).reshape([3, 4]) result = vqnet_metrics.MSE(y_true_Qtensor, y_pred_Qtensor) print(result) # 9.0
RMSE¶
- class pyvqnet.utils.metrics.RMSE(y_true_Qtensor, y_pred_Qtensor)¶
计算均方根误差 (Root Mean Square Error, RMSE) 。
- Parameters:
y_true_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,真实目标值。
y_pred_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,估计目标值。
- Returns:
输出float结果。
Example:
import numpy as np from pyvqnet.tensor import tensor from pyvqnet.utils import metrics as vqnet_metrics from pyvqnet import _core _vqnet = _core.vqnet y_true_Qtensor = tensor.arange(1, 12) y_pred_Qtensor = tensor.arange(4, 15) result = vqnet_metrics.RMSE(y_true_Qtensor, y_pred_Qtensor) print(result) # 3.0 y_true_Qtensor = tensor.arange(1, 13).reshape([3, 4]) y_pred_Qtensor = tensor.arange(4, 16).reshape([3, 4]) result = vqnet_metrics.RMSE(y_true_Qtensor, y_pred_Qtensor) print(result) # 3.0
MAE¶
- class pyvqnet.utils.metrics.MAE(y_true_Qtensor, y_pred_Qtensor)¶
计算预测值和真实值之间绝对平均误差 (Mean Absolute Error , MAE) 。
- Parameters:
y_true_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,真实目标值。
y_pred_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,估计目标值。
- Returns:
输出float结果。
Example:
import numpy as np from pyvqnet.tensor import tensor from pyvqnet.utils import metrics as vqnet_metrics from pyvqnet import _core _vqnet = _core.vqnet y_true_Qtensor = tensor.arange(1, 12) y_pred_Qtensor = tensor.arange(4, 15) result = vqnet_metrics.MAE(y_true_Qtensor, y_pred_Qtensor) print(result) # 3.0 y_true_Qtensor = tensor.arange(1, 13).reshape([3, 4]) y_pred_Qtensor = tensor.arange(4, 16).reshape([3, 4]) result = vqnet_metrics.MAE(y_true_Qtensor, y_pred_Qtensor) print(result) # 3.0
R_Square¶
- class pyvqnet.utils.metrics.R_Square(y_true_Qtensor, y_pred_Qtensor, sample_weight=None)¶
计算预测值和真实值之间的R方分数。 可能的最佳分数为1.0,可以为负(因为模型可以任意恶化)。不考虑输入特征的常数模型,将获得0.0的R^2分数。
- Parameters:
y_true_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,真实目标值。
y_pred_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,估计目标值。
sample_weight – 形状类似(n_samples,)的数组,可选样本权重,默认为None。
- Returns:
输出float结果。
Example:
import numpy as np from pyvqnet.tensor import tensor from pyvqnet.utils import metrics as vqnet_metrics from pyvqnet import _core _vqnet = _core.vqnet y_true_Qtensor = tensor.arange(1, 12) y_pred_Qtensor = tensor.arange(4, 15) result = vqnet_metrics.R_Square(y_true_Qtensor, y_pred_Qtensor) print(result) # 0.09999999999999998 y_true_Qtensor = tensor.arange(1, 13).reshape([3, 4]) y_pred_Qtensor = tensor.arange(4, 16).reshape([3, 4]) result = vqnet_metrics.R_Square(y_true_Qtensor, y_pred_Qtensor) print(result) # 0.15625
precision_recall_f1_2_score¶
- class pyvqnet.utils.metrics.precision_recall_f1_2_score(y_true_Qtensor, y_pred_Qtensor)¶
计算2分类任务下预测值的精确率,召回率和F1分数。其中预测值和真值需要是形状类似(n_samples,)的QTensor,值为0或1,代表两个类的标签。
- Parameters:
y_true_Qtensor – 一维QTensor的输入,形状类似(n_samples,),真实目标值。
y_pred_Qtensor – 一维QTensor的输入,形状类似(n_samples,),估计目标值。
- Returns:
precision - 精确率
recall - 召回率
f1 - F1 分数
Example:
import numpy as np from pyvqnet.tensor import tensor from pyvqnet.utils import metrics as vqnet_metrics from pyvqnet import _core _vqnet = _core.vqnet y_true_Qtensor = tensor.QTensor([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) y_pred_Qtensor = tensor.QTensor([0, 0, 1, 1, 1, 0, 0, 1, 1, 1]) precision, recall, f1 = vqnet_metrics.precision_recall_f1_2_score( y_true_Qtensor, y_pred_Qtensor) print(precision, recall, f1) # 0.5 0.6 0.5454545454545454
precision_recall_f1_N_score¶
- class pyvqnet.utils.metrics.precision_recall_f1_N_score(y_true_Qtensor, y_pred_Qtensor, N, average)¶
多分类任务的精确率,召回率,F1分数计算。其中预测值和真值是形状类似(n_samples,)的QTensor,值为0到N-1的整数,代表N个类的标签。
- Parameters:
y_true_Qtensor – 一维QTensor的输入,真实目标值。
y_pred_Qtensor – 一维QTensor的输入,估计目标值。
N – N类(类别数)。
average –
string, [‘micro’, ‘macro’, ‘weighted’]。 多类/多标签目标需要此参数。
'micro'
: 通过计算总真正数来全局计算指标,假阴性和假阳性。'macro'
: 计算每个标签的指标,并找到其未加权值。意思是不考虑标签的平衡。'weighted'
: 计算每个标签的指标,并找到它们的平均值(每个标签的真实实例数)。这改变'macro'
以解释标签不平衡; 这可能会导致F分数不在精度和召回之间。
- Returns:
precision - 精确率
recall - 召回率
f1 - F1 分数
Example:
import numpy as np from pyvqnet.tensor import tensor from pyvqnet.utils import metrics as vqnet_metrics from pyvqnet import _core _vqnet = _core.vqnet reference_list = [1, 1, 2, 2, 2, 3, 3, 3, 3, 3] prediciton_list = [1, 2, 2, 2, 3, 1, 2, 3, 3, 3] y_true_Qtensor = tensor.QTensor(reference_list) y_pred_Qtensor = tensor.QTensor(prediciton_list) precision_micro, recall_micro, f1_micro = vqnet_metrics.precision_recall_f1_N_score( y_true_Qtensor, y_pred_Qtensor, 3, average='micro') print(precision_micro, recall_micro, f1_micro) # 0.6 0.6 0.6 precision_macro, recall_macro, f1_macro = vqnet_metrics.precision_recall_f1_N_score( y_true_Qtensor, y_pred_Qtensor, 3, average='macro') print(precision_macro, recall_macro, f1_macro) # 0.5833333333333334 0.5888888888888889 0.5793650793650794 precision_weighted, recall_weighted, f1_weighted = vqnet_metrics.precision_recall_f1_N_score( y_true_Qtensor, y_pred_Qtensor, 3, average='weighted') print(precision_weighted, recall_weighted, f1_weighted) # 0.625 0.6 0.6047619047619047
precision_recall_f1_Multi_score¶
- class pyvqnet.utils.metrics.precision_recall_f1_Multi_score(y_true_Qtensor, y_pred_Qtensor, N, average)¶
多分类任务的精确率,召回率,F1分数计算。其中预测值和真值是形状类似(n_samples,N)的QTensor,预测值和真实标签必须为0-1独热编码的形式。
- Parameters:
y_true_Qtensor – 二维QTensor的输入,真实目标值。
y_pred_Qtensor – 二维QTensor的输入,估计目标值。
N – N类(类别数)。
average –
string, [‘micro’, ‘macro’, ‘weighted’]。 多类/多标签目标需要此参数。
'micro'
: 通过计算总真正数来全局计算指标,假阴性和假阳性。'macro'
: 计算每个标签的指标,并找到其未加权值。意思是不考虑标签的平衡。'weighted'
: 计算每个标签的指标,并找到它们的平均值(每个标签的真实实例数)。这改变'macro'
以解释标签不平衡; 这可能会导致F分数不在精度和召回之间。
- Returns:
precision - 精确率
recall - 召回率
f1 - F1 分数
Example:
import numpy as np from pyvqnet.tensor import tensor from pyvqnet.utils import metrics as vqnet_metrics from pyvqnet import _core _vqnet = _core.vqnet reference_list = [[1, 0], [0, 1], [0, 0], [1, 1], [1, 0]] prediciton_list = [[1, 0], [0, 0], [1, 0], [0, 0], [0, 0]] y_true_Qtensor = tensor.QTensor(reference_list) y_pred_Qtensor = tensor.QTensor(prediciton_list) micro_precision, micro_recall, micro_f1 = vqnet_metrics.precision_recall_f1_Multi_score(y_true_Qtensor, y_pred_Qtensor, 2, average='micro') print(micro_precision, micro_recall, micro_f1) # 0.5 0.2 0.28571428571428575 macro_precision, macro_recall, macro_f1 = vqnet_metrics.precision_recall_f1_Multi_score(y_true_Qtensor, y_pred_Qtensor, 2, average='macro') print(macro_precision, macro_recall, macro_f1) # 0.25 0.16666666666666666 0.2 weighted_precision, weighted_recall, weighted_f1 = vqnet_metrics.precision_recall_f1_Multi_score(y_true_Qtensor, y_pred_Qtensor, 2, average='weighted') print(weighted_precision, weighted_recall, weighted_f1) # 0.3 0.19999999999999998 0.24 reference_list = [[1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 1, 0], [1, 0, 1]] prediciton_list = [[1, 0, 0], [1, 0, 0], [1, 1, 1], [1, 0, 0], [0, 1, 1]] y_true_Qtensor = tensor.QTensor(reference_list) y_pred_Qtensor = tensor.QTensor(prediciton_list) micro_precision, micro_recall, micro_f1 = vqnet_metrics.precision_recall_f1_Multi_score(y_true_Qtensor, y_pred_Qtensor, 3, average='micro') print(micro_precision, micro_recall, micro_f1) # 0.5 0.5714285714285714 0.5333333333333333 macro_precision, macro_recall, macro_f1 = vqnet_metrics.precision_recall_f1_Multi_score(y_true_Qtensor, y_pred_Qtensor, 3, average='macro') print(macro_precision, macro_recall, macro_f1) # 0.5 0.5555555555555555 0.5238095238095238 weighted_precision, weighted_recall, weighted_f1 = vqnet_metrics.precision_recall_f1_Multi_score(y_true_Qtensor, y_pred_Qtensor, 3, average='weighted') print(weighted_precision, weighted_recall, weighted_f1) # 0.5 0.5714285714285714 0.5306122448979592
auc_calculate¶
- class pyvqnet.utils.metrics.auc_calculate(y_true_Qtensor, y_pred_Qtensor, pos_label=None, sample_weight=None, drop_intermediate=True)¶
计算模型对预测值和真值之间进行分类获取的(Area Under Curve, AUC)结果。
- Parameters:
y_true_Qtensor – 一维QTensor的输入,shape = [n_samples]。 真正的二进制标签。如果标签不是{1,1}或{0,1},则pos_label应明确给出。
y_pred_Qtensor – 一维QTensor的输入,shape = [n_samples]。 目标分数,可以是正的概率估计类别、置信值或决策的非阈值度量(由某些分类器上的“决策函数”返回)
pos_label – int 或 str,正类的标签。默认为None。 当
pos_label
是 None 时,如果y_true_Qtensor
位于{-1,1}或{0,1},pos_label
设置为1,否则将引发错误。sample_weight – 形状(n_samples,)的数组,默认为None。
drop_intermediate – boolean,是否降低一些在绘制的ROC曲线上不会出现的次优阈值。(默认为None)。
- Returns:
输出float结果。
Example:
import numpy as np from pyvqnet.tensor import tensor from pyvqnet.utils import metrics as vqnet_metrics from pyvqnet import _core _vqnet = _core.vqnet y = np.array([1, 1, 1, 1, 0, 1, 0, 0, 0, 0]) pred = np.array([0.9, 0.8, 0.7, 0.6, 0.6, 0.4, 0.4, 0.3, 0.2, 0.1]) y_Qtensor = tensor.QTensor(y) pred_Qtensor = tensor.QTensor(pred) result = vqnet_metrics.auc_calculate(y_Qtensor, pred_Qtensor) print("auc:", result) # 0.92 y = np.array([1, 1, 1, 1, 1, 0, 0, 1, 1, 1]) pred = np.array([1, 0, 1, 1, 1, 1, 0, 1, 1, 0]) y_Qtensor = tensor.QTensor(y) pred_Qtensor = tensor.QTensor(pred) result = vqnet_metrics.auc_calculate(y_Qtensor, pred_Qtensor) print("auc:", result) # 0.625 y = [1, 2, 1, 1, 1, 0, 0, 1, 1, 1] pred = [1, 0, 2, 1, 1, 1, 0, 1, 1, 0] y_Qtensor = tensor.QTensor(y) pred_Qtensor = tensor.QTensor(pred) result = vqnet_metrics.auc_calculate(y_Qtensor, pred_Qtensor, pos_label=2) print("auc:", result) # 0.1111111111111111
分布式计算模块¶
环境部署¶
以下介绍分别分别基于CPU、GPU分布式计算Linux系统下环境的部署.
MPI安装¶
MPI为CPU间通信的常用库, VQNet中CPU的分布式计算功能则基于MPI进行实现,以下将介绍如何在Linux系统中对MPI进行安装(目前基于CPU的分布式计算功能仅在Linux上实现)。
检测gcc、gfortran编译器是否安装。
which gcc
which gfortran
当显示了gcc和gfortran的路径,即可进行下一步的安装,若没有相应的编译器,请先安装编译器。当检查完编译器之后,使用wget命令下载。
wget http://www.mpich.org/static/downloads/3.3.2/mpich-3.3.2.tar.gz
tar -zxvf mpich-3.3.2.tar.gz
cd mpich-3.3.2
./configure --prefix=/usr/local/mpich
make
make install
完成mpich的编译安装,配置其环境变量
vim ~/.bashrc
# 在文档最下面加入
export PATH="/usr/local/mpich/bin:$PATH"
保存退出之后 使用source执行
source ~/.bashrc
用which来检验下配置的环境变量是否正确。显示了其路径, 则说明安装顺利完成。
此外通过pip install完成mpi4py的安装即可, 若是出现以下类似错误
为mpi4py与python版本之间不兼容的问题, 可以通过以下方法解决
# 通过下列代码暂存当前python环境的编译器
pushd /root/anaconda3/envs/mpi39/compiler_compat && mv ld ld.bak && popd
# 再次安装
pip install mpi4py
# 还原
pushd /root/anaconda3/envs/mpi39/compiler_compat && mv ld.bak ld && popd
NCCL安装¶
NCCL为GPU间通信的常用库, VQNet中GPU的分布式计算功能则基于NCCL进行实现,以下介绍如何在Linux系统中对NCCL进行安装(目前基于GPU的分布式计算功能仅在Linux上实现).
该部分需要MPI的支持, 因此MPI的环境也需要进行部署。
从github上将NCCL的仓库拉到本地:
git clone https://github.com/NVIDIA/nccl.git
进入nccl根目录并编译
cd nccl
make -j src.build
如果cuda没有安装到默认的路径即/usr/local/cuda, 则需要定义CUDA的路径, 使用以下代码来编译
make src.build CUDA_HOME=<path to cuda install>
并且可以根据BUILDDIR指定安装目录, 指令如下
make src.build CUDA_HOME=<path to cuda install> BUILDDIR=/usr/local/nccl
安装完成后在.bashrc文件中添加配置
vim ~/.bashrc
# 在最下面加入
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/nccl/lib
export PATH=$PATH:/usr/local/nccl/bin
保存后, 执行
source ~/.bashrc
可以通过nccl-test进行验证
git clone https://github.com/NVIDIA/nccl-tests.git
cd nccl-tests
make -j12 CUDA_HOME=/usr/local/cuda
./build/all_reduce_perf -b 8 -e 256M -f 2 -g 1
节点间通信环境部署¶
在多节点上实现分布式计算,首先需要保证多节点上mpich环境的一致,python环境一致,其次,需要设置节点间的免密通信。 假设需要设置node0(主节点)、node1、node2三个节点的免密通信。
# 在每个节点上执行
ssh-keygen
# 之后一直回车,在.ssh文件夹下生成一个公钥(id_rsa.pub)一个私钥(id_rsa)
# 将其另外两个节点的公钥都添加到第一个节点的authorized_keys文件中,
# 再将第一个节点authorized_keys文件传到另外两个节点便可以实现节点间的免密通信
# 在子节点node1上执行
cat ~/.ssh/id_dsa.pub >> node0:~/.ssh/authorized_keys
# 在子节点node2上执行
cat ~/.ssh/id_dsa.pub >> node0:~/.ssh/authorized_keys
# 先删除node1、node2中的authorized_keys文件后,在node0上将authorized_keys文件拷贝到另外两个节点上
scp ~/.ssh/authorized_keys node1:~/.ssh/authorized_keys
scp ~/.ssh/authorized_keys node2:~/.ssh/authorized_keys
# 保证三个不同节点生成的公钥都在authorized_keys文件中,即可实现节点间的免密通信
除此外,最好还设置一个共享目录,使得改变共享目录下的文件时,不同节点中文件也会进行更改,预防多节点运行模型时不同节点中的文件不同步的问题。 使用nfs-utils和rpcbind实现共享目录。
# 安装软件包
yum -y install nfs* rpcbind
# 编辑主节点上配置文件
vim /etc/exports
/data/mpi *(rw,sync,no_all_squash,no_subtree_check)
# 主节点上启动服务
systemctl start rpcbind
systemctl start nfs
# 在所有子结点node1,node2上mount要共享的目录
mount node1:/data/mpi/ /data/mpi
mount node2:/data/mpi/ /data/mpi
CPU分布式计算接口及样例¶
本块介绍如何在cpu硬件平台上, 利用VQNet分布式计算接口实现数据并行训练模型(目前仅支持在Linux系统上)。
init_process¶
使用 init_process
对分布式计算参数进行初始化。
- pyvqnet.distributed.init.init_process(size, path, hostpath=None, train_size=None, test_size=None, shuffle=False)¶
设置分布式计算参数。
- Parameters:
size – 进程数。
path – 当前运行文件绝对路径。
hostpath – 多节点配置文件绝对路径。
train_size – 训练集大小。
test_size – 测试集大小。
shuffle – 是否随机采样。
Example:
import argparse import os from pyvqnet.distributed import * parser = argparse.ArgumentParser(description='parser example') parser.add_argument('--init', default=False, type=bool, help='whether to use multiprocessing') parser.add_argument('--np', default=1, type=int, help='number of processes') parser.add_argument('--hostpath', default=None, type=str, help='multi node configuration files') parser.add_argument('--shuffle', default=False, type=bool, help='shuffle') parser.add_argument('--train_size', default=120, type=int, help='train_size') parser.add_argument('--test_size', default=50, type=int, help='test_size') args = parser.parse_args() if(args.init): init_process(args.np, os.path.realpath(__file__)) else: break # python run.py --init true --np 2
average_parameters_allreduce¶
使用 average_parameters_allreduce
以allreduce的方式对不同进程上模型参数进行传递并以平均值更新。
- pyvqnet.distributed.comm.average_parameters_allreduce(model)¶
设置分布式计算参数。
- Parameters:
model – Module - 训练的模型.
- Returns:
参数更新后的模型.
Example:
from pyvqnet.distributed import average_parameters_allreduce import numpy as np from pyvqnet.nn.module import Module from pyvqnet.nn.linear import Linear from pyvqnet.nn import activation as F from pyvqnet.distributed import * class Net(Module): def __init__(self): super(Net, self).__init__() self.fc = Linear(input_channels=5, output_channels=1) def forward(self, x): x = F.ReLu()(self.fc(x)) return x model = Net() print(f"rank {get_rank()} parameters is {model.parameters()}") model = average_parameters_allreduce(model) if get_rank() == 0: print(model.parameters()) # mpirun -n 2 python run.py
average_grad_allreduce¶
使用 average_grad_allreduce
以allreduce的方式对不同进程上模型参数梯度进行传递并以平均值更新.
- pyvqnet.distributed.comm.average_grad_allreduce(optimizer)¶
设置分布式计算参数。
- Parameters:
optimizer – optimizer.
- Returns:
梯度更新后的优化器。
Example:
from pyvqnet.distributed import average_grad_allreduce import numpy as np from pyvqnet.nn.module import Module from pyvqnet.nn.linear import Linear from pyvqnet.nn import activation as F from pyvqnet.distributed import * from pyvqnet.nn.loss import MeanSquaredError from pyvqnet.optim import Adam class Net(Module): def __init__(self): super(Net, self).__init__() self.fc = Linear(input_channels=5, output_channels=1) def forward(self, x): x = F.ReLu()(self.fc(x)) return x model = Net() opti = Adam(model.parameters(), lr=0.01) actual = tensor.QTensor([1,1,1,1,1,0,0,0,0,0],dtype=6).reshape((10,1)) x = tensor.randn((10, 5)) for i in range(10): opti.zero_grad() model.train() result = model(x) loss = MeanSquaredError()(actual, result) loss.backward() print(f"rank {get_rank()} grad is {model.parameters()[0].grad}") opti = average_grad_allreduce(opti) # if get_rank() == 0 : print(f"rank {get_rank()} grad is {model.parameters()[0].grad}") opti.step() # mpirun -n 2 python run.py
average_parameters_reduce¶
使用 average_parameters_reduce
以reduce的方式对进程上模型参数进行传递, 并对指定进程上的参数进行更新。
- pyvqnet.distributed.comm.average_parameters_reduce(model, root=0)¶
设置分布式计算参数。
- Parameters:
model – Module - 训练的模型.
root – 指定的进程号.
- Returns:
参数更新后的模型。
Example:
from pyvqnet.distributed import average_parameters_reduce import numpy as np from pyvqnet.nn.module import Module from pyvqnet.nn.linear import Linear from pyvqnet.nn import activation as F from pyvqnet.distributed import * class Net(Module): def __init__(self): super(Net, self).__init__() self.fc = Linear(input_channels=5, output_channels=1) def forward(self, x): x = F.ReLu()(self.fc(x)) return x model = Net() print(f"rank {get_rank()} parameters is {model.parameters()}") model = average_parameters_reduce(model) if get_rank() == 0: print(model.parameters()) # mpirun -n 2 python run.py
average_grad_reduce¶
使用 average_grad_reduce
以reduce的方式对进程上参数的梯度进行传递, 并对指定进程上的参数梯度更新。
- pyvqnet.distributed.comm.average_grad_reduce(optimizer, root=0)¶
设置分布式计算参数。
- Parameters:
optimizer – optimizer.
root – 指定的进程号.
- Returns:
梯度更新后的优化器.
Example:
from pyvqnet.distributed import average_grad_reduce import numpy as np from pyvqnet.nn.module import Module from pyvqnet.nn.linear import Linear from pyvqnet.nn import activation as F from pyvqnet.distributed import * from pyvqnet.nn.loss import MeanSquaredError from pyvqnet.optim import Adam class Net(Module): def __init__(self): super(Net, self).__init__() self.fc = Linear(input_channels=5, output_channels=1) def forward(self, x): x = F.ReLu()(self.fc(x)) return x model = Net() opti = Adam(model.parameters(), lr=0.01) actual = tensor.QTensor([1,1,1,1,1,0,0,0,0,0],dtype=6).reshape((10,1)) x = tensor.randn((10, 5)) for i in range(10): opti.zero_grad() model.train() result = model(x) loss = MeanSquaredError()(actual, result) loss.backward() print(f"rank {get_rank()} grad is {model.parameters()[0].grad}") opti = average_grad_reduce(opti) # if get_rank() == 0 : print(f"rank {get_rank()} grad is {model.parameters()[0].grad}") opti.step() # mpirun -n 2 python run.py
样例¶
导入相关库
import sys
sys.path.insert(0,"../")
import time
import os
import struct
import gzip
from pyvqnet.nn.module import Module
from pyvqnet.nn.linear import Linear
from pyvqnet.nn.conv import Conv2D
from pyvqnet.nn import activation as F
from pyvqnet.nn.pooling import MaxPool2D
from pyvqnet.nn.loss import CategoricalCrossEntropy
from pyvqnet.optim.adam import Adam
from pyvqnet.data.data import data_generator
from pyvqnet.tensor import tensor
from pyvqnet.tensor.tensor import QTensor
import pyqpanda as pq
import time
import numpy as np
import matplotlib
from pyvqnet.distributed import * # 分布式计算模块
import argparse
数据获取
url_base = "http://yann.lecun.com/exdb/mnist/"
key_file = {
"train_img": "train-images-idx3-ubyte.gz",
"train_label": "train-labels-idx1-ubyte.gz",
"test_img": "t10k-images-idx3-ubyte.gz",
"test_label": "t10k-labels-idx1-ubyte.gz"
}
if_show_sample = 0
grad_time = []
forward_time = []
forward_time_sum = []
def _download(dataset_dir, file_name):
"""
Download mnist data if needed.
"""
file_path = dataset_dir + "/" + file_name
if os.path.exists(file_path):
with gzip.GzipFile(file_path) as file:
file_path_ungz = file_path[:-3].replace("\\", "/")
if not os.path.exists(file_path_ungz):
open(file_path_ungz, "wb").write(file.read())
return
print("Downloading " + file_name + " ... ")
urllib.request.urlretrieve(url_base + file_name, file_path)
if os.path.exists(file_path):
with gzip.GzipFile(file_path) as file:
file_path_ungz = file_path[:-3].replace("\\", "/")
file_path_ungz = file_path_ungz.replace("-idx", ".idx")
if not os.path.exists(file_path_ungz):
open(file_path_ungz, "wb").write(file.read())
print("Done")
def download_mnist(dataset_dir):
for v in key_file.values():
_download(dataset_dir, v)
def load_mnist(dataset="training_data", digits=np.arange(2), path="./"):
"""
load mnist data
"""
from array import array as pyarray
download_mnist(path)
if dataset == "training_data":
fname_image = os.path.join(path, "train-images.idx3-ubyte").replace(
"\\", "/")
fname_label = os.path.join(path, "train-labels.idx1-ubyte").replace(
"\\", "/")
elif dataset == "testing_data":
fname_image = os.path.join(path, "t10k-images.idx3-ubyte").replace(
"\\", "/")
fname_label = os.path.join(path, "t10k-labels.idx1-ubyte").replace(
"\\", "/")
else:
raise ValueError("dataset must be 'training_data' or 'testing_data'")
flbl = open(fname_label, "rb")
_, size = struct.unpack(">II", flbl.read(8))
lbl = pyarray("b", flbl.read())
flbl.close()
fimg = open(fname_image, "rb")
_, size, rows, cols = struct.unpack(">IIII", fimg.read(16))
img = pyarray("B", fimg.read())
fimg.close()
ind = [k for k in range(size) if lbl[k] in digits]
num = len(ind)
images = np.zeros((num, rows, cols))
labels = np.zeros((num, 1), dtype=int)
for i in range(len(ind)):
images[i] = np.array(img[ind[i] * rows * cols:(ind[i] + 1) * rows *
cols]).reshape((rows, cols))
labels[i] = lbl[ind[i]]
return images, labels
def data_select(train_num, test_num):
"""
Select data from mnist dataset.
"""
x_train, y_train = load_mnist("training_data") # 下载训练数据
x_test, y_test = load_mnist("testing_data")
idx_train = np.append(
np.where(y_train == 0)[0][0:train_num],
np.where(y_train == 1)[0][0:train_num])
x_train = x_train[idx_train]
y_train = y_train[idx_train]
x_train = x_train / 255
y_train = np.eye(2)[y_train].reshape(-1, 2)
idx_test = np.append(
np.where(y_test == 0)[0][:test_num],
np.where(y_test == 1)[0][:test_num])
x_test = x_test[idx_test]
y_test = y_test[idx_test]
x_test = x_test / 255
y_test = np.eye(2)[y_test].reshape(-1, 2)
return x_train, y_train, x_test, y_test
模型定义
def circuit_func(weights):
"""
A function using QPanda to create quantum circuits and run.
"""
num_qubits = 1
machine = pq.CPUQVM()
machine.init_qvm()
qubits = machine.qAlloc_many(num_qubits)
cbits = machine.cAlloc_many(num_qubits)
circuit = pq.QCircuit()
circuit.insert(pq.H(qubits[0]))
circuit.insert(pq.RY(qubits[0], weights[0]))
prog = pq.QProg()
prog.insert(circuit)
prog << pq.measure_all(qubits, cbits) #pylint:disable=expression-not-assigned
result = machine.run_with_configuration(prog, cbits, 1000)
counts = np.array(list(result.values()))
states = np.array(list(result.keys())).astype(float)
# Compute probabilities for each state
probabilities = counts / 100
# Get state expectation
expectation = np.sum(states * probabilities)
return expectation
class Hybrid(Module):
""" Hybrid quantum - Quantum layer definition """
def __init__(self, shift):
super(Hybrid, self).__init__()
self.shift = shift
self.input = None
def forward(self, x):
self.input = x
expectation_z = circuit_func(np.array(x.data))
result = [[expectation_z]]
# requires_grad = x.requires_grad and not QTensor.NO_GRAD
requires_grad = x.requires_grad
def _backward_mnist(g, x):
""" Backward pass computation """
start_grad_time = time.time()
input_list = np.array(x.data)
shift_right = input_list + np.ones(input_list.shape) * self.shift
shift_left = input_list - np.ones(input_list.shape) * self.shift
gradients = []
for i in range(len(input_list)):
expectation_right = circuit_func(shift_right[i])
expectation_left = circuit_func(shift_left[i])
gradient = expectation_right - expectation_left
gradients.append(gradient)
gradients = np.array([gradients]).T
end_grad_time = time.time()
grad_time.append(end_grad_time - start_grad_time)
in_g = gradients * np.array(g)
return in_g
nodes = []
if x.requires_grad:
nodes.append(
QTensor.GraphNode(tensor=x,
df=lambda g: _backward_mnist(g, x)))
return QTensor(data=result, requires_grad=requires_grad, nodes=nodes)
class Net(Module):
"""
Hybird Quantum Classci Neural Network Module
"""
def __init__(self):
super(Net, self).__init__()
self.conv1 = Conv2D(input_channels=1,
output_channels=6,
kernel_size=(5, 5),
stride=(1, 1),
padding="valid")
self.maxpool1 = MaxPool2D([2, 2], [2, 2], padding="valid")
self.conv2 = Conv2D(input_channels=6,
output_channels=16,
kernel_size=(5, 5),
stride=(1, 1),
padding="valid")
self.maxpool2 = MaxPool2D([2, 2], [2, 2], padding="valid")
self.fc1 = Linear(input_channels=256, output_channels=64)
self.fc2 = Linear(input_channels=64, output_channels=1)
self.hybrid = Hybrid(np.pi / 2)
self.fc3 = Linear(input_channels=1, output_channels=2)
def forward(self, x):
start_time_forward = time.time()
x = F.ReLu()(self.conv1(x))
x = self.maxpool1(x)
x = F.ReLu()(self.conv2(x))
x = self.maxpool2(x)
x = tensor.flatten(x, 1)
x = F.ReLu()(self.fc1(x))
x = self.fc2(x)
start_time_hybrid = time.time()
x = self.hybrid(x)
end_time_hybrid = time.time()
forward_time.append(end_time_hybrid - start_time_hybrid)
x = self.fc3(x)
end_time_forward = time.time()
forward_time_sum.append(end_time_forward - start_time_forward)
return x
在训练时引用split_data、average_parameters_allreduce、init_process实现基于CPU数据并行的分布式计算。
使用方法如下
def run(args):
"""
Run mnist train function
"""
x_train, y_train, x_test, y_test = data_select(args.train_size, args.test_size)
x_train, y_train= split_data(x_train, y_train) # 分布式模块接口对数据切分
print(get_rank())
model = Net()
optimizer = Adam(model.parameters(), lr=0.001)
loss_func = CategoricalCrossEntropy()
epochs = 10
train_loss_list = []
val_loss_list = []
train_acc_list = []
val_acc_list = []
model.train()
for epoch in range(1, epochs):
total_loss = []
model.train()
batch_size = 1
correct = 0
n_train = 0
for x, y in data_generator(x_train,
y_train,
batch_size=1,
shuffle=False):
x = x.reshape(-1, 1, 28, 28)
optimizer.zero_grad()
output = model(x)
loss = loss_func(y, output)
loss_np = np.array(loss.data)
np_output = np.array(output.data, copy=False)
mask = (np_output.argmax(1) == y.argmax(1))
correct += np.sum(np.array(mask))
n_train += batch_size
loss.backward()
# optimizer = average_grad_allreduce(optimizer) 以allreduce方式对优化器中参数梯度进行传递, 并更新
optimizer._step()
total_loss.append(loss_np)
model = average_parameters_allreduce(model) # 对不同rank的模型参数以allreduce方式通信, 并对参数更新
train_loss_list.append(np.sum(total_loss) / len(total_loss))
train_acc_list.append(np.sum(correct) / n_train)
print("{:.0f} loss is : {:.10f}".format(epoch, train_loss_list[-1]))
model.eval()
correct = 0
n_eval = 0
for x, y in data_generator(x_test, y_test, batch_size=1, shuffle=True):
x = x.reshape(-1, 1, 28, 28)
output = model(x)
loss = loss_func(y, output)
loss_np = np.array(loss.data)
np_output = np.array(output.data, copy=False)
mask = (np_output.argmax(1) == y.argmax(1))
correct += np.sum(np.array(mask))
n_eval += 1
total_loss.append(loss_np)
print(f"Eval Accuracy: {correct / n_eval}")
val_loss_list.append(np.sum(total_loss) / len(total_loss))
val_acc_list.append(np.sum(correct) / n_eval)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='parser example')
parser.add_argument('--init', default=False, type=bool, help='whether to use multiprocessing')
parser.add_argument('--np', default=1, type=int, help='number of processes')
parser.add_argument('--hostpath', default=None, type=str, help='hosts absolute path')
parser.add_argument('--shuffle', default=False, type=bool, help='shuffle')
parser.add_argument('--train_size', default=120, type=int, help='train_size')
parser.add_argument('--test_size', default=50, type=int, help='test_size')
args = parser.parse_args()
# p_path = os.path.realpath (__file__)
if(args.init):
init_process(args.np, os.path.realpath(__file__), args.hostpath, args.train_size,args.test_size, args.shuffle)
else:
a = time.time()
run(args)
b=time.time()
if(get_rank()==0):
print("time: {}",format(b-a))
其中init代表是否基于分布式训练模型,np代表进程数,另外hostpath文件代码在多节点上运行模型时的配置文件的绝对路径,配置文件内容包括多节点的ip以及进程分配情况,如下
node0:1
node1:1
node2:1
在命令行输入
python test_mdis.py --init true
0
1 loss is : 0.8230862300
Eval Accuracy: 0.5
...
9 loss is : 0.5660219193
Eval Accuracy: 0.46
time: {} 15.132369756698608
python test_mdis.py --init true --np 2
得到结果
1
1 loss is : 0.0316730281
Eval Accuracy: 0.5
...
9 loss is : 0.0006756162
Eval Accuracy: 0.5
0
1 loss is : 0.0072183679
Eval Accuracy: 0.85
...
9 loss is : 0.0001979264
Eval Accuracy: 0.82
time: {} 9.132536888122559
以上是在单节点上多进程模型训练,可以明显看出训练时间缩短
在多节点上训练,命令如下
python3 test_mdis.py --init true --np 4 --hostpath ~/example/host.txt
0
1 loss is : 0.8609524409
Eval Accuracy: 0.5
...
9 loss is : 0.4251357079
Eval Accuracy: 0.5
time: {} 6.5950517654418945
3
1 loss is : 0.0034498004
Eval Accuracy: 0.5
...
9 loss is : 0.0001483827
Eval Accuracy: 0.5
1
1 loss is : 0.0990966797
Eval Accuracy: 0.5
...
9 loss is : 0.0037492002
Eval Accuracy: 0.5
2
1 loss is : 0.8468652089
Eval Accuracy: 0.5
...
Eval Accuracy: 0.53
9 loss is : 0.4186156909
Eval Accuracy: 0.52
GPU分布式计算接口及样例¶
nccl_average_parameters_allreduce¶
使用 nccl_average_parameters_allreduce
以allreduce的方式对不同进程上模型参数进行传递并更新。
- pyvqnet.distributed.nccl_api.nccl_average_parameters_allreduce(optimizer, Ncclop: NCCL_api, c_op='avg')¶
设置分布式计算参数。
- Parameters:
model – Module - 训练的模型.
Ncclop – NCCL_api.
c_op – 计算方式.
Example:
import numpy as np from pyvqnet.nn.module import Module from pyvqnet.nn.linear import Linear from pyvqnet.nn import activation as F from pyvqnet.distributed.nccl_api import * nccl_op = NCCL_api() nccl_op.ncclCommInitRank() class Net(Module): def __init__(self): super(Net, self).__init__() self.fc = Linear(input_channels=5, output_channels=1) def forward(self, x): x = F.ReLu()(self.fc(x)) return x model = Net().toGPU(1000 + get_rank()) print(f"rank {get_rank()} parameters is {model.parameters()}") nccl_average_parameters_allreduce(model, nccl_op) if get_rank() == 0: print(model.parameters()) # mpirun -n 2 python test.py # rank 1 parameters is [[[ 0.8647987], # [ 0.8910748], # [-0.3896213], # [-0.871486 ], # [-0.8997867]], [0.4014191]] # rank 0 parameters is [[[-0.6880538], # [ 0.0963508], # [-0.3776291], # [ 0.1773794], # [ 0.6670241]], [-0.1019871]] # [[[ 0.0883724], # [ 0.4937128], # [-0.3836252], # [-0.3470533], # [-0.1163813]], [0.149716]]
nccl_average_parameters_reduce¶
使用 nccl_average_parameters_reduce
以reduce的方式对不同进程上模型参数进行传递并更新。
- pyvqnet.distributed.nccl_api.nccl_average_parameters_reduce(model, Ncclop: NCCL_api, root=0, c_op='avg')¶
设置分布式计算参数。
- Param:
model: Module - 训练的模型.
- Parameters:
Ncclop – NCCL_api.
root – 指定进程号.
c_op – 计算方式.
Example:
import numpy as np from pyvqnet.nn.module import Module from pyvqnet.nn.linear import Linear from pyvqnet.nn import activation as F from pyvqnet.distributed.nccl_api import * nccl_op = NCCL_api() nccl_op.ncclCommInitRank() class Net(Module): def __init__(self): super(Net, self).__init__() self.fc = Linear(input_channels=5, output_channels=1) def forward(self, x): x = F.ReLu()(self.fc(x)) return x model = Net().toGPU(1000 + get_rank()) print(f"rank {get_rank()} parameters is {model.parameters()}") nccl_average_parameters_reduce(model, nccl_op) if get_rank() == 0: print(model.parameters()) # mpirun -n 2 python test.py # rank 1 parameters is [[[-0.7666817], # [ 0.3023796], # [-0.6021696], # [ 0.5293468], # [-0.1318247]], [0.4162451]] # rank 0 parameters is [[[ 0.1145883], # [-0.3539237], # [ 0.8672745], # [ 0.5483069], # [-0.5038487]], [0.4179307]] # [[[-0.3260467], # [-0.025772 ], # [ 0.1325525], # [ 0.5388269], # [-0.3178367]], [0.4170879]]
nccl_average_grad_allreduce¶
使用 nccl_average_grad_allreduce
以allreduce的方式对不同进程上参数梯度进行传递并更新。
- pyvqnet.distributed.nccl_api.nccl_average_grad_allreduce(optimizer, Ncclop: NCCL_api, c_op='avg')¶
设置分布式计算参数。
- Parameters:
optimizer – Optimizer.
Ncclop – NCCL_api.
root – 指定的进程号.
Example:
import numpy as np from pyvqnet.nn.module import Module from pyvqnet.nn.linear import Linear from pyvqnet.nn import activation as F from pyvqnet.distributed.nccl_api import * from pyvqnet.nn.loss import MeanSquaredError from pyvqnet.optim import Adam from pyvqnet.tensor import tensor nccl_op = NCCL_api() nccl_op.ncclCommInitRank() class Net(Module): def __init__(self): super(Net, self).__init__() self.fc = Linear(input_channels=5, output_channels=1) def forward(self, x): x = F.ReLu()(self.fc(x)) return x model = Net().toGPU(1000+ get_rank()) opti = Adam(model.parameters(), lr=0.01) actual = tensor.QTensor([1,1,1,1,1,0,0,0,0,0],dtype=6).reshape((10,1)).toGPU(1000+get_rank()) x = tensor.randn((10, 5)).toGPU(1000+get_rank()) for i in range(10): opti.zero_grad() model.train() result = model(x) loss = MeanSquaredError()(actual, result) loss.backward() print(f"rank {get_rank()} grad is {model.parameters()[0].grad}") nccl_average_grad_allreduce(opti, nccl_op) if get_rank() == 0 : print(f"rank {get_rank()} grad is {model.parameters()[0].grad}") opti.step() exit() # mpirun -n 2 python test.py # rank 1 grad is [[-0.2537998], # [-0.0411504], # [-0.3565139], # [ 0.5702319], # [ 0.0177623]] # rank 0 grad is [[-0.1322807], # [ 0.481559 ], # [-0.8823745], # [ 0.211081 ], # [-0.0234532]] # rank 0 grad is [[-0.1930403], # [ 0.2202043], # [-0.6194442], # [ 0.3906564], # [-0.0028455]]
nccl_average_grad_reduce¶
使用 nccl_average_grad_reduce
以reduce的方式对不同进程上参数梯度进行传递并更新。
- pyvqnet.distributed.nccl_api.nccl_average_grad_reduce(optimizer, Ncclop: NCCL_api, root=0, c_op='avg')¶
设置分布式计算参数。
- Parameters:
optimizer – Optimizer.
Ncclop – NCCL_api.
root – 在指定的节点上更新参数梯度.
c_op – 计算方式.
Example:
import numpy as np from pyvqnet.nn.module import Module from pyvqnet.nn.linear import Linear from pyvqnet.nn import activation as F from pyvqnet.distributed.nccl_api import * from pyvqnet.nn.loss import MeanSquaredError from pyvqnet.optim import Adam from pyvqnet.tensor import tensor nccl_op = NCCL_api() nccl_op.ncclCommInitRank() class Net(Module): def __init__(self): super(Net, self).__init__() self.fc = Linear(input_channels=5, output_channels=1) def forward(self, x): x = F.ReLu()(self.fc(x)) return x model = Net().toGPU(1000+ get_rank()) opti = Adam(model.parameters(), lr=0.01) actual = tensor.QTensor([1,1,1,1,1,0,0,0,0,0],dtype=6).reshape((10,1)).toGPU(1000+get_rank()) x = tensor.randn((10, 5)).toGPU(1000+get_rank()) for i in range(10): opti.zero_grad() model.train() result = model(x) loss = MeanSquaredError()(actual, result) loss.backward() print(f"rank {get_rank()} grad is {model.parameters()[0].grad}") nccl_average_grad_reduce(opti, nccl_op) if get_rank() == 0 : print(f"rank {get_rank()} grad is {model.parameters()[0].grad}") opti.step() exit() # mpirun -n 2 python test.py # rank 1 grad is [[ 0.2536973], # [ 0.1971456], # [ 0.2229966], # [-0.1126524], # [-0.4308025]] # rank 0 grad is [[-0.7967089], # [ 0.3266841], # [ 0.087491 ], # [-2.0684564], # [ 1.0999191]] # rank 0 grad is [[-0.2715058], # [ 0.2619148], # [ 0.1552438], # [-1.0905544], # [ 0.3345583]]
案例¶
from pyvqnet.qnn.vqc import *
from pyvqnet.optim import Adam
from pyvqnet.nn import Module, BinaryCrossEntropy, Sigmoid
from pyvqnet.data import data_generator
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from pyvqnet.tensor import QTensor
from pyvqnet.distributed.nccl_api import *
from pyvqnet.distributed import split_data, broadcast_model_params
from time import time
# NCCL 初始化
nccl_op = NCCL_api()
nccl_op.ncclCommInitRank()
iris_dataset = datasets.load_iris()
X1 = iris_dataset.data[:100, :].astype(
np.float32) # 选取iris_dataset的data的前100个数据,将其数据类型转换为float32,并储存在X中
X_feature_names = iris_dataset.feature_names # 将iris_dataset的特征名称储存在X_feature_names中
y = iris_dataset.target[:100].astype(
int) # 选取iris_dataset的target的前100个数据,将其数据类型转换为int,并储存在y中
y_target_names = iris_dataset.target_names[:
2] # 选取iris_dataset的target_names的前2个数据,并储存在y_target_names中
alpha = X1[:, :
3] * X1[:,
1:] # 每一个样本中,利用相邻两个特征值计算出一个参数,即每一个样本会多出3个参数(因为有4个特征值),并储存在alpha中
X1 = np.append(X1, alpha, axis=1) # 在axis=1的维度上,将alpha的数据值添加到X的特征值中
print(X1.shape)
# exit()
X_train, X_test, y_train, y_test = train_test_split(X1,
y,
test_size=0.2,
random_state=0,
shuffle=True)
class Q_model(Module):
def __init__(self):
super(Q_model, self).__init__()
self.hardward = VQC_HardwareEfficientAnsatz(
n_qubits=4,
single_rot_gate_list=["ry"],
entangle_gate="cnot",
depth=15)
obs_list = [{
'wires': [2, 3],
'observables': ['Z', 'Z'],
'coefficient': [1, 1]
}]
# print(obs_list)
self.ma = MeasureAll(obs=obs_list)
self.ac = Sigmoid()
self.qm = QMachine(4)
def forward(self, input):
qm = self.qm
qm.reset_states(input.shape[0])
def cir(qm, x):
for i in range(4):
hadamard(qm, i)
for i in range(4):
rz(qm, i, x[:, [i]])
for i in range(3):
cnot(qm, [i, i + 1])
rz(qm, i + 1, x[:, [4 + i]])
return qm
qm = cir(qm, input)
self.hardward(q_machine=qm)
y = self.ma(q_machine=qm)
y = self.ac(y)
return y
def run():
"""
Main run function
"""
model = Q_model()
model = broadcast_model_params(model)
model = model.toGPU(1000 + get_rank())
# print(model.parameters())
optimizer = Adam(model.parameters(), lr=0.1)
batch_size = 20
epoch = 20
loss = BinaryCrossEntropy()
print("start training..............")
model.train()
datas, labels= split_data(X_train, y_train)
def get_accuary(result, label):
result = (result > 0.5).astype(4)
score = tensor.sums(result == label)
return score
time2 = time()
runtime = 0
for i in range(epoch):
count = 0
sum_loss = 0
accuary = 0
t = 0
for data, label in data_generator(datas, labels, batch_size, False):
time3 = time()
optimizer.zero_grad()
data, label = QTensor(data,requires_grad=True).toGPU(1000 + get_rank()), QTensor(label,
dtype=6,
requires_grad=False).toGPU(1000 + get_rank())
result = model(data)
loss_b = loss(label.reshape([-1, 1]), result)
loss_b.backward()
nccl_average_grad_allreduce(optimizer, nccl_op)
optimizer._step()
sum_loss += loss_b.item()
count += batch_size
accuary += get_accuary(result, label.reshape([-1,1]))
t = t + 1
runtime += time() - time3
# nccl_average_parameters_reduce(model, nccl_op)
if get_rank()==0:
print(
f"epoch:{i}, #### loss:{sum_loss/count} #####accuray:{accuary/count}"
)
print("start testing..............")
model.eval()
count = 0
if get_rank() == 0:
print(time() - time2)
test_data, test_label = X_test, y_test
test_batch_size = 5
accuary = 0
sum_loss = 0
for testd, testl in data_generator(test_data, test_label, test_batch_size):
testd = QTensor(testd).toGPU(1000+get_rank())
testl = QTensor(testl, dtype=6).toGPU(1000+get_rank())
test_result = model(testd)
test_loss = loss(testl.reshape([-1, 1]), test_result)
sum_loss += test_loss
count += test_batch_size
accuary += get_accuary(test_result, testl.reshape([-1, 1]))
if get_rank()==0:
print(
f"test:--------------->loss:{sum_loss/count} #####accuray:{accuary/count}"
)
run()
split_data¶
在多进程中,使用 split_data
根据进程数对数据进行切分,返回相应进程上数据。
- pyvqnet.distributed.datasplit.split_data(x_train, y_train, shuffle=False)¶
设置分布式计算参数。
- Parameters:
x_train – np.array - 训练数据.
y_train – np.array - 训练数据标签.
shuffle – bool - 是否打乱后再进行切分,默认值是False.
- Returns:
切分后的训练数据和标签。
Example:
from pyvqnet.distributed import split_data import numpy as np x_train = np.random.randint(255, size = (100, 5)) y_train = np.random.randint(2, size = (100, 1)) x_train, y_train= split_data(x_train, y_train)
broadcast_model_params¶
使用 broadcast_model_params
在模型训练前将指定进程上的模型参数广播到其他进程,使模型训练前的参数保持一致。
- pyvqnet.distributed.comm.broadcast_model_params(model, root=0)¶
设置分布式计算参数。
- Parameters:
model – Module - 训练的模型.
root – 指定的进程号.
Example:
from pyvqnet.nn.module import Module from pyvqnet.nn.linear import Linear from pyvqnet.nn import activation as F from pyvqnet.distributed import broadcast_model_params, get_rank class Net(Module): def __init__(self): super(Net, self).__init__() self.fc = Linear(input_channels=5, output_channels=1) def forward(self, x): x = F.ReLu()(self.fc(x)) return x model = Net() print(f"bcast before rank {get_rank()}:{model.parameters()}") model = broadcast_model_params(model) model = model.toGPU(1000+ get_rank()) print(f"bcast after rank {get_rank()}: {model.parameters()}") # mpirun -n 2 python run.py