我有一个包含整数（正数或负数）的二维数组。每行代表特定空间站点随时间变化的值，而每列代表给定时间各种空间站点的值。
所以如果数组是这样的：
1 3 4 2 2 7
5 2 2 1 4 1
3 3 2 2 1 1
结果应该是
1 3 2 2 2 1
请注意，当模式有多个值时，可以将任何一个（随机选择）设置为模式。
我可以一次遍历查找模式的列，但我希望 numpy 可能有一些内置函数来做到这一点。或者，如果有一个技巧可以在不循环的情况下有效地找到它。
问问题
240699 次
10 回答
158
检查scipy.stats.mode()（灵感来自@tom10 的评论）：
import numpy as np
from scipy import stats
a = np.array([[1, 3, 4, 2, 2, 7],
[5, 2, 2, 1, 4, 1],
[3, 3, 2, 2, 1, 1]])
m = stats.mode(a)
print(m)
输出：
ModeResult(mode=array([[1, 3, 2, 2, 1, 1]]), count=array([[1, 2, 2, 2, 1, 2]]))
如您所见，它返回模式和计数。您可以通过以下方式直接选择模式m[0]：
print(m[0])
输出：
[[1 3 2 2 1 1]]
于 2013-05-02T05:50:00.670 回答
29
更新
自这篇文章以来，该scipy.stats.mode功能已得到显着优化，将是推荐的方法
旧答案
这是一个棘手的问题，因为没有太多可以计算沿轴的模式。对于一维数组，解决方案很简单，numpy.bincount很方便，还有numpy.uniquearg return_countsas True。我看到的最常见的 n 维函数是 scipy.stats.mode，尽管它速度非常慢——尤其是对于具有许多唯一值的大型数组。作为解决方案，我开发了这个功能，并大量使用它：
import numpy
def mode(ndarray, axis=0):
# Check inputs
ndarray = numpy.asarray(ndarray)
ndim = ndarray.ndim
if ndarray.size == 1:
return (ndarray[0], 1)
elif ndarray.size == 0:
raise Exception('Cannot compute mode on empty array')
try:
axis = range(ndarray.ndim)[axis]
except:
raise Exception('Axis "{}" incompatible with the {}-dimension array'.format(axis, ndim))
# If array is 1-D and numpy version is > 1.9 numpy.unique will suffice
if all([ndim == 1,
int(numpy.__version__.split('.')[0]) >= 1,
int(numpy.__version__.split('.')[1]) >= 9]):
modals, counts = numpy.unique(ndarray, return_counts=True)
index = numpy.argmax(counts)
return modals[index], counts[index]
# Sort array
sort = numpy.sort(ndarray, axis=axis)
# Create array to transpose along the axis and get padding shape
transpose = numpy.roll(numpy.arange(ndim)[::-1], axis)
shape = list(sort.shape)
shape[axis] = 1
# Create a boolean array along strides of unique values
strides = numpy.concatenate([numpy.zeros(shape=shape, dtype='bool'),
numpy.diff(sort, axis=axis) == 0,
numpy.zeros(shape=shape, dtype='bool')],
axis=axis).transpose(transpose).ravel()
# Count the stride lengths
counts = numpy.cumsum(strides)
counts[~strides] = numpy.concatenate([[0], numpy.diff(counts[~strides])])
counts[strides] = 0
# Get shape of padded counts and slice to return to the original shape
shape = numpy.array(sort.shape)
shape[axis] += 1
shape = shape[transpose]
slices = [slice(None)] * ndim
slices[axis] = slice(1, None)
# Reshape and compute final counts
counts = counts.reshape(shape).transpose(transpose)[slices] + 1
# Find maximum counts and return modals/counts
slices = [slice(None, i) for i in sort.shape]
del slices[axis]
index = numpy.ogrid[slices]
index.insert(axis, numpy.argmax(counts, axis=axis))
return sort[index], counts[index]
结果：
In [2]: a = numpy.array([[1, 3, 4, 2, 2, 7],
[5, 2, 2, 1, 4, 1],
[3, 3, 2, 2, 1, 1]])
In [3]: mode(a)
Out[3]: (array([1, 3, 2, 2, 1, 1]), array([1, 2, 2, 2, 1, 2]))
一些基准：
In [4]: import scipy.stats
In [5]: a = numpy.random.randint(1,10,(1000,1000))
In [6]: %timeit scipy.stats.mode(a)
10 loops, best of 3: 41.6 ms per loop
In [7]: %timeit mode(a)
10 loops, best of 3: 46.7 ms per loop
In [8]: a = numpy.random.randint(1,500,(1000,1000))
In [9]: %timeit scipy.stats.mode(a)
1 loops, best of 3: 1.01 s per loop
In [10]: %timeit mode(a)
10 loops, best of 3: 80 ms per loop
In [11]: a = numpy.random.random((200,200))
In [12]: %timeit scipy.stats.mode(a)
1 loops, best of 3: 3.26 s per loop
In [13]: %timeit mode(a)
1000 loops, best of 3: 1.75 ms per loop
编辑：提供更多背景知识并修改方法以提高内存效率
于 2016-02-27T19:59:55.097 回答
21
如果您只想使用 numpy：
x = [-1, 2, 1, 3, 3]
vals,counts = np.unique(x, return_counts=True)
给
(array([-1, 1, 2, 3]), array([1, 1, 1, 2]))
并提取它：
index = np.argmax(counts)
return vals[index]
于 2020-04-17T02:34:33.797 回答
16
一个巧妙的解决方案，只使用numpy（不是scipy类Counter）：
A = np.array([[1,3,4,2,2,7], [5,2,2,1,4,1], [3,3,2,2,1,1]])
np.apply_along_axis(lambda x: np.bincount(x).argmax(), axis=0, arr=A)
数组（[1, 3, 2, 2, 1, 1]）
于 2019-05-08T23:54:33.293 回答
13
扩展此方法，应用于查找数据的模式，您可能需要实际数组的索引来查看该值与分布中心的距离。
(_, idx, counts) = np.unique(a, return_index=True, return_counts=True)
index = idx[np.argmax(counts)]
mode = a[index]
请记住在 len(np.argmax(counts)) > 1 时丢弃模式，同时验证它是否真的代表数据的中心分布，您可以检查它是否在标准差区间内。
于 2017-05-06T08:30:48.187 回答
3
Python中获取列表或数组模式的最简单方法
import statistics
print("mode = "+str(statistics.(mode(a)))
而已
于 2020-03-25T10:47:55.220 回答
3
我认为一个非常简单的方法是使用 Counter 类。然后，您可以使用此处提到的 Counter 实例的 most_common() 函数。
对于一维数组：
import numpy as np
from collections import Counter
nparr = np.arange(10)
nparr[2] = 6
nparr[3] = 6 #6 is now the mode
mode = Counter(nparr).most_common(1)
# mode will be [(6,3)] to give the count of the most occurring value, so ->
print(mode[0][0])
对于多维数组（差别不大）：
import numpy as np
from collections import Counter
nparr = np.arange(10)
nparr[2] = 6
nparr[3] = 6
nparr = nparr.reshape((10,2,5)) #same thing but we add this to reshape into ndarray
mode = Counter(nparr.flatten()).most_common(1) # just use .flatten() method
# mode will be [(6,3)] to give the count of the most occurring value, so ->
print(mode[0][0])
这可能是也可能不是有效的实现，但它很方便。
于 2018-04-25T01:29:45.047 回答
2
from collections import Counter
n = int(input())
data = sorted([int(i) for i in input().split()])
sorted(sorted(Counter(data).items()), key = lambda x: x[1], reverse = True)[0][0]
print(Mean)
计算Counter(data)频率并返回一个默认字典。sorted(Counter(data).items())使用键排序，而不是频率。最后，需要使用另一个排序的频率对频率进行排序key = lambda x: x[1]。反过来告诉 Python 将频率从最大到最小排序。
于 2019-08-23T10:06:57.527 回答
0
如果您只想使用 numpy 并在不使用数组索引的情况下执行此操作。可以使用以下结合字典和 numpy 的实现。
val,count = np.unique(x,return_counts=True)
freq = {}
for v,c in zip(val,count):
freq[v] = c
mode = sorted(freq.items(),key =lambda kv :kv[1])[-1]
于 2021-09-21T12:00:34.957 回答
0
如果你想在这里找到模式为 int 值，这是 我尝试使用 Scipy Stats 找出数组模式的最简单方法，但问题是代码的输出如下所示：
ModeResult(mode=array(2), count=array([[1, 2, 2, 2, 1, 2]]))，我只想要整数输出，所以如果你想要同样的，试试这个
import numpy as np
from scipy import stats
numbers = list(map(int, input().split()))
print(int(stats.mode(numbers)[0]))
最后一行足以在 Python 中打印模式值：print(int(stats.mode(numbers)[0]))
于 2021-02-22T13:32:30.750 回答