数学建模社区-数学中国

标题: 使用乳腺癌数据集的人工神经网络 [打印本页]

作者: 1047521767    时间: 2021-10-15 17:10
标题: 使用乳腺癌数据集的人工神经网络
使用乳腺癌数据集的人工神经网络人工神经网络7 f% P$ k9 d; s  T" g, B
顾名思义,人工神经网络,就是人工神经元的网络。它指的是模仿大脑的生物启发模型。可以说,构建人脑结构的通常是基于生物神经网络的计算网络。) C$ x4 m  Y& [5 d  K4 g
( W$ e; ~0 N" y/ u  `" c; j# y# G! q5 D
大家都知道,在我们的大脑中,神经元是相互连接和传递数据的过程。它类似于人脑神经元之间相互连接,神经网络由大量人工神经元组成,称为按层顺序排列的单元。具有各层神经元并形成一个完整的网络。这些神经元被称为节点。
, @* ^8 u+ ~, }) G# J' V8 h) Q+ D/ O" h  x& Q. W6 ^  a4 r
它由三层组成,分别是:
7 w7 U" N/ y- j3 m) r  _' S+ u; O2 w  c, ?( d% ^. e5 V3 R
输入层
( W% I! M' u- h; t
! A! q; R4 j8 P/ n2 s隐藏层; h& x: e9 R- m1 h" ]$ \4 p
, V& W4 g" a3 A: u- X2 G: _' g
输出层
# \( A+ `3 Q8 @* {+ K" C8 @. G
  E$ x1 o4 ^' z( f1 f$ m! ~( `4 R. m7 u1 s
使用乳腺癌数据集创建ANN  w0 o4 G2 u: i
现在我们进入我们的主题,这里我们将采用数据集,然后创建人工神经网络并对诊断进行分类。* T9 Y1 \$ L% r: j3 q

4 v# Z. \8 g1 r2 F; N' R, h首先,我们采用乳腺癌的数据集,然后继续前进。% c$ n" E. Y& r- k+ s  a- L6 z

2 K( X; v2 [+ f9 U* Q7 k; M7 Q3 I乳腺癌数据集:https://www.kaggle.com/uciml/breast-cancer-wisconsin-data
0 H# _) n/ Q: M2 o' `) ~5 q( P6 H- C& \' f& c7 R
下载数据集后,我们将导入所需的重要库。- ?& ~. F; U* V( i  j5 d
  q) I. g6 x2 A
导入库
7 a/ P% ?3 [4 Q6 K' ~) G. g#import pandas
0 c; V  J/ E8 p& h7 E+ Oimport pandas as pd
+ U* z: }  z1 v1 b3 ?, U, n#import numpy
* y  h- {5 j2 Z. Uimport numpy as np
/ \, `6 k( X& p; O" `import matplotlib.pyplot as plt
/ Y4 _3 L5 ]8 [import seaborn as sb4 G3 I, \/ a) ]% R: ]6 g5 f5 K1 b! W
这里我们导入了 pandas、NumPy 和一些可视化库。* b% ]! @* l/ `( q

现在我们使用pandas加载我们的数据集:

! A1 B/ {4 [* C- V0 h
df = pd.read_csv('Breast_cancer.csv')
: e3 l9 L3 k2 gdf; w3 S- m4 Q6 P$ j$ u) e/ l
  x% \4 d7 y( U2 Y
0 {, W  Q" S% d) F$ c1 M
在此数据集中,我们指向**“diagnosis”**特征列,因此我们使用 Pandas 检查该列的值计数:
* h. c9 p5 W% q- \: K. K9 M+ T2 X7 {7 b- R. @1 C
# counting values of variables in 'diagnosis'" u. G4 b& i1 s( q* N
df['diagnosis'].value_counts()$ H) x3 l4 h$ K; _, f1 S
: P  y# }9 o7 l/ U1 L4 w: }8 u+ v
+ K" o, \% F2 Y3 \) W% V1 n% S  s

现在为了更好地理解,我们可视化“diagnosis列”的值计数。

可视化值计数* Q1 x0 `# ^: f7 a0 U" g
plt.figure(figsize=[17,9])
8 ~8 `( u- R9 d$ H0 D/ Usb.countplot(df['diagnosis'].value_counts()): d% b. L1 N/ u( U! Z/ Y. o
plt.show()- ~" y2 g. a/ {( o( G- N
: \/ p# F1 }) p9 j: F

! s9 i  U, A; b2 w  B" q空值

在数据集中,我们必须检查我们使用pandas的变量中是否存在空值:

+ M) `  k% n' I' i
df.isnull().sum()
" T# b7 D/ A8 h7 ~+ \ 执行程序后,我们得出结论,特征名称“Unnamed:32”包含所有空值,因此我们删除该列。. B' {$ v2 w0 s! W* ]

8 M, ?! Z; c8 i, c8 K5 D+ t" D#droping feature* B" v5 l) l) N, s: a) ?; m! W
df.drop(['Unnamed: 32','id'],axis=1,inplace=True)& h( x) h( U9 p7 w3 N) p
9 p; O, R* d) `  _
自变量和因变量

现在是时候将数据集划分为自变量和因变量了,为此我们创建了两个变量,一个代表自变量,另一个代表因变量。

- f9 E) C$ x# v7 b$ g0 `# N
# independent variables; p" f& @' `3 b# T2 w; S2 _4 k% U
x = df.drop('diagnosis',axis=1)* g7 L2 X) n/ B. u* H3 y
#dependent variables- K' L% m) _6 r3 |  ]1 o
y = df.diagnosis
' l" E; l0 _, ]) q$ u' i- ~ 处理分类值# i6 |: o' a: p7 l0 J
当我们打印因变量y 时,我们看到其中包含分类数据,我们必须将分类数据转换为二进制格式以进行进一步处理,因此我们使用 Scikit learn Label Encoder 对分类数据进行编码。  \- I/ ~* Q5 v0 V( |& l

* T4 W9 j( N1 x) {) j! ~, ~: Rfrom sklearn.preprocessing import LabelEncoder+ p9 R5 ]1 @6 I( h
#creating the object. K$ {* E( e+ E  E% f
lb = LabelEncoder()' i: n' q' X& Y1 r. G' L0 s
y = lb.fit_transform(y)6 t, h* W+ T7 T0 f# ~3 Q  T
% D, }7 R% O7 o. v1 m" a
拆分数据
( F2 |9 ?5 W, k, Z1 [现在是时候将数据拆分为训练和测试部分了:
+ ]0 n4 _1 ?  N) U  O. w3 c# f* K. W
from sklearn.model_selection import train_test_split+ l! n. t5 m3 T4 r2 P$ Y# t
xtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3,random_state=40)
# N* p0 U8 Q) J1 m+ j- x) }8 s$ |9 W) |8 p3 L' L
缩放数据
! Y7 K  ]" I3 M0 m( Y% _当我们创建人工神经网络时,我们必须将数据缩放为更小的数字,因为深度学习算法将节点的权重和输入数据相乘,这需要大量时间,因此为了减少该时间,我们缩放数据。  s- E7 Z% P" j/ I/ y
9 g2 r# V6 x+ H6 k2 S
对于缩放,我们使用 scikit learn StandardScaler模块,我们缩放训练和测试数据集:
/ o9 n* _1 O2 \; ^' O. f+ h5 E: t$ z5 q0 J9 s/ b2 u; F
#importing StandardScaler
7 }, c6 V: I! f; T! }4 mfrom sklearn.preprocessing import StandardScaler
4 I) i! f. t9 t; E/ N* E5 b#creating object, G& m: f5 P9 j6 [1 Z
sc = StandardScaler()+ M- k; E% p9 F( w- N! Q2 w% S
xtrain = sc.fit_transform(xtrain)
# Q/ F3 o  f& D" k8 nxtest = sc.transform(xtest)
6 r% F, i$ G0 m' S  ]* R( v3 k& J4 B( J1 _# u* r3 D& y
从这里我们开始创建人工神经网络,为此我们导入用于创建 ANN 的重要库:$ q9 b# _' Z9 R

6 k6 c8 m) l; p#importing keras5 n2 F' W$ A! N
import keras9 ~7 X: L! N5 o; ~+ y4 f2 S
#importing sequential module
1 d- ?7 w& }4 S2 i' v2 ~from keras.models import Sequential/ P, ^+ w% W1 h3 R, v( Z9 S
# import dense module for hidden layers3 H2 ]+ Z/ W- ^
from keras.layers import Dense
, v0 O* x4 ]- n#importing activation functions
; e3 P1 T) t- Gfrom keras.layers import LeakyReLU,PReLU,ELU
) e2 E7 T4 M! N% Nfrom keras.layers import Dropout$ z! W' m' X9 A1 |2 e+ f

% e! L' Z" W; h- I2 M; l创建层
! B5 P. [) c8 V# _, \导入这些库后,我们创建了三种类型的层:% e( T. t; e5 ]7 G# p

- z5 R7 v2 H0 P, X5 S: G# [输入层
2 ]1 r3 j1 h1 H4 ]3 v. w
% }* z# e3 q4 o- Y1 ?# d# J- U隐藏层
! R! J9 r6 L% T5 ]2 ~8 ?' [
( T4 m, U* n; S' n输出层
6 H% |% z4 R7 ^2 t0 y! D" ]- @% T- Q7 Q$ I( P7 U" Z
首先,我们创建模型:, d: w9 }3 H) m( B

& O2 m' g6 s0 n6 a: x#creating model7 k3 t. r* q( S! c* B. q
classifier = Sequential()7 {1 V3 _$ Q6 v6 P$ l3 i2 Y

2 J0 ^: P& A; }7 o. M3 Y8 o4 LSequential模型适用于每一层恰好有一个输入张量和一个输出张量的平面堆栈。- V9 q' V3 ]2 G/ s$ R! |; v
, u" ~8 [3 o* t; y; x
现在我们创建神经网络的层:6 S: B& A3 R! Y9 v2 m! L

# Q' W, f+ H6 ^  C  o5 j& J/ n9 l#first hidden layer
9 x" h" ]) M$ L( S& Eclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu',input_dim=30))
- K5 f& o8 W% M9 M* \- a#second hidden layer
; |2 H- N% L* O: Lclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu'))$ ~! l! j; N+ G; p2 ^
# last layer or output layer. A5 d: ?$ c2 X; r
classifier.add(Dense(units=1,kernel_initializer='glorot_uniform',activation='sigmoid'))$ `" [5 J1 T  G  q0 W
: [9 g0 p, p0 @/ e
在以下代码中,使用 Dense 方法创建图层,因为我们使用基本参数。
' E  F2 Q' \( u( N8 r# m" o- D2 z; Z: @3 ]  x
第一个参数是输出节点
- V$ D, D3 U* [( {" J8 [, @1 X" W! C2 ^/ s" n1 a( ?; d
第二个是内核权重矩阵的初始化器' h- m. O$ p) l3 X' g
# `8 S* o2 `5 ]
第三个是激活函数1 v3 ~: i8 J: X- T9 Y

$ }* I- R/ I( c9 ~最后一个参数是输入节点或独立特征的数量。9 t/ |+ L$ d' [- _5 {

" S1 y+ m" ^: }* V& [执行此代码后,我们使用以下方法对其进行总结:/ [. v( ?8 X) z/ B7 y
#taking summary of layers
7 k0 P1 ~$ Q/ Z$ g. r1 b& o3 @( q+ q! X& qclassifier.summary()
) I! @  L  w# Q9 J7 K  L7 f8 r
6 ^4 V" l, V3 |; F+ @1 D, u6 D; v
编译人工神经网络5 {* u( s- A4 d5 z3 P) n
现在我们用优化器编译我们的模型:7 S. j, \- A+ U5 U. W$ r

3 r" ~+ y9 g% _#compiling the ANN8 ~, f+ k1 s- q1 u5 g1 e
classifier.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])% j" k  j+ D* o/ V& D: p
3 Y* d9 V! P9 I$ `  `6 v. `
将 ANN 拟合到训练数据中
/ ?# J8 S: X$ \/ Y1 y1 H编译模型后,我们必须将 ANN 拟合到训练数据中以进行预测:
5 t1 K! [& s! s4 y/ Y3 y7 W' z& x* p- ~" w4 T
#fitting the ANN to the training set- @7 y' R& k% {% p
model = classifier.fit(xtrain,ytrain,batch_size=100,epochs=100)- n% p: P# D( j+ t7 E

4 d4 M, l( i( s! G$ Q# i, w/ q) P4 _9 v4 ~3 A* Y- v
it()方法将神经网络与训练数据进行拟合,在参数中设置batch_size、epochs等变量的具体值。2 N8 k; L/ m/ O7 s1 M$ |* w

; t# f2 G) A& B* h8 ?' t在训练数据之后,我们还要对测试数据的准确性评分进行测试,如下所示:
" j' K  i& s- _9 F
% S4 V! t! p) \/ Z1 Z: ^& \: K6 z5 G#now testing for Test data3 d' t4 \; R- i* t& ^9 e+ ]/ v* `
y_pred = classifier.predict(test)' y7 \8 A; X: u3 }0 \

" o0 ?, t+ f# ]在执行此代码时,我们发现 y_pred 包含不同的值,因此我们将预测值转换为阈值,如True, False。/ y  p  \4 x7 I  }) U0 u

; v5 |5 H9 c1 N; i3 X#converting values9 x. _# I( ?( g: L7 D, I
y_pred = (y_pred>0.5)0 ~, i' j$ n% M
print(y_pred)
5 z' h; x- t+ y1 \+ ]: `) ?4 V- W, G1 H7 D# B
" Q5 g( G* C! Z* |2 a) D4 K5 F5 F

/ Q$ L. I3 v: W; Y5 t" X0 x分数和混淆矩阵4 C# `9 e! J+ ]1 e; U9 B+ Q; @
现在我们检查混淆矩阵和预测值的分数。; D, R5 \( r2 k9 u  K2 q0 E

* n- S  _' ~4 f+ \) f* Pfrom sklearn.metrics import confusion_matrix8 o' m! [! V4 U! v! k7 K# ]
from sklearn.metrics import accuracy_score  a; ^, X7 j" v/ g0 W* }' N; `/ h
cm = confusion_matrix(ytest,y_pred)
" P) ^4 U8 S% e& u+ _score = accuracy_score(ytest,y_pred)+ v5 a. X3 T! M/ [+ u& t$ B& W
print(cm)$ j0 F6 d$ f0 [4 V* P# Z
print('score is:',score)
  m7 L4 p* n# N2 {  W  U% v. y  R3 B8 o- U3 Z" C
输出:
; I0 c6 n$ i: }3 h3 G! i4 h" L9 R9 H

' }. [, N* @. w9 ?8 i
" |; ~1 l2 D  ?9 F) j; R: }可视化混淆矩阵. ?5 Z) d1 X  Z" Y9 G
在这里,我们可视化预测值的混淆矩阵8 _6 j0 I; J; x
3 a0 Y9 n6 ?: B
# creating heatmap of comfussion matrix8 l. s, `' t, ?+ c6 u+ x
plt.figure(figsize=[14,7]). h, t& {0 u( O6 S0 H
sb.heatmap(cm,annot=True)8 S3 w. }* p% |0 ^5 b# `& R' }
plt.show(). @- ?' K7 j7 D& Z4 i+ t: t7 Y1 ]
1 k) p8 \) Z) M1 ?( }" k  @* h0 A

) d2 y! }! U( ]9 V1 l  \# C
) {2 F# h7 ~  N# U- h6 T可视化数据历史; u: }# n2 W: a, ~+ _2 M
现在我们可视化每个时期的损失和准确性。
& _+ L9 }' e$ }5 K7 E# U2 B
1 q3 t. a: ?1 f2 V# list all data in history
$ f5 [, w7 _  `& ~print(model.history.keys())
8 u: C/ G  w* n$ p" Z# K0 R! K# summarize history for accuracy
! Q. p' l' o  z. l. C# s( T- Lplt.plot(model.history['accuracy'])
1 J: v' R& H7 v! ?plt.title('model accuracy')
. ^% u2 o( X1 W# r' k1 d  h5 Uplt.ylabel('accuracy')
8 Q8 Z' Z: p7 F' Dplt.xlabel('epoch')
) P$ Q/ I; X% m1 `plt.legend(['train', 'test'], loc='upper left'). h! V. ^5 q3 H! e: w! _9 M
plt.show()
# a% w, f5 t3 _; K0 m. [. V1 N9 ^& v& b' N; S4 c
- W+ A4 {" ^" Z2 ]8 |2 k. A$ R
; O! p1 Q. v( Z) Y7 U- u+ `/ B

9 t0 a: v3 t5 H1 t3 c2 O2 G# summarize history for loss
/ {& ?+ `& \3 X/ Bplt.plot(model.history['loss']). k- b# O( m/ K3 `7 Q
plt.title('model loss')
( P* S; v# T1 _$ N8 k7 c7 }plt.ylabel('loss')2 \' x& |& D# e1 d% G& _% e5 C; s: ^
plt.xlabel('epoch')( w. y. ?3 w* N9 c# i# j
plt.legend(['train', 'test'], loc='upper left')8 t8 d! E, C& [* E. r" I5 R
plt.show()% d& h) w9 t- w! ~

/ v& k) d: Q4 Z5 |) W$ y1 }
4 T  S+ L% x" [+ \) G( l
" v3 P) |/ Y3 Q# y- }保存模型

最后,我们保存我们的模型

, M- y* M9 |8 O5 d
# d6 o4 C  b" M  y1 {) _  W  |8 T
) O6 @2 C/ D+ t& `5 u





欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5