
from IPython.display import Image
Image(filename='dimensions.png',width=600)


import numpy as np

def full_log_signature_dim_two_level_three(X, deg):
    """
    :param X: Matrix of discrete sample paths.
    :param deg: Truncation level of the log-signature (>=1,<=3).
    :return: log-signature for each subinterval.
    """
    m, n, d = X.shape
    
    assert d == 2
    assert (deg>=1) and (deg<=3)
    
    log_sig_dim = {1: 2, 2: 3, 3: 5}
    
    log_sig = np.zeros((m, n, log_sig_dim[deg]))
    
    log_sig[:,1:,:2] = X[:, 1:] - X[:, 0].reshape(-1, 1, 2)
        
    if deg >=2:
        dX = np.diff(X, axis=1)
        
        for i in range(1, n):
            l = log_sig[:, i - 1]
            dx = dX[:, i - 1]
            log_sig[:, i, 2] = l[:, 2] + 0.5 * (l[:, 0] * dx[:, 1] - l[:, 1] * dx[:, 0])
            
    if deg == 3:
        for i in range(1, n):
            l = log_sig[:, i - 1]
            dx = dX[:, i - 1]
            log_sig[:, i, 3] = l[:, 3] - 0.5 * l[:, 2] * dx[:, 0] + (1 / 12) * \
                    (l[:, 0] - dx[:, 0]) * (l[:, 0] * dx[:, 1] - l[:, 1] * dx[:, 0])
            log_sig[:, i, 4] = l[:, 4] + 0.5 * l[:, 2] * dx[:, 1] - (1 / 12) * \
                    (l[:, 1] - dx[:, 1]) * (l[:, 0] * dx[:, 1] - l[:, 1] * dx[:, 0])
            
    return log_sig


X = np.array([
    [[0,0], [1,1], [2,2], [3,3]]
])

log_sig = full_log_signature_dim_two_level_three(X, 3)


def print_log_sig_dim_two_degree_three(log_sig_):
    print(8*" ", "".join(["{0:^11s}".format(s) 
                          for s in ["1", "2", "12", "112", "122"]]))
    for j, l in enumerate(log_sig_[0]):
        print('j = {}:'.format(j), 
              " ".join(format(e_, "10.3f") for e_ in l))
        
print_log_sig_dim_two_degree_three(log_sig)

              1          2         12         112        122    
j = 0:      0.000      0.000      0.000      0.000      0.000
j = 1:      1.000      1.000      0.000      0.000      0.000
j = 2:      2.000      2.000      0.000      0.000      0.000
j = 3:      3.000      3.000      0.000      0.000      0.000


X = np.array([
    [[0,0], [1,1], [2,0], [3,-1], [4,0]]
])

log_sig = full_log_signature_dim_two_level_three(X, 3)

print_log_sig_dim_two_degree_three(log_sig)

              1          2         12         112        122    
j = 0:      0.000      0.000      0.000      0.000      0.000
j = 1:      1.000      1.000      0.000      0.000      0.000
j = 2:      2.000      0.000     -1.000      0.000      0.333
j = 3:      3.000     -1.000     -2.000      0.333      1.000
j = 4:      4.000      0.000      0.000      2.000      0.667


import iisignature as ii

def full_log_signature(X, deg):
    """
    :param X: Matrix of discrete sample paths.
    :param deg: Truncation level of the log-signature.
    :return: log-signature for each subinterval.
    """
    m, n, d = X.shape
    
    log_sig = np.zeros((m, n, ii.logsiglength(d, deg)))
    
    if (d==2) and (deg<=3):
        return full_log_signature_dim_two_level_three(X, deg)
    else:
        bch = ii.prepare(d, deg, 'C') #precalculate the BCH formula
        for i in range(1, n):
            log_sig[:, i] = ii.logsig(X[:,:i+1], bch, 'C')
    
    return log_sig


import tensorflow as tf
from functools import reduce

class DensNeuralNetwork:
    
    def __init__(self, n_nodes, n_layers):
        self.layers = [
            tf.keras.layers.Dense(n_nodes, activation='relu') 
                       for i in range(n_layers)]
        self.final_layer = tf.keras.layers.Dense(1, activation=None)
        self.flatten = tf.keras.layers.Flatten()

    def __call__(self, x):
        y = reduce(lambda x_, f: f(x_), [x] + self.layers)
        return self.flatten(self.final_layer(y))

class IntegratedStoppingRule(tf.keras.layers.Layer):

    def __init__(self):
        super(IntegratedStoppingRule, self).__init__()
        self.steps = None

    def build(self, input_shape):
        self.steps = input_shape[-1]

    def call(self, rule, **kwargs):
        return tf.cumsum(rule**2, axis=1) / (self.steps - 1)
    
class RandomizedStoppingLoss(tf.keras.layers.Layer):
    
    def __init__(self):
        super(RandomizedStoppingLoss, self).__init__()

    def call(self, inputs, **kwargs):
        rule, Y = inputs
        
        out = tf.exp(-rule)
        
        dY = Y[:, 1:] - Y[:, :-1]
        
        out = Y[:, 0] + tf.reduce_sum(out[:, :-1] * dY, axis=1)
        
        self.add_loss(-out)
        
        return out


import scipy
from scipy.fft import hfft, ihfft

def stationary_gaussian(m, mean, c):
    gam = np.concatenate([c, c[1:-1][::-1]])
    lam = np.sqrt(scipy.fft.rfft(gam))
    return hfft(lam * ihfft( np.random.randn(m, len(gam)) ))[:,:n]

def simulate_fBm(m, H, delta, n):
    cov = lambda k: 0.5*(np.abs(k+1)**(2*H) + np.abs(k-1)**(2*H))\
                        - np.abs(k)**(2*H)
    X = np.zeros((m,n+1))
    X[:, 1:] = stationary_gaussian(m, 0, cov(np.arange(n)))
    return delta**H * np.cumsum(X, axis=1, out=X)

from matplotlib import pyplot as plt

n = 100
delta = 1.0/n
T = np.linspace(0, 1, n+1)

plt.figure(dpi=120)
for H in [0.1, 0.5, 0.9, 1.0]:
    X = simulate_fBm(2, H, delta, n)
    plt.plot(T, X[0], label="H = {}".format(H))
plt.legend();


def build_network(n, deg, I, q):
    
    d = ii.logsiglength(2, deg)
    
    input_logsig = tf.keras.Input(shape=(n, d), name='sig')
    
    input_y = tf.keras.Input(shape=(n,), name='Y')

    rule_layer = IntegratedStoppingRule()(DensNeuralNetwork(d + q, I)(input_logsig))
    
    loss_layer = RandomizedStoppingLoss()([rule_layer, input_y]) 
    
    model = tf.keras.Model([input_logsig, input_y], loss_layer)
    
    rule_model = tf.keras.Model(input_logsig, rule_layer)
    
    return model, rule_model


def log_sig_fbm(m, H, T, n, deg):
    
    X = np.zeros((m, n + 1, 2))
    
    X[:, :, 0] = np.linspace(0, T, n + 1)
    
    X[:, :, 1] = simulate_fBm(m, H, T/(n+1), n)
    
    return full_log_signature(X, deg)


log_signature = log_sig_fbm(m=1, H=0.1, T=1.0, n=100, deg=3)

plt.figure(dpi=120)
plt.plot(log_signature[0,:,0], log_signature[0,:,1], label="2")
plt.plot(log_signature[0,:,0], log_signature[0,:,2], label="12")
plt.plot(log_signature[0,:,0], log_signature[0,:,3], label="112")
plt.plot(log_signature[0,:,0], log_signature[0,:,4], label="122")
plt.legend();


import tensorflow as tf

m = 100_000
T = 1
n = 100
deg = 3
H = 0.9

model, rule_model = build_network(n + 1, deg, I = 2, q = 30)

log_sig = log_sig_fbm(m, H, T, n, deg)
Y = log_sig[:,:,1]

log_sig_val = log_sig_fbm(m, H, T, n, deg)
Y_val = log_sig_val[:,:,1]

optimizer = tf.keras.optimizers.Adagrad(learning_rate=.1)
model.compile(optimizer)

model.fit([log_sig, Y], batch_size=100, epochs=10, verbose=1, 
validation_data=([log_sig_val, Y_val]));

Epoch 1/10
1000/1000 [==============================] - 8s 7ms/step - loss: -0.2959 - val_loss: -0.3206
Epoch 2/10
1000/1000 [==============================] - 4s 4ms/step - loss: -0.3220 - val_loss: -0.3255
Epoch 3/10
1000/1000 [==============================] - 5s 5ms/step - loss: -0.3245 - val_loss: -0.3261
Epoch 4/10
1000/1000 [==============================] - 5s 5ms/step - loss: -0.3259 - val_loss: -0.3270
Epoch 5/10
1000/1000 [==============================] - 5s 5ms/step - loss: -0.3223 - val_loss: -0.3274
Epoch 6/10
1000/1000 [==============================] - 5s 5ms/step - loss: -0.3243 - val_loss: -0.3265
Epoch 7/10
1000/1000 [==============================] - 5s 5ms/step - loss: -0.3244 - val_loss: -0.3278
Epoch 8/10
1000/1000 [==============================] - 6s 6ms/step - loss: -0.3273 - val_loss: -0.3283
Epoch 9/10
1000/1000 [==============================] - 5s 5ms/step - loss: -0.3274 - val_loss: -0.3284
Epoch 10/10
1000/1000 [==============================] - 5s 5ms/step - loss: -0.3254 - val_loss: -0.3284


log_sig = log_sig_fbm(100_000, H, T, n, deg)
Y = log_sig[:,:,1]
res = model.predict([log_sig, Y])
res.mean(), res.var()/np.sqrt(100_000)

(1.0304726, 0.0021025969237349557)


i = np.random.randint(m)
rule = rule_model.predict(log_sig[i:i+1]).flatten()

plt.figure(dpi=120)
plt.plot(log_sig[0, :, 0], log_sig[i, :, 1], label=r'$X_t^H$')
plt.legend(loc=1);
plt.twinx()
plt.hlines(np.random.exponential(1.0), 0, T, color='C3', label="$Z$")
plt.plot(log_sig[0, :, 0], rule.flatten(), 
         c='C1', label=r'$\int_0^t\theta(\mathbb{X}_{0,s})^2ds$')
plt.ylim(-0.5,10)
plt.legend(loc=5);


from IPython.display import Image
Image(filename='different_H_plot.png',width=600)

Mini-Course on¶

Machine Learning Methods in Finance @ KAUST¶

From Signatures to Reinforcement Learning¶

Outline of the Lecture¶

1. Calculation of Log-Signatures¶

1.1 Recap of Signatures of Smooth Paths¶

1.2 The Free Lie algebra¶

1.3 A Basis of the Free Lie Algebra¶

1.4 The Signature of Piecewise Linear Paths¶

Theorem (Baker-Campbell-Hausdorff + Dynkin formula)¶

2. Implementing Deep Signature Stopping Rules¶

Theorem (Bayer-H-Riedel-Schoenmakers)¶

3. Optimal Stopping of Fractional Brownian Motion¶

... collecting all the code¶

Generating the data and training the network¶

Calculating Lower Bounds¶

Visualisation of the trained signature stopping rule¶

Results for different Hurst parameters¶

References¶

Thank You!¶