कैसे एक खस्ता सरणी में सुन्न सरणियों की सूची में परिवर्तित करने के लिए?

Question

मान लो कि मेरे पास है;

LIST = [[array([1, 2, 3, 4, 5]), array([1, 2, 3, 4, 5],[1,2,3,4,5])] # inner lists are numpy arrays

मैं बदलने की कोशिश करता हूं;

array([[1, 2, 3, 4, 5],
       [1, 2, 3, 4, 5],
       [1, 2, 3, 4, 5])

मैं इसे अभी vstack पर पुनरावृत्ति द्वारा हल कर रहा हूं, लेकिन यह विशेष रूप से बड़े LIST के लिए वास्तव में धीमा है

आप सबसे अच्छे तरीके के लिए क्या सुझाव देते हैं?

Comments

LIST = [[array([1, 2, 3, 4, 5]), array([1, 2, 3, 4, 5],[1,2,3,4,5])]यह पायथन सिंटैक्स सही नहीं है। कृपया स्पष्ट करें।

— मार्सिन

Answer 1

सामान्य तौर पर आप किसी भी अक्ष के साथ सरणियों के एक पूरे क्रम को समाप्‍त कर सकते हैं:

numpy.concatenate( LIST, axis=0 )

लेकिन आप करते हैं (, आप यह सुनिश्चित करना है कि वे सभी 2-आयामी n-दर-5 सरणियों पहले से ही कर रहे हैं जरूरत है एक 2-आयामी 3x5 उत्पादन के लिए) आकार और सूची में प्रत्येक सरणी के आयामी स्वरूप के बारे में चिंता करने की ज़रूरत। यदि आप 1-आयामी सरणियों को 2-आयामी आउटपुट की पंक्तियों के रूप में संक्षिप्त करना चाहते हैं, तो आपको उनकी आयामीता का विस्तार करने की आवश्यकता है।

जैसा कि जॉर्ज का जवाब बताता है, वहाँ भी कार्य किया जाता है stack, जो 1.10 में पेश किया गया है:

numpy.stack( LIST, axis=0 )

यह पूरक दृष्टिकोण लेता है: यह प्रत्येक इनपुट सरणी का एक नया दृश्य बनाता है और एक अतिरिक्त आयाम जोड़ता है (इस मामले में, बाईं ओर, इसलिए प्रत्येक n-कोड 1 डी सरणी , कंक्रीटिंग nसे पहले 1-बाय -2 डी सरणी बन जाता है )। यह तभी काम करेगा जब सभी इनपुट सरणियों का आकार एक जैसा हो - यहां तक ​​कि संघनन की धुरी के साथ भी।

vstack(या समतुल्य row_stack) अक्सर एक आसान-से-उपयोग वाला समाधान होता है क्योंकि यह 1- और / या 2-आयामी सरणियों का एक क्रम लेगा और पूरी तरह से जहां आवश्यक हो केवल और केवल जहां आवश्यक हो, वहां आयामीता का विस्तार करें। जहां एक नए आयाम की आवश्यकता होती है, उसे बाईं ओर जोड़ा जाता है। पुन:, आप पुनरावृति की आवश्यकता के बिना एक बार में एक पूरी सूची बना सकते हैं:

numpy.vstack( LIST )

इस लचीले व्यवहार को सिंटैक्टिक शॉर्टकट numpy.r_[ array1, ...., arrayN ](वर्ग कोष्ठक पर ध्यान दें) द्वारा भी प्रदर्शित किया जाता है । यह कुछ स्पष्ट रूप से नामित सरणियों को संक्षिप्त करने के लिए अच्छा है लेकिन आपकी स्थिति के लिए अच्छा नहीं है क्योंकि यह वाक्यविन्यास आपके जैसे सरणियों के अनुक्रम को स्वीकार नहीं करेगा LIST।

क्षैतिज (स्तंभ-वार) स्टैकिंग के साथ-साथ एक समरूप फलन column_stackऔर शॉर्टकट भी है c_[...], साथ ही एक लगभग -संबंधी कार्य- hstackहालांकि किसी कारण से उत्तरार्द्ध कम लचीला है (यह इनपुट सरणियों की आयामीता के बारे में सख्त है, और संक्षिप्त करने की कोशिश करता है 1-डी सरणियों को स्तंभ के रूप में मानने के बजाय एंड-टू-एंड है)।

अंत में, 1-डी सरणियों के ऊर्ध्वाधर स्टैकिंग के विशिष्ट मामले में, निम्नलिखित भी काम करता है:

numpy.array( LIST )

... क्योंकि सरणियों का निर्माण अन्य सरणियों के अनुक्रम से बाहर किया जा सकता है, जो शुरुआत में एक नया आयाम जोड़ते हैं।

Comments

मुझे लगता है कि वह आउटपुट के रूप में 2d सरणी चाहता था।

— बीफस्टर

Answer 2

NumPy संस्करण 1.10 में शुरू, हमारे पास विधि स्टैक है । यह किसी भी आयाम के सरणियों को ढेर कर सकता है (सभी बराबर):

# List of arrays.
L = [np.random.randn(5,4,2,5,1,2) for i in range(10)]

# Stack them using axis=0.
M = np.stack(L)
M.shape # == (10,5,4,2,5,1,2)
np.all(M == L) # == True

M = np.stack(L, axis=1)
M.shape # == (5,10,4,2,5,1,2)
np.all(M == L) # == False (Don't Panic)

# This are all true    
np.all(M[:,0,:] == L[0]) # == True
all(np.all(M[:,i,:] == L[i]) for i in range(10)) # == True

का आनंद लें,

Answer 3

मैंने गति प्रदर्शन के कुछ तरीकों की जाँच की और पाया कि इसमें कोई अंतर नहीं है! अंतर केवल इतना है कि कुछ विधियों का उपयोग करके आपको सावधानीपूर्वक आयाम की जांच करनी चाहिए।

समय:

|------------|----------------|-------------------|
|            | shape (10000)  |  shape (1,10000)  |
|------------|----------------|-------------------|
| np.concat  |    0.18280     |      0.17960      |
|------------|----------------|-------------------|
|  np.stack  |    0.21501     |      0.16465      |
|------------|----------------|-------------------|
| np.vstack  |    0.21501     |      0.17181      |
|------------|----------------|-------------------|
|  np.array  |    0.21656     |      0.16833      |
|------------|----------------|-------------------|

जैसा कि आप देख सकते हैं कि मैंने 2 प्रयोग करने की कोशिश की - प्रयोग np.random.rand(10000)और np.random.rand(1, 10000) और अगर हम 2d सरणियों का उपयोग करते हैं np.stackऔर सेnp.array अतिरिक्त आयाम बनाते हैं - result.shape (1,10000,10000) और (10000,1,10000) तो इससे बचने के लिए उन्हें अतिरिक्त क्रियाओं की आवश्यकता होती है ।

कोड:

from time import perf_counter
from tqdm import tqdm_notebook
import numpy as np
l = []
for i in tqdm_notebook(range(10000)):
    new_np = np.random.rand(10000)
    l.append(new_np)



start = perf_counter()
stack = np.stack(l, axis=0 )
print(f'np.stack: {perf_counter() - start:.5f}')

start = perf_counter()
vstack = np.vstack(l)
print(f'np.vstack: {perf_counter() - start:.5f}')

start = perf_counter()
wrap = np.array(l)
print(f'np.array: {perf_counter() - start:.5f}')

start = perf_counter()
l = [el.reshape(1,-1) for el in l]
conc = np.concatenate(l, axis=0 )
print(f'np.concatenate: {perf_counter() - start:.5f}')