numpy.as_strided के परिणाम इनपुट dtype पर निर्भर करेगा?

Question

numpy.lib.stride_tricks.as_strided के नतीजे NumPy सरणी के प्रकार पर निर्भर करते हैं?

यह सवाल .strides की परिभाषा है, जो बाइट्स जब एक सरणी traversing प्रत्येक आयाम में कदम रखने की

टपल से उठता है।

निम्नलिखित प्रश्नों का पालन करें जिन्हें मैंने अन्य प्रश्नों में उपयोग किया है। यह 1 डी या 2 डी सरणी लेता है और लंबाई window की ओवरलैपिंग विंडो बनाता है। परिणाम इनपुट से एक आयाम अधिक होगा।

def rwindows(a, window): 
    if a.ndim == 1: 
     a = a.reshape(-1, 1) 
    shape = a.shape[0] - window + 1, window, a.shape[-1] 
    strides = (a.strides[0],) + a.strides 
    windows = np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides) 
    return np.squeeze(windows) 

# examples 
# rwindows(np.arange(5), window=2) 
# rwindows(np.arange(20).reshape((5,4)), window=2) 

प्रगति की परिभाषा और क्योंकि, उदाहरण के लिए, अन्यथा बराबर dtype float32 और float64 की सरणियों की वजह से

विभिन्न प्रगति, यह कभी ऊपर मेरी rwindows समारोह को उड़ाने होगा?

मैंने परीक्षण करने की कोशिश की है लेकिन यह एक गैर-संपूर्ण तरीके से रहा है और मैं एक उत्तर की तलाश में हूं कि (1) बताता है कि फ़ंक्शन डॉक्टर से अस्वीकरण/चेतावनी के बारे में कुछ भी नहीं है जो मैं यहां पूछ रहा हूं और (2) बताता है कि अन्य dtypes & चरणों के साथ अन्यथा समकक्ष सरणी क्यों उपरोक्त में अलग-अलग परिणाम प्राप्त करेंगे।

Answer 1

नहीं, as_strided के लिए चेतावनी दो मुद्दों के लिए है जो वास्तव में डेटा के आकार से संबंधित नहीं हैं और परिणामस्वरूप परिणामस्वरूप परिणाम से अधिक परिणाम हैं।

1. सबसे पहले, वहाँ कोई सुरक्षा a में स्मृति को view = as_strided(a . . .)केवल अंक आश्वस्त करने के लिए है। यही कारण है कि as_strided पर कॉल करने से पहले बहुत जानबूझकर तैयारी का काम किया गया है। यदि आपका एल्गोरिदम बंद है, तो आप आसानी से view मेमोरी को इंगित कर सकते हैं जो a में नहीं है, और जिसे वास्तव में कचरा, अन्य चर या आपके ऑपरेटिंग सिस्टम को संबोधित किया जा सकता है। यदि आप उस दृश्य को लिखते हैं, तो आपका डेटा खोया जा सकता है, गलत स्थानांतरित हो सकता है, दूषित हो सकता है। । । या अपने कंप्यूटर को दुर्घटनाग्रस्त करें।

अपने विशिष्ट उदाहरण के लिए, यह कितना सुरक्षित है कि आप किस इनपुट का उपयोग कर रहे हैं इस पर निर्भर करता है। आपने stridesa.strides के साथ सेट किया है ताकि यह गतिशील हो। आप assert चाहते हैं कि dtypeaobject जैसे अजीब कुछ नहीं है।

क्या आप वाकई हमेशा 2-डी awindow से भी बड़ा है कि होगा कि कर रहे हैं, तो आप शायद अपने एल्गोरिथ्म के साथ ठीक हो जाएगा, लेकिन आप भी assert सुनिश्चित करने के लिए कि कर सकते हैं। यदि नहीं, तो आप यह सुनिश्चित करना चाहते हैं कि as_strided आउटपुट एन-डी a सरणी के लिए काम करता है। उदाहरण के लिए:

shape = a.shape[0] - window + 1, window, a.shape[-1] 

शायद क्रम एन डी इनपुट को स्वीकार करने के लिए

shape = (a.shape[0] - window + 1, window) + a.shape[1:] 

होना चाहिए।यह शायद खराब स्मृति का संदर्भ देने में कोई समस्या नहीं है, लेकिन वर्तमान shape यदि आपके पास अधिक आयाम हैं तो a में गलत डेटा का संदर्भ लेंगे।

2. दूसरा, दृश्य दृश्य एक ही डेटा ब्लॉक को कई बार संदर्भित करता है। यदि आप उस दृश्य को समानांतर लिखते हैं (view = foo या bar(. . ., out = view) के माध्यम से), परिणाम unpredictable हो सकते हैं और शायद आप जो अपेक्षा करते हैं वह नहीं हो सकता है।

कहा कि, अगर आप समस्याओं से डरते हैं और (आप सबसे अधिक घुमाव के अनुप्रयोगों के लिए जहां यह आमतौर पर इस्तेमाल किया जाता है के लिए नहीं करते हैं), तो आप हमेशा writable = False के रूप में यह निर्धारित कर सकते हैं as_strided देखने के लिए लिखने की जरूरत नहीं है , जो आपके strides और/या shape गलत होने पर भी दोनों समस्याओं को रोक देगा।

संपादित करें: के रूप में, @hpaulj द्वारा बताया उन दो समस्याओं के अलावा, यदि आप एक view कि एक प्रति (जैसे .flatten() या फैंसी अनुक्रमण यह की एक बड़ी हिस्सा) में आता है के लिए कुछ करना है, यह एक पैदा कर सकता है MemoryError।