在Cython中使用小写的unicode字符串数组的最快方法

Question

Numpy的字符串函数都非常慢,并且性能低于纯python列表.我期待使用Cython优化所有正常的字符串函数.

例如,让我们采用一个100,000个unicode字符串的numpy数组,其数据类型为unicode或object,每个字符串为lowecase.

alist = ['JsDated', '???????'] * 50000
arr_unicode = np.array(alist)
arr_object = np.array(alist, dtype='object')

%timeit np.char.lower(arr_unicode)
51.6 ms ± 1.99 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

使用列表理解同样快

%timeit [a.lower() for a in arr_unicode]
44.7 ms ± 2.69 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

对于对象数据类型,我们无法使用np.char.列表理解速度是3倍.

%timeit [a.lower() for a in arr_object]
16.1 ms ± 147 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

我知道如何在Cython中执行此操作的唯一方法是创建一个空对象数组并lower在每次迭代时调用Python字符串方法.

import numpy as np
cimport numpy as np
from numpy cimport ndarray

def lower(ndarray[object] arr):
    cdef int i
    cdef int n = len(arr)
    cdef ndarray[object] result = np.empty(n, dtype='object')
    for i in range(n):
        result[i] = arr[i].lower()
    return result

这产生了适度的改善

%timeit lower(arr_object)
11.3 ms ± 383 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

我试过用datandarray属性直接访问内存,如下所示:

def lower_fast(ndarray[object] arr):
    cdef int n = len(arr)
    cdef int i
    cdef char* data = arr.data
    cdef int itemsize = arr.itemsize
    for i in range(n):
        # no idea here

我相信data是一个连续的内存,一个接一个地保存所有原始字节.访问这些字节非常快,似乎转换这些原始字节会使性能提高2个数量级.我发现了一个tolower可能有效的c ++函数,但我不知道如何用Cython挂钩它.

用最快的方法更新(对unicode不起作用)

这是迄今为止我发现的最快的方法,来自另一篇SO帖子.这通过data属性访问numpy memoryview来降低所有ascii字符的范围.我认为它会破坏其他字节在65到90之间的unicode字符.但速度非常好.

cdef int f(char *a, int itemsize, int shape):
    cdef int i
    cdef int num
    cdef int loc
    for i in range(shape * itemsize):
        num = a[i]
        print(num)
        if 65 <= num <= 90:
            a[i] +=32

def lower_fast(ndarray arr):
    cdef char *inp
    inp = arr.data
    f(inp, arr.itemsize, arr.shape[0])
    return arr

这比其他人快100倍,我正在寻找.

%timeit lower_fast(arr)
103 µs ± 1.23 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Answer 1

这仅比我的机器上的列表理解快一点，但如果您想要 unicode 支持，这可能是最快的方法。你需要apt-get install libunistring-dev或任何适合您的操作系统/包管理器的东西。

\n\n

例如，在某个 C 文件中，_lower.c，

\n\n

#include <stdlib.h>\n#include <string.h>   \n#include <unistr.h>\n#include <unicase.h>\n\nvoid _c_tolower(uint8_t  **s, uint32_t total_len) {\n    size_t lower_len, s_len;\n    uint8_t *s_ptr = *s, *lowered;\n    while(s_ptr - *s < total_len) {\n        s_len = u8_strlen(s_ptr);\n        if (s_len == 0) {\n            s_ptr += 1;\n            continue;\n        }\n        lowered = u8_tolower(s_ptr, s_len, NULL, NULL, NULL, &lower_len);\n        memcpy(s_ptr, lowered, lower_len);\n        free(lowered);\n        s_ptr += s_len;\n    }\n}\n

\n\n

然后，在lower.pxd你做

\n\n

cdef extern from "_lower.c":\n    cdef void _c_tolower(unsigned char **s, unsigned int total_len)\n

\n\n

最后，在lower.pyx：

\n\n

cpdef void lower(ndarray arr):\n    cdef unsigned char * _arr\n    _arr = <unsigned char *> arr.data\n    _c_tolower(&_arr, arr.shape[0] * arr.itemsize)\n

\n\n

在我的笔记本电脑上，我对上面的列表理解花费了 46 毫秒，对这个方法花费了 37 毫秒（对于你的列表理解花费了 0.8 毫秒）lower_fast），所以这可能不值得，但我想我会把它写出来，以防你想要一个如何将这样的东西挂接到 Cython 的示例。

\n\n

有几点改进我不知道会产生很大的影响：

\n\n

\n
• arr.data我猜是类似方阵的东西吗？（我不知道，我不使用 numpy 做任何事情），并用\\x00s 填充较短字符串的末尾。我懒得弄清楚如何u8_tolower查看过去的 0，所以我只是手动快进过去它们（这就是该if (s_len == 0)子句所做的）。我怀疑一次调用u8_tolower会比调用数千次要快得多。
\n
• 我正在做很多释放/内存复制。如果你聪明的话，也许可以避免这种情况。
\n
• 我认为每个小写 unicode 字符最多与其大写变体一样宽，因此这不应该遇到任何段错误或缓冲区覆盖或只是重叠子字符串问题，但不要相信我的话。
\n

\n\n

不是真正的答案，但希望它有助于您进一步的调查！

\n\n

PS 你会注意到这会就地降低，所以用法如下：

\n\n

>>> alist = [\'JsDated\', \'\xd0\xa3\xd0\x9a\xd0\xa0\xd0\x90\xd0\x87\xd0\x9d\xd0\x90\', \'\xe9\x81\x93\xe5\xbe\xb7\xe7\xb6\x93\', \'\xd0\x9d\xd1\x83 \xd0\x98 \xd0\xb9\xd0\x95\xd1\x88\xd0\xa8\xd0\xbe\'] * 2\n>>> arr_unicode = np.array(alist)\n>>> lower_2(arr_unicode)\n>>> for x in arr_unicode:\n...     print x\n...\njsdated\n\xd1\x83\xd0\xba\xd1\x80\xd0\xb0\xd1\x97\xd0\xbd\xd0\xb0\n\xe9\x81\x93\xe5\xbe\xb7\xe7\xb6\x93\n\xd0\xbd\xd1\x83 \xd0\xb8 \xd0\xb9\xd0\xb5\xd1\x88\xd1\x88\xd0\xbe\njsdated\n\xd1\x83\xd0\xba\xd1\x80\xd0\xb0\xd1\x97\xd0\xbd\xd0\xb0\n\xe9\x81\x93\xe5\xbe\xb7\xe7\xb6\x93\n\xd0\xbd\xd1\x83 \xd0\xb8 \xd0\xb9\xd0\xb5\xd1\x88\xd1\x88\xd0\xbe\n\n>>> alist = [\'JsDated\', \'\xd0\xa3\xd0\x9a\xd0\xa0\xd0\x90\xd0\x87\xd0\x9d\xd0\x90\'] * 50000\n>>> arr_unicode = np.array(alist)\n>>> ct = time(); x = [a.lower() for a in arr_unicode]; time() - ct;\n0.046072959899902344\n>>> arr_unicode = np.array(alist)\n>>> ct = time(); lower_2(arr_unicode); time() - ct\n0.037489891052246094\n

\n\n

编辑

\n\n

DUH，你将 C 函数修改为如下所示

\n\n

void _c_tolower(uint8_t  **s, uint32_t total_len) {\n    size_t lower_len;\n    uint8_t *lowered;\n\n    lowered = u8_tolower(*s, total_len, NULL, NULL, NULL, &lower_len);\n    memcpy(*s, lowered, lower_len);\n    free(lowered);\n}\n

\n\n

然后它一口气完成了这一切。看起来更危险，因为旧数据中留下的东西可能lower_len比原始字符串短……简而言之，这段代码完全是实验性的，仅用于说明目的，请勿在生产中使用它，它可能会损坏。

\n\n

无论如何，这样速度快了约 40%：

\n\n

>>> alist = [\'JsDated\', \'\xd0\xa3\xd0\x9a\xd0\xa0\xd0\x90\xd0\x87\xd0\x9d\xd0\x90\'] * 50000\n>>> arr_unicode = np.array(alist)\n>>> ct = time(); lower_2(arr_unicode); time() - ct\n0.022463043975830078 \n

\n