def reconstruct_plot(model, X, y, order=0):
batch = y.shape[0]
criterion = nn.MSELoss()
with torch.no_grad():
X = torch.tensor(X, dtype=torch.float)
y_predict, X_predict = model(X)
lo = criterion(X, X_predict)
print('LOSS is: ', lo.numpy())
if batch > 1:
y_recover = [
(leadlag_inverse(y_id)[0] + leadlag_inverse(y_predict_id)).numpy()
for y_id, y_predict_id in zip(y, y_predict)
]
logsig_recover = signatory.logsignature(y_predict, order)
plt.figure(figsize=(16, 2))
for i in range(4):
plt.subplot(1, 4, i + 1)
idx = np.random.randint(0, batch)
y_true = leadlag_inverse(y[idx])
plt.plot(y_true)
plt.plot(y_recover[idx])
plt.show()
return y_recover, logsig_recover
else:
logsig_recover = signatory.logsignature(y_predict, order)
y_recover = leadlag_inverse(y_predict[0]) #+ leadlag_inverse(y[0])[0]
# plt.plot(leadlag_inverse(y[0]))
# plt.plot(y_recover)
return y_recover, logsig_recover
def get_data(order, params, freq, ll, scale):
Batchsize = params['M']
train_windows, train_path, time = _load_rough_bergomi(params, freq, ll)
train_logsig = signatory.logsignature(torch.tensor(train_windows),
order).numpy()
train_sig = signatory.signature(torch.tensor(train_windows), order).numpy()
train_sig_exp = np.concatenate([np.ones([Batchsize, 1]), train_sig],
axis=1)
# train_sig_normalized = normalize.normalize_sig(2, order, train_sig_exp)
test_windows, test_path, time = _load_rough_bergomi(params, freq, ll)
test_logsig = signatory.logsignature(torch.tensor(test_windows),
order).numpy()
test_sig = signatory.signature(torch.tensor(test_windows), order).numpy()
test_sig_exp = np.concatenate([np.ones([Batchsize, 1]), test_sig], axis=1)
if scale:
scaler_logsig = MinMaxScaler(feature_range=(0.00001, 0.99999))
logsig_transformed = scaler_logsig.fit_transform(train_logsig)
data = logsig_transformed[1:] # 1 week forecasting 1 week
data_cond = logsig_transformed[:-1]
data_cond = np.zeros_like(
data_cond) ######################################### for VAE
scaler = scaler_logsig
else:
logsig_transformed = None
scaler = None
data = train_logsig[1:] # 1 week forecasting 1 week
data_cond = train_logsig[:-1]
data_cond = np.zeros_like(
data_cond) ######################################### for VAE
return train_windows, train_path, train_logsig, train_sig, train_sig_exp, test_windows, test_path,\
test_logsig, test_sig, test_sig_exp, logsig_transformed, data, data_cond, scaler
def __init__(self,
controls,
responses,
sampler=None,
depth=2,
response_in_initial=False):
"""
Args:
controls (torch.Tensor): The control path of shape [N, L, C_control].
responses (torch.Tensor): The response path of shape [N, L, C_response] (if regression) or shape (N,) if
classification.
sampler (IntervalSampler): An initialised sampler from src.data.utils.intervals.
depth (int): The depth of the log-signature to truncate at.
response_in_initial (bool): If a continuous regression problem, set True to include the response at time
t=0 to the initial values.
"""
# Hold onto the initial values
if response_in_initial:
assert responses.dim(
) == 3, "Can only put the response in the IC if dim == 3."
self.initial_values = torch.cat(
(controls[:, 0, :], responses[:, 0, :]), dim=1)
else:
self.initial_values = controls[:, 0, :]
self.initial_dim = self.initial_values.size(-1)
# Setup intervals
intervals, knot_idxs = sampler.intervals, sampler.knot_idxs
self.sampler = None
# Responses and params
self.responses = responses[:, knot_idxs] if responses.dim(
) == 3 else responses
self.depth = depth
# Compute the signatures
self.signatures = torch.stack([
signatory.logsignature(controls[:, i[0]:i[1]], depth=depth)
for i in intervals
],
dim=1)
# Some params
self.n_samples = self.signatures.size(0)
self.ds_length = self.signatures.size(1)
self.input_dim = self.signatures.size(2)
self.controls = self.signatures # As the signatures are now the controls
# Add some functionality
self.size = self.signatures.size()
def logsig(step,stride,level,data):
size = data.shape[0]
frame=data.shape[1]
data = data.reshape(size, 39, 19, 3)
data = np.swapaxes(data, 1, 2)
data = data.reshape(size * 19, 39, 3)
sig = list()
for i in range(0, frame - step + 1, stride):
temp_data = data[:, i:i + step, :]
temp_data = torch.from_numpy(temp_data).float()
temp_sig = (signatory.logsignature(temp_data, level))
temp_data = temp_data.cpu().numpy()
temp_sig = temp_sig.cpu().numpy()
temp_data = np.swapaxes(temp_data, 0, 1)
temp_data = temp_data[0]
att = np.concatenate((temp_data, temp_sig), axis=1)
sig.append(att)
if frame % stride>1:
temp_data1 = data[:, frame-step+1:frame, :]
temp_data1 = torch.from_numpy(temp_data1).float()
temp_sig1 = (signatory.logsignature(temp_data1, level))
temp_data1 = temp_data1.cpu().numpy()
temp_sig1 = temp_sig1.cpu().numpy()
temp_data1 = np.swapaxes(temp_data1, 0, 1)
temp_data1 = temp_data1[0]
att1 = np.concatenate((temp_data1, temp_sig1), axis=1)
sig.append(att1)
sig = np.swapaxes(sig, 0, 1)
t1 = sig.shape[1]
s1 = sig.shape[2]
sig = sig.reshape(size, 19, t1, s1)
sig = np.swapaxes(sig, 1, 3)
sig = np.expand_dims(sig, axis=-1)
return sig
def Ito_map(X):
N = X.shape[1]
Y = torch.zeros((1, N, 3)) #.cuda()
if X.shape[2] == 2:
Y[0, :, 0] = X[0, :, 0]
Y[0, :, 1] = X[0, :, 1]
Y[0, :, 2] = torch.tensor([0.] + [
signatory.logsignature(X[:, :i + 1, :], 2, mode='brackets')[0, -1]
for i in range(1, N)
]) #.cuda()
else:
Y[0, :, 0] = X[0, :, 0]
Y[0, :, 1] = X[0, :, 1]
Y[0, :, 2] = 0.5 * (X[0, :, 3] - X[0, :, 4])
return Y
def inverse_multiple_path(path, order, net=None, train=True):
N = path.shape[1] - 1
path_torch = leadlag(torch.tensor(path)[:, :, 0])
path_leadlag = path_torch.numpy()
logsig = signatory.logsignature(path_torch, order)
X = logsig.numpy()
y = path_leadlag
if not net:
ds, dl = data_prepare(X, y)
net = Net(X.shape[-1], order, N)
net.train_net(dl, 1000)
elif train:
ds, dl = data_prepare(X, y)
net.train_net(dl, 1000)
y_recover, logsig_recover = reconstruct_plot(net, X, y, order)
return y_recover, logsig_recover, net
def inverse_single_path(path0, order, sig=True, net0=None, N=28):
if not sig:
N = path0.shape[1] - 1
path_torch = leadlag(torch.tensor(path0)[:, :, 0])
path_leadlag = path_torch.numpy()
logsig = signatory.logsignature(path_torch, order)
X0 = logsig.numpy()
y0 = path_leadlag
else:
X0 = path0
y0 = path0[:, :, None]
dl = data_prepare(X0, y0)
if not net0:
net0 = Net(X0.shape[-1], order, N)
net0.train_net(dl, 1000)
y_recover, logsig_recover = reconstruct_plot(net0, X0, y0, order)
return net0, y_recover, logsig_recover