Самый быстрый Способ генерировать 1,000,000 + случайные числа в Python
Я в настоящее время пишу приложение в Python, который должен генерировать большое количество случайных чисел, FAST. В настоящее время у меня есть схема, идущая, который использует numpy для генерации всех чисел в гигантском пакете (приблизительно ~500 000 за один раз). В то время как это, кажется, быстрее, чем реализация Python. Мне все еще нужен он для движения быстрее. Какие-либо идеи? Я открыт для записи его в C и встраивании его в программе или выполнении w/e, это берет.
Ограничения на случайные числа:
- Ряд 7 чисел, которые могут все иметь различные границы:
- например: [0-X1, 0-X2, 0-X3, 0-X4, 0-X5, 0-X6, 0-X7]
- В настоящее время я генерирую список 7 чисел со случайными значениями от [0-1), затем умножение на [X1.. X7]
- Ряд 13 чисел, которые все составляют в целом 1
- В настоящее время просто генерировав 13 чисел, затем делящихся на их сумму
Какие-либо идеи? Был бы пред вычисление этих чисел, и хранение их в файле делают это быстрее?
Спасибо!
4 ответа
Вы можете немного ускорить процесс по сравнению с тем, что mtrw опубликовал выше, просто выполнив то, что вы описали изначально (сгенерировав кучу случайных чисел, а затем умножив и разделив соответственно) ...
Кроме того, вы, вероятно, уже это знаете, но обязательно выполняйте операции на месте (* =, / =, + = и т. д.) при работе с большими массивами numpy. Это дает огромную разницу в использовании памяти с большими массивами, а также дает значительное увеличение скорости.
In [53]: def rand_row_doubles(row_limits, num):
....: ncols = len(row_limits)
....: x = np.random.random((num, ncols))
....: x *= row_limits
....: return x
....:
In [59]: %timeit rand_row_doubles(np.arange(7) + 1, 1000000)
10 loops, best of 3: 187 ms per loop
По сравнению с:
In [66]: %timeit ManyRandDoubles(np.arange(7) + 1, 1000000)
1 loops, best of 3: 222 ms per loop
Это не большая разница, но если вы действительно беспокоитесь о скорости, это что-то.
Просто чтобы показать, что это правильно:
In [68]: x.max(0)
Out[68]:
array([ 0.99999991, 1.99999971, 2.99999737, 3.99999569, 4.99999836,
5.99999114, 6.99999738])
In [69]: x.min(0)
Out[69]:
array([ 4.02099599e-07, 4.41729377e-07, 4.33480302e-08,
7.43497138e-06, 1.28446819e-05, 4.27614385e-07,
1.34106753e-05])
Точно так же для вашей части «сумма строк в одну» ...
In [70]: def rand_rows_sum_to_one(nrows, ncols):
....: x = np.random.random((ncols, nrows))
....: y = x.sum(axis=0)
....: x /= y
....: return x.T
....:
In [71]: %timeit rand_rows_sum_to_one(1000000, 13)
1 loops, best of 3: 455 ms per loop
In [72]: x = rand_rows_sum_to_one(1000000, 13)
In [73]: x.sum(axis=1)
Out[73]: array([ 1., 1., 1., ..., 1., 1., 1.])
Честно говоря, даже если вы повторно реализуете что-то на C, я не уверен, что вы быть в состоянии превзойти numpy намного в этом ... Хотя я могу ошибаться!
РЕДАКТИРОВАТЬ Созданные функции, которые возвращают полный набор чисел, а не только одну строку за раз. РЕДАКТИРОВАТЬ 2 Сделайте функции более питонными (и более быстрыми), добавьте решение для второго вопроса
Для первого набора чисел вы можете рассмотреть numpy.random.randint или ] numpy.random.uniform , которые принимают параметры low и high . Генерация массива из 7 x 1 000 000 чисел в указанном диапазоне, кажется, занимает <0,7 секунды на моем компьютере с частотой 2 ГГц:
def LimitedRandInts(XLim, N):
rowlen = (1,N)
return [np.random.randint(low=0,high=lim,size=rowlen) for lim in XLim]
def LimitedRandDoubles(XLim, N):
rowlen = (1,N)
return [np.random.uniform(low=0,high=lim,size=rowlen) for lim in XLim]
>>> import numpy as np
>>> N = 1000000 #number of randoms in each range
>>> xLim = [x*500 for x in range(1,8)] #convenient limit generation
>>> fLim = [x/7.0 for x in range(1,8)]
>>> aa = LimitedRandInts(xLim, N)
>>> ff = LimitedRandDoubles(fLim, N)
Это возвращает целые числа в [0, xLim-1] или с плавающей точкой в [0, fLim). Целочисленная версия заняла ~ 0,3 секунды, двойная ~ 0,66 на моей одноядерной машине с частотой 2 ГГц.
Для второго набора я использовал предложение @Joe Kingston.
def SumToOneRands(NumToSum, N):
aa = np.random.uniform(low=0,high=1.0,size=(NumToSum,N)) #13 rows by 1000000 columns, for instance
s = np.reciprocal(aa.sum(0))
aa *= s
return aa.T #get back to column major order, so aa[k] is the kth set of 13 numbers
>>> ll = SumToOneRands(13, N)
Это занимает ~ 1,6 секунды.
Во всех случаях результат [k] дает вам k-й набор данных.
Параллельная работа кода, конечно, не помешает. Попробуйте адаптировать его для SMP с помощью Parallel Python
Попробуйте r = 1664525 * r + 1013904223
из «еще более быстрого генератора»
в «Числовых рецептах на C "2nd edition, Press et al., Isbn 0521431085, p. 284.
np.random определенно "более случайный"; см.
Линейный конгруэнтный генератор .
В Python используйте np.uint32 следующим образом:
python -mtimeit -s '
import numpy as np
r = 1
r = np.array([r], np.uint32)[0] # 316 py -> 16 us np
# python longs can be arbitrarily long, so slow
' '
r = r*1664525 + 1013904223 # NR2 p. 284
'
Чтобы генерировать большие блоки за раз:
# initialize --
np.random.seed( ... )
R = np.random.randint( 0, np.iinfo( np.uint32 ).max, size, dtype=np.uint32 )
...
R *= 1664525
R += 1013904223