क्या यह जांचने का कोई तरीका है कि NumPy arrays समान डेटा साझा करते हैं या नहीं?

Question

मेरी धारणा यह है कि न्यूमपी में, दो सरणी एक ही स्मृति साझा कर सकते हैं। निम्न उदाहरण लें:

import numpy as np 
a=np.arange(27) 
b=a.reshape((3,3,3)) 
a[0]=5000 
print (b[0,0,0]) #5000 

#Some tests: 
a.data is b.data #False 
a.data == b.data #True 

c=np.arange(27) 
c[0]=5000 
a.data == c.data #True (Same data, not same memory storage), False positive 

तो स्पष्ट रूप से ba की एक प्रतिलिपि बनाने नहीं किया था; इसने अभी कुछ नया मेटा-डेटा बनाया है और इसे उसी मेमोरी बफर से जोड़ा है जो a उपयोग कर रहा है। क्या यह जांचने का कोई तरीका है कि दो सरणी एक ही मेमोरी बफर का संदर्भ देते हैं या नहीं?

मेरा पहला प्रभाव a.data is b.data का उपयोग करना था, लेकिन यह झूठा रिटर्न देता है। मैं a.data == b.data कर सकता हूं जो सच देता है, लेकिन मुझे नहीं लगता कि a और b एक ही मेमोरी बफर साझा करें, केवल a द्वारा संदर्भित स्मृति की ब्लॉक और b द्वारा संदर्भित एक ही बाइट्स है।

Answer 1

मुझे लगता है कि jterrace का जवाब शायद जाने के लिए सबसे अच्छा तरीका है, लेकिन यहाँ एक और संभावना है।

def byte_offset(a): 
    """Returns a 1-d array of the byte offset of every element in `a`. 
    Note that these will not in general be in order.""" 
    stride_offset = np.ix_(*map(range,a.shape)) 
    element_offset = sum(i*s for i, s in zip(stride_offset,a.strides)) 
    element_offset = np.asarray(element_offset).ravel() 
    return np.concatenate([element_offset + x for x in range(a.itemsize)]) 

def share_memory(a, b): 
    """Returns the number of shared bytes between arrays `a` and `b`.""" 
    a_low, a_high = np.byte_bounds(a) 
    b_low, b_high = np.byte_bounds(b) 

    beg, end = max(a_low,b_low), min(a_high,b_high) 

    if end - beg > 0: 
     # memory overlaps 
     amem = a_low + byte_offset(a) 
     bmem = b_low + byte_offset(b) 

     return np.intersect1d(amem,bmem).size 
    else: 
     return 0 

उदाहरण:

>>> a = np.arange(10) 
>>> b = a.reshape((5,2)) 
>>> c = a[::2] 
>>> d = a[1::2] 
>>> e = a[0:1] 
>>> f = a[0:1] 
>>> f = f.reshape(()) 
>>> share_memory(a,b) 
80 
>>> share_memory(a,c) 
40 
>>> share_memory(a,d) 
40 
>>> share_memory(c,d) 
0 
>>> share_memory(a,e) 
8 
>>> share_memory(a,f) 
8 

यहाँ प्रत्येक share_memory(a,a[::2]) अपने कंप्यूटर पर a में तत्वों की संख्या के एक समारोह के रूप में कॉल के लिए समय दिखा एक साजिश है।

Answer 2

आप एक सरणी एक और सरणी के साथ स्मृति के शेयरों अगर जाँच करने के लिए base विशेषता का उपयोग कर सकते हैं: कि

>>> import numpy as np 
>>> a = np.arange(27) 
>>> b = a.reshape((3,3,3)) 
>>> b.base is a 
True 
>>> a.base is b 
False 

सुनिश्चित नहीं हैं कि अगर आपकी समस्या नहीं सुलझती। यदि सरणी की अपनी याददाश्त है तो मूल विशेषता None होगी। ध्यान दें कि एक सरणी के आधार एक और सरणी हो जाएगा, भले ही वह एक सबसेट है:

>>> c = a[2:] 
>>> c.base is a 
True 

Answer 3

बस कार्य करें:

a = np.arange(27) 
a.__array_interface__['data'] 

दूसरी पंक्ति एक टपल वापस आ जाएगी जहां पहली प्रविष्टि स्मृति पता है और दूसरा कि क्या सरणी केवल पढ़ने के लिए है। आकार और डेटा प्रकार के साथ, आप सरणी को कवर करने वाले मेमोरी पते की सटीक अवधि का पता लगा सकते हैं, ताकि जब आप एक सरणी दूसरे का सबसेट हो, तो आप इससे भी काम कर सकते हैं।