Apache spark MLlib到Breeze向量/矩阵对于org.apache.spark.MLlib范围是私有的？

我在某个地方读到，MLlib局部向量/矩阵目前正在包装Breeze实现，但是将MLlib转换为Breeze向量/矩阵的方法对于org.apache.spark.MLlib范围是私有的。解决这个问题的建议是在org.apache.spark.mllib.something包中编写代码

有更好的方法吗？你能举出一些相关的例子吗

---

感谢并问候，

据我所知，Spark人不想公开第三方API（包括Breeze），这样，如果他们决定离开他们，就更容易更改

---

您总是可以在该包中放入一个简单的隐式转换类，并在您自己的包中编写其余的代码。这并不比把所有东西都放进去好多少，但这会让你更清楚地知道为什么要这么做。

我做了与@dlwh建议的相同的解决方案。下面是执行此操作的代码：

package org.apache.spark.mllib.linalg
对象向量{
隐式类VectorPublications（val vector:vector）扩展了AnyVal{
def toBreeze:breeze.linalg.Vector[scala.Double]=Vector.toBreeze
}
隐式类BreezeVectorPublications（val-breezeVector:breeze.linalg.Vector[Double]）扩展了AnyVal{
def FROMBREESE:Vector=Vectors.FROMBREESE（breezeVector）
}
}

---

请注意，隐式类扩展了AnyVal，以防止在调用这些方法时分配新对象

，这是我迄今为止最好的方法。@dlwh注意：请提供对此可能需要的任何改进

我能想到的解决方案-是将每个向量转换成一个新的Breeze DenseVector，而不是将代码放入mllib.linalg包中

val v1 = Vectors.dense(1.0, 2.0, 3.0)
val v2 = Vectors.dense(4.0, 5.0, 6.0)
val bv1 = new DenseVector(v1.toArray)
val bv2 = new DenseVector(v2.toArray)
val vectout = Vectors.dense((bv1 + bv2).toArray)
vectout: org.apache.spark.mllib.linalg.Vector = [5.0,7.0,9.0]

---

此解决方案避免将代码放入Spark的包中，并避免将稀疏向量转换为密集向量：

def toBreeze(vector: Vector) : breeze.linalg.Vector[scala.Double] = vector match {
      case sv: SparseVector => new breeze.linalg.SparseVector[Double](sv.indices, sv.values, sv.size)
      case dv: DenseVector => new breeze.linalg.DenseVector[Double](dv.values)
    }

---

这是一种将Mlib密度矩阵转换为微风矩阵的方法，可能会有帮助

import breeze.linalg._
import org.apache.spark.mllib.linalg.Matrix

def toBreez(X:org.apache.spark.mllib.linalg.Matrix):breeze.linalg.DenseMatrix[Double] = {
var i=0;
var j=0;
val m = breeze.linalg.DenseMatrix.zeros[Double](X.numRows,X.numCols)
for(i <- 0 to X.numRows-1){
  for(j <- 0 to X.numCols-1){
    m(i,j)=X.apply(i, j)
  }
}
m
}

import breeze.linalg_
导入org.apache.spark.mllib.linalg.Matrix
def toBreez（X:org.apache.spark.mllib.linalg.Matrix）：breeze.linalg.DenseMatrix[Double]={
var i=0；
var j=0；
val m=微风、直线、密度矩阵、零[双]（X.numRows，X.numCols）
对于（i我的解决方案是上面@barclar和@lev的混合。如果不使用spark ml隐式转换，则无需将代码放入
org.apache.spark.mllib.linalg
。您可以在自己的包中定义自己的隐式转换，如：

打包您的包
导入org.apache.spark.ml.linalg.DenseVector
导入org.apache.spark.ml.linalg.SparseVector
导入org.apache.spark.ml.linalg.Vector
导入breeze.linalg.{DenseVector=>BDV，SparseVector=>BSV，Vector=>BV}
对象转换器
{
隐式def-toBreeze（dv:DenseVector）：BDV[双精度]=
新BDV[Double]（dv.值）
隐式def toBreeze（sv:SparseVector）：BSV[双精度]=
新BSV[Double]（sv指数、sv值、sv大小）
隐式def-toBreeze（v:Vector）：BV[Double]=
v匹配{
案例dv:DenseVector=>toBreeze（dv）
案例sv:SparseVector=>toBreeze（sv）
}
来自Breeze的隐式def（dv:BDV[Double]）：DenseVector=
新DenseVector（dv.toArray）
Breeze的隐式def（sv:BSV[Double]）：SparseVector=
新SparseVector（sv.length、sv.index、sv.data）
隐式def frombree（bv:bv[Double]）：向量=
bv匹配{
案例dv:BDV[Double]=>fromBreeze（dv）
案例sv:BSV[Double]=>fromBreeze（sv）
}
}

然后，您可以使用以下方法将这些隐式导入到代码中：

导入您的.package.breezecoverters_
将代码放入mllib.linalg包对于mllib framework的客户端来说不是一个可行的解决方案。我同意这是愚蠢的，但您只需要放入一个小类（正如@lev所见证的），这是最好的解决方案，不需要像下面的解决方案那样创建额外的数组。（如果他们想保留更改它的权利，我当然认为他们应该将Breeze公开为“实验性”的，但这不是我的事。）但是添加到mllib/linalg对于普通客户机来说是一个“出界”的解决方案（不应修改该包）：这不是一个好办法。我也不喜欢我的解决方案的便利性：但至少它是“合法的”。如果你有一个普遍允许的更好的解决方案的想法，我完全赞成。恐怕，任何更好的解决方案都需要政治化。此代码放在spark mllib.linalg包中。对于mllib框架的客户端来说，这不是一个可行的通用解决方案：他们不应该接触框架类和packages。它在spark.mllib.linalg包中，但是spark不应该为此重新编译。只创建一个新的程序集来包装现有的spark程序集，并在那里添加这个类。它有点粗糙，但这是我发现的最好的。像这样的东西有点危险。例如，如果你取一片微风向量并尝试用fromBreeze

，它将失败。这似乎是一个很好的解决方案，至少对我来说是有效的，但当我们执行

v1时。toArray

我们正在收集

v1

的所有元素，这可能会导致问题，例如，“v1”很大，无法装入RAM！