Question

我有这样的数据：

data = {'x':Counter({'a':1,'b':45}), 'y':Counter({'b':1, 'c':212})}

我的标签是data的键，内部字典的键是功能：

all_features = ['a','b','c']
all_labels = ['x','y']

我需要创建列表列表：

[[data[label][feat] for feat in all_features] for label in all_labels]

[OUT]：

[[1, 45, 0], [0, 1, 212]]

我的len(all_features)约为5,000,000，len(all_labels)约为100,000

最终目的是创建scipy稀疏矩阵，例如：

from collections import Counter
from scipy.sparse import csc_matrix
import numpy as np


all_features = ['a','b','c']
all_labels = ['x','y']

csc_matrix(np.array([[data[label][feat] for feat in all_features] for label in all_labels]))

但是循环遍历大量列表是非常低效的。

那么如何有效地查看大型列表？

还有其他方法可以在data创建scipy矩阵而不循环浏览所有功能和标签吗？

Answer 1

正如您所经历的那样，将词典字典转换为numpy或scipy数组并不是太有趣。如果您事先知道all_features和all_labels，那么最好从一开始就使用scipy稀疏COO矩阵来保持计数。

无论是否可行，您都希望按排序顺序保留功能和标签列表，以加快查找速度。所以我假设以下内容不会改变任何一个数组：

all_features = np.array(all_features)
all_labels = np.array(all_labels)
all_features.sort()
all_labels.sort()

让我们按照它们存储在词典中的顺序提取data中的标签，并查看每个项目落入all_labels的位置：

labels = np.fromiter(data.iterkeys(), all_labels.dtype, len(data))
label_idx = np.searchsorted(all_labels, labels)

现在让我们计算每个标签有多少个特征，并从中计算稀疏数组中非零项的数量：

label_features = np.fromiter((len(c) for c in data.iteritems()), np.intp,
                             len(data))
indptr = np.concatenate(([0], np.cumsum(label_features)))
nnz = indptr[-1]

现在，我们提取每个标签的功能及其相应的计数

import itertools
features_it = itertools.chain(*(c.iterkeys() for c in data.itervalues()))
features = np.fromiter(features_it, all_features.dtype, nnz)
feature_idx = np.searchsorted(all_features, features)
counts_it = itertools.chain(*(c.itervalues() for c in data.itervalues()))
counts = np.fromiter(counts_it, np.intp, nnz)

凭借我们所拥有的，我们可以直接创建CSR矩阵，标签为行，功能为列：

sps_data = csr_matrix((counts, feature_idx, indptr),
                      shape=(len(all_labels), len(all_features)))

唯一的问题是这个稀疏数组的行不是all_labels的顺序，而是按照它们在data上迭代时出现的顺序。但是我们feature_idx告诉我们每个标签的最终位置，我们可以通过执行以下操作来重新排列行：

sps_data = sps_data[np.argsort(label_idx)]

是的，它很混乱，令人困惑，而且可能不是很快，但是它有效，并且它会比你在问题中提出的内存效率更高：

>>> sps_data.A
array([[  1,  45,   0],
       [  0,   1, 212]], dtype=int64)
>>> all_labels
array(['x', 'y'], 
      dtype='<S1')
>>> all_features
array(['a', 'b', 'c'], 
      dtype='<S1')

Answer 2

数据集非常大，所以我认为构造一个临时的numpy数组是不切实际的（如果使用32位整数，1e5 x 5e6矩阵需要大约2TB的内存）。

我假设您知道标签数量的上限。

代码可能如下所示：

import scipy.sparse
n_rows = len(data.keys())
max_col = int(5e6)
temp_sparse = scipy.sparse.lil_matrix((n_rows, max_col), dtype='int')

for i, (features, counts) in enumerate(data.iteritems()):
    for label, n in counts.iteritem():
        j = label_pos[label]
        temp_sparse[i, j] = n
csc_matrix = temp_sparse.csc_matrix(temp_matrix)

label_pos返回标签的列索引。如果使用字典来存储硬盘数据库应该做的5百万个标签的索引是不切实际的。字典可以在线创建，因此不需要事先了解所有标签。

迭代100,000个特征需要一段合理的时间，所以我认为如果数据集足够稀疏，这个解决方案可以工作。祝好运！

Answer 3

还有其他方法可以从数据创建scipy矩阵而不需要循环通过所有功能和标签？

我认为没有任何捷径可以减少查找总数。你开始使用计数器字典（一个字典子类），因此嵌套级别都是无序集合。将它们按所需顺序放回的唯一方法是对每个数据点执行data[label][feat]查找。

通过确保每个标签只执行一次data[label]查询，您可以将时间缩短一半：

>>> counters = [data[label] for label in all_labels]
>>> [[counter[feat] for feat in all_features] for counter in counters]
[[1, 45, 0], [0, 1, 212]]

您还可以尝试使用 map（）而不是列表推导来加快运行时间（映射可以利用内部length_hint来预先调整结果数组的大小）：

>>> [map(counter.__getitem__, all_features) for counter in counters]
[[1, 45, 0], [0, 1, 212]]

最后，确保在函数内部运行代码（CPython中的局部变量查找比全局变量查找更快）：

def f(data, all_features, all_labels):
    counters = [data[label] for label in all_labels]
    return [map(counter.__getitem__, all_features) for counter in counters]

如何有效地在python中创建大型列表列表？

3 个答案: