Linear Regression、Logistic Regression、激励函数activation function（relu,sigmoid, tanh, softplus）

1.5.2.Linear Regression
1.5.2.1.Linear Regression
1.5.2.1.1.案例1
1.5.2.1.2.案例2
1.5.2.1.3.案例3源码（带有保存模型）
1.5.2.2.Logistic Regression
1.5.2.2.1.案例1
1.5.2.2.2.更深更宽的网络
1.5.2.2.3.逻辑回归案例
1.5.2.3.Classification
1.5.2.4.激励函数activation function（relu,sigmoid, tanh, softplus）

1.5.2.Linear Regression

以下转自：

https://blog.csdn.net/caichao08/article/details/78993893
https://blog.csdn.net/weixin_42587745/article/details/90346126
https://ptorch.com/news/6.html
https://www.jb51.net/article/140557.htm

1.5.2.1.Linear Regression

对于线性回归，即给出一系列的点，找一条直线，使得这条直线与这些点的距离之和最小。

上图就简单地描绘出了线性回归的基本原理，接下来我们来重点讲讲如何用pytorch写一个简单的线性回归。

接下来，使用torch.from_numpy()和numpy函数即可进行相互转换：

x = torch.from_numpy(x)
y = torch.from_numpy(y)

1.5.2.1.1.案例1

使用PyTorch定义线性回归模型一般分以下几步：
1.设计网络架构
2.构建损失函数(loss)和优化器(optimizer)
3.训练（包括前馈（forward）、反向传播（backward）、更新模型参数（update））

# -*- coding: UTF-8 -*-

import torch
from torch.autograd import Variable

# train data
x_data = Variable(torch.Tensor([[1.0],[2.0],[3.0]]))
y_data = Variable(torch.Tensor([[2.0],[4.0],[6.0]]))

class Model(torch.nn.Module):
    def __init__(self):
        super(Model,self).__init__()
        self.linear = torch.nn.Linear(1,1)  #One in and one out

    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred


# our model
model = Model()

criterion = torch.nn.MSELoss(size_average=False)         # Defined loss function
optimizer = torch.optim.SGD(model.parameters(),lr=0.01)  # Defined optimizer

# Training: forward,loss,backward,step
# Training loop
for epoch in range(50):
    # Forward pass
    y_pred = model(x_data)

    # Compute loss
    loss = criterion(y_pred, y_data)
    print(epoch,'次循环：', loss.data.numpy())

    # Zero gradients
    optimizer.zero_grad()
    # perform backward pass
    loss.backward()
    # update weights
    optimizer.step()


# After training
hour_var = Variable(torch.Tensor([[4.0]]))
print("predict (after training)", 4, model.forward(hour_var).data.numpy())

迭代十次打印结果：

0 次循环： 128.36353
1 次循环： 57.22348
2 次循环： 25.55281
3 次循环： 11.452799
4 次循环： 5.1747613
5 次循环： 2.3788614
6 次循环： 1.1331253
7 次循环： 0.57749355
8 次循环： 0.32909214
9 次循环： 0.2174757

loss还在继续下降，此时输入4得到的结果还不是预测的很准
当迭代次数设置为50时：

10 次循环： 0.16676745
11 次循环： 0.14318845
12 次循环： 0.13170049
13 次循环： 0.12560984
14 次循环： 0.12193605
15 次循环： 0.11935152
16 次循环： 0.117265806
17 次循环： 0.11541578
18 次循环： 0.11368369
19 次循环： 0.11201717
20 次循环： 0.11039279
21 次循环： 0.108799875
22 次循环： 0.10723348
23 次循环： 0.105691046
24 次循环： 0.10417137
25 次循环： 0.10267406
26 次循环： 0.10119824
27 次循环： 0.09974393
28 次循环： 0.09831043
29 次循环： 0.0968976
30 次循环： 0.09550497
31 次循环： 0.09413239
32 次循环： 0.09277948
33 次循环： 0.09144618
34 次循环： 0.0901321
35 次循环： 0.08883653
36 次循环： 0.08755979
37 次循环： 0.08630159
38 次循环： 0.085061245
39 次循环： 0.08383879
40 次循环： 0.082633875
41 次循环： 0.08144614
42 次循环： 0.08027585
43 次循环： 0.07912208
44 次循环： 0.07798502
45 次循环： 0.07686419
46 次循环： 0.07575947
47 次循环： 0.07467067
48 次循环： 0.073597685
49 次循环： 0.07253992
predict (after training) 4 [[7.690391]]

此时，函数已经拟合比较好了

torch.nn.Linear(1,1),只需要知道输入和输出维度，里面的参数矩阵是随机初始化的（具体是不是随机的还是按照一定约束条件初始化的我不确定），所有每次计算loss会下降到不同的位置（模型的参数更新从而也不同），导致结果不一样。

1.5.2.1.2.案例2

以下转自：https://blog.csdn.net/caichao08/article/details/78993893

首先第一步是产生训练的数据，这里我们采用scikit工具箱来完成。

# -*- coding: UTF-8 -*-

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets.samples_generator import make_regression
import torch
import torch.nn as nn
from torch.autograd import Variable

# n_samples表示样本数量， n_features表示输入参数个数, noise代表噪声, coef选择是否输出系数
# 当n_features = 1 时，可以进行可视化
X, y, coef =make_regression(n_samples=1000, n_features=1,noise=10, coef=True)
plt.scatter(X, y,  color='green')
plt.plot(X, X*coef, color='red',linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

print(coef)
print(np.shape(X))
print(np.shape(y))

输出结果：

84.20925934904598
(1000, 1)
(1000,)

下一步是建立一个模型

# 首先将数据转换成tensor变量
# 上面的make_regression产生的是double型数据, 直接导入到tensor里面会跑不通， 这里把它们转成float32型的变量
X = X.astype('float32')
y = y.astype('float32')

print(np.size(X))
print(np.shape(X))
print(np.shape(y))

# 下面的这一步非常的关键， pytorch里面只支持(n, 1)这种类型的matric，而不支持这种(n,)类似的scaler或vector类型的变量
y = np.reshape(y, (np.size(X), 1))
# 下面是将numpy转换成Tensor，使用torch.from_numpy()和numpy函数即可进行相互转换
train_x = torch.from_numpy(X)
train_y = torch.from_numpy(y)


# 再定义一个模型，一般用类的形式来产生
# 这里的nn.Module是被继承了，nn.Module里面包含了很多需要的模块
class linear_regression(nn.Module):
    """
    linear regression module
    """

    def __init__(self):
        super(linear_regression, self).__init__()
        # 定义Linear 函数只有一个输入一个输出，这里的nn.Linear表示的是 y=w*x+b，里面的两个参数都是1，表示的是x是1维，y也是1维。
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        out = self.linear(x)
        return out


model = linear_regression()
print(model)
print(train_x.size())
print(train_y.size())
print(type(train_x))

输出结果：

1000
(1000, 1)
(1000,)
linear_regression(
  (linear): Linear(in_features=1, out_features=1, bias=True)
)
torch.Size([1000, 1])
torch.Size([1000, 1])
<class 'torch.Tensor'>

接着对模型的未知参数进行求解

# 紧接着需要定义loss和optimize了
# 利用最小二乘来定义损失
# 学习率,当学习率很小的时候，得循环很多次才能得到比较好的结果，如果是le-3,下面的num_epoch得1900次差不多才能得到比较好的效果
learning_rate = 1e-2   

# 这里使用的是最小二乘loss，之后我们做分类问题更多的使用的是cross entropy loss，交叉熵。优化函数使用的是随机梯度下降，注意需要将model的参数model.parameters()传进去让这个函数知道他要优化的参数是哪些。
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# SGD的第一参数传入的是模型要优化的参数， 第二个表示的是学习率
# 开始训练
num_epoch = 200

for epoch in range(num_epoch):
    # 将数据转换成tensor变量，这样可以自动求导
    inputs = Variable(train_x)
    targets = Variable(train_y)
    # # 前向 + 后向 + 优化
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()

if (epoch+1) % 20 == 0:
        print("loss:" + {loss.item()})
        #print(f'Epoch[{epoch+1}/{num_epochs}], loss: {loss.item():.6f}')

只要learning_rate选的好，这里基本上一步就能得出正确结果了

再看看预测的结果

# 下面来用数据做预测
# 特别注意的是需要用model.eval()，让model变成测试模式，这主要是对dropout和batch,  normalization的操作在训练和测试的时候是不一样的。
model.eval()
# model只支持tensor类型的变量， 所以对model的输入要进行转换, 而画图则要转化成numpy类型
predicts = model(Variable(train_x)).data.numpy()
plt.figure()
plt.plot(X, y, 'go', label=u'original data')
plt.plot(X, coef*X, 'b', label=u'ground truth')
plt.plot(X, predicts, 'r', label=u'predicted data')
plt.legend()
plt.show()

从下面的结果图上来看还是很准的

1.5.2.1.3.案例3源码（带有保存模型）

# -*- coding: UTF-8 -*-

import matplotlib.pyplot as plt
import numpy as np
import torch
from torch import nn
from torch.autograd import Variable

x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
                    [9.779], [6.182], [7.59], [2.167], [7.042],
                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)

y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
                    [3.366], [2.596], [2.53], [1.221], [2.827],
                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)


x_train = torch.from_numpy(x_train)

y_train = torch.from_numpy(y_train)


# Linear Regression Model
class linearRegression(nn.Module):
    def __init__(self):
        super(linearRegression, self).__init__()
        self.linear = nn.Linear(1, 1)  # input and output is 1 dimension

    def forward(self, x):
        out = self.linear(x)
        return out


model = linearRegression()
# 定义loss和优化函数
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)

# 开始训练
num_epochs = 2000
for epoch in range(num_epochs):
    inputs = x_train
    target = y_train

    # forward
    out = model(inputs)
    loss = criterion(out, target)
    # backward
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 20 == 0:
        print(f'Epoch[{epoch+1}/{num_epochs}], loss: {loss.item():.6f}')

model.eval()
with torch.no_grad():
    predict = model(x_train)
predict = predict.data.numpy()

fig = plt.figure(figsize=(10, 5))
plt.plot(x_train.numpy(), y_train.numpy(), 'ro', label='Original data')
plt.plot(x_train.numpy(), predict, label='Fitting Line')
# 显示图例
plt.legend()
plt.show()

# 保存模型
torch.save(model.state_dict(), './linear.pth')

运行结果：

Epoch[20/2000], loss: 16.022251
Epoch[40/2000], loss: 11.373667
Epoch[60/2000], loss: 8.088304
Epoch[80/2000], loss: 5.766390
Epoch[100/2000], loss: 4.125387
Epoch[120/2000], loss: 2.965617
Epoch[140/2000], loss: 2.145954
Epoch[160/2000], loss: 1.566661
Epoch[180/2000], loss: 1.157250
Epoch[200/2000], loss: 0.867900
Epoch[220/2000], loss: 0.663402
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Epoch[1960/2000], loss: 0.170428
Epoch[1980/2000], loss: 0.170426
Epoch[2000/2000], loss: 0.170425

1.5.2.2.Logistic Regression

以下参考：https://www.jb51.net/article/140557.htm
http://blog.csdn.net/m0_37306360
线性回归是解决回归问题的，逻辑回归和线性回归很像，但是它是解决分类问题的(一般二分类问题:0 or 1)。也可以多分类问题(用softmax可以实现)。

使用pytorch实现逻辑回归的基本过程和线性回归差不多，但是有以下几个区别：

以下为sigmoid函数：

在逻辑回归中，我们预测如果当输出大于0.5时，y=1;否则y=0。
损失函数一般采用交叉熵loss:

1.5.2.2.1.案例1

import torch
from torch.autograd import Variable

x_data = Variable(torch.Tensor([[0.6], [1.0], [3.5], [4.0]]))
y_data = Variable(torch.Tensor([[0.], [0.], [1.], [1.]]))


class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear = torch.nn.Linear(1, 1)  # One in one out
        self.sigmoid = torch.nn.Sigmoid()

    def forward(self, x):
        y_pred = self.sigmoid(self.linear(x))
        return y_pred


# Our model
model = Model()

# Construct loss function and optimizer
criterion = torch.nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# Training loop
for epoch in range(500):
    # Forward pass
    y_pred = model(x_data)

    # Compute loss
    loss = criterion(y_pred, y_data)
    if epoch % 20 == 0:
        print(loss.data.numpy())
        
    # Zero gradients
    optimizer.zero_grad()
    # Backward pass
    loss.backward()
    # update weights
    optimizer.step()
    

# After training
hour_var = Variable(torch.Tensor([[0.5]]))
print("predict (after training)", 0.5, model.forward(hour_var).data[0][0])
hour_var = Variable(torch.Tensor([[7.0]]))
print("predict (after training)", 7.0, model.forward(hour_var).data[0][0])

输出结果为：

2.1419365
1.5513724
1.0856804
0.7997792
0.6584054
0.59043765
0.55404615
0.53147745
0.5154158
0.50267094
0.49175227
0.4819196
0.47278577
0.46413925
0.4558599
0.44787702
0.44014725
0.432643
0.4253458
0.41824245
0.4113233
0.4045803
0.3980071
0.3915978
0.38534725
predict (after training) 0.5 tensor(0.4064)
predict (after training) 7.0 tensor(0.9840)

训练完模型之后，输入新的数据0.5，此时输出小于0.5，则为0类别，输入7输出大于0.5，则为1类别。使用softmax做多分类时，哪个维度的数值大，则为哪个数值所对应位置的类别。

1.5.2.2.2.更深更宽的网络

前面的例子都是浅层输入为一维的网络，如果需要更深更宽的网络，使用pytorch也可以很好的实现，以逻辑回归为例：

当输入x的维度很大时，需要更宽的网络：

更深的网络：

采用下面数据集（下载地址：https://github.com/hunkim/PyTorchZeroToAll/tree/master/data）

输入维度为八：

# -*- coding: UTF-8 -*-

import torch
from torch.autograd import Variable
import numpy as np

xy = np.loadtxt('./data/diabetes.csv', delimiter=',', dtype=np.float32)
x_data = Variable(torch.from_numpy(xy[:, 0:-1]))
y_data = Variable(torch.from_numpy(xy[:, [-1]]))

# print(x_data.data.shape)
# print(y_data.data.shape)


class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.l1 = torch.nn.Linear(8, 6)
        self.l2 = torch.nn.Linear(6, 4)
        self.l3 = torch.nn.Linear(4, 1)
        self.sigmoid = torch.nn.Sigmoid()

    def forward(self, x):
        x = self.sigmoid(self.l1(x))
        x = self.sigmoid(self.l2(x))
        y_pred = self.sigmoid(self.l3(x))
        return y_pred


# our model
model = Model()

cirterion = torch.nn.BCELoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

hour_var = Variable(torch.Tensor([[-0.294118, 0.487437, 0.180328, -0.292929, 0, 0.00149028, -0.53117, -0.0333333]]))
print("(Before training)", model.forward(hour_var).data)

# Training loop
for epoch in range(2000):
    y_pred = model(x_data)
    # y_pred,y_data不能写反(因为损失函数为交叉熵loss)
    loss = cirterion(y_pred, y_data)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if epoch % 50 == 0:
        print(epoch, loss.data.numpy())


# After training
hour_var = Variable(torch.Tensor([[-0.294118, 0.487437, 0.180328, -0.292929, 0, 0.00149028, -0.53117, -0.0333333]]))
print("predict (after training)", model.forward(hour_var).data.numpy())

结果：

(Before training) tensor([[0.3952]])
0 0.78095376
50 0.7321978
100 0.7009846
150 0.68111795
200 0.668492
250 0.66046023
300 0.6553401
350 0.65206724
400 0.6499692
xxxxxxxxxxxxxxxxxxx
1550 0.6460486
1600 0.6460425
1650 0.64603657
1700 0.6460306
1750 0.64602476
1800 0.6460189
1850 0.6460131
1900 0.6460073
1950 0.6460014
predict (after training) [[0.6534828]]

1.5.2.2.3.逻辑回归案例：

# -*- coding: UTF-8 -*-

import time

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 定义超参数
batch_size = 64
learning_rate = 1e-3
num_epochs = 100

# 下载训练集 MNIST 手写数字训练集
train_dataset = datasets.FashionMNIST(
    root='../datasets', train=True, transform=transforms.ToTensor(), download=True)

test_dataset = datasets.FashionMNIST(
    root='../datasets', train=False, transform=transforms.ToTensor())

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)


# 定义 Logistic Regression 模型
class Logistic_Regression(nn.Module):
    def __init__(self, in_dim, n_class):
        super(Logistic_Regression, self).__init__()
        self.logistic = nn.Linear(in_dim, n_class)

    def forward(self, x):
        out = self.logistic(x)
        return out


model = Logistic_Regression(28 * 28, 10)  # 图片大小是28x28
use_gpu = torch.cuda.is_available()  # 判断是否有GPU加速
if use_gpu:
    model = model.cuda()
# 定义loss和optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# 开始训练
for epoch in range(num_epochs):
    print('*' * 10)
    print(f'epoch {epoch + 1}')
    since = time.time()
    running_loss = 0.0
    running_acc = 0.0
    model.train()
    for i, data in enumerate(train_loader, 1):
        img, label = data
        img = img.view(img.size(0), -1)  # 将图片展开成 28x28
        if use_gpu:
            img = img.cuda()
            label = label.cuda()
        # 向前传播
        out = model(img)
        loss = criterion(out, label)
        running_loss += loss.item()
        _, pred = torch.max(out, 1)
        running_acc += (pred == label).float().mean()
        # 向后传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if i % 300 == 0:
            print(f'[{epoch + 1}/{num_epochs}] Loss: {running_loss / i:.6f}, Acc: {running_acc / i:.6f}')
    print(f'Finish {epoch + 1} epoch, Loss: {running_loss / i:.6f}, Acc: {running_acc / i:.6f}')
    model.eval()
    eval_loss = 0.
    eval_acc = 0.
    for data in test_loader:
        img, label = data
        img = img.view(img.size(0), -1)
        if use_gpu:
            img = img.cuda()
            label = label.cuda()
        with torch.no_grad():
            out = model(img)
            loss = criterion(out, label)
        eval_loss += loss.item()
        _, pred = torch.max(out, 1)
        eval_acc += (pred == label).float().mean()
    print(f'Test Loss: {eval_loss / len(test_loader):.6f}, Acc: {eval_acc / len(test_loader):.6f}')
    print(f'Time:{(time.time() - since):.1f} s')

# 保存模型
torch.save(model.state_dict(), './logstic.pth')

1.5.2.3.Classification

以下参考：https://www.jb51.net/article/139098.htm

1.5.2.4.激励函数activation function

以下参考：https://www.jb51.net/article/139098.htm
Torch的激励函数都在torch.nn.functional中，relu,sigmoid, tanh, softplus都是常用的激励函数。

相关代码：

# -*- coding: UTF-8 -*-

import torch
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt

x = torch.linspace(-5, 5, 200)
x_variable = Variable(x)  # 将x放入Variable
x_np = x_variable.data.numpy()

# 经过4种不同的激励函数得到的numpy形式的数据结果
y_relu = F.relu(x_variable).data.numpy()
y_sigmoid = torch.sigmoid(x_variable).data.numpy()
y_tanh = torch.tanh(x_variable).data.numpy()
y_softplus = F.softplus(x_variable).data.numpy()

plt.figure(1, figsize=(8, 6))

plt.subplot(221)
plt.plot(x_np, y_relu, c='red', label='relu')
plt.ylim((-1, 5))
plt.legend(loc='best')

plt.subplot(222)
plt.plot(x_np, y_sigmoid, c='red', label='sigmoid')
plt.ylim((-0.2, 1.2))
plt.legend(loc='best')

plt.subplot(223)
plt.plot(x_np, y_tanh, c='red', label='tanh')
plt.ylim((-1.2, 1.2))
plt.legend(loc='best')

plt.subplot(224)
plt.plot(x_np, y_softplus, c='red', label='softplus')
plt.ylim((-0.2, 6))
plt.legend(loc='best')

plt.show()

输出结果：