def _gresnet(mlp_type, mlp, params, inputs): ravel, unravel = _make_ravelers(inputs.shape) mlp_params, (W, b1, b2) = params if mlp_type == 'mean': mu_mlp, sigmasq_mlp = mlp(mlp_params, inputs) mu_res = unravel(np.dot(ravel(inputs), W) + b1) sigmasq_res = log1pexp(b2) return tuple_((mu_mlp + mu_res, sigmasq_mlp + sigmasq_res)) else: J_mlp, h_mlp = mlp(mlp_params, inputs) J_res = -1. / 2 * log1pexp(b2) h_res = unravel(np.dot(ravel(inputs), W) + b1) return tuple_((J_mlp + J_res, h_mlp + h_res))
def expectedstats_standard(nu, S, M, K, fudge=1e-8): m = M.shape[0] E_Sigmainv = nu * symmetrize(np.linalg.inv(S)) + fudge * np.eye(S.shape[0]) E_Sigmainv_A = nu * np.linalg.solve(S, M) E_AT_Sigmainv_A = m*K + nu*symmetrize(np.dot(M.T, np.linalg.solve(S, M))) \ + fudge*np.eye(K.shape[0]) E_logdetSigmainv = digamma((nu-np.arange(m))/2.).sum() \ + m*np.log(2) - np.linalg.slogdet(S)[1] assert is_posdef(E_Sigmainv) assert is_posdef(E_AT_Sigmainv_A) return tuple_((-1. / 2 * E_AT_Sigmainv_A, E_Sigmainv_A.T, -1. / 2 * E_Sigmainv, 1. / 2 * E_logdetSigmainv))
def natural_lds_inference_general_autograd(natparam, node_params, num_samples=None): init_params, pair_params = natparam def lds_log_normalizer(all_natparams): init_params, pair_params, node_params = all_natparams forward_messages, lognorm = natural_filter_forward_general( init_params, pair_params, node_params) return lognorm, (lognorm, forward_messages) all_natparams = tuple_(init_params, pair_params, node_params) expected_stats, ( lognorm, forward_messages) = agrad(lds_log_normalizer)(all_natparams) samples = natural_sample_backward_general(forward_messages, pair_params, num_samples) return samples, expected_stats, lognorm
def get_hmm_vlb(lds_global_natparam, hmm_local_natparam, lds_expected_stats): init_params, pair_params, _ = hmm_local_natparam node_params = get_arhmm_local_nodeparams(lds_global_natparam, lds_expected_stats) local_natparam = tuple_(init_params, pair_params, node_params) return hmm_logZ(local_natparam)
def bind(result, step): next_smooth, stats = result J, h, (mu, ExxT, ExxnT) = step(next_smooth) return tuple_(J, h, mu), [(mu, ExxT, ExxnT)] + stats
def unit(filtered_message): J, h = filtered_message mu, Sigma = natural_to_mean(filtered_message) ExxT = Sigma + np.outer(mu, mu) return tuple_(J, h, mu), [(mu, ExxT, 0.)]
def gaussian_info(inputs): J_input, h = np.split(inputs, 2, axis=-1) J = -1. / 2 * log1pexp(J_input) return tuple_((J, h))
def gaussian_mean(inputs, sigmoid_mean=False): mu_input, sigmasq_input = np.split(inputs, 2, axis=-1) mu = sigmoid(mu_input) if sigmoid_mean else mu_input sigmasq = log1pexp(sigmasq_input) return tuple_((mu, sigmasq))