问题描述
通过将类型添加到某些变量，我已经将python函数转换为cython等效项.但是，cython函数产生的输出与原始python函数略有不同.
我在这篇文章中了解了造成这种差异的一些原因 Cython:unsigned int numpy数组的索引给出不同的结果但是，即使我在本文中学到了什么，我仍然无法获得cython函数来产生与python相同的结果.
因此，我整理了4个函数来说明我尝试过的内容.有人可以帮忙揭开为什么我在每个功能上都得到稍微不同的结果吗?以及如何获取返回与function1相同的精确值的cython函数?我在下面发表一些评论:
%%cython
import numpy as np
cimport numpy as np
def function1(response, max_loc):
x, y = int(max_loc[0]), int(max_loc[1])
tmp1 = (response[y,x+1] - response[y,x-1]) / 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
tmp2 = (response[y,x+1] - response[y,x-1])
tmp3 = 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
print tmp1, tmp2, tmp3
return tmp1, tmp2, tmp3
cpdef function2(np.ndarray[np.float32_t, ndim=2] response, np.ndarray[np.float64_t, ndim=1] max_loc):
cdef unsigned int x, y
x, y = int(max_loc[0]), int(max_loc[1])
tmp1 = (response[y,x+1] - response[y,x-1]) / 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
tmp2 = (response[y,x+1] - response[y,x-1])
tmp3 = 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
print tmp1, tmp2, tmp3
return tmp1, tmp2, tmp3
cpdef function3(np.ndarray[np.float32_t, ndim=2] response, np.ndarray[np.float64_t, ndim=1] max_loc):
cdef unsigned int x, y
x, y = int(max_loc[0]), int(max_loc[1])
cdef np.float32_t tmp1, tmp2, tmp3
cdef np.float32_t r1 =response[y,x+1]
cdef np.float32_t r2 =response[y,x-1]
cdef np.float32_t r3 =response[y,x]
cdef np.float32_t r4 =response[y,x-1]
cdef np.float32_t r5 =response[y,x+1]
tmp1 = (r1 - r2) / 2*(r3 - min(r4, r5))
tmp2 = (r1 - r2)
tmp3 = 2*(r3 - min(r4, r5))
print tmp1, tmp2, tmp3
return tmp1, tmp2, tmp3
def function4(response, max_loc):
x, y = int(max_loc[0]), int(max_loc[1])
tmp1 = (float(response[y,x+1]) - response[y,x-1]) / 2*(float(response[y,x]) - min(response[y,x-1], response[y,x+1]))
tmp2 = (float(response[y,x+1]) - response[y,x-1])
tmp3 = 2*(float(response[y,x]) - min(response[y,x-1], response[y,x+1]))
print tmp1, tmp2, tmp3
return tmp1, tmp2, tmp3
max_loc = np.asarray([ 15., 25.], dtype=np.float64)
response = np.zeros((49,49), dtype=np.float32)
x, y = int(max_loc[0]), int(max_loc[1])
response[y,x] = 0.959878861904
response[y,x-1] = 0.438348740339
response[y,x+1] = 0.753262758255
result1 = function1(response, max_loc)
result2 = function2(response, max_loc)
result3 = function3(response, max_loc)
result4 = function4(response, max_loc)
print result1
print result2
print result3
print result4
和结果:
0.0821185777156 0.314914 1.04306030273
0.082118573023 0.314914017916 1.04306024313
0.0821185708046 0.314914017916 1.04306030273
0.082118573023 0.314914017916 1.04306024313
(0.082118577715618812, 0.31491402, 1.043060302734375)
(0.08211857302303427, 0.3149140179157257, 1.0430602431297302)
(0.08211857080459595, 0.3149140179157257, 1.043060302734375)
(0.082118573023034269, 0.31491401791572571, 1.0430602431297302)
function1 代表我在原始python函数中执行的操作. tmp1是结果.
function2 是我的第一个cython版本，其结果略有不同.显然，如果响应数组使用类型为unsigned int或int的类型变量索引，则即使数组的类型为np.float32_t，结果也将强制转换为double(使用PyFloat_FromDouble).但是，如果数组是用python int索引的，则使用函数PyObject_GetItem代替，而我得到的是np.float32_t，这就是function1中发生的情况.因此，使用np.float32_t操作数来计算function1中的表达式，而使用double来计算function2中的表达式.我得到的打印结果与function1中的打印结果略有不同.
function3 是我的第二次cython尝试，试图获得与function1相同的输出.在这里，我使用无符号的int索引来访问数组响应，但结果留在np.float32_t中间变量中，然后将其用于计算中.我得到的结果略有不同.显然，print语句将使用PyFloat_FromDouble，因此它将无法打印np.float32_t.
然后我尝试更改python函数以匹配cython. function4 试图通过将每个表达式中的至少一个操作数转换为浮点数来实现此目的，因此其余操作数也被强制转换为python float，这是cython中的double，并且该表达式使用double来计算，就像在function2中一样.该函数内部的打印内容与function2完全相同，但是返回的值略有不同?！
如果您使用的是单精度浮点数，其精度只有7.225的十进制数字，那么我不希望强制转换会产生两倍的小变化很多.
为了阐明对function2的描述，如果使用对象进行索引，则Cython使用PyObject_GetItem来获取np.float32标量对象(不是np.float32_t，它只是C float的typedef ).如果您改为直接索引到缓冲区中，而Cython需要一个对象，它将调用PyFloat_FromDouble.由于没有输入对象，因此需要对象分配tmp1，tmp2和tmp3.
function3中，您键入了tmp变量，但是它仍然需要创建float对象以打印并返回结果.如果您改用NumPy ndarray(请参见下文)，则不会出现此问题:顺便说一下，在function1中，当您除以2时，会将结果提升为np.float64.例如:
>>> type(np.float32(1) / 2)
<type 'numpy.float64'>
vs.
>>> type(np.float32(1) / np.float32(2))
<type 'numpy.float32'>
即使您确保def和cpdef函数中的所有操作都为float32，最终结果仍可能在已编译扩展模块中的两者之间有所不同.在下面的示例中，我检查了function1中的中间结果是否都是np.float32对象.在生成的function2 C中，我检查了是否没有强制转换为double(或等效的typedef).但是，这两个函数仍然会产生稍微不同的结果.我可能不得不深入编译后的程序集以找出原因，但也许我忽略了一些简单的事情.
def function1(response, max_loc):
tmp = np.zeros(3, dtype=np.float32)
x, y = int(max_loc[0]), int(max_loc[1])
tmp[0] = (((response[y,x+1] - response[y,x-1]) / np.float32(2)) *
(response[y,x] - min(response[y,x-1], response[y,x+1])))
tmp[1] = response[y,x+1] - response[y,x-1]
tmp[2] = 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
print tmp[0], tmp[1], tmp[2]
return tmp
cpdef function2(np.ndarray[np.float32_t, ndim=2] response, max_loc):
cdef np.ndarray[np.float32_t, ndim=1] tmp = np.zeros(3, dtype=np.float32)
cdef unsigned int x, y
x, y = int(max_loc[0]), int(max_loc[1])
tmp[0] = (((response[y,x+1] - response[y,x-1]) / <np.float32_t>2) *
(response[y,x] - min(response[y,x-1], response[y,x+1])))
tmp[1] = response[y,x+1] - response[y,x-1]
tmp[2] = 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
print tmp[int(0)], tmp[int(1)], tmp[int(2)]
return tmp
比较:
>>> function1(response, max_loc)
0.0821186 0.314914 1.04306
array([ 0.08211858, 0.31491402, 1.0430603 ], dtype=float32)
>>> function2(response, max_loc)
0.0821186 0.314914 1.04306
array([ 0.08211857, 0.31491402, 1.0430603 ], dtype=float32)
I have converted a python function into a cython equivalent by adding types to some variables. However, the cython function to produces slightly different output than the original python function.
I've learnt some of the reasons for this difference in this postCython: unsigned int indices for numpy arrays gives different resultBut even with what I've learnt in this post I still can't get the cython function to produce the same results as the python one.
So I have put together 4 functions illustrating what I have tried. Could someone help to unveil why I get slightly different results for each function? and how to get a cython function that returns the same exact values as function1? I make some comments bellow:
%%cython
import numpy as np
cimport numpy as np
def function1(response, max_loc):
x, y = int(max_loc[0]), int(max_loc[1])
tmp1 = (response[y,x+1] - response[y,x-1]) / 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
tmp2 = (response[y,x+1] - response[y,x-1])
tmp3 = 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
print tmp1, tmp2, tmp3
return tmp1, tmp2, tmp3
cpdef function2(np.ndarray[np.float32_t, ndim=2] response, np.ndarray[np.float64_t, ndim=1] max_loc):
cdef unsigned int x, y
x, y = int(max_loc[0]), int(max_loc[1])
tmp1 = (response[y,x+1] - response[y,x-1]) / 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
tmp2 = (response[y,x+1] - response[y,x-1])
tmp3 = 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
print tmp1, tmp2, tmp3
return tmp1, tmp2, tmp3
cpdef function3(np.ndarray[np.float32_t, ndim=2] response, np.ndarray[np.float64_t, ndim=1] max_loc):
cdef unsigned int x, y
x, y = int(max_loc[0]), int(max_loc[1])
cdef np.float32_t tmp1, tmp2, tmp3
cdef np.float32_t r1 =response[y,x+1]
cdef np.float32_t r2 =response[y,x-1]
cdef np.float32_t r3 =response[y,x]
cdef np.float32_t r4 =response[y,x-1]
cdef np.float32_t r5 =response[y,x+1]
tmp1 = (r1 - r2) / 2*(r3 - min(r4, r5))
tmp2 = (r1 - r2)
tmp3 = 2*(r3 - min(r4, r5))
print tmp1, tmp2, tmp3
return tmp1, tmp2, tmp3
def function4(response, max_loc):
x, y = int(max_loc[0]), int(max_loc[1])
tmp1 = (float(response[y,x+1]) - response[y,x-1]) / 2*(float(response[y,x]) - min(response[y,x-1], response[y,x+1]))
tmp2 = (float(response[y,x+1]) - response[y,x-1])
tmp3 = 2*(float(response[y,x]) - min(response[y,x-1], response[y,x+1]))
print tmp1, tmp2, tmp3
return tmp1, tmp2, tmp3
max_loc = np.asarray([ 15., 25.], dtype=np.float64)
response = np.zeros((49,49), dtype=np.float32)
x, y = int(max_loc[0]), int(max_loc[1])
response[y,x] = 0.959878861904
response[y,x-1] = 0.438348740339
response[y,x+1] = 0.753262758255
result1 = function1(response, max_loc)
result2 = function2(response, max_loc)
result3 = function3(response, max_loc)
result4 = function4(response, max_loc)
print result1
print result2
print result3
print result4
and the results:
0.0821185777156 0.314914 1.04306030273
0.082118573023 0.314914017916 1.04306024313
0.0821185708046 0.314914017916 1.04306030273
0.082118573023 0.314914017916 1.04306024313
(0.082118577715618812, 0.31491402, 1.043060302734375)
(0.08211857302303427, 0.3149140179157257, 1.0430602431297302)
(0.08211857080459595, 0.3149140179157257, 1.043060302734375)
(0.082118573023034269, 0.31491401791572571, 1.0430602431297302)
function1 represents the operations I did in my original python function. tmp1 is the result.
function2 is my first cython version, which produces slightly different results. Apparently, if the response array is indexed with a typed variable, unsigned int or int, the result is coerced to a double (using PyFloat_FromDouble) even if the type of the array is np.float32_t. But if the array is indexed with a python int the function PyObject_GetItem is used instead and I get the np.float32_t, which is what happens in function1. So the expressions in function1 are calculated using np.float32_t operands, whereas the expressions in function2 are calculated using doubles.I get slightly different print out than in function1.
function3 is my second cython attempt trying to get the same output as function1. Here I use unsigned int indices to access the array response but the results are left on np.float32_t intermediate variables that then I use in the calculation. I get slightly different result. Apparently the print statement will use PyFloat_FromDouble so it won't be able to print the np.float32_t.
Then I tried to change the python function to match the cython one. function4 tries to achieve this by converting to float at least one operand in each expression so the rest of operands are coerced to python float too, which is a double in cython, and the expression is calculated with doubles, as in function2. The prints inside the function are exactly the same as function2, but the returned values are slightly different?!
If you're using single-precision floats, which only have 7.225 decimal digits of precision, I wouldn't expect a small variance from coercion to double to matter much.
To clarify your description of function2, if you index with an object, Cython usesPyObject_GetItem to get an np.float32 scalar object (not an np.float32_t, which is just a typedef for a C float). If you instead index directly into the buffer, and Cython needs an object, it calls PyFloat_FromDouble. It needs objects to assign tmp1, tmp2, and tmp3, since they aren't typed.
In function3, on the other hand, you typed the tmp variables, but it still needs to create float objects to print and return the results. If you instead use a NumPy ndarray (see below), you won't have that problem:
In function1, by the way, you promote the result to np.float64 when you divide by 2. For example:
>>> type(np.float32(1) / 2)
<type 'numpy.float64'>
vs.
>>> type(np.float32(1) / np.float32(2))
<type 'numpy.float32'>
Even if you ensure that all operations are float32 in both the def and cpdef functions, the end result might still vary between the two in the compiled extension module. In the following example I checked that the intermediate results in function1 are all np.float32 objects. In the generated C of function2 I checked that there was no cast to double (or equivalent typedef). Yet these two functions still produce slightly different results. I'd probably have to dive into the compiled assembly to figure out why, but maybe I'm overlooking something simple.
def function1(response, max_loc):
tmp = np.zeros(3, dtype=np.float32)
x, y = int(max_loc[0]), int(max_loc[1])
tmp[0] = (((response[y,x+1] - response[y,x-1]) / np.float32(2)) *
(response[y,x] - min(response[y,x-1], response[y,x+1])))
tmp[1] = response[y,x+1] - response[y,x-1]
tmp[2] = 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
print tmp[0], tmp[1], tmp[2]
return tmp
cpdef function2(np.ndarray[np.float32_t, ndim=2] response, max_loc):
cdef np.ndarray[np.float32_t, ndim=1] tmp = np.zeros(3, dtype=np.float32)
cdef unsigned int x, y
x, y = int(max_loc[0]), int(max_loc[1])
tmp[0] = (((response[y,x+1] - response[y,x-1]) / <np.float32_t>2) *
(response[y,x] - min(response[y,x-1], response[y,x+1])))
tmp[1] = response[y,x+1] - response[y,x-1]
tmp[2] = 2*(response[y,x] - min(response[y,x-1], response[y,x+1]))
print tmp[int(0)], tmp[int(1)], tmp[int(2)]
return tmp
Comparison:
>>> function1(response, max_loc)
0.0821186 0.314914 1.04306
array([ 0.08211858, 0.31491402, 1.0430603 ], dtype=float32)
>>> function2(response, max_loc)
0.0821186 0.314914 1.04306
array([ 0.08211857, 0.31491402, 1.0430603 ], dtype=float32)
这篇关于cython函数输出与python函数输出略有不同的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！