使用乳腺癌数据集的人工神经网络人工神经网络* F0 b' T# u( b$ ]
顾名思义,人工神经网络,就是人工神经元的网络。它指的是模仿大脑的生物启发模型。可以说,构建人脑结构的通常是基于生物神经网络的计算网络。
' s$ a3 |, ~8 s v, G- d/ ]
0 A; A2 _( |8 k大家都知道,在我们的大脑中,神经元是相互连接和传递数据的过程。它类似于人脑神经元之间相互连接,神经网络由大量人工神经元组成,称为按层顺序排列的单元。具有各层神经元并形成一个完整的网络。这些神经元被称为节点。
- y' |0 ?6 P p
, S) r' ^) K- v. t它由三层组成,分别是:8 Q: [9 S- o n, \
# N& i9 r3 K. D2 G- I- J
输入层) s+ T9 f$ {$ i2 r# ^% b
! S0 `. |% g) g; m隐藏层 P6 v' Q1 Y! Q; f
8 u3 [) w+ m0 h% N# @输出层
* g- i: g0 l& K8 k: y, C. e8 X![]()
1 p; t& r: j' B
7 ]$ @( S; @6 z: U; f使用乳腺癌数据集创建ANN
5 p+ W8 u5 p4 M, u现在我们进入我们的主题,这里我们将采用数据集,然后创建人工神经网络并对诊断进行分类。
. q$ ?9 l. C9 g9 K
( \' l/ _, m3 B# Y! ~7 L首先,我们采用乳腺癌的数据集,然后继续前进。! ~4 ~& Q! |5 ]4 B- U E1 m* a
) @: l( ^5 Q9 F: v+ i2 D乳腺癌数据集:https://www.kaggle.com/uciml/breast-cancer-wisconsin-data
% i1 n$ I. J! O+ E& t3 S: K( W/ I7 ~3 J) ~* @
下载数据集后,我们将导入所需的重要库。
* Z; Y, w$ d5 Z: v+ b8 x3 ^# R8 K4 L/ n2 T' U, t
导入库7 }* W+ y0 b0 V. W
#import pandas
/ g" g! n7 C! y8 E; \import pandas as pd
0 A# Y% W8 Y! {5 a$ [6 z# K" q#import numpy
5 p1 q( |% i( w& v; e7 _9 Ximport numpy as np
: v" Q/ C K* P0 J. yimport matplotlib.pyplot as plt
! f% n, L) v6 c6 t' H- K w7 u$ Ximport seaborn as sb1 O7 A3 F! e9 |4 Y9 G2 k
这里我们导入了 pandas、NumPy 和一些可视化库。
1 t1 c- Y) z+ o- B* N现在我们使用pandas加载我们的数据集:
3 X E# I6 b, S0 G% s8 Q M4 Jdf = pd.read_csv('Breast_cancer.csv')+ |" Z! F; s3 d, U
df0 Q, k$ Q; R C5 }
3 v6 ], |: V) O! R9 o x6 @
* A5 j# F! Z. _$ K+ Q& |+ e- O
在此数据集中,我们指向**“diagnosis”**特征列,因此我们使用 Pandas 检查该列的值计数:' ]: x5 W: \4 x, `8 A
) n' `, a3 c1 ]5 S% X T7 [( L
# counting values of variables in 'diagnosis'
. T* |2 S2 b: Y' \" \% X, ~df['diagnosis'].value_counts()5 s4 ]0 }8 A, {9 J
7 p1 R" K( o7 T; Z; t' N( k
; J# L9 a7 [6 v. N* }现在为了更好地理解,我们可视化“diagnosis列”的值计数。 可视化值计数
, J: Y1 a4 X& Yplt.figure(figsize=[17,9])
5 u2 ?. q! W+ Y" u# D, c& E* lsb.countplot(df['diagnosis'].value_counts())( o V) _5 P8 C5 v8 }+ y; F
plt.show()
, G8 F6 Y% F& N% H0 o ![]()
5 Z! s* q. @3 q, _% F1 Z& A6 W
4 x7 L. z4 v0 y/ s1 t8 x) `空值在数据集中,我们必须检查我们使用pandas的变量中是否存在空值: # R; z" Q7 D/ B' p
df.isnull().sum()
+ O/ k' s( @$ D+ ~! q% n& k7 w; {9 n 执行程序后,我们得出结论,特征名称“Unnamed:32”包含所有空值,因此我们删除该列。& b9 f% Z: I( _+ o8 W/ f
/ ^% P9 R6 Q" P* X! Q3 [' l% w! G
#droping feature' \! S8 D9 i! c4 R
df.drop(['Unnamed: 32','id'],axis=1,inplace=True)
. r& ]6 y; Y0 E% r& z7 [* [( G6 B9 h8 P, |: u
自变量和因变量现在是时候将数据集划分为自变量和因变量了,为此我们创建了两个变量,一个代表自变量,另一个代表因变量。
2 N) d8 `2 S4 w# independent variables4 e8 x6 Q4 r: V7 M: y% `0 ]
x = df.drop('diagnosis',axis=1)3 A, ~! g0 L; _# [! n
#dependent variables
6 n5 l" u0 `3 ^: {) B8 T0 V) ^: ?y = df.diagnosis
0 F3 S/ L. {2 B( k8 |; c/ _6 j 处理分类值
& N* d) s- q* B' N4 z) \6 }0 V- S% l当我们打印因变量y 时,我们看到其中包含分类数据,我们必须将分类数据转换为二进制格式以进行进一步处理,因此我们使用 Scikit learn Label Encoder 对分类数据进行编码。
2 S! \, O7 Q6 J& x/ r, D- K L( F! U7 G# M8 L
from sklearn.preprocessing import LabelEncoder, _- j5 I- T" |8 G7 ?
#creating the object
Z' L8 q9 u9 L m: Wlb = LabelEncoder() E/ W) o% q+ D Q( j
y = lb.fit_transform(y)
" H$ t3 n3 s/ ^& n1 p+ ^6 J5 K5 T+ c& T
拆分数据9 k6 h$ Q5 S' D" E
现在是时候将数据拆分为训练和测试部分了:
6 `3 F8 q, N& [! H0 J! M/ [ A$ s2 d. t: P
from sklearn.model_selection import train_test_split, G7 P, h1 M8 N3 K% R& q2 h
xtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3,random_state=40)
/ p6 S/ U7 K0 g
5 |, M1 I- |% W! A缩放数据
& }0 [3 h+ q* H当我们创建人工神经网络时,我们必须将数据缩放为更小的数字,因为深度学习算法将节点的权重和输入数据相乘,这需要大量时间,因此为了减少该时间,我们缩放数据。( d! j0 A# H2 p5 p
7 i' [* p) c2 w7 S6 u- R$ }2 I
对于缩放,我们使用 scikit learn StandardScaler模块,我们缩放训练和测试数据集:
* a' l% ^% f/ r. s
4 e I, i% A" K6 x8 \! L) J" a#importing StandardScaler; u& @6 z$ S) F+ t% Q
from sklearn.preprocessing import StandardScaler3 z6 D' }) \( I" U
#creating object% A' M! V7 ~1 ^ Z) t T! x7 {4 W6 p
sc = StandardScaler()
5 W1 U% m6 u0 J$ l, @. _3 c# w! j3 I+ Dxtrain = sc.fit_transform(xtrain)
2 P/ ?# L% \( u( Y7 t5 Axtest = sc.transform(xtest)
( c6 A( i( [. Y' o' f9 O- |' r# l; V F0 [4 ^( G% [
从这里我们开始创建人工神经网络,为此我们导入用于创建 ANN 的重要库:# E$ K' e- N6 Z* _8 x7 o5 z
" R8 I8 W, {. l" G# N
#importing keras/ Q" Q* S; l' {1 B" [) b
import keras
2 t6 k% R$ b. Z#importing sequential module Q" m u2 H0 x7 k- J j
from keras.models import Sequential
& f0 I6 ^8 b5 i+ |# import dense module for hidden layers
r' @+ g; K' d9 b4 y1 G Cfrom keras.layers import Dense" s' l7 j+ f% {% |- a
#importing activation functions! ]. N8 Y3 y( d$ M1 e, G$ r
from keras.layers import LeakyReLU,PReLU,ELU
" P! N* R& s) q+ c& i+ @$ D2 Zfrom keras.layers import Dropout+ N4 i; U$ P K" Q5 W
8 f6 Q( z" d$ v7 O5 c, x, z创建层, h2 I) X. c) O4 ?, v# ]1 x2 B ]
导入这些库后,我们创建了三种类型的层:
' I3 }1 `5 R9 r# o2 \; J
- b5 V: F0 j- |* W9 K* W" w8 l输入层
! U. o* J/ ~" i4 l2 q) t
! p H: E; n D, j6 ~" o6 j隐藏层2 }+ H0 i5 s" V5 ]
3 `& ^0 x' v c输出层
x. i: [* ^1 p, ?0 X9 X: v. I( K" r/ z9 v; O( ~
首先,我们创建模型:4 `# L3 m& ~: N' a9 Z
% O! r8 z% q2 m- m( T
#creating model9 m! {, E3 \. d% H" b
classifier = Sequential()
4 l" @( R/ t k8 F
6 N c; Q( V6 J) }5 `. l% l+ `Sequential模型适用于每一层恰好有一个输入张量和一个输出张量的平面堆栈。
' @1 l3 P( U4 S7 x2 M4 I
( X3 b! L) `& g+ ]; q现在我们创建神经网络的层:4 S" _2 v; s2 J
# i. a+ {' @! A#first hidden layer
' _7 ~, c$ \) C9 H/ }7 c U3 Xclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu',input_dim=30))
$ w1 ?, u# E' K$ X; k. I#second hidden layer
( e) N! _1 q% t' v3 Gclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu'))
5 E9 z ?/ V5 C* n$ A. n# m1 H" j. ]# last layer or output layer8 F& O" f- b, ^8 T% l% S8 R
classifier.add(Dense(units=1,kernel_initializer='glorot_uniform',activation='sigmoid'))
; F4 M6 d$ v* o! A8 C; A) b" O
, x @- v. p. T' x: O& Z8 s在以下代码中,使用 Dense 方法创建图层,因为我们使用基本参数。* p, p' ^% f* ^* I+ a" b
; E7 ^5 h& J) W0 V, V8 E; _. K第一个参数是输出节点
! d8 F4 A* D7 V9 g( I
1 [; `4 k: o# k5 N2 S: C第二个是内核权重矩阵的初始化器. k8 \0 ]& [: ]3 S8 {2 P: M3 Y
) a9 N" N- J. ~0 k! r3 \! {
第三个是激活函数
+ Z |7 f6 T3 ~) \+ T- W
8 M7 h( y# Z* U3 K& F1 W, X最后一个参数是输入节点或独立特征的数量。( q- ~9 }- b4 M2 r
& M3 L+ Y; {/ k7 A% W
执行此代码后,我们使用以下方法对其进行总结:
5 v( N$ H/ t8 L8 B#taking summary of layers3 m0 j- f+ V$ D, x+ e: f/ ?
classifier.summary()
& o( J3 U, t. t: l6 E- s; M 3 p, w3 c u: t, d" f
5 ^8 Z9 S: p# m8 b) \. E编译人工神经网络
! {3 D( _4 p i" f4 O现在我们用优化器编译我们的模型:- e' W5 F9 l+ X# N: _* C. Q
0 e- t& }0 p9 ?& I/ S: n#compiling the ANN
4 @/ w$ C j9 F8 _% ~4 bclassifier.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])
: O0 V0 k( c8 b/ @9 C: F" y/ s: t) k) P; K
将 ANN 拟合到训练数据中
7 b( m9 M" m/ D* N0 ]# n4 |# s编译模型后,我们必须将 ANN 拟合到训练数据中以进行预测:
3 t9 I% S& I% ]; K
+ `; k! L d" a #fitting the ANN to the training set
' j& z1 [$ D" N2 B' Kmodel = classifier.fit(xtrain,ytrain,batch_size=100,epochs=100)1 `! `. x9 Z; J) A( a" M
![]()
; d& w1 C1 a2 p$ `
7 R2 y$ m8 a+ y: X0 a; vit()方法将神经网络与训练数据进行拟合,在参数中设置batch_size、epochs等变量的具体值。
7 n5 v9 ?7 M7 v9 @3 [7 g- N f
0 h: O' G( S/ K# i在训练数据之后,我们还要对测试数据的准确性评分进行测试,如下所示:
) Y# W3 O8 w# L& d0 g9 ~5 Z5 D J5 k3 ?' H$ c) `- W
#now testing for Test data4 x3 H6 k5 e* M, W+ p3 n/ W) v
y_pred = classifier.predict(test)
8 [' q7 }2 |, _9 \8 _
5 {# x4 S& u6 U' ^: m! Z$ X在执行此代码时,我们发现 y_pred 包含不同的值,因此我们将预测值转换为阈值,如True, False。9 m2 y2 K- S* P: ~% A
* V! B! x. |4 q( d2 M#converting values' i- W3 X! X9 z& C
y_pred = (y_pred>0.5): B- a- |8 X3 j2 ?) h* t2 V
print(y_pred)
, J, U) K9 C+ i( ~3 x$ H4 H
/ n- J- h- D/ B: e8 b4 M( y$ m" d+ K
7 O* e9 D8 G- D分数和混淆矩阵1 H; b2 D8 q% H. K+ s+ G
现在我们检查混淆矩阵和预测值的分数。# l, U/ N4 F6 e: z+ I( ]8 w
: `- m J {' W" f8 ]8 bfrom sklearn.metrics import confusion_matrix+ Z% k' y9 t% l4 u2 M4 p7 [2 N
from sklearn.metrics import accuracy_score
$ m- L9 P( U8 S1 i7 |cm = confusion_matrix(ytest,y_pred)
" _1 |. \" V6 A9 I$ l6 g. Jscore = accuracy_score(ytest,y_pred)3 n3 V- W! Q$ }2 v
print(cm)# i5 j# q5 p3 p+ V# e
print('score is:',score); h% [9 E- G2 Y8 L
: @0 H( R) E/ z: m4 H1 c% A0 w输出:' u5 u* z4 Z& y0 n7 m, W- g7 o
! @) m, k( R& T- `8 b" n
/ v; S, U9 F' H8 w4 E: N ~
- Q. w! h! b3 N m
可视化混淆矩阵) r( q6 I, N$ m: S* i3 x( w4 E% @( e
在这里,我们可视化预测值的混淆矩阵
( i: c, R U( X5 F+ A/ k* B/ `. Y) T4 C ?/ c K6 W1 d
# creating heatmap of comfussion matrix) z1 o' s) L) W7 c* R# Y- [7 s( ?7 K
plt.figure(figsize=[14,7])
/ i! O, W( _* T6 f( msb.heatmap(cm,annot=True)
9 @: ~* d4 H; z# Kplt.show()! V: U8 u# n/ V1 v) }# s
, h1 ^- a7 b. t( V![]()
* c5 N2 w+ Y3 O$ J/ n8 r$ i! W- g' n+ [: m2 }% M
可视化数据历史, S) K0 c7 g& T" H) p8 v
现在我们可视化每个时期的损失和准确性。
, |( X& Q0 H, x" E9 q
+ h B: V) {1 u4 p7 i: q# list all data in history3 h& z+ P+ v) x* p. {6 x
print(model.history.keys())% Z! G9 F2 n7 `5 X" ^$ o
# summarize history for accuracy1 B+ I! r6 _" H7 J' W8 O! l" f8 G1 }8 `
plt.plot(model.history['accuracy'])& l' Q! X7 B1 J( I4 i$ ]) t
plt.title('model accuracy')3 E( B/ ^0 K6 V
plt.ylabel('accuracy')
8 w* f6 ?+ R5 L" `1 r: mplt.xlabel('epoch')
9 U2 U# P' v: W* {; qplt.legend(['train', 'test'], loc='upper left')
6 \) e! k) R$ j0 Q0 H0 Z; P1 Splt.show()
) O0 o# @5 ~( Z* r. I- [; l: e" q; M! M" p. ?, C
![]()
. I" B+ T: v, K/ a6 @3 `
7 P* C) D: W$ a y$ c% x1 V! }. |& s) \
# summarize history for loss
! R- |8 J% Y" h: E$ ]plt.plot(model.history['loss'])
5 s% [& ~/ e$ ~. xplt.title('model loss')
3 i# Y1 y" {: i& o }$ j- Nplt.ylabel('loss')* M1 a4 F1 |3 h. k! ^
plt.xlabel('epoch')
. v9 A; U% q/ Rplt.legend(['train', 'test'], loc='upper left')
: l9 y k8 H5 Vplt.show()1 Z: {! Q2 v+ i
( Y- s# h- P) R$ w" G3 n ' O$ Q m! v! j: R! C. h
% c+ m" G, V) t, @1 n0 q保存模型最后,我们保存我们的模型
6 z k7 L3 g$ J7 P. g/ V- Q2 _, _# B3 Y$ Y' }' z6 X! r7 z: E1 S
#saving the model/ t- c, E4 [# b. [; Q# p# y
7 P. B1 Y" |; @8 D
6 |) B0 t* C9 ]% g3 M9 p6 T/ @3 |& {
& K8 P" C/ g* T+ mclassifier.save('File_name.h5')& P' {! P. R) L y
+ `' R& L Q/ }: b, D, v* C8 _0 E- x- ! z; z1 Z$ E% \1 l
- w! ~) F# ~2 J, q( T8 i* L
; w5 }" O3 [2 g" t& O* A5 q
6 ^8 o: v, a6 O1 Z
7 R5 `5 X- M9 ^ |