### 卷积神经网络模型
卷积神经网络（简称 CNN）是一种专为图像输入而设计的网络。它最明显的特征就是具有三个层次，卷积层，池化层，全连接层。
借用一张图，下图很好的表示了什么是卷积（提取特征），什么是池化（减少数据量），而全连接层就是一个简单普通的神经网络。
如下代码，该代码定义了一个卷积神经网络。其中仅有一个简单的函数前向传播`forward函数`，这个函数的功能其实就是输入数据，给出预测，并不复杂。
1 from numpy import argmax, vstack 2 from sklearn.metrics import accuracy_score 3 from torch.nn import Module, Conv2d, ReLU, MaxPool2d, Linear, CrossEntropyLoss, Softmax 4 from torch.nn.init import kaiming_uniform_, xavier_uniform_ 5 from torch.optim import SGD 6 from torch.utils.data import DataLoader 7 from torchvision.datasets import MNIST 8 from torchvision.transforms import Compose, ToTensor, Normalize 9 10 11 # 定义模型 12 class CNN(Module): 13 def __init__(self, n_channels): 14 # 模型属性 15 super(CNN, self).__init__() 16 # 隐藏层1。采用了Conv2d函数，n_channels输入数据的通道（彩色RGB图像为3），out_channels即输出的通道数量，kernel_size卷积核的大小 17 self.hidden1 = Conv2d(n_channels, 32, kernel_size=(3, 3)) 18 kaiming_uniform_(self.hidden1.weight, nonlinearity='relu') # 初始化权重 19 self.act1 = ReLU() # 激活函数 20 # 池化层1。二维最大池化（Max Pooling）层，kernel_size池化窗口的大小，stride池化窗口的滑动步长 21 self.pool1 = MaxPool2d((2, 2), stride=(2, 2)) 22 # 隐藏层2 23 self.hidden2 = Conv2d(32, 32, kernel_size=(3, 3)) 24 kaiming_uniform_(self.hidden2.weight, nonlinearity='relu') 25 self.act2 = ReLU() 26 # 池化层2 27 self.pool2 = MaxPool2d((2, 2), stride=(2, 2)) 28 # 全连接层 29 self.hidden3 = Linear(5 * 5 * 32, 100) 30 kaiming_uniform_(self.hidden3.weight, nonlinearity='relu') 31 self.act3 = ReLU() 32 # 输出层 33 self.hidden4 = Linear(100, 10) 34 xavier_uniform_(self.hidden4.weight) 35 self.act4 = Softmax(dim=1) 36 37 # 前向传播 38 def forward(self, X): 39 # 输入到隐藏层1 40 X = self.hidden1(X) 41 X = self.act1(X) 42 X = self.pool1(X) 43 # 输入到隐藏层2 44 X = self.hidden2(X) 45 X = self.act2(X) 46 X = self.pool2(X) 47 # 扁平化 48 X = X.view(-1, 4 * 4 * 50) 49 # 输入到隐藏层3 50 X = self.hidden3(X) 51 X = self.act3(X) 52 # 输入到输出层 53 X = self.hidden4(X) 54 X = self.act4(X) 55 return X
然后准备数据，开始划分训练集和测试集
# 准备数据集
def prepare_data(path):
# 定义标准化
trans = Compose([ToTensor(), Normalize((0.1307,), (0.3081,))])
# 加载数据集
train = MNIST(path, train=True, download=True, transform=trans)
test = MNIST(path, train=False, download=True, transform=trans)
# 创建 DataLoader
train_dl = DataLoader(train, batch_size=64, shuffle=True)
test_dl = DataLoader(test, batch_size=1024, shuffle=False)
return train_dl, test_dl
所准备是数据如下图，是一种手写数字，通过识别图片分析来得到答案
然后我们就要看是训练模型了
# 训练模型
def train_model(train_dl, model):
criterion = CrossEntropyLoss() # 损失函数
# 定义优化器，SGD（随机梯度下降），lr学习率，momentum动量，用于加速 SGD 在相关方向上的收敛，并抑制震荡
optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
# 枚举 epochs
for epoch in range(10):
# 枚举 mini batches
for i, (inputs, tragets) in enumerate(train_dl):
# 梯度清零
optimizer.zero_grad()
# 计算模型输出
yhat = model(inputs)
# 计算损失
loss = criterion(yhat, tragets)
# 反向传播，通过pytorch的自动求导系统（Autograd）间接地影响模型的参数
loss.backward()
# 升级模型权重，然后优化器根据反向传播所存储的数据来优化
optimizer.step()
训练完模型，还要评估一下模型
# 评估模型
def evaluate_model(test_dl, model):
predictions, actuals = list(), list()
for i, (inputs, tragets) in enumerate(test_dl):
# 在测试集上评估模型
yhat = model(inputs)
# 转化为 numpy 数据类型
yhat = yhat.detach().numpy()
actual = tragets.numpy()
# 转化为类标签
yhat = argmax(yhat, axis=1)
# 为 stack 格式化数据集
actual = actual.reshape(len(actual), 1)
yhat = yhat.reshape(len(yhat), 1)
# 保存
predictions.append(yhat)
actuals.append(actual)
predictions, actuals = vstack(predictions), vstack(actuals)
# 计算准确度
acc = accuracy_score(actuals, predictions)
return acc
最后我们利用如下代码开始运行
# 准备数据
path = './'
train_dl, test_dl = prepare_data(path)
print(len(train_dl.dataset), len(test_dl.dataset))
# 定义网络
model = CNN(1)
train_model(train_dl, model)
acc = evaluate_model(test_dl, model)
print('Accuracy: %.3f' % acc)
### 多层感知机模型
1 from numpy import vstack, argmax
2 from pandas import read_csv
3 from sklearn.metrics import accuracy_score
4 from sklearn.preprocessing import LabelEncoder
5 from torch import Tensor
6 from torch.nn import Module, Linear, ReLU, Softmax, CrossEntropyLoss
7 from torch.nn.init import kaiming_uniform_, xavier_uniform_
8 from torch.optim import SGD
9 from torch.utils.data import Dataset, random_split, DataLoader
10
11
12 # 数据集定义
13 class CSVDataset(Dataset):
14 # 导入数据集
15 def __init__(self, path):
16 # 导入数据集
17 df = read_csv(path, header=None)
18 # 设置神经网络的输入与输出
19 self.X = df.values[:, :-1]
20 self.y = df.values[:, -1]
21 # 确保输入数据是浮点数
22 self.X = self.X.astype('float32')
23 # 使用浮点型标签编码原输出
24 self.y = LabelEncoder().fit_transform(self.y)
25
26 # 定义获取数据集长度的方法
27 def __len__(self):
28 return len(self.X)
29
30 # 定义获取某一行数据的方法
31 def __getitem__(self, idx):
32 return [self.X[idx], self.y[idx]]
33
34 # 在类内部定义划分训练集和测试集的方法
35 def get_splits(self, n_test = 0.33):
36 # 确定训练集和测试集的尺寸
37 test_size = round(len(self.X) * n_test)
38 train_size = len(self.X) - test_size
39 # 根据尺寸划分训练集和测试集并返回
40 return random_split(self, [train_size, test_size])
41
42
43 # 模型定义
44 class MLP(Module):
45 # 定义模型属性
46 def __init__(self, n_inputs):
47 super(MLP, self).__init__()
48 # 隐藏层1（输入）
49 self.hidden1 = Linear(n_inputs, 10)
50 kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
51 self.act1 = ReLU()
52 # 隐藏层2
53 self.hidden2 = Linear(10, 8)
54 kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
55 self.act2 = ReLU()
56 # 隐藏层3（输出）
57 self.hidden3 = Linear(8, 3)
58 xavier_uniform_(self.hidden3.weight)
59 self.act3 = Softmax(dim=1)
60
61 # 前向传播
62 def forward(self, X):
63 # 输入
64 X = self.hidden1(X)
65 X = self.act1(X)
66 # 隐藏层2
67 X = self.hidden2(X)
68 X = self.act2(X)
69 # 输出
70 X = self.hidden3(X)
71 X = self.act3(X)
72 return X
73
74
75 # 准备数据集
76 def prepare_data(path):
77 # 导入数据集
78 dataset = CSVDataset(path)
79 train, test = dataset.get_splits()
80 train_dl = DataLoader(train, batch_size=32, shuffle=True)
81 test_dl = DataLoader(test, batch_size=1024, shuffle=False)
82 return train_dl, test_dl
83
84 # 训练模型
85 def train_model(train_dl, model):
86 # 定义优化器
87 criterion = CrossEntropyLoss()
88 optimizer = SGD(model.parameters(), lr=0.01, momentum=0.9)
89 # 枚举 epochs
90 for epoch in range(500):
91 # 枚举 mini batches
92 for i, (inputs, targets) in enumerate(train_dl):
93 # 梯度清除
94 optimizer.zero_grad()
95 # 计算模型输出
96 yhat = model(inputs)
97 # 计算损失
98 loss = criterion(yhat, targets)
99 # 反向传播
100 loss.backward()
101 # 更新
102 optimizer.step()
103
104 def evaluate_model(test_dl, model):
105 predictions, actuals = list(), list()
106 for i, (inputs, targets) in enumerate(test_dl):
107 # 在测试集上评估模型
108 yhat = model(inputs)
109 # 转化为 numpy 数据类型
110 yhat = yhat.detach().numpy()
111 actual = targets.numpy()
112 # 转化为类标签
113 yhat = argmax(yhat, axis=1)
114 # 为 stacking reshape 矩阵
115 actual = actual.reshape((len(actual), 1))
116 yhat = yhat.reshape((len(yhat), 1))
117 # 保存
118 predictions.append(yhat)
119 actuals.append(actual)
120 predictions, actuals = vstack(predictions), vstack(actuals)
121 # 计算准确度
122 acc = accuracy_score(actuals, predictions)
123 return acc
124
125 # 对一行数据进行类预测
126 def predict(row, model):
127 # 转换源数据
128 row = Tensor([row])
129 # 做出预测
130 yhat = model(row)
131 # 转化为 numpy 数据类型
132 yhat = yhat.detach().numpy()
133 return yhat
134
135 # 准备数据
136 path = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv'
137 train_dl, test_dl = prepare_data(path)
138 print(len(train_dl), len(test_dl))
139 # 定义网络
140 model = MLP(4)
141 # 训练模型
142 train_model(train_dl, model)
143 # 评估模型
144 acc = evaluate_model(test_dl, model)
145 print('Accuracy: %.3f' % acc)
146 # 进行单个预测
147 row = [5.1,3.5,1.4,0.2]
148 yhat = predict(row, model)
149 print('Predicted: %s (class=%d)' % (yhat, argmax(yhat)))
这个就比较简单了，最简单的感知机（最简单的两层神经网络），这里只不过是多层的感知机。它的思想还是比较好理解的，主要是如何针对不同的应用来实现它
标签：dl,入门,yhat,self,pytorch,train,test,model From： https://www.cnblogs.com/Dav-ove3/p/18402661