blocks|key|844216|text|我还没有测试过这个，但你应该接近你正在寻找的东西。代码行数稍多，但应该更高效、更具可读性，而且不会滥用正则表达式:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|844217|def+find_silent(samples):
++++num_silent+=+0
++++start+=+0
++++for+index+in+range(0,+len(samples)):
++++++++if+abs(samples[index])+<+SILENCE_THRESHOLD:
++++++++++++if+num_silent+==+0:
++++++++++++++++start+=+index
++++++++++++num_silent+%2B=+1
++++++++else:
++++++++++++if+num_silent+>+MIN_SILENCE:
++++++++++++++++yield+samples[start:index]
++++++++++++num_silent+=+0
++++if+num_silent+>+MIN_SILENCE:
++++++++yield+samples[start:]

for+match+in+find_silent(samples):
++++#+code+goes+here|code-block|syntax|javascript|844218|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|$]]

I haven't tested this but you it should be close to what you are looking for. Slightly more lines of code but should be more efficient, readable, and it doesn't abuse regular expressions :-)

<pre><code>def find_silent(samples):
 num_silent = 0
 start = 0
 for index in range(0, len(samples)):
 if abs(samples[index]) &lt; SILENCE_THRESHOLD:
 if num_silent == 0:
 start = index
 num_silent += 1
 else:
 if num_silent &gt; MIN_SILENCE:
 yield samples[start:index]
 num_silent = 0
 if num_silent &gt; MIN_SILENCE:
 yield samples[start:]

for match in find_silent(samples):
 # code goes here
</code></pre>

blocks|key|844239|text|这将返回(start,length)对的列表：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|844240|def+silent_segs(samples,threshold,min_dur):
++start+=+-1
++silent_segments+=+[]
++for+idx,x+in+enumerate(samples):
++++if+start+<+0+and+abs(x)+<+threshold:
++++++start+=+idx
++++elif+start+>=+0+and+abs(x)+>=+threshold:
++++++dur+=+idx-start
++++++if+dur+>=+min_dur:
++++++++silent_segments.append((start,dur))
++++++start+=+-1
++return+silent_segments|code-block|syntax|javascript|844241|一个简单的测试：|844242|>>>+s+=+[-1,0,0,0,-1,10,-10,1,2,1,0,0,0,-1,-10]
>>>+silent_segs(s,2,2)
[(0,+5),+(9,+5)]|844243|entityMap^0|4|E|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

This should return a list of <code>(start,length)</code> pairs:

<pre><code>def silent_segs(samples,threshold,min_dur):
 start = -1
 silent_segments = []
 for idx,x in enumerate(samples):
 if start &lt; 0 and abs(x) &lt; threshold:
 start = idx
 elif start &gt;= 0 and abs(x) &gt;= threshold:
 dur = idx-start
 if dur &gt;= min_dur:
 silent_segments.append((start,dur))
 start = -1
 return silent_segments
</code></pre>

And a simple test:

<pre><code>&gt;&gt;&gt; s = [-1,0,0,0,-1,10,-10,1,2,1,0,0,0,-1,-10]
&gt;&gt;&gt; silent_segs(s,2,2)
[(0, 5), (9, 5)]
</code></pre>

blocks|key|844343|text|如果您不介意使用scipy，请稍显马虎，但简单且快速：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|844344|from+scipy.ndimage+import+gaussian_filter
sigma+=+3
threshold+=+1
above_threshold+=+gaussian_filter(data,+sigma=sigma)+>+threshold|code-block|syntax|javascript|844345|这个想法是，数据的安静部分将平滑到低振幅，而响亮的区域则不会。调整“sigma”将影响“安静”区域必须有多长时间；调整“阈值”将影响它必须有多安静。对于较大的sigma，这会减慢速度，此时使用基于FFT的平滑可能会更快。|844346|这还有一个额外的好处，那就是单一的“热点像素”不会扰乱你的静音搜索，所以你对某些类型的噪音不那么敏感。|844347|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Slightly sloppy, but simple and fast-ish, if you don't mind using scipy:

<pre><code>from scipy.ndimage import gaussian_filter
sigma = 3
threshold = 1
above_threshold = gaussian_filter(data, sigma=sigma) &gt; threshold
</code></pre>

The idea is that quiet portions of the data will smooth down to low amplitude, and loud regions won't. Tune 'sigma' to affect how long a 'quiet' region must be; tune 'threshold' to affect how quiet it must be. This slows down for large sigma, at which point using FFT-based smoothing might be faster.

This has the added benefit that single 'hot pixels' won't disrupt your silence-finding, so you're a little less sensitive to certain types of noise.

blocks|key|1058869|text|这里有一个基于numpy的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1058870|我认为(?)它应该比其他选项更快。希望这是相当清楚的。|1058871|但是，它需要的内存是各种基于生成器的解决方案的两倍。只要您可以在内存中保存数据的一个临时副本(对于diff)，以及与您的数据长度相同的布尔数组(每个元素1位)，它应该是非常有效的……|1058872|import+numpy+as+np

def+main():
++++#+Generate+some+random+data
++++x+=+np.cumsum(np.random.random(1000)+-+0.5)
++++condition+=+np.abs(x)+<+1
++++
++++#+Print+the+start+and+stop+indices+of+each+region+where+the+absolute+
++++#+values+of+x+are+below+1,+and+the+min+and+max+of+each+of+these+regions
++++for+start,+stop+in+contiguous_regions(condition):
++++++++segment+=+x[start:stop]
++++++++print+start,+stop
++++++++print+segment.min(),+segment.max()

def+contiguous_regions(condition):
++++"""Finds+contiguous+True+regions+of+the+boolean+array+"condition".+Returns
++++a+2D+array+where+the+first+column+is+the+start+index+of+the+region+and+the
++++second+column+is+the+end+index."""

++++#+Find+the+indicies+of+changes+in+"condition"
++++d+=+np.diff(condition)
++++idx,+=+d.nonzero()+

++++#+We+need+to+start+things+after+the+change+in+"condition".+Therefore,+
++++#+we'll+shift+the+index+by+1+to+the+right.
++++idx+%2B=+1

++++if+condition[0]:
++++++++#+If+the+start+of+condition+is+True+prepend+a+0
++++++++idx+=+np.r_[0,+idx]

++++if+condition[-1]:
++++++++#+If+the+end+of+condition+is+True,+append+the+length+of+the+array
++++++++idx+=+np.r_[idx,+condition.size]+#+Edit

++++#+Reshape+the+result+into+two+columns
++++idx.shape+=+(-1,2)
++++return+idx

main()|code-block|syntax|javascript|1058873|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's a numpy-based solution.
I think (?) it should be faster than the other options. Hopefully it's fairly clear.
However, it does require a twice as much memory as the various generator-based solutions. As long as you can hold a single temporary copy of your data in memory (for the diff), and a boolean array of the same length as your data (1-bit-per-element), it should be pretty efficient...
<pre><code>import numpy as np

def main():
 # Generate some random data
 x = np.cumsum(np.random.random(1000) - 0.5)
 condition = np.abs(x) &lt; 1
 
 # Print the start and stop indices of each region where the absolute 
 # values of x are below 1, and the min and max of each of these regions
 for start, stop in contiguous_regions(condition):
 segment = x[start:stop]
 print start, stop
 print segment.min(), segment.max()

def contiguous_regions(condition):
 &quot;&quot;&quot;Finds contiguous True regions of the boolean array &quot;condition&quot;. Returns
 a 2D array where the first column is the start index of the region and the
 second column is the end index.&quot;&quot;&quot;

 # Find the indicies of changes in &quot;condition&quot;
 d = np.diff(condition)
 idx, = d.nonzero() 

 # We need to start things after the change in &quot;condition&quot;. Therefore, 
 # we'll shift the index by 1 to the right.
 idx += 1

 if condition[0]:
 # If the start of condition is True prepend a 0
 idx = np.r_[0, idx]

 if condition[-1]:
 # If the end of condition is True, append the length of the array
 idx = np.r_[idx, condition.size] # Edit

 # Reshape the result into two columns
 idx.shape = (-1,2)
 return idx

main()
</code></pre>

blocks|key|1058925|text|另一种快速而简洁的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1058926|import+pylab+as+pl

v=[0,0,1,1,0,0,1,1,1,1,1,0,1,0,1,1,0,0,0,0,0,1,0,0]
vd+=+pl.diff(v)
#vd[i]==1+for+0->1+crossing;+vd[i]==-1+for+1->0+crossing
#need+to+add+%2B1+to+indexes+as+pl.diff+shifts+to+left+by+1

i1=pl.array([i+for+i+in+xrange(len(vd))+if+vd[i]==1])%2B1
i2=pl.array([i+for+i+in+xrange(len(vd))+if+vd[i]==-1])%2B1

#corner+cases+for+the+first+and+the+last+element
if+v[0]==1:
++i1=pl.hstack((0,i1))
if+v[-1]==1:
++i2=pl.hstack((i2,len(v)))|code-block|syntax|javascript|1058927|现在i1包含起始索引，i2包含结束索引1，...,1区域|1058928|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

another way to do this quickly and concisely:

<pre><code>import pylab as pl

v=[0,0,1,1,0,0,1,1,1,1,1,0,1,0,1,1,0,0,0,0,0,1,0,0]
vd = pl.diff(v)
#vd[i]==1 for 0-&gt;1 crossing; vd[i]==-1 for 1-&gt;0 crossing
#need to add +1 to indexes as pl.diff shifts to left by 1

i1=pl.array([i for i in xrange(len(vd)) if vd[i]==1])+1
i2=pl.array([i for i in xrange(len(vd)) if vd[i]==-1])+1

#corner cases for the first and the last element
if v[0]==1:
 i1=pl.hstack((0,i1))
if v[-1]==1:
 i2=pl.hstack((i2,len(v)))
</code></pre>

now i1 contains the beginning index and i2 the end index of 1,...,1 areas

blocks|key|1058968|text|有一个使用scipy.ndimage的非常方便的解决方案。对于数组：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1058969|a+=+np.array([1,+1,+1,+1,+0,+0,+0,+1,+1,+1,+0])|code-block|syntax|javascript|1058970|这可能是应用于另一个数组的条件的结果，查找连续区域就像下面这样简单：|1058971|regions+=+scipy.ndimage.find_objects(scipy.ndimage.label(a)[0])|1058972|然后，可以对这些区域应用任何函数，例如：|1058973|[np.sum(a[r])+for+r+in+regions]|1058974|entityMap^0|5|D|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

There is a very convenient solution to this using <code>scipy.ndimage</code>. For an array:
<pre><code>a = np.array([1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0])
</code></pre>
which can be the result of a condition applied to another array, finding the contiguous regions is as simple as:
<pre><code>regions = scipy.ndimage.find_objects(scipy.ndimage.label(a)[0])
</code></pre>
Then, applying any function to those regions can be done e.g. like:
<pre><code>[np.sum(a[r]) for r in regions]
</code></pre>

blocks|key|1059009|text|@joe-kington我使用argmax比np.diff+/+np.nonzero解决方案的速度提高了20%25-25%25+(参见下面的代码，condition是布尔型的)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1059010|def+contiguous_regions(condition):
++++idx+=+[]
++++i+=+0
++++while+i+<+len(condition):
++++++++x1+=+i+%2B+condition[i:].argmax()
++++++++try:
++++++++++++x2+=+x1+%2B+condition[x1:].argmin()
++++++++except:
++++++++++++x2+=+x1+%2B+1
++++++++if+x1+==+x2:
++++++++++++if+condition[x1]+==+True:
++++++++++++++++x2+=+len(condition)
++++++++++++else:
++++++++++++++++break
++++++++idx.append(+[x1,x2]+)
++++++++i+=+x2
++++return+idx|code-block|syntax|javascript|1059011|当然，根据您的数据，您的里程可能会有所不同。|1059012|此外，我不完全确定，但我猜True/False可能会优化布尔数组上的argmin/argmax，以便在第一次出现numpy时停止搜索。这也许能解释这一切。|1059013|entityMap^0|F|6|M|K|1X|9|0|0|0|D|A|Y|D|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

@joe-kington I've got about 20%-25% speed improvement over <code>np.diff / np.nonzero</code> solution by using <code>argmax</code> instead (see code below, <code>condition</code> is boolean)

<pre><code>def contiguous_regions(condition):
 idx = []
 i = 0
 while i &lt; len(condition):
 x1 = i + condition[i:].argmax()
 try:
 x2 = x1 + condition[x1:].argmin()
 except:
 x2 = x1 + 1
 if x1 == x2:
 if condition[x1] == True:
 x2 = len(condition)
 else:
 break
 idx.append( [x1,x2] )
 i = x2
 return idx
</code></pre>

Of course, your mileage may vary depending on your data.

Besides, I'm not entirely sure, but i guess numpy may optimize <code>argmin/argmax</code> over boolean arrays to stop searching on first <code>True/False</code> occurrence. That might explain it.

blocks|key|844541|text|我知道我来晚了，但另一种方法是1d卷积：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|844542|np.convolve(sig+>+threshold,+np.ones((cons_samples)),+'same')+==+cons_samples|code-block|syntax|javascript|844543|其中cons_samples是超过阈值所需的连续样本数|offset|length|style|CODE|844544|entityMap^0|0|0|2|C|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]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I know I'm late to the party, but another way to do this is with 1d convolutions:

<pre><code>np.convolve(sig &gt; threshold, np.ones((cons_samples)), 'same') == cons_samples
</code></pre>

Where <code>cons_samples</code> is the number of consecutive samples you require above threshold

I have some audio data loaded in a numpy array and I wish to segment the data by finding silent parts, i.e. parts where the audio amplitude is below a certain threshold over a a period in time.

An extremely simple way to do this is something like this:

<pre><code>values = ''.join(("1" if (abs(x) &lt; SILENCE_THRESHOLD) else "0" for x in samples))
pattern = re.compile('1{%d,}'%int(MIN_SILENCE)) 
for match in pattern.finditer(values):
 # code goes here
</code></pre>

The code above finds parts where there are at least MIN_SILENCE consecutive elements smaller than SILENCE_THRESHOLD.

Now, obviously, the above code is horribly inefficient and a terrible abuse of regular expressions. Is there some other method that is more efficient, but still results in equally simple and short code?

Find large number of consecutive values fulfilling condition in a numpy array

我有一些加载到numpy数组中的音频数据，我希望通过查找静默部分来分割数据，即音频幅度在一段时间内低于某个阈值的部分。一种非常简单的方法是这样的：values = ''.join(("1" if (abs(x) < SILENCE_THRESHOLD) else "0" for x in samples))patter...

问在numpy数组中查找满足条件的大量连续值
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在numpy数组中查找满足条件的大量连续值EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在numpy数组中查找满足条件的大量连续值
EN