Pytorch-多分类问题

在Mnist数据集中，我们要得到的输出是0-9，共有十类，这种情况下我们希望输出0-9的概率都大于0，且和为1。

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

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 # 优化器

#一个没有激活函数的神经网络将只不过是一个线性回归模型（Linear regression Model）罢了，
# 它功率有限，并且大多数情况下执行得并不好。我们希望我们的神经网络不仅仅可以学习和计算线性函数，
#而且还要比这复杂得多。同样是因为没有激活函数，我们的神经网络将无法学习和模拟其他复杂类型的数据，
# 例如图像、视频、音频、语音等。

batch_size = 64
transform = transforms.Compose([transforms.ToTensor(),
                            transforms.Normalize((0.1307, ), (0.3081, ))])
#将原始像素数据归一到（0，1）中 并基于均值0.1307和标准差0.3081来对数据进行标准化处理

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)

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()

criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

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()

作业如下：

# 导入依赖库
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('data/train.csv/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('data/train.csv/train.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()