Numpy

Question

में अवरोधक संचालन क्या नम्पी सरणी पर अवरुद्ध संचालन करने के लिए कोई सुविधा उपयोगिता है?

मैं आइसिंग स्पिन रेनोर्मलाइजेशन जैसे संचालन के बारे में सोच रहा हूं, जहां आप ब्लॉक में मैट्रिक्स विभाजित करते हैं और मैट्रिक्स लौटाते हैं जहां प्रत्येक ब्लॉक को इसके योग, औसत या अन्य फ़ंक्शन द्वारा प्रतिस्थापित किया जाता है।

Answer 1

आप superbatfish's blockwise_view खोज रहे हैं। यह सरणी का दृश्य बनाने के लिए np.lib.stride_tricks.as_strided का उपयोग करता है जो सरणी के अपने ब्लॉक में "ब्लॉक" रखता है।

उदाहरण के लिए, आप इस तरह के रूप में एक 2 डी सरणी है लगता है,

In [97]: arr = np.arange(24).reshape(6, 4) 

In [98]: arr.shape 
Out[98]: (6, 4) 

In [99]: arr 
Out[99]: 
array([[ 0, 1, 2, 3], 
     [ 4, 5, 6, 7], 
     [ 8, 9, 10, 11], 
     [12, 13, 14, 15], 
     [16, 17, 18, 19], 
     [20, 21, 22, 23]]) 

और आप "यह काट" ​​के आकार के 4 ब्लॉक में इच्छा (3, 2)। आप blockwise_view इस्तेमाल कर सकते हैं यह आकार का एक 4D सरणी में परिवर्तित करने के लिए (4, 3, 2):

In [34]: blocked = blockwise_view(arr, (3, 2)); blocked 
Out[34]: 
array([[[[ 0, 1], 
     [ 4, 5], 
     [ 8, 9]], 

     [[ 2, 3], 
     [ 6, 7], 
     [10, 11]]], 


     [[[12, 13], 
     [16, 17], 
     [20, 21]], 

     [[14, 15], 
     [18, 19], 
     [22, 23]]]]) 

In [37]: blocked.shape 
Out[37]: (2, 2, 3, 2) 

अब आप नयी आकृति प्रदान कर सकता है यह इतना एक ब्लॉक से सभी मूल्यों पिछले अक्ष में हैं:

In [41]: reshaped = blocked.reshape(-1, 3*2); reshaped 
Out[41]: 
array([[ 0, 1, 4, 5, 8, 9], 
     [ 2, 3, 6, 7, 10, 11], 
     [12, 13, 16, 17, 20, 21], 
     [14, 15, 18, 19, 22, 23]]) 

अब आप कि अक्ष के साथ जोड़ सकते हैं, या अपने मतलब लेने के लिए या प्रत्येक ब्लॉक के तत्वों के कुछ अन्य समारोह लागू होते हैं:

In [103]: reshaped.sum(axis=-1) 
Out[103]: array([ 27, 39, 99, 111]) 

In [104]: reshaped.mean(axis=-1) 
Out[104]: array([ 4.5, 6.5, 16.5, 18.5]) 

my first answer के विपरीत, जो एच केवल 2 डी सरणी पर लागू किया जा सकता है, blockwise_view मनमाने ढंग से एन-आयामी सरणी पर लागू किया जा सकता है। यह 2 एन-आयामी सरणी देता है जहां पहला एन अक्ष ब्लॉक ब्लॉक करता है।

Answer 2

blockwise संचालन फिसलने के लिए, आप Implement Matlab's im2col_sliding 'sliding' in python कि समूहों को एक स्तंभ में प्रत्येक ब्लॉक, जिससे blockwise आपरेशन axis = 0 साथ है और इस तरह के रूप में काम vectorized समाधान के लिए सभी NumPy ufuncs स्वीकार करेंगे उतना ही आसान हो जाएगा से एक क्रियान्वयन उधार ले सकते हैं।

def im2col_sliding(A,BLKSZ): 

    # Parameters 
    M,N = A.shape 
    col_extent = N - BLKSZ[1] + 1 
    row_extent = M - BLKSZ[0] + 1 

    # Get Starting block indices 
    start_idx = np.arange(BLKSZ[0])[:,None]*N + np.arange(BLKSZ[1]) 

    # Get offsetted indices across the height and width of input array 
    offset_idx = np.arange(row_extent)[:,None]*N + np.arange(col_extent) 

    # Get all actual indices & index into input array for final output 
    return np.take (A,start_idx.ravel()[:,None] + offset_idx.ravel()) 

---

नमूना रन blockwise sum, average, std, आदि की गणना करने के लिए - - यहाँ समारोह बनाने इस तरह के एक फिसलने ब्लॉकों को परिभाषित करने के लिए एक औपचारिक तरीका है

In [6]: arr     # Sample array 
Out[6]: 
array([[6, 5, 0, 6, 0], 
     [7, 4, 2, 3, 6], 
     [6, 3, 3, 8, 1], 
     [5, 5, 1, 1, 8]]) 

In [7]: im2col_sliding(arr,[2,3]) # Blockwise array with blocksize : (2,3) 
Out[7]: 
array([[6, 5, 0, 7, 4, 2, 6, 3, 3], 
     [5, 0, 6, 4, 2, 3, 3, 3, 8], 
     [0, 6, 0, 2, 3, 6, 3, 8, 1], 
     [7, 4, 2, 6, 3, 3, 5, 5, 1], 
     [4, 2, 3, 3, 3, 8, 5, 1, 1], 
     [2, 3, 6, 3, 8, 1, 1, 1, 8]]) 

In [8]: np.sum(im2col_sliding(arr,[2,3]),axis=0) # Perform blockwise summation 
Out[8]: array([24, 20, 17, 25, 23, 23, 23, 21, 22]) 

In [9]: np.mean(im2col_sliding(arr,[2,3]),axis=0) # Perform blockwise averaging 
Out[9]: 
array([ 4.  , 3.33333333, 2.83333333, 4.16666667, 3.83333333, 
     3.83333333, 3.83333333, 3.5  , 3.66666667]) 

In [10]: np.std(im2col_sliding(arr,[2,3]),axis=0) # Blockwise std. deviation 
Out[10]: 
array([ 2.38047614, 1.97202659, 2.47767812, 1.77169097, 1.95078332, 
     2.40947205, 1.67497927, 2.43241992, 3.14466038])