def test_lpol2index_index2lpol():
process = ArmaProcess([1, 0, 0, -0.8])
coefs, locs = lpol2index(process.arcoefs)
assert_almost_equal(coefs, [0.8])
assert_equal(locs, [2])
process = ArmaProcess([1, 0.1, 0.1, -0.8])
coefs, locs = lpol2index(process.arcoefs)
assert_almost_equal(coefs, [-0.1, -0.1, 0.8])
assert_equal(locs, [0, 1, 2])
ar = index2lpol(coefs, locs)
assert_equal(process.arcoefs, ar)
def test_empty_coeff(self):
process = ArmaProcess()
assert_equal(process.arcoefs, np.array([]))
assert_equal(process.macoefs, np.array([]))
process = ArmaProcess([1, -0.8])
assert_equal(process.arcoefs, np.array([0.8]))
assert_equal(process.macoefs, np.array([]))
process = ArmaProcess(ma=[1, -0.8])
assert_equal(process.arcoefs, np.array([]))
assert_equal(process.macoefs, np.array([-0.8]))
def get_synthetic_ts_data_period(n_steps=1000,
forecast_length=1,
max_window_size=50):
simulated_data = ArmaProcess().generate_sample(nsample=n_steps)
x1 = np.arange(0, n_steps)
x2 = np.arange(0, n_steps) + 1
simulated_data = simulated_data + x1 * 0.0005 - x2 * 0.0001
periodicity = np.sin(x1 / 50)
simulated_data = simulated_data + periodicity
task = Task(
TaskTypesEnum.ts_forecasting,
TsForecastingParams(forecast_length=forecast_length,
max_window_size=max_window_size,
return_all_steps=False))
data = InputData(idx=np.arange(0, n_steps),
features=np.asarray([x1, x2]).T,
target=simulated_data,
task=task,
data_type=DataTypesEnum.ts)
return train_test_data_setup(data)
def _gen_ar2(do_fit=True):
phi = np.r_[0.9, 0.05]
ar2 = ArmaProcess(ar=np.r_[1, -phi], nobs=500)
y = ar2.generate_sample()
assert ar2.isstationary and ar2.isinvertible
fit = sm.tsa.ARMA(y, (2, 0)).fit() if do_fit else None
return y, fit
def arima_process(size, ar_coefs, ma_coefs, d=0):
"""Simulate a series from an arima model."""
arma = ArmaProcess(ar_coefs, ma_coefs)
arma_series = arma.generate_sample(size + d)
# Integrate d times.
for i in six.moves.range(d):
arma_series = np.cumsum(arma_series)
return pd.Series(arma_series)
def generate_noise(timepoints=200, scale=0.01):
np.random.seed(12345)
# make the noise component
rho = 0.12
ar = np.array([1, -rho]) # statmodels says to invert rho
ap = ArmaProcess(ar)
err = ap.generate_sample(timepoints, scale=scale, axis=0)
return err
def simulate_ar1_time_series():
# Plot 1: AR parameter = +0.9
plt.subplot(2, 1, 1)
ar1 = np.array([1, -0.9])
ma1 = np.array([1])
AR_object1 = ArmaProcess(ar1, ma1)
simulated_data_1 = AR_object1.generate_sample(nsample=1000)
plt.plot(simulated_data_1)
# Plot 1: AR parameter = -0.9
plt.subplot(2, 1, 2)
ar2 = np.array([1, 0.9])
ma2 = np.array([1])
AR_object2 = ArmaProcess(ar2, ma2)
simulated_data_2 = AR_object2.generate_sample(nsample=1000)
plt.plot(simulated_data_2)
plt.show()
def test_lower_upper_percentile():
np.random.seed(1)
ar = np.r_[1, 0.9]
ma = np.array([1])
arma_process = ArmaProcess(ar, ma)
X = 100 + arma_process.generate_sample(nsample=100)
y = 1.2 * X + np.random.normal(size=(100))
data = pd.DataFrame({'y': y, 'X': X}, columns=['y', 'X'])
ci = CausalImpact(data, [0, 69], [70, 99])
ci.lower_upper_percentile == [2.5, 97.5]
def test_default_causal_cto_no_signal():
np.random.seed(1)
ar = np.r_[1, 0.9]
ma = np.array([1])
arma_process = ArmaProcess(ar, ma)
X = 100 + arma_process.generate_sample(nsample=100)
y = 1.2 * X + np.random.normal(size=(100))
data = pd.DataFrame({'y': y, 'X': X}, columns=['y', 'X'])
ci = CausalImpact(data, [0, 69], [70, 99])
assert ci.p_value > 0.05
def sample_random_walk_arma(X0, realisations):
np.random.seed(1234)
# ARMA(1,1)
arparams = np.array([1])
maparams = np.array([0])
# include zero-th lag
arparams = np.r_[1, -arparams]
maparams = np.r_[1, maparams]
arma_t = ArmaProcess(arparams, maparams)
return arma_t.generate_sample(nsample=realisations)
def ar_example1():
from statsmodels.tsa.arima_process import ArmaProcess
# Plot 1: AR parameter = +0.9
plt.subplot(2, 1, 1)
ar1 = np.array([1, -0.9])
ma1 = np.array([1])
AR_object1 = ArmaProcess(ar1, ma1)
simulated_data_1 = AR_object1.generate_sample(nsample=1000)
plt.plot(simulated_data_1)
# Plot 2: AR parameter = -0.9
plt.subplot(2, 1, 2)
ar2 = np.array([1, 0.9])
ma2 = np.array([1])
AR_object2 = ArmaProcess(ar2, ma2)
simulated_data_2 = AR_object2.generate_sample(nsample=1000)
plt.plot(simulated_data_2)
plt.show()
def __init__(self, s: int, rho: int):
"""
Constructor for process.
:param s: (int): Scale factor.
:param rho: (int): Autoregressive parameter.
"""
self.ar = np.array([s, -s * rho])
self.ma = np.array([1])
self.process = ArmaProcess(self.ar, self.ma)
def sample_MA_process_ARMA(mu, theta, realisations):
np.random.seed(1234)
dist = lambda size: np.random.normal(0, 1, size)
arparams = np.array([])
maparams = np.array(theta)
# include zero-th lag
arparams = np.r_[1, arparams]
maparams = np.r_[1, maparams]
arma_t = ArmaProcess(arparams, maparams)
return arma_t.generate_sample(nsample=realisations, distrvs=dist)
def gen_arma(n_probes=20000, n_patients=80, corr=0.2, df=2, scale=0.2):
# these parameters are taken from the Bump Hunting Paper
from statsmodels.tsa.arima_process import ArmaProcess
sigma = 0.5
rvs = ss.norm(df, loc=0.05 / sigma, scale=scale).rvs
corr = -abs(corr)
return np.column_stack([
sigma * ArmaProcess([1, corr], [1]).generate_sample(n_probes=n_probes,
distrvs=rvs)
for i in range(n_patients)
])
def data():
ar = np.r_[1, 0.9]
ma = np.array([1])
arma_process = ArmaProcess(ar, ma)
X = 1 + arma_process.generate_sample(nsample=100)
X = X.reshape(-1, 1)
y = 1.2 * X + np.random.normal(size=(100, 1))
data = np.concatenate((y, X), axis=1)
data = pd.DataFrame(data)
return data
def test_causal_cto_w_positive_signal_no_standardization():
np.random.seed(1)
ar = np.r_[1, 0.9]
ma = np.array([1])
arma_process = ArmaProcess(ar, ma)
X = 100 + arma_process.generate_sample(nsample=100)
y = 1.2 * X + np.random.normal(size=(100))
y[70:] += 1
data = pd.DataFrame({'y': y, 'X': X}, columns=['y', 'X'])
ci = CausalImpact(data, [0, 69], [70, 99], standardize=False)
assert ci.p_value < 0.05
def estimate_order_of_model_pacf():
# Simulate AR(1) with phi=+0.6
ma = np.array([1])
ar = np.array([1, -0.6])
AR_object = ArmaProcess(ar, ma)
simulated_data_1 = AR_object.generate_sample(nsample=5000)
# Plot PACF for AR(1)
plot_pacf(simulated_data_1, lags=20)
plt.show()
# Simulate AR(2) with phi1=+0.6, phi2=+0.3
ma = np.array([1])
ar = np.array([1, -0.6, -0.3])
AR_object = ArmaProcess(ar, ma)
simulated_data_2 = AR_object.generate_sample(nsample=5000)
# Plot PACF for AR(2)
plot_pacf(simulated_data_2, lags=20)
plt.show()
def get_ts(N, p=0, q=0):
"""
p is the number of poles
q is the number of nills
Generates stable processes.
"""
model = ArmaProcess(poles(p // 2), poles(q // 2))
return model, model.generate_sample(N)
def equivalence_of_ar1_and_ma_infinity(intraday):
# Build a list MA parameters
ma = [0.8**i for i in range(30)]
# Simulate the MA(30) model
ar = np.array([1])
AR_object = ArmaProcess(ar, ma)
simulated_data = AR_object.generate_sample(nsample=5000)
# Plot the ACF
plot_acf(simulated_data, lags=30)
plt.show()
def get_synthetic_ts_data(n_steps=10000) -> InputData:
simulated_data = ArmaProcess().generate_sample(nsample=n_steps)
x1 = np.arange(0, n_steps)
x2 = np.arange(0, n_steps) + 1
simulated_data = simulated_data + x1 * 0.0005 - x2 * 0.0001
input_data = InputData(idx=np.arange(0, n_steps),
features=np.asarray([x1, x2]).T,
target=simulated_data,
task_type=MachineLearningTasksEnum.auto_regression)
return input_data
def simulate_ar2_time_series():
fig, axes = plt.subplots(3, 1)
ar = np.array([2, -0.9, -0.8])
ma = np.array([1])
arma = ArmaProcess(ar, ma)
simulated = arma.generate_sample(nsample=1000)
axes[0].plot(simulated)
axes[0].set_title("AR(2, [0.9, 0.8]), MA(1, 0)")
plot_acf(simulated, ax=axes[1])
plot_pacf(simulated, ax=axes[2])
plt.show()
def generate_test_dataset():
n = 100
ar = np.r_[1, 0.9]
ma = np.array([1])
arma_process = ArmaProcess(ar, ma)
x1 = 8 + arma_process.generate_sample(nsample=n)
x2 = 12 + arma_process.generate_sample(nsample=n)
x3 = 3 + arma_process.generate_sample(nsample=n)
y = 1.2 * x1 + 4.0 * x2 + 0.0 * x3 + np.random.normal(size=n)
t = range(1, n + 1)
y[70:] += 5
return pd.DataFrame({"y": y, "x1": x1, "x2": x2, "x3": x3, "t": t})
def generate_stoch_ar1(nt, a1):
"""
Generate AR1 process for strong noisy source
Input:
nt - number of timesteps.
a1 - interior parameter.
Output:
np.array with values of size (nt,).
"""
ar_par = np.array([1.0, a1])
ma = np.array([1.0])
simulated_ar1 = ArmaProcess(ar_par, ma).generate_sample(nsample=nt)
return simulated_ar1 / np.std(simulated_ar1)
def test_from_model(self):
process = ArmaProcess([1, -.8], [1, .3], 1000)
t = 1000
rs = np.random.RandomState(12345)
y = process.generate_sample(t, burnin=100, distrvs=rs.standard_normal)
res = ARMA(y, (1, 1)).fit(disp=False)
process_model = ArmaProcess.from_estimation(res)
process_coef = ArmaProcess.from_coeffs(res.arparams, res.maparams, t)
assert_equal(process_model.arcoefs, process_coef.arcoefs)
assert_equal(process_model.macoefs, process_coef.macoefs)
assert_equal(process_model.nobs, process_coef.nobs)
assert_equal(process_model.isinvertible, process_coef.isinvertible)
assert_equal(process_model.isstationary, process_coef.isstationary)
def compare_the_acf_for_several_ar_time_series():
ar_parameters = [0.9, -0.9, 0.3]
fig, axes = plt.subplots(3, 1, sharex=True)
for i, p in enumerate(ar_parameters):
ar = np.array([1, -p])
ma = np.array([1])
ar_object = ArmaProcess(ar, ma)
simulated_data = ar_object.generate_sample(nsample=1000)
plot_acf(simulated_data, ax=axes[i])
axes[i].set_title("AR parameter φ = %4.2f" % (p))
fig.suptitle("Comparison of ACF")
plt.show()
def mc_ar1_ARMA(self, phi, std, n, N=1000):
""" Monte-Carlo AR(1) processes
input:
phi .. (estimated) lag-1 autocorrelation
std .. (estimated) standard deviation of noise
n .. length of original time series
N .. number of MC simulations
"""
AR_object = ArmaProcess(np.array([1, -phi]), np.array([1]), nobs=n)
mc = AR_object.generate_sample(nsample=(N, n),
scale=std,
axis=1,
burnin=1000)
return mc
def test_simulated_y_default_model():
np.random.seed(1)
ar = np.r_[1, 0.9]
ma = np.array([1])
arma_process = ArmaProcess(ar, ma)
X = 100 + arma_process.generate_sample(nsample=100)
y = 1.2 * X + np.random.normal(size=(100))
data = pd.DataFrame({'y': y, 'X': X}, columns=['y', 'X'])
ci = CausalImpact(data, [0, 69], [70, 99])
assert ci.simulated_y.shape == (1000, 30)
lower, upper = np.percentile(ci.simulated_y.mean(axis=1), [5, 95])
assert lower > 119
assert upper < 121
def do_one_res_bootstrap(n, slope_hat, residuals):
rand_res = lambda size: np.random.choice(residuals, size)
ar = np.array([1, -slope_hat])
ma = np.array([1])
AR_res = ArmaProcess(ar,ma)
data = AR_res.generate_sample(nsample = n + 1, scale = 1, distrvs = rand_res)
x = data[0:(n-1)]
y = data[1:n]
slope = solve(x, y)
stderr = calc_StdErr(slope, x, y)
T = (slope - slope_hat) / stderr
return T
def make_trend(series_len,
method='rw',
arma=[.25, .6],
rw_loc=0.0,
rw_scale=0.1,
seed=1):
""" Module to generate time-series trend with different methods
Parameters
----------
series_len: int
Total length of series
method: str ['arma', 'rw']
In case of `'rw'`, a simple random walk process will be used. For `'arma'`, we will use `statsmodels.api` to
simulate a simple ARMA(1, 1) process
arma: list
List [arparams, maparams] of size 2 where used for arma(1) generating process
rw_loc: float
Location parameter of random walk generated by `np.random.normal()`
rw_scale: float
Scale parameter of random walk generated by `np.random.normal()`
seed: int
Seed passed into `np.random.default_rng()`
Returns
-------
np.array-llike
Simulated trend with length equals `series_len`
Notes
-----
1. ARMA process: https://www.statsmodels.org/stable/generated/statsmodels.tsa.arima_process.ArmaProcess.html
"""
# make trend
if method == "rw":
rw = np.random.default_rng(seed).normal(rw_loc, rw_scale, series_len)
trend = np.cumsum(rw)
elif method == "arma":
arparams = np.array([arma[0]])
maparams = np.array([arma[1]])
# add zero-lag and negate
ar = np.r_[1, -arparams]
# add zero-lag
ma = np.r_[1, maparams]
arma_process = ArmaProcess(ar, ma)
trend = arma_process.generate_sample(series_len)
else:
raise IllegalArgument("Invalid trend method.")
return trend
def get_synthetic_ts_data(n_steps=10000) -> InputData:
simulated_data = ArmaProcess().generate_sample(nsample=n_steps)
x1 = np.arange(0, n_steps)
x2 = np.arange(0, n_steps) + 1
simulated_data = simulated_data + x1 * 0.0005 - x2 * 0.0001
task = Task(TaskTypesEnum.ts_forecasting,
TsForecastingParams(forecast_length=1, max_window_size=2))
input_data = InputData(idx=np.arange(0, n_steps),
features=np.asarray([x1, x2]).T,
target=simulated_data,
task=task,
data_type=DataTypesEnum.ts)
return input_data
