2011-12-19 45 views
20

से डुप्लिकेट कॉलम और पंक्तियों को हटा रहा है मैं अक्षांश जोड़े (अक्षांश) के जोड़े को स्टोर करने के लिए 2 डी आकार सरणी का उपयोग कर रहा हूं। एक बिंदु पर, मुझे इन 2 डी सरणी में से दो को मर्ज करना होगा, और फिर किसी भी डुप्लीकेट प्रविष्टि को हटा देना होगा। मैं numpy.unique के समान फ़ंक्शन खोज रहा हूं, लेकिन मुझे कोई भाग्य नहीं मिला है। कोई भी कार्यान्वयन मैं पर बहुत "अनौपचारिक" दिखने पर सोच रहा हूं। उदाहरण के लिए, मैं, tuples की एक सूची के लिए सरणी परिवर्तित सेट के साथ डुप्लिकेट हटाने, और फिर एक सरणी के लिए फिर से परिवर्तित करने के साथ कोशिश कर रहा हूँ: वहाँ किसी भी मौजूदा समाधानएक NumPy 2D सरणी

coordskeys = np.array(list(set([tuple(x) for x in coordskeys]))) 

हैं, तो मैं पहिया बदलने नहीं है ? मैं बस इसके लिए tuples की एक सूची का उपयोग करना चाहता

>>> a = np.array([[1, 1], [2, 3], [1, 1], [5, 4], [2, 3]]) 
>>> unique_rows(a) 
array([[1, 1], [2, 3],[5, 4]]) 

Btw,, लेकिन सूचियों इतना बड़ा है कि वे मेरी 4GB RAM + 4Gb भस्म थे:

यह स्पष्ट है, मैं तलाश कर रहा हूँ करने के लिए स्वैप (numpy arrays अधिक मेमोरी कुशल हैं)।

+0

देखें http://stackoverflow.com/questions/7989722/finding-unique-points-in-numpy-array – joris

उत्तर

16

यहाँ एक विचार है, यह काम का एक छोटा सा ले लेंगे लेकिन काफी तेजी से हो सकता है। मैं आपको 1 डी केस दूंगा और आपको यह पता लगाने दूंगा कि इसे 2 डी तक कैसे बढ़ाया जाए। निम्न फ़ंक्शन को 1 डी सरणी के अद्वितीय तत्व मिलते हैं:

import numpy as np 
def unique(a): 
    a = np.sort(a) 
    b = np.diff(a) 
    b = np.r_[1, b] 
    return a[b != 0] 

अब इसे 2 डी तक बढ़ाने के लिए आपको दो चीजों को बदलने की आवश्यकता है। आपको यह पता लगाने की आवश्यकता होगी कि खुद को कैसे करें, इस तरह की महत्वपूर्ण बात यह होगी कि दो समान प्रविष्टियां एक दूसरे के बगल में समाप्त होती हैं। दूसरा, आपको (b != 0).all(axis) जैसे कुछ करने की आवश्यकता होगी क्योंकि आप पूरी पंक्ति/कॉलम की तुलना करना चाहते हैं। अगर आपको शुरू करने के लिए पर्याप्त है तो मुझे बताएं।

अपडेट किया गया: डॉग के साथ कुछ मदद के साथ, मुझे लगता है कि यह 2 डी मामले के लिए काम करना चाहिए।

import numpy as np 
def unique(a): 
    order = np.lexsort(a.T) 
    a = a[order] 
    diff = np.diff(a, axis=0) 
    ui = np.ones(len(a), 'bool') 
    ui[1:] = (diff != 0).any(axis=1) 
    return a[ui] 
+0

+1 ने अभी मेरा जवाब पोस्ट किया है, फिर अपना पढ़ें - ऐसा लगता है कि मेरा तुम्हारा एक वफादार 2 डी कार्यान्वयन है - समान कार्यों का एक ही अनुक्रम (मुझे पहले भी एक पंक्ति संगतता चरण था, लेकिन मैंने इसे हटा दिया और पहली पंक्ति काट दिया इसके बजाय मूल सरणी से बाहर। – doug

+0

ध्यान दें कि यह * Python3 * – Bzazz

+0

के साथ काम नहीं कर रहा है, यह उत्तर अधिकतर numpy का उपयोग करता है, इसलिए python2/3 'पदार्थ' नहीं होना चाहिए। अगर यह आपके लिए काम नहीं कर रहा है, तो शायद कुछ और चल रहा है –

1

चूंकि आप numpy.unique का संदर्भ देते हैं, तो आप मूल क्रम को बनाए रखने की परवाह नहीं करते हैं, सही? सूची में सेट है, जो नकल को हटा में परिवर्तित करने, और फिर वापस अक्सर मुहावरा प्रयोग किया जाता है:

>>> x = [(1, 1), (2, 3), (1, 1), (5, 4), (2, 3)] 
>>> y = list(set(x)) 
>>> y 
[(5, 4), (2, 3), (1, 1)] 
>>> 
+1

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

31

इस चाल करना चाहिए:

def unique_rows(a): 
    a = np.ascontiguousarray(a) 
    unique_a = np.unique(a.view([('', a.dtype)]*a.shape[1])) 
    return unique_a.view(a.dtype).reshape((unique_a.shape[0], a.shape[1])) 

उदाहरण:

>>> a = np.array([[1, 1], [2, 3], [1, 1], [5, 4], [2, 3]]) 
>>> unique_rows(a) 
array([[1, 1], 
     [2, 3], 
     [5, 4]]) 
+0

अच्छा और संक्षिप्त! – erikreed

+1

नोट: यह एक ट्रांसपोज़ेड सरणी के साथ काम नहीं करेगा। – user100464

+1

@ user100464, संपादित किया गया है ताकि यह ट्रांसपोज़ेड सरणी के साथ काम करेगा। – user545424

3
>>> import numpy as NP 
>>> # create a 2D NumPy array with some duplicate rows 
>>> A 
    array([[1, 1, 1, 5, 7], 
      [5, 4, 5, 4, 7], 
      [7, 9, 4, 7, 8], 
      [5, 4, 5, 4, 7], 
      [1, 1, 1, 5, 7], 
      [5, 4, 5, 4, 7], 
      [7, 9, 4, 7, 8], 
      [5, 4, 5, 4, 7], 
      [7, 9, 4, 7, 8]]) 

>>> # first, sort the 2D NumPy array row-wise so dups will be contiguous 
>>> # and rows are preserved 
>>> a, b, c, d, e = A.T # create the keys for to pass to lexsort 
>>> ndx = NP.lexsort((a, b, c, d, e)) 
>>> ndx 
    array([1, 3, 5, 7, 0, 4, 2, 6, 8]) 
>>> A = A[ndx,] 

>>> # now diff by row 
>>> A1 = NP.diff(A, axis=0) 
>>> A1 
    array([[0, 0, 0, 0, 0], 
      [4, 3, 3, 0, 0], 
      [0, 0, 0, 0, 0], 
      [0, 0, 0, 1, 0], 
      [0, 0, 1, 0, 0], 
      [2, 5, 0, 2, 1], 
      [0, 0, 0, 0, 0], 
      [0, 0, 0, 0, 0]]) 

>>> # the index array holding the location of each duplicate row 
>>> ndx = NP.any(A1, axis=1) 
>>> ndx 
    array([False, True, False, True, True, True, False, False], dtype=bool) 

>>> # retrieve the duplicate rows: 
>>> A[1:,:][ndx,] 
    array([[7, 9, 4, 7, 8], 
      [1, 1, 1, 5, 7], 
      [5, 4, 5, 4, 7], 
      [7, 9, 4, 7, 8]]) 
+0

डौग, मुझे लगता है कि आप 'बंद हो जाओ लेकिन आप परेशानी में भागने जा रहे हैं क्योंकि एनपी.sort (ए, अक्ष = 0) स्वतंत्र रूप से प्रत्येक कॉलम को टाइप करता है। दो विधियों पर अपनी विधि चलाने का प्रयास करें: '[[0, 0], [1, 1], [2,2]]' और '[[0, 1], [1, 0], [2,2 ]] '। मैंने अपना एक जवाब जोड़ा जो मेरा जवाब है जो सॉर्ट करते समय पंक्तियों को बरकरार रखता है। –

+0

@ बागो इसे पकड़ने के लिए धन्यवाद - बस ठीक करने के लिए संपादित किया गया। – doug

+0

मुझे लेक्सॉर्ट के बारे में पता नहीं था, मैं इसे अपने उत्तर में शामिल करने जा रहा हूं यदि यह ठीक है –

5

मेरे विधि 1 दिन जटिल श्रृंखला है, जहां वास्तविक हिस्सा है में एक 2d सरणी बदल कर है पहला कॉलम, काल्पनिक हिस्सा दूसरा कॉलम है। फिर np.unique का उपयोग करें। हालांकि यह केवल 2 कॉलम के साथ काम करेगा।

import numpy as np 
def unique2d(a): 
    x, y = a.T 
    b = x + y*1.0j 
    idx = np.unique(b,return_index=True)[1] 
    return a[idx] 

उदाहरण -

a = np.array([[1, 1], [2, 3], [1, 1], [5, 4], [2, 3]]) 
unique2d(a) 
array([[1, 1], 
     [2, 3], 
     [5, 4]]) 
3

numpy_indexed पैकेज (अस्वीकरण: मैं उसके लेखक हूँ):

import numpy_indexed as npi 
npi.unique(coordskeys) 
समाधान एक अच्छा और परीक्षण इंटरफ़ेस में user545424 द्वारा पोस्ट की गई, के साथ साथ कई संबंधित सुविधाओं लपेटता
संबंधित मुद्दे