시계열 지연 평가

게으른 평가(Lazy evaluation)는 표현식의 값이 필요해질 때까지 그 평가를 미루는 평가 전략입니다. 메모화와 결합될 경우, 지연 평가 전략은 중복된 평가를 방지하여 특정 함수의 실행 시간을 상당히 단축할 수 있습니다.

시계열 라이브러리는 데이터를 처리할 때 지연 평가를 사용합니다. 개념적으로 실행 그래프는 시계열 데이터 위에 구축되며, 그 출력이 구체화될 때만 평가가 실행됩니다. 어떤 물체가 1차원 공간에서 움직이고 있으며, 그 위치는 x(t)로 표현된다고 가정하자. 이 물체의 급격한 가속/제동 (h(t))은 다음과 같이 속도 (v(t))와 가속도 (a(t))의 시계열 데이터를 사용하여 파악할 수 있습니다:

# 1d location timeseries
x(t) = input location timeseries

# velocity - first derivative of x(t)
v(t) = x(t) - x(t-1)

# acceleration - second derivative of x(t)
a(t) = v(t) - v(t-1)

# harsh acceleration/braking using thresholds on acceleration
h(t) = +1 if a(t) > threshold_acceleration
     = -1 if a(t) < threshold_deceleration
     = 0 otherwise

그 결과 다음과 같은 형태의 간단한 실행 그래프가 생성됩니다:

x(t) --> v(t) --> a(t) --> h(t)

평가는 특정 작업이 수행될 때만 실행됩니다. 예를 들어 compute h(5...10), 즉 compute h(5), ..., h(10). 이 라이브러리는 시계열 간의 미묘한 시간적 의존성을 포착합니다. 이 예시에서 는 h(5...10) 를 필요로 하고 a(5...10), 이는 다시 를 필요로 하며 v(4...10), 이는 다시 를 필요로 합니다 x(3...10). , v(t) 및 a(t) 중 관련 x(t) 부분만 계산됩니다.

h(5...10) <-- a(5...10) <-- v(4...10) <-- x(3...10)

또한, 평가 결과는 메모리화되어 있으므로, 이후의 작업에서 재사용할 수 h 있습니다. 예를 들어, 에 대한 요청이 에 h(7...12) 대한 요청에 h(5...10) 이어지면, 메모화된 값 이 h(7...10) 활용될 것입니다. 또한, h(11...12) 는 와 를 a(11...12), v(10...12) 사용하여 x(9...12) 계산되며, 이 과정에서 이전 계산에서 메모화된 x(9...10) 와 가 다시 v(10) 활용될 것입니다.

좀 더 일반적인 예로, 평활화된 속도 시계열을 다음과 같이 정의할 수 있습니다:

# 1d location timeseries
x(t) = input location timeseries

# velocity - first derivative of x(t)
v(t) = x(t) - x(t-1)

# smoothened velocity
# alpha is the smoothing factor
# n is a smoothing history
v_smooth(t) =  (v(t)*1.0 + v(t-1)*alpha + ... + v(t-n)*alpha^n) / (1 + alpha + ... + alpha^n)

# acceleration - second derivative of x(t)
a(t) = v_smooth(t) - v_smooth(t-1)

이 예제에서는 다음과 같은 h(l...u) 시간적 의존성을 가집니다. 메모화를 통해 수행되는 평가는 이러한 시간적 h(l...u) 의존성을 엄격하게 준수할 것입니다.

h(l...u) <-- a(l...u) <-- v_smooth(l-1...u) <-- v(l-n-1...u) <-- x(l-n-2...u)

import tspy
from tspy.builders.functions import transformers

x = tspy.time_series([1.0, 2.0, 4.0, 7.0, 11.0, 16.0, 22.0, 29.0, 28.0, 30.0, 29.0, 30.0, 30.0])
v = x.transform(transformers.difference())
a = v.transform(transformers.difference())
h = a.map(harsh).filter(lambda h: h != 0)

print(h[5, 10])

def harsh(a):
    threshold_acceleration = 2.0
    threshold_braking = -2.0

    if (a > threshold_acceleration):
        return +1
    elif (a < threshold_braking):
        return -1
    else:
        return 0