import torch
from torch.distributions import multinomial
from d2l import torch as d2l

# 为了抽取⼀个样本，我们只需传⼊⼀个概率向量。输出是另⼀个相同⻓度的向量：它在索引i处的值是采样结果中i出现的次数。
fair_probs = torch.ones([6]) / 6
# print(fair_probs)   # tensor([0.1667, 0.1667, 0.1667, 0.1667, 0.1667, 0.1667])
print(multinomial.Multinomial(1, fair_probs).sample())  # tensor([0., 0., 1., 0., 0., 0.])

# 如果你运⾏采样器很多次，你会发现每次你都得到随机的值。在估计⼀个骰⼦的公平性时，我们经常希望从
# 同⼀分布中⽣成多个样本。如果⽤Python的for循环来完成这个任务，速度会慢得令⼈难以忍受，因此我们使
# ⽤的函数⽀持同时抽取多个样本，返回我们想要的任意形状的独⽴样本数组。
print(multinomial.Multinomial(10, fair_probs).sample())  # tensor([1., 2., 1., 2., 2., 2.])

# 现在我们知道如何对骰⼦进⾏采样，我们可以模拟1000次投掷。然后，我们可以统计1000次投掷后, 每个数字
# 被投中了多少次。具体来说，我们计算相对频率作为真实概率的估计。
# 将结果存储为32位浮点数以进⾏除法
counts = multinomial.Multinomial(1000, fair_probs).sample()
counts = counts / 1000  # 相对频率作为估计值
print(counts)  # tensor([0.1530, 0.1700, 0.1620, 0.1600, 0.1770, 0.1780])
# 因为我们是从⼀个公平的骰⼦中⽣成的数据，我们知道每个结果都有真实的概率1/6，⼤约是0.167，所以上⾯
# 输出的估计值看起来不错。

# 我们也可以看到这些概率如何随着时间的推移收敛到真实概率。让我们进⾏500组实验，每组抽取10个样本
counts = multinomial.Multinomial(10, fair_probs).sample((500,))
print(counts.shape)  # torch.Size([500, 6])
cum_counts = counts.cumsum(dim=0)   # 沿指定轴逐级累加

estimates = cum_counts / cum_counts.sum(dim=1, keepdims=True)   # 获得概率

# 绘图
d2l.set_figsize((6, 4.5))
for i in range(6):
    # d2l.plt.plot(estimates[:, i].numpy(), label=("P(die=" + str(i + 1) + ")"))
    d2l.plt.plot(estimates[:, i], label=("P(die=" + str(i + 1) + ")"))  # 转不转换成numpy数组都行
d2l.plt.axhline(y=0.167, color='black', linestyle='dashed') # 绘制水平参考线
d2l.plt.gca().set_xlabel('Groups of experiments')
d2l.plt.gca().set_ylabel('Estimated probability')
d2l.plt.legend()    # 设置图例？不设置标签label就显示不出来？
d2l.plt.show()

运行结果：

每条实线对应于骰⼦的6个值中的⼀个，并给出骰⼦在每组实验后出现值的估计概率。当我们通过更多的实验获得更多的数据时，这6条实体曲线向真实概率收敛。

概率论公理（93）

在处理骰⼦掷出时，我们将集合S = {1, 2, 3, 4, 5, 6}称为样本空间（sample space）或结果空间（outcomespace），其中每个元素都是结果（outcome）。事件（event）是来⾃给定样本空间的⼀组结果。例如，“看到
5”（{5}）和“看到奇数”（{1, 3, 5}）都是掷出骰⼦的有效事件。注意，如果随机实验的结果在事件A中，则事件A已经发⽣。也就是说，如果投掷出3点，因为3 ∈ {1, 3, 5}，我们可以说，“看到奇数”的事件发⽣了。形式上，概率（probability）可以被认为是将集合映射到真实值的函数。在给定的样本空间S中，事件A的概率，表⽰为P(A)，满⾜以下属性：

这些也是概率论的公理，由科尔莫⼽罗夫于1933年提出。有了这个公理系统，我们可以避免任何关于随机性
的哲学争论；相反，我们可以⽤数学语⾔严格地推理。例如，让事件A1为整个样本空间，且当所有i > 1时
的Ai = ∅，我们可以证明P(∅) = 0，即不可能发⽣事件的概率是0。

随机变量（94）

在我们掷骰⼦的随机实验中，我们引⼊了随机变量（randomvariable）的概念。随机变量⼏乎可以是任何数量，并且不是确定性的。它可以在随机实验的⼀组可能性中取⼀个值。考虑⼀个随机变量X，其值在掷骰⼦的样本空间S = {1, 2, 3, 4, 5, 6}中。我们可以将事件“看到⼀个5”表⽰为{X = 5}或X = 5，其概率表⽰为P({X = 5})或P(X = 5)。通过P(X = a)，我们区分了随机变量X和X可以采取的值（例如a）。然而，这可能会导致繁琐的表⽰。为了简化符号，⼀⽅⾯，我们可以将P(X)表⽰为随机变量X上的分布（distribution）：

分布告诉我们X获得任意值的概率。另⼀⽅⾯，我们可以简单⽤P(a)表⽰随机变量取值a的概率。由于概率论中的事件是来⾃样本空间的⼀组结果，因此我们可以为随机变量指定值的可取范围。例如，P(1 ≤ X ≤ 3)表⽰事件{1 ≤ X ≤ 3}，即{X = 1, 2, or, 3}的概率。等价地，P(1 ≤ X ≤ 3)表⽰随机变量X从{1, 2, 3}中取值的概率。

数值的可能性量化为密度(density)。（94）

2.6.2 处理多个随机变量（94）

一切不确定的数据都可以理解为随机变量

联合概率（联合）（95）

第⼀个被称为联合概率（joint probability）P(A = a, B = b)。给定任何值a和b,联合概率可以回答,A = a和B =b同时满⾜的概率是多少?请注意，对于任何a和b的取值，P(A = a, B = b) ≤ P(A = a)。这点是确定的，因为要同时发⽣A = a和B = b，A = a就必须发⽣，B = b也必须发⽣（反之亦然）。因此，A = a和B = b同时发⽣的可能性不⼤于A = a或是B = b单独发⽣的可能性。

条件概率（95）

贝叶斯定理（Bayes 定理）（95）

边际化（边缘化）（求和规则）（啥意思，看不懂？看下面关于艾滋病检测的应用！）（95）

独立性（95）

另⼀个要检查的有⽤属性是依赖与独⽴。两个随机变量A和B是独⽴的，意味着事件A的发⽣不会透露有关B事件的发⽣情况的任何信息。在这种情况下，统计学家通常将这⼀点表述为A ⊥ B。根据⻉叶斯定理，⻢上就能同样得到P(A | B) = P(A)。在所有其他情况下，我们称A和B依赖。⽐如，⼀个骰⼦的两次连续抛出是独⽴的。相⽐之下，灯开关的位置和房间的亮度并不是（尽管它们不是具有确定性的，因为总是可能存在灯泡坏掉，电源故障，或者开关故障）。

应⽤（艾滋病二次检测）（96）

记住俩：

示例：艾滋病的检测，

结论：概率违反直觉

2.6.3 期望和差异（97）

为了概括概率分布的关键特征，我们需要⼀些测量⽅法。随机变量 X 的期望（或平均值）表⽰为：

当函数 f(x) 的输⼊是从分布 P 中抽取的随机变量时，f(x) 的期望值为：

在许多情况下，我们希望衡量随机变量 X 与其期望值的偏置。这可以通过⽅差来量化：

它的平⽅根被称为标准差 (standared deviation)。随机变量函数的⽅差衡量的是，当从该随机变量分布中采样不同值 x 时，函数值偏离该函数的期望的程度：

2.6.4 ⼩结（98）

• 我们可以从概率分布中采样。
• 我们可以使⽤联合分布、条件分布、Bayes 定理、边缘化和独立性假设来分析多个随机变量。
• 期望和⽅差为概率分布的关键特征的概括提供了实⽤的度量形式。

2.6.5 练习（98）

我们进⾏了 m = 500 组实验，每组抽取 n = 10 个样本。变化 m 和 n，观察和分析实验结果。
给定两个概率为 P(A) 和 P(B) 的事件，计算 P(A ∪ B) 和 P(A ∩ B) 的上限和下限。（提⽰：使⽤友元图44 来展⽰这些情况。）
假设我们有⼀系列随机变量，例如 A，B 和 C，其中 B 只依赖于 A，而 C 只依赖于 B，你能简化联合
概率 P(A, B, C) 吗？（提⽰：这是⼀个⻢尔可夫链45。）
在 2.6.2节中，第⼀个测试更准确。为什么不运⾏第⼀个测试两次，而是同时运⾏第⼀个和第⼆个测试?

https://discuss.d2l.ai/t/topic/1762

2.7 查阅⽂档（98）

2.7.1 查找模块中的所有函数和类（98）

import torch

print(dir(torch.distributions))
# ['AbsTransform', 'AffineTransform', 'Bernoulli', 'Beta', 'Binomial', 'CatTransform', 'Categorical', 'Cauchy', 'Chi2', 'ComposeTransform', 'ContinuousBernoulli', 'CorrCholeskyTransform', 'Dirichlet', 'Distribution', 'ExpTransform', 'Exponential', 'ExponentialFamily', 'FisherSnedecor', 'Gamma', 'Geometric', 'Gumbel', 'HalfCauchy', 'HalfNormal', 'Independent', 'IndependentTransform', 'Kumaraswamy', 'LKJCholesky', 'Laplace', 'LogNormal', 'LogisticNormal', 'LowRankMultivariateNormal', 'LowerCholeskyTransform', 'MixtureSameFamily', 'Multinomial', 'MultivariateNormal', 'NegativeBinomial', 'Normal', 'OneHotCategorical', 'OneHotCategoricalStraightThrough', 'Pareto', 'Poisson', 'PowerTransform', 'RelaxedBernoulli', 'RelaxedOneHotCategorical', 'ReshapeTransform', 'SigmoidTransform', 'SoftmaxTransform', 'StackTransform', 'StickBreakingTransform', 'StudentT', 'TanhTransform', 'Transform', 'TransformedDistribution', 'Uniform', 'VonMises', 'Weibull', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', 'bernoulli', 'beta', 'biject_to', 'binomial', 'categorical', 'cauchy', 'chi2', 'constraint_registry', 'constraints', 'continuous_bernoulli', 'dirichlet', 'distribution', 'exp_family', 'exponential', 'fishersnedecor', 'gamma', 'geometric', 'gumbel', 'half_cauchy', 'half_normal', 'identity_transform', 'independent', 'kl', 'kl_divergence', 'kumaraswamy', 'laplace', 'lkj_cholesky', 'log_normal', 'logistic_normal', 'lowrank_multivariate_normal', 'mixture_same_family', 'multinomial', 'multivariate_normal', 'negative_binomial', 'normal', 'one_hot_categorical', 'pareto', 'poisson', 'register_kl', 'relaxed_bernoulli', 'relaxed_categorical', 'studentT', 'transform_to', 'transformed_distribution', 'transforms', 'uniform', 'utils', 'von_mises', 'weibull']

通常，我们可以忽略以__开始和结束的函数（Python中的特殊对象）或以单个_开始的函数（通常是内部函数）。根据剩余的函数名或属性名，我们可能会猜测这个模块提供了各种⽣成随机数的⽅法，包括从均匀分布（uniform）、正态分布（normal）和多项分布（multinomial）中采样。

2.7.2 查找特定函数和类的⽤法（99）【help()函数】

有关如何使⽤给定函数或类的更具体说明，我们可以调⽤help函数。例如，我们来查看张量ones函数的⽤法。

import torch
help(torch.ones)

运行结果：

Help on built-in function ones:

ones(...)
    ones(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor
    
    Returns a tensor filled with the scalar value `1`, with the shape defined
    by the variable argument :attr:`size`.
    
    Args:
        size (int...): a sequence of integers defining the shape of the output tensor.
            Can be a variable number of arguments or a collection like a list or tuple.
    
    Keyword arguments:
        out (Tensor, optional): the output tensor.
        dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor.
            Default: if ``None``, uses a global default (see :func:`torch.set_default_tensor_type`).
        layout (:class:`torch.layout`, optional): the desired layout of returned Tensor.
            Default: ``torch.strided``.
        device (:class:`torch.device`, optional): the desired device of returned tensor.
            Default: if ``None``, uses the current device for the default tensor type
            (see :func:`torch.set_default_tensor_type`). :attr:`device` will be the CPU
            for CPU tensor types and the current CUDA device for CUDA tensor types.
        requires_grad (bool, optional): If autograd should record operations on the
            returned tensor. Default: ``False``.
    
    Example::
    
        >>> torch.ones(2, 3)
        tensor([[ 1.,  1.,  1.],
                [ 1.,  1.,  1.]])
    
        >>> torch.ones(5)
        tensor([ 1.,  1.,  1.,  1.,  1.])