深度学习PyTorch | 线性回归，softmax和分类模型，多层感知机

线性回归

损失函数：

优化函数-梯度下降：

在求数值解的优化算法中，小批量随机梯度下降（mini-batch stochastic gradient descent）在深度学习中被广泛使用。它的算法很简单：先选取一组模型参数的初始值，如随机选取；接下来对参数进行多次迭代，使每次迭代都可能降低损失函数的值。在每次迭代中，先随机均匀采样一个由固定数目训练数据样本所组成的小批量（mini-batch）BB，然后求小批量中数据样本的平均损失有关模型参数的导数（梯度），最后用此结果与预先设定的一个正数的乘积作为模型参数在本次迭代的减小量。

学习率: ηη代表在每次优化中，能够学习的步长的大小
批量大小: BB是小批量计算中的批量大小batch size

优化函数的有以下两个步骤：

• (i)初始化模型参数，一般来说使用随机初始化；
• (ii)我们在数据上迭代多次，通过在负梯度方向移动参数来更新每个参数。

线性回归模型使用pytorch的简洁实现：

import torch
from torch import nn
import numpy as np
import torch.utils.data as Data
from torch.nn import init
import torch.optim as optim

torch.manual_seed(1)

# 生成数据集
num_inputs = 2 # 即x1与x2两个参数
num_examples = 1000 # 数据集样本数，利用np.random.normal生成。

true_w = [2, -3.4] # 真实值，最后预测值应该无线靠近它
true_b = 4.2  #真实值
##生成1000行两列的特征数据，这两列，第一列当作x1,第二列当作x2
features = torch.tensor(np.random.normal(0, 1, (num_examples, num_inputs)), dtype=torch.float)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b # 得到1000个数的tensor
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()), dtype=torch.float)

# 读取数据
batch_size = 10
# combine featues and labels of dataset
dataset = Data.TensorDataset(features, labels)

# put dataset into DataLoader
data_iter = Data.DataLoader(
    dataset=dataset,            # torch TensorDataset format
    batch_size=batch_size,      # mini batch size
    shuffle=True,               # whether shuffle the data or not
    num_workers=2,              # read data in multithreading
)

# 定义模型
class LinearNet(nn.Module):
    def __init__(self, n_feature):
        super(LinearNet, self).__init__()      # call father function to init 
        self.linear = nn.Linear(n_feature, 1)  # nn.Linear表示的是 y=w*x b，分布表示的是x是n_featue维，y是1维

    def forward(self, x):
        y = self.linear(x)
        return y
    
net = LinearNet(num_inputs)

# ways to init a multilayer network
# method one
net = nn.Sequential(
    nn.Linear(num_inputs, 1)
    # other layers can be added here
    )

# method two
net = nn.Sequential()
net.add_module('linear', nn.Linear(num_inputs, 1))
# net.add_module ......

# method three
from collections import OrderedDict
net = nn.Sequential(OrderedDict([
          ('linear', nn.Linear(num_inputs, 1))
          # ......
        ]))

 # 初始化模型参数

init.normal_(net[0].weight, mean=0.0, std=0.01)
init.constant_(net[0].bias, val=0.0)  # or you can use `net[0].bias.data.fill_(0)` to modify it directly

# 定义损失函数
loss = nn.MSELoss()  

# 定义优化函数
optimizer = optim.SGD(net.parameters(), lr=0.03)   # built-in random gradient descent function
print(optimizer)  # function prototype: `torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)`

# 训练
num_epochs = 3 #迭代次数
for epoch in range(1, num_epochs + 1):
    for X, y in data_iter:
        output = net(X) #前向传播
        l = loss(output, y.view(-1, 1)) #计算loss
        optimizer.zero_grad() # 梯度归零
        l.backward() # 反向传播
        optimizer.step() # 更新参数
    print('epoch %d, loss: %f' % (epoch, l.item()))

# 结果比较
# result comparision
dense = net[0]
print(true_w, dense.weight.data)  # [2, -3.4] tensor([[ 2.0008, -3.4007]])
print(true_b, dense.bias.data)    # 4.2 tensor([4.2006])

softmax和分类模型

softmax基本概念：

softmax回归与线性回归相同，都是将输入特征与权重做线性叠加，，其输出层也是一个全连接层。与线性回归的最大不同在于：Softmaxso回归的输出值个数等于标签中的类别数；

softmax回归对样本ii分类的矢量计算表达式为：

总结：

• Softmax回归适用于分类问题，使用Softmax运算输出类别的概率分布；
• Softmax回归是一个单层神经网络，输出个数等于分类问题中的类别个数；
• 交叉熵用于衡量两个概率分布的差异；

softmax回归模型使用pytorch的简洁实现：

# 加载各种包或者模块
import torch
from torch import nn
from torch.nn import init
import numpy as np
import sys
sys.path.append("/home/kesci/input")
import d2lzh1981 as d2l

# 初始化参数和获取数据
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

# 定义网络模型
num_inputs = 784
num_outputs = 10

class LinearNet(nn.Module):
    def __init__(self, num_inputs, num_outputs):
        super(LinearNet, self).__init__()
        self.linear = nn.Linear(num_inputs, num_outputs)
    def forward(self, x): # x 的形状: (batch, 1, 28, 28)
        y = self.linear(x.view(x.shape[0], -1))
        return y
    
# net = LinearNet(num_inputs, num_outputs)

class FlattenLayer(nn.Module):
    def __init__(self):
        super(FlattenLayer, self).__init__()
    def forward(self, x): # x 的形状: (batch, *, *, ...)
        return x.view(x.shape[0], -1)

from collections import OrderedDict
net = nn.Sequential(
        # FlattenLayer(),
        # LinearNet(num_inputs, num_outputs) 
        OrderedDict([
           ('flatten', FlattenLayer()),
           ('linear', nn.Linear(num_inputs, num_outputs))]) # 或者写成我们自己定义的 LinearNet(num_inputs, num_outputs) 也可以
        )

# 初始化模型参数
init.normal_(net.linear.weight, mean=0, std=0.01)
init.constant_(net.linear.bias, val=0)

# 定义损失函数
loss = nn.CrossEntropyLoss() # 下面是他的函数原型
# class torch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean')

# 定义优化函数
optimizer = torch.optim.SGD(net.parameters(), lr=0.1) # 下面是函数原型
# class torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)

# 训练
num_epochs = 5
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)

多层感知机（MLP)

多层感知机由感知机推广而来，最主要的特点是有多个神经元层，因此也叫深度神经网络(DNN: Deep Neural Networks)。

多层感知机的一个重要特点就是多层，我们将第一层称之为输入层，最后一层称之有输出层，中间的层称之为隐层。MLP并没有规定隐层的数量，因此可以根据各自的需求选择合适的隐层层数。且对于输出层神经元的个数也没有限制。

多层感知机就是含有至少一个隐藏层的由全连接层组成的神经网络，且每个隐藏层的输出通过**函数进行变换。多层感知机的层数和各隐藏层中隐藏单元个数都是超参数。以单隐藏层为例并沿用本节之前定义的符号，多层感知机按以下方式计算输出：

其中ϕ表示**函数。

**函数:

对隐藏变量使用按元素运算的非线性函数进行变换，然后再作为下一个全连接层的输入。这个非线性函数被称为**函数（activation function）。

几个常用的**函数：

ReLU函数

ReLU（rectified linear unit）函数提供了一个很简单的非线性变换。给定元素x，该函数定义为

ReLU函数只保留正数元素，并将负数元素清零。

Sigmoid函数

sigmoid函数可以将元素的值变换到0和1之间：

tanh函数

tanh（双曲正切）函数可以将元素的值变换到-1和1之间：

ReLu函数是一个通用的**函数，目前在大多数情况下使用。但是，ReLU函数只能在隐藏层中使用。

用于分类器时，sigmoid函数及其组合通常效果更好。由于梯度消失问题，有时要避免使用sigmoid和tanh函数。

在神经网络层数较多的时候，最好使用ReLu函数，ReLu函数比较简单计算量少，而sigmoid和tanh函数计算量大很多。

在选择**函数的时候可以先选用ReLu函数如果效果不理想可以尝试其他**函数。