DL：CNN With Python

“ 简单的介绍 ”

在统计学习中，我们也经常遇到高维数据的问题，比如图片处理，图片的处理技术在目前也是非常热门，不断被探索的领域，本次学习blog为大家带来鄙人封装的卷积神经网络python代码，供大家处理基本的图片分类预测问题并将结果进行可视化，当然大家也可以根据自己需求修改代码中的parames参数，从而选择出预测效果最佳的模型。

“ CNN的基本原理 ”

关于CNN的基本介绍大家可以在 A Simple Introduction About CNN 里进行学习。

“ python代码 ”

本次的卷积神经网络使用的pytorch包，只要求有友友所使用的训练图片数据集标记好并放至所在的文件夹目录，即可以运行鄙人的CNN函数。并且一般卷积神经网络（CNN）主要用于图像处理技术，因此本代码针对的数据集为 jpg、png等图片数据。

导入所需的库

pytorch、glob、numpy、sklearn、matplotlib、copy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import optim
from torchvision import utils
from torch.optim.lr_scheduler import ReduceLROnPlateau
from torchvision import datasets, models, transforms
from torch.utils.data import DataLoader, Dataset

import copy
import glob
import numpy as np
import plotly.graph_objs as go
import matplotlib.pyplot as plt
from plotly.subplots import make_subplots
from sklearn.model_selection import train_test_split
%matplotlib inline

数据集的构建

CPU or CUDA

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# 1. 选择 CPU 还是 GPU 版的 pytorch 进行建模
device = 'cuda' if torch.cuda.is_available() else 'cpu'

# 2. 设置随机种子
torch.manual_seed(816)
if device =='cuda':
	torch.cuda.manual_seed_all(816)

# 将所有图片数据的路径存储至列表中, train_dir和 test_dir为训练集图片和验证集图片所在的文件夹
train_list = glob.glob(os.path.join(train_dir,'*.jpg')) # 如果图片为png形式，则将jpg改成png即可
test_list = glob.glob(os.path.join(test_dir, '*.jpg')) # 如果有测试集则使用这行代码，否则可以删除

模型的搭建

数据增强、模型结构设计、模型的训练与保持、结果可视化

  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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
# 3. 定义完整的 CNN 框架模型
def So_CNN_model(train_list, test_list = None):

	# 训练集和验证集的分割
	train_list, val_list = train_test_split(train_list, test_size=0.2)
	
	# 4. 图片的预处理，图片增强
	train_transforms =  transforms.Compose([
			transforms.Resize((224, 224)), # 设计训练图片转化为224*224图片大小，可以根据需求自行修改大小
			transforms.RandomResizedCrop(224),
			transforms.RandomHorizontalFlip(),
			transforms.ToTensor(),
		])

	val_transforms = transforms.Compose([
			transforms.Resize((224, 224)), # 设计验证集图片转化为224*224图片大小
			transforms.RandomResizedCrop(224),
			transforms.RandomHorizontalFlip(),
			transforms.ToTensor(),
		])
	
	# 如果有测试集需要输出，则也对验证集进行图片转化增强
	if test_list != None:
			test_transforms = transforms.Compose([   
				transforms.Resize((224, 224)),
				transforms.RandomResizedCrop(224),
				transforms.RandomHorizontalFlip(),
				transforms.ToTensor()
				])

	# 5. 定义一个类进行数据转化、图片数据集的处理、以及图片的标注转化
	class dataset(torch.utils.data.Dataset):
	
		def __init__(self, file_list, transform=None):
	
			self.file_list = file_list # 图片名字列表
			self.transform = transform  # 转化器
			self.label_list = label_list # 所有的标签种类
	
		def __len__(self):

			self.filelength = len(self.file_list)
			return self.filelength  # 图片数目
		
		# 对于本地图片的下载与标注
		def __getitem__(self,idx):
			img_path = self.file_list[idx]
			img = Image.open(img_path)  # 打开本地图片数据集所在的位置
			img_transformed = self.transform(img)  # 数据增强
			
			label = img_path.split('/')[-1].split('.')[0] # 对图片名字分割，前提是图片名字即为标注
					label = label_list.index(label) # 搜索该标签在列表中的位置，并将其进行数值标注，有几个种类数值就有几种
				
			return img_transformed, label

	# 6. 定义各个类
	train_data = dataset(train_list, transform=train_transforms)
	if test_list != None:
			test_data = dataset(test_list, transform=test_transforms)
	val_data = dataset(val_list, transform=test_transforms)

	# 7. 数据加载
	batch_size = 100
	train_loader = torch.utils.data.DataLoader(dataset = train_data, batch_size = batch_size, shuffle=True )
	if test_list != None:
			test_loader = torch.utils.data.DataLoader(dataset = test_data, batch_size = batch_size, shuffle=True)
	val_loader = torch.utils.data.DataLoader(dataset = val_data, batch_size = batch_size, shuffle=True)

	# 8. CNN模型架构的设计
	class Cnn(nn.Module):

		def __init__(self):

			super(Cnn,self).__init__()
	
		'''以下所有层的结构参数和层数数量都可以进行需修改
		可以比较参数不同产生的模型结果，从而选择最优参数'''

		c,h,w = params['shape_in'] # 初始 数据结构
		f = params['initial_filters'] # 初始 数据转化的层数
		num_classes = params['num_classes']  # 需要分类的总数
		num_fc1 =  params['num_fc1'] # 全连接层的第一层
		dropout_rate = params['dropout_rate']

		# 第一层卷积层，将3通道 c 维数据转化为 f 维数据，卷积的矩阵大小为3*3，步长为2，填白大小为0
			self.layer1 = nn.Sequential(
				nn.Conv2d(c, f, kernel_size = 3, padding=0, stride=2),
				nn.BatchNorm2d(f),  # f 维 数据进行标准化处理
				nn.ReLU(), # 激活函数为 ReLU 函数，也可以根据需要对其进行重新选择
				nn.MaxPool2d(2) # 池化层，2*2 矩阵大小进行池化
			)
	
		# 第一层后，转化得到的维度
			h,w = findConv2dOutShape(h, w, nn.MaxPool2d(2))
		h,w = h/2, w/2

		# 第二层卷积层，将 f 维数据转化为 2*f 维数据，卷积的矩阵大小为3*3，步长为2，填白大小为0
			self.layer2 = nn.Sequential(
				nn.Conv2d(f, 2*f, kernel_size=3, padding=0, stride=2),
				nn.BatchNorm2d(2*f), # 2*f 维 数据进行标准化处理
				nn.ReLU(), # 激活函数为 ReLU 函数，也可以根据需要对其进行重新选择
				nn.MaxPool2d(2) # 池化层，2*2矩阵大小进行池化
				)
	
		# 第二层后，转化得到的维度
			h,w = findConv2dOutShape(h, w, nn.Conv2d(f, 2*f, kernel_size=3, padding=0, stride=2))
		h,w = h/2, w/2

		# 第三层卷积层，将 32 维数据转化为 64 维数据，卷积的矩阵大小为3*3，步长为2，填白大小为0
			self.layer3 = nn.Sequential(
				nn.Conv2d(2*f, 4*f, kernel_size=3, padding=0, stride=2),
				nn.BatchNorm2d(4*f), # 4*f 维 数据进行标准化处理
				nn.ReLU(), # 激活函数为 ReLU 函数，也可以根据需要对其进行重新选择
				nn.MaxPool2d(2) # 池化层，2*2矩阵大小进行池化
			)
	
		# 第三层后，转化得到的维度	
			h,w = findConv2dOutShape(h, w, nn.Conv2d(2*f, 4*f, kernel_size=3, padding=0, stride=2))
		h,w = h/2, w/2

		# 第四层卷积层，将 4*f 维数据转化为 8*f 维数据，卷积的矩阵大小为3*3，步长为2，填白大小为0
			self.layer4 = nn.Sequential(
				nn.Conv2d(4*f, 8*f, kernel_size=3, padding=0, stride=2),
				nn.BatchNorm2d(8*f), # 8*f 维 数据进行标准化处理
				nn.ReLU(), # 激活函数为 ReLU 函数，也可以根据需要对其进行重新选择
				nn.MaxPool2d(2) # 池化层，2*2矩阵大小进行池化
			)
	
		# 第四层后，转化得到的维度
			h,w = findConv2dOutShape(h, w, nn.Conv2d(4*f, 8*f, kernel_size=3, padding=0, stride=2))        
		h,w = h/2, w/2

		# 最后 我设计了2层全连接神经网络结构
		self.num_flatten= h * w* 8*f
			self.fc1 = nn.Linear(self.num_flatten, num_fc1)  
			self.dropout = nn.Dropout(dropout_rate) # 以 0.5 的概率对其进行剔除
			self.fc2 = nn.Linear(num_fc1, num_class)
			self.relu = nn.ReLU() # 定义激活函数  RELU
		self.softmax = nn.log_softmax() # 定义 最后的输出函数 Softmax
	
		# 定义向前传播
		def forward(self,x):
			out = self.layer1(x)
			out = self.layer2(out)
			out = self.layer3(out)
		out = self.layer4(out)
			out = out.view(-1, self.num_flatten)
			out = self.relu(self.fc1(out))
		out = self.softmax(self.fc2(out), dim = 1)
	
			return out
	
	params_model={
			"shape_in": (3, 224, 224), 
			"initial_filters": 8,    
			"num_fc1": 100,
			"dropout_rate": 0.25,
			"num_classes": len(label_list)}  # num_class,根据类别的总数而定

	# 传达模型结构给cnn_model
	cnn_model = Cnn(params_model)
	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
	model = cnn_model.to(device)

	# 9. 定义损失函数
	loss_func = nn.NLLLoss(reduction="sum")
		
	# 10. 定义一个优化器，优化器将保持当前状态，并根据计算的梯度更新参数
	opt = optim.Adam(cnn_model.parameters(), lr=3e-4)
	lr_scheduler = ReduceLROnPlateau(opt, mode='min',factor=0.5, patience=20,verbose=1)

	# 11. 定义模型训练函数
	def train_val(model, params,verbose=False):

		# 获取训练参数
		epochs = params["epochs"]
		loss_func = params["loss_func"]
		opt = params["optimiser"]
		train_dl = params["train"]
		val_dl = params["val"]
		check = params["check"]
		lr_scheduler = params["lr_change"]
		weight_path = params["weight_path"]
	  
		loss_history = {"train": [],"val": []} # 每次 epoch 的训练集和验证集的损失值
		metric_history = {"train": [],"val": []} # 每次 epoch 的 metric值
		best_model_wts = copy.deepcopy(model.state_dict()) # 深度复制最佳性能模型的权重
		best_loss = float('inf') # 将最佳的损失值初始化为极大值

		# 迭代循环
		for epoch in range(epochs):
			
			# 获取学习率
			current_lr = get_lr(opt)
			if(verbose):
				print('Epoch {}/{}, current lr={}'.format(epoch, epochs - 1, current_lr))
			
			# 使用训练集训练 CNN 模型
			model.train()
			train_loss, train_metric = loss_epoch(model,loss_func,train_dl,check,opt)
	
			# 收集训练数据集的损失和衡量标准
			loss_history["train"].append(train_loss)
			metric_history["train"].append(train_metric)
			
			# 使用验证集对模型结果进行评估
			model.eval()
			with torch.no_grad():
				val_loss, val_metric = loss_epoch(model, loss_func, val_dl,check)
			
			# 选择最好的参数模型
			if val_loss < best_loss:
				best_loss = val_loss
				best_model_wts = copy.deepcopy(model.state_dict())
				
				# 存储模型参数至本地文件
				torch.save(model.state_dict(), weight_path)
				if(verbose):
					print("已经保存完训练得到的最好模型！")
			
			# 存储验证数据集的损失和衡量标准
			loss_history["val"].append(val_loss)
			metric_history["val"].append(val_metric)
			
			# 学习率筛选
			lr_scheduler.step(val_loss)
			if current_lr != get_lr(opt):
				if(verbose):
					print("已经加载完CNN模型！")
				model.load_state_dict(best_model_wts) 
	
			if(verbose):
				print(f"train loss: {train_loss:.6f}, dev loss: {val_loss:.6f}, accuracy: {100*val_metric:.2f}")
				print("-"*10) 
	
		# 存储模型的权重和参数数据至本地
		model.load_state_dict(best_model_wts)
			
		return model, loss_history, metric_history

	params_train={
	 "train": train_dl,"val": val_dl,
	 "epochs": 50, # 迭代 50 次
	 "optimiser": optim.Adam(cnn_model.parameters(),
							 lr=3e-4),
	 "lr_change": ReduceLROnPlateau(opt,
									mode = 'min',
									factor = 0.5,
									patience = 20,
									verbose = 0),
	 "loss_func": nn.NLLLoss(reduction = "sum"),
	 "weight_path": "weights.pt",
	 "check": False, 
	}
	
	# 训练和验证模型
	cnn_model,loss_hist,metric_hist = train_val(cnn_model, params_train)
	# 训练参数进程
	epochs = params_train["epochs"]
	
	# 绘制结果图
	fig = make_subplots(rows = 1, cols = 2, subplot_titles = ['损失值-折线图','准确率-折线图'])
	fig.add_trace(go.Scatter(x = [*range(1,epochs+1)], y = loss_hist["train"], name = '训练集的损失值'), row = 1, col = 1)
	fig.add_trace(go.Scatter(x = [*range(1,epochs+1)], y = loss_hist["val"], name = '验证集的损失值'), row = 1, col = 1)
	fig.add_trace(go.Scatter(x = [*range(1,epochs+1)], y = metric_hist["train"], name = '训练集的准确率'), row = 1, col = 2)
	fig.add_trace(go.Scatter(x = [*range(1,epochs+1)], y = metric_hist["val"], name = '验证集的准确率'), row = 1, col = 2)
	fig.update_layout(template = 'plotly_white'); fig.update_layout(margin = {"r":0,"t":60,"l":0,"b":0}, height=  300)
	fig.show()

So_CNN_model(train_list, test_list)

感谢各位友友能看到最后！附一张我超级喜欢的数学宇宙gif代表结束！

The End！

“ 简单的介绍 ”#

“ CNN的基本原理 ”#

“ python代码 ”#

“ 简单的介绍 ”

“ CNN的基本原理 ”

“ python代码 ”