Valutazione lazy di serie temporali

La valutazione laica è una strategia di valutazione che ritarda la valutazione di un'espressione fino a quando non è necessario il suo valore. Quando combinato con la memoizzazione, la strategia di valutazione lazy evita valutazioni ripetute e può ridurre il tempo di esecuzione di determinate funzioni per un fattore significativo.

La libreria di serie temporali utilizza la valutazione pigra per elaborare i dati. Il grafico di esecuzione notoriamente è costruito su dati di serie temporali la cui valutazione viene innescata solo quando la sua emissione viene materializzata. Assumere un oggetto si muove in uno spazio unidimensionale, la cui posizione è catturata da x (t). È possibile determinare la dura accelerazione / frenata (h(t)) di questo oggetto utilizzando la sua serie di velocità (v(t)) e di accelerazione (a(t)) come segue:

# 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

Ne deriva un semplice grafico di esecuzione del modulo:

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

Le valutazioni vengono attivate solo quando viene eseguita un'azione, ad esempio compute h(5...10), ovvero compute h(5), ..., h(10). La libreria cattura le strette dipendenze temporali tra le serie storiche. In questo esempio, h(5...10) richiede a(5...10), che a sua volta richiede v(4...10), che quindi richiede x(3...10). Vengono valutate solo le relative porzioni di a(t), v(t) e x(t) .

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

Inoltre le valutazioni sono memorizzate e possono quindi essere riutilizzate nelle azioni successive su h. Ad esempio, quando una richiesta di h(7...12) segue una richiesta per h(5...10), i valori memoizzati h(7...10) sarebbero leveraged; ulteriormente, h(11...12) verrebbe valutato utilizzando a(11...12), v(10...12) e x(9...12), che avrebbe a sua volta fatto leva su v(10) e x(9...10) memoizzata dal calcolo preventivo.

In un esempio più generale, si potrebbe definire una serie di tempi di velocità smoothie come segue:

# 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)

In questo esempio h(l...u) ha la seguente dipendenza temporale. La valutazione di h(l...u) si adatterebbe rigorosamente a questa dipendenza temporale con la memoizzazione.

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