问题

我正在尝试Cythonize两个小函数,主要处理numpy ndarray用于某些科学目的.这两个小函数在遗传算法中被称为数百万次,占算法占用的大部分时间.

我自己取得了一些进展并且都很好地工作,但我只获得了很小的速度提升(10%).更重要的是,cython --annotate表明大多数代码仍然通过Python.

代码

第一个功能:

此函数的目的是获取数据切片,并在内部嵌套循环中调用数百万次.根据数据[1] [1]中的bool,我们要么以正序或反向顺序得到切片.

#Ipython notebook magic for cython
%%cython --annotate
import numpy as np
from scipy import signal as scisignal

cimport cython
cimport numpy as np
def get_signal(data):
    #data[0] contains the data structure containing the numpy arrays
    #data[1][0] contains the position to slice
    #data[1][1] contains the orientation to slice, forward = 0, reverse = 1

    cdef int halfwinwidth = 100
    cdef int midpoint = data[1][0]
    cdef int strand = data[1][1]
    cdef int start = …

我正在使用cython memoryviews来引用一些灰度图像.我已经在我编写的一些图像处理代码中成功使用了它.现在,我需要使用一些OpenCV函数.不幸的是,我发现我无法将内存视图作为图像参数传递给OpenCV函数.代码编译,但是当它运行时,它在OpenCV函数调用时停止,并出现"TypeError:不是一个numpy数组"

我可以使用np.asarray(my_memoryview)将memoryview转换回numpy数组.这有效,但它复制数据并且速度很慢.

在memoryview文档中,他们谈论强制到numpy http://docs.cython.org/src/userguide/memoryviews.html#coercion-to-numpy 似乎我应该能够将内存视图强制为numpy数组没有复制内存.但是,如果我写:

im = np.asarray(<np.uint8_t[:, :]> my_memoryview)

它导致编译错误:"只能从指针或数组创建cython.array"

有关如何将内存视图传递给OpenCV函数的任何帮助,或者如何将内存视图强制转换为numpy数组而不复制数据将非常感激!

我打算在 python 数组中使用 memoryview：

...
cdef double[:, :] a = np.array([[1, 1, 0]])
cdef double[:, :] c = 0,5 * a * a.T

但它引发了一个错误：

'*' 的操作数类型无效（double; double[:, :]）

在这种情况下我能做什么？

我试图将数据从memoryview传递到ctypes数组,这在Python 3.4中运行良好,但在Python 2.7中运行不正常.

我跑的时候

from ctypes import c_byte
data = memoryview(b'012')
array = c_byte * 3
array.from_buffer_copy(data)

我进入<__main__.c_byte_Array_3 at 0x7f3022cb8730>Python 3.4,但在Python 2.7.6中我收到以下错误:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: expected a readable buffer object

这个错误的原因是什么,以及我如何在这两种情况下都能完成这项工作？

我知道我可以使用将数据转换为字节

array.from_buffer_copy(data.tobytes())

但我认为这是一个额外的数据副本,并不优雅,所以我正在寻找一个更好的解决方案(任何关于该tobytes方法是否有效的评论也是受欢迎的).

我有一个numpy的布尔数组：

myarr = np.array([[False, True], [True, False]])

如果我尝试使用它初始化Cython MemoryView，如下所示：

cdef bint[:,:] mymem = myarr

我收到此错误：

ValueError: Does not understand character buffer dtype format string ('?')

如果我改为这样做，则可以正常工作：

cdef np.int_t[:,:] mymem = np.int_(myarr)

如何使用Cython MemoryViews存储布尔型numpy数组？

如何在Cython中对就地存储器视图进行排序？是否有内置功能可以做到这一点？现在我必须使用numpy数组而使用numpy排序,这非常慢.

我正在将 Windows 的 C 库代码移植到 Android 中

当我在 NDK C 代码中创建动态分配的数组时，变量查看器窗口仅显示第一个元素的地址以及第一个元素的值

我想查看手机内存中的 所有数组成员

android studio中有NDK的内存查看器或类似的东西吗？

或者作为替代方案，我可以在 lldb 控制台中进行某种内存转储吗？

我正在尝试使用 Cython 用数组参数 ( quick_sort())包装 c 函数，因此我可以将一个 numpy 数组传递给它。我已经在文档、SO 和 web 上搜索了一个有效的、最小的示例，但没有找到。我已经尝试了几种可能性，但没有任何进展，所以请帮我弄清楚。这是我的文件：

快速排序

#include <stdio.h>

void quick_sort (int* a, int n) {
    int i, j, p, t;
    if (n < 2)
        return;
    p = a[n / 2];
    for (i = 0, j = n - 1;; i++, j--) {
        while (a[i] < p)
            i++;
        while (p < a[j])
            j--;
        if (i >= j)
            break;
        t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    quick_sort(a, i);
    quick_sort(a + i, …

int main(){
   int i;
   int arr[4];
   for(int i=0; i<=4; i++){
      arr[i] = 0;
   }
   return 0;
}

1. 我在youtube上看了CS107（第13讲）的一个视频，其中展示了这个例子，并通过内存图告诉了为什么上面的程序会导致无限循环。arr[4] 超出范围，应该导致存储 i 的地址并将 i 的值更改回 0，从而导致无限循环。但是当我尝试使用 gcc 编译器在我的 mac 上运行它时，for 循环执行了 5 次（通过插入 printf 检查）。即 i 的值 = 0,1,2,3,4。

我正在尝试将一个 numpy 数组转换为一个MemoryView对象，因为我必须在两个程序之间进行通信。一个只能处理 NumPy 数组，另一个只能处理 MemoryView 对象。

从 MemoryView 转换为 numpy 数组很容易通过以下方式完成：

import numpy as np
MyNumpyArray=np.array(MyMemoryView)

但是如何将 numpy 数组转换为 MemoryView？

我在这里找到：https : //docs.python.org/3/c-api/memoryview.html 有一个 PyMemoryView_FromObject(PyObject *obj) 函数，但我不知道如何在没有示例的情况下调用它。

谢谢！

我正在编写Python代码来加速二进制图像中标记对象的区域属性函数.以下代码将根据对象的索引计算二进制图像中标记对象的边界像素数.main()函数将遍历二进制图像"mask"中的所有标记对象,并计算每个对象的边框像素数.

我想知道在这个Cython代码中传递或返回变量的最佳方法是什么.变量可以是NumPy数组,也可以是类型化的Memoryviews.我已经在绕过搞砸/在不同的格式返回变量,但不能推导出最佳/最有效的方法是什么.我是新来用Cython所以Memoryviews仍然相当抽象的我,是否有这两种方法之间的不同仍是一个谜.我正在使用的图像包含100,000多个标记对象,因此这些操作需要相当高效.

总结一下:

什么时候/我应该将我的变量作为类型化的Memoryviews而不是NumPy数组传递/返回以进行非常重复的计算？有没有最好的方式或者它们是完全一样的？

%%cython --annotate

import numpy as np
import cython
cimport numpy as np

DTYPE = np.intp
ctypedef np.intp_t DTYPE_t

@cython.boundscheck(False)
@cython.wraparound(False)
def erode(DTYPE_t [:,:] img):

    # Image dimensions
    cdef int height, width, local_min
    height = img.shape[0]
    width = img.shape[1]

    # Padded Array
    padded_np = np.zeros((height+2, width+2), dtype = DTYPE)
    cdef DTYPE_t[:,:] padded = padded_np
    padded[1:height+1,1:width+1] = img

    # Eroded image
    eroded_np = np.zeros((height,width),dtype=DTYPE)
    cdef DTYPE_t[:,:] eroded = eroded_np

    cdef DTYPE_t i,j
    for i in range(height):
        for j …

我的函数接受不同大小的 numpy 数组的列表：

def function1(list list_of_numpy_arrays):

现在我正在做：

cdef int[:] a_view = list_of_numpy_arrays[index]

问题是我必须多次索引列表，因此开销大大增加了时间（10 倍）。我正在寻找类似cdef int[:] a[5]可以拥有内存视图数组的东西，这样我就可以避免索引 python 列表的开销。

如果有解决方案，我还可以传递一个列表列表。

def function2(list list_of_lists):

我编写了一些程序，该程序会numpy在每次迭代中更新列表并对其进行一些操作。迭代次数取决于时间。例如1秒内，可能会有1000到2500次迭代。这意味着numpy列表中的项目在运行1秒钟时不会超过2500。

我已经实现了一种基本算法，但我不确定这是否是最快的计算方法bonus：

import numpy as np

cdef int[:, :] pl_list
cdef list pl_length
cdef list bonus
pl_list = np.array([[8, 7]], dtype=np.int32)

def modify(pl_list, pl_length):
    cdef int k_const = 10
    mean = np.mean(pl_list, axis=0)
    mean = np.subtract(mean, pl_length)
    dev = np.std(pl_list, axis=0)
    mean[0] / dev[0] if dev[0] != 0 else 0
    mean[1] / dev[1] if dev[1] != 0 else 0

    bonus = -1 + (2 / (1 + np.exp(-k_const * mean)))
    return list(bonus)


for i in range(2499): …