बेवकूफ: एक बहुआयामी सरणी को एक बहुआयामी सरणी

Question

द्वारा सॉर्ट करना अगर यह अनावश्यक या सुपर मूल है तो मुझे क्षमा करें। मैं आर से पायथन/न्यूम्पी में आ रहा हूं और मेरे सिर में चीजों को फिसलने में मुश्किल हो रही है।

मेरे पास एक आयामी सरणी है जिसे मैं इंडेक्स मानों की एक और एन आयामी सरणी का उपयोग करके क्रमबद्ध करना चाहता हूं। मुझे पता है कि मैं इसे एक लूप में लपेट सकता हूं लेकिन ऐसा लगता है कि सबमिशन में इसे मारने का वास्तव में संक्षेप में न्यूमोनिक तरीका होना चाहिए।

a1 = random.standard_normal(size=[2,5]) 
index = array([[0,1,2,4,3] , [0,1,2,3,4] ]) 

तो अब मैं यादृच्छिक संख्या की एक 2 x 5 सरणी और एक 2 x 5 सूचकांक: यहाँ समस्या जहां n = 2 स्थापित करने के लिए मेरे उदाहरण कोड है। मैंने take() के लिए लगभग 10 बार मदद की है लेकिन मेरा दिमाग यह स्पष्ट रूप से ग्रोक नहीं कर रहा है।

मैंने सोचा था कि यह मेरे वहाँ मिल सकता है:

take(a1, index) 

array([[ 0.29589188, -0.71279375, -0.18154864, -1.12184984, 0.25698875], 
     [ 0.29589188, -0.71279375, -0.18154864, 0.25698875, -1.12184984]]) 

लेकिन यह स्पष्ट रूप से केवल पहला तत्व (मैं सपाट की वजह से अनुमान) को पुन: क्रम है।

किसी भी समाधान से मैं कैसे प्राप्त करता हूं इस पर कोई सुझाव है कि मैं इंडेक्स के तत्व 0 द्वारा तत्व 1 के तत्व 0 को टाइप करता हूं ... element n?

Answer 1

मैं कैसे अभी तक एन आयामों में यह काम करने के लिए के बारे में सोच नहीं सकते हैं, लेकिन यहाँ 2 डी संस्करण है:

>>> a[list(np.ogrid[[slice(x) for x in a.shape]][:-1])+[i]] 

:

>>> a = np.random.standard_normal(size=(2,5)) 
>>> a 
array([[ 0.72322499, -0.05376714, -0.28316358, 1.43025844, -0.90814293], 
     [ 0.7459107 , 0.43020728, 0.05411805, -0.32813465, 2.38829386]]) 
>>> i = np.array([[0,1,2,4,3],[0,1,2,3,4]]) 
>>> a[np.arange(a.shape[0])[:,np.newaxis],i] 
array([[ 0.72322499, -0.05376714, -0.28316358, -0.90814293, 1.43025844], 
     [ 0.7459107 , 0.43020728, 0.05411805, -0.32813465, 2.38829386]]) 

यहाँ एन आयामी संस्करण है यहां बताया गया है कि यह कैसे काम करता है:

ठीक है, आइए चित्रण के लिए 3 आयामी सरणी से शुरू करें।

>>> import numpy as np 
>>> a = np.arange(24).reshape((2,3,4)) 
>>> a 
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]]]) 

इस प्रकार आप प्रत्येक अक्ष के साथ सूचकांक निर्दिष्ट करके इस सरणी के तत्वों का उपयोग कर सकते हैं:

>>> a[0,1,2] 
6 

यह जो है कि कैसे आप एक ही तत्व अगर हम साथ काम कर रहे थे का उपयोग होता a[0][1][2] के बराबर है एक सरणी के बजाय एक सूची।

Numpy तुम भी अधिक सजावटी जब सरणियों टुकड़ा करने की क्रिया पाने के लिए अनुमति देता है:

>>> a[[0,1],[1,1],[2,2]] 
array([ 6, 18]) 
>>> a[[0,1],[1,2],[2,2]] 
array([ 6, 22]) 

इन उदाहरणों [a[0][1][2],a[1][1][2]] के बराबर होगा और [a[0][1][2],a[1][2][2]] अगर हम सूचियों के साथ काम कर रहे थे।

आप दोहराए गए सूचकांक भी छोड़ सकते हैं और numpy आप जो चाहते हैं उसे समझ लेंगे। उदाहरण के लिए, ऊपर के उदाहरण समतुल्य रूप में लिखा जा सकता है:

>>> a[[0,1],1,2] 
array([ 6, 18]) 
>>> a[[0,1],[1,2],2] 
array([ 6, 22]) 

सरणी (या सूची) के आकार आप प्रत्येक आयाम में साथ स्लाइस केवल आकार लौटे सरणी के प्रभावित करता है। दूसरे शब्दों में, numpy परवाह नहीं है कि आप अपने सरणी को (2,3,4) आकार के सरणी के साथ इंडेक्स करने की कोशिश कर रहे हैं, सिवाय इसके कि यह आपको आकार (2,3,4) आकार की एक सरणी वापस खिलाएगा।उदाहरण के लिए:

>>> a[[[0,0],[0,0]],[[0,0],[0,0]],[[0,0],[0,0]]] 
array([[0, 0], 
     [0, 0]]) 

इस मामले में, हम बार बार एक ही तत्व, a[0,0,0] हथियाने रहे हैं, लेकिन एक ही numpy आकार के साथ एक सरणी लौटा रहा है के रूप में हम में पारित

ठीक है, पर। तुम्हारी समस्या। आप अपने index सरणी में संख्याओं के साथ अंतिम धुरी के साथ सरणी को इंडेक्स करना चाहते हैं। तो, आपके प्रश्न में उदाहरण के लिए आप [[a[0,0],a[0,1],a[0,2],a[0,4],a[0,3]],a[1,0],a[1,1],...

तथ्य यह है कि आपकी अनुक्रमणिका सरणी बहुआयामी है, जैसा कि मैंने पहले कहा था, इस बारे में कुछ भी नहीं बताता है कि आप इन इंडेक्स को कहां से खींचना चाहते हैं; यह सिर्फ आउटपुट सरणी के आकार को निर्दिष्ट करता है। तो, आपके उदाहरण में, आपको numpy को बताने की जरूरत है कि पहले 5 मान a[0] से और a[1] से बाद वाले 5 को खींचा जाना है। आसान!

>>> a[[[0]*5,[1]*5],index] 

यह एन आयामों में जटिल है, लेकिन यह 3 आयामी सरणी a मैं जिस तरह से ऊपर परिभाषित के लिए करते हैं हो जाता है। मान लें कि हमारे पास निम्न इंडेक्स सरणी है:

>>> i = np.array(range(4)[::-1]*6).reshape(a.shape) 
>>> i 
array([[[3, 2, 1, 0], 
     [3, 2, 1, 0], 
     [3, 2, 1, 0]], 

     [[3, 2, 1, 0], 
     [3, 2, 1, 0], 
     [3, 2, 1, 0]]]) 

तो, ये मान अंतिम धुरी के साथ सूचकांक के लिए हैं। हमें numpy को बताने की जरूरत है कि पहले और दूसरी अक्ष के साथ सूचकांक इन नंबरों से लिया जाना है;

i1 = [[[0, 0, 0, 0], 
     [0, 0, 0, 0], 
     [0, 0, 0, 0]], 

     [[1, 1, 1, 1], 
     [1, 1, 1, 1], 
     [1, 1, 1, 1]]] 

और दूसरा अक्ष के लिए सूचकांक हैं: यानी हम numpy बताने के लिए है कि पहले अक्ष के लिए सूचकांक की जरूरत

i2 = [[[0, 0, 0, 0], 
     [1, 1, 1, 1], 
     [2, 2, 2, 2]], 

     [[0, 0, 0, 0], 
     [1, 1, 1, 1], 
     [2, 2, 2, 2]]] 

तो हम बस कर सकते हैं:

>>> a[i1,i2,i] 
array([[[ 3, 2, 1, 0], 
     [ 7, 6, 5, 4], 
     [11, 10, 9, 8]], 

     [[15, 14, 13, 12], 
     [19, 18, 17, 16], 
     [23, 22, 21, 20]]]) 

आसान numpy फ़ंक्शन जो i1 और i2 उत्पन्न करता है उसे np.mgrid कहा जाता है। मैं अपने उत्तर में np.ogrid का उपयोग करता हूं जो इस मामले में बराबर है क्योंकि मैंने पहले के बारे में बात की थी।

आशा है कि मदद करता है!

Answer 2

इस कुछ और आज के साथ खेलने के बाद मैं पता लगा कि अगर मैं ले के साथ एक नक्शाकार फ़ंक्शन का उपयोग किया मैं बस इस तरह वास्तव में 2 आयामी संस्करण का समाधान कर सकता:

a1 = random.standard_normal(size=[2,5]) 
index = array([[0,1,2,4,3] , [0,1,2,3,4] ]) 
map(take, a1, index) 

मैं करने के लिए map()take() करने की जरूरत प्रत्येक तत्व a1

बेशक, स्वीकृत उत्तर एन-आयामी संस्करण हल करता है। हालांकि पीछे की ओर मैंने यह निर्धारित किया कि मुझे वास्तव में एन-आयामी समाधान की आवश्यकता नहीं है, केवल 2-डी संस्करण।