class RowMatrix extends DistributedMatrix with Logging
Represents a roworiented distributed Matrix with no meaningful row indices.
 Annotations
 @Since( "1.0.0" )
 Source
 RowMatrix.scala
 Alphabetic
 By Inheritance
 RowMatrix
 Logging
 DistributedMatrix
 Serializable
 Serializable
 AnyRef
 Any
 Hide All
 Show All
 Public
 All
Instance Constructors

new
RowMatrix(rows: RDD[Vector])
Alternative constructor leaving matrix dimensions to be determined automatically.
Alternative constructor leaving matrix dimensions to be determined automatically.
 Annotations
 @Since( "1.0.0" )

new
RowMatrix(rows: RDD[Vector], nRows: Long, nCols: Int)
 rows
rows stored as an RDD[Vector]
 nRows
number of rows. A nonpositive value means unknown, and then the number of rows will be determined by the number of records in the RDD
rows
. nCols
number of columns. A nonpositive value means unknown, and then the number of columns will be determined by the size of the first row.
 Annotations
 @Since( "1.0.0" )
Value Members

final
def
!=(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

final
def
##(): Int
 Definition Classes
 AnyRef → Any

final
def
==(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

final
def
asInstanceOf[T0]: T0
 Definition Classes
 Any

def
clone(): AnyRef
 Attributes
 protected[lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( ... ) @native()

def
columnSimilarities(threshold: Double): CoordinateMatrix
Compute similarities between columns of this matrix using a sampling approach.
Compute similarities between columns of this matrix using a sampling approach.
The threshold parameter is a tradeoff knob between estimate quality and computational cost.
Setting a threshold of 0 guarantees deterministic correct results, but comes at exactly the same cost as the bruteforce approach. Setting the threshold to positive values incurs strictly less computational cost than the bruteforce approach, however the similarities computed will be estimates.
The sampling guarantees relativeerror correctness for those pairs of columns that have similarity greater than the given similarity threshold.
To describe the guarantee, we set some notation: Let A be the smallest in magnitude nonzero element of this matrix. Let B be the largest in magnitude nonzero element of this matrix. Let L be the maximum number of nonzeros per row.
For example, for {0,1} matrices: A=B=1. Another example, for the Netflix matrix: A=1, B=5
For those column pairs that are above the threshold, the computed similarity is correct to within 20% relative error with probability at least 1  (0.981)^{10/B}
The shuffle size is bounded by the *smaller* of the following two expressions:
O(n log(n) L / (threshold * A)) O(m L^{2})
The latter is the cost of the bruteforce approach, so for nonzero thresholds, the cost is always cheaper than the bruteforce approach.
 threshold
Set to 0 for deterministic guaranteed correctness. Similarities above this threshold are estimated with the cost vs estimate quality tradeoff described above.
 returns
An n x n sparse uppertriangular matrix of cosine similarities between columns of this matrix.
 Annotations
 @Since( "1.2.0" )

def
columnSimilarities(): CoordinateMatrix
Compute all cosine similarities between columns of this matrix using the bruteforce approach of computing normalized dot products.
Compute all cosine similarities between columns of this matrix using the bruteforce approach of computing normalized dot products.
 returns
An n x n sparse uppertriangular matrix of cosine similarities between columns of this matrix.
 Annotations
 @Since( "1.2.0" )

def
computeColumnSummaryStatistics(): MultivariateStatisticalSummary
Computes columnwise summary statistics.
Computes columnwise summary statistics.
 Annotations
 @Since( "1.0.0" )

def
computeCovariance(): Matrix
Computes the covariance matrix, treating each row as an observation.
Computes the covariance matrix, treating each row as an observation.
 returns
a local dense matrix of size n x n
 Annotations
 @Since( "1.0.0" )
 Note
This cannot be computed on matrices with more than 65535 columns.

def
computeGramianMatrix(): Matrix
Computes the Gramian matrix
A^T A
.
Computes the Gramian matrix
A^T A
.
 Annotations
 @Since( "1.0.0" )
 Note
This cannot be computed on matrices with more than 65535 columns.

def
computePrincipalComponents(k: Int): Matrix
Computes the top k principal components only.
Computes the top k principal components only.
 k
number of top principal components.
 returns
a matrix of size nbyk, whose columns are principal components
 Annotations
 @Since( "1.0.0" )
 See also
computePrincipalComponentsAndExplainedVariance

def
computePrincipalComponentsAndExplainedVariance(k: Int): (Matrix, Vector)
Computes the top k principal components and a vector of proportions of variance explained by each principal component.
Computes the top k principal components and a vector of proportions of variance explained by each principal component. Rows correspond to observations and columns correspond to variables. The principal components are stored a local matrix of size nbyk. Each column corresponds for one principal component, and the columns are in descending order of component variance. The row data do not need to be "centered" first; it is not necessary for the mean of each column to be 0. But, if the number of columns are more than 65535, then the data need to be "centered".
 k
number of top principal components.
 returns
a matrix of size nbyk, whose columns are principal components, and a vector of values which indicate how much variance each principal component explains
 Annotations
 @Since( "1.6.0" )

def
computeSVD(k: Int, computeU: Boolean = false, rCond: Double = 1e9): SingularValueDecomposition[RowMatrix, Matrix]
Computes singular value decomposition of this matrix.
Computes singular value decomposition of this matrix. Denote this matrix by A (m x n). This will compute matrices U, S, V such that A ~= U * S * V', where S contains the leading k singular values, U and V contain the corresponding singular vectors.
At most k largest nonzero singular values and associated vectors are returned. If there are k such values, then the dimensions of the return will be:
 U is a RowMatrix of size m x k that satisfies U' * U = eye(k),
 s is a Vector of size k, holding the singular values in descending order,
 V is a Matrix of size n x k that satisfies V' * V = eye(k).
We assume n is smaller than m, though this is not strictly required. The singular values and the right singular vectors are derived from the eigenvalues and the eigenvectors of the Gramian matrix A' * A. U, the matrix storing the right singular vectors, is computed via matrix multiplication as U = A * (V * S^{1}), if requested by user. The actual method to use is determined automatically based on the cost:
 If n is small (n < 100) or k is large compared with n (k > n / 2), we compute the Gramian matrix first and then compute its top eigenvalues and eigenvectors locally on the driver. This requires a single pass with O(n^{2}) storage on each executor and on the driver, and O(n^{2} k) time on the driver.
 Otherwise, we compute (A' * A) * v in a distributive way and send it to ARPACK's DSAUPD to compute (A' * A)'s top eigenvalues and eigenvectors on the driver node. This requires O(k) passes, O(n) storage on each executor, and O(n k) storage on the driver.
Several internal parameters are set to default values. The reciprocal condition number rCond is set to 1e9. All singular values smaller than rCond * sigma(0) are treated as zeros, where sigma(0) is the largest singular value. The maximum number of Arnoldi update iterations for ARPACK is set to 300 or k * 3, whichever is larger. The numerical tolerance for ARPACK's eigendecomposition is set to 1e10.
 k
number of leading singular values to keep (0 < k <= n). It might return less than k if there are numerically zero singular values or there are not enough Ritz values converged before the maximum number of Arnoldi update iterations is reached (in case that matrix A is illconditioned).
 computeU
whether to compute U
 rCond
the reciprocal condition number. All singular values smaller than rCond * sigma(0) are treated as zero, where sigma(0) is the largest singular value.
 returns
SingularValueDecomposition(U, s, V). U = null if computeU = false.
 Annotations
 @Since( "1.0.0" )
 Note
The conditions that decide which method to use internally and the default parameters are subject to change.

final
def
eq(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

def
equals(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

def
finalize(): Unit
 Attributes
 protected[lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( classOf[java.lang.Throwable] )

final
def
getClass(): Class[_]
 Definition Classes
 AnyRef → Any
 Annotations
 @native()

def
hashCode(): Int
 Definition Classes
 AnyRef → Any
 Annotations
 @native()

def
initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean
 Attributes
 protected
 Definition Classes
 Logging

def
initializeLogIfNecessary(isInterpreter: Boolean): Unit
 Attributes
 protected
 Definition Classes
 Logging

final
def
isInstanceOf[T0]: Boolean
 Definition Classes
 Any

def
isTraceEnabled(): Boolean
 Attributes
 protected
 Definition Classes
 Logging

def
log: Logger
 Attributes
 protected
 Definition Classes
 Logging

def
logDebug(msg: ⇒ String, throwable: Throwable): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
logDebug(msg: ⇒ String): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
logError(msg: ⇒ String, throwable: Throwable): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
logError(msg: ⇒ String): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
logInfo(msg: ⇒ String, throwable: Throwable): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
logInfo(msg: ⇒ String): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
logName: String
 Attributes
 protected
 Definition Classes
 Logging

def
logTrace(msg: ⇒ String, throwable: Throwable): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
logTrace(msg: ⇒ String): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
logWarning(msg: ⇒ String, throwable: Throwable): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
logWarning(msg: ⇒ String): Unit
 Attributes
 protected
 Definition Classes
 Logging

def
multiply(B: Matrix): RowMatrix
Multiply this matrix by a local matrix on the right.
Multiply this matrix by a local matrix on the right.
 B
a local matrix whose number of rows must match the number of columns of this matrix
 returns
a org.apache.spark.mllib.linalg.distributed.RowMatrix representing the product, which preserves partitioning
 Annotations
 @Since( "1.0.0" )

final
def
ne(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

final
def
notify(): Unit
 Definition Classes
 AnyRef
 Annotations
 @native()

final
def
notifyAll(): Unit
 Definition Classes
 AnyRef
 Annotations
 @native()

def
numCols(): Long
Gets or computes the number of columns.
Gets or computes the number of columns.
 Definition Classes
 RowMatrix → DistributedMatrix
 Annotations
 @Since( "1.0.0" )

def
numRows(): Long
Gets or computes the number of rows.
Gets or computes the number of rows.
 Definition Classes
 RowMatrix → DistributedMatrix
 Annotations
 @Since( "1.0.0" )

val
rows: RDD[Vector]
 Annotations
 @Since( "1.0.0" )

final
def
synchronized[T0](arg0: ⇒ T0): T0
 Definition Classes
 AnyRef

def
tallSkinnyQR(computeQ: Boolean = false): QRDecomposition[RowMatrix, Matrix]
Compute QR decomposition for RowMatrix.
Compute QR decomposition for RowMatrix. The implementation is designed to optimize the QR decomposition (factorization) for the RowMatrix of a tall and skinny shape. Reference: Paul G. Constantine, David F. Gleich. "Tall and skinny QR factorizations in MapReduce architectures" (see here)
 computeQ
whether to computeQ
 returns
QRDecomposition(Q, R), Q = null if computeQ = false.
 Annotations
 @Since( "1.5.0" )

def
toString(): String
 Definition Classes
 AnyRef → Any

final
def
wait(): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long, arg1: Int): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... ) @native()