Spark MLlib Deep Learning Neural Net(深度学习-神经网络)1.2

Spark MLlib Deep Learning Neural Net(深度学习-神经网络)1.2

http://blog.youkuaiyun.com/sunbow0

第一章Neural Net(神经网络)

2基础及源码解析

2.1 Neural Net神经网络基础知识

2.1.1 神经网络

基础知识参照：

http://deeplearning.stanford.edu/wiki/index.php/%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C

2.1.2 反向传导算法

基础知识参照：

http://deeplearning.stanford.edu/wiki/index.php/%E5%8F%8D%E5%90%91%E4%BC%A0%E5%AF%BC%E7%AE%97%E6%B3%95

2.1.3 Denoise Autoencoder

当采用无监督的方法分层预训练深度网络的权值时，为了学习到较鲁棒的特征，可以在网络的可视层（即数据的输入层）引入随机噪声，这种方法称为Denoise Autoencoder(简称dAE)，具体加入的方法就是把训练样例中的一些数据调整变为0，inputZeroMaskedFraction表示了调整的比例

这部分请参见《Extracting and Composing Robust Features with Denoising Autoencoders》这篇论文。参照：

http://wenku.baidu.com/link?url=lhFEf7N3n2ZG2K-mfWsts2on9gN5K-KkrMuuNvHU2COdehkDv9vxVsw-F23e5Yiww_38kWYB56hskLXwVp0_9c7DLw7XZX_w8NoNXfxtoIm

2.1.4 Dropout

训练神经网络模型时，如果训练样本较少，为了防止模型过拟合，Dropout可以作为一种trikc供选择。Dropout是hintion最近2年提出的，源于其文章Improving neural networks by preventing co-adaptation of feature detectors.中文大意为：通过阻止特征检测器的共同作用来提高神经网络的性能。

　Dropout是指在模型训练时随机让网络某些隐含层节点的权重不工作，不工作的那些节点可以暂时认为不是网络结构的一部分，但是它的权重得保留下来（只是暂时不更新而已），因为下次样本输入时它可能又得工作了。参照：

http://wenku.baidu.com/link?url=WpsRjVTrMIhCNqDSDnzm8M6nz2Q7AoNhpnY2XxM9SFYkGni8t94JOgsZUCbSuccOnO8mJyGx67RGLjPr8D9aoxhyOUkYtvfitU9ilaQ-Rqm

2.1.5 Sparsity Penalty

对神经网络每层节点的sparsity计算，对没达到sparsitytarget的参数的惩罚系数的节点进行惩罚。

2.2 Deep Learning NN源码解析

2.2.1 NN代码结构

NN源码主要包括：NeuralNet，NeuralNetModel两个类，源码结构如下：

NeuralNet结构：

NeuralNetModel结构：

2.2.2 NN训练过程

2.2.3 NeuralNet解析

(1)NNLabel

/**

 * label：目标矩阵

 *nna：神经网络每层节点的输出值,a(0),a(1),a(2)

 * error：输出层与目标值的误差矩阵

 */

caseclass NNLabel(label: BDM[Double],nna: ArrayBuffer[BDM[Double]],error: BDM[Double])extends Serializable

NNLabel：自定义数据类型，存储样本数据，格式：目标值，输出值，误差。

(2) NNConfig

/**

 *配置参数

 */

caseclassNNConfig(

  size: Array[Int],

  layer: Int,

  activation_function: String,

  learningRate: Double,

  momentum: Double,

  scaling_learningRate: Double,

  weightPenaltyL2: Double,

  nonSparsityPenalty: Double,

  sparsityTarget: Double,

  inputZeroMaskedFraction: Double,

  dropoutFraction: Double,

  testing: Double,

  output_function: String)extends Serializable

NNConfig：定义参数配置，存储配置信息。参数说明：

 size:神经网络结构

 layer:神经网络层数

 activation_function:隐含层函数

 learningRate:学习率

 momentum: Momentum因子

 scaling_learningRate:学习迭代因子

 weightPenaltyL2:正则化L2因子

 nonSparsityPenalty:权重稀疏度惩罚因子

 sparsityTarget:权重稀疏度目标值

 inputZeroMaskedFraction:权重加入噪声因子

 dropoutFraction: Dropout因子

 testing: testing

(3) InitialWeight

初始化权重

/**

   * 初始化权重

   * 初始化为一个很小的、接近零的随机值

   */

  def InitialWeight(size: Array[Int]): Array[BDM[Double]] = {

    // 初始化权重参数

    // weights and weight momentum

    // nn.W{i - 1} = (rand(nn.size(i), nn.size(i - 1)+1) - 0.5) * 2 * 4 * sqrt(6 / (nn.size(i) + nn.size(i - 1)));

    valn = size.length

    valnn_W = ArrayBuffer[BDM[Double]]()

    for (i <-1 ton - 1) {

      vald1 = BDM.rand(size(i), size(i - 1) + 1)

      d1 :-= 0.5

      valf1 =2 *4 * sqrt(6.0 / (size(i) + size(i -1)))

      vald2 =d1 :*f1

      //val d3 = new DenseMatrix(d2.rows, d2.cols, d2.data, d2.isTranspose)

      //val d4 = Matrices.dense(d2.rows, d2.cols, d2.data)

      nn_W += d2

    }

    nn_W.toArray

  }

(4) InitialWeightV

初始化权重vW

  /**

   * 初始化权重vW

   * 初始化为0

   */

  def InitialWeightV(size: Array[Int]): Array[BDM[Double]] = {

    // 初始化权重参数

    // weights and weight momentum

    // nn.vW{i - 1} = zeros(size(nn.W{i - 1}));

    valn = size.length

    valnn_vW = ArrayBuffer[BDM[Double]]()

    for (i <-1 ton - 1) {

      vald1 = BDM.zeros[Double](size(i), size(i - 1) + 1)

      nn_vW += d1

    }

    nn_vW.toArray

  }

(5) InitialActiveP

初始神经网络激活度

  /**

   * 初始每一层的平均激活度

   * 初始化为0

   */

  def InitialActiveP(size: Array[Int]): Array[BDM[Double]] = {

    // 初始每一层的平均激活度

    // average activations (for use with sparsity)

    // nn.p{i}     = zeros(1, nn.size(i)); 

    valn = size.length

    valnn_p = ArrayBuffer[BDM[Double]]()

    nn_p += BDM.zeros[Double](1,1)

    for (i <-1 ton - 1) {

      vald1 = BDM.zeros[Double](1, size(i))

      nn_p += d1

    }

    nn_p.toArray

  }

(6) AddNoise

样本数据增加随机噪声

  /**

   * 增加随机噪声

   * 若随机值>=Fraction，值不变，否则改为0

   */

  def AddNoise(rdd: RDD[(BDM[Double], BDM[Double])], Fraction: Double): RDD[(BDM[Double], BDM[Double])] = {

    valaddNoise = rdd.map { f =>

      valfeatures = f._2

      vala = BDM.rand[Double](features.rows,features.cols)

      vala1 =a :>= Fraction

      vald1 =a1.data.map { f =>if (f ==true)1.0else0.0 }

      vala2 =new BDM(features.rows,features.cols,d1)

      valfeatures2 =features :*a2

      (f._1, features2)

    }

    addNoise

  }

 

(7) DropoutWeight

神经网络权重随机休眠。

  /**

   * 随机让网络某些隐含层节点的权重不工作

   * 若随机值>=Fraction，矩阵值不变，否则改为0

   */

  def DropoutWeight(matrix: BDM[Double], Fraction: Double): Array[BDM[Double]] = {

    valaa = BDM.rand[Double](matrix.rows, matrix.cols)

    valaa1 =aa :> Fraction

    vald1 =aa1.data.map { f =>if (f ==true)1.0else0.0 }

    valaa2 =new BDM(matrix.rows: Int, matrix.cols: Int,d1: Array[Double])

    valmatrix2 = matrix :*aa2

    Array(aa2, matrix2)

  }

 

(8) NNff

神经网络进行前向传播，从输入层->隐含层->输出层，计算每一层每一个节点的输出值，其中输入值为样本数据。输入参数：

batch_xy2：样本数据

bc_config：神经网络配置参数

bc_nn_W：神经网络当前权重参数

输出参数：

RDD[(NNLabel, Array[BDM[Double]])]，格式为(NNLabel(label, nn_a, error), dropOutMask)。

/**

   * nnff是进行前向传播

   * 计算神经网络中的每个节点的输出值;

   */

  def NNff(

    batch_xy2: RDD[(BDM[Double], BDM[Double])],

    bc_config: org.apache.spark.broadcast.Broadcast[NNConfig],

    bc_nn_W: org.apache.spark.broadcast.Broadcast[Array[BDM[Double]]]): RDD[(NNLabel, Array[BDM[Double]])] = {