60行代码徒手实现深度神经网络

Cristalyin 2019-07-25

01

准备数据集

采用的数据集是sklearn中的breast cancer数据集,30维特征,569个样本。训练前进行MinMax标准化缩放至[0,1]区间。按照75/25比例划分成训练集和验证集。

  1. # 获取数据集 
  2. import numpy as np 
  3. import pandas as pd 
  4. from sklearn import datasets 
  5. from sklearn import preprocessing 
  6. from sklearn.model_selection import train_test_split 
  7. breast = datasets.load_breast_cancer() 
  8. scaler = preprocessing.MinMaxScaler() 
  9. data = scaler.fit_transform(breast['data']) 
  10. target = breast['target'
  11. X_train,X_test,y_train,y_test = train_test_split(data,target) 

02

模型结构图

03

正反传播公式

04

NN实现代码

  1. import numpy as np 
  2. import pandas as pd 
  3. #定义激活函数 
  4. ReLu = lambda z:np.maximum(0.0,z) 
  5. d_ReLu = lambda z:np.where(z<0,0,1
  6. LeakyReLu = lambda z:np.maximum(0.01*z,z) 
  7. d_LeakyReLu = lambda z:np.where(z<0,0.01,1
  8. Sigmoid = lambda z:1/(1+np.exp(-z)) 
  9. d_Sigmoid = lambda z: Sigmoid(z)*(1-Sigmoid(z)) #d_Sigmoid = a(1-a) 
  10. Tanh = np.tanh 
  11. d_Tanh = lambda z:1 - Tanh(z)**2 #d_Tanh = 1 - a**2 
  12. class NNClassifier(object): 
  13.  def __init__(self,n = [np.nan,5,5,1],alpha = 0.1,ITERNUM = 50000, gfunc = 'ReLu'): 
  14.  self.n = n #各层节点数 
  15.  self.gfunc = gfunc #隐藏层激活函数 
  16.  self.alpha,self.ITERNUM = alpha,ITERNUM 
  17.  self.dfJ = pd.DataFrame(data = np.zeros((ITERNUM,1)),columns = ['J']) 
  18.  self.W,self.b = np.nan,np.nan 
  19.  # 确定各层激活函数 
  20.  self.g = [eval(self.gfunc) for i in range(len(n))]; 
  21.  self.g[-1] = Sigmoid;self.g[0] = np.nan 
  22.  # 确定隐藏层激活函数的导数 
  23.  self.d_gfunc = eval('d_' + self.gfunc) 
  24.  def fit(self,X_train,y_train): 
  25.  X,Y = X_train.T,y_train.reshape(1,-1
  26.  m = X.shape[1] #样本个数 
  27.  n = self.n; n[0] = X.shape[0] # 各层节点数量 
  28.  # 节点值和参数初始化 
  29.  A = [np.zeros((ni,m)) for ni in n];A[0] = X #各层节点输出值初始化 
  30.  Z = [np.zeros((ni,m)) for ni in n];Z[0] = np.nan #各层节点中间值初始化 
  31.  W = [np.nan] + [np.random.randn(n[i],n[i-1]) * 0.01 for i in range(1,len(n))] #各层系数参数 
  32.  b = [np.zeros((ni,1)) for ni in n];b[0] = np.nan #n各层偏置参数 
  33.  # 导数初始化 
  34.  dA = [np.zeros(Ai.shape) for Ai in A] 
  35.  dZ = [np.zeros(Ai.shape) for Ai in A] 
  36.  dW = [np.zeros(Wi.shape) if isinstance(Wi,np.ndarray) else np.nan for Wi in W]  
  37.  db = [np.zeros(bi.shape) if isinstance(bi,np.ndarray) else np.nan for bi in b]  
  38.  for k in range(self.ITERNUM): 
  39.  # ---------正向传播 ---------- 
  40.  for i in range(1,len(n)): 
  41.  Z[i] = np.dot(W[i],A[i-1]) + b[i] 
  42.  A[i] = self.g[i](Z[i]) 
  43.  J = (1/m) * np.sum(- Y*np.log(A[len(n)-1]) -(1-Y)*np.log(1-A[len(n)-1])) 
  44.  self.dfJ.loc[k]['J']= J 
  45.  # ----------反向传播 --------- 
  46.  hmax = len(n) - 1 
  47.  dA[hmax] = 1/m*(-Y/A[hmax] + (1-Y)/(1-A[hmax])) 
  48.  dZ[hmax] = 1/m*(A[hmax]-Y) 
  49.  dW[hmax] = np.dot(dZ[hmax],A[hmax-1].T) 
  50.  db[hmax] = np.dot(dZ[hmax],np.ones((m,1))) 
  51.  for i in range(len(n)-2,0,-1): 
  52.  dA[i] = np.dot(W[i+1].T,dZ[i+1]) 
  53.  dZ[i] = dA[i]* self.d_gfunc(Z[i]) 
  54.  dW[i] = np.dot(dZ[i],A[i-1].T) 
  55.  db[i] = np.dot(dZ[i],np.ones((m,1))) 
  56.  #-----------梯度下降 --------- 
  57.  for i in range(1,len(n)): 
  58.  W[i] = W[i] - self.alpha*dW[i]  
  59.  b[i] = b[i] - self.alpha*db[i] 
  60.  # 显示进度 
  61.  if (k+1)%1000 == 0
  62.  print('progress rate:{}/{}'.format(k+1,self.ITERNUM),end = '\r'
  63.  self.W,self.b = W,b 
  64.  def predict_prob(self,X_test): 
  65.  # ---------正向传播 ---------- 
  66.  W,b = self.W,self.b 
  67.  Ai = X_test.T 
  68.  for i in range(1,len(self.n)): 
  69.  Zi = np.dot(W[i],Ai) + b[i] 
  70.  Ai = self.g[i](Zi) 
  71.  return(Ai.reshape(-1)) 
  72.  def predict(self,X_test): 
  73.  Y_prob = self.predict_prob(X_test) 
  74.  Y_test = Y_prob.copy() 
  75.  Y_test[Y_prob>=0.5] = 1 
  76.  Y_test[Y_prob< 0.5] = 0 
  77.  return(Y_test)  

05

单隐层神经网络

设置1个隐藏层,隐藏层节点数为5,隐藏层使用Sigmoid激活函数。

  1. # 采用Sigmoid激活函数 
  2. NN = NNClassifier(n = [np.nan,5,1],alpha = 0.02
  3.  ITERNUM = 200000, gfunc = 'Sigmoid'
  4. NN.fit(X_train,y_train) 
  5. # 绘制目标函数迭代曲线 
  6. %matplotlib inline 
  7. NN.dfJ.plot(figsize = (12,8)) 
  8. # 测试在验证集的auc得分 
  9. from sklearn.metrics import roc_auc_score 
  10. Y_prob = NN.predict_prob(X_test) 
  11. roc_auc_score(list(y_test),list(Y_prob)) 

隐藏层使用Tanh激活函数。

  1. # 采用 Tanh激活函数 
  2. NN = NNClassifier(n = [np.nan,5,1],alpha = 0.02
  3.  ITERNUM = 200000, gfunc = 'Tanh'
  4. NN.fit(X_train,y_train) 
  5. # 绘制目标函数迭代曲线 
  6. %matplotlib inline 
  7. NN.dfJ.plot(figsize = (12,8)) 
  8. # 测试在验证集的auc得分 
  9. from sklearn.metrics import roc_auc_score 
  10. Y_prob = NN.predict_prob(X_test) 
  11. roc_auc_score(list(y_test),list(Y_prob)) 

隐藏层使用ReLu激活函数。

  1. # 采用 ReLu激活函数 
  2. NN = NNClassifier(n = [np.nan,5,1],alpha = 0.02
  3.  ITERNUM = 200000, gfunc = 'ReLu'
  4. NN.fit(X_train,y_train) 
  5. # 绘制目标函数迭代曲线 
  6. %matplotlib inline 
  7. NN.dfJ.plot(figsize = (12,8)) 
  8. # 测试在验证集的auc得分 
  9. from sklearn.metrics import roc_auc_score 
  10. Y_prob = NN.predict_prob(X_test) 
  11. roc_auc_score(list(y_test),list(Y_prob)) 

隐藏层使用LeakyReLu激活函数。

  1. # 采用 LeakyReLu激活函数 
  2. NN = NNClassifier(n = [np.nan,5,1],alpha = 0.02
  3.  ITERNUM = 200000, gfunc = 'LeakyReLu'
  4. NN.fit(X_train,y_train) 
  5. # 绘制目标函数迭代曲线 
  6. %matplotlib inline 
  7. NN.dfJ.plot(figsize = (12,8)) 
  8. # 测试在验证集的auc得分 
  9. from sklearn.metrics import roc_auc_score 
  10. Y_prob = NN.predict_prob(X_test) 
  11. roc_auc_score(list(y_test),list(Y_prob)) 

以上试验似乎表明,在当前的数据集上,隐藏层采用ReLu激活函数是一个最好的选择,AUC最高得分为0.99958。

06

双隐层神经网络

设置2个隐藏层,隐藏层节点数都为5,隐藏层都使用ReLu激活函数。

  1. # 设置两个隐藏层,采用ReLu激活函数 
  2. NN = NNClassifier(n = [np.nan,5,5,1],alpha = 0.02
  3.  ITERNUM = 200000, gfunc = 'ReLu'
  4. NN.fit(X_train,y_train) 
  5. # 绘制目标函数迭代曲线 
  6. %matplotlib inline 
  7. NN.dfJ.plot(figsize = (12,8)) 
  8. # 测试在验证集的auc得分 
  9. from sklearn.metrics import roc_auc_score 
  10. Y_prob = NN.predict_prob(X_test) 
  11. roc_auc_score(list(y_test),list(Y_prob)) 

AUC得分0.99874比采用单隐藏层的最优得分0.99958有所降低,可能是模型复杂度过高,我们尝试减少隐藏层节点的个数至3以降低模型复杂度。

  1. # 双隐藏层,隐藏层节点数为3 
  2. NN = NNClassifier(n = [np.nan,3,3,1],alpha = 0.02
  3.  ITERNUM = 200000, gfunc = 'ReLu'
  4. NN.fit(X_train,y_train) 
  5. # 绘制目标函数迭代曲线 
  6. %matplotlib inline 
  7. NN.dfJ.plot(figsize = (12,8)) 
  8. # 测试在验证集的auc得分 
  9. from sklearn.metrics import roc_auc_score 
  10. Y_prob = NN.predict_prob(X_test) 
  11. roc_auc_score(list(y_test),list(Y_prob)) 

AUC得分0.99979,又有所提高。

和sklearn中自带的神经网络分类器进行对比。

相关推荐