def bip_s_resid(x, beta_hat,p,q):
phi_hat = np.array(beta_hat[:p])
theta_hat = np.array(beta_hat[p:])
N = len(x)
r = max(p,q)
a_bip = np.zeros(N)
x_sc = rsp.m_scale(x)
kap2 = 0.8724286
xArr = lambda ii: x[ii-1::-1] if ii-p-1 < 0 else x[ii-1:ii-p-1:-1]
aqArr = lambda ii: a_bip[ii-1::-1] if ii-q-1 < 0 else a_bip[ii-1:ii-q-1:-1]
apArr = lambda ii: a_bip[ii-1::-1] if ii-p-1 < 0 else a_bip[ii-1:ii-p-1:-1]
if np.sum(np.abs(np.roots(-1*np.array([-1, *phi_hat])))>1) \
or np.sum(np.abs(np.roots(-1*np.array([-1, *theta_hat])))>1):
sigma_hat = x_sc
else:
# MA infinity approximation to compute scale used in eta function
lamb = rsp.ma_infinity(phi_hat, -theta_hat, 100)
# Scale used in eta function
sigma_hat = np.sqrt(x_sc**2 /(1+kap2*np.sum(lamb**2)))
if r == 0:
a_sc_bip = x_sc
a_bip = np.array(x)
return a_bip
else:
if np.sum(np.abs(np.roots(-1*np.array([-1, *phi_hat])))>1) \
or np.sum(np.abs(np.roots(-1*np.array([-1, *theta_hat])))>1):
a_bip_sc = 10**10
else:
if p>=1 and q>=1:
# ARMA model
for ii in range(r,N):
# BIP-ARMA residuals
a_bip[ii] = x[ii] -phi_hat@(xArr(ii)-apArr(ii)+sigma_hat*rsp.eta(apArr(ii)/sigma_hat))\
+theta_hat@(sigma_hat*rsp.eta(aqArr(ii)/sigma_hat))
elif p==0 and q>=1:
# MA model
for ii in range(r,N):
# BIP-MA residuals
a_bip[ii] = x[ii]+theta_hat@(sigma_hat*rsp.eta(aqArr(ii)/sigma_hat))
elif p>=1 and q==0:
# AR model
for ii in range(r,N):
# BIP-AR residuals
a_bip[ii] = x[ii] - phi_hat@(xArr(ii)-apArr(ii)+sigma_hat*rsp.eta(apArr(ii)/sigma_hat))
a_bip_sc = rsp.m_scale(a_bip[p:])
# cleaned signal
x_filt = np.array(x)
for ii in range(p,N):
x_filt[ii] = x[ii]-a_bip[ii]+sigma_hat*rsp.eta(a_bip[ii]/sigma_hat)
return a_bip, x_filt
def compA(xII,pred,xArr,aArr,sig):
return xII - np.array(pred) @(np.array(xArr)-np.array(aArr)+sig*rsp.eta(np.array(aArr)/sig))
def bip_resid(xx, beta_hatx, p, q):
x = np.array(xx)
beta_hat = np.array(beta_hatx)
phi_hat = beta_hat[:p] if p > 0 else []
theta_hat = beta_hat[p:] if q > 0 else []
N = len(x)
r = max(p, q)
a_bip = np.zeros(N)
x_sc = rsp.m_scale(x)
kap2 = 0.8724286
if np.sum(np.abs(np.roots(np.array([1, *phi_hat*-1])))>1)\
or np.sum(np.abs(np.roots(np.array([1, *theta_hat])))>1):
sigma_hat = x_sc
a_bip = np.array(x)
else:
lamb = rsp.ma_infinity(phi_hat, -theta_hat, 100)
sigma_hat = np.sqrt(x_sc**2 / (1 + kap2 * np.sum(lamb**2)))
if r == 0:
a_bip = np.array(x)
else:
if p >= 1 and q >= 1:
# ARMA Models
for ii in range(r, N):
# BIP-ARMA residuals
xArr = x[ii - 1::-1] if ii - p - 1 < 0 else x[ii - 1:ii -
p - 1:-1]
abArr = a_bip[ii -
1::-1] if ii - p - 1 < 0 else a_bip[ii -
1:ii -
p - 1:-1]
aqArr = a_bip[ii -
1::-1] if ii - q - 1 < 0 else a_bip[ii -
1:ii -
q - 1:-1]
a_bip[ii] = x[ii] - phi_hat @ (
xArr - abArr + sigma_hat * rsp.eta(abArr / sigma_hat)
) + sigma_hat * theta_hat @ rsp.eta(aqArr / sigma_hat)
r += 1
elif p == 0 and q >= 1:
# MA models
for ii in range(r, N):
# BIP-MA residuals
aArr = a_bip[ii -
1::-1] if ii - q - 1 < 0 else a_bip[ii -
1:ii - q -
1:-1]
a_bip[ii] = x[ii] + theta_init * sigma_hat * rsp.eta(
aArr / sigma_hat)
elif p >= 1 and q == 0:
# AR models
for ii in range(r, N):
# BIP-AR residuals
xArr = x[ii - 1::-1] if ii - p - 1 < 0 else x[ii - 1:ii -
p - 1:-1]
aArr = a_bip[ii -
1::-1] if ii - p - 1 < 0 else a_bip[ii -
1:ii - p -
1:-1]
a_bip[ii] = x[ii] + phi_hat @ (
xArr - aArr) + sigma_hat * rsp.eta(aArr / sigma_hat)
return a_bip[p:]
def ar_est_bip_s(xxx, P):
'''
Inputs:
x : 1darray, dtype=float. data
P : scalar. Autoregressive order
'''
x = np.array(xxx)
N = len(x)
kap2 = 0.8724286
phi_grid = np.arange(-.99,.991,.05) # coarse grid search
fine_grid= np.arange(-.99,.991,.001) # finer grid via polynomial interpolation
a_bip_sc = np.zeros([len(phi_grid)]) # residual scale for BIP-AR on finer grid
a_sc = np.zeros(len(phi_grid)) # residual scale for AR on finer grid
# The following was introduced so as not to predict based
# on highly contaminated data in the
# first few samples.
x_tran = x[:min(10,int(np.floor(N/2)))]
sig_x_tran = np.median(np.abs(x-np.median(x)))
x_tran[np.abs(x_tran)>3*sig_x_tran] = 3*sig_x_tran*np.sign(x_tran[np.abs(x_tran)>3*sig_x_tran])
x[1:min(10,int(np.floor(N/2)))] = x_tran[1:min(10,int(np.floor(N/2)))]
if P==0:
# AR order = 0
phi_hat = [] # return empty AR-parameter vector
a_scale_final = rsp.m_scale(x)
return phi_hat, a_scale_final
elif P==1:
x_filt, phi_hat, a_scale_final = rsp.bip_ar1_s(x,N,phi_grid,fine_grid,kap2)
elif P>1:
phi_hat = np.zeros((P,P))
x_filt, phi_hat[0,0], a_scale_final = rsp.bip_ar1_s(x,N,phi_grid,fine_grid,kap2)
npa = lambda x: np.array(x)
for p in range(1,P):
for mm in range(len(phi_grid)):
for pp in range(p):
phi_hat[p,pp] =\
phi_hat[p-1,pp]-phi_grid[mm]*phi_hat[p-1,p-pp-1]
predictor_coeffs =\
np.array([*phi_hat[p,:p], phi_grid[mm]])
M = len(predictor_coeffs)
if np.mean(np.abs(np.roots([1, *predictor_coeffs]))<1)==1:
lambd = rsp.ma_infinity(predictor_coeffs, 0, 100)
sigma_hat = a_scale_final[0]/np.sqrt(1+kap2*np.sum(lambd**2))
else:
sigma_hat = 1.483*np.median(np.abs(x-np.median(x)))
a = np.zeros(len(x))
a2= np.zeros(len(x))
for ii in range(p+1,N):
xArr = x[ii-1::-1] if ii-M-1 <0 else x[ii-1:ii-M-1:-1]
aArr = a[ii-1::-1] if ii-M-1 <0 else a[ii-1:ii-M-1:-1]
a[ii] = compA(x[ii],predictor_coeffs,xArr,aArr,sigma_hat)
a2[ii] = x[ii] - predictor_coeffs@xArr
a_bip_sc[mm] = rsp.m_scale(a[p:]) # residual scale for BIP-AR
a_sc[mm] = rsp.m_scale(a2[p:]) # residual scale for AR
# tau-estimate under the BIP-AR(p) and AR(p)
phi, phi2, temp, temp2, ind_max, ind_max2 = tauEstim(phi_grid, a_bip_sc, fine_grid, a_sc)
# final estimate minimizes the residual scale of the two
if temp2<temp:
ind_max=ind_max2
temp=temp2
for pp in range(p):
phi_hat[p,pp] = phi_hat[p-1,pp]-fine_grid[ind_max]*phi_hat[p-1,p-pp-1]
phi_hat[p,p] = fine_grid[ind_max]
# final AR(p) tau-scale-estimate depending on phi_hat(p,p)
if np.mean(np.abs(np.roots([1,*phi_hat[p,:]]))<1) == 1:
lambd = rsp.ma_infinity(phi_hat[p,:], 0, 100)
#sigma used for bip-model
sigma_hat = a_scale_final[0]/np.sqrt(1+kap2*np.sum(lambd**2))
else:
sigma_hat = 1.483*np.median(np.abs(x-np.median(x)))
x_filt = np.zeros(len(x))
for ii in range(p+1,N):
xArr = x[ii-1::-1] if ii-M-1 <0 else x[ii-1:ii-M-1:-1]
aArr = a[ii-1::-1] if ii-M-1 <0 else a[ii-1:ii-M-1:-1]
a[ii] = x[ii]-phi_hat[p,:p+1]@(xArr-aArr\
+sigma_hat*rsp.eta(aArr/sigma_hat))
a2[ii]=x[ii]-phi_hat[p,:p+1]@xArr
if temp2>temp:
a_scale_final.append(rsp.m_scale(a[p:]))
else:
a_scale_final.append(rsp.m_scale(a2[p:]))
phi_hat = phi_hat[p,:] # BIP-AR(P) tau-estimate
for ii in range(p,N):
x_filt[ii] = x[ii] - a[ii] + sigma_hat*rsp.eta(a[ii]/sigma_hat)
return phi_hat, x_filt, a_scale_final
def bip_ar1_tau(x, N, phi_grid, fine_grid, kap2, P):
a_scale_final = np.zeros(P + 1)
a_scale_final[0] = rsp.tau_scale(
x) # AR(0): residual scale equals observation scale
# grid search for partial autocorrelations
a_bip_sc = np.zeros(len(phi_grid))
a_sc = np.zeros(len(phi_grid))
for mm in range(len(phi_grid)):
a = np.zeros(len(x)) # residuals for BIP-AR
a2 = np.zeros(len(x)) # residuals for AR
lambd = rsp.ma_infinity(phi_grid[mm], 0, 100)
sigma_hat = a_scale_final[0] / np.sqrt(
1 + kap2 * np.sum(lambd**2)) # sigma used for BIP-model
for ii in range(1, N):
a[ii] = x[ii]-phi_grid[mm]*\
(x[ii-1]-a[ii-1]+sigma_hat*rsp.eta(a[ii-1]/sigma_hat)) # residuals for BIP-AR
a2[ii] = x[ii] - phi_grid[mm] * x[ii - 1] # residuals for AR
a_bip_sc[mm] = rsp.tau_scale(
a[1:]) # tau-scale of residuals for BIP-AR
a_sc[mm] = rsp.tau_scale(a2[1:]) # tau-scale of residuals for AR
poly_approx = np.polyfit(
phi_grid, a_bip_sc, 5
) # polynomial approximation of tau scale objective function for BIP-AR(1) tau-estimates
a_interp_scale = np.polyval(
poly_approx, fine_grid
) # interpolation of tau scale objective function for BIP-AR(1) tau-estimates to fine grid
poly_approx2 = np.polyfit(
phi_grid, a_sc, 5
) # polynomial approximation of tau scale objective function for AR(1) tau-estimates
a_interp_scale2 = np.polyval(poly_approx2, fine_grid)
temp = np.min(a_interp_scale)
ind_max = np.argmin(a_interp_scale)
phi = fine_grid[ind_max] # tau-estimate unter the BIP-AR(1)
temp2 = np.min(a_interp_scale2)
ind_max2 = np.argmin(a_interp_scale2)
phi2 = fine_grid[ind_max2] # tau-estimate under the AR(1)
# final estimate maximizes robust likelihood of the two
if temp2 < temp:
phi_s = phi2
temp = temp2
else:
phi_s = phi
phi_hat = phi_s # final BIP-tau-estimate for AR(1)
# final AR(1) tau-scale-estimate depending on phi_hat
lambd = rsp.ma_infinity(phi_hat, 0, 100)
sigma_hat = a_scale_final[0] / np.sqrt(1 + kap2 * np.sum(lambd**2))
a = np.zeros(len(x)) # residuals for BIP-AR
a2 = np.zeros(len(x)) # residuals for AR
x_filt = np.zeros(len(x))
for ii in range(1, N):
a[ii] = x[ii] - phi_hat * (x[ii - 1] - a[ii - 1] +
sigma_hat * rsp.eta(a[ii - 1] / sigma_hat))
a2[ii] = x[ii] - phi_hat * x[ii - 1]
x_filt[ii] = x[ii] - a[ii] + sigma_hat * rsp.eta(a[ii] / sigma_hat)
if temp2 < temp:
a_scale_final[1] = rsp.tau_scale(a[1:])
else:
a_scale_final[1] = rsp.tau_scale(a2[1:])
return x_filt, phi_hat, a_scale_final
def bip_s_resid_sc(x, beta_hat, p, q):
phi_hat = np.array(beta_hat[:p]) # [] if p=0, MA case
theta_hat = np.array(beta_hat[p:]) # [] if p=length(beta_hat), AR case
#x = np.array(x)
N = len(x)
r = max(p, q)
a_bip = np.zeros(N)
x_sc = rsp.m_scale(x)
kap2 = 0.8724286
poles = lambda x: np.sum(np.abs(np.roots(-1 * np.array([-1, *x]))) > 1)
if poles(phi_hat) or poles(theta_hat):
sigma_hat = x_sc
else:
lamb = rsp.ma_infinity(
phi_hat, -1 * theta_hat, 100
) # MA infinity approximation to compute scale used in eta function
sigma_hat = np.sqrt(x_sc**2 /
(1 + kap2 * np.sum(lamb**2))) # scale used in eta
if r == 0:
a_sc_bip = x_sc
a_bip = np.array(x)
else:
if poles(phi_hat) or poles(theta_hat):
return 10**10, a_bip, x[p:]
else:
xArr = lambda ii: x[ii - 1::-1] if ii - p - 1 < 0 else x[
ii - 1:ii - p - 1:-1]
aArr = lambda ii: a_bip[ii-1::-1] if ii-q-1 < 0 \
else a_bip[ii-1:ii-q-1:-1]
apArr = lambda ii: a_bip[ii-1::-1] if ii-p-1 < 0 \
else a_bip[ii-1:ii-p-1:-1]
if p >= 1 and q >= 1:
# ARMA model
for ii in range(r, N):
# BIP-ARMA residuals
a_bip[ii] = x[ii]\
-phi_hat@\
(xArr(ii)-apArr(ii)+sigma_hat*rsp.eta(apArr(ii)/sigma_hat))+sigma_hat*([email protected](aArr(ii)/sigma_hat))
elif p == 0 and q >= 1:
# MA residuals
for ii in range(r, N):
# BIP-MA residuals
a_bip[ii] = x[ii] + theta_hat @ (
sigma_hat * rsp.eta(aArr(ii) / sigma_hat))
elif p >= 1 and q == 0:
# AR Model
for ii in range(r, N):
a_bip[ii] = x[ii]-phi_hat@(xArr(ii)-apArr(ii)\
+sigma_hat*rsp.eta(apArr(ii)/sigma_hat))
a_bip_sc = rsp.m_scale(a_bip[p:])
x_filt = np.array(x)
for ii in range(p, N):
x_filt[ii] = x[ii] - a_bip[ii] + sigma_hat * rsp.eta(
a_bip[ii] / sigma_hat)
return a_bip_sc, x_filt, a_bip[p:]
