blocks|key|1578527|text|彼得，这是个多么好的问题。这是你的回答：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1578528|import+numpy+as+np


def+get_broadcast_shape(*shapes):
++++'''
++++Given+a+set+of+array+shapes,+return+the+shape+of+the+output+when+arrays+of+those+
++++shapes+are+broadcast+together
++++'''
++++max_nim+=+max(len(s)+for+s+in+shapes)
++++equal_len_shapes+=+np.array([(1,+)*(max_nim-len(s))%2Bs+for+s+in+shapes])+
++++max_dim_shapes+=+np.max(equal_len_shapes,+axis+=+0)
++++assert+np.all(np.bitwise_or(equal_len_shapes==1,+equal_len_shapes+==+max_dim_shapes[None,+:])),+\
++++++++'Shapes+%25s+are+not+broadcastable+together'+%25+(shapes,+)
++++return+tuple(max_dim_shapes)


def+get_broadcast_indeces(*shapes):
++++'''
++++Given+a+set+of+shapes+of+arrays+that+you+could+broadcast+together,+return:
++++++++output_shape:+The+shape+of+the+resulting+output+array
++++++++broadcast_shape_iterator:+An+iterator+that+returns+a+len(shapes)%2B1+tuple
++++++++++++of+the+indeces+of+each+input+array+and+their+corresponding+index+in+the+
++++++++++++output+array
++++'''
++++output_shape+=+get_broadcast_shape(*shapes)
++++base_iter+=+np.ndindex(output_shape)

++++def+broadcast_shape_iterator():
++++++++for+out_ix+in+base_iter:
++++++++++++in_ixs+=+tuple(tuple(0+if+s[i]+==+1+else+ix+for+i,+ix+in+enumerate(out_ix[-len(s):]))+for+s+in+shapes)
++++++++++++yield+in_ixs+%2B+(out_ix,+)

++++return+output_shape,+broadcast_shape_iterator()


output_shape,+ix_iter+=+get_broadcast_indeces((2,+2,+1),+(2,+3))
assert+output_shape+==+(2,+2,+3)
for+in1_ix,+in_2_ix,+out_ix+in+ix_iter:
++++print+(in1_ix,+in_2_ix,+out_ix)|code-block|syntax|javascript|1578529|返回|1578530|((0,+0,+0),+(0,+0),+(0,+0,+0))
((0,+0,+0),+(0,+1),+(0,+0,+1))
((0,+0,+0),+(0,+2),+(0,+0,+2))
((0,+1,+0),+(1,+0),+(0,+1,+0))
((0,+1,+0),+(1,+1),+(0,+1,+1))
((0,+1,+0),+(1,+2),+(0,+1,+2))
((1,+0,+0),+(0,+0),+(1,+0,+0))
((1,+0,+0),+(0,+1),+(1,+0,+1))
((1,+0,+0),+(0,+2),+(1,+0,+2))
((1,+1,+0),+(1,+0),+(1,+1,+0))
((1,+1,+0),+(1,+1),+(1,+1,+1))
((1,+1,+0),+(1,+2),+(1,+1,+2))|1578531|如果有人知道任何解决这一问题的numpy构建，那就更好了。|1578532|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

What a great question Peter. Here is your answer:

<pre><code>import numpy as np


def get_broadcast_shape(*shapes):
 '''
 Given a set of array shapes, return the shape of the output when arrays of those 
 shapes are broadcast together
 '''
 max_nim = max(len(s) for s in shapes)
 equal_len_shapes = np.array([(1, )*(max_nim-len(s))+s for s in shapes]) 
 max_dim_shapes = np.max(equal_len_shapes, axis = 0)
 assert np.all(np.bitwise_or(equal_len_shapes==1, equal_len_shapes == max_dim_shapes[None, :])), \
 'Shapes %s are not broadcastable together' % (shapes, )
 return tuple(max_dim_shapes)


def get_broadcast_indeces(*shapes):
 '''
 Given a set of shapes of arrays that you could broadcast together, return:
 output_shape: The shape of the resulting output array
 broadcast_shape_iterator: An iterator that returns a len(shapes)+1 tuple
 of the indeces of each input array and their corresponding index in the 
 output array
 '''
 output_shape = get_broadcast_shape(*shapes)
 base_iter = np.ndindex(output_shape)

 def broadcast_shape_iterator():
 for out_ix in base_iter:
 in_ixs = tuple(tuple(0 if s[i] == 1 else ix for i, ix in enumerate(out_ix[-len(s):])) for s in shapes)
 yield in_ixs + (out_ix, )

 return output_shape, broadcast_shape_iterator()


output_shape, ix_iter = get_broadcast_indeces((2, 2, 1), (2, 3))
assert output_shape == (2, 2, 3)
for in1_ix, in_2_ix, out_ix in ix_iter:
 print (in1_ix, in_2_ix, out_ix)
</code></pre>

returns 

<pre><code>((0, 0, 0), (0, 0), (0, 0, 0))
((0, 0, 0), (0, 1), (0, 0, 1))
((0, 0, 0), (0, 2), (0, 0, 2))
((0, 1, 0), (1, 0), (0, 1, 0))
((0, 1, 0), (1, 1), (0, 1, 1))
((0, 1, 0), (1, 2), (0, 1, 2))
((1, 0, 0), (0, 0), (1, 0, 0))
((1, 0, 0), (0, 1), (1, 0, 1))
((1, 0, 0), (0, 2), (1, 0, 2))
((1, 1, 0), (1, 0), (1, 1, 0))
((1, 1, 0), (1, 1), (1, 1, 1))
((1, 1, 0), (1, 2), (1, 1, 2))
</code></pre>

If anyone knows of any numpy builtins that solve this, that would be better though.

blocks|key|1578534|text|import+numpy+as+np
x+=+10*np.arange(4).reshape((2,+2,+1))
y+=+100*np.arange(6).reshape((2,+3))

z+=+np.nditer([x,+y],+flags=['multi_index',+'c_index'],+order='C')
for+a,b+in+z:
++++print(np.unravel_index(z.index+%25+x.size,+x.shape)
++++++++++,+np.unravel_index(z.index+%25+y.size,+y.shape)
++++++++++,+z.multi_index)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1578535|收益率|unstyled|1578536|((0,+0,+0),+(0,+0),+(0,+0,+0))
((0,+1,+0),+(0,+1),+(0,+0,+1))
((1,+0,+0),+(0,+2),+(0,+0,+2))
((1,+1,+0),+(1,+0),+(0,+1,+0))
((0,+0,+0),+(1,+1),+(0,+1,+1))
((0,+1,+0),+(1,+2),+(0,+1,+2))
((1,+0,+0),+(0,+0),+(1,+0,+0))
((1,+1,+0),+(0,+1),+(1,+0,+1))
((0,+0,+0),+(0,+2),+(1,+0,+2))
((0,+1,+0),+(1,+0),+(1,+1,+0))
((1,+0,+0),+(1,+1),+(1,+1,+1))
((1,+1,+0),+(1,+2),+(1,+1,+2))|1578537|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>import numpy as np
x = 10*np.arange(4).reshape((2, 2, 1))
y = 100*np.arange(6).reshape((2, 3))

z = np.nditer([x, y], flags=['multi_index', 'c_index'], order='C')
for a,b in z:
 print(np.unravel_index(z.index % x.size, x.shape)
 , np.unravel_index(z.index % y.size, y.shape)
 , z.multi_index)
</code></pre>

yields

<pre><code>((0, 0, 0), (0, 0), (0, 0, 0))
((0, 1, 0), (0, 1), (0, 0, 1))
((1, 0, 0), (0, 2), (0, 0, 2))
((1, 1, 0), (1, 0), (0, 1, 0))
((0, 0, 0), (1, 1), (0, 1, 1))
((0, 1, 0), (1, 2), (0, 1, 2))
((1, 0, 0), (0, 0), (1, 0, 0))
((1, 1, 0), (0, 1), (1, 0, 1))
((0, 0, 0), (0, 2), (1, 0, 2))
((0, 1, 0), (1, 0), (1, 1, 0))
((1, 0, 0), (1, 1), (1, 1, 1))
((1, 1, 0), (1, 2), (1, 1, 2))
</code></pre>

blocks|key|2457390|text|以下是一个开始：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2457391|array1+=+np.arange(4).reshape(2,2,1)*10
array2+=+np.arange(6).reshape(2,3)

I,+J+=+np.broadcast_arrays(array1,+array2)
print+I.shape
K+=+np.empty(I.shape,+dtype=int)
for+ijk+in+np.ndindex(I.shape):
++++K[ijk]+=+I[ijk]%2BJ[ijk]
print+K|code-block|syntax|javascript|2457392|生产|2457393|(2,+2,+3)++#+broadcasted+shape

[[[+0++1++2]
++[13+14+15]]++++
+[[20+21+22]
++[33+34+35]]]|2457394|I是(2,2,3)，但是它与array1共享数据--它是一个广播视图，而不是副本(看看它的.__array_interface__)。|offset|length|style|CODE|2457395|只要给出这些形状，你就可以在二维上迭代。|2457396|K+=+np.empty(I.shape,+dtype=int)
for+i,j+in+np.ndindex(I.shape[:2]):
++++K[i,j,:]+=+I[i,j,:]%2BJ[i,j,:]
++++print+K[i,j,:]|2457397|通过查看broadcast_arrays和ndindex的代码，可以对其进行细化，以找到必要的部分。例如，在https://stackoverflow.com/a/25097271/901925中，我直接调用nditer来生成multi_index+(一个可以适应于cython的操作)。|2457398|xx+=+np.zeros(y.shape[:2])
it+=+np.nditer(xx,flags=['multi_index'])+++++++++++++++++++++++++++++++
while+not+it.finished:
++++print+y[it.multi_index],
++++it.iternext()
#+[242++14+211]+[198+++7+++0]+[235++60++81]+[164++64+236]|2457399|2457400|要制作几乎没有成本的“虚拟数组”，我可以从ndindex获得线索，并从np.zeros(1)开始制作数组。|2457401|def+make_dummy(shape):
++++x+=+as_strided(np.zeros(1),shape=shape,+strides=np.zeros_like(shape))
++++return+x
array1+=+make_dummy((2,2,1))
array2+=+make_dummy((2,3))|2457402|我可以深入研究np.broadcast_arrays，以了解它如何组合来自2个输入数组的形状，从而生成I的形状。|2457403|2457404|你想要的解决方案和我的有区别，我已经掩盖了。|2457405|(0,+0,+0),+(0,+0),+(0,+0,+0)
(0,+0,+0),+(0,+1),+(0,+0,+1)
...
(1,+1,+0),+(1,+1),+(1,+1,+1)
(1,+1,+0),+(1,+2),+(1,+1,+2)|2457406|期望每个数组都有不同的迭代器元组，一个在(2,2,1)上范围，另一个在(2,3)上，等等。|2457407|我的方法(我认为是numpy+c代码使用的)(至少是基于nditer的部分)在(2,2,3)上生成一个迭代器，并通过as_strided对数组进行传递，以接受更大的范围。这样更容易实现一个通用的广播机制。它将广播复杂度从计算核中分离出来。|2457408|这里是nditer的一个很好的介绍|2457409|http://docs.scipy.org/doc/numpy/reference/arrays.nditer.html|2457410|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/25097271/901925|1^0|0|0|0|0|0|1|2|7|E|6|19|K|0|0|0|4|G|L|7|2W|6|35|B|1I|17|0|0|0|0|L|7|Z|B|0|0|7|J|1F|1|0|0|0|0|K|7|Z|5|0|9|5|S|6|13|7|1M|A|0|3|6|0|0|1O|1|0^^$0|@$1|2|3|4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1T|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1U|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1V|8|@$M|1W|N|1X|O|P]|$M|1Y|N|1Z|O|P]|$M|20|N|21|O|P]|$M|22|N|23|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|24|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|25|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|26|8|@$M|27|N|28|O|P]|$M|29|N|2A|O|P]|$M|2B|N|2C|O|P]|$M|2D|N|2E|O|P]]|9|@$M|2F|N|2G|1|2H]]|A|$]]|$1|W|3|X|5|D|7|2I|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|2J|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2K|8|@$M|2L|N|2M|O|P]|$M|2N|N|2O|O|P]]|9|@]|A|$]]|$1|11|3|12|5|D|7|2P|8|@]|9|@]|A|$E|F]]|$1|13|3|14|5|6|7|2Q|8|@$M|2R|N|2S|O|P]|$M|2T|N|2U|O|P]]|9|@]|A|$]]|$1|15|3|-4|5|6|7|2V|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2W|8|@]|9|@]|A|$]]|$1|18|3|19|5|D|7|2X|8|@]|9|@]|A|$E|F]]|$1|1A|3|1B|5|6|7|2Y|8|@$M|2Z|N|30|O|P]|$M|31|N|32|O|P]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|33|8|@$M|34|N|35|O|P]|$M|36|N|37|O|P]|$M|38|N|39|O|P]|$M|3A|N|3B|O|P]]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|3C|8|@$M|3D|N|3E|O|P]]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|3F|8|@]|9|@$M|3G|N|3H|1|3I]]|A|$]]|$1|1I|3|-4|5|6|7|3J|8|@]|9|@]|A|$]]]|1J|$1K|$5|1L|1M|1N|A|$1O|1P]]|1Q|$5|1L|1M|1N|A|$1O|1H]]]]

Here's a start:

<pre><code>array1 = np.arange(4).reshape(2,2,1)*10
array2 = np.arange(6).reshape(2,3)

I, J = np.broadcast_arrays(array1, array2)
print I.shape
K = np.empty(I.shape, dtype=int)
for ijk in np.ndindex(I.shape):
 K[ijk] = I[ijk]+J[ijk]
print K
</code></pre>

producing

<pre><code>(2, 2, 3) # broadcasted shape

[[[ 0 1 2]
 [13 14 15]] 
 [[20 21 22]
 [33 34 35]]]
</code></pre>

<code>I</code> is <code>(2,2,3)</code>, but shares its data with <code>array1</code> - it's a broadcasted view, not a copy (look at its <code>.__array_interface__</code>).

You can iterate over just 2 dimensions by giving <code>ndindex</code> just those shapes.

<pre><code>K = np.empty(I.shape, dtype=int)
for i,j in np.ndindex(I.shape[:2]):
 K[i,j,:] = I[i,j,:]+J[i,j,:]
 print K[i,j,:]
</code></pre>

It can be refined by looking at the code for <code>broadcast_arrays</code> and <code>ndindex</code> to find the essential pieces. For example in <a href="https://stackoverflow.com/a/25097271/901925">https://stackoverflow.com/a/25097271/901925</a> I call <code>nditer</code> directly to generate a <code>multi_index</code> (an operation which could be adapted to cython).

<pre><code>xx = np.zeros(y.shape[:2])
it = np.nditer(xx,flags=['multi_index']) 
while not it.finished:
 print y[it.multi_index],
 it.iternext()
# [242 14 211] [198 7 0] [235 60 81] [164 64 236]
</code></pre>

<hr>

To make 'dummy arrays' that are virtually costless, I could take a clue from <code>ndindex</code>, and make array starting with <code>np.zeros(1)</code>

<pre><code>def make_dummy(shape):
 x = as_strided(np.zeros(1),shape=shape, strides=np.zeros_like(shape))
 return x
array1 = make_dummy((2,2,1))
array2 = make_dummy((2,3))
</code></pre>

I could dig into <code>np.broadcast_arrays</code> to find out how it combines the shapes from the 2 input arrays to come up with the shape for <code>I</code>.

<hr>

There's a difference between your desired solution and mine that I've glossed over.

<pre><code>(0, 0, 0), (0, 0), (0, 0, 0)
(0, 0, 0), (0, 1), (0, 0, 1)
...
(1, 1, 0), (1, 1), (1, 1, 1)
(1, 1, 0), (1, 2), (1, 1, 2)
</code></pre>

expects a different iterator tuple for each array, one that ranges over <code>(2,2,1)</code>, another than ranges over <code>(2,3)</code>, etc.

My approach, which I believe is that used by <code>numpy</code> c code (at least those parts based on <code>nditer</code>), generates one iterator over <code>(2,2,3)</code>, and massages the arrays, via <code>as_strided</code> to accept that larger range. It is easier to implement a general broadcasting mechanism this way. It separates the broadcasting complexity from the calculation core.

Here's a good intro to <code>nditer</code>:

<a href="http://docs.scipy.org/doc/numpy/reference/arrays.nditer.html" rel="nofollow noreferrer">http://docs.scipy.org/doc/numpy/reference/arrays.nditer.html</a>

I have 2 array shapes which are broadcastable against eachother.

e.g. (2, 2, 1) and (2, 3)

I want a function that takes those shapes and gives me an iterator returning the indices from these arrays with these shapes that would be broadcast together, and the indices in the resulting output array. 

<pre><code>iter, output_shape = broadcast_indeces_iterator((2, 2, 1), (2, 3))
assert output_shape == (2, 2, 3)
for in1_ix, in_2_ix, out_ix in iter:
 print (in1_ix, in_2_ix, out_ix) 
</code></pre>

results in output:

<pre><code>(0, 0, 0), (0, 0), (0, 0, 0)
(0, 0, 0), (0, 1), (0, 0, 1)
(0, 0, 0), (0, 2), (0, 0, 2)
(0, 1, 0), (1, 0), (0, 1, 0)
(0, 1, 0), (1, 1), (0, 1, 1)
(0, 1, 0), (1, 2), (0, 1, 2)
(1, 0, 0), (0, 0), (1, 0, 0)
(1, 0, 0), (0, 1), (1, 0, 1)
(1, 0, 0), (0, 2), (1, 0, 2)
(1, 1, 0), (1, 0), (1, 1, 0)
(1, 1, 0), (1, 1), (1, 1, 1)
(1, 1, 0), (1, 2), (1, 1, 2)
</code></pre>

np.broadcast does something close but wants actual created arrays. 

<ul>
<li>Note to NumPy people: It would be nice for np.broadcast to have an additional argument allowing you to not iterate, for instance, over the last 2 dimensions. This would also solve my problem.</li>
</ul>

Numpy Broadcast indices from shape

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有两个阵列形状，可以互相广播。例如(2，2，1)和(2，3)我想要一个函数，它接受这些形状，并给我一个迭代器，返回这些数组中的索引，并将这些形状一起广播，以及结果输出数组中的索引。iter, output_shape = broadcast_indeces_iterator((2, 2, 1), (2, 3))ass...

问从形状看Numpy广播索引
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从形状看Numpy广播索引EN