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_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_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 generate_armaprocess_data(samples, noise_std, random_order=None, params=None, limit_abs_sum=True): if params is not None: # use specified params, make sure to sum up to 1 or less arparams, maparams = params arma_process = ArmaProcess.from_coeffs(arparams, maparams, nobs=samples) else: is_stationary = False iteration = 0 while not is_stationary: iteration += 1 # print("Iteration", iteration) if iteration > 100: raise RuntimeError("failed to find stationary coefficients") # Generate random parameters arparams = [] maparams = [] ar_order, ma_order = random_order 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=samples) is_stationary = arma_process.isstationary # sample output from ARMA Process series = arma_process.generate_sample(samples, scale=noise_std) # make zero-mean: series = series - np.mean(series) return series, arparams, maparams
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_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 _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 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_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_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_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_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 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_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 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 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_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 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 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_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_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_impulse_response(self): process = ArmaProcess.from_coeffs([0.9]) ir = process.impulse_response(10) assert_almost_equal(ir, 0.9 ** np.arange(10))
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))
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')
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_arma2ar(self): process1 = ArmaProcess.from_coeffs([], [0.8]) vals = process1.arma2ar(100) assert_almost_equal(vals, (-0.8) ** np.arange(100.0))