线性回归

线性回归

数学模型

$$y=w_1\ast x_1+w_2\ast x_2+...+w_n\ast x_n+b$$

令

$$\vec{W}=[w_1,w_2,...,w_n]$$

$$\vec{X}=[x_1,x_2,...,x_n]$$

则

$$y=W\ast X^T+b$$

术语

样 本：$\vec{X}$

标 签：$y$

特 征：$\vec{W}$

数据集：$\overrightarrow{DataSets}=[X_1,X_2,X_3,...,X_m]$

##传统求解

在没有深度学习之前，

当$len(DataSets)<len(\vec{W})$时是无解的，

当$len(DataSets)>len(\vec{W})$时：一般使用最小二乘法求解，

损失函数（评价）

在传统方法里面，使用$MSE$作为评价标准

$$l^i(\vec{W},b)=\frac{1}{2}({\hat{y}}^i-y^i{)}^2$$

$$L(\vec{W},b)=\frac{1}{n}\sum _{i=1}^m{l}^i(\vec{W},b)=\frac{1}{n}\sum _{i=1}^m\frac{1}{2}({\hat{y}}^i-y^i{)}^2$$

优化函数-随机梯度下降

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

$$(\vec{W},b)\leftarrow (\vec{W},b)-\frac{\eta }{\beta }\sum _{i\in \beta }{\partial }_{(}\vec{W},b)l^i(\vec{W},b)$$

学 习 率$(\eta )$：代表在每次优化中，能够学习的步长的大小

批量大小$(\beta )$：是小批量计算中的批量大小batch size

####优化函数步骤：

1、初始化模型参数，一般来说使用随机初始化；

2、我们在数据上迭代多次，通过在负梯度方向移动参数来更新每个参数。

# 使用pytorch实现线性回归模型
import torch
from torch import nn
import numpy as np
torch.manual_seed(1)

print(torch.__version__)
torch.set_default_tensor_type('torch.FloatTensor')

# 设置输入特征数
num_inputs = 2
# 设置样本数量
num_examples = 1000
# 设置真实的权重和偏差，以生成相应的标签
true_w = [2, -3.4]
true_b = 4.2

features = torch.randn(num_examples, num_inputs, dtype=torch.float32)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()),
                       dtype=torch.float32)

# 显示生成的数据
plt.scatter(features[:, 1].numpy(), labels.numpy(), 1)

# 读取数据集
import torch.utils.data as Data

batch_size = 10

# 结合数据集的特性和标签
dataset = Data.TensorDataset(features, labels)
# 将数据集放入DataLoader
data_iter = Data.DataLoader(dataset=dataset,        # torch张量数据集格式
                            batch_size=batch_size,  # 小批量大小
                            shuffle=True,           # 是否打乱数据
                            num_workers=2)          # 线程数
for X, y in data_iter:
    print(X, '\n', y)
    break

# 定义模型
class LinearNet(nn.Module):
    def __init__(self, n_feature):
        super(LinearNet, self).__init__()  # 调用父函数初始化
        # 函数原型: `torch.nn.Linear(in_features, out_features, bias=True)`
        self.linear = nn.Linear(n_feature, 1)
        
    def forward(self, x):
        y = self.linear(x)
        return y

net = LinearNet(num_inputs)
print(net)

# 初始化多层网络的方法
# 方法一
net = nn.Sequential(
    nn.Linear(num_inputs, 1)
    # 可以在内部添加其他层
)

# 方法二
net = nn.Sequential()
net.add_module('linear', nn.Linear(num_inputs, 1))
# 可以继续添加其他层

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

print(net)
print(net[0])

# 初始化模型参数
from torch.nn import init

init.normal_(net[0].weight, mean=0.0, std=0.01)
init.constant_(
    net[0].bias, val=0.0
)  
#  或者您可以使用' net[0].bias.data.fill_(0) '直接修改它

for param in net.parameters():
    print(param)
    
# 定义损失函数
loss = nn.MSELoss()
'''
nn内置平方损失函数
功能原型:“torch.nn.MSELoss(size_average=None, 
                            reduce=None, 
                            reduction='mean')”)”
'''
# 定义优化函数
import torch.optim as optim

optimizer = optim.SGD(net.parameters(), lr=0.03)
'''
内置随机梯度下降功能
函数原型: torch.optim.SGD(params, 
                          lr=, 
                          momentum=0, 
                          dampening=0, 
                          weight_decay=0, 
                          nesterov=False)
'''
print(optimizer)  

# 训练
num_epochs = 5
for epoch in range(1, num_epochs + 1):
    for X, y in data_iter:
        output = net(X)
        l = loss(output, y.view(-1, 1))
        optimizer.zero_grad() # reset gradient == net.zero_grad()
        l.backward()
        optimizer.step()
    print('epoch %d, loss: %f' % (epoch, l.item()))