使用卷积神经网络（普通CNN和改进型LeNet）以及数据增强和迁移学习技巧识别猫和狗，并制作成分类器软件（基于Keras）

数据集:https://www.microsoft.com/en-us/download/confirmation.aspx?id=54765

猫和狗的图片各自有12500张。

第一步
整理数据集，查看各类别图片的分辨率，发现猫和狗图片的分辨率都毫无规律，且不少于10种。

import os
import numpy as np
from matplotlib import pyplot as plt
from PIL import Image
dogs_dir = os.listdir(r'D:\kaggle\data\Dog')
cats_dir = os.listdir(r'D:\kaggle\data\Cat')dog_shapes = []
cat_shapes = []
os.chdir(r'D:\kaggle\data\Dog')
for each in dogs_dir:img = np.array(Image.open(each))if img.shape not in dog_shapes:dog_shapes.append(img.shape)print('已知狗的图片分辨率有%d种'%(len(dog_shapes)))if len(dog_shapes) == 10:print('分辨率不少于10种')breakprint('\n')os.chdir(r'D:\kaggle\data\Cat')
for each in cats_dir:img = np.array(Image.open(each))if img.shape not in cat_shapes:cat_shapes.append(img.shape)print('已知猫的图片分辨率有%d种'%(len(cat_shapes)))if len(cat_shapes) == 10:print('分辨率不少于10种')break

第二步
数据预处理（裁剪，筛选，洗牌），然后保存成.npy文件，有些图片只有一个通道，所以没有选入数据集(大概60张左右，影响不大)。

import numpy as np
import os
from PIL import Image
from matplotlib import pyplot as plt
from sklearn.utils import shuffle
import warnings
warnings.filterwarnings("error", category=UserWarning)#捕获警告dogs_dir = os.listdir(r'D:\kaggle\data\Dog')
cats_dir = os.listdir(r'D:\kaggle\data\Cat')#训练集 11961:111935      测试集 498:500       狗：猫
#猫的标签[1,0]  狗的标签[0,1]
train_batches = []
train_labels  = []
test_batches  = []
test_labels   = []os.chdir(r'D:\kaggle\data\Dog')
for idx,each in enumerate(dogs_dir):try:img = Image.open(each)img = np.array(img.resize((224,224),Image.ANTIALIAS))except:plt.imshow(img)plt.show()if img.shape !=(224,224,3):continueif idx >= 12000:test_batches.append(img)test_labels.append(np.array([0,1]))if (idx+1) %100 == 0:print('狗图片的测试集已完成:{:.2f}%'.format((len(test_batches)/500)*100))else:    train_batches.append(img)train_labels.append(np.array([0,1]))if (idx+1) %100 == 0:print('狗图片的训练集已完成:{:.2f}%'.format((len(train_batches)/12000)*100))print('\n')os.chdir(r'D:\kaggle\data\Cat')
for idx,each in enumerate(cats_dir):try:img = Image.open(each)img = np.array(img.resize((224,224),Image.ANTIALIAS))except:plt.imshow(img)plt.show()if img.shape !=(224,224,3):continueif idx >= 12000:test_batches.append(img)test_labels.append(np.array([1,0]))if (idx+1) %100 == 0: print('猫图片的测试集已完成:{:.2f}%'.format(((len(test_batches)-500)/500)*100))else:    train_batches.append(img)train_labels.append(np.array([1,0]))if (idx+1) %100 == 0:print('猫图片的训练集已完成:{:.2f}%'.format(((len(train_batches)-12000)/12000)*100))
#打乱数据
train = shuffle(train_batches,train_labels)
test  = shuffle(test_batches,test_labels)
#把dataset以npy格式保存
os.chdir(r'D:\kaggle')
np.save('train_batches.npy',train[0])
np.save('train_labels.npy',train[1])
np.save('test_batches.npy',test[0])
np.save('test_labels.npy',test[1])

第三步
建模（训练模型，评估模型，保存模型）

由于内存不够，只能取部分数据集进行训练，但训练集和测试集准确率还是能达到百分之七十以上。

网络模型包括三层（卷积+池化），在输出层展开并利用Dense层改变输出维度，笔者曾尝试过使用rate=0.3的Dropout层（位于Dense层前）抑制过拟合，结果效果并不理想，虽然测试集与训练集精度差值减小，可是代价是两者的精度都降低了大概5个百分点，于是我改成使用权重正则化（L2正则化）约束权重的更新，效果虽然未达到期盼（精度还是没上80），但效果比Dropout要好。

import numpy as np
from matplotlib import pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
from keras.layers import Input, Conv2D, MaxPooling2D, Flatten ,Dense
from keras.models import Model
import keras#Loss = 0.6403      Train accuracy = 0.7803     Test accuracy = 0.7224def get_data():train_batches = np.load(r'D:\kaggle\train_batches.npy',allow_pickle=True)train_labels = np.load(r'D:\kaggle\train_labels.npy',allow_pickle=True)test_batches = np.load(r'D:\kaggle\test_batches.npy',allow_pickle=True)test_labels = np.load(r'D:\kaggle\test_labels.npy',allow_pickle=True)return (train_batches,train_labels),(test_batches,test_labels)#载入数据集
(train_x_batch,train_y_batch),(test_x_batch,test_y_batch)=get_data()
#内存不够，取部分图片训练
train_x_batch = train_x_batch[0:4000]
train_y_batch = train_y_batch[0:4000]
#归一化
train_x_batch = train_x_batch.astype('float32') / 255.0
test_x_batch = test_x_batch.astype('float32') / 255.0
#建模
input_imgs = Input(shape=train_x_batch[0].shape)tower_1 = Conv2D(32, (3, 3), padding='same', activation='relu',kernel_regularizer=keras.regularizers.l2(0.01))(input_imgs)
tower_1 = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(tower_1)tower_2 = Conv2D(32, (3, 3), padding='same', activation='relu',kernel_regularizer=keras.regularizers.l2(0.01))(tower_1)
tower_2 = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(tower_2)tower_3 = Conv2D(64, (3, 3), padding='same', activation='relu',kernel_regularizer=keras.regularizers.l2(0.01))(tower_2)
tower_3 = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(tower_3)flat_imgs = Flatten()(tower_3)
output = Dense(2, activation='softmax')(flat_imgs)model = Model(inputs = input_imgs,outputs = output)#编译模型
model.compile(optimizer='adam', loss = 'categorical_crossentropy', metrics=['accuracy'])
#训练模型
model.fit(train_x_batch,train_y_batch,epochs=10,batch_size=96,verbose=1)
#保存模型
model.save_weights("weights")
with open("model.json", "w") as f:f.write(model.to_json())
#评估模型
preds = model.evaluate(test_x_batch,test_y_batch)
print('Loss = ' + str(preds[0]))
print('Test Accuracy = ' + str(preds[1]))input()

为了进一步提高精度，尝试使用经典的改进型LeNet网络，该网络架构为：
Input->第一层卷积层（size=55,Cout=32）->第一层最大值池化层->第二层卷积层(size=55,Cout=64)->第二层最大值池化层->Flatten->Dense层（神经元数目=1024）->Dropout层(保留比例=0.5)->Dense层(改变输出维度)->Output.
此外，为了抑制过拟合，将数据量从4000增加至5000，同时将epochs从10降低为8.

按照架构一步步建模，接着训练，便可得到结果，代码和结果如下:

import numpy as np
from matplotlib import pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
from keras.layers import Input, Conv2D, MaxPooling2D, Flatten ,Dense ,Dropout
from keras.models import Model
import keras#Loss = 1.1238     Train accuracy = 0.9428     Test accuracy = 0.6303def get_data():train_batches = np.load(r'D:\kaggle\train_batches.npy',allow_pickle=True)train_labels = np.load(r'D:\kaggle\train_labels.npy',allow_pickle=True)test_batches = np.load(r'D:\kaggle\test_batches.npy',allow_pickle=True)test_labels = np.load(r'D:\kaggle\test_labels.npy',allow_pickle=True)return (train_batches,train_labels),(test_batches,test_labels)
#载入数据集
(train_x_batch,train_y_batch),(test_x_batch,test_y_batch)=get_data()#内存不够，取部分图片训练
train_x_batch = train_x_batch[0:5000]
train_y_batch = train_y_batch[0:5000]
#归一化
train_x_batch = train_x_batch.astype('float32') / 255.0
test_x_batch = test_x_batch.astype('float32') / 255.0
#建模(改进型LeNet)
input_imgs = Input(shape=train_x_batch[0].shape)tower_1 = Conv2D(32, (5, 5), padding='same', activation='relu')(input_imgs)
tower_1 = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(tower_1)tower_2 = Conv2D(64, (5, 5), padding='same', activation='relu')(tower_1)
tower_2 = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(tower_2)flat_imgs = Flatten()(tower_2)
fc = Dense(1024, activation='relu')(flat_imgs)
drop = Dropout(rate=0.5)(fc)
output = Dense(2, activation='softmax')(drop)model = Model(inputs = input_imgs,outputs = output)#编译模型
model.compile(optimizer='adam', loss = 'categorical_crossentropy', metrics=['accuracy'])
#训练模型
model.fit(train_x_batch,train_y_batch,epochs=8,batch_size=96,verbose=1)
#保存模型
model.save_weights("weights")
with open("model.json", "w") as f:f.write(model.to_json())
#评估模型
preds = model.evaluate(test_x_batch,test_y_batch)
print('Loss = ' + str(preds[0]))
print('Test Accuracy = ' + str(preds[1]))input()

由结果可知，训练集精度的确得到有效提升，然而出现了严重的过拟合问题。
对付过拟合问题，除了正则化技术和BatchNnormalization外，还有一个强有力的武器——数据增强。我们使用keras.preprocessing.imageImageDataGenerator来实现数据增强，其拥有以下重要参数:
rotation_range :在指定角度范围内，对图片作随机角度的选择。
width_shift_range：在指定长度范围内，对图片的宽度作随机长度的变换。
height_shift_range：在指定长度范围内，对图片的高度作随机长度的变换。
rescale：可以实现归一化（1/255）
shear_range：可以实现剪切变换，参见剪切变换
zoom_range：在指定范围内实现放大和缩小
horizontal_flip：水平翻转

注意，要将数据整理成以下形式("/"表示一个目录)：

 /train/dogdog0.jpgdog1.jpg.../cat   cat0.jpgcat1.jpg.../val/dogdog1500.jpg.../catcat1500.jpg...

此外，将损失函数调整为binary_crossentropy并调整输出层，将输出维度调整为1。由于使用了数据增强，可以上调dropout的保留比例，并且增加网络的深度，使得模型学习到更丰富的特征。

另外由于输出维度的改变，使得分类器的调用函数需要重写。如下：

    def classify(self,img_dir):model = load_model()img_dir = self.img_dircategories = ['猫','狗']img = (Image.open(img_dir)).resize((224,224),Image.ANTIALIAS)img = ((np.array(img)).reshape(1,224,224,3))/255pred = model.predict((np.array(img)).reshape(1,224,224,3))if pred.size > 1:name = categories[np.argmax(pred)]confidence = str(pred[0][np.argmax(pred[0])])else:if pred[0][0] < 0.5:name = '猫'confidence = str(1-pred[0][0])else:name = '狗'confidence = str(pred[0][0])self.textBrowser.setText('预测结果为：'+name+'\n置信度为：'+confidence)

模型的代码和结果如下所示：

import os
import numpy as np
from matplotlib import pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
from keras.layers import Input, Conv2D, MaxPooling2D, Flatten ,Dense ,Dropout
from keras.models import Model
from keras.preprocessing.image import ImageDataGenerator
import keras#Loss = 0.4673     Train accuracy = 0.8012     Test accuracy = 0.8124#采用增强的数据进行训练
train_datagen = ImageDataGenerator(rotation_range = 40,width_shift_range = 0.2,height_shift_range = 0.2,rescale = 1/255,shear_range = 0.2,zoom_range = 0.2,horizontal_flip = True,fill_mode = 'nearest')
train = train_datagen.flow_from_directory(r'D:\kaggle\data\for_enhanced_data\train',target_size=(224,224),batch_size=96,class_mode='binary')#创造验证集
test_datagen = ImageDataGenerator(rescale=1/255)
validation_generator = test_datagen.flow_from_directory(r'D:\kaggle\data\for_enhanced_data\val',target_size=(224, 224),batch_size=50,class_mode='binary'
#建模(改进型LeNet)
input_imgs = Input(shape=(224,224,3).shape)tower_1 = Conv2D(32, (3, 3), padding='same', activation='relu')(input_imgs)
tower_1 = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(tower_1)tower_2 = Conv2D(32, (3, 3), padding='same', activation='relu')(tower_1)
tower_2 = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(tower_2)tower_3 = Conv2D(64, (3, 3), padding='same', activation='relu')(tower_2)
tower_3 = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(tower_3)flat_imgs = Flatten()(tower_3)
fc = Dense(512, activation='relu')(flat_imgs)
drop = Dropout(rate=0.8)(fc)
output = Dense(1, activation='sigmoid')(drop)
model = Model(inputs = input_imgs,outputs = output)
#编译模型
model.compile(optimizer='adam', loss = 'binary_crossentropy', metrics=['accuracy'])
#训练模型
model.fit_generator(train,samples_per_epoch = 3000,nb_epoch = 60,validation_data = validation_generator,nb_val_samples=800)
#保存模型
model.save_weights("weights")
with open("model.json", "w") as f:f.write(model.to_json())input()

可见精度达到了百分之八十左右，效果还是挺不错的。

可是我们还想进一步提高精度，于是想到增加网络的深度和宽度，用深度学习的思路去建模，可是问题来了，具有相当深度和宽度的网络，需要的算力可不是一般人能承担的。好在别人已经帮我们训练好了模型（在别的任务上，比如ImageNet），我们可以使用迁移学习的技巧，既能节省运算资源，也能使模型获得良好的性能。
迁移学习分为两步，首先要冻结基础模型所有的层，只训练新层；然后冻结基础模型的部分层，训练剩余的层和新层。
良好的微调能使模型从别的任务学到的特征重用到自己的任务里（比如纹理、颜色等细节），从而使得模型具有良好的泛化能力。
代码和结果如下图所示：

我是手动下载InceptionV3的模型数据再导入的，模型数据下载资源不好找，可以从GITHUB下载或者私信我。

import os
import numpy as np
from matplotlib import pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
from keras.layers import Input, Conv2D, MaxPooling2D, Flatten ,Dense ,Dropout ,GlobalAveragePooling2D
from keras.models import Model,load_model
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.inception_v3 import InceptionV3,preprocess_input
from keras.optimizers import Adagrad
import keras#Loss =  0.0495    Train accuracy =  0.9835    Test accuracy = 0.976#采用增强的数据进行训练
train_datagen = ImageDataGenerator(rotation_range = 40,width_shift_range = 0.2,height_shift_range = 0.2,rescale = 1/255,shear_range = 0.2,zoom_range = 0.2,horizontal_flip = True,fill_mode = 'nearest')
train = train_datagen.flow_from_directory(r'D:\kaggle\data\for_enhanced_data\train',target_size=(299,299),batch_size=96,class_mode='binary')
#创造验证集
test_datagen = ImageDataGenerator(rescale=1/255)
validation_generator = test_datagen.flow_from_directory(r'D:\kaggle\data\for_enhanced_data\val',target_size=(299, 299),batch_size=50,class_mode='binary')#建模(迁移学习InceptionV3)
base_model = InceptionV3(weights=None,include_top=False)
base_model.load_weights(r'D:\kaggle\inceptionV3\inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5')
# 增加新的输出层
global_pooling = GlobalAveragePooling2D()(base_model.output) # GlobalAveragePooling2D 将 MxNxC 的张量转换成 1xC 张量，C是通道数
fc = Dense(512,activation='relu')(global_pooling)
drop = Dropout(rate=0.8)(fc)
output = Dense(1,activation='sigmoid')(drop)
model = Model(inputs=base_model.input,outputs=output#编译模型(两步，第一步只训练新层，基础模型冻结；第二步训练基础模型的部分层以及新层，其余层冻结。
def setup_to_transfer_learning(model,base_model):#base_modelfor layer in base_model.layers:layer.trainable = Falsemodel.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])def setup_to_fine_tuning(model,base_model):FROZEN_LAYER = 16 for layer in base_model.layers[:FROZEN_LAYER]:layer.trainable = Falsefor layer in base_model.layers[FROZEN_LAYER:]:layer.trainable = Truemodel.compile(optimizer=Adagrad(lr=0.0001),loss='binary_crossentropy',metrics=['accuracy'])#训练和评估模型
setup_to_transfer_learning(model,base_model)
model.fit_generator(train,samples_per_epoch = 3000,nb_epoch = 3,validation_data = validation_generator,nb_val_samples=800)
setup_to_fine_tuning(model,base_model)
model.fit_generator(train,samples_per_epoch = 3000,nb_epoch = 3,validation_data = validation_generator,nb_val_samples=800)
#保存模型
model.save_weights("weights")
with open("model.json", "w") as f:f.write(model.to_json())input()

可见结果是相当好的。基本上人能分辨出来的，模型都能分辨出来。

第四步
使用PyQt5为分类器设置用户界面

安装:
1.pip install PyQt5
2.pip install pyqt5-tools

建议下载国内镜像，速度更快，如果安装过程中出现ReadTimeoutError，只需要重新进行安装就可以了。
安装完后，在cmd中输入pyuic5，如果出现Error: one input ui-file must be specified，则说明安装成功。否则，你可能需要去配置环境变量，打开控制面板-系统和安全-系统-高级系统设置-环境变量，然后在path里输入相应的路径即可。

找到安装的地址（一般在Python的Scripts目录下），打开可执行文件pyqt5designer.exe，便可进入GUI的设置界面
左边可以选择你想要的工具，将其按住并拖入到主窗口便可自动生成，非常方便，这里注意一个问题:Textedit是编辑文本，Textbrowser是用来显示文本的，这里我们使用Textbrowser，如果需要编辑文本，也可以自行添加。窗口设计完后，将其保存在和模型的同一个目录下，然后在用cmd进入该目录，输入命令pyuic5 -o classifier.py classifier_ui.ui便可生成一个.py文件。建立文件main.py，进入文件，导入相应的库(其中classifier_ui是我们之前生成的文件)

import sys
from classifier_ui import *
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtWidgets import QApplication, QMainWindow

并添加主函数

if __name__ == '__main__':app = QApplication(sys.argv)MainWindow = QMainWindow()ui = Ui_MainWindow()ui.setupUi(MainWindow)MainWindow.show()sys.exit(app.exec_())

运行该文件，如果不出意外，你可以看见自己设计的GUI界面。

首先，我们需要利用QFileDialog.getOpenFileName获取图片。这需要在之前生成的classify_ui.py文件中加入一个load_img函数，具体实现方法为

    def openImg(self):file_name, _ = QFileDialog.getOpenFileName(None, '选择图片', 'D:\\', 'Image files(*.jpg *.gif *.png)')print(file_name)

接着我们可以利用graphicsView.setPixmap(QPixmap(file_name))来将获取的图片显示在Label上。

然后我们可以使用ui.pushButton.clicked.connect(func,args)来绑定事件。
那么这里func就应该实现模型对输入图片的识别。

同时，我们可以使用ui.textBrowser.setText()，将识别的结果显示在TextBrowser内。
完整代码如下：

from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtWidgets import QApplication, QMainWindow,QAction,QFileDialog
from PyQt5.Qt import *
from keras.models import model_from_json
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
import osdef load_model():#载入模型model = model_from_json(open('model.json').read())model.load_weights('weights')return modelclass Ui_MainWindow(object):def __init__(self):self.img_dir = Nonedef setupUi(self, MainWindow):MainWindow.setObjectName("MainWindow")MainWindow.resize(800, 600)self.centralwidget = QtWidgets.QWidget(MainWindow)self.centralwidget.setObjectName("centralwidget")self.pushButton = QtWidgets.QPushButton(self.centralwidget)self.pushButton.setGeometry(QtCore.QRect(320, 480, 101, 31))self.pushButton.setObjectName("pushButton")self.pushButton.clicked.connect(self.classify)self.textBrowser = QtWidgets.QTextBrowser(self.centralwidget)self.textBrowser.setGeometry(QtCore.QRect(490, 450, 261, 81))self.textBrowser.setObjectName("textBrowser")self.label = QtWidgets.QLabel(self.centralwidget)self.label.setGeometry(QtCore.QRect(600, 430, 72, 20))self.label.setObjectName("label")self.graphicsView = QtWidgets.QLabel(self.centralwidget)self.graphicsView.setGeometry(QtCore.QRect(140, 70, 531, 331))self.graphicsView.setObjectName("graphicsView")self.label_2 = QtWidgets.QLabel(self.centralwidget)self.label_2.setGeometry(QtCore.QRect(380, 40, 72, 15))self.label_2.setObjectName("label_2")MainWindow.setCentralWidget(self.centralwidget)self.statusbar = QtWidgets.QStatusBar(MainWindow)self.statusbar.setObjectName("statusbar")MainWindow.setStatusBar(self.statusbar)self.menuBar = QtWidgets.QMenuBar(MainWindow)self.menuBar.setGeometry(QtCore.QRect(0, 0, 800, 26))self.menuBar.setObjectName("menuBar")self.menu = QtWidgets.QMenu(self.menuBar)self.menu.setObjectName("menu")MainWindow.setMenuBar(self.menuBar)self.localfile_action = QAction(MainWindow)self.localfile_action.setCheckable(False)self.localfile_action.setObjectName('localFileAction')self.localfile_action.triggered.connect(self.openImg)self.localfile_action.setText('输入图片')self.menuBar.addAction(self.localfile_action)self.retranslateUi(MainWindow)QtCore.QMetaObject.connectSlotsByName(MainWindow)def retranslateUi(self, MainWindow):_translate = QtCore.QCoreApplication.translateMainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))self.pushButton.setText(_translate("MainWindow", "识别"))self.label.setText(_translate("MainWindow", "结果"))self.label_2.setText(_translate("MainWindow", "图片"))def openImg(self):file_name, _ = QFileDialog.getOpenFileName(None, '选择图片', 'D:\\', 'Image files(*.jpg *.gif *.png)')self.graphicsView.setPixmap(QPixmap(file_name))self.img_dir = file_namedef classify(self,img_dir):model = load_model()img_dir = self.img_dircategories = ['猫','狗']img = (Image.open(img_dir)).resize((224,224),Image.ANTIALIAS)img = ((np.array(img)).reshape(1,224,224,3))/255pred = model.predict(img)if pred.size > 1:name = categories[np.argmax(pred)]confidence = str(pred[0][np.argmax(pred[0])])else:if pred[0][0] < 0.5:name = '猫'confidence = str(1-pred[0][0])else:name = '狗'confidence = str(pred[0][0])self.textBrowser.setText('预测结果为：'+name+'\n置信度为：'+confidence)

最终结果如图所示

使用卷积神经网络（普通CNN和改进型LeNet）以及数据增强和迁移学习技巧识别猫和狗，并制作成分类器软件（基于Keras）相关推荐

2020-10-08 吴恩达-C4 卷积神经网络-w2 CNN实例探究(课后编程1-Keras tutorial - the Happy House-笑脸识别)
原文链接卷积神经网络实例探究 Keras tutorial - the Happy House-笑脸识别为什么要使用Keras? 1- 开心屋 2- 在Keras中构建模型 3- 总结 4- 用你 ...
一维卷积神经网络直接读取mat文件并进行数据增强和归一化
众多师弟师妹在使用一维卷积神经网络对凯斯西储,哥伦比亚等大学开源的轴承故障数据集进行故障诊断时,不知道该怎么把Matlab文件中的数据直接导进伸进网络进行训练.我之前也不会,我一直用matlab打开数 ...
（论文加源码）基于DEAP和MABHOB数据集的二分类脑电情绪识别（pytorch深度神经网络（DNN）和卷积神经网络（CNN））代码解析
论文解析见个人主页: https://blog.csdn.net/qq_45874683/article/details/130000469?csdn_share_tail=%7B%22type%22 ...
keras构建卷积神经网络（CNN(Convolutional Neural Networks)）进行图像分类模型构建和学习
keras构建卷积神经网络(CNN(Convolutional Neural Networks))进行图像分类模型构建和学习全连接神经网络(Fully connected neural networ ...
机器学习——深度学习之卷积神经网络（CNN）——AlexNet卷积神经网络结构
目录一.AlexNet卷积神经网络结构模型 1.数据库ImageNet 2.AlexNet第一层卷积层二.AlexNet卷积神经网络的改进 1.非线性变化函数的改变--ReLU 2.最大池化(Ma ...
卷积神经网络（CNN）超详细介绍
文章转自:https://blog.csdn.net/jiaoyangwm/article/details/80011656 文章目录 1.卷积神经网络的概念 2. 发展过程 3.如何利用CNN实现图 ...
卷积神经网络（CNN）详细介绍及其原理详解
文章目录前言一.什么是卷积神经网络二.输入层三.卷积层四.池化层五.全连接层六.输出层七.回顾整个过程总结前言本文总结了关于卷积神经网络(CNN)的一些基础的概念,并且对于其中的 ...
TensorFlow2.0 学习笔记（三）：卷积神经网络（CNN）
欢迎关注WX公众号:[程序员管小亮] 专栏--TensorFlow学习笔记文章目录欢迎关注WX公众号:[程序员管小亮] 专栏--TensorFlow学习笔记一.神经网络的基本单位:神经元二.卷 ...
今日学习——卷积神经网络（CNN）
文章目录一.空间不变性和局部性二.边界检测--一个小例子感受卷积三.CNN里的一些概念 1. padding 2. stride 步长 3. pooling 池化 4. 多通道卷积 5. 1x1 ...

使用卷积神经网络（普通CNN和改进型LeNet）以及数据增强和迁移学习技巧识别猫和狗，并制作成分类器软件（基于Keras）

使用卷积神经网络（普通CNN和改进型LeNet）以及数据增强和迁移学习技巧识别猫和狗，并制作成分类器软件（基于Keras）相关推荐

最新文章

热门文章