बेवकूफ मेष्रिड पॉइंट

Question

मैं ग्रिड के अनुरूप बिंदुओं की सूची बनाना चाहता हूं। इसलिए यदि मैं क्षेत्र (0,0) से (1,1) तक क्षेत्र का ग्रिड बनाना चाहता हूं, तो इसमें अंक (0,0), (0,1), (1,0), (1, 0)।

मुझे पता है कि यह निम्न कोड के साथ किया जा सकता है कि:

g = np.meshgrid([0,1],[0,1]) 
np.append(g[0].reshape(-1,1),g[1].reshape(-1,1),axis=1) 

परिणाम पैदावार:

array([[0, 0], 
     [1, 0], 
     [0, 1], 
     [1, 1]]) 

मेरा प्रश्न दोहरा है:

1. कोई बेहतर है ऐसा करने का तरीका?
2. क्या उच्च आयामों को सामान्यीकृत करने का कोई तरीका है?

Answer 1

मैं सिर्फ देखा है कि numpy में प्रलेखन एक भी तेजी से जिस तरह से यह करने के लिए प्रदान करता है:

X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j] 
positions = np.vstack([X.ravel(), Y.ravel()]) 

यह आसानी से जुड़ा हुआ meshgrid2 समारोह का उपयोग कर और जिसके परिणामस्वरूप ग्रिड से 'घपलेबाज़ी' मानचित्रण अधिक आयामों को सामान्यीकृत किया जा सकता ।

g = meshgrid2(x, y, z) 
positions = np.vstack(map(np.ravel, g)) 

परिणाम प्रत्येक धुरी पर 1000 टिकों के साथ 3 डी सरणी के लिए ज़िप विधि से लगभग 35 गुना तेज है।

स्रोत: http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.gaussian_kde.html#scipy.stats.gaussian_kde

तुलना करने के लिए दो तरीकों कोड की निम्न वर्गों पर विचार करें:

लौकिक टिक के निशान ग्रिड बनाने के लिए मदद मिलेगी बनाएँ।

In [23]: import numpy as np 

In [34]: from numpy import asarray 

In [35]: x = np.random.rand(100,1) 

In [36]: y = np.random.rand(100,1) 

In [37]: z = np.random.rand(100,1) 

समारोह है कि meshgrid के लिए से जुड़ा हुआ mgilson परिभाषित करें:

In [38]: def meshgrid2(*arrs): 
    ....:  arrs = tuple(reversed(arrs)) 
    ....:  lens = map(len, arrs) 
    ....:  dim = len(arrs) 
    ....:  sz = 1 
    ....:  for s in lens: 
    ....:  sz *= s 
    ....:  ans = [] 
    ....:  for i, arr in enumerate(arrs): 
    ....:   slc = [1]*dim 
    ....:   slc[i] = lens[i] 
    ....:   arr2 = asarray(arr).reshape(slc) 
    ....:   for j, sz in enumerate(lens): 
    ....:    if j != i: 
    ....:     arr2 = arr2.repeat(sz, axis=j) 
    ....:   ans.append(arr2) 
    ....:  return tuple(ans) 

ग्रिड और समय दो कार्य बनाएँ।

In [39]: g = meshgrid2(x, y, z) 

In [40]: %timeit pos = np.vstack(map(np.ravel, g)).T 
100 loops, best of 3: 7.26 ms per loop 

In [41]: %timeit zip(*(x.flat for x in g)) 
1 loops, best of 3: 264 ms per loop 

Answer 2

क्या आपके ग्रिडपॉइंट हमेशा अभिन्न हैं? यदि हां, तो आप numpy.ndindex

print list(np.ndindex(2,2)) 

उच्चतर आयाम इस्तेमाल कर सकते हैं:

print list(np.ndindex(2,2,2)) 

---

दुर्भाग्य से, यह अभिन्न धारणा (0 के साथ शुरू) के बाद से ओपी की आवश्यकताओं को पूरा नहीं करता है को पूरा नहीं कर रहा है । मैं इस जवाब को केवल तभी छोड़ दूंगा जब कोई और एक ही चीज़ की तलाश कर रहा हो जहां उन धारणाएं सच हों।

---

यह करने के लिए एक और तरीका है zip पर निर्भर करता है:

g = np.meshgrid([0,1],[0,1]) 
zip(*(x.flat for x in g)) 

इस भाग मनमाना आयामों को अच्छी तरह से मापता है। दुर्भाग्यवश, np.meshgrid कई आयामों के लिए अच्छी तरह से स्केल नहीं करता है, इसलिए भाग को काम करने की आवश्यकता होगी, या (इसे मानते हुए), आप अपना खुद का ndmeshgrid फ़ंक्शन बनाने के लिए इस SO answer का उपयोग कर सकते हैं।

Answer 3

फिर भी एक और तरीका यह करने के लिए है:

np.indices((2,2)).T.reshape(-1,2) 

कौन सा उच्च आयामों को सामान्यीकृत किया जा सकता, उदा .:

In [60]: np.indices((2,2,2)).T.reshape(-1,3) 
Out[60]: 
array([[0, 0, 0], 
     [1, 0, 0], 
     [0, 1, 0], 
     [1, 1, 0], 
     [0, 0, 1], 
     [1, 0, 1], 
     [0, 1, 1], 
     [1, 1, 1]])