pytorch基础（3）【sigmoid,激活函数，优化器】

sigmoid函数

logistic function是一种sigmoid函数

和Linear的区别

sigmoid函数是不需要参数的，所以不用对其初始化（直接调用nn.functional.sigmoid即可）。
另外loss函数从MSE改用交叉熵BCE：尽可能和真实分类贴近。

# -*- coding: utf-8 -*-
"""
Created on Mon Oct 18 08:35:00 2021

@author: 86493
"""
import torch
import torch.nn as nn
import matplotlib.pyplot as plt  
import torch.nn.functional as F
import numpy as np

# 准备数据
x_data = torch.Tensor([[1.0], [2.0], [3.0]])
y_data = torch.Tensor([[0], [0], [1]])


losslst = []

class LogisticRegressionModel(nn.Module):
    def __init__(self):
        super(LogisticRegressionModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)
        
    def forward(self, x):
    	# 和线性模型的网络的唯一区别在这句，多了F.sigmoid
        y_predict = F.sigmoid(self.linear(x))
        return y_predict
    
model = LogisticRegressionModel()

# 使用交叉熵作损失函数
criterion = torch.nn.BCELoss(size_average = False)
optimizer = torch.optim.SGD(model.parameters(), 
                            lr = 0.01)

# 训练
for epoch in range(1000):
    y_predict = model(x_data)
    loss = criterion(y_predict, y_data)
    # 打印loss对象会自动调用__str__
    print(epoch, loss.item())
    losslst.append(loss.item())
    # 梯度清零后反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# 画图
plt.plot(range(1000), losslst)
plt.ylabel('Loss')
plt.xlabel('epoch')
plt.show()


# test
# 每周学习的时间，200个点
x = np.linspace(0, 10, 200)
x_t = torch.Tensor(x).view((200, 1))
y_t = model(x_t)
y = y_t.data.numpy()
plt.plot(x, y)
# 画 probability of pass = 0.5的红色横线
plt.plot([0, 10], [0.5, 0.5], c = 'r')
plt.xlabel('Hours')
plt.ylabel('Probability of Pass')
plt.grid()
plt.show()

1.如果reduce=false，size_average参数失效，直接返回向量形式的loss。
2.如果reduce=true，那么loss返回的是标量
3.size_average=true，返回的是loss.mean()

4.size_average=false，返回的是loss.sum()

注意：默认情况下， reduce = True，size_average = True

和一维特征的区别

之前的一维特征input，只有一个x和权重w相乘，多维的情况则是xi依次与逐个wi相乘（ps：每行x都这样算，每行即每个样本），可以用向量形式表示：

激活函数

relu取值范围也是0到1，但是如果input是小于0的则relu值为0（输出0是有风险的，因为后面可能会算ln 0，所以如果前面用的其他的激活函数，注意：最后一个一般改为sigmoid激活函数，这样就能输出0到1之间数）。

Pytorch的优化器

Pytorch提供了一个优化器的库torch.optim，在这里面给我们提供了十种优化器。

torch.optim.ASGD
torch.optim.Adadelta
torch.optim.Adagrad
torch.optim.Adam
torch.optim.AdamW
torch.optim.Adamax
torch.optim.LBFGS
torch.optim.RMSprop
torch.optim.Rprop
torch.optim.SGD
torch.optim.SparseAdam

而以上这些优化算法均继承于Optimizer，下面我们先来看下所有优化器的基类Optimizer。定义如下：

class Optimizer(object):
    def __init__(self, params, defaults):        
        self.defaults = defaults
        self.state = defaultdict(dict)
        self.param_groups = []

Optimizer有三个属性：
defaults：存储的是优化器的超参数，例子如下：

{'lr': 0.1, 'momentum': 0.9, 'dampening': 0, 'weight_decay': 0, 'nesterov': False}

state：参数的缓存，例子如下

defaultdict(<class 'dict'>, {tensor([[ 0.3864, -0.0131],
        [-0.1911, -0.4511]], requires_grad=True): {'momentum_buffer': tensor([[0.0052, 0.0052],
        [0.0052, 0.0052]])}})

param_groups：管理的参数组，是一个list，其中每个元素是一个字典，顺序是params，lr，momentum，dampening，weight_decay，nesterov，例子如下

[{'params': [tensor([[-0.1022, -1.6890],
					[-1.5116, -1.7846]],
					requires_grad=True)], 
			'lr': 1, 
			'momentum': 0, 
			'dampening': 0, 
			'weight_decay': 0, 
			'nesterov': False}]

zero_grad()：清空所管理参数的梯度，Pytorch的特性是张量的梯度不自动清零，因此每次反向传播后都需要清空梯度。

def zero_grad(self, set_to_none: bool = False):
    for group in self.param_groups:
        for p in group['params']:
            if p.grad is not None:  #梯度不为空
                if set_to_none: 
                    p.grad = None
                else:
                    if p.grad.grad_fn is not None:
                        p.grad.detach_()
                    else:
                        p.grad.requires_grad_(False)
                    p.grad.zero_()# 梯度设置为0

step()：执行一步梯度更新，参数更新
add_param_group()：添加参数组
load_state_dict() ：加载状态参数字典，可以用来进行模型的断点续训练，继续上次的参数进行训练
state_dict()：获取优化器当前状态信息字典