1

在 montecarlo 模拟中，我有以下 7 张扑克牌，供 2 名玩家和 3 次不同的 montecarlo 运行。

自我卡：

array([[[  6.,  12.],
    [  1.,   6.],
    [  3.,   3.],
    [  8.,   8.],
    [  1.,   1.],
    [  4.,   4.],
    [  2.,   2.]],

   [[  6.,   7.],
    [  1.,   1.],
    [  3.,   3.],
    [  2.,   2.],
    [ 12.,  12.],
    [  5.,   5.],
    [ 10.,  10.]],

   [[  6.,   3.],
    [  1.,  11.],
    [  2.,   2.],
    [  6.,   6.],
    [ 12.,  12.],
    [  6.,   6.],
    [  7.,   7.]]])

对应的套装是：

自我西装

array([[[ 2.,  1.],
    [ 1.,  2.],
    [ 2.,  2.],
    [ 2.,  2.],
    [ 1.,  1.],
    [ 2.,  2.],
    [ 2.,  2.]],

   [[ 2.,  0.],
    [ 1.,  3.],
    [ 2.,  2.],
    [ 0.,  0.],
    [ 1.,  1.],
    [ 1.,  1.],
    [ 1.,  1.]],

   [[ 2.,  2.],
    [ 1.,  0.],
    [ 3.,  3.],
    [ 2.,  2.],
    [ 1.,  1.],
    [ 1.,  1.],
    [ 1.,  1.]]])

现在我想“合并”数组，将卡片数组扩展到第 4 维，大小为 4：0 包含所有套装==1、1 所有套装==2、2 所有套装==3和 3 所有西装 ==4

我可以轻松创建 4 个不同的数组：

club_cards=(self.suits == 1) * self.cards 
diamond_cards=(self.suits == 2) * self.cards 
heart_cards=(self.suits == 3) * self.cards 
spade_cards=(self.suits == 4) * self.cards

然后将它们堆叠在一起：

stacked_array=np.stack((club_cards,diamond_cards, heart_cards, spade_cards),axis=0)

预期结果的形状为 (4, 3, 8, 2)

array([[[[  1.,  12.],
         [  1.,   1.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-11.,   0.]],

        [[ 12.,  12.],
         [ 10.,  10.],
         [  5.,   5.],
         [  1.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.]],

        [[ 12.,  12.],
         [  7.,   7.],
         [  6.,   6.],
         [  1.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.]]],


       [[[  8.,   8.],
         [  6.,   6.],
         [  4.,   4.],
         [  3.,   3.],
         [  2.,   2.],
         [  0.,   0.],
         [  0.,   0.],
         [ -4.,  -4.]],

        [[  6.,   3.],
         [  3.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [ -6.,  -9.]],

        [[  6.,   6.],
         [  6.,   3.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [ -6.,  -6.]]],


       [[[  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -12.]],

        [[  0.,   1.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -11.]],

        [[  2.,   2.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-10., -10.]]],


       [[[  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -12.]],

        [[  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -12.]],

        [[  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [  0.,   0.],
         [-12., -12.]]]])

虽然在上述情况下这可能是有道理的，但这并不总是可能的，特别是如果有超过 4 个案例需要堆叠在一起，这让我想到了我的问题：

我怎样才能通过广播做到这一点？下面是我的具体问题：

我已经尝试了几件事。

  1. 让我们关注第一步，让布尔值在做花色==np.arange(4) （第二步只是与需要以与花色相同的方式广播的卡片的乘法）。我的理解是我们想为 suits 数组添加一个维度，所以我们不应该用 3 点符号表示这个：self.suits[...,:,:,:]==np.arange(4)？相反，以下似乎几乎可以工作：（self.suits[:,:,:,None]==np.arange(4)除了它在错误的位置添加维度）。以下也不起作用：self.suits[None,:,:,:]==np.arange(4). 如何在第一维中扩展数组，以使结果与上述堆栈中的结果相同？

  2. 在什么情况下我需要...和什么时候None？我希望使用 ，...因为这将表明需要根据需要扩展此维度（在本例中为 4 的大小）？为什么这似乎是不正确的，而是使用 None ？

4

1 回答 1

4

您正在堆叠个人卡片结果axis=0。因此，当移植到基于广播的解决方案时，我们可以在数组中创建这些标量的范围数组，1, 2, 3, 4除4D第一个轴外，所有轴都是单维维度（长度 = 1 的维度）。可以有不同的方法来创建这样的4D数组。一种方法是：np.arange(1,5)[:,None,None,None]，我们创建一个1D数组，np.arange然后简单地添加三个单例暗淡作为最后三个暗淡np.newaxis/None。

4D我们对这个数组执行相等比较b，这将允许内部元素broadcasting沿着b最后三个暗淡。然后，我们将它与原始代码中的方法相乘a，得到所需的输出。

因此，实施将是 -

out = a*(b == np.arange(1,5)[:,None,None,None])

何时/如何使用...（省略号）：

...当尝试将新轴添加到多维数组中并且我们不想指定colons每个暗淡时，我们使用（省略号）。因此，要使最后一个暗淡为单例a的4D数组，我们会这样做 : a[:,:,:,None]。打字太多了！所以，我们用...那里来帮助我们：a[...,None]。请注意，...无论维数如何，都使用此符号。因此，如果a是一个5D数组并在其中添加一个新轴作为最后一个轴，我们会做a[:,:,:,:,:,None]或简单地使用省略号 : a[...,None]。整齐啊！

于 2016-11-02T14:52:40.983 回答