1D अंक वाले सरणी में Numpy के साथ स्थानीय मैक्सिमा / मिनिमा खोजना

Question

क्या आप सुन्न / खुरपी से एक मॉड्यूल फ़ंक्शन का सुझाव दे सकते हैं जो एक 1D अंकुरण सरणी में स्थानीय मैक्सिमा / मिनिमा पा सकते हैं? जाहिर है कि सबसे सरल दृष्टिकोण कभी भी निकटतम पड़ोसियों पर एक नज़र रखना है, लेकिन मैं एक स्वीकृत समाधान रखना चाहूंगा जो कि सुदूर डिस्ट्रो का हिस्सा है।

Comments

संभवत: डुप्लिकेट में एक चिकनी बहुआयामी सरणी के स्थानीय मिनीमा को कुशलता से खोजने के लिए कैसे का एक डुप्लिकेट ? ।

— स्वेन मार्नाच

2 डी में नहीं (मैं 1 डी के बारे में बात कर रहा हूं) और इसमें कस्टम फ़ंक्शन शामिल हैं। मेरा अपना सरल कार्यान्वयन है, लेकिन मैं सोच रहा था कि क्या कोई बेहतर है, जो नम्पी / स्किपी मॉड्यूल के साथ आता है।

— नवी

हो सकता है कि आप इस प्रश्न को शामिल करने के लिए अद्यतन कर सकते हैं कि (1) आपके पास 1d सरणी है और (2) आप किस प्रकार का स्थानीय न्यूनतम खोज रहे हैं। सिर्फ एक प्रविष्टि दो आसन्न प्रविष्टियों से छोटी है?

— स्वेन मार्नाच

आप scipy.signal.find_peaks_cwt पर एक नज़र डाल सकते हैं यदि आप शोर के साथ डेटा की बात कर रहे हैं

— Lakshay Garg

Answer 1

यदि आप aअपने पड़ोसियों से छोटे 1d सरणी में सभी प्रविष्टियों की तलाश कर रहे हैं , तो आप कोशिश कर सकते हैं

numpy.r_[True, a[1:] < a[:-1]] & numpy.r_[a[:-1] < a[1:], True]

आप इस चरण का उपयोग करने से पहले अपने सरणी को सुचारू कर सकते हैं numpy.convolve()।

मुझे नहीं लगता कि इसके लिए कोई समर्पित कार्य है।

Comments

हम्म, मुझे चिकनी करने की आवश्यकता क्यों होगी? शोर को दूर करने के लिए? यह दिलचस्प लगता है। यह मुझे लगता है कि मैं आपके उदाहरण कोड में 1 के बजाय दूसरे पूर्णांक का उपयोग कर सकता हूं। मैं भी ग्रेडिएंट्स की गणना करने के बारे में सोच रहा था। वैसे भी अगर कोई फंक्शन नहीं है तो बहुत बुरा है।

— नवी

@Navi: समस्या यह है कि "स्थानीय न्यूनतम" की धारणा उपयोग के मामले में उपयोग किए जाने वाले मामले से बहुत भिन्न होती है, इसलिए इस उद्देश्य के लिए "मानक" फ़ंक्शन प्रदान करना कठिन है। चौरसाई सिर्फ निकटतम पड़ोसी से अधिक खाते में लेने में मदद करता है। 1 के बजाय एक अलग पूर्णांक का उपयोग करते हुए, 3 कहते हैं, यह अजीब होगा क्योंकि यह केवल दोनों दिशाओं में तीसरे-अगले तत्व पर विचार करेगा, लेकिन प्रत्यक्ष नेहबगॉर नहीं।

— स्वेन मार्नाच

@Sven Marnach: जिस रेसिपी को आप लिंक करते हैं वह सिग्नल को देरी करती है। वहाँ एक दूसरा नुस्खा जो का उपयोग करता है filtfilt scipy.signal से

— bobrobbob

बस इसके लिए, के <साथ की जगह >आप

— मिनीमा के

@SvenMarnach मैंने अपनी समस्या के समाधान के लिए आपके उपरोक्त समाधान का उपयोग किया है यहाँ stackoverflow.com/questions/57403659/… लेकिन मुझे आउटपुट मिला [False False]है यहाँ समस्या क्या हो सकती है?

— Msquare

Answer 2

SciPy में = = 0.11

import numpy as np
from scipy.signal import argrelextrema

x = np.random.random(12)

# for local maxima
argrelextrema(x, np.greater)

# for local minima
argrelextrema(x, np.less)

का उत्पादन

>>> x
array([ 0.56660112,  0.76309473,  0.69597908,  0.38260156,  0.24346445,
    0.56021785,  0.24109326,  0.41884061,  0.35461957,  0.54398472,
    0.59572658,  0.92377974])
>>> argrelextrema(x, np.greater)
(array([1, 5, 7]),)
>>> argrelextrema(x, np.less)
(array([4, 6, 8]),)

ध्यान दें, ये x के सूचक हैं जो स्थानीय अधिकतम / मिनट हैं। मान प्राप्त करने के लिए, प्रयास करें:

>>> x[argrelextrema(x, np.greater)[0]]

scipy.signalक्रमशः प्रदान करता है argrelmaxऔर argrelminअधिकतम और मिनीमा खोजने के लिए।

Comments

12 का महत्व क्या है?

— मार्शमैलो

@ मार्शमैलो: np.random.random(12)12 यादृच्छिक मान उत्पन्न करता है, इनका उपयोग फ़ंक्शन को प्रदर्शित करने के लिए किया जाता है argrelextrema।

— सेबिक्स

यदि इनपुट है test02=np.array([10,4,4,4,5,6,7,6]), तो यह काम नहीं करता है। यह स्थानीय मिनीमा के रूप में लगातार मूल्यों को नहीं पहचानता है।

— Leos313

धन्यवाद, @Cleb मैं अन्य समस्याओं को इंगित करना चाहता हूं: सरणी के चरम बिंदुओं के बारे में क्या? पहला तत्व स्थानीय अधिकतम भी है क्योंकि सरणी का अंतिम तत्व स्थानीय न्यूनतम भी है। और, यह भी, यह नहीं लौटता है कि कितने लगातार मूल्यों की स्थापना की जाती है। हालाँकि, मैंने यहां इस प्रश्न के कोड में एक समाधान प्रस्तावित किया । धन्यवाद!!

— लेओस 313

धन्यवाद, यह अब तक मुझे मिले सबसे अच्छे समाधानों में से एक है

— नौफल ई

Answer 3

बहुत अधिक शोर के साथ घटता के लिए, मैं निम्नलिखित छोटे कोड स्निपेट सुझाता हूं:

from numpy import *

# example data with some peaks:
x = linspace(0,4,1e3)
data = .2*sin(10*x)+ exp(-abs(2-x)**2)

# that's the line, you need:
a = diff(sign(diff(data))).nonzero()[0] + 1 # local min+max
b = (diff(sign(diff(data))) > 0).nonzero()[0] + 1 # local min
c = (diff(sign(diff(data))) < 0).nonzero()[0] + 1 # local max


# graphical output...
from pylab import *
plot(x,data)
plot(x[b], data[b], "o", label="min")
plot(x[c], data[c], "o", label="max")
legend()
show()

+1महत्वपूर्ण है, क्योंकि diffमूल इंडेक्स नंबर कम करता है।

Comments

नेस्टेड सुन्न कार्यों का अच्छा उपयोग! लेकिन ध्यान दें कि यह सरणी के दोनों छोर पर मैक्सिमा को याद करता है :)

— danodonovan

यह भी अजीब कार्य करेगा यदि दोहराव वाले मूल्य हैं। उदाहरण के लिए यदि आप सरणी लेते हैं [1, 2, 2, 3, 3, 3, 2, 2, 1], तो स्थानीय मैक्सिमा स्पष्ट रूप से 3 के बीच में कहीं है। लेकिन अगर आप अपने द्वारा प्रदान किए गए कार्यों को चलाते हैं, तो आपको सूचकांक 2,6 में अधिकतम और इंडेक्स 1,3,5,7 पर न्यूनतम मिलता है, जो मेरे लिए बहुत मायने नहीं रखता है।

— कोरम

उपयोग के +1बजाय इससे बचने के np.diff()लिए np.gradient()।

— अकोस्टिस

मुझे पता है कि यह धागा वर्षों पुराना है, लेकिन यह जोड़ने योग्य है कि यदि आपकी वक्र बहुत अधिक शोर है, तो आप हमेशा स्मूथिंग के लिए कम-पास फ़िल्टरिंग की कोशिश कर सकते हैं। मेरे लिए कम से कम, अपने स्थानीय अधिकतम / मिनट का उपयोग करता है के सबसे वैश्विक अधिकतम / मिनट कुछ स्थानीय क्षेत्र के भीतर (उदा, बड़े चोटियों और घाटियों, डेटा में नहीं हर परिवर्तन) के लिए कर रहे हैं

— marcman

Answer 4

एक और दृष्टिकोण (अधिक शब्द, कम कोड) जो मदद कर सकता है:

स्थानीय अधिकतम और मिनिमा के स्थान भी पहले व्युत्पन्न के शून्य क्रॉसिंग के स्थान हैं। आम तौर पर स्थानीय क्रॉसिमा और मिनीमा को खोजने की तुलना में शून्य क्रॉसिंग को ढूंढना बहुत आसान है।

दुर्भाग्य से, पहला व्युत्पन्न शोर को "बढ़ाना" देता है, इसलिए जब मूल डेटा में महत्वपूर्ण शोर मौजूद होता है, तो मूल डेटा के लागू होने के कुछ समय बाद ही मूल व्युत्पत्ति का सबसे अच्छा उपयोग किया जाता है।

चूँकि स्मूथिंग, सबसे सरल अर्थों में, एक कम पास फिल्टर है, एक कनवल्शन कर्नेल का उपयोग करके स्मूदी अक्सर सबसे अच्छा (अच्छी तरह से, सबसे आसानी से) किया जाता है, और "आकार" जो कर्नेल सुविधा-संरक्षण / संवर्द्धन क्षमता की एक आश्चर्यजनक मात्रा प्रदान कर सकता है। । एक इष्टतम कर्नेल खोजने की प्रक्रिया को विभिन्न प्रकार के साधनों का उपयोग करके स्वचालित किया जा सकता है, लेकिन सबसे अच्छा सरल जानवर बल हो सकता है (छोटे कर्नेल को खोजने के लिए बहुत तेज़)। एक अच्छा कर्नेल मूल डेटा को बड़े पैमाने पर विकृत कर देगा, लेकिन यह चोटियों / घाटियों के स्थान को प्रभावित नहीं करेगा।

सौभाग्य से, अक्सर एक उपयुक्त कर्नेल को एक साधारण SWAG ("शिक्षित अनुमान") के माध्यम से बनाया जा सकता है। चौरसाई कर्नेल की चौड़ाई मूल डेटा में व्यापक "अपेक्षित" चोटी की तुलना में थोड़ी चौड़ी होनी चाहिए, और इसका आकार उस चोटी (एकल-स्केल वाली तरंगिका) जैसा होगा। मीन-प्रोटेक्टिंग कर्नेल के लिए (क्या कोई अच्छा स्मूथिंग फ़िल्टर होना चाहिए) कर्नेल तत्वों का योग ठीक 1.00 के बराबर होना चाहिए, और कर्नेल को इसके केंद्र के बारे में सममित होना चाहिए (जिसका अर्थ है कि इसमें विषम संख्या में तत्व होंगे।

एक इष्टतम चौरसाई कर्नेल (या अलग-अलग डेटा सामग्री के लिए अनुकूलित गुठली की एक छोटी संख्या) को देखते हुए, चौरसाई कारक ("लाभ") की सजा कर्नेल के लिए स्केलिंग कारक बन जाता है।

चौरसाई (दृढ़ संकल्प कर्नेल लाभ) की "सही" (इष्टतम) डिग्री का निर्धारण भी स्वचालित किया जा सकता है: स्मूथ डेटा के मानक विचलन के साथ पहले व्युत्पन्न डेटा के मानक विचलन की तुलना करें। चौरसाई कैम की डिग्री में परिवर्तन के साथ दो मानक विचलन का अनुपात कैसे प्रभावी चौरसाई मूल्यों की भविष्यवाणी करने के लिए उपयोग किया जाता है। कुछ मैनुअल डेटा चलता है (जो वास्तव में प्रतिनिधि हैं) सभी की आवश्यकता होनी चाहिए।

उपरोक्त पोस्ट किए गए सभी पूर्व समाधान पहले व्युत्पन्न की गणना करते हैं, लेकिन वे इसे एक सांख्यिकीय उपाय के रूप में नहीं मानते हैं, और न ही उपरोक्त समाधान सुविधा के संरक्षण / चौरसाई को बढ़ाने के लिए (सूक्ष्म चोटियों "शोर से ऊपर" छलांग में मदद करने के लिए) का प्रयास करते हैं।

अंत में, बुरी खबर: "असली" चोटियों को ढूंढना एक शाही दर्द बन जाता है जब शोर में ऐसी विशेषताएं भी होती हैं जो वास्तविक चोटियों (ओवरलोडिंग बैंडविड्थ) की तरह दिखती हैं। अगला अधिक-जटिल समाधान आम तौर पर एक लंबी सजा कर्नेल (एक "व्यापक कर्नेल एपर्चर") का उपयोग करने के लिए है जो आसन्न "वास्तविक" चोटियों (जैसे शिखर घटना के लिए न्यूनतम या अधिकतम दर), या कई का उपयोग करने के बीच संबंध को ध्यान में रखता है। कन्वेक्शन अलग-अलग चौड़ाई वाली गुठली का उपयोग करके गुजरता है (लेकिन केवल अगर यह तेज है: यह एक मौलिक गणितीय सत्य है कि अनुक्रम में किए गए रैखिक संकेंद्रण हमेशा एक एकल संकेतन में एक साथ दोषी ठहराए जा सकते हैं)। लेकिन अक्सर उपयोगी गुठली (अलग-अलग चौड़ाई के) का एक क्रम ढूंढना आसान होता है और उन्हें एक साथ जोड़कर इसे हल करना होता है, सीधे एक ही चरण में अंतिम कर्नेल को खोजने के लिए।

उम्मीद है कि यह Google (और शायद एक अच्छा आँकड़े पाठ) को अंतराल में भरने के लिए पर्याप्त जानकारी प्रदान करता है। मैं वास्तव में कामना करता हूं कि मेरे पास काम करने के लिए एक उदाहरण या एक लिंक उपलब्ध कराने का समय है। अगर किसी को एक ऑनलाइन भर आता है, तो कृपया इसे यहाँ पोस्ट करें

Answer 5

SciPy संस्करण 1.1 के अनुसार, आप find_peaks का भी उपयोग कर सकते हैं । नीचे प्रलेखन से ही दो उदाहरण दिए गए हैं।

heightतर्क का उपयोग करते हुए, एक निश्चित सीमा से ऊपर सभी मैक्सिमा का चयन कर सकते हैं (इस उदाहरण में, सभी गैर-नकारात्मक मैक्सिमा; यह बहुत उपयोगी हो सकता है अगर किसी को शोर बेसलाइन से निपटना पड़ता है; यदि आप मिनीमा खोजना चाहते हैं, तो बस आप इनपुट का गुणा करें। द्वारा -1):

import matplotlib.pyplot as plt
from scipy.misc import electrocardiogram
from scipy.signal import find_peaks
import numpy as np

x = electrocardiogram()[2000:4000]
peaks, _ = find_peaks(x, height=0)
plt.plot(x)
plt.plot(peaks, x[peaks], "x")
plt.plot(np.zeros_like(x), "--", color="gray")
plt.show()

एक अन्य अत्यंत उपयोगी तर्क है distance, जो दो चोटियों के बीच न्यूनतम दूरी को परिभाषित करता है:

peaks, _ = find_peaks(x, distance=150)
# difference between peaks is >= 150
print(np.diff(peaks))
# prints [186 180 177 171 177 169 167 164 158 162 172]

plt.plot(x)
plt.plot(peaks, x[peaks], "x")
plt.show()

Answer 6

कार्य करने के लिए Scipy बिल्ट-इन फ़ंक्शन सिग्नल का उपयोग क्यों न करें ।find_peaks_cwt ?

from scipy import signal
import numpy as np

#generate junk data (numpy 1D arr)
xs = np.arange(0, np.pi, 0.05)
data = np.sin(xs)

# maxima : use builtin function to find (max) peaks
max_peakind = signal.find_peaks_cwt(data, np.arange(1,10))

# inverse  (in order to find minima)
inv_data = 1/data
# minima : use builtin function fo find (min) peaks (use inversed data)
min_peakind = signal.find_peaks_cwt(inv_data, np.arange(1,10))

#show results
print "maxima",  data[max_peakind]
print "minima",  data[min_peakind]

परिणाम:

maxima [ 0.9995736]
minima [ 0.09146464]

सादर

Comments

विभाजन करने के बजाय (सटीक नुकसान के साथ), अधिकतम से मिनीमा तक जाने के लिए सिर्फ -1 से गुणा क्यों नहीं?

— लिवियस

मैंने '1 / डेटा' को 'डेटा * -1' में बदलने की कोशिश की, लेकिन फिर यह एक त्रुटि बढ़ाता है, क्या आप अपने तरीके को लागू करने के लिए साझा कर सकते हैं?

— एक स्टेफनी

शायद इसलिए कि हम उस अंतिम उपयोगकर्ता को अतिरिक्त रूप से स्केपी स्थापित करना चाहते हैं।

— दामियन येरिक

Answer 7

अद्यतन: मैं ग्रेडिएंट से खुश नहीं था इसलिए मैंने इसे उपयोग करने के लिए अधिक विश्वसनीय पायाnumpy.diff । कृपया मुझे बताएं कि क्या यह वही है जो आप चाहते हैं।

शोर के मुद्दे के बारे में, गणितीय समस्या यह है कि मैक्सिमा / मिनिमा का पता लगाना है यदि हम शोर को देखना चाहते हैं तो हम कुछ ऐसी चीजों का उपयोग कर सकते हैं जो पहले उल्लिखित हैं।

import numpy as np
from matplotlib import pyplot

a=np.array([10.3,2,0.9,4,5,6,7,34,2,5,25,3,-26,-20,-29],dtype=np.float)

gradients=np.diff(a)
print gradients


maxima_num=0
minima_num=0
max_locations=[]
min_locations=[]
count=0
for i in gradients[:-1]:
        count+=1

    if ((cmp(i,0)>0) & (cmp(gradients[count],0)<0) & (i != gradients[count])):
        maxima_num+=1
        max_locations.append(count)     

    if ((cmp(i,0)<0) & (cmp(gradients[count],0)>0) & (i != gradients[count])):
        minima_num+=1
        min_locations.append(count)


turning_points = {'maxima_number':maxima_num,'minima_number':minima_num,'maxima_locations':max_locations,'minima_locations':min_locations}  

print turning_points

pyplot.plot(a)
pyplot.show()

Comments

क्या आप जानते हैं कि इस ढाल की गणना कैसे की जाती है? यदि आपके पास शोर डेटा है तो शायद ढाल बहुत बदल जाती है, लेकिन इसका मतलब यह नहीं है कि अधिकतम / मिनट है।

— नवी

हां मुझे पता है, हालांकि शोर डेटा एक अलग मुद्दा है। इसके लिए मुझे लगता है कि उपयोग का हल है।

— माइक वेला

मुझे उस परियोजना के लिए कुछ इसी तरह की आवश्यकता थी जिस पर मैं काम कर रहा था और ऊपर उल्लिखित numpy.diff पद्धति का उपयोग किया था, मैंने सोचा कि यह उल्लेख करना उपयोगी हो सकता है कि मेरे डेटा के लिए उपरोक्त कोड कुछ मैक्सिमा और मिनिमा से चूक गए, दोनों में मध्य अवधि को बदलकर यदि बयान <= और> = क्रमशः, मैं सभी बिंदुओं को पकड़ने में सक्षम था।

Answer 8

जबकि यह प्रश्न वास्तव में पुराना है। मेरा मानना ​​है कि संख्यात्मक (एक लाइनर) में बहुत सरल दृष्टिकोण है।

import numpy as np

list = [1,3,9,5,2,5,6,9,7]

np.diff(np.sign(np.diff(list))) #the one liner

#output
array([ 0, -2,  0,  2,  0,  0, -2])

एक स्थानीय अधिकतम या मिनट खोजने के लिए हम अनिवार्य रूप से तब खोजना चाहते हैं जब सूची में मूल्यों (3-1, 9-3 ...) के बीच का अंतर सकारात्मक से नकारात्मक (अधिकतम) या नकारात्मक से सकारात्मक (मिनट) में बदल जाता है। इसलिए, पहले हम अंतर पाते हैं। फिर हम साइन को ढूंढते हैं, और फिर हम फिर से अंतर लेते हुए साइन में बदलाव पाते हैं। (कैलकुलस में पहले और दूसरे व्युत्पन्न की तरह, केवल हमारे पास असतत डेटा है और एक निरंतर कार्य नहीं है)।

मेरे उदाहरण में आउटपुट में एक्स्ट्रेमा (सूची में पहला और अंतिम मान) नहीं है। साथ ही, कैलकुलस की तरह, यदि दूसरा व्युत्पन्न नकारात्मक है, तो आपके पास अधिकतम है, और यदि यह सकारात्मक है तो आपके पास एक मिनट है।

इस प्रकार हमारे पास निम्नलिखित मिलान है:

[1,  3,  9,  5,  2,  5,  6,  9,  7]
    [0, -2,  0,  2,  0,  0, -2]
        Max     Min         Max

Comments

मुझे लगता है कि यह (अच्छा!) उत्तर 2012 से आरसी के उत्तर के समान है? वह तीन एक-लाइन समाधान प्रदान करता है, इस पर निर्भर करता है कि क्या कॉलर को न्यूनतम, अधिकतम या दोनों चाहिए, यदि मैं उसका समाधान सही ढंग से पढ़ रहा हूं।

— ब्रैंडन रोड्स

Answer 9

इनमें से किसी भी समाधान ने मेरे लिए काम नहीं किया क्योंकि मैं मूल्यों को दोहराने के केंद्र में चोटियों को ढूंढना चाहता था। उदाहरण के लिए, में

ar = np.array([0,1,2,2,2,1,3,3,3,2,5,0])

उत्तर होना चाहिए

array([ 3,  7, 10], dtype=int64)

मैंने यह एक लूप का उपयोग करके किया। मुझे पता है कि यह सुपर क्लीन नहीं है, लेकिन इससे काम हो जाता है।

def findLocalMaxima(ar):
# find local maxima of array, including centers of repeating elements    
maxInd = np.zeros_like(ar)
peakVar = -np.inf
i = -1
while i < len(ar)-1:
#for i in range(len(ar)):
    i += 1
    if peakVar < ar[i]:
        peakVar = ar[i]
        for j in range(i,len(ar)):
            if peakVar < ar[j]:
                break
            elif peakVar == ar[j]:
                continue
            elif peakVar > ar[j]:
                peakInd = i + np.floor(abs(i-j)/2)
                maxInd[peakInd.astype(int)] = 1
                i = j
                break
    peakVar = ar[i]
maxInd = np.where(maxInd)[0]
return maxInd 

Answer 10

import numpy as np
x=np.array([6,3,5,2,1,4,9,7,8])
y=np.array([2,1,3,5,3,9,8,10,7])
sortId=np.argsort(x)
x=x[sortId]
y=y[sortId]
minm = np.array([])
maxm = np.array([])
i = 0
while i < length-1:
    if i < length - 1:
        while i < length-1 and y[i+1] >= y[i]:
            i+=1

        if i != 0 and i < length-1:
            maxm = np.append(maxm,i)

        i+=1

    if i < length - 1:
        while i < length-1 and y[i+1] <= y[i]:
            i+=1

        if i < length-1:
            minm = np.append(minm,i)
        i+=1


print minm
print maxm

minmऔर maxmक्रमशः मिनिमा और मैक्सिमा के सूचकांक होते हैं। एक विशाल डेटा सेट के लिए, यह बहुत सारे मैक्सिमम / न्यूनतम देगा ताकि उस मामले में पहले वक्र को चिकना करें और फिर इस एल्गोरिथ्म को लागू करें।

Comments

यह दिलचस्प लग रहा है। कोई पुस्तकालय नहीं। यह कैसे काम करता है?

— जॉन ktejik

प्रारंभिक बिंदु से वक्र को पीछे छोड़ें और देखें कि क्या आप लगातार ऊपर या नीचे की ओर जा रहे हैं, एक बार जब आप ऊपर से नीचे की ओर बदलते हैं तो इसका मतलब है कि आपको एक अधिकतम मिला है, यदि आप नीचे जा रहे हैं, तो आपको एक मिनीमा मिला है।

— prtkp

Answer 11

आवश्यक रूप से एक पतला ऑपरेटर का उपयोग कर एक और समाधान:

import numpy as np
from scipy.ndimage import rank_filter

def find_local_maxima(x):
   x_dilate = rank_filter(x, -1, size=3)
   return x_dilate == x

और मिनीमा के लिए:

def find_local_minima(x):
   x_erode = rank_filter(x, -0, size=3)
   return x_erode == x

इसके अलावा, scipy.ndimageआप के rank_filter(x, -1, size=3)साथ grey_dilationऔर rank_filter(x, 0, size=3)साथ बदल सकते हैं grey_erosion। इसके लिए स्थानीय प्रकार की आवश्यकता नहीं होगी, इसलिए यह थोड़ा तेज है।

Comments

यह इस समस्या के लिए ठीक से काम करता है। यहाँ समाधान एकदम सही है (+1)

— Leos313

Answer 12

और एक:

def local_maxima_mask(vec):
    """
    Get a mask of all points in vec which are local maxima
    :param vec: A real-valued vector
    :return: A boolean mask of the same size where True elements correspond to maxima. 
    """
    mask = np.zeros(vec.shape, dtype=np.bool)
    greater_than_the_last = np.diff(vec)>0  # N-1
    mask[1:] = greater_than_the_last
    mask[:-1] &= ~greater_than_the_last
    return mask