1、Softmax（层）函数：将输出值转换成概率值（各个值按自身大小按比例缩放在[0,1]之间，且加起来等于1）：
Softmax公式：
如下流程图中，Exponent相当于softmax的表达式中的分子部分，Sum相当于把三个Exponent处理过后的相加，Divide相当于把单个Exponent处理好的数除以三个Exponent处理过后的和：
2、交叉熵损失函数流程框图：
3、交叉熵损失函数（CrossEntropyLoss）：已经包括了Softmax函数层，不需要再加Softmax函数层
4、全连接网络模型设计
卷积网络代码：
################################卷积模型##############################################
# import torch
# in_channels, out_channels = 5, 10 # s
# width, height = 100, 100
# kernel_size = 3
# batch_size = 1
#
# input = torch.randn(batch_size,
# in_channels,
# width,
# height)
# # 卷积层
# conv_layer = torch.nn.Conv2d(in_channels, # 输入通道数量
# out_channels, # 输出通道数量
# kernel_size=kernel_size)
#
# output = conv_layer(input)
#
# print(input.shape) # 输入是5个通道，100x100
# print(output.shape) # 输出是10个通道，98x98
# print(conv_layer.weight.shape) # 卷积层权重形状，10个输入通道、5个输出通道、3x3卷积核大小
###############################卷积##################################################
# import torch
#
# # 输入数据
# input = [3,4,6,5,7,
# 2,4,6,8,2,
# 1,6,7,8,4,
# 9,7,4,6,2,
# 3,7,5,4,1]
# # 将输入数据转换成 1 层、1通道的 5 x 5 矩阵数据
# input = torch.Tensor(input).view(1, 1, 5, 5)
# # 卷积层中参数：1层卷积层、1通道、卷积核大小3、滑动2格、没有加偏置
# conv_layer = torch.nn.Conv2d(1, 1, kernel_size=3, stride=2, padding=1, bias=False)
# # 将数据...构造一个输出通道数（1）、输入通道数（1）、3x3的卷积核，
# kernel = torch.Tensor([1,2,3,4,5,6,7,8,9]).view(1, 1, 3, 3)
# # 把张量 kernel的.data 赋予给卷积层的权重的 .data
# conv_layer.weight.data = kernel.data
#
# output = conv_layer(input)
# print(output)
############################池化处理#####################################################
# import torch
#
# # 输入数据
# input = [3,4,6,5,
# 2,4,6,8,
# 1,6,7,8,
# 3,7,5,4]
# # 将输入数据转换成 1 层、1通道的 5 x 5 矩阵数据
# input = torch.Tensor(input).view(1, 1, 4, 4)
# # 最大值池化
# maxpooling_layer = torch.nn.MaxPool2d(kernel_size=2)
#
# output = maxpooling_layer(input)
# print(output)
#############将上一个程序（04_09_Number_Detect.py）全连接层转换成卷积层###################
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(), # 将PIL格式图像转换成Tensor矩阵向量（维度28x28转换成1x28x28，1：为RGB通道）【 [0...255]--->[0,1] 】
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.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)
self.pooling = torch.nn.MaxPool2d(2)
self.fc = torch.nn.Linear(320, 10)
def forward(self, x):
batch_size = x.size(0)
x = F.relu(self.pooling(self.conv1(x)))
x = F.relu(self.pooling(self.conv2(x)))
x = x.view(batch_size, -1) # -1：自动检测矩阵有有多少行，列指定为784
x = self.fc(x)
return x
# 想使用模型，就实例化即可，可以直接调用
model = Net()
# 将模型放到GPU上运行，需要加如下两行代码（训练集、测试集中的输入值、实际值也需要加载到GPU上）
# device = torch.device("cude:0" if torch.cuda.is_available() else "cpu")
# model.to(device)
###################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):
# 准备数据（input：输入，target：实际值）
inputs, target = data
# 将输入、实际值加载到GPU
# inputs, target = inputs.to(device), target.to(device)
# 梯度清0
optimizer.zero_grad()
# 前向传播
outputs = model(inputs)
# 交叉熵损失函数计算
loss = criterion(outputs, target)
# 反向传播
loss.backward()
# 参数优化
optimizer.step()
# 累计loss
running_loss += loss.item()
# 数据集一共有batch_idx个数据，每隔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 # 得到样品数据images（矩阵形式）,以及样品数据的标签(矩阵形式)
# 将输入、实际值加载到GPU中
# inputs, target = inputs.to(device), target.to(device)
outputs = model(images) # 根据样品数据做预测，得到一个矩阵
_, predicted = torch.max(outputs.data, dim=1) # _:每一行的最大值是多少；predicted：每一行最大值的下标；（dim=0:以列方向找，dim=1:以行方向找）
total += labels.size(0) # 获取一共的lables标签数量
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()
运行结果：
