python - 在 Cython 中小写 unicode 字符串的 numpy 数组的最快方法

Question

Numpy 的字符串函数都非常慢，而且性能不如纯 Python 列表。我希望使用 Cython 优化所有普通字符串函数。

例如，让我们采用一个包含 100,000 个数据类型为 unicode 或对象的 unicode 字符串的 numpy 数组，并将每个字符串小写。

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 中执行此操作的唯一方法是创建一个空对象数组并在每次迭代时调用 Python 字符串方法 lower。

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)

我试过像这样使用 data ndarray 属性直接访问内存:

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 是一 block 连续的内存，一个接一个地保存所有原始字节。访问这些字节非常快，转换这些原始字节似乎可以将性能提高 2 个数量级。我找到了一个 tolower可能有效的 c++ 函数，但我不知道如何将它与 Cython Hook 。

用最快的方法更新(不适用于 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 或适合您的操作系统/包管理器的任何内容。

在一些 C 文件中，例如，_lower.c，有

#include <stdlib.h>
#include <string.h>   
#include <unistr.h>
#include <unicase.h>

void _c_tolower(uint8_t  **s, uint32_t total_len) {
    size_t lower_len, s_len;
    uint8_t *s_ptr = *s, *lowered;
    while(s_ptr - *s < total_len) {
        s_len = u8_strlen(s_ptr);
        if (s_len == 0) {
            s_ptr += 1;
            continue;
        }
        lowered = u8_tolower(s_ptr, s_len, NULL, NULL, NULL, &lower_len);
        memcpy(s_ptr, lowered, lower_len);
        free(lowered);
        s_ptr += s_len;
    }
}

然后，在 lower.pxd 中做

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

最后，在 lower.pyx 中:

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

在我的笔记本电脑上，我用了 46 毫秒来理解你上面的列表，用了 37 毫秒来用这个方法(你的 lower_fast 是 0.8 毫秒)，所以这可能不值得，但我想我' d 键入它以防你想要一个如何将这样的东西挂接到 Cython 的例子。

我不知道有几点改进会产生很大的不同:

• arr.data 我猜是不是有点像方阵？ (我不知道，我什么都不用 numpy)，并用 \x00 填充较短字符串的末尾。我懒得弄清楚如何让 u8_tolower 看过去的 0，所以我只是手动快进过去(这就是 if (s_len == 0) 条款正在做)。我怀疑一次调用 u8_tolower 会比调用数千次快得多。
• 我正在做大量的释放/存储操作。如果你聪明的话，你或许可以避免这种情况。
• 我认为每个小写 unicode 字符最多与其大写变体一样宽，因此这不应该遇到任何段错误或缓冲区覆盖或只是重叠子字符串问题，但不要相信我的话。

不是真正的答案，但希望对您的进一步调查有所帮助!

PS 你会注意到这是就地降低，所以用法是这样的:

>>> alist = ['JsDated', 'УКРАЇНА', '道德經', 'Ну И йЕшШо'] * 2
>>> arr_unicode = np.array(alist)
>>> lower_2(arr_unicode)
>>> for x in arr_unicode:
...     print x
...
jsdated
україна
道德經
ну и йешшо
jsdated
україна
道德經
ну и йешшо

>>> alist = ['JsDated', 'УКРАЇНА'] * 50000
>>> arr_unicode = np.array(alist)
>>> ct = time(); x = [a.lower() for a in arr_unicode]; time() - ct;
0.046072959899902344
>>> arr_unicode = np.array(alist)
>>> ct = time(); lower_2(arr_unicode); time() - ct
0.037489891052246094

编辑

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

void _c_tolower(uint8_t  **s, uint32_t total_len) {
    size_t lower_len;
    uint8_t *lowered;

    lowered = u8_tolower(*s, total_len, NULL, NULL, NULL, &lower_len);
    memcpy(*s, lowered, lower_len);
    free(lowered);
}

然后它一次完成所有操作。就 lower_len 遗留的旧数据中的某些内容可能比原始字符串更短而言，看起来更危险...简而言之，此代码完全是实验性的，仅用于说明目的，请勿使用此代码在生产中它可能会中断。

无论如何，这种方式快 40%:

>>> alist = ['JsDated', 'УКРАЇНА'] * 50000
>>> arr_unicode = np.array(alist)
>>> ct = time(); lower_2(arr_unicode); time() - ct
0.022463043975830078