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