साइथन: numpy arrays के लिए हस्ताक्षरित int इंडेक्स अलग-अलग परिणाम देता है

Question

मैंने कुछ प्रकार जोड़कर और इसे संकलित करके साइथन को एक पायथन फ़ंक्शन में परिवर्तित कर दिया। मुझे अजगर और साइथन कार्यों के परिणामों के बीच छोटे संख्यात्मक मतभेद मिल रहे थे। कुछ काम करने के बाद मैंने पाया कि अंतर int के बजाय हस्ताक्षरित int का उपयोग करके एक numpy सरणी तक पहुंचने से आया था।

मैं अहस्ताक्षरित पूर्णांक सूचकांक उपयोग कर रहा था के अनुसार पहुँच तेजी लाने के लिए: http://docs.cython.org/src/userguide/numpy_tutorial.html#tuning-indexing-further

वैसे भी मैंने सोचा कि यह अहस्ताक्षरित ints उपयोग करने के लिए हानिरहित था।

cpdef function(np.ndarray[np.float32_t, ndim=2] response, max_loc): 
    cdef unsigned int x, y 
    x, y = int(max_loc[0]), int(max_loc[1]) 
    x2, y2 = int(max_loc[0]), int(max_loc[1]) 
    print response[y,x], type(response[y,x]), response.dtype 
    print response[y2,x2], type(response[y2,x2]), response.dtype 
    print 2*(response[y,x] - min(response[y,x-1], response[y,x+1])) 
    print 2*(response[y2,x2] - min(response[y2,x2-1], response[y2,x2+1])) 

प्रिंट:

इस कोड को देखते हैं?

0.959878861904 <type 'float'> float32 
0.959879 <type 'numpy.float32'> float32 
1.04306024313 
1.04306030273 

इस क्यों होता है !!! क्या यह एक बग है?

ठीक है, यहाँ का अनुरोध एक ही प्रकार और मूल्यों है कि मैं अपने मूल कार्य में प्रयोग किया जाता के साथ एक SSCCE है के रूप में

cpdef function(): 
    cdef unsigned int x, y 
    max_loc2 = np.asarray([ 15., 25.], dtype=float) 
    cdef np.ndarray[np.float32_t, ndim=2] response2 = np.zeros((49,49), dtype=np.float32)  
    x, y = int(max_loc2[0]), int(max_loc2[1]) 
    x2, y2 = int(max_loc2[0]), int(max_loc2[1]) 

    response2[y,x] = 0.959878861904 
    response2[y,x-1] = 0.438348740339 
    response2[y,x+1] = 0.753262758255 


    print response2[y,x], type(response2[y,x]), response2.dtype 
    print response2[y2,x2], type(response2[y2,x2]), response2.dtype 
    print 2*(response2[y,x] - min(response2[y,x-1], response2[y,x+1])) 
    print 2*(response2[y2,x2] - min(response2[y2,x2-1], response2[y2,x2+1])) 

प्रिंट

0.959878861904 <type 'float'> float32 
0.959879 <type 'numpy.float32'> float32 
1.04306024313 
1.04306030273 

मैं अजगर 2.7.3 का उपयोग 0.18 और msvc9 cython एक्सप्रेस

Answer 1

मैंने मॉड्यूल के लिए जेनरेट किए गए सी स्रोत को पढ़ने में आसान बनाने के लिए प्रश्न में उदाहरण को संशोधित किया। मुझे केवल उस तर्क को देखने में दिलचस्पी है जो सरणी से np.float32 ऑब्जेक्ट प्राप्त करने के बजाय पाइथन float ऑब्जेक्ट्स बनाता है।

मैं विस्तार मॉड्यूल संकलित करने के लिए pyximport का उपयोग कर रहा हूं। यह जेनरेट सी फ़ाइल को ~/.pyxbld (शायद %userprofile%\.pyxbld विंडोज़) की उपनिर्देशिका में सहेजता है।

import numpy as np 
import pyximport 
pyximport.install(setup_args={'include_dirs': [np.get_include()]}) 

open('_tmp.pyx', 'w').write(''' 
cimport numpy as np 
cpdef function(np.ndarray[np.float32_t, ndim=2] response, max_loc): 
    cdef unsigned int p_one, q_one 
    p_one = int(max_loc[0]) 
    q_one = int(max_loc[1]) 
    p_two = int(max_loc[0]) 
    q_two = int(max_loc[1]) 
    r_one = response[q_one, p_one] 
    r_two = response[q_two, p_two] 
''') 

import _tmp 
assert(hasattr(_tmp, 'function')) 

यहां रुचि के अनुभाग के लिए जेनरेट किया गया सी कोड है (इसे पढ़ने में आसान बनाने के लिए थोड़ा सुधार हुआ)। यह पता चला है कि जब आप सी unsigned int इंडेक्स चर का उपयोग करते हैं, तो जेनरेट कोड सीधे सरणी बफर से डेटा पकड़ता है और PyFloat_FromDouble पर कॉल करता है, जो इसे double पर ले जाता है। दूसरी ओर, जब आप पाइथन int इंडेक्स चर का उपयोग करते हैं, तो यह सामान्य दृष्टिकोण लेता है। यह एक ट्यूपल बनाता है और PyObject_GetItem पर कॉल करता है। इस तरह np.float32 dtype का सही सम्मान करने के लिए ndarray की अनुमति देता है।

#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) \ 
    (type)((char*)buf + i0 * s0 + i1 * s1) 

    /* "_tmp.pyx":9 
*  p_two = int(max_loc[0]) 
*  q_two = int(max_loc[1]) 
*  r_one = response[q_one, p_one]    # <<<<<<<<<<<<<< 
*  r_two = response[q_two, p_two] 
*/ 
    __pyx_t_3 = __pyx_v_q_one; 
    __pyx_t_4 = __pyx_v_p_one; 
    __pyx_t_5 = -1; 

    if (unlikely(__pyx_t_3 >= (size_t)__pyx_bshape_0_response)) 
    __pyx_t_5 = 0; 
    if (unlikely(__pyx_t_4 >= (size_t)__pyx_bshape_1_response)) 
    __pyx_t_5 = 1; 

    if (unlikely(__pyx_t_5 != -1)) { 
    __Pyx_RaiseBufferIndexError(__pyx_t_5); 
    { 
     __pyx_filename = __pyx_f[0]; 
     __pyx_lineno = 9; 
     __pyx_clineno = __LINE__; 
     goto __pyx_L1_error; 
    } 
    } 

    __pyx_t_1 = PyFloat_FromDouble((
    *__Pyx_BufPtrStrided2d(
     __pyx_t_5numpy_float32_t *, 
     __pyx_bstruct_response.buf, 
     __pyx_t_3, __pyx_bstride_0_response, 
     __pyx_t_4, __pyx_bstride_1_response))); 

    if (unlikely(!__pyx_t_1)) { 
    __pyx_filename = __pyx_f[0]; 
    __pyx_lineno = 9; 
    __pyx_clineno = __LINE__; 
    goto __pyx_L1_error; 
    } 

    __Pyx_GOTREF(__pyx_t_1); 
    __pyx_v_r_one = __pyx_t_1; 
    __pyx_t_1 = 0; 

    /* "_tmp.pyx":10 
*  q_two = int(max_loc[1]) 
*  r_one = response[q_one, p_one] 
*  r_two = response[q_two, p_two]    # <<<<<<<<<<<<<< 
*/ 
    __pyx_t_1 = PyTuple_New(2); 

    if (unlikely(!__pyx_t_1)) { 
    __pyx_filename = __pyx_f[0]; 
    __pyx_lineno = 10; 
    __pyx_clineno = __LINE__; 
    goto __pyx_L1_error; 
    } 

    __Pyx_GOTREF(((PyObject *)__pyx_t_1)); 
    __Pyx_INCREF(__pyx_v_q_two); 
    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_q_two); 
    __Pyx_GIVEREF(__pyx_v_q_two); 
    __Pyx_INCREF(__pyx_v_p_two); 
    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_p_two); 
    __Pyx_GIVEREF(__pyx_v_p_two); 

    __pyx_t_2 = PyObject_GetItem(
    ((PyObject *)__pyx_v_response), 
    ((PyObject *)__pyx_t_1)); 

    if (!__pyx_t_2) { 
    __pyx_filename = __pyx_f[0]; 
    __pyx_lineno = 10; 
    __pyx_clineno = __LINE__; 
    goto __pyx_L1_error; 
    } 

    __Pyx_GOTREF(__pyx_t_2); 
    __Pyx_DECREF(((PyObject *)__pyx_t_1)); 
    __pyx_t_1 = 0; 
    __pyx_v_r_two = __pyx_t_2; 
    __pyx_t_2 = 0; 

Answer 2

मेरी मशीन पर इसके साथ खेलना, मुझे कोई फर्क नहीं पड़ता। मैं cython जादू के साथ IPython नोटबुक का उपयोग कर रहा:

In [1]: 

%load_ext cythonmagic 

In [12]: 

%%cython 

import numpy as np 
cimport numpy as np 

cpdef function(np.ndarray[np.float32_t, ndim=2] response, max_loc): 
    cdef unsigned int x, y 
    x, y = int(max_loc[0]), int(max_loc[1]) 
    x2, y2 = int(max_loc[0]), int(max_loc[1]) 
    #return 2*(response[y,x] - min(response[y,x-1], response[y,x+1])), 2*(response[y2,x2] - min(response[y2,x2-1], response[y2,x2+1])) 
    print response[y,x], type(response[y,x]), response.dtype 
    print response[y2,x2], type(response[y2,x2]), response.dtype 
    print 2*(response[y,x] - min(response[y,x-1], response[y,x+1])) 
    print 2*(response[y2,x2] - min(response[y2,x2-1], response[y2,x2+1])) 

In [13]: 

a = np.random.normal(size=(10,10)).astype(np.float32) 
m = [3,2] 
function(a,m) 

0.586090564728 <type 'float'> float32 
0.586091 <type 'numpy.float32'> float32 
4.39655685425 
4.39655685425 

परिणामों के प्रथम जोड़ी, अंतर प्रिंट बयान का सिर्फ उत्पादन सटीक है। साइथन का आप किस संस्करण का उपयोग कर रहे हैं? इंडेक्स उत्तर को प्रभावित करने की बेहद असंभव हैं क्योंकि यह केवल स्मृति की एक निश्चित लंबाई तक पहुंच रहा है कि numpy सरणी का डेटा विशेषता भंडारण कर रही है।