计算时间序列设定点跟踪的运行性能分数

Question

假设我有一个 pandas 数据框，其中包含设定点 (SP) 的时间序列数据和实际输出，以及两个包含设定点增量（与上一个时间步相比的变化）和误差（设定点 - 输出）的计算列。

     Setpoint    Output    SP Delta    Error
t0      10         10         0          0
t1      10         10         0          0
t2      20         10        10         10
t3      20         17         0          3
t4      20         19         0          1
t5      20         20         0          0
t6      25         20         5          5
t7      25         24         0          1
t8      10         25        -15        15
t9      10         14         0          4
t10     10         11         0          1

我想根据一些标准计算跑步表现得分（每个间隔）：

1. 分数范围为 0（差）到 1（完美）。

2. 在发生设定点变化的时间间隔内不评估分数（在发生设定点变化时假设瞬时输出响应是不合理的）。

3. 分数应受以下因素影响：

   3a。误差大小

   3b。达到新设定点所需的时间

实际上，设定点更改后，性能分数应下降至 <1 and then increase back to 1 as the setpoint is achieved. The "size" and "shape" of the dip should depend on both the magnitude of error and the length of time error is non-zero. The output should look something like this (filled with arbitrary score numbers):

     Setpoint    Output    SP Delta    Error    Score
t0      10         10         0          0       1.0
t1      10         10         0          0       1.0
t2      20         10        10         10       NaN
t3      20         17         0          3       0.7
t4      20         19         0          1       0.9
t5      20         20         0          0       1.0
t6      25         20         5          5       NaN
t7      25         24         0          1       0.9
t8      10         25        -15        15       NaN
t9      10         14         0          4       0.7
t10     10         11         0          1       0.9

我目前正在做的是计算每个事件的单个分数（而不是我更喜欢的不断变化的分数）。该代码将迭代时间序列，每当发生设定值更改时，都会发生嵌套迭代来收集该事件的所有错误值并生成错误百分比（事件错误/总可能错误），然后将其转换达到（0-1 界限）分数：

    error_lim = 0.1
    error_max = 25
    time_range = df.index.tolist()
    
    for i_iter, t_iter in enumerate(time_range):
        delta = df.at[t_iter, 'SP Delta']
        error = df.at[t_iter, 'Error']

        if error < error_lim:
            score_norm = 1
        elif delta != 0:
            error_list = []

            for ii_iter, tt_iter in enumerate(time_range[i_iter:]):
                delta_next = df.at[time_range[i_iter+1], 'SP Delta']
                error_ii = df.at[tt_iter, 'Error']

                if error_ii > error_lim and delta_next == 0:
                    error_list.append(error_ii)
                else:
                    break

            if len(error_list) == 0:
                error_perc = 0
            else:
                error_perc = sum(error_list) / (error_max * len(error_list))

            score_norm  = 1 - round(min(1, max(error_perc, 0)), 3)

        df.at[t_iter, 'Score'] = score_norm

Answer 1

尽管我在评论中有所保留，但这里有一种可能性。

# Assume maximum error is delta between current and previous Setpoint
df['MaxErr'] = df['SP Delta'].replace(0, np.nan).ffill().fillna(1)
# Where Setpoint is stable, calculate a score, normalized by this maximum error
df['Score_Abs'] = np.where(df['SP Delta'] == 0,
                           1 - abs(df['Error']/df['MaxErr']),
                           np.nan)

输出：（四舍五入至小数点后两位）

    Setpoint  Output  SP Delta  Error  Score_OP  MaxErr  Score_Abs
0         10      10         0      0       1.0     1.0       1.00
1         10      10         0      0       1.0     1.0       1.00
2         20      10        10     10       NaN    10.0        NaN
3         20      17         0      3       0.7    10.0       0.70
4         20      19         0      1       0.9    10.0       0.90
5         20      20         0      0       1.0    10.0       1.00
6         25      20         5      5       NaN     5.0        NaN
7         25      24         0      1       0.9     5.0       0.80
8         10      25       -15     15       NaN   -15.0        NaN
9         10      14         0      4       0.7   -15.0       0.73
10        10      11         0      1       0.9   -15.0       0.93

其中

'Score_OP'

是您提供的指示性分数。

该提案不允许自己及时展望，您似乎对此表示同意，但从工程角度来看却令人不安。