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