一、逻辑回归基本模型

基本模型：$\hat{y}=\sigma (x\ast \omega +b)$，其中 $\sigma ()$ 表示 sigmod 函数 $\sigma (x)=\frac{1}{1+e^{-x}}$。

二分类问题损失函数：二分类交叉熵（Binary Cross Entropy，BCE）$$loss=-(ylog\hat{y}+(1-y)log(1-\hat{y}))$$

Mini-Batch 版本：$$loss=-\frac{1}{N}\sum _{n=1}^N{y}_{n}log\widehat{y_n}+(1-y_n)log(1-\widehat{y_n})$$

代码实现：

import torch
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as pltx_data = torch.Tensor([[1.0], [2.0], [3.0]])
y_data = torch.Tensor([[0], [0], [1]])class LogisticRegressionModel(torch.nn.Module):def __init__(self):super(LogisticRegressionModel, self).__init__()self.linear = torch.nn.Linear(1, 1)def forward(self, x):y_pred = F.sigmoid(self.linear(x))return y_predmodel = LogisticRegressionModel()
criterion = torch.nn.BCELoss(reduction='sum')
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)for epoch in range(1000):y_pred = model(x_data)loss = criterion(y_pred, y_data)print(epoch, loss.item())optimizer.zero_grad()loss.backward()optimizer.step()x = np.linspace(0, 10, 200)
x_t = torch.Tensor(x).view((200, 1))  # view作用相当于reshape
y_t = model(x_t)
y = y_t.data.numpy()  # 获取矩阵
plt.plot(x, y)
plt.plot([0, 10], [0.5, 0.5], c='r')
plt.xlabel('Hours')
plt.ylabel('Probability of Pass')
plt.grid()
plt.show()

二、处理多维特征输入

数据：

这是一个由 10 个 sample（每行称为一个 sample），每个 sample 有 8 个 feature 构成的数据集。

多维度数据输入的时候，模型会发生变化，即变成多维度逻辑回归模型：

$$\begin{array}{rl}{\hat{y}}^{(i)}=\sigma (x^{(i)}\ast \omega +b)\Rightarrow {\hat{y}}^{(i)}& =\sigma (\sum _{n=1}^8{x}_n^{(i)}\ast {\omega }_n+b)\\ & =\sigma (\left[\begin{array}{ccc}{x}_1^{(i)}& \cdots & x_8^{(i)}\end{array}\right]\left[\begin{array}{c}{\omega }_1\\ ⋮\\ {\omega }_8\end{array}\right]+b)\\ & =\sigma (z^{(i)})\end{array}$$

对于有 N 个 samples，即 Mini-Batch（N samples），其矩阵运算如下：

$$\left[\begin{array}{c}{\hat{y}}^{(1)}\\ ⋮\\ {\hat{y}}^{(N)}\end{array}\right]=\left[\begin{array}{c}\sigma (z^{(1)})\\ ⋮\\ \sigma (z^{(N)})\end{array}\right]=\sigma (\left[\begin{array}{c}{z}^{(1)}\\ ⋮\\ z^{(N)}\end{array}\right])$$

其中：
$$\begin{array}{rl}{z}^{(1)}& =\left[\begin{array}{ccc}{x}_1^{(1)}& \cdots & x_8^{(1)}\end{array}\right]\left[\begin{array}{c}{\omega }_1\\ ⋮\\ {\omega }_8\end{array}\right]+b\\ & ⋮\\ z^{(N)}& =\left[\begin{array}{ccc}{x}_1^{(N)}& \cdots & x_8^{(N)}\end{array}\right]\left[\begin{array}{c}{\omega }_1\\ ⋮\\ {\omega }_8\end{array}\right]+b\end{array}$$

可转换为矩阵运算（注意矩阵维度的变换）：

$${\left[\begin{array}{c}{z}^{(1)}\\ ⋮\\ z^{(N)}\end{array}\right]}_{N\times 1}={\left[\begin{array}{ccc}{x}_1^{(1)}& \cdots & x_8^{(1)}\\ ⋮& \ddots & ⋮\\ x_1(N)& \cdots & x_8^{(N)}\end{array}\right]}_{N\times 8}{\left[\begin{array}{c}{\omega }_1\\ ⋮\\ {\omega }_8\end{array}\right]}_{8\times 1}+{\left[\begin{array}{c}b\\ ⋮\\ b\end{array}\right]}_{N\times 1}$$

矩阵变换，实质上是一种空间变换的函数，上述变换过程就将输入 feature=8 的空间映射到输出 feature=1 的空间。同样，也可以实现从 feature=8 映射到输出 feature=x 的空间，其中 x 可以自行设置。

上面过程都是线性变换的，需要在每一次映射之后引入一个非线性函数（比如 sigmod 函数），使得该神经网络可以去拟合一个非线性的变换。

这里的目标是将 feature=8 映射到 feature=1，但是由上面矩阵变换的性质，这里可以分步将 feature 从 8 降到 1，这样这个分类的神经网络模型就可以由很多层构成，这样我们模型的拟合能力就越强，如下图：

上图中 feature 降维的过程是 8 → 6 → 4 → 1。

代码实现：

import numpy as np
import torchxy = np.loadtxt('./Data/diabetes.csv.gz', delimiter=',', dtype=np.float32)  # 分隔符为','，读取数据格式一般为浮点数32位即可
x_data = torch.from_numpy(xy[:, :-1])  # 最后一列不取
y_data = torch.from_numpy(xy[:, [-1]])  # [-1]表示只取最后一列，并且形成矩阵class Model(torch.nn.Module):def __init__(self):super(Model, self).__init__()self.linear1 = torch.nn.Linear(8, 6)  # 第一层feature从8到6self.linear2 = torch.nn.Linear(6, 4)  # 第二层feature从6到4self.linear3 = torch.nn.Linear(4, 1)  # 第二层feature从4到1self.sigmoid = torch.nn.Sigmoid()def forward(self, x):x = self.sigmoid(self.linear1(x))x = self.sigmoid(self.linear2(x))x = self.sigmoid(self.linear3(x))return xmodel = Model()criterion = torch.nn.BCELoss(reduction='sum')
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)for epoch in range(1000):y_pred = model(x_data)loss = criterion(y_pred, y_data)print(epoch, loss.item())optimizer.zero_grad()loss.backward()optimizer.step()

三、加载数据集

Pytorch 中有两个工具：

• Dataset：构建数据集，支持索引，在 Pytorch 中，它是一个抽象类，只能被继承，不能被实例化。
• DataLoader：从 Dataset 中拿出一个 Mini-Batch 这样一组数据用于训练，在 Pytorch 中，它是一个类，可以被实例化。

在上一节的代码中，每一次梯度下降将所有数据都进行了运算，会比较浪费时间。如果每次梯度下降仅使用一个点的梯度，这样带来的好处是可以克服求导时的鞍点，这样训练出的模型性能可能会更好，但是训练时优化的时间会非常长。所以折中便是用部分数据进行梯度下降，即一个 Mini-Batch。

几个概念需要了解：

• Epoch：One forward pass and one backword pass of all the training examples，即所有样本都进行过一次前馈、反馈传播训练就成为一次 Epoch。
• Batch-Size：The number of training examples in one forward backward pass，即一次训练所使用的样本数量，或者说是一次 Epoch 的样本数量。
• Iterations：Number of passes， each pass using batch-size number of examples，举一个例子，假设由 10000 个样本，Batch-Size = 1000， 那么 Iterations = 10000 / Batch-Size =10。

DataLoader 的工作流程：

import numpy as np
import torch
from torch.utils.data import Dataset, DataLoaderclass DiabetesDataset(Dataset):def __init__(self, filePath):xy = np.loadtxt(filePath, delimiter=',', dtype=np.float32)self.len = xy.shape[0]  # 有多少个sampleself.x_data = torch.from_numpy(xy[:, :-1])  # 最后一列不要self.y_data = torch.from_numpy(xy[:, [-1]])  # 仅取最后一列且形成矩阵def __getitem__(self, item):  # 根据索引返回数据return self.x_data[item], self.y_data[item]def __len__(self):  # 返回数据中sample的个数return self.lendataset = DiabetesDataset('./Data/diabetes.csv.gz')
# print(len(dataset))
train_loader = DataLoader(dataset=dataset, batch_size=32, shuffle=True)  # 读取数据进程数目设置为2，但是这里设置多线程会报错class Model(torch.nn.Module):def __init__(self):super(Model, self).__init__()self.linear1 = torch.nn.Linear(8, 6)self.linear2 = torch.nn.Linear(6, 4)self.linear3 = torch.nn.Linear(4, 1)self.sigmoid = torch.nn.Sigmoid()def forward(self, x):x = self.sigmoid(self.linear1(x))x = self.sigmoid(self.linear2(x))x = self.sigmoid(self.linear3(x))return xmodel = Model()criterion = torch.nn.BCELoss(reduction='sum')
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)for epoch in range(100):  # 对所有数据100次for i, (x, y) in enumerate(train_loader, 0):# 这里x、y自动转换为了tensor# 每一次取出一个batch-size=32，共759个samples，所以iterations=759/32=23y_pred = model(x)loss = criterion(y_pred, y)print(epoch, i, loss.item())optimizer.zero_grad()loss.backward()optimizer.step()

四、多分类问题

针对 MNIST 数据集，其中存在 10 中手写数字标签（$0\sim 10$），如下图所示：

按照二分类问题的思路，在每一层结束的时候使用激活函数 sigmoid，那么最终输出的结果就会十个值，如下图所示：

并且$$\sum _{n=1}^{10}{\hat{y}}_n\ne 1$$这样并不能很好地预测出结果，为了使输出结果能够给相互抑制且呈现出一个分布状态，使用 Softmax 作为最后一层的激活函数，如下图所示：

在 Softmax 层中的计算：假设最后一层的输出位 $Z^l\in R^K$，则有 $$P(y=i)=\frac{e^{Z_i}}{{\sum }_{j=0}^{K-1}{e}^{Z_j}}$$其中 i ∈ { 0 , ⋯ , K − 1 } i \in \{0, \cdots, K-1 \} i∈{0,⋯,K−1}。

将上式应用到 MNIST 数据集中，就会有 $P(y=i)>0$，并且 ${\sum }_{i=1}^{10}P(y=i)=1$。

对于多分类问题的损失函数：交叉熵损失函数

• 如果使用 Numpy 来实现：

代码如下：

import numpy as npy = np.array([1, 0, 0])
z = np.array([0.2, 0.1, -0.1])
y_pred = np.exp(z) / np.exp(z).sum()
loss = (-y * np.log(y_pred)).sum()
print(loss)

• 如果使用 Pytorch 来实现：

代码实现如下：

import torchy = torch.LongTensor([0])  # y必须是一个 LongTensor
z = torch.Tensor([[0.2, 0.1, -0.1]])  # 最后一层不能使用激活函数
criterion = torch.nn.CrossEntropyLoss()
loss = criterion(z, y)
print(loss.item())

针对 MNIST 数据集的多分类识别：

最终精度只能达到 97%

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optimbatch_size = 64
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])  # 归一化并将图像从单通道转换为多通道，即28x28转换为1x28x28train_dataset = datasets.MNIST(root='./Data/mnist/', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)test_dataset = datasets.MNIST(root='./Data/mnist', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)class Net(torch.nn.Module):def __init__(self):super(Net, self).__init__()self.l1 = torch.nn.Linear(784, 512)self.l2 = torch.nn.Linear(512, 256)self.l3 = torch.nn.Linear(256, 128)self.l4 = torch.nn.Linear(128, 64)self.l5 = torch.nn.Linear(64, 10)def forward(self, x):x = x.view(-1, 784)x = F.relu(self.l1(x))x = F.relu(self.l2(x))x = F.relu(self.l3(x))x = F.relu(self.l4(x))x = self.l5(x)  # 最后一层不激活return xmodel = Net()criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # 添加了动量def train(epoch):  # 将每一轮训练封装成一个函数running_loss = 0.0for batch_idx, data in enumerate(train_loader, 0):inputs, target = dataoptimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, target)loss.backward()optimizer.step()running_loss += loss.item()if batch_idx % 300 == 299:print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))running_loss = 0.0def test():correct = 0  # 预测正确的数目total = 0  # 总共的数目with torch.no_grad():  # with范围内的代码不计算梯度for data in test_loader:images, labels = dataoutputs = model(images)_, predicted = torch.max(outputs.data, dim=1)  # 返回(最大值, 最大值下标)total += labels.size(0)  # label是一个矩阵correct += (predicted == labels).sum().item()print('Accuracy on test set: %d %%' % (100 * correct / total))if __name__ == '__main__':for epoch in range(10):train(epoch)test()