Spark 线性代数库 Breeze API 详解

最新推荐文章于 2020-04-03 17:41:24 发布
最新推荐文章于 2020-04-03 17:41:24 发布
阅读量1w 收藏 19
点赞数 3
分类专栏： Spark 文章标签： Spark MLlib Breeze
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wo334499/article/details/51728628
版权

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

运算

加，减，乘，除

向量与向量

  • 加：+
  • 减：-
  • 乘：:*
  • 除：:/

规则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 机器学习算法与源码解析课程

小帆的帆
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Spark MLlib】（三）Spark MLlib 数据基础_spark mlib中那个函数用于计算两个向量的点积(1)
2401_84181577的博客
05-06 420
然后每次用k-1个子集的并集作为训练集，余下的那个作为测试集，这样得到k组训练/测试集。可以进行k次训练和测试，最终返回的是这个k个结果的均值。可以随机使用不同的划分多次，例如：10次10折交叉验证通常把交叉验证法称为“k折交叉验证”（k-fold cross validation），k最常用的取值时10，为10折交叉验证。Spark MLlib底层的向量、矩阵运算使用了Breeze库，Breeze库提供了Vector/Matrix的实现以及相应计算的接口（Linalg）。1、Breeze创建函数。
spark 矩阵转置 java_Spark MLlib之使用Breeze操作矩阵向量
weixin_30269201的博客
02-26 464
这下面的练习中，需要自己将spark的jar包 添加进来。1.spark Mlib 底层使用的向量、矩阵运算使用了Breeze库。scalaNLP 是一套 机器学习和数值技算的库。它主要是关于科学技术(sc)、机器学习(ML)和自然语言处理(NLP)的。它包括三个库，Breeze、Epic 和 Puck。Breeze :是机器学习和数值技术库 ，它是sparkMlib的核心，包括线性代数、数值技术...
Breeze库API总结(Spark线性代数库)（转载）
weixin_34102807的博客
12-29 454
导入 import breeze.linalg._ import breeze.numerics._ Spark Mllib底层的向量、矩阵运算使用了Breeze库，Breeze库提供了Vector/Matrix的实现以及相应计算的接口（Linalg）。但是在MLlib里面同时也提供了Vector和Linalg等的实现。在使用Breeze库时，需要导入相关包： ...
Breeze库API总结(Spark线性代数库)
lirika_777的博客
05-11 765
导入 import breeze.linalg._ import breeze.numerics._ Breeze创建函数: 操作名称 Breeze函数 对应Numpy函数 全0矩阵 DenseMatrix.zeros[Double](2,3) zeros((2,3)) 全0向量 DenseVector.zeros[D...
成功导入并运行breeze jar库
ningyanggege的博客
01-16 1668
通过各种方法导入自己下载的jar包，却发现命令 import breeze.linalg._一直是失败的；却发现下载的包是错误的；重新下载就ok了； 如图所示：   不单单是添加breeze包；然后察看项目菜单的        ...
Scala中的矩阵Breeze.linalg.DenseMatrix
Silence的博客
11-23 7848
scala 中有一个包叫做breeze.linalg.DenseMatrix，是专门针对矩阵运算的，目前只是用到DenseMatrix这一个，暂时讲解一下他的用法 DenseMatrix即稠密矩阵与SparseMatrix（稀疏矩阵相对应） 为了写起来方便，可以这样对其重命名为：import breeze.linalg.{DenseMatrix => BDM}即BDM相当于DenseMatri
Spark 线性代数库 Breeze API 详解 - 小帆的帆的专栏 - 博客频道 - CSDN1
08-04
【Spark 线性代数库 Breeze API 详解】 Spark作为一个强大的大数据处理框架，提供了丰富的库来支持各种计算任务，其中包括对线性代数的支持。Breeze是Spark的一个重要组件，它是一个针对Scala设计的科学计算库，...
机器学习,scala,线性代数
09-19
在IT领域，特别是数据科学和人工智能的分支，掌握Scala、机器学习和线性代数是至关重要的。Scala是一种多范式编程语言，以其强大的并发处理能力和面向对象与函数式编程的融合而备受赞誉。它在大数据处理框架Spark中...
spark_API文档
11-13
在实际应用中，开发人员通常会结合使用Spark API、Scala编程技巧以及第三方库，例如Breeze用于数值计算，或者Algebird和Tungsten用于优化计算性能。通过深入理解Spark API，开发者能够构建出高效、可扩展的大数据...
breeze-macros_2.12-0.13.2-API文档-中文版.zip
04-08
包含翻译后的API文档：breeze-macros_2.12-0.13.2-javadoc-API文档-中文(简体)版.zip 对应Maven信息：groupId：org.scalanlp，artifactId：breeze-macros_2.12，version：0.13.2 使用方法：解压翻译后的API文档，用...
breeze_2.12-0.13.2-API文档-中文版.zip
04-08
包含翻译后的API文档：breeze_2.12-0.13.2-javadoc-API文档-中文(简体)版.zip 对应Maven信息：groupId：org.scalanlp，artifactId：breeze_2.12，version：0.13.2 使用方法：解压翻译后的API文档，用浏览器打开...
matlab运算符代码-Scalala:Scalala已被dlwh/breeze取代。Scalala是Scala的高性能数字线性代数库，在向量
05-28
Scalala是一个在Scala编程语言中的高性能线性代数库，它的设计目标是为了提供类似于Matlab的便捷性，同时利用Scala的类型系统和面向对象特性来提升性能和可维护性。 Scalala虽然现在已经被dlwh/breeze取代，但理解...
breeze-2.10.0:0.12.jar
05-09
scalanlp工程下breeze完整库包，直接作为外部jar包导入即可，相关所有依赖均...免去了自己sbt、maven的过程，脱离spark平台使用breeze库。懒人菜鸟提供~ https://github.com/scalanlp/breeze http://www.scalanlp.org/
linear-least-squares:线性代数项目
07-11
Scala Breeze 是一个为 Scala 语言设计的科学计算库，它提供了广泛的数学运算和优化工具，包括线性代数、微积分、概率统计等。利用 Breeze，我们可以轻松处理向量、矩阵和其他线性代数结构，并进行高效的计算。 ...
breeze_2.12-0.13.2-API文档-中英对照版.zip
07-05
包含翻译后的API文档：breeze_2.12-0.13.2-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：org.scalanlp:breeze_2.12:0.13.2； 标签：scalanlp、breeze、中英对照文档、jar包、java； 使用方法：解压翻译...
Python库 | breeze_connect-0.0.2.tar.gz
05-12
资源分类：Python库 所属语言：Python 资源全名：breeze_connect-0.0.2.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
计算 期望与方差（mean and Variance）在 Tensorflow 与 Numpy 对比
Harry的博客
04-03 1622
计算 期望与方差（mean and Variance）在Tensorflow 与 Numpy 对比 Tensorlfow 里 计算期望与方差是用 tf.nn.moments(img, axis) 函数 Numpy 里 计算期望与方差是用 mean 与var 函数 分别计算的。 代码实现如下。 可以看到它们的计算结果完全一样的。 import tensorflow as tf import num...
Spark聚类模型K-Means----来源Spark机器学习
小猪猪and小马马的博客
03-14 1099
import breeze.linalg.DenseVector import breeze.numerics.pow import org.apache.spark.mllib.clustering.KMeans import org.apache.spark.mllib.linalg.Vectors import org.apache.spark.mllib.linalg.distribute
Spark MLlib之使用Breeze操作矩阵向量
weixin_33695450的博客
12-28 247
2019独角兽企业重金招聘Python工程师标准>>> ...
spark tfidf breeze 文本相似度代码
最新发布
05-20
以下是使用Spark MLlib中的TF-IDF和Breeze库计算文本相似度的示例代码： ```scala import org.apache.spark.ml.feature.{HashingTF, IDF} import org.apache.spark.ml.linalg.SparseVector import breeze.linalg.{...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值