SparseMatrixSparseCholesky

Calcola la scomposizione sparsa di Cholesky di "input".

Calcola la scomposizione di Cholesky sparsa di una matrice sparsa, con la permutazione di riduzione del riempimento data.

La matrice sparsa di input e la "permutazione" di riduzione del riempimento devono avere forme compatibili. Se la matrice sparsa ha rango 3; con la dimensione batch "B", allora la "permutazione" deve essere di rango 2; con la stessa dimensione del lotto "B". Non c'è supporto per la trasmissione.

Inoltre, ciascun vettore componente di `permutazione` deve essere di lunghezza `N`, contenente ciascuno degli interi {0, 1, ..., N - 1} esattamente una volta, dove `N` è il numero di righe di ciascun componente della matrice sparsa.

Ciascun componente della matrice sparsa di input deve rappresentare una matrice definita positiva simmetrica (SPD); sebbene venga letta solo la parte triangolare inferiore della matrice. Se un singolo componente non è SPD, viene generato un errore InvalidArgument.

La matrice sparsa restituita ha la stessa forma densa della matrice sparsa di input. Per ciascun componente "A" della matrice sparsa di input, la matrice sparsa di output corrispondente rappresenta "L", il fattore di Cholesky triangolare inferiore che soddisfa la seguente identità:

A = L * Lt
 

dove Lt denota la trasposizione di L (o la sua trasposizione coniugata, se ` tipo" è "complesso64" o "complesso128").

Il parametro "tipo" denota il tipo degli elementi della matrice. I tipi supportati sono: `float32`, `float64`, `complex64` e `complex128`.

Esempio di utilizzo:

from tensorflow.python.ops.linalg.sparse import sparse_csr_matrix_ops
 
     a_indices = np.array([[0, 0], [1, 1], [2, 1], [2, 2], [3, 3]])
     a_values = np.array([1.0, 2.0, 1.0, 3.0, 4.0], np.float32)
     a_dense_shape = [4, 4]
 
     with tf.Session() as sess:
       # Define (COO format) SparseTensor over Numpy array.
       a_st = tf.sparse.SparseTensor(a_indices, a_values, a_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)
 
       # Obtain the Sparse Cholesky factor using AMD Ordering for reducing zero
       # fill-in (number of structural non-zeros in the sparse Cholesky factor).
       ordering_amd = sparse_csr_matrix_ops.sparse_matrix_ordering_amd(sparse_matrix)
       cholesky_sparse_matrices = (
           sparse_csr_matrix_ops.sparse_matrix_sparse_cholesky(
               sparse_matrix, ordering_amd, type=tf.float32))
 
       # Convert the CSRSparseMatrix Cholesky factor to a dense Tensor
       dense_cholesky = sparse_csr_matrix_ops.csr_sparse_matrix_to_dense(
           cholesky_sparse_matrices, tf.float32)
 
       # Evaluate the dense Tensor value.
       dense_cholesky_value = sess.run(dense_cholesky)
 

`dense_cholesky_value` memorizza il fattore Cholesky denso:

[[  1.  0.    0.    0.]
      [  0.  1.41  0.    0.]
      [  0.  0.70  1.58  0.]
      [  0.  0.    0.    2.]]
 

input: A `CSRSparseMatrix`. permutazione: Un `Tensore`. tipo: il tipo di "input".