def statistics(self, x, y): if isinstance(x, np.ndarray) and isinstance(y, np.ndarray): idx = np.logical_and(~np.isnan(x).any(axis=1), ~np.isnan(y).any(axis=1)) x, y = x[idx], y[idx] if self.affine: x = np.hstack((x, np.ones((x.shape[0], 1)))) contract = 'nd,nl->dl' yxT = np.einsum(contract, y, x, optimize=True) xxT = np.einsum(contract, x, x, optimize=True) yyT = np.einsum(contract, y, y, optimize=True) n = y.shape[0] yxTk = np.array([yxT for _ in range(self.size)]) xxTk = np.array([xxT for _ in range(self.size)]) yyTk = np.array([yyT for _ in range(self.size)]) nk = np.array([n for _ in range(self.size)]) return Stats([yxTk, xxTk, yyTk, nk]) else: stats = list(map(self.statistics, x, y)) return reduce(add, stats)
def std_to_nat(self, params): params_list = list(zip(*params)) natparams_list = [ dist.std_to_nat(par) for dist, par in zip(self.dists, params_list) ] natparams_stack = Stats( map(partial(np.stack, axis=0), zip(*natparams_list))) return natparams_stack
def weighted_statistics(self, data, weights): if isinstance(data, np.ndarray): idx = ~np.isnan(data).any(axis=0) data, weights = data[idx], weights[idx] n = 0.5 * np.sum(weights) xx = -0.5 * np.einsum('nd,n,nd->d', data, weights, data) return Stats([n, xx]) else: stats = list(map(self.weighted_statistics, data, weights)) return reduce(add, stats)
def statistics(self, data): if isinstance(data, np.ndarray): idx = ~np.isnan(data).any(axis=0) data = data[idx] n = 0.5 * data.shape[0] xx = -0.5 * np.einsum('nd,nd->d', data, data) return Stats([n, xx]) else: stats = list(map(self.statistics, data)) return reduce(add, stats)
def weighted_statistics(self, data, weights): if isinstance(data, np.ndarray): idx = ~np.isnan(data).any(axis=1) data, weights = data[idx], weights[idx] x = np.einsum('n,nd->d', weights, data) n = np.sum(weights) xx = np.einsum('nd,n,nd->d', data, weights, data) nd = np.broadcast_to(np.sum(weights), (self.dim, )) return Stats([x, nd, nd, xx]) else: stats = list(map(self.weighted_statistics, data, weights)) return reduce(add, stats)
def statistics(self, data): if isinstance(data, np.ndarray): idx = ~np.isnan(data).any(axis=1) data = data[idx] x = np.sum(data, axis=0) n = data.shape[0] xx = np.einsum('nd,nd->d', data, data) nd = np.broadcast_to(data.shape[0], (self.dim, )) return Stats([x, nd, nd, xx]) else: stats = list(map(self.statistics, data)) return reduce(add, stats)
def weighted_statistics(self, data, weights): if isinstance(data, np.ndarray): idx = ~np.isnan(data).any(axis=1) data, weights = data[idx], weights[idx] xk = np.einsum('nk,nd->kd', weights, data) xxk = np.einsum('nd,nk,nd->kd', data, weights, data) ndk = np.broadcast_to(np.sum(weights, axis=0, keepdims=True), (self.size, self.dim)) return Stats([xk, ndk, ndk, xxk]) else: stats = list(map(self.weighted_statistics, data, weights)) return reduce(add, stats)
def weighted_statistics(self, data, weights): if isinstance(data, np.ndarray): idx = ~np.isnan(data).any(axis=1) data, weights = data[idx], weights[idx] c0, c1 = 'nk,nd->kd', 'nd,nk,nl->kdl' xk = np.einsum(c0, weights, data, optimize=True) xxTk = np.einsum(c1, data, weights, data, optimize=True) nk = np.sum(weights, axis=0) return Stats([xk, nk, xxTk, nk]) else: stats = list(map(self.weighted_statistics, data, weights)) return reduce(add, stats)
def statistics(self, data): if isinstance(data, np.ndarray): idx = ~np.isnan(data).any(axis=1) data = data[idx] c0, c1 = 'nd->d', 'nd,nl->dl' x = np.einsum(c0, data, optimize=True) xxT = np.einsum(c1, data, data, optimize=True) n = data.shape[0] return Stats([x, n, xxT, n]) else: stats = list(map(self.statistics, data)) return reduce(add, stats)
def weighted_statistics(self, x, y, weights): if isinstance(x, np.ndarray) and isinstance(y, np.ndarray): idx = np.logical_and(~np.isnan(x).any(axis=1), ~np.isnan(y).any(axis=0)) x, y, weights = x[idx], y[idx], weights[idx] if self.affine: x = np.hstack((x, np.ones((x.shape[0], 1)))) xxT = - 0.5 * np.einsum('nd,n,nl->dl', x, weights, x, optimize=True) yxT = np.einsum('n,n,nl->l', y, weights, x, optimize=True) return Stats([yxT, xxT]) else: stats = list(map(self.weighted_statistics, x, y, weights)) return reduce(add, stats)
def std_to_nat(self, params): # stats = [A.T @ V, # -0.5 * A.T @ V @ A, # -0.5 * V, # 0.5 * log_det(V)] # # nats = [M @ K, # K, # psi^-1 + M @ K @ M.T, # nu - d - 1. + l] a = params[0] @ params[1] b = params[1] c = np.linalg.inv(params[2]) + params[0] @ params[1] @ params[0].T d = params[3] - self.row_dim - 1. + self.column_dim return Stats([a, b, c, d])
def std_to_nat(params): # stats = [mu * lmbda_diag, # -0.5 * lmbda_diag * mu * mu, # 0.5 * log(lmbda_diag), # -0.5 * lmbda_diag] # # nats = [kappa * m, # kappa, # 2. * alpha - 1., # 2. * beta + kappa * m * m] a = params[1] * params[0] b = params[1] c = 2. * params[2] - 1. d = 2. * params[3] + params[1] * params[0]**2 return Stats([a, b, c, d])
def std_to_nat(params): # stats = [A.T * V_diag, # -0.5 * A.T @ A, # 0.5 * log(V_diag), # -0.5 * V_diag] # # nats = [M @ K, # K, # 2. * alpha - 1., # 2. * beta + M @ K @ M.T] a = params[0] @ params[1] b = params[1] c = 2. * params[2] - 1. d = 2. * params[3] + np.einsum('dl,lm,dm->d', params[0], params[1], params[0]) return Stats([a, b, c, d])
def std_to_nat(params): # stats = [mu.T @ lmbda, # -0.5 * lmbda @ (mu @ mu.T), # -0.5 * lmbda, # 0.5 * logdet(lmbda)] # # nats = [kappa * m, # kappa, # psi^-1 + kappa * (m @ m.T), # nu - d] a = params[1] * params[0] b = params[1] c = np.linalg.inv( params[2]) + params[1] * np.outer(params[0], params[0]) d = params[3] - params[2].shape[0] return Stats([a, b, c, d])
def weighted_statistics(self, x, y, weights): if isinstance(x, np.ndarray) and isinstance(y, np.ndarray): idx = np.logical_and(~np.isnan(x).any(axis=1), ~np.isnan(y).any(axis=0)) x, y, weights = x[idx], y[idx], weights[idx] if self.affine: x = np.hstack((x, np.ones((x.shape[0], 1)))) n = 0.5 * np.sum(weights) yy = - 0.5 * np.sum(weights * y * y) yxTa = np.einsum('n,n,nl,l->', y, weights, x, self.W, optimize=True) xTaaTx = - 0.5 * np.einsum('l,nl,n,nd,d->', self.W, x, weights, x, self.W, optimize=True) return Stats([n, yy + yxTa + xTaaTx]) else: stats = list(map(self.weighted_statistics, x, y, weights)) return reduce(add, stats)
def weighted_statistics(self, x, y, weights): if isinstance(x, np.ndarray) and isinstance(y, np.ndarray): idx = np.logical_and(~np.isnan(x).any(axis=1), ~np.isnan(y).any(axis=1)) x, y, weights = x[idx], y[idx], weights[idx] if self.affine: x = np.hstack((x, np.ones((x.shape[0], 1)))) xxT = np.einsum('nd,n,nl->dl', x, weights, x, optimize=True) yxT = np.einsum('nd,n,nl->dl', y, weights, x, optimize=True) yy = np.einsum('nd,n,nd->d', y, weights, y, optimize=True) nd = np.broadcast_to(np.sum(weights), (self.output_dim, )) return Stats([yxT, xxT, nd, yy]) else: stats = list(map(self.weighted_statistics, x, y, weights)) return reduce(add, stats)
def statistics(self, data): if isinstance(data, np.ndarray): idx = ~np.isnan(data).any(axis=1) data = data[idx] c0, c1 = 'nd->d', 'nd,nd->d' x = np.einsum(c0, data, optimize=True) xx = np.einsum(c1, data, data, optimize=True) nd = np.broadcast_to(data.shape[0], (self.dim, )) xk = np.array([x for _ in range(self.size)]) xxk = np.array([xx for _ in range(self.size)]) ndk = np.array([nd for _ in range(self.size)]) return Stats([xk, ndk, ndk, xxk]) else: stats = list(map(self.statistics, data)) return reduce(add, stats)
def statistics(self, data): if isinstance(data, np.ndarray): idx = ~np.isnan(data).any(axis=1) data = data[idx] c0, c1 = 'nd->d', 'nd,nl->dl' x = np.einsum(c0, data, optimize=True) xxT = np.einsum(c1, data, data, optimize=True) n = data.shape[0] xk = np.array([x for _ in range(self.size)]) xxTk = np.array([xxT for _ in range(self.size)]) nk = np.array([n for _ in range(self.size)]) return Stats([xk, nk, xxTk, nk]) else: stats = list(map(self.statistics, data)) return reduce(add, stats)
def weighted_statistics(self, x, y, weights): if isinstance(x, np.ndarray) and isinstance(y, np.ndarray): idx = np.logical_and(~np.isnan(x).any(axis=1), ~np.isnan(y).any(axis=1)) x, y, weights = x[idx], y[idx], weights[idx] if self.affine: x = np.hstack((x, np.ones((x.shape[0], 1)))) contract = 'nd,nk,nl->kdl' yxTk = np.einsum(contract, y, weights, x, optimize=True) xxTk = np.einsum(contract, x, weights, x, optimize=True) yyTk = np.einsum(contract, y, weights, y, optimize=True) nk = np.sum(weights, axis=0) return Stats([yxTk, xxTk, yyTk, nk]) else: stats = list(map(self.weighted_statistics, x, y, weights)) return reduce(add, stats)
def statistics(self, x, y): if isinstance(x, np.ndarray) and isinstance(y, np.ndarray): idx = np.logical_and(~np.isnan(x).any(axis=1), ~np.isnan(y).any(axis=1)) x, y = x[idx], y[idx] if self.affine: x = np.hstack((x, np.ones((x.shape[0], 1)))) xxT = np.einsum('nd,nl->dl', x, x, optimize=True) yxT = np.einsum('nd,nl->dl', y, x, optimize=True) yy = np.einsum('nd,nd->d', y, y, optimize=True) nd = np.broadcast_to(y.shape[0], (self.output_dim, )) xxTk = np.array([xxT for _ in range(self.size)]) yxTk = np.array([yxT for _ in range(self.size)]) yyk = np.array([yy for _ in range(self.size)]) ndk = np.array([nd for _ in range(self.size)]) return Stats([yxTk, xxTk, ndk, yyk]) else: stats = list(map(self.statistics, x, y)) return reduce(add, stats)
def estep(self, ems, act=None): if isinstance(ems, np.ndarray) \ and isinstance(act, np.ndarray): smooth_mean, smooth_covar, gain, log_lik =\ self.kalman_smoother(ems, act) nb_steps = ems.shape[0] # currently only for full covariances Ex = smooth_mean # E[x{n}] ExxpT = np.zeros_like(gain) # E[x_{n} x_{n-1}^T] for t in range(nb_steps - 1): ExxpT[t] = smooth_covar[t + 1] @ gain[t].T\ + np.outer(smooth_mean[t + 1], smooth_mean[t]) ExxT = np.zeros_like(smooth_covar) # E[x_{n} x_{n}^T] for t in range(nb_steps): ExxT[t] = smooth_covar[t] + np.outer(smooth_mean[t], smooth_mean[t]) # init_ltn_stats x, xxT = Ex[0], ExxT[0] init_ltn_stats = Stats([x, 1., xxT, 1.]) # ltn_stats xxT = np.zeros((nb_steps - 1, self.ltn_dim + 1, self.ltn_dim + 1)) for t in range(nb_steps - 1): xxT[t] = np.block([[ExxT[t], Ex[t][:, np.newaxis]], [Ex[t][np.newaxis, :], np.ones((1, ))]]) yxT = np.zeros((nb_steps - 1, self.ltn_dim, self.ltn_dim + 1)) for t in range(nb_steps - 1): yxT[t] = np.hstack((ExxpT[t], Ex[t + 1][:, np.newaxis])) yyT = ExxT[1:] ltn_stats = Stats([ np.sum(yxT, axis=0), np.sum(xxT, axis=0), np.sum(yyT, axis=0), yyT.shape[0] ]) # ems_stats xxT = np.zeros((nb_steps, self.ltn_dim + 1, self.ltn_dim + 1)) for t in range(nb_steps): xxT[t] = np.block([[ExxT[t], Ex[t][:, np.newaxis]], [Ex[t][np.newaxis, :], np.ones((1, ))]]) x = np.hstack((Ex, np.ones((Ex.shape[0], 1)))) yxT = np.einsum('nd,nl->ndl', ems, x) yyT = np.einsum('nd,nl->ndl', ems, ems) ems_stats = Stats([ np.sum(yxT, axis=0), np.sum(xxT, axis=0), np.sum(yyT, axis=0), yyT.shape[0] ]) return init_ltn_stats, ltn_stats, ems_stats, log_lik else: def inner(ems, act): return self.estep.__wrapped__(self, ems, act) result = map(inner, ems, act) init_ltn_stats, ltn_stats, ems_stats, log_lik = list( map(list, zip(*result))) stats = tuple([ reduce(add, init_ltn_stats), reduce(add, ltn_stats), reduce(add, ems_stats) ]) return stats, np.sum(np.hstack(log_lik))
def std_to_nat(params): alphas = params[0] - 1 betas = -params[1] return Stats([alphas, betas])
def std_to_nat(params): psi = - 0.5 * np.linalg.inv(params[0]) nu = 0.5 * (params[1] - psi.shape[0] - 1) return Stats([psi, nu])
def std_to_nat(params): a = params[1] * params[0] b = -0.5 * params[1] return Stats([a, b])