SparseMatrixSparseMatMul

clase final pública SparseMatrixSparseMatMul

Matriz dispersa: multiplica dos matrices CSR `a` y `b`.

Realiza una multiplicación matricial de una matriz dispersa `a` con una matriz dispersa `b`; devuelve una matriz dispersa `a * b`, a menos que `a` o `b` se transpongan o se unan.

Cada matriz puede transponerse o adjuntarse (conjugada y transpuesta) de acuerdo con los parámetros booleanos `transpose_a`, `adjoint_a`, `transpose_b` y `adjoint_b`. Como máximo, uno de `transpose_a` o `adjoint_a` puede ser Verdadero. De manera similar, como máximo uno de `transpose_b` o `adjoint_b` puede ser Verdadero.

Las entradas deben tener formas compatibles. Es decir, la dimensión interior de "a" debe ser igual a la dimensión exterior de "b". Este requisito se adapta en función de si se transpone o se añade "a" o "b".

El parámetro "tipo" denota el tipo de elementos de la matriz. Tanto `a` como `b` deben tener el mismo tipo. Los tipos admitidos son: `float32`, `float64`, `complex64` y `complex128`.

Tanto "a" como "b" deben tener el mismo rango. No se admite la transmisión. Si tienen rango 3, cada lote de CSRSparseMatrices 2D dentro de "a" y "b" debe tener la misma forma densa.

El producto de matriz dispersa puede tener ceros numéricos (no estructurales). TODO(anudhyan): considere agregar un atributo booleano para controlar si se eliminan los ceros.

Ejemplo de uso:

from tensorflow.python.ops.linalg.sparse import sparse_csr_matrix_ops
 
     a_indices = np.array([[0, 0], [2, 3], [2, 4], [3, 0]])
     a_values = np.array([1.0, 5.0, -1.0, -2.0], np.float32)
     a_dense_shape = [4, 5]
 
     b_indices = np.array([[0, 0], [3, 0], [3, 1]])
     b_values = np.array([2.0, 7.0, 8.0], np.float32)
     b_dense_shape = [5, 3]
 
     with tf.Session() as sess:
       # Define (COO format) Sparse Tensors over Numpy arrays
       a_st = tf.sparse.SparseTensor(a_indices, a_values, a_dense_shape)
       b_st = tf.sparse.SparseTensor(b_indices, b_values, b_dense_shape)
 
       # Convert SparseTensors to CSR SparseMatrix
       a_sm = sparse_csr_matrix_ops.sparse_tensor_to_csr_sparse_matrix(
           a_st.indices, a_st.values, a_st.dense_shape)
       b_sm = sparse_csr_matrix_ops.sparse_tensor_to_csr_sparse_matrix(
           b_st.indices, b_st.values, b_st.dense_shape)
 
       # Compute the CSR SparseMatrix matrix multiplication
       c_sm = sparse_csr_matrix_ops.sparse_matrix_sparse_mat_mul(
           a=a_sm, b=b_sm, type=tf.float32)
 
       # Convert the CSR SparseMatrix product to a dense Tensor
       c_sm_dense = sparse_csr_matrix_ops.csr_sparse_matrix_to_dense(
           c_sm, tf.float32)
       # Evaluate the dense Tensor value
       c_sm_dense_value = sess.run(c_sm_dense)
 
`c_sm_dense_value` almacena el producto de matriz densa:
[[  2.   0.   0.]
      [  0.   0.   0.]
      [ 35.  40.   0.]
      [ -4.   0.   0.]]
 
a: Una `CSRSparseMatrix`. b: Un `CSRSparseMatrix` con el mismo tipo y rango que `a`. tipo: El tipo de `a` y `b`. transpose_a: si es verdadero, `a` se transpone antes de la multiplicación. transpose_b: si es verdadero, `b` se transpone antes de la multiplicación. adjoint_a: si es verdadero, `a` adjunto antes de la multiplicación. adjoint_b: si es verdadero, `b` se adjunta antes de la multiplicación.

Clases anidadas

Constantes

Cadena OP_NOMBRE El nombre de esta operación, como lo conoce el motor central de TensorFlow.

Métodos públicos

estático SparseMatrixSparseMatMul.Options
adjuntoA (booleano adjuntoA)
estático SparseMatrixSparseMatMul.Options
adjuntoB (adjunto booleanoB)
Salida < Tipo T >
como salida ()
Devuelve el identificador simbólico del tensor.
Salida <?>
c ()
Un CSRSparseMatrix.
estático <T extiende TType > SparseMatrixSparseMatMul
crear (alcance alcance , Operando <?> a, Operando <?> b, Tipo Clase<T>, Opciones... opciones)
Método de fábrica para crear una clase que envuelve una nueva operación SparseMatrixSparseMatMul.
estático SparseMatrixSparseMatMul.Options
transposeA (transposeA booleana)
estático SparseMatrixSparseMatMul.Options
transposiciónB (transposición booleanaB)

Métodos heredados

org.tensorflow.op.RawOp
booleano final
es igual (Objeto obj)
entero final
Operación
operación ()
Devuelve esta unidad de cálculo como una única Operation .
cadena final
booleano
es igual (Objeto arg0)
Clase final<?>
obtenerclase ()
entero
código hash ()
vacío final
notificar ()
vacío final
notificar a todos ()
Cadena
a cadena ()
vacío final
esperar (arg0 largo, int arg1)
vacío final
espera (arg0 largo)
vacío final
esperar ()
org.tensorflow.op.Op
entorno de ejecución abstracto
entorno ()
Devuelve el entorno de ejecución en el que se creó esta operación.
operación abstracta
operación ()
Devuelve esta unidad de cálculo como una única Operation .
org.tensorflow.Operand
Salida abstracta < Tipo T >
como salida ()
Devuelve el identificador simbólico del tensor.
tipo T abstracto
como Tensor ()
Devuelve el tensor en este operando.
forma abstracta
forma ()
Devuelve la forma (posiblemente parcialmente conocida) del tensor al que hace referencia la Output de este operando.
Clase abstracta < TType >
tipo ()
Devuelve el tipo de tensor de este operando.
org.tensorflow.ndarray.Shaped
resumen entero
rango ()
forma abstracta
forma ()
resumen largo
tamaño ()
Calcula y devuelve el tamaño total de este contenedor, en número de valores.

Constantes

Cadena final estática pública OP_NAME

El nombre de esta operación, como lo conoce el motor central de TensorFlow.

Valor constante: "SparseMatrixSparseMatMul"

Métodos públicos

pública estática SparseMatrixSparseMatMul.Options adjuntoA (booleano adjuntoA)

Parámetros
adjuntoA Indica si `a` debe transponerse de forma conjugada.

público estático SparseMatrixSparseMatMul.Options adjuntoB (booleano adjuntoB)

Parámetros
adjuntoB Indica si `b` debe transponerse de forma conjugada.

Salida pública < TType > asOutput ()

Devuelve el identificador simbólico del tensor.

Las entradas a las operaciones de TensorFlow son salidas de otra operación de TensorFlow. Este método se utiliza para obtener un identificador simbólico que representa el cálculo de la entrada.

Salida pública <?> c ()

Una CSRSparseMatrix.

creación pública estática SparseMatrixSparseMatMul (alcance alcance , operando <?> a, operando <?> b, tipo clase<T>, opciones... opciones)

Método de fábrica para crear una clase que envuelve una nueva operación SparseMatrixSparseMatMul.

Parámetros
alcance alcance actual
a Una CSRSparseMatrix.
b Una CSRSparseMatrix.
opciones lleva valores de atributos opcionales
Devoluciones
  • una nueva instancia de SparseMatrixSparseMatMul

pública estática SparseMatrixSparseMatMul.Options transposeA (transposeA booleana)

Parámetros
transponerA Indica si "a" debe transponerse.

pública estática SparseMatrixSparseMatMul.Options transposeB (transposeB booleana)

Parámetros
transponerB Indica si `b` debe transponerse.