Beispiel #1
0
def _noise_variance(hparams, tau_cmmn, verbose=0):
    dist_std_noise = hparams.dist_std_noise

    if dist_std_noise == 'tr_normal':
        h1 = HalfNormal('h1', tau=np.float32(1 / tau_cmmn[0]), dtype=floatX)
        h2 = HalfNormal('h2', tau=np.float32(1 / tau_cmmn[1]), dtype=floatX)

        if 10 <= verbose:
            print('Truncated normal for prior scales')

    elif dist_std_noise == 'log_normal':
        h1 = Lognormal('h1', tau=np.float32(1 / tau_cmmn[0]), dtype=floatX)
        h2 = Lognormal('h2', tau=np.float32(1 / tau_cmmn[1]), dtype=floatX)

        if 10 <= verbose:
            print('Log normal for prior scales')

    elif dist_std_noise == 'uniform':
        h1 = Uniform('h1', upper=np.float32(1 / tau_cmmn[0]), dtype=floatX)
        h2 = Uniform('h2', upper=np.float32(1 / tau_cmmn[1]), dtype=floatX)

        if 10 <= verbose:
            print('Uniform for prior scales')

    else:
        raise ValueError("Invalid value of dist_std_noise: %s" %
                         dist_std_noise)

    return h1, h2
Beispiel #2
0
def _noise_variance(
    hparams, tau_cmmn, HalfNormal, Lognormal, Uniform, floatX, verbose):
    if hparams['prior_scale'] == 'tr_normal':
        h1 = HalfNormal('h1', tau=np.float32(1 / tau_cmmn[0]), dtype=floatX)
        h2 = HalfNormal('h2', tau=np.float32(1 / tau_cmmn[1]), dtype=floatX)

        if 10 <= verbose:
            print('Truncated normal for prior scales')

    elif hparams['prior_scale'] == 'log_normal':
        h1 = Lognormal('h1', tau=np.float32(1 / tau_cmmn[0]), dtype=floatX)
        h2 = Lognormal('h2', tau=np.float32(1 / tau_cmmn[1]), dtype=floatX)

        if 10 <= verbose:
            print('Log normal for prior scales')

    elif hparams['prior_scale'] == 'uniform':
        h1 = Uniform('h1', upper=np.float32(1 / tau_cmmn[0]), dtype=floatX)
        h2 = Uniform('h2', upper=np.float32(1 / tau_cmmn[1]), dtype=floatX)

        if 10 <= verbose:
            print('Uniform for prior scales')

    else:
        raise ValueError("Invalid value of prior_scale: %s" % 
            hparams['prior_scale'])

    return h1, h2
Beispiel #3
0
def createSignalModelExponential(data):
  """
    Toy model that treats the first ~10% of the waveform as an exponential.  Does a good job of finding the start time (t_0)
    Since I made this as a toy, its super brittle.  Waveform must be normalized
  """
  with Model() as signal_model:
    switchpoint = Uniform('switchpoint', lower=0, upper=len(data), testval=len(data)/2)
    
    noise_sigma = HalfNormal('noise_sigma', sd=1.)
    
    #Modeling these parameters this way is why wf needs to be normalized
    exp_rate = Uniform('exp_rate', lower=0, upper=.5, testval = 0.05)
    exp_scale = Uniform('exp_scale', lower=0, upper=.5, testval = 0.1)
    
    timestamp = np.arange(0, len(data), dtype=np.float)
    
    rate = switch(switchpoint >= timestamp, 0, exp_rate)
    
    baseline_model = Deterministic('baseline_model', exp_scale * (exp( (timestamp-switchpoint)*rate)-1.) )
    
    baseline_observed = Normal("baseline_observed", mu=baseline_model, sd=noise_sigma, observed= data )
  return signal_model
    def fit(self, base_models_predictions, true_targets,
            model_identifiers=None):

        ba = BayesianAverage()
        weight_vector = ba.fit(base_models_predictions, true_targets)
        default = True

        base_models_predictions = base_models_predictions.transpose()
        n_basemodels = base_models_predictions.shape[2]
        with Model() as basic_model:
            #define prior
            HalfNormal('weights', sd=1, shape=n_basemodels)
            #define likelihood function
            ensemble_pred = np.dot(base_models_predictions, weight_vector)
            Categorical('likelihood', p=ensemble_pred.transpose(), observed=true_targets)

        with basic_model:
            start = find_MAP(model=basic_model)
            if not default:
                step = Metropolis()
            step = NUTS()
            trace = sample(self.n_samples, step=step, start=start)
        trace = trace[5000:]
        self.sampled_weights = trace["weights"]
N_GROUPS = comm.Get_size(
) - 1  #Groups used for simulation - one less than used cores

if rank == 0:  #master
    print("CHAIN ", CHAIN)
    print("DRAWS", NDRAWS)

    print("How many sentences used?", n_sentences)
    basic_model = Model()

    #Below we specify the Bayesian model
    with basic_model:

        #Priors
        le = HalfNormal('le', sd=0.5, testval=abs(np.random.randn()) / 2)
        lf = Gamma('lf', alpha=1, beta=5, testval=abs(np.random.randn() / 4))
        #emvt = Gamma('emvt', alpha=1, beta=3, testval=abs(np.random.randn()))
        emap = HalfNormal('emap', sd=1.0, testval=abs(np.random.randn() / 2))

        intercept = Normal('intercept', mu=50, sd=25)

        sigma = HalfNormal('sigma', sd=20)

        # Expected value of outcome
        mu = intercept + model(lf, le, emap, intercept, sigma)

        # Likelihood (sampling distribution) of observations
        Normal('Y_obs', mu=mu, sd=50, observed=Y)

        step = Metropolis(basic_model.vars)
Beispiel #6
0
axes[1].scatter(X2, Y)
axes[0].set_ylabel('Y'); axes[0].set_xlabel('X1'); axes[1].set_xlabel('X2');

plt.show()




basic_model = Model()

with basic_model:

    # Priors for unknown model parameters
    alpha = Normal('alpha', mu=0, sd=10)
    beta = Normal('beta', mu=0, sd=10, shape=2)
    sigma = HalfNormal('sigma', sd=1)

    # Expected value of outcome
    mu = alpha + beta[0]*X1 + beta[1]*X2

    # Likelihood (sampling distribution) of observations
    Y_obs = Normal('Y_obs', mu=mu, sd=sigma, observed=Y)

# map_estimate = find_MAP(model=basic_model)

# print(map_estimate)

map_estimate = find_MAP(model=basic_model, fmin=optimize.fmin_powell)

print(map_estimate)
Beispiel #7
0
def createSignalModelWithLookup(data, wfMax):
  """
    Uses a lookup table to avoid having to call siggen.  Lookup locations are along a one-dimensional line from PC to the detector corner.  See generate_siggen_lookup.py
    
    wfMax: maximum of the input signal.  Used as a prior for the for scaling of the simulated pulse
    
  """

  with Model() as signal_model:
    
    switchpoint = DiscreteUniform('switchpoint', lower=0, upper=len(data))
    noise_sigma = HalfNormal('noise_sigma', sd=1.)
    siggen_sigma = HalfNormal('siggen_sigma', sd=10.)
    
    
    
    timestamp = np.arange(0, len(data), dtype=np.int)

    uncertainty_model = switch(switchpoint >= timestamp, noise_sigma, siggen_sigma)
    
    wf_scale = Normal('wf_scale', sd=10., mu=wfMax)
    
    detRad = np.floor(35.41)
    detZ = np.floor(41.5)
    
    dtEstimate = DiscreteUniform('dtEstimate', lower=0, upper=99  )

    
  #          radiusEstimate = DiscreteUniform('radiusEstimate', lower=0, upper=35  )
  #          zEstimate =      DiscreteUniform('zEstimate', lower=0, upper=41)

    
    
    @as_op(itypes=[T.lscalar, T.lscalar, T.dscalar], otypes=[T.dvector])
    def siggen_model_dt(switchpoint, dtEstimate, wf_scale):
      siggen_out = dt_array[dtEstimate, :]
      siggen_out *= wf_scale

      T.clip(dtEstimate, 0, 99) #THIS IS A DISASTER. NEED to find a better way to handle this

      out = np.zeros(len(data))
      out[switchpoint:] = siggen_out[0:(len(data) - switchpoint)]
      
  #            print "length of out is %d" % len(out)
      return out
    
    @as_op(itypes=[T.lscalar, T.lscalar, T.lscalar], otypes=[T.dvector])
    def siggen_model(switchpoint, r, z):
      siggen_out = findSiggenWaveform(0,r,z,np.amax(np_data))
      out = np.zeros(len(data))
      out[switchpoint:] = siggen_out[0:(len(data) - switchpoint)]
      
      return out
    
    
  #          print "length of data is %d" % len(data)

  #          @as_op(itypes=[T.lscalar, T.dscalar, T.dscalar], otypes=[T.dvector])
  #          
  #          def crazy_modulo3(switchpoint, exp_scale, exp_rate):
  #            out = np.zeros(len(data))
  #            out[switchpoint:] = exp_scale * (np.exp( exp_rate * (timestamp[switchpoint:] - switchpoint))-1.)
  #            return out

    
    #baseline_model = Deterministic('baseline_model', exp_scale * (exp( (timestamp-switchpoint)*rate)-1.) )
    
  #          baseline_model = siggen_model(switchpoint, radiusEstimate, zEstimate)
    baseline_model_dt = siggen_model_dt(switchpoint, dtEstimate, wf_scale)
    
    
    baseline_observed = Normal("baseline_observed", mu=baseline_model_dt, sd=uncertainty_model, observed= data )

  return signal_model

#def createSignalModelDynamic(data, wfMax):
#  """
#    Calls siggen in real time
#    
#  """
#
#  with Model() as signal_model:
#    
#    switchpoint = DiscreteUniform('switchpoint', lower=0, upper=len(data))
#    noise_sigma = HalfNormal('noise_sigma', sd=1.)
#    siggen_sigma = HalfNormal('siggen_sigma', sd=10.)
#    
#    timestamp = np.arange(0, len(data), dtype=np.int)
#
#    uncertainty_model = switch(switchpoint >= timestamp, noise_sigma, siggen_sigma)
#    
#    detRad = np.floor(35.41)
#    detZ = np.floor(41.5)
#    
#    dtEstimate = DiscreteUniform('dtEstimate', lower=0, upper=99  )
#
#    
#  #          radiusEstimate = DiscreteUniform('radiusEstimate', lower=0, upper=35  )
#  #          zEstimate =      DiscreteUniform('zEstimate', lower=0, upper=41)
#
#    
#    
#    @as_op(itypes=[T.lscalar, T.lscalar], otypes=[T.dvector])
#    def siggen_model_dt(switchpoint, dtEstimate):
#      siggen_out = dt_array[dtEstimate, :]
#      siggen_out *= wfMax
#
#      T.clip(dtEstimate, 0, 99) #THIS IS A DISASTER. NEED to find a better way to handle this
#
#      out = np.zeros(len(data))
#      out[switchpoint:] = siggen_out[0:(len(data) - switchpoint)]
#      
#  #            print "length of out is %d" % len(out)
#      return out
#    
#    @as_op(itypes=[T.lscalar, T.lscalar, T.lscalar], otypes=[T.dvector])
#    def siggen_model(switchpoint, r, z):
#      siggen_out = findSiggenWaveform(0,r,z,np.amax(np_data))
#      out = np.zeros(len(data))
#      out[switchpoint:] = siggen_out[0:(len(data) - switchpoint)]
#      
#      return out
#    
#    
#  #          print "length of data is %d" % len(data)
#
#  #          @as_op(itypes=[T.lscalar, T.dscalar, T.dscalar], otypes=[T.dvector])
#  #          
#  #          def crazy_modulo3(switchpoint, exp_scale, exp_rate):
#  #            out = np.zeros(len(data))
#  #            out[switchpoint:] = exp_scale * (np.exp( exp_rate * (timestamp[switchpoint:] - switchpoint))-1.)
#  #            return out
#
#    
#    #baseline_model = Deterministic('baseline_model', exp_scale * (exp( (timestamp-switchpoint)*rate)-1.) )
#    
#  #          baseline_model = siggen_model(switchpoint, radiusEstimate, zEstimate)
#    baseline_model_dt = siggen_model_dt(switchpoint, dtEstimate)
#    
#    
#    baseline_observed = Normal("baseline_observed", mu=baseline_model_dt, sd=uncertainty_model, observed= data )
#
#  return signal_model
df = pd.read_csv("../data/data-ss2.txt")
T = df.values[:, 0].astype(np.float32)
Y = df.values[:, 1].astype(np.float32)

n_times = len(df["X"].unique())  #時間の数
L = 4  #トレンド周期

basic_model = Model()

#subtensorの使い方↓
#http://deeplearning.net/software/theano/library/tensor/basic.html

with basic_model:
    #事前分布
    s_mu = HalfNormal('s_mu', sd=100)  #隣接時刻の状態の誤差
    s_season = HalfNormal('s_season', sd=100)  #季節誤差
    s_Y = HalfNormal('s_Y', sd=100)  #各時刻における状態と観測の誤差
    season_0_1_2 = Normal('season_0_1_2', mu=0, sd=100, shape=3)  #季節項の誤差なし初期値

    #季節process
    ##まず初期状態の代入
    season = tt.zeros((n_times))
    for i in range(L - 1):
        season = tt.set_subtensor(season[i], season_0_1_2[i])

    ##初期状態以降の代入
    for t in range(n_times - 3):
        # sum^{L-1}_{l=1} -season[t-l] のテンソルを作成
        Sigma = tt.zeros((1))
        for l in range(L - 1):
Beispiel #9
0
    parser.model_parameters["strength_of_association"] = \
            strength_of_association
    parser.model_parameters["rule_firing"] = rule_firing
    parser.model_parameters["latency_factor"] = latency_factor

    sample = np.array(run_fan_exp(), dtype=np.dtype('f8')) * 1000

    #print("SAMPLE", sample)

    return sample

fan_model = Model()

with fan_model:
    # Priors
    buffer_spreading_activation = HalfNormal("bsa", sd=2)
    strength_of_association = HalfNormal("soa", sd=4)
    rule_firing = HalfNormal("rf", sd=0.03)
    latency_factor = HalfNormal("lf", sd=0.2)
    # Likelihood
    pyactr_rt = actrmodel_latency(rule_firing, latency_factor,
                                  buffer_spreading_activation,
                                  strength_of_association)
    mu_rt = Deterministic('mu_rt', pyactr_rt)
    rt_observed = Normal('rt_observed', mu=mu_rt, sd=10, observed=RT)

#with fan_model:
    # Compute posteriors
    #step = pm.SMC(parallel=True)
    #trace = pm.sample(draws=5000, step=step, njobs=1, cores=50)
import matplotlib.pyplot as plt
from pymc3 import Model, Normal, HalfNormal
from pymc3 import NUTS, sample
from scipy import optimize
from pymc3 import traceplot
from pymc3 import summary

#shape = クラスの数の確率変数に、クラスの値を取るデータ数次元のベクトルを入れる操作がありますが
#その詳細な説明は(https://pymc-devs.github.io/pymc3/notebooks/GLM-hierarchical.html)参照

df = pd.read_csv("data-salary-2.txt")
X_data = df.values[:, 0]
Y_data = df.values[:, 1]
Class_data = df.values[:, 2] - 1
n_Class = len(df["KID"].unique())

basic_model = Model()

with basic_model:
    a_0 = Normal('a_0', mu=0, sd=10)
    b_0 = Normal('b_0', mu=0, sd=10)
    s_a = HalfNormal('sigma_a', sd=100)
    s_b = HalfNormal('sigma_b', sd=100)
    s_Y = HalfNormal('sigma_Y', sd=100)

    a = a_0 + Normal('a', mu=0, sd=s_a, shape=n_Class)
    b = b_0 + Normal('b', mu=0, sd=s_b, shape=n_Class)
    mu = a[Class_data] + b[Class_data] * X_data
    Y_obs = Normal('Y_obs', mu=mu, sd=s_Y, observed=Y_data)
    trace = sample(2000)
    summary(trace)
Beispiel #11
0
def mcmc_changepoint(dates,
                     ratings,
                     mcmc_iter=1000,
                     discrete=0,
                     plot_result=1):
    """This function models Yelp reviews as coming from two normal distributions
    with a switch point somewhere between them. When left of the switch point then
    reviews are drawn from the first normal distribution. To the right of the
    switch point reviews are drawn from the second normal distribution. Normal
    distributions are used if the reviews have been normalized to the user's
    average rating; otherwise if analyzing in terms of 1-5 stars set discrete=1
    and the function will do the same estimation on Poisson distributions. This
    function then finds the most likely distribution for where the switchpoint is
    and the most likely parameters for the two generator distributions by using
    Metropolis-Hastings sampling and Hamiltonian Monte Carlo."""

    # dates: Array of dates when the reviews were posted
    # ratings: Array of the ratings given by each review
    # mcmc_iter: How many iterations of the MCMC to run?
    # discrete: Should I use Normal or Poisson distributions to model the ratings?
    # (i.e. are the user-averaged or 1-5 stars)
    # plot_result: Should the function output a plot?

    number_of_ratings = np.arange(0, len(ratings))

    if discrete == 0:
        with Model() as switch_model:
            switchpoint = DiscreteUniform('switchpoint',
                                          lower=0,
                                          upper=len(dates))

            before_intensity = Normal('before_intensity', mu=0, sd=1)
            after_intensity = Normal('after_intensity', mu=0, sd=1)

            intensity = switch(switchpoint >= number_of_ratings,
                               before_intensity, after_intensity)
            sigma = HalfNormal('sigma', sd=1)

            rating = Normal('rating', mu=intensity, sd=sigma, observed=ratings)

    elif discrete == 1:
        with Model() as switch_model:
            switchpoint = DiscreteUniform('switchpoint',
                                          lower=0,
                                          upper=len(dates))

            before_intensity = Exponential('before_intensity', 1)
            after_intensity = Exponential('after_intensity', 1)

            intensity = switch(switchpoint >= number_of_ratings,
                               before_intensity, after_intensity)

            rating = Poisson('rating', intensity, observed=ratings)

    with switch_model:
        trace = sample(mcmc_iter)

    if plot_result == 1:
        traceplot(trace)
        plt.show()

    switch_posterior = trace['switchpoint']
    N_MCs = switch_posterior.shape[0]

    before_intensity_posterior = trace['before_intensity']
    after_intensity_posterior = trace['after_intensity']

    expected_stars = np.zeros(len(ratings))
    for a_rating in number_of_ratings:
        where_switch = a_rating < switch_posterior
        expected_stars[a_rating] = (
            before_intensity_posterior[where_switch].sum() +
            after_intensity_posterior[~where_switch].sum()) / N_MCs

    if plot_result == 1:
        plt.plot(dates, ratings, 'o')
        plt.plot(dates, expected_stars, 'b-')
        plt.show()

    # Return the mode and it's frequency / mcmc_iter
    b_mean, b_count = scipy.stats.mode(trace['before_intensity'])
    a_mean, a_count = scipy.stats.mode(trace['after_intensity'])
    modal_switch, count = scipy.stats.mode(trace['switchpoint'])
    sigma_est, sigma_count = scipy.stats.mode(trace['sigma'])
    differential = b_mean - a_mean
    return differential, modal_switch, expected_stars, sigma_est, switch_posterior
Beispiel #12
0
        for x in zip(LEMMA_CHUNKS, activation_from_time)
    }
    lex_decision.decmem.activations.update(activation_dict)
    sample = run_lex_decision_task()
    return np.array(sample)


lex_decision_with_bayes = pm.Model()
with lex_decision_with_bayes:
    # prior for activation
    decay = Uniform('decay', lower=0, upper=1)
    # priors for accuracy
    noise = Uniform('noise', lower=0, upper=5)
    threshold = Normal('threshold', mu=0, sd=10)
    # priors for latency
    lf = HalfNormal('lf', sd=1)
    le = HalfNormal('le', sd=1)
    # compute activation
    scaled_time = time**(-decay)

    def compute_activation(scaled_time_vector):
        compare = tt.isinf(scaled_time_vector)
        subvector = scaled_time_vector[(1 - compare).nonzero()]
        activation_from_time = tt.log(subvector.sum())
        return activation_from_time

    activation_from_time, _ = theano.scan(fn=compute_activation,
                                          sequences=scaled_time)
    # latency likelihood -- this is where pyactr is used
    pyactr_rt = actrmodel_latency(lf, le, decay, activation_from_time)
    mu_rt = Deterministic('mu_rt', pyactr_rt)
Beispiel #13
0
    # print("predicted RTs:", predicted_ms)

    return predicted_ms


comm = MPI.COMM_WORLD
rank = comm.Get_rank()

N_GROUPS = comm.Get_size()  #Groups used for simulation

if rank == 0:  #master
    parser_model = Model()
    with parser_model:
        # Priors
        latency_exponent = HalfNormal('le', sd=0.3)
        # Likelihood
        pyactr_rt = actrmodel_latency(latency_exponent)
        mu_rt = Deterministic('mu_rt', pyactr_rt)
        rt_observed = Normal('rt_observed', mu=mu_rt, sd=30, observed=RT)
        # Compute posteriors
        #step = pm.SMC()
        #trace = sample(draws=NDRAWS, step=step, njobs=1)
else:
    run_exp(rank)

#dump('parser_model_'+str(NDRAWS)+'_iterations', trace)

with parser_model:
    trace = load('../../data/parser_model_' + str(NDRAWS) + '_iterations')
Beispiel #14
0
#その詳細な説明は(https://pymc-devs.github.io/pymc3/notebooks/GLM-hierarchical.html)参照

basic_model = Model()

with basic_model:
    #グローバルな変数
    b_1 = Normal('b_1', mu=0, sd=10)
    b_2 = Normal('b_2', mu=0, sd=10)
    b_3 = Normal('b_3', mu=0, sd=10)
    b_4 = Normal('b_4', mu=0, sd=10)

    #天気依存変数
    x_weather = b_4 * Weather

    #科目依存変数
    s_c = HalfNormal('s_c', sd=10)
    x_course = Normal('x_course', mu=0, sd=s_c, shape=n_course)
    x_course = x_course[C_ID]

    #学生依存変数
    s_p = HalfNormal('s_p', sd=10)
    b_student_variance = Normal('b_student', mu=0, sd=s_p, shape=n_student)
    x_student = tt.dot(b_2, A) + tt.dot(b_3, Score) + b_student_variance[P_ID]

    #likelihood (NormalをBernoulliにするとNUTSにできないので、分散がほとんどない正規分布で対処.)
    x = b_1 + x_student + x_course + x_weather
    Y_obs = Normal('Y_obs', mu=tt.nnet.sigmoid(x), sd=0.00001, observed=Y)

    #サンプリング
    trace = sample(1000)
    summary(trace)
# -*- coding: utf-8 -*-
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pymc3 import Model, Normal, HalfNormal
from pymc3 import NUTS, sample
from scipy import optimize
from pymc3 import traceplot
from pymc3 import summary

#shape = クラスの数の確率変数に、クラスの値を取るデータ数次元のベクトルを入れる操作がありますが
#その詳細な説明は(https://pymc-devs.github.io/pymc3/notebooks/GLM-hierarchical.html)参照

df = pd.read_csv("data-salary-2.txt")
X_data = df.values[:, 0]
Y_data = df.values[:, 1]
Class_data = df.values[:, 2] - 1
n_Class = len(df["KID"].unique())

basic_model = Model()

with basic_model:
    a = Normal('a', mu=0, sd=10, shape=n_Class)
    b = Normal('b', mu=0, sd=10, shape=n_Class)
    epsilon = HalfNormal('sigma', sd=1)

    #likelihood
    mu = a[Class_data] + b[Class_data] * X_data
    Y_obs = Normal('Y_obs', mu=mu, sd=epsilon, observed=Y_data)
    trace = sample(2000)
    summary(trace)
Beispiel #16
0
            sim.step()
        except simpy.core.EmptySchedule:
            break
        if not counting.goal:
            break
    return np.repeat(
        np.array(last_time),
        size)  #what is outputed -- nparray of simulated time points


basic_model = Model()

with basic_model:

    # Priors for unknown model parameters
    rule_firing = HalfNormal('rule_firing', sd=2)

    sigma = HalfNormal('sigma', sd=1)

    #Deterministic value, found in the model
    mu = model(rule_firing)

    # Likelihood (sampling distribution) of observations
    Normal('Y_obs', mu=mu, sd=sigma, observed=Y)

map_estimate = find_MAP(model=basic_model, fmin=scipy.optimize.fmin_powell)

print(map_estimate)

print("Estimated rule firing:", math.exp(map_estimate['rule_firing_log_']))
TRP = theano.shared(ReferencePeriod)
TBinTimes = theano.shared(ShiftedBinTimes)
#TInterpBasis  = theano.shared(InterpBasis)
#TInterpolatedTime = theano.shared(InterpolatedTime)

TFlatTimes = theano.shared(FlatBinTimes)
FlatData = (ProfileData.flatten())[:useToAs * 1024]

basic_model = Model()

with basic_model:

    # Priors for unknown model parameters
    amplitude = Normal('amplitude', mu=0, sd=10000, shape=useToAs)
    offset = Normal('offset', mu=0, sd=10000, shape=useToAs)
    noise = HalfNormal('noise', sd=10000, shape=useToAs)
    phase = Uniform('phase', lower=0, upper=ReferencePeriod)

    #parameters that define a two gaussian model
    gsep = Savex[1] * ReferencePeriod / 1024
    g1width = Savex[2] * ReferencePeriod / 1024
    g2width = Savex[3] * ReferencePeriod / 1024
    g2amp = Savex[4]

    Tg1width = theano.shared(g1width)
    Tg2width = theano.shared(g2width)
    Tg2amp = theano.shared(g2amp)
    Tgsep = theano.shared(gsep)

    #Calculate the X values for first gaussian, these have to wrap on a period of [-ReferencePeriod/2, ReferencePeriod/2]
    x = TFlatTimes - phase
    """
    parser.model_parameters["latency_factor"] = lf
    parser.model_parameters["latency_exponent"] = le
    parser.model_parameters["rule_firing"] = rf
    parser.model_parameters["eye_mvt_angle_parameter"] = emap
    predicted_rts = run_self_paced_task()
    #print(predicted_rts)
    return predicted_rts


stimuli_csv = load_file(SENTENCES, sep=",")  #sentences with frequencies
sentences = stimuli_csv.groupby(['item', 'label'], sort=False)

parser_with_bayes = pm.Model()
with parser_with_bayes:
    lf = HalfNormal('lf', sd=0.3)
    le = HalfNormal('le', sd=0.5)
    rf = HalfNormal('rf', sd=0.05)
    emap = HalfNormal('emap', sd=1.0)
    # latency likelihood -- this is where pyactr is used
    pyactr_rt = actrmodel_latency(lf, le, rf, emap)
    subj_mu_rt = Deterministic('subj_mu_rt', pyactr_rt[0])
    subj_rt_observed = Normal('subj_rt_observed',
                              mu=subj_mu_rt,
                              sd=10,
                              observed=subj_extraction['rt'])
    obj_mu_rt = Deterministic('obj_mu_rt', pyactr_rt[1])
    obj_rt_observed = Normal('obj_rt_observed',
                             mu=obj_mu_rt,
                             sd=10,
                             observed=obj_extraction['rt'])
Beispiel #19
0
def hmetad_groupLevel(data: dict, sample_model: bool = True, **kwargs):
    """Compute hierachical meta-d' at the subject level.

    This is an internal function. The group level model must be
    called using :py:func:`metadPy.hierarchical.hmetad`.

    Parameters
    ----------
    data : dict
        Response data.
    sample_model : boolean
        If `False`, only the model is returned without sampling.
    **kwargs : keyword arguments
        All keyword arguments are passed to `func::pymc3.sampling.sample`.

    Returns
    -------
    model : :py:class:`pymc3.Model` instance
        The pymc3 model. Encapsulates the variables and likelihood factors.
    trace : :py:class:`pymc3.backends.base.MultiTrace` or
        :py:class:`arviz.InferenceData`
        A `MultiTrace` or `ArviZ InferenceData` object that contains the
        samples.

    References
    ----------
    .. [#] Fleming, S.M. (2017) HMeta-d: hierarchical Bayesian estimation
    of metacognitive efficiency from confidence ratings, Neuroscience of
    Consciousness, 3(1) nix007, https://doi.org/10.1093/nc/nix007
    """
    nSubj = data["nSubj"]
    hits = data["hits"]
    falsealarms = data["falsealarms"]
    s = data["s"]
    n = data["n"]
    counts = data["counts"]
    nRatings = data["nRatings"]
    Tol = data["Tol"]
    cr = data["cr"]
    m = data["m"]

    with Model() as model:

        # hyperpriors on d, c and c2
        mu_c1 = Normal(
            "mu_c1", mu=0, tau=0.01, shape=(1), testval=np.random.rand() * 0.1
        )
        mu_c2 = Normal(
            "mu_c2", mu=0, tau=0.01, shape=(1, 1), testval=np.random.rand() * 0.1
        )
        mu_d1 = Normal(
            "mu_d1", mu=0, tau=0.01, shape=(1), testval=np.random.rand() * 0.1
        )

        sigma_c1 = HalfNormal(
            "sigma_c1", tau=0.01, shape=(1), testval=np.random.rand() * 0.1
        )
        sigma_c2 = HalfNormal(
            "sigma_c2", tau=0.01, shape=(1, 1), testval=np.random.rand() * 0.1
        )
        sigma_d1 = HalfNormal(
            "sigma_d1", tau=0.01, shape=(1), testval=np.random.rand() * 0.1
        )

        # Type 1 priors
        c1_tilde = Normal("c1_tilde", mu=0, sigma=1, shape=(nSubj, 1))
        c1 = Deterministic("c1", mu_c1 + sigma_c1 * c1_tilde)

        d1_tilde = Normal("d1_tilde", mu=0, sigma=1, shape=(nSubj, 1))
        d1 = Deterministic("d1", mu_d1 + sigma_d1 * d1_tilde)

        # TYPE 1 SDT BINOMIAL MODEL
        h = cumulative_normal(d1 / 2 - c1)
        f = cumulative_normal(-d1 / 2 - c1)
        H = Binomial("H", n=s, p=h, observed=hits)
        FA = Binomial("FA", n=n, p=f, observed=falsealarms)

        # Hyperpriors on mRatio
        mu_logMratio = Normal(
            "mu_logMratio", mu=0, tau=1, shape=(1), testval=np.random.rand() * 0.1
        )
        sigma_delta = HalfNormal("sigma_delta", tau=1, shape=(1))

        delta_tilde = Normal("delta_tilde", mu=0, sigma=1, shape=(nSubj, 1))
        delta = Deterministic("delta", sigma_delta * delta_tilde)

        epsilon_logMratio = Beta("epsilon_logMratio", 1, 1, shape=(1))
        logMratio = Deterministic("logMratio", mu_logMratio + epsilon_logMratio * delta)
        mRatio = Deterministic("mRatio", math.exp(logMratio))

        # Type 2 priors
        meta_d = Deterministic("meta_d", mRatio * d1)

        # Specify ordered prior on criteria
        # bounded above and below by Type 1 c1
        cS1_hn = Normal(
            "cS1_hn",
            mu=0,
            sigma=1,
            shape=(nSubj, nRatings - 1),
            testval=np.linspace(-1.5, -0.5, nRatings - 1)
            .reshape(1, nRatings - 1)
            .repeat(nSubj, axis=0),
        )
        cS1 = Deterministic("cS1", -mu_c2 + (cS1_hn * sigma_c2))

        cS2_hn = Normal(
            "cS2_hn",
            mu=0,
            sigma=1,
            shape=(nSubj, nRatings - 1),
            testval=np.linspace(0.5, 1.5, nRatings - 1)
            .reshape(1, nRatings - 1)
            .repeat(nSubj, axis=0),
        )
        cS2 = Deterministic("cS2", mu_c2 + (cS2_hn * sigma_c2))

        # Means of SDT distributions
        S2mu = meta_d / 2
        S1mu = -meta_d / 2

        # Calculate normalisation constants
        C_area_rS1 = cumulative_normal(c1 - S1mu)
        I_area_rS1 = cumulative_normal(c1 - S2mu)
        C_area_rS2 = 1 - cumulative_normal(c1 - S2mu)
        I_area_rS2 = 1 - cumulative_normal(c1 - S1mu)

        # Get nC_rS1 probs
        nC_rS1 = cumulative_normal(cS1 - S1mu) / C_area_rS1
        nC_rS1 = Deterministic(
            "nC_rS1",
            math.concatenate(
                (
                    [
                        cumulative_normal(cS1[:, 0].reshape((nSubj, 1)) - S1mu)
                        / C_area_rS1,
                        nC_rS1[:, 1:] - nC_rS1[:, :-1],
                        (
                            (
                                cumulative_normal(c1 - S1mu)
                                - cumulative_normal(
                                    cS1[:, nRatings - 2].reshape((nSubj, 1)) - S1mu
                                )
                            )
                            / C_area_rS1
                        ),
                    ]
                ),
                axis=1,
            ),
        )

        # Get nI_rS2 probs
        nI_rS2 = (1 - cumulative_normal(cS2 - S1mu)) / I_area_rS2
        nI_rS2 = Deterministic(
            "nI_rS2",
            math.concatenate(
                (
                    [
                        (
                            (1 - cumulative_normal(c1 - S1mu))
                            - (
                                1
                                - cumulative_normal(
                                    cS2[:, 0].reshape((nSubj, 1)) - S1mu
                                )
                            )
                        )
                        / I_area_rS2,
                        nI_rS2[:, :-1]
                        - (1 - cumulative_normal(cS2[:, 1:] - S1mu)) / I_area_rS2,
                        (
                            1
                            - cumulative_normal(
                                cS2[:, nRatings - 2].reshape((nSubj, 1)) - S1mu
                            )
                        )
                        / I_area_rS2,
                    ]
                ),
                axis=1,
            ),
        )

        # Get nI_rS1 probs
        nI_rS1 = (-cumulative_normal(cS1 - S2mu)) / I_area_rS1
        nI_rS1 = Deterministic(
            "nI_rS1",
            math.concatenate(
                (
                    [
                        cumulative_normal(cS1[:, 0].reshape((nSubj, 1)) - S2mu)
                        / I_area_rS1,
                        nI_rS1[:, :-1]
                        + (cumulative_normal(cS1[:, 1:] - S2mu)) / I_area_rS1,
                        (
                            cumulative_normal(c1 - S2mu)
                            - cumulative_normal(
                                cS1[:, nRatings - 2].reshape((nSubj, 1)) - S2mu
                            )
                        )
                        / I_area_rS1,
                    ]
                ),
                axis=1,
            ),
        )

        # Get nC_rS2 probs
        nC_rS2 = (1 - cumulative_normal(cS2 - S2mu)) / C_area_rS2
        nC_rS2 = Deterministic(
            "nC_rS2",
            math.concatenate(
                (
                    [
                        (
                            (1 - cumulative_normal(c1 - S2mu))
                            - (
                                1
                                - cumulative_normal(
                                    cS2[:, 0].reshape((nSubj, 1)) - S2mu
                                )
                            )
                        )
                        / C_area_rS2,
                        nC_rS2[:, :-1]
                        - ((1 - cumulative_normal(cS2[:, 1:] - S2mu)) / C_area_rS2),
                        (
                            1
                            - cumulative_normal(
                                cS2[:, nRatings - 2].reshape((nSubj, 1)) - S2mu
                            )
                        )
                        / C_area_rS2,
                    ]
                ),
                axis=1,
            ),
        )

        # Avoid underflow of probabilities
        nC_rS1 = math.switch(nC_rS1 < Tol, Tol, nC_rS1)
        nI_rS2 = math.switch(nI_rS2 < Tol, Tol, nI_rS2)
        nI_rS1 = math.switch(nI_rS1 < Tol, Tol, nI_rS1)
        nC_rS2 = math.switch(nC_rS2 < Tol, Tol, nC_rS2)

        # TYPE 2 SDT MODEL (META-D)
        # Multinomial likelihood for response counts ordered as c(nR_S1,nR_S2)
        Multinomial(
            "CR_counts",
            cr,
            nC_rS1,
            shape=(nSubj, nRatings),
            observed=counts[:, :nRatings],
        )
        Multinomial(
            "FA_counts",
            FA,
            nI_rS2,
            shape=(nSubj, nRatings),
            observed=counts[:, nRatings : nRatings * 2],
        )
        Multinomial(
            "M_counts",
            m,
            nI_rS1,
            shape=(nSubj, nRatings),
            observed=counts[:, nRatings * 2 : nRatings * 3],
        )
        Multinomial(
            "H_counts",
            H,
            nC_rS2,
            shape=(nSubj, nRatings),
            observed=counts[:, nRatings * 3 : nRatings * 4],
        )

        if sample_model is True:

            trace = sample(return_inferencedata=True, **kwargs)

            return model, trace

        else:
            return model
            sim.step()
        except simpy.core.EmptySchedule:
            break
        if not counting.goal:
            break
    return np.repeat(
        np.array(last_time),
        size)  #what is outputed -- nparray of simulated time points


basic_model = Model()

with basic_model:

    # Priors for unknown model parameters
    rule_firing = HalfNormal('rule_firing', sd=2)

    sigma = HalfNormal('sigma', sd=1)

    #Deterministic value, found in the model
    mu = model(rule_firing)

    # Likelihood (sampling distribution) of observations
    Normal('Y_obs', mu=mu, sd=sigma, observed=Y)

map_estimate = find_MAP(model=basic_model, fmin=scipy.optimize.fmin_powell)

print(map_estimate)

print("Estimated rule firing:", math.exp(map_estimate['rule_firing_log_']))
Beispiel #21
0
def hmetad_subjectLevel(data, sample_model=True, **kwargs):
    """Hierachical Bayesian modeling of meta-d' (subject level).

    This is an internal function. The subject level model must be
    called using :py:func:`metadPy.hierarchical.hmetad`.

    Parameters
    ----------
    data : dict
        Response data.
    sample_model : boolean
        If `False`, only the model is returned without sampling.
    **kwargs : keyword arguments
        All keyword arguments are passed to `func::pymc3.sampling.sample`.

    Returns
    -------
    model : :py:class:`pymc3.Model` instance
        The pymc3 model. Encapsulates the variables and likelihood factors.
    trace : :py:class:`pymc3.backends.base.MultiTrace` or
        :py:class:`arviz.InferenceData`
        A `MultiTrace` or `ArviZ InferenceData` object that contains the
        samples.

    References
    ----------
    .. [#] Fleming, S.M. (2017) HMeta-d: hierarchical Bayesian estimation
    of metacognitive efficiency from confidence ratings, Neuroscience of
    Consciousness, 3(1) nix007, https://doi.org/10.1093/nc/nix007
    """
    nRatings = data["nratings"]
    with Model() as model:

        # Type 1 priors
        c1 = Normal("c1", mu=0.0, tau=2)
        d1 = Normal("d1", mu=0.0, tau=0.5)

        # TYPE 1 SDT BINOMIAL MODEL
        h = cumulative_normal(d1 / 2 - c1)
        f = cumulative_normal(-d1 / 2 - c1)
        H = Binomial("H", data["S"], h, observed=data["H"])
        FA = Binomial("FA", data["N"], f, observed=data["FA"])

        # Type 2 priors
        meta_d = Normal("metad", mu=d1, tau=2)

        # Specify ordered prior on criteria
        # bounded above and below by Type 1 c1
        cS1_hn = HalfNormal(
            "cS1_hn",
            tau=2,
            shape=nRatings - 1,
            testval=np.linspace(1.5, 0.5, nRatings - 1),
        )
        cS1 = Deterministic("cS1", -cS1_hn + (c1 - data["Tol"]))

        cS2_hn = HalfNormal(
            "cS2_hn",
            tau=2,
            shape=nRatings - 1,
            testval=np.linspace(0.5, 1.5, nRatings - 1),
        )
        cS2 = Deterministic("cS2", cS2_hn + (c1 - data["Tol"]))

        # Means of SDT distributions
        S2mu = math.flatten(meta_d / 2, 1)
        S1mu = math.flatten(-meta_d / 2, 1)

        # Calculate normalisation constants
        C_area_rS1 = cumulative_normal(c1 - S1mu)
        I_area_rS1 = cumulative_normal(c1 - S2mu)
        C_area_rS2 = 1 - cumulative_normal(c1 - S2mu)
        I_area_rS2 = 1 - cumulative_normal(c1 - S1mu)

        # Get nC_rS1 probs
        nC_rS1 = cumulative_normal(cS1 - S1mu) / C_area_rS1
        nC_rS1 = Deterministic(
            "nC_rS1",
            math.concatenate(
                (
                    [
                        cumulative_normal(cS1[0] - S1mu) / C_area_rS1,
                        nC_rS1[1:] - nC_rS1[:-1],
                        (
                            (
                                cumulative_normal(c1 - S1mu)
                                - cumulative_normal(cS1[(nRatings - 2)] - S1mu)
                            )
                            / C_area_rS1
                        ),
                    ]
                ),
                axis=0,
            ),
        )

        # Get nI_rS2 probs
        nI_rS2 = (1 - cumulative_normal(cS2 - S1mu)) / I_area_rS2
        nI_rS2 = Deterministic(
            "nI_rS2",
            math.concatenate(
                (
                    [
                        (
                            (1 - cumulative_normal(c1 - S1mu))
                            - (1 - cumulative_normal(cS2[0] - S1mu))
                        )
                        / I_area_rS2,
                        nI_rS2[:-1]
                        - (1 - cumulative_normal(cS2[1:] - S1mu)) / I_area_rS2,
                        (1 - cumulative_normal(cS2[nRatings - 2] - S1mu)) / I_area_rS2,
                    ]
                ),
                axis=0,
            ),
        )

        # Get nI_rS1 probs
        nI_rS1 = (-cumulative_normal(cS1 - S2mu)) / I_area_rS1
        nI_rS1 = Deterministic(
            "nI_rS1",
            math.concatenate(
                (
                    [
                        cumulative_normal(cS1[0] - S2mu) / I_area_rS1,
                        nI_rS1[:-1] + (cumulative_normal(cS1[1:] - S2mu)) / I_area_rS1,
                        (
                            cumulative_normal(c1 - S2mu)
                            - cumulative_normal(cS1[(nRatings - 2)] - S2mu)
                        )
                        / I_area_rS1,
                    ]
                ),
                axis=0,
            ),
        )

        # Get nC_rS2 probs
        nC_rS2 = (1 - cumulative_normal(cS2 - S2mu)) / C_area_rS2
        nC_rS2 = Deterministic(
            "nC_rS2",
            math.concatenate(
                (
                    [
                        (
                            (1 - cumulative_normal(c1 - S2mu))
                            - (1 - cumulative_normal(cS2[0] - S2mu))
                        )
                        / C_area_rS2,
                        nC_rS2[:-1]
                        - ((1 - cumulative_normal(cS2[1:] - S2mu)) / C_area_rS2),
                        (1 - cumulative_normal(cS2[nRatings - 2] - S2mu)) / C_area_rS2,
                    ]
                ),
                axis=0,
            ),
        )

        # Avoid underflow of probabilities
        nC_rS1 = math.switch(nC_rS1 < data["Tol"], data["Tol"], nC_rS1)
        nI_rS2 = math.switch(nI_rS2 < data["Tol"], data["Tol"], nI_rS2)
        nI_rS1 = math.switch(nI_rS1 < data["Tol"], data["Tol"], nI_rS1)
        nC_rS2 = math.switch(nC_rS2 < data["Tol"], data["Tol"], nC_rS2)

        # TYPE 2 SDT MODEL (META-D)
        # Multinomial likelihood for response counts ordered as c(nR_S1,nR_S2)
        Multinomial(
            "CR_counts",
            data["CR"],
            nC_rS1,
            shape=nRatings,
            observed=data["counts"][:nRatings],
        )
        Multinomial(
            "FA_counts",
            FA,
            nI_rS2,
            shape=nRatings,
            observed=data["counts"][nRatings : nRatings * 2],
        )
        Multinomial(
            "M_counts",
            data["M"],
            nI_rS1,
            shape=nRatings,
            observed=data["counts"][nRatings * 2 : nRatings * 3],
        )
        Multinomial(
            "H_counts",
            H,
            nC_rS2,
            shape=nRatings,
            observed=data["counts"][nRatings * 3 : nRatings * 4],
        )

        if sample_model is True:
            trace = sample(
                trace=[meta_d, cS1, cS2], return_inferencedata=True, **kwargs
            )

            return model, trace

        else:
            return model
X['etl_task_time_last7d_sec'] = X['etl_task_time_last7d_sec'].astype('float32')
X_INPUT = shared(X.values)  # numpy array
Y = log(PP[MEASURE]).copy()
Y_OUTPUT = shared(Y.values)  # numpy array

#######################################
# Model definition
# MEASURE = exp(ALPHA)*exp(BETA)**log(X)
# mu = log(MEASURE) = ALPHA+BETA*log(X)
#######################################

with Model() as cost_model:
    # Priors for unknown cost model parameters
    ALPHA = Normal('ALPHA', mu=0, sigma=1000)
    BETA = Normal('BETA', mu=0, sigma=1000, shape=len(ATT))
    SIGMA = HalfNormal('SIGMA', sigma=100)

    # Model
    MU = ALPHA + dot(X_INPUT, BETA)
    NU = Deterministic('NU', Exponential('nu_', 1 / 29))

    # Likelihood (sampling distribution) of observations
    #     Y_OBS = Normal('Y_OBS', mu=mu, sigma=sigma, observed=Y_OUTPUT)
    Y_OBS = StudentT('Y_OBS', mu=MU, sigma=SIGMA, observed=Y_OUTPUT, nu=NU)

with cost_model:
    TRACE = sample(SAMPLES, tune=TUNE, cores=6)
    traceplot(TRACE)

with cost_model:
    Y_PRED = sample_posterior_predictive(TRACE, 1000, cost_model)
Beispiel #23
0
def hmetad_rm1way(data: dict, sample_model: bool = True, **kwargs: int):
    """Compute hierachical meta-d' at the subject level.

    This is an internal function. The repeated measures model must be
    called using :py:func:`metadPy.hierarchical.hmetad`.

    Parameters
    ----------
    data : dict
        Response data.
    sample_model : boolean
        If `False`, only the model is returned without sampling.
    **kwargs : keyword arguments
        All keyword arguments are passed to `func::pymc3.sampling.sample`.

    Returns
    -------
    model : :py:class:`pymc3.Model` instance
        The pymc3 model. Encapsulates the variables and likelihood factors.
    trace : :py:class:`pymc3.backends.base.MultiTrace` or
        :py:class:`arviz.InferenceData`
        A `MultiTrace` or `ArviZ InferenceData` object that contains the
        samples.

    References
    ----------
    .. [#] Fleming, S.M. (2017) HMeta-d: hierarchical Bayesian estimation
    of metacognitive efficiency from confidence ratings, Neuroscience of
    Consciousness, 3(1) nix007, https://doi.org/10.1093/nc/nix007
    """
    nSubj = data["nSubj"]
    nCond = data["nCond"]
    nRatings = data["nRatings"]
    hits = data["hits"].reshape(nSubj, 2)
    falsealarms = data["falsealarms"].reshape(nSubj, 2)
    counts = data["counts"]
    Tol = data["Tol"]
    cr = data["cr"].reshape(nSubj, 2)
    m = data["m"].reshape(nSubj, 2)
    c1 = data["c1"].reshape(nSubj, 2, 1)
    d1 = data["d1"].reshape(nSubj, 2, 1)

    with Model() as model:

        #############
        # Hyperpriors
        #############
        mu_c2 = Normal("mu_c2",
                       tau=0.01,
                       shape=(1, ),
                       testval=np.random.rand() * 0.1)
        sigma_c2 = HalfNormal("sigma_c2",
                              tau=0.01,
                              shape=(1, ),
                              testval=np.random.rand() * 0.1)

        mu_D = Normal("mu_D",
                      tau=0.001,
                      shape=(1),
                      testval=np.random.rand() * 0.1)
        sigma_D = HalfNormal("sigma_D",
                             tau=0.1,
                             shape=(1),
                             testval=np.random.rand() * 0.1)

        mu_Cond1 = Normal("mu_Cond1",
                          mu=0,
                          tau=0.001,
                          shape=(1),
                          testval=np.random.rand() * 0.1)
        sigma_Cond1 = HalfNormal("sigma_Cond1",
                                 tau=0.1,
                                 shape=(1),
                                 testval=np.random.rand() * 0.1)

        #############################
        # Hyperpriors - Subject level
        #############################
        dbase_tilde = Normal(
            "dbase_tilde",
            mu=0,
            sigma=1,
            shape=(nSubj, 1, 1),
        )
        dbase = Deterministic("dbase", mu_D + sigma_D * dbase_tilde)

        Bd_Cond1_tilde = Normal(
            "Bd_Cond1_tilde",
            mu=0,
            sigma=1,
            shape=(nSubj, 1, 1),
        )

        Bd_Cond1 = Deterministic(
            "Bd_Cond1",
            mu_Cond1 + sigma_Cond1 * Bd_Cond1_tilde,
        )

        lambda_logMratio = Gamma(
            "lambda_logMratio",
            alpha=0.001,
            beta=0.001,
            shape=(nSubj, 1, 1),
        )
        sigma_logMratio = Deterministic("sigma_logMratio",
                                        1 / math.sqrt(lambda_logMratio))

        ###############################
        # Hypterprior - Condition level
        ###############################
        mu_regression = [dbase + (Bd_Cond1 * c) for c in range(nCond)]

        log_mRatio_tilde = Normal("log_mRatio_tilde",
                                  mu=0,
                                  sigma=1,
                                  shape=(nSubj, 1, 1))
        log_mRatio = Deterministic(
            "log_mRatio",
            tt.stack(mu_regression, axis=1)[:, :, :, 0] +
            tt.tile(log_mRatio_tilde,
                    (1, 2, 1)) * tt.tile(sigma_logMratio, (1, 2, 1)),
        )

        mRatio = Deterministic("mRatio", tt.exp(log_mRatio))

        # Means of SDT distributions
        metad = Deterministic("metad", mRatio * d1)
        S2mu = Deterministic("S2mu", metad / 2)
        S1mu = Deterministic("S1mu", -metad / 2)

        # TYPE 2 SDT MODEL (META-D)
        # Multinomial likelihood for response counts
        # Specify ordered prior on criteria
        # bounded above and below by Type 1 c
        cS1_hn = Normal(
            "cS1_hn",
            mu=0,
            sigma=1,
            shape=(nSubj, nCond, nRatings - 1),
            testval=np.linspace(-1.5, -0.5, nRatings - 1).reshape(
                1, 1, nRatings - 1).repeat(nSubj, axis=0).repeat(nCond,
                                                                 axis=1),
        )
        cS1 = Deterministic("cS1", -mu_c2 + (cS1_hn * sigma_c2))

        cS2_hn = Normal(
            "cS2_hn",
            mu=0,
            sigma=1,
            shape=(nSubj, nCond, nRatings - 1),
            testval=np.linspace(0.5, 1.5, nRatings - 1).reshape(
                1, 1, nRatings - 1).repeat(nSubj, axis=0).repeat(nCond,
                                                                 axis=1),
        )
        cS2 = Deterministic("cS2", mu_c2 + (cS2_hn * sigma_c2))

        # Calculate normalisation constants
        C_area_rS1 = cumulative_normal(c1 - S1mu)
        I_area_rS1 = cumulative_normal(c1 - S2mu)
        C_area_rS2 = 1 - cumulative_normal(c1 - S2mu)
        I_area_rS2 = 1 - cumulative_normal(c1 - S1mu)

        # Get nC_rS1 probs
        nC_rS1 = cumulative_normal(cS1 - S1mu) / C_area_rS1
        nC_rS1 = Deterministic(
            "nC_rS1",
            math.concatenate(
                ([
                    cumulative_normal(cS1[:, :, 0].reshape((nSubj, 2, 1)) -
                                      S1mu) / C_area_rS1,
                    nC_rS1[:, :, 1:] - nC_rS1[:, :, :-1],
                    ((cumulative_normal(c1 - S1mu) -
                      cumulative_normal(cS1[:, :, (nRatings - 2)].reshape(
                          (nSubj, 2, 1)) - S1mu)) / C_area_rS1),
                ]),
                axis=2,
            ),
        )

        # Get nI_rS2 probs
        nI_rS2 = (1 - cumulative_normal(cS2 - S1mu)) / I_area_rS2
        nI_rS2 = Deterministic(
            "nI_rS2",
            math.concatenate(
                ([
                    ((1 - cumulative_normal(c1 - S1mu)) -
                     (1 - cumulative_normal(cS2[:, :, 0].reshape(
                         (nSubj, nCond, 1)) - S1mu))) / I_area_rS2,
                    nI_rS2[:, :, :-1] -
                    (1 - cumulative_normal(cS2[:, :, 1:] - S1mu)) / I_area_rS2,
                    (1 - cumulative_normal(cS2[:, :, nRatings - 2].reshape(
                        (nSubj, nCond, 1)) - S1mu)) / I_area_rS2,
                ]),
                axis=2,
            ),
        )

        # Get nI_rS1 probs
        nI_rS1 = (-cumulative_normal(cS1 - S2mu)) / I_area_rS1
        nI_rS1 = Deterministic(
            "nI_rS1",
            math.concatenate(
                ([
                    cumulative_normal(cS1[:, :, 0].reshape((nSubj, nCond, 1)) -
                                      S2mu) / I_area_rS1,
                    nI_rS1[:, :, :-1] +
                    (cumulative_normal(cS1[:, :, 1:] - S2mu)) / I_area_rS1,
                    (cumulative_normal(c1 - S2mu) -
                     cumulative_normal(cS1[:, :, nRatings - 2].reshape(
                         (nSubj, nCond, 1)) - S2mu)) / I_area_rS1,
                ]),
                axis=2,
            ),
        )

        # Get nC_rS2 probs
        nC_rS2 = (1 - cumulative_normal(cS2 - S2mu)) / C_area_rS2
        nC_rS2 = Deterministic(
            "nC_rS2",
            math.concatenate(
                ([
                    ((1 - cumulative_normal(c1 - S2mu)) -
                     (1 - cumulative_normal(cS2[:, :, 0].reshape(
                         (nSubj, nCond, 1)) - S2mu))) / C_area_rS2,
                    nC_rS2[:, :, :-1] -
                    ((1 - cumulative_normal(cS2[:, :, 1:] - S2mu)) /
                     C_area_rS2),
                    (1 - cumulative_normal(cS2[:, :, nRatings - 2].reshape(
                        (nSubj, nCond, 1)) - S2mu)) / C_area_rS2,
                ]),
                axis=2,
            ),
        )

        # Avoid underflow of probabilities
        nC_rS1 = math.switch(nC_rS1 < Tol, Tol, nC_rS1)
        nI_rS2 = math.switch(nI_rS2 < Tol, Tol, nI_rS2)
        nI_rS1 = math.switch(nI_rS1 < Tol, Tol, nI_rS1)
        nC_rS2 = math.switch(nC_rS2 < Tol, Tol, nC_rS2)

        for c in range(nCond):
            Multinomial(
                f"CR_counts_{c}",
                n=cr[:, c],
                p=nC_rS1[:, c, :],
                observed=counts[:, c, :nRatings],
                shape=(nSubj, nRatings),
            )
            Multinomial(
                f"H_counts_{c}",
                n=hits[:, c],
                p=nC_rS2[:, c, :],
                observed=counts[:, c, nRatings * 3:nRatings * 4],
                shape=(nSubj, nRatings),
            )
            Multinomial(
                f"FA_counts_{c}",
                n=falsealarms[:, c],
                p=nI_rS2[:, c, :],
                observed=counts[:, c, nRatings:nRatings * 2],
                shape=(nSubj, nRatings),
            )
            Multinomial(
                f"M_counts_{c}",
                n=m[:, c],
                p=nI_rS1[:, c, :],
                observed=counts[:, c, nRatings * 2:nRatings * 3],
                shape=(nSubj, nRatings),
            )

        if sample_model is True:

            trace = sample(return_inferencedata=True, **kwargs)

            return model, trace

        else:
            return model
import theano.tensor as tt

df = pd.read_csv("data/data-conc-2.txt")
df = df.drop("PersonID", axis=1)
Y_nt = df.values
n_patient = Y_nt.shape[0]
times = np.reshape(np.array([1, 2, 4, 8, 12, 24]), (1, -1))

basic_model = Model()

with basic_model:
    #全体平均
    a_0 = Normal('a_0', mu=0, sd=10)
    b_0 = Normal('b_0', mu=0, sd=10)
    #全体分散
    s_ag = HalfNormal('sigma_a', sd=10)
    s_bg = HalfNormal('sigma_b', sd=10)

    #個人パラメータ
    a = Lognormal('a', mu=a_0, sd=s_ag, shape=[n_patient, 1])
    b = Lognormal('b', mu=b_0, sd=s_bg, shape=[n_patient, 1])

    #個人分散
    s_Y = HalfNormal('sigma_Y', sd=10)

    #likelihood
    mu = 1 - tt.exp(-tt.dot(b, times))
    mu = a * mu
    Y_obs = Normal('Y_obs', mu=mu, sd=s_Y, observed=Y_nt)

    #サンプリング
Beispiel #25
0
import math

df = pd.read_csv("../data/data-changepoint.txt")
T = df.values[:100,0].astype(np.float32)
Y = df.values[:100,1].astype(np.float32)
n_times = 100
#n_times = len(df["X"].unique()) #時間の数
basic_model = Model()

#subtensorの使い方↓
#http://deeplearning.net/software/theano/library/tensor/basic.html

with basic_model: 
    #事前分布
    #コーシー分布は逆関数法にて乱数生成
    s_mu =  HalfNormal('s_mu', sd=1) #コーシー分布の分散
    s_Y =  HalfNormal('s_Y', sd=1) #観測誤差
    mu_0 = Normal('mu_0',mu=0, sd=1)  #初期状態
    x = Uniform("x" ,lower=-math.pi/2,upper=math.pi/2, shape=n_times-1)
    
    #Cauchyの誤差process
    c = tt.dot(s_mu,tt.tan(x))
    
    #状態process
    mu = tt.zeros((n_times))
    mu = tt.set_subtensor(mu[0], mu_0)
    for i in range(n_times-1):
        mu = tt.set_subtensor(mu[i+1], mu[i]+c[i])

    #likelihood
    Y_obs = Normal('Y_obs', mu=mu, sd=s_Y, observed=Y)    
Beispiel #26
0
#print X_obs
print C
print U
plt.plot(X_obs[:], np.ones(X_obs.shape), 'o', markersize=8)
plt.show()

# Infer class labels
from pymc3 import Dirichlet, Normal, MvNormal, HalfNormal, Categorical
import theano.tensor

with Model() as gmm:
    C = Dirichlet('mixture_coeff',
                  dirichlet_scale * dirichlet_shape,
                  shape=nclusters)
    S = HalfNormal('S', sd=sd_halfnormal, shape=nclusters)
    U = Normal('mu', mu=mean_prior_mean, sd=mean_prior_sd, shape=nclusters)
    Y = Categorical('labels', p=C, shape=nsamples)
    X = Normal('X', mu=U[Y], sd=S[Y], observed=X_obs)

from pymc3 import find_MAP
map_estimate = find_MAP(model=gmm)
print map_estimate

from pymc3 import NUTS, sample, Slice, Metropolis, ElemwiseCategorical, HamiltonianMC

modified_map_estimate = copy.deepcopy(map_estimate)
modified_map_estimate['mu'] = [
    1 if x < 0.001 else x for x in modified_map_estimate['mu']
]
cluster_data = df.values[:, 3] - 1
n_company = len(df["KID"].unique())
n_cluster = len(df["GID"].unique())

basic_model = Model()

#shape = クラスの数の確率変数に、クラスの値を取るデータ数次元のベクトルを入れる操作がありますが
#その詳細な説明は(https://pymc-devs.github.io/pymc3/notebooks/GLM-hierarchical.html)参照

#model8-5に業界毎の分散を追加
with basic_model:
    #全体平均
    a_0 = Normal('a_0', mu=0, sd=10)
    b_0 = Normal('b_0', mu=0, sd=10)
    #全体分散
    s_ag = HalfNormal('s_ag', sd=100)
    s_bg = HalfNormal('s_bg', sd=100)
    #業界平均
    a_g = Normal('a_g', mu=a_0, sd=s_ag, shape=n_cluster)
    b_g = Normal('b_g', mu=b_0, sd=s_bg, shape=n_cluster)
    #業界毎の誤差分散
    s_a = HalfNormal('sigma_a', sd=100, shape=n_cluster)
    s_a = s_a[cluster_data]
    s_b = HalfNormal('sigma_b', sd=100, shape=n_cluster)
    s_b = s_b[cluster_data]

    #個人の誤差分散
    s_Y = HalfNormal('sigma_Y', sd=100)

    #likelihood
    #b = Normal('b', mu=b_g[cluster_data], sd=s_b)とするとエラーがでる