def _contour_t(mu, Cov, nu, axes=None, scale=4, transpose=False, colors='k'):
"""
"""
if axes is None:
axes = plt.gca()
if np.shape(mu) != (2, ) or np.shape(Cov) != (2, 2) or np.shape(nu) != ():
print(np.shape(mu), np.shape(Cov), np.shape(nu))
raise ValueError("Only 2-d t-distribution allowed")
if transpose:
mu = mu[[1, 0]]
Cov = Cov[np.ix_([1, 0], [1, 0])]
s = np.sqrt(np.diag(Cov))
x0 = np.linspace(mu[0] - scale * s[0], mu[0] + scale * s[0], num=100)
x1 = np.linspace(mu[1] - scale * s[1], mu[1] + scale * s[1], num=100)
X0X1 = misc.grid(x0, x1)
Y = X0X1 - mu
L = linalg.chol(Cov)
logdet_Cov = linalg.chol_logdet(L)
Z = linalg.chol_solve(L, Y)
Z = linalg.inner(Y, Z, ndim=1)
lpdf = random.t_logpdf(Z, logdet_Cov, nu, 2)
p = np.exp(lpdf)
shape = (np.size(x0), np.size(x1))
X0 = np.reshape(X0X1[:, 0], shape)
X1 = np.reshape(X0X1[:, 1], shape)
P = np.reshape(p, shape)
return axes.contour(X0, X1, P, colors=colors)
def gaussian_mixture_logpdf(x, w, mu, Sigma):
# Shape(x) = (N, D)
# Shape(w) = (K,)
# Shape(mu) = (K, D)
# Shape(Sigma) = (K, D, D)
# Shape(result) = (N,)
# Dimensionality
D = np.shape(x)[-1]
# Cholesky decomposition of the covariance matrix
U = linalg.chol(Sigma)
# Reshape x:
# Shape(x) = (N, 1, D)
x = np.expand_dims(x, axis=-2)
# (x-mu) and (x-mu)'*inv(Sigma)*(x-mu):
# Shape(v) = (N, K, D)
# Shape(z) = (N, K)
v = x - mu
z = np.einsum('...i,...i', v, linalg.chol_solve(U, v))
# Log-determinant of Sigma:
# Shape(ldet) = (K,)
ldet = linalg.chol_logdet(U)
# Compute log pdf for each cluster:
# Shape(lpdf) = (N, K)
lpdf = misc.gaussian_logpdf(z, 0, 0, ldet, D)
def _contour_t(mu, Cov, nu, axes=None, scale=4, transpose=False, colors='k'):
"""
"""
if axes is None:
axes = plt.gca()
if np.shape(mu) != (2,) or np.shape(Cov) != (2,2) or np.shape(nu) != ():
print(np.shape(mu), np.shape(Cov), np.shape(nu))
raise ValueError("Only 2-d t-distribution allowed")
if transpose:
mu = mu[[1,0]]
Cov = Cov[np.ix_([1,0],[1,0])]
s = np.sqrt(np.diag(Cov))
x0 = np.linspace(mu[0]-scale*s[0], mu[0]+scale*s[0], num=100)
x1 = np.linspace(mu[1]-scale*s[1], mu[1]+scale*s[1], num=100)
X0X1 = misc.grid(x0, x1)
Y = X0X1 - mu
L = linalg.chol(Cov)
logdet_Cov = linalg.chol_logdet(L)
Z = linalg.chol_solve(L, Y)
Z = linalg.inner(Y, Z, ndim=1)
lpdf = random.t_logpdf(Z, logdet_Cov, nu, 2)
p = np.exp(lpdf)
shape = (np.size(x0), np.size(x1))
X0 = np.reshape(X0X1[:,0], shape)
X1 = np.reshape(X0X1[:,1], shape)
P = np.reshape(p, shape)
return axes.contour(X0, X1, P, colors=colors)
def gaussian_mixture_logpdf(x, w, mu, Sigma):
# Shape(x) = (N, D)
# Shape(w) = (K,)
# Shape(mu) = (K, D)
# Shape(Sigma) = (K, D, D)
# Shape(result) = (N,)
# Dimensionality
D = np.shape(x)[-1]
# Cholesky decomposition of the covariance matrix
U = linalg.chol(Sigma)
# Reshape x:
# Shape(x) = (N, 1, D)
x = np.expand_dims(x, axis=-2)
# (x-mu) and (x-mu)'*inv(Sigma)*(x-mu):
# Shape(v) = (N, K, D)
# Shape(z) = (N, K)
v = x - mu
z = np.einsum('...i,...i', v, linalg.chol_solve(U, v))
# Log-determinant of Sigma:
# Shape(ldet) = (K,)
ldet = linalg.chol_logdet(U)
# Compute log pdf for each cluster:
# Shape(lpdf) = (N, K)
lpdf = misc.gaussian_logpdf(z, 0, 0, ldet, D)
def kalman_filter(y, U, A, V, mu0, Cov0, out=None):
"""
Perform Kalman filtering to obtain filtered mean and covariance.
The parameters of the process may vary in time, thus they are
given as iterators instead of fixed values.
Parameters
----------
y : (N,D) array
"Normalized" noisy observations of the states, that is, the
observations multiplied by the precision matrix U (and possibly
other transformation matrices).
U : (N,D,D) array or N-list of (D,D) arrays
Precision matrix (i.e., inverse covariance matrix) of the observation
noise for each time instance.
A : (N-1,D,D) array or (N-1)-list of (D,D) arrays
Dynamic matrix for each time instance.
V : (N-1,D,D) array or (N-1)-list of (D,D) arrays
Covariance matrix of the innovation noise for each time instance.
Returns
-------
mu : array
Filtered mean of the states.
Cov : array
Filtered covariance of the states.
See also
--------
rts_smoother
"""
mu = mu0
Cov = Cov0
# Allocate memory for the results
(N, D) = np.shape(y)
X = np.empty((N, D))
CovX = np.empty((N, D, D))
# Update step for t=0
M = np.dot(np.dot(Cov, U[0]), Cov) + Cov
L = linalg.chol(M)
mu = np.dot(Cov, linalg.chol_solve(L, np.dot(Cov, y[0]) + mu))
Cov = np.dot(Cov, linalg.chol_solve(L, Cov))
X[0, :] = mu
CovX[0, :, :] = Cov
# for (yn, Un, An, Vn) in zip(y, U, A, V):
for n in range(len(y) - 1): # (yn, Un, An, Vn) in zip(y, U, A, V):
# Prediction step
mu = np.dot(A[n], mu)
Cov = np.dot(np.dot(A[n], Cov), A[n].T) + V[n]
# Update step
M = np.dot(np.dot(Cov, U[n + 1]), Cov) + Cov
L = linalg.chol(M)
mu = np.dot(Cov, linalg.chol_solve(L, np.dot(Cov, y[n + 1]) + mu))
Cov = np.dot(Cov, linalg.chol_solve(L, Cov))
# Force symmetric covariance (for numeric inaccuracy)
Cov = 0.5 * Cov + 0.5 * Cov.T
# Store results
X[n + 1, :] = mu
CovX[n + 1, :, :] = Cov
return (X, CovX)
def kalman_filter(y, U, A, V, mu0, Cov0, out=None):
"""
Perform Kalman filtering to obtain filtered mean and covariance.
The parameters of the process may vary in time, thus they are
given as iterators instead of fixed values.
Parameters
----------
y : (N,D) array
"Normalized" noisy observations of the states, that is, the
observations multiplied by the precision matrix U (and possibly
other transformation matrices).
U : (N,D,D) array or N-list of (D,D) arrays
Precision matrix (i.e., inverse covariance matrix) of the observation
noise for each time instance.
A : (N-1,D,D) array or (N-1)-list of (D,D) arrays
Dynamic matrix for each time instance.
V : (N-1,D,D) array or (N-1)-list of (D,D) arrays
Covariance matrix of the innovation noise for each time instance.
Returns
-------
mu : array
Filtered mean of the states.
Cov : array
Filtered covariance of the states.
See also
--------
rts_smoother
"""
mu = mu0
Cov = Cov0
# Allocate memory for the results
(N,D) = np.shape(y)
X = np.empty((N,D))
CovX = np.empty((N,D,D))
# Update step for t=0
M = np.dot(np.dot(Cov, U[0]), Cov) + Cov
L = linalg.chol(M)
mu = np.dot(Cov, linalg.chol_solve(L, np.dot(Cov,y[0]) + mu))
Cov = np.dot(Cov, linalg.chol_solve(L, Cov))
X[0,:] = mu
CovX[0,:,:] = Cov
#for (yn, Un, An, Vn) in zip(y, U, A, V):
for n in range(len(y)-1): #(yn, Un, An, Vn) in zip(y, U, A, V):
# Prediction step
mu = np.dot(A[n], mu)
Cov = np.dot(np.dot(A[n], Cov), A[n].T) + V[n]
# Update step
M = np.dot(np.dot(Cov, U[n+1]), Cov) + Cov
L = linalg.chol(M)
mu = np.dot(Cov, linalg.chol_solve(L, np.dot(Cov,y[n+1]) + mu))
Cov = np.dot(Cov, linalg.chol_solve(L, Cov))
# Force symmetric covariance (for numeric inaccuracy)
Cov = 0.5*Cov + 0.5*Cov.T
# Store results
X[n+1,:] = mu
CovX[n+1,:,:] = Cov
return (X, CovX)
