分类网络怎么设计？
将分类网络设置成多个输出，但是这样会产生一个问题，如果输出是概率的情况下，如果出现多个神经元输出都很高？这样就不是很合理了，希望y输出能够满足分布性质的要求，即和等于1，>0,与二分类不同，二分类只需要一个参数就行.P（正确） = 0.8那么P（错误） = 0.2.
所以这样的，sigmoid得不到想要的结果，变换一下网络结构
保证神经网络输出变成正值并且和为一
心里一万句这个图也太形象了吧！一图胜千言。
损失函数的问题，之前的二分类使用的是这个损失函数，
（这个函数可以参考哔哩哔哩up王木头学科学的视频，上面链接是我看王木头学科学做的笔记，强推）
刘老师画的图总是这么一目了然，经过softmax之后输出是y_head，损失函数是-YlogY_head，使用的是ont-hot编码方式，也就是只有一个是1，其他都是0。（感觉老师做的太好了，看PPT很清晰）
代码对照上面图看
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)
仔细看看其实是很好理解的代码， 。
这里有另一种损失函数，
注意这个框框，这个框框表示这个损失函数是处理到log之后再进行的，这种成为NLLLLoss，编写代码的时候要注意，而之前说的损失函数是从softmax就开始的（softmax的输入就开始了）就像这样。
import torch
y = torch.LongTensor([0])
z = torch.Tensor([[0.2, 0.1, -0.1]])
criterion = torch.nn.CrossEntropyLoss()
loss = criterion(z, y)
print(loss)
其含义是，y因该分成第0位，输入的z是图中的0.2,0.1,-0.1。在Pytorch里面提供了一个CrossEntropyLoss，这个函数从softmax就开始计算了（用的比较多，也可以自己softmax log再调用别的，知道流程了随便组合不怕了），最后一层是线性的不用激活，激活的操作已经包括在CrossEntropyLoss里面了，就上面那个框框，
额，然后再来看代码，心说，就这？
import torch
criterion = torch.nn.CrossEntropyLoss()
Y = torch.LongTensor([2, 0, 1])
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)
老师留了作业：
看NLL损失和交叉熵损失
Exercie 9-1: CrossEntropyLoss vs NLLLoss
• What are the differences?
• Reading the document:
• https://pytorch.org/docs/stable/nn.html#crossentropyloss
• https://pytorch.org/docs/stable/nn.html#nllloss
• Try to know why:
• CrossEntropyLoss <==> LogSoftmax + NLLLoss
MINIST是一个28*28的矩阵，
import torch
from torchvision import transforms
#Transforms是torchvision的一个工具包，主要是对图像原始数据处理
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
#激活函数
import torch.optim as optim
#优化器
batch_size = 64
#Pytorch里面都这个图象的时候，用的是Python的Image Libary（PIL）现在用的都是另外一个
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((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)
这一步的操作将图片28*28的转成1个Channel*28*28的，并且将像素值映射到[0,1]区间之内，这个过程可以用Transformers的ToTensor（）来实现。Compose函数可以把中括号里面的一系列对象构成一个pipeline一样的东西处理，拿到一个原始图像之后先toTensor，转成一个Pytorch的张量，Normolize((0.1037,）,(0.1081))这两个参数是均值和标准差，那么这两个数字是啥啊，自己弄的吗？
这个是对MNIST数据集算出来的。
其实就是把人家弄成那种N~(0,1)的，以后碰到类似的问题操作就是先toTensor，然后Normal，对神经网络进行训练。接下来看看模型。
看输入的维度，4阶张量，每个里面N个样本，每个样本1维28*28.
神经网络里面需要输入的是个矩阵。
这里不是有N个嘛，把N个拼起来骨肉相连，每一个是1维喽，28 * 28 = 728个喽。
使用x = x.view(-1, 784)
-1是说x本来是个奇怪的维度张量，变成矩阵嘛二位，填个-1就是自己No算，叫程序给算出来-1是啥玩意儿。
听老师讲课起来，就感觉看代码好爽，从0到1的突破。让人不禁想问一句，真的有这么丝滑嘛。。。
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))
return self.l5(x)
model = Net()
def train(epoch):
running_loss = 0.0
for batch_idx, data in enumerate(train_loader, 0):
inputs, target = data
optimizer.zero_grad()
# forward + backward + update
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.0
训练过程， 注意优化器optimizer.zero_grad()要清零，loss.items()不要少。
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)
correct += (predicted == labels).sum().item()
print('Accuracy on test set: %d %%' % (100 * correct / total))
test过程中不需要计算梯度， 不需要反向传播，只需要算正向的，算一下分类对了多少，with里面就是说不用算梯度，outputs就是这样的，输出每一行一个向量，找出最大值，dim表示第一个维度，竖的是第0个维度，横的是第一个维度。
沿着第一个维度找，也就是一行一行找。找最大值。（下图是维度）
返回两个值，一个是最大值，一个是下标。
整个代码如下：
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
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((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)
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()
# forward + backward + update
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.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)
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()
刘老师牛逼~！
附一张跑出来的代码图。
最高到97跑不上去了。
刘老师最后留下的一个练习，
把这个用softmax分类
