3 Spark机器学习 spark MLlib 矩阵向量、矩阵运算Breeze库-1

你的名字 2022-05-11 02:20 179阅读 0赞

机器学习里矩阵是必不可少的，无论Python、Java能做机器学习的语言，都会提供比较优质的矩阵库。

spark mllib中提供的矩阵库是Breeze，可以简单看看Breeze库的情况。

ScalaNLP是一套机器学习和数值计算的库，主要是关于科学计算、机器学习和自然语言处理（NLP）的，里面包含三个库，Breeze、Epic和Puck。

其中Breeze是机器学习和数值计算库，Epic是一种高性能统计分析器和结构化预测库，Puck是一个快速GPU加速解析器。

本篇就是来看看Breeze的用法。

### 1 Breeze创建矩阵、向量 ###

创建向量：

//创建全0的向量
            val v1 = DenseVector.zeros[Double](5)
            println(v1)
            //创建全1的向量
            val v2 = DenseVector.ones[Double](5)
            println(v2)
            //用某个值填充整个向量
            val v3 = DenseVector.fill(3){5}
            println(v3)
            //创建某个范围内的向量，参数分别是start、end、step（可不填）
            val v4 = DenseVector.range(1, 10, 2)
            println(v4)
            //按照行创建向量
            val v5 = DenseVector(1, 2, 3, 4)
            println(v5)
            //向量转置，就是把行向量转为列向量
            val v6 = DenseVector(1, 2, 3, 4).t
            println(v6)
            //从数组创建向量
            val v7 = DenseVector(Array(1, 2, 3, 4))
            println(v7)
            //0到1的随机向量，参数是数量
            val v8 = DenseVector.rand(4)
            println(v8)
            //从函数创建向量
            val v9 = DenseVector.tabulate(3){i => 2 * i}
            println(v9)

根据注释，基本可以猜到结果是什么。下面看结果：

DenseVector(0.0, 0.0, 0.0, 0.0, 0.0)
    DenseVector(1.0, 1.0, 1.0, 1.0, 1.0)
    DenseVector(5, 5, 5)
    DenseVector(1, 3, 5, 7, 9)
    DenseVector(1, 2, 3, 4)
    Transpose(DenseVector(1, 2, 3, 4))
    DenseVector(1, 2, 3, 4)
    DenseVector(0.712553382031057, 0.7818284949827337, 0.55561285848614, 0.9092804939652446)
    DenseVector(0, 2, 4)

创建矩阵：

//创建全0的矩阵，2行3列
            val m1 = DenseMatrix.zeros[Double](2, 3)
            println(m1)
            //单位矩阵，对角线为1，其他全为0
            val m2 = DenseMatrix.eye[Double](3)
            println(m2)
            //对角矩阵，用给定的值作为对角线，其他全为0
            val m3 = diag(DenseVector(1, 2, 3))
            println(m3)
            //按照行创建矩阵
            val m4 = DenseMatrix((1, 2, 3), (4, 5, 6))
            println(m4)
            //从数组创建矩阵
            val m5 = new DenseMatrix(2, 3, Array(1, 2, 3, 4, 5, 6))
            println(m5)
            //0到1的随机矩阵
            val m6 = DenseMatrix.rand(2, 3)
            println(m6)
            //从函数创建矩阵
            val m7 = DenseMatrix.tabulate(2, 3) {case(i, j) => i + j}
            println(m7)

结果是：

![70][]

![70 1][]

![70 2][]

![70 3][]

![70 4][]

![70 5][]

![70 6][]

### 2 Breeze访问矩阵元素 ###

前面是各种方式创建矩阵和向量的代码，这里来看看如何访问元素。

val v = DenseVector(Array(1, 2, 3, 4, 5, 6))
            //-1是末位，其他的v(0)
            println(v(-1))
            //指定坐标范围
            println(v(0 to 4))
            //按照指定步长取子集
            println(v(4 to 0 by -1))
            println(v(1 to -1))
    
            val m = DenseMatrix((1, 2, 3),(4, 5, 6))
            //指定矩阵的位置
            println(m(0, 1))
            //指定列
            println(m(::, 1))

结果是：

6
    DenseVector(1, 2, 3, 4, 5)
    DenseVector(5, 4, 3, 2, 1)
    DenseVector(2, 3, 4, 5, 6)
    2
    DenseVector(2, 5)

### 3 Breeze元素操作 ###

元素的操作有很多种，譬如赋值、矩阵转换、调整形状、连接矩阵等。

<table style="width:500px;">  Breeze元素操作函数  
 <tbody> 
  <tr> 
   <td>操作名称</td> 
   <td>Breeze函数</td> 
  </tr> 
  <tr> 
   <td>调整矩阵形状</td> 
   <td>a.reshape(3,2)</td> 
  </tr> 
  <tr> 
   <td>矩阵转成向量</td> 
   <td>a.toDenseVector</td> 
  </tr> 
  <tr> 
   <td>矩阵复制</td> 
   <td>a.copy</td> 
  </tr> 
  <tr> 
   <td>取对象线元素</td> 
   <td>diag(a)</td> 
  </tr> 
  <tr> 
   <td>给子集赋数值</td> 
   <td>a(1 to 4) := 5.0</td> 
  </tr> 
  <tr> 
   <td>给子集赋向量</td> 
   <td>a(1 to 4) :=DenseVector(1,2,3)</td> 
  </tr> 
  <tr> 
   <td>矩阵赋值</td> 
   <td>a(1 to 3,1 to 3) := 5.0</td> 
  </tr> 
  <tr> 
   <td>矩阵列赋值</td> 
   <td>a(::,2) := 5.0</td> 
  </tr> 
  <tr> 
   <td>垂直连接矩阵</td> 
   <td>DenseMatrix.vertcat(a.b)</td> 
  </tr> 
  <tr> 
   <td>横向连接矩阵</td> 
   <td>DenseMatrix.horzcat(d,e)</td> 
  </tr> 
  <tr> 
   <td>向量连接</td> 
   <td>DenseVector.vertcat(a,b)</td> 
  </tr> 
 </tbody> 
</table>

我们来看看各个功能：

定义一个初始的矩阵，4行3列

val m = DenseMatrix((1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12))

1   2   3   
    4   5   6   
    7   8   9   
    10  11  12

//转成vector向量
            val denseVector = m.toDenseVector
            println(denseVector)

结果是：

DenseVector(1, 4, 7, 10, 2, 5, 8, 11, 3, 6, 9, 12)

注意一下这个结果，将矩阵转为向量时，是按照列的顺序依次获取所有元素组成一个向量的。

//形状变成3行4列
            val reshape = m.reshape(3, 4)

结果是：

1  10  8   6   
    4  2   11  9   
    7  5   3   12

可以看到，矩阵变形时也是按照列从上到下从左到右依次填满矩阵的。

然后看一下diag，取对角线元素。

val m1 = DenseMatrix((1, 2, 3), (4, 5, 6), (7, 8, 9))
            //取对角线元素
            val diagM1 = diag(m1)
            println(diagM1)

结果如下图，需要注意的是，diag只支持行列数一样的矩阵，譬如3行3列。而3行4列的就无法使用该函数了。

DenseVector(1, 5, 9)

修改某一列的值

//将第二列的值变成5
            m1(::, 2) := 5
            println(m1)

结果：

1  2  5  
    4  5  5  
    7  8  5

给某个行列区间赋值

//矩阵赋值，从第二行到第三行，第二列到第三列赋值为5
            m1(1 to 2, 1 to 2) := 5
            println(m1)

结果：

1  2  3  
    4  5  5  
    7  5  5

垂直连接矩阵

//垂直连接矩阵
            val a1 = DenseMatrix((1, 2, 3), (4, 5, 6))
            val a2 = DenseMatrix((7, 8, 9))
            val a1a2 = DenseMatrix.vertcat(a1, a2)
            println(a1a2)

结果：

1  2  3  
    4  5  6  
    7  8  9

可以看到两个矩阵垂直连接时，只有列数相同就可以，行数不必相同。同理，横向连接时

横向连接矩阵

//横向连接矩阵
            val b1 = DenseMatrix((1, 2, 3), (4, 5, 6))
            val b2 = DenseMatrix((7, 8, 9), (10, 11, 12))
            val b1b2 = DenseMatrix.horzcat(b1, b2)
            println(b1b2)

结果是：

1  2  3  7   8   9   
    4  5  6  10  11  12

[70]: /images/20220511/a547581356fa421389bdd79491c98c28.png
[70 1]: /images/20220511/e97c57d7536a463cbe93947424c4ed05.png
[70 2]: /images/20220511/bc80234fba2541d383cb5c1486c92fed.png
[70 3]: /images/20220511/d1b49d3fae044b4bae3c685927da43ba.png
[70 4]: /images/20220511/d16fd6eefdf14a778f7ac0e6a1b4e4f6.png
[70 5]: /images/20220511/aa9cc0869904401e95577c4008fd74a1.png
[70 6]: /images/20220511/f6c1b14a6bad4623b7cbddb01fa1b0ff.png