• 刘二大人 PyTorch深度学习实践 笔记 P9 多分类问题

    刘二大人 PyTorch深度学习实践 笔记 P9 多分类问题

    P9 多分类问题

    1、softmax函数

    糖尿病数据集分类为0和1，MNIST数据集有10个分类怎么办？输出时输出10个y？

    在这里插入图片描述

    神经网络希望输出之间是带有竞争性的，即所有概率之和为1，且所有概率均大于0，softmax可以实现这两点。

    在这里插入图片描述

    图中绿色框中就是指包括softmax的计算过程：

    在这里插入图片描述

    2、作业：CrossEntropyLoss vs NULLoss

    在这里插入图片描述

    I NLLLoss损失函数

    在这里插入图片描述

    代码实现如下：

    import numpy as np
y = 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)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    输出：

    0.9729189131256584

    • 1

    II CrossEntropyLoss损失函数

    CrossEntropyLoss损失函数 = Softmax + NLLLoss损失函数
    神经网络的最后一层不需要做激活(经过Softmax层的计算)，直接输入到CrossEntropyLoss损失函数中就可以。

    在这里插入图片描述
    代码实现如下：

    import torch
y = torch.LongTensor([0]) # 使用了one-hot，标签类型是LongTensor
z = torch.Tensor([[0.2, 0.1, -0.1]])
criterion = torch.nn.CrossEntropyLoss()
loss = criterion(z, y)
print(loss)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    输出：

    tensor(0.9729)

    • 1

    III 举例

    import torch
criterion = torch.nn.CrossEntropyLoss()
# Y表示第几个标签分类
Y = torch.LongTensor([2, 0, 1]) # 注意此处是LongTensor

Y_pred1 = torch.Tensor([[0.1, 0.2, 0.9],
						[1.1, 0.1, 0.2],
						[0.2, 2.1, 0.1]])
Y_pred2 = torch.Tensor([[0.8, 0.2, 0.3],
						[0.2, 0.3, 0.5],
						[0.2, 0.2, 0.5]])

l1 = criterion(Y_pred1, Y)
l2 = criterion(Y_pred2, Y)
print("Batch Loss1 = ", l1.data, "\nBatch Loss2 = ", l2.data)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    输出：

    Batch Loss1 =  tensor(0.4966) 
Batch Loss2 =  tensor(1.2389)

    • 1
    • 2

    3、应用在MINIST数据集

    I 实现过程

    1. 准备数据集
    2. 设计模型
    3. 构造损失函数和优化器
    4. 训练+测试(前馈、反馈、更新)

    II 实现代码

    import torch
from torchvision import transforms # transforms针对图像进行一些处理
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F # relu激活函数
import torch.optim as optim # 优化器

# 1. 准备数据集
batch_size = 64
# 读图像的时候 将像素转化成图像张量
transform = transforms.Compose([
    transforms.ToTensor(),
# 均值 标准差 => 切换到0-1正态分布
    transforms.Normalize((0.1307, ), (0.3081, )) # 数值计算之后得到的结果
])
# 在视觉里面，灰度图就是一个矩阵，但实际上并不是一个矩阵，我们把它叫做单通道图像，彩色图像是RGB三通道图像，通道有宽度和高度，一般我们读进来的图像张量是WHC(宽高通道)
# 在PyTorch里面我们需要将WHC转化成CWH,把通道放在前面是为了在PyTorch里面进行更高效的图像处理，卷积运算
train_dataset = datasets.MNIST(root='dataset/mnist/',
                               train=True,
                               download=True,
                               transform=transform)
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
test_dataset = datasets.MNIST(root='dataset/mnist',
                              train=False,
                              download=True,
                              transform=transform)
test_loader = DataLoader(test_dataset,
                         shuffle=False,
                         batch_size=batch_size)

# 2. 设计模型
# 设计模型
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) # 变成二阶张量，-1表示自动算batchsize，列数为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)) 
		return self.l5(x) # 最后一层不做激活，不进行非线性变换

model = Net()

# 3. 构建损失函数和优化器
# 构建损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

# 4. 训练+测试
# 定义训练函数
def train(epoch):
	running_loss = 0.0
	for batch_idx, data in enumerate(train_loader, 0):
		inputs, target = data
		optimizer.zero_grad()
		# 前馈+反馈+更新
		outputs = model(inputs)
		loss = criterion(outputs, target)
		loss.backward()
		optimizer.step()

		running_loss += loss.item()
		# 每300次迭代输出一次
		if batch_idx % 300 == 299:
			print('[%d,%5d] loss:%.3f' % (
			epoch + 1, batch_idx + 1, running_loss / 300))
			running_loss = 0.0


# 定义测试函数
def test():
	correct = 0
	total = 0
	with torch.no_grad(): # 不会再去计算梯度
		for data in test_loader:
			images, labels = data
			outputs = model(images)
			# 沿着第一维度找最大值的下标
			_, predicted = torch.max(outputs.data, dim=1) # _ 是占位符，表示有值，但是用不着
			total += labels.size(0) # (N, 1)取第0个元素N
			correct += (predicted == labels).sum().item()
	print('Accuracy on test set:%d %%' % (100 * correct / total))


# 实例化训练和测试
if __name__ == '__main__':
	# 训练10轮
	for epoch in range(10):
		train(epoch)
		test()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100

    输出：

    [1,  300] loss:2.256
[1,  600] loss:1.102
[1,  900] loss:0.432
Accuracy on test set:89 %
[2,  300] loss:0.331
[2,  600] loss:0.279
[2,  900] loss:0.238
Accuracy on test set:93 %
[3,  300] loss:0.198
[3,  600] loss:0.180
[3,  900] loss:0.158
Accuracy on test set:95 %
[4,  300] loss:0.137
[4,  600] loss:0.124
[4,  900] loss:0.119
Accuracy on test set:96 %
[5,  300] loss:0.102
[5,  600] loss:0.101
[5,  900] loss:0.093
Accuracy on test set:96 %
[6,  300] loss:0.083
[6,  600] loss:0.072
[6,  900] loss:0.078
Accuracy on test set:97 %
[7,  300] loss:0.063
[7,  600] loss:0.060
[7,  900] loss:0.064
Accuracy on test set:97 %
[8,  300] loss:0.047
[8,  600] loss:0.052
[8,  900] loss:0.054
Accuracy on test set:97 %
[9,  300] loss:0.040
[9,  600] loss:0.040
[9,  900] loss:0.042
Accuracy on test set:97 %
[10,  300] loss:0.030
[10,  600] loss:0.031
[10,  900] loss:0.035
Accuracy on test set:97 %

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    损失不断降低，准确率高达97%，但是到最后准确率就上不去了，是因为对图像用全连接神经网络忽略了对局部信息的利用，把所有的元素都全连接了，处理时权重不够高，处理图像时更关心高级别的特征。
    如果可以先做特征提取，再做分类训练，效果可能会好些。
    人工特征(wavelet )提取方法：FFT傅里叶变换、小波变化
    自动特征提取：CNN

    5、作业

    在这里插入图片描述

    代码：

    # 导入依赖库
import pandas as pd
import numpy as np
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import torch.optim as optim

# 数据预处理
# 定义函数将类别标签转为id表示，方便后面计算交叉熵
def labels2id(labels):
    target_id = [] # 给所有target建立一个词典
    target_labels = ['Class_1','Class_2','Class_3','Class_4','Class_5','Class_6','Class_7','Class_8','Class_9'] #自定义9个标签
    for label in labels: # 遍历labels中的所有label
        target_id.append(target_labels.index(label)) #添加label对应的索引项到target_labels中
    return target_id

class OttogroupDataset(Dataset):  # 准备数据集
	def __init__(self, filepath):
		data = pd.read_csv(filepath)
		labels = data['target']
		self.len = data.shape[0]  # 多少行多少列

		# 处理特征和标签
		self.x_data = torch.tensor(np.array(data)[:, 1:-1].astype(float))  # 1:-1 左闭右开
		self.y_data = labels2id(labels)

	def __getitem__(self, index):  # 魔法方法 支持dataset[index]
		return self.x_data[index], self.y_data[index]

	def __len__(self):  # 魔法函数 len() 返回长度
		return self.len

#载入训练集
train_dataset = OttogroupDataset('dataset/otto-group/train.csv')

#建立数据加载器
train_loader= DataLoader(dataset=train_dataset, batch_size=64, shuffle=True, num_workers=0)


class Net(torch.nn.Module):
	def __init__(self):
		super(Net, self).__init__()
		self.l1 = torch.nn.Linear(93, 64)  # 93个feature
		self.l2 = torch.nn.Linear(64, 32)
		self.l3 = torch.nn.Linear(32, 16)
		self.l4 = torch.nn.Linear(16, 9)
		self.relu = torch.nn.ReLU()  # 激活函数

	def forward(self, x):  # 正向传播
		x = self.relu(self.l1(x))
		x = self.relu(self.l2(x))
		x = self.relu(self.l3(x))
		return self.l4(x)  # 最后一层不做激活，不进行非线性变换

	def predict(self, x):  # 预测函数
		with torch.no_grad():  # 梯度清零 不累计梯度
			x = self.relu(self.l1(x))
			x = self.relu(self.l2(x))
			x = self.relu(self.l3(x))
			x = self.relu(self.l4(x))
			# 这里先取出最大概率的索引，即是所预测的类别。
			_, predicted = torch.max(x, dim=1)
			# 将预测的类别转为one-hot表示，方便保存为预测文件。
			y = pd.get_dummies(predicted)
			return y


model = Net()

criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.5) #冲量，冲过鞍点和局部最优


def train(epoch):  # 单次循环 epoch决定循环多少次
	running_loss = 0.0
	for batch_idx, data in enumerate(train_loader):
		inputs, target = data  # 输入数据
		inputs = inputs.float()
		optimizer.zero_grad()  # 优化器归零

		# 前馈+反馈+更新
		outputs = model(inputs)
		loss = criterion(outputs, target)
		loss.backward()
		optimizer.step()

		running_loss += loss.item()  # 累计的损失
		if batch_idx % 300 == 299:  # 每300轮输出一次
			print('[%d,%5d] loss:%.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
			running_loss = 0.0

if __name__ =='__main__':
    for epoch in range(50):
        train(epoch)

# 定义预测保存函数，用于保存预测结果。
def predict_save():
	test_data = pd.read_csv('dataset/otto-group/test.csv')
	test_inputs = torch.tensor(np.array(test_data)[:, 1:].astype(float))  # test_data是series，要转为array；[1:]指的是第一列开始到最后，左闭右开，去掉‘id’列
	out = model.predict(test_inputs.float())  # 调用预测函数，并将inputs 改为float格式

	# 自定义新的标签
	labels = ['Class_1', 'Class_2', 'Class_3', 'Class_4', 'Class_5', 'Class_6',
			  'Class_7', 'Class_8', 'Class_9']

	# 添加列标签
	out.columns = labels

	# 插入id行
	out.insert(0, 'id', test_data['id'])
	output = pd.DataFrame(out)
	output.to_csv('my_predict.csv', index=False)
	return output
predict_save()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
  • 相关阅读:
    【Hot100】LeetCode—118. 杨辉三角
    xctf攻防世界 Web高手进阶区 web2
    C专家编程 第5章 对链接的思考 5.4 警惕Interpositioning
    selenium 文件上传方法
    线上展厅搭建流程案例
    解决微信小程序不支持TextEncoder/TextDecoder对象
    “机器学习”名字的由来
    【linux外设挂载】linux系统找到U盘解决方案
    洛谷 P1106 删数问题
    数学模型水动力模拟、水质建模、复杂河网构建技术在环境影响评价、排污口论证及防洪评价中的实践技术应用
  • 原文地址：https://blog.csdn.net/qq_44948213/article/details/126480753