使用乳腺癌数据集的人工神经网络人工神经网络8 s! p7 R- c \# z1 \) K
顾名思义,人工神经网络,就是人工神经元的网络。它指的是模仿大脑的生物启发模型。可以说,构建人脑结构的通常是基于生物神经网络的计算网络。% \; V) j8 @3 A( ?+ d
0 }: L) b- ? k0 s" j* l8 L6 R( x
大家都知道,在我们的大脑中,神经元是相互连接和传递数据的过程。它类似于人脑神经元之间相互连接,神经网络由大量人工神经元组成,称为按层顺序排列的单元。具有各层神经元并形成一个完整的网络。这些神经元被称为节点。! p: v! N5 p. b; W
, T: Y# y) i/ l7 }5 H/ B
它由三层组成,分别是:
1 y; d) }: w, T7 m5 j- L
7 Q- U9 E' c( X# H/ i输入层! m, D) D' {- m+ k
/ G& g& y8 K$ o* E& O& k- g
隐藏层& l! p( q, [% Y, u5 A+ ]0 F% Q6 Y
6 v! U+ e7 w4 q$ ]输出层1 S, y5 b2 K; ^
9 r5 R5 I% m/ Q, n2 Y7 I: @
! Z& P) @( Q8 q& }3 M- F
使用乳腺癌数据集创建ANN
* f0 r0 h/ ^+ u1 u# G) O' n现在我们进入我们的主题,这里我们将采用数据集,然后创建人工神经网络并对诊断进行分类。
7 G. P+ p3 V& u8 M ^" F A1 w5 N
+ d( C3 Z A- y: x( F首先,我们采用乳腺癌的数据集,然后继续前进。
' X: m) t/ x! \* N6 [' }4 P5 O: ?! J* V8 Z" a
乳腺癌数据集:https://www.kaggle.com/uciml/breast-cancer-wisconsin-data8 U2 q! }" K0 i. |4 Y9 h
% P& v( I" g- X8 ~% b5 z下载数据集后,我们将导入所需的重要库。/ o. E" q2 y# W% j* c
; A8 I% M: U# `$ h5 q# \$ k1 ~# q" `. U
导入库
; T: h1 o' [. R8 A" C#import pandas* Q: ?" ^ L# o3 {1 |
import pandas as pd# d [- G k: N7 u; Y# o
#import numpy
* ?: I1 m7 B0 z: }! } g( S& aimport numpy as np% b0 J# P) ?6 t
import matplotlib.pyplot as plt
; L2 C+ V: Z4 f H" r! ?- Gimport seaborn as sb9 j# x+ `/ L& e# d3 ~' h
这里我们导入了 pandas、NumPy 和一些可视化库。
6 j/ \5 ~ {+ e; m$ d' p现在我们使用pandas加载我们的数据集: + s1 r* Q6 y) u( p t7 Y, a$ H
df = pd.read_csv('Breast_cancer.csv')
- R) V- m+ C$ Q3 qdf8 ?& b, o) N( `1 B# ?
![]()
+ V7 ?" u2 x% d2 t+ Y9 h# v
0 X9 X1 r7 o6 C2 N" v5 J+ e' T: s* B在此数据集中,我们指向**“diagnosis”**特征列,因此我们使用 Pandas 检查该列的值计数:5 \/ z ]2 C5 \3 Y0 V
9 [! U) L% R) O* a8 v# counting values of variables in 'diagnosis'
2 p* E+ f8 b0 g2 mdf['diagnosis'].value_counts()
5 M. W/ S& J* u ![]()
0 H4 y3 B( t% g* k* A3 h
' G. n" B" M" ^4 X现在为了更好地理解,我们可视化“diagnosis列”的值计数。 可视化值计数" F. J* }( a5 t: z7 N6 c. b x: M* r
plt.figure(figsize=[17,9])
! M! |% l5 Z# m; Z6 i5 T+ p9 G+ _7 Isb.countplot(df['diagnosis'].value_counts())
^6 `. Z7 v2 \plt.show()
" v1 R, O S O" D% z, o1 i " c7 Z2 u( ?. F$ \0 `
8 Q W; G+ y7 f% s/ ]7 g
空值在数据集中,我们必须检查我们使用pandas的变量中是否存在空值:
7 }; x" v d; M2 ^' }1 bdf.isnull().sum()
* j+ q; X8 l5 ]+ @+ a) n- Q 执行程序后,我们得出结论,特征名称“Unnamed:32”包含所有空值,因此我们删除该列。
6 Q( Y# B3 s1 K( w' x
/ U/ l8 l9 J0 ]. P% k) A/ R- s' e#droping feature* s9 B7 c, Z3 m: ~/ Z. [/ `2 J
df.drop(['Unnamed: 32','id'],axis=1,inplace=True)
* e+ W4 I" m: a6 t: w* |: g0 K( b7 S) i" V: [& q9 V
自变量和因变量现在是时候将数据集划分为自变量和因变量了,为此我们创建了两个变量,一个代表自变量,另一个代表因变量。 4 {, S# t& J2 |! d K- P% Q2 y
# independent variables
$ V5 q9 R; e+ m# x1 ]x = df.drop('diagnosis',axis=1)7 _" L2 N; k- R* R
#dependent variables. N5 D* W* H" O" B
y = df.diagnosis8 x) u8 s; I M
处理分类值
! o! h$ P6 M4 f4 a当我们打印因变量y 时,我们看到其中包含分类数据,我们必须将分类数据转换为二进制格式以进行进一步处理,因此我们使用 Scikit learn Label Encoder 对分类数据进行编码。
2 t# Q! X2 T( _6 w( Q9 J" K9 x% w1 j
from sklearn.preprocessing import LabelEncoder2 H& g- H( l& t( {* Y
#creating the object
8 m( w! {7 o- O6 Y, ]" N! vlb = LabelEncoder() i2 ]& U7 i* e3 z' Z
y = lb.fit_transform(y)
7 k8 j: z; S2 s5 {% R# |! O/ d8 C9 G) p
拆分数据) w) b0 Q4 I2 S0 Q' j8 `& A
现在是时候将数据拆分为训练和测试部分了: R6 O. }$ E! `8 c
% n& ^% n E C, z1 Bfrom sklearn.model_selection import train_test_split
3 N& @# I2 i0 G% G/ `xtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3,random_state=40)
. \; {/ b y1 T% M
2 t H6 u" v3 q) H4 y0 ?$ c& P( x; b缩放数据
8 b7 i$ @$ {1 h+ z当我们创建人工神经网络时,我们必须将数据缩放为更小的数字,因为深度学习算法将节点的权重和输入数据相乘,这需要大量时间,因此为了减少该时间,我们缩放数据。
5 P1 R; }" ?6 X5 g5 h# R4 Y
' M3 C+ P6 ?, o/ ^& J$ P& }对于缩放,我们使用 scikit learn StandardScaler模块,我们缩放训练和测试数据集:
6 w4 T# f, @! C" L0 Y4 s/ u0 k0 {& s- o+ g
#importing StandardScaler
% E/ b) p) L" [& ?0 qfrom sklearn.preprocessing import StandardScaler
* H# _ Y8 z' V7 G: y( F#creating object) r! E- l: Z; W1 n# h
sc = StandardScaler()
6 X( r- Y2 p' ~8 xxtrain = sc.fit_transform(xtrain)) _$ y# ?7 c$ _' Z+ X$ O
xtest = sc.transform(xtest): { T: a9 W! M% M7 i2 ^& ]/ F
3 `, ?5 s9 p5 }! r3 S. Y
从这里我们开始创建人工神经网络,为此我们导入用于创建 ANN 的重要库:7 Q6 a1 v3 r8 J" \4 j
c0 u) h4 p, H1 I5 N& Y
#importing keras6 z* l/ R9 G! W Y3 q8 k
import keras
- e! T( A: R* P; v4 h( x+ l p#importing sequential module
! a0 b$ l/ m: c! Kfrom keras.models import Sequential
. V1 ?3 U4 {. y* E) _: i# F" N3 x# import dense module for hidden layers
4 u T0 Y# M' o+ C" Nfrom keras.layers import Dense
" b! ]- Z1 r8 U! L$ X1 _7 P#importing activation functions
4 n0 M" ^6 ^& B3 L3 pfrom keras.layers import LeakyReLU,PReLU,ELU
4 G; h6 Q, b, {& \4 @% _4 {5 jfrom keras.layers import Dropout+ C, R% n6 ~& p
! s# w% x* r2 q! V6 u* a创建层2 Q- e6 [$ N6 A: y$ W
导入这些库后,我们创建了三种类型的层:
5 J6 f- N' n9 g0 ?% `5 |+ Z" ?, j$ j* P
输入层
1 M& A" ]) {6 q' c6 I$ @' e2 y! e& }9 v2 P) d( ?' j0 r8 e
隐藏层
6 {( l2 a# W; C- Z" X* [ `2 |! V2 D j/ P& L
输出层" ?1 T8 {8 I6 e6 K% v* S; _+ S
' d# G- n% x i6 N首先,我们创建模型:2 F5 R1 m. `$ E; U: U
, f! w5 }0 u- w# v W1 g- D9 A& J#creating model# @. U z5 J# E4 u& W# v
classifier = Sequential()) A! h* m' b. E9 x
" P' s. f$ ~* \% Y& c5 e+ S/ v
Sequential模型适用于每一层恰好有一个输入张量和一个输出张量的平面堆栈。) u B/ G0 g1 }! l4 G
7 ~ o) B# z0 u$ T/ a3 p现在我们创建神经网络的层:
3 }8 M" f( K& ?9 g% s. X. H) f4 P. ~: D. r1 p" Q
#first hidden layer; s6 r1 _1 a2 M9 P: R) j
classifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu',input_dim=30))4 u# v0 f% L+ a
#second hidden layer- a; \- B u. G4 G
classifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu'))' ]+ \. M! e! Z) G
# last layer or output layer
% K# F( [( O' {) k4 K; \( nclassifier.add(Dense(units=1,kernel_initializer='glorot_uniform',activation='sigmoid'))0 q$ w6 M2 C8 |: c/ O& b
6 [6 |- E2 K: z- h
在以下代码中,使用 Dense 方法创建图层,因为我们使用基本参数。
. c( E7 c$ x+ c% A6 o: n, @
, y. R8 s( ^0 A E, R) E% {3 e第一个参数是输出节点
7 s1 M4 Q8 V7 c( t5 l) U; |; l) y z$ D9 _" M4 A1 n
第二个是内核权重矩阵的初始化器. C' F1 r4 p* Y" l/ F
2 A: O- _7 k# A9 R+ O- E. z9 P" H第三个是激活函数4 W! v. @. ?4 a. Y
- X- X, R& p1 x: Z8 D
最后一个参数是输入节点或独立特征的数量。9 z" N( K/ X9 h1 y* [5 u
, B* H4 W0 d1 w% S& p
执行此代码后,我们使用以下方法对其进行总结:
$ k2 ?. n7 z( `$ a#taking summary of layers
9 @+ ~* @* @+ Q% l" f3 }classifier.summary()
2 I8 Y. r, c w8 ~ 4 s9 T4 I" a* _* t
8 s, @+ k/ H% P T; h, ^编译人工神经网络& U9 \! k1 [5 I) m* n% L& A
现在我们用优化器编译我们的模型:
7 n' l' M d/ [9 g4 l* l. R3 l Q# d' O
#compiling the ANN7 ~* y. l2 |# Y; ?+ @! H& |1 H
classifier.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])
) C- P0 ~# T; o2 Y7 Y' \9 v4 T! o' Y0 x7 V
将 ANN 拟合到训练数据中
' p9 L& N" F& K$ j+ E8 P7 B' j! L编译模型后,我们必须将 ANN 拟合到训练数据中以进行预测:
+ k8 @- a+ X5 Y
- _# n& Y$ ^% G- \0 e #fitting the ANN to the training set! T- x0 e5 V& C. I# C; p
model = classifier.fit(xtrain,ytrain,batch_size=100,epochs=100)( ]" z$ ~0 r) H, r! ? H
* O0 {. g" s+ V" X: U
: c. C0 z& V+ X6 P) K7 Git()方法将神经网络与训练数据进行拟合,在参数中设置batch_size、epochs等变量的具体值。
7 J8 d3 K9 j2 J' O
0 u/ @* W) F5 B9 h2 T; \- l在训练数据之后,我们还要对测试数据的准确性评分进行测试,如下所示:7 A4 j5 @% D. Z
; K+ B! F N& F1 s% z8 P
#now testing for Test data
% ]1 v, E1 o( ?6 Ry_pred = classifier.predict(test)/ J. G( Q6 J1 _. N# r/ Q* D% R
$ G- U; t/ R1 p# T
在执行此代码时,我们发现 y_pred 包含不同的值,因此我们将预测值转换为阈值,如True, False。" |0 j" c- Q* @
N* d5 Y0 B, ]( P#converting values
* T" W8 e- n, x2 G6 J$ d7 H3 F- qy_pred = (y_pred>0.5)
0 G- {7 h4 r6 c3 Z! Hprint(y_pred)
; ^& T, h8 j0 m) p1 E
( f# k( V) @7 a6 r- z) z) h c9 N( r- \6 l( Z
C7 y5 P* }6 G- u分数和混淆矩阵& |. O$ l0 \+ O- G
现在我们检查混淆矩阵和预测值的分数。. K0 v- }" W% t
$ D+ c* u* L( r6 z: Q6 x; x. C8 Lfrom sklearn.metrics import confusion_matrix
) h9 p: b3 I8 ufrom sklearn.metrics import accuracy_score
' H$ M' k# r6 @cm = confusion_matrix(ytest,y_pred)3 l8 e1 V2 G% k) Q: d; c. H
score = accuracy_score(ytest,y_pred)+ ^7 ^, q) x* F6 l5 k
print(cm)
/ G+ O' t- w; s9 v6 Kprint('score is:',score)2 ?' D- i2 c7 r2 O) m
( {' \% ~, o! x* j
输出:
, F3 @4 x0 n& D
% F# [0 x. m7 g
U* m; {" ~- I9 A% r* R5 w$ F: z& l
可视化混淆矩阵
. h( P# B( ]) A" p0 H在这里,我们可视化预测值的混淆矩阵
! c! r6 o& k/ p/ Z9 }. C" |
5 O5 _' \, b0 }+ M3 N# creating heatmap of comfussion matrix
0 Z) z6 o. `4 L3 S- ]plt.figure(figsize=[14,7]). [7 D# d, e9 t
sb.heatmap(cm,annot=True)
8 \+ ~. {, _0 u7 {1 lplt.show()1 a( c4 E; R# \% ^- Z8 `
7 M- Y9 _% C' b![]()
& E; h+ `7 u8 \6 R5 Z4 k, T
& Q% E% V7 g6 S3 u( ^% m可视化数据历史
+ C/ p1 y' f" y& N现在我们可视化每个时期的损失和准确性。
4 R% P# B7 {1 ?+ B J6 t4 V* B: r3 Z5 W- W, G2 t
# list all data in history6 h- a/ P8 M& ?" y, g; S8 k
print(model.history.keys())
' @$ \) d/ B0 u( M" p0 T! }# summarize history for accuracy" D4 x# }8 v7 k g, P
plt.plot(model.history['accuracy']) J, U. I ^8 g$ ^# n+ {. X
plt.title('model accuracy')
! [* T; ~ n7 n" Xplt.ylabel('accuracy')+ L) R: r- g$ `, s. p* |3 I0 x9 r
plt.xlabel('epoch')& m7 F6 Y; p! D# }5 Q/ e
plt.legend(['train', 'test'], loc='upper left')- u" p- n" t0 R& f6 ]* L3 h9 v7 q
plt.show()
5 I% |/ ~* N8 K ] ^0 ?) a" y4 l, ?- m& o( F
. u# n7 ?. L9 Q6 X* n+ T9 z
S8 k6 m7 F' ]& @7 Z3 ^" {
4 L, [9 ^# m$ \7 x& h
# summarize history for loss
8 Q" A0 g2 c/ U/ U U/ z5 Nplt.plot(model.history['loss'])1 {" L8 `7 U6 C7 D- E
plt.title('model loss')
7 s7 i3 j5 I+ Q @+ S- M; W" Zplt.ylabel('loss')
" o( w, i6 t2 B8 y2 \! i+ e* ]plt.xlabel('epoch')+ f. x1 [9 s# |, B0 J |/ u
plt.legend(['train', 'test'], loc='upper left')
8 y9 X+ |4 C; F4 Tplt.show()
, f0 J# h) x$ f1 p
2 y( G) @. s3 i5 x3 j7 _( ~. [" h![]()
$ b! ?/ M1 U" W
6 e, {8 ]2 Y3 h# J3 E保存模型最后,我们保存我们的模型 - $ K( C# o0 u1 V3 t
7 i8 N$ E. s4 w1 c
#saving the model
) R% c; L: c l) L' \
5 r* h/ y$ {6 Y! `+ a& U - $ ]8 h4 _2 J" |/ p
5 J1 u/ P* J+ Y- `$ b. yclassifier.save('File_name.h5')9 {: R" u! @2 L/ b
: Q! `% r2 x+ p: ` - : K4 _( l4 u! M1 z @$ t' t
+ _3 s( P, G* a8 j( B% q, M) t
; T0 Q. x' n2 _2 i
( T" j9 s2 G! @5 }- A/ E
& ?, w' M N3 H! W
|