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))
