blocks|key|130384|text|对Numpy采取蒙面手段|type|unstyled|depth|inlineStyleRanges|entityRanges|data|130385|如果我理解你想要做的是什么，这里有一个更好的方法：|130386|row1_mean+=+Y_mat[0][R_mat[0].astype(bool)].mean()|code-block|syntax|javascript|130387|这是如果你只想要单行的平均值。您可以像这样计算每一行的平均值：|130388|means+=+np.nanmean(np.where(mask,+arr,+np.nan),+axis=1)
#+if+every+value+in+a+given+row+is+masked,+the+mean+will+be+calculated+as+nan.+Change+those+to+zeros
means[np.isnan(means)]+=+0|130389|Numpy中的布尔索引|130390|作为将来使用的注意事项，您实际上可以使用布尔数组来索引Numpy数组(就像Octave一样，我猜？)。下面是一个简单的例子：|130391|import+numpy+as+np

arr+=+np.arange(10*5).reshape(10,5)
mask+=+np.random.randint(0,+2,+(10,+5),+dtype=bool)

print('original+array\n%25s\n'+%25+arr)
print('boolean+masked+array\n%25s\n'+%25+arr[mask])|130392|输出：|130393|original+array
[[+0++1++2++3++4]
+[+5++6++7++8++9]
+[10+11+12+13+14]
+[15+16+17+18+19]
+[20+21+22+23+24]
+[25+26+27+28+29]
+[30+31+32+33+34]
+[35+36+37+38+39]
+[40+41+42+43+44]
+[45+46+47+48+49]]

boolean+masked+array
[+1++2++3++4++7++8+10+11+12+14+15+19+26+27+29+33+38+39+44+45+46]|130394|正如您所看到的，布尔索引将扁平化2D数组(原因由Paul+Panzer在注释中解释)。这就是我在上面的第二个答案中使用np.where的原因。|offset|length|style|CODE|130395|entityMap^0|0|0|0|0|0|0|0|0|0|0|1N|8|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1B|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1D|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1E|8|@$Y|1F|Z|1G|10|11]]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

<h1>Take the masked mean with Numpy</h1>

If I understand what you're trying to do correctly, here's a much better way:

<pre><code>row1_mean = Y_mat[0][R_mat[0].astype(bool)].mean()
</code></pre>

That's if you just want the mean of a single row. You can calculate the means for every row like this:

<pre><code>means = np.nanmean(np.where(mask, arr, np.nan), axis=1)
# if every value in a given row is masked, the mean will be calculated as nan. Change those to zeros
means[np.isnan(means)] = 0
</code></pre>

<h1>Boolean indexing in Numpy</h1>

As a note for future use, you actually can index a Numpy array with a boolean array (just like Octave, I guess?). Here's a brief example:

<pre><code>import numpy as np

arr = np.arange(10*5).reshape(10,5)
mask = np.random.randint(0, 2, (10, 5), dtype=bool)

print('original array\n%s\n' % arr)
print('boolean masked array\n%s\n' % arr[mask])
</code></pre>

Output:

<pre><code>original array
[[ 0 1 2 3 4]
 [ 5 6 7 8 9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]
 [25 26 27 28 29]
 [30 31 32 33 34]
 [35 36 37 38 39]
 [40 41 42 43 44]
 [45 46 47 48 49]]

boolean masked array
[ 1 2 3 4 7 8 10 11 12 14 15 19 26 27 29 33 38 39 44 45 46]
</code></pre>

As you can see, boolean indexing will flatten a 2D array (for reasons explained by Paul Panzer in the comments). This is why I used <code>np.where</code> in my second answer above.

blocks|key|129964|text|如果你想使用掩码数组，这里有一个简化的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|129965|import+numpy+as+np

#+create+some+mock+data
R_mat+=+np.arange(16).reshape(4,+4)
Y_mat+=+np.random.randint(0,+2,+(4,+4))

R_mat
#+array([[+0,++1,++2,++3],
#++++++++[+4,++5,++6,++7],
#++++++++[+8,++9,+10,+11],
#++++++++[12,+13,+14,+15]])
Y_mat
#+array([[0,+1,+0,+1],
#++++++++[0,+1,+1,+0],
#++++++++[0,+1,+0,+1],
#++++++++[0,+0,+1,+0]])

#+compute+all+row+means+or+all+column+means+at+once
#+use+Y_mat==0+to+invert+and+convert+to+bool+in+one+go
row_means+=+np.ma.MaskedArray(R_mat,+Y_mat==0).mean(axis=1)
col_means+=+np.ma.MaskedArray(R_mat,+Y_mat==0).mean(axis=0)

row_means
#+masked_array(data=[2.0,+5.5,+10.0,+14.0],
#++++++++++++++mask=[False,+False,+False,+False],
#++++++++fill_value=1e%2B20)
col_means
#+masked_array(data=[--,+5.0,+10.0,+7.0],
#++++++++++++++mask=[+True,+False,+False,+False],
#++++++++fill_value=1e%2B20)


#+or+take+just+one+row+or+column+and+get+the+mean+
np.ma.MaskedArray(R_mat,+Y_mat==0)[2].mean()
#+10.0
np.ma.MaskedArray(R_mat,+Y_mat==0)[:,+0].mean()
#+masked|code-block|syntax|javascript|129966|如果出于某种原因，您希望避免使用掩码数组：|129967|nrow,+ncol+=+R_mat.shape

I,+J+=+np.where(Y_mat)
row_means+=+np.bincount(I,+R_mat[I,+J],+nrow)+/+np.bincount(I,+None,+nrow)

J,+I+=+np.where(Y_mat.T)
col_means+=+np.bincount(J,+R_mat[I,+J],+ncol)+/+np.bincount(J,+None,+ncol)
#+__main__:1:+RuntimeWarning:+invalid+value+encountered+in+true_divide

row_means
#+array([+2.+,++5.5,+10.+,+14.+])
col_means
#+array([nan,++5.,+10.,++7.])|129968|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you want to use masked arrays, here is a streamlined way of doing that:

<pre><code>import numpy as np

# create some mock data
R_mat = np.arange(16).reshape(4, 4)
Y_mat = np.random.randint(0, 2, (4, 4))

R_mat
# array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11],
# [12, 13, 14, 15]])
Y_mat
# array([[0, 1, 0, 1],
# [0, 1, 1, 0],
# [0, 1, 0, 1],
# [0, 0, 1, 0]])

# compute all row means or all column means at once
# use Y_mat==0 to invert and convert to bool in one go
row_means = np.ma.MaskedArray(R_mat, Y_mat==0).mean(axis=1)
col_means = np.ma.MaskedArray(R_mat, Y_mat==0).mean(axis=0)

row_means
# masked_array(data=[2.0, 5.5, 10.0, 14.0],
# mask=[False, False, False, False],
# fill_value=1e+20)
col_means
# masked_array(data=[--, 5.0, 10.0, 7.0],
# mask=[ True, False, False, False],
# fill_value=1e+20)


# or take just one row or column and get the mean 
np.ma.MaskedArray(R_mat, Y_mat==0)[2].mean()
# 10.0
np.ma.MaskedArray(R_mat, Y_mat==0)[:, 0].mean()
# masked
</code></pre>

If for some reason you want to avoid masked arrays:

<pre><code>nrow, ncol = R_mat.shape

I, J = np.where(Y_mat)
row_means = np.bincount(I, R_mat[I, J], nrow) / np.bincount(I, None, nrow)

J, I = np.where(Y_mat.T)
col_means = np.bincount(J, R_mat[I, J], ncol) / np.bincount(J, None, ncol)
# __main__:1: RuntimeWarning: invalid value encountered in true_divide

row_means
# array([ 2. , 5.5, 10. , 14. ])
col_means
# array([nan, 5., 10., 7.])
</code></pre>

In converting this simple line of Octave code to Python, I’m wondering if there's a quicker/cleaner way:

Given two matrices, the Octave command averages a row of matrix <code>Y</code> using a Boolean matrix <code>R</code> to tag the values that are of interest:

<pre><code>load (‘mydata.mat’)
row1_mean = mean( Y(1, R(1, :) ) )
</code></pre>

Nice and quick and easy. Trying to do that in Python is much less succinct, but so far I can get there like this:

<pre><code>import numpy as np
from scipy import io as spio

myDict = spio.loadmat(‘mydata.mat’)
Y_mat = myDict['Y']
R_mat = myDict['R']

maskR = ~R_mat.astype(bool)[0][:] # row as boolean so we can invert it
maskR = maskR.astype(int) # turn it back to 1s &amp; 0s

maskedY = np.ma.masked_array(Y_mat[0][:], mask=maskR) # mask row of Y with R matrix

row1_mean = maskedY.mean() # get the mean
</code></pre>

I’m probably missing a better approach.
Particularly, is there an easier way to invert a matrix of 1s and 0s? 
Maybe too there's a more direct way to get a mean of an array slice (I know about <code>axis</code>) but taking into account a masking array?

Calculate mean across a row of an array using a row of a masking array

Python

在将这行简单的Octave代码转换为Python时，我想知道是否有更快、更干净的方法：给定两个矩阵，Octave命令使用布尔矩阵R对一行矩阵Y求平均值，以标记感兴趣的值：load (‘mydata.mat’)row1_mean = mean( Y(1, R(1, :) ) )又好又快又简单。尝试用Python做到这一点...

问使用掩码数组的行计算数组的行的平均值
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用掩码数组的行计算数组的行的平均值EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用掩码数组的行计算数组的行的平均值
EN