我有一个包含整数(正数或负数)的2D数组。每一行代表特定空间站点随时间的值,而每一列代表给定时间内各种空间站点的值。
因此,如果数组是这样的:
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可能有一些内置函数来做到这一点。或者,如果有一个技巧可以有效地发现而不循环。
我有一个包含整数(正数或负数)的2D数组。每一行代表特定空间站点随时间的值,而每一列代表给定时间内各种空间站点的值。
因此,如果数组是这样的:
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可能有一些内置函数来做到这一点。或者,如果有一个技巧可以有效地发现而不循环。
Answers:
检查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]]
import scipy.stats
明确地说明,当您简单地执行时就不会包括在内import scipy
。
axis=0
。上面的代码报告输入每一列的模式。该计数告诉我们在每一列中看到报告模式的次数。如果需要整体模式,则需要指定axis=None
。有关更多信息,请参阅docs.scipy.org/doc/scipy/reference/genic/…–
更新资料
scipy.stats.mode
自发布以来,该功能已得到显着优化,将是推荐的方法
旧答案
这是一个棘手的问题,因为沿轴计算模式的地方不多。该解决方案是直线前进1-d阵列,其中numpy.bincount
是很方便的,沿着numpy.unique
与return_counts
ARG作为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
编辑:提供了更多的背景,并修改了方法以提高内存效率
扩展此方法,适用于查找数据模式,在该模式下您可能需要实际数组的索引才能查看该值与分布中心的距离。
(_, idx, counts) = np.unique(a, return_index=True, return_counts=True)
index = idx[np.argmax(counts)]
mode = a[index]
请记住,当len(np.argmax(counts))> 1时放弃该模式,还要验证它是否实际上代表数据的中心分布,您可以检查它是否落在标准偏差区间内。
一个仅使用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])
scipy.stats.mode
。当有多个出现次数最多的值(多个模式)时,它将引发期望值。但是此方法将自动采用“第一模式”。
我认为一种非常简单的方法是使用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])
这可能是有效的实现方式,也可能不是,但是很方便。
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)
计数频率,并返回一个defaultdict。sorted(Counter(data).items())
使用键而不是频率进行排序。最后,需要使用另一个与排序的频率key = lambda x: x[1]
。反之则告诉Python将频率从最大到最小排序。