数学建模社区-数学中国
标题: 使用乳腺癌数据集的人工神经网络 [打印本页]
作者: 1047521767 时间: 2021-10-15 17:10
标题: 使用乳腺癌数据集的人工神经网络
使用乳腺癌数据集的人工神经网络人工神经网络. q* v0 N& \) I3 S. ?
顾名思义,人工神经网络,就是人工神经元的网络。它指的是模仿大脑的生物启发模型。可以说,构建人脑结构的通常是基于生物神经网络的计算网络。
O; f% c% l0 m0 P/ Y$ j5 b4 W
8 c* o. x: E6 Q a# B大家都知道,在我们的大脑中,神经元是相互连接和传递数据的过程。它类似于人脑神经元之间相互连接,神经网络由大量人工神经元组成,称为按层顺序排列的单元。具有各层神经元并形成一个完整的网络。这些神经元被称为节点。
! A- b" u. K, a8 [! u8 e7 H; N* t c
它由三层组成,分别是:
, R: ?, p- d0 s4 {9 H: ?' p4 ~( R; @. f4 w) x9 ]# L( Q. U. v
输入层
$ E0 |5 E! Z& e; @2 A( J! y1 t
& d1 Y% m2 d9 L& e隐藏层' m3 }3 x+ \0 ~& ^# K
7 ^: q0 z* ^) w8 c' y输出层
5 d& Y: O6 Z) M& G
/ q/ _& G% Z* p6 }7 ~2 g
* o/ D$ S' S3 ^( O I: q: B使用乳腺癌数据集创建ANN/ O) X5 \: u! E1 l* T
现在我们进入我们的主题,这里我们将采用数据集,然后创建人工神经网络并对诊断进行分类。, d8 ^2 i$ ]$ Y! l8 D$ O; {0 R
/ y- o1 q( M( C/ ?6 j. Y" t
首先,我们采用乳腺癌的数据集,然后继续前进。
5 S1 B7 V9 B, B& C. d1 Y/ d# g [0 n- Q8 k& X
乳腺癌数据集:https://www.kaggle.com/uciml/breast-cancer-wisconsin-data2 w' z2 n! b |7 Z! K9 E
4 E5 K1 N# l" h
下载数据集后,我们将导入所需的重要库。( \( Q+ `: U" z8 r- j
3 |5 r) M% D2 ^3 C0 Y! b# W& T
导入库
% \6 {% x( M# n9 U4 `5 J#import pandas
" ]; g: S: W+ X* Fimport pandas as pd3 W& Q6 B& V% a. Q- |/ u: h, X7 @1 v' b0 H
#import numpy
* h! y% h/ \* u0 Y8 f+ a( X5 yimport numpy as np
4 g& Z9 k6 D. ~ d+ p6 ^8 }import matplotlib.pyplot as plt
; s' m; O* ^0 I. L1 o1 b7 uimport seaborn as sb) t" F: `) w9 @: `4 j
这里我们导入了 pandas、NumPy 和一些可视化库。
' j& I3 ]& p- {) h- p( \' Z现在我们使用pandas加载我们的数据集:
+ c% y& z1 d3 G2 o. H
df = pd.read_csv('Breast_cancer.csv')
2 w# u1 V9 y7 W3 D2 Xdf
2 a. E8 x- e' H$ Z* Z$ V7 H
1 N! Q- i/ @9 D z
. Y' N3 Y" v" \- @/ H在此数据集中,我们指向**“diagnosis”**特征列,因此我们使用 Pandas 检查该列的值计数:
' I2 o( ~. d5 A$ K6 p! Z3 e8 ]2 g6 N W. E
# counting values of variables in 'diagnosis'
1 h2 [' ^) `& Ldf['diagnosis'].value_counts()
, ~4 D( g7 g% P3 V: I/ z6 e
0 t4 \$ h* X* x- W
% V( ~0 Z, A% Q, t1 G现在为了更好地理解,我们可视化“diagnosis列”的值计数。
可视化值计数
5 ^0 k* ?5 F0 ~& T+ i. _plt.figure(figsize=[17,9])
" X) F3 a# i+ ~! Isb.countplot(df['diagnosis'].value_counts()). i* U+ k: S8 s8 T' P% @" Z, y
plt.show()/ r# u# F) k1 O% _% F
7 m( x0 Q+ I4 d' _1 h
& F- N1 k# j K7 f N( n$ U! }空值在数据集中,我们必须检查我们使用pandas的变量中是否存在空值:
4 [/ }# `) L' l% B, e* m$ q
df.isnull().sum(). f+ x1 x# B. t6 g) p4 [# S9 f* n3 L' x( M
执行程序后,我们得出结论,特征名称“Unnamed:32”包含所有空值,因此我们删除该列。
; X. [6 W: J3 |7 }- a. p% ]3 r! a( l0 h. Z
#droping feature) ~. ^& ?! s0 I' W3 X2 b1 a8 |
df.drop(['Unnamed: 32','id'],axis=1,inplace=True)
8 `$ J1 p! m, B, W2 }
/ i: ^" s4 M, K7 ? |7 s( V& P) Z自变量和因变量现在是时候将数据集划分为自变量和因变量了,为此我们创建了两个变量,一个代表自变量,另一个代表因变量。
9 L/ K' f n# ^! [( X, E' _+ q5 J% z! |
# independent variables- I7 C \0 D# l+ {8 j
x = df.drop('diagnosis',axis=1)
, _; e0 c. u& [. T4 ~/ n9 o, `% n#dependent variables
V2 D) j4 C1 i, I. sy = df.diagnosis* C& D% f) ^4 Z$ C, B
处理分类值
, {& P! t6 O8 [当我们打印因变量y 时,我们看到其中包含分类数据,我们必须将分类数据转换为二进制格式以进行进一步处理,因此我们使用 Scikit learn Label Encoder 对分类数据进行编码。
( W2 o; W8 L( K# _
$ m1 k7 E& [: y! sfrom sklearn.preprocessing import LabelEncoder
3 @, @2 j2 G6 s, |#creating the object
5 `* e, Q8 \$ d) I6 p% m) blb = LabelEncoder()
3 @( j+ n' j$ y7 N9 Zy = lb.fit_transform(y)
" {8 `1 D3 M4 u: h* n5 T5 r
" l1 w% ~( ^4 e1 X3 L拆分数据0 N( p9 g1 n+ E0 N9 K3 v
现在是时候将数据拆分为训练和测试部分了:
+ v! K2 j) _% u: }& @) L( p5 Z" [! M" @' z8 @: X6 I
from sklearn.model_selection import train_test_split
! w! Q1 w7 i0 E( D* v1 n0 e% ^xtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3,random_state=40)
2 a" G- {0 e6 h
! ~! G2 e7 i7 b9 ?缩放数据
/ [( c, M" W- b: d8 N" b3 O9 t( K当我们创建人工神经网络时,我们必须将数据缩放为更小的数字,因为深度学习算法将节点的权重和输入数据相乘,这需要大量时间,因此为了减少该时间,我们缩放数据。
2 Y f- e9 D6 f; ]2 @0 C! ^. ]0 p* H# X% \% i
对于缩放,我们使用 scikit learn StandardScaler模块,我们缩放训练和测试数据集:9 ]1 D7 r* {, v& k$ a
- ^3 R. \1 V( n0 C* y& w# h+ M+ Q#importing StandardScaler+ ]) p: m; F; \. l& c
from sklearn.preprocessing import StandardScaler
7 ] m: E6 Y& i/ H3 H) T# R#creating object9 }% y$ \& a a" _0 U+ m; \5 \
sc = StandardScaler(). M2 }8 y( |: X& W" |( x
xtrain = sc.fit_transform(xtrain)
. c& {. E4 |7 |8 ~0 ~3 v, ]xtest = sc.transform(xtest)6 v7 v$ a( Z z
& s/ w* Q6 n/ d
从这里我们开始创建人工神经网络,为此我们导入用于创建 ANN 的重要库:
+ b8 ~) j% e7 G! @( O, G# g: Y
* L5 e8 b& P4 Q' v1 N S#importing keras
1 E3 [) M% `, q, M8 Mimport keras
3 _- Q8 {3 c+ _#importing sequential module
2 h2 }: a0 Y+ }from keras.models import Sequential
d: L, t& G" F8 b P, y+ c- ]# import dense module for hidden layers- c# [4 E( X" \3 ~
from keras.layers import Dense M+ h, [/ R+ h8 S
#importing activation functions5 j# J/ }# a' {3 r8 P3 {
from keras.layers import LeakyReLU,PReLU,ELU
5 `& [2 V6 f w/ P8 Ufrom keras.layers import Dropout* T1 n# D4 N+ a
' ~! T, b" s% t2 A5 |9 c- }5 r创建层
# b; c" ?9 A f导入这些库后,我们创建了三种类型的层:% u# ^8 D/ y$ [8 p4 C# L
# |6 A( | Y0 h2 W+ Y1 [输入层
( T4 t z# R! \5 f
. m3 s. e) j% s E2 B隐藏层" q4 d4 T0 B, Y' G, P @, V
/ Y7 H( ~9 S7 W# F输出层9 V n+ p" _2 A5 w1 R1 }+ @7 Y
t f9 ]5 @( |( \
首先,我们创建模型:
- t6 ^6 F' S# z! I' @0 U1 d0 |" v3 S* s) E$ N5 g
#creating model
# S' w# c( x3 X6 S& iclassifier = Sequential()4 P' V) r+ i/ ]: [' } ~
2 \( ~3 t; v6 w2 S* u8 c/ FSequential模型适用于每一层恰好有一个输入张量和一个输出张量的平面堆栈。, R3 N) _4 U, j9 c, h
! {9 J" o' n2 p1 V, e/ F现在我们创建神经网络的层:7 a# r* q" r5 j
2 D/ p% N8 T* D* L" v1 Z#first hidden layer
: o: h$ V/ m6 K h0 x- tclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu',input_dim=30))7 A/ H _" }! ^) j# ^: ?% ~3 z
#second hidden layer
& h# E2 h1 O, @! W6 Z. Vclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu'))
2 c$ H* Z' g+ z7 L% u% h# last layer or output layer
0 E/ F$ j, l. @! hclassifier.add(Dense(units=1,kernel_initializer='glorot_uniform',activation='sigmoid'))
5 `5 l- R% j1 ^+ U, Y# N
}$ F; G/ w4 ?" r1 s在以下代码中,使用 Dense 方法创建图层,因为我们使用基本参数。
, a M6 w# d7 r E
& y9 ]# J- J6 c( {. D9 k8 \1 z第一个参数是输出节点7 @8 a2 N0 c1 k+ m
; I1 G$ r8 O/ [第二个是内核权重矩阵的初始化器# V) P9 S+ R/ K* \
/ ]2 o6 ?9 ?& M4 s; W第三个是激活函数( R# W+ ^3 n6 M8 d. n5 F
! z1 T' C; i6 Q m: l
最后一个参数是输入节点或独立特征的数量。" }" y D" V: a$ B7 C
2 O2 h/ T3 H) Q6 E- \( Y
执行此代码后,我们使用以下方法对其进行总结:
$ ?- w* Q ~7 Z#taking summary of layers
$ I0 @& T3 m3 m' Z3 ]classifier.summary()+ N7 C) t9 Q% T0 V% \! L

$ j) ~( O' t( |' Y0 u6 C$ H
4 L2 {- D5 y6 ~编译人工神经网络' Y h! F0 e2 m m% h
现在我们用优化器编译我们的模型:! h$ U* g" Q. H" U, A
6 s4 h* u, N$ o
#compiling the ANN, d& q1 _) r) s5 o4 Y
classifier.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])
5 @4 } a/ C' g+ Y& n" ?4 u6 O# \# G/ c" x, W
将 ANN 拟合到训练数据中
+ [/ w+ D7 R4 A编译模型后,我们必须将 ANN 拟合到训练数据中以进行预测:% s$ I% u; Z' u. n# G0 _
/ ^! K% v; G# n3 ~: n9 u, f
#fitting the ANN to the training set! T k, m1 L( [: y1 q9 p
model = classifier.fit(xtrain,ytrain,batch_size=100,epochs=100)/ R/ z0 U1 X7 v( w$ @+ e
6 J0 k/ |8 x( Q1 e, N
5 h" Z8 K1 v9 A R/ a
it()方法将神经网络与训练数据进行拟合,在参数中设置batch_size、epochs等变量的具体值。
, m! ~, W3 q) t( t. s: C
! j5 Q5 ~* y( s: r在训练数据之后,我们还要对测试数据的准确性评分进行测试,如下所示:6 A* F' |- w5 B) [0 t
9 j5 h/ h. K, n1 i/ @! g
#now testing for Test data. O9 N: I' N$ |+ [: ]9 ~
y_pred = classifier.predict(test) q" K/ s: n( R( B
1 u1 E" N% k' T
在执行此代码时,我们发现 y_pred 包含不同的值,因此我们将预测值转换为阈值,如True, False。
" j7 S, H6 \* o& z, @- w5 R
. q; _0 {" I: I+ W#converting values6 I! i+ T0 p8 {6 a3 q
y_pred = (y_pred>0.5)
4 R% C) z9 P& {7 U4 W. G/ q- Y; k; Uprint(y_pred)
' e3 S6 f& F( |# I: E+ m6 N& h t# M+ H4 X
9 T# Q' {( r+ p' I" k/ ?$ S
1 b* _1 g( e# @( d
分数和混淆矩阵
" o2 A3 ?2 X' R# N: ?/ ?7 _5 K; y2 b现在我们检查混淆矩阵和预测值的分数。
+ y" I. g: a/ p$ L8 S
/ x# X; n0 F& i+ \; Xfrom sklearn.metrics import confusion_matrix. a" S M6 Z# A3 K
from sklearn.metrics import accuracy_score# |0 z8 J+ @1 j, v3 o9 l2 S
cm = confusion_matrix(ytest,y_pred): R% V6 v3 `& e
score = accuracy_score(ytest,y_pred)
. ~) m! y3 o. C5 M( vprint(cm)6 r" ?- k$ ? h1 E; s8 I; N
print('score is:',score)9 j6 \0 n5 [8 `& x: L
$ z5 X/ b; x% ]# L1 w
输出:
4 _" d- X& r5 l" s. l( \1 D4 w
]: e2 r; }" Y$ H! g4 Q2 N" u* Y3 v+ U% @6 c5 d. l0 F8 N8 D' S
. v8 P; V$ }4 f; m- P. M可视化混淆矩阵; d9 J0 ]/ A' d
在这里,我们可视化预测值的混淆矩阵* H. W& t p- [* w# @& y3 N1 i
$ r; K6 g8 _$ P. L0 |, Z3 P# creating heatmap of comfussion matrix
: s: T! y0 |- e, M; W8 R7 A+ qplt.figure(figsize=[14,7])% P6 I6 x1 e2 \" d- {+ R; h$ O4 ?
sb.heatmap(cm,annot=True)
, M/ @; `$ x9 N6 g! x% Nplt.show()
4 |. @9 I7 \/ @8 t9 m3 D+ [& G+ u' M0 n) Q
; n& K/ A* ~" m5 v9 `6 W$ |
$ o) s0 N- P6 W! u
可视化数据历史
, Y4 o1 j: q) {现在我们可视化每个时期的损失和准确性。7 a9 A7 p! Y2 B2 [
! B$ O" Z9 V3 _* }8 Q0 j0 B
# list all data in history
+ y! L* G: ~: x; e4 h+ oprint(model.history.keys())3 l( ?+ h/ w6 O; W: r/ V/ `8 d
# summarize history for accuracy
. M0 @$ n5 `( P0 g/ N+ kplt.plot(model.history['accuracy'])
$ [3 U0 S" f) f. uplt.title('model accuracy')
2 a% e% `# o. O, x0 {! @plt.ylabel('accuracy')
" N) E$ \. ~" k/ U+ `5 f8 xplt.xlabel('epoch')
. H* \4 S0 Z2 @: yplt.legend(['train', 'test'], loc='upper left')& ]+ a& x; G7 Q' _: i
plt.show()0 E8 \& j' ?" f. `1 h, G. V
. u* L& t4 L: [9 q9 Y' Y. u9 y) r
- M% `) P, {5 n+ d
; H9 G7 ` M6 ~' g9 |( Y2 {9 S5 ^( Y; ^: z0 y
# summarize history for loss
# y, P3 a0 G% ?, Mplt.plot(model.history['loss'])
5 i2 j, V7 u3 d2 u5 Aplt.title('model loss')
! [0 U; j* V' M0 nplt.ylabel('loss')
: _0 j3 e! p3 `/ xplt.xlabel('epoch')
^* i" ~; z" Z4 ?( l2 x! q8 e* F+ Uplt.legend(['train', 'test'], loc='upper left')" ~) p+ D/ s# N0 d3 W
plt.show()$ I9 c7 W: `* ]9 v" L s y1 G
# Z* m4 G- R* ?# d# J( k4 g" y% W
. `3 v1 S( G' [5 ]6 l' M0 j! Q! c8 f Q% U: N
保存模型最后,我们保存我们的模型
- 8 Y. V- J0 y. {) ^+ x7 }0 V, H0 n
6 C: y3 P+ {' ~) t2 I2 N Q
#saving the model
4 Y/ ^6 @, `8 W/ w' U
( H5 |! r" a, r& N( y: N
4 L( |* R$ ?8 e! o1 p3 a* z! q5 j$ A+ ?9 }
classifier.save('File_name.h5')
( M3 p5 v% H8 d; X1 D9 w! {. j5 k: T* k
; C6 p( o% @& O: y) I
/ C( t3 Y9 s o, ^- C- i
6 U3 z% X+ D$ n# D
& y+ d) {5 B O d3 V
" Q8 r/ r7 F! L& d q+ R. {" ]/ l- `. i8 b1 u: N8 m2 _
| 欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) |
Powered by Discuz! X2.5 |