def test_generate_sample(self):
process = ArmaProcess.from_coeffs([0.9])
np.random.seed(12345)
sample = process.generate_sample()
np.random.seed(12345)
expected = np.random.randn(100)
for i in range(1, 100):
expected[i] = 0.9 * expected[i - 1] + expected[i]
assert_almost_equal(sample, expected)
process = ArmaProcess.from_coeffs([1.6, -0.9])
np.random.seed(12345)
sample = process.generate_sample()
np.random.seed(12345)
expected = np.random.randn(100)
expected[1] = 1.6 * expected[0] + expected[1]
for i in range(2, 100):
expected[i] = 1.6 * expected[i - 1] - 0.9 * expected[i - 2] + expected[i]
assert_almost_equal(sample, expected)
process = ArmaProcess.from_coeffs([1.6, -0.9])
np.random.seed(12345)
sample = process.generate_sample(burnin=100)
np.random.seed(12345)
expected = np.random.randn(200)
expected[1] = 1.6 * expected[0] + expected[1]
for i in range(2, 200):
expected[i] = 1.6 * expected[i - 1] - 0.9 * expected[i - 2] + expected[i]
assert_almost_equal(sample, expected[100:])
np.random.seed(12345)
sample = process.generate_sample(nsample=(100,5))
assert_equal(sample.shape, (100,5))
def test_isstationary(self):
process1 = ArmaProcess.from_coeffs([1.1])
assert_equal(process1.isstationary, False)
process1 = ArmaProcess.from_coeffs([1.8, -0.9])
assert_equal(process1.isstationary, True)
process1 = ArmaProcess.from_coeffs([1.5, -0.5])
print(np.abs(process1.arroots))
assert_equal(process1.isstationary, False)
def test_invertroots(self):
process1 = ArmaProcess.from_coeffs([], [2.5])
process2 = process1.invertroots(True)
assert_almost_equal(process2.ma, np.array([1.0, 0.4]))
process1 = ArmaProcess.from_coeffs([], [0.4])
process2 = process1.invertroots(True)
assert_almost_equal(process2.ma, np.array([1.0, 0.4]))
process1 = ArmaProcess.from_coeffs([], [2.5])
roots, invertable = process1.invertroots(False)
assert_equal(invertable, False)
assert_almost_equal(roots, np.array([1, 0.4]))
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 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 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 _generate_random_arparams(ar_order, ma_order, limit_abs_sum=True, maxiter=100):
is_stationary = False
iteration = 0
while not is_stationary:
iteration += 1
# print("Iteration", iteration)
if iteration > maxiter:
raise RuntimeError("failed to find stationary coefficients")
# Generate random parameters
arparams = []
maparams = []
for i in range(ar_order):
arparams.append(2 * np.random.random() - 1)
for i in range(ma_order):
maparams.append(2 * np.random.random() - 1)
# print(arparams)
arparams = np.array(arparams)
maparams = np.array(maparams)
if limit_abs_sum:
ar_abssum = sum(np.abs(arparams))
ma_abssum = sum(np.abs(maparams))
if ar_abssum > 1:
arparams = arparams / (ar_abssum + 10e-6)
arparams = arparams * (0.5 + 0.5 * np.random.random())
if ma_abssum > 1:
maparams = maparams / (ma_abssum + 10e-6)
maparams = maparams * (0.5 + 0.5 * np.random.random())
arparams = arparams - np.mean(arparams)
maparams = maparams - np.mean(maparams)
arma_process = ArmaProcess.from_coeffs(arparams, maparams, nobs=100)
is_stationary = arma_process.isstationary
return arparams, maparams
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 test_from_estimation(d, seasonal):
ar = [0.8] if not seasonal else [0.8, 0, 0, 0.2, -0.16]
ma = [0.4] if not seasonal else [0.4, 0, 0, 0.2, -0.08]
ap = ArmaProcess.from_coeffs(ar, ma, 500)
idx = pd.date_range(dt.datetime(1900, 1, 1), periods=500, freq="Q")
data = ap.generate_sample(500)
if d == 1:
data = np.cumsum(data)
data = pd.Series(data, index=idx)
seasonal_order = (1, 0, 1, 4) if seasonal else None
mod = ARIMA(data, order=(1, d, 1), seasonal_order=seasonal_order)
res = mod.fit()
ap_from = ArmaProcess.from_estimation(res)
shape = (5,) if seasonal else (1,)
assert ap_from.arcoefs.shape == shape
assert ap_from.macoefs.shape == shape
def test_acf(self):
process1 = ArmaProcess.from_coeffs([.9])
acf = process1.acf(10)
expected = np.array(0.9) ** np.arange(10.0)
assert_array_almost_equal(acf, expected)
acf = process1.acf()
assert_(acf.shape[0] == process1.nobs)
def test_acf(self):
process1 = ArmaProcess.from_coeffs([0.9])
acf = process1.acf(10)
expected = np.array(0.9) ** np.arange(10.0)
assert_array_almost_equal(acf, expected)
acf = process1.acf()
assert_(acf.shape[0] == process1.nobs)
def test_arma_acovf_persistent():
# Test arma_acovf in case where there is a near-unit root.
# .999 is high enough to trigger the "while ir[-1] > 5*1e-5:" clause,
# but not high enough to trigger the "nobs_ir > 50000" clause.
ar = np.array([1, -0.9995])
ma = np.array([1])
process = ArmaProcess(ar, ma)
res = process.acovf(10)
# Theoretical variance sig2 given by:
# sig2 = .9995**2 * sig2 + 1
sig2 = 1 / (1 - 0.9995 ** 2)
corrs = 0.9995 ** np.arange(10)
expected = sig2 * corrs
assert_equal(res.ndim, 1)
assert_allclose(res, expected)
def test_arma_acovf_persistent():
# Test arma_acovf in case where there is a near-unit root.
# .999 is high enough to trigger the "while ir[-1] > 5*1e-5:" clause,
# but not high enough to trigger the "nobs_ir > 50000" clause.
ar = np.array([1, -.9995])
ma = np.array([1])
process = ArmaProcess(ar, ma)
res = process.acovf(10)
# Theoretical variance sig2 given by:
# sig2 = .9995**2 * sig2 + 1
sig2 = 1/(1-.9995**2)
corrs = .9995**np.arange(10)
expected = sig2*corrs
assert_equal(res.ndim, 1)
assert_allclose(res, expected, atol=1e-6)
def test_pacf(self):
process1 = ArmaProcess.from_coeffs([0.9])
pacf = process1.pacf(10)
expected = np.array([1, 0.9] + [0] * 8)
assert_array_almost_equal(pacf, expected)
pacf = process1.pacf()
assert_(pacf.shape[0] == process1.nobs)
def test_pacf(self):
process1 = ArmaProcess.from_coeffs([.9])
pacf = process1.pacf(10)
expected = np.array([1, 0.9] + [0] * 8)
assert_array_almost_equal(pacf, expected)
pacf = process1.pacf()
assert_(pacf.shape[0] == process1.nobs)
def test_from_coeff(self):
ar = [1.8, -0.9]
ma = [0.3]
process = ArmaProcess.from_coeffs(np.array(ar), np.array(ma))
ar.insert(0, -1)
ma.insert(0, 1)
ar_p = -1 * np.array(ar)
ma_p = ma
process_direct = ArmaProcess(ar_p, ma_p)
assert_equal(process.arcoefs, process_direct.arcoefs)
assert_equal(process.macoefs, process_direct.macoefs)
assert_equal(process.nobs, process_direct.nobs)
assert_equal(process.maroots, process_direct.maroots)
assert_equal(process.arroots, process_direct.arroots)
assert_equal(process.isinvertible, process_direct.isinvertible)
assert_equal(process.isstationary, process_direct.isstationary)
def estimating_an_ar_model():
ar = np.array([1, -0.9])
ma = np.array([1])
ar_process = ArmaProcess(ar, ma)
simulated_data = ar_process.generate_sample(nsample=1000)
# Fit an AR(1) model to the first simulated data
mod = ARMA(simulated_data, order=(1, 0))
res = mod.fit()
# Print out summary information on the fit
print(res.summary())
# Print out the estimate for the constant and for phi
print("When the true phi=0.9, the estimate of phi (and the constant) are:")
print(res.params)
return simulated_data, res
def generate_signal(go_onset=2, ss_onset=12, fs_onset=22,
go_pwr=1, ss_pwr=2, fs_pwr=3, noise=0,
design_resolution=0.1, duration=40,
stim_duration=1, tr=1):
rho = 0.12
cond_order = [0, 1, 2]
betas = np.array([go_pwr, ss_pwr, fs_pwr])
onsets = np.array([go_onset, ss_onset, fs_onset])
onsets_res = onsets / design_resolution
onsets_res = onsets_res.astype(int)
duration_res = int(duration / design_resolution)
stim_duration_res = int(stim_duration / design_resolution)
sampling_rate = int(tr / design_resolution)
X = np.zeros((duration_res, onsets.shape[0]))
B = np.zeros((onsets.shape[0], 1))
for idx, (cond, onset) in enumerate(zip(cond_order, onsets_res)):
# set the design matrix
X[onset:onset+stim_duration_res, idx] = 1
X[:, idx] = np.convolve(
X[:, idx], hemodynamic_models._gamma_difference_hrf(
tr, oversampling=sampling_rate))[0:X.shape[0]]
# set the beta for the trial depending on condition
B[idx, :] = betas[cond]
# downsample X so it's back to TR resolution
X = X[::sampling_rate, :]
signal = X @ B
signal = np.squeeze(signal)
if noise > 0.0:
np.random.seed(12345)
# make the noise component
n_trs = int(duration / tr)
ar = np.array([1, -rho]) # statmodels says to invert rho
ap = ArmaProcess(ar)
err = ap.generate_sample(n_trs, scale=noise, axis=0)
Y = signal + err
else:
Y = signal
return Y
def test_process_multiplication(self):
process1 = ArmaProcess.from_coeffs([0.9])
process2 = ArmaProcess.from_coeffs([0.7])
process3 = process1 * process2
assert_equal(process3.arcoefs, np.array([1.6, -0.7 * 0.9]))
assert_equal(process3.macoefs, np.array([]))
process1 = ArmaProcess.from_coeffs([0.9], [0.2])
process2 = ArmaProcess.from_coeffs([0.7])
process3 = process1 * process2
assert_equal(process3.arcoefs, np.array([1.6, -0.7 * 0.9]))
assert_equal(process3.macoefs, np.array([0.2]))
process1 = ArmaProcess.from_coeffs([0.9], [0.2])
process2 = process1 * (np.array([1.0, -0.7]), np.array([1.0]))
assert_equal(process2.arcoefs, np.array([1.6, -0.7 * 0.9]))
assert_raises(TypeError, process1.__mul__, [3])
def get_AR(process, iters, params):
# AR
if params == None:
params = {'AR': [-0.999]}
metadata = {"NAME": process, "number_of_iterations": iters}
metadata.update(params)
ar = np.array([1] + params['AR'])
ar_object = ArmaProcess(ar, [1])
y = ar_object.generate_sample(nsample=iters)
true_var = sum([
y[i:-(len(ar) - i)] * (-1 * ar[len(ar) - i])
for i in range(1, len(ar))
]) + sps.norm.ppf(0.01)
y = y[len(ar):]
data = pd.DataFrame(data={'Returns': y, 'True_VAR_0.01': true_var})
return metadata, data
def estimate_order_of_model_information_criteria():
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)
# Fit the data to an AR(p) for p = 0,...,6 , and save the BIC
BIC = np.zeros(7)
for p in range(7):
mod = ARMA(simulated_data_2, order=(p, 0))
res = mod.fit()
# Save BIC for AR(p)
BIC[p] = res.bic
# Plot the BIC as a function of p
plt.plot(range(1, 7), BIC[1:7], marker='o')
plt.xlabel('Order of AR Model')
plt.ylabel('Bayesian Information Criterion')
plt.show()
def test_str_repr(self):
process1 = ArmaProcess.from_coeffs([.9], [.2])
out = process1.__str__()
print(out)
assert_(out.find('AR: [1.0, -0.9]') != -1)
assert_(out.find('MA: [1.0, 0.2]') != -1)
out = process1.__repr__()
assert_(out.find('nobs=100') != -1)
assert_(out.find('at ' + str(hex(id(process1)))) != -1)
def test_str_repr(self):
process1 = ArmaProcess.from_coeffs([0.9], [0.2])
out = process1.__str__()
print(out)
assert_(out.find("AR: [1.0, -0.9]") != -1)
assert_(out.find("MA: [1.0, 0.2]") != -1)
out = process1.__repr__()
assert_(out.find("nobs=100") != -1)
assert_(out.find("at " + str(hex(id(process1)))) != -1)
def test_process_multiplication(self):
process1 = ArmaProcess.from_coeffs([.9])
process2 = ArmaProcess.from_coeffs([.7])
process3 = process1 * process2
assert_equal(process3.arcoefs, np.array([1.6, -0.7 * 0.9]))
assert_equal(process3.macoefs, np.array([]))
process1 = ArmaProcess.from_coeffs([.9], [.2])
process2 = ArmaProcess.from_coeffs([.7])
process3 = process1 * process2
assert_equal(process3.arcoefs, np.array([1.6, -0.7 * 0.9]))
assert_equal(process3.macoefs, np.array([0.2]))
process1 = ArmaProcess.from_coeffs([.9], [.2])
process2 = process1 * (np.array([1.0, -0.7]), np.array([1.0]))
assert_equal(process2.arcoefs, np.array([1.6, -0.7 * 0.9]))
assert_raises(TypeError, process1.__mul__, [3])
def test_str_repr(self):
process1 = ArmaProcess.from_coeffs([.9], [.2])
out = process1.__str__()
print(out)
assert_(out.find('AR: [1.0, -0.9]') != -1)
assert_(out.find('MA: [1.0, 0.2]') != -1)
out = process1.__repr__()
assert_(out.find('nobs=100') != -1)
assert_(out.find('at ' + str(hex(id(process1)))) != -1)
def simulate_ar_process(phi=0.9, plot=False):
"""
# 0 lag coefficient of 1
# sign of other coefficient is opposite from what we are using
# Example, AR(1) process with phi = 0.9
# the second element of AR array should be the opposite sign, - 0.9
# Since ignoring MA at the moment, we just use 1
:param phi:
:return:
"""
ar = np.array([1, -phi])
ma = np.array([1])
AR_object = ArmaProcess(ar, ma)
simulated_data = AR_object.generate_sample(nsample=1000)
if plot:
plt.plot(simulated_data)
plt.show()
return simulated_data
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 estimating_an_ma_model():
ar1 = np.array([1])
ma1 = np.array([1, -0.9])
MA_object1 = ArmaProcess(ar1, ma1)
simulated_data_1 = MA_object1.generate_sample(nsample=1000)
# Fit an MA(1) model to the first simulated data
mod = ARMA(simulated_data_1, order=(0, 1))
res = mod.fit()
# Print out summary information on the fit
print(res.summary())
# Print out the estimate for the constant and for theta
print(
"When the true theta=-0.9, the estimate of theta (and the constant) are:"
)
print(res.params)
return res
def plot_MA(maxit = 100, N = 365, T = 1000, save=False, name='img/results/emission.png'):
"""Generate emission model output with transition replaced with MA.
Transition model is defined as
z_t = z_{t-1} + 3*sin(2*pi*t/T)
Args:
maxit (int): Number of samples
N (int): Size of time range.
T (int): Constant test size.
save (bool, optional): Whether to save the figure, defaultly not.
name (str, optional): Path to save the plot to.
"""
# create model
MA = ArmaProcess(ma = [.2,-.4,.2,-.7])
# iterate
z = np.zeros((maxit, N))
x = np.zeros((maxit, N))
for i in range(maxit):
# create z[t] sample
z[i,:] = MA.generate_sample(nsample=N) + 3*np.sin(np.array(range(N))/N*2*np.pi)
z[i,:] = (z[i,:] - z[i,:].min()) / (z[i,:].max() - z[i,:].min())
# create x[t] sample
x[i,:] = emission(z[i,:], np.array([T for i in range(N)]), 1, 50)
def get_mu_ci(ts):
mu = ts.mean(axis = 0)
ci = np.quantile(ts, [.025,.975],axis=0)
return mu,ci
z_mu,z_ci = get_mu_ci(z)
x_mu,x_ci = get_mu_ci(x)
# plot
fig1, ax1 = plt.subplots()
ax1.plot(range(N), z_mu, color='red', label='z[t]')
ax1.fill_between(range(N), z_ci[0,:], z_ci[1,:], color = 'red', alpha = .1)
ax1.plot(range(N), x_mu, color='blue', label='x[t]')
ax1.fill_between(range(N), x_ci[0,:], x_ci[1,:], color = 'blue', alpha = .1)
ax1.set_xlabel('Time')
ax1.set_ylabel('Value')
ax1.legend()
if save: fig1.savefig(name)
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 generate_armaprocess_data(samples, ar_order, ma_order, noise_std, params=None):
if params is not None:
# use specified params (make sure to sum up to 1 or less)
arparams, maparams = params
else:
# iterate to find random arparams that are stationary
arparams, maparams = _generate_random_arparams(ar_order, ma_order)
arma_process = ArmaProcess.from_coeffs(arparams, maparams, nobs=samples)
# sample output from ARMA Process
series = arma_process.generate_sample(samples, scale=noise_std)
# make zero-mean:
series = series - np.mean(series)
return series, list(arparams), list(maparams)
def test_simulated_y_custom_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'])
intervention_idx = 70
normed_pre_data, _ = standardize(data.iloc[:intervention_idx])
model = UnobservedComponents(
endog=normed_pre_data['y'].iloc[0:intervention_idx],
level='llevel',
exog=normed_pre_data['X'].iloc[0:intervention_idx])
ci = CausalImpact(data, [0, 69], [70, 99], model=model)
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 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_generate_sample(self):
process = ArmaProcess.from_coeffs([0.9])
np.random.seed(12345)
sample = process.generate_sample()
np.random.seed(12345)
expected = np.random.randn(100)
for i in range(1, 100):
expected[i] = 0.9 * expected[i - 1] + expected[i]
assert_almost_equal(sample, expected)
process = ArmaProcess.from_coeffs([1.6, -0.9])
np.random.seed(12345)
sample = process.generate_sample()
np.random.seed(12345)
expected = np.random.randn(100)
expected[1] = 1.6 * expected[0] + expected[1]
for i in range(2, 100):
expected[i] = (
1.6 * expected[i - 1] - 0.9 * expected[i - 2] + expected[i]
)
assert_almost_equal(sample, expected)
process = ArmaProcess.from_coeffs([1.6, -0.9])
np.random.seed(12345)
sample = process.generate_sample(burnin=100)
np.random.seed(12345)
expected = np.random.randn(200)
expected[1] = 1.6 * expected[0] + expected[1]
for i in range(2, 200):
expected[i] = (
1.6 * expected[i - 1] - 0.9 * expected[i - 2] + expected[i]
)
assert_almost_equal(sample, expected[100:])
np.random.seed(12345)
sample = process.generate_sample(nsample=(100, 5))
assert_equal(sample.shape, (100, 5))
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
def test_from_coeff(self):
ar = [1.8, -0.9]
ma = [0.3]
process = ArmaProcess.from_coeffs(np.array(ar), np.array(ma))
ar.insert(0, -1)
ma.insert(0, 1)
ar_p = -1 * np.array(ar)
ma_p = ma
process_direct = ArmaProcess(ar_p, ma_p)
assert_equal(process.arcoefs, process_direct.arcoefs)
assert_equal(process.macoefs, process_direct.macoefs)
assert_equal(process.nobs, process_direct.nobs)
assert_equal(process.maroots, process_direct.maroots)
assert_equal(process.arroots, process_direct.arroots)
assert_equal(process.isinvertible, process_direct.isinvertible)
assert_equal(process.isstationary, process_direct.isstationary)
def test_fit_arima(fn):
np.random.seed(200)
ar_params = np.array([1, -0.5])
ma_params = np.array([1, -0.3])
ret = ArmaProcess(ar_params, ma_params).generate_sample(nsample=5*252)
ret = pd.Series(ret)
drift = 100
price = pd.Series(np.cumsum(ret)) + drift
lret = np.log(price) - np.log(price.shift(1))
lret = lret[1:]
# choose autoregression lag of 1
AR_lag_p = 1
# choose moving average lag of 1
MA_lag_q = 1
# choose order of integration 1
order_of_integration_d = 1
# Create a tuple of p,d,q
order = (AR_lag_p, order_of_integration_d, MA_lag_q)
arima_model = ARIMA(lret.values, order=order)
arima_result = arima_model.fit()
fittedvalues = arima_result.fittedvalues
arparams = arima_result.arparams
maparams = arima_result.maparams
fn_inputs = {
'lret': lret
}
fn_correct_outputs = OrderedDict([
('fittedvalues',fittedvalues),
('arparams',arparams),
('maparams',maparams),
])
assert_output(fn, fn_inputs, fn_correct_outputs)
def get_synthetic_ts_data_period(n_steps=1000, forecast_length=5):
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))
data = InputData(idx=np.arange(0, n_steps),
features=simulated_data,
target=simulated_data,
task=task,
data_type=DataTypesEnum.ts)
a, b = train_test_data_setup(data)
return train_test_data_setup(data)
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()
from statsmodels.tsa.arima_process import arma_generate_sample, ArmaProcess # <codecell> np.random.seed(1234) # include zero-th lag arparams = np.array([1, .75, -.65, -.55, .9]) maparams = np.array([1, .65]) # <markdowncell> # * Let's make sure this models is estimable. # <codecell> arma_t = ArmaProcess(arparams, maparams) # <codecell> arma_t.isinvertible() # <codecell> arma_t.isstationary() # <rawcell> # * What does this mean? # <codecell>
100XP Import the class ArmaProcess in the arima_process module. Plot the simulated AR procesees: Let ar1 represent an array of the AR parameters [1, −ϕ − ϕ ] as explained above. For now, the MA parmater array, ma1, will contain just the lag-zero coefficient of one. With parameters ar1 and ma1, create an instance of the class ArmaProcess(ar,ma) called AR_object1. Simulate 1000 data points from the object you just created, AR_object1, using the method .generate_sample(). Plot the simulated data in a subplot. Repeat for the other AR parameter. ''' # import the module for simulating data 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 invertibleroots(ma):
proc = ArmaProcess(ma=ma)
return proc.invertroots(retnew=False)
# ### Exercise: Can you obtain a better fit for the Sunspots model? (Hint: # sm.tsa.AR has a method select_order) # ### Simulated ARMA(4,1): Model Identification is Difficult from statsmodels.tsa.arima_process import ArmaProcess np.random.seed(1234) # include zero-th lag arparams = np.array([1, .75, -.65, -.55, .9]) maparams = np.array([1, .65]) # Let's make sure this model is estimable. arma_t = ArmaProcess(arparams, maparams) arma_t.isinvertible arma_t.isstationary # * What does this mean? fig = plt.figure(figsize=(12, 8)) ax = fig.add_subplot(111) ax.plot(arma_t.generate_sample(nsample=50)) arparams = np.array([1, .35, -.15, .55, .1]) maparams = np.array([1, .65]) arma_t = ArmaProcess(arparams, maparams) arma_t.isstationary
, 0.8 , 0.8 2 , 0.8 3 , … Simulate 5000 observations of the MA(30) model Plot the ACF of the simulated series ''' # import the modules for simulating data and plotting the ACF from statsmodels.tsa.arima_process import ArmaProcess from statsmodels.graphics.tsaplots import plot_acf # 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()
nobs = 500
ar = [1, -0.6, -0.1]
ma = [1, 0.7]
dist = lambda n: np.random.standard_t(3, size=n)
np.random.seed(8659567)
x = arma_generate_sample(ar, ma, nobs, sigma=1, distrvs=dist,
burnin=500)
mod = TArma(x)
order = (2, 1)
res = mod.fit(order=order)
res2 = mod.fit_mle(order=order, start_params=np.r_[res[0], 5, 1], method='nm')
print(res[0])
proc = ArmaProcess.from_coeffs(res[0][:order[0]], res[0][:order[1]])
print(ar, ma)
proc.nobs = nobs
# TODO: bug nobs is None, not needed ?, used in ArmaProcess.__repr__
print(proc.ar, proc.ma)
print(proc.ar_roots(), proc.ma_roots())
from statsmodels.tsa.arma_mle import Arma
modn = Arma(x)
resn = modn.fit_mle(order=order)
moda = ARMA(x, order=order)
resa = moda.fit( trend='nc')
self.trend.plot(ax=axes[2], legend=False)
axes[2].set_ylabel('Trend')
self.irregular.plot(ax=axes[3], legend=False)
axes[3].set_ylabel('Irregular')
fig.tight_layout()
return fig
if __name__ == "__main__":
import numpy as np
from statsmodels.tsa.arima_process import ArmaProcess
np.random.seed(123)
ar = [1, .35, .8]
ma = [1, .8]
arma = ArmaProcess(ar, ma, nobs=100)
assert arma.isstationary()
assert arma.isinvertible()
y = arma.generate_sample()
dates = pd.date_range("1/1/1990", periods=len(y), freq='M')
ts = pd.TimeSeries(y, index=dates)
xpath = "/home/skipper/src/x12arima/x12a"
try:
results = x13_arima_analysis(xpath, ts)
except:
print("Caught exception")
results = x13_arima_analysis(xpath, ts, log=False)
def test_arma2ar(self):
process1 = ArmaProcess.from_coeffs([], [0.8])
vals = process1.arma2ar(100)
assert_almost_equal(vals, (-0.8) ** np.arange(100.0))
def test_periodogram(self):
process = ArmaProcess()
pg = process.periodogram()
assert_almost_equal(pg[0], np.linspace(0,np.pi,100,False))
assert_almost_equal(pg[1], np.sqrt(2 / np.pi) / 2 * np.ones(100))
def test_impulse_response(self):
process = ArmaProcess.from_coeffs([0.9])
ir = process.impulse_response(10)
assert_almost_equal(ir, 0.9 ** np.arange(10))
