- 在线时间
- 514 小时
- 最后登录
- 2023-12-1
- 注册时间
- 2018-7-17
- 听众数
- 15
- 收听数
- 0
- 能力
- 0 分
- 体力
- 40255 点
- 威望
- 0 点
- 阅读权限
- 255
- 积分
- 12788
- 相册
- 0
- 日志
- 0
- 记录
- 0
- 帖子
- 1419
- 主题
- 1178
- 精华
- 0
- 分享
- 0
- 好友
- 15
TA的每日心情 | 开心 2023-7-31 10:17 |
|---|
签到天数: 198 天 [LV.7]常住居民III
- 自我介绍
- 数学中国浅夏
 |
使用乳腺癌数据集的人工神经网络人工神经网络
2 E) S- L; u( y顾名思义,人工神经网络,就是人工神经元的网络。它指的是模仿大脑的生物启发模型。可以说,构建人脑结构的通常是基于生物神经网络的计算网络。
0 M8 c* J7 [' G6 y% a7 V1 Q4 v" D$ n, ?- V/ J
大家都知道,在我们的大脑中,神经元是相互连接和传递数据的过程。它类似于人脑神经元之间相互连接,神经网络由大量人工神经元组成,称为按层顺序排列的单元。具有各层神经元并形成一个完整的网络。这些神经元被称为节点。 Y5 V: x# k9 E
7 T2 B8 d5 V1 s, u3 h' J& ]: }2 A它由三层组成,分别是:
8 G4 ]* A8 ^- W* S0 _: @: m) c9 k" a3 K$ W
输入层" s e* ^( T8 S w$ O1 W+ f9 O
. M% A' M7 q7 H% r( d$ @
隐藏层- h: c& q8 b$ { C$ n/ n# H
( r# u/ }; z1 z9 A( g
输出层
$ m: @- Q: x; P$ e6 k2 r& R+ t6 ? 8 F' T6 c4 p. v. n1 d" Z3 R8 A/ x3 _$ x2 f, [
# z0 q& ]2 C+ z& q3 W
使用乳腺癌数据集创建ANN. G) C3 N7 a0 |7 F4 \
现在我们进入我们的主题,这里我们将采用数据集,然后创建人工神经网络并对诊断进行分类。3 `; d7 F* o% `9 [2 f" e7 w, s! {
' L+ \/ E/ l! l) o. [
首先,我们采用乳腺癌的数据集,然后继续前进。
0 C% w0 B* y; I: c
& T2 F$ ]7 q; S( b) X. u3 p1 {; X乳腺癌数据集:https://www.kaggle.com/uciml/breast-cancer-wisconsin-data
6 T5 b- k2 C% T* I. z, h
, W6 a! Z. T% L) K$ P7 z# a# g下载数据集后,我们将导入所需的重要库。
9 _8 u3 j, e+ l; U& |% i# O
% A7 Z, ]8 w/ C& C7 r/ K2 q导入库
8 A, H& X: ^1 M# r. r; {#import pandas
- O3 k, _: H4 ?+ z$ {import pandas as pd# K; M! i2 Q2 i0 y. g
#import numpy+ P3 d- k1 ^- h6 d- ?( ~: t
import numpy as np/ l+ I _7 a8 f% ^$ h
import matplotlib.pyplot as plt# S1 e0 o( W" ?9 H5 I* W8 _) \
import seaborn as sb
5 o; J0 j/ h' o# \2 U 这里我们导入了 pandas、NumPy 和一些可视化库。
5 r$ s) {# d3 `& @* [! Z' z现在我们使用pandas加载我们的数据集: 9 S! u( j0 @- g: f( t$ K2 u
df = pd.read_csv('Breast_cancer.csv')% [- F- D5 f* P8 h6 E9 C9 w
df
1 C" ^7 `; n3 t' ~# e! r+ Z ![]()
h0 C. G, s |+ c0 z8 C1 q! J
( T+ N4 d# h; L# l& V1 P7 g0 l在此数据集中,我们指向**“diagnosis”**特征列,因此我们使用 Pandas 检查该列的值计数:# d$ `7 X, y" N
0 c" O6 u% S$ \3 }* l4 U# counting values of variables in 'diagnosis'
4 p5 B' ^( e$ v0 @. r9 i" D, Odf['diagnosis'].value_counts()2 ^9 w+ C3 h3 \' K# \
2 E! b5 \0 c9 i* Y
8 N3 p9 u1 Q8 ~- W, r7 [
现在为了更好地理解,我们可视化“diagnosis列”的值计数。 可视化值计数
0 U' P4 `/ j) r$ V$ w. ?1 wplt.figure(figsize=[17,9])5 \( Y+ H. Z6 C! Z) Y# w6 b! R
sb.countplot(df['diagnosis'].value_counts())
* U8 n/ Q+ {2 gplt.show(), v/ N/ X5 d, Z" |
![]()
* A4 X+ B5 |+ W. y: C' r: m ]+ U* y4 j( c
空值在数据集中,我们必须检查我们使用pandas的变量中是否存在空值: 8 C' i" E( C/ n4 A4 \. p2 H- b( p
df.isnull().sum()
F( z t( D' b! E ? 执行程序后,我们得出结论,特征名称“Unnamed:32”包含所有空值,因此我们删除该列。1 `* W7 p! Y* c8 w# D& Z
7 N- T3 M7 {3 g/ Y" V5 J2 }6 \3 w
#droping feature
: I5 a. J! ~* F: t3 Jdf.drop(['Unnamed: 32','id'],axis=1,inplace=True)# c0 c5 o% _! `9 D
) W" m9 _! O' r* _) ?
自变量和因变量现在是时候将数据集划分为自变量和因变量了,为此我们创建了两个变量,一个代表自变量,另一个代表因变量。
: Y5 p$ @; l" G4 B# independent variables5 D( S4 w) I4 U7 n: o
x = df.drop('diagnosis',axis=1)
3 v, |$ o. O' q1 @, v3 w#dependent variables3 r }+ N7 u) }" y
y = df.diagnosis+ I ]6 `- o" ?# |: ^3 L' j+ g- ]
处理分类值! J4 f2 R& R9 {
当我们打印因变量y 时,我们看到其中包含分类数据,我们必须将分类数据转换为二进制格式以进行进一步处理,因此我们使用 Scikit learn Label Encoder 对分类数据进行编码。
$ D1 N4 t+ _" g2 Y/ h& V* N- M% k# G/ Z+ s
from sklearn.preprocessing import LabelEncoder
) u. W" T7 S- a; U#creating the object, U1 G+ N/ y4 w& i! ]
lb = LabelEncoder()
5 L1 J0 r& o+ K" S. ?" S I* P. }, l3 Iy = lb.fit_transform(y)
8 C! V; a) a9 \0 b4 }1 s" Z4 O& z2 D! s& E
拆分数据+ k: _1 v/ P6 w. V3 f* {
现在是时候将数据拆分为训练和测试部分了: \- b) }+ N, u2 d8 l3 f1 `0 j
% f3 F! ~8 A9 C7 Dfrom sklearn.model_selection import train_test_split
- b) n2 I. Y5 p# T: z) rxtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3,random_state=40)
- I( b1 ^+ W3 |5 v- i/ W* [$ j$ e+ x
缩放数据
3 O* s* E8 X" w l! s3 \1 T/ ]& F- M+ z) X当我们创建人工神经网络时,我们必须将数据缩放为更小的数字,因为深度学习算法将节点的权重和输入数据相乘,这需要大量时间,因此为了减少该时间,我们缩放数据。* w8 S! @/ N2 f/ v- _' o7 Z; A* h# t
1 O$ |+ b' V0 o/ S" t+ t0 `对于缩放,我们使用 scikit learn StandardScaler模块,我们缩放训练和测试数据集:1 g7 s! \. U. v. j) V
) H- @+ J1 P. H% f4 U#importing StandardScaler6 m& n2 n, j Z4 I
from sklearn.preprocessing import StandardScaler
/ v8 t/ J0 b* M9 E& j# W6 i#creating object b2 ?1 q! O( b/ a( w
sc = StandardScaler()# _& V+ U9 w& V" p% X2 N2 d7 A
xtrain = sc.fit_transform(xtrain)
( Q1 |9 g$ Q6 Xxtest = sc.transform(xtest)
: F& ^/ d' @) @6 L: f
2 V. e9 C7 Q$ @1 V) j Z3 w从这里我们开始创建人工神经网络,为此我们导入用于创建 ANN 的重要库:4 [, Z4 B: g& T- M! a3 z" s0 c
' ~) K# W; x. s: x#importing keras
4 ]# Q/ u0 C Q. p" l4 I) b/ `, Rimport keras; S/ Y7 `; @' J8 I
#importing sequential module9 P5 U H- ~+ t7 n1 C2 i, W
from keras.models import Sequential
7 k7 `8 U0 u! m8 G0 f# import dense module for hidden layers: e" i3 w$ O- G" P" q
from keras.layers import Dense1 V3 G; Q, R( U% m
#importing activation functions% d) Q- s8 C# n, T" Q3 G
from keras.layers import LeakyReLU,PReLU,ELU* ^, k6 }- K4 c m, J* Y3 \
from keras.layers import Dropout' V0 x/ y1 b, q& j8 f9 q
5 c8 f% p% v2 [" b( t" G
创建层
; H5 {# H; C# g0 A& f7 X导入这些库后,我们创建了三种类型的层:
" N% G+ t( W: N) I, V
7 }4 M! A8 s. F4 a# B5 v& S输入层
/ L; }! P2 @9 ?$ K1 f
8 H, U6 C7 @6 s4 l5 ~: T隐藏层
' ~ |* O) T. r- q: ~
0 f% n3 m8 M* @输出层
, @4 |1 v l$ B+ C
: u% s$ | ?. z# p* R# E8 D7 B! m& z首先,我们创建模型:0 h7 h) Y* v4 T2 d; N5 T2 x5 c/ O2 _9 c
7 ]" a8 @: V0 d) e) k
#creating model
- \1 ~' a. I8 nclassifier = Sequential()$ X3 h: Z. Q5 G/ e# T8 v
4 t! {+ s1 U$ y0 ^9 i
Sequential模型适用于每一层恰好有一个输入张量和一个输出张量的平面堆栈。
$ a% ^; Z0 R- M! x' }# p3 q( \1 U# ?- @2 i0 A; _
现在我们创建神经网络的层:& D6 z$ c* T6 Y2 q# t
0 i' A( n) ]" ?2 t) _4 k" Y8 @
#first hidden layer
! B1 A* M! U7 P5 Y1 Mclassifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu',input_dim=30))
3 h6 P: ^/ T6 o3 Z2 U#second hidden layer- G$ Y, R1 \5 {) E7 f' A T3 }
classifier.add(Dense(units=9,kernel_initializer='he_uniform',activation='relu'))" f u2 ]! h! |9 o' F. N
# last layer or output layer' S1 _7 g2 J0 P$ T4 r
classifier.add(Dense(units=1,kernel_initializer='glorot_uniform',activation='sigmoid')); I$ l4 z8 B2 ]3 }4 E$ [
2 M+ x# u8 r# N在以下代码中,使用 Dense 方法创建图层,因为我们使用基本参数。
; `! o1 Q0 m& u" D3 P, i+ F3 R Y9 S2 `& H
第一个参数是输出节点
. w8 P! e+ }( d+ M+ Z( q% u2 C8 B1 I! _* u/ X
第二个是内核权重矩阵的初始化器
, r* g1 q* s! t% `2 {8 Q! B% ]7 I( G$ {# W) _
第三个是激活函数; k0 E: H- _' {8 y; D
( U3 C+ u6 l' h' t2 h最后一个参数是输入节点或独立特征的数量。4 ~- J1 N% I" X: `* R
r' h5 Q7 g9 K1 T; G5 M执行此代码后,我们使用以下方法对其进行总结:
' V0 O- W \7 B6 r0 m" a#taking summary of layers. }6 [9 d+ J* T \( ~! ?
classifier.summary()/ K ]+ \+ m. N$ j: `# B# e6 X7 R3 _8 J( U
![]()
* d2 t+ }, v, X" Z4 |+ S3 b7 s+ a
% j" D& r# ^( t% |! [; d6 t1 J编译人工神经网络
$ w* M$ f- P5 [* m6 \) i$ g9 E现在我们用优化器编译我们的模型:
8 r8 ?$ V& j" ?$ A
E6 }6 O+ x0 x! v9 U" C7 O#compiling the ANN, Z' l) h, d7 G
classifier.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])' N% C E- ]% |6 p8 X
; {% M5 X& V. w$ a1 h
将 ANN 拟合到训练数据中
/ k& s$ ]2 I5 c3 l3 R3 \& u编译模型后,我们必须将 ANN 拟合到训练数据中以进行预测:9 W; u3 R- X% s. M5 n
' V! D/ L! t- f) \
#fitting the ANN to the training set5 d& B- _1 i2 T
model = classifier.fit(xtrain,ytrain,batch_size=100,epochs=100)1 ~) h- c$ k1 g
8 L* O* I. P2 d0 O+ z; ?
" E! J9 Z9 h M
it()方法将神经网络与训练数据进行拟合,在参数中设置batch_size、epochs等变量的具体值。
7 U' {; Z8 e+ @& _1 [7 Q
0 y) u. Y X! w8 q5 U* R" X! r5 Q: f在训练数据之后,我们还要对测试数据的准确性评分进行测试,如下所示:9 j/ C+ z/ d6 G+ s- s
* q {& p! s# g8 S: M
#now testing for Test data0 m- Y# l" O( v
y_pred = classifier.predict(test)
4 @+ n" h) i: I/ W( ?
! r5 M+ d$ k+ ^6 r* n在执行此代码时,我们发现 y_pred 包含不同的值,因此我们将预测值转换为阈值,如True, False。; v: A' k) D( {+ p5 {
* o$ F' X! a3 N#converting values* J$ k# D+ N8 D$ T: U
y_pred = (y_pred>0.5)# ]: Q3 i* I' w( y. d
print(y_pred)3 ~* J+ V; c: X" p- {; Z$ a+ S3 y
- _7 X1 T( Y. ]
2 H9 n# r& e9 S5 q! E6 s! R$ g0 M1 x% v1 W2 U* j+ `
分数和混淆矩阵
' @. q9 \4 j& w+ m+ ]* A( W% w现在我们检查混淆矩阵和预测值的分数。 j( O/ I. ?) f) W) M1 V
l1 H& w. x3 `2 A
from sklearn.metrics import confusion_matrix# D' J* O( t2 O! ~+ a+ E+ ?, y5 D
from sklearn.metrics import accuracy_score
+ G, v) p7 y2 k/ qcm = confusion_matrix(ytest,y_pred)
6 Q" a0 d! d3 e( wscore = accuracy_score(ytest,y_pred)
0 o' z: j6 C2 i3 I% w- s5 Sprint(cm)
. t) z+ m! l: v: _print('score is:',score)% ]7 z {+ A; x% @
; c! c6 D6 x" @/ g6 P$ @' j2 M
输出:- J/ }. k( F* U
# g: B( J0 [8 f* n0 |, ^ N: [+ M* W# B4 s" n5 |# e
5 x4 s5 q4 Y8 X M4 |2 d& {# r1 [
可视化混淆矩阵# V) L* L4 r. G; a# Q) G0 w
在这里,我们可视化预测值的混淆矩阵
0 u4 l, W6 J) m
1 d2 Z* G% Q/ Y; y& H3 Z# creating heatmap of comfussion matrix
! ], v1 {% ?) j6 ]" e4 L/ uplt.figure(figsize=[14,7])" [4 F+ m$ C3 }( }$ u
sb.heatmap(cm,annot=True)
9 s( ]8 V0 W2 {' z6 Xplt.show()5 D+ J. \2 r0 l2 B1 B$ B
, w% N3 b- i# ]9 Z6 a2 T![]()
6 G# [5 n- s3 X( {& j3 p w u$ R4 y: H( y3 ~. H
可视化数据历史6 s- T3 r" H# K( }5 j0 D$ ~
现在我们可视化每个时期的损失和准确性。2 c S+ i9 m& F' ^& @- n
( W- |% G# J4 G# list all data in history
, s& s2 B$ m& zprint(model.history.keys())
. q0 W- Q7 v! ?/ k/ O# summarize history for accuracy% v8 m: L" r# \
plt.plot(model.history['accuracy'])3 q$ D% V( S6 p
plt.title('model accuracy')( b. D0 y# V& \' F' w# C2 w
plt.ylabel('accuracy')
9 n7 n$ D9 \- J/ |: pplt.xlabel('epoch')
5 w3 f4 a. x! P' W. F w: F7 uplt.legend(['train', 'test'], loc='upper left')- d C+ ~/ z- L, o
plt.show() A6 J- m( o8 z7 e: ]3 X. ]
! l" Y: j7 T4 l8 g6 E0 o
![]()
6 d# V$ L+ t* ?' P! k; r
h4 p7 l" d- Q; p
. e9 U$ D; }' V. _/ ~+ _, y# summarize history for loss/ a, }; O. l- T1 ~
plt.plot(model.history['loss'])
( q' U- @8 B& e0 ^ i5 Vplt.title('model loss'), P. G E3 }; B3 T. R
plt.ylabel('loss')
2 r4 \: r0 q" P) h& t$ ]plt.xlabel('epoch')
- s" i1 K- n8 C/ y4 f0 a: x' Vplt.legend(['train', 'test'], loc='upper left')
" `( F6 R; x( s4 mplt.show()
3 h) q# G& A4 M
/ {% \' A- R0 [" w! \/ Z![]()
: n* S0 X/ d9 n% T8 l5 Q9 r7 P) X; o+ l: Y2 Z. T
保存模型最后,我们保存我们的模型
% R# S4 d) K3 T7 B) l3 V- @; v3 G) H& l
#saving the model
; Q8 r& \- S8 w8 Y I9 P7 c6 B$ G: @# ?* [
+ B2 P4 v& z0 K3 N
( C; {* K3 `$ ?- oclassifier.save('File_name.h5')
8 l+ m& |" V3 \9 B, J4 x
: c. L/ }" ^+ [; t; Z
) G, _) ~' J* q5 L5 P5 [) d. X1 T# }( E- y6 i
/ q# r9 S' W" b- m6 h
& v( }% l# ~$ w4 x* b; L7 I
- |9 d6 P9 |' ~% n |
zan
|