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

http://blog.csdn.net/sunbow0

第一章Neural Net(神经网络)

3 实例

3.1 测试数据

3.1.1 测试函数

采用智能优化算法的经典测试函数,如下:

(1 )Sphere Model

函数表达式

搜索范围

全局最优值

函数简介:此函数为非线性的对称单峰函数,不同维之间是不可分离的。此函数相对比较简单,大多数算法都能够轻松地达到优化效果,其主要用于测试算法的寻优精度。下图给出了此函数维数为2 时的图形。

(2 )Generalized Rosenbrock

函数表达式

搜索范围

全局最优值

函数简介:此函数是很难极小化的典型病态二次函数,其全局最优与可到达的局部最优之间有一道狭窄的山谷,曲面山谷中的点的最速下降方向几乎与到函数最小值的最好方向垂直。由于此函数对搜索提供很少信息,使算法很难辨别搜索方向。下图给出了此函数维数为2 时的图形。

(3 )Generalized Rastrigin

函数表达式

搜索范围

全局最优值

函数简介:此函数基于Sphere 函数的基础上,使用了余弦函数来产生大量的局部最小值。它是一个典型的具有大量局部最优点的复杂多峰函数,此函数很容易使算法陷入局部最优,而不能得到全局最优解。下图给出了此函数维数为2时的图形。

3.1.2 测试函数代码

/**

* 测试函数 : Rosenbrock , Rastrigin

* 随机生成 n2 维数据,并根据测试函数计算 Y

* n1 行, n2 列, b1 上限, b2 下限, function 计算函数

*/

def RandM(

n1: Int,

n2: Int,

b1: Double,

b2: Double,

function: String): BDM[Double] = {

// val n1 = 2

// val n2 = 3

// val b1 = -30

// val b2 = 30

val bdm1 = BDM.rand(n1, n2) * (b2 - b1).toDouble + b1.toDouble

val bdm_y = function match {

case "rosenbrock" =>

val xi0 = bdm1( :: , 0 to ( bdm1 . cols - 2 ))

val xi1 = bdm1( :: , 1 to ( bdm1 . cols - 1 ))

val xi2 = ( xi0 :* xi0 )

val m1 = (( xi1 - xi2 ) :* ( xi1 - xi2 )) * 100.0 + (( xi0 - 1.0 ) :* ( xi0 - 1.0 ))

val m2 = m1 * BDM.ones[Double]( m1 . cols , 1 )

m2

case "rastrigin" =>

val xi0 = bdm1

val xi2 = ( xi0 :* xi0 )

val sicos = Bcos( xi0 * 2.0 * Pi ) * 10.0

val m1 = xi2 - sicos + 10.0

val m2 = m1 * BDM.ones[Double]( m1 . cols , 1 )

m2

case "sphere" =>

val xi0 = bdm1

val xi2 = ( xi0 :* xi0 )

val m1 = xi2

val m2 = m1 * BDM.ones[Double]( m1 . cols , 1 )

m2

}

val randm = BDM.horzcat( bdm_y , bdm1 )

randm

}

}

3.2 NN实例

//******************* 1 (基于经典优化算法测试函数随机生成样本) *****************//

//2 随机生成测试数据

// 随机数生成

Logger.getRootLogger.setLevel(Level. WARN )

val sample_n1 = 1000

val sample_n2 = 5

val randsamp1 = RandSampleData.RandM( sample_n1 , sample_n2 , - 10 , 10 , "sphere" )

// 归一化 [0 1]

val normmax = Bmax( randsamp1 ( :: , breeze.linalg.*))

val normmin = Bmin( randsamp1 ( :: , breeze.linalg.*))

val norm1 = randsamp1 - (BDM.ones[Double]( randsamp1 . rows , 1 )) * normmin

val norm2 = norm1 :/ ((BDM.ones[Double]( norm1 . rows , 1 )) * ( normmax - normmin ))

// 转换样本 train_d

val randsamp2 = ArrayBuffer[BDM[Double]]()

for ( i <- 0 to sample_n1 - 1 ) {

val mi = norm2 ( i , :: )

val mi1 = mi . inner

val mi2 = mi1 .toArray

val mi3 = new BDM( 1 , mi2 .length, mi2 )

randsamp2 += mi3

}

val randsamp3 = sc .parallelize( randsamp2 , 10 )

sc .setCheckpointDir( "/user/checkpoint" )

randsamp3 .checkpoint()

val train_d = randsamp3 .map(f => ( new BDM( 1 , 1 , f( :: , 0 ). data ), f( :: , 1 to - 1 )))

//3 设置训练参数,建立模型

// opts: 迭代步长,迭代次数,交叉验证比例

val opts = Array( 100.0 , 20.0 , 0.2 )

train_d .cache

val numExamples = train_d .count()

println(s "numExamples = $ numExamples ." )

val NNmodel = new NeuralNet().

setSize(Array( 5 , 7 , 1 )).

setLayer( 3 ).

setActivation_function( "tanh_opt" ).

setLearningRate( 2.0 ).

setScaling_learningRate( 1.0 ).

setWeightPenaltyL2( 0.0 ).

setNonSparsityPenalty( 0.0 ).

setSparsityTarget( 0.05 ).

setInputZeroMaskedFraction( 0.0 ).

setDropoutFraction( 0.0 ).

setOutput_function( "sigm" ).

NNtrain( train_d , opts )

//4 模型测试

val NNforecast = NNmodel .predict( train_d )

val NNerror = NNmodel .Loss( NNforecast )

println(s "NNerror = $ NNerror ." )

val printf1 = NNforecast .map(f => (f. label . data ( 0 ), f. predict_label . data ( 0 ))).take( 200 )

println( " 预测结果 —— 实际值:预测值:误差 " )

for ( i <- 0 until printf1 .length)

println( printf1 ( i ). _1 + " " + printf1 ( i ). _2 + " " + ( printf1 ( i ). _2 - printf1 ( i ). _1 ))

println( " 权重 W{1}" )

val tmpw0 = NNmodel . weights ( 0 )

for ( i <- 0 to tmpw0 . rows - 1 ) {

for ( j <- 0 to tmpw0 . cols - 1 ) {

print( tmpw0 ( i , j ) + " " )

}

println()

}

println( " 权重 W{2}" )

val tmpw1 = NNmodel . weights ( 1 )

for ( i <- 0 to tmpw1 . rows - 1 ) {

for ( j <- 0 to tmpw1 . cols - 1 ) {

print( tmpw1 ( i , j ) + " " )

}

println()

}

转载请注明出处:

http://blog.csdn.net/sunbow0