Почему сжатие не работает на разреженных массивах?

Question

У меня есть следующий код:

import numpy as np
from scipy import sparse

x = np.eye(3)
print(x.sum(axis=1).shape)

x = sparse.eye(3)
print(x.sum(axis=1).shape)
print(x.sum(axis=1).squeeze().shape)

Я получил следующий вывод:

(3,)
(3, 1)
(1, 3)

Похоже, squeeze не работает, как предполагалось. Что я делаю не так?

Answer 1

In [1]: from scipy import sparse                                                                 
In [2]: x = np.eye(3)                                                                            
In [3]: x                                                                                        
Out[3]: 
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
In [4]: x.shape                                                                                  
Out[4]: (3, 3)

In [5]: xs = sparse.eye(3)                                                                       
In [6]: xs                                                                                       
Out[6]: 
<3x3 sparse matrix of type '<class 'numpy.float64'>'
    with 3 stored elements (1 diagonals) in DIAgonal format>
In [7]: print(xs)                                                                                
  (0, 0)    1.0
  (1, 1)    1.0
  (2, 2)    1.0
In [8]: xs.shape                                                                                 
Out[8]: (3, 3)

Сумма np создает массив с одним меньшим измерением (если вы не используете параметр keepdims)

In [9]: x.sum(axis=1)                                                                            
Out[9]: array([1., 1., 1.])

разреженная сумма создает объект np.matrix.

In [10]: xs.sum(axis=1)                                                                          
Out[10]: 
matrix([[1.],
        [1.],
        [1.]])
In [11]: _.shape                                                                                 
Out[11]: (3, 1)

np.matrix по определению всегда 2d. Но у него есть свойство A1, которое преобразуется в ndarray и применяет сжатие.

In [12]: xs.sum(axis=1).A1                                                                       
Out[12]: array([1., 1., 1.])

---

Sparse фактически выполняет сумму строк или столбцов с помощью умножения матриц:

In [21]: xs*np.matrix(np.ones((3,1)))                                                            
Out[21]: 
matrix([[1.],
        [1.],
        [1.]])

разреженная матрица * np.matrix создает np.matrix

Если sum используется ndarray, результат будет ndarray и сжимаемым

In [22]: xs*np.ones((3,1))                                                                       
Out[22]: 
array([[1.],
       [1.],
       [1.]])

Обратите внимание, что я использовал * (я мог бы использовать @); разреженное определение умножения (например, точка) имеет приоритет.

In [23]: np.matrix(np.ones((1,3)))*xs                                                            
Out[23]: matrix([[1., 1., 1.]])