Sparse-Matrix-Slicing mit Liste von Int

Question

Ich schreibe einen maschinellen Lernalgorithmus auf riesigen & spärlichen Daten (meine Matrix ist von Form (347, 5 416 812 801) aber sehr spärlich, nur 0,13% der Daten ist nicht Null

.

Meine spärlichen Größe der Matrix ist 105 000 Bytes (< 1Mbytes) und ist von csr Art.

ich durch die Wahl einer Liste von Beispielen Indizes für jeweils separaten Zug/Test-Sets bin versucht. ich so Ich möchte meinen Datensatz in zwei Teile unterteilen:

training_set = matrix[train_indices] 

der Form (len(training_indices), 5 416 812 801), spärlich noch

testing_set = matrix[test_indices] 

der Form (347-len(training_indices), 5 416 812 801) auch spärlich

Mit training_indices und testing_indices zwei list von int

Aber training_set = matrix[train_indices] scheint zum Scheitern verurteilt und gibt ein Segmentation fault (core dumped)

Es ist möglicherweise kein Speicherproblem , wie ich diesen Code auf einem Server mit 64 GB RAM ausführen.

Irgendwelche Hinweise darauf, was die Ursache sein könnte?

Answer 1

Ich denke, dass ich die csr Reihe neu erstellt haben Indizierung mit:

def extractor(indices, N): 
    indptr=np.arange(len(indices)+1) 
    data=np.ones(len(indices)) 
    shape=(len(indices),N) 
    return sparse.csr_matrix((data,indices,indptr), shape=shape) 

Testing auf einem csr ich um hatte hängen:

In [185]: M 
Out[185]: 
<30x40 sparse matrix of type '<class 'numpy.float64'>' 
    with 76 stored elements in Compressed Sparse Row format> 

In [186]: indices=np.r_[0:20] 

In [187]: M[indices,:] 
Out[187]: 
<20x40 sparse matrix of type '<class 'numpy.float64'>' 
    with 57 stored elements in Compressed Sparse Row format> 

In [188]: extractor(indices, M.shape[0])*M 
Out[188]: 
<20x40 sparse matrix of type '<class 'numpy.float64'>' 
    with 57 stored elements in Compressed Sparse Row format> 

Wie bei einer Reihe von anderen csr Methoden, verwendet es Matrixmultiplikation, um den endgültigen Wert zu erzeugen. In diesem Fall mit einer Sparse-Matrix mit 1 in ausgewählten Zeilen. Die Zeit ist tatsächlich ein bisschen besser.

In [189]: timeit M[indices,:] 
1000 loops, best of 3: 515 µs per loop 
In [190]: timeit extractor(indices, M.shape[0])*M 
1000 loops, best of 3: 399 µs per loop 

In Ihrem Fall die Extraktor Matrix (len (training_indices), 347) in der Form, mit nur len(training_indices) Werten. Es ist also nicht groß.

Aber wenn die matrix ist so groß (oder mindestens die 2. Dimension so groß), dass es einen Fehler in der Matrix Multiplikation Routinen erzeugt, könnte es zu Segmentierungsfehler führen, ohne Python/numpy Trapping es.

Funktioniert matrix.sum(axis=1). Auch das verwendet eine Matrixmultiplikation, allerdings mit einer dichten Matrix von 1s. Oder sparse.eye(347)*M, eine Matrixmultiplikation ähnlicher Größe?