33- PyTorch实现分类和线性回归 (PyTorch系列) (深度学习)

知识要点

pytorch最常见的创建模型的方式, 子类
读取数据: data = pd.read_csv('./dataset/credit-a.csv', header=None)
数据转换为tensor: X = torch.from_numpy(X.values).type(torch.FloatTensor)
创建简单模型:

from torch import nn
model = nn.Sequential(nn.Linear(15, 1),
                      nn.Sigmoid())

定义损失函数: loss_fn = nn.BCELoss()
定义优化器: opt = torch.optim.SGD(model.parameters(), lr=0.00001)
- 把梯度清零: opt.zero_grad()
- 反向传播计算梯度: loss.backward()
- 更新梯度: opt.step()
查看最终参数: model.state_dict()
计算准确率: ((model(X).data.numpy() > 0.5).astype('int') == Y.numpy()).mean()
独热编码: data = data.join(pd.get_dummies(data.part)).join(pd.get_dummies(data.salary)) # 对每个类别的值都进行0-1编码
删除参数: data.drop(columns=['part', 'salary'], inplace=True)
函数方式执行训练:

for epoch in range(epochs):
    for i in range(no_of_batches):
        start = i*batch
        end = start + batch
        x = X[start: end]
        y = Y[start: end]
        y_pred = model(x)
        loss = loss_fn(y_pred, y)
        opt.zero_grad()
        loss.backward()
        opt.step()

使用dataset, dataloader

HR_ds = TensorDataset(X, Y)
HR_dl = DataLoader(HR_ds, batch_size=batch)

数据拆分: train_x, test_x, train_y, test_y = train_test_split(X_data, Y_data)
常用激活函数:
- relu
- sigmoid
- tanh
- leak relu
目标值: Y_data = data.left.values.reshape(-1, 1) # left 离职
- Y = torch.from_numpy(Y_data).type(torch.FloatTensor)

一逻辑回归

1.1 什么是逻辑回归

线性回归预测的是一个连续值, 逻辑回归给出的”是”和“否”的回答, 逻辑回归通过sigmoid函数把线性回归的结果规范到0到1之间.

sigmoid函数是一个概率分布函数，给定某个输入，它将输出为一个概率值.

1.2 逻辑回归损失函数

平方差所惩罚的是与损失为同一数量级的情形, 对于分类问题，我们最好的使用交叉熵损失函数会更有效, 交叉熵会输出一个更大的“损失”.

交叉熵刻画的是实际输出（概率）与期望输出（概率）的距离，也就是交叉熵的值越小，两个概率分布就越接近。假设概率分布p为期望输出，概率分布q为实际输出，H(p,q)为交叉熵, 则在pytorch 里，我们使用 nn.BCELoss() 来计算二元交叉熵.

下面我们用一个实际的例子来实现pytorch中的逻辑回归

二逻辑回归分类实例 (信用卡反欺诈数据 )

2.1 导包

import torch
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from torch import nn

2.2 数据导入

data = pd.read_csv('./dataset/credit-a.csv', header = None)
data   # 前15列是特征 , 最后一列是标记

# 前15列是特征 , 最后一列是标记
X = data.iloc[:, :-1]
# series 不能作为标记
Y = data.iloc[:, -1]
print(X.shape, Y.shape)   # (653, 15) (653,)

取代Y值中的 -1, 调整为0 (方便后面求概率)

# 把标记改为0, 1, 方便后面求概率
Y.replace(-1, 0, inplace = True)  # 替换值

查看数据是否均衡

Y.value_counts()  # 数据是否均衡
'''
1    357
0    296
Name: 15, dtype: int64'''

数据转换为 tensor

X = torch.from_numpy(X.values).type(torch.FloatTensor)
Y = torch.from_numpy(Y.values.reshape(-1, 1)).type(torch.FloatTensor)
print(X.shape)     # torch.Size([653, 15])

2.3 定义模型

from torch import nn
# 回归和分类之间, 区别不大, 回归后面加上一层sigmoid, 就变成分类了.
model = nn.Sequential(nn.Linear(15, 1024),
                      nn.Linear(1024, 1),
                      nn.Sigmoid())

2.4 梯度下降

# BCE binary cross entroy 二分类的交叉熵损失
loss_fn = nn.BCELoss()
opt = torch.optim.SGD(model.parameters(), lr = 0.0001)

batch_size = 32
steps = 653 // 32

for epoch in range(1000):
    # 每次取32个数据
    for batch in range(steps):
        # 起始索引
        start = batch * batch_size
        # 结束索引
        end = start + batch_size
        # 取数据
        x = X[start: end]
        y = Y[start: end]
        y_pred = model(x)
        loss = loss_fn(y_pred, y)
        # 梯度清零
        opt.zero_grad()
        # 反向传播
        loss.backward()
        # 更新
        opt.step()

model.state_dict()

# 计算正确率  # 设定阈值
# 现在预测得到概率, 根据阈值, 把概率转换为类别, 然后计算准确率
((model(X).data.numpy() > 0.5) == Y.numpy()).mean()    # 0.5834609494640123

三面向对象的方式实现逻辑回归分类 (预测员工离职数据 )

3.1 导包

import torch
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

3.2 导入数据

data = pd.read_csv('./dataset/HR.csv')
data.head(10)

data.info()

data.part.unique()
'''array(['sales', 'accounting', 'hr', 'technical', 'support', 'management',
       'IT', 'product_mng', 'marketing', 'RandD'], dtype=object)'''

3.3 数据处理

对于离散的字符串, 有两种处理方式: 1. 转换为数字 2. 进行one-hot编码.
- 把 part 和 salary 中的每一项单独列出来, 如果有就转换为1, 没有就转换为 0.

# 对于离散的字符串, 有两种处理方式: 1. 转换为数字  2. 进行one-hot编码.
data = data.join(pd.get_dummies(data.part)).join(pd.get_dummies(data.salary))
data

把 part 和 salary 删掉

# 把part和salary删掉
data.drop(columns = ['part', 'salary'], inplace = True)

查看数据是否均衡

data.left.value_counts()
'''
0    11428
1     3571
Name: left, dtype: int64'''

查看Y值

# SMOTE
Y_data = data.left.values.reshape(-1, 1)
Y = torch.from_numpy(Y_data).type(torch.FloatTensor)
Y

[c for c in data.columns if c != 'left']

X_data = data[[c for c in data.columns if c != 'left']].values
X = torch.from_numpy(X_data).type(torch.FloatTensor)
X.shape      # torch.Size([14999, 20])

3.4 通过class 定义模型 (pytorch 最常见的创建模型的方式, 子类)

# pytorch 最常见的创建模型的方式, 子类
from torch import nn
# 需要自定义类
class HRModel(nn.Module):
    def __init__(self):
        # 先调用父类的方法
        super().__init__()
        # 定义网络中会用到的东西.
        self.lin_1 = nn.Linear(20, 64)
        self.lin_2 = nn.Linear(64, 64)
        self.lin_3 = nn.Linear(64, 1)
        self.activate = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, input):  # forward 前向传播
        # 定义前向传播
        x = self.lin_1(input)
        x = self.activate(x)
        x = self.lin_2(x)
        x = self.activate(x)
        x = self.lin_3(x)
        x = self.sigmoid(x)
        return x

lr = 0.0001
# 定义获取函数, 优化器
def get_model():
    model = HRModel()
    return model, torch.optim.Adam(model.parameters(), lr=lr)

# 定义损失, 定义优化过程
loss_fn = nn.BCELoss()
model, opt = get_model()

batch_size = 64
steps = len(data) // batch_size
epochs = 100
# 训练过程
for epoch in range(epochs):
    for i in range(steps):
        start = i * batch_size
        end = start + batch_size
        x = X[start: end]
        y = Y[start: end]
        y_pred = model(x)
        loss = loss_fn(y_pred, y)
        opt.zero_grad()
        loss.backward()
        opt.step()
print('epoch:', epoch, '-------', 'loss:', loss_fn(model(X), Y))
'''epoch: 99 ------- loss: tensor(0.5532, grad_fn=<BinaryCrossEntropyBackward0>)'''
model

查看参数

model.state_dict()

查看准确率

# 计算准确率   # 设定阈值
# 现在预测得到的是概率, 我们根据阈值, 把概率转换为类别, 就可以计算准确率
((model(X).data.numpy() > 0.5) == Y.numpy()).mean()   # 0.7619174611640777

四 dataset 数据重构

4.1 使用dataset进行重构

PyTorch有一个抽象的 Dataset 类。Dataset可以是任何具有 len 函数和 getitem__ 作为对其进行索引的方法的函数。本教程将通过示例将自定义HRDataset类创建为的Dataset的子类。

PyTorch的TensorDataset 是一个包装张量的Dataset。通过定义索引的长度和方式，这也为我们提供了沿张量的第一维进行迭代，索引和切片的方法。这将使我们在训练的同一行中更容易访问自变量和因变量。

from torch.utils.data import TensorDataset

HRdataset = TensorDataset(X, Y)
model, opt = get_model()
epochs = 100
batch = 64
no_of_batches = len(data)//batch
for epoch in range(epochs):
    for i in range(no_of_batches):
        x, y = HRdataset[i * batch: i * batch + batch]
        y_pred = model(x)
        loss = loss_fn(y_pred, y)
        opt.zero_grad()
        loss.backward()
        opt.step()
print('epoch:', epoch, '   ', 'loss:', loss_fn(model(X), Y))
'''epoch: 99     loss: tensor(0.5202, grad_fn=<BinaryCrossEntropyBackward0>)'''

4.2 使用DataLoader进行重构

Pytorch DataLoader 负责管理批次。

DataLoader从Dataset创建。

DataLoader使遍历批次变得更容易。DataLoader会自动为我们提供每个小批量。

无需使用 HRdataset[i * batch: i * batch + batch]

# dataloader可以自动分批取数据  # dataloader可以有dataset创建出来
# 有了dataloader就不需要按切片取数据
from torch.utils.data import DataLoader
HR_ds = TensorDataset(X, Y)
HR_dl = DataLoader(HR_ds, batch_size=batch)
# 现在，我们的循环更加简洁了，因为（xb，yb）是从数据加载器自动加载的：
for x,y in HR_dl:
    pred = model(x)
    
model, opt = get_model()
for epoch in range(epochs):
    for x, y in HR_dl:
        y_pred = model(x)
        loss = loss_fn(y_pred, y)
        opt.zero_grad()
        loss.backward()
        opt.step()
print('epoch:', epoch, '   ', 'loss:', loss_fn(model(X), Y))
'''epoch: 99     loss: tensor(0.5310, grad_fn=<BinaryCrossEntropyBackward0>)'''

五添加验证

5.1 添加验证集

前面我们只是试图建立一个合理的训练循环以用于我们的训练数据。实际上，您始终还应该具有一个验证集，以识别您是否过度拟合。

训练数据的乱序（shuffle）对于防止批次与过度拟合之间的相关性很重要。另一方面，无论我们是否乱序验证集，验证损失都是相同的。由于shufle需要额外的开销，因此shuffle验证数据没有任何意义。我们将为验证集使用批大小，该批大小是训练集的两倍。这是因为验证集不需要反向传播，因此占用的内存更少（不需要存储梯度）。我们利用这一优势来使用更大的批量，并更快地计算损失。

# 需要分割成训练数据和测试数据
# 刚才是把所有数据作为训练数据
from sklearn.model_selection import train_test_split

train_x, test_x, train_y, test_y = train_test_split(X_data, Y_data)
train_x = torch.from_numpy(train_x).type(torch.FloatTensor)
test_x = torch.from_numpy(test_x).type(torch.FloatTensor)
train_y = torch.from_numpy(train_y).type(torch.FloatTensor)
test_y = torch.from_numpy(test_y).type(torch.FloatTensor)

train_ds = TensorDataset(train_x, train_y)
train_dl = DataLoader(train_ds, batch_size=batch, shuffle=True)

valid_ds = TensorDataset(test_x, test_y)
valid_dl = DataLoader(valid_ds, batch_size=batch * 2)

5.2 定义计算正确率函数

def accuracy(out, yb):
    preds = (out>0.5).type(torch.IntTensor)
    return (preds == yb).float().mean()

5.3 创建fit和get_data

按批次计算损失

# 按批次计算损失
def loss_batch(model, loss_func, xb, yb, opt=None):
    loss = loss_func(model(xb), yb)
    if opt is not None:
        loss.backward()
        opt.step()
        opt.zero_grad()
    return loss.item(), len(xb)

封装训练过程

# 封装训练过程
def fit(epochs, model, loss_func, opt, train_dl, valid_dl):
    for epoch in range(epochs):
        model.train()
        for xb, yb in train_dl:
            loss_batch(model, loss_func, xb, yb, opt)

        model.eval()
        with torch.no_grad():    # * 进行解包
            losses, nums = zip(
                *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]
            )
        val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)

        print(epoch, val_loss)

封装定义数据

def get_data(train_ds, valid_ds, bs):
    return (DataLoader(train_ds, batch_size=bs, shuffle=True),
             DataLoader(valid_ds, batch_size=bs * 2))

整个训练校验过程可以直接使用三行代码

# 整个训练校验过程可以直接使用三行代码   # 获取数据
train_dl, valid_dl = get_data(train_ds, valid_ds, batch)
model, opt = get_model()
fit(epochs, model, loss_fn, opt, train_dl, valid_dl)

六多层感知机

6.1简介

上一节我们学习的逻辑回归模型是单个神经元：计算输入特征的加权和然后使用一个激活函数（或传递函数）计算输出.

单个神经元（二分类）:

多个神经元（多分类）:

单层神经元的缺陷: 无法拟合“异或”运算异或问题看似简单，使用单层的神经元确实没有办法解决.神经元要求数据必须是线性可分的, 异或问题无法找到一条直线分割两个类, 这个问题是的神经网络的发展停滞了很多年.

多层感知器: 生物的神经元一层一层连接起来，当神经信号达到某一个条件，这个神经元就会激活, 然后继续传递信息下去为了继续使用神经网络解决这种不具备线性可分性的问题，采取在神经网络的输入端和输出端之间插入更多的神经元.

6.2 激活函数

relu:

sigmoid:

tanh:

leak relu:

6.3 我们依然使用hr数据集创建多层感知机来做分类

import torch
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from torch import nn

data = pd.read_csv('dataset/HR.csv')
data = data.join(pd.get_dummies(data.salary))
del data['salary']
data = data.join(pd.get_dummies(data.part))
del data['part']

Y_data = data.left.values.reshape(-1, 1)
Y = torch.from_numpy(Y_data).type(torch.FloatTensor)
X_data = data[[c for c in data.columns if c !='left']].values
X = torch.from_numpy(X_data).type(torch.FloatTensor)

# 自定义模型：
# nn.Module: 继承这个类
# __init__:  初始化所有的层
# forward:   定义模型的运算过程（前向传播的过程）
class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.liner_1 = nn.Linear(20, 64)
        self.liner_2 = nn.Linear(64, 64)
        self.liner_3 = nn.Linear(64, 1)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
    def forward(self, input):
        x = self.liner_1(input)
        x = self.relu(x)
        x = self.liner_2(x)
        x = self.relu(x)
        x = self.liner_3(x)
        x = self.sigmoid(x)
        return x

6.4 借助F对象改写模型, 让模型更简洁

import torch.nn.functional as F
class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.liner_1 = nn.Linear(20, 64)
        self.liner_2 = nn.Linear(64, 64)
        self.liner_3 = nn.Linear(64, 1)
    def forward(self, input):
        x = F.relu(self.liner_1(input))
        x = F.relu(self.liner_2(x))
        x = F.sigmoid(self.liner_3(x))
        return x

七线性回归实例 (收入和受教育年限的关系)

7.1 导包

import torch
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

7.2 数据导入

data = pd.read_csv('./dataset/Income1.csv')
data

查看受教育年限和收入的关系

plt.scatter(data.Education, data.Income)
plt.xlabel('Education')
plt.ylabel('Incomel')

转换数据为 tensor

# 取数据
X = torch.from_numpy(data.Education.values.reshape(-1, 1)).type(torch.FloatTensor)
Y = torch.from_numpy(data.Income.values.reshape(-1, 1)).type(torch.FloatTensor)

7.3 定义梯度下降过程

定义斜率w, 截距b

# 分解写法
w = torch.randn(1, requires_grad = True)    # tensor([-0.5106], requires_grad=True)
b = torch.zeros(1, requires_grad = True)    # tensor([0.], requires_grad=True)

梯度下降

learning_rate = 0.001
# 定义训练过程
for epoch in range(5000):
    for x, y in zip(X, Y):
        y_pred = torch.matmul(x, w) + b
        # 损失函数
        loss = (y - y_pred).pow(2).sum()  # x.pow() 求原始值的n次方
        # pytorch对一个变量多次求导， 求导结果会累加
        if w.grad is not None:  # w.grad  求导   grad: 梯度
            # 重置w 的导数
            w.grad.data.zero_()  # zero_ 加下划线直接更改原数据
        if b.grad is not None:
            b.grad.data.zero_()
            
        # 反向传播， 即求w, b的导数
        loss.backward()
        
        # 更新w, b
        with torch.no_grad():
            w.data -= w.grad.data * learning_rate
            b.data -= b.grad.data * learning_rate
            
print('w*', w)   # w* tensor([5.1266], requires_grad=True)
print('b*', b)   # b* tensor([-32.6957], requires_grad=True)

图像直观显示

plt.scatter(data.Education, data.Income)
plt.plot(X.numpy(), (torch.matmul(X, w) + b).data.numpy(), c = 'red')