使用python将时间范围扩展为具有精确标签的更小增量的更多步骤

Question

我有一个带有时间戳和标签的文本文件，如下所示：

0.000000    14.463912   tone
14.476425   16.891247   noise
16.891247   21.232923   not_music
21.232923   23.172289   not_music
23.172289   29.128018   not_music

如果我指定1秒的步长。我希望这个列表爆炸成1秒长的时间帧，但仍然带有最近的标签。我如何将时间范围分解成更小的步骤，但有准确的标签？

例如，如果我的步长为1秒，则第一行将变为~14行，如：

0.0 1.0 tone
1.0 2.0 tone 
.  
.  
.
13.0 14.0 tone 
[14.0 , 14.46] and [14.47, 15.0] #fall in a grey zone , don't know 
what to do
15.0 16.0 noise

到目前为止，我已设法读入文本文件并将其存储在如下列表中：

my_segments =[]
for line in open('./data/annotate.txt', 'rb').readlines():
            start, end, label = line.split("\t")
            start = float(start)
            end = float(end)
            label = label.strip()
            my_segments.append((start, end, label))

# print my_segments
for i in range(len(my_segments)):
    print my_segments[i]

我看着https://stackoverflow.com/a/18265979/4932791由@Jared编写，详细介绍了如何使用numpy在给定步长的两个数字之间创建一个范围。像这样：

>>> numpy.arange(11, 17, 0.5)
array([ 11. ,  11.5,  12. ,  12.5,  13. ,  13.5,  14. ,  14.5,  15. ,
        15.5,  16. ,  16.5])

无法找出如何在一系列范围内执行类似操作。

我设法想出的伪代码/算法是：

• 步骤1-采取步长，
• 步骤2-将步长分配给left_variable和与步长相对应的right_variable
  步骤3-在每个范围内移动这个类似步长的窗口，并检查步长是否在范围内相应的标签。
• 步骤4-现在更新左右1步。
• 步骤5-重复步骤3直到文件结束。

我认为要处理边缘情况，我应该将步长减小到0.25秒或类似的时间，并设置一个条件，如果当前步长至少有40%或50%的重叠，那么我会相应地分配标签。

更新：我的非工作解决方案：

sliding_window = 0
#st,en = [0.0,1.0]
jumbo= []
for i in range(len(hold_segments)):
    if sliding_window > hold_segments[i][0] and sliding_window+1 < hold_segments[i][1]:
        jumbo.append((sliding_window,sliding_window+1,hold_segments[i][2]))
        sliding_window=sliding_window+1
        print hold_segments[i][2]

Answer 1

我希望通过这些评论可以清楚地了解代码的作用。也适用于非整数步长

from __future__ import division
import numpy as np

my_segments = [
    (0, 14.46, "ringtone"),
    (14.46, 16.89, "noise"),
    (16.89, 21.23, "not_music"),
]


def expand(segments, stepsize):
    result = []
    levels = [x[0] for x in segments] + [segments[-1][1]] #0, 14.46, 16.89, 21.23
    i = 0   # tracks the index in segments that we need at the current step
    for step in np.arange(0, levels[-1], stepsize):

        # first check if the index needs to be updated
        # update when the next level will be reached at the next 'stepsize / 2'
        # (this effectively rounds to the nearest level)
        if i < len(levels) - 2 and (step + stepsize / 2) > levels[i+1]:
            i += 1

        # now append the values
        result.append((step, step + stepsize, segments[i][2]))

    return result

stepsize = 0.02
print len(expand(my_segments, stepsize))
print my_segments[-1][1] / stepsize

>>> 1062  # steps are rounded up
>>> 1061.5

Answer 2

对于pandas，这非常简单，假设您已将数据加载到名为df的数据帧中，例如：

df

               value        tag
index
0.000000   14.463912   ringtone
14.476425  16.891247      noise
16.891247  21.232923  not_music
21.232923  23.172289    music_B
23.172289  29.128018    music_A


df = df.reindex(
    [i + 0.5 for i in range(math.floor(df.index.min()), math.ceil(df.value.max()))], 
    method='pad'
)

然后使用以下命令恢复范围：

(df.index, df.value) = (df.index - 0.5, df.index + 0.5)

       value        tag
index
0.0      1.0   ringtone
1.0      2.0   ringtone
2.0      3.0   ringtone
3.0      4.0   ringtone
4.0      5.0   ringtone
5.0      6.0   ringtone
6.0      7.0   ringtone
7.0      8.0   ringtone
8.0      9.0   ringtone
9.0     10.0   ringtone
10.0    11.0   ringtone
11.0    12.0   ringtone
12.0    13.0   ringtone
13.0    14.0   ringtone
14.0    15.0      noise
15.0    16.0      noise
16.0    17.0      noise
17.0    18.0  not_music
18.0    19.0  not_music
19.0    20.0  not_music
20.0    21.0  not_music
21.0    22.0    music_B
22.0    23.0    music_B
23.0    24.0    music_A
24.0    25.0    music_A
25.0    26.0    music_A
26.0    27.0    music_A
27.0    28.0    music_A
28.0    29.0    music_A
29.0    30.0    music_A