使用乳腺癌数据集的人工神经网络人工神经网络
* ^) m# X2 Y+ @: f9 S顾名思义,人工神经网络,就是人工神经元的网络。它指的是模仿大脑的生物启发模型。可以说,构建人脑结构的通常是基于生物神经网络的计算网络。
$ n' Q% |2 Z2 l7 G7 y0 ~( g9 H1 b
0 j6 D) i$ R) h# T2 n( J- t大家都知道,在我们的大脑中,神经元是相互连接和传递数据的过程。它类似于人脑神经元之间相互连接,神经网络由大量人工神经元组成,称为按层顺序排列的单元。具有各层神经元并形成一个完整的网络。这些神经元被称为节点。
! D4 K# q; r0 z& d5 k5 Q
$ w7 O& O3 }: M6 t0 C它由三层组成,分别是:
- J* u7 i2 [4 x& N' a! |* k# _& R# |* X7 o' b
输入层
! K2 P7 Y- n' z6 H
8 n& X' P( G$ v& q5 U隐藏层
7 O2 R# w% ~. e7 B0 l' Z
8 A' T8 ~* s& n, T; j3 h输出层
" T" e8 N& n9 d![]()
3 P- u @$ _6 J! n" s3 r+ J5 z; m' N$ Z
使用乳腺癌数据集创建ANN
8 Z* C! Z- t9 y' T/ ^" Y现在我们进入我们的主题,这里我们将采用数据集,然后创建人工神经网络并对诊断进行分类。7 X" _9 N2 e2 s& L" H" s- x$ q; X- G+ G
: v9 q$ b; b$ K+ ^( o* v9 W' }首先,我们采用乳腺癌的数据集,然后继续前进。
* ]7 R5 F8 H9 @+ j$ r6 G
% o/ h6 z) A& w. `7 D乳腺癌数据集:https://www.kaggle.com/uciml/breast-cancer-wisconsin-data
) l/ Q/ p- Q* z% X0 J. e. S5 A( H9 Z4 M2 X% i2 ?9 o, a
下载数据集后,我们将导入所需的重要库。
, c0 N) ^6 x0 T1 _" a
# u+ q8 P8 ^* K( o( g0 Y0 L* M导入库/ d( p: \7 m1 q. N2 W0 G% q# J
#import pandas
: U c4 R. v! s5 C* Uimport pandas as pd
5 L) y7 {+ ?- H4 a% m [4 Y#import numpy
/ g5 q) R8 A! r3 `; r( S& |import numpy as np4 d4 r2 M& r \) P. i
import matplotlib.pyplot as plt& \5 r* F, Z5 o7 S- ?
import seaborn as sb, m/ L" z V4 H' @( B- B
这里我们导入了 pandas、NumPy 和一些可视化库。" ]+ ]4 e( h$ V: K
现在我们使用pandas加载我们的数据集:
! W/ c; L |. D, a! F- b3 S) Vdf = pd.read_csv('Breast_cancer.csv')3 w% L" W. a O+ b9 G
df4 g+ r: m c& W$ R% l6 e8 @* k; z
4 r; d+ g8 L7 l# g% i9 s
+ ]$ x8 ], m) D
在此数据集中,我们指向**“diagnosis”**特征列,因此我们使用 Pandas 检查该列的值计数:
9 D3 J6 h3 j5 u! A5 W. n' S0 E: Z( [
# counting values of variables in 'diagnosis'; J) s5 H, N: O9 j! |+ P5 w6 a
df['diagnosis'].value_counts()3 d$ b( {; ?( l# A4 e; i- a: j6 ?1 W
5 k) F# K; ]) u9 ?& p/ y) Z# V+ |8 |
- n- d* N/ |3 u9 a4 I现在为了更好地理解,我们可视化“diagnosis列”的值计数。 可视化值计数3 V. p) X o: l1 N* [; U
plt.figure(figsize=[17,9])
$ x; E1 N; ?% jsb.countplot(df['diagnosis'].value_counts())
( W! D) |. t- J v5 x5 S% K/ Rplt.show(): d' n$ _& T& ` S& I% y' ~
![]()
7 h/ T: \, x `0 G' J) R# J- R5 \+ Q9 R! J; G+ o+ z# G
空值在数据集中,我们必须检查我们使用pandas的变量中是否存在空值:
. S) ]5 l3 H- s* V( f3 D- V6 m7 hdf.isnull().sum()& v" {1 S# m x* c* h7 q
执行程序后,我们得出结论,特征名称“Unnamed:32”包含所有空值,因此我们删除该列。- v6 H9 j' C# G) C$ V) b
! G) W1 M) z& L$ h8 p#droping feature
. w' Q7 n& ]- s9 }8 Y3 ldf.drop(['Unnamed: 32','id'],axis=1,inplace=True)' ]. ]1 w5 w: [ M8 X( s# I }5 J! J
0 X1 Y; @8 l [. k; L0 ~
自变量和因变量现在是时候将数据集划分为自变量和因变量了,为此我们创建了两个变量,一个代表自变量,另一个代表因变量。 $ _" o {9 l0 o
# independent variables
# q- ` d2 h* yx = df.drop('diagnosis',axis=1)
7 w! v1 D, l9 E* u5 h+ N#dependent variables
0 @7 H5 c/ r1 K: x v/ u+ Zy = df.diagnosis
& C8 ]1 n; n- y1 j c9 X( `5 V# I 处理分类值2 H' @% j1 t0 G! E: I
当我们打印因变量y 时,我们看到其中包含分类数据,我们必须将分类数据转换为二进制格式以进行进一步处理,因此我们使用 Scikit learn Label Encoder 对分类数据进行编码。
2 h' Z1 `$ J, f0 j0 J& }4 f* \' g& X* y- s6 ^* r( |
from sklearn.preprocessing import LabelEncoder4 S" q4 ]0 _5 |; R+ u; B& w/ i
#creating the object7 P1 x; d+ n! q( f9 U' o$ u
lb = LabelEncoder()$ B8 {- `1 a6 y, N' d
y = lb.fit_transform(y)
- O# H3 _# F, U- S6 v' v1 t# y0 y& H: p$ ^' E' R, A
拆分数据
8 ]/ L2 t; K% a( l0 y) m2 t' P现在是时候将数据拆分为训练和测试部分了:7 D& S$ J5 l3 x8 E3 l* y
- x1 d6 ]+ s+ x( U7 @4 P1 c; [& dfrom sklearn.model_selection import train_test_split; e# ~1 H; b. L8 t) T4 i; _
xtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3,random_state=40). x# m# W/ X: Q
' _& b1 Y: Z! P( ^2 d: z. U& ^1 ^* i! c
缩放数据
) i- [/ s/ F+ ?. J当我们创建人工神经网络时,我们必须将数据缩放为更小的数字,因为深度学习算法将节点的权重和输入数据相乘,这需要大量时间,因此为了减少该时间,我们缩放数据。
/ g6 e/ b! d t
. k/ t9 D" L8 T6 p% ~) c. H, {对于缩放,我们使用 scikit learn StandardScaler模块,我们缩放训练和测试数据集:: l: e# }; _$ y
& f) y; x) E- l. b8 i; \" C& k0 c#importing StandardScaler4 t% d/ w7 p- P6 U7 h m; _: `% O
from sklearn.preprocessing import StandardScaler
" c& m7 g( V+ e7 H1 f8 l! \#creating object% ?1 Y0 x* v9 w, }1 B6 O2 v
sc = StandardScaler(): k! L9 |! J$ M+ B3 P8 R
xtrain = sc.fit_transform(xtrain)9 Z l6 B7 ]/ P
xtest = sc.transform(xtest)+ U4 `# b8 x5 O& b4 G
" c( E" T: w4 q( }
从这里我们开始创建人工神经网络,为此我们导入用于创建 ANN 的重要库:# a$ s2 Z: R) J( e: q$ \6 p* r6 `
. P' I: N1 v" W+ p) k
#importing keras
6 V! a0 q0 Q% C! Bimport keras8 n' C7 Q# @& R3 X4 E4 {0 L
#importing sequential module$ ], U, Z7 v9 O( }
from keras.models import Sequential8 c0 S$ Y" z, s
# import dense module for hidden layers
8 H( J+ h: d; T1 }, e. Dfrom keras.layers import Dense
6 R3 d% T% T0 T/ N7 `0 V) |' }. t4 A#importing activation functions0 V0 t8 F( |4 \ Z$ |( C
from keras.layers import LeakyReLU,PReLU,ELU6 F! \" q2 D. D. v! G, u. n
from keras.layers import Dropout9 C% h8 t& c2 P( |
r* \% y7 G+ H3 g创建层
( ]/ |5 p' V, l/ C0 `' @导入这些库后,我们创建了三种类型的层:
5 B$ [; i5 h K3 Y- X' ?2 r+ ~5 J* ~5 h% ?7 O' M' k( ?2 V- o
输入层( k+ }. }/ c5 A( _
6 ` I9 | Q! S ~) K
隐藏层 c5 C8 L& S+ Z" Q$ d F8 M: Q5 A+ K
& `9 N( M6 G. B# X- E输出层
3 P$ E4 O' e0 Z. B7 j1 B- M1 O$ Y! S, q& N, b4 a, w( g% X
首先,我们创建模型:
$ ^& S, F, e5 N- |
9 d- e, T9 n( K3 Q. z5 y$ D$ @$ }#creating model7 s% g8 ]4 j& Y& u; X# S
classifier = Sequential()! `# g8 T6 G7 _- n
( b# V( y1 G6 t e3 c9 {
Sequential模型适用于每一层恰好有一个输入张量和一个输出张量的平面堆栈。
5 ]+ T( S' ]$ T# k3 R
" O6 m, L4 ~' Y' v+ {现在我们创建神经网络的层:; B9 Q2 w) [0 q& V% ]2 f1 O
1 W2 R8 ?3 t& D2 o6 F( j( k9 E
#first hidden layer2 c9 B* H4 @% |1 k$ O$ M
classifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu',input_dim=30))$ o7 F: T* w n, G
#second hidden layer
2 m, D" l- g( Q; j/ a" I( hclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu'))) _7 ^- i4 t9 @) }
# last layer or output layer
+ [9 n6 {+ B- }1 n- oclassifier.add(Dense(units=1,kernel_initializer='glorot_uniform',activation='sigmoid'))
4 \- j* v6 L$ V
8 Q" N2 ]/ p6 \/ W& R* D在以下代码中,使用 Dense 方法创建图层,因为我们使用基本参数。: ]% E* [. F+ M- K9 A, P3 |
: C1 |' N5 f/ U; s& F+ L' N第一个参数是输出节点* a' J* O- L! w$ n9 }: p! X
' ~4 P- `& k9 K6 n! t9 Z( n
第二个是内核权重矩阵的初始化器
/ J) L% V6 i9 r9 S0 } b
# y) Q3 J% R. T( X- G- `第三个是激活函数
3 s+ W/ z( n5 @) |3 C* q' t, z, ]0 Y* s
最后一个参数是输入节点或独立特征的数量。- E `5 M# ]* M% N
" J' H3 L6 L) g( M: m3 [
执行此代码后,我们使用以下方法对其进行总结:, C- ?2 f T! V3 b, o
#taking summary of layers
8 ~) k5 z1 s4 v, d6 `& l1 ^) G5 Y; cclassifier.summary()
( ]1 s! |! p8 W( P$ W# o ![]()
5 Y" h2 L, d8 k
8 E$ i( w5 S# \编译人工神经网络
- s5 u2 J5 I. [5 F% e; s, }现在我们用优化器编译我们的模型:
' b* A j9 R4 M# t3 u9 ?& s* p& S3 P) o/ b
#compiling the ANN
$ I+ s$ _4 S) h- Qclassifier.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy']), @6 x* X+ }$ U' {7 d1 W$ m
6 ~) i0 Z5 j; B* U
将 ANN 拟合到训练数据中
! o9 W5 c1 ]; ^- `编译模型后,我们必须将 ANN 拟合到训练数据中以进行预测:
5 Z9 Q9 ?& f" E7 ` |3 v6 N9 m) s0 n* p1 w2 v9 x7 K6 h
#fitting the ANN to the training set
1 I4 P6 v0 s0 l& s& E8 v' _model = classifier.fit(xtrain,ytrain,batch_size=100,epochs=100)
% n& {+ a* }3 d/ }. X ![]()
$ m. ]: q0 V( c- ?4 H" W/ C4 d5 y% N8 H# O4 z% ~! | b" {
it()方法将神经网络与训练数据进行拟合,在参数中设置batch_size、epochs等变量的具体值。% |' o# g. a1 h9 G' {2 i) O
! Y; `5 p3 ?: U/ H# B" O0 x在训练数据之后,我们还要对测试数据的准确性评分进行测试,如下所示:! \; N# W) |9 s0 n. s3 Z
. G7 ?6 U# }: z( \# V0 P! d4 ? J
#now testing for Test data$ O: k# O3 w: M9 e* f7 ]
y_pred = classifier.predict(test)& S m3 R; L7 k' A: { A9 J/ M4 j
* }1 C- H4 k6 D- |* j在执行此代码时,我们发现 y_pred 包含不同的值,因此我们将预测值转换为阈值,如True, False。- d: n. x* G- j: w
7 ^3 V- Z' V! V7 V* ~#converting values. x: L/ x- l+ }5 @( q! K
y_pred = (y_pred>0.5)9 `: X! I2 W' B3 F. b) E& O' i
print(y_pred)
3 b/ T/ Y M; ^; U% f5 M
3 a7 B% T, V% O, e* r. ^- G; t6 Z2 u2 I7 J! H1 C# |
/ z. f5 l( Y2 T: f p6 E分数和混淆矩阵, s8 V" Z, Q$ L4 d. D
现在我们检查混淆矩阵和预测值的分数。
9 I' }/ Z4 f8 n8 h/ i) P3 ?; x( c5 G% K8 P
from sklearn.metrics import confusion_matrix, p( ?- p( B4 E. V7 y
from sklearn.metrics import accuracy_score
8 ?2 I1 W: |1 d/ \$ }6 f# Y4 bcm = confusion_matrix(ytest,y_pred)' o) R6 s* U m& x& f
score = accuracy_score(ytest,y_pred)" d0 _% u0 N0 H+ @, B1 ]# w
print(cm)( F: D- O" `/ y# k$ K; A
print('score is:',score)
& T. [' G6 l5 ^# A$ u5 N7 i! R. j; u% w( i2 a3 G9 m1 f
输出:6 ~5 t" V: p/ Z' m* p1 v( k7 ?/ W
0 B! M* P" _, m- _: N; _9 _' j! H G3 r- V% P
& R1 D) ]' ^6 W( Y( e+ T, k可视化混淆矩阵; ~. m* h% U6 E+ Z/ A
在这里,我们可视化预测值的混淆矩阵
- a( J6 H2 j- I" P& `# g; x# N! f. @6 p! i
# creating heatmap of comfussion matrix
5 K. ?- \' G }# M, J& lplt.figure(figsize=[14,7])
6 x/ o/ l( F) H/ Q7 l6 Bsb.heatmap(cm,annot=True)7 U: K% v& w& ]4 I# O" }
plt.show()
, k# }+ ?6 b+ D& n6 d5 K# a
' a% @. O5 P* W ; Y) J7 P0 Q/ S
. {) t! v0 i$ k% r v' M/ a: e可视化数据历史- C8 e; p2 Q, i) x
现在我们可视化每个时期的损失和准确性。
) n: b! B# p. W. u1 j: P( v1 P K
; o7 w* f1 Q6 h+ D% l1 M# |# list all data in history
# e& E) A7 B4 z6 o+ O+ _" X2 Uprint(model.history.keys())
' d1 A4 Q# u0 \# q2 [" w# summarize history for accuracy4 u% h8 t. J5 C- k" `+ @1 E
plt.plot(model.history['accuracy'])
) ` G0 X( e7 t5 x+ Pplt.title('model accuracy')
3 ]7 ^9 c* G% ]. L6 v y* G5 l. f Zplt.ylabel('accuracy'): p3 ]% Z4 _8 x4 n2 G1 s
plt.xlabel('epoch')8 E) a5 [2 D+ \4 e' ^
plt.legend(['train', 'test'], loc='upper left')* H( M+ z; o7 Z
plt.show()
% J5 T! ^: s" M8 ~7 s( e2 }; h0 i4 w4 _- r" f
![]()
) x! K6 o# \. A p* Q
" u$ r6 v, Q m( y6 x) R, v; H5 |" G7 W) N6 o. i' Z
# summarize history for loss# D& W* X( p) l& ]4 C" s
plt.plot(model.history['loss'])' l. m$ [# l) \( \6 b S, t
plt.title('model loss')
- @; d: p8 @6 _8 v/ v0 O/ splt.ylabel('loss')
6 u6 e- X5 H& N# S9 Jplt.xlabel('epoch')
% D1 S; g# ` s5 g' B% @2 Rplt.legend(['train', 'test'], loc='upper left'). ?# s/ ~9 { G
plt.show()% [0 A8 u1 w1 y- b& A; r9 Q
. J+ b3 ~# d+ B' C+ A
![]()
% M0 [/ u* B6 f9 I& k- O( u+ l: H" O# @) {: V* d3 O$ V7 n
保存模型最后,我们保存我们的模型
2 Y4 C9 u0 `( T4 s
" S* z& u n: d#saving the model
- n8 [ o! _6 A0 m2 E; B" c. ^4 I0 U7 Z) ^
- # ]! j( k6 l; P+ @# V2 I
7 f7 p. r# ~/ u6 a
classifier.save('File_name.h5')7 g3 K# ^/ z/ j
5 y. J: z, a4 P# a
- / o! m7 C1 ^! Q" D6 A1 p
! R l* y' Z& Z2 A o$ b
! v1 J5 n8 X6 G( c& f# g/ T' S
+ V/ m, S" p" x: p& q$ M, @! R+ R- A9 l) f2 r S
|