Holen Sie sich top-n Elemente jeder Zeile in einer scipy spärlich Matrix

Question

Nach dem Lesen this ähnliche Frage, ich kann immer noch nicht vollständig verstehen, wie man die Implementierung der Lösung im Auge zu suchen geht. Ich habe eine Sparse Matrix, d.h .:

import numpy as np 
from scipy import sparse 
arr = np.array([[0,5,3,0,2],[6,0,4,9,0],[0,0,0,6,8]]) 
arr_csc = sparse.csc_matrix(arr) 

Ich mag effizient die oberen n Elemente jede Reihe bekommen, ohne die spärliche Matrix zu dichte Umwandlung. Das Endergebnis sollte wie folgt aussehen (vorausgesetzt, n = 2):

top_n_arr = np.array([[0,5,3,0,0],[6,0,0,9,0],[0,0,0,6,8]]) 
top_n_arr_csc = sparse.csc_matrix(top_n_arr) 

Answer 1

Was mit der verknüpften Antwort falsch ist? Funktioniert es in Ihrem Fall nicht? oder du verstehst es einfach nicht? Oder ist es nicht effizient genug?

Ich schlug vor, ein Mittel zum Auffinden der oberen Werte für eine Zeile einer lil Format-Matrix, und wenden Sie diese Zeile für Zeile. Aber ich würde nur meine frühere Antwort wiederholen.

---

OK, war meine Antwort ein Anfang, aber es fehlte ein paar Details über das lol Format auf iterieren. Hier ist ein Anfang; es könnte wahrscheinlich aufgeräumt werden.

das Array und eine lil Version:

In [42]: arr = np.array([[0,5,3,0,2],[6,0,4,9,0],[0,0,0,6,8]])  
In [43]: arr_sp=sparse.csc_matrix(arr) 
In [44]: arr_ll=arr_sp.tolil() 

Die Zeilenfunktion aus der vorherigen Antwort:

def max_n(row_data, row_indices, n): 
     i = row_data.argsort()[-n:] 
     # i = row_data.argpartition(-n)[-n:] 
     top_values = row_data[i] 
     top_indices = row_indices[i] # do the sparse indices matter? 
     return top_values, top_indices, i 

Iterate über die Zeilen von arr_ll, diese Funktion anzuwenden und die Elemente ersetzen:

In [46]: for i in range(arr_ll.shape[0]): 
    d,r=max_n(np.array(arr_ll.data[i]),np.array(arr_ll.rows[i]),2)[:2] 
    arr_ll.data[i]=d.tolist() 
    arr_ll.rows[i]=r.tolist() 
    ....:  

In [47]: arr_ll.data 
Out[47]: array([[3, 5], [6, 9], [6, 8]], dtype=object) 

In [48]: arr_ll.rows 
Out[48]: array([[2, 1], [0, 3], [3, 4]], dtype=object) 

In [49]: arr_ll.tocsc().A 
Out[49]: 
array([[0, 5, 3, 0, 0], 
     [6, 0, 0, 9, 0], 
     [0, 0, 0, 6, 8]]) 

In der lil Format werden die Daten in 2 Objekttyp-Arrays als Unterlisten gespeichert, eines mit den Datennummern, das andere mit den Spaltenindizes.

Das Anzeigen der Datenattribute von Sparse-Matrix ist praktisch, wenn Sie neue Dinge tun. Das Ändern dieser Attribute birgt ein gewisses Risiko, da es das gesamte Array durcheinanderbringt. Aber es sieht so aus, als könnte das lil Format so sicher optimiert werden.

Das Format csr ist besser für den Zugriff auf Zeilen als csc. Es ist Daten in 3 Arrays gespeichert, data, indices und indptr. Das lil-Format teilt effektiv 2 dieser Arrays in Teillisten basierend auf Informationen in der indptr. csr ist großartig für Mathe (Multiplikation, Addition usw.), aber nicht so gut, wenn die Sparsity geändert wird (indem man Werte ungleich Null in Nullen umwandelt).