如何在 Python 中优化二维字符串数组的序数编码？

Question

我有一个 Pandas 系列，每行包含一个字符串数组：

0                                           []
1                                           []
2                                           []
3                                           []
4         [0007969760, 0007910220, 0007910309]
                          ...                 
243223                                      []
243224                            [0009403370]
243225                [0009403370, 0007190939]
243226                                      []
243227                                      []
Name: Item History, Length: 243228, dtype: object

我的目标是在这里做一些简单的 Ordinal Encoding，但要尽可能高效（在时间和内存方面），但要注意以下几点：

1. 空列表需要插入一个表示“空列表”的整数，该整数也是唯一的。 （例如，如果有 100 个唯一字符串，则空列表可能被编码为 [101]）。
2. 必须以某种方式保存编码，以便将来我可以对其他列表进行相同的编码
3. 如果这些未来列表包含初始输入数据中不存在的字符串，则它必须对其单独的整数进行编码以表示“在 mate 之前从未见过”。

显而易见的问题是“你为什么不只使用 sklearn 中的 OrdinalEncoder”。好吧，除了没有未知的项目处理程序之外，以这种方式逐行应用实际上也非常慢（我们必须将它放在所有不同字符串的组合单个数组中，然后使用 Series.apply(lambda x: oe.transform(x)) 转换每一行)，因为它必须做一些 dict-comprehension 来为每一行构建映射表，这需要时间。 每次调用的时间并不多，只有大约 0.01 秒，但这对于我拥有的数据量来说仍然太慢了。

一种解决方案是将字典理解从每一行部分中取出，并在遍历行之前构建一个映射表，如以下函数所示：

def encode_labels(X, table, noHistory, unknownItem):

    res = np.empty(len(X), dtype=np.ndarray)

    for i in range(len(X)):
        if len(X[i]) == 0:
            res[i] = np.array([noHistory])
        else:
            res[i] = np.empty(len(X[i]), dtype=np.ndarray)
            for j in range(len(X[i])):
                try:
                    res[i][j] = table[X[i][j]]
                except KeyError:
                    res[i][j] = unknownItem

    return res

这比逐行的.apply() 好很多，但仍然不是最快的代码。我可以对它进行 cythonize 并进行一系列其他优化以获得更多的加速，但这并不是更好的数量级：

%%cython

cimport numpy as cnp
import numpy as np
from cpython cimport array
import array

cpdef list encode_labels_cy(cnp.ndarray X, dict table, int noHistory, int unknownItem, array.array rowLengths):

    cdef int[:] crc = rowLengths

    cdef list flattenedX = []    
    cdef Py_ssize_t i, j
    cdef list row = []

    for row in X:
        if len(row)==0:
            flattenedX.append('ZZ')
        else:
            flattenedX.extend(row)

    cdef Py_ssize_t lenX = len(flattenedX)

    cdef array.array res = array.array('i', [0]*lenX)
    cdef int[:] cres = res

    i=0
    while i < lenX:
        try:
            cres[i] = table[flattenedX[i]]
        except KeyError:
            cres[i] = unknownItem
        i += 1

    cdef list pyres = []
    cdef Py_ssize_t s = 0

    for k in crc:
        pyres.append(res[s:s+k])
        s+= k

    return pyres

# classes is a dict of {string:int} mappings. noHistory and unknownItem are ints encoding those values

%timeit encode_labels(X.values, classes, noHistory, unknownItem)
%timeit encode_labels_cy(X.values, classes, noHistory, unknownItem, array.array('i', [1 if x == 0 else x for x in [len(j) for j in X]]))

50.4 ms ± 2.76 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
11.2 ms ± 1.11 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)

（这是针对 5000 行样本，而不是整个数据集）。

更新：我设法得到一个在 ctypes 中工作的实现，并且 比逐行的 .apply() 和我原来的原生 python 都快，但它是仍然比 Cython 慢（在我看来真的不应该这样！）

所以;我怎样才能让它更快？并且理想地同时保持内存使用尽可能低？ 这不一定是纯 python。如果您可以在 Cython 或 ctypes 或其他东西中使其变得活泼，那就太好了。这段代码将构成神经网络预处理的一部分，因此此时还有一些 GPU 在等待数据；如果你能利用这些，那就更好了。多处理也可能是我还没有设法探索的一个选项，但问题是它需要每个进程的 string:int 映射表的副本，这 a) 生成速度慢 b) 使用大量内存.

编辑：

忘记提供一些数据。您可以运行以下命令来获取与我的格式相似的输入数据集：

import numpy as np
import pandas as pd

a = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']

X = pd.Series([[a[np.random.randint(0, 26)] for i in range(np.random.randint(0, 10))] for j in range(5000)])

classes = dict(zip(a, np.arange(0, 26)))
unknownItem = 26
noHistory = 27

只有 5000 行，但这应该足以准确地确定哪种方法更快。

Answer 1

这是基于NumPy's searchsorted的一个-

k,v = classes.keys(),classes.values()
k,v = np.array(list(k)),np.array(list(v))

cl = np.concatenate(s)

sidx = k.argsort()
idx = np.searchsorted(k,cl, sorter=sidx)
out_of_bounds_mask = idx==len(k)

idx[out_of_bounds_mask] = 0
ssidx = sidx[idx]
invalidmask = k[ssidx] != cl
out_of_bounds_mask |= invalidmask

vals = v[ssidx]
vals[out_of_bounds_mask] = unknownItem

lens = list(map(len,s))
E = [noHistory] # use np.array() if you need outputs for empty entries as arrays
out = []
start = 0
for l in lens:
    if l==0:
        out.append(E)
    else:
        out.append(vals[start:start+l])
        start += l

另一种方法基本上是来自已发布问题的encode_labels，但经过优化，减少了对输入的访问并避免了 try-catch -

def encode_labels2(X, table, noHistory, unknownItem):
    L0 = len(X)
    res = [[noHistory]]*L0
    for i in range(L0):
        L = len(X[i])
        if L != 0:
            res_i = [unknownItem]*L
            for j in range(L):
                Xij = X[i][j]
                if Xij in table:
                    res_i[j] = table[Xij]
            res[i] = res_i
    return res

那么，我们就可以介绍numba的jit编译了。因此，更改将是 -

from numba import jit

@jit
def encode_labels2(X, table, noHistory, unknownItem):
# .. function stays the same

很少有警告，这似乎是因为我们使用的是列表而不是数组。这些可以忽略。

Answer 2

使用以下 Cython 函数，我得到了大约 5 倍的加速因子。它使用一个临时列表来存储相关数据的逐行副本，这些数据应该被初始化得足够大，以便它可以容纳每一行的数据（即，如果每行最大元素数的上限是已知的，请使用该上限，否则请使用启发式值，以将必要的调整大小数量保持在最低限度。

cpdef list encode_labels_cy_2(cnp.ndarray X, dict table, int noHistory, int unknownItem):

    cdef Py_ssize_t i, n
    cdef list result = []
    cdef list tmp = [noHistory] * 10  # initialize big enough so that it's likely to fit all elements of a row

    for row in X:
        n = len(row)
        while len(tmp) < n:  # if too small, resize
            tmp.append(noHistory)
        if n > 0:
            i = 0
            while i < n:
                tmp[i] = table.get(row[i], unknownItem)
                i += 1
        else:
            tmp[0] = noHistory
            i = 1
        result.append(tmp[:i])

    return result

如果每行的元素数量变化很大，并且无法在启动时做出好的估计，您还可以通过类似于CPython's list growth pattern 的过度分配来调整tmp 列表的大小。