数学建模社区-数学中国

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

作者: 1047521767    时间: 2021-10-15 17:10
标题: 使用乳腺癌数据集的人工神经网络
使用乳腺癌数据集的人工神经网络人工神经网络1 |3 p( S6 g6 |4 ~* g
顾名思义,人工神经网络,就是人工神经元的网络。它指的是模仿大脑的生物启发模型。可以说,构建人脑结构的通常是基于生物神经网络的计算网络。- V0 w# x$ k, s/ K: d

" j2 B; u- I7 ]/ {大家都知道,在我们的大脑中,神经元是相互连接和传递数据的过程。它类似于人脑神经元之间相互连接,神经网络由大量人工神经元组成,称为按层顺序排列的单元。具有各层神经元并形成一个完整的网络。这些神经元被称为节点。
1 w/ T; S' @5 `
/ w6 J% D, e0 J它由三层组成,分别是:
2 E  B3 [, M1 u. s  l
, U' j8 Z3 D* K% j+ F- Q+ L* o输入层
$ w0 J- v& J! O3 r
0 H8 F! n1 w& ?4 }+ K0 H隐藏层2 `5 k7 g( Q7 J8 o* Z  k& G

  ?/ M7 o$ `1 m/ K% `9 v' u输出层
; M$ Z9 ~6 P, `: }0 r8 J% h( Y) u) y: j' n# r! Q' v1 k

0 N2 N  U  H: G2 ~+ @使用乳腺癌数据集创建ANN; V1 y6 T" j8 ]% M' q& {& z9 w
现在我们进入我们的主题,这里我们将采用数据集,然后创建人工神经网络并对诊断进行分类。
) W+ T  z; @- L, g- [* u4 W
. u) f6 V+ M2 p. V$ ~9 p首先,我们采用乳腺癌的数据集,然后继续前进。5 I8 [! V; J6 Y3 @7 z
' u! v5 ~* B: [- `
乳腺癌数据集:https://www.kaggle.com/uciml/breast-cancer-wisconsin-data3 N( K3 m3 z9 d4 P# B2 K6 I
* ]( R# U9 n3 @
下载数据集后,我们将导入所需的重要库。
* C: b( a: ]( `- v6 H
6 q, m+ \6 B3 Y& X0 C导入库
3 w" p# e( a7 |#import pandas
  I2 n: d: {' r- x; j- _- F. {import pandas as pd, z+ c  E, H0 R$ g: K, h6 ]5 V
#import numpy8 f& K% @; u# P; c
import numpy as np/ C0 M% O2 L( O9 J7 [+ V
import matplotlib.pyplot as plt
, ?  ?; j& s  i' oimport seaborn as sb
" `+ ]" X) `* V: b 这里我们导入了 pandas、NumPy 和一些可视化库。  V- ]4 B+ V0 V# ^" `

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


# K$ B  G5 [4 f3 _: [df = pd.read_csv('Breast_cancer.csv')
4 c: v3 [) \" E) d8 {7 W2 @df
; n* |1 w% J- t: D) w 6 E5 y+ s0 m0 B# G6 ~2 e! }; {: X
1 [5 R$ q3 v) J* \4 R8 U
在此数据集中,我们指向**“diagnosis”**特征列,因此我们使用 Pandas 检查该列的值计数:- V0 r! k# Q4 o5 f9 |

  m- o& O7 r2 x- B  m! D3 }5 L# R* T! i# counting values of variables in 'diagnosis'
9 M; F# D* W. f, }df['diagnosis'].value_counts()
+ b2 j. z* M" F( r# y4 @' e
3 D: Y7 t/ G) \. T- g! ?% n0 `- b* e7 L4 F

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

可视化值计数& ?2 F; D* l: g9 L3 R& P6 V
plt.figure(figsize=[17,9])
" A2 c. m: C( \0 U7 D, B/ ?sb.countplot(df['diagnosis'].value_counts())% a' O3 y( w5 `1 q# o- z9 z
plt.show()4 V- s" P% Y6 l2 m! W
3 o7 j* Z3 N* e4 E" e" p" n
/ P) h! `/ q' _6 m, H% L
空值

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


; [7 g7 S6 h+ ~: J  ?df.isnull().sum()/ R% b& e3 q- l0 h; F8 a# c8 Y
执行程序后,我们得出结论,特征名称“Unnamed:32”包含所有空值,因此我们删除该列。
2 }, m* I6 H& L0 s3 q8 \
0 Z8 C% n  e! p$ Z  E#droping feature
# k; |- E/ W0 Q, L; w- E/ Y( idf.drop(['Unnamed: 32','id'],axis=1,inplace=True)
$ v2 T! ?- @& \( x1 r9 A+ P
& A* w! e* e& h( A( A自变量和因变量

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

$ d( G' a( a, v: E- [! Z- D) v( {
# independent variables# R! j4 F+ y3 J4 J% B9 K# Y2 a
x = df.drop('diagnosis',axis=1)
2 \, K4 \$ y2 [* Q- w$ [#dependent variables
$ t$ a1 M1 J( Z. b+ n4 F  _y = df.diagnosis6 y3 w3 P5 V, q% F& k" a
处理分类值
+ ^  p& g& f+ v, H) d. J当我们打印因变量y 时,我们看到其中包含分类数据,我们必须将分类数据转换为二进制格式以进行进一步处理,因此我们使用 Scikit learn Label Encoder 对分类数据进行编码。
2 Y& F  g/ W: d) v
  p( j# i( x  Yfrom sklearn.preprocessing import LabelEncoder
. `5 j" y: r8 C& ?# p#creating the object* D; E" U8 [$ e( e" D
lb = LabelEncoder()+ I* `) L5 s7 G3 q' A0 ^- y1 P
y = lb.fit_transform(y)
  m6 f: l3 Z0 `( S2 c0 _& l9 F" @) U- w' d" o/ ]5 z# d
拆分数据6 y  s6 y6 K0 R( x5 U2 ?
现在是时候将数据拆分为训练和测试部分了:3 N; q6 w0 _8 G. I$ X3 v

2 h) L: H2 _) s" ]7 k  O& @& [from sklearn.model_selection import train_test_split& y+ j3 D* y( D. c
xtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3,random_state=40)
4 Q7 E# j4 N1 W% \6 T0 q
0 ~9 g! Z" y/ A缩放数据
+ F! B8 d8 p$ u8 L当我们创建人工神经网络时,我们必须将数据缩放为更小的数字,因为深度学习算法将节点的权重和输入数据相乘,这需要大量时间,因此为了减少该时间,我们缩放数据。
% @* W& _$ W1 @' N* \
  m/ M2 j& D% `  W, B, b, {' }对于缩放,我们使用 scikit learn StandardScaler模块,我们缩放训练和测试数据集:! l9 V: p( ~! ]  F- H* `

- f$ [# u+ @3 t* [; A#importing StandardScaler% u2 {) f  \- r4 ^/ P! Z7 ?
from sklearn.preprocessing import StandardScaler! |! Q2 k0 J8 R7 r
#creating object7 m; g) s6 \. M& U9 l
sc = StandardScaler()
2 [; Z) e4 F: G5 F. wxtrain = sc.fit_transform(xtrain)" P6 u9 A* S5 `5 ]% |6 [
xtest = sc.transform(xtest)0 z2 c9 v) `0 }) g- S. Z( v
0 o3 C& Q  S8 H2 y. x8 ~
从这里我们开始创建人工神经网络,为此我们导入用于创建 ANN 的重要库:  y; X5 l0 ]7 g* s! Y

4 h! z) A5 \3 G. k$ O4 ~8 d#importing keras
- W2 m$ \: r7 N& p/ kimport keras
. R# @. Q* L+ a' e4 k# ]$ ]#importing sequential module8 Z1 w, _8 @: i# A0 B* n$ N. D( X
from keras.models import Sequential+ M$ b: A* j% M/ L1 y9 M$ S
# import dense module for hidden layers
# I; F# b" z2 [3 Xfrom keras.layers import Dense
' k5 K5 U3 I- N7 V  X9 C, I# H# U#importing activation functions
6 ?0 }2 _$ L4 s* s, D, }* hfrom keras.layers import LeakyReLU,PReLU,ELU2 Y! s7 s. y9 z# E3 b, i; C/ O
from keras.layers import Dropout
4 s3 d9 x3 W. S( L0 h
6 W' t0 P* R9 K  p创建层
' M9 [+ |! d. u/ @7 E& g导入这些库后,我们创建了三种类型的层:4 N$ I/ c8 Z* p
; o* r3 f* D* U  ]) }* `0 k  _
输入层7 l; o5 e1 \  e8 E+ r
. d6 R9 i$ Y3 G; S- ]
隐藏层+ b! ?+ C. m) n( [5 v

8 Z* ^% }3 e) X. x输出层
! t& y% @1 j3 |$ N  E  i
0 v7 d2 J0 j) c5 h8 R0 h% T首先,我们创建模型:
$ ~- X! m9 N# ^4 e( K
" [" i- z; I9 N3 V! e2 j" Q! P#creating model* c4 A' h# e- a; N5 [) I+ o$ o
classifier = Sequential()
; \) k' y: k: g, f5 ~2 \& l0 i4 I5 d9 }( G2 ^8 d
Sequential模型适用于每一层恰好有一个输入张量和一个输出张量的平面堆栈。
6 y+ b' s" @7 A5 c( a* L
( r+ g% u4 Q( F/ b, u; `/ Y现在我们创建神经网络的层:
4 ~9 B2 q5 Z& Z" P. X( z
8 h) f: l% j$ G#first hidden layer; }8 m% t& G% H4 w
classifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu',input_dim=30))
& \$ h3 t% P" j" ]1 E$ e7 G#second hidden layer
0 W  e& Q+ a$ l" H6 I& g3 sclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu')); r. I5 T3 g5 S$ j" a; H( M
# last layer or output layer8 v+ D# b5 f" I5 J0 C1 {  N: V: D
classifier.add(Dense(units=1,kernel_initializer='glorot_uniform',activation='sigmoid'))2 O9 p+ \. ]2 Q% _; l5 {) e& T- i

  q6 O& M; m6 G& v  s  @, h. u在以下代码中,使用 Dense 方法创建图层,因为我们使用基本参数。
) A2 Q( G, ?8 s& [( G( {: n* F5 N( {
第一个参数是输出节点
) K, a& D9 Y, j  j/ A; ]8 g. P9 f0 X$ B; s
第二个是内核权重矩阵的初始化器
: W. Y  u- E3 G/ l3 y( h( N% V# D% l: c4 L2 K) I% c7 y
第三个是激活函数
! ]( P- _& d+ c; e5 ]: ~2 G# K" M
0 J- Y; j: U7 T' Q最后一个参数是输入节点或独立特征的数量。
% e4 ^; L4 p: Q3 S4 @
& |2 z& J! v, {8 g* ^4 a% S6 M执行此代码后,我们使用以下方法对其进行总结:
5 [( }" D9 k. H" T#taking summary of layers9 [. V' [2 W2 d- i1 Q4 A! T, s8 z
classifier.summary()9 u5 N8 G& I' c

7 `  K" d; b1 O
: M* L% v9 v/ X% v& p编译人工神经网络
6 E4 f) {% \; @1 p0 c现在我们用优化器编译我们的模型:
7 @2 ?  W0 z9 O+ ]5 t5 ^& y& m3 d, \
#compiling the ANN
* z4 P; _' \5 G% Aclassifier.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy']). E# P( T% `; ^( V/ V, j
6 b& {7 n# w+ O% x1 I- [; A: u' w
将 ANN 拟合到训练数据中' I" |0 }' n9 k( V% x0 Z6 ?
编译模型后,我们必须将 ANN 拟合到训练数据中以进行预测:
; B4 c! R5 E/ v' ?' |+ e& Z
; ]3 R. p) k* {7 m$ b2 X #fitting the ANN to the training set/ z, D' s0 k( Y( M; D5 U3 f
model = classifier.fit(xtrain,ytrain,batch_size=100,epochs=100)& K. S( L3 }7 I8 L4 ~3 W
3 H; t5 q9 z0 e1 F4 p
0 j! ]1 P& D% b- v' v4 s# Z* V
it()方法将神经网络与训练数据进行拟合,在参数中设置batch_size、epochs等变量的具体值。) m1 a( O7 o8 c
  q* P8 l0 w/ B+ `' I2 ~/ p
在训练数据之后,我们还要对测试数据的准确性评分进行测试,如下所示:
. [$ V1 P' b) C3 C
  y  u% h$ r7 h) g- R#now testing for Test data2 t; E, Q3 s0 d# ^: C
y_pred = classifier.predict(test)
7 _! I2 n0 Z- @/ E0 v# N3 x9 L' b; b& K! _3 B. h/ y
在执行此代码时,我们发现 y_pred 包含不同的值,因此我们将预测值转换为阈值,如True, False。
1 O& i# E3 T, ~5 m+ A. _! ~
! y4 n+ O, Q" O4 n, k#converting values  h9 s9 ?0 E. Q0 Y
y_pred = (y_pred>0.5)
2 `$ q1 j, z- J7 D  K1 ?print(y_pred)
& v. v# d$ E9 |) e) F9 d2 g* B8 b% T0 p0 r; d6 u; ^' ~

5 k' I0 _4 r: S5 V: y( j
" Y4 ?) j: y) D! U, C: V# ?0 d- D分数和混淆矩阵) h: V( ]6 z1 I
现在我们检查混淆矩阵和预测值的分数。
/ h7 v  }3 O3 x$ F- C9 {/ K3 I. m) U, m+ f( [+ D
from sklearn.metrics import confusion_matrix( @/ }2 U$ q" k0 O# R: R3 s
from sklearn.metrics import accuracy_score
7 g' x  L* J2 T  N( _cm = confusion_matrix(ytest,y_pred)
/ x, ^" W. M, k" Nscore = accuracy_score(ytest,y_pred)
; C! R' D) A* }0 R/ |3 J+ cprint(cm)
# q! A; f) L. J1 }print('score is:',score)  n+ o6 ]- q4 D. ^

* ?  K: @7 X0 Y/ _/ F输出:9 i6 \2 l6 P4 w' x! ^, t
/ b9 N% r* o& A% g- A& X) Q: j% y
. e6 F- Z! v. a% v$ ]/ `( }

: S2 b: c7 V, v/ c4 z$ U- q3 V可视化混淆矩阵
' F. \- P* F9 |在这里,我们可视化预测值的混淆矩阵1 Z6 G, q6 @1 T0 ?  H
4 T( D; o& z/ X3 [
# creating heatmap of comfussion matrix6 }1 m. e! m( e3 F3 j! n: G
plt.figure(figsize=[14,7])
. }0 k/ {' u8 q- u/ E% Lsb.heatmap(cm,annot=True)" r" x, e9 @. X
plt.show()
- T, o! W" @, [. \
! o, h: j  g& J0 J6 s4 b: L3 |7 e9 p% s6 ~! o9 ~. H

: M# \3 z6 |0 B" Z% M可视化数据历史4 @1 n( }, v0 j4 }+ n
现在我们可视化每个时期的损失和准确性。6 N* q- i6 R. X/ C

, i# M/ v! a4 M4 B! X# list all data in history$ _% u# \& N$ a) Q  n
print(model.history.keys())
* r/ e3 t: b1 _5 D, V% T# summarize history for accuracy% L8 M! n( w" k
plt.plot(model.history['accuracy'])
4 {: G8 n% w* J. {3 h5 p& kplt.title('model accuracy'); w0 ]  M# P. K5 I* X2 N, ]5 `
plt.ylabel('accuracy')
, Y8 I) I5 B& O/ o7 V' W* {! [1 Nplt.xlabel('epoch')
$ O6 X) J& u/ \& Q: C7 q% f& E, W( Yplt.legend(['train', 'test'], loc='upper left')
* H6 k9 ]( _6 Q! W5 splt.show()2 ?0 Z: w5 y/ @# q6 D7 J7 O

7 r1 t' ]1 _6 ]% j2 S+ }- ~2 l3 j  ~% _: g' B: j

8 E! e2 y1 y! e& Z) N6 `
% v: Z1 t* e$ k9 k8 O6 P# summarize history for loss
- t: t7 ?# m3 O, R6 E; A# Jplt.plot(model.history['loss'])
5 I# X# S& v, L4 u% `% v8 ^plt.title('model loss')7 a8 S0 ?% _2 D
plt.ylabel('loss')- s! G$ e  U# r( ]' |( B5 M
plt.xlabel('epoch')
' @$ I2 @2 e3 |* J1 ]9 ]plt.legend(['train', 'test'], loc='upper left')
2 y  C0 x% A" r) T( P% z# a/ zplt.show()! f( I9 D; i' W7 t

' ?  O* y; L1 E7 d  A; c
! Q3 {* p& ?3 w$ c
4 E6 n& g: I. I& z: _  v保存模型

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

7 G) L) Q, v) s: D7 o; @

6 I7 j( D* M% D7 O: e# u
! t8 o5 v; X/ s2 R; n




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