Question

当我使用由CountVectorizer等生成的一些稀疏矩阵的scipy.sparse.hstack时，我想合并它们以用于回归，但不知怎的，它们更慢：

X1有来自analyze =“char”
X2有来自analyze =“word”
X3拥有来自analyze =“char”
X4拥有来自analyze =“word”

你会期望当你遇到X1和X2时，它会与X3或X4（相同数量的功能）的速度大致相同。但这似乎并不紧密：

from scipy.sparse import hstack
>>> a=linear_model.Ridge(alpha=30).fit(hstack((X1, X2)),y).predict(hstack((t1,t2)))
time:  57.85
>>> b=linear_model.Ridge(alpha=30).fit(X1,y).predict(t1)
time:  6.75
>>> c=linear_model.Ridge(alpha=30).fit(X2,y).predict(t2)
time:  7.33
>>> d=linear_model.Ridge(alpha=30).fit(X3,y).predict(t3)
time:  6.80
>>> e=linear_model.Ridge(alpha=30).fit(X4,y).predict(t4)
time:  11.67

我甚至注意到，当我hstack只有一个功能时，模型也会变慢。可能导致这种情况的原因是，我做错了什么，当然还有什么改进？

值得注意的编辑：

我想介绍一种我认为可以解决它的方法，即构建词汇并使用它来适应：

feats = []
method = CountVectorizer(analyzer="word", max_features=10000, ngram_range=(1,3))
method.fit(train["tweet"])
X = method.fit(...)
feats.extend(method.vocabulary_.keys())
method = CountVectorizer(analyzer="char", max_features=10000, ngram_range=(4,4))
method.fit(train["tweet"])
X2 = method.fit(...)
feats.extend(method.vocabulary_.keys())
newm = CountVectorizer(vocabulary=feats)
newm.fit(train["tweet"])
X3 = newm.fit(...)

当我适应这些时，存储的项目数量会发生奇怪的事情（我并不感到惊讶，因为可能存在重叠，因此没有20,000个功能）。怎么会有这么少的“那些”？

X
<49884x10000 sparse matrix of type '<class 'numpy.int64'>'
    with 927131 stored elements in Compressed Sparse Row format>
X2
<49884x10000 sparse matrix of type '<class 'numpy.int64'>'
    with 3256162 stored elements in Compressed Sparse Row format>
X3
<49884x19558 sparse matrix of type '<class 'numpy.int64'>'
    with 593712 stored elements in Compressed Sparse Row format>

Answer 1

Hstacking将其转换为COO格式：

>>> hstack((csr_matrix([1]), csr_matrix([2])))
<1x2 sparse matrix of type '<type 'numpy.int64'>'
    with 2 stored elements in COOrdinate format>

也许请hstack(...).tocsr()检查是否加快了速度。

Answer 2

你可以轻而易举地hstack两个CSC矩阵，保持输出CSC：

In [1]: import scipy.sparse as sps

In [2]: a = sps.csc_matrix(np.arange(25).reshape(5, 5))

In [3]: b = sps.csc_matrix(np.arange(25).reshape(5, 5))

In [4]: data = np.concatenate((a.data, b.data))

In [5]: indices = np.concatenate((a.indices, b.indices))

In [7]: indptr = np.concatenate((a.indptr[:-1], b.indptr + a.indptr[-1]))


In [10]: c = sps.csc_matrix((data, indices, indptr),
...                         shape = (a.shape[0], a.shape[1]+b.shape[1]))

In [11]: c.A
Out[11]: 
array([[ 0,  1,  2,  3,  4,  0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19, 15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24, 20, 21, 22, 23, 24]])

完全相同的代码，csc替换为csr无处不在，vstack两个CSR矩阵。

您需要做一些时间安排，但在大多数情况下，我认为将两种矩阵转换为CSR或CSC会更快，具体取决于您要进行的堆叠，如上所述进行堆叠，然后将结果转换为无论你想要什么，而不是使用内置的堆叠功能。

Hstacking功能以某种方式导致预测的额外减速

值得注意的编辑：

2 个答案: