मेरे पास एक विशाल 3D-सरणी (float16) है जिसे numpy.save का उपयोग करके डिस्क में संग्रहीत किया गया था। जब मैं इसे लोड करता हूं, तो यह मेरी मेमोरी को भर देता है, इसलिए मुझे इसे टुकड़ों में पढ़ने और डेटा को चरणबद्ध तरीके से संसाधित करने की आवश्यकता है। लेकिन ऐसा लगता है कि डेटा को सहेजे जाने की तुलना में आयामों के एक अलग क्रम में पढ़ा जाता है। मैंने निम्नलिखित सरल उदाहरण तैयार किया:

import numpy as np

myArray = np.zeros((2, 5, 3))
content = np.arange(0,10).reshape((2, 5))
myArray[:,:,0] = content
myArray[:,:,1] = content*10
myArray[:,:,2] = content*100

np.save("myArray.npy", myArray.astype(np.float16))

myArray z-दिशा में 2 पंक्तियों, 5 स्तंभों और 3 स्लाइस के साथ एक 3D सरणी है। ध्यान दें कि z के साथ मेरे पास पहले स्लाइस में 0 से 9 तक, फिर दूसरे में 0 से 90 और तीसरे में 0 से 900 तक की संख्याएं हैं। np.load के माध्यम से पहला टुकड़ा लोड करना ठीक काम करता है, लेकिन जब मैं निम्नलिखित का प्रयास करता हूं, तो ऑर्डर गड़बड़ हो जाता है:

with open("myArray.npy", mode="rb") as fhandle:
    chunknp = np.fromfile(fhandle, count=10, dtype=np.float16)
    chunknp = np.resize(chunknp, new_shape=(2, 5, 1))

print(chunknp)
# Out: 
>> [[[2.630e+01]
  [2.133e+01]
  [1.700e+02]
  [5.960e-08]
  [7.033e-06]]

 [[2.922e-02]
  [1.380e+03]
  [9.535e+02]
  [2.908e-02]
  [8.255e-03]]]

Count=10 मुझे पहले 10 तत्व देता है जो मुझे लगा कि z==0 के 2x5 हैं। समस्या के लिए (2, 5, 1) का आकार बदलना आवश्यक नहीं है, लेकिन यह अंतिम आदेश है जिसकी मुझे आवश्यकता है। मैं इसे सही तरीके से कैसे निकालूं?

0
offeltoffel 10 जिंदा 2020, 12:23

1 उत्तर

सबसे बढ़िया उत्तर
In [103]: myArray = np.zeros((2, 5, 3)) 
     ...: content = np.arange(0,10).reshape((2, 5)) 
     ...: myArray[:,:,0] = content 
     ...: myArray[:,:,1] = content*10 
     ...: myArray[:,:,2] = content*100 
     ...:                                                                                                 
In [104]: myArray                                                                                         
Out[104]: 
array([[[  0.,   0.,   0.],
        [  1.,  10., 100.],
        [  2.,  20., 200.],
        [  3.,  30., 300.],
        [  4.,  40., 400.]],

       [[  5.,  50., 500.],
        [  6.,  60., 600.],
        [  7.,  70., 700.],
        [  8.,  80., 800.],
        [  9.,  90., 900.]]])
In [105]: myArray.ravel()                                                                                 
Out[105]: 
array([  0.,   0.,   0.,   1.,  10., 100.,   2.,  20., 200.,   3.,  30.,
       300.,   4.,  40., 400.,   5.,  50., 500.,   6.,  60., 600.,   7.,
        70., 700.,   8.,  80., 800.,   9.,  90., 900.])

tostring का उपयोग करना एक ही क्रम दिखाता है:

In [108]: np.frombuffer(myArray.tostring(), dtype=float)                                                  
Out[108]: 
array([  0.,   0.,   0.,   1.,  10., 100.,   2.,  20., 200.,   3.,  30.,
       300.,   4.,  40., 400.,   5.,  50., 500.,   6.,  60., 600.,   7.,
        70., 700.,   8.,  80., 800.,   9.,  90., 900.])

संग्रहीत डेटा के लगातार स्लाइस का चयन करने के लिए, पहले आयाम पर अनुक्रमणिका:

In [112]: myArray[0,:,:]                                                                                  
Out[112]: 
array([[  0.,   0.,   0.],
       [  1.,  10., 100.],
       [  2.,  20., 200.],
       [  3.,  30., 300.],
       [  4.,  40., 400.]])

अंतिम पहुंच पर content मानों को अनुक्रमित करना, लेकिन ऐसा नहीं है कि वे myArray डेटाबफ़र में कैसे संग्रहीत होते हैं:

In [113]: myArray[:,:,0]                                                                                  
Out[113]: 
array([[0., 1., 2., 3., 4.],
       [5., 6., 7., 8., 9.]])
1
hpaulj 10 जिंदा 2020, 17:55