经典神经网络模块

基本例子

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类抽象前向计算函数

参数:

• x – 输入QTensor。

• *args – 非关键字可变参数。

• **kwargs – 关键字可变参数。

返回:

模型输出。

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='')

返回包含模块整个状态的字典:包括参数和缓存值。 键是对应的参数和缓存值名称。

参数:

• destination – 返回保存模型内部模块,参数的字典。

• prefix – 使用的参数和缓存值的命名前缀。

返回:

包含模块整个状态的字典。

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上。

备注

Module在不同GPU上无法进行计算。 如果您尝试在 ID 超过验证 GPU 最大数量的 GPU 上创建 QTensor,将引发 Cuda 错误。

参数:

device – 当前保存QTensor的设备,默认:DEV_GPU_0。device= pyvqnet.DEV_GPU_0,存储在第一个 GPU 中,devcie = DEV_GPU_1,存储在第二个 GPU 中,依此类推

返回:

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 设备中。

返回:

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)

保存模型参数的字典到一个文件。

参数:

• obj – 需要保存的字典。

• f – 保存参数的文件名。

返回:

无。

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)

从文件中载入参数到一个字典中。

参数:

f – 保存参数的文件名。

返回:

保存参数的字典。

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的内部参数等可以被保存起来。

参数:

modules – nn.Modules 列表

返回:

一个模块列表

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]))

    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的内部参数等可以被保存起来。

参数:

modules – nn.Parameter 列表

返回:

一个参数列表

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() 方法接受任何输入,并将其转发给它的第一个模块。 然后将输出依次 “链 “到其后每个模块的输入、最后返回最后一个模块的输出。

参数:

modules – 添加的Module

返回:

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)。

参数:

• 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:””。

返回:

一维卷积实例。

备注

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)。

参数:

• 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:””。

返回:

二维卷积实例。

备注

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, out_padding=(0, 0), group: int = 1, dtype=None, name='')

在输入上进行二维转置卷积运算。 Conv2D模块的输入具有形状(batch_size, input_channels, height, width)。

参数:

• 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。

• out_padding – 在输出形状中每个维度的一侧添加的额外尺寸。默认值:(0,0)

• group – int - 分组卷积的分组数. Default: 1。

• dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。

• name – 模块的名字,default:””。

返回:

二维转置卷积实例。

备注

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)。

参数:

• kernel – 平均池化的窗口大小。

• strides – 窗口移动的步长。

• padding – 填充选项, “valid” or “same” 或者整数指定填充长度。 默认 “valid”。

• name – 模块的名字,default:””。

返回:

一维平均池化层实例。

备注

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)。

参数:

• kernel – 最大池化的窗口大小。

• strides – 窗口移动的步长。

• padding – 填充选项, “valid” or “same” 或者整数指定填充长度。 默认 “valid”。

• name – 命名,默认为””。

返回:

一维最大池化层实例。

备注

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)。

参数:

• kernel – 平均池化的窗口大小。

• strides – 窗口移动的步长。

• padding – 填充选项, “valid” or “same” 或包含2个整数的元组,整数为两个维度上的填充长度。 默认 “valid”。

• name – 命名,默认为””。

返回:

二维平均池化层实例。

备注

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)。

参数:

• kernel – 最大池化的窗口大小。

• strides – 窗口移动的步长。

• padding – 填充选项, “valid” or “same” 或包含2个整数的元组,整数为两个维度上的填充长度。 默认 “valid”。

• name – 命名,默认为””。

返回:

二维最大池化层实例。

备注

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。

参数:

• num_embeddings – int - 嵌入字典的大小。

• embedding_dim – int - 每个嵌入向量的大小

• weight_initializer – callable - 参数初始化方式,默认正态分布。

• dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。

• name – 嵌入层的命名,默认为””。

返回:

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-5, affine=True, 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。

参数:

• channel_num – int - 输入通道数。

• momentum – float - 计算指数加权平均时的动量,默认为 0.1。

• epsilon – float - 数值稳定参数, 默认 1e-5。

• affine – bool - 一个布尔值,当设置为 True 时,此模块具有可学习的每通道仿射参数,初始化为 1(用于权重)和 0(用于偏差)。默认值:True。

• beta_initializer – callable - beta的初始化方式,默认全零初始化。

• gamma_initializer – callable - gamma的的初始化方式,默认全一初始化。

• dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。

• name – 批归一化层命名,默认为””。

返回:

二维批归一化层实例。

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-5, affine=True, 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。

参数:

• channel_num – int - 输入通道数。

• momentum – float - 计算指数加权平均时的动量,默认为 0.1。

• epsilon – float - 数值稳定性常数,默认为 1e-5。

• affine – bool - 一个布尔值,当设置为 True 时,此模块具有可学习的每通道仿射参数,初始化为 1(用于权重)和 0(用于偏差)。默认值:True。

• beta_initializer – callable - beta的初始化方式,默认全零初始化。

• gamma_initializer – callable - gamma的的初始化方式,默认全一初始化。

• dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。

• name – 批归一化层命名,默认为””。

返回:

一维批归一化层实例。

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-5, affine=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] .

参数:

• norm_shape – float - 标准化形状。

• epsilon – float - 数值稳定性常数,默认为 1e-5。

• affine – bool - 一个布尔值,当设置为 True 时,此模块具有可学习的每通道仿射参数,初始化为 1(用于权重)和 0(用于偏差)。默认值:True。

• dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。

• name – 这个模块的名字, 默认为””。

返回:

一个 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-5, affine=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。

参数:

• norm_size – float - 归一化大小,应该等于 C * H * W。

• epsilon – float - 数值稳定性常数,默认为 1e-5。

• affine – bool - 一个布尔值,当设置为 True 时,此模块具有可学习的每通道仿射参数,初始化为 1(用于权重)和 0(用于偏差)。默认值:True。

• dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。

• name – 这个模块的名字, 默认为””。

返回:

二维层归一化实例。

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-5, affine=True, dtype=None, name='')

在 2D 输入上进行层归一化。具体方式如论文所述: Layer Normalization。

\[y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta\]

均值和标准差是在最后一个维度大小上计算的,其中“norm_size” 是 norm_size 的值。

参数:

• norm_size – float - 归一化大小,应该等于最后一维大小。

• epsilon – float - 数值稳定性常数,默认为 1e-5。

• affine – bool - 一个布尔值,当设置为 True 时,此模块具有可学习的每通道仿射参数,初始化为 1(用于权重)和 0(用于偏差)。默认值:True。

• dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。

• name – 这个模块的名字, 默认为””。

返回:

一维层归一化实例。

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]
# ]

GroupNorm

class pyvqnet.nn.group_norm.GroupNorm(num_groups: int, num_channels: int, epsilon=1e-5, affine=True, dtype=None, name='')

对小批量输入应用组归一化。输入: \((N, C, *)\) 其中 \(C=\text{num_channels}\) , 输出: \((N, C, *)\) 。

此层实现论文 组归一化 中描述的操作。

\[y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta\]

输入通道被分成 num_groups 组,每组包含 num_channels / num_groups 个通道。num_channels 必须能被 num_groups 整除。平均值和标准差是在每个组中分别计算的。如果 affine 为 True,则 \(\gamma\) 和 \(\beta\) 是可学习的。每个通道仿射变换参数向量,大小为 num_channels。

参数:

• (int) (num_channels) – 将通道分成的组数

• (int) – 输入中预期的通道数

• eps – 添加到分母的值,以实现数值稳定性。默认值:1e-5

• affine – 一个布尔值,当设置为 True 时,此模块具有可学习的每通道仿射参数,初始化为 1(用于权重)和 0(用于偏差)。默认值: True。

• dtype – 参数的数据类型,defaults:None,使用默认数据类型:kfloat32,代表32位浮点数。

• name – 这个模块的名字, 默认为””。

返回:

GroupNorm 类

Example:

import numpy as np
from pyvqnet.tensor import QTensor,kfloat32
from pyvqnet.nn import GroupNorm
test_conv = GroupNorm(2,10)
x = QTensor(np.arange(0,60*2*5).reshape([2,10,3,2,5]),requires_grad=True,dtype=kfloat32)
y = test_conv.forward(x)
print(y)

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\)

参数:

• 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 – 线性层的命名,默认为””。

返回:

线性层实例。

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 概率升级其他单元。

参数:

• dropout_rate – float - 神经元被设置为零的概率。

• name – 这个模块的名字, 默认为””。

返回:

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.]]]
# ]

DropPath

class pyvqnet.nn.dropout.DropPath(dropout_rate=0.5, name='')

DropPath 模块将逐样本丢弃路径(随机深度)。

参数:

• dropout_rate – float - 神经元被设置为零的概率。

• name – 这个模块的名字, 默认为””。

返回:

DropPath实例。

Example:

import pyvqnet.nn as nn
import pyvqnet.tensor as tensor

x = tensor.randu([4])
y = nn.DropPath()(x)
print(y)
#[0.9074978,0.9350062,0.6896403,0.3541051]

Pixel_Shuffle

class pyvqnet.nn.pixel_shuffle.Pixel_Shuffle(upscale_factors, name='')

重新排列形状为:(, C * r^2, H, W) 的张量 到形状为 (, C, H * r, W * r) 的张量,其中 r 是尺度变换因子。

参数:

• upscale_factors – 增加尺度变换的因子

• name – 这个模块的名字, 默认为””。

返回:

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 是缩小因子。

参数:

• downscale_factors – 增加尺度变换的因子

• name – 这个模块的名字, 默认为””。

返回:

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}\]

参数:

• 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 – 这个模块的名字, 默认为””。

返回:

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\)。

参数:

• 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 – 这个模块的名字, 默认为””。

返回:

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}\]

参数:

• 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 – 这个模块的名字, 默认为””。

返回:

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}\]

参数:

• 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 – 这个模块的名字, 默认为””。

返回:

一个 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\)。

参数:

• 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 – 这个模块的名字, 默认为””。

返回:

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}\]

参数:

• 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 – 这个模块的名字, 默认为””。

返回:

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]

Interpolate

class pyvqnet.nn.Interpolate(size=None, scale_factor=None, mode='nearest', align_corners=None, recompute_scale_factor=None, name='')

向下/向上对输入进行采样。

目前只支持四维输入数据。

输入尺寸的解释形式为 B x C x H x W。

可用于选择的 mode 有 nearest 、bilinear 、bicubic.

参数:

• size – 输出大小,默认为None。

• scale_factor – 缩放因子,默认为None。

• mode – 用于上采样的算法 nearest | bilinear | bicubic.

• align_corners – 从几何学角度看,我们将输入和输出的像素点视为方形而不是点。输入和输出的像素点视为正方形,而不是点。 如果设置为 true,输入和输出张量将根据其角像素的中心点对齐。角像素的中心点对齐,保留角像素的值。 如果设置为 false,输入和输出张量将按其角像素的角点对齐,而角像素的值将保留。角像素的角点对齐,插值会使用边缘值填充 对超出边界的值进行填充,从而使此操作与输入大小无关。 当 scale_factor 保持不变时。这只有在 mode 为 bilinear 时才有效。

• recompute_scale_factor – 重新计算缩放因子,以便在插值计算中使用。 当 scale_factor 作为参数传递时,它将用于来计算输出尺寸。

• name – 模块名字.

Example:

from pyvqnet.nn import Interpolate
from pyvqnet.tensor import tensor
import pyvqnet
pyvqnet.utils.set_random_seed(1)

import numpy as np
np.random.seed(0)

np_ = np.random.randn(36).reshape((1, 1, 6, 6)).astype(np.float32)
mode_ = "bilinear"
size_ = 3

class model_vqnet(pyvqnet.nn.Module):

    def __init__(self):
        super().__init__()
        self.inter = Interpolate(size = size_, mode=mode_)
        self.ln = pyvqnet.nn.Linear(9, 1)

    def forward(self, x):
        x = self.inter(x).reshape((1,-1))
        x = self.ln(x)
        return 2 * x

input_vqnet = tensor.QTensor(np_,  dtype=pyvqnet.kfloat32, requires_grad=True)
loss_pyvqnet = pyvqnet.nn.MeanSquaredError()
output_vqnet = model_vqnet(input_vqnet)
l = loss_pyvqnet(tensor.QTensor([[1.0]]), output_vqnet)
l.backward()
print(model.parameters()[0].grad)

fuse_module

class pyvqnet.nn.fuse_module(model)

用于模型在推理阶段的相应相邻模块融合成一个模块,减少模型推理阶段计算量, 增加模型推理速度。

目前支持的模块序列如下:

conv, bn

linear, bn

其他序列保持不变,对于这些序列将列表中的第一个模块替换成融合后的模块,其他的用 Identity 代替。

参数:

input – 包括融合模块的模型。

返回:

模块融合后的模型。

Examples:

from pyvqnet import tensor
from pyvqnet.nn import Linear
from pyvqnet.nn import Module, BatchNorm1d, BatchNorm2d, Conv1D, Conv2D

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 pyvqnet.tensor import QTensor

from time import time
from pyvqnet.utils import set_random_seed
from pyvqnet.nn import fuse_module

def get_accuary(result, label):
    result = (result > 0.5).astype(4)
    score = tensor.sums(result == label)
    return score.item()

class Model(Module):
    def __init__(self):

        super(Model, self).__init__()

        self.conv1 = Conv2D(1,2,1)
        self.ban = BatchNorm2d(2)

        self.conv2 = Conv2D(2,1,1)
        self.li1 = Linear(64,1)
        self.ac = Sigmoid()

    def forward(self, x):
        x = self.conv1(x)
        x = self.ban(x)
        x = self.conv2(x).reshape([-1,64])
        x = self.li1(x)
        x = self.ac(x)

        return x
X_train = np.random.randn(80, 1, 8, 8)
y_train = np.random.choice([0,1], size=(80))

model = Model().toGPU()
optimizer = Adam(model.parameters(), lr = 0.001)
batch_size = 20
epoch = 80
loss = BinaryCrossEntropy()
print("start training..............")
model.train()

loss_history = []
accuracy_history = []
time2 = time()

for i in range(epoch):
    count = 0
    sum_loss = 0
    accuary = 0
    t = 0
    for data, label in data_generator(X_train, y_train, batch_size, False):
        optimizer.zero_grad()
        data, label = QTensor(data,requires_grad=True).toGPU(), QTensor(label,
                                            dtype=6,
                                            requires_grad=False).toGPU()

        result = model(data)

        loss_b = loss(label.reshape([-1, 1]), result)

        loss_b.backward()
        optimizer._step()

        sum_loss += loss_b.item()
        count += batch_size
        accuary += get_accuary(result, label.reshape([-1,1]))
        t = t + 1

    loss_history.append(sum_loss/count)
    accuracy_history.append(accuary/count)
    print(
        f"epoch:{i}, #### loss:{sum_loss/count} #####accuray:{accuary/count}"
    )
print(f"run time {time() - time2}")


model.eval()

input = tensor.randn((20, 1, 8, 8)).toGPU()
print(list(model.named_children()))
time_a = time()
a = model(input)
print(f"fuse before {time() - time_a}")
fuse_module(model)
model.toGPU()
print(list(model.named_children()))
time_b = time()
b = model(input)
print(f"fuse after {time() - time_b}")

print(tensor.max(tensor.abs(a - b)).item())

SDPA

class pyvqnet.transformer.SDPA(attn_mask=None, dropout_p=0., scale=None, is_causal=False)

构造计算查询、键和值张量的缩放点积注意力的类。如果输入为cpu下的QTensor,则使用数学公式计算, 如果输入在gpu下QTensor,则使用flash-attention方法计算。

参数:

• attn_mask – 注意力掩码；形状必须可以广播到注意力权重的形状。

• dropout_p – Dropout 概率,如果大于 0.0, 则应用。

• scale – 在 softmax 之前应用的缩放因子。

• is_causal – 如果为 “true”,则假定存在左上因果注意屏蔽,如果同时设置了 attn_mask 和 is_causal, 则会出现错误。

返回:

一个SDPA类

Examples:

from pyvqnet.transformer import SDPA
from pyvqnet import tensor
model = SDPA(tensor.QTensor([1.])).toGPU()

forward(query, key, value)

进行前向计算,如果输入为cpu下的QTensor,则使用数学公式计算, 如果输入在gpu下QTensor,则使用flash-attention方法计算。

参数:

• query – query输入QTensor。

• key – key输入QTensor。

• value – key输入QTensor。

返回:

SDPA计算返回的QTensor。

Examples:

from pyvqnet.transformer import SDPA
from pyvqnet import tensor
import pyvqnet
from time import time
import pyvqnet.nn as nn
import numpy as np

np.random.seed(42)

model = SDPA(tensor.QTensor([1.])).toGPU()

query_np = np.random.randn(3, 3, 3, 5).astype(np.float32)
key_np = np.random.randn(3, 3, 3, 5).astype(np.float32)
value_np = np.random.randn(3, 3, 3, 5).astype(np.float32)

query_p = tensor.QTensor(query_np, dtype=pyvqnet.kfloat32, requires_grad=True).toGPU()
key_p = tensor.QTensor(key_np, dtype=pyvqnet.kfloat32, requires_grad=True).toGPU()
value_p = tensor.QTensor(value_np, dtype=pyvqnet.kfloat32, requires_grad=True).toGPU()

out_sdpa = model(query_p, key_p, value_p)

out_sdpa.backward()

损失函数层

以下为神经网络常用的损失层。

备注

请注意,跟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)\]

参数:

name – 这个模块的名字, 默认为””。

返回:

一个均方根误差实例。

均方根误差前向计算函数的所需参数:

x: \((N, *)\) 预测值,其中 \(*\) 表示任意维度。

y: \((N, *)\), 目标值, 和输入一样维度的 QTensor 。

备注

请注意,跟pytorch等框架不同的是,以下MeanSquaredError函数的前向函数中,第一个参数为目标值,第二个参数为预测值。

Example:

from pyvqnet.tensor import QTensor
from pyvqnet import 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)\]

参数:

name – 这个模块的名字, 默认为””。

返回:

一个平均二元交叉熵实例。

平均二元交叉熵误差前向计算函数的所需参数:

x: \((N, *)\) 预测值,其中 \(*\) 表示任意维度。

y: \((N, *)\), 目标值,和输入一样维度的 QTensor 。

备注

请注意,跟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)\]

参数:

name – 这个模块的名字, 默认为””。

返回:

平均分类交叉熵实例。

误差前向计算函数的所需参数:

x: \((N, *)\) 预测值,其中 \(*\) 表示任意维度。

y: \((N, *)\), 目标值,和输入一样维度的 QTensor 。必须为64位整数,kint64。

备注

请注意,跟pytorch等框架不同的是,CategoricalCrossEntropy函数的前向函数中,第一个参数为目标值,第二个参数为预测值。

Example:

from pyvqnet.tensor import QTensor
from pyvqnet import 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)\]

参数:

name – 这个模块的名字, 默认为””。

返回:

一个Softmax交叉熵损失函数实例

误差前向计算函数的所需参数:

x: \((N, *)\) 预测值,其中 \(*\) 表示任意维度。

y: \((N, *)\), 目标值,和输入一样维度的 QTensor 。必须为64位整数,kint64。

备注

请注意,跟pytorch等框架不同的是,SoftmaxCrossEntropy函数的前向函数中,第一个参数为目标值,第二个参数为预测值。

Example:

from pyvqnet.tensor import QTensor
from pyvqnet import 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\]

参数:

name – 这个模块的名字, 默认为””。

返回:

一个NLL_Loss损失函数实例

误差前向计算函数的所需参数:

x: \((N, *)\),损失函数的输出预测值,可以为多维变量。

y: \((N, *)\),损失函数目标值。必须为64位整数,kint64。

备注

请注意,跟pytorch等框架不同的是,NLL_Loss函数的前向函数中,第一个参数为目标值,第二个参数为预测值。

Example:

from pyvqnet.tensor import QTensor
from pyvqnet import 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=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)\]

参数:

name – 这个模块的名字, 默认为””。

返回:

一个CrossEntropyLoss损失函数实例

误差前向计算函数的所需参数:

x: \((N, *)\),损失函数的输出,可以为多维变量。

y: \((N, *)\),损失函数期望的真值。必须为64位整数,kint64。

备注

请注意,跟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=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)}\]

参数:

name – 激活函数层的命名,默认为””。

返回:

一个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))\]

参数:

name – 激活函数层的命名,默认为””。

返回:

一个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|}\]

参数:

name – 激活函数层的命名,默认为””。

返回:

一个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)}\]

参数:

• axis – 计算的维度(最后一个轴为-1),默认值 = -1。

• name – 激活函数层的命名,默认为””。

返回:

一个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}\]

参数:

name – 激活函数层的命名,默认为””。

返回:

一个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}\]

参数:

name – 激活函数层的命名,默认为””。

返回:

一个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}\]

参数:

• alpha – LeakyRelu 系数,默认:0.01。

• name – 激活函数层的命名,默认为””。

返回:

一个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.]

Gelu

class pyvqnet.nn.Gelu(approximate='tanh', name='')

应用高斯误差线性单元函数:

\[\text{GELU}(x) = x * \Phi(x)\]

当近似参数为 ‘tanh’ 时, GELU 通过以下方式估计:

\[\text{GELU}(x) = 0.5 * x * (1 + \text{Tanh}(\sqrt{2 / \pi} * (x + 0.044715 * x^3)))\]

参数:

• approximate – 近似计算方式, 默认为”tanh”。

• name – 激活函数层的命名,默认为””。

返回:

Gelu 激活函数层实例。

Examples:

from pyvqnet.tensor import randu, ones_like
from pyvqnet.nn import Gelu
qa = randu([5,4])
qb = Gelu()(qa)
print(qb)
# [[0.0292515,0.0668998,0.4036024,0.8369502],
#  [0.1929213,0.1981275,0.2358531,0.7790835],
#  [0.1754935,0.6204091,0.2354677,0.2409406],
#  [0.4238827,0.804715 ,0.1633414,0.2853   ],
#  [0.1959854,0.590143 ,0.553995 ,0.0008423]]

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}\]

参数:

• alpha – ELU 系数,默认:1。

• name – 激活函数层的命名,默认为””。

返回:

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)}\]

参数:

name – 激活函数层的命名,默认为””。

返回:

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)

所有优化器的基类。

参数:

• params – 需要优化的模型参数。

• lr – 学习率,默认值:0.01。

Adadelta

class pyvqnet.optim.adadelta.Adadelta(params, lr=0.01, beta=0.99, epsilon=1e-8)

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}\]

参数:

• params – 需要优化的模型参数。

• lr – 学习率(默认值:0.01)。

• beta – 用于计算平方梯度的运行平均值(默认值:0.99)。

• epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。

返回:

一个 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-8)

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}\]

参数:

• params – 需要优化的模型参数。

• lr – 学习率(默认值:0.01)。

• epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。

返回:

一个 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-8, weight_decay=0, amsgrad: bool = False)

Adam优化器,它可以使用一阶矩估计动态调整每个参数的学习率和梯度的二阶矩估计。

参考:https://arxiv.org/abs/1412.6980。

\[t = t + 1\]

\[param = param - lr*weight\_decay*param\]

\[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}\]

参数:

• params – 需要优化的模型参数。

• lr – 学习率(默认值:0.01)。

• beta1 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.9)。

• beta2 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.999)。

• epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。

• amsgrad – 是否使用该算法的 AMSGrad 变体(默认值:False)。

• weight_decay – 权重衰减系数(默认值0)。

返回:

一个 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]]]
# ]

AdamW

class pyvqnet.optim.adam.AdamW(params, lr=0.01, beta1=0.9, beta2=0.999, epsilon=1e-8, weight_decay=0.01, amsgrad: bool = False)

实现 AdamW 算法.

\[t = t + 1\]

\[param\_new = param - lr*weight\_decay*param\]

\[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\_new-lr*\frac{moment\_1}{\sqrt{moment\_2\_max}+\epsilon}\]

否则

\[param\_new=param\_new-lr*\frac{moment\_1}{\sqrt{moment\_2}+\epsilon}\]

参数:

• params – 需要优化的模型参数。

• lr – 学习率(默认值:0.01)。

• beta1 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.9)。

• beta2 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.999)。

• epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。

• weight_decay – 权重衰减系数,默认0.01。

• amsgrad – 是否使用该算法的 AMSGrad 变体(默认值:False)。

返回:

一个 AdamW 优化器。

Example:

from pyvqnet.optim import adam
import numpy as np
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.AdamW(params, lr=0.5)

for i in range(1,3):
    opti.step()
print(param)
# [[[[ 0.       ,-0.007475 , 0.98255  , 1.972575 ],
#    [ 2.9626   , 3.952625 , 4.9426501, 5.9326751],
#    [ 6.9227001, 7.9127251, 8.9027501, 9.8927751]],

#   [[10.8828001,11.8728251,12.8628501,13.8528751],
#    [14.8429002,15.8329252,16.8229502,17.8129752],
#    [18.8030002,19.7930252,20.7830502,21.7730752]]]]

Adamax

class pyvqnet.optim.adamax.Adamax(params, lr=0.01, beta1=0.9, beta2=0.999, epsilon=1e-8)

实现 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}\]

参数:

• params – 需要优化的模型参数。

• lr – 学习率(默认值:0.01)。

• beta1 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.9)。

• beta2 – 用于计算梯度及其平方的运行平均值的系数(默认值:0.999)。

• epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。

返回:

一个 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-8)

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}\]

参数:

• params – 需要优化的模型参数。

• lr – 学习率(默认值:0.01)。

• beta – 用于计算梯度及其平方的运行平均值的系数(默认值:0.99)。

• epsilon – 添加到分母以提高数值稳定性的常数(默认值:1e-8)。

返回:

一个 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}\]

参数:

• params – 需要优化的模型参数。

• lr – 学习率(默认值:0.01)。

• momentum – 动量因子(默认值:0)。

• nesterov – 启用 Nesterov 动量 (默认: False)。

返回:

一个 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。

参数:

max_iter – rotosolve 更新的最大迭代次数。

返回:

一个 Rotosolve 优化器。

Example:

from pyvqnet.optim.rotosolve import Rotosolve
import pyqpanda as pq
from pyvqnet.tensor import QTensor
from pyvqnet import 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)。

参数:

• y_true_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,真实目标值。

• y_pred_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,估计目标值。

返回:

输出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) 。

参数:

• y_true_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,真实目标值。

• y_pred_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,估计目标值。

返回:

输出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) 。

参数:

• y_true_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,真实目标值。

• y_pred_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,估计目标值。

返回:

输出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分数。

参数:

• y_true_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,真实目标值。

• y_pred_Qtensor – 形状类似(n_samples,)或(n_samples, n_outputs)的输入,估计目标值。

• sample_weight – 形状类似(n_samples,)的数组,可选样本权重,默认为None。

返回:

输出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,代表两个类的标签。

参数:

• y_true_Qtensor – 一维QTensor的输入,形状类似(n_samples,),真实目标值。

• y_pred_Qtensor – 一维QTensor的输入,形状类似(n_samples,),估计目标值。

返回:

• 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个类的标签。

参数:

• y_true_Qtensor – 一维QTensor的输入,真实目标值。

• y_pred_Qtensor – 一维QTensor的输入,估计目标值。

• N – N类(类别数)。

• average –

  string, [‘micro’, ‘macro’, ‘weighted’]。 多类/多标签目标需要此参数。 'micro': 通过计算总真正数来全局计算指标,假阴性和假阳性。

  'macro': 计算每个标签的指标,并找到其未加权值。意思是不考虑标签的平衡。

  'weighted': 计算每个标签的指标,并找到它们的平均值(每个标签的真实实例数)。这改变 'macro' 以解释标签不平衡; 这可能会导致F分数不在精度和召回之间。

返回:

• 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独热编码的形式。

参数:

• y_true_Qtensor – 二维QTensor的输入,真实目标值。

• y_pred_Qtensor – 二维QTensor的输入,估计目标值。

• N – N类(类别数)。

• average –

  string, [‘micro’, ‘macro’, ‘weighted’]。 多类/多标签目标需要此参数。 'micro': 通过计算总真正数来全局计算指标,假阴性和假阳性。

  'macro': 计算每个标签的指标,并找到其未加权值。意思是不考虑标签的平衡。

  'weighted': 计算每个标签的指标,并找到它们的平均值(每个标签的真实实例数)。这改变 'macro' 以解释标签不平衡; 这可能会导致F分数不在精度和召回之间。

返回:

• 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)结果。

参数:

• 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)。

返回:

输出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

VQNet的分布式计算模块

分布式计算​​是指通过多台设备（如GPU/CPU节点）协同完成神经网络的训练或推理任务，利用并行处理加速计算并扩展模型规模。 其核心是通过​​分布式接口​​（如MPI、NCCL、gRP）协调设备间的通信与同步

VQNet的分布式计算模块模块使用mpi启动多进程并行计算, 使用nccl进行GPU之间通信。该功能仅在linux操作系统下能够使用。

环境部署

以下介绍VQNet分别基于CPU、GPU分布式计算所需的Linux系统下环境的部署.该部分必须MPI的支持, 以下介绍MPI的环境部署。

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来检验下配置的环境变量是否正确。显示了其路径, 则说明安装顺利完成。

此外我们还必须安装 mpi4py 库。通过pip install完成mpi4py的安装即可, 若是出现以下类似错误

为mpi4py与python版本之间不兼容的问题, 可以通过以下方法解决

# 通过下列代码暂存当前python环境的编译器
pushd /root/anaconda3/envs/$CONDA_DEFAULT_ENV/compiler_compat && mv ld ld.bak && popd

# 再次安装
pip install mpi4py

# 还原
pushd /root/anaconda3/envs/$CONDA_DEFAULT_ENV/compiler_compat && mv ld.bak ld && popd

NCCL安装

NCCL为GPU间通信的常用库, VQNet中GPU的分布式计算功能则基于NCCL进行实现,本软件默认在安装时候同时安装NCCL的动态链接库, 一般不需要安装NCCL。 如果要安装NCCL,可以按照以下介绍如何在Linux系统中对NCCL进行安装(目前基于GPU的分布式计算功能仅在Linux上实现).

从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

分布式启动

使用分布式计算接口,通过 vqnetrun 命令启动, 接下来介绍 vqnetrun 的各个参数.

n, np

vqnetrun 接口中可以通过 -n, -np 参数控制启动的进程数,执行样例如下:

Example:

from pyvqnet.distributed import CommController
Comm_OP = CommController("mpi") # init mpi controller

rank = Comm_OP.getRank()
size = Comm_OP.getSize()
print(f"rank: {rank}, size {size}")

# vqnetrun -n 2 python test.py
# vqnetrun -np 2 python test.py

H, hosts

vqnetrun 接口中可以通过 -H, --hosts 指定节点以及进程分配来跨节点执行(在跨节点运行时必须将节点的环境配置成功, 在相同的环境,相同的路径下执行),执行样例如下:

Example:

from pyvqnet.distributed import CommController, get_host_name
Comm_OP = CommController("mpi") # init mpi controller

rank = Comm_OP.getRank()
size = Comm_OP.getSize()
print(f"rank: {rank}, size {size}")
print(f"LocalRank {Comm_OP.getLocalRank()} hosts name {get_host_name()}")

# vqnetrun -np 4 -H node0:1,node2:1 python test.py
# vqnetrun -np 4 --hosts node0:1,node2:1 python test.py

hostfile, f, hostfile

vqnetrun 接口中可以通过指定hosts文件来指定节点以及进程分配来跨节点(在跨节点运行时必须将节点的环境配置成功, 在相同的环境,相同的路径下执行), 命令行参数为 -hostfile, -f, --hostfile.

文件内每行的格式必须为:<hostname> slots=<slots> 如；

node0 slots=1

node2 slots=1

执行样例如下

Example:

from pyvqnet.distributed import CommController, get_host_name
Comm_OP = CommController("mpi") # init mpi controller

rank = Comm_OP.getRank()
size = Comm_OP.getSize()
print(f"rank: {rank}, size {size}")
print(f"LocalRank {Comm_OP.getLocalRank()} hosts name {get_host_name()}")

# vqnetrun -np 4 -f hosts python test.py
# vqnetrun -np 4 -hostfile hosts python test.py
# vqnetrun -np 4 --hostfile hosts python test.py

output-filename

vqnetrun 接口中可以通过命令行参数 --output-filename 来将输出结果保存到指定文件.

执行样例如下

Example:

from pyvqnet.distributed import CommController, get_host_name
Comm_OP = CommController("mpi") # init mpi controller

rank = Comm_OP.getRank()
size = Comm_OP.getSize()
print(f"rank: {rank}, size {size}")
print(f"LocalRank {Comm_OP.getLocalRank()} hosts name {get_host_name()}")

# vqnetrun -np 4 --hostfile hosts --output-filename output  python test.py

verbose

vqnetrun 接口中可以通过命令行参数 --verbose 来对节点间的通信进行检测,并额外输出检测结果。

执行样例如下

Example:

from pyvqnet.distributed import CommController, get_host_name
Comm_OP = CommController("mpi") # init mpi controller

rank = Comm_OP.getRank()
size = Comm_OP.getSize()
print(f"rank: {rank}, size {size}")
print(f"LocalRank {Comm_OP.getLocalRank()} hosts name {get_host_name()}")

# vqnetrun -np 4 --hostfile hosts --verbose python test.py

start-timeout

vqnetrun 接口中可以通过命令行参数 --start-timeout 来指定超时前执行所有检查并启动进程。默认值为 30 秒。

执行样例如下

Example:

from pyvqnet.distributed import CommController, get_host_name
Comm_OP = CommController("mpi") # init mpi controller

rank = Comm_OP.getRank()
size = Comm_OP.getSize()
print(f"rank: {rank}, size {size}")
print(f"LocalRank {Comm_OP.getLocalRank()} hosts name {get_host_name()}")

# vqnetrun -np 4 --start-timeout 10 python test.py

h

vqnetrun 接口中可以通过该标志, 输出vqnetrun支持的所有参数以及参数的详细介绍。

执行代码如下

# vqnetrun -h

CommController

class pyvqnet.distributed.ControllComm.CommController(backend, rank=None, world_size=None)

CommController用于控制在cpu、gpu下数据通信的控制器, 通过设置参数 backend 来生成cpu(mpi)、gpu(nccl)的控制器。(目前分布式计算的功能仅支持linux操作系系统下使用)

参数:

• backend – 用于生成cpu或者gpu的数据通信控制器。

• rank – 该参数仅在非pyvqnet后端下有用, 默认值为: None。

• world_size – 该参数仅在非pyvqnet后端下有用, 默认值为: None。

返回:

CommController 实例。

Examples:

from pyvqnet.distributed import CommController
Comm_OP = CommController("nccl") # init nccl controller

# Comm_OP = CommController("mpi") # init mpi controller

getRank()

用于获得当前进程的进程号。

返回:

返回当前进程的进程号。

Examples:

from pyvqnet.distributed import CommController
Comm_OP = CommController("nccl") # init nccl controller

Comm_OP.getRank()

getSize()

用于获得总共启动的进程数。

返回:

返回总共进程的数量。

Examples:

from pyvqnet.distributed import CommController
Comm_OP = CommController("nccl") # init nccl controller

Comm_OP.getSize()
# vqnetrun -n 2 python test.py
# 2

getLocalRank()

用于获得当前机器上的当前进程号。

返回:

当前机器上的当前进程号。

Examples:

from pyvqnet.distributed import CommController
Comm_OP = CommController("nccl") # init nccl controller

Comm_OP.getLocalRank()
# vqnetrun -n 2 python test.py

ncclSplitGroup(rankL)

用于划分gpu上的通信组。

参数:

rankL – 进程组列表。

Examples:

from pyvqnet.distributed import CommController
Comm_OP = CommController("nccl")

Comm_OP.ncclSplitGroup([[0, 1]])
# vqnetrun -n 2 python test.py

barrier()

同步。

返回:

同步操作。

Examples:

from pyvqnet.distributed import CommController
Comm_OP = CommController("nccl")

Comm_OP.barrier()

GetDeviceNum()

用于获得当前节点上的显卡数量, (仅支持gpu下使用)。

返回:

返回当前节点上显卡数量。

Examples:

from pyvqnet.distributed import CommController
Comm_OP = CommController("nccl")

Comm_OP.GetDeviceNum()
# python test.py

allreduce(tensor, c_op='avg')

支持对数据作allreduce通信。

参数:

• tensor – 输入数据.

• c_op – 计算方式.

Examples:

from pyvqnet.distributed import CommController
from pyvqnet.tensor import tensor
import numpy as np
Comm_OP = CommController("mpi")

num = tensor.to_tensor(np.random.rand(1, 5))
print(f"rank {Comm_OP.getRank()}  {num}")

Comm_OP.allreduce(num, "sum")
print(f"rank {Comm_OP.getRank()}  {num}")
# vqnetrun -n 2 python test.py

reduce(tensor, root=0, c_op='avg')

支持对数据作reduce通信。

参数:

• tensor – 输入数据。

• root – 指定数据返回的节点。

• c_op – 计算方式。

Examples:

from pyvqnet.distributed import CommController
from pyvqnet.tensor import tensor
import numpy as np
Comm_OP = CommController("mpi")

num = tensor.to_tensor(np.random.rand(1, 5))
print(f"rank {Comm_OP.getRank()}  {num}")

Comm_OP.reduce(num, 1)
print(f"rank {Comm_OP.getRank()}  {num}")
# vqnetrun -n 2 python test.py

broadcast(tensor, root=0)

将指定进程root上的数据广播到所有进程上。

参数:

• tensor – 输入数据。

• root – 指定的节点。

Examples:

from pyvqnet.distributed import CommController
from pyvqnet.tensor import tensor
import numpy as np
Comm_OP = CommController("mpi")

num = tensor.to_tensor(np.random.rand(1, 5))
print(f"rank {Comm_OP.getRank()}  {num}")

Comm_OP.broadcast(num, 1)
print(f"rank {Comm_OP.getRank()}  {num}")
# vqnetrun -n 2 python test.py

allgather(tensor)

将所有进程上数据allgather到一起。

参数:

tensor – 输入数据。

Examples:

from pyvqnet.distributed import CommController
from pyvqnet.tensor import tensor
import numpy as np
Comm_OP = CommController("mpi")

num = tensor.to_tensor(np.random.rand(1, 5))
print(f"rank {Comm_OP.getRank()}  {num}")

num = Comm_OP.allgather(num)
print(f"rank {Comm_OP.getRank()}  {num}")
# vqnetrun -n 2 python test.py

send(tensor, dest)

p2p通信接口。

参数:

• tensor – 输入数据.

• dest – 目的进程.

Examples:

from pyvqnet.distributed import CommController,get_rank
from pyvqnet.tensor import tensor
import numpy as np
Comm_OP = CommController("mpi")

num = tensor.to_tensor(np.random.rand(1, 5))
recv = tensor.zeros_like(num)

if get_rank() == 0:
    Comm_OP.send(num, 1)
elif get_rank() == 1:
    Comm_OP.recv(recv, 0)
print(f"rank {Comm_OP.getRank()}  {num}")
print(f"rank {Comm_OP.getRank()}  {recv}")

# vqnetrun -n 2 python test.py

recv(tensor, source)

p2p通信接口。

参数:

• tensor – 输入数据.

• source – 接受进程.

Examples:

from pyvqnet.distributed import CommController,get_rank
from pyvqnet.tensor import tensor
import numpy as np
Comm_OP = CommController("mpi")

num = tensor.to_tensor(np.random.rand(1, 5))
recv = tensor.zeros_like(num)

if get_rank() == 0:
    Comm_OP.send(num, 1)
elif get_rank() == 1:
    Comm_OP.recv(recv, 0)
print(f"rank {Comm_OP.getRank()}  {num}")
print(f"rank {Comm_OP.getRank()}  {recv}")

# vqnetrun -n 2 python test.py

allreduce_group(tensor, c_op='avg', GroupComm=None)

组内allreduce通信接口。

参数:

• tensor – 输入数据.

• c_op – 计算方法.

• GroupComm – 通信组, 仅mpi进行组内通信时需要.

Examples:

from pyvqnet.distributed import CommController,get_rank,get_local_rank
from pyvqnet.tensor import tensor
import numpy as np
Comm_OP = CommController("nccl")

Comm_OP.ncclSplitGroup([[0, 1]])

complex_data = tensor.QTensor([3+1j, 2, 1 + get_rank()],dtype=8).reshape((3,1)).toGPU(1000+ get_local_rank())

print(f"allreduce_group before rank {get_rank()}: {complex_data}")

Comm_OP.allreduce_group(complex_data, c_op="sum")
print(f"allreduce_group after rank {get_rank()}: {complex_data}")
# vqnetrun -n 2 python test.py

reduce_group(tensor, root=0, c_op='avg', GroupComm=None)

组内reduce通信接口。

参数:

• tensor – 输入数据.

• root – 指定进程号.

• c_op – 计算方法.

• GroupComm – 通信组, 仅mpi进行组内通信时需要.

Examples:

from pyvqnet.distributed import CommController,get_rank,get_local_rank
from pyvqnet.tensor import tensor
import numpy as np
Comm_OP = CommController("nccl")

Comm_OP.ncclSplitGroup([[0, 1]])

complex_data = tensor.QTensor([3+1j, 2, 1 + get_rank()],dtype=8).reshape((3,1)).toGPU(1000+ get_local_rank())

print(f"reduce_group before rank {get_rank()}: {complex_data}")

Comm_OP.reduce_group(complex_data, c_op="sum")
print(f"reduce_group after rank {get_rank()}: {complex_data}")
# vqnetrun -n 2 python test.py

broadcast_group(tensor, root=0, GroupComm=None)

组内broadcast通信接口。

参数:

• tensor – 输入数据.

• root – 指定进程号.

• GroupComm – 通信组, 仅mpi进行组内通信时需要.

Examples:

from pyvqnet.distributed import CommController,get_rank,get_local_rank
from pyvqnet.tensor import tensor
import numpy as np
Comm_OP = CommController("nccl")

Comm_OP.ncclSplitGroup([[0, 1]])

complex_data = tensor.QTensor([3+1j, 2, 1 + get_rank()],dtype=8).reshape((3,1)).toGPU(1000+ get_local_rank())

print(f"broadcast_group before rank {get_rank()}: {complex_data}")

Comm_OP.broadcast_group(complex_data)
Comm_OP.barrier()
print(f"broadcast_group after rank {get_rank()}: {complex_data}")
# vqnetrun -n 2 python test.py

allgather_group(tensor, GroupComm=None)

组内allgather通信接口。

参数:

• tensor – 输入数据.

• GroupComm – 通信组, 仅mpi进行组内通信时需要.

Examples:

from pyvqnet.distributed import CommController,get_rank,init_group
from pyvqnet.tensor import tensor

Comm_OP = CommController("mpi")
group = init_group([[0,1]])
#mpi init group internally
# A list of lists, where each sublist contains a communicator and the corresponding rank list.
complex_data = tensor.QTensor([3+1j, 2, 1 + get_rank()],dtype=8).reshape((3,1))
print(f" before rank {get_rank()}: {complex_data}")
for comm_ in group:
    if Comm_OP.getRank() in comm_[1]:
        complex_data = Comm_OP.all_gather_group(complex_data, comm_[0])
        print(f"after rank {get_rank()}: {complex_data}")
# mpirun -n 2 python test.py

from pyvqnet.distributed import CommController,get_rank,get_local_rank
from pyvqnet.tensor import tensor
Comm_OP = CommController("nccl")
Comm_OP.ncclSplitGroup([[0, 1]])
complex_data = tensor.QTensor([3+1j, 2, 1 + get_rank()],dtype=8).reshape((3,1)).toGPU(1000+ get_local_rank())
print(f" before rank {get_rank()}: {complex_data}")
complex_data = Comm_OP.all_gather_group(complex_data)
print(f"after rank {get_rank()}: {complex_data}")
# mpirun -n 2 python test.py

split_data

在多进程中,使用 split_data 根据进程数对数据进行切分,返回相应进程上数据。

pyvqnet.distributed.datasplit.split_data(x_train, y_train, shuffle=False)

设置分布式计算参数。

参数:

• x_train – np.array - 训练数据.

• y_train – np.array - 训练数据标签.

• shuffle – bool - 是否打乱后再进行切分,默认值是False.

返回:

切分后的训练数据和标签。

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)

get_local_rank

pyvqnet.distributed.ControllComm.get_local_rank()

得到当前节点上进程号。例如你在第2个节点的第3个进程,每个节点5个进程,则返回2。

返回:

当前机器上的当前进程号。

Example:

from pyvqnet.distributed.ControllComm import get_local_rank

print(get_local_rank())
# vqnetrun -n 2 python test.py

get_rank

pyvqnet.distributed.ControllComm.get_rank()

用于获得当前进程的全局进程号。例如你在第2个节点的第3个进程,每个节点5个进程,则返回7。

返回:

当前进程的进程号。

Example:

from pyvqnet.distributed.ControllComm import get_rank

print(get_rank())
# vqnetrun -n 2 python test.py

init_group

pyvqnet.distributed.ControllComm.init_group(rank_lists)

根据给出的进程数列表来对基于cpu下的进程组进行初始化。

参数:

rank_lists – 通信进程组列表.

返回:

初始化后的进程组列表。

Example:

from pyvqnet.distributed import *

Comm_OP = CommController("mpi")
num = tensor.to_tensor(np.random.rand(1, 5))
print(f"rank {Comm_OP.getRank()}  {num}")

group_l = init_group([[0,2], [1]])

for comm_ in group_l:
    if Comm_OP.getRank() in comm_[1]:
        Comm_OP.allreduce_group(num, "sum", GroupComm = comm_[0])
        print(f"rank {Comm_OP.getRank()}  {num} after")

# vqnetrun -n 3 python test.py

PipelineParallelTrainingWrapper

class pyvqnet.distributed.pp.PipelineParallelTrainingWrapper(args, join_layers, trainset)

Pipeline Parallel Training Wrapper 实现了 1F1B训练。仅在 Linux 平台上,且具有 GPU 的情况下可用。 更多算法细节可以在(https://www.deepspeed.ai/tutorials/pipeline/)找到。

参数:

• args – 参数字典。参见示例。

• join_layers – Sequential 模块的列表。

• trainset – 数据集。

返回:

PipelineParallelTrainingWrapper 实例。

以下使用 CIFAR10数据库 CIFAR10_Dataset,在2块GPU上训练AlexNet上的分类任务。 本例子中分成两个流水线并行进程 pipeline_parallel_size = 2。 批处理大小为 train_batch_size = 64, 单GPU 上为 train_micro_batch_size_per_gpu = 32。 其他配置参数可见 args。 此外,每个进程需要在 __main__ 函数中配置环境变量的 LOCAL_RANK。

os.environ["LOCAL_RANK"] = str(dist.get_local_rank())

调用 train_batch 进行训练。

Examples:

import os
import pyvqnet

from pyvqnet.nn import Module,Sequential,CrossEntropyLoss
from pyvqnet.nn import Linear
from pyvqnet.nn import Conv2D
from pyvqnet.nn import activation as F
from pyvqnet.nn import MaxPool2D
from pyvqnet.nn import CrossEntropyLoss

from pyvqnet.tensor import tensor
from pyvqnet.distributed.pp import PipelineParallelTrainingWrapper
from pyvqnet.distributed.configs import comm as dist
from pyvqnet.distributed import *


pipeline_parallel_size = 2

num_steps = 1000

def cifar_trainset_vqnet(local_rank, dl_path='./cifar10-data'):
    transform = pyvqnet.data.TransformCompose([
        pyvqnet.data.TransformResize(256),
        pyvqnet.data.TransformCenterCrop(224),
        pyvqnet.data.TransformToTensor(),
        pyvqnet.data.TransformNormalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    ])

    trainset = pyvqnet.data.CIFAR10_Dataset(root=dl_path,
                                            mode="train",
                                            transform=transform,layout="HWC")

    return trainset

class Model(Module):
    def __init__(self):
        super(Model, self).__init__()
        self.features = Sequential(
        Conv2D(input_channels=3, output_channels=8, kernel_size=(3, 3), stride=(1, 1), padding='same'),
        F.ReLu(),
        MaxPool2D([2, 2], [2, 2]),

        Conv2D(input_channels=8, output_channels=16, kernel_size=(3, 3), stride=(1, 1), padding='same'),
        F.ReLu(),
        MaxPool2D([2, 2], [2, 2]),

        Conv2D(input_channels=16, output_channels=32, kernel_size=(3, 3), stride=(1, 1), padding='same'),
        F.ReLu(),

        Conv2D(input_channels=32, output_channels=64, kernel_size=(3, 3), stride=(1, 1), padding='same'),
        F.ReLu(),

        Conv2D(input_channels=64, output_channels=64, kernel_size=(3, 3), stride=(1, 1), padding='same'),
        F.ReLu(),
        MaxPool2D([3, 3], [2, 2]),)

        self.cls = Sequential(
        Linear(64 * 27 * 27, 512),
        F.ReLu(),

        Linear(512, 256),
        F.ReLu(),
        Linear(256, 10) )

    def forward(self, x):
        x = self.features(x)
        x = tensor.flatten(x,1)
        x = self.cls(x)

        return x

def join_layers(vision_model):
    layers = [
        *vision_model.features,
        lambda x: tensor.flatten(x, 1),
        *vision_model.cls,
    ]
    return layers


if __name__ == "__main__":


    args = {
    "backend":'nccl',
    "train_batch_size" : 64,
    "train_micro_batch_size_per_gpu" : 32,
    "epochs":5,
"optimizer": {
    "type": "Adam",
    "params": {
    "lr": 0.001
    }},
    "local_rank":dist.get_local_rank(),
    "pipeline_parallel_size":pipeline_parallel_size, "seed":42, "steps":num_steps,
    "loss":CrossEntropyLoss(),
    }
    os.environ["LOCAL_RANK"] = str(dist.get_local_rank())
    trainset = cifar_trainset_vqnet(args["local_rank"])
    w = PipelineParallelTrainingWrapper(args,join_layers(Model()),trainset)

    all_loss = {}

    for i in range(args["epochs"]):
        w.train_batch()

    all_loss = w.loss_dict

ZeroModelInitial

class pyvqnet.distributed.ZeroModelInitial(args, model, optimizer)

Zero1 api接口, 目前仅用于linux平台下基于GPU并行计算。

参数:

• args – 参数字典。参见示例。

• model – 输入模型。

• optimizer – 优化器。

返回:

Zero1 Engine.

以下使用 MNIST 数据库, 在2块GPU上训练一个MLP模型上的分类任务。

批处理大小为 train_batch_size = 64, zero_optimization 的阶段 stage 设置为1. 若Optimizer为None, 则采用 args 中 optimizer 的设置. 其他配置参数可见 args。 此外,每个进程需要在配置环境变量的 LOCAL_RANK。

os.environ["LOCAL_RANK"] = str(dist.get_local_rank())

Examples:

from pyvqnet.distributed import *
from pyvqnet import *
from time import time
import pyvqnet.optim as optim
import pyvqnet.nn as nn
import pyvqnet
import sys
import pyvqnet
import numpy as np
import os
import struct

def load_mnist(dataset="training_data",
            digits=np.arange(2),
            path="./"):
    """
    load mnist data
    """
    from array import array as pyarray
    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),dtype=np.float32)

    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


train_images_np, train_labels_np = load_mnist(dataset="training_data", digits=np.arange(10),path="../data/MNIST_data/")
train_images_np = train_images_np / 255.

test_images_np, test_labels_np = load_mnist(dataset="testing_data", digits=np.arange(10),path="../data/MNIST_data/")
test_images_np = test_images_np / 255.

local_rank = pyvqnet.distributed.get_rank()

from pyvqnet.distributed import ZeroModelInitial

class MNISTClassifier(nn.Module):

    def __init__(self):
        super(MNISTClassifier, self).__init__()
        self.fc1 = nn.Linear(28*28, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 128)
        self.fc4 = nn.Linear(128, 64)
        self.fc5 = nn.Linear(64, 10)
        self.ac = nn.activation.ReLu()

    def forward(self, x:pyvqnet.QTensor):

        x = x.reshape([-1, 28*28])
        x = self.ac(self.fc1(x))
        x = self.fc2(x)
        x = self.fc3(x)
        x = self.fc4(x)
        x = self.fc5(x)
        return x

model = MNISTClassifier()

model.to(local_rank + 1000)

Comm_op = CommController("nccl")
Comm_op.broadcast_model_params(model, 0)

batch_size = 64

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

args_ = {
        "train_batch_size": batch_size, # 等效的总batch
        "optimizer": {
            "type": "adam",
            "params": {
            "lr": 0.001,
            }
        },
        "zero_optimization": {
            "stage": 1,
        }
    }

os.environ["LOCAL_RANK"] = str(get_local_rank())
model = ZeroModelInitial(args=args_, model=model, optimizer=optimizer)

def compute_acc(outputs, labels, correct, total):
    predicted = pyvqnet.tensor.argmax(outputs, dim=1, keepdims=True)
    total += labels.size
    correct += pyvqnet.tensor.sums(predicted == labels).item()
    return correct, total

train_acc = 0
test_acc = 0
epochs = 5
loss = 0
time1 = time()

for epoch in range(epochs):
    model.train()
    total = 0
    correct = 0
    step = 0

    num_batches = (train_images_np.shape[0] + batch_size - 1) // batch_size

    for i in range(num_batches):

        data_ = tensor.QTensor(train_images_np[i*batch_size: (i+1) * batch_size,:], dtype = kfloat32)
        labels = tensor.QTensor(train_labels_np[i*batch_size: (i+1) * batch_size,:], dtype = kint64)

        data_ = data_.to(local_rank + 1000)
        labels = labels.to(local_rank + 1000)

        outputs = model(data_)
        loss = criterion(labels, outputs)

        model.backward(loss) # 基于返回的model做backward、step
        model.step()

        correct, total = compute_acc(outputs, labels, correct, total)
        step += 1
        if step % 50 == 0:
            print(f"Train : rank {get_rank()} Epoch [{epoch+1}/{epochs}], step {step} Loss: {loss.item():.4f} acc {100 * correct / total}")
            sys.stdout.flush()

    train_acc = 100 * correct / total

time2 = time()
print(f'Accuracy of the model on the 10000 Train images: {train_acc}% time cost {time2 - time1}')

ColumnParallelLinear

class pyvqnet.distributed.ColumnParallelLinear(input_size, output_size, weight_initializer, bias_initializer, use_bias, dtype, name, tp_comm)

张量并行计算,列并行线性层

线性层定义为 Y = XA + b。 其二维并行为 A = [A_1,…,A_p]。

参数:

• input_size – 矩阵 A 的第一个维度。

• output_size – 矩阵 A 的第二个维度。

• weight_initializer – callable 默认为 normal。

• bias_initializer – callable 默认为0。

• use_bias – bool - 默认为 True。

• dtype – 默认 None,使用默认数据类型。

• name – 模块名称,默认为“”。

• tp_comm – 通讯控制器。

以下使用 MNIST 数据库, 在2块GPU上训练一个MLP模型上的分类任务。

使用时与经典的Linear层的使用相似

多进程使用时基于 vqnetrun -n 2 python test.py 的方式进行

Examples:

import pyvqnet.distributed
import pyvqnet.optim as optim
import pyvqnet.nn as nn
import pyvqnet
import sys
from pyvqnet.distributed.tensor_parallel import ColumnParallelLinear, RowParallelLinear
from pyvqnet.distributed import *
from time import time

import pyvqnet
import numpy as np
import os
from pyvqnet import *
import pytest

Comm_OP = CommController("nccl")

import struct
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),dtype=np.float32)

    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

train_images_np, train_labels_np = load_mnist(dataset="training_data", digits=np.arange(10),path="./data/MNIST/raw/")
train_images_np = train_images_np / 255.

test_images_np, test_labels_np = load_mnist(dataset="testing_data", digits=np.arange(10),path="./data/MNIST/raw/")
test_images_np = test_images_np / 255.

local_rank = pyvqnet.distributed.get_rank()

class MNISTClassifier(nn.Module):
    def __init__(self):
        super(MNISTClassifier, self).__init__()
        self.fc1 = RowParallelLinear(28*28, 512, tp_comm = Comm_OP)
        self.fc2 = ColumnParallelLinear(512, 256, tp_comm = Comm_OP)
        self.fc3 = RowParallelLinear(256, 128, tp_comm = Comm_OP)
        self.fc4 = ColumnParallelLinear(128, 64, tp_comm = Comm_OP)
        self.fc5 = RowParallelLinear(64, 10, tp_comm = Comm_OP)
        self.ac = nn.activation.ReLu()

    def forward(self, x:pyvqnet.QTensor):

        x = x.reshape([-1, 28*28])
        x = self.ac(self.fc1(x))
        x = self.fc2(x)
        x = self.fc3(x)
        x = self.fc4(x)
        x = self.fc5(x)
        return x


model = MNISTClassifier()
total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)

model.to(local_rank + 1000)

Comm_OP.broadcast_model_params(model, 0)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

def compute_acc(outputs, labels, correct, total):
    predicted = pyvqnet.tensor.argmax(outputs, dim=1, keepdims=True)
    total += labels.size
    correct += pyvqnet.tensor.sums(predicted == labels).item()
    return correct, total

train_acc = 0
test_acc = 0
epochs = 5
loss = 0

time1 = time()
for epoch in range(epochs):
    model.train()
    total = 0
    correct = 0
    step = 0

    batch_size = 64
    num_batches = (train_images_np.shape[0] + batch_size - 1) // batch_size

    for i in range(num_batches):
        data_ = tensor.QTensor(train_images_np[i*batch_size: (i+1) * batch_size,:], dtype = kfloat32)
        labels = tensor.QTensor(train_labels_np[i*batch_size: (i+1) * batch_size,:], dtype = kint64)

        data_ = data_.to(local_rank + 1000)
        labels = labels.to(local_rank + 1000)

        optimizer.zero_grad()

        outputs = model(data_)
        loss = criterion(labels, outputs)

        loss.backward()
        optimizer.step()

        correct, total = compute_acc(outputs, labels, correct, total)
        step += 1
        if step % 50 == 0:
            print(f"Train : rank {get_rank()} Epoch [{epoch+1}/{epochs}], step {step} Loss: {loss.item():.4f} acc {100 * correct / total}")
            sys.stdout.flush()

    train_acc = 100 * correct / total
time2 = time()

print(f'Accuracy of the model on the 10000 Train images: {train_acc}% time cost {time2 - time1}')

RowParallelLinear

class pyvqnet.distributed.RowParallelLinear(input_size, output_size, weight_initializer, bias_initializer, use_bias, dtype, name, tp_comm)

张量并行计算,行并行线性层。

线性层的定义为 Y = XA + b。A 沿其一维并行,X 沿其二维并行。 A = transpose([A_1 … A_p]) X = [X_1, …, X_p]。

参数:

• input_size – 矩阵 A 的第一个维度。

• output_size – 矩阵 A 的第二个维度。

• weight_initializer – callable 默认为 normal。

• bias_initializer – callable 默认为0。

• use_bias – bool - 默认为 True。

• dtype – 默认 None,使用默认数据类型。

• name – 模块名称。

• tp_comm – 通讯控制器。

以下使用 MNIST 数据库, 在2块GPU上训练一个MLP模型上的分类任务。 使用时与经典的Linear层的使用相似

多进程使用时基于 vqnetrun -n 2 python test.py 的方式进行

Examples:

import pyvqnet.distributed
import pyvqnet.optim as optim
import pyvqnet.nn as nn
import pyvqnet
import sys
from pyvqnet.distributed.tensor_parallel import ColumnParallelLinear, RowParallelLinear
from pyvqnet.distributed import *
from time import time

import pyvqnet
import numpy as np
import os
from pyvqnet import *
import pytest

Comm_OP = CommController("nccl")

import struct
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),dtype=np.float32)

    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

train_images_np, train_labels_np = load_mnist(dataset="training_data", digits=np.arange(10),path="./data/MNIST/raw/")
train_images_np = train_images_np / 255.

test_images_np, test_labels_np = load_mnist(dataset="testing_data", digits=np.arange(10),path="./data/MNIST/raw/")
test_images_np = test_images_np / 255.

local_rank = pyvqnet.distributed.get_rank()

class MNISTClassifier(nn.Module):
    def __init__(self):
        super(MNISTClassifier, self).__init__()
        self.fc1 = RowParallelLinear(28*28, 512, tp_comm = Comm_OP)
        self.fc2 = ColumnParallelLinear(512, 256, tp_comm = Comm_OP)
        self.fc3 = RowParallelLinear(256, 128, tp_comm = Comm_OP)
        self.fc4 = ColumnParallelLinear(128, 64, tp_comm = Comm_OP)
        self.fc5 = RowParallelLinear(64, 10, tp_comm = Comm_OP)
        self.ac = nn.activation.ReLu()


    def forward(self, x:pyvqnet.QTensor):

        x = x.reshape([-1, 28*28])
        x = self.ac(self.fc1(x))
        x = self.fc2(x)
        x = self.fc3(x)
        x = self.fc4(x)
        x = self.fc5(x)
        return x

model = MNISTClassifier()
total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)

model.to(local_rank + 1000)
Comm_OP.broadcast_model_params(model, 0)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

def compute_acc(outputs, labels, correct, total):
    predicted = pyvqnet.tensor.argmax(outputs, dim=1, keepdims=True)
    total += labels.size
    correct += pyvqnet.tensor.sums(predicted == labels).item()
    return correct, total

train_acc = 0
test_acc = 0
epochs = 5
loss = 0

time1 = time()
for epoch in range(epochs):
    model.train()
    total = 0
    correct = 0
    step = 0

    batch_size = 64
    num_batches = (train_images_np.shape[0] + batch_size - 1) // batch_size

    for i in range(num_batches):
        data_ = tensor.QTensor(train_images_np[i*batch_size: (i+1) * batch_size,:], dtype = kfloat32)
        labels = tensor.QTensor(train_labels_np[i*batch_size: (i+1) * batch_size,:], dtype = kint64)

        data_ = data_.to(local_rank + 1000)
        labels = labels.to(local_rank + 1000)

        optimizer.zero_grad()

        outputs = model(data_)
        loss = criterion(labels, outputs)

        loss.backward()
        optimizer.step()

        correct, total = compute_acc(outputs, labels, correct, total)
        step += 1
        if step % 50 == 0:
            print(f"Train : rank {get_rank()} Epoch [{epoch+1}/{epochs}], step {step} Loss: {loss.item():.4f} acc {100 * correct / total}")
            sys.stdout.flush()

    train_acc = 100 * correct / total
time2 = time()

print(f'Accuracy of the model on the 10000 Train images: {train_acc}% time cost {time2 - time1}')