使用python将数字列表压缩到唯一的不重叠时间范围

Question

我来自生物学，对python和ML非常陌生，实验室有一个blackbox ML模型，输出如下序列：

Predictions =
[1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,0,0,1,1,1,1,1,1,0]  

每个值表示持续时间为0.25秒的预测时间帧。
1表示高。
0表示不高。

如何将这些预测转换为[开始、停止、标签]
以便将更长的序列分组，例如，前10个序列表示0到10*。因此，第一个范围和标签为

[[0.0,2.5， High]
接下来有13个零===

因此，最终列表类似于列表/范围的列表，具有唯一的非重叠间隔以及标签，如：

[[0.0,2.5, High],
[2.5, 5.75, Not-High],
[5.75,6.50, High] ..

我尝试过的：
1.计算预测
中的值数2.生成两个范围，一个从零开始，另一个从0.25开始
3.将这两个列表合并为元组

import numpy as np  
len_pred = len(Predictions) 
range_1 = np.arange(0,len_pred,0.25)
range_2 = np.arange(0.25,len_pred,0.25)
new_range = zip(range_1,range_2)  

在这里，我可以得到范围，但错过了标签<这似乎是个简单的问题，但我在兜圈子。

请告知。谢谢

Answer 1

如果我对你的理解是正确的，我认为这样的事情应该有用。

compact_prediction = list()
sequence = list()  # This will contain each sequence list [start, end, label]

last_prediction = 0

for index, prediction in enumerate(Predictions):
    if index == 0:
        sequence.append(0)  # It's the first sequence, so it will start in zero

    # When we not talking about the prediction we only end the sequence
    # when the last prediction is different from the current one, 
    # signaling a change
    elif prediction != last_prediction:
        sequence.append((index - 1) * 0.25) # We append the end of the sequence

        # And we put the label based on the last prediction
        if last_prediction == 1:  
            sequence.append('High')
        else:
            sequence.append('Not-High')

        # Append to our compact list and reset the sequence
        compact_prediction.append(sequence)
        sequence= list()

        # After reseting the sequence we append the start of the new one
        sequence.append(index * 0.25)

    # Save the last prediction so we can check if it changed
    last_prediction = prediction

print(compact_prediction)

结果：[[0.0,2.25，'High']，[2.5,5.5，'不高']，[5.75,6.25，'High']，[6.5,6.5，'不高']，[6.75,6.75，'High']，[7.0,7.0，'不高']，[7.25,7.25，'High']，[7.5,7.5，'不高']，[7.75,7.75，'High']，[8.0,8.0，'不高']，[8.25,9.25，'High']，[9.5,10.0，'不高']，[10.25, 11.5，'High']]

Answer 2

通过使用diff（）和其中（）您可以找到值更改的所有索引：

import numpy as np

p = np.array([1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,0,0,1,1,1,1,1,1,0])

idx = np.r_[0, np.where(np.diff(p) != 0)[0]+1, len(p)]
t = idx * 0.25

np.c_[t[:-1], t[1:], p[idx[:-1]]]

输出：

array([[  0.  ,   2.5 ,   1.  ],
       [  2.5 ,   5.75,   0.  ],
       [  5.75,   6.5 ,   1.  ],
       [  6.5 ,   6.75,   0.  ],
       [  6.75,   7.  ,   1.  ],
       [  7.  ,   7.25,   0.  ],
       [  7.25,   7.5 ,   1.  ],
       [  7.5 ,   7.75,   0.  ],
       [  7.75,   8.  ,   1.  ],
       [  8.  ,   8.25,   0.  ],
       [  8.25,   9.5 ,   1.  ],
       [  9.5 ,  10.25,   0.  ],
       [ 10.25,  11.75,   1.  ],
       [ 11.75,  12.  ,   0.  ]])

Answer 3

您可以遍历列表并在检测到更改时创建一个范围。使用此方法时，您还需要考虑最终范围。可能不是非常干净，但应该是有效的。

current_time = 0
range_start = 0
current_value = predictions[0]
ranges = []
for p in predictions:
  if p != current_value:
    ranges.append([range_start, current_time, 'high' if current_value == 1 else 'not high'])
    range_start = current_time
    current_value = p
  current_time += .25
ranges.append([range_start, current_time, 'high' if current_value == 1 else 'not high'])

已更新以修复一些由一种类型关闭的错误。