def run_test():
time_sampler = ts.TimeSampler(stop_time=20)
irregular_time_samples = time_sampler.sample_irregular_time(num_points=500, keep_percentage=50)
dde = ts.signals.MackeyGlass()
samples = dde.sample_vectorized(irregular_time_samples)
single_sample = dde.sample_next(irregular_time_samples[0], None, None)
return samples, single_sample
def es():
open = 2873
# Initializing TimeSampler
time_sampler = ts.TimeSampler(stop_time=7200)
# # Sampling irregular time samples
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=7200, keep_percentage=30)
car = ts.signals.CAR(ar_param=0.9, sigma=3)
car_series = ts.TimeSeries(signal_generator=car)
samples = car_series.sample(irregular_time_samples)
samples[0][:] += open
obsims = [
OrderBookSim(
Instrument('ESU18', datetime(2018, 9, 21), emini_spread, 1),
MinuteBarGenerator(), 2879, open, 0, 10, (10, 1000)),
OrderBookSim(
Instrument('ESZ18', datetime(2018, 12, 21), emini_spread, 0.8),
MinuteBarGenerator(), 2883.75, open, 4.75, 20, (10, 100)),
OrderBookSim(
Instrument('ESH18', datetime(2019, 3, 15), emini_spread, 0.7),
MinuteBarGenerator(), 2890.75, open, 11.75, 25, (5, 50)),
OrderBookSim(
Instrument('ESM18', datetime(2019, 6, 21), emini_spread, 0.5),
MinuteBarGenerator(), 2899, open, 20, 30, (1, 10)),
OrderBookSim(
Instrument('ESU19', datetime(2019, 9, 20), emini_spread, 0.3),
MinuteBarGenerator(), 2902, open, 23, 40, (1, 10))
]
run_sim(obsims, irregular_time_samples, samples)
def crude():
open = 67.88
# Initializing TimeSampler
time_sampler = ts.TimeSampler(stop_time=7200)
# # Sampling irregular time samples
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=7200, keep_percentage=30)
car = ts.signals.CAR(ar_param=0.9, sigma=3)
car_series = ts.TimeSeries(signal_generator=car)
samples = car_series.sample(irregular_time_samples)
samples[0][:] += open
obsims = [
OrderBookSim(
Instrument('CLV18', datetime(2018, 9, 20), crude_spread, 1),
MinuteBarGenerator(), 67.88, open, 0, 10, (10, 1000)),
OrderBookSim(
Instrument('CLX18', datetime(2018, 10, 22), crude_spread, 0.8),
MinuteBarGenerator(), 67.72, open, -.1, 20, (10, 100)),
OrderBookSim(
Instrument('CLZ18', datetime(2018, 11, 19), crude_spread, 0.7),
MinuteBarGenerator(), 67.63, open, -.25, 25, (5, 50)),
OrderBookSim(
Instrument('CLF19', datetime(2018, 12, 19), crude_spread, 0.5),
MinuteBarGenerator(), 67.44, open, -.4, 30, (1, 10)),
OrderBookSim(
Instrument('CLG19', datetime(2019, 1, 22), crude_spread, 0.3),
MinuteBarGenerator(), 67.28, open, -.6, 40, (1, 10))
]
run_sim(obsims, irregular_time_samples, samples)
def eurodollar():
open = 97.6425
# Initializing TimeSampler
time_sampler = ts.TimeSampler(stop_time=7200)
# # Sampling irregular time samples
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=7200, keep_percentage=30)
car = ts.signals.CAR(ar_param=0.9, sigma=3)
car_series = ts.TimeSeries(signal_generator=car)
samples = car_series.sample(irregular_time_samples)
samples[0][:] += open
obsims = [
OrderBookSim(
Instrument('EDU18', datetime(2018, 9, 17), eurodollar_spread, 1),
MinuteBarGenerator(), 97.6425, open, 0, 10, (10, 1000)),
OrderBookSim(
Instrument('EDZ18', datetime(2018, 12,
17), eurodollar_spread, 0.8),
MinuteBarGenerator(), 97.345, open, -0.3, 20, (10, 100)),
OrderBookSim(
Instrument('EDH18', datetime(2019, 3, 18), eurodollar_spread, 0.7),
MinuteBarGenerator(), 97.185, open, -0.5, 25, (5, 50)),
OrderBookSim(
Instrument('EDM18', datetime(2019, 6, 17), eurodollar_spread, 0.5),
MinuteBarGenerator(), 97.06, open, -0.7, 30, (1, 10)),
OrderBookSim(
Instrument('EDU19', datetime(2019, 9, 16), eurodollar_spread, 0.3),
MinuteBarGenerator(), 97.00, open, -0.9, 40, (1, 10))
]
run_sim(obsims, irregular_time_samples, samples)
def generate_sequence():
time_sampler = ts.TimeSampler(stop_time=20)
time_sampler = ts.TimeSampler(stop_time=20)
sinusoid = ts.signals.Sinusoidal(frequency=0.25)
white_noise = ts.noise.GaussianNoise(std=0.3)
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=2000, keep_percentage=100)
# print(irregular_time_samples)
timeseries = ts.TimeSeries(sinusoid, noise_generator=white_noise)
samples, signals, errors = timeseries.sample(irregular_time_samples)
samples = (samples * 10)
samples = samples.astype(int)
samples = np.absolute(samples)
samples = samples % 11
#print(len(samples))
return samples
def run_test():
time_sampler = ts.TimeSampler(stop_time=20)
irregular_time_samples = time_sampler.sample_irregular_time(num_points=500, keep_percentage=50)
white_noise = ts.noise.GaussianNoise(std=0.3)
wnoise_vec = white_noise.sample_vectorized(irregular_time_samples)
wnoise_value = white_noise.sample_next(irregular_time_samples[0],
None, None)
return wnoise_vec, wnoise_value
def Time_series_Gaussian(t):
time_sampler = ts.TimeSampler(stop_time=t)
regular_time_samples = time_sampler.sample_regular_time(num_points=t)
gp = ts.signals.GaussianProcess(kernel='Matern', nu=3. / 2)
gp_series = ts.TimeSeries(signal_generator=gp)
samples = gp_series.sample(regular_time_samples)[0]
return samples
def ir_Time_series_Gaussian(t):
time_sampler = ts.TimeSampler(stop_time=t)
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=100, keep_percentage=50)
gp = ts.signals.GaussianProcess(kernel='Matern', nu=3. / 2)
gp_series = ts.TimeSeries(signal_generator=gp)
samples = gp_series.sample(irregular_time_samples)[0]
return (samples, irregular_time_samples)
def Time_series_CAR(t):
time_sampler = ts.TimeSampler(stop_time=t)
regular_time_samples = time_sampler.sample_regular_time(num_points=t)
car = ts.signals.CAR(ar_param=0.9, sigma=0.01)
car_series = ts.TimeSeries(signal_generator=car)
samples = car_series.sample(regular_time_samples)
# plt.plot(regular_time_samples, samples[0], marker='o', markersize=4)
return samples[0]
def ir_Time_series_CAR(t):
time_sampler = ts.TimeSampler(stop_time=t)
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=500, keep_percentage=50)
car = ts.signals.CAR(ar_param=0.9, sigma=0.01)
car_series = ts.TimeSeries(signal_generator=car)
samples = car_series.sample(irregular_time_samples)
return (samples[0], irregular_time_samples)
def __init__(self, n_samples, sample_time_start, sample_time_end):
self.sample_time_start = sample_time_start
self.sample_time_end = sample_time_end
self.n_samples = n_samples
self.time_sampler = ts.TimeSampler(start_time=self.sample_time_start,
stop_time=self.sample_time_end)
self.time_samples = self.time_sampler.sample_regular_time(
num_points=self.n_samples)
def generate_timeseries(signals,
T=100, #
noise_std=0.01, #
transforms=None, #
transforms_std=None
):
# used to define the time scale
time_sampler = ts.TimeSampler(stop_time=T // 5)
# create the time samples
regular_time_samples = time_sampler.sample_regular_time(num_points=T)
# define the standard gaussian white noise to add
white_noise = ts.noise.GaussianNoise(std=noise_std)
# the list of all the time serieses
timeserieses = []
for signal_type, params in signals:
if signal_type == "sinusoid": # sinusoidal signal
sinusoid = ts.signals.Sinusoidal(**params)
timeserieses.append(ts.TimeSeries(sinusoid, noise_generator=white_noise))
if signal_type == "ar": # autoregressive process
ar_p = ts.signals.AutoRegressive(**params)
timeserieses.append(ts.TimeSeries(signal_generator=ar_p))
if signal_type == "car": # autoregressive process
car_p = ts.signals.CAR(**params)
timeserieses.append(ts.TimeSeries(signal_generator=car_p))
if signal_type == "gp": # gaussian process
gp = ts.signals.GaussianProcess(**params)
timeserieses.append(ts.TimeSeries(gp, noise_generator=white_noise))
# convert to numpy array and select only the signals
output_samples = np.array([cur_timeseries.sample(regular_time_samples)[0]
for cur_timeseries in timeserieses])
# apply transforms to obtain correlated time series. Each transformation will be
# applied to each time series sequence. So only the original/untransformed sequences
# will be truly uncorrelated
if transforms is not None:
# if no noise/standard deviation was given for the transformations just use the noise_std
if transforms_std is None:
transforms_std = [noise_std] * len(transforms)
# apply the transforms
output_samples_transforms = output_samples
for f_idx, f in enumerate(transforms):
std = transforms_std[f_idx]
transformed_seq = f(output_samples) + np.random.randn(T) * std
output_samples_transforms = np.append(output_samples_transforms,
transformed_seq,
axis=0)
output_samples = output_samples_transforms
# transpose to allow [time x features]
return output_samples.T
def createSample(args, Target, start_ImpTS, end_ImpTS, start_ImpFeat,
end_ImpFeat):
if (args.DataGenerationProcess == None):
sample = np.random.normal(0, 1, [args.NumTimeSteps, args.NumFeatures])
Features = np.random.normal(Target, 1,
[args.ImpTimeSteps, args.ImpFeatures])
sample[start_ImpTS:end_ImpTS, start_ImpFeat:end_ImpFeat] = Features
# print(start_ImpFeat,end_ImpFeat)
else:
time_sampler = ts.TimeSampler(stop_time=20)
sample = np.zeros([args.NumTimeSteps, args.NumFeatures])
if (args.Sampler == "regular"):
time = time_sampler.sample_regular_time(
num_points=args.NumTimeSteps * 2, keep_percentage=50)
else:
time = time_sampler.sample_irregular_time(
num_points=args.NumTimeSteps * 2, keep_percentage=50)
for i in range(args.NumFeatures):
if (args.DataGenerationProcess == "Harmonic"):
signal = ts.signals.Sinusoidal(frequency=args.Frequency)
elif (args.DataGenerationProcess == "GaussianProcess"):
signal = ts.signals.GaussianProcess(kernel=args.Kernal,
nu=3. / 2)
elif (args.DataGenerationProcess == "PseudoPeriodic"):
signal = ts.signals.PseudoPeriodic(frequency=args.Frequency,
freqSD=0.01,
ampSD=0.5)
elif (args.DataGenerationProcess == "AutoRegressive"):
signal = ts.signals.AutoRegressive(ar_param=[args.ar_param])
elif (args.DataGenerationProcess == "CAR"):
signal = ts.signals.CAR(ar_param=args.ar_param, sigma=0.01)
elif (args.DataGenerationProcess == "NARMA"):
signal = ts.signals.NARMA(order=args.Order)
if (args.hasNoise):
noise = ts.noise.GaussianNoise(std=0.3)
timeseries = ts.TimeSeries(signal, noise_generator=noise)
else:
timeseries = ts.TimeSeries(signal)
feature, signals, errors = timeseries.sample(time)
sample[:, i] = feature
sample[start_ImpTS:end_ImpTS, start_ImpFeat:end_ImpFeat] = sample[
start_ImpTS:end_ImpTS, start_ImpFeat:end_ImpFeat] + Target
return sample
def generate_data(phi, sigma, num_points):
time_sampler = ts.TimeSampler(stop_time=20)
irregular_time_samples = time_sampler.sample_irregular_time(num_points=num_points,
keep_percentage=50)
irregular_time_samples_diff = np.diff(np.append(0, irregular_time_samples))
signal = np.zeros(len(irregular_time_samples)+1)
noise_samples = np.random.normal(size=len(irregular_time_samples))
for i in range(len(irregular_time_samples)):
signal[i+1] = np.power(phi, irregular_time_samples_diff[i])*signal[i] + \
sigma*np.sqrt(1 - np.power(phi, 2*irregular_time_samples_diff[i]))*noise_samples[i]
return irregular_time_samples, signal[1:]
def generate_car(self):
time_sampler = ts.TimeSampler()
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=self.num_points)
ar_param = random.uniform(0, 1)
sigma = random.uniform(0.01, .11)
car = ts.signals.CAR(ar_param=ar_param, sigma=sigma)
car_series = ts.TimeSeries(signal_generator=car)
samples = car_series.sample(irregular_time_samples)[0]
return samples + 10
def gaussian(steps, min, max):
gp = ts.signals.GaussianProcess(kernel='Matern', nu=3.0 / 2)
gp_series = ts.TimeSeries(signal_generator=gp)
time_sampler = ts.TimeSampler(stop_time=steps)
regular_time_samples = time_sampler.sample_regular_time(num_points=steps)
samples = gp_series.sample(regular_time_samples)[0]
ret = []
interpolator = interp1d([samples.min(), samples.max()], [min, max])
for s in samples:
ret.append(int(interpolator(s)))
return ret
def car(steps, min, max):
car = ts.signals.CAR(ar_param=0.9, sigma=0.01)
car_series = ts.TimeSeries(signal_generator=car)
time_sampler = ts.TimeSampler(stop_time=steps)
regular_time_samples = time_sampler.sample_regular_time(num_points=steps)
samples, signals, errors = car_series.sample(regular_time_samples)
ret = []
interpolator = interp1d([samples.min(), samples.max()], [min, max])
for s in samples:
ret.append(int(interpolator(s)))
return ret
def ar(steps, min, max):
# Initializing TimeSampler
time_sampler = ts.TimeSampler(stop_time=steps)
# Sampling regular time samples
regular_time_samples = time_sampler.sample_regular_time(num_points=steps)
# Initializing AR(2) model
ar_p = ts.signals.AutoRegressive(ar_param=[1.5, -0.75])
ar_p_series = ts.TimeSeries(signal_generator=ar_p)
samples, signals, errors = ar_p_series.sample(regular_time_samples)
interpolator = interp1d([samples.min(), samples.max()], [min, max])
ret = []
for s in samples:
ret.append(int(interpolator(s)))
return ret
def generate_sinusoidal(self):
time_sampler = ts.TimeSampler()
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=self.num_points)
frequency = random.random()
std = random.random()
sinusoid = ts.signals.Sinusoidal(frequency=frequency)
white_noise = ts.noise.GaussianNoise(std=std)
timeseries = ts.TimeSeries(sinusoid, noise_generator=white_noise)
samples, signals, errors = timeseries.sample(irregular_time_samples)
if random.random() > .5:
trend = random.uniform(-.01, .01)
samples = samples + trend * np.array(range(self.num_points))
return samples + 10
def generate_psuedoperiodic(self):
time_sampler = ts.TimeSampler()
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=self.num_points)
frequency = random.random() * 2
freqSD = random.uniform(.005, .1)
pseudo_periodic = ts.signals.PseudoPeriodic(frequency=frequency,
freqSD=freqSD,
ampSD=0.5)
timeseries_pp = ts.TimeSeries(pseudo_periodic)
samples, signals, errors = timeseries_pp.sample(irregular_time_samples)
if random.random() > .5:
trend = random.uniform(-.01, .01)
samples = samples + trend * np.array(range(self.num_points))
return samples + 10
def generateNewSample(data_generation_process, num_timesteps, num_features,
sampler, frequency, kernel, ar_param, order, has_noise):
if data_generation_process is None:
sample = np.random.normal(0, 1, [num_timesteps, num_features])
else:
time_sampler = ts.TimeSampler(stop_time=20)
sample = np.zeros([num_timesteps, num_features])
if sampler == "regular":
time = time_sampler.sample_regular_time(num_points=num_timesteps *
2,
keep_percentage=50)
else:
time = time_sampler.sample_irregular_time(
num_points=num_timesteps * 2, keep_percentage=50)
for i in range(num_features):
if data_generation_process == "Harmonic":
signal = ts.signals.Sinusoidal(frequency=frequency)
elif data_generation_process == "GaussianProcess":
signal = ts.signals.GaussianProcess(kernel=kernel, nu=3. / 2)
elif data_generation_process == "PseudoPeriodic":
signal = ts.signals.PseudoPeriodic(frequency=frequency,
freqSD=0.01,
ampSD=0.5)
elif data_generation_process == "AutoRegressive":
signal = ts.signals.AutoRegressive(ar_param=[ar_param])
elif data_generation_process == "CAR":
signal = ts.signals.CAR(ar_param=ar_param, sigma=0.01)
elif data_generation_process == "NARMA":
signal = ts.signals.NARMA(order=order)
if has_noise:
noise = ts.noise.GaussianNoise(std=0.3)
timeseries = ts.TimeSeries(signal, noise_generator=noise)
else:
timeseries = ts.TimeSeries(signal)
feature, signals, errors = timeseries.sample(time)
sample[:, i] = feature
return sample
def generate_syntethic_timeseries(ampSD=0.5, frequency=2, freqSD=0.01, n=784):
time_sampler_pp = ts.TimeSampler(stop_time=24)
irregular_time_samples_pp = time_sampler_pp.sample_irregular_time(
num_points=2 * n, keep_percentage=50)
# Initializing Pseudoperiodic signal
pseudo_periodic = ts.signals.PseudoPeriodic(frequency=frequency,
freqSD=freqSD,
ampSD=ampSD)
# Initializing Gaussian noise
white_noise = ts.noise.GaussianNoise(std=0.3)
# Initializing TimeSeries class with the pseudoperiodic signal
timeseries_pp = ts.TimeSeries(pseudo_periodic, noise_generator=white_noise)
# Sampling using the irregular time samples
samples_pp = timeseries_pp.sample(irregular_time_samples_pp)[0]
# gp = ts.signals.GaussianProcess(kernel='Matern', nu=3./2)
# gp_series = ts.TimeSeries(signal_generator=gp)
# samples = gp_series.sample(irregular_time_samples)[0]
return samples_pp
def get_sinusoidal_timeseries(configuration):
"""
@param configuration: timeseries configuration defining attributes of data points
@return: a list of rescaled sinusoidal-shaped data points based on given configuration
"""
time_sampler = ts.TimeSampler(stop_time=get_num_points(configuration))
regular_time_samples = time_sampler.sample_regular_time(
num_points=get_num_points(configuration))
sinusoid = ts.signals.Sinusoidal(
frequency=configuration.get('frequency', 1.0),
amplitude=configuration.get('amplitude', 1.0))
timeseries = ts.TimeSeries(sinusoid)
datapoints = timeseries.sample(regular_time_samples)[0]
return scale_signal(datapoints, configuration).tolist()
def __init__(self, stop_time, period, amplitude, std, ftype = np.sin, signal_type = ts.signals.Sinusoidal):
# initialize time steps
self.stop_time = stop_time
self.series_length = self.stop_time # this is correct! since starting point range from zero to stop_time e.g. 0__1__2
# when plotting, stop_time will not be shown.
self.time_sampler = ts.TimeSampler(stop_time=self.stop_time)
self.irregular_time_samples = self.time_sampler.sample_irregular_time(num_points=self.stop_time + 1,keep_percentage=100) # + 1 here to fix the bug
# initialize time series pattern
self.period = period
self.amplitude = amplitude
self.std = std
self.ftype = ftype
self.signal_type = signal_type
self.signal_generator = self.signal_type(amplitude=self.amplitude, frequency=1/self.period, ftype=self.ftype)
self.white_noise_generator = ts.noise.GaussianNoise(std=self.std)
self.timeseries = ts.TimeSeries(signal_generator=self.signal_generator, noise_generator=self.white_noise_generator)
# generate data
self.samples, self.signals, self.errors = self.timeseries.sample(self.irregular_time_samples)
import timesynth as ts
time_sampler = ts.TimeSampler()
irregular_time_samples = time_sampler.sample_irregular_time(num_points=500,
keep_percentage=50)
edgecolors="red",
zorder=3)
# plt.xticks(self.bin_edges_invcdf, np.round(self.bin_edges_invcdf), rotation=15)
for i in range(self.nr_bins):
plt.text(self.bin_centers_invcdf[i] - 0.024, np.max(X),
centerText[i])
plt.title("inverse CDF $x = F^{-1}(Q)$")
plt.xlabel("Quantile")
plt.ylabel("X")
plt.show()
if __name__ == "__main__":
import timesynth as ts
# Initializing TimeSampler
time_sampler = ts.TimeSampler(stop_time=500)
# Sampling irregular time samples
irregular_time_samples = time_sampler.sample_irregular_time(
num_points=10000, keep_percentage=20)
# Initializing Sinusoidal signal
sinusoid = ts.signals.Sinusoidal(frequency=0.1)
# Initializing Gaussian noise
white_noise = ts.noise.GaussianNoise(std=0.1)
# Initializing TimeSeries class with the signal and noise objects
timeseries = ts.TimeSeries(sinusoid, noise_generator=white_noise)
# Sampling using the irregular time samples
samples, signals, errors = timeseries.sample(irregular_time_samples)
dataHandler = DataHandler(samples, nr_bins=10, debug=True)
