使用乳腺癌数据集的人工神经网络人工神经网络! N S. k& o$ |( H1 V4 P
顾名思义,人工神经网络,就是人工神经元的网络。它指的是模仿大脑的生物启发模型。可以说,构建人脑结构的通常是基于生物神经网络的计算网络。
/ {9 a: Y6 S# X, G5 p4 r2 x d
. \" t0 ^7 `( i大家都知道,在我们的大脑中,神经元是相互连接和传递数据的过程。它类似于人脑神经元之间相互连接,神经网络由大量人工神经元组成,称为按层顺序排列的单元。具有各层神经元并形成一个完整的网络。这些神经元被称为节点。/ N! j$ X4 K3 }" G
0 p$ F) g7 Z2 T' }3 R它由三层组成,分别是:
! m: S2 @$ z) g# z* o/ P" y7 P& i+ m+ w" u2 ^: O
输入层$ f& ~6 {( c) P7 j! C
, b$ I4 O- ]8 j! p" v隐藏层
|/ K1 q5 f+ n9 R+ @# S2 w' G% \. z! _6 O* b: J+ B
输出层6 R( v8 w9 s, H) z: B, V# l
![]()
6 v* p- @" R, [1 @3 s" E5 [- d8 |3 @
}! ^: C) |! A7 {9 b使用乳腺癌数据集创建ANN
( g9 I/ f: l D. n& k; Y0 Q现在我们进入我们的主题,这里我们将采用数据集,然后创建人工神经网络并对诊断进行分类。
! p" ^0 s3 W7 H$ F" H% @
# l ~2 T) k" |7 L* y/ ~; n首先,我们采用乳腺癌的数据集,然后继续前进。9 G9 ?0 v0 d# T- M3 t
. ]/ R- V% ]. S" h% M乳腺癌数据集:https://www.kaggle.com/uciml/breast-cancer-wisconsin-data+ k0 b) h" R9 n# E4 x1 H
% J( c7 M: U! f2 Z% Z
下载数据集后,我们将导入所需的重要库。
# T" n, g, I, n9 M% P) m! F6 U/ ~! l
导入库) N# m& q6 t# @# @( A% ` R
#import pandas, T, H( U& F) L* A. p9 m- E0 ]
import pandas as pd
; {1 h5 ?: V* Y7 Y#import numpy
9 h$ A1 u$ s6 r; Yimport numpy as np
; ~, e/ ~5 u& U, Limport matplotlib.pyplot as plt% o! l2 n2 K6 {. n# ^
import seaborn as sb- j! k8 V) K; E) B$ q0 D Y' M( O% T
这里我们导入了 pandas、NumPy 和一些可视化库。9 V; T( {, @. I1 E' U" n2 i; Y* B
现在我们使用pandas加载我们的数据集: ; I! ~5 n. T. P1 D) R! `
df = pd.read_csv('Breast_cancer.csv')) s# m# s7 b0 ?
df
' U' N. L- g& U2 H: w ^ # ~9 n/ E" e" N1 C
( y" h( Y/ e _" V8 q! D! a在此数据集中,我们指向**“diagnosis”**特征列,因此我们使用 Pandas 检查该列的值计数:5 x: E" K I% C+ N8 g
5 R+ y8 P% F& S0 w( S# counting values of variables in 'diagnosis'
% I \$ |; f. Y8 y- m5 E8 Rdf['diagnosis'].value_counts()
' J: n& b* C7 _ ![]()
6 T; H4 g- k# I. z) `* }5 Y0 ~" I" I0 m$ p& j* _
现在为了更好地理解,我们可视化“diagnosis列”的值计数。 可视化值计数3 a% x5 D c! X. G
plt.figure(figsize=[17,9])
|' M. i; K5 }9 ]sb.countplot(df['diagnosis'].value_counts())
: J5 d& i/ z( A; a% ^plt.show()# t; M5 ^ E2 m- O( p5 l
![]()
/ n a! ^, T8 [: o- q
" [9 q6 {1 Z4 y, ?! [5 C) L空值在数据集中,我们必须检查我们使用pandas的变量中是否存在空值:
. m7 D; z# r# [1 J. fdf.isnull().sum()" i' L2 S8 V, \4 k6 [& \
执行程序后,我们得出结论,特征名称“Unnamed:32”包含所有空值,因此我们删除该列。
) o( F! t6 `* l( }) J5 [' g5 b, Z, B# o# m
#droping feature
2 j8 v& c/ I. D& S. [df.drop(['Unnamed: 32','id'],axis=1,inplace=True)! |9 M0 ?: k3 f
3 w- j0 O( _& M- {自变量和因变量现在是时候将数据集划分为自变量和因变量了,为此我们创建了两个变量,一个代表自变量,另一个代表因变量。 + P. e: J# Y x2 C9 G3 c% E+ I( R0 h
# independent variables
- a, r0 y' ?+ e' S& ax = df.drop('diagnosis',axis=1)2 k, {* ~7 L4 U8 U- {7 S
#dependent variables8 a8 U8 w) P4 N* `$ B
y = df.diagnosis
$ g [5 l* l5 {5 i5 z 处理分类值" d% U8 N$ a# y. [" {' k
当我们打印因变量y 时,我们看到其中包含分类数据,我们必须将分类数据转换为二进制格式以进行进一步处理,因此我们使用 Scikit learn Label Encoder 对分类数据进行编码。
) k. L6 s7 T# h- [
, a5 x0 P* i; m3 G* P3 P2 v1 qfrom sklearn.preprocessing import LabelEncoder
2 G5 Z0 \( t3 [#creating the object9 |6 C9 j: I& ]
lb = LabelEncoder()
* \, j# T; X+ q& O$ ~1 N3 vy = lb.fit_transform(y)
8 s& k# Z0 q) W3 e- g$ \2 q6 n7 D) G2 h$ E" [) m
拆分数据' _( \7 O# k' u* a' H. [" C
现在是时候将数据拆分为训练和测试部分了:0 L. ]5 V5 t* M7 O/ W* c: a
" B& T* V' e) P+ h+ m) e6 Ifrom sklearn.model_selection import train_test_split+ f: p! u' Y6 ?7 n- Z6 X, C
xtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3,random_state=40)
$ ]8 ^* V8 q4 L5 K. ?- V0 p
( a6 M' J; e( n9 |+ J' S4 p* Y缩放数据
# v- k0 |" }9 I& p- D |当我们创建人工神经网络时,我们必须将数据缩放为更小的数字,因为深度学习算法将节点的权重和输入数据相乘,这需要大量时间,因此为了减少该时间,我们缩放数据。: C. h7 q. Z, |! g
; L" m+ g O4 u! c( L' z' v对于缩放,我们使用 scikit learn StandardScaler模块,我们缩放训练和测试数据集:
& [. h% ~& _5 V/ m
" a" B5 O6 d' _6 f2 F* ?#importing StandardScaler
2 h* ^3 J! T) w/ @: V# f; q/ x) Jfrom sklearn.preprocessing import StandardScaler* n6 R% v) t: l
#creating object% C: m6 L$ Q+ x& T+ O
sc = StandardScaler()
$ r; E o) j) ?( s5 x2 h. d6 G7 ]xtrain = sc.fit_transform(xtrain)
, j* W0 T* E( j$ q: j5 }xtest = sc.transform(xtest)
" Q: |9 {& k4 k9 G0 p9 {3 j; j8 [3 M# j- O- l/ E' l7 R
从这里我们开始创建人工神经网络,为此我们导入用于创建 ANN 的重要库:: D' V, I3 H, ?# z- l$ K
: U% f( l% ~7 A1 v#importing keras
/ ^. {5 o3 y* ^import keras5 {* m# \: C5 o
#importing sequential module
/ f3 S) A5 N1 e2 N9 Tfrom keras.models import Sequential# i# ~) |' Z3 }, @7 h
# import dense module for hidden layers
! J" z& F0 F+ Lfrom keras.layers import Dense d& p# ]6 n+ e7 X+ D3 `
#importing activation functions% h! R; n$ u2 s
from keras.layers import LeakyReLU,PReLU,ELU
8 u, @; H; b afrom keras.layers import Dropout* l3 K. P2 o4 E0 b: f- O
( D0 T0 B' J6 E6 }7 }+ N$ E
创建层
4 Y' |) x! | h. E- j导入这些库后,我们创建了三种类型的层:2 U& [2 t) T4 ~2 P" S
; a, N! x) F$ }: W
输入层
* o, N& u: J& j+ J% |4 W; f( W6 n2 f4 ?; _0 ^+ c
隐藏层) X" W/ [) B t6 T# I
% M# z% i: u5 J0 ^. O0 g输出层
1 Z2 K3 r0 O4 n* N) C& t. W, a) \' C: z
+ k5 J, h$ G, h0 g) S, z) s首先,我们创建模型:7 u$ P4 U3 i5 F
9 B( |/ x% ]# |4 Y5 \
#creating model
+ n2 K3 g+ X( {6 B2 c" I i& Qclassifier = Sequential()" Z8 L T; L( B( @9 F6 ]% ~: P& g
2 S+ H' c7 d) T2 }' @. HSequential模型适用于每一层恰好有一个输入张量和一个输出张量的平面堆栈。+ p* y$ P3 P7 A8 n# _
& n: F. I5 H' c* e J! {! v' c+ G
现在我们创建神经网络的层:
1 W- p! P) h6 q* f& S- r
$ s' i/ B1 J( b2 L5 U, r8 Y! @#first hidden layer1 C0 i6 u3 v: B# N4 s" u7 k
classifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu',input_dim=30))2 r. L' G/ L) f
#second hidden layer
3 c% _1 G* P( b& s# [; C) u2 _classifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu'))8 Z% F; K4 i5 _* P$ {
# last layer or output layer
1 z) S1 ^7 B) F) {classifier.add(Dense(units=1,kernel_initializer='glorot_uniform',activation='sigmoid'))
6 ~0 T! ?7 W- i# z/ u: k1 A% x* ]$ T5 X+ D; h3 j6 z' K
在以下代码中,使用 Dense 方法创建图层,因为我们使用基本参数。
0 y& m6 B8 z$ G. W8 p2 _$ C3 k, Z, P( o+ i3 M- R9 ^. g, R
第一个参数是输出节点! p: y! s0 u9 P- h8 p+ @
& m) `7 p8 Q7 u* p. g第二个是内核权重矩阵的初始化器
4 Z" _, x, c: B# g& e9 U1 p
4 @/ {" z) V3 p3 b$ Z第三个是激活函数8 J( X8 _; j; X( Z- w( q
* Y+ y) }3 C. E- X
最后一个参数是输入节点或独立特征的数量。
; y4 a; {. E. Q [7 W1 d
3 t/ s, n; }8 b8 }4 m7 R执行此代码后,我们使用以下方法对其进行总结:8 ^$ u3 @9 v/ o
#taking summary of layers6 ^; l1 p, l# n8 X3 s l' Z
classifier.summary()3 k5 {. q2 |' o1 b8 U
![]()
- G; J3 P4 W0 C, U5 Q9 S t. |6 i% e. Z/ R8 Z: d* r; z
编译人工神经网络
4 ]$ h; @! {1 l2 c. {现在我们用优化器编译我们的模型:( I& b" g6 U; Q
* Q1 @& Z+ a) ]
#compiling the ANN1 A; _. i6 W3 j9 V
classifier.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])
5 K1 ^2 \* U8 \' i! Z/ e
5 m( {( ]1 G/ V- p将 ANN 拟合到训练数据中; i2 R5 y; l8 z# p# J% }
编译模型后,我们必须将 ANN 拟合到训练数据中以进行预测:9 I# k6 q4 ^. c+ S* w
' r2 e2 B4 \" a. O6 { x( U) A
#fitting the ANN to the training set8 K+ G1 Z; B' J @! P$ C
model = classifier.fit(xtrain,ytrain,batch_size=100,epochs=100)
1 Y: i& {3 @! p3 b% {) i ![]()
- N( l3 ~$ H1 \5 A- e
0 ]7 v" l2 \) w8 cit()方法将神经网络与训练数据进行拟合,在参数中设置batch_size、epochs等变量的具体值。
1 D5 N, }: w4 ]. H' U4 h
! z) E* ^1 ?/ i在训练数据之后,我们还要对测试数据的准确性评分进行测试,如下所示:
% g! q1 K! h" u
1 D5 }0 m: e `#now testing for Test data
; ?, V3 T. S; q( Hy_pred = classifier.predict(test)
; {8 a6 w- I6 z0 ^: t( n" W6 `6 `' W
在执行此代码时,我们发现 y_pred 包含不同的值,因此我们将预测值转换为阈值,如True, False。
, b h2 Z1 }8 L
: y! H7 `' v8 ` k0 l6 I#converting values
8 D6 t1 f7 R7 r! [ ny_pred = (y_pred>0.5)
1 f! \* L( V r$ D" Cprint(y_pred)* O# s4 s8 l a( A
) o4 F$ p, Z6 l
: K) M( G7 A& ~) w
! N" d$ {9 s1 \( ^8 K. k1 C分数和混淆矩阵
" T0 @/ w; C$ f( j1 A现在我们检查混淆矩阵和预测值的分数。
- r( |- z R% x
* `: c- G% |# ~! a' Y! p: F2 K) Jfrom sklearn.metrics import confusion_matrix( l0 s# P# [! ] i! U
from sklearn.metrics import accuracy_score/ t, ^: y$ e* s6 z2 Z, O+ |
cm = confusion_matrix(ytest,y_pred)
; [, i% h' P3 cscore = accuracy_score(ytest,y_pred)
# O/ U5 M/ W5 k: N2 J8 Bprint(cm)+ P8 }( S$ q, G& V/ F: p
print('score is:',score)1 Q v; E2 h3 o
' b- Z+ z" K& V0 T4 Z5 P
输出:
' N4 C/ v- W) }; Z+ @2 s) C, f: y
. x+ @$ T& K: t$ Z' |, p$ T; _8 j1 d2 F: ?- t
- u5 O6 t% S k1 ?$ t% g可视化混淆矩阵& G+ H% k9 i$ P' t
在这里,我们可视化预测值的混淆矩阵3 k1 d7 m3 w4 N$ s$ |- d- D- _+ B
0 g$ D: d! t& n" I# creating heatmap of comfussion matrix7 K7 g* E+ N! A8 |8 O
plt.figure(figsize=[14,7])
! Q$ E" w7 S+ J% ~- }/ T- _; Tsb.heatmap(cm,annot=True)# u9 ?- h3 L) E, G; E c! t" ^
plt.show()
: @, q5 v$ w4 a( I1 A" L1 v3 z' E. J4 j
" i0 q4 p9 g8 o9 ~! n6 `' S) B" `![]()
) E l0 l, p f& V$ A2 C! k5 @7 R4 p' L1 F9 J3 X5 ^! ]
可视化数据历史
- R( J8 Z+ ]# x2 X2 u现在我们可视化每个时期的损失和准确性。
; e9 O) u* l \: Q! L
5 v( x2 } |2 m) Z% U# list all data in history, `2 s3 I4 p7 t/ m3 v
print(model.history.keys())
9 c$ O! S8 G7 V4 R# summarize history for accuracy
7 B2 u9 ?* j' @- Y: `& j% hplt.plot(model.history['accuracy'])1 H" K$ c+ a. q7 o, }* Y- u; k n
plt.title('model accuracy')
% G( Z' {& I8 f2 kplt.ylabel('accuracy')# J7 k H( }8 ?' T" |& B, v
plt.xlabel('epoch')$ f- i: Y0 u& G) X
plt.legend(['train', 'test'], loc='upper left')
. `! ]# \5 U. O2 qplt.show()
0 o- Y0 ?! L$ D' ?. {
% `3 ?! p7 \( M. B1 p0 c. f+ T( T0 e ; ?2 v9 _3 p" V) X8 D9 L9 ?$ ~
' D5 B, [8 r/ Q5 @" O# m5 T5 L: b# A9 a+ R F8 D: b
# summarize history for loss
: b$ e8 b' B7 ]" Z& B. s( @plt.plot(model.history['loss'])0 I4 q2 z/ z& q- b
plt.title('model loss')$ L8 W1 o8 }6 v, Y" Z( @6 O
plt.ylabel('loss'): w5 I6 @/ t c1 _
plt.xlabel('epoch')
0 b/ v5 ^ i4 i% G$ Jplt.legend(['train', 'test'], loc='upper left')
" P8 V; h8 i3 o9 ?1 A* |2 jplt.show()6 R- K+ v9 Q6 W/ W/ w2 K
6 O# C. S; j$ H5 O0 d![]()
7 m6 A5 t1 m, l# i6 e; K- H
: W, |1 ^% @, x/ @保存模型最后,我们保存我们的模型
- I2 K: ~) D( L p" |$ K7 N: S6 F- v! U6 W$ ~! a ?
#saving the model
/ F! `! m- Y1 ~
5 g) @5 | Z9 b& S5 R8 C
( n% |3 o# l7 y- s+ L
+ R5 k: V" _# ^# @1 y- Vclassifier.save('File_name.h5')
. k0 c' s) N" {4 k6 m
: v: b2 {* R# B& U; S# x2 o- 6 J+ i* x' D9 I! n# Q
* X- a, X) q9 v5 K' R, I& Z + ~9 ^6 z: z8 [1 n& ]
( a: D7 k" Z# ?# z1 M; P) G' S6 I5 N
|