def simulate_data_v1(nCells = 5*10**4, nPersons = 40, seed = 123456, ratio_P = [1., 1., 0.8, 0.1]): """ Simulates the data following the instruction presented in the article """ if seed is not None: npr.seed(seed) P = [0.49, 0.3, 0.2 , 0.01 ] Thetas = [np.array([0.,0, 0]), np.array([0, -2, 1]), np.array([1., 2, 0]), np.array([-2,2,1.5])] Z_Sigma = [np.array([[1.27, 0.25, 0],[0.25, 0.27, -0.001],[0., -0.001, 0.001]]), np.array([[0.06, 0.04, -0.03],[0.04, 0.05, 0],[-0.03, 0., 0.09]]), np.array([[0.44, 0.08, 0.08],[0.08, 0.16, 0],[0.08, 0., 0.16]]), 0.01*np.eye(3)] Sigmas = [0.1*np.eye(3), 0.1*spl.toeplitz([2.,0.5,0]),0.1* spl.toeplitz([2.,-0.5,1]), 0.1*spl.toeplitz([1.,.3,.3]) ] nu = 100 Y, act_Class, mus, x = simulate_data_(Thetas, Z_Sigma, Sigmas, P, nu = nu, ratio_act = ratio_P, n_cells = nCells, n_persons = nPersons, seed = seed) return Y, act_Class, mus, Thetas, Sigmas, P
def X1B(xtrain,btrain,ytest,degre=10):
""" Excercie 1 partie B"""
# (RXX+RBB) h = rXX
rXX=correlate(xtrain,xtrain)
rBB=correlate(btrain,btrain)
# Ah=b
A=scl.toeplitz(rXX[:degre])+scl.toeplitz(rBB[:degre])
b=rXX[:degre]
h=npl.inv(A).dot(b)
# Estimation de X par filtrage h de Y
xest=scipy.signal.lfilter(h,[1],ytest)
plt.figure(1)
plt.title('X1 B')
plt.subplot(3,1,1)
plt.ylabel('y')
plt.plot(ytest,'b-')
plt.subplot(3,1,2)
plt.ylabel('x estime')
plt.plot(xest,'r-')
plt.subplot(3,1,3)
plt.ylabel('y, x estime')
plt.plot(ytest,'b-')
plt.plot(xest,'r-')
plt.savefig('X1B.pdf')
plt.close()
if inspection:
global X1Bvars
X1Bvars=inspect.currentframe().f_locals
def test_mv(sim, d, n, mv, string):
row = np.zeros(d)
row2 = np.zeros(d)
row[0] = 4.
row2[0] = 2.
if d > 1:
row[1] = -1
row2[1] = 1
prior = {'mu':-10 * np.ones(d),'Sigma':spl.toeplitz(row)}
param = {'Sigma': spl.toeplitz(row2)}
Y = np.empty((n,d))
L = np.linalg.cholesky(param['Sigma'])
for i in range(n): # @UnusedVariable
Y[i,:] = np.dot(L,np.random.randn(d,1)).reshape((d,))
dist = mv(prior = prior, param = param)
mu_est = np.zeros((sim,dist.mu_p.shape[0]))
t0 = time.time()
dist.set_data(Y)
for i in range(sim):
dist.set_parameter(param)
dist.set_prior(prior)
dist.set_data(Y)
mu_est[i,:] = dist.sample()
t1 = time.time()
string += " %.4f msec/sim (sim, n ,d ) = (%d %d,%d) "%(1000*np.double(t1-t0)/sim, sim, n, d )
print(string)
def main():
print('Testing SVM class')
height=3
width=5
samples=10
#Create the D matrix
D_w=toeplitz(np.hstack([1,np.zeros(width-2)]),np.hstack([1,-1, np.zeros(width-2)]))
D_h=toeplitz(np.hstack([1,np.zeros(height-2)]),np.hstack([1,-1, np.zeros(height-2)]))
# D=np.c_[D,np.zeros(width-1)]
# D[width-2,width-1]=-1
D2=np.kron(D_w,np.eye(height))
D3=np.kron(np.eye(width),D_h)
D=np.r_[D2,D3]
w=np.random.randn(height*width)
X=np.random.randn(samples,height*width)
Y=np.random.randint(2,size=samples)
Y[Y==0]=-1
SHuber=SVMHuber(huber=0.5)
print w
print X
print SHuber.gradf(X,Y,w)
print SHuber.f(X,Y,w)
print('Testing P class')
KTVS=KtvSVM(D,huber=0.01,lambda1=1,lambda2=0.1,k=1)
print KTVS.f(X,Y,w)
print KTVS.gradf(X,Y,w)
def estimate_time_constant(Y, sn, p=None, lags=5, include_noise=False, pixels=None):
"""
Estimating global time constants for the dataset Y through the autocovariance function (optional).
The function is no longer used in the standard setting of the algorithm since every trace has its own
time constant.
Inputs:
Y: np.ndarray (2D)
input movie data with time in the last axis
p: positive integer
order of AR process, default: 2
lags: positive integer
number of lags in the past to consider for determining time constants. Default 5
include_noise: Boolean
Flag to include pre-estimated noise value when determining time constants. Default: False
pixels: np.ndarray
Restrict estimation to these pixels (e.g., remove saturated pixels). Default: All pixels
Output:
g: np.ndarray (p x 1)
Discrete time constants
"""
if p is None:
raise Exception("You need to define p")
if pixels is None:
pixels = np.arange(np.size(Y) / np.shape(Y)[-1])
from scipy.linalg import toeplitz
npx = len(pixels)
g = 0
lags += p
XC = np.zeros((npx, 2 * lags + 1))
for j in range(npx):
XC[j, :] = np.squeeze(axcov(np.squeeze(Y[pixels[j], :]), lags))
gv = np.zeros(npx * lags)
if not include_noise:
XC = XC[:, np.arange(lags - 1, -1, -1)]
lags -= p
A = np.zeros((npx * lags, p))
for i in range(npx):
if not include_noise:
A[i * lags + np.arange(lags), :] = toeplitz(
np.squeeze(XC[i, np.arange(p - 1, p + lags - 1)]), np.squeeze(XC[i, np.arange(p - 1, -1, -1)])
)
else:
A[i * lags + np.arange(lags), :] = toeplitz(
np.squeeze(XC[i, lags + np.arange(lags)]), np.squeeze(XC[i, lags + np.arange(p)])
) - (sn[i] ** 2) * np.eye(lags, p)
gv[i * lags + np.arange(lags)] = np.squeeze(XC[i, lags + 1 :])
if not include_noise:
gv = XC[:, p:].T
gv = np.squeeze(np.reshape(gv, (np.size(gv), 1), order="F"))
g = np.dot(np.linalg.pinv(A), gv)
return g
def estimate_time_constant(Y, sn, p = 2, lags = 5, include_noise = False, pixels = None):
if pixels is None:
pixels = np.arange(np.size(Y)/np.shape(Y)[-1])
from scipy.linalg import toeplitz
npx = len(pixels)
g = 0
lags += p
XC = np.zeros((npx,2*lags+1))
for j in range(npx):
XC[j,:] = np.squeeze(axcov(np.squeeze(Y[pixels[j],:]),lags))
gv = np.zeros(npx*lags)
if not include_noise:
XC = XC[:,np.arange(lags-1,-1,-1)]
lags -= p
A = np.zeros((npx*lags,p))
for i in range(npx):
if not include_noise:
A[i*lags+np.arange(lags),:] = toeplitz(np.squeeze(XC[i,np.arange(p-1,p+lags-1)]),np.squeeze(XC[i,np.arange(p-1,-1,-1)]))
else:
A[i*lags+np.arange(lags),:] = toeplitz(np.squeeze(XC[i,lags+np.arange(lags)]),np.squeeze(XC[i,lags+np.arange(p)])) - (sn[i]**2)*np.eye(lags,p)
gv[i*lags+np.arange(lags)] = np.squeeze(XC[i,lags+1:])
if not include_noise:
gv = XC[:,p:].T
gv = np.squeeze(np.reshape(gv,(np.size(gv),1),order='F'))
g = np.dot(np.linalg.pinv(A),gv)
return g
def simulate_data(nCells = 5*10**4, nPersons = 40, seed = 123456, ratio_P = [1., 1., 0.8, 0.1]): """ Simulates the data following the instruction presented in the article """ if seed != None: npr.seed(seed) nClass = 4 dim = 3 P = [0.49, 0.3, 0.2 , 0.01 ] Thetas = [np.array([0.,0, 0]), np.array([0, -2, 1]), np.array([1., 2, 0]), np.array([-2,2,1.5])] Z_Sigma = [np.array([[1.27, 0.25, 0],[0.25, 0.27, -0.001],[0., -0.001, 0.001]]), np.array([[0.06, 0.04, -0.03],[0.04, 0.05, 0],[-0.03, 0., 0.09]]), np.array([[0.44, 0.08, 0.08],[0.08, 0.16, 0],[0.08, 0., 0.16]]), 0.01*np.eye(3)] Sigmas = [0.1*np.eye(3), 0.1*spl.toeplitz([2.,0.5,0]),0.1* spl.toeplitz([2.,-0.5,1]), 0.1*spl.toeplitz([1.,.3,.3]) ] act_Class = np.zeros((nPersons,4)) for i in range(nClass): act_Class[:np.ceil(nPersons*ratio_P[i]),i] = 1. Y = [] nu = 100 mus = [] for i in range(nPersons): mix_obj = GMM.mixture(K = np.int(np.sum(act_Class[i, :]))) theta_temp = [] sigma_temp = [] for j in range(nClass): if act_Class[i, j] == 1: theta_temp.append(Thetas[j] + npr.multivariate_normal(np.zeros(3), Z_Sigma[j])) sigma_temp.append(wishart.invwishartrand(nu, (nu - dim - 1)* Sigmas[j])) else: theta_temp.append(np.ones(dim)*np.NAN) sigma_temp.append(np.ones((dim,dim))*np.NAN) theta_temp_ = [ theta_temp[aC] for aC in np.where(act_Class[i, :] == 1)[0]] sigma_temp_ = [ sigma_temp[aC] for aC in np.where(act_Class[i, :] == 1)[0]] mix_obj.mu = theta_temp_ mus.append(theta_temp) mix_obj.sigma = sigma_temp_ p_ = np.array([ (0.2*np.random.rand()+0.9) * P[aC] for aC in np.where(act_Class[i, :] == 1)[0]] ) p_ /= np.sum(p_) mix_obj.p = p_ mix_obj.d = dim Y.append(mix_obj.simulate_data(nCells)) mus = np.array(mus) return Y, act_Class, mus.T, Thetas, Sigmas, P
def maestx(y, pcs, q, norder=3,samp_seg=1,overlap=0):
"""
MAEST MA parameter estimation via the GM-RCLS algorithm, with Tugnait's fix
y - time-series (vector or matrix)
q - MA order
norder - cumulant-order to use [default = 3]
samp_seg - samples per segment for cumulant estimation
[default: length of y]
overlap - percentage overlap of segments [default = 0]
flag - 'biased' or 'unbiased' [default = 'biased']
Return: estimated MA parameter vector
"""
assert norder>=2 and norder<=4, "Cumulant order must be 2, 3, or 4!"
nsamp = len(y)
overlap = max(0, min(overlap,99))
c2 = cumx(y, pcs, 2,q, samp_seg, overlap)
c2 = np.hstack((c2, np.zeros(q)))
cumd = cumx(y, pcs, norder,q,samp_seg,overlap,0,0)[::-1]
cumq = cumx(y, pcs, norder,q,samp_seg,overlap,q,q)
cumd = np.hstack((cumd, np.zeros(q)))
cumq[:q] = np.zeros(q)
cmat = toeplitz(cumd, np.hstack((cumd[0],np.zeros(q))))
rmat = toeplitz(c2, np.hstack((c2[0],np.zeros(q))))
amat0 = np.hstack((cmat, -rmat[:,1:q+1]))
rvec0 = c2
cumq = np.hstack((cumq[2*q:q-1:-1], np.zeros(q)))
cmat4 = toeplitz(cumq, np.hstack((cumq[0],np.zeros(q))))
c3 = cumd[:2*q+1]
amat0 = np.vstack((np.hstack((amat0, np.zeros((3*q+1,1)))), \
np.hstack((np.hstack((np.zeros((2*q+1,q+1)), cmat4[:,1:q+1])), \
np.reshape(-c3,(len(c3),1))))))
rvec0 = np.hstack((rvec0, -cmat4[:,0]))
row_sel = range(q)+range(2*q+1,3*q+1)+range(3*q+1,4*q+1)+range(4*q+2,5*q+2)
amat0 = amat0[row_sel,:]
rvec0 = rvec0[row_sel]
bvec = lstsq(amat0, rvec0)[0]
b1 = bvec[1:q+1]/bvec[0]
b2 = bvec[q+1:2*q+1]
if norder == 3:
if all(b2 > 0):
b1 = np.sign(b1) * np.sqrt(0.5*(b1**2 + b2))
else:
print 'MAEST: alternative solution b1 used'
else:
b1 = np.sign(b2)* (abs(b1) + abs(b2)**(1./3))/2
# if all(np.sign(b2) == np.sign(b1)):
# b1 = np.sign(b1)* (abs(b1) + abs(b2)**(1./3))/2
# else:
# print 'MAEST: alternative solution b1 used'
return np.hstack(([1], b1))
def kern2mat(H, size):
"""Create a matrix corresponding to the application of the convolution kernel H.
The size argument should be a tuple (output_size, input_size).
"""
N = H.size
half = int((N - 1) / 2)
Nout, Mout = size
if Nout == Mout:
return linalg.toeplitz(np.r_[H[half:], np.zeros(Nout - half)], np.r_[H[half:], np.zeros(Mout-half)])
else:
return linalg.toeplitz(np.r_[H, np.zeros(Nout - N)], np.r_[H[-1], np.zeros(Mout-1)])
def _setup_bias_correct(self, model):
R = np.identity(model.design.shape[0]) - np.dot(model.design, model.calc_beta)
M = np.zeros((self.p+1,)*2)
I = np.identity(R.shape[0])
for i in range(self.p+1):
Di = np.dot(R, toeplitz(I[i]))
for j in range(self.p+1):
Dj = np.dot(R, toeplitz(I[j]))
M[i,j] = np.diagonal((np.dot(Di, Dj))/(1.+(i>0))).sum()
self.invM = L.inv(M)
return
def _least_square_evoked(data, events, event_id, tmin, tmax, sfreq):
"""Least square estimation of evoked response from data.
Parameters
----------
data : ndarray, shape (n_channels, n_times)
The data to estimates evoked
events : ndarray, shape (n_events, 3)
The events typically returned by the read_events function.
If some events don't match the events of interest as specified
by event_id, they will be ignored.
event_id : dict
The id of the events to consider
tmin : float
Start time before event.
tmax : float
End time after event.
sfreq : float
Sampling frequency.
Returns
-------
evokeds_data : dict of ndarray
A dict of evoked data for each event type in event_id.
toeplitz : dict of ndarray
A dict of toeplitz matrix for each event type in event_id.
"""
nmin = int(tmin * sfreq)
nmax = int(tmax * sfreq)
window = nmax - nmin
n_samples = data.shape[1]
toeplitz_mat = dict()
full_toep = list()
for eid in event_id:
# select events by type
ix_ev = events[:, -1] == event_id[eid]
# build toeplitz matrix
trig = np.zeros((n_samples, 1))
ix_trig = (events[ix_ev, 0]) + nmin
trig[ix_trig] = 1
toep_mat = linalg.toeplitz(trig[0:window], trig)
toeplitz_mat[eid] = toep_mat
full_toep.append(toep_mat)
# Concatenate toeplitz
full_toep = np.concatenate(full_toep)
# least square estimation
predictor = np.dot(linalg.pinv(np.dot(full_toep, full_toep.T)), full_toep)
all_evokeds = np.dot(predictor, data.T)
all_evokeds = np.vsplit(all_evokeds, len(event_id))
# parse evoked response
evoked_data = dict()
for idx, eid in enumerate(event_id):
evoked_data[eid] = all_evokeds[idx].T
return evoked_data, toeplitz_mat
def yule_walker_acov(acov, order=1, method="unbiased", df=None, inv=False):
"""
Estimate AR(p) parameters from acovf using Yule-Walker equation.
Parameters
----------
acov : array-like, 1d
auto-covariance
order : integer, optional
The order of the autoregressive process. Default is 1.
inv : bool
If inv is True the inverse of R is also returned. Default is False.
Returns
-------
rho : ndarray
The estimated autoregressive coefficients
sigma
TODO
Rinv : ndarray
inverse of the Toepliz matrix
"""
R = toeplitz(r[:-1])
rho = np.linalg.solve(R, r[1:])
sigmasq = r[0] - (r[1:]*rho).sum()
if inv == True:
return rho, np.sqrt(sigmasq), np.linalg.inv(R)
else:
return rho, np.sqrt(sigmasq)
def X1A(xtrain,ytrain,ytest,degre=10):
""" Excercie 1 partie A"""
# RYY h = rXY
rYY=correlate(ytrain,ytrain)
rXY=correlate(xtrain,ytrain)
# Ah=b
A=scl.toeplitz(rYY[:degre])
b=rXY[:degre]
h=npl.inv(A).dot(b)
# Estimation de X par filtrage h de Y
xest=scipy.signal.lfilter(h,[1],ytest)
plt.figure(1)
plt.title('X1 A')
plt.subplot(3,1,1)
plt.ylabel('y')
plt.plot(ytest,'b-')
plt.subplot(3,1,2)
plt.ylabel('x estime')
plt.plot(xest,'r-')
plt.subplot(3,1,3)
plt.ylabel('y, x estime')
plt.plot(ytest,'b-')
plt.plot(xest,'r-')
plt.savefig('X1A.pdf')
plt.close()
if inspection:
global X1Avars
X1Avars=inspect.currentframe().f_locals
def _least_square_evoked(epochs_data, events, tmin, sfreq):
"""Least square estimation of evoked response from epochs data.
Parameters
----------
epochs_data : array, shape (n_channels, n_times)
The epochs data to estimate evoked.
events : array, shape (n_events, 3)
The events typically returned by the read_events function.
If some events don't match the events of interest as specified
by event_id, they will be ignored.
tmin : float
Start time before event.
sfreq : float
Sampling frequency.
Returns
-------
evokeds : array, shape (n_class, n_components, n_times)
An concatenated array of evoked data for each event type.
toeplitz : array, shape (n_class * n_components, n_channels)
An concatenated array of toeplitz matrix for each event type.
"""
n_epochs, n_channels, n_times = epochs_data.shape
tmax = tmin + n_times / float(sfreq)
# Deal with shuffled epochs
events = events.copy()
events[:, 0] -= events[0, 0] + int(tmin * sfreq)
# Contruct raw signal
raw = _construct_signal_from_epochs(epochs_data, events, sfreq, tmin)
# Compute the independent evoked responses per condition, while correcting
# for event overlaps.
n_min, n_max = int(tmin * sfreq), int(tmax * sfreq)
window = n_max - n_min
n_samples = raw.shape[1]
toeplitz = list()
classes = np.unique(events[:, 2])
for ii, this_class in enumerate(classes):
# select events by type
sel = events[:, 2] == this_class
# build toeplitz matrix
trig = np.zeros((n_samples, 1))
ix_trig = (events[sel, 0]) + n_min
trig[ix_trig] = 1
toeplitz.append(linalg.toeplitz(trig[0:window], trig))
# Concatenate toeplitz
toeplitz = np.array(toeplitz)
X = np.concatenate(toeplitz)
# least square estimation
predictor = np.dot(linalg.pinv(np.dot(X, X.T)), X)
evokeds = np.dot(predictor, raw.T)
evokeds = np.transpose(np.vsplit(evokeds, len(classes)), (0, 2, 1))
return evokeds, toeplitz
def setUp(self): npr.seed(123456) self.nClass = 3 self.dim = 3 self.P = [0.4, 0.3, 0.3] self.Thetas = [np.array([0.,0, 0]), np.array([0., -2, 1]), np.array([1., 2, 0])] self.Sigmas = [ 0.1*spl.toeplitz([2.,0.5,0]),0.1* spl.toeplitz([2.,-0.5,1]), 0.1*spl.toeplitz([1.,.3,.3]) ] mix_obj = mixP(K = self.nClass) mix_obj.mu = cp.deepcopy(self.Thetas) mix_obj.sigma = cp.deepcopy(self.Sigmas) mix_obj.p = cp.deepcopy(self.P) mix_obj.d = self.dim self.Y = mix_obj.simulate_data(self.n)
def covariance_matrix_grid(self, endog_expval, index):
from scipy.linalg import toeplitz
r = np.zeros(len(endog_expval))
r[0] = 1
r[1:self.max_lag + 1] = self.dep_params
return toeplitz(r), True
def pacf(x, periodogram=True, lagmax=None):
"""Computes the partial autocorrelation function of series `x` along
the given axis.
:Parameters:
x : 1D array
Time series.
periodogram : {True, False} optional
Whether to use a periodogram-like estimate of the ACF or not.
lagmax : {None, int} optional
Maximum lag. If None, the maximum lag is set to n/4+1, with n the series
length.
"""
acfx = acf(x, periodogram)[:,None]
#
if lagmax is None:
n = len(x) // 4 + 1
else:
n = min(lagmax, len(x))
#
arkf = np.zeros((n,n),float)
arkf[1,1] = acfx[1,0]
for k in range(2,n):
res = solve(toeplitz(acfx[:k]), acfx[1:k+1]).squeeze()
arkf[k,1:k+1] = res
return arkf.diagonal()
def ssaeig(x, M):
"""Syntax: [E,V,C]=ssaeig(x, M);
This function starts an SSA of series 'x', for embedding dimension 'M'.
Returns: E - eigenfunction matrix in standard form
(columns are the eigenvectors, or T-EOFs)
V - vector containing variances (unnormalized eigenvalues)
C - Covariance Matrix
E and V are ordered from large to small.
See section 2 of Vautard, Yiou, and Ghil, Physica D 58, 95-126, 1992."""
from scipy.linalg import toeplitz, eigh
N=size(x)
if not isinstance(N, int):
if N[0] < N[1]: x = transpose(x); N = size(x)
else: raise ValueError('Hey! Vectors only!')
if M-1 >= N: raise ValueError('Hey! Too big a lag!')
acov=ac(x, M-1) # calculate autocovariance estimates
Tc = toeplitz(acov) # create Toeplitz matrix (trajectory matrix)
C = Tc
L,E = eigh(Tc) # calculate eigenvectors, values of T
V = abs(L) # create eigenvalue vector
ind = argsort(V) # sort eigenvalues
ind = ind[M::-1]
V = V[ind]
E = E[:][:,ind] # sort eigenvectors
return [E,V,C]
def conv_mat(lin_op):
"""Returns the coefficient matrix for CONV linear op.
Parameters
----------
lin_op : LinOp
The conv linear op.
Returns
-------
list of NumPy matrix
The matrix representing the convolution operation.
"""
constant = const_mat(lin_op.data)
# Cast to 1D.
constant = intf.from_2D_to_1D(constant)
# Create a Toeplitz matrix with constant as columns.
rows = lin_op.size[0]
nonzeros = lin_op.data.size[0]
toeplitz_col = np.zeros(rows)
toeplitz_col[0:nonzeros] = constant
cols = lin_op.args[0].size[0]
toeplitz_row = np.zeros(cols)
toeplitz_row[0] = constant[0]
coeff = sp_la.toeplitz(toeplitz_col, toeplitz_row)
return [np.matrix(coeff)]
def arma_pacf(ar, ma, nobs=10):
'''partial autocorrelation function of an ARMA process
Parameters
----------
ar : array_like, 1d
coefficient for autoregressive lag polynomial, including zero lag
ma : array_like, 1d
coefficient for moving-average lag polynomial, including zero lag
nobs : int
number of terms (lags plus zero lag) to include in returned pacf
Returns
-------
pacf : array
partial autocorrelation of ARMA process given by ar, ma
Notes
-----
solves yule-walker equation for each lag order up to nobs lags
not tested/checked yet
'''
apacf = np.zeros(nobs)
acov = arma_acf(ar,ma, nobs=nobs+1)
apacf[0] = 1.
for k in range(2,nobs+1):
r = acov[:k];
apacf[k-1] = linalg.solve(linalg.toeplitz(r[:-1]), r[1:])[-1]
return apacf
def test_gbmv(self):
seed(1234)
for ind, dtype in enumerate(DTYPES):
n = 7
m = 5
kl = 1
ku = 2
# fake a banded matrix via toeplitz
A = toeplitz(append(rand(kl+1), zeros(m-kl-1)),
append(rand(ku+1), zeros(n-ku-1)))
A = A.astype(dtype)
Ab = zeros((kl+ku+1, n), dtype=dtype)
# Form the banded storage
Ab[2, :5] = A[0, 0] # diag
Ab[1, 1:6] = A[0, 1] # sup1
Ab[0, 2:7] = A[0, 2] # sup2
Ab[3, :4] = A[1, 0] # sub1
x = rand(n).astype(dtype)
y = rand(m).astype(dtype)
alpha, beta = dtype(3), dtype(-5)
func, = get_blas_funcs(('gbmv',), dtype=dtype)
y1 = func(m=m, n=n, ku=ku, kl=kl, alpha=alpha, a=Ab,
x=x, y=y, beta=beta)
y2 = alpha * A.dot(x) + beta * y
assert_array_almost_equal(y1, y2)
def determineOptimalFilter(self, x):
# performs the direct solution (Wiener-Hopf solution)
# to determine optimal filter weights for equalization (optimal w/ respect to MMSE)
# this function expects data @ 1sps, not 2 sps
# if the data is available @ a higher samples/sym than 1,
# it is OK to decimate the data and pass it into this block because
# the equalization should take care of some of the timing. Of course,
# if the sps is 4 or greater, something smarter could probably be done
# than just throwing data away, so think about that
numTrainingSyms = len(self.preSyms)
x_n = x[0:numTrainingSyms] # slice the appropriate preamble data
# generate the input correlation matrix
m = numTrainingSyms
X = numpy.fft.fft(x_n, 128) # the FFT Size is 128 - this will change if the preamble length changes, so beware!
X_magSq = numpy.square(numpy.absolute(X))
rxx = numpy.fft.ifft(X_magSq)
rxx = rxx/m
toeplitzMatCol = rxx[0:m]
R = linalg.toeplitz(toeplitzMatCol)
# generate the P vector
xc = numpy.correlate(self.preSyms, x_n, 'full')
P = xc[0:m]
w = numpy.linalg.solve(R,P)
w /= numpy.amax(numpy.absolute(w)) # scale the filter coefficients
return w
def CovarianceMatrixBlockToeplitzMult(theta,X,Y,ToeplitzKernel,mf,mf_pars,mf_args_pred,mf_args): """ X - input matrix (q x D) - of training points Y - input matrix (n x D) - of predictive points theta - hyperparameter array/list K - (q x n) covariance matrix block Note that this only works when the step sizes are the same for X and Y, toplitz usaully 1D! """ a = ToeplitzKernel(X,Y,theta,white_noise=False) #length q b = ToeplitzKernel(Y,X,theta,white_noise=False) #length n #return q x n matrix block K = LA.toeplitz(a,b) #get mean function m = mf(mf_pars,mf_args) * np.ones(Y.shape[0]) #and predictive mean ms = mf(mf_pars,mf_args_pred) * np.ones(X.shape[0]) #and calculate the affine transform Kp = np.diag(ms) * np.matrix(K) * np.diag(m) return np.matrix(Kp)
def aryw(x, order=30):
x = x - _np.mean(x)
ac = autocorr(x, order+1)
R = _linalg.toeplitz(ac[:order])
r = ac[1:order+1]
params = _np.linalg.inv(R).dot(r)
return(params)
def __init__(self, n=80, sig=0.05, err=2, **kwargs):
self.n = n # Number of grid points
self.sig = float(sig) # Gaussian kernel width
self.err = float(err) / 100 # Percent error in data
# Setup grid
h = 1.0 / n
z = np.arange(h / 2, 1 - h / 2 + h, h)
# Compute nxn matrix K = convolution with Gaussian kernel
gaussKernel = 1 / sqrt(np.pi) / self.sig * np.exp(-(z - h / 2) ** 2 / self.sig ** 2)
self.K = h * np.matrix(toeplitz(gaussKernel))
# Setup true solution, blurred and noisy data
trueimg = 0.75 * np.where((0.1 < z) & (z < 0.25), 1, 0)
trueimg += 0.25 * np.where((0.3 < z) & (z < 0.32), 1, 0)
trueimg += np.where((0.5 < z) & (z < 1), 1, 0) * np.sin(2 * np.pi * z) ** 4
blurred = self.K * np.asmatrix(trueimg).T
blurred = np.asarray(blurred.T)[0] # np.matrix messes up your data
noise = self.err * np.linalg.norm(blurred) * np.random.random(n) / sqrt(n)
self.data = blurred + noise
self.z = z
self.trueimg = trueimg
self.blurred = blurred
self.setsolver()
def roots(self):
"""
Utilises Boyd's O(n^2) recursive subdivision algorithm. The chebfun
is recursively subsampled until it is successfully represented to
machine precision by a sequence of piecewise interpolants of degree
100 or less. A colleague matrix eigenvalue solve is then applied to
each of these pieces and the results are concatenated.
See:
J. P. Boyd, Computing zeros on a real interval through Chebyshev
expansion and polynomial rootfinding, SIAM J. Numer. Anal., 40 (2002),
pp. 1666–1682.
"""
if self.size() <= 100:
ak = self.coefficients()
v = np.zeros_like(ak[:-1])
v[1] = 0.5
C1 = linalg.toeplitz(v)
C2 = np.zeros_like(C1)
C1[0,1] = 1.
C2[-1,:] = ak[:-1]
C = C1 - .5/ak[-1] * C2
eigenvalues = linalg.eigvals(C)
roots = [eig.real for eig in eigenvalues
if np.allclose(eig.imag,0,atol=1e-10)
and np.abs(eig.real) <=1]
scaled_roots = self._ui_to_ab(np.array(roots))
return scaled_roots
else:
# divide at a close-to-zero split-point
split_point = self._ui_to_ab(0.0123456789)
return np.concatenate(
(self.restrict([self._domain[0],split_point]).roots(),
self.restrict([split_point,self._domain[1]]).roots())
)
def aryw(x, p=5):
x = x - mean(x)
ac = autocorr(x, p+1)
R = linalg.toeplitz(ac[:p])
r = ac[1:p+1]
params = inv(R).dot(r)
return(params)
def test_toeplitz(N=50):
print("Testing circulant linear algebra...")
x = np.linspace(0, 10, N)
y = np.vstack((np.sin(x), np.cos(x), x, x**2)).T
c_row = np.exp(-0.5 * x ** 2)
c_row[0] += 0.1
cnum = circulant(c_row)
cmat = CirculantMatrix(c_row)
# Test dot products.
assert np.allclose(np.dot(cnum, y[:, 0]), cmat.dot(y[:, 0]))
assert np.allclose(np.dot(cnum, y), cmat.dot(y))
# Test solves.
assert np.allclose(np.linalg.solve(cnum, y[:, 0]), cmat.solve(y[:, 0]))
assert np.allclose(np.linalg.solve(cnum, y), cmat.solve(y))
# Test eigenvalues.
ev = np.linalg.eigvals(cnum)
ev = ev[np.argsort(np.abs(ev))[::-1]]
assert np.allclose(np.abs(cmat.eigvals()), np.abs(ev))
print("Testing Toeplitz linear algebra...")
tnum = toeplitz(c_row)
tmat = ToeplitzMatrix(c_row)
# Test dot products.
assert np.allclose(np.dot(tnum, y[:, 0]), tmat.dot(y[:, 0]))
assert np.allclose(np.dot(tnum, y), tmat.dot(y))
# Test solves.
assert np.allclose(np.linalg.solve(tnum, y[:, 0]),
tmat.solve(y[:, 0], tol=1e-12, verbose=True))
assert np.allclose(np.linalg.solve(tnum, y),
tmat.solve(y, tol=1e-12, verbose=True))
def _cumulant3(self):
"""
Calculates the 3rd Order cummulant of the lightcurve.
Assigns:
self.cum3,
self.lags
"""
# Initialize square cumulant matrix if zeros
cum3_dim = 2 * self.maxlag + 1
self.cum3 = np.zeros((cum3_dim, cum3_dim))
# calculate lags for different values of 3rd order cumulant
lagindex = np.arange(-self.maxlag, self.maxlag + 1)
self.lags = lagindex * self.lc.dt
# Defines indices for matrices
ind = np.arange((self.n - self.maxlag) - 1, self.n)
ind_t = np.arange(self.maxlag, self.n)
zero_maxlag = np.zeros((1, self.maxlag))
zero_maxlag_t = zero_maxlag.transpose()
sig = self.signal.transpose()
rev_signal = np.array([self.signal[0][::-1]])
col = np.concatenate((sig[ind], zero_maxlag_t), axis=0)
row = np.concatenate((rev_signal[0][ind_t], zero_maxlag[0]), axis=0)
# converts row and column into a toeplitz matrix
toep = toeplitz(col, row)
rev_signal = np.repeat(rev_signal, [2 * self.maxlag + 1], axis=0)
# Calulates Cummulant of 1D signal i.e. Lightcurve counts
self.cum3 = self.cum3 + np.matmul(np.multiply(toep, rev_signal), toep.transpose())
def firls(m, bands, desired, weight=None):
if weight==None : weight = ones(len(bands)/2)
bands, desired, weight = array(bands), array(desired), array(weight)
#if not desired[-1] == 0 and bands[-1] == 1 and m % 2 == 1:
if m % 2 == 1:
m = m + 1
M = m/2
w = kron(weight, [-1,1])
omega = bands * pi
i1 = arange(1,M+1)
# generate the matrix q
# as illustrated in the above-cited reference, the matrix can be
# expressed as the sum of a hankel and toeplitz matrix. a factor of
# 1/2 has been dropped and the final filter hficients multiplied
# by 2 to compensate.
cos_ints = append(omega, sin(mat(arange(1,m+1)).T*mat(omega))).reshape((-1,omega.shape[0]))
q = append(1, 1.0/arange(1.0,m+1)) * array(mat(cos_ints) * mat(w).T).T[0]
q = toeplitz(q[:M+1]) + hankel(q[:M+1], q[M : ])
# the vector b is derived from solving the integral:
#
# _ w
# / 2
# b = / w(w) d(w) cos(kw) dw
# k / w
# - 1
#
# since we assume that w(w) is constant over each band (if not, the
# computation of q above would be considerably more complex), but
# d(w) is allowed to be a linear function, in general the function
# w(w) d(w) is linear. the computations below are derived from the
# fact that:
# _
# / a ax + b
# / (ax + b) cos(nx) dx = --- cos (nx) + ------ sin(nx)
# / 2 n
# - n
#
enum = append(omega[::2]**2 - omega[1::2]**2, cos(mat(i1).T * mat(omega[1::2])) - cos(mat(i1).T * mat(omega[::2]))).flatten()
deno = mat(append(2, i1)).T * mat(omega[1::2] - omega[::2])
cos_ints2 = enum.reshape(deno.shape)/array(deno)
d = zeros_like(desired)
d[::2] = -weight * desired[::2]
d[1::2] = weight * desired[1::2]
b = append(1, 1.0/i1) * array(mat(kron (cos_ints2, [1, 1]) + cos_ints[:M+1,:]) * mat(d).T)[:,0]
# having computed the components q and b of the matrix equation,
# solve for the filter hficients.
a = (array(inv(q)*mat(b).T).T)[0]
h = append( a[:0:-1], append(2*a[0], a[1:]))
return h
mask = np.abs(x.copy()) < eps
x[mask] = 0
return x
def maxabs(x):
return np.max(np.abs(x))
if __name__ == '__main__':
n = 5
y = np.arange(n)
x = np.random.randn(100, n)
autocov = 2 * 0.8**np.arange(n) + 0.01 * np.random.randn(n)
sigma = linalg.toeplitz(autocov)
mat = PlainMatrixArray(sym=sigma)
print tiny2zero(mat.mhalf)
mih = mat.minvhalf
print tiny2zero(mih) #for nicer printing
mat2 = PlainMatrixArray(data=x)
print maxabs(mat2.yt_minv_y(np.dot(x.T, x)) - mat2.m)
print tiny2zero(mat2.minv_y(mat2.m))
mat3 = SvdArray(data=x)
print mat3.meigh[0]
print mat2.meigh[0]
testcompare(mat2, mat3)
def time_toeplitz(self, size):
sl.toeplitz(self.x)
def update(self, x):
"""
Updates statistics estimates.
Args:
x: np.array, partial trajectory of shape [dim, num_updating_points]
Returns:
current dimension-wise mean and variance estimates of sizes [dim, 1], [dim, 1]
"""
assert len(x.shape) == 2 and x.shape[0] == self.dim
# Update length:
k = x.shape[-1]
self.num_obs += k
if not self.is_decayed:
self.alpha = 1 / (self.num_obs - 1)
# Mean estimation:
# Broadcast input to [dim, update_len, update_len]:
xx = np.tile(x[:, None, :], [1, k, 1])
gamma = 1 - self.alpha
# Exp. decays as powers of (1-alpha):
g = np.cumprod(np.repeat(gamma, k))
# Diag. matrix of decayed coeff:
tp = toeplitz(g / gamma, r=np.zeros(k))[::-1, ::1]
# Backward-ordered mean updates as sums of decayed inputs:
k_step_mean_update = np.sum(xx * tp[None, ...], axis=2) # tp expanded for sure broadcast
# Broadcast stored value of mean to [dim, 1] and apply decay:
k_decayed_old_mean = (np.tile(self.mean[..., None], [1, k]) * g)
# Get backward-recursive array of mean values from (num_obs - update_len) to (num_obs):
means = k_decayed_old_mean + self.alpha * k_step_mean_update[:, ::-1]
# Variance estimation:
# Get deviations of update:
dx = x - np.concatenate([self.mean[..., None], means[:, :-1]], axis=1)
# Get new variance value at (num_obs) point:
k_decayed_old_var = gamma ** k * self.variance
k_step_var_update = np.sum(g[::-1] * dx ** 2, axis=1)
variance = k_decayed_old_var + self.alpha * k_step_var_update
# Update current values:
self.mean = means[:, -1]
self.variance = variance
# Keep g and dx:
self.g = g
self.dx = dx
return self.mean, self.variance
def get_decay_toeplitz_matrix(size: int, decay_param: float) -> np.ndarray:
return toeplitz(np.power(decay_param, np.arange(size)),
np.insert(np.zeros(size - 1), 0, 1.))
def Tmtx(data, K):
'''
Construct convolution matrix for a filter specified by 'data'
'''
return splin.toeplitz(data[K::], data[K::-1])
def test_scalar_04(self):
r = array([10, 2, 3])
t = toeplitz(1, r)
assert_array_equal(t, [[1, 2, 3]])
u_11 = np.zeros(n+1)
u_11[x > 0.3] = 1
u_12 = np.zeros(n+1)
u_12[x > 0.7] = 1
u_1 = u_11 - u_12
u_2 = x * (1 - x)
# Display response functions
plt.plot(x, u_1)
plt.plot(x, u_2)
# define forward operator
a = 1
c = np.exp(-a * x_matrix ** 2) / ((n - 1) * np.sqrt(np.pi/a))
K = la.toeplitz(c)
K_cond_nr = np.linalg.cond(K)
print('Condition number... ', K_cond_nr)
# Okay we are off good...
# Now let use vary that delta.. and recover u...
# But also see the impact of a.
result_dict = {}
for i, u_sel in enumerate([u_1, u_2]):
u_key = f'u_{i+1}'
result_dict.setdefault(u_key, {})
for delta in [0.001, 0.01, 0.1]:
temp_key = f"delta:{delta}"
u_svd, s_svd, vh_svd = np.linalg.svd(K, full_matrices=True)
K_svd_inv = vh_svd.conj().T @ np.diag(1 / s_svd) @ u_svd.conj().T
def test_scalar_00(self):
"""Scalar arguments still produce a 2D array."""
t = toeplitz(10)
assert_array_equal(t, [[10]])
t = toeplitz(10, 20)
assert_array_equal(t, [[10]])
def test_basic(self):
y = toeplitz([1, 2, 3])
assert_array_equal(y, [[1, 2, 3], [2, 1, 2], [3, 2, 1]])
y = toeplitz([1, 2, 3], [1, 4, 5])
assert_array_equal(y, [[1, 4, 5], [2, 1, 4], [3, 2, 1]])
def cohens_kappa(table, weights=None, return_results=True, wt=None):
'''Compute Cohen's kappa with variance and equal-zero test
Parameters
----------
table : array_like, 2-Dim
square array with results of two raters, one rater in rows, second
rater in columns
weights : array_like
The interpretation of weights depends on the wt argument.
If both are None, then the simple kappa is computed.
see wt for the case when wt is not None
If weights is two dimensional, then it is directly used as a weight
matrix. For computing the variance of kappa, the maximum of the
weights is assumed to be smaller or equal to one.
TODO: fix conflicting definitions in the 2-Dim case for
wt : None or string
If wt and weights are None, then the simple kappa is computed.
If wt is given, but weights is None, then the weights are set to
be [0, 1, 2, ..., k].
If weights is a one-dimensional array, then it is used to construct
the weight matrix given the following options.
wt in ['linear', 'ca' or None] : use linear weights, Cicchetti-Allison
actual weights are linear in the score "weights" difference
wt in ['quadratic', 'fc'] : use linear weights, Fleiss-Cohen
actual weights are squared in the score "weights" difference
wt = 'toeplitz' : weight matrix is constructed as a toeplitz matrix
from the one dimensional weights.
return_results : bool
If True (default), then an instance of KappaResults is returned.
If False, then only kappa is computed and returned.
Returns
-------
results or kappa
If return_results is True (default), then a results instance with all
statistics is returned
If return_results is False, then only kappa is calculated and returned.
Notes
-----
There are two conflicting definitions of the weight matrix, Wikipedia
versus SAS manual. However, the computation are invariant to rescaling
of the weights matrix, so there is no difference in the results.
Weights for 'linear' and 'quadratic' are interpreted as scores for the
categories, the weights in the computation are based on the pairwise
difference between the scores.
Weights for 'toeplitz' are a interpreted as weighted distance. The distance
only depends on how many levels apart two entries in the table are but
not on the levels themselves.
example:
weights = '0, 1, 2, 3' and wt is either linear or toeplitz means that the
weighting only depends on the simple distance of levels.
weights = '0, 0, 1, 1' and wt = 'linear' means that the first two levels
are zero distance apart and the same for the last two levels. This is
the sampe as forming two aggregated levels by merging the first two and
the last two levels, respectively.
weights = [0, 1, 2, 3] and wt = 'quadratic' is the same as squaring these
weights and using wt = 'toeplitz'.
References
----------
Wikipedia
SAS Manual
'''
table = np.asarray(table, float) #avoid integer division
agree = np.diag(table).sum()
nobs = table.sum()
probs = table / nobs
freqs = probs #TODO: rename to use freqs instead of probs for observed
probs_diag = np.diag(probs)
freq_row = table.sum(1) / nobs
freq_col = table.sum(0) / nobs
prob_exp = freq_col * freq_row[:, None]
assert np.allclose(prob_exp.sum(), 1)
#print prob_exp.sum()
agree_exp = np.diag(prob_exp).sum() #need for kappa_max
if weights is None and wt is None:
kind = 'Simple'
kappa = (agree / nobs - agree_exp) / (1 - agree_exp)
if return_results:
#variance
term_a = probs_diag * (1 - (freq_row + freq_col) * (1 - kappa))**2
term_a = term_a.sum()
term_b = probs * (freq_col[:, None] + freq_row)**2
d_idx = np.arange(table.shape[0])
term_b[d_idx, d_idx] = 0 #set diagonal to zero
term_b = (1 - kappa)**2 * term_b.sum()
term_c = (kappa - agree_exp * (1 - kappa))**2
var_kappa = (term_a + term_b - term_c) / (1 - agree_exp)**2 / nobs
#term_c = freq_col * freq_row[:, None] * (freq_col + freq_row[:,None])
term_c = freq_col * freq_row * (freq_col + freq_row)
var_kappa0 = (agree_exp + agree_exp**2 - term_c.sum())
var_kappa0 /= (1 - agree_exp)**2 * nobs
else:
if weights is None:
weights = np.arange(table.shape[0])
#weights follows the Wikipedia definition, not the SAS, which is 1 -
kind = 'Weighted'
weights = np.asarray(weights, float)
if weights.ndim == 1:
if wt in ['ca', 'linear', None]:
weights = np.abs(weights[:, None] - weights) / \
(weights[-1] - weights[0])
elif wt in ['fc', 'quadratic']:
weights = (weights[:, None] - weights)**2 / \
(weights[-1] - weights[0])**2
elif wt == 'toeplitz':
#assume toeplitz structure
from scipy.linalg import toeplitz
#weights = toeplitz(np.arange(table.shape[0]))
weights = toeplitz(weights)
else:
raise ValueError('wt option is not known')
else:
rows, cols = table.shape
if (table.shape != weights.shape):
raise ValueError('weights are not square')
#this is formula from Wikipedia
kappa = 1 - (weights * table).sum() / nobs / (weights * prob_exp).sum()
#TODO: add var_kappa for weighted version
if return_results:
var_kappa = np.nan
var_kappa0 = np.nan
#switch to SAS manual weights, problem if user specifies weights
#w is negative in some examples,
#but weights is scale invariant in examples and rough check of source
w = 1. - weights
w_row = (freq_col * w).sum(1)
w_col = (freq_row[:, None] * w).sum(0)
agree_wexp = (w * freq_col * freq_row[:, None]).sum()
term_a = freqs * (w - (w_col + w_row[:, None]) * (1 - kappa))**2
fac = 1. / ((1 - agree_wexp)**2 * nobs)
var_kappa = term_a.sum() - (kappa - agree_wexp * (1 - kappa))**2
var_kappa *= fac
freqse = freq_col * freq_row[:, None]
var_kappa0 = (freqse * (w - (w_col + w_row[:, None]))**2).sum()
var_kappa0 -= agree_wexp**2
var_kappa0 *= fac
kappa_max = (np.minimum(freq_row, freq_col).sum() - agree_exp) / \
(1 - agree_exp)
if return_results:
res = KappaResults(kind=kind,
kappa=kappa,
kappa_max=kappa_max,
weights=weights,
var_kappa=var_kappa,
var_kappa0=var_kappa0)
return res
else:
return kappa
def _fetch_cis_oe(reg1, reg2):
reg1_coords = tuple(regions.loc[reg1])
reg2_coords = tuple(regions.loc[reg2])
obs_mat = clr.matrix(balance=weight_name).fetch(reg1_coords)
exp_mat = toeplitz(expected[reg1][:obs_mat.shape[0]])
return obs_mat / exp_mat
import matplotlib.pyplot as plt
n = 10**4
sim = 300
c = 0.1 * n
##
#simulating data
##
npr.seed(123456)
nClass = 3
dim = 3
P = [0.4, 0.3, 0.3]
Thetas = [np.array([0., 0, 0]), np.array([0., -2, 1]), np.array([1., 2, 0])]
Sigmas = [
0.1 * spl.toeplitz([2., 0.5, 0]), 0.1 * spl.toeplitz([2., -0.5, 1]),
0.1 * spl.toeplitz([1., .3, .3])
]
mix_obj = mixP(K=nClass)
mix_obj.mu = cp.deepcopy(Thetas)
mix_obj.sigma = cp.deepcopy(Sigmas)
mix_obj.p = cp.deepcopy(P)
mix_obj.d = dim
Y = mix_obj.simulate_data(n)
mix = mixP(K=nClass, high_memory=False)
mix.set_data(Y)
for i in range(10): #np.int(np.ceil(0.1*self.sim))): # @UnusedVariable
mix.sample()
A = domega * np.sum(states[0, :])
print('Initial area: ', A)
states[0, :] = states[0, :] / A # Normalise distribution
# Time simulation
if 1:
for t in range(t_steps - 1):
if t % 100 == 0:
print('Area at t =', t, ' equals ', np.sum(states[t, :]) * domega)
print("calculating for t =", t)
# Explanation of the discrete averaging integral underneath.
H2 = np.append(0, states[t, :round(3 * x_steps / (4)) - 1:-1])
H = toeplitz(states[t, :], H2)
H = H[:, 1:]
G2 = np.append(states[t, -1], states[t, 0:round(x_steps / (4))])
G = hankel(states[t, :], G2)
G = G[:, 1:]
averagingintegral = np.sum(H * G, axis=1)
# averagingintegral = averagingintegralfunc(states[t, :], x_steps)
# if (abs(averagingintegral-averagingintegral_check) > eps).any():
# print('ERROR: averaging integral')
# print(averagingintegral)
# print(averagingintegral_check)
# print(averagingintegral.shape)
# print(averagingintegral_check.shape)
# break
def questao_25():
# -----------------------------------------------------------
# Exercício 25
# -----------------------------------------------------------
NFFT = 1024
N = 19
SNR = 20
h = [.34 - .21 * 1j, .87 + .43 * 1j, .34 - .27 * 1j]
qam = QAM()
channel = Filter(h, [1.])
data = ChannelEqualization(qam,
channel,
N=N,
input_delay=int((N + len(h)) / 2),
noise=GaussianNoise,
SNR=SNR)
a = qam(100000, )
A = toeplitz(np.hstack([a[0], np.zeros(N)]), a)
R = A.dot(A.T.conj()) / 100000
trR = R.trace()
mu_max = 1 / trR
MSE, W = [], []
for mu in (mu_max / 2, mu_max / 10, mu_max / 50):
E_hist, W_hist = lms(data,
mu,
N + 1,
max_runs=50,
max_iter=5000,
dtype='complex128',
print_every=-1)
MSE.append(np.mean(np.abs(E_hist)**2, axis=0))
W.append(np.mean(W_hist, axis=0))
plt.figure()
for mse, name in zip(
MSE,
['$\\mu_{\\max}/2$', '$\\mu_{\\max}/10$', '$\\mu_{\\max}/50$']):
plt.plot(10 * np.log10(mse), label=name)
plt.legend()
plt.xlabel('Iteração')
plt.ylabel('MSE (em dB)')
# plt.savefig('ex25-mse-{}.pdf'.format(N+1), dpi=300, bbox_inches='tight')
plt.show()
b_adap = np.mean(W_hist, axis=0)[-1, :].conj()
mse = np.mean(np.abs(E_hist)**2, axis=0)
plt.figure()
freqs = np.linspace(-1, 1, NFFT)
plt.plot(freqs, 20 * np.log10(fft(h, n=NFFT)), label='Canal')
plt.plot(freqs,
20 * np.log10(fft(b_adap, n=NFFT)),
'r--',
label='Equalizador')
plt.plot(freqs,
20 * np.log10(np.abs(fft(np.convolve(b_adap, h), n=NFFT))),
'y--',
label='Canal equalizado')
plt.xlim([-1, 1])
plt.legend()
plt.xlabel('Frequência normalizada')
plt.ylabel('Magnitude (em dB)')
plt.show()
# plt.savefig('figs/ex25-freq-{}.pdf'.format(N+1), dpi=300, bbox_inches='tight')
plt.figure()
plt.plot(signal.convolve(b_adap, h))
plt.xlabel('Amostra')
plt.ylabel('Amplitude')
plt.show()
# plt.savefig('ex25-tempo-{}.pdf'.format(N+1), dpi=300, bbox_inches='tight')
tx = qam(100)
rx = signal.lfilter(h, [1.], tx)
noise = GaussianNoise(std=np.sqrt(rx.var() / (2 * SNR)), complex=True)(100)
rx += noise
rx_eq = np.convolve(rx, b_adap)
plt.figure()
plt.plot(np.real(rx), np.imag(rx), 'o', label='Recebido')
plt.plot(np.real(rx_eq), np.imag(rx_eq), 'o', label='Equalizado')
plt.plot(1, 1, 'ro', label='Alvo')
plt.plot(1, -1, 'ro')
plt.plot(-1, 1, 'ro')
plt.plot(-1, -1, 'ro')
plt.legend()
plt.xlabel('Real')
plt.ylabel('Imaginário')
plt.show()
def worker_train_VBN(input_worker_VBN):
"""Explanations"""
#Global variables:
global numInput,numOutput,numHidden1,numHidden2
global dim_hidden2_output, dim_input_hidden1, dim_hidden1_hidden2
global env
#Local:
seed=int(input_worker_VBN[0])
p = input_worker_VBN[1]
env.seed(seed)
#np.random.seed(seed)
VBN_dict = {}
#VBN_dict['mu_i']=np.zeros((numInput,1))
#VBN_dict['var_i']=np.ones((numInput,1))
VBN_dict['mu_h1']=np.zeros((numHidden1,1))
VBN_dict['var_h1']=np.ones((numHidden1,1))
VBN_dict['mu_h2']=np.zeros((numHidden2,1))
VBN_dict['var_h2']=np.zeros((numHidden2,1))
#Neural Networks:
NN = NeuralNetwork(numInput,numHidden1,numHidden2,numOutput, VBN_dict)
NN.W1=toeplitz(p[0][numInput:],p[0][:numInput])
NN.W2=toeplitz(p[1][numHidden1:],p[1][:numHidden1])
NN.W3=toeplitz(p[2][numHidden2:],p[2][:numHidden2])
#SHOULD IT BE PLACED IN THE LOOP ? CANT THINK RIGHT NOW
sum_zh1=[0.] * numHidden1
sum_zh2=[0.] *numHidden2
#sum_zi=[0.] * numInput
sum_zh1_sq=[0.] * numHidden1
sum_zh2_sq=[0.] *numHidden2
#sum_zi_sq=[0.] * numInput
steps=1000
Ai = env.reset()
num_step=steps
NN.use_VBN=False #we don't want to use feedforward options with VBN to compute the statistics
for j in range(steps):
Ao = NN.feedForward(Ai)
sum_zh1=[sum(x) for x in zip(sum_zh1, NN.Z1)]
sum_zh2=[sum(x) for x in zip(sum_zh2, NN.Z2)]
#sum_zi=[sum(x) for x in zip(sum_zi, NN.Ai)]
sum_zh1_sq=[sum(x) for x in zip(sum_zh1_sq, square(NN.Z1))]
sum_zh2_sq=[sum(x) for x in zip(sum_zh2_sq, square(NN.Z2))]
#sum_zi_sq=[sum(x) for x in zip(sum_zi_sq, square(NN.Ai))]
action=np.argmax(Ao)
Ai, reward, done, info = env.step(action)
if done:
break
num_step=j
#return(sum_zi,sum_zh1,sum_zh2,sum_zi_sq,sum_zh1_sq,sum_zh2_sq,num_step)
return(sum_zh1,sum_zh2,sum_zh1_sq,sum_zh2_sq,num_step)
#if the user wants skew-symmetric matrix
elif matrix_structure == 5:
final = arr - arr.T
print(final)
#if the user wants Toepliz matrix
elif matrix_structure == 6:
#get all the first coloumn
col = arr[:][0]
#get the second coloumn
row = arr[0]
final = linalg.toeplitz(col, row)
print(final)
#if the user wants Circuilant matrix
elif matrix_structure == 7:
#get the first row in the matrix
row = arr[0]
final = linalg.circulant(row)
print(final)
#if the user wants stochastic matrix
elif matrix_structure == 9:
def pbdesign(n):
"""
Generate a Plackett-Burman design
Parameter
---------
n : int
The number of factors to create a matrix for.
Returns
-------
H : 2d-array
An orthogonal design matrix with n columns, one for each factor, and
the number of rows being the next multiple of 4 higher than n (e.g.,
for 1-3 factors there are 4 rows, for 4-7 factors there are 8 rows,
etc.)
Example
-------
A 3-factor design::
>>> pbdesign(3)
array([[-1., -1., 1.],
[ 1., -1., -1.],
[-1., 1., -1.],
[ 1., 1., 1.]])
A 5-factor design::
>>> pbdesign(5)
array([[-1., -1., 1., -1., 1.],
[ 1., -1., -1., -1., -1.],
[-1., 1., -1., -1., 1.],
[ 1., 1., 1., -1., -1.],
[-1., -1., 1., 1., -1.],
[ 1., -1., -1., 1., 1.],
[-1., 1., -1., 1., -1.],
[ 1., 1., 1., 1., 1.]])
"""
if not n > 0:
raise Exception('Number of factors must be a positive integer')
keep = int(n)
n = 4 * (int(n / 4) + 1
) # calculate the correct number of rows (multiple of 4)
f, e = np.frexp([n, n / 12., n / 20.])
k = [idx for idx, val in enumerate(np.logical_and(f == 0.5, e > 0)) if val]
if not (isinstance(n, int) and k != []):
raise Exception('Invalid inputs. n must be a multiple of 4.')
k = k[0]
e = e[k] - 1
if k == 0: # N = 1*2**e
H = np.ones((1, 1))
elif k == 1: # N = 12*2**e
H = np.vstack(
(np.ones((1, 12)),
np.hstack((np.ones((11, 1)),
toeplitz([-1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1],
[-1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1])))))
elif k == 2: # N = 20*2**e
H = np.vstack((np.ones((1, 20)),
np.hstack((np.ones((19, 1)),
hankel([
-1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1,
-1, 1, 1, 1, 1, -1, -1, 1
], [
1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1,
1, -1, 1, 1, 1, 1, -1, -1
])))))
# Kronecker product construction
for _ in range(e):
H = np.vstack((np.hstack((H, H)), np.hstack((H, -H))))
# Reduce the size of the matrix as needed
H = H[:, 1:(keep + 1)]
return np.flipud(H)
def estimate_parameters_diracs_sectoral(self, spectrum):
L = spectrum.L
l = np.arange(L)
#Get sectoral SH coefficients
f_ll = spectrum[l, l]
N_ll = get_N_l_m(l, l)
N_l = np.zeros(N_ll.shape, dtype=np.complex)
for ll in l:
N_l[ll] = polypart_coeffs(ll, ll, L)[-1]
z_l = f_ll / N_ll / N_l
#Cadzow denoising
z_l = self.cadzow(z_l)
#Compute annihilating filter coefficients
Z = linalg.toeplitz(z_l[self.K:], np.flipud(z_l[:self.K + 1]))
U, s, V = np.linalg.svd(Z)
V = V.conj().T
u_k = np.roots(V[:, -1])
#Find the phi_k angles
phi_k = np.mod(-np.angle(u_k), 2 * np.pi)
#Find the cks
van = np.vander(u_k, len(z_l), increasing=True).T
c_k = np.linalg.lstsq(van, z_l)[0]
f_lm1l = spectrum[l[1:], l[:-1]]
N_lm1l = get_N_l_m(l[1:], l[:-1])
N_lm1 = np.zeros(N_lm1l.shape, dtype=np.complex)
for ll in l[1:]:
N_lm1[ll - 1] = polypart_coeffs(ll, ll - 1, L)[-2]
w_l = f_lm1l / N_lm1l / N_lm1
van2 = np.vander(u_k, len(w_l), increasing=True).T
cos_k_exp_rk = np.real(np.linalg.lstsq(van2, w_l)[0] / c_k)
#Estimate the width
a = u_k / np.exp(-1j * phi_k)
b = cos_k_exp_rk
r_k = np.real(0.5 * np.log(
(-b**2 + np.sqrt(4 * a**2 + b**4)) / (2 * a**2)))
cos_k = cos_k_exp_rk / np.exp(-r_k)
theta_k = np.arccos(cos_k)
#correct the rks (if the roots are outside the unit circle)
r_k[np.where(r_k < 0)] = 1 / 200.0
#update the cks using the entire spectrum
spectrum_1D = spectrum.to_1D()
mat = np.zeros([spectrum_1D.shape[0], self.K], dtype=np.complex)
sph_vpw = Spherical_FRI(theta_k, phi_k, np.ones(theta_k.shape), r_k)
for k in np.arange(self.K):
mat[:, k] = Spherical_Function_Spectrum(
sph_vpw.vpw_pulse_sh(k, spectrum.L)).to_1D()
c_k = np.real(np.linalg.lstsq(mat, spectrum_1D)[0])
#Call nonlinear least squares method to refine the estimation
vpw_fct = lambda x: Spherical_FRI(x[:self.K], x[self.K:2 * self.K], x[
2 * self.K:3 * self.K], x[3 * self.K:]).vpw_sh(L=spectrum.L).to_1D(
)
vpw_diff = lambda x: np.abs(spectrum_1D - vpw_fct(x))
x0 = np.hstack((theta_k, phi_k, c_k, r_k))
x_new = optimize.leastsq(vpw_diff, x0)[0]
#print 'Squared error before nonlinear optimization:'
#print np.sum(vpw_diff(x0)**2)
#print 'Squared error after nonlinear optimization:'
#print np.sum(vpw_diff(x_new)**2)
theta_k = x_new[:self.K]
phi_k = x_new[self.K:2 * self.K]
c_k = x_new[2 * self.K:3 * self.K]
r_k = x_new[3 * self.K:]
return Spherical_FRI(theta_k, phi_k, c_k, r_k)
#!/usr/bin/env python
import sys
import numpy as np
from scipy.linalg import inv, toeplitz
from toeplitz_decomp import *
# 1-d case
a = np.load('simdata.npy')
pad = 1
b = 1
n = a.shape[0]
print n
A = toeplitz(a[:, 0])
z = np.zeros(shape=((n + pad * n) * b, (n + pad * n) * b), dtype=complex)
z[0:n * b, 0:n * b] = toeplitz(a[:, 0])
#A=toeplitz(z[:,0])
#in0=np.copy(a[0:512,0:1])
#toeplitz_decomp
#l=toeplitz_blockschur(np.conj(a[:,0:1].T),1)
l = toep_zpad(np.array(z[:, 0:1]).reshape(-1, ).tolist(), 0)
k = np.copy(l[n + n * pad - 1, n * pad:n + n * pad])
u = np.copy(l[n + n * pad - 1, 0:n + n * pad])
ll = np.correlate(u, k)[1:n + 1]
ll = ll[::-1]
print sum(ll[:] - a[:, 0])
#result = np.dot(l,np.conj(l).T)
AA = toeplitz(np.conj(ll[0:n]))
print("Consistency check, these numbers should be small:", np.sum(AA - A))
# 1-d case
plt.xlabel('Time (s)')
plt.subplot(2,2,4)
plt.plot(n[0:N-3], dot(D_jerk, position_profile))
plt.xlabel('Time (s)')
plt.title('Jerk')
'''
Solve minimum effort control problem for a partical at an intial postion of 2.0
and a final position of 5.0. This is the "straight path" trajectory.
'''
# set up jerk matrix D_{jerk}:
row_jerk = hstack((array([[-1, 3, -3, 1]]), zeros((1,N-4))))
col_jerk = vstack((array([[-1]]), zeros((N-4,1))))
D_jerk = power(N, 3)*toeplitz(col_jerk, row_jerk)
# set up constraint matrices:Aeq*x = beq
initial_position = hstack((array([[1]]), zeros((1,N-1))))
final_position = hstack((zeros((1,N-1)), array([[1]])))
initial_velocity = hstack((array([[-1, 1]]), zeros((1,N-2))))
final_velocity = hstack((zeros((1,N-2)), array([[-1, 1]])))
initial_acceleration = hstack((array([[1,-2,1]]), zeros((1,N-3))))
final_acceleration = hstack((zeros((1,N-3)), array([[1,-2,1]])))
Aeq = vstack((initial_position, final_position, initial_velocity, \
final_velocity, initial_acceleration, final_acceleration))
beq = zeros((6,1))
beq[0] = 2 #initial position
def firls(numtaps, bands, desired, weight=None, nyq=None, fs=None):
"""
FIR filter design using least-squares error minimization.
Calculate the filter coefficients for the linear-phase finite
impulse response (FIR) filter which has the best approximation
to the desired frequency response described by `bands` and
`desired` in the least squares sense (i.e., the integral of the
weighted mean-squared error within the specified bands is
minimized).
Parameters
----------
numtaps : int
The number of taps in the FIR filter. `numtaps` must be odd.
bands : array_like
A monotonic nondecreasing sequence containing the band edges in
Hz. All elements must be non-negative and less than or equal to
the Nyquist frequency given by `nyq`.
desired : array_like
A sequence the same size as `bands` containing the desired gain
at the start and end point of each band.
weight : array_like, optional
A relative weighting to give to each band region when solving
the least squares problem. `weight` has to be half the size of
`bands`.
nyq : float, optional, deprecated
This is the Nyquist frequency. Each frequency in `bands` must be
between 0 and `nyq` (inclusive). Default is 1.
.. deprecated:: 1.0.0
`firls` keyword argument `nyq` is deprecated in favour of `fs` and
will be removed in SciPy 1.12.0.
fs : float, optional
The sampling frequency of the signal. Each frequency in `bands`
must be between 0 and ``fs/2`` (inclusive). Default is 2.
Returns
-------
coeffs : ndarray
Coefficients of the optimal (in a least squares sense) FIR filter.
See also
--------
firwin
firwin2
minimum_phase
remez
Notes
-----
This implementation follows the algorithm given in [1]_.
As noted there, least squares design has multiple advantages:
1. Optimal in a least-squares sense.
2. Simple, non-iterative method.
3. The general solution can obtained by solving a linear
system of equations.
4. Allows the use of a frequency dependent weighting function.
This function constructs a Type I linear phase FIR filter, which
contains an odd number of `coeffs` satisfying for :math:`n < numtaps`:
.. math:: coeffs(n) = coeffs(numtaps - 1 - n)
The odd number of coefficients and filter symmetry avoid boundary
conditions that could otherwise occur at the Nyquist and 0 frequencies
(e.g., for Type II, III, or IV variants).
.. versionadded:: 0.18
References
----------
.. [1] Ivan Selesnick, Linear-Phase Fir Filter Design By Least Squares.
OpenStax CNX. Aug 9, 2005.
http://cnx.org/contents/eb1ecb35-03a9-4610-ba87-41cd771c95f2@7
Examples
--------
We want to construct a band-pass filter. Note that the behavior in the
frequency ranges between our stop bands and pass bands is unspecified,
and thus may overshoot depending on the parameters of our filter:
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> fig, axs = plt.subplots(2)
>>> fs = 10.0 # Hz
>>> desired = (0, 0, 1, 1, 0, 0)
>>> for bi, bands in enumerate(((0, 1, 2, 3, 4, 5), (0, 1, 2, 4, 4.5, 5))):
... fir_firls = signal.firls(73, bands, desired, fs=fs)
... fir_remez = signal.remez(73, bands, desired[::2], fs=fs)
... fir_firwin2 = signal.firwin2(73, bands, desired, fs=fs)
... hs = list()
... ax = axs[bi]
... for fir in (fir_firls, fir_remez, fir_firwin2):
... freq, response = signal.freqz(fir)
... hs.append(ax.semilogy(0.5*fs*freq/np.pi, np.abs(response))[0])
... for band, gains in zip(zip(bands[::2], bands[1::2]),
... zip(desired[::2], desired[1::2])):
... ax.semilogy(band, np.maximum(gains, 1e-7), 'k--', linewidth=2)
... if bi == 0:
... ax.legend(hs, ('firls', 'remez', 'firwin2'),
... loc='lower center', frameon=False)
... else:
... ax.set_xlabel('Frequency (Hz)')
... ax.grid(True)
... ax.set(title='Band-pass %d-%d Hz' % bands[2:4], ylabel='Magnitude')
...
>>> fig.tight_layout()
>>> plt.show()
""" # noqa
nyq = 0.5 * _get_fs(fs, nyq)
numtaps = int(numtaps)
if numtaps % 2 == 0 or numtaps < 1:
raise ValueError("numtaps must be odd and >= 1")
M = (numtaps - 1) // 2
# normalize bands 0->1 and make it 2 columns
nyq = float(nyq)
if nyq <= 0:
raise ValueError('nyq must be positive, got %s <= 0.' % nyq)
bands = np.asarray(bands).flatten() / nyq
if len(bands) % 2 != 0:
raise ValueError("bands must contain frequency pairs.")
if (bands < 0).any() or (bands > 1).any():
raise ValueError("bands must be between 0 and 1 relative to Nyquist")
bands.shape = (-1, 2)
# check remaining params
desired = np.asarray(desired).flatten()
if bands.size != desired.size:
raise ValueError("desired must have one entry per frequency, got %s "
"gains for %s frequencies." %
(desired.size, bands.size))
desired.shape = (-1, 2)
if (np.diff(bands) <= 0).any() or (np.diff(bands[:, 0]) < 0).any():
raise ValueError("bands must be monotonically nondecreasing and have "
"width > 0.")
if (bands[:-1, 1] > bands[1:, 0]).any():
raise ValueError("bands must not overlap.")
if (desired < 0).any():
raise ValueError("desired must be non-negative.")
if weight is None:
weight = np.ones(len(desired))
weight = np.asarray(weight).flatten()
if len(weight) != len(desired):
raise ValueError("weight must be the same size as the number of "
"band pairs (%s)." % (len(bands), ))
if (weight < 0).any():
raise ValueError("weight must be non-negative.")
# Set up the linear matrix equation to be solved, Qa = b
# We can express Q(k,n) = 0.5 Q1(k,n) + 0.5 Q2(k,n)
# where Q1(k,n)=q(k-n) and Q2(k,n)=q(k+n), i.e. a Toeplitz plus Hankel.
# We omit the factor of 0.5 above, instead adding it during coefficient
# calculation.
# We also omit the 1/π from both Q and b equations, as they cancel
# during solving.
# We have that:
# q(n) = 1/π ∫W(ω)cos(nω)dω (over 0->π)
# Using our nomalization ω=πf and with a constant weight W over each
# interval f1->f2 we get:
# q(n) = W∫cos(πnf)df (0->1) = Wf sin(πnf)/πnf
# integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
n = np.arange(numtaps)[:, np.newaxis, np.newaxis]
q = np.dot(np.diff(np.sinc(bands * n) * bands, axis=2)[:, :, 0], weight)
# Now we assemble our sum of Toeplitz and Hankel
Q1 = toeplitz(q[:M + 1])
Q2 = hankel(q[:M + 1], q[M:])
Q = Q1 + Q2
# Now for b(n) we have that:
# b(n) = 1/π ∫ W(ω)D(ω)cos(nω)dω (over 0->π)
# Using our normalization ω=πf and with a constant weight W over each
# interval and a linear term for D(ω) we get (over each f1->f2 interval):
# b(n) = W ∫ (mf+c)cos(πnf)df
# = f(mf+c)sin(πnf)/πnf + mf**2 cos(nπf)/(πnf)**2
# integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
n = n[:M + 1] # only need this many coefficients here
# Choose m and c such that we are at the start and end weights
m = (np.diff(desired, axis=1) / np.diff(bands, axis=1))
c = desired[:, [0]] - bands[:, [0]] * m
b = bands * (m * bands + c) * np.sinc(bands * n)
# Use L'Hospital's rule here for cos(nπf)/(πnf)**2 @ n=0
b[0] -= m * bands * bands / 2.
b[1:] += m * np.cos(n[1:] * np.pi * bands) / (np.pi * n[1:])**2
b = np.dot(np.diff(b, axis=2)[:, :, 0], weight)
# Now we can solve the equation
try: # try the fast way
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
a = solve(Q, b, assume_a="pos", check_finite=False)
for ww in w:
if (ww.category == LinAlgWarning
and str(ww.message).startswith('Ill-conditioned matrix')):
raise LinAlgError(str(ww.message))
except LinAlgError: # in case Q is rank deficient
# This is faster than pinvh, even though we don't explicitly use
# the symmetry here. gelsy was faster than gelsd and gelss in
# some non-exhaustive tests.
a = lstsq(Q, b, lapack_driver='gelsy')[0]
# make coefficients symmetric (linear phase)
coeffs = np.hstack((a[:0:-1], 2 * a[0], a[1:]))
return coeffs
def generate_block(self, k=None):
from scipy.linalg import toeplitz
r = self.block_initializer(size=(self.block_size, ), k=k)
c = self.block_initializer(size=(self.block_size, ), k=k)
block = toeplitz(r, c)
return block
def create_A_and_b_room2(self):
""" Initializes the matrices A and b for room 2.
For room 2, b will change in every iteration, while A is CONSTANT """
height = 2 # heigth of room 2
M = int(round(height / self.dx)) - 1 # number of rows of nodes
N = self.N # number of cols of nodes
size = M * N # number of unknown nodes
""" Create A """
# The bulk of A is very close to a toeplitz matrix with 5 diagonals.
first_row = np.zeros(size)
first_row[0] = -4
first_row[1] = 1
first_row[N] = 1
A = sl.toeplitz(first_row, first_row)
# The two inner super- and subdiagonals of this toeplitz matrix need to
# be modified. Specifically, every N:th element should be set to zero,
# for a total of (M-1) times, since our grid has M rows, and only the
# first element to be set to zero goes "outside" of the matrix A.
#
# SUB: first zero goes in row N.
row = N
for i in range(M - 1):
A[row, row - 1] = 0
row += N
# SUPER: first zero goes in row N-1.
row = N - 1
for i in range(M - 1):
A[row, row + 1] = 0
row += N
# [Building b].
# Room 2 has 6 different (Dirichlet) boundaries. Of these, 2 change in every
# iteration, while 4 are constant. Here we initialize b,considering only the
# 4 constant boundary conditions, while the other 2 are considered in
# update_b_room2(), called in every iteration in solve().
b = np.zeros(size)
# Upper bounndary:
b[:N] = -self.heater_temp
# Lower boundary:
b[-N:] = -self.window_temp
# Upper left boundary:
# Every N nodes are effected by the upper left boundary, and in total
# N+1 nodes are effected. The first effected node is the 0:th node.
index = 0
for i in range(N + 1):
b[index] -= self.wall_temp
index += N
# Lower right boundary:
# Every N nodes are effected by the upper left boundary, and in total
# N+1 nodes are effected. The first effected node is the (N^2+(N-1)):th node.
index = N**2 + (N - 1)
for i in range(N + 1):
b[index] -= self.wall_temp
index += N
self.A = sp.csc_matrix(A, dtype=float).todense()
self.b = b
def computeWeights(self,
sources,
interferers,
R_n,
delay=0.03,
epsilon=5e-3):
dist_mat = pra.distance(self.R, sources)
s_time = dist_mat / pra.c
s_dmp = 1. / (4 * np.pi * dist_mat)
dist_mat = pra.distance(self.R, interferers)
i_time = dist_mat / pra.c
i_dmp = 1. / (4 * np.pi * dist_mat)
offset = np.maximum(s_dmp.max(),
i_dmp.max()) / (np.pi * self.Fs * epsilon)
t_min = np.minimum(s_time.min(), i_time.min())
t_max = np.maximum(s_time.max(), i_time.max())
s_time -= t_min - offset
i_time -= t_min - offset
Lh = int((t_max - t_min + 2 * offset) * float(self.Fs))
if ((Lh - 1) > (self.M - 1) * self.Lg):
import warnings
wng = "Beamforming filters length (%d) are shorter than minimum required (%d)." % (
self.Lg, Lh)
warnings.warn(wng, UserWarning)
# the channel matrix
Lg = self.Lg
L = self.Lg + Lh - 1
H = np.zeros((Lg * self.M, 2 * L))
for r in np.arange(self.M):
hs = pra.lowPassDirac(s_time[r, :, np.newaxis], s_dmp[r, :,
np.newaxis],
self.Fs, Lh).sum(axis=0)
row = np.pad(hs, ((0, L - len(hs))), mode='constant')
col = np.pad(hs[:1], ((0, Lg - 1)), mode='constant')
H[r * Lg:(r + 1) * Lg, 0:L] = toeplitz(col, row)
hi = pra.lowPassDirac(i_time[r, :, np.newaxis], i_dmp[r, :,
np.newaxis],
self.Fs, Lh).sum(axis=0)
row = np.pad(hi, ((0, L - len(hi))), mode='constant')
col = np.pad(hi[:1], ((0, Lg - 1)), mode='constant')
H[r * Lg:(r + 1) * Lg, L:2 * L] = toeplitz(col, row)
# the constraint vector
kappa = int(delay * self.Fs)
#kappa = np.minimum(int(0.6*(Lh+Lg)), int(2*t_max*self.Fs))
h = H[:, kappa]
# We first assume the sample are uncorrelated
R_xx = np.dot(H[:, :L], H[:, :L].T)
K_nq = np.dot(H[:, L:], H[:, L:].T) + R_n
# Compute the TD filters
C = la.cho_factor(R_xx + K_nq, check_finite=False)
g_val = la.cho_solve(C, h)
g_val /= np.inner(h, g_val)
self.filters = g_val.reshape((self.M, Lg))
'''
import matplotlib.pyplot as plt
plt.figure()
plt.subplot(2,1,1)
plt.plot(np.arange(L)/float(self.Fs), np.dot(H[:,:L].T, g_val))
plt.plot(np.arange(L)/float(self.Fs), np.dot(H[:,L:].T, g_val))
plt.legend(('Channel of desired source','Channel of interferer'))
plt.subplot(2,1,2)
for m in np.arange(self.M):
plt.plot(np.arange(Lh)/float(self.Fs), H[m*Lg,:Lh])
'''
# compute and return SNR
num = np.inner(g_val.T, np.dot(R_xx, g_val))
denom = np.inner(np.dot(g_val.T, K_nq), g_val)
return num / denom
'pvalues': mdl.pvalues,
'params': mdl.params
},
index=x_columns)
if 'const' in pp.sort_values('pvalues')[:s].index:
sig_ind = sorted(np.argpartition(mdl.pvalues, s)[:s])
else:
sig_ind = sorted(np.argpartition(mdl.pvalues, s - 1)[:(s - 1)]) + [0]
x_f_new = x_f[:N, sig_ind]
x_columns_new = x_columns[sig_ind]
y_f_new = y_f[:N]
cov_mat = toeplitz(0.5**np.arange(d - s))
np.random.seed(93)
x_f_new = np.hstack(
(x_f_new, np.random.multivariate_normal(np.zeros(d - s), cov_mat, N)))
x_f_new[:, int(-(d - s) /
2):] = (x_f_new[:, int(-(d - s) / 2):] >= 0).astype(float)
x_m_new = x_f_new[:n0]
y_m = y_f_new[:n0]
logregcv = LogisticRegressionCV(cv=10,
scoring='neg_log_loss',
penalty='l1',
solver='saga',
fit_intercept=False,
max_iter=1000,
n_jobs=-1,
def estimate_time_constant(Y,
sn,
p=None,
lags=5,
include_noise=False,
pixels=None):
"""
Estimating global time constants for the dataset Y through the autocovariance function (optional).
The function is no longer used in the standard setting of the algorithm since every trace has its own
time constant.
Args:
Y: np.ndarray (2D)
input movie data with time in the last axis
p: positive integer
order of AR process, default: 2
lags: positive integer
number of lags in the past to consider for determining time constants. Default 5
include_noise: Boolean
Flag to include pre-estimated noise value when determining time constants. Default: False
pixels: np.ndarray
Restrict estimation to these pixels (e.g., remove saturated pixels). Default: All pixels
Returns:
g: np.ndarray (p x 1)
Discrete time constants
"""
if p is None:
raise Exception("You need to define p")
if pixels is None:
pixels = np.arange(old_div(np.size(Y), np.shape(Y)[-1]))
from scipy.linalg import toeplitz
npx = len(pixels)
lags += p
XC = np.zeros((npx, 2 * lags + 1))
for j in range(npx):
XC[j, :] = np.squeeze(axcov(np.squeeze(Y[pixels[j], :]), lags))
gv = np.zeros(npx * lags)
if not include_noise:
XC = XC[:, np.arange(lags - 1, -1, -1)]
lags -= p
A = np.zeros((npx * lags, p))
for i in range(npx):
if not include_noise:
A[i * lags + np.arange(lags), :] = toeplitz(
np.squeeze(XC[i, np.arange(p - 1, p + lags - 1)]),
np.squeeze(XC[i, np.arange(p - 1, -1, -1)]))
else:
A[i * lags + np.arange(lags), :] = toeplitz(
np.squeeze(XC[i, lags + np.arange(lags)]),
np.squeeze(XC[i, lags +
np.arange(p)])) - (sn[i]**2) * np.eye(lags, p)
gv[i * lags + np.arange(lags)] = np.squeeze(XC[i, lags + 1:])
if not include_noise:
gv = XC[:, p:].T
gv = np.squeeze(np.reshape(gv, (np.size(gv), 1), order='F'))
g = np.dot(np.linalg.pinv(A), gv)
return g
def FIRuncFilter(y,
sigma_noise,
theta,
Utheta=None,
shift=0,
blow=None,
kind="corr"):
"""Uncertainty propagation for signal y and uncertain FIR filter theta
Parameters
----------
y: np.ndarray
filter input signal
sigma_noise: float or np.ndarray
float: standard deviation of white noise in y
1D-array: interpretation depends on kind
theta: np.ndarray
FIR filter coefficients
Utheta: np.ndarray
covariance matrix associated with theta
shift: int
time delay of filter output signal (in samples)
blow: np.ndarray
optional FIR low-pass filter
kind: string
only meaningfull in combination with isinstance(sigma_noise, numpy.ndarray)
"diag": point-wise standard uncertainties of non-stationary white noise
"corr": single sided autocovariance of stationary (colored/corrlated) noise (default)
Returns
-------
x: np.ndarray
FIR filter output signal
ux: np.ndarray
point-wise uncertainties associated with x
References
----------
* Elster and Link 2008 [Elster2008]_
.. seealso:: :mod:`PyDynamic.deconvolution.fit_filter`
"""
Ntheta = len(theta) # FIR filter size
# filterOrder = Ntheta - 1 # FIR filter order
if not isinstance(Utheta,
np.ndarray): # handle case of zero uncertainty filter
Utheta = np.zeros((Ntheta, Ntheta))
# check which case of sigma_noise is necessary
if isinstance(sigma_noise, float):
sigma2 = sigma_noise**2
elif isinstance(sigma_noise, np.ndarray):
if kind == "diag":
sigma2 = sigma_noise**2
elif kind == "corr":
sigma2 = sigma_noise
else:
raise ValueError("unknown kind of sigma_noise")
else:
raise ValueError(
"sigma_noise is neither of type float nor numpy.ndarray.")
if isinstance(blow, np.ndarray
): # calculate low-pass filtered signal and propagate noise
if isinstance(sigma2, float):
Bcorr = np.correlate(blow, blow,
'full') # len(Bcorr) == 2*Ntheta - 1
ycorr = sigma2 * Bcorr[len(
blow) - 1:] # only the upper half of the correlation is needed
# trim / pad to length Ntheta
ycorr = trimOrPad(ycorr, Ntheta)
Ulow = toeplitz(ycorr)
elif isinstance(sigma2, np.ndarray):
if kind == "diag":
# [Leeuw1994](Covariance matrix of ARMA errors in closed form) can be used, to derive this formula
# The given "blow" corresponds to a MA(q)-process.
# Going through the calculations of Leeuw, but assuming
# that E(vv^T) is a diagonal matrix with non-identical elements,
# the covariance matrix V becomes (see Leeuw:corollary1)
# V = N * SP * N^T + M * S * M^T
# N, M are defined as in the paper
# and SP is the covariance of input-noise prior to the observed time-interval
# (SP needs be available len(blow)-timesteps into the past. Here it is
# assumed, that SP is constant with the first value of sigma2)
# V needs to be extended to cover Ntheta-1 timesteps more into the past
sigma2_extended = np.append(sigma2[0] * np.ones((Ntheta - 1)),
sigma2)
N = toeplitz(blow[1:][::-1], np.zeros_like(sigma2_extended)).T
M = toeplitz(trimOrPad(blow, len(sigma2_extended)),
np.zeros_like(sigma2_extended))
SP = np.diag(sigma2[0] * np.ones_like(blow[1:]))
S = np.diag(sigma2_extended)
# Ulow is to be sliced from V, see below
V = N.dot(SP).dot(N.T) + M.dot(S).dot(M.T)
elif kind == "corr":
# adjust the lengths sigma2 to fit blow and theta
# this either crops (unused) information or appends zero-information
# note1: this is the reason, why Ulow will have dimension (Ntheta x Ntheta) without further ado
# calculate Bcorr
Bcorr = np.correlate(blow, blow, "full")
# pad or crop length of sigma2, then reflect some part to the left and invert the order
# [0 1 2 3 4 5 6 7] --> [0 0 0 7 6 5 4 3 2 1 0 1 2 3]
sigma2 = trimOrPad(sigma2, len(blow) + Ntheta - 1)
sigma2_reflect = np.pad(sigma2, (len(blow) - 1, 0),
mode="reflect")
ycorr = np.correlate(
sigma2_reflect, Bcorr, mode="valid"
) # used convolve in a earlier version, should make no difference as Bcorr is symmetric
Ulow = toeplitz(ycorr)
xlow, _ = lfilter(blow, 1.0, y, zi=y[0] * lfilter_zi(blow, 1.0))
else: # if blow is not provided
if isinstance(sigma2, float):
Ulow = np.eye(Ntheta) * sigma2
elif isinstance(sigma2, np.ndarray):
if kind == "diag":
# V needs to be extended to cover Ntheta timesteps more into the past
sigma2_extended = np.append(sigma2[0] * np.ones((Ntheta - 1)),
sigma2)
# Ulow is to be sliced from V, see below
V = np.diag(
sigma2_extended
) # this is not Ulow, same thing as in the case of a provided blow (see above)
elif kind == "corr":
Ulow = toeplitz(trimOrPad(sigma2, Ntheta))
xlow = y
# apply FIR filter to calculate best estimate in accordance with GUM
x, _ = lfilter(theta, 1.0, xlow, zi=xlow[0] * lfilter_zi(theta, 1.0))
x = np.roll(x, -int(shift))
# add dimension to theta, otherwise transpose won't work
if len(theta.shape) == 1:
theta = theta[:, np.newaxis]
# handle diag-case, where Ulow needs to be sliced from V
if kind == "diag":
# UncCov needs to be calculated inside in its own for-loop
# V has dimension (len(sigma2) + Ntheta) * (len(sigma2) + Ntheta) --> slice a fitting Ulow of dimension (Ntheta x Ntheta)
UncCov = np.zeros((len(sigma2)))
for k in range(len(sigma2)):
Ulow = V[k:k + Ntheta, k:k + Ntheta]
UncCov[k] = np.squeeze(
theta.T.dot(Ulow.dot(theta)) + np.abs(
np.trace(Ulow.dot(Utheta)))) # static part of uncertainty
else:
UncCov = theta.T.dot(Ulow.dot(theta)) + np.abs(
np.trace(Ulow.dot(Utheta))) # static part of uncertainty
unc = np.zeros_like(y)
for m in range(Ntheta, len(xlow)):
XL = xlow[m:m - Ntheta:-1,
np.newaxis] # extract necessary part from input signal
unc[m] = XL.T.dot(Utheta.dot(XL)) # apply formula from paper
ux = np.sqrt(np.abs(UncCov + unc))
ux = np.roll(ux, -int(shift)) # correct for delay
return x, ux.flatten() # flatten in case that we still have 2D array
def _project_images(reference_sources, estimated_source, flen, G=None):
"""Least-squares projection of estimated source on the subspace spanned by
delayed versions of reference sources, with delays between 0 and flen-1.
Passing G as all zeros will populate the G matrix and return it so it can
be passed into the next call to avoid recomputing G (this will only works
if not computing permutations).
"""
nsrc = reference_sources.shape[0]
nsampl = reference_sources.shape[1]
nchan = reference_sources.shape[2]
reference_sources = np.reshape(np.transpose(reference_sources, (2, 0, 1)),
(nchan * nsrc, nsampl), order='F')
# computing coefficients of least squares problem via FFT ##
# zero padding and FFT of input data
reference_sources = np.hstack((reference_sources,
np.zeros((nchan * nsrc, flen - 1))))
estimated_source = \
np.hstack((estimated_source.transpose(), np.zeros((nchan, flen - 1))))
n_fft = int(2 ** np.ceil(np.log2(nsampl + flen - 1.)))
sf = scipy.fftpack.fft(reference_sources, n=n_fft, axis=1)
sef = scipy.fftpack.fft(estimated_source, n=n_fft)
# inner products between delayed versions of reference_sources
if G is None:
saveg = False
G = np.zeros((nchan * nsrc * flen, nchan * nsrc * flen))
for i in range(nchan * nsrc):
for j in range(i + 1):
ssf = sf[i] * np.conj(sf[j])
ssf = np.real(scipy.fftpack.ifft(ssf))
ss = toeplitz(np.hstack((ssf[0], ssf[-1:-flen:-1])),
r=ssf[:flen])
G[i * flen: (i + 1) * flen, j * flen: (j + 1) * flen] = ss
G[j * flen: (j + 1) * flen, i * flen: (i + 1) * flen] = ss.T
else: # avoid recomputing G (only works if no permutation is desired)
saveg = True # return G
if np.all(G == 0): # only compute G if passed as 0
G = np.zeros((nchan * nsrc * flen, nchan * nsrc * flen))
for i in range(nchan * nsrc):
for j in range(i + 1):
ssf = sf[i] * np.conj(sf[j])
ssf = np.real(scipy.fftpack.ifft(ssf))
ss = toeplitz(np.hstack((ssf[0], ssf[-1:-flen:-1])),
r=ssf[:flen])
G[i * flen: (i + 1) * flen, j * flen: (j + 1) * flen] = ss
G[j * flen: (j + 1) * flen, i * flen: (i + 1) * flen] = ss.T
# inner products between estimated_source and delayed versions of
# reference_sources
D = np.zeros((nchan * nsrc * flen, nchan))
for k in range(nchan * nsrc):
for i in range(nchan):
ssef = sf[k] * np.conj(sef[i])
ssef = np.real(scipy.fftpack.ifft(ssef))
D[k * flen: (k + 1) * flen, i] = \
np.hstack((ssef[0], ssef[-1:-flen:-1])).transpose()
# Computing projection
# Distortion filters
try:
C = np.linalg.solve(G, D).reshape(flen, nchan * nsrc, nchan, order='F')
except np.linalg.linalg.LinAlgError:
C = np.linalg.lstsq(G, D)[0].reshape(flen, nchan * nsrc, nchan,
order='F')
# Filtering
sproj = np.zeros((nchan, nsampl + flen - 1))
for k in range(nchan * nsrc):
for i in range(nchan):
sproj[i] += fftconvolve(C[:, k, i].transpose(),
reference_sources[k])[:nsampl + flen - 1]
# return G only if it was passed in
if saveg:
return sproj, G
else:
return sproj
def test_scalar_03(self):
c = array([1, 2, 3])
t = toeplitz(c, array([1]))
assert_array_equal(t, [[1], [2], [3]])
def generate_mai(m: int,
k: int,
N: int,
M: int,
sparse_variables_1: float = 0,
sparse_variables_2: float = 0,
signal: float = 1,
structure: str = 'identity',
sigma: float = 0.9,
decay: float = 0.5):
mean = np.zeros(N + M)
cov = np.zeros((N + M, N + M))
p = np.arange(0, k)
p = decay**p
# Covariance Bit
if structure == 'identity':
cov_1 = np.eye(N)
cov_2 = np.eye(M)
elif structure == 'gaussian':
x = np.linspace(-1, 1, N)
x_tile = np.tile(x, (N, 1))
mu_tile = np.transpose(x_tile)
dn = 2 / (N - 1)
cov_1 = gaussian(x_tile, mu_tile, sigma, dn)
cov_1 /= cov_1.max()
x = np.linspace(-1, 1, M)
x_tile = np.tile(x, (M, 1))
mu_tile = np.transpose(x_tile)
dn = 2 / (M - 1)
cov_2 = gaussian(x_tile, mu_tile, sigma, dn)
cov_2 /= cov_2.max()
elif structure == 'toeplitz':
c = np.arange(0, N)
c = sigma**c
cov_1 = linalg.toeplitz(c, c)
c = np.arange(0, M)
c = sigma**c
cov_2 = linalg.toeplitz(c, c)
elif structure == 'random':
if N < 2000:
cov_1 = np.random.rand(N, N)
U, S, V = np.linalg.svd(cov_1.T @ cov_1)
cov_1 = U @ (1.0 + np.diag(np.random.rand(N))) @ V
else:
cov_1 = np.random.rand(N, N)
cov_1 = cov_1.T @ cov_1
if M < 2000:
cov_2 = np.random.rand(M, M)
U, S, V = np.linalg.svd(cov_2.T @ cov_2)
cov_2 = U @ (1.0 + np.diag(np.random.rand(M))) @ V
else:
cov_2 = np.random.rand(M, M)
cov_2 = cov_2.T @ cov_2
cov[:N, :N] = cov_1
cov[N:, N:] = cov_2
del cov_1
del cov_2
"""
# Sparse Bits
if sparse_variables_1 > 0:
sparse_cov_1 = csr_matrix(cov_1)
cov_1 = sparse_cov_1.copy()
else:
sparse_cov_1 = cov_1.copy()
"""
up = np.random.rand(N, k) - 0.5
for _ in range(k):
if sparse_variables_1 > 0:
if sparse_variables_1 < 1:
sparse_variables_1 = np.ceil(sparse_variables_1 *
N).astype('int')
first = np.random.randint(N - sparse_variables_1)
up[:first, _] = 0
up[(first + sparse_variables_1):, _] = 0
up[:, _] /= np.sqrt((up[:, _].T @ cov[:N, :N] @ up[:, _]))
"""
if _ < (k - 1) and sparse_variables_1 == 0:
proj = csr_matrix(up[:, _]).T @ csr_matrix(up[:, _])
cov_1 = (identity(up[:, _].shape[0]) - proj) @ cov_1 @ (identity(up[:, _].shape[0]) - proj)
"""
"""
# Elimination step:
for _ in range(k):
mat_1 = up.T @ sparse_cov_1 @ up
up[:, (_ + 1):] -= np.outer(up[:, _], mat_1[_, (_ + 1):])
"""
"""
if sparse_variables_2 > 0:
sparse_cov_2 = csr_matrix(cov_2)
cov_2 = sparse_cov_2.copy()
else:
sparse_cov_2 = cov_2.copy()
"""
vp = np.random.rand(M, k) - 0.5
for _ in range(k):
if sparse_variables_2 > 0:
if sparse_variables_2 < 1:
sparse_variables_2 = np.ceil(sparse_variables_2 *
M).astype('int')
first = np.random.randint(M - sparse_variables_2)
vp[:first, _] = 0
vp[(first + sparse_variables_2):, _] = 0
vp[:, _] /= np.sqrt((vp[:, _].T @ cov[N:, N:] @ vp[:, _]))
"""
if _ < (k - 1) and sparse_variables_2 == 0:
proj = csr_matrix(vp[:, _]).T @ csr_matrix(vp[:, _])
cov_2 = (identity(vp[:, _].shape[0]) - proj) @ cov_2 @ (identity(vp[:, _].shape[0]) - proj)
"""
"""
for _ in range(k):
mat_2 = vp.T @ sparse_cov_2 @ vp
vp[:, (_ + 1):] -= np.outer(vp[:, _], mat_2[_, (_ + 1):])
"""
cross = np.zeros((N, M))
for _ in range(k):
cross += signal * p[_] * np.outer(up[:, _], vp[:, _])
# Cross Bit
cross = cov[:N, :N] @ cross @ cov[N:, N:]
cov[N:, :N] = cross.T
cov[:N, N:] = cross
del cross
if cov.shape[0] < 2000:
X = np.random.multivariate_normal(mean, cov, m)
else:
X = np.zeros((m, N + M))
chol = np.linalg.cholesky(cov)
for _ in range(m):
X[_, :] = chol_sample(mean, chol)
Y = X[:, N:]
X = X[:, :N]
return X, Y, up, vp, cov
