#Python算法实现-贝叶斯模型-分层模型

最新推荐文章于 2023-10-24 16:47:14 发布
最新推荐文章于 2023-10-24 16:47:14 发布
阅读量2.9k 收藏 16
点赞数 1
原文链接：http://python.jobbole.com/85991/
版权

贝叶斯模型的一个核心优势就是简单灵活，可以实现一个分层模型。这一节将实现和比较整体合并模型和局部融合模型。

import itertools

import matplotlib.pyplot as plt

import numpy as np

import pandas as pd

import pymc3 as pm

import scipy

import scipy.stats as stats

import seaborn.apionly as sns

from IPython.display import Image

from sklearn import preprocessing

%matplotlib inline

plt.style.use('bmh')

colors = ['#348ABD', '#A60628', '#7A68A6', '#467821', '#D55E00', 

          '#CC79A7', '#56B4E9', '#009E73', '#F0E442', '#0072B2']

messages = pd.read_csv('data/hangout_chat_data.csv')

模型合并

让我们采取一种不同的方式来对我的 hangout 聊天回复时间进行建模。我的直觉告诉我回复的快慢与聊天的对象有关。我很可能回复女朋友比回复一个疏远的朋友更快。这样，我可以对每个对话独立建模，对每个对话i估计参数 μi 和 αi。μi=Uniform(0,100)

一个必须考虑的问题是，有些对话相比其他的含有的消息很少。这样，和含有大量消息的对话相比，我们对含有较少消息的对话的回复时间的估计，就具有较大的不确定度。下图表明了每个对话在样本容量上的差异。

ax = messages.groupby('prev_sender')['conversation_id'].size().plot(

    kind='bar', figsize=(12,3), title='Number of messages sent per recipient', color=colors[0])

_ = ax.set_xlabel('Previous Sender')

_ = ax.set_ylabel('Number of messages')

_ = plt.xticks(rotation=45)

640?wx_fmt=png

对于每个对话i中的每条消息j，模型可以表示为：

640?wx_fmt=png

indiv_traces = {}

# Convert categorical variables to integer

le = preprocessing.LabelEncoder()

participants_idx = le.fit_transform(messages['prev_sender'])

participants = le.classes_

n_participants = len(participants)

for p in participants:

    with pm.Model() as model:

        alpha = pm.Uniform('alpha', lower=0, upper=100)

        mu = pm.Uniform('mu', lower=0, upper=100)

        

        data = messages[messages['prev_sender']==p]['time_delay_seconds'].values

        y_est = pm.NegativeBinomial('y_est', mu=mu, alpha=alpha, observed=data)

        y_pred = pm.NegativeBinomial('y_pred', mu=mu, alpha=alpha)

        

        start = pm.find_MAP()

        step = pm.Metropolis()

        trace = pm.sample(20000, step, start=start, progressbar=True)

        

        indiv_traces[p] = trace

Applied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 9.7 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 12.4 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 12.0 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 12.0 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 10.3 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 16.4 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 12.1 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 17.4 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 19.9 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 15.2 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 16.1 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 10.1 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 11.1 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 11.9 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 12.8 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 13.0 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 12.4 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 10.9 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 22.6 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 18.7 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 13.1 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 13.9 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 14.0 secApplied interval-transform to alpha and added transformed alpha_interval to model.

Applied interval-transform to mu and added transformed mu_interval to model.

 [-----------------100%-----------------] 20000 of 20000 complete in 13.6 sec

fig, axs = plt.subplots(3,2, figsize=(12, 6))

axs = axs.ravel()

y_left_max = 2

y_right_max = 2000

x_lim = 60

ix = [3,4,6]

for i, j, p in zip([0,1,2], [0,2,4], participants[ix]):

    axs[j].set_title('Observed: %s' % p)

    axs[j].hist(messages[messages['prev_sender']==p]['time_delay_seconds'].values, range=[0, x_lim], bins=x_lim, histtype='stepfilled')

    axs[j].set_ylim([0, y_left_max])

for i, j, p in zip([0,1,2], [1,3,5], participants[ix]):

    axs[j].set_title('Posterior predictive distribution: %s' % p)

    axs[j].hist(indiv_traces[p].get_values('y_pred'), range=[0, x_lim], bins=x_lim, histtype='stepfilled', color=colors[1])

    axs[j].set_ylim([0, y_right_max])

axs[4].set_xlabel('Response time (seconds)')

axs[5].set_xlabel('Response time (seconds)')

plt.tight_layout()

640?wx_fmt=png

上图显示了3例对话的观测数据分布（左）和后验预测分布（右）。可以看出，不同对话的后验预测分布大不相同。这可能准确反映出对话的特点，也可能是样本容量太小造成的误差。

如果我们把后验预测分布联合起来，我们希望得到的分布和观测数据分布近似，让我们来进行后验预测检验。

combined_y_pred = np.concatenate([v.get_values('y_pred') for k, v in indiv_traces.items()])

x_lim = 60

y_pred = trace.get_values('y_pred')

fig = plt.figure(figsize=(12,6))

fig.add_subplot(211)

fig.add_subplot(211)

_ = plt.hist(combined_y_pred, range=[0, x_lim], bins=x_lim, histtype='stepfilled', color=colors[1])   

_ = plt.xlim(1, x_lim)

_ = plt.ylim(0, 20000)

_ = plt.ylabel('Frequency')

_ = plt.title('Posterior predictive distribution')

fig.add_subplot(212)

_ = plt.hist(messages['time_delay_seconds'].values, range=[0, x_lim], bins=x_lim, histtype='stepfilled')

_ = plt.xlim(0, x_lim)

_ = plt.xlabel('Response time in seconds')

_ = plt.ylim(0, 20)

_ = plt.ylabel('Frequency')

_ = plt.title('Distribution of observed data')

plt.tight_layout()

640?wx_fmt=png

是的，后验预测分布和观测数据的分布近似。但是，我关心的是数据较少的对话，对它们的估计也可能具有较大的方差。一个减小这种风险的方法是分享对话信息，但仍对每个对话单独估计 μi，我们称之为局部融合。

局部融合

就像整体合并模型，局部融合模型对每个对话i都有独自的参数估计。但是，这些参数通过融合参数联系在一起。这反映出，我的不同对话间的response_time有相似之处，就是我本性上倾向于回复快或慢。

640?wx_fmt=png

接着上面的例子，估计负二项分布的参数 μi 和 αi。相比于使用均匀分布作为先验分布，我使用带两个参数（μ，σ）的伽马分布，从而当能够预测 μ 和 σ 的值时，可以引入更多的先验信息到模型中。

首先，我们来看看伽马分布，下面你可以看到，它非常灵活。

mu = [5,25,50]

sd = [3,7,2]

plt.figure(figsize=(11,3))

_ = plt.title('Gamma distribution')

with pm.Model() as model:

    for i, (j, k) in enumerate(zip(mu, sd)):

        samples = pm.Gamma('gamma', mu=j, sd=k).random(size=10**6)

        plt.hist(samples, bins=100, range=(0,60), color=colors[i], alpha=1)

_ = plt.legend(['$mu$ = %s, $sigma$ = %s' % (mu[a], sd[a]) for a in [0,1,2]])

Applied log-transform to gamma and added transformed gamma_log to model.

Applied log-transform to gamma and added transformed gamma_log to model.

Applied log-transform to gamma and added transformed gamma_log to model.

640?wx_fmt=png

局部融合模型可以表示为：

640?wx_fmt=png

640?wx_fmt=png

with pm.Model() as model:

    hyper_alpha_sd = pm.Uniform('hyper_alpha_sd', lower=0, upper=50)

    hyper_alpha_mu = pm.Uniform('hyper_alpha_mu', lower=0, upper=10)

    

    hyper_mu_sd = pm.Uniform('hyper_mu_sd', lower=0, upper=50)

    hyper_mu_mu = pm.Uniform('hyper_mu_mu', lower=0, upper=60)

    

    alpha = pm.Gamma('alpha', mu=hyper_alpha_mu, sd=hyper_alpha_sd, shape=n_participants)

    mu = pm.Gamma('mu', mu=hyper_mu_mu, sd=hyper_mu_sd, shape=n_participants)

    

    y_est = pm.NegativeBinomial('y_est', 

                                mu=mu[participants_idx], 

                                alpha=alpha[participants_idx], 

                                observed=messages['time_delay_seconds'].values)

    

    y_pred = pm.NegativeBinomial('y_pred', 

                                 mu=mu[participants_idx], 

                                 alpha=alpha[participants_idx],

                                 shape=messages['prev_sender'].shape)

    

    start = pm.find_MAP()

    step = pm.Metropolis()

    hierarchical_trace = pm.sample(200000, step, progressbar=True)

Applied interval-transform to hyper_alpha_sd and added transformed hyper_alpha_sd_interval to model.

Applied interval-transform to hyper_alpha_mu and added transformed hyper_alpha_mu_interval to model.

Applied interval-transform to hyper_mu_sd and added transformed hyper_mu_sd_interval to model.

Applied interval-transform to hyper_mu_mu and added transformed hyper_mu_mu_interval to model.

Applied log-transform to alpha and added transformed alpha_log to model.

Applied log-transform to mu and added transformed mu_log to model.

 [-----------------100%-----------------] 200000 of 200000 complete in 593.0 sec

_ = pm.traceplot(hierarchical_trace[120000:], 

                 varnames=['mu','alpha','hyper_mu_mu',

                           'hyper_mu_sd','hyper_alpha_mu',

                           'hyper_alpha_sd'])

640?wx_fmt=png

对 μ 和 α 的估计有多条曲线，每个对话i对应一条。整体合并和局部融合模型的不同之处在于，局部融合模型的参数（μ和 α）拥有一个被所有对话共享的融合参数。这带来两个好处：

  1. 信息在对话间共享，所以对于含有有限样本容量的对话来说，在估计过程中从别的对话处“借”信息来减小估计的方差。

  2. 我们对每个对话单独做了估计，也对所有对话整体做了估计。

我们快速看一下后验预测分布

x_lim = 60

y_pred = hierarchical_trace.get_values('y_pred')[::1000].ravel()

fig = plt.figure(figsize=(12,6))

fig.add_subplot(211)

fig.add_subplot(211)

_ = plt.hist(y_pred, range=[0, x_lim], bins=x_lim, histtype='stepfilled', color=colors[1])   

_ = plt.xlim(1, x_lim)

_ = plt.ylabel('Frequency')

_ = plt.title('Posterior predictive distribution')

fig.add_subplot(212)

_ = plt.hist(messages['time_delay_seconds'].values, range=[0, x_lim], bins=x_lim, histtype='stepfilled')

_ = plt.xlabel('Response time in seconds')

_ = plt.ylabel('Frequency')

_ = plt.title('Distribution of observed data')

plt.tight_layout()

640?wx_fmt=png

收缩效果：合并模型 vs 分层模型

如讨论的那样，局部融合模型中 μ 和 α 享有一个融合参数，通过对话间信息共享，它使得参数的估计收缩得更紧密，尤其是对含有少量数据的对话。

下图显示了这种收缩效果，可以看出通过融合参数，参数μ 和 α 是怎样聚集在一起。

hier_mu = hierarchical_trace['mu'][500:].mean(axis=0)

hier_alpha = hierarchical_trace['alpha'][500:].mean(axis=0)

indv_mu = [indiv_traces[p]['mu'][500:].mean() for p in participants]

indv_alpha = [indiv_traces[p]['alpha'][500:].mean() for p in participants]

fig = plt.figure(figsize=(8, 6))

ax = fig.add_subplot(111, xlabel='mu', ylabel='alpha', 

                     title='Pooled vs. Partially Pooled Negative Binomial Model', 

                     xlim=(5, 45), ylim=(0, 10))

ax.scatter(indv_mu, indv_alpha, c=colors[5], s=50, label = 'Pooled', zorder=3)

ax.scatter(hier_mu, hier_alpha, c=colors[6], s=50, label = 'Partially Pooled', zorder=4)

for i in range(len(indv_mu)):  

    ax.arrow(indv_mu[i], indv_alpha[i], hier_mu[i] - indv_mu[i], hier_alpha[i] - indv_alpha[i], 

            fc="grey", ec="grey", length_includes_head=True, alpha=.5, head_width=0)

_ = ax.legend()

640?wx_fmt=png

对后验分布提问

我们开始利用贝叶斯统计最好的方面之一——后验分布。不像频率论方法，我们得到完整的后验分布而不是点估计。本质上，我们是得到许多可信的参数值，这使得我们可以按照比较自然直观的方式提问。

What are the chances I’ll respond to my friend in less than 10 seconds?

为了估计这个概率，我们可以看看 Timothy 和 Andrew 的回复时间的后验预测分布，检查有多少样本是小于 10 秒的。当我第一次听到这个方法时，我以为我理解错了，因为它太简单了。

def participant_y_pred(person):

    """Return posterior predictive for person"""

    ix = np.where(participants == person)[0][0]

    return hierarchical_trace['y_pred'][100000:, ix]

print("Here are some samples from Timothy's posterior predictive distribution: n %s" % participant_y_pred('Timothy'))

Here are some samples from Timothy's posterior predictive distribution: 

 [24 24 24 ..., 19 19 19]

def person_plotA(person_name):

    ix_check = participant_y_pred(person_name) > 10

    _ = plt.hist(participant_y_pred(person_name)[~ix_check], range=[0, x_lim], bins=x_lim, histtype='stepfilled', label='<10 seconds')

    _ = plt.hist(participant_y_pred(person_name)[ix_check], range=[0, x_lim], bins=x_lim, histtype='stepfilled', label='>10 seconds')

    _ = plt.title('Posterior predictive ndistribution for %s' % person_name)

    _ = plt.xlabel('Response time')

    _ = plt.ylabel('Frequency')

    _ = plt.legend()

def person_plotB(person_name):

    x = np.linspace(1, 60, num=60)

    num_samples = float(len(participant_y_pred(person_name)))

    prob_lt_x = [100*sum(participant_y_pred(person_name) < i)/num_samples for i in x]

    _ = plt.plot(x, prob_lt_x, color=colors[4])

    _ = plt.fill_between(x, prob_lt_x, color=colors[4], alpha=0.3)

    _ = plt.scatter(10, float(100*sum(participant_y_pred(person_name) < 10))/num_samples, s=180, c=colors[4])

    _ = plt.title('Probability of responding nto %s before time (t)' % person_name)

    _ = plt.xlabel('Response time (t)')

    _ = plt.ylabel('Cumulative probability t')

    _ = plt.ylim(ymin=0, ymax=100)

    _ = plt.xlim(xmin=0, xmax=60)

fig = plt.figure(figsize=(11,6))

_ = fig.add_subplot(221)

person_plotA('Timothy')

_ = fig.add_subplot(222)

person_plotB('Timothy')

_ = fig.add_subplot(223)

person_plotA('Andrew')

_ = fig.add_subplot(224)

person_plotB('Andrew')

plt.tight_layout()

640?wx_fmt=png

participant_y_pred('Andrew')

array([13, 13, 13, ..., 28, 28, 28])

我发现这个方法非常直观而且灵活。上图左边根据大于 10 秒或小于 10 秒把后验预测的样本分为两部分，通过计算小于 10 的样本比例来计算概率。右边的图对回复时间小于每个 0 到 60 间的值的概率进行了计算。所以，看起来，Timothy 和 Andrew 分别有 3% 和 4% 的可能性在 10 秒内得到回复。

我的朋友们两两之间比较如何呢？

def prob_persona_faster(persona, personb):

    return sum(participant_y_pred(persona) < participant_y_pred(personb))/len(participant_y_pred(persona))

print("Probability that Tom is responded to faster than Andrew: {:.2%}".format(prob_persona_faster('Tom', 'Andrew')))

640?wx_fmt=png

# Create an empty dataframe

ab_dist_df = pd.DataFrame(index=participants, columns=participants, dtype=np.float)

# populate each cell in dataframe with persona_less_personb()

for a, b in itertools.permutations(participants, 2):

    ab_dist_df.ix[a, b] = prob_persona_faster(a, b)

    

# populate the diagonal

for a in participants:

    ab_dist_df.ix[a, a] = 0.5

# Plot heatmap

f, ax = plt.subplots(figsize=(12, 9))

cmap = plt.get_cmap("Spectral")

_ = sns.heatmap(ab_dist_df, square=True, cmap=cmap)

_ = plt.title('Probability that Person A will be responded to faster than Person B')

_ = plt.ylabel('Person A')

_ = plt.xlabel('Person B')

640?wx_fmt=png

—End—

Pysamlam
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
winbugs14：层次贝叶斯建模软件
07-27
WinBUGS是剑桥公共卫生研究所推出的用马尔可夫链-蒙特卡罗方法进行贝叶斯推理的专用软件包。 GeoBUGS是WinBUGS中一个特别的模块，可以产生和管理空间邻接矩阵、空间条件自回归模型的计算，并为计算的结果提供图形输出功能。
pyglm:具有完全贝叶斯推理算法的可解释神经峰值训练模型
04-30
PyGLM：计数数据的非线性自回归模型的贝叶斯推断 神经回路包含类型，位置，连接性和基本响应属性不同的异类神经元。 但是，传统的降维和聚类方法不适用于恢复神经回路组织基础的结构。 特别是，它们没有利用多神经元记录中丰富的时间相关性，也无法考虑神经尖峰序列中的噪声。 该存储库包含使用多神经元过程模型（通常称为广义线性模型（GLM））的分层扩展从同时记录的峰值序列数据推断潜在结构的工具。 在统计和时间序列分析社区中，这些对应于带有计数观测值的非线性向量自回归过程。 我们将GLM与灵活的图论先验相结合，以控制潜在特征和神经连接模式之间的关系。 通过\ polyagamma增强对结果模型的完全贝叶斯推断，我们可以对神经元进行分类，并从相关的尖峰序列中推断出电路组织的潜在尺寸。 我们证明了我们的方法在灵长类动物视网膜中的合成数据和多神经元记录中的应用的有效性，揭示了单独的尖峰序列的神经类型和位置的潜
hddm:HDDM是一个python模块，可实现漂移扩散模型的分级贝叶斯参数估计（通过PyMC）
05-13
介绍 作者： Thomas V. Wiecki，Imri Sofer，Mads L.Pedersen，Michael J.Frank 接触： ， ， ， 网站： Github： 邮件列表： 版权： 该文档已放置在公共领域。 执照： HDDM是根据BSD 2许可证发行的。 版本： 0.7.8 目的 HDDM是用于漂移扩散模型（通过PyMC）的分层贝叶斯参数估计的python工具箱。 漂移扩散模型被广泛用于心理学和认知神经科学中以研究决策。 查看有关如何入门的。 可以在下面以及部分和找到更多信息。 特征 使用DDM参数的分层贝叶斯估计（通过PyMC）允许同时估计主题和组参数，其中假定单个主题是从组分布中得出的。 因此，与使用个别受试者最大可能性（即DMAT或fast-dm ）的其他方法相比，当测量的RT值较少时，HDDM应产生更好的估计。 针对速度进行了高度优
BNPSeg:使用HDP-MRF的贝叶斯非参数图像分割
05-13
贝叶斯非参数图像分割 该项目实现了Gibbs采样器，用于在联合分层Dirichlet过程-Markov随机场贝叶斯非参数模型中执行矢量值体素表示的像素级分类（图像分段）。 该模型是为学习肿瘤内分割而开发的。 该模型将整个患者图像中的每个体素放置到可变数量的类别之一中。 HDP的使用保证了所有患者的分类定义相对应，从而允许算法根据人群信息选择适当数量的不同体素表示。 MRF约束置于类分配上，以加强以下假设：在具有显示性的表示（特征向量）下，体素（细胞集合）倾向于将自己组成为更大的簇，而不是将自己分散为小的，不相交的簇。 该算法从整个状态空间向量上的条件分布中抽取样本，以推断潜在类别分配参数和唯一单元格分类的隐式数量。 入门 第一次运行代码很容易，安装所有依赖项后，只需执行以下步骤 克隆仓库： git clone https://github.com/ryanneph/bnp-tumo
bayes-drt:电化学阻抗谱（EIS）数据反演的分层贝叶斯方法
03-09
bayes_drt bayes_drt是一个Python软件包，用于反转电化学阻抗谱（EIS）数据以获得弛豫时间（DRT）的分布和/或扩散时间（DDT）的分布。 bayes_drt实现了分层的贝叶斯模型，以提供经过精确校准的DRT或DDT估计，而无需进行临时调整。 该软件包提供了两种方法来求解模型： 汉密尔顿蒙特卡洛（HMC）采样以估计后验分布，同时提供分布的点估计和可信区间 L-BFGS优化可最大化后验概率，从而提供分布的最大后验（MAP）点估计 使用这些方法，还可以执行多分布反演，例如同时安装DRT和DDT。 这是一项实验性功能，需要进行一些手动调整。 有关示例，请参见教程。 该软件包还提供了普通的和超参数的岭回归方法，这可能对比较或获得分布的初始估计很有用。 超参数岭回归方法是Ciucci和Chen（ ）开发并由Effat和Ciucci（ ）扩展的方法的实现。 ）。
贝叶斯分层模型（Hierarchical Models）
weixin_43172869的博客
03-21 4320
许多统计应用涉及多个参数，这些参数可以通过问题的结构以某种方式被视为相关或连接，这意味着这些参数的联合概率模型应该反映它们的相关性。例如，在一项关于心脏治疗效果的研究中，由于j医院的患者具有生存概率θj，因此可以合理地预期θj​的估计值（代表医院样本）应该相互关联。如果我们使用先验分布，其中θj​的估计值被视为普通种群分布的样本，我们将看到这是以自然的方式实现的。这种应用的一个关键特征是，观测到的数据y ij，在以j为索引的组中以i为索引的单位，可以用来估计θj​的种群分布，即使θj。
分层贝叶斯模型——结构
weixin_30344795的博客
07-13 1973
分层贝叶斯模型 对于一个随机变量序列$Y_{1},...,Y_{n} $，如果在任意排列顺序$\pi $下，其概率密度都满足$p(y_{1},...,y_{n})=p(y_{\pi_{1}},...,y_{\pi_{n}}) $，那么称这些变量是可交换的。当我们缺乏区分这些随机变量的信息时，可交换性是$p(y_{1},...,y_{n}) $的一个合理属性。在这种情况下，各个随机变...
【项目实战】Python实现Naive Bayes贝叶斯分类模型(GaussianNB、MultinomialNB算法)项目实战
京斗码农的博客
11-21 6730
Python实现Naive Bayes贝叶斯分类模型(GaussianNB、MultinomialNB算法)项目实战
使用Python、PyMC3、ArviZ的贝叶斯统计实战开发
weixin_42608414的博客
08-18 7328
统计学中有两个主要学派：频率学派和贝叶斯学派,他们之间有共同点，又有不同点。为了说清楚他们之间的差异，我们从统计推断所使用的三种信息说起。 总体信息 即总体分布或者总体所属分布族给我们的信息,譬如,总体是“正太分布”，那我们就知道它的密度曲线是一条钟形曲线,并且有μ和σ这两个参数，它们分别正太分布的均值和标准差(方差)。总体信息是很重要的信息，为了获取此种信息往往耗资巨大。如美国军方为了获得某种...
Python贝叶斯MCMC：Metropolis-Hastings、Gibbs抽样、分层模型、收敛性评估
最新发布
拓端研究室TRL
10-24 234
全文链接：https://tecdat.cn/?p=33961在常规的马尔可夫链模型中，我们通常感兴趣的是找到一个平衡分布（点击文末“阅读原文”获取完整代码数据）。相关视频MCMC则是反过来思考——我们将平衡分布固定为后验分布：并寻找一种转移核，使其收敛到该平衡分布。岛屿示例首先提供一个示例，以具体展示Metropolis算法的机制，然后探讨为什么它有效。以一个有趣的例子开始，讲述了政治家访问一系...
bnpy:Python 的贝叶斯非参数机器学习
05-29
bnpy ：python 的贝叶斯非参数机器学习。 关于 这个 python 模块提供了在大型数据集上训练流行的聚类模型的代码。 我们专注于基于 Dirichlet 过程的贝叶斯非参数模型，但也提供参数对应模型。 bnpy支持最新的在线学习算法以及标准的离线方法。 我们的目标是提供一个推理平台，使研究人员和从业人员可以轻松比较模型和算法。 支持的概率模型（又名分配模型） 混合模型 FiniteMixtureModel ：固定数量的集群 DPMixtureModel ：无限数量的集群，通过狄利克雷过程 主题模型（又名混合物模型） FiniteTopicModel ：固定数量的主题。 这是潜在狄利克雷分配。 HDPTopicModel ：无限数量的主题，通过分层狄利克雷过程 隐马尔可夫模型 (HMM) FiniteHMM ：具有固定状态数的马尔可夫序列模型 HDPHMM ：具有无限多
用R和WinBUGS实现贝叶斯分级模型
12-15
共享有关R的资源：R和WinBUGS实现贝叶斯分级模型。欢迎下载使用。
没有ggplot这个函数_那些年，我们追过的似然函数【2】贝叶斯估计、MCMC估计法、分层贝叶斯模型...
weixin_39951018的博客
12-07 665
大部分人的爱情不是像柯景腾那样子一股脑的就去追小B了。而是循序渐渐式地慢慢试探，互相表达好感，然后再进一步努力最终走到一起的。所以小A现在要从新手模式进入简单模式，也就是用贝叶斯的思想来优化估计自己的似然函数。贝叶斯回归图示第一，先说一下最基本的贝叶斯估计步骤，还是小A估计似然函数 我们要把右边的函数拆成两个部分，先验概率部分（prior distribution） 和实际数据部分（eviden...
Numpy_02随机抽样
phacpf123
11-25 699
Numpy_随机抽样 二项分布 random.binomial(n, p, size)； 返回的是n次试验中事件A发生的次数； Size表示做size次的n伯努利试验； 需要注意的是，size可以取(10, 3)等，相当于做10*3次实验，这样就会返回10行3列的矩阵，这个函数其实返回的是一个ndarray数组 array是一个数组，而ndarray是一个类对象； np.array([1,2,3,4]) 如: import numpy as np np.random.seed(20201124) n
层次贝叶斯模型
qq_16236875的博客
10-22 7701
1 概念: 层次贝叶斯模型是具有结构化层次的统计模型，它可以用来为复杂的统计问题建立层次模型从而避免参数过多导致的过拟合问题。 通过贝叶斯方法来估计后验分布的参数。 2 推断过程： 我们对层次贝叶斯推断的策略与一般的多参数问题一样，但由于在实际中层次模型的参数很多，所以比较困难，在实际中我们很难画出联合后联合概率分布的图形。但是可以使用近似的基于仿真的方法.运用层次贝叶斯模型主要需要计算所有参赛在已知观察量下的条件后验概率，其推导过程主要包含三个步骤: 1)写出联合后验密度，p(θ, φ|y)，.
分层贝叶斯模型——采样算法
weixin_30836759的博客
07-12 492
1. 蒙特卡洛估计 若$\theta$是要估计的参数，$y_{1},...,y_{n}$是从分布$p(y_{1},...,y_{n}|\theta) $中采样的样本值，假定我们从后验分布$p(\theta|y_{1},...,y_{n})$中独立随机采样$S$个$\theta$值，则$$\theta^{(1)},...,\theta^{(S)}\sim^{i.i.d.}p(\t...
分层贝叶斯模型——应用
weixin_30474613的博客
07-13 5248
One-Shot Learning with a Hierarchical Nonparametric Bayesian Model 该篇文章通过分层贝叶斯模型学习利用单一训练样本来学习完成分类任务，模型通过影响一个类别的均值和方差，可以将已经学到的类别信息用到新的类别当中。模型能够发现如何组合一组类别，将其归属为一个有意义的父类。对一个对象进行分类需要知道在一个合适的特征空间中每一维...
贝叶斯估计及其python实现
qq_45814396的博客
10-08 5226
从估计结果来看，贝叶斯估计对总体均值的估计误差较小。
贝叶斯决策思想的应用与延伸
沈春旭的博客
03-19 3371
1.贝叶斯的应用 以下举一些实际例子来说明贝叶斯方法被运用的普遍性，这里主要集中在机器学习方面，因为我不是学经济的，否则还可以找到一堆经济学的例子。 1.1 中文分词 贝叶斯是机器学习的核心方法之一。比如中文分词领域就用到了贝叶斯。Google 研究员吴军在《数学之美》系列中就有一篇是介绍中文分词的，这里只介绍一下核心的思想，不做赘述，详细请参考吴军的文章。 分词问题的描述为：
分层贝叶斯模型python
07-13
在Python中，可以使用PyMC3库来构建和拟合分层贝叶斯模型。 首先，确保已经安装了PyMC3库。可以使用以下命令安装： ``` pip install pymc3 ``` 接下来，可以使用以下代码示例来构建一个简单的分层贝叶斯模型： `...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值