blocks|key|829833|text|如果要在一维数组a中查找比其相邻项小的所有条目，可以尝试|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|829834|numpy.r_[True,+a[1:]+<+a[:-1]]+&+numpy.r_[a[:-1]+<+a[1:],+True]|code-block|syntax|javascript|829835|您还可以在此步骤之前使用numpy.convolve()+smooth您的阵列。|829836|我不认为有专门的函数来做这件事。|829837|entityMap|0|LINK|mutability|MUTABLE|url|http://scipy-cookbook.readthedocs.org/items/SignalSmooth.html^0|8|1|0|0|C|G|T|6|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

If you are looking for all entries in the 1d array <code>a</code> smaller than their neighbors, you can try

<pre><code>numpy.r_[True, a[1:] &lt; a[:-1]] &amp; numpy.r_[a[:-1] &lt; a[1:], True]
</code></pre>

You could also <a href="http://scipy-cookbook.readthedocs.org/items/SignalSmooth.html">smooth</a> your array before this step using <code>numpy.convolve()</code>.

I don't think there is a dedicated function for this.

blocks|key|1044753|text|对于没有太多噪声的曲线，我推荐以下小代码片段：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1044754|from+numpy+import+*

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

#+that's+the+line,+you+need:
a+=+diff(sign(diff(data))).nonzero()[0]+%2B+1+#+local+min%2Bmax
b+=+(diff(sign(diff(data)))+>+0).nonzero()[0]+%2B+1+#+local+min
c+=+(diff(sign(diff(data)))+<+0).nonzero()[0]+%2B+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()|code-block|syntax|javascript|1044755|%2B1很重要，因为diff减少了原始索引号。|offset|length|style|CODE|1044756|entityMap^0|0|0|0|2|8|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

For curves with not too much noise, I recommend the following small code snippet:

<pre><code>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))) &gt; 0).nonzero()[0] + 1 # local min
c = (diff(sign(diff(data))) &lt; 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()
</code></pre>

The <code>+1</code> is important, because <code>diff</code> reduces the original index number.

blocks|key|1044796|text|在SciPy+>=+0.11中|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1044797|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)|code-block|syntax|javascript|1044798|产生|1044799|>>>+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]),)|1044800|请注意，这些是x的索引，即本地最大值/分钟。要获取这些值，请尝试：|1044801|>>>+x[argrelextrema(x,+np.greater)[0]]|1044802|scipy.signal还提供了argrelmax和argrelmin，分别用于查找最大值和最小值。|offset|length|style|CODE|1044803|entityMap^0|0|0|0|0|0|0|0|C|G|9|Q|9|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@$Q|13|R|14|S|T]|$Q|15|R|16|S|T]|$Q|17|R|18|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|V|$]]

In SciPy >= 0.11

<pre><code>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)
</code></pre>

Produces 

<pre><code>&gt;&gt;&gt; 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])
&gt;&gt;&gt; argrelextrema(x, np.greater)
(array([1, 5, 7]),)
&gt;&gt;&gt; argrelextrema(x, np.less)
(array([4, 6, 8]),)
</code></pre>

Note, these are the indices of x that are local max/min. To get the values, try:

<pre><code>&gt;&gt;&gt; x[argrelextrema(x, np.greater)[0]]
</code></pre>

<code>scipy.signal</code> also provides <code>argrelmax</code> and <code>argrelmin</code> for finding maxima and minima respectively.

blocks|key|829977|text|另一种方法(更多的单词，更少的代码)可能会有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829978|局部极大值和极小值的位置也是一阶导数过零点的位置。通常，找到零交叉比直接找到局部最大值和最小值容易得多。|829979|不幸的是，一阶导数往往会“放大”噪声，所以当原始数据中存在显著的噪声时，只有在原始数据应用了一定程度的平滑之后，才能使用一阶导数。|829980|由于平滑在最简单的意义上是低通滤波器，因此平滑通常最好(好吧，最容易)通过使用卷积核来完成，并且该核可以提供惊人数量的特征保留/增强能力。寻找最优内核的过程可以使用各种方法自动化，但最好的方法可能是简单的蛮力(对于寻找小内核来说已经足够快了)。一个好的内核将(如预期的那样)极大地扭曲原始数据，但它不会影响感兴趣的峰/谷的位置。|829981|幸运的是，通常可以通过一个简单的包(“有根据的猜测”)来创建一个合适的内核。平滑核的宽度应该比原始数据中最宽的预期“有趣”峰值稍宽一点，其形状将类似于该峰值(单尺度小波)。对于保持均值的核(任何好的平滑滤波器都应该是这样)，核元素的和应该精确等于1.00，并且核应该围绕其中心对称(这意味着它将具有奇数个元素。|829982|给定一个最优平滑核(或针对不同数据内容优化的少量核)，平滑程度将成为卷积核(“增益”)的缩放因子。|829983|确定“正确的”(最佳)平滑度(卷积核增益)甚至可以自动进行:将一阶导数数据的标准偏差与平滑数据的标准偏差进行比较。两个标准差的比值如何随平滑度的变化而变化，可以用来预测有效平滑值。一些手动数据运行(真正具有代表性)应该是所需的全部。|829984|上面发布的所有先前的解决方案都计算了一阶导数，但它们没有将其视为统计度量，也没有尝试执行特征保留/增强平滑(以帮助微妙的峰值“跳过”噪声)。|829985|最后，坏消息是:当噪声也具有看起来像真实峰值的特征(重叠带宽)时，寻找“真正的”峰值就成了一件苦差事。下一个更复杂的解决方案通常是使用更长的卷积核(“更宽的核孔径”)，它考虑了相邻的“真实”峰值之间的关系(例如峰值出现的最小或最大速率)，或者使用具有不同宽度的核的多个卷积通道(但只有在其更快的情况下:这是一个基本的数学事实，即按顺序执行的线性卷积总是可以被卷积到单个卷积中)。但是，首先找到一系列有用的内核(宽度不同)并将它们卷积在一起，通常比直接在单个步骤中找到最终内核要容易得多。|829986|希望这能提供足够的信息，让Google+(也许还有一个很好的统计文本)来填补这个空白。我真希望我有时间提供一个有效的例子，或者一个链接。如果任何人在网上遇到一个，请在这里张贴！|829987|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|11|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|12|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|13|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|14|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|U|$]]

Another approach (more words, less code) that may help:

The locations of local maxima and minima are also the locations of the zero crossings of the first derivative. It is generally much easier to find zero crossings than it is to directly find local maxima and minima.

Unfortunately, the first derivative tends to "amplify" noise, so when significant noise is present in the original data, the first derivative is best used only after the original data has had some degree of smoothing applied.

Since smoothing is, in the simplest sense, a low pass filter, the smoothing is often best (well, most easily) done by using a convolution kernel, and "shaping" that kernel can provide a surprising amount of feature-preserving/enhancing capability. The process of finding an optimal kernel can be automated using a variety of means, but the best may be simple brute force (plenty fast for finding small kernels). A good kernel will (as intended) massively distort the original data, but it will NOT affect the location of the peaks/valleys of interest.

Fortunately, quite often a suitable kernel can be created via a simple SWAG ("educated guess"). The width of the smoothing kernel should be a little wider than the widest expected "interesting" peak in the original data, and its shape will resemble that peak (a single-scaled wavelet). For mean-preserving kernels (what any good smoothing filter should be) the sum of the kernel elements should be precisely equal to 1.00, and the kernel should be symmetric about its center (meaning it will have an odd number of elements.

Given an optimal smoothing kernel (or a small number of kernels optimized for different data content), the degree of smoothing becomes a scaling factor for (the "gain" of) the convolution kernel.

Determining the "correct" (optimal) degree of smoothing (convolution kernel gain) can even be automated: Compare the standard deviation of the first derivative data with the standard deviation of the smoothed data. How the ratio of the two standard deviations changes with changes in the degree of smoothing cam be used to predict effective smoothing values. A few manual data runs (that are truly representative) should be all that's needed.

All the prior solutions posted above compute the first derivative, but they don't treat it as a statistical measure, nor do the above solutions attempt to performing feature preserving/enhancing smoothing (to help subtle peaks "leap above" the noise).

Finally, the bad news: Finding "real" peaks becomes a royal pain when the noise also has features that look like real peaks (overlapping bandwidth). The next more-complex solution is generally to use a longer convolution kernel (a "wider kernel aperture") that takes into account the relationship between adjacent "real" peaks (such as minimum or maximum rates for peak occurrence), or to use multiple convolution passes using kernels having different widths (but only if it is faster: it is a fundamental mathematical truth that linear convolutions performed in sequence can always be convolved together into a single convolution). But it is often far easier to first find a sequence of useful kernels (of varying widths) and convolve them together than it is to directly find the final kernel in a single step.

Hopefully this provides enough info to let Google (and perhaps a good stats text) fill in the gaps. I really wish I had the time to provide a worked example, or a link to one. If anyone comes across one online, please post it here!

blocks|key|1044905|text|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%2B1]+>=+y[i]:
++++++++++++i%2B=1

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

++++++++i%2B=1

++++if+i+<+length+-+1:
++++++++while+i+<+length-1+and+y[i%2B1]+<=+y[i]:
++++++++++++i%2B=1

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


print+minm
print+maxm|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1044906|minm和maxm分别包含最小值和最大值的索引。对于一个巨大的数据集，它会给出大量的最大值/最小值，因此在这种情况下，首先平滑曲线，然后应用此算法。|unstyled|offset|length|style|CODE|1044907|entityMap^0|0|0|4|5|4|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|S|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>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 &lt; length-1:
 if i &lt; length - 1:
 while i &lt; length-1 and y[i+1] &gt;= y[i]:
 i+=1

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

 i+=1

 if i &lt; length - 1:
 while i &lt; length-1 and y[i+1] &lt;= y[i]:
 i+=1

 if i &lt; length-1:
 minm = np.append(minm,i)
 i+=1


print minm
print maxm
</code></pre>

<code>minm</code> and <code>maxm</code> contain indices of minima and maxima, respectively. For a huge data set, it will give lots of maximas/minimas so in that case smooth the curve first and then apply this algorithm.

blocks|key|830060|text|为什么不使用Scipy内置函数signal.find_peaks_cwt来完成这项工作呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|830061|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]|code-block|syntax|javascript|830062|结果：|830063|maxima+[+0.9995736]
minima+[+0.09146464]|830064|问候|830065|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/scipy-0.19.1/reference/generated/scipy.signal.find_peaks_cwt.html^0|F|L|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Why not use Scipy built-in function <a href="https://docs.scipy.org/doc/scipy-0.19.1/reference/generated/scipy.signal.find_peaks_cwt.html" rel="nofollow noreferrer">signal.find_peaks_cwt</a> to do the job ?

<pre><code>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]
</code></pre>

results:

<pre><code>maxima [ 0.9995736]
minima [ 0.09146464]
</code></pre>

Regards

blocks|key|1045035|text|这些解决方案对我都不起作用，因为我也想在重复值的中心找到峰值。例如，在|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1045036|ar+=+np.array([0,1,2,2,2,1,3,3,3,2,5,0])|offset|length|style|CODE|1045037|答案应该是|1045038|array([+3,++7,+10],+dtype=int64)|code-block|syntax|javascript|1045039|我使用一个循环完成了这项工作。我知道它不是很干净，但它能完成工作。|1045040|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+%2B=+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+%2B+np.floor(abs(i-j)/2)
++++++++++++++++maxInd[peakInd.astype(int)]+=+1
++++++++++++++++i+=+j
++++++++++++++++break
++++peakVar+=+ar[i]
maxInd+=+np.where(maxInd)[0]
return+maxInd+|1045041|entityMap^0|0|0|14|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

None of these solutions worked for me since I wanted to find peaks in the center of repeating values as well. for example, in 

<code>ar = np.array([0,1,2,2,2,1,3,3,3,2,5,0])</code>

the answer should be

<pre><code>array([ 3, 7, 10], dtype=int64)
</code></pre>

I did this using a loop. I know it's not super clean, but it gets the job done.

<pre><code>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 &lt; len(ar)-1:
#for i in range(len(ar)):
 i += 1
 if peakVar &lt; ar[i]:
 peakVar = ar[i]
 for j in range(i,len(ar)):
 if peakVar &lt; ar[j]:
 break
 elif peakVar == ar[j]:
 continue
 elif peakVar &gt; 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 
</code></pre>

blocks|key|830210|text|我相信在numpy+(一个一行程序)中有一种更简单的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|830211|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])|code-block|syntax|javascript|830212|为了找到局部最大值或最小值，我们本质上是想找出列表中的值之间的差异(3-1，9-3...)从正到负(max)或从负到正(min)。因此，我们首先找出不同之处。然后我们找到符号，然后我们通过再次求差找到符号中的变化。(有点像微积分中的一阶和二阶导数，只是我们有离散的数据，没有连续的函数。)|830213|我的示例中的输出不包含极值(列表中的第一个和最后一个值)。同样，就像微积分一样，如果二阶导数是负的，你就有max，如果它是正的，你就有一个min。|830214|因此，我们有以下匹配：|830215|[1,++3,++9,++5,++2,++5,++6,++9,++7]
++++[0,+-2,++0,++2,++0,++0,+-2]
++++++++Max+++++Min+++++++++Max|830216|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I believe there is a much simpler approach in numpy (a one liner).
<pre><code>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])
</code></pre>
To find a local max or min we essentially want to find when the difference between the values in the list (3-1, 9-3...) changes from positive to negative (max) or negative to positive (min). Therefore, first we find the difference. Then we find the sign, and then we find the changes in sign by taking the difference again. (Sort of like a first and second derivative in calculus, only we have discrete data and don't have a continuous function.)
The output in my example does not contain the extrema (the first and last values in the list). Also, just like calculus, if the second derivative is negative, you have max, and if it is positive you have a min.
Thus we have the following matchup:
<pre><code>[1, 3, 9, 5, 2, 5, 6, 9, 7]
 [0, -2, 0, 2, 0, 0, -2]
 Max Min Max
</code></pre>

blocks|key|1045262|text|从SciPy版本1.1开始，您还可以使用find_peaks。下面是取自文档本身的两个示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1045263|使用height参数，可以选择超过某个阈值的所有最大值(在本例中，选择所有非负最大值；如果必须处理噪声基线，这将非常有用；如果您想找到最小值，只需将您的输入乘以-1)：|style|CODE|1045264|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()|code-block|syntax|javascript|1045265|​|1045266|📷|atomic|1045267|1045268|另一个非常有用的参数是distance，它定义了两个峰之间的最小距离：|1045269|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()|1045270|1045271|1045272|1045273|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.find_peaks.html|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/921d3bceb7dd58c5a026649d8c7a6114.png|imageAlt|2|https://ask.qcloudimg.com/http-save/yehe-900000/8f37555b2cba90b20252cadcb2f91a14.png^0|K|A|0|0|2|6|28|2|0|0|0|0|1|1|0|0|B|8|0|0|0|0|1|2|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]]|C|$]]|$1|D|3|E|5|6|7|1J|8|@$A|1K|B|1L|F|G]|$A|1M|B|1N|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1O|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1P|8|@]|9|@]|C|$]]|$1|O|3|P|5|Q|7|1Q|8|@]|9|@$A|1R|B|1S|1|1T]]|C|$]]|$1|R|3|N|5|6|7|1U|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1V|8|@$A|1W|B|1X|F|G]]|9|@]|C|$]]|$1|U|3|V|5|J|7|1Y|8|@]|9|@]|C|$K|L]]|$1|W|3|N|5|6|7|1Z|8|@]|9|@]|C|$]]|$1|X|3|P|5|Q|7|20|8|@]|9|@$A|21|B|22|1|23]]|C|$]]|$1|Y|3|N|5|6|7|24|8|@]|9|@]|C|$]]|$1|Z|3|-4|5|6|7|25|8|@]|9|@]|C|$]]]|10|$11|$5|12|13|14|C|$15|16]]|17|$5|18|13|19|C|$1A|1B|1C|-4]]|1D|$5|18|13|19|C|$1A|1E|1C|-4]]]]

As of SciPy version 1.1, you can also use <a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.find_peaks.html" rel="noreferrer">find_peaks</a>. Below are two examples taken from the documentation itself.

Using the <code>height</code> argument, one can select all maxima above a certain threshold (in this example, all non-negative maxima; this can be very useful if one has to deal with a noisy baseline; if you want to find minima, just multiply you input by <code>-1</code>):

<pre><code>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()
</code></pre>

<a href="https://i.stack.imgur.com/2bmeW.png" rel="noreferrer"><img src="https://i.stack.imgur.com/2bmeW.png" alt="enter image description here"></a>

Another extremely helpful argument is <code>distance</code>, which defines the minimum distance between two peaks:

<pre><code>peaks, _ = find_peaks(x, distance=150)
# difference between peaks is &gt;= 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()
</code></pre>

<a href="https://i.stack.imgur.com/U8HBD.png" rel="noreferrer"><img src="https://i.stack.imgur.com/U8HBD.png" alt="enter image description here"></a>

blocks|key|1045280|text|另一个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1045281|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|code-block|syntax|javascript|1045282|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another one:
<pre><code>def local_maxima_mask(vec):
 &quot;&quot;&quot;
 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. 
 &quot;&quot;&quot;
 mask = np.zeros(vec.shape, dtype=np.bool)
 greater_than_the_last = np.diff(vec)&gt;0 # N-1
 mask[1:] = greater_than_the_last
 mask[:-1] &amp;= ~greater_than_the_last
 return mask
</code></pre>

blocks|key|830448|text|另一种解决方案本质上是使用扩张运算符：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|830449|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|code-block|syntax|javascript|830450|对于最小值：|830451|def+find_local_minima(x):
+++x_erode+=+rank_filter(x,+-0,+size=3)
+++return+x_erode+==+x|830452|此外，在scipy.ndimage中，可以将rank_filter(x,+-1,+size=3)替换为grey_dilation，将rank_filter(x,+0,+size=3)替换为grey_erosion。这不需要本地排序，所以它稍微快一些。|offset|length|style|CODE|830453|entityMap^0|0|0|0|0|4|D|M|Q|1F|D|1U|P|2M|C|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]|$M|11|N|12|O|P]|$M|13|N|14|O|P]|$M|15|N|16|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$]]

Another solution using essentially a dilate operator:

<pre><code>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

</code></pre>

and for the minima:

<pre><code>def find_local_minima(x):
 x_erode = rank_filter(x, -0, size=3)
 return x_erode == x

</code></pre>

Also, from <code>scipy.ndimage</code> you can replace <code>rank_filter(x, -1, size=3)</code> with <code>grey_dilation</code> and <code>rank_filter(x, 0, size=3)</code> with <code>grey_erosion</code>. This won't require a local sort, so it is slightly faster.

Can you suggest a module function from numpy/scipy that can find local maxima/minima in a 1D numpy array? Obviously the simplest approach ever is to have a look at the nearest neighbours, but I would like to have an accepted solution that is part of the numpy distro.

Finding local maxima/minima with Numpy in a 1D numpy array

你能推荐一个能在一维numpy数组中找到局部最大值/最小值的numpy/scipy中的模块函数吗？显然，最简单的方法是看看最近的邻居，但我希望有一个可以接受的解决方案，这是numpy发行版的一部分。

问在1Dnumpy数组中寻找具有Numpy的局部最大值/最小值
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在1Dnumpy数组中寻找具有Numpy的局部最大值/最小值EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在1Dnumpy数组中寻找具有Numpy的局部最大值/最小值
EN