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

1047521767

                                                   使用卷积神经网络开发图像分类模型
简介
  G6 F( f- t: R% z* C" ~, O, `8 ]
这篇文章是关于卷积网络、它的工作和组件: 在本文中，我们将使用卷积神经网络执行图像分类，并详细了解所有步骤。因此，如果你对此不熟悉，请继续阅读。
! p) O+ L  b' n* @: ]  V( C& `
/ V& @3 l* s6 Q3 L简而言之，CNN 是一种深度学习算法，也是适用于图像和视频的神经网络类型之一。我们可以从 CNN 中实现各种功能，其中一些是图像分类、图像识别、目标检测、人脸识别等等。

今天，我们将对CIFAR10 数据集执行图像分类，它是 Tensorflow 库的一部分。它由各种物体的图像组成，如船舶、青蛙、飞机、狗、汽车。该数据集共有 60,000 张彩色图像和 10 个标签。现在让我们进入编码部分。
. ^! h; F, k; @3 {! L9 F
6 @8 j  _1 G& i* _实施

$ |7 u: \1 Q$ V9 E* u# importing necessary libraries
6 O& C) e- v/ C/ Kimport numpy as np
! p- l! c( V% p" T% S0 j, n+ kimport matplotlib.pyplot as plt
) \# `6 t# ^, ]" k3 N! l% X) h%matplotlib inline
# To convert to categorical data
from tensorflow.keras.utils import to_categorical
#libraries for building model
from tensorflow.keras.models import Sequential
* V8 q; ^7 i$ k# }# }from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Dropout,Flatten
4 t+ H6 g) i0 x: A9 `  F/ Tfrom tensorflow.keras.datasets import cifar10

. f5 J( z6 ~* f/ w#loading the data
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

探索性数据分析
#shape of the dataset
6 A( d/ m  u' V9 T) }. Y, mprint(X_train.shape)
print(y_train.shape)
print(X_test.shape)
0 m/ E. \9 s1 N2 sprint(y_test.shape)
& i& c  i# s7 V* _

我们的训练数据有 50,000 张图像，测试数据有 10,000 张图像，大小为 32*32 和 3 个通道，即 RGB（红、绿、蓝）
, U! ]* y) ], }, C9 z& \+ J; j#checking the labels
np.unique(y_train)
$ e, t0 @, e" A8 h( t
" s4 ]( \& [& [' z: g2 x4 ]" L
( w5 q8 L- J- c1 C* M* d$ ^#first image of training data
1 I  o  _4 ^$ f6 E" d9 a% G2 Fplt.subplot(121)
" r$ r7 m; }4 P3 Y( B' L  Oplt.imshow(X_train[0])
plt.title("Label : {}".format(y_train[0]))
3 e( G" b7 z) F2 B/ A3 B#first image of test data
/ k& C( d# `, ]/ B- b7 `/ Iplt.subplot(122)
/ k# G) z$ {3 r) u$ I) j5 `plt.imshow(X_test[0])
% C/ f9 y' l! B7 |plt.title("Label : {}".format(y_test[0]));
, X/ s' F$ F1 m2 _& G& y! J% v
7 H, a" H( x' |9 I  S* g" U
) X8 @: ^: V! u$ ^! b3 r( d* i$ g#visualizing the first 20 images in the dataset
for i in range(20):
    #subplot
, p: [. K" m* _' @* [& J" H    plt.subplot(5, 5, i+1)
+ ?2 i9 ?0 e* m# u( `+ L2 |    # plotting pixel data
    plt.imshow(X_train, cmap=plt.get_cmap('gray'))
# show the figure
plt.show()
* K4 h+ w4 ^% M4 P
) f4 E5 e3 X4 N$ y( A4 W
预处理数据

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

6 W6 |$ E) Y( x6 l1 Z9 p$ f# Scale the data to lie between 0 to 1
1 J; c7 o! f0 G/ I$ Z. K8 @X_train = X_train/255
X_test = X_test/255
) `4 \+ R" E1 S- T5 ?print(X_train)
8 D3 ^# t5 l9 H/ W/ x% B

0 e) M) h+ B, H) @#reshaping the train and test lables to 1D
y_train = y_train.reshape(-1,)
y_test = y_test.reshape(-1,)
1 h% m4 \, v8 l# j/ a5 S
我们在上图中可以看到，图像的像素值已经进行了缩放，其数值在 0 到 1 之间，并且标签也进行了重塑。数据已准备好建模，现在让我们构建 CNN 模型。
3 Z! `- b9 s1 y1 L. |2 W模型搭建

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

5 {& y) k1 m$ W; j0 ]model=Sequential()
#adding the first Convolution layer
: S/ w+ ~5 O. J" x7 m& vmodel.add(Conv2D(32,(3,3),activation='relu',input_shape=(32,32,3)))
2 L7 s) y) \$ W3 F5 Z#adding Max pooling layer
model.add(MaxPool2D(2,2))
#adding another Convolution layer
2 c) Z$ B4 Q" j! Gmodel.add(Conv2D(64,(3,3),activation='relu'))
model.add(MaxPool2D(2,2))
9 o4 ?% G3 Z& Y; |+ _9 J  B# pmodel.add(Flatten())
$ \5 w# j8 O1 K/ r$ E#adding dense layer
3 z: O6 G1 x8 [% m) Cmodel.add(Dense(216,activation='relu'))
. [. Z. H0 W2 L- O+ O  Z9 L2 e#adding output layer
model.add(Dense(10,activation='softmax'))

我们添加了第一个带有 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/

' V6 S9 U; I5 i3 C6 G然后我们又添加了一个卷积层， 其中包含 64 个大小为(3*3) 的过滤器 和一个大小为 (2*2)的 最大池化层
& v2 G8 b( v2 o5 B3 O- L
在下一步中，我们将层展平以将它们传递到 Dense 层，并添加了一个包含 216 个神经元的Dense 层。
3 R4 @5 h* A5 Q' Y( H  l$ `
最后，输出层添加了一个 softmax 激活函数，因为我们有 10 个标签。

, y3 e9 ^3 `( {8 n6 I' ?第 2 步：编译模型
6 }  P6 R" b6 W7 ?; G. Nmodel.compile(optimizer='rmsprop',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
1 j; h( g7 `- J: x
- D6 b2 E* L& i3 o% h- }# e; q' S  |2 L; W第 3 步：拟合模型model.fit(X_train,y_train,epochs=10)


4 C8 j: R$ J( @. \  H: E& _/ X如上图所示，我们的准确率为 89%，损失为 0.31。让我们看看测试数据的准确性。
$ q+ {; z5 K, M  H0 h第 4 步：评估模型model.evaluate(X_test,y_test)
! ?  g/ E0 ?5 }0 ?2 t
# c2 a$ J4 t; B. w# B
1 {* h- T6 x' K' s# e" ?测试数据的准确率为 69%，与训练数据相比非常低，这意味着我们的模型过度拟合。
第 5 步：进行预测
pred=model.predict(X_test)
#printing the first element from predicted data
3 `$ m+ p0 l9 k, Y- c4 {print(pred[0])
6 {% e6 e# U7 w3 V#printing the index of
print('Index:',np.argmax(pred[0]))
; H( V7 c; {$ O1 N( o1 q6 c/ U
% K* D, _0 M/ B$ g- Y

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

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

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

y_classes = [np.argmax(element) for element in pred]
print('Predicted_values:',y_classes[:10])
print('Actual_values:',y_test[:10])
) y+ P' Y# e4 y

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

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

model4=Sequential()
4 U/ |1 d2 b# G#adding the first Convolution layer
model4.add(Conv2D(32,(3,3),activation='relu',input_shape=(32,32,3)))
#adding Max pooling layer
1 E1 E0 U' ?* X7 G: ymodel4.add(MaxPool2D(2,2))
#adding dropout
" p3 u3 b: }/ smodel4.add(Dropout(0.2))
#adding another Convolution layer
0 \5 S( H- Q3 N. Wmodel4.add(Conv2D(64,(3,3),activation='relu'))
model4.add(MaxPool2D(2,2))
2 ]& ^  n1 h' n1 w+ {) S) m: y#adding dropout
8 `3 k8 {: u3 a7 _  R  J! r- gmodel4.add(Dropout(0.2))
2 p* z% e- x6 I! ]5 e1 amodel4.add(Flatten())
#adding dense layer
# @8 P6 M3 ?: O7 }$ N$ A7 m  Hmodel4.add(Dense(216,activation='relu'))
#adding dropout
( ]' P( ~$ m  O" imodel4.add(Dropout(0.2))
% x5 t( ]# }6 m$ ~3 L, H# Y6 q6 q#adding output layer
model4.add(Dense(10,activation='softmax'))
model4.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
model4.fit(X_train,y_train,epochs=10)

" F1 U$ _1 D# d: V) |3 b
5 c+ d6 {2 B! I: r' jmodel4.evaluate(X_test,y_test)

通过这个模型，我们得到了76%的训练准确率（低于第一个模型），但我们得到了72%的测试准确率，这意味着过拟合的问题在一定程度上得到了解决。

尾注
这就是我们在 Python 中实现 CNN 的方式。这里使用的数据集是一个简单的数据集，可用于学习目的，但一定要尝试在更大和更复杂的数据集上实现 CNN。这也将有助于发现更多挑战和解决方案。



* G. W- d- W3 c2 C1 @) s( `