一起来学PyTorch——torch.nn感知机神经网络

torch.nn提供了Module类，实现了网络各层的定义及前向计算与反向传播。在使用中，需要创建对象继承torch.nn.Module，在初始化中定义模型结构与参数，在函数forward（）中编写网络前向过程即可。也就是说torch.nn可以用来编写感知机，所以我们先介绍一下感知机。

一.感知机

上面的图可以表示一个两层的感知机。每一个箭头都表示一个线性计算，如红色箭头，表示h1=w1*x1+b1，其中w1，b1为参数。x1为这个箭头的输入，h1为输出。 在蓝色箭头中，h1作为输入之前，可以使用激活函数进行处理【对这一步有疑问的同学，可以留言】。同样进行线性运算。接下来就用torch.nn的Module类来模拟，红色+蓝色箭头的过程。

import torch
from torch import nn
#首先建立一个子module，继承nn.Module
#代表线性计算过程，参数随机生成
class Linear(nn.Module):
    def __init__(self, in_dim, out_dim):
        super(Linear, self).__init__() #调用nn.Module的__init__函数
        #使用nn.Parameter来构造w，b参数
        self.w = nn.Parameter(torch.randn(in_dim, out_dim))
        self.b = nn.Parameter(torch.randn(out_dim))
    #在forward中进行前向传播，即 h = w*x+b
    def forward(self, x):
        x = x.matmul(self.w)
        y = x + self.b.expend_as(x)
        return y

# 构建感知机类，继承nn.Module，并调用Linear的实例
class Perception(nn.Module):
    def __init__(self, in_dim, hid_dim, out_dim):
        super(Perception, self).__init__()
        self.layer1 = Linear(in_dim, hid_dim) #红色箭头那一层的计算
        self.layer2 = Linear(hid_dim, out_dim)#蓝色箭头那一层的计算
    def forward(self, x):
        x = self.layer1(x) #计算h = w*x+b
        y = torch.sigmod(x)#用sigmoid激活函数处理h
        y = self.layer2(y) #将h作为蓝色箭头的输入，进行计算 w*h+b
        y = torch.sigmoid(y) #将结果用sigmoid激活函数处理
        return y

建立完之后，进行调用

>>> perception = Perception(2, 3, 2)
>>> perception
Perception(
 (layer1): Linear()
 (layer2): Linear()
)
# named_parameters()可以返回学习参数的迭代器，分别为参数名与参数值
# 即w和b
>>> for name, parameter in perception.named_parameters():
        print(name, parameter)
layer1.w Parameter containing:
tensor([[ 0.1265, -0.6858, 0.0637],
        [ 0.5424, -0.2596, -2.1362]])
layer1.b Parameter containing:
tensor([-0.1427, 1.4034, 0.1175])
layer2.w Parameter containing:
tensor([[ 0.2575, -3.6569],
        [ 0.3657, -1.2370],
        [ 0.7178, -0.9569]])
layer2.b Parameter containing:
tensor([ 0.2041, -0.2558])
#随机生成数据，
>>> data = torch.randn(4, 2)
>>> data
tensor([[ 0.1399, -0.6214],
        [ 0.1325, -1.6260],
        [ 0.0035, -1.0567],
        [-0.6020, -0.9674]])
# 将输入数据传入perception，perception（）相当于调用perception中的forward（）函数
>>> output = perception(data)
>>> output
tensor([[ 0.7654, 0.0308],
        [ 0.7829, 0.0386],
        [ 0.7779, 0.0331],
        [ 0.7781, 0.0326]])

搭建一个基本的神经网络还是比较容易实现的，再介绍几个应用的关键点：

1. nn.Parameter函数

用来定义全连接中的w和b参数，这是一种特殊的Tensor构造方法，默认需要求导，即requires_grad为True

2. forward()

设a为继承了Module的实例，则a（data）可以直接调用a对象的forward方法。因为底层.__call__()方法调用了forward（）函数。

3. nn.Sequential()模块

当模型中只是简单的前馈网络，即上一层的输出直接作为下一层的输入，这是可以采用nn.Sequential（）模块来快速搭建模型。

# 构建感知机类，继承nn.Module，并调用了Linear的子module
from torch import nn
class Perception(nn.Module):
    def __init__(self, in_dim, hid_dim, out_dim):
        super(Perception, self).__init__()
        # 利用nn.Sequential()快速搭建网络模块
        self.layer = nn.Sequential(
            nn.Linear(in_dim, hid_dim),
            nn.Sigmoid(),
            nn.Linear(hid_dim, out_dim),
            nn.Sigmoid()
        )
    def forward(self, x):
        y = self.layer(x)
        return y
    

欢迎同学们共同探讨学习。