Example #1
0
def plot3(A,B,S,T,D, tMAP=None):
    States = D.Y
    pMAP = [9.75961269, 0.0583687877, 78.4901534, 78.1696975]
    alpha, beta, sig2, ome2 = pMAP
    tMAP = (alpha, beta, sig2, ome2, States, D.Y)

    x1 = np.linspace(norm.ppf(0.01), norm.ppf(0.99), 100)
    x2 = np.linspace(invgamma.ppf(0.01, S.prior.p1/2), invgamma.ppf(0.99, S.prior.p1/2), 100)
    x3 = np.linspace(invgamma.ppf(0.01, T.prior.p1/2), invgamma.ppf(0.99, T.prior.p1/2), 100)

    tmp = lambda (a, b, s, t, X, Y): 1/(1/A.prior.var + D.n/S.prior.p2)
    print tMAP
    print tmp(tMAP)
    print A.cond.var(tMAP)
    print A.cond.m(tMAP)
    print A.cond.rv((tMAP))

    plt.plot(x1, A.cond.rv(tMAP).pdf(x1), 'r-', lw=5, alpha=0.6, label='a prior')
    plt.title('alpha conditional at MAP')
    plt.show()

    plt.plot(x1, B.cond.rv(tMAP).pdf(x1), 'r-', lw=5, alpha=0.6, label='b prior')
    plt.title('beta conditional at MAP')
    plt.show()

    plt.plot(x2, S.cond.rv(tMAP).pdf(x2), 'r-', lw=5, alpha=0.6, label='sig2 prior')
    plt.title('sig2 conditional at MAP')
    plt.show()

    plt.plot(x3, T.cond.rv(tMAP).pdf(x3), 'r-', lw=5, alpha=0.6, label='sig2 prior')
    plt.title('sig2 conditional at MAP')
    plt.show()
Example #2
0
def calc_estimates(n, t):
    # posterior rate (lambda) is a Gamma distributiona (with Jeffreys prior of Poisson observations)
    a = n + 0.5  #
    b = t

    p10 = invgamma.ppf(0.1, a=a, scale=b)
    p90 = invgamma.ppf(0.9, a=a, scale=b)
    mean = invgamma.mean(a=a, scale=b)
    return mean, p10, p90
 def equitailed_cs(self, alpha2):
     """
     Calculates the equitailed credible set of a parameter.
     The alpha to be inserted should be between (0-100).
     """
     alpha_split = (100 - alpha2) / 200
     lower_bound = invgamma.ppf(alpha_split, self.alpha, scale=self.beta)
     upper_bound = invgamma.ppf(1 - alpha_split,
                                self.alpha,
                                scale=self.beta)
     return (lower_bound, upper_bound)
Example #4
0
def pre_process_data(xdata, ydata, train_test_ratio):
    test_index = np.random.choice(len(ydata),
                                  int(np.ceil(len(ydata) * train_test_ratio)),
                                  replace=False)
    train_index = np.delete(np.arange(len(ydata)), test_index)

    xdata_train = xdata[train_index]
    ydata_train = ydata[train_index]
    xdata_test = xdata[test_index]
    ydata_test = ydata[test_index]

    ydata_train_min = np.min(ydata_train)
    ydata_train_max = np.max(ydata_train)
    ydata_train_mean = (ydata_train_max + ydata_train_min) / 2
    dd = ydata_train_max - ydata_train_min

    ydata_train = (ydata_train - ydata_train_mean) / dd
    ydata_test = (ydata_test - ydata_train_mean) / dd

    # set up the hyper-parameters
    regr = linear_model.LinearRegression()
    regr.fit(xdata_train, ydata_train)
    y_train_predict = regr.predict(xdata_train)
    variance_hat = np.var(y_train_predict - ydata_train)

    hyper_sigma_1 = 1.5
    percentile_val = 0.9

    val1 = invgamma.ppf(percentile_val, a=hyper_sigma_1, scale=1)
    hyper_sigma_2 = variance_hat / val1
    # invgamma.cdf(variance_hat, a=hyper_sigma_1, scale=hyper_sigma_2)
    # Calculate the standard deviation for least square regression

    return xdata_train, ydata_train, xdata_test, ydata_test, ydata_train_mean, dd, hyper_sigma_1, hyper_sigma_2, variance_hat
Example #5
0
def Friedman_pre_process(xdata_train, ydata_train, xdata_test, ydata_test):

    ydata_train_min = np.min(ydata_train)
    ydata_train_max = np.max(ydata_train)
    ydata_train_mean = (ydata_train_max + ydata_train_min) / 2
    dd = ydata_train_max - ydata_train_min

    ydata_train = (ydata_train - ydata_train_mean) / dd
    ydata_test = (ydata_test - ydata_train_mean) / dd

    # set up the hyper-parameters
    regr = linear_model.LinearRegression()
    regr.fit(xdata_train, ydata_train)
    y_train_predict = regr.predict(xdata_train)
    variance_hat = np.var(y_train_predict - ydata_train)

    hyper_sigma_1 = 1.5
    percentile_val = 0.9

    val1 = invgamma.ppf(percentile_val, a=hyper_sigma_1, scale=1)
    hyper_sigma_2 = variance_hat / val1
    # invgamma.cdf(variance_hat, a=hyper_sigma_1, scale=hyper_sigma_2)
    # Calculate the standard deviation for least square regression

    return xdata_train, ydata_train, xdata_test, ydata_test, ydata_train_mean, dd, hyper_sigma_1, hyper_sigma_2, variance_hat
Example #6
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")
Example #7
0
def plot2(A,B,S,T):
    x = np.linspace(norm.ppf(0.01), norm.ppf(0.99), 100)
    plt.plot(x, A.prior.rv.pdf(x), 'b-', lw=5, alpha=0.6)
    plt.title('alpha prior')
    plt.show()

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

    x = np.linspace(invgamma.ppf(0.01, S.prior.p1/2), invgamma.ppf(0.99, S.prior.p1/2), 100)
    plt.plot(x, S.prior.rv.pdf(x), 'b-', lw=5, alpha=0.6)
    plt.title('sig2 prior')
    plt.show()

    x = np.linspace(invgamma.ppf(0.01, T.prior.p1/2), invgamma.ppf(0.99, T.prior.p1/2), 100)
    plt.plot(x, T.prior.rv.pdf(x), 'b-', lw=5, alpha=0.6)
    plt.title('omg2 prior')
    plt.show()
Example #8
0
def true_posterior(data, m_0, s_sq_0, v_0, k_0, n):
    m_data = np.mean(data)
    n_data = len(data)
    sum_sq_diff_data = np.sum([(x - m_data)**2 for x in data])

    k_n = k_0 + n_data
    v_n = v_0 + n_data
    m_n = k_0 * m_0 / k_n + n_data * m_data / k_n
    v_n_times_s_sq_n = v_0 * s_sq_0 + sum_sq_diff_data + k_0 * n_data / k_n * (
        m_data - m_0)**2

    alpha = v_n / 2
    beta = v_n_times_s_sq_n / 2

    x = np.linspace(invgamma.ppf(1 / n, alpha, scale=beta),
                    invgamma.ppf(1 - 1 / n, alpha, scale=beta), n * 10)
    y = invgamma.pdf(x, alpha, scale=beta)

    return alpha, beta, m_n, k_n, x, y
 def __init__(self, domain, alpha, q, delta=0.001):
     self._domain = self._target = DomainTuple.make(domain)
     self._alpha, self._q, self._delta = \
         float(alpha), float(q), float(delta)
     self._xmin, self._xmax = -8.2, 8.2
     # Precompute
     xs = np.arange(self._xmin, self._xmax+2*delta, delta)
     self._table = np.log(invgamma.ppf(norm.cdf(xs), self._alpha,
                                       scale=self._q))
     self._deriv = (self._table[1:]-self._table[:-1]) / delta
Example #10
0
    def quantile(self, p):
        """ Return the p-quantile of the Gauss posterior.

        .. warning:: Very experimental, I am not sure of what I did here...

        .. note:: I recommend to NOT use :class:`BayesUCB` with Gauss posteriors...
        """
        # warn("Gauss.quantile() : Not implemented for a 2 dimensional distribution!", RuntimeWarning)
        quantile_on_sigma2 = invgamma.ppf(p, self.alpha, scale=self.beta)
        scale = self.beta / float(self.alpha)  # mean of the Inverse-gamma
        quantile_on_x = norm.ppf(p, loc=self.mu, scale=scale / float(self.nu))
        return quantile_on_x * quantile_on_sigma2
        raise ValueError(
            "Gauss.quantile() : Not implemented for a 2 dimensional distribution!"
        )
Example #11
0
def pre_process_data(xdata, ydata, train_test_ratio):
    # Usage: pre-process the data
    # Input:
    # xdata, ydata: the original full data

    # Output:
    # xdata_train, ydata_train, xdata_test, ydata_test: the train and test data
    # ydata_train_mean: the "mean" of the original training data
    # dd: the difference between the maximum and minimum ydata_train
    # hyper_sigma_1, hyper_sigma_2: hyper-parameters for infer the variance
    # variance_hat: rough estimated variance for ydata_train

    test_index = np.random.choice(len(ydata),
                                  int(np.ceil(len(ydata) * train_test_ratio)),
                                  replace=False)
    train_index = np.delete(np.arange(len(ydata)), test_index)

    xdata_train = xdata[train_index]
    ydata_train = ydata[train_index]
    xdata_test = xdata[test_index]
    ydata_test = ydata[test_index]

    ydata_train_min = np.min(ydata_train)
    ydata_train_max = np.max(ydata_train)
    ydata_train_mean = (ydata_train_max + ydata_train_min) / 2
    dd = ydata_train_max - ydata_train_min

    ydata_train = (ydata_train - ydata_train_mean) / dd
    ydata_test = (ydata_test - ydata_train_mean) / dd

    # set up the hyper-parameters
    regr = linear_model.LinearRegression()
    regr.fit(xdata_train, ydata_train)
    y_train_predict = regr.predict(xdata_train)
    variance_hat = np.var(y_train_predict - ydata_train)

    hyper_sigma_1 = 1.5
    percentile_val = 0.9

    val1 = invgamma.ppf(percentile_val, a=hyper_sigma_1, scale=1)
    hyper_sigma_2 = variance_hat / val1
    # invgamma.cdf(variance_hat, a=hyper_sigma_1, scale=hyper_sigma_2)
    # Calculate the standard deviation for least square regression

    return xdata_train, ydata_train, xdata_test, ydata_test, ydata_train_mean, dd, hyper_sigma_1, hyper_sigma_2, variance_hat
Example #12
0
def make_invgamma_prior(lower_bound: float = 0.1,
                        upper_bound: float = 0.5) -> rv_frozen:
    """Create an inverse gamma distribution prior with 98% density inside the bounds.

    Not all combinations of (lower_bound, upper_bound) are feasible and some of them
    could result in a RuntimeError.

    Parameters
    ----------
    lower_bound : float, default=0.1
        Lower bound at which 1 % of the cumulative density is reached.
    upper_bound : float, default=0.5
        Upper bound at which 99 % of the cumulative density is reached.

    Returns
    -------
    scipy.stats._distn_infrastructure.rv_frozen
        The frozen distribution with shape parameters already set.

    Raises
    ------
    ValueError
        Either if any of the bounds is 0 or negative, or if the upper bound is equal or
        smaller than the lower bound.
    """
    if lower_bound <= 0 or upper_bound <= 0:
        raise ValueError("The bounds cannot be equal to or smaller than 0.")
    if lower_bound >= upper_bound:
        raise ValueError(
            "Lower bound needs to be strictly smaller than the upper "
            "bound.")
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        (a_out, scale_out), pcov = curve_fit(
            lambda xdata, a, scale: invgamma.ppf(xdata, a=a, scale=scale),
            [0.01, 0.99],
            [lower_bound, upper_bound],
        )
    return invgamma(a=a_out, scale=scale_out)
Example #13
0
    def test_quantile(self):
        ys = np.arange(0.01, 0.99, 0.1)
        shapes = np.arange(0.01, 20, 0.5)
        scales = np.arange(0.01, 10, 0.5)

        test_params = cartesian([ys, shapes, scales]).astype(np.float64)

        python_results = np.zeros(test_params.shape[0])
        for ind in range(test_params.shape[0]):
            y = test_params[ind, 0]
            shape = test_params[ind, 1]
            scale = test_params[ind, 2]

            python_results[ind] = invgamma.ppf(y, shape, scale=scale)

        opencl_results = invgamma_ppf().evaluate(
            {
                'y': test_params[:, 0],
                'shape': test_params[:, 1],
                'scale': test_params[:, 2]
            }, test_params.shape[0])

        assert_allclose(opencl_results, python_results, atol=1e-7, rtol=1e-7)
 def IG(field, alpha, q):
     foo = invgamma.ppf(norm.cdf(field.local_data), alpha, scale=q)
     return Field.from_local_data(field.domain, foo)
def inverseGammaVisualize(alpha,beta):
    x = np.linspace(invgamma.ppf(0.01, alpha,scale=beta),invgamma.ppf(0.99,alpha,scale=beta), 100)
    plt.plot(x, invgamma.pdf(x, alpha,scale=beta),
             'r-', lw=5, alpha=0.6, label='IG density for alpha={0}, beta={1}'.format(alpha,beta))
    plt.legend()
    return plt.gca()
Example #16
0
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)
plt.title('sig2 prior')
plt.show()


### Full conditionals

# In[139]:

aC = lambda (a, b, s2): 1/(1/a0[1] + D.n/s20[1])
am = lambda (a, b, s2): aC((a,b,s2))*(sum(D.Y-b*D.X)/s20[1] + a0[0]/a0[1])
bC = lambda (a, b, s2): 1/(1/b0[1] + sum(D.X**2)/s20[1])
bm = lambda (a, b, s2): bC((a,b,s2))*(sum((D.Y-a)*D.X)/s20[1]+b0[0]/b0[1])
sA = lambda (a, b, s2): s20[0] + D.n
sB = lambda (a, b, s2): s20[0]*s20[1] + sum((D.Y-a-b*D.X)**2)
from scipy.stats import invgamma
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 1)

# Calculate a few first moments:

a = 4.07
mean, var, skew, kurt = invgamma.stats(a, moments='mvsk')

# Display the probability density function (``pdf``):

x = np.linspace(invgamma.ppf(0.01, a), invgamma.ppf(0.99, a), 100)
ax.plot(x, invgamma.pdf(x, a), 'r-', lw=5, alpha=0.6, label='invgamma pdf')

# Alternatively, the distribution object can be called (as a function)
# to fix the shape, location and scale parameters. This returns a "frozen"
# RV object holding the given parameters fixed.

# Freeze the distribution and display the frozen ``pdf``:

rv = invgamma(a)
ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

# Check accuracy of ``cdf`` and ``ppf``:

vals = invgamma.ppf([0.001, 0.5, 0.999], a)
np.allclose([0.001, 0.5, 0.999], invgamma.cdf(vals, a))
# True

# Generate random numbers:
Example #18
0
from scipy.stats import invgamma
import matplotlib.pyplot as plt

import numpy as np

x = np.linspace(invgamma.ppf(0.01, a), invgamma.ppf(0.99, a), 100)
rv = invgamma(a)
fig, ax = plt.subplots(1, 1)

ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')
Example #19
0
def ppf_inv_gamma(x, a, b):
    return b * invgamma.ppf(x, a)