SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Here we provide details for each of the experiments outlined in the body of the paper. We also provide some extra methods of evaluation aside from the KS test. These include the following:
1. Qualitative plot: We give a plot of samples  $\mathbb{P}_{X^{\theta}}$  from a trained generator against the true data measure  $\mathbb{P}_{X^{\mathrm{true}}}$ .
2. Autocorrelation: To measure temporal dependencies or correlations, we leverage the autocorrelation function
$$
\mathrm {A C F} _ {\ell} = \frac {1}{N \sigma^ {2}} \sum_ {t = l} ^ {N} (X _ {t} - \mu) (X _ {t - l} - \mu),
$$
where  $\mu$  is the average of the path  $X_{t}$  over  $[0,N]$  and  $\sigma^2$  is the corresponding variance. We provide a qualitative plot of  $\mathrm{ACF}_{\ell}$  for each generator against the real data measure. We also provide a table summarizing the scores for some of the earliest lags  $\ell \in \mathbb{N}$ .
3. Cross-correlation: We provide average cross-correlation scores  $(r_t, r_{t,\ell}^2)$  between the returns process associated to  $X_t \sim \mathbb{P}_{X^\theta}$  and the squared, lagged returns process  $r_{t,\ell}^2$ . We present the scores in matrix form. Finally, we provide the MSE between the matrix obtained from  $\mathbb{P}_{X^{\mathrm{true}}}$  and those obtained from each generator.
We make a note here that each of the three discriminators performed similarly in the additional quantitative metrics omitted from the body. Finally, we wish to first make the following general notes about each of the three methods studied in this paper:
- Speed: Training a Neural SDE with respect to  $\phi_{\mathrm{sig}}^{N}$  was the fastest, followed by the SDE-GAN, and finally with  $\phi_{\mathrm{sig}}$  being the slowest. It was possible to decrease training time respect to the latter by using a coarser dyadic refinement in the PDE solver. However, we felt that achieving more accurate gradients at the cost of longer training time was worthwhile.
- Stability: The Wasserstein SDE-GAN was the least stable, in terms of the difficulty in obtaining a training instance where the loss converged in reasonable time. Even with fine-tuning of both generator and discriminator parameters, the loss associated to the SDE-GAN tended to oscillate, making obtaining a converged model a very difficult task with the hardware available to us.
- Scaling: All of the results in the paper are sensitive to path scalings; more so with the signature kernel-based approaches, less so with the Wasserstein approach. The basic idea is as follows: the signature kernel-based methods will tend to fail if paths are scaled too low (resulting in lower-order terms dominating the calculation of  $k_{\mathrm{sig}}$ ) or too high (the sum, although finite, can exceed a 64-bit float quite easily). Path scaling (and transformations) form an integral part in training a successful generative model, and we have tried to be as descriptive as possible regarding this matter. The details as to why scalings matter have been touched upon in [CLX21]; we intend to expand upon this in a future work.
- Standardisation: On a similar note, standardizing path data before training was often found to improve the stability of training in any setting. By standardization we are referring to transforming each marginal of paths  $X \sim \mathbb{P}_{X^{\mathrm{true}}}$  via the transformation  $\hat{X}_t = (X_t - \mu_T) / \sigma_T$ , where  $\mu_T = \mathbb{E}_{\mathbb{P}_{X^{\mathrm{true}}}}[X_T]$  and  $\sigma_T = \mathbb{E}_{\mathbb{P}_{X^{\mathrm{true}}}}[(X_T - \mu_T)^2]$ . By having the terminal marginal distributed standard normal, the task of finding suitable path scalings and smoothing parameters in the RBF kernel was made much simpler, as this task became less problem-specific.
B.1 Geometric Brownian motion
Data processing and hyperparameters To generate our data measure, we simulate 32768 paths according to eq. (9) using the torchsde package. These were solved over the interval [0, 64] by setting  $y_0 = 1, \mu = 0, \sigma = 0.2$ , with  $dt = 0.1$ . Paths were then interpolated along the grid  $\Delta = \{0, 1, 2, \ldots, 63\}$ , so each element of the training set had total length 64. Stochastic integrals were taken in the Ito sense and the driving noise  $W$  was taken in the general sense. We used the SRK method to solve the corresponding SDE. Each path is time-augmented, so  $\hat{X}_t = (t, X_t)$  at each point on the grid. After we have simulated our dataset, we standardized each path as outlined in the dot points above.
Generator hyperparameters The generator is a Neural SDE with vector fields  $\mu_{\theta}:[0,T]\times \mathbb{R}^{y}\to \mathbb{R}^{y}$  and  $\sigma_{\theta}:[0,T]\times \mathbb{R}^{y\times w}\to \mathbb{R}^{y}$  taken to be neural networks with 1 hidden layer, and 16 neurons in said layer. As per  $[\mathrm{KFL}^{+}21]$  the LipSwish activation function was used to ensure the Lipschitz condition held on the vector fields of the Neural SDE. We also used the final tanh regularisation which we found was necessary for training success. Thus we have that
$$
\mu_ {\theta}, \sigma_ {\theta} \in \mathcal {N N} (1, 1 6, 1, \text {L i p S w i s h}, \tanh).
$$
The size of the hidden state of the neural SDE was chosen to be  $y = 8$ , and the noise dimension was chosen to be  $w = 3$ . Stochastic integration was taken in the Itô sense and we set  $dt = 1$  over [0, 63]. As we are not learning an initial distribution in this instance, we modified the generator architecture to have  $\xi_{\theta}(X_0) = a$  for some  $a \in \mathbb{R}$ , where  $\xi_{\theta}$  is the network acting on the initial condition. Before passing to the discriminator, both generated and real paths were translated to start at 0.
Discriminator hyperparameters For the signature kernel-based discriminators, we applied the time normalisation transformation so the time component of both the real and generated paths was over [0, 1] as opposed to [0, 63]. This was to ensure each channel of the generated and real data evolved over a similar scale. For training with respect to  $\phi_{\mathrm{sig}}$ , we set the order of dyadic refinement associated to the PDE solver for the signature kernel to 1. We also used three different kernels, corresponding to three different scalings of the paths, for increased expressivity. For  $\phi_{\mathrm{sig}}^N$ , we set the order of truncation equal to  $N = 3$ . Finally, for the SDE-GAN, we chose the drift and diffusion vector fields to be feed-forward neural networks
$$
f _ {\phi}, g _ {\phi} \in \mathcal {N N} (1, 1 6, 1, \text {L i p S w i s h}, \tanh ),
$$
matching that from the generator.
Training hyperparameters All methods used a batch size of 128 and the Adam optimisation algorithm for backpropagating through the generator optimisers, except for the SDE-GAN, which as suggested by the authors we used Adadelta. As a remark, we did not see much difference in using either Adam, Adadelta, or RMSProp, although we did see poorer performance using pure SGD, with or without momentum. Learning rates were roughly proportional to the average size of the batched loss: as a rough guide, proportionality like  $\eta_G \times \mathcal{L}(\theta) \approx 10^{-5}$  tended to yield good results, with the generator learning rate being around  $\eta_G \approx 10^{-4}$  for the signature kernel(s), and  $\eta_D \approx \eta_G \times 10^{-2}$  for the SDE-GAN. As mentioned in the body, we trained for 4000 steps with  $\phi_{\mathrm{sig}}^N$ , 10000 with  $\phi_{\mathrm{sig}}^N$  and 5000 with the SDE-GAN to normalise for training time.
Results We begin with a qualitative plot of the results from each generator.
Figure 4: Qualitative plot of generator output versus data measure. Trained with (from left to right):  $\phi_{\mathrm{sig}}$ ,  $\phi_{\mathrm{sig}}^{N}$ , SDE-GAN
Table 5 gives the autocorrelation scores for the first five lags for each of the three models, along with plots of the mean ACF values in Figure 5 and the associated  $95\%$  confidence intervals. We can see that all three models do well at capturing temporal effects, with the Neural SDE trained with respect to  $\phi_{\mathrm{sig}}$  most closely matching the data measure, except in the first lag.
Discriminator	Lags
l=1	l=2	l=3	l=4	l=5
SDE-GAN	0.887 ± 0.120	0.782 ± 0.211	0.686 ± 0.282	0.597 ± 0.342	0.515 ± 0.384
φsigN(N=3)	0.883 ± 0.115	0.781 ± 0.197	0.684 ± 0.261	0.594 ± 0.320	0.514 ± 0.364
φsig	0.886 ± 0.111	0.785 ± 0.199	0.696 ± 0.267	0.612 ± 0.315	0.535 ± 0.350
Data measure	0.892 ± 0.105	0.793 ± 0.183	0.702 ± 0.258	0.616 ± 0.319	0.532 ± 0.374
Table 5: Sample autocorrelation scores, gBm
Finally, we present the cross-correlation matrices between the returns process  $r_t$  and the lagged squared returns process  $r_{t - l}^2$  for lags  $l = \{0,1,2,3,4,5\}$ . Again all models tend to perform quite well in that they match relational dynamics observed in the data measure. Table 6 gives the MSE between the generated matrices and the data matrix. We see that the Neural SDE trained with  $\phi_{\mathrm{sig}}$
Figure 5: Qualitative plot of ACF scores, generator output versus data measure. Trained with (from left to right):  $\phi_{\mathrm{sig}}$ ,  $\phi_{\mathrm{sig}}^{N}$ , SDE-GAN
achieves the lowest score of the three, however again performance is strong regardless of method used for training.
(a) Data measure.
(b)  $\phi_{\mathrm{sig}}$
(c)  $\phi_{\mathrm{sig}}^N$
(d) SDE-GAN.
Figure 6: Cross-correlation matrices, gBm
Discriminator	MSE
SDE-GAN	0.014688
φN sig(N=3)	0.066745
φsig	0.010718
Table 6: MSE between cross-correlation matrices, gBm
B.2 Rough Bergomi
Data processing and hyperparameters We simulate 32768 paths to make up our data measure via the rBergomi Python package<sup>5</sup>. We fixed the time window to be [0, 2], and specified  $dt = 1/32$ , so paths were of length 64. We chose  $(\xi_0, \eta, \rho, H) = (0.04, 1.5, -0.7, 0.2)$  and set  $d = 1$ . Paths started at 1. As always, paths were time-augmented. Paths were normalised to start at 0 via translation and were standardized again according to the terminal data from the train set. A final point is that although the data was generated over [0, 2], the time grid passed to the generators in an optimiser step was  $\Delta = \{0, 1, \dots, 63\}$ . We found that this improved performance.
Generator hyperparameters Given the increased complexity of the data generating model, we increased the expressivity of the vector fields governing the drift and diffusion vector fields  $\mu_{\theta}$  and  $\sigma_{\theta}$ . This was done by increasing the depth and width of the constituent feed-forward networks to include 3 hidden layers of size 32. We also increased the size of the hidden state to  $y = 16$  and the
See https://github.com/ryanmccrickerd/rough_bergomi
noise dimension to  $w = 8$ . Thus
$$
\mu_ {\theta} \in \mathcal {N N} (1 7, 3 2, 3 2, 3 2, 1 6; \text {L i p S w i s h}, \text {L i p S w i s h}, \text {L i p S w i s h}, \tanh)
$$
$$
\sigma_ {\theta} \in \mathcal {N N} (1 7, 3 2, 3 2, 3 2, 1 2 8; \text {L i p S w i s h}, \text {L i p S w i s h}, \text {L i p S w i s h}, \tanh).
$$
Discriminator hyperparameters For training with respect to  $\phi_{\mathrm{sig}}$ , we mapped path state values to  $(\mathcal{H},\kappa)$  where  $\kappa$  denotes the RBF kernel on  $\mathbb{R}^2$ . We set associated the smoothing parameter  $\sigma = 1$ . For  $\phi_{\mathrm{sig}}^{N}$ , we increased the truncation level to  $N = 5$ . In both these settings we again applied the time normalisation transformation on both the generated and data measure paths before being passed through the loss function. For the SDE-GAN, we increased the expressiveness of the vector fields governing the Neural CDE in the same way as we did the Neural SDE.
Training hyperparameters Learning rates for the Neural SDE trained according to  $\phi_{\mathrm{sig}}$  was set to  $\eta_G = 1\times 10^{-4}$ . Due to the increasing number of terms in the expected signature for the truncated MMD approach, we had to reduce the learning rate to  $\eta_G = 1\times 10^{-6}$  - larger values caused instability in the training procedure. The SDE-GAN was again quite difficult to train, however we were able to have some success by setting  $\eta_D\approx 2\times 10^{-3}$  and  $\eta_G\approx 1\times 10^{-3}$ . Initialisation of the generator vector fields was especially important for the Wasserstein method, as initialisation too far from the data measure cause oscillatory patterns in the training loss, which leads to more epochs required for the loss to converge. We again used the Adam optimisation algorithm for the MMD-based discriminator/generators and Adadelta for the SDE-GAN. We trained for the same number of steps as per the gBm method.
Results Figure 7 gives a qualitative plot of the simulated paths.
Figure 7: Qualitative plot of generator output versus data measure. Trained with (from left to right):  $\phi_{\mathrm{sig}}$ ,  $\phi_{\mathrm{sig}}^N$ , SDE-GAN
Figure 8 gives the same plot of the ACF scores at corresponding lags for the data measure and each of the generated models, along with the  $95\%$  confidence interval. Table 7 explicitly gives these scores.
Figure 8: Qualitative plot of ACF scores, generator output versus data measure. Trained with (from left to right):  $\phi_{\mathrm{sig}}$ ,  $\phi_{\mathrm{sig}}^{N}$ , SDE-GAN
Discriminator	Lags
l=1	l=2	l=3	l=4	l=5
SDE-GAN	0.893 ± 0.105	0.795 ± 0.191	0.705 ± 0.262	0.622 ± 0.319	0.543 ± 0.377
φNsig(N=5)	0.897 ± 0.115	0.799 ± 0.208	0.710 ± 0.289	0.628 ± 0.338	0.546 ± 0.383
φsig	0.890 ± 0.115	0.790 ± 0.203	0.702 ± 0.269	0.618 ± 0.316	0.521 ± 0.382
Data measure	0.885 ± 0.121	0.778 ± 0.215	0.685 ± 0.278	0.600 ± 0.336	0.521 ± 0.380
Finally, we present the same cross-correlation matrices, along with the MSE between either of the three generators and the data measure. Although each of the models perform well, the generator trained with  $\phi_{\mathrm{sig}}$  achieves the best results.
(d) SDE-GAN
Figure 9: Cross-correlation matrices, rBergomi
Table 7: Sample autocorrelation scores, rBergomi
Discriminator	MSE
SDE-GAN	0.091707
φsigN(N=5)	0.054731
φsig	0.016785
Table 8: MSE between cross-correlation matrices, rBergomi
B.3 Multidimensional real data
We now give the details regarding the unconditional generation of foreign exchange data.
Data processing and hyperparameters Data is given by hourly returns associated to the currency pairs EUR/USD and USD/JPY. We stride the concatenated time series (corresponding to close prices at each time) into paths of length  $\ell = 64$ . Paths are normalized to start at 1. We augmented the state values with their original timestamps, (as epoch seconds). Call this dataset  $\mathcal{V}$ . As we are dealing with financial data, one can expect the time intervals between prices to be irregular. This is not usually an issue when using signature methods. However, in this setting we found training to be less stable if paths were not normalised to evolve over the same time grid as that which the neural SDE was solved over in a forward pass.
To circumvent this issue, for every  $y \in \mathcal{V}$  we find the median terminal time  $\tilde{T}$ , where
$$
\tilde {T} = \operatorname {M e d i a n} _ {i = 1, \dots , | y |} \left[ t _ {\ell} ^ {i} / t _ {0} ^ {i} \right].
$$
All paths whose terminal time is greater than  $\tilde{T}$  were filtered out of the dataset which we call  $\tilde{\mathcal{V}}$ . We then define an evenly-spaced time grid  $\Delta^{*} = \{0, \dots, \tilde{T}\}$  containing 64 observations in total, and linearly interpolate each  $y \in \tilde{\mathcal{V}}$  over this grid, where we use these interpolated coefficients to
form our train and test sets. Again we standardize using the terminal values of the train set data. We simulate our generators over the time grid  $\Delta = \{0, \dots, 63\}$  as we found that using  $\Delta^{*}$ , the realistic time-grid (in fractions of a year) induced little variability in the generated paths; i.e., the quadratic variation associated to the generated paths was significantly lower than that obtained from the real data measure.
Generator hyperparameters The generator maintains the same architecture as outlined in the rBergomi section. We tried increasing the size of the hidden state to  $x = 32$  and the noise state  $w = 16$  but found that this had little impact on training performance. We also found that increasing the expressivity of the neural vector fields did not overly impact performance; neither refining the mesh over which the Neural SDE was solved.
Discriminator hyperparameters We used the same discriminator hyperparameters for each of the three methods as per the rBergomi section.
Training hyperparameters We used the same batch size (128) as per the previous sections. We allowed for increased training time here, training with respect  $\phi_{\mathrm{sig}}$  for 4000 steps, 15000 for  $\phi_{\mathrm{sig}}^N$  and 10000 for the SDE-GAN. The same learning rate parameters were used as well. We did not use any learning rate annealers. The Adam optimisation algorithm was employed for the MMD-based generators, whereas again Adadelta was used for the Wasserstein case.
Results Extended results are provided as per the previous sections. We being with the qualitative plots.
Figure 10: Qualitative plot of generator output versus data measure. Trained with (from left to right):  $\phi_{\mathrm{sig}}$ ,  $\phi_{\mathrm{sig}}^{N}$ , SDE-GAN
(a) EUR/USD
(b) USD/JPY
Visual inspection gives that the generator trained with respect to  $\phi_{\mathrm{sig}}$  appears to have most accurately captured the data measure, in particular the less regular, outlier paths. In contrast the SDE-GAN and truncated kernel methods tend to over-represent the mean element. For the GAN this could be the "mode collapse" phenomenon in effect, whereas in the case of the Neural SDE trained with  $\phi_{\mathrm{sig}}^N$ , it is likely that higher-order terms cannot be discarded if one wishes to accurately model the data measure.
We now provide the plot associated to the ACF scores obtained from training with respect to each generator, along with the summarizing table. Table 9 shows that that each of the discriminators perform relatively well, aside from the EURUSD autocorrelative factors obtained via training the Neural SDE in the SDE-GAN framework. Finally we give the cross-correlation matrices and the associated MSEs. The Neural SDE trained with respect to  $\phi_{\mathrm{sig}}$  appears to perform the best by this evaluation metric.
(a) EUR/USD
Figure 11: Qualitative plot of ACF scores, generator output versus data measure. Trained with (from left to right):  $\phi_{\mathrm{sig}}$ ,  $\phi_{\mathrm{sig}}^{N}$ , SDE-GAN
(b) USD/JPY
Discriminator	Lags
l=1	l=2	l=3	l=4	l=5
SDE-GAN	0.905 ± 0.108	0.817 ± 0.195	0.736 ± 0.264	0.660 ± 0.319	0.590 ± 0.362
φNsig(N=5)	0.889 ± 0.123	0.788 ± 0.215	0.695 ± 0.289	0.610 ± 0.345	0.532 ± 0.388
φsig	0.890 ± 0.123	0.790 ± 0.218	0.699 ± 0.291	0.615 ± 0.347	0.538 ± 0.388
Data measure	0.885 ± 0.140	0.785 ± 0.236	0.696 ± 0.302	0.615 ± 0.302	0.541 ± 0.387
(a) EUR/USD
Discriminator	Lags
l=1	l=2	l=3	l=4	l=5
SDE-GAN	0.891 ± 0.121	0.791 ± 0.216	0.700 ± 0.290	0.616 ± 0.346	0.539 ± 0.389
φNsig(N=5)	0.887 ± 0.123	0.785 ± 0.218	0.692 ± 0.292	0.607 ± 0.348	0.529 ± 0.390
φsig	0.891 ± 0.121	0.790 ± 0.215	0.698 ± 0.288	0.614 ± 0.344	0.537 ± 0.385
Data measure	0.885 ± 0.132	0.784 ± 0.227	0.694 ± 0.296	0.613 ± 0.347	0.539 ± 0.385
(b) USD/JPY.
Table 9: Sample autocorrelation scores, forign exchange data
(d) SDE-GAN
(e) USD/JPY
(f)  $\phi_{\mathrm{sig}}$
(g)  $\phi_{\mathrm{sig}}^N$
(h) SDE-GAN
Figure 12: Cross-correlation matrices, foreign exchange data
Discriminator	MSE
EUR/USD	USD/JPY
SDE-GAN	0.051728	0.027539
φsigN(N=5)	0.045966	0.036628
φsig	0.035791	0.003898
Table 10: MSE between cross-correlation matrices, foreign exchange data
B.4 Conditional generation
In this section we describe in detail the training procedure for the conditional generator.
Problem setting The conditioning variables are given by path segments  $x:[t_0 - dt,t_0]\to \mathbb{R}^2$  representing time-augmented asset price values. At time  $t_0$ , one wishes to make a prediction about the resultant path  $y:[t_0,t_0 + dt']\rightarrow \mathbb{R}^2$  conditional on  $x$ . Here,  $dt,dt'$  are hyperparameters describing how much of the past one wishes to consider and how far into the future one wishes to forecast. With  $x\sim \mathbb{Q}$  We thus want to train a conditional generator so that  $\mathbb{P}_{X^{\theta}}(\cdot |x) = \mathbb{P}_{X^{\mathrm{real}}}(\cdot |x)$ . We briefly state the three major difficulties associated to this generation problem:
1. Unobservable true conditional distribution. In practice, one never observes the entire true conditional distribution  $\mathbb{P}_{X^{\mathrm{real}}}(\cdot |x)$ : only a sample from it. This means that classical metrics on path space (MMD, Wasserstein, and so on) cannot be used without modification, or making assumptions about the relationship between the conditioning and resultant paths.
2. Using paths as conditioning variables. It is not immediately clear what is the best way to consume a path as a conditioning variable for a given generator.
3. "Unseen" conditioning variables. It is not guaranteed that the conditional generator will behave in an expected way if an as-yet unseen conditioning variable is provided (by unseen, we are referring to within the training procedure). These conditioning variables are often the ones of interest.
Our procedure attempts to solve the first and second problems with our architecture choices on the conditional generator, and our choice of loss function. The third issue is omnipresent in conditional modelling.
The generator now is given by a (conditional) Neural SDE with architecture given by
$$
Y _ {0} = \xi_ {\theta} (x _ {t _ {0}}, C (x)), \quad d Y _ {t} = \mu_ {\theta} (t, Y _ {t}, C (x)) d t + \sigma_ {\theta} (t, Y _ {t}, C (x)) \circ d W _ {t}, \quad X _ {t} = \pi_ {\theta} (Y _ {t}, C (x))
$$
for  $\mu_{\theta}:[t_0,t_0 + dt']\times \mathbb{R}^y\times \mathbb{R}^{d_C}\to \mathbb{R}^y,\sigma_{\theta}:[t_0,t_0 + dt']\times \mathbb{R}^x\times \mathbb{R}^{d_C}\to \mathbb{R}^{x\times w},\xi_{\theta}:\mathbb{R}^x\times \mathbb{R}^{d_C}\to \mathbb{R}^y$  and  $\pi_{\theta}:\mathbb{R}^{y}\times \mathbb{R}^{d_{C}}\to \mathbb{R}^{x}$ . Here,  $C(x)$  denotes the function acting on the conditioning path and encoding it as a vector in  $\mathbb{R}^{d_C}$ . A natural way to perform this encoding is via the truncated signature  $S^{M}(X)$  of the path  $x$ . In this way the neural networks defining the vector fields in the generator (for instance) are now mappings
$$
\mu_ {\theta}: [ t _ {0}, t _ {0} + d t ^ {\prime} ] \times \mathbb {R} ^ {y} \times \mathbb {R} ^ {1 + d + d ^ {2} + \dots + d ^ {N}} \to \mathbb {R} ^ {y},
$$
$$
\sigma_ {\theta}: [ t _ {0}, t _ {0} + d t ^ {\prime} ] \times \mathbb {R} ^ {y} \times \mathbb {R} ^ {1 + d + d ^ {2} + \dots + d ^ {N}} \to \mathbb {R} ^ {y \times w}.
$$
We note here that all of the regularity conditions required to ensure a strong solution to the standard Neural SDE here remain satisfied; we are only augmenting each of the trainable components to accept the encoded conditioning path. We also note here that this technique is flexible enough to include any amount of  $\mathbb{R}^d$  -valued conditioning variables.
Data processing and hyperparameters Data comes from 15-minute close prices associated to the EUR/USD price pair. We again extracted paths of length 48 (normalising for erroneous terminal times as per the unconditional setting) and split these paths into conditioning-resultant pairs  $\{x^i, y^i\}_{i=1}^N$  with  $x^i$  representing the first 32 observations and  $y^i$  the next 16. We normalized both sets of paths by their initial value. Instead of standardizing, in this setting we scaled all path values up by a factor of 100. We found this was crucial so that the lower-order signature terms did not overly contribute to the value of the signature kernel. Both conditioning and resultant paths were then translated to start at 0. In total the dataset size was comprised of 52428 conditioning/resultant pairs.