使用乳腺癌数据集的人工神经网络人工神经网络. g. M4 f0 i. W& m$ _
顾名思义,人工神经网络,就是人工神经元的网络。它指的是模仿大脑的生物启发模型。可以说,构建人脑结构的通常是基于生物神经网络的计算网络。
# r* K& u0 E$ D
4 G5 C6 b/ _9 W ?9 L4 X4 V大家都知道,在我们的大脑中,神经元是相互连接和传递数据的过程。它类似于人脑神经元之间相互连接,神经网络由大量人工神经元组成,称为按层顺序排列的单元。具有各层神经元并形成一个完整的网络。这些神经元被称为节点。- N: z* Q1 S; w2 x) x/ D9 X
# g4 H5 w4 J7 X @% h
它由三层组成,分别是:% E" ]% z$ i3 W, ?
7 {- {* }4 k. z" W8 n4 z) l; s输入层( G! V9 u( S D. c1 g
$ T9 Y# H/ m% C( w$ D8 C, K9 R隐藏层; o" h: I2 u( b2 ^9 A, L8 H
2 l) B% o3 C0 I输出层
# C9 X- Q8 O2 w 2 w1 C8 k. R- v- Q! A) R4 p( f; A
" p5 z( }1 u: h
使用乳腺癌数据集创建ANN
. ~- k. J( S5 u0 Z; z8 c现在我们进入我们的主题,这里我们将采用数据集,然后创建人工神经网络并对诊断进行分类。1 B' W9 C) o8 l f, d4 t$ j& d
9 l7 x5 |6 B0 M" {; [
首先,我们采用乳腺癌的数据集,然后继续前进。
& Y- S/ j3 X# }. e+ n, m' s; B$ ]' U$ S& k# D, n& B8 @
乳腺癌数据集:https://www.kaggle.com/uciml/breast-cancer-wisconsin-data% O) J* n: }% C0 `1 ]
' i6 N% o% O2 u7 ~: a( g下载数据集后,我们将导入所需的重要库。
1 c. {2 x# z2 Q3 S# Z# Q7 u; I
& l0 }" G& L& s* j' A导入库. H( P4 G) y; g5 O. Y7 a8 G
#import pandas
$ J2 v' w3 @( z' N' O& Ximport pandas as pd& h- t1 F; H3 H4 q4 U7 P
#import numpy. t3 X. u6 ~6 s8 J8 j' i
import numpy as np
% u3 Y% u, B# U8 E$ u; I, jimport matplotlib.pyplot as plt
$ B0 m+ c8 F, ^& Y- I8 e. c2 Pimport seaborn as sb
- U) R* j% M( U) w; J 这里我们导入了 pandas、NumPy 和一些可视化库。
) o( g+ a6 R! U3 u现在我们使用pandas加载我们的数据集:
0 y" M1 U* o0 b# Xdf = pd.read_csv('Breast_cancer.csv')
6 o4 M( I+ o6 I) e9 x7 O' Z( wdf1 w# v! X' e* q2 z" j/ b
![]()
* @+ H5 |; u0 e+ S% O2 d4 X+ A- E
. ~) `' v$ u( h) E/ n- _; n* W在此数据集中,我们指向**“diagnosis”**特征列,因此我们使用 Pandas 检查该列的值计数:2 e; R1 w+ Z( `; }
. h. D9 u0 R- G+ W1 B) t7 I" O
# counting values of variables in 'diagnosis'
' h- `& R1 Y4 G6 e1 kdf['diagnosis'].value_counts()
& O+ ~% o9 p+ K/ U* M" e" \9 _2 g 1 g& \" b) j# v8 o w
6 V9 ~4 G! a$ k现在为了更好地理解,我们可视化“diagnosis列”的值计数。 可视化值计数2 ~, x% U9 c9 j3 P+ [% {. J
plt.figure(figsize=[17,9])
7 o: t2 V% r- D4 Z+ ]2 D! q4 Gsb.countplot(df['diagnosis'].value_counts())
) Q7 f- A/ Y @% [plt.show()/ w& F0 I/ X3 O: l b c8 p+ i
![]()
. n: q' y% R( W3 X( T! y
# |! r, T3 P" X6 N空值在数据集中,我们必须检查我们使用pandas的变量中是否存在空值:
1 h; e' I- m% Z$ wdf.isnull().sum()' ~, u) R; Y! V, D8 d
执行程序后,我们得出结论,特征名称“Unnamed:32”包含所有空值,因此我们删除该列。2 j5 s" I( N4 |8 } k
$ p) {+ O4 }) x( g7 t7 X) E( w1 s
#droping feature
, h _& ~9 m0 w8 b) Tdf.drop(['Unnamed: 32','id'],axis=1,inplace=True)0 l) _) X! W) f7 a
0 N h, W9 @. ?# w3 H& Z S
自变量和因变量现在是时候将数据集划分为自变量和因变量了,为此我们创建了两个变量,一个代表自变量,另一个代表因变量。
' t2 e: @* L7 q+ U0 r# independent variables) {# M) {/ w# G! I4 M Z
x = df.drop('diagnosis',axis=1)
2 K1 ]0 f, D; _/ F% ?1 p#dependent variables, J# ]5 l1 \* ]! J( W5 b
y = df.diagnosis
; Z8 E, O+ \6 B& b0 q1 N 处理分类值4 @+ g0 g5 e8 K$ M8 E0 ]+ d
当我们打印因变量y 时,我们看到其中包含分类数据,我们必须将分类数据转换为二进制格式以进行进一步处理,因此我们使用 Scikit learn Label Encoder 对分类数据进行编码。
" ?" p4 \0 h5 z/ {
6 h8 H' _3 {$ ~) kfrom sklearn.preprocessing import LabelEncoder
# E3 [% |( b( E2 h* X# A5 Y#creating the object
/ Y% O) R* b% \$ klb = LabelEncoder()$ V- [' }$ E8 w! s4 n0 k
y = lb.fit_transform(y)
* D( J l$ @% Q7 q2 V' b/ c0 T7 |* w
3 s- l% E: q' M拆分数据8 _& Q6 d5 b+ c$ _
现在是时候将数据拆分为训练和测试部分了:2 K; g7 v7 o% k: `4 e5 l& V/ L9 X2 R
, B. G- G$ x9 l+ n( h$ M- j! X( _from sklearn.model_selection import train_test_split
~, \ _+ K k7 j& j2 O! Pxtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3,random_state=40)$ s( ?+ M# Y$ T' T% Y
" R* m- l! r5 H; f3 ]5 n7 C& H& u8 J
缩放数据
2 X) e) {% L# k1 y- R当我们创建人工神经网络时,我们必须将数据缩放为更小的数字,因为深度学习算法将节点的权重和输入数据相乘,这需要大量时间,因此为了减少该时间,我们缩放数据。
. Z3 n0 |% k( U j4 E
- g1 a$ E6 L; T; y! y对于缩放,我们使用 scikit learn StandardScaler模块,我们缩放训练和测试数据集:& h* Y. u" Y7 E3 y$ \: r
1 m& B7 L2 K# f5 ]' h
#importing StandardScaler
9 ~: E6 O) E* h+ ~# ]from sklearn.preprocessing import StandardScaler& M0 v: B: d8 h1 t0 t+ j* k O
#creating object
& j% z7 B" c6 K- d& }sc = StandardScaler()2 o0 {2 [ v9 }" I5 W3 `& k
xtrain = sc.fit_transform(xtrain)
/ z$ V. q1 E+ M* F, Qxtest = sc.transform(xtest)
g$ j3 S$ _, J% X; K
+ |* O" |+ X! H2 V* o4 f从这里我们开始创建人工神经网络,为此我们导入用于创建 ANN 的重要库:
4 v/ ^' J3 ], k* u) `: P+ L& E1 f% C8 c) C3 J& a
#importing keras. }; \2 ^% h+ D* p( z5 y
import keras
2 u$ b* c; W3 A, t% ~7 x/ p9 D#importing sequential module, {$ K: \. o7 `! O; g; Z) P
from keras.models import Sequential
B2 K0 B. g6 z: I; g: `5 K# import dense module for hidden layers4 f9 O$ b$ n4 W Q/ Y6 z7 B
from keras.layers import Dense* z; Q% }' Z6 M7 n! G
#importing activation functions; Y8 R6 [1 R! |+ U- F/ x
from keras.layers import LeakyReLU,PReLU,ELU5 n; S( B- W4 ]! @
from keras.layers import Dropout
& G' v) Z( H( G, ]' O/ B
+ a+ h3 ^, o" X* [创建层% y( W6 E- y% Q( H, s# |
导入这些库后,我们创建了三种类型的层:
$ S1 |2 w- J7 j: L: T% d$ n
; V" J% ^3 D3 g0 [5 J( J输入层* S. G; r x% G- b6 [( Y
. ]5 j0 X4 |; L, X9 E, ^/ Y
隐藏层3 v \5 }! a/ R7 d, g# A4 T/ I
, s: D* V+ q y8 T1 y2 b4 `$ A
输出层3 v9 w1 M1 t% h6 R+ a
+ g7 H. s. d" q% e8 Q首先,我们创建模型:6 r/ x' l! N- V% ]4 k- X# k* O
5 v2 M2 n6 T6 p#creating model
W, I3 ~( n6 x" X. Vclassifier = Sequential()
% c9 l7 k9 e# ]1 C/ w1 i* ~- a+ r+ w# d; i4 j" A2 M) `
Sequential模型适用于每一层恰好有一个输入张量和一个输出张量的平面堆栈。
- z- b+ ?& e; `& m/ A: c7 Q. X
& Y) h0 N, V8 S0 |7 ?现在我们创建神经网络的层:
8 t) `7 | M" j0 i+ x2 w, ?8 P* r5 K
#first hidden layer
8 S, n4 E; `7 @5 e3 }classifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu',input_dim=30))6 g' J$ [3 ^1 ^' R4 E$ @8 h
#second hidden layer
: n- m6 m4 L# Y6 wclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu'))! J/ R( q" @ z7 Q$ A6 L
# last layer or output layer8 L s9 u4 O$ c/ {" r7 x8 l
classifier.add(Dense(units=1,kernel_initializer='glorot_uniform',activation='sigmoid'))8 m5 Z6 }3 P0 I3 F+ F, R
) c3 l) N$ Y4 c- f
在以下代码中,使用 Dense 方法创建图层,因为我们使用基本参数。. z3 Y. i8 z2 J8 v1 t2 H' p; u
0 ^9 P8 E7 W) D, X, n& |& e2 m! S7 x
第一个参数是输出节点- q3 J1 v1 T3 D! g' A
- V5 e6 Q3 l8 H) U( g/ l3 h第二个是内核权重矩阵的初始化器6 ?! V5 @8 M/ p; X7 S
% r4 I1 E& u8 j
第三个是激活函数6 I3 l! @. A0 x9 G% c1 Z5 }8 Z
3 H L5 x5 h* T4 d# U4 m最后一个参数是输入节点或独立特征的数量。, w8 U, h- J3 A; a' h
% J& H: v, R1 {; `9 W! s执行此代码后,我们使用以下方法对其进行总结:" ]% W4 _0 j7 O
#taking summary of layers
7 d9 \7 }8 V+ C" rclassifier.summary()
7 w# H; o( _1 c( h# z% A ![]()
& l! }) K" E$ A7 a6 e$ C
3 [, R. `! g0 [编译人工神经网络5 l% D: q5 J* t$ s) X% d
现在我们用优化器编译我们的模型:" d* l. m3 d0 S: W
: k6 n8 L2 E4 n; w h$ C
#compiling the ANN y4 {0 X6 [ h8 _; J2 c$ p7 {
classifier.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])/ z2 _- {) u" f) _/ {" t
; [! U$ }3 b) D! n& ~) G
将 ANN 拟合到训练数据中& `2 Y! T* t) Y% i8 x# ?3 y/ e
编译模型后,我们必须将 ANN 拟合到训练数据中以进行预测:) l8 W5 g, y" I$ l% g
& q; a; @" c- T) X! E: u3 f: k- d5 F #fitting the ANN to the training set0 z+ \8 z: M8 _5 a& w3 X
model = classifier.fit(xtrain,ytrain,batch_size=100,epochs=100)
( _! b; K B; T& h) k( G# Y$ n 4 T8 W! u' {; {
5 ^# u* j9 S* r- P% {it()方法将神经网络与训练数据进行拟合,在参数中设置batch_size、epochs等变量的具体值。
- O" h/ A' J$ L6 T- b: M" V( ~* _* W2 P7 t
在训练数据之后,我们还要对测试数据的准确性评分进行测试,如下所示:
4 K2 a4 [4 L6 l. m9 n r6 f' Y( {/ g3 `/ `0 a% T2 D! V; {3 _) N9 H
#now testing for Test data8 Z( b+ R& e# R
y_pred = classifier.predict(test)
) | x7 l$ Z6 x! g K; D% @% c- K5 i0 y5 M# D/ S# F
在执行此代码时,我们发现 y_pred 包含不同的值,因此我们将预测值转换为阈值,如True, False。- \) m1 I/ l: o: u+ Z8 G4 w& j
2 [/ Z- X8 a% d4 y
#converting values
! T6 a# m) i" `& |3 py_pred = (y_pred>0.5)# Z% I+ e8 F! v c
print(y_pred)2 r+ U1 s- v. U0 p* q
: p' I. [5 m, X: V$ [- Y3 V
3 |! r; S( f7 ~
1 |8 @* y. C B. F! S i
分数和混淆矩阵
4 g: v7 P# b6 @* ?* O现在我们检查混淆矩阵和预测值的分数。
6 a l. K/ C5 U* U& q6 s( ~9 B+ a2 {/ b
from sklearn.metrics import confusion_matrix0 i( X. U$ t# }' g8 ?8 t
from sklearn.metrics import accuracy_score
/ _0 R' T7 l, ^/ d9 e. `4 H! _" Bcm = confusion_matrix(ytest,y_pred)
* {- m/ @6 t' j& hscore = accuracy_score(ytest,y_pred)# @1 Z1 J/ M% D: \0 K4 Q' X* f
print(cm)% B g, D; t. M) r/ m, q/ s I; W
print('score is:',score)
. U) _0 }7 D% E- N3 J, s6 t. M7 Q
5 P0 G7 r% l5 f7 W/ [1 X输出:$ M. R- H/ B' A$ [7 Q b9 r1 f
, ^0 [) \% E$ w8 j1 R4 s
& V) y: M( B. b! W( Z7 Z8 l: v% L8 d6 \# c$ ?
可视化混淆矩阵
+ a3 @! z/ A' { c" k& }6 j. I/ T在这里,我们可视化预测值的混淆矩阵7 c o; I+ G3 {4 ]5 m5 `# d
) e2 ~$ q/ ~" h1 Y# creating heatmap of comfussion matrix
- O. U6 o G- C- i3 @plt.figure(figsize=[14,7])
. H1 Y1 b3 u* J# N7 C8 r- hsb.heatmap(cm,annot=True)
4 M, v$ Z3 ?* u2 w7 uplt.show()
7 I- p5 F$ l5 m! o F& s7 _: d+ X4 z9 L, Z% ?! o
T0 V' z& m2 Q, }+ `! k
( f* ]- _ Y5 c5 ~5 {可视化数据历史
8 ^/ R2 F7 b( n- U' T/ }" X4 c8 s/ |现在我们可视化每个时期的损失和准确性。3 s6 ?% u" l3 E5 ]/ K1 ^
) Q8 }5 M3 N3 H6 @; \# list all data in history
" Y' e6 O+ o Q1 n. W2 c) L" _print(model.history.keys())( y) |2 ]0 r! g- R$ A
# summarize history for accuracy
5 S5 t$ f/ x5 p% [$ R& h1 bplt.plot(model.history['accuracy'])
4 x% Y; j6 h0 q6 \, R5 Q1 w% S) {plt.title('model accuracy')# L+ T0 m0 d6 K6 |( K }% L
plt.ylabel('accuracy')$ D4 T+ F8 `: \9 n I( F
plt.xlabel('epoch')
" _; ]# ^* m: l5 Mplt.legend(['train', 'test'], loc='upper left')/ F' O; f4 ?* V$ H
plt.show()
. {# n9 p7 \) M- l/ ^' {
+ G8 \* d0 @7 w4 z' J5 b* @![]()
K6 \' _9 @' S+ K f: O7 n
2 z( ~* n/ F4 Q j9 \- ?" b( j; B
+ m+ _9 {5 l, d' j: n# summarize history for loss. s" G; K( m: U H
plt.plot(model.history['loss'])$ {# b, T5 Y* |' b1 a* G& O
plt.title('model loss')
, o9 q- }3 @5 ^5 P7 h& ^1 O6 ^* Zplt.ylabel('loss')
1 y5 h" \3 u K" n) C& ?; M" xplt.xlabel('epoch')
; h! S, H! V) [& r0 R, J6 H' }plt.legend(['train', 'test'], loc='upper left') `6 u& o0 s" f5 l) z
plt.show()
3 m7 N1 w5 Z2 r9 i- \) Y" A I! L
$ ~4 t1 u. u9 c4 A9 } ( N f- e5 ?. V! U
0 `- @9 U* q& q; j7 w7 K保存模型最后,我们保存我们的模型
4 v) f( m9 N$ `. N- y
( f# z! o) {! E1 }" o#saving the model
9 N: ]+ n( B% K! {, q; b0 D: }2 z, z5 t& N w. h. [
- : ^; e. N1 X2 J4 u" @+ ~
3 W9 y2 t- o/ D& O# U
classifier.save('File_name.h5')- \$ @5 T. S7 ]& a: O
' ?+ g! _. v) Z G* @% R7 z
5 a Q) ]# z1 I) p0 ?& K
9 {/ Q: c; Y' B0 d & Q' I. q3 V# ]" i1 m/ }
7 `" n3 w1 W. {0 J, t4 i* Y L: G0 `* }# S% p+ z4 V( E: \
|