11

在编写脚本时，我发现了 numpy.random.choice 函数。我实现了它，因为它比等效的 if 语句要干净得多。但是，在运行脚本后，我意识到它比if 语句慢得多。

以下是MWE。第一种方法需要 0.0 秒，而第二种方法需要 7.2 秒。如果你扩大i循环，你会看到 random.choice 变慢的速度。

谁能评论为什么 random.choice 这么慢？

import numpy as np
import numpy.random as rand
import time as tm

#-------------------------------------------------------------------------------

tStart = tm.time()
for i in xrange(100):
    for j in xrange(1000):
        tmp = rand.rand()
        if tmp < 0.25:
            var = 1
        elif tmp < 0.5:
            var = -1
print('Time: %.1f s' %(tm.time() - tStart))

#-------------------------------------------------------------------------------

tStart = tm.time()
for i in xrange(100):
    for j in xrange(1000):
        var = rand.choice([-1, 0, 1], p = [0.25, 0.5, 0.25])
print('Time: %.1f s' %(tm.time() - tStart))
4

5 回答 5

20

你用错了。向量化操作，否则 numpy 将没有任何好处：

var = numpy.random.choice([-1, 0, 1], size=1000, p=[0.25, 0.5, 0.25])

时序数据：

>>> timeit.timeit('''numpy.random.choice([-1, 0, 1],
...                                      size=1000,
...                                      p=[0.25, 0.5, 0.25])''',
...               'import numpy', number=10000)
2.380380242513752

>>> timeit.timeit('''
... var = []
... for i in xrange(1000):
...     tmp = rand.rand()
...     if tmp < 0.25:
...         var.append(1)
...     elif tmp < 0.5:
...         var.append(-1)
...     else:
...         var.append(0)''',
... setup='import numpy.random as rand', number=10000)
5.673041396894519
于 2013-09-04T20:05:46.637 回答
4

这个具有累积分数的解决方案大约快 25 倍：

def choice(options,probs):
    x = np.random.rand()
    cum = 0
    for i,p in enumerate(probs):
        cum += p
        if x < cum:
            break
    return options[i]


options = ['a','b','c','d']
probs = [0.2,0.6,0.15,0.05]
runs = 100000


now = time.time()
temp = []
for i in range(runs):
    op = choice(options,probs)
    temp.append(op)
temp = Counter(temp)
for op,x in temp.items():
    print(op,x/runs)
print(time.time()-now)

print("")
now = time.time()
temp = []
for i in range(runs):
    op = np.random.choice(options,p = probs)
    temp.append(op)
temp = Counter(temp)
for op,x in temp.items():
    print(op,x/runs)
print(time.time()-now)

运行它我得到：

b 0.59891
a 0.20121
c 0.15007
d 0.04981
0.16232800483703613

b 0.5996
a 0.20138
c 0.14856
d 0.05046
3.8451428413391113
于 2019-09-25T15:34:38.263 回答
3

我花了很长时间才发现我的数据生成器非常慢，因为随机密钥采样是通过np.random.choice.

如果不需要非均匀分布，那么这是我找到的可行解决方案。

代替

def get_random_key(a_huge_key_list):
    return np.random.choice(a_huge_key_list)

和

def get_random_key(a_huge_key_list):
    L = len(a_huge_key_list)
    i = np.random.randint(0, L)
    return a_huge_key_list[i]

这提供了 x60 的加速。

于 2018-10-21T07:42:24.923 回答
2

我怀疑普遍性np.random.choice正在减慢它的速度，对于小样本比大样本更是如此。

该版本的粗略矢量化if是：

def foo(n):
    x = np.random.rand(n)
    var = np.zeros(n)
    var[x<.25] = -1
    var[x>.75] = 1
    return var

运行ipython我得到：

timeit np.random.choice([-1,0,1],size=1000,p=[.25,.5,.25])
1000 loops, best of 3: 293 us per loop

timeit foo(1000)
10000 loops, best of 3: 83.4 us per loop

timeit np.random.choice([-1,0,1],size=100000,p=[.25,.5,.25])
100 loops, best of 3: 11 ms per loop

timeit foo(100000)
100 loops, best of 3: 8.12 ms per loop

因此，对于1000大小，choice速度要慢 3-4 倍，但是对于更大的向量，差异开始消失。

于 2013-09-05T06:45:42.033 回答
0

其他答案至少涉及以下一项：

1- 使用 python 列表作为 numpy.random.choice 的输入并创建开销。

2-使用len(array)将为3的先验知识。

3-分布均匀。

对于任意长度的列表，最快的算法之一会在每一步将列表分成 2 个。例如，以下代码适用于一般情况。

def my_random_function(collection, p):
    miles = []
    current = 0
    for prob in p:
        miles.append(current)
        current += prob
    if not math.isclose(current,1):
        raise ValueError()
    x = random.random()
    _all = list(zip(collection,miles))
    while(len(_all)!= 1):
        if _all[len(_all)//2][1] < x:
            _all = _all[len(_all)//2:]
        else:
            _all = _all[0: len(_all)//2]
    return _all[0][0]

为了比较差异，我准备了两个案例：

small_list = list(range(3))
small_array = np.arange(3)
#create a random probability list
small_p = [random.random() for i in range(3)]
small_p = [prob/sum(small_p) for prob in small_p]
small_p_np = np.array(small_p)

large_list = list(range(10000))
large_array = np.arange(10000)
#create a random probability list
large_p = [random.random() for i in range(10000)]
large_p = [prob/sum(large_p) for prob in large_p]
large_p_np = np.array(large_p)

结果如下：

%timeit np.random.choice(small_array, p= small_p_np)

68.1 µs ± 196 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit my_random_function(small_list, small_p)

5.13 µs ± 26.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit np.random.choice(large_array, p= large_p_np)

279 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit my_random_function(large_list, large_p)

3.26 ms ± 5.82 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

结果表明 numpy.random.choice 对于小型集合需要超过 x10 的时间，但当元素更多时，它很快就会成为更好的选择。似乎这个函数有很大的开销，最好避免在代码的性能关键部分中使用小列表。

于 2022-03-02T23:27:58.373 回答