Spark 线性代数库 Breeze API 详解

转载请标明出处：小帆的帆的专栏

运算

加，减，乘，除

向量与向量

加：+

减：-

乘：:*

除：:/

规则1:

乘除前面，加冒号；单独的乘号和除号分别表示点积和线性求解

规则2:

累加效果，加等号

import breeze.linalg.DenseVector

object Test {
def main(args: Array[String]) {
val v1 = DenseVector(1.0, 2.0, 3.0, 4.0)
val v2 = DenseVector(0.5, 0.5, 0.5, 0.5)
// DenseVector(1.5, 2.5, 3.5, 4.5)
println("\nv1 + v2 : ")
println(v1 + v2)

// DenseVector(0.5, 1.5, 2.5, 3.5)
println("\nv1 - v2 : ")
println(v1 - v2)

// DenseVector(0.5, 1.0, 1.5, 2.0)
println("\nv1 :* v2 : ")
// 规则1：乘号前面多了冒号
println(v1 :* v2)

// DenseVector(2.0, 4.0, 6.0, 8.0)
println("\nv1 :/ v2 : ")
// 规则1：除号前面多了冒号
println(v1 :/ v2)

// 但是v1 和 v2并没有改变
// DenseVector(1.0, 2.0, 3.0, 4.0)
println("\nv1 : ")
println(v1)

// DenseVector(0.5, 0.5, 0.5, 0.5)
println("\nv2 : ")
println(v2)

// 规则2
// 如果想把最后的结果保存到v1上，需要加等号
// DenseVector(1.5, 2.5, 3.5, 4.5)
println("\nv1 += v2 : ")
println(v1 += v2)

// DenseVector(1.0, 2.0, 3.0, 4.0)
println("\nv1 -= v2 : ")
println(v1 -= v2)

// DenseVector(0.5, 1.0, 1.5, 2.0)
println("\nv1 :*= v2 : ")
// 注意：乘号前面多了冒号
println(v1 :*= v2)

// DenseVector(1.0, 2.0, 3.0, 4.0)
println("\nv1 :/= v2 : ")
// 注意：除号前面多了冒号
println(v1 :/= v2)
}
}

矩阵与矩阵

跟向量与向量完全一样

加：+

减：-

乘：:*

除：:/

规则1:

乘除前面，加冒号；单独的乘号和除号分别表示点积和线性求解

规则2:

累加效果，加等号

import breeze.linalg.DenseMatrix

object Test1 {
def main(args: Array[String]) {
val m1 = DenseMatrix((1.0, 2.0), (3.0, 4.0))
val m2 = DenseMatrix((0.5, 0.5), (0.5, 0.5))

/**
* 1.5  2.5
* 3.5  4.5
*/
println("\nm1 + m2 : ")
println(m1 + m2)

/**
* 0.5  1.5
* 2.5  3.5
*/
println("\nm1 - m2 : ")
println(m1 - m2)

/**
* 0.5  1.0
* 1.5  2.0
*/
println("\nm1 :* m2 : ")
// 注意：乘号前面多了冒号
println(m1 :* m2)

/**
* 2.0  4.0
* 6.0  8.0
*/
println("\nm1 :/ m2 : ")
// 注意：除号前面多了冒号
println(m1 :/ m2)

// 但是m1 和 m2并没有改变
/**
* 1.0  2.0
* 3.0  4.0
*/
println("\nm1 : ")
println(m1)

/**
* 0.5  0.5
* 0.5  0.5
*/
println("\nm2 : ")
println(m2)

// 如果想把最后的结果保存到m1上，需要加等号
/**
* 1.5  2.5
* 3.5  4.5
*/
println("\nm1 += m2 : ")
println(m1 += m2)

/**
* 1.0  2.0
* 3.0  4.0
*/
println("\nm1 -= m2 : ")
println(m1 -= m2)

/**
* 0.5  1.0
* 1.5  2.0
*/
println("\nm1 :*= m2 : ")
// 注意：乘号前面多了冒号
println(m1 :*= m2)

/**
* 1.0  2.0
* 3.0  4.0
*/
println("\nm1 :/= m2 : ")
// 注意：除号前面多了冒号
println(m1 :/= m2)
}
}

矩阵或向量与数值

加：+

减：-

乘：*

除：/

规则1:

累加效果，加等号

注意

：乘除号前不需要冒号，因为没有矩阵与数值的点积等计算

import breeze.linalg.{DenseMatrix, DenseVector}

object Test1 {
def main(args: Array[String]) {
val v1 = DenseVector(1.0, 2.0, 3.0, 4.0)

// DenseVector(1.5, 2.5, 3.5, 4.5)
println("v1 + 0.5 : ")
println(v1 + 0.5)

// DenseVector(0.5, 1.5, 2.5, 3.5)
println("\nv1 - 0.5 : ")
println(v1 - 0.5)

// DenseVector(0.5, 1.0, 1.5, 2.0)
println("\nv1 * 0.5 : ")
println(v1 * 0.5)

// DenseVector(2.0, 4.0, 6.0, 8.0)
println("\nv1 / 0.5 : ")
println(v1 / 0.5)

// v1依然不变
// DenseVector(1.0, 2.0, 3.0, 4.0)
println("\nv1 : ")
println(v1)

// DenseVector(1.5, 2.5, 3.5, 4.5)
println("\nv1 += 0.5 : ")
println(v1 += 0.5)

// DenseVector(1.0, 2.0, 3.0, 4.0)
println("\nv1 -= 0.5 : ")
println(v1 -= 0.5)

// DenseVector(0.5, 1.0, 1.5, 2.0)
println("\nv1 *= 0.5 : ")
println(v1 *= 0.5)

// DenseVector(5.0, 10.0, 15.0, 20.0)
println("\nv1 /= 0.1 : ")
println(v1 /= 0.1)

// DenseVector(5.0, 10.0, 15.0, 20.0)
println("\nv1 : ")
println(v1)

val m1 = DenseMatrix((1.0, 2.0), (3.0, 4.0))

/**
* 1.5  2.5
* 3.5  4.5
*/
println("m1 + 0.5 : ")
println(m1 + 0.5)

/**
* 0.5  1.5
* 2.5  3.5
*/
println("\nm1 - 0.5 : ")
println(m1 - 0.5)

/**
* 0.5  1.0
* 1.5  2.0
*/
println("\nm1 * 0.5 : ")
println(m1 * 0.5)

/**
* 2.0  4.0
* 6.0  8.0
*/
println("\nm1 / 0.5 : ")
println(m1 / 0.5)

// m1依然不变
/**
* 1.0  2.0
* 3.0  4.0
*/
println("\nm1 : ")
println(m1)

/**
* 1.5  2.5
* 3.5  4.5
*/
println("\nm1 += 0.5 : ")
println(m1 += 0.5)

/**
* 1.0  2.0
* 3.0  4.0
*/
println("\nm1 -= 0.5 : ")
println(m1 -= 0.5)

/**
* 0.5  1.0
* 1.5  2.0
*/
println("\nm1 *= 0.5 : ")
println(m1 *= 0.5)

/**
* 5.0   10.0
* 15.0  20.0
*/
println("\nm1 /= 0.1 : ")
println(m1 /= 0.1)

/**
* 5.0   10.0
* 15.0  20.0
*/
println("\nm1 : ")
println(m1)
}
}

矩阵与向量

加：+

减：-

乘：:*

除：:/

规则1:

乘除前面，加冒号；单独的乘号和除号分别表示点积和线性求解

规则2:

累加效果，加等号

规则3:

必须有星号

规则4:

星号在左，逐行；星号在右，逐列；

与向量是列向量还是行向量无关

规则5:

向量必须是列向量

import breeze.linalg.{*, DenseMatrix, DenseVector}

object Test1 {
def main(args: Array[String]) {

val m1 = DenseMatrix(
(1.0, 2.0),
(3.0, 4.0)
)

val v1 = DenseVector(1.0, 2.0)
//    val v1 = DenseVector(1.0, 2.0).t // 运行时异常，规则5，向量必须是列向量
//    val v1 = DenseVector(1.0, 2.0).t.t // 正确，如果是一个列向量，需要转换成行向量

// 规则4: 星号在左，逐行；星号在右，逐列
println("-------------星号在左边，就逐行操作-----------------")

/**
* 2.0  4.0
* 4.0  6.0
*/
println("\nm1(*, ::) + v1 : ")
println(m1(*, ::) + v1)

/**
* 0.0  0.0
* 2.0  2.0
*/
println("\nm1(*, ::) - v1 : ")
println(m1(*, ::) - v1)

//    规则1: 乘除前面，加冒号

/**
* 1.0  4.0
* 3.0  8.0
*/
println("\nm1(*, ::) :* v1 : ")
println(m1(*, ::) :* v1)

/**
* 1.0  1.0
* 3.0  2.0
*/
println("\nm1(*, ::) :/ v1 : ")
println(m1(*, ::) :/ v1)

println("-------------星号在右边，就逐列操作-----------------")

/**
* 2.0  3.0
* 5.0  6.0
*/
println("\nm1(::, *) + v1 : ")
println(m1(::, *) + v1)

/**
* 0.0  1.0
* 1.0  2.0
*/
println("\nm1(::, *) - v1 : ")
println(m1(::, *) - v1)

/**
* 1.0  2.0
* 6.0  8.0
*/
println("\nm1(::, *) :* v1 : ")
println(m1(::, *) :* v1)

/**
* 1.0  2.0
* 1.5  2.0
*/
println("\nm1(::, *) :/ v1 : ")
println(m1(::, *) :/ v1)

// 无论星号在哪，m1都不会改变
println("-------------规则2: 累加效果，加等号-----------------")

// 下面以整除为例，注意星号的位置，一个在左，一个在右

/**
* 1.0  2.0
* 3.0  4.0
*/
println("\nm1 : ")
println(m1)

/**
* BroadcastedRows(1.0  4.0
* 3.0  8.0  )
*/
println("\nm1(*, ::) :*= v1 : ")
println(m1(*, ::) :*= v1)

/**
* 1.0  4.0
* 3.0  8.0
*/
println("\nm1 : ")
println(m1)

/**
* BroadcastedColumns(1.0  4.0
* 1.5  4.0  )
*/
println("\nm1(::, *) :/= v1 : ")
println(m1(::, *) :/= v1)

/**
* 1.0  4.0
* 1.5  4.0
*/
println("\nm1 : ")
println(m1)
}
}

函数

统计

求和

import breeze.linalg.{Axis, DenseMatrix, sum}

object Test1 {
def main(args: Array[String]) {

val m1 = DenseMatrix(
(1.0, 2.0),
(3.0, 4.0)
)

// Axis._0 纵向
// 4.0  6.0
println(sum(m1, Axis._0))

// Axis._1 横向
// 3.0 7.0
println(sum(m1, Axis._1))
}
}

均值

import breeze.linalg.{Axis, DenseMatrix}
import breeze.stats.mean

object Test1 {
def main(args: Array[String]) {

val m1 = DenseMatrix(
(1.0, 2.0),
(3.0, 4.0)
)

// Axis._0 纵向
// 4.0  6.0
println(mean(m1, Axis._0))

// Axis._1 横向
// 1.5  3.5
println(mean(m1, Axis._1))
}
}

方差和标准差

import breeze.linalg.{Axis, DenseMatrix}
import breeze.stats.{stddev, variance}

object Test1 {
def main(args: Array[String]) {

val m1 = DenseMatrix(
(1.0, 2.0),
(3.0, 4.0)
)

// Axis._0 纵向
// 2.0  2.0
println(variance(m1, Axis._0))

// Axis._1 横向
// 0.5, 0.5
println(variance(m1, Axis._1))

// Axis._0 纵向
// 2.0  2.0
println(stddev(m1, Axis._0))

// Axis._1 横向
// 0.5, 0.5
println(stddev(m1, Axis._1))
}
}

N次方和开方

import breeze.linalg.DenseMatrix
import breeze.numerics.{pow, sqrt}

object Test1 {
def main(args: Array[String]) {

val m1 = DenseMatrix(
(1.0, 2.0),
(3.0, 4.0)
)

/**
* 1.0  4.0
* 9.0  16.0
*/
println(pow(m1, 2))

/**
* 1.0   8.0
* 27.0  64.0
*/
println(pow(m1, 3))

/**
* 1.0                 1.4142135623730951
* 1.7320508075688772  2.0
*/
println(sqrt(m1))
}
}

E和log

import breeze.linalg.DenseMatrix
import breeze.numerics.{exp, log, log10, log1p}

object Test1 {
def main(args: Array[String]) {

val m1 = DenseMatrix(
(1.0, 2.0),
(3.0, 4.0)
)

/**
* 2.718281828459045   7.38905609893065
* 20.085536923187668  54.598150033144236
*/
// e = 2.718281828459045
println(exp(m1))

/**
* 0.0                 0.6931471805599453
* 1.0986122886681098  1.3862943611198906
*/
// 以e为底
println(log(m1))

/**
* 0.0                  0.3010299956639812
* 0.47712125471966244  0.6020599913279624
*/
// 以10为底
println(log10(m1))

/**
* 0.6931471805599453  1.0986122886681096
* 1.3862943611198906  1.6094379124341003
*/
// 以e为底
// log1p() 以返回 log(1 + x)，甚至当 x 的值接近零也能计算出准确结果。
println(log1p(m1))
}
}

三角

sin, sinh, asin, asinh

cos, cosh, acos, acosh

tan, tanh, atan, atanh

atan2

sinc(x) == sin(x)/x

sincpi(x) == sinc(x * Pi)

取整

import breeze.linalg.DenseVector
import breeze.numerics._

object Test1 {
def main(args: Array[String]) {
val a = DenseVector(1.4, 0.5, -2.3)

// 四舍五入
println(round(a))

// 向上取整
println(ceil(a))

// 向下取整
println(floor(a))

// 大于0，为1；小于0，为-1
println(signum(a))

// 绝对值
println(abs(a))
}
}

示例

模拟逻辑回归

利用Breze进行，归一化，添加截距项，预测

import breeze.linalg._
import breeze.numerics._
import breeze.stats._

object Work2 {
def main(args: Array[String]) {

// 随机产生数据
//    val featuresMatrix = DenseMatrix.rand[Double](3, 3)
//    val labelMatrix = DenseMatrix.rand[Double](3, 1)

// 测试数据
val featuresMatrix = DenseMatrix(
(1.0, 2.0, 3.0),
(4.0, 5.0, 6.0),
(7.0, 8.0, 9.0)
)

val labelMatrix = DenseMatrix(
1.0,
1.0,
0.0
)

// 均值
// DenseVector(4.0, 5.0, 6.0)
val featuresMean = mean(featuresMatrix(::, *)).toDenseVector
println("均值：")
println(featuresMean)

// 标准差
// DenseVector(3.0, 3.0, 3.0)
val featuresStddev = stddev(featuresMatrix(::, *)).toDenseVector
println("\n标准差：")
println(featuresStddev)

// 减去均值
/**
* -3.0  -3.0  -3.0
* 0.0   0.0   0.0
* 3.0   3.0   3.0
*/
featuresMatrix(*, ::) -= featuresMean
println("\n减去均值：")
println(featuresMatrix)

// 除以标准差
/**
* -1.0  -1.0  -1.0
* 0.0   0.0   0.0
* 1.0   1.0   1.0
*/
featuresMatrix(*, ::) /= featuresStddev
println("\n除以标准差：")
println(featuresMatrix)

// 生成截距
/**
* 1.0
* 1.0
* 1.0
*/
val intercept = DenseMatrix.ones[Double](featuresMatrix.rows, 1)
println("\n截距：")
println(intercept)

// 拼接成为最终的训练集
/**
* 1.0  -1.0  -1.0  -1.0
* 1.0  0.0   0.0   0.0
* 1.0  1.0   1.0   1.0
*/
val train = DenseMatrix.horzcat(intercept, featuresMatrix)
println("\n训练集：")
println(train)

// 参数
// 为方便检查结果，这里全部设置为1
/**
* 1.0
* 1.0
* 1.0
* 1.0
*/
val w = new DenseMatrix(4, 1, Array(1.0, 1.0, 1.0, 1.0))
//    val w = DenseMatrix.rand[Double](4, 1) // 随机生成, 一定要指定类型
println("\n参数：")
println(w)

/**
* -2.0
* 1.0
* 4.0
*/
// 随机生成w时，如果没有指定类型，A的计算结果虽然不会有错，但是后面将无法计算，除非通过asInstanceOf进行类型转换
// 如果w指定了类型，那么在idea中，转换语句会是灰色的，意思是这句话没有作用，可以不写
val A = (train * w).asInstanceOf[DenseMatrix[Double]]
println("\nA：")
println(A)

/**
* 0.11920292202211755
* 0.7310585786300049
* 0.9820137900379085
*/
// Sigmoid函数
val probability = 1.0 / (exp(A * -1.0) + 1.0)
println("\nprobability：")
println(probability)

/**
* MSE : 0.6041613548425021
*/
val MSE = mean(pow(probability - labelMatrix, 2))
println("\nMSE：")
println(MSE)

/**
* RMSE : 0.777278170825929
*/
val RMSE = sqrt(MSE)
println("\nRMSE：")
println(RMSE)
}

}

参考

Quickstart

Linear Algebra Cheat Sheet

炼数成金-黄美灵老师的Spark MLlib 机器学习算法与源码解析课程