Beispiel #1
0
 def sample(self):
     if self.transform:
         sample = np.log(
             stats.invgamma(a=self._alpha, scale=self._beta).rvs(1))
     else:
         sample = stats.invgamma(a=self._alpha, scale=self._beta).rvs(1)
     return sample
Beispiel #2
0
def invGamma(lower, upper, x0=[1, 5], showit=False):
    """
    Arguments
    ---------
    lower, upper : float
        The upper and lower limits between which we want 98% of the probability
    x0 : list, length 2
        Initial guesses for the parameters of the inverse gamma (a and scale)
    showit : bool
        Make a plot
    """
    limits = [lower, upper]
    result = minimize(f,
                      x0=x0,
                      args=limits,
                      method='L-BFGS-B',
                      bounds=[(0, None), (0, None)],
                      tol=1e-10)
    a, b = result.x
    if showit:
        import matplotlib.pyplot as plt
        fig, ax = plt.subplots(1, 1, constrained_layout=True)
        d = invgamma(a=a, scale=b)
        x = np.linspace(0.2 * limits[0], 2 * limits[1], 1000)
        ax.plot(x, d.pdf(x))
        ax.vlines(limits, 0, d.pdf(x).max())
        plt.show()
    return invgamma(a=a, scale=b)
def define_model(data):
    # Builds model object
    n = len(data)
    z = data.get('z')
    variable_names = ['surfaces', 'T', 'p_type', 'sigma_g', 'sigma_h']
    known_params = {
        'sigma_z_g': sigma_z_g,
        'sigma_z_h': sigma_z_h,
        'mu_h': mu_h,
        'phi': phi
    }
    hyper_params = {
        'alpha_type': array((1., 1., 1.)),
        'prior_mu_g': -25. + zeros(n),
        'prior_cov_g': 100. * eye(n),
        'prior_mu_h': 30. + zeros(n),
        'prior_cov_h': 100. * eye(n),
        'a_g': 11,
        'b_g': .1,
        'a_h': 11,
        'b_h': 40
    }
    initials = {
        'surfaces': [-25, 30] * ones((n, 2)),
        'sigma_g': .1,
        'sigma_h': 1,
        'T': array([(0 if abs(z[i] + 25) > 1 else 1) for i in xrange(n)])
    }
    #initials = {'sigma_g': sigma_g,
    #            'sigma_h': sigma_h,
    #            'T': T[:n],
    #            'g': g[:n],
    #            'h': h[:n]}
    priors = {
        'p_type': dirichlet(hyper_params['alpha_type']),
        'sigma_g': stats.invgamma(hyper_params['a_g'],
                                  scale=hyper_params['b_g']),
        'sigma_h': stats.invgamma(hyper_params['a_h'],
                                  scale=hyper_params['b_h']),
        'T': iid_dist(categorical(hyper_params['alpha_type']), n)
    }
    FCP_samplers = {
        'p_type': p_type_step(),
        'surfaces': surfaces_step(),
        'sigma_g': sigma_ground_step(),
        'sigma_h': sigma_height_step(),
        'T': type_step()
    }

    model = Model()
    model.set_variable_names(variable_names)
    model.set_known_params(known_params)
    model.set_hyper_params(hyper_params)
    model.set_priors(priors)
    model.set_initials(initials)
    model.set_FCP_samplers(FCP_samplers)
    model.set_data(data)

    return model
def define_model(params_module, data):
    # Builds model object
    # Everything the gibbs sampler needs to know about.

    # Parameters and initialization values
    n = len(list(set(data.shot_id)))
    N = len(data)
    known_params = params_module.get_known_params(data)
    initials = params_module.get_initials(data)
    hyper_params = params_module.get_hyper_params(data)
    m_cover = params_module.m_cover
    m_type = params_module.m_type


    # Variables to be sampled (in this order)
    variable_names = ['h', 'g', 'T', 'C', 'noise_proportion', 'transition_var_g', 'transition_var_h']

    priors = {'g': MVNormal(hyper_params['g']['mu'], hyper_params['g']['cov']),
              'h': MVNormal(hyper_params['h']['mu'], hyper_params['h']['cov']),
              'C': IID(Categorical(hyper_params['C']['p']), n),
              'T': IID(Categorical(hyper_params['T']['p']), N),
              'noise_proportion': beta(*hyper_params['noise_proportion']['alpha']),
              'transition_var_g': stats.invgamma(hyper_params['transition_var_g']['a'], scale=hyper_params['transition_var_g']['b']),
              'transition_var_h': stats.invgamma(hyper_params['transition_var_h']['a'], scale=hyper_params['transition_var_h']['b'])}
    FCP_samplers = {'g': ground_elev_step(),
                    'h': canopy_height_step(),
                    'C': cover_step(),
                    'T': type_step(),
                    'noise_proportion': noise_proportion_step(),
                    'transition_var_g': transition_var_g_step(),
                    'transition_var_h': transition_var_h_step()}
    sample_handlers = {'g': [indep_meanvar_handler()],
                       'h': [indep_meanvar_handler()],
                       'T': [discrete_handler(support=range(m_type), length=N)],
                       'C': [discrete_handler(support=range(m_cover), length=n)],
                       'noise_proportion': [raw_sample_handler()],
                       'transition_var_g': [raw_sample_handler()],
                       'transition_var_h': [raw_sample_handler()]}
    diagnostic_variable = 'noise_proportion'

    model = Model()
    model.set_variable_names(variable_names)
    model.set_known_params(known_params)
    model.set_hyper_params(hyper_params)
    model.set_priors(priors)
    model.set_initials(initials)
    model.set_FCP_samplers(FCP_samplers)
    model.set_sample_handlers(sample_handlers)
    model.set_diagnostic_variable(diagnostic_variable)
    model.set_data(data)

    return model
Beispiel #5
0
    def __update_theta_1d(self, state_assignments):

        mu0, nu, alpha, beta = self.priors

        Y, L, theta = self.Y, self.L, self.theta
        z = state_assignments['z']
        # z = mode_convolution(z, window=3)

        # need to update the parameters for each model
        for k in range(self.L):

            indexes = np.where(z == k)[0]
            ykk = Y[indexes]

            nk = len(ykk)

            # if ((nk == 0) and (len(self.queue) > 0)):
            #     ykk = np.array([self.queue.pop()])
            #     nk = len(ykk)
            #     y_bar = ykk[0]
            #     samp_var = 2

            if nk > 0:

                y_bar = np.mean(ykk)
                samp_var = np.var(ykk)

                # posterior sigma values
                alpha_post = alpha + nk / 2
                beta_post = beta + nk * samp_var / 2 + (nk * nu) / (
                    nu + nk) * np.square(y_bar - mu0) / 2

                # sample sigma
                sig = stats.invgamma(a=alpha_post, scale=beta_post).rvs()
                T = 1 / sig

                mu_post = (nu * mu0 + nk * y_bar) / (nu + nk)
                nu_post = nu + nk
                mu_samp = np.random.normal(mu_post, np.sqrt(sig / nu_post))

            else:
                # if we don't have any data then we set the posterior to the value of the prior
                sig = stats.invgamma(a=alpha, scale=beta).rvs()
                T = 1 / sig
                mu_samp = np.random.normal(mu0, np.sqrt(sig / nu))

            theta[k]['Cov'] = np.array([[sig]])
            theta[k]['A'] = np.array([mu_samp])

        return theta
def define_model(data):
    # Builds model object
    m = 3
    n_points = len(data)
    n_shots = len(set(data['shot_id']))
    variable_names = ['g', 'h', 'T', 'p_type', 'sigma_g', 'sigma_h']
    known_params = {'sigma_z_g': sigma_z_g,
                    'sigma_z_h': sigma_z_h,
                    'mu_h': mu_h,
                    'phi': phi}
    hyper_params = {'alpha_type': array((0, 1., 1.)),
                    'prior_mu_g': -25.+zeros(n_shots),
                    'prior_cov_g': 100.*eye(n_shots),
                    'prior_mu_h': 30.+zeros(n_shots),
                    'prior_cov_h': 100.*eye(n_shots),
                    'a_g': 6,
                    'b_g': 1,
                    'a_h': 6,
                    'b_h': 1}
    initials = {}
    #initials = {'sigma_g': sigma_g,
    #            'sigma_h': sigma_h,
    #            'T': T[:n_shots],
    #            'g': g[:n_shots],
    #            'h': h[:n_shots]}
    priors = {'p_type': dirichlet(hyper_params['alpha_type']),
              'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']),
              'sigma_h': stats.invgamma(hyper_params['a_h'], scale=hyper_params['b_h']),
              'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g']),
              'h': mvnorm(hyper_params['prior_mu_h'], hyper_params['prior_cov_h']),
              'T': iid_dist(categorical(hyper_params['alpha_type']/sum(hyper_params['alpha_type'])), n_points)}
    FCP_samplers = {'p_type': p_type_step(),
                    'g': ground_height_step(),
                    'h': canopy_height_step(),
                    'sigma_g': sigma_ground_step(),
                    'sigma_h': sigma_height_step(),
                    'T': type_step()}

    model = Model()
    model.set_variable_names(variable_names)
    model.set_known_params(known_params)
    model.set_hyper_params(hyper_params)
    model.set_priors(priors)
    model.set_initials(initials)
    model.set_FCP_samplers(FCP_samplers)
    model.set_data(data)

    return model
Beispiel #7
0
    def test_1D_is_invgamma(self):
        # The 1-dimensional inverse Wishart with an identity scale matrix is
        # just an inverse gamma distribution.
        # Test variance, mean, pdf
        # Kolgomorov-Smirnov test for rvs
        np.random.seed(482974)

        sn = 500
        dim = 1
        scale = np.eye(dim)

        df_range = np.arange(5, 20, 2, dtype=float)
        X = np.linspace(0.1, 10, num=10)
        for df in df_range:
            iw = invwishart(df, scale)
            ig = invgamma(df / 2, scale=1. / 2)

            # Statistics
            assert_allclose(iw.var(), ig.var())
            assert_allclose(iw.mean(), ig.mean())

            # PDF
            assert_allclose(iw.pdf(X), ig.pdf(X))

            # rvs
            rvs = iw.rvs(size=sn)
            args = (df / 2, 0, 1. / 2)
            alpha = 0.01
            check_distribution_rvs('invgamma', args, alpha, rvs)
Beispiel #8
0
    def __init__(self, alpha, beta):
        self.alpha = alpha
        self.beta = beta

        # set dist before calling super's __init__
        self.dist = st.invgamma(alpha, scale=beta)
        super(InverseGamma, self).__init__()
Beispiel #9
0
def minimal_priors():
    return [
        lambda x: halfnorm(scale=1.).logpdf(np.sqrt(np.exp(x))) + x / 2.0 - np.
        log(2.0), lambda x: invgamma(a=5.0, scale=1.).logpdf(np.exp(x)) + x,
        lambda x: halfnorm(scale=1.).logpdf(np.sqrt(np.exp(x))
                                            ) + x / 2.0 - np.log(2.0)
    ]
Beispiel #10
0
def fit_invgamma_dist(data, plot=False, x_range=None, num=100,label=""):
    """
    Fits data to inverse gamma distribution. If plot is True it will return a plot. Otherwise it will return
    a scipy function.
    :param data: numpy array
    :param plot: Bool
    :param xrange: If none it will automatically find range. otherwise, you can set it. must be tuple: (1,2)
    :param num: the number of points to plot i.e. num from numpy.linspace
    :return:
    """
    ig_dist = sps.invgamma.fit(data, floc=0)
    ig_dist = sps.invgamma(*ig_dist)

    if plot is False:
        return ig_dist

    if x_range is None:
        x_min = data.min()
        x_max = data.max()

    else:
        x_min = x_range[0]
        x_max = x_range[1]

        xs = np.linspace(x_min, x_max, num=num)
        plt.plot(xs, ig_dist.pdf(xs),label=label)
Beispiel #11
0
def fix_alpha(alpha, Sigma, Sigma_star):
    p = Sigma.shape[0]
    Sigma_12 = fractional_matrix_power(Sigma, 0.5)

    matrix = Sigma_12.T @ np.linalg.inv(Sigma_star) @ Sigma_12

    lambdas = np.real(np.linalg.eigvals(matrix))
    factorials = [1, 1, 2, 8]
    k = np.asarray([factorials[r] * np.sum(lambdas**r) for r in [1,1,2,3]])

    t1 = 4*k[1]*k[2]**2 + k[3]*(k[2]-k[1]**2)
    t2 = k[3]*k[1] - 2*k[2]**2
    chi_quantile = sps.chi2(p).ppf(1-alpha)
    if t1 < 10**(-5):
        a_new = 2 + (k[1]**2)/(k[2]**2)
        b_new = (k[1]**3)/k[2] + k[1]
        s1 = 2*k[1]*(k[3]*k[1] + k[2]*k[1]**2 - k[2]**2)
        s2 = 3*t2 + 2*k[2]*(k[2] + k[1]**2)
        alpha_star = 1 - sps.invgamma(a_new, scale = b_new).cdf(chi_quantile)
    elif t2 < 10**(-5):
        a_new = (k[1]**2)/k[2]
        b_new = k[2]/k[1]
        alpha_star = 1 - sps.gamma(a_new, scale = b_new).cdf(chi_quantile)
    else:
        a1 = 2*k[1]*(k[3]*k[1] + k[2]*k[1]**2 - k[2]**2)/t1
        a2 = 3 + 2*k[2]*(k[2] + k[1]**2)/t2
        alpha_star = 1 - sps.f(2*a1, 2*a2).cdf(a2*t2*chi_quantile/(a1*t1))
        
    return alpha_star
def define_model(data):
    # Builds model object
    n = len(data)
    variable_names = ['g', 'sigma_g']
    known_params = {'sigma_z_g': sigma_z_g,
                    'T': ones(n)}
    hyper_params = {'prior_mu_g': 0+zeros(n),
                    'prior_cov_g': 100*eye(n),
                    'a_g': 0.,
                    'b_g': 0.}
    priors = {'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']),
              'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g'])}
    initials = {'g': g[:n],
                'sigma_g': sigma_g}
    FCP_samplers = {'g': ground_height_step(),
                    'sigma_g': sigma_ground_step()}

    model = Model()
    model.set_variable_names(variable_names)
    model.set_known_params(known_params)
    model.set_hyper_params(hyper_params)
    model.set_priors(priors)
    model.set_initials(initials)
    model.set_FCP_samplers(FCP_samplers)
    model.set_data(data)

    return model
Beispiel #13
0
def _recursive_priors(kernel, prior_list):
    if hasattr(kernel, "kernel"):  # Unary operations
        _recursive_priors(kernel.kernel, prior_list)
    elif hasattr(kernel, "k1"):  # Binary operations
        _recursive_priors(kernel.k1, prior_list)
        _recursive_priors(kernel.k2, prior_list)
    elif hasattr(kernel, "kernels"):  # CompoundKernel
        for k in kernel.kernels:
            _recursive_priors(k, prior_list)
    else:
        name = type(kernel).__name__
        if name in ["ConstantKernel", "WhiteKernel"]:
            # We use a half-normal prior distribution on the signal variance and
            # noise. The input x is sampled in log-space, which is why the
            # change of variables is necessary.
            # This prior assumes that the function values are standardized.
            # Note, that we do not know the structure of the kernel, which is
            # why this is just only a best guess.
            prior_list.append(
                lambda x: halfnorm(scale=2.0).logpdf(np.sqrt(np.exp(x))) + x /
                2.0 - np.log(2.0), )
        elif name in ["Matern", "RBF"]:
            # Here we apply an inverse gamma distribution to any lengthscale
            # parameter we find. We assume the input variables are normalized
            # to lie in [0, 1]. The specific values for a and scale were
            # obtained by fitting the 1% and 99% quantile to 0.15 and 0.8.
            prior_list.append(
                lambda x: invgamma(a=8.286, scale=2.4605).logpdf(np.exp(x)) +
                x, )
        else:
            raise NotImplementedError(
                f"Unable to guess priors for this kernel: {kernel}.")
Beispiel #14
0
    def test_1D_is_invgamma(self):
        # The 1-dimensional inverse Wishart with an identity scale matrix is
        # just an inverse gamma distribution.
        # Test variance, mean, pdf
        # Kolgomorov-Smirnov test for rvs
        np.random.seed(482974)

        sn = 500
        dim = 1
        scale = np.eye(dim)

        df_range = np.arange(5, 20, 2, dtype=float)
        X = np.linspace(0.1,10,num=10)
        for df in df_range:
            iw = invwishart(df, scale)
            ig = invgamma(df/2, scale=1./2)

            # Statistics
            assert_allclose(iw.var(), ig.var())
            assert_allclose(iw.mean(), ig.mean())

            # PDF
            assert_allclose(iw.pdf(X), ig.pdf(X))

            # rvs
            rvs = iw.rvs(size=sn)
            args = (df/2, 0, 1./2)
            alpha = 0.01
            check_distribution_rvs('invgamma', args, alpha, rvs)
def define_model(data):
    # Builds model object
    n = len(data)
    variable_names = ['g', 'sigma_g', 'p_type', 'T']
    known_params = {'sigma_z_g': sigma_z_g}
    hyper_params = {'prior_mu_g': 0*ones(n),
                    'prior_cov_g': 100*eye(n),
                    'alpha_type': (1., 1.),
                    'a_g': 3.,
                    'b_g': 1.}
    priors = {'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']),
              'p_type': dirichlet(hyper_params['alpha_type']),
              'T': iid_dist(categorical((1., 1.)), n),
              'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g'])}
    #initials = {'g': g[:n],
    #            'sigma_g': sigma_g}
    FCP_samplers = {'g': ground_height_step(),
                    'p_type': p_type_step(),
                    'T': type_step(),
                    'sigma_g': sigma_ground_step()}

    model = Model()
    model.set_variable_names(variable_names)
    model.set_known_params(known_params)
    model.set_hyper_params(hyper_params)
    model.set_priors(priors)
    #model.set_initials(initials)
    model.set_FCP_samplers(FCP_samplers)
    model.set_data(data)

    return model
def define_model(data):
    # Builds model object
    n = len(data)
    variable_names = ['g', 'sigma_g']
    known_params = {'sigma_z_g': sigma_z_g, 'T': ones(n)}
    hyper_params = {
        'prior_mu_g': 0 + zeros(n),
        'prior_cov_g': 100 * eye(n),
        'a_g': 0.,
        'b_g': 0.
    }
    priors = {
        'sigma_g': stats.invgamma(hyper_params['a_g'],
                                  scale=hyper_params['b_g']),
        'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g'])
    }
    initials = {'g': g[:n], 'sigma_g': sigma_g}
    FCP_samplers = {'g': ground_height_step(), 'sigma_g': sigma_ground_step()}

    model = Model()
    model.set_variable_names(variable_names)
    model.set_known_params(known_params)
    model.set_hyper_params(hyper_params)
    model.set_priors(priors)
    model.set_initials(initials)
    model.set_FCP_samplers(FCP_samplers)
    model.set_data(data)

    return model
Beispiel #17
0
    def init(self):
        self.sigma2 = np.apply_along_axis(
            lambda ab: invgamma(ab[0], scale=1 / ab[1]).rvs(P), 0,
            [[a0] + ak, [b0] + bk]).squeeze()  # P * (K+1)

        self.beta = []
        self.Gamma_0 = []
        self.nu = []
        self.mu_0 = []
        for k in range(2):
            sigma2_k = self.sigma2[:, k + 1]  # P

            self.beta.append(
                np.apply_along_axis(lambda sigma: norm(b0k[k], sigma).rvs(R),
                                    0, [h * sigma2_k]))
            Gamma_0k = invwishart(dk[k], Q).rvs(1)  # P * P
            self.Gamma_0.append(Gamma_0k)

            m_0k = np.ones(P) * self.m_0k[k]
            nu_k = multivariate_normal(m_0k,
                                       h1 * Gamma_0k).rvs(1).squeeze()  # P
            self.nu.append(nu_k)
            self.mu_0.append(multivariate_normal(nu_k,
                                                 h1 * Gamma_0k).rvs(1))  # P

        self.beta = np.array(self.beta)  # K * R * P
        self.Gamma_0 = np.array(self.Gamma_0)  # K * P * P
        self.nu = np.array(self.nu)  # K * P
        self.mu_0 = np.array(self.mu_0)  # K * P
        self.det_Q = np.linalg.det(Q)
        self.b_0_p = []
        for j in range(P):
            self.b_0_p.append(b0 + sum(X[:, j]**2))
        self.b_0_p = np.array(self.b_0_p)
Beispiel #18
0
def update_theta(Y, fwd_vals, params, priors, **kwargs):

    mu0, sig0, nu, Delta = priors

    # how many time to iterate these samples?
    num_iter = 1
    L, theta = params['L'], params['theta']
    z = fwd_vals['z']

    Yk = [Y[np.where(z == j)[0]] for j in range(L)]
    # print(z)
    # system.exit(0)

    for i in range(num_iter):
        for k in range(0, L):

            ykk = Yk[k]
            sig2 = theta[k][1]**2

            # update mu
            sig0_inv = 1 / sig0
            SigHat = (sig0_inv + len(ykk) / (sig2))**-1
            muHat = SigHat * (mu0 * sig0_inv + np.sum(ykk) / sig2)
            theta[k][0] = np.random.normal(loc=muHat, scale=np.sqrt(SigHat))

            # update sigma
            nu_k = nu + len(ykk) / 2
            nukDeltak = Delta + np.sum(np.square(ykk - theta[k][0])) / 2
            theta[k][1] = np.sqrt(
                stats.invgamma(a=nu_k, scale=nukDeltak).rvs())

    return theta
def define_model(data):
    # Builds model object
    n = len(data)
    z = data.get('z')
    variable_names = ['surfaces', 'T', 'p_type', 'sigma_g', 'sigma_h']
    known_params = {'sigma_z_g': sigma_z_g,
                    'sigma_z_h': sigma_z_h,
                    'mu_h': mu_h,
                    'phi': phi}
    hyper_params = {'alpha_type': array((1., 1., 1.)),
                    'prior_mu_g': -25.+zeros(n),
                    'prior_cov_g': 100.*eye(n),
                    'prior_mu_h': 30.+zeros(n),
                    'prior_cov_h': 100.*eye(n),
                    'a_g': 11,
                    'b_g': .1,
                    'a_h': 11,
                    'b_h': 40}
    initials = {'surfaces': [-25, 30]*ones((n,2)),
                'sigma_g': .1,
                'sigma_h': 1,
                'T': array([(0 if abs(z[i]+25)>1 else 1) for i in xrange(n)])}
    #initials = {'sigma_g': sigma_g,
    #            'sigma_h': sigma_h,
    #            'T': T[:n],
    #            'g': g[:n],
    #            'h': h[:n]}
    priors = {'p_type': dirichlet(hyper_params['alpha_type']),
              'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']),
              'sigma_h': stats.invgamma(hyper_params['a_h'], scale=hyper_params['b_h']),
              'T': iid_dist(categorical(hyper_params['alpha_type']), n)}
    FCP_samplers = {'p_type': p_type_step(),
                    'surfaces': surfaces_step(),
                    'sigma_g': sigma_ground_step(),
                    'sigma_h': sigma_height_step(),
                    'T': type_step()}

    model = Model()
    model.set_variable_names(variable_names)
    model.set_known_params(known_params)
    model.set_hyper_params(hyper_params)
    model.set_priors(priors)
    model.set_initials(initials)
    model.set_FCP_samplers(FCP_samplers)
    model.set_data(data)

    return model
    def generate_outcome_with_site(self):
        self._rnd = check_random_state(self.random_state)
        var_noise = 1.0 - self.var_x - self.var_z
        assert var_noise > 0.0

        n_samples, n_features = self.data.shape

        # causal effect

        dem_data = get_volume_causes(self.known_causes)

        rv_x = stats.norm(loc=0.0, scale=0.5)
        coef_x = rv_x.rvs(size=n_features, random_state=self._rnd)
        coef_x = self._make_sparse(coef_x)

        causal_data = fit_regress_out(self.data, dem_data)

        mu_x = np.dot(causal_data.values, coef_x)
        contrib_x = np.sqrt(self.var_x) / np.std(mu_x, ddof=1)

        # confounding
        site_id = self.get_site_assignments(causal_data)

        # per group intercept and error variance
        intercepts = np.arange(1, self.num_sites + 1)
        err_var = stats.invgamma(a=3, loc=1).rvs(size=self.num_sites, random_state=self._rnd)
        LOG.info("Per-cluster intercepts: %s", intercepts)
        LOG.info("Per-cluster error variance: %s", err_var)

        mu_z_hidden = intercepts[site_id]
        contrib_z = np.sqrt(self.var_z * 0.9)  / np.std(mu_z_hidden, ddof=1)

        rv_age = stats.norm(loc=0.0, scale=0.2)
        coef_age = rv_age.rvs(random_state=self._rnd)
        mu_age = dem_data.loc[:, "AGE"].values * coef_age
        contrib_age = np.sqrt(self.var_z * 0.1) / np.std(mu_age, ddof=1)

        noise = stats.norm.rvs(loc=np.zeros(n_samples), scale=err_var[site_id], random_state=self._rnd)
        contrib_noise = np.sqrt(var_noise) / np.std(noise, ddof=1)

        mu = np.stack([mu_x, mu_z_hidden, mu_age, noise], axis=1)
        contrib = np.array([contrib_x, contrib_z, contrib_age, contrib_noise])

        # linear predictor
        eta = np.dot(mu, contrib)
        # center around 0
        eta -= np.mean(eta)

        intercept = stats.logistic.ppf(self.prob_event)
        eta += intercept

        true_coef = pd.Series(coef_x, index=self.data.columns)
        true_coef.loc["Intercept"] = intercept

        outcome = self.logistic(eta)

        conf_hidden = pd.Series(mu_z_hidden, index=self.data.index, name="unobserved_confounder")
        confounders = pd.concat((conf_hidden, dem_data.loc[:, "AGE"]), axis=1)
        return outcome, true_coef, confounders
Beispiel #21
0
def params(D):
    A = Params()
    A.prior = Params()
    B = Params()
    B.prior = Params()
    S = Params()
    S.prior = Params()
    T = Params()
    T.prior = Params()

    (A.prior.m, A.prior.var) = (0.0, 10.0)
    (B.prior.m, B.prior.var) = (0.0, 10.0)
    (S.prior.p1, S.prior.p2) = (3.0, 1.0)
    (T.prior.p1, T.prior.p2) = (3.0, 1.0)

    A.prior.rv = norm(loc=A.prior.m, scale=np.sqrt(A.prior.var))
    B.prior.rv = norm(loc=B.prior.m, scale=np.sqrt(A.prior.var))
    S.prior.rv = invgamma(S.prior.p1/2, loc=0, scale=S.prior.p1*S.prior.p2/2)
    T.prior.rv = invgamma(T.prior.p1/2, loc=0, scale=T.prior.p1*T.prior.p2/2)

    ### Full conditionals

    A.cond = Params()
    B.cond = Params()
    S.cond = Params()
    T.cond = Params()

    # AR-1 without noise; regress X[1:] on X[:-1]
    A.cond.var = lambda (a, b, s, t, X, Y): 1/(1/A.prior.var + D.n/S.prior.p2)
    A.cond.m = lambda (a, b, s, t, X, Y): A.cond.var((a,b,s,t,X,Y))*(sum(X[1:]-b*X[:-1])/S.prior.p2 + A.prior.m/A.prior.var)
    B.cond.var = lambda (a, b, s, t, X, Y): 1/(1/B.prior.var + sum(X**2)/S.prior.p2)
    B.cond.m = lambda (a, b, s, t, X, Y): B.cond.var((a,b,s,t,X,Y))*(sum((X[1:]-a)*X[:-1])/S.prior.p2 + B.prior.m/B.prior.var)
    S.cond.a = lambda (a, b, s, t, X, Y): S.prior.p1 + D.n
    S.cond.b = lambda (a, b, s, t, X, Y): S.prior.p1*S.prior.p2 + sum((X[1:]-a-b*X[:-1])**2)

    # Regression of Y on X
    T.cond.a = lambda (a, b, s, t, X, Y): T.prior.p1 + D.n
    T.cond.b = lambda (a, b, s, t, X, Y): T.prior.p1*T.prior.p2 + sum((Y-X)**2)

    # conditional draws
    A.cond.rv = lambda theta: norm(loc=A.cond.m(theta), scale=np.sqrt(A.cond.var(theta)))
    B.cond.rv = lambda theta: norm(loc=B.cond.m(theta), scale=np.sqrt(B.cond.var(theta)))
    S.cond.rv = lambda theta: invgamma(S.cond.a(theta)/2, loc=0, scale=S.cond.b(theta)/2)
    T.cond.rv = lambda theta: invgamma(T.cond.a(theta)/2, loc=0, scale=T.cond.b(theta)/2)

    return ParamsHolder(A, B, S, T)
    def sample(self, model, evidence):
        prior_mu_g, a_g, b_g = [model.hyper_params[var] for var in ['prior_mu_g', 'a_g', 'b_g']]
        g = evidence['g']
        n = len(g)

        g_var_posterior = stats.invgamma(a_g + (n-1)/2., scale=b_g + sum((g[1:] - g[:-1])**2)/2.)
        g_var = g_var_posterior.rvs()
        return sqrt(g_var)
Beispiel #23
0
def make_widths():
    np.random.seed(1)

    a = 10
    b = 4000
    precision_dist = stats.invgamma(a, scale=b)

    return precision_dist.rvs(n)**-0.5
    def sample(self, model, evidence):
        prior_mu_h, a_h, b_h = [model.hyper_params[var] for var in ['prior_mu_h', 'a_h', 'b_h']]
        h = evidence['surfaces'][:,1]
        n = len(h)

        h_var_posterior = stats.invgamma(a_h + (n-1)/2., scale=b_h + sum((h[1:] - h[:-1])**2)/2.)
        h_var = h_var_posterior.rvs()
        return min(sqrt(h_var), 3)
Beispiel #25
0
def getline(stops):
    fit_alpha, fit_loc, fit_scale = stats.gamma.fit(stops)
    sort_stops = sorted(stops)
    length = len(sort_stops)
    y = np.empty(length)
    for i in range(length):
        number = (i - 0.5) / length
        new = stats.invgamma(fit_alpha, fit_loc, fit_scale)
        print(sort_stops[i], new.pdf(number))
Beispiel #26
0
def eval_logjoint(y: np.ndarray, x: np.ndarray, bet: np.ndarray,
                  sig: np.ndarray, lam: float, v: np.ndarray,
                  s: np.ndarray) -> float:

    m = np.zeros((y.shape[0], x.shape[0]))
    l = lam / np.var(x, 1)

    return np.sum(lm.eval_loglik(y, x, bet, sig)) \
           + np.sum(lm.eval_norm(bet, m, sig / l)) \
           + np.sum(invgamma(a=v / 2, scale=s / 2).logpdf(sig))
Beispiel #27
0
def sample_sigma2(state, VS=True):
    b = np.zeros(state['num_clusters_'])
    a = np.array(
        state['suffstats'].values()) / 2.0 + state['hyperparameters_']['a0k']
    for cluster_id in state['cluster_ids_']:
        if (cluster_id == 0) and VS is True:
            continue
        b[cluster_id] = np.sum(state['beta'][np.where(state['assignment'] == cluster_id)]**2) / 2.0 + \
        state['hyperparameters_']['b0k']

    if VS is True:
        out = dict(
            zip(range(1, state['num_clusters_']),
                stats.invgamma(a=a[1:], scale=b[1:]).rvs()))
        out[0] = 0
    else:
        out = dict(
            zip(range(0, state['num_clusters_']),
                stats.invgamma(a=a, scale=b).rvs()))
    return out
    def sample(self, model, evidence):
        prior_mu_g, a_g, b_g = [
            model.hyper_params[var] for var in ['prior_mu_g', 'a_g', 'b_g']
        ]
        g = evidence['g']
        n = len(g)

        g_var_posterior = stats.invgamma(a_g + (n - 1) / 2.,
                                         scale=b_g + sum(
                                             (g[1:] - g[:-1])**2) / 2.)
        g_var = g_var_posterior.rvs()
        return sqrt(g_var)
    def sample(self, model, evidence):
        prior_mu_h, a_h, b_h = [
            model.hyper_params[var] for var in ['prior_mu_h', 'a_h', 'b_h']
        ]
        h = evidence['surfaces'][:, 1]
        n = len(h)

        h_var_posterior = stats.invgamma(a_h + (n - 1) / 2.,
                                         scale=b_h + sum(
                                             (h[1:] - h[:-1])**2) / 2.)
        h_var = h_var_posterior.rvs()
        return min(sqrt(h_var), 3)
def hs_step(
    lambda2: np.ndarray,
    tau2: np.ndarray,
    vi: np.ndarray,
    xi: np.ndarray,
    X: np.ndarray,
    y: np.ndarray,
):
    _, M = X.shape

    D_diag = tau2 * lambda2
    beta = large_p_mvnormal_sampler(D_diag, X, y)
    beta2 = beta**2

    lambda2 = invgamma(a=1, scale=1 / vi + beta2 / (2 * tau2)).rvs()
    tau2 = invgamma(a=(M + 1) / 2,
                    scale=1 / xi + (beta2 / lambda2).sum() / 2).rvs()
    vi = invgamma(a=1, scale=1 + 1 / lambda2).rvs()
    xi = invgamma(a=1, scale=1 + 1 / tau2).rvs()

    return beta, lambda2, tau2, vi, xi
    def sim_dataset(self, G0, lambdas):
        """
        calculate the target Y based on the simulated dataset
        input:
        G0: level 0 data
        lambdas: unknown groups
        n_causes and n_units: int, dimensions of the dataset
        output:
        G: G0 in pandas format with colnames that indicate if its a cause or not
        tc: causal columns
        y01: binary target
        """
        np.random.seed(self.seed)

        tc_ = npr.normal(loc=0, scale=0.5 * 0.5, size=self.true_causes)
        tc = np.hstack((tc_, np.repeat(0.0, self.confounders)))  # True causes
        tau = stats.invgamma(3, 1).rvs(3, random_state=99)
        sigma = np.zeros(self.n_units)
        sigma = [
            tau[0] if lambdas[j] == 0 else sigma[j] for j in range(len(sigma))
        ]
        sigma = [
            tau[1] if lambdas[j] == 1 else sigma[j] for j in range(len(sigma))
        ]
        sigma = [
            tau[2] if lambdas[j] == 2 else sigma[j] for j in range(len(sigma))
        ]
        y0 = np.array(tc).reshape(1, -1).dot(np.transpose(G0))
        l1 = lambdas.reshape(1, -1)
        y1 = (np.sqrt(np.var(y0)) / np.sqrt(0.4)) * (np.sqrt(0.4) /
                                                     np.sqrt(np.var(l1))) * l1
        e = npr.normal(0, sigma, self.n_units).reshape(1, -1)
        y2 = (np.sqrt(np.var(y0)) / np.sqrt(0.4)) * (np.sqrt(0.2) /
                                                     np.sqrt(np.var(e))) * e
        p = 1 / (1 + np.exp(y0 + y1 + y2))
        y01 = [npr.binomial(1, p[0][i], 1)[0] for i in range(len(p[0]))]
        y01 = np.asarray(y01)
        G, col = self.add_colnames(G0, tc)

        treatment = G.iloc[:, col].values.reshape(-1)
        G.drop(G.columns[col].values, axis=1, inplace=True)

        y = y0 + y1 + y2

        logger.debug('... Covariates: %i', G.shape[1] - len(col))
        logger.debug('... Target (y) : %f', np.sum(y01) / len(y01))
        logger.debug('... Sample Size: %i', G.shape[0])
        if len(col) == 1:
            T = G.iloc[:, col[0]].values
            logger.debug('... Proportion of T: %f', sum(T) / len(T))
        logger.debug('Dataset - GWAS Done!')
        return G, y, treatment, tc_
Beispiel #32
0
    def sample_fixed_effects(self, n_samples, summary_statistics):
        """samples from the posterior distribution of the fixed effects model

        parameters
        ----------
        n_samples: int
            number of samples to draw
        summary_statistics: (int, np.array, np.array)
            number of observations per group, group specific means, group specific variances

        returns
        -------
        np.array
            (n_samples, n_groups) mu_j/fixed effects
        np.array
            (n_samples, ) sigma_2/observation variances
        np.array
            (n_samples, ) mu
        np.array
            (n_samples, ) tau_2
        """
        n_observations, means, variances = summary_statistics
        n_groups = means.shape[0]

        # Sample from observation variance posterior
        a = n_observations * n_groups / 2.0
        b = n_observations * variances.sum() / 2.0
        sigma_2 = stats.invgamma(a=a, scale=b).rvs(n_samples)

        # Sample from the fixed effects
        fixed_effects = stats.norm().rvs(
            (n_samples, n_groups)) * (sigma_2[:, None] /
                                      n_observations)**0.5 + means[None, :]

        # sample the NIG prior
        tau_2 = stats.invgamma(a=self.a, scale=self.b).rvs(n_samples)
        mu = stats.norm().rvs(n_samples) * tau_2**0.5

        return fixed_effects, mu, sigma_2, tau_2
    def sample(self, model, evidence):
        g = evidence['g']

        prior_mu_g = model.hyper_params['g']['mu']
        a = model.hyper_params['transition_var_g']['a']
        b = model.hyper_params['transition_var_g']['b']
        max_var = model.hyper_params['transition_var_g']['max']

        n = len(g)

        g_var_posterior = stats.invgamma(a + (n-1)/2., scale=b + sum((g[1:] - g[:-1])**2)/2.)
        g_var = g_var_posterior.rvs()

        return min(g_var, max_var)
Beispiel #34
0
def plot_inv_gamma():
    print("mean", st.invgamma(2, scale=1e-9).mean())
    x = np.linspace(0.0, 1, 1000)
    fig, ax = plt.subplots()
    f = lambda alpha, beta: st.invgamma.pdf(x, alpha, scale=beta)
    plot_pdf = lambda alpha, beta: ax.plot(x,
                                           f(alpha, beta),
                                           label=r'$\alpha$={0}, $\beta$={1}'.
                                           format(alpha, beta))
    plot_pdf(2, 0.1)
    # plot_pdf(1., 1e-2)
    # plot_pdf(1.1, 1e-2)
    plt.legend(loc='upper right', frameon=False)
    ax.set(xlim=[0, 1], xlabel='x', ylabel='f(x)')
    plt.show()
Beispiel #35
0
    def __init__(self, taylor_args, *args, **kwargs):

        # Initialize the baseclass
        super(TaylorRulePrior, self).__init__(*args, **kwargs)

        # r_loc  = ordering[0]
        # pi_loc = ordering[1]
        # y_loc  = ordering[2]

        npara = self.n * (self.n +
                          1) / 2 + self.n**2 * self.p + self.n * self.cons

        A0_r_start = self.n * (self.n + 1) / 2 - self.n
        A0_r_end = self.n * (self.n + 1) / 2
        last_col_A0 = np.arange(A0_r_start, A0_r_end)

        A1_r_start = A0_r_end + (self.n - 1) * self.n * (self.p) + (
            self.n - 1) * self.cons
        A1_r_end = A1_r_start + self.n
        last_col_A1 = np.arange(A1_r_start, A1_r_end)

        cons_Aplus = npara - 1
        r_idx = np.r_[last_col_A0, last_col_A1, cons_Aplus]
        r_idx = np.asarray(r_idx, dtype=int)
        print('r_idx', r_idx)
        #r_idx = np.array([ 3,  4,  5,  14,  15,  16,  17])
        self.r_idx = r_idx
        self.non_r_idx = np.ones((npara, ), dtype=bool)
        self.non_r_idx[r_idx] = False

        # drop out r variables
        self.sigma_con = self.sigma[self.non_r_idx, :][:, self.non_r_idx]
        self.mu_con = self.mu[self.non_r_idx]
        self.prior_con = multivariate_normal(self.mu_con, self.sigma_con)

        from scipy.stats import norm, beta, invgamma

        self.tlr = OrderedDict()
        self.tlr['r_star'] = taylor_args.pop(
            'r_star', norm(loc=4 / 100, scale=0.5 / 100))
        self.tlr['rho'] = taylor_args.pop('rho', norm(loc=0.75, scale=0.1))
        self.tlr['alpha_pi'] = taylor_args.pop('alpha_pi',
                                               norm(loc=1.5, scale=0.25))
        self.tlr['alpha_z'] = taylor_args.pop('alpha_z',
                                              norm(loc=1.0, scale=0.25))
        self.tlr['sigma_R'] = taylor_args.pop('sigma_R', invgamma(10))
        self.tlr['tau_1'] = taylor_args.pop('tau_1', norm(loc=0, scale=0.25))
        self.tlr['tau_2'] = taylor_args.pop('tau_2', norm(loc=0, scale=0.25))
    def sample(self, model, evidence):
        g = evidence['g']

        prior_mu_g = model.hyper_params['g']['mu']
        a = model.hyper_params['transition_var_g']['a']
        b = model.hyper_params['transition_var_g']['b']
        max_var = model.hyper_params['transition_var_g']['max']

        n = len(g)

        g_var_posterior = stats.invgamma(a + (n - 1) / 2.,
                                         scale=b + sum(
                                             (g[1:] - g[:-1])**2) / 2.)
        g_var = g_var_posterior.rvs()

        return min(g_var, max_var)
Beispiel #37
0
    def updateQ_s(data, Q_m, Q_s):
        """
        implements the update seen in 33.44
        :param Q_m: Q of m optimal
        :param data: the samples
        :return: Q_s
        """
        mean_sigma, var_sigma = Q_s.stats(moments='mv')
        mean_beta = 1 / mean_sigma**2

        mu_sigma_data = np.sqrt(1 / (data.size * mean_beta))
        S = np.std(data)**2 * data.size

        b_prime = 0.5 * (data.size * mu_sigma_data**2 + S)
        c_prime = data.size / 2
        return stats.invgamma(a=b_prime, scale=c_prime)
Beispiel #38
0
def sample_posterior(priors, data, param_priors):

    mu0, sig0, alpha, beta = param_priors

    post_params = priors
    for observation in data:
        post_params = get_posterior_params(post_params, observation)

    mu_post, nu_post, alpha_post, beta_post = post_params

    sigma = stats.invgamma(a=alpha_post, scale=beta_post).rvs()
    tau = np.sqrt(1 / sigma)

    tau_post = 1 / sig0 + tau
    mu = np.random.normal(mu_post, 1 / tau_post)

    return mu, sigma
Beispiel #39
0
def sim_dataset(G0, lambdas, n_causes, n_units, randseed):
    '''
    calculate the target Y based on the simulated dataset

    input:
    G0: level 0 data
    lambdas: unknown groups
    n_causes and n_units: int, dimensions of the dataset
    output:
    G: G0 in pandas format with colnames that indicate if its a cause or not
    tc: causal columns
    y01: binary target

    '''
    np.random.seed(randseed)
    tc_ = npr.normal(loc=0, scale=0.5 * 0.5, size=int(n_causes * 0.1))
    tc = np.hstack(
        (np.repeat(0.0, n_causes - int(n_causes * 0.1)), tc_))  #True causes
    tc.shuffle(tc)

    tau = stats.invgamma(3, 1).rvs(3, random_state=99)
    sigma = np.zeros(n_units)
    sigma = [
        tau[0] if lambdas[j] == 0 else sigma[j] for j in range(len(sigma))
    ]
    sigma = [
        tau[1] if lambdas[j] == 1 else sigma[j] for j in range(len(sigma))
    ]
    sigma = [
        tau[2] if lambdas[j] == 2 else sigma[j] for j in range(len(sigma))
    ]
    y0 = np.array(tc).reshape(1, -1).dot(np.transpose(G0))
    l1 = lambdas.reshape(1, -1)
    y1 = (np.sqrt(np.var(y0)) / np.sqrt(0.4)) * (np.sqrt(0.4) /
                                                 np.sqrt(np.var(l1))) * l1
    e = npr.normal(0, sigma, n_units).reshape(1, -1)
    y2 = (np.sqrt(np.var(y0)) / np.sqrt(0.4)) * (np.sqrt(0.2) /
                                                 np.sqrt(np.var(e))) * e
    y = y0 + y1 + y2
    p = 1 / (1 + np.exp(y0 + y1 + y2))

    y01 = np.zeros(len(p[0]))
    y01 = [npr.binomial(1, p[0][i], 1)[0] for i in range(len(p[0]))]
    y01 = np.asarray(y01)
    G = add_colnames(G0, tc)
    return G, tc, y01
    def sample(self, model, evidence):
        h = evidence['h']

        prior_mu_h = model.hyper_params['h']['mu']
        a = model.hyper_params['transition_var_h']['a']
        b = model.hyper_params['transition_var_h']['b']
        max_var = model.hyper_params['transition_var_h']['max']

        phi = model.known_params['phi']
        mu = model.known_params['mu_h']

        n = len(h)

        h_var_posterior = stats.invgamma(a + (n-1)/2., scale=b + sum(((h[1:]-mu) - phi*(h[:-1]-mu))**2)/2.)
        h_var = h_var_posterior.rvs()

        return min(h_var, max_var)
Beispiel #41
0
def test_CovDiagonalGammaPrior(seeded_rng):

    cov_np = np.diag(np.exp(np.random.normal(size=m)))
    cov = CovDiagonalGammaPrior(size=m,
                                sigma=np.diag(cov_np),
                                alpha=1.5,
                                beta=1e-10)

    ig = invgamma(1.5, scale=1e-10)

    # compute the naive version
    logdet_np, sinv_np, sinvx_np = logdet_sinv_np(X, cov_np)
    penalty_np = np.sum(ig.logpdf(1 / np.diag(cov_np)))
    assert_allclose(logdet_np, cov.logdet, rtol=rtol)
    assert_allclose(sinv_np, cov.solve(eye), rtol=rtol)
    assert_allclose(sinvx_np, cov.solve(X_tf), rtol=rtol)
    assert_allclose(penalty_np, cov.logp, rtol=rtol)
Beispiel #42
0
def main():
    """
    Main CLI handler.
    """

    parser = argparse.ArgumentParser(description=__description__)
    parser.add_argument("--version",
                        action="version",
                        version="%(prog)s " + __version__)
    parser.add_argument("alpha",
                        type=float,
                        default=3.00,
                        help="Alpha parameter value [default=%(default)s].")
    parser.add_argument("beta",
                        type=float,
                        default=0.001,
                        help="Beta parameter value [default=%(default)s].")
    parser.add_argument("-f",
                        "--input-format",
                        type=str,
                        default="newick",
                        choices=["nexus", "newick"],
                        help="Input data format (default='%(default)s')")

    args = parser.parse_args()
    args.output_prefix = None
    args.show_plot_on_screen = True
    a = args.alpha
    b = args.beta
    rv = invgamma(a, loc=0, scale=b)
    print("Mean: {}".format(rv.mean()))
    print("Variance: {}".format(rv.var()))
    fig, ax = plt.subplots(1, 1)
    x = np.linspace(invgamma.ppf(0.01, a, scale=b),
                    invgamma.ppf(0.99, a, scale=b), 100)
    ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')
    ax.plot(x,
            invgamma.pdf(x, a, scale=b),
            'r-',
            lw=5,
            alpha=0.6,
            label='invgamma pdf')
    spdw.render_output(args, "InverseGamma")
	def initialize(self):
		# InvGamma RV with beta=1, alpha=1
		IG = invgamma(1)

		self.U = numpy.empty([self.K,self.I])
		self.S_U = numpy.empty([self.K,self.I])

		for k in range(0,self.K):
			for i in range(0,self.I):
				self.U[k][i] = random.normalvariate(0,1)
				self.S_U[k][i] = IG.rvs()

		self.V = numpy.empty([self.K,self.J])
		self.S_V = numpy.empty([self.K,self.J])

		for k in range(0,self.K):
			for j in range(0,self.J):
				self.V[k][j] = random.normalvariate(0,1)
				self.S_V[k][j] = IG.rvs()

		self.R = self.X - numpy.dot(self.U.transpose(),self.V)

		return
Beispiel #44
0
def check_eta_samples(test_model, samples):
    from pyglm.internals.activation import GaussianNoiseActivation
    if not isinstance(test_model.activation_model, GaussianNoiseActivation):
        return
    alpha_eta = test_model.activation_model.alpha_0
    beta_eta  = test_model.activation_model.beta_0

    # Convert samples to arrays
    eta_samples = np.array([s.activation_model.eta for s in samples])

    eta_mean = eta_samples.mean(0)
    eta_std  = eta_samples.std(0)
    eta_dist = invgamma(a=alpha_eta, scale=beta_eta)

    # Make Q-Q plots
    fig = plt.figure()
    # w_ax = fig.add_subplot(121)
    # probplot(w_samples[:,0,0,0], dist=w_dist, plot=w_ax)

    fig.add_subplot(122)
    _, bins, _ = plt.hist(eta_samples[:,0], 50, normed=True, alpha=0.2)
    bincenters = 0.5*(bins[1:]+bins[:-1])
    plt.plot(bincenters, eta_dist.pdf(bincenters), 'r--', linewidth=1)
    plt.show()
Beispiel #45
0

### Priors

# In[136]:

a0 = [0.0, 10.0]
b0 = [0.0, 10.0]
s20 = [3.0, 1.0]


# In[137]:

ap = norm(loc=a0[0], scale=np.sqrt(a0[1]))
bp = norm(loc=b0[0], scale=np.sqrt(b0[1]))
s2p = invgamma(s20[0]/2, loc=0, scale=s20[0]*s20[1]/2)


# In[138]:

x = np.linspace(norm.ppf(0.01), norm.ppf(0.99), 100)
plt.plot(x, ap.pdf(x), 'b-', lw=5, alpha=0.6)
plt.title('alpha prior')
plt.show()

plt.plot(x, bp.pdf(x), 'b-', lw=5, alpha=0.6)
plt.title('beta prior')
plt.show()

x = np.linspace(invgamma.ppf(0.01, s20[0]/2), invgamma.ppf(0.99, s20[1]/2), 100)
plt.plot(x, s2p.pdf(x), 'b-', lw=5, alpha=0.6)
def define_model(data):
    # Builds model object
    # Known values from simulation (can use to initialize sampler/skip burn-in)
    p = pickle.load(open('../data/sims/simulation_delta_0.pkl', 'rb'))
    g = p['g']
    h = p['h']
    T = p['T']
    sigma_g = p['sigma_g']
    sigma_h = p['sigma_h']
    # Also needed for known parameters (so load the right pkl dummy!)
    phi = p['phi']
    mu_h = p['mu_h']
    sigma_z_g = p['sigma_z_g']
    sigma_z_h = p['sigma_z_h']

    n = len(data)
    z = data.get('z')
    variable_names = ['g', 'h', 'T', 'p_type', 'sigma_g', 'sigma_h']
    known_params = {'sigma_z_g': sigma_z_g,
                    'sigma_z_h': sigma_z_h,
                    'mu_h': mu_h,
                    'phi': phi}
    hyper_params = {'alpha_type': array((1., 1., 1.)),
                    'prior_mu_g': -25.+zeros(n),
                    'prior_cov_g': 100.*eye(n),
                    'prior_mu_h': 30.+zeros(n),
                    'prior_cov_h': 100.*eye(n),
                    'a_g': 11,
                    'b_g': .1,
                    'a_h': 11,
                    'b_h': 40}
    #initials = {'g': -25+zeros(n),
    #            'sigma_g': .1,
    #            'sigma_h': 1,
    #            'T': array([(0 if abs(z[i]+25)>1 else 1) for i in xrange(n)])}
    initials = {'sigma_g': sigma_g,
                'sigma_h': sigma_h,
                'p_type': array((0, .5, .5)),
                'T': T[:n],
                'g': g[:n],
                'h': h[:n]}
    priors = {'p_type': dirichlet(hyper_params['alpha_type']),
              'sigma_g': stats.invgamma(hyper_params['a_g'], scale=hyper_params['b_g']),
              'sigma_h': stats.invgamma(hyper_params['a_h'], scale=hyper_params['b_h']),
              'g': mvnorm(hyper_params['prior_mu_g'], hyper_params['prior_cov_g']),
              'h': mvnorm(hyper_params['prior_mu_h'], hyper_params['prior_cov_h']),
              'T': iid_dist(categorical(hyper_params['alpha_type']), n)}
    FCP_samplers = {'p_type': p_type_step(),
                    'g': ground_height_step(),
                    'h': canopy_height_step(),
                    'sigma_g': sigma_ground_step(),
                    'sigma_h': sigma_height_step(),
                    'T': type_step()}

    model = Model()
    model.set_variable_names(variable_names)
    model.set_known_params(known_params)
    model.set_hyper_params(hyper_params)
    model.set_priors(priors)
    model.set_initials(initials)
    model.set_FCP_samplers(FCP_samplers)
    model.set_data(data)

    return model
Beispiel #47
0
 def __init__(self, alpha, beta) :
   """ """
   self.alpha = alpha
   self.beta = beta
   self.dist = invgamma(alpha, scale = beta)
   self.co = log((beta**alpha)/ gamma(alpha))
Beispiel #48
0
    samples, logs = metropolis.metropolis(x, mu, sigma, n_samples=2500)
    plt.plot(samples[:,0], samples[:,1], '.')
    plt.savefig('samples.pdf')
    plt.clf()
    
    plt.plot(logs)
    plt.savefig('logprobs.pdf')
    plt.clf()

# let's do a metropolis sampler for the exam scores data
alpha=3
beta=50
mu0 = 80
sig20 = 16
muprior=st.norm(loc=mu0, scale=sqrt(sig20))
sig2prior = st.invgamma(alpha,scale=beta)
def proposal(y, std):
    return st.multivariate_normal.rvs(mean=y, cov=std*np.eye(len(y)))
def propLogDensity(x):
    return muprior.logpdf(x[0])+sig2prior.logpdf(x[1])+st.norm.logpdf(scores,loc=x[0],scale=sqrt(x[1])).sum()
def metropolis(x0, s, n_samples):
    """
    Use the Metropolis algorithm to sample from posterior.
    
    Parameters
    ----------
    x0 : ndarray of shape (2,)
        The first entry is mu, the second entry is sigma2
    s : float > 0
        The standard deviation parameter for the proposal function
    n_samples : int
Beispiel #49
0
 def chi2inv(p, v):
     return st.invgamma(v/2,scale=2).ppf(p)
 def _kstest(self, alpha, beta, samples):
   # Uses the Kolmogorov-Smirnov test for goodness of fit.
   ks, _ = stats.kstest(samples, stats.invgamma(alpha, scale=beta).cdf)
   # Return True when the test passes.
   return ks < 0.02
Beispiel #51
0
 def var_post_dist(self):
     post_n, post_d = self.var_post_params
     return stats.invgamma(post_n, scale=post_d / 2.0)
def define_model(data):
    # Builds model object 
    # Encapsulates everything the gibbs sampler needs to know about.

    # Data and dimensions
    N = len(data) # Number of data points
    shot_id = data.get('shot_id')
    n = len(set(shot_id)) # Number of shots
    print data.filepath

    if 'Cedar2' in data.filepath:
        import params_cedar2 as params
    elif 'Cedar4' in data.filepath:
        import params_cedar4 as params
    elif 'SERC1' in data.filepath:
        import params_serc1 as params
    elif 'SERC3' in data.filepath:
        import params_serc3 as params
    elif 'SERC5' in data.filepath:
        import params_serc5 as params
    elif 'zeta' in data.filepath:
        import params_zeta as params
    elif 'eta' in data.filepath:
        import params_eta as params
    elif 'matlas' in data.filepath:
        import params_matlas as params
    else:
        import params_default as params 

    # Parameters and initialization values
    known_params = params.get_known_params(data)
    initials = params.get_initials(data)
    hyper_params = params.get_hyper_params(data)
    m_cover = params.m_cover
    m_type = params.m_type


    # Variables to be sampled (in this order)
    variable_names = ['h', 'g', 'T', 'C', 'noise_proportion', 'transition_var_g', 'transition_var_h']

    priors = {'g': MVNormal(hyper_params['g']['mu'], hyper_params['g']['cov']),
              'h': MVNormal(hyper_params['h']['mu'], hyper_params['h']['cov']),
              'C': IID(Categorical(hyper_params['C']['p']), n),
              'T': IID(Categorical(hyper_params['T']['p']), N),
              'noise_proportion': Dirichlet(hyper_params['noise_proportion']['alpha']),
              'transition_var_g': stats.invgamma(hyper_params['transition_var_g']['a'], scale=hyper_params['transition_var_g']['b']),
              'transition_var_h': stats.invgamma(hyper_params['transition_var_h']['a'], scale=hyper_params['transition_var_h']['b'])}
    FCP_samplers = {'g': ground_elev_step(),
                    'h': canopy_height_step(),
                    'C': cover_step(),
                    'T': type_step(),
                    'noise_proportion': noise_proportion_step(),
                    'transition_var_g': transition_var_g_step(),
                    'transition_var_h': transition_var_h_step()}
    sample_handlers = {'g': [indep_meanvar_handler()],
                       'h': [indep_meanvar_handler()],
                       'T': [discrete_handler(support=range(m_type), length=N)],
                       'C': [discrete_handler(support=range(m_cover), length=n)],
                       'noise_proportion': [raw_sample_handler()],
                       'transition_var_g': [raw_sample_handler()],
                       'transition_var_h': [raw_sample_handler()]}
    diagnostic_variable = 'noise_proportion'



    model = Model()
    model.set_variable_names(variable_names)
    model.set_known_params(known_params)
    model.set_hyper_params(hyper_params)
    model.set_priors(priors)
    model.set_initials(initials)
    model.set_FCP_samplers(FCP_samplers)
    model.set_sample_handlers(sample_handlers)
    model.set_diagnostic_variable(diagnostic_variable)
    model.set_data(data)

    return model