यह निश्चित आकार

Question

की कोशिकाओं में विभाजित करने के लिए 2 डी सरणी पर एक 4D दृश्य बनाना मैं numpy में एक 2 डी सरणी t है:

>>> t = numpy.array(range(81)).reshape((9,9)) 
>>> t 
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, 24, 25, 26], 
     [27, 28, 29, 30, 31, 32, 33, 34, 35], 
     [36, 37, 38, 39, 40, 41, 42, 43, 44], 
     [45, 46, 47, 48, 49, 50, 51, 52, 53], 
     [54, 55, 56, 57, 58, 59, 60, 61, 62], 
     [63, 64, 65, 66, 67, 68, 69, 70, 71], 
     [72, 73, 74, 75, 76, 77, 78, 79, 80]]) 

यह दो नंबर द्वारा अनुक्रमित: पंक्ति और स्तंभ सूचकांक।

>>> t[2,3] 
21 
>>> t.shape 
(9, 9) 
>>> t.strides 
(72, 8) 

मुझे क्या करना चाहते हैं विभाजन तय आकार के आयताकार कोशिकाओं में सरणी, 3 × उदाहरण के लिए 3 के लिए है। मैं स्मृति प्रतिलिपि से बचना चाहता हूं। जिस तरह से मैं इसे प्राप्त करने का प्रयास करता हूं वह को t पर क्रमशः संवाददाता और स्ट्रिड्स ((3,3,3,3) और (216,24,72,8)) के साथ बना रहा है। इस तरह दृश्य के पहले दो इंडेक्स का मतलब बड़े ग्रिड में 3 × 3 सेल की स्थिति होगी और अंतिम दो का मतलब सेल के अंदर तत्व की स्थिति होगी। उदाहरण के लिए, t[0,1,:,:] वापसी होगी

array([[ 3, 4, 5], 
     [12, 13, 14], 
     [21, 22, 23]]) 

तो मेरे सवाल है - कैसे वर्णित दृश्य बनाने के लिए? क्या मुझे एक आसान तरीका याद आ रहा है? क्या यह स्लाइसिंग सिंटैक्स के साथ खूबसूरती से किया जा सकता है?

Answer 1

संपादित: एक तरीका है कि आप प्रगति यह पता लगाने की खुद

numpy.rollaxis(t.reshape(3, 3, 3, 3), 2, 1) 

[संपादित के अंत]

एक और तरीका है प्राप्त करने के लिए इस numpy.lib.stride_tricks.as_strided उपयोग करने के लिए है की आवश्यकता नहीं है:

>>> t = numpy.arange(81.).reshape((9,9)) 
>>> numpy.lib.stride_tricks.as_strided(t, shape=(3,3,3,3), strides=(216,24,72,8)) 
array([[[[ 0., 1., 2.], 
     [ 9., 10., 11.], 
     [ 18., 19., 20.]], 

     [[ 3., 4., 5.], 
     [ 12., 13., 14.], 
     [ 21., 22., 23.]], 

     [[ 6., 7., 8.], 
     [ 15., 16., 17.], 
     [ 24., 25., 26.]]], 


     [[[ 27., 28., 29.], 
     [ 36., 37., 38.], 
     [ 45., 46., 47.]], 

     [[ 30., 31., 32.], 
     [ 39., 40., 41.], 
     [ 48., 49., 50.]], 

     [[ 33., 34., 35.], 
     [ 42., 43., 44.], 
     [ 51., 52., 53.]]], 


     [[[ 54., 55., 56.], 
     [ 63., 64., 65.], 
     [ 72., 73., 74.]], 

     [[ 57., 58., 59.], 
     [ 66., 67., 68.], 
     [ 75., 76., 77.]], 

     [[ 60., 61., 62.], 
     [ 69., 70., 71.], 
     [ 78., 79., 80.]]]]) 

ध्यान दें कि आपके द्वारा प्रदान किए गए चरण केवल फ़्लोट सरणी (itemsize == 8) के लिए सही हैं, whi उदाहरण के लिए t आपकी पोस्ट में int सरणी है (जो itemsize == 8 हो सकता है या नहीं हो सकता है)।

Answer 2

आप कर सकते हैं:

t = np.arange(81).reshape(9,9) 
t.shape = (3, 3, 3, 3) 
t = t.transpose((0, 2, 1, 3)) 

>>> print t.strides 
(108, 12, 36, 4) 

>>> print t 
[[[[ 0 1 2] 
    [ 9 10 11] 
    [18 19 20]] 

    [[ 3 4 5] 
    [12 13 14] 
    [21 22 23]] 

    [[ 6 7 8] 
    [15 16 17] 
    [24 25 26]]] 


[[[27 28 29] 
    [36 37 38] 
    [45 46 47]] 

    [[30 31 32] 
    [39 40 41] 
    [48 49 50]] 

    [[33 34 35] 
    [42 43 44] 
    [51 52 53]]] 


[[[54 55 56] 
    [63 64 65] 
    [72 73 74]] 

    [[57 58 59] 
    [66 67 68] 
    [75 76 77]] 

    [[60 61 62] 
    [69 70 71] 
    [78 79 80]]]] 

पक्षांतरित एक दृश्य वापस आ जाएगी जब भी संभव हो, इस तरह आप की जरूरत नहीं है डेटा प्रकार जानने के बारे में चिंता करने के लिए।