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

1047521767

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

% C# i- w: J  f( F# |" @这篇文章是关于卷积网络、它的工作和组件: 在本文中，我们将使用卷积神经网络执行图像分类，并详细了解所有步骤。因此，如果你对此不熟悉，请继续阅读。

1 i0 l6 @) U+ N1 Y) Y简而言之，CNN 是一种深度学习算法，也是适用于图像和视频的神经网络类型之一。我们可以从 CNN 中实现各种功能，其中一些是图像分类、图像识别、目标检测、人脸识别等等。

% b, P) Z2 a) |. F今天，我们将对CIFAR10 数据集执行图像分类，它是 Tensorflow 库的一部分。它由各种物体的图像组成，如船舶、青蛙、飞机、狗、汽车。该数据集共有 60,000 张彩色图像和 10 个标签。现在让我们进入编码部分。

实施

; T# H* e- z% |2 H* q/ V# importing necessary libraries
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# To convert to categorical data
from tensorflow.keras.utils import to_categorical
#libraries for building model
9 l- B$ s  W" |9 k0 ^/ T  Z" D7 efrom tensorflow.keras.models import Sequential
  @5 C0 j5 s( @  Efrom tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Dropout,Flatten
; l7 S. A7 W$ Mfrom tensorflow.keras.datasets import cifar10

#loading the data
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

探索性数据分析
; ^: i5 O" Q$ v, p#shape of the dataset
. G8 L9 S0 h% O7 |% a* \print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)


" ?- j6 c4 d; X1 ~$ S+ W0 p我们的训练数据有 50,000 张图像，测试数据有 10,000 张图像，大小为 32*32 和 3 个通道，即 RGB（红、绿、蓝）
#checking the labels
np.unique(y_train)
% {2 S# Y4 Y0 M( S
0 C' E8 @1 V6 s0 c8 v2 M
#first image of training data
plt.subplot(121)
plt.imshow(X_train[0])
6 v; H) Q/ A+ v( V* uplt.title("Label : {}".format(y_train[0]))
#first image of test data
* y! F) F2 B2 `, n% splt.subplot(122)
plt.imshow(X_test[0])
plt.title("Label : {}".format(y_test[0]));


#visualizing the first 20 images in the dataset
! p" E0 ?) P3 \0 H8 H, U/ afor i in range(20):
" [, l3 v( Y3 w    #subplot
# e0 ?1 j" J! O0 j& f- @! t8 ]    plt.subplot(5, 5, i+1)
+ z" ?4 E1 Y' x    # plotting pixel data
( l" Z9 R: @. Z" u; r& E    plt.imshow(X_train, cmap=plt.get_cmap('gray'))
* P9 ], h. ?2 H( T& l# show the figure
; e9 s' b, H9 _( C2 Iplt.show()

1 p2 ^& L4 t1 i
预处理数据

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

+ u* m" s; I' i5 I" {# Scale the data to lie between 0 to 1
X_train = X_train/255
4 O( y8 n# g9 o6 u8 }" k2 IX_test = X_test/255
print(X_train)
, U; J0 x4 p( m! H7 h
9 _6 f" l/ K6 C$ ?" L: E) r
2 l+ g& ?7 F+ D4 h' u4 Q#reshaping the train and test lables to 1D
y_train = y_train.reshape(-1,)
y_test = y_test.reshape(-1,)

+ X6 O2 n+ i, i  c( t5 z. z我们在上图中可以看到，图像的像素值已经进行了缩放，其数值在 0 到 1 之间，并且标签也进行了重塑。数据已准备好建模，现在让我们构建 CNN 模型。
模型搭建

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

model=Sequential()
#adding the first Convolution layer
* @0 w* ?: u; n0 smodel.add(Conv2D(32,(3,3),activation='relu',input_shape=(32,32,3)))
#adding Max pooling layer
  G8 z) L& O% t; m8 rmodel.add(MaxPool2D(2,2))
#adding another Convolution layer
4 y- \" g+ q" T9 r& e/ m0 _8 b3 vmodel.add(Conv2D(64,(3,3),activation='relu'))
( F# s3 d; M( D) Lmodel.add(MaxPool2D(2,2))
model.add(Flatten())
" m. C" F- ^, Y6 a7 q3 m#adding dense layer
& c- L8 \. s. s5 cmodel.add(Dense(216,activation='relu'))
#adding output layer
- A1 x, l" B  G/ p# b  kmodel.add(Dense(10,activation='softmax'))

) `, \6 s/ J" E% G* I' V我们添加了第一个带有 32 个大小为 (3*3) 的过滤器的卷积层，使用的激活函数是 Relu，并为模型提供输入形状。
1 z, M( k4 B3 B; m* I1 q; `' a, a
接下来添加了大小为 (2*2)的Max Pooling 层。最大池化有助于减少维度。CNN 组件的解释请参考：https://www.analyticsvidhya.com/blog/2021/08/beginners-guide-to-convolutional-neural-network-with-implementation-in-python/
% b1 x9 D0 }8 c) G2 V
然后我们又添加了一个卷积层， 其中包含 64 个大小为(3*3) 的过滤器 和一个大小为 (2*2)的 最大池化层
+ ]2 ~( G2 c; w, k% k2 k, i" o3 u
- a/ j& Z4 o- q3 ~& o5 H0 P在下一步中，我们将层展平以将它们传递到 Dense 层，并添加了一个包含 216 个神经元的Dense 层。

" h- y( r# B  L# t! V5 l3 x6 t% d最后，输出层添加了一个 softmax 激活函数，因为我们有 10 个标签。
% S4 q$ C* f  \/ x$ B. q
6 X& |' K# `! Z! p, J% x第 2 步：编译模型
model.compile(optimizer='rmsprop',loss='sparse_categorical_crossentropy',metrics=['accuracy'])

# j# M/ T( d! n3 E第 3 步：拟合模型model.fit(X_train,y_train,epochs=10)
* a; E! w& j6 p

如上图所示，我们的准确率为 89%，损失为 0.31。让我们看看测试数据的准确性。
第 4 步：评估模型model.evaluate(X_test,y_test)
0 _, J( V( r+ C0 [" _& x7 f

* {) D# C  U& L2 B( N! e测试数据的准确率为 69%，与训练数据相比非常低，这意味着我们的模型过度拟合。
第 5 步：进行预测
pred=model.predict(X_test)
3 {# W2 L% ~! y  e) L3 }' k3 q9 ?5 g#printing the first element from predicted data
print(pred[0])
7 t; K8 M0 O* j# o* [#printing the index of
* t6 |  @$ F5 S4 {. @print('Index:',np.argmax(pred[0]))
' @* Q0 f3 }' @5 }( ^

5 y6 N8 {: W+ Z! j0 e; `

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

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

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

y_classes = [np.argmax(element) for element in pred]
% v4 K( y; o$ U+ D% p3 N- mprint('Predicted_values:',y_classes[:10])
% M0 g  j8 G& y% \# A0 {0 xprint('Actual_values:',y_test[:10])
1 F# P9 y" e- v

, ?: ]- s( [2 D1 V5 G

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

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

% O) L$ m3 }( {  A+ Y- u( M7 T, v4 emodel4=Sequential()
% C2 w8 I1 z" e5 K' Q) i/ q: U  K#adding the first Convolution layer
# K* a# H! S; U1 I' _3 Pmodel4.add(Conv2D(32,(3,3),activation='relu',input_shape=(32,32,3)))
) o7 E2 j" n* y+ \1 O#adding Max pooling layer
model4.add(MaxPool2D(2,2))
. w* D- N5 ]8 ]! O6 A$ k#adding dropout
1 ?$ F5 O: z3 a: {model4.add(Dropout(0.2))
, ~/ n2 P. G* L0 v! s#adding another Convolution layer
model4.add(Conv2D(64,(3,3),activation='relu'))
) J  P: }4 F  a& {0 ?0 Pmodel4.add(MaxPool2D(2,2))
' j7 ~9 \; t9 y/ C: {3 A, S#adding dropout
2 v" _8 b0 B7 z9 ]3 fmodel4.add(Dropout(0.2))
model4.add(Flatten())
6 I2 \7 e; r2 [. c" G; i) \5 P#adding dense layer
model4.add(Dense(216,activation='relu'))
#adding dropout
7 }5 p& H( C9 B) X$ X# U* kmodel4.add(Dropout(0.2))
5 _( v) Y& a" i#adding output layer
# l& e4 F. v0 g6 o- O$ X/ Jmodel4.add(Dense(10,activation='softmax'))
9 c" R5 R' }2 u) s) b# Umodel4.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
- o0 k  q0 B, N' p; C* }" i3 Nmodel4.fit(X_train,y_train,epochs=10)


model4.evaluate(X_test,y_test)

1 P, W7 k1 P, ]& F* f' v1 m9 D' q通过这个模型，我们得到了76%的训练准确率（低于第一个模型），但我们得到了72%的测试准确率，这意味着过拟合的问题在一定程度上得到了解决。
$ b/ {/ B2 h7 I4 p
1 x6 c% \% f6 A3 \8 {尾注
" t  |5 y! P/ e, s( J; {( N( P这就是我们在 Python 中实现 CNN 的方式。这里使用的数据集是一个简单的数据集，可用于学习目的，但一定要尝试在更大和更复杂的数据集上实现 CNN。这也将有助于发现更多挑战和解决方案。