使用卷积神经网络开发图像分类模型

1047521767

                                                   使用卷积神经网络开发图像分类模型
2 {0 v6 ~. y8 d" k6 d9 m1 ]& I简介

这篇文章是关于卷积网络、它的工作和组件: 在本文中，我们将使用卷积神经网络执行图像分类，并详细了解所有步骤。因此，如果你对此不熟悉，请继续阅读。
2 z5 ?# Q  s4 w5 Q6 D, S$ b
简而言之，CNN 是一种深度学习算法，也是适用于图像和视频的神经网络类型之一。我们可以从 CNN 中实现各种功能，其中一些是图像分类、图像识别、目标检测、人脸识别等等。
2 w. }) S  \( i5 S3 s( G8 ^3 y
+ K& H) W' p) o, n& Y今天，我们将对CIFAR10 数据集执行图像分类，它是 Tensorflow 库的一部分。它由各种物体的图像组成，如船舶、青蛙、飞机、狗、汽车。该数据集共有 60,000 张彩色图像和 10 个标签。现在让我们进入编码部分。

# E6 g. i+ ~' k# Z, h3 d实施

# importing necessary libraries
9 _# ~0 ]! Z$ v& |7 `. n; ~/ qimport numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
. w1 W, u6 @( A# To convert to categorical data
from tensorflow.keras.utils import to_categorical
4 ^+ ~, i) G! H7 w1 v! c% i3 r: W#libraries for building model
, W4 R( m, i- ifrom tensorflow.keras.models import Sequential
8 f. F* f: E! {5 W9 M5 s  ^. gfrom tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Dropout,Flatten
( c# V) ^. {& B, V( h+ r% I5 Efrom tensorflow.keras.datasets import cifar10
* w) B* n1 \$ B
#loading the data
4 d- j& ], |/ y" p5 a& L(X_train, y_train), (X_test, y_test) = cifar10.load_data()

探索性数据分析
9 x6 H2 N: P: o#shape of the dataset
print(X_train.shape)
print(y_train.shape)
9 I/ H0 a6 U# E; V1 {5 @3 tprint(X_test.shape)
3 f# G/ k- o8 j6 v8 yprint(y_test.shape)
* o0 d- T5 b+ X2 s/ s
$ P% Y8 z; X" k  M
/ B  K' E+ \1 I- i2 Q我们的训练数据有 50,000 张图像，测试数据有 10,000 张图像，大小为 32*32 和 3 个通道，即 RGB（红、绿、蓝）
, s. T, P. P* x7 Q#checking the labels
np.unique(y_train)


#first image of training data
plt.subplot(121)
: @$ p- F. P& u5 G: R! aplt.imshow(X_train[0])
: o$ M1 a4 u' t0 t" {0 Wplt.title("Label : {}".format(y_train[0]))
$ y9 y" R# Y# @$ Y6 f  g  \#first image of test data
  I- ~* Y  p$ F5 Nplt.subplot(122)
4 G3 ~1 ]9 d) D7 S0 Lplt.imshow(X_test[0])
plt.title("Label : {}".format(y_test[0]));


#visualizing the first 20 images in the dataset
for i in range(20):
    #subplot
    plt.subplot(5, 5, i+1)
- p" }* P5 i  `. l/ S    # plotting pixel data
* W9 P2 H7 e6 u* Z8 Q7 `2 P    plt.imshow(X_train, cmap=plt.get_cmap('gray'))
# show the figure
plt.show()
7 B/ j7 {5 Y: B6 S

预处理数据

对于数据预处理，我们只需要在这里执行两个步骤，首先是缩放图像的像素值到0到1之间，然后是将标签从 2D 重塑为 1D

# Scale the data to lie between 0 to 1
8 ]9 S0 S& l- @8 nX_train = X_train/255
0 k$ k" R  C  B9 u9 e2 x  h0 XX_test = X_test/255
print(X_train)

# t6 A% m( Q2 m4 X7 G
5 f; h+ a- ?" w# k) y1 d; g/ ~#reshaping the train and test lables to 1D
y_train = y_train.reshape(-1,)
y_test = y_test.reshape(-1,)
3 O6 |, k1 t7 i/ t6 |8 R3 y
: m0 w3 S1 A5 C' I我们在上图中可以看到，图像的像素值已经进行了缩放，其数值在 0 到 1 之间，并且标签也进行了重塑。数据已准备好建模，现在让我们构建 CNN 模型。
模型搭建

正如我们之前讨论的，深度学习模型的构建分为 5 个步骤，即定义模型、编译模型、拟合模型、评估模型和进行预测，这也是我们在这里要做的。

/ g% C6 O9 L% w2 Smodel=Sequential()
+ N/ k3 F5 y0 h#adding the first Convolution layer
/ ]5 P8 X4 Q( s( L+ O: zmodel.add(Conv2D(32,(3,3),activation='relu',input_shape=(32,32,3)))
1 N; }# p7 f! U/ |#adding Max pooling layer
  E# o0 ]2 V& Q5 \% Emodel.add(MaxPool2D(2,2))
#adding another Convolution layer
model.add(Conv2D(64,(3,3),activation='relu'))
' L* d' K$ L' i& q4 N6 j9 Imodel.add(MaxPool2D(2,2))
model.add(Flatten())
: x' h  `; I$ c* y" V' a2 \0 A3 }7 D#adding dense layer
  b/ P: C8 A, ^1 u! q$ y& Xmodel.add(Dense(216,activation='relu'))
#adding output layer
( S" E7 M! s2 U+ r. Fmodel.add(Dense(10,activation='softmax'))
7 z# Y- S! F6 f5 n
9 b  t6 V9 u' ]# {* f: a我们添加了第一个带有 32 个大小为 (3*3) 的过滤器的卷积层，使用的激活函数是 Relu，并为模型提供输入形状。

接下来添加了大小为 (2*2)的Max Pooling 层。最大池化有助于减少维度。CNN 组件的解释请参考：https://www.analyticsvidhya.com/blog/2021/08/beginners-guide-to-convolutional-neural-network-with-implementation-in-python/

然后我们又添加了一个卷积层， 其中包含 64 个大小为(3*3) 的过滤器 和一个大小为 (2*2)的 最大池化层
8 F4 s, x7 ?# f6 R2 A. r8 j
在下一步中，我们将层展平以将它们传递到 Dense 层，并添加了一个包含 216 个神经元的Dense 层。
4 Z5 o- i! T8 w  ~3 B5 e+ G
最后，输出层添加了一个 softmax 激活函数，因为我们有 10 个标签。

第 2 步：编译模型
2 D+ h0 k) ^7 r/ W8 I+ X' |4 imodel.compile(optimizer='rmsprop',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
( H- X& e3 W( W7 x$ w
第 3 步：拟合模型model.fit(X_train,y_train,epochs=10)
) C1 e0 E3 j3 T& c9 w0 k2 c
% w5 n' E8 y" y
  k* h7 {+ ^# _) l# A如上图所示，我们的准确率为 89%，损失为 0.31。让我们看看测试数据的准确性。
第 4 步：评估模型model.evaluate(X_test,y_test)


; I$ j, C8 W  Q" `  a测试数据的准确率为 69%，与训练数据相比非常低，这意味着我们的模型过度拟合。
# g9 G/ O% }) r8 [8 Q第 5 步：进行预测
1 Z' }, M1 Q3 j4 S) r) I" npred=model.predict(X_test)
#printing the first element from predicted data
print(pred[0])
* r) Z- ?* \0 S8 p- z+ L#printing the index of
+ B2 M7 x4 ~, a: ]7 b% }print('Index:',np.argmax(pred[0]))
5 l) v1 E& {+ M; O  O8 g2 I% R
5 Z  o. D7 S6 U1 M1 b
; |& }& g( O7 H2 t! q

因此，预测函数给出的是所有10个标签的概率值，概率最高的标签是最终预测。在我们的例子中，我们得到了第三个索引处的标签作为预测。

将预测值与实际值进行比较以查看模型执行的正确程度。

在下图中，我们可以看到预测值与实际值的差异。

y_classes = [np.argmax(element) for element in pred]
print('Predicted_values:',y_classes[:10])
print('Actual_values:',y_test[:10])

当我们看到我们的模型过度拟合时，我们可以使用一些额外的步骤来提高模型性能并减少过度拟合，例如向模型添加 Dropouts或执行数据增强，因为过度拟合问题也可能是由于可用数据量较少。

在这里，我将展示我们如何使用 Dropout 来减少过拟合。我将为此定义一个新模型。

7 m/ W* G4 [  J2 t% nmodel4=Sequential()
#adding the first Convolution layer
model4.add(Conv2D(32,(3,3),activation='relu',input_shape=(32,32,3)))
, R0 H/ T8 u! \, j& I* b, v#adding Max pooling layer
" U0 ?, o% f8 D6 X" |model4.add(MaxPool2D(2,2))
#adding dropout
! X. c2 w0 s5 F; m( Q2 Qmodel4.add(Dropout(0.2))
4 c7 B# M% @0 k. B7 o$ W#adding another Convolution layer
/ c) i' M% |; I7 J; lmodel4.add(Conv2D(64,(3,3),activation='relu'))
model4.add(MaxPool2D(2,2))
#adding dropout
model4.add(Dropout(0.2))
model4.add(Flatten())
; _7 R1 [' D0 O. L& A: `3 \- F#adding dense layer
* t  k% y0 u2 @0 F+ bmodel4.add(Dense(216,activation='relu'))
: g. u5 `7 N3 T#adding dropout
1 w7 l6 e+ w2 H: @$ F. hmodel4.add(Dropout(0.2))
#adding output layer
. E8 M( H9 P$ l1 Wmodel4.add(Dense(10,activation='softmax'))
/ l# {: B7 e4 x) `model4.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
7 R8 Y( y$ \5 r9 n+ H3 jmodel4.fit(X_train,y_train,epochs=10)
# n. t% t5 n% T, T

model4.evaluate(X_test,y_test)
6 ?" i3 d* w  h+ M  N7 B+ m
8 q  k4 V5 ~$ i% S. V* E通过这个模型，我们得到了76%的训练准确率（低于第一个模型），但我们得到了72%的测试准确率，这意味着过拟合的问题在一定程度上得到了解决。

1 k& w. D  t; a3 W7 G尾注
8 J5 f* E5 K; j4 t3 b这就是我们在 Python 中实现 CNN 的方式。这里使用的数据集是一个简单的数据集，可用于学习目的，但一定要尝试在更大和更复杂的数据集上实现 CNN。这也将有助于发现更多挑战和解决方案。
+ j9 `7 f# Y6 T' P
' D' J! f! q0 L4 a& o7 |/ R
9 w( Q% k- `! x: o) w* L