def setUpClass(cls): schools_code = """\ data { int<lower=0> J; // number of schools real y[J]; // estimated treatment effects real<lower=0> sigma[J]; // s.e. of effect estimates } parameters { real mu; real<lower=0> tau; real eta[J]; } transformed parameters { real theta[J]; for (j in 1:J) theta[j] = mu + tau * eta[j]; } model { eta ~ normal(0, 1); y ~ normal(theta, sigma); }""" cls.schools_dat = {'J': 8, 'y': [28, 8, -3, 7, -1, 1, 18, 12], 'sigma': [15, 10, 16, 11, 9, 11, 10, 18]} cls.model = get_model("schools_model", schools_code)
def test_specify_args(self): y = (0.70, -0.16, 0.77, -1.37, -1.99, 1.35, 0.08, 0.02, -1.48, -0.08, 0.34, 0.03, -0.42, 0.87, -1.36, 1.43, 0.80, -0.48, -1.61, -1.27) code = """ data { int N; real y[N]; } parameters { real mu; real<lower=0> sigma; } model { y ~ normal(mu, sigma); }""" stepsize0 = 0.15 sm = get_model("normal_mu_sigma_model", code) sf = sm.sampling(data=dict(y=y, N=20), iter=200, control=dict(adapt_engaged=False, stepsize=stepsize0)) self.assertEqual(sf.get_sampler_params()[0]['stepsize__'][0], stepsize0) sf2 = stan(fit=sf, iter=20, algorithm='HMC', data=dict(y=y, N=20), control=dict(adapt_engaged=False, stepsize=stepsize0)) self.assertEqual(sf2.get_sampler_params()[0]['stepsize__'][0], stepsize0) sf3 = stan(fit=sf, iter=1, data=dict(y=y, N=20), init=0, chains=1) i_u = sf3.unconstrain_pars(sf3.get_inits()[0]) np.testing.assert_equal(i_u, [0, 0])
def setUpClass(cls): model_code = 'parameters {real y;} model {y ~ normal(0,1);}' cls.model = get_model("standard_normal_model", model_code, model_name="normal1", verbose=True, obfuscate_model_name=False) #model = pystan.StanModel(model_code=model_code) cls.fits = [cls.model.sampling(iter=4000, chains=2, seed=i) for i in range(10)]
def test_stan_args_basic(self): y = np.array([0.70, -0.16, 0.77, -1.37, -1.99, 1.35, 0.08, 0.02, -1.48, -0.08, 0.34, 0.03, -0.42, 0.87, -1.36, 1.43, 0.80, -0.48, -1.61, -1.27]) code = ''' data { int N; real y[N]; } parameters { real mu; real<lower=0> sigma; } model { y ~ normal(mu, sigma); }''' sm = get_model("normal_mu_sigma_model", code) sf = sm.sampling(iter=10, thin=3, data=dict(y=y, N=20)) args = sf.stan_args[0] self.assertEqual(args['iter'], 10) self.assertEqual(args['thin'], 3) self.assertEqual(args['init'], b'random') sampling = args['ctrl']['sampling'] self.assertEqual(sampling['adapt_engaged'], True) self.assertEqual(sampling['adapt_window'], 25) self.assertEqual(sampling['adapt_init_buffer'], 75) self.assertEqual(sampling['adapt_gamma'], 0.05) self.assertEqual(sampling['adapt_delta'], 0.8) self.assertEqual(sampling['adapt_kappa'], 0.75) self.assertEqual(sampling['adapt_t0'], 10)
def setUpClass(cls): model_code = """ data { int<lower=2> K; int<lower=1> D; } parameters { matrix[K,D] beta; } model { for (k in 1:K) for (d in 1:D) beta[k,d] ~ normal((d==2?100:0),1); }""" cls.model = get_model("matrix_normal_model", model_code)
def setUpClass(cls): model_code = """ data { int<lower=2> K; int<lower=1> D; } parameters { matrix[K,D] beta; } model { for (k in 1:K) for (d in 1:D) beta[k,d] ~ normal(if_else(d==2,100, 0),1); }""" cls.model = get_model("matrix_normal_model", model_code)
def test_grad_log(self): y = np.array([0.70, -0.16, 0.77, -1.37, -1.99, 1.35, 0.08, 0.02, -1.48, -0.08, 0.34, 0.03, -0.42, 0.87, -1.36, 1.43, 0.80, -0.48, -1.61, -1.27]) code = ''' data { int N; real y[N]; } parameters { real mu; real<lower=0> sigma; } model { y ~ normal(mu, sigma); }''' def log_prob_fun(mu, log_sigma, adjust=True): sigma = np.exp(log_sigma) lp = -1 * np.sum((y - mu)**2) / (2 * (sigma**2)) - len(y) * np.log(sigma) if adjust: lp = lp + np.log(sigma) return lp def log_prob_grad_fun(mu, log_sigma, adjust=True): sigma = np.exp(log_sigma) g_lsigma = np.sum((y - mu)**2) * sigma**(-2) - len(y) if adjust: g_lsigma = g_lsigma + 1 g_mu = np.sum(y - mu) * sigma**(-2) return (g_mu, g_lsigma) sm = get_model("normal_mu_sigma_model", code) sf = sm.sampling(data=dict(y=y, N=20), iter=200) mu = 0.1 sigma = 2 self.assertEqual(sf.log_prob(sf.unconstrain_pars(dict(mu=mu, sigma=sigma))), log_prob_fun(mu, np.log(sigma))) self.assertEqual(sf.log_prob(sf.unconstrain_pars(dict(mu=mu, sigma=sigma)), False), log_prob_fun(mu, np.log(sigma), adjust=False)) g1 = sf.grad_log_prob(sf.unconstrain_pars(dict(mu=mu, sigma=sigma)), False) np.testing.assert_allclose(g1, log_prob_grad_fun(mu, np.log(sigma), adjust=False))
def setUpClass(cls): model_code = 'parameters {real y;} model {y ~ normal(0,1);}' model = get_model("standard_normal_model", model_code, model_name="normal1", verbose=True, obfuscate_model_name=False) fit = model.sampling() tempfolder = tempfile.mkdtemp() cls.pickle_fit = os.path.join(tempfolder, 'stanfit.pkl') cls.pickle_extract = os.path.join(tempfolder, 'stanextract.pkl') with io.open(cls.pickle_fit, mode="wb") as f: pickle.dump(fit, f) with io.open(cls.pickle_extract, mode="wb") as f: pickle.dump(fit.extract(), f) module_name = model.module.__name__ del model del sys.modules[module_name]
def setUpClass(cls): bernoulli_model_code = """ data { int<lower=0> N; int<lower=0,upper=1> y[N]; } parameters { real<lower=0,upper=1> theta; } model { for (n in 1:N) y[n] ~ bernoulli(theta); } """ cls.bernoulli_data = bernoulli_data = {'N': 10, 'y': [0, 1, 0, 0, 0, 0, 0, 0, 0, 1]} cls.model = model = get_model("bernoulli_model", bernoulli_model_code, model_name="bernoulli") #cls.model = model = pystan.StanModel(model_code=bernoulli_model_code, model_name="bernoulli") cls.fit = model.sampling(data=bernoulli_data)
def setUpClass(cls): stdnorm = """ data { int N; real y[N]; } parameters { real mu; real<lower=0> sigma; } model { y ~ normal(mu, sigma); } """ N = 30 np.random.seed(1) y = np.random.normal(size=N) cls.dat = {'N': N, 'y': y} cls.sm = get_model("normal_mu_sigma_model", stdnorm, verbose=True)
def setUpClass(cls): model_code = """ data { int<lower=2> K; int<lower=1> D; } parameters { matrix[K,D] beta; } model { for (k in 1:K) for (d in 1:D) beta[k,d] ~ normal((d==2?100:0),1); }""" cls.model = get_model("matrix_normal_model", model_code) #cls.model = StanModel(model_code=model_code) control = {"metric": "diag_e"} fit = cls.model.sampling(chains=1, data=dict(K=3, D=4), warmup=1500, iter=1501, control=control, check_hmc_diagnostics=False, seed=14) cls.pos_def_matrix_diag_e = fit.get_inv_metric()[0] cls.stepsize_diag_e = fit.get_stepsize()[0] control = {"metric": "dense_e"} fit = cls.model.sampling(chains=1, data=dict(K=3, D=4), warmup=1500, iter=1501, control=control, check_hmc_diagnostics=False, seed=14) cls.pos_def_matrix_dense_e = fit.get_inv_metric()[0] cls.stepsize_dense_e = fit.get_stepsize()[0]
def test_specify_args(self): y = (0.70, -0.16, 0.77, -1.37, -1.99, 1.35, 0.08, 0.02, -1.48, -0.08, 0.34, 0.03, -0.42, 0.87, -1.36, 1.43, 0.80, -0.48, -1.61, -1.27) code = """ data { int N; real y[N]; } parameters { real mu; real<lower=0> sigma; } model { y ~ normal(mu, sigma); }""" stepsize0 = 0.15 sm = get_model("normal_mu_sigma_model", code) sf = sm.sampling(data=dict(y=y, N=20), iter=200, control=dict(adapt_engaged=False, stepsize=stepsize0)) self.assertEqual(sf.get_sampler_params()[0]['stepsize__'][0], stepsize0) sf2 = stan(fit=sf, iter=20, algorithm='HMC', data=dict(y=y, N=20), control=dict(adapt_engaged=False, stepsize=stepsize0)) self.assertEqual(sf2.get_sampler_params()[0]['stepsize__'][0], stepsize0) sf3 = stan(fit=sf, iter=1, data=dict(y=y, N=20), init=0, chains=1, control={"adapt_engaged": False}) i_u = sf3.unconstrain_pars(sf3.get_inits()[0]) np.testing.assert_equal(i_u, [0, 0])
def setUpClass(cls): model_code = 'parameters {real y;} model {y ~ normal(0,1);}' cls.model = get_model("standard_normal_model", model_code, model_name="normal1", verbose=True, obfuscate_model_name=False)
def setUpClass(cls): model_code = 'parameters {real x;real y;real z;} model {x ~ normal(0,1);y ~ normal(0,1);z ~ normal(0,1);}' cls.model = get_model("standard_normals_model", model_code)
def setUpClass(cls): model_code = 'parameters {real x;real y;real z;} model {x ~ normal(0,1);y ~ normal(0,1);z ~ normal(0,1);}' cls.model = get_model("standard_normals_model", model_code)