糖尿病数据集来源：torchvision中的datasets带的MNIST数据集
1.Mnist数据集分为两部分，分别含有60000张训练图片和10000张测试图片
2.每一张图片包含2828个像素。Mnist数据集把代表一张图片的二维数据转开成一个向量，长度为2828=784。因此在Mnist的训练数据集中mnist.train.images是一个形状为[60000, 784]的张量
3.第一个维度数字用来索引图片，第二个维度数字用来索引每张图片中的像素点，图片里的某个像素的强度值介于0-1之间
4.模型输出是一个长度为10的向量，其中每个值代表了该图片属于0-9的概率，其中概率最大的值可以作为本次输出的分类结果
这是一个典型的多分类问题，可以用Softmax函数来解决
1. 数据集构建
每个像素点即每条数据中的值范围为0-255，有的数字过大不利于训练且难以收敛，故将其归一化到（0-1）之间
# 数据集处理
# transforms.ToTensor()---shape从(H,W,C)->(C,H,W), 每个像素点从(0-255)映射到(0-1):直接除以255
# transforms.Normalize()---先将输入归一化到(0,1),像素点通过"(x-mean)/std",将每个元素分布到(-1,1)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(std=(0.1307,), mean=(0.3081,))
])
# 1.准备数据集
train_dataset = datasets.MNIST(root="../DataSet/mnist",
train=True,
transform=transform,
download=True)
test_dataset = datasets.MNIST(root="../DataSet/mnist",
train=False,
transform=transform,
download=True)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)
2. 用Pytorch提供的DataLoader来加载数据集
# dataset:数据集 batch_size:mini-batch的大小 shuffle:是否打乱数据集顺序
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)
3.采用全连接的神经网络来构建模型，最后接Softmax来处理output
# 构建网络模型
class Module(torch.nn.Module):
def __init__(self):
super(Module, self).__init__()
# 因为把图片展开成一个向量作为全连接的输入，所以这里输入的特征长度是28*28=784
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)
# softmax 函数的作用包含在 CrossEntropyLoss 中
return x
4. 构建损失函数和优化器
损失函数采用CrossEntropyLoss
优化器采用 SGD 随机梯度优化算法
# 构建损失函数和优化器
# softmax 函数的作用包含在 CrossEntropyLoss 中,交叉熵算法
criterion = torch.nn.CrossEntropyLoss()
opt = optim.SGD(params=model.parameters(), lr=0.01, momentum=0.5)
5.完整代码
# -*- codeing = utf-8 -*-
# @Software : PyCharm
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 optim
batch_size = 64
# transforms.ToTensor()---shape从(H,W,C)->(C,H,W), 每个像素点从(0-255)映射到(0-1):直接除以255
# transforms.Normalize()---先将输入归一化到(0,1),像素点通过"(x-mean)/std",将每个元素分布到(-1,1)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(std=(0.1307,), mean=(0.3081,))
])
# 1.准备数据集
train_dataset = datasets.MNIST(root="../DataSet/mnist",
train=True,
transform=transform,
download=False)
test_dataset = datasets.MNIST(root="../DataSet/mnist",
train=False,
transform=transform,
download=False)
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)
# 2.构建网络模型---模型时针对单个样本的处理情况
class Module(torch.nn.Module):
def __init__(self):
super(Module, self).__init__()
# 因为把图片展开成一个向量作为全连接的输入，所以这里输入的特征长度是28*28=784
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)
# softmax 函数的作用包含在 CrossEntropyLoss 中
return x
model = Module()
# 3.构造损失器和优化器
criterion = torch.nn.CrossEntropyLoss() # softmax 函数的作用包含在 CrossEntropyLoss 中,交叉熵算法
opt = optim.SGD(params=model.parameters(), lr=0.01, momentum=0.5)
# 4.训练数据集
def train(epoch):
runing_loss = 0
for batch_idx, (inputs, target) in enumerate(train_loader, 0):
opt.zero_grad()
y_pred_data = model(inputs)
loss = criterion(y_pred_data, target)
loss.backward()
opt.step()
runing_loss += loss.item()
if batch_idx % 300 == 299:
print("[%5d, %5d] loss: %3.f" % (epoch + 1, batch_idx + 1, runing_loss / 300))
runing_loss == 0.0
# 5.测试数据集
def verify():
correct = 0
total = 0
with torch.no_grad(): # 该语句下的所有tensor在进行反向传播时,不会被计算梯度
for (images, labels) in test_loader:
# 数据进入模型进行计算
outputs = model(images)
# 沿着维度为1的方向(行方向) 寻找每行最大元素的值与其下标
_, predicted = torch.max(outputs.data, dim=1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print("Accuracy on test set: %d%%" % (100 * correct / total))
if __name__ == '__main__':
for epoch in range(10):
train(epoch)
verify()
# 使用全连接的神经网络准确率在 97% 左右
6.结果展示
result.png
