plt.style.use('seaborn-darkgrid') np.random.seed(314) N = 100 alfa_real = 2.5 beta_real = 0.9 eps_real = np.random.normal(0, 0.5, size= N) x = np.random.normal(10, 1, N) y_real = alfa_real + beta_real * x y = y_real + eps_real data = np.stack((x, y)).T #print(data) with pm.Model() as pearson_model: mu = pm.Normal('mu', mu=data.mean(0), sd = 10, shape = 2) sigma_1 = pm.HalfNormal('sigma_1', 10) sigma_2 = pm.HalfNormal('sigma_2', 10) rho = pm.Uniform('rho', -1, 1) cov = pm.math.stack(([sigma_1**2, sigma_1 * sigma_2 * rho], [sigma_1 * sigma_2 * rho, sigma_2**2])) y_pred = pm.MvNormal('y_pres', mu=mu, cov = cov, observed=data) start = pm.find_MAP() step = pm.NUTS(scaling= start) trace_p = pm.sample(1000, step = step, stsrt = start, njobs=1) pm.traceplot(trace_p) pm.summary(trace_p) plt.savefig('img413.png')
model = pm.Model() n_data = social_distance.shape[0] t = np.arange(n_data) with model: # Weakly informative priors on the parameters gamma = pm.Normal('gamma', mu=0, sigma=10, shape=(4, 3)) mu = pm.Normal('mu', mu=0, sigma=10, shape=3) sigma = pm.MatrixNormal('sigma', mu=np.eye(3), rowcov=np.eye(3) * 10, colcov=np.eye(3) * 10, shape=(3, 3)) # Define relationships amongst the params eta = pm.MvNormal('eta', mu=np.zeros(3), cov=sigma, shape=3) mat = social_distance @ gamma beta_0 = mu[0] + mat[:, 0] + eta[0] beta_1 = mu[1] + mat[:, 1] + eta[1] beta_2 = mu[2] + mat[:, 2] + eta[2] lamb = np.exp(beta_0 + beta_1 * t + beta_2 * (t**2)) Y_obs = pm.NegativeBinomial('Y_obs', mu=lamb, alpha=1, observed=death_data) for RV in model.basic_RVs: print(RV.name, RV.logp(model.test_point)) trace = pm.sample()
def __init__(self, name, votes, polls, party_groups, cholesky_matrix, test_results, house_effects_model, min_polls_per_pollster, adjacent_day_fn): super(ElectionDynamicsModel, self).__init__(name) self.votes = votes self.polls = polls self.party_groups = party_groups self.num_parties = polls.num_parties self.num_days = polls.num_days self.num_pollsters = polls.num_pollsters self.max_poll_days = polls.max_poll_days self.num_party_groups = max(self.party_groups) + 1 self.cholesky_matrix = cholesky_matrix if type(adjacent_day_fn) in [int, float]: self.adjacent_day_fn = lambda diff: (1. + diff)**adjacent_day_fn else: self.adjacent_day_fn = adjacent_day_fn self.test_results = (polls.get_last_days_average(10) if test_results is None else test_results) # The base polls model. House-effects models # are optionally set up based on this model. # The innovations are multivariate normal with the same # covariance/cholesky matrix as the polls' MvStudentT # variable. The assumption is that the parties' covariance # is invariant throughout the election campaign and # influences polls, evolving support and election day # vote. self.innovations = pm.MvNormal( 'innovations', mu=np.zeros([self.num_days, self.num_parties]), chol=self.cholesky_matrix, shape=[self.num_days, self.num_parties], testval=np.zeros([self.num_days, self.num_parties])) # The random walk itself is a cumulative sum of the innovations. self.walk = pm.Deterministic('walk', self.innovations.cumsum(axis=0)) # The modeled support of the various parties over time is the sum # of both the election-day votes and the innovations that led up to it. # The support at day 0 is the election day vote. self.support = pm.Deterministic('support', self.votes + self.walk) # In some cases, we might want to filter pollsters without a minimum # number of polls. Because these pollsters produced only a few polls, # we cannot determine whether their results are biased or not. polls_per_pollster = { pollster_id: sum(1 for p in self.polls if p.pollster_id == pollster_id) for pollster_id in range(self.num_pollsters) } self.min_polls_per_pollster = min_polls_per_pollster self.num_pollsters_in_model = 0 self.pollster_mapping = {} for pollster_id, count in polls_per_pollster.items(): if count >= self.min_polls_per_pollster: self.pollster_mapping[ pollster_id] = self.num_pollsters_in_model self.num_pollsters_in_model += 1 else: self.pollster_mapping[pollster_id] = None self.filtered_polls = [ p for p in self.polls if polls_per_pollster[p.pollster_id] >= self.min_polls_per_pollster ] if self.min_polls_per_pollster > 1: print( "Some polls were filtered out. Provided polls: %d, filtered: %d, final total: %d" % (len(self.polls), len(self.polls) - len(self.filtered_polls), len(self.filtered_polls))) # Group polls by number of days. This is necessary to allow generating # a different cholesky matrix for each. This corresponds to the # average of the modeled support used for multi-day polls. group_polls = lambda poll: poll.num_poll_days # Group the polls and create the likelihood variable. self.grouped_polls = [ (num_poll_days, [p for p in polls]) for num_poll_days, polls in itertools.groupby( sorted(self.filtered_polls, key=group_polls), group_polls) ] # To handle multiple-day polls, we average the party support for the # relevant days def expected_poll_outcome(p): if p.num_poll_days > 1: poll_days = [d for d in range(p.end_day, p.start_day + 1)] return self.walk[poll_days].mean(axis=0) else: return self.walk[p.start_day] def expected_polls_outcome(polls): if self.adjacent_day_fn is None: return [expected_poll_outcome(p) for p in polls] + self.votes else: weights = np.asarray([[ sum( self.adjacent_day_fn(abs(d - poll_day)) for poll_day in range(p.end_day, p.start_day + 1)) for d in range(self.num_days) ] for p in polls]) return tt.dot(weights / weights.sum(axis=1, keepdims=True), self.walk + self.votes) self.mus = { num_poll_days: expected_polls_outcome(polls) for num_poll_days, polls in self.grouped_polls } self.create_house_effects(house_effects_model) self.likelihoods = [ # The Multivariate Student-T variable that models the polls. # # The polls are modeled as a MvStudentT distribution which allows to # take into consideration the number of people polled as well as the # cholesky-covariance matrix that is central to the model. # Because we average the support over the number of poll days n, we # also need to appropriately factor the cholesky matrix. We assume # no correlation between different days, so the factor is 1/n for # the variance, and 1/sqrt(n) for the cholesky matrix. pm.MvStudentT('polls_%d_days' % num_poll_days, nu=[p.num_polled - 1 for p in polls], mu=self.mus[num_poll_days], chol=self.cholesky_matrix / np.sqrt(num_poll_days), testval=test_results, shape=[len(polls), self.num_parties], observed=[p.percentages for p in polls]) for num_poll_days, polls in self.grouped_polls ]
def run_model(index, in_dir, out_dir, data_filename, func_filename, struct_filename, dist_filename, kernel, n, sample_size, tune_size): """ index: data in_dir: set up work directory out_dir: save the trace as csv in the out directory data_filename: filename for time series data func_filename: filename for functional connectivity struct_filename: filename for structural connectivity dist_filename: filename for distribution matrix of n ROIs kernel: "exponential" or "gaussian" or "matern52" or "matern32" n: ROI number sample_size: NUTS number tune_size: burning number """ os.chdir(in_dir + str(index)) Y = get_data(data_filename) mFunc = get_func(func_filename, n) Struct = get_struct(struct_filename, n) Dist = get_dist(dist_filename, n) m = Dist[0].shape[0] k = Y.shape[1] n_vec = n * (n + 1) // 2 Y_mean = [] for i in range(n): Y_mean.append(np.mean(Y[i * m:(i + 1) * m, 0])) Y_mean = np.array(Y_mean) with pm.Model() as model_generator: # convariance matrix log_Sig = pm.Uniform("log_Sig", -8, 8, shape=(n, )) SQ = tt.diag(tt.sqrt(tt.exp(log_Sig))) Func_Covm = tt.dot(tt.dot(SQ, mFunc), SQ) Struct_Convm = tt.dot(tt.dot(SQ, Struct), SQ) # double fusion of structural and FC L_fc_vec = tt.reshape( tt.slinalg.cholesky(tt.squeeze(Func_Covm)).T[np.triu_indices(n)], (n_vec, )) L_st_vec = tt.reshape( tt.slinalg.cholesky( tt.squeeze(Struct_Convm)).T[np.triu_indices(n)], (n_vec, )) Struct_vec = tt.reshape(Struct[np.triu_indices(n)], (n_vec, )) lambdaw = pm.Beta("lambdaw", alpha=1, beta=1, shape=(n_vec, )) Kf = pm.Beta("Kf", alpha=1, beta=1, shape=(n_vec, )) rhonn = Kf*( (1-lambdaw)*L_fc_vec + lambdaw*L_st_vec ) + \ (1-Kf)*( (1-Struct_vec*lambdaw)*L_fc_vec + Struct_vec*lambdaw*L_st_vec ) # correlation Cov_temp = tt.triu(tt.ones((n, n))) Cov_temp = tt.set_subtensor(Cov_temp[np.triu_indices(n)], rhonn) Cov_mat_v = tt.dot(Cov_temp.T, Cov_temp) d = tt.sqrt(tt.diagonal(Cov_mat_v)) rho = (Cov_mat_v.T / d).T / d rhoNew = pm.Deterministic("rhoNew", rho[np.triu_indices(n, 1)]) # temporal correlation AR(1) phi_T = pm.Uniform("phi_T", 0, 1, shape=(n, )) sigW_T = pm.Uniform("sigW_T", 0, 100, shape=(n, )) B = pm.Normal("B", 0, 100, shape=(n, )) muW1 = Y_mean - B # get the shifted mean mean_overall = muW1 / (1.0 - phi_T) # AR(1) mean tau_overall = (1.0 - tt.sqr(phi_T)) / tt.sqr(sigW_T) # AR (1) variance W_T = pm.MvNormal("W_T", mu=mean_overall, tau=tt.diag(tau_overall), shape=(k, n)) # add all parts together one_m_vec = tt.ones((m, 1)) one_k_vec = tt.ones((1, k)) D = pm.MvNormal("D", mu=tt.zeros(n), cov=Cov_mat_v, shape=(n, )) phi_s = pm.Uniform("phi_s", 0, 20, shape=(n, )) spat_prec = pm.Uniform("spat_prec", 0, 100, shape=(n, )) H_base = pm.Normal("H_base", 0, 1, shape=(m, n)) Mu_all = tt.zeros((m * n, k)) if kernel == "exponential": for i in range(n): r = Dist[i] * phi_s[i] H_temp = tt.sqr(spat_prec[i]) * tt.exp(-r) L_H_temp = tt.slinalg.cholesky(H_temp) Mu_all_update = tt.set_subtensor(Mu_all[m*i:m*(i+1), :], B[i] + D[i] + one_m_vec*W_T[:,i] + \ tt.dot(L_H_temp, tt.reshape(H_base[:,i], (m, 1)))*one_k_vec) Mu_all = Mu_all_update elif kernel == "gaussian": for i in range(n): r = Dist[i] * phi_s[i] H_temp = tt.sqr(spat_prec[i]) * tt.exp(-tt.sqr(r) * 0.5) L_H_temp = tt.slinalg.cholesky(H_temp) Mu_all_update = tt.set_subtensor(Mu_all[m*i:m*(i+1), :], B[i] + D[i] + one_m_vec*W_T[:,i] + \ tt.dot(L_H_temp, tt.reshape(H_base[:,i], (m, 1)))*one_k_vec) Mu_all = Mu_all_update elif kernel == "matern52": for i in range(n): r = Dist[i] * phi_s[i] H_temp = tt.sqr(spat_prec[i]) * ( (1.0 + tt.sqrt(5.0) * r + 5.0 / 3.0 * tt.sqr(r)) * tt.exp(-1.0 * tt.sqrt(5.0) * r)) L_H_temp = tt.slinalg.cholesky(H_temp) Mu_all_update = tt.set_subtensor(Mu_all[m*i:m*(i+1), :], B[i] + D[i] + one_m_vec*W_T[:,i] + \ tt.dot(L_H_temp, tt.reshape(H_base[:,i], (m, 1)))*one_k_vec) Mu_all = Mu_all_update elif kernel == "matern32": for i in range(n): r = Dist[i] * phi_s[i] H_temp = tt.sqr(spat_prec[i]) * ( 1.0 + tt.sqrt(3.0) * r) * tt.exp(-tt.sqrt(3.0) * r) L_H_temp = tt.slinalg.cholesky(H_temp) Mu_all_update = tt.set_subtensor(Mu_all[m*i:m*(i+1), :], B[i] + D[i] + one_m_vec*W_T[:,i] + \ tt.dot(L_H_temp, tt.reshape(H_base[:,i], (m, 1)))*one_k_vec) Mu_all = Mu_all_update sigma_error_prec = pm.Uniform("sigma_error_prec", 0, 100) Y1 = pm.Normal("Y1", mu=Mu_all, sd=sigma_error_prec, observed=Y) with model_generator: step = pm.NUTS() trace = pm.sample(sample_size, step=step, tune=tune_size, chains=1) # save as pandas format and output the csv file save_trace = pm.trace_to_dataframe(trace) save_trace.to_csv(out_dir + date.today().strftime("%m_%d_%y") + \ "_sample_size_" + str(sample_size) + "_index_" + str(index) + ".csv")
plt.xlabel('$x$', fontsize=16) plt.ylabel('$f(x)$', fontsize=16, rotation=0) plt.savefig('img808.png', dpi=300, figsize=[5.5, 5.5]) plt.figure() with pm.Model() as GP: mu = np.zeros(N) eta = pm.HalfCauchy('eta', 5) rho = pm.HalfCauchy('rho', 5) sigma = pm.HalfCauchy('sigma', 5) D = squared_distance(x, x) K = tt.fill_diagonal(eta * pm.math.exp(-rho * D), eta + sigma) obs = pm.MvNormal('obs', mu, cov=K, observed=y) test_points = np.linspace(0, 10, 100) D_pred = squared_distance(test_points, test_points) D_off_diag = squared_distance(x, test_points) K_oo = eta * pm.math.exp(-rho * D_pred) K_o = eta * pm.math.exp(-rho * D_off_diag) mu_post = pm.Deterministic( 'mu_post', pm.math.dot(pm.math.dot(K_o, tt.nlinalg.matrix_inverse(K)), y)) SIGMA_post = pm.Deterministic( 'SIGMA_post', K_oo - pm.math.dot(pm.math.dot(K_o, tt.nlinalg.matrix_inverse(K)), K_o.T)) trace = pm.sample(1000, njobs=1)
def PPCs(stat, model): sx, sy, st, sdx, sdy, sdt = stat if model == "bm": bm = pm.Model() with bm: D = pm.Lognormal("D", 0, 1) pm.Normal( "like_x", mu=0, sd=tt.sqrt(2 * D * sdt), observed=sdx ) pm.Normal( "like_y", mu=0, sd=tt.sqrt(2 * D * sdt), observed=sdy ) trace_bm = pm.sample(2000, chains=2, cores=1, progressbar=False) ppc_bm = pm.sample_posterior_predictive( trace_bm, model=bm, progressbar=False ) simulated_dx_bm = ppc_bm[bm.observed_RVs[0].name] simulated_dy_bm = ppc_bm[bm.observed_RVs[1].name] simulated_x_bm = np.insert( np.cumsum(simulated_dx_bm, axis=1), 0, 0, axis=1 ) simulated_y_bm = np.insert( np.cumsum(simulated_dy_bm, axis=1), 0, 0, axis=1 ) # ppc in autocorrX, lag=1 pxstd = [] for i in range(4000): pxstd.append(calAutoCorr(simulated_x_bm[i, :], 1)[-1]) fig, axes = plt.subplots(1, 3, figsize=(16, 4)) for i, j in zip(simulated_x_bm[::2, :], simulated_y_bm[::2, :]): axes[0].plot(i, j, alpha=0.2) axes[0].plot(sx, sy, c="k", label="True data") axes[1].hist(simulated_x_bm.std(axis=1), bins=30) axes[2].hist(pxstd, bins=30) axes[2].axvline( x=autoCorrFirstX(sx, sdt), ls="--", c="r", label="data autocorrX" ) axes[1].axvline(x=sx.std(), ls="--", c="r", label="data std in x") axes[0].legend() axes[1].legend() axes[2].legend() axes[0].set_title("PP Samples from BM model and True track") axes[1].set_title("PP Samples std in x") axes[2].set_title("PP Samples autocorrX") if model == "me": model_stick = pm.Model() with model_stick: me = pm.Lognormal("me", 0, 1) _, sig = sticking_covariance(len(sx) - 1, 0, me) pm.MvNormal("likex", mu=0, cov=sig, observed=sx) pm.MvNormal("likey", mu=0, cov=sig, observed=sy) with model_stick: trace_stick = pm.sample(2000, chains=2, cores=1, progressbar=False) # manually generate ppc samples simulated_x_stick, simulated_y_stick = ( np.zeros((4000, len(sx))), np.zeros((4000, len(sx))), ) for i in range(4000): mu1, Sigma1 = sticking_covariance( len(sx) - 1, 0, trace_stick["me"][i] ) x = np.random.multivariate_normal(mu1, Sigma1) mu2, Sigma2 = sticking_covariance( len(sx) - 1, 0, trace_stick["me"][i] ) y = np.random.multivariate_normal(mu2, Sigma2) simulated_x_stick[i, :], simulated_y_stick[i, :] = x, y # ppc in autocorrX, lag=1 pxstd = [] for i in range(4000): pxstd.append(calAutoCorr(simulated_x_stick[i, :], 1)[-1]) fig, axes = plt.subplots(1, 3, figsize=(16, 4)) for i, j in zip(simulated_x_stick[::2, :], simulated_y_stick[::2, :]): axes[0].plot(i, j, alpha=0.2) axes[0].plot(sx, sy, c="k", label="True data") axes[1].hist(pxstd, bins=30) axes[2].hist(simulated_x_stick.std(axis=1), bins=30) axes[1].axvline( x=autoCorrFirstX(sx, sdt), ls="--", c="r", label="data autocorrX" ) axes[2].axvline(x=sx.std(), ls="--", c="r", label="data std in x") axes[0].legend() axes[1].legend() axes[2].legend() axes[0].set_title("PP Samples from Stuck model and True track") axes[1].set_title("PP Samples autocorrX") axes[2].set_title("PP Samples std in x") plt.show() if model == "hpw": model_hpw = pm.Model() with model_hpw: D = pm.Lognormal("D", 0, 1) k = pm.Lognormal("k", 0, 1) mean_x = (-sx[:-1]) * (1 - tt.exp(-k * sdt)) mean_y = (-sy[:-1]) * (1 - tt.exp(-k * sdt)) std = tt.sqrt(D * (1 - tt.exp(-2 * k * sdt)) / k) pm.Normal("like_x", mu=mean_x, sd=std, observed=sdx) pm.Normal("like_y", mu=mean_y, sd=std, observed=sdy) with model_hpw: trace_hpw = pm.sample( 2000, tune=2000, chains=2, cores=1, progressbar=False ) simulated_x_hpw, simulated_y_hpw = ( np.zeros((4000, len(sx))), np.zeros((4000, len(sx))), ) for i in range(trace_hpw["D"].shape[0]): base = base_HPW_D( [0, 0], [i for i in range(len(sx))], trace_hpw["D"][i], [0, 0], trace_hpw["k"][i], ) simulated_x_hpw[i, :], simulated_y_hpw[i, :] = base[0], base[1] pxstd = [] for i in range(4000): pxstd.append(calAutoCorr(simulated_x_hpw[i, :], 1)[-1]) fig, axes = plt.subplots(1, 3, figsize=(16, 4)) for i, j in zip(simulated_x_hpw[::2, :], simulated_y_hpw[::2, :]): axes[0].plot(i, j, alpha=0.2) axes[0].plot(sx, sy, c="k", label="True data") axes[1].hist(pxstd, bins=30) axes[2].hist(simulated_x_hpw.std(axis=1), bins=30) axes[1].axvline( x=autoCorrFirstX(sx, sdt), ls="--", c="r", label="data autocorrX" ) axes[2].axvline(x=sx.std(), ls="--", c="r", label="data std in x") axes[0].legend() axes[1].legend() axes[2].legend() axes[0].set_title("PP Samples from Stuck model and True track") axes[1].set_title("PP Samples autocorrX") axes[2].set_title("PP Samples std in x") plt.show()
def flat_bnn(annInput, errAnnInput, annTarget, errAnnTarget): annInput = theano.shared(annInput) errAnnInput = theano.shared(errAnnInput) annTarget = theano.shared(annTarget) errAnnTarget = theano.shared(errAnnTarget) n_samples = samples['w_in_1_grp'].shape[0] prior_1_mu = samples['w_in_1_grp'].mean(axis=0) bias_1_mu = samples['b_in_1_grp'].mean(axis=0) prior_1_cov = np.cov(samples['w_in_1_grp'].reshape((n_samples, -1)).T) bias_1_cov = np.cov(samples['b_in_1_grp'].reshape((n_samples, -1)).T) prior_1_in_2_mu = samples['w_1_in_2_grp'].mean(axis=0) bias_1_in_2_mu = samples['b_1_in_2_grp'].mean(axis=0) prior_1_in_2_cov = np.cov(samples['w_1_in_2_grp'].reshape( (n_samples, -1)).T) bias_1_in_2_cov = np.cov(samples['b_1_in_2_grp'].reshape( (n_samples, -1)).T) prior_out_mu = samples['w_2_out_grp'].mean(axis=0) bias_out_mu = samples['b_2_out_grp'].mean(axis=0) prior_out_cov = np.cov(samples['w_2_out_grp'].reshape((n_samples, -1)).T) bias_out_cov = np.cov(samples['b_2_out_grp'].reshape((n_samples, -1)).T) with pm.Model() as flat_neural_network: Xs_true = pm.Normal('xtrue', mu=0., sd=20., shape=annInput.shape.eval(), testval=annInput.eval()) # In order to model the correlation structure between the 2D weights, # we flatten them first. Now here we have to reshape to give them their # original 2D shape. weights_in_1 = (pm.MvNormal('w_in_1', prior_1_mu.flatten(), cov=prior_1_cov, shape=prior_1_cov.shape[0]).reshape( (n_data, n_hidden_1))) print(weights_in_1.tag.test_value.shape) bias_in_1 = (pm.MvNormal('bias_in_1', bias_1_mu.flatten(), cov=bias_1_cov, shape=bias_1_cov.shape[0]).reshape( (n_hidden_1, ))) print(weights_in_1.tag.test_value.shape) # Layer 2 weights_1_in_2 = (pm.MvNormal('w_1_in_2', prior_1_in_2_mu.flatten(), cov=prior_1_in_2_cov, shape=prior_1_in_2_cov.shape[0]).reshape( (n_hidden_1, n_hidden_2))) print(weights_1_in_2.tag.test_value.shape) bias_1_in_2 = (pm.MvNormal('bias_1_in_2', bias_1_in_2_mu.flatten(), cov=bias_1_in_2_cov, shape=bias_1_in_2_cov.shape[0]).reshape( (n_hidden_2, ))) print(bias_1_in_2.tag.test_value.shape) # Weights from hidden layer to output weights_2_out = (pm.MvNormal('w_2_out', prior_out_mu.flatten(), cov=prior_out_cov, shape=prior_out_cov.shape[0]).reshape( (n_hidden_2, ))) bias_2_out = (pm.Normal('bias_2_out', mu=bias_out_mu.flatten(), sd=bias_out_cov, shape=(ntargets)).reshape((ntargets, ))) # Build neural-network using relu (informed by hyperas on 2 layers) activation function act_1 = tt.nnet.relu(tt.dot(Xs_true, weights_in_1) + bias_in_1) act_2 = tt.nnet.relu(tt.dot(act_1, weights_1_in_2) + bias_1_in_2) act_out = tt.dot(act_2, weights_2_out) + bias_2_out pred = pm.Deterministic('pred', act_out) likelihood_x = pm.Normal('x', mu=Xs_true, sd=errAnnInput, observed=annInput) out = pm.Normal('out', pred, observed=annTarget, sd=errAnnTarget) return flat_neural_network
jpfont = FontProperties(fname=FontPath) #%% ロジット・モデルからのデータ生成 n = 500 np.random.seed(99) x1 = st.uniform.rvs(loc=-np.sqrt(3.0), scale=2.0 * np.sqrt(3.0), size=n) x2 = st.uniform.rvs(loc=-np.sqrt(3.0), scale=2.0 * np.sqrt(3.0), size=n) q = st.logistic.cdf(0.5 * x1 - 0.5 * x2) y = st.bernoulli.rvs(q) X = np.stack((np.ones(n), x1, x2), axis=1) #%% ロジット・モデルの係数の事後分布の設定 n, k = X.shape b0 = np.zeros(k) A0 = 0.01 * np.eye(k) logit_model = pm.Model() with logit_model: b = pm.MvNormal('b', mu=b0, tau=A0, shape=k) idx = pm.math.dot(X, b) likelihood = pm.Bernoulli('y', logit_p=idx, observed=y) #%% 事後分布からのサンプリング n_draws = 5000 n_chains = 4 n_tune = 1000 with logit_model: trace = pm.sample(draws=n_draws, chains=n_chains, tune=n_tune, random_seed=123) print(pm.summary(trace)) #%% 事後分布のグラフの作成 fig, ax = plt.subplots(k, 2, num=1, figsize=(8, 1.5 * k), facecolor='w') for index in range(k):
""" https://twitter.com/junpenglao/status/928206574845399040 """ import pymc3 as pm import numpy as np import matplotlib.pylab as plt L = np.array([[2, 1]]).T Sigma = L.dot(L.T) + np.diag([1e-2, 1e-2]) L_chol = np.linalg.cholesky(Sigma) with pm.Model() as model: y = pm.MvNormal('y', mu=np.zeros(2), chol=L_chol, shape=2) tr0 = pm.sample(500, chains=1) tr1 = pm.fit(method='advi').sample(500) tr2 = pm.fit(method='fullrank_advi').sample(500) tr3 = pm.fit(method='svgd').sample(500) plt.figure() plt.plot(tr0['y'][:,0], tr0['y'][:,1], 'o', alpha=.1, label='NUTS') plt.plot(tr1['y'][:,0], tr1['y'][:,1], 'o', alpha=.1, label='ADVI') plt.plot(tr2['y'][:,0], tr2['y'][:,1], 'o', alpha=.1, label='FullRank') plt.plot(tr3['y'][:,0], tr3['y'][:,1], 'o', alpha=.1, label='SVGD') plt.legend(); """ https://twitter.com/junpenglao/status/930826259734638598 """ import matplotlib.pylab as plt
def test_show_ld_pymc3(theano_config): with pm.Model(**theano_config) as model: map = starry.Map(udeg=2) map[1:] = pm.MvNormal("u", [0.5, 0.25], np.eye(2), shape=(2, )) map.show(file="tmp.pdf", point=model.test_point) os.remove("tmp.pdf")
plt.savefig('data.png') else: plt.show() # ## First lets fit the background alone... # In[15]: if cpu != 'bear': pm_model = pm.Model() with pm_model: # Background treatment phi = pm.MvNormal('phi', mu=phi_, chol=phi_cholesky, testval=phi_, shape=len(phi_)) # Construct the model fit = mod.model([*init_m[:11], phi]) like = pm.Gamma('like', alpha=1, beta=1.0 / fit, observed=p) trace = pm.sample(target_accept=.99) # In[16]: if cpu != 'bear': pm.summary(trace) # In[17]:
# Citation: http://am207.info/wiki/corr.html for code controlling correlation structure # The parameter nu is the prior on correlation; 0 is uniform, infinity is no corelation nu = pm.Uniform('nu', 1.0, 5.0) # The number of dimensions here is 2: correlation structure is bewteen alpha and beta by district num_factors: int = 2 # Sample the correlation coefficients using the LKJ distribution corr_coeffs = pm.LKJCorr('corr_coeffs', nu, num_factors) # Sample the variances of the single factors sigma_priors = tt.stack([pm.Lognormal('sigma_prior_alpha', mu=0.0, tau=1.0), pm.Lognormal('sigma_prior_beta', mu=0.0, tau=1.0)]) # Make the covariance matrix as a Theano tensor cov = pm.Deterministic('cov', pm_make_cov(sigma_priors, corr_coeffs, num_factors)) # The multivariate Gaussian of (alpha, beta) by district theta_district = pm.MvNormal('theta_district', mu=[0.0, 0.0], cov=cov, shape=(num_districts, num_factors)) # The vector of standard deviations for each variable; size num_factors x num_factors # Citation: efficient generation of sigmas and rhos from cov # https://github.com/aloctavodia/Statistical-Rethinking-with-Python-and-PyMC3/blob/master/Chp_13.ipynb sigmas = pm.Deterministic('sigmas', tt.sqrt(tt.diag(cov))) # correlation matrix (num_factors x num_factors) rhos = pm.Deterministic('rhos', tt.diag(sigmas**-1).dot(cov.dot(tt.diag(sigmas**-1)))) # Extract the standard deviations of alpha and beta, and the correlation coefficient rho sigma_alpha = pm.Deterministic('sigma_alpha', sigmas[0]) sigma_beta = pm.Deterministic('sigma_beta', sigmas[1]) rho = pm.Deterministic('rho', rhos[0, 1]) # Extract alpha_district and beta_district from theta_district alpha_district = pm.Deterministic('alpha_district', theta_district[:,0])
def getmodel(holds={}, mu={}, sig={}, transform=False, nterms=1): params = [ 'logS0', 'logw', 'alpha', 'logsig', 'mean', 'u', 'logrp', 'logrm', 't0p', 't0m' ] for p in params: if p not in holds: holds[p] = None if p not in mu: mu[p] = None if p not in sig: sig[p] = None with pm.Model() as model: logS0 = pm.Normal("logS0", mu=mu["logS0"], sd=sig["logS0"], observed=holds['logS0']) logw = pm.Normal("logw", mu=mu["logw"], sd=sig["logw"], observed=holds['logw']) if np.shape(flux)[0] > 1: alpha = pm.MvNormal("alpha", mu=mu["alpha"], chol=np.diag(sig["alpha"]), shape=np.shape(flux)[0] - 1, observed=holds['alpha']) logsig = pm.MvNormal("logsig", mu=mu["logsig"], chol=np.diag(sig["logsig"]), shape=np.shape(flux)[0], observed=holds['logsig']) mean = pm.MvNormal("mean", mu=mu["mean"], chol=np.diag(sig["mean"]), shape=np.shape(flux)[0], observed=holds['mean']) u = sgp.distributions.MvUniform("u", lower=[0, 0], upper=[1, 1], testval=[0.5, 0.5], observed=holds['u']) if transform: logrp = pm.Uniform("logrp", lower=-20.0, upper=0.0, testval=mu['logrp'], observed=holds['logrp']) logrm = pm.Uniform("logrm", lower=-20.0, upper=0.0, testval=mu['logrm'], observed=holds['logrm']) t0p = pm.Uniform("t0p", lower=t[0], upper=t[-1], testval=mu['t0p'], observed=holds['t0p']) t0m = pm.Uniform("t0m", lower=t[0], upper=t[-1], testval=mu['t0m'], observed=holds['t0m']) else: logrp = pm.Uniform("logrp", lower=-20.0, upper=0.0, testval=mu['logrp'], transform=None, observed=holds['logrp']) logrm = pm.Uniform("logrm", lower=-20.0, upper=0.0, testval=mu['logrm'], transform=None, observed=holds['logrm']) t0p = pm.Uniform("t0p", lower=t[0], upper=t[-1], testval=mu['t0p'], transform=None, observed=holds['t0p']) t0m = pm.Uniform("t0m", lower=t[0], upper=t[-1], testval=mu['t0m'], transform=None, observed=holds['t0m']) orbit = xo.orbits.KeplerianOrbit(period=5.0 * 60 * 60) lcp = (xo.LimbDarkLightCurve(u).get_light_curve( orbit=orbit, r=np.exp(logrp), t=t / (60 * 60) - t0p, texp=np.mean(np.diff(t)) / (60 * 60))) lcm = (xo.LimbDarkLightCurve(u).get_light_curve( orbit=orbit, r=np.exp(logrm), t=t / (60 * 60) - t0m, texp=np.mean(np.diff(t)) / (60 * 60))) mean = mean[:, None] + lcp.T[0] + lcm.T[0] term = xo.gp.terms.SHOTerm(log_S0=logS0, log_w0=logw, log_Q=-np.log(np.sqrt(2))) if np.shape(flux)[0] > 1: a = tt.exp(tt.concatenate([[0.0], alpha])) kernel = sgp.terms.KronTerm(term, alpha=a) else: kernel = term yerr = tt.exp(2 * logsig) yerr = yerr[:, None] * tt.ones(len(t)) if np.shape(flux)[0] > 1: gp = xo.gp.GP(kernel, t, yerr, J=2, mean=sgp.means.KronMean(mean)) else: gp = xo.gp.GP(kernel, t, yerr[0], J=2, mean=mean) marg = gp.marginal("gp", observed=obs.T) return model
beta = pm.Normal('beta', mu=0, sigma=100, shape=X_masked.shape[1]) alpha = pm.HalfCauchy('alpha', beta=5) # impute missing X chol, stds, corr = pm.LKJCholeskyCov('chol', n=X_masked.shape[1], eta=2, sd_dist=pm.Exponential.dist(1), compute_corr=True) cov = pm.Deterministic('cov', chol.dot(chol.T)) X_mu = pm.Normal('X_mu', mu=0, sigma=100, shape=X_masked.shape[1], testval=X_masked.mean(axis=0)) X_modeled = pm.MvNormal('X', mu=X_mu, chol=chol, observed=X_masked) # observation mu_ = intercept + tt.dot(X_modeled, beta) # likelihood mu = tt.exp(mu_) likelihood = pm.Gamma('y', alpha=alpha, beta=alpha / mu, observed=y) # sample trace = pm.sample(4000, tune=1000, chains=2) # summarize results summary_coef = np.quantile(trace.beta, axis=0, q=[0.5, 0.025, 0.25, 0.75, 0.975])
def inference( self, observedData): #figure out properties of beta, gamma of our model import pymc3 as pm import theano.tensor as tt def Smean(Stm1, Itm1, beta, N): return Stm1 - Stm1 * beta * Itm1 / N def Imean(Stm1, Itm1, beta, gamma, N): return Itm1 + Stm1 * Itm1 * beta / N - Itm1 * gamma def Rmean(Rtm1, Itm1, gamma): return Rtm1 + Itm1 * gamma def proposeEpidemic(S0, I0, R, beta, gamma, timesteps=10): pop = {"S": [S0], "I": [I0], "R": [R0]} N = S0 + I0 + R0 for t in range(timesteps - 1): Stm1, Itm1, Rtm1 = pop["S"][-1], pop["I"][-1], pop["R"][-1] St = Smean(Stm1, Itm1, beta, N) It = Imean(Stm1, Itm1, beta, gamma, N) Rt = Rmean(Rtm1, Itm1, gamma) pop['S'].append(St) pop['I'].append(It) pop['R'].append(Rt) return pop['S'], pop['I'], pop['R'] timesteps = len(observedData) S0, I0, R0 = observedData.iloc[0] p = proposeEpidemic(S0, I0, R0, 1., 0.5, timesteps) self.p = p with pm.Model( ) as model: #uses pymc3 to make an object of a model class beta = pm.Normal( 'beta', mu=1, sigma=0.5) #calculate normal distribution of beta and gamma gamma = pm.Normal('gamma', mu=1, sigma=0.5) sigma = pm.Gamma('sigma', 0.5, 0.5) meanS, meanI, meanR = proposeEpidemic(S0, I0, R0, beta, gamma, timesteps) allObs = list(observedData.I.values) + list(observedData.R.values) meanIandMeanR = meanI + meanR obs = pm.MvNormal('obs', observed=allObs, mu=meanIandMeanR, cov=sigma * np.eye(timesteps * 2)) with model: trace = pm.sample(2 * 10**3) self.trace = trace