с использованием многопроцессорности с sympy

Question

У меня есть большое уравнение, и я использую библиотеку Sympy для ее решения, в случае символьных переменных и большого количества Python тратит много времени на решение. Как я могу использовать многопроцессорность в этой проблеме? UPD: Да, я должен решить его почти 1000 ~ 10000 раз с различными переменными.

>>> price = Symbol('price') 
>>> k = delta * np.divide(1., Piecewise((0, z <= 0), (z, z > 0))) 
>>> wantedEstate = (wealth/(price + self.q/self.rate)) * Piecewise((1, k > 1), (k, k <= 1)) - realEstate 
>>> return wantedEstate 

Answer 1

Я не могу видеть то, что вы хотите сделать, потому что вы не разместил полный фрагмент кода ... но я могу сделать что-то приближенное.

Вам нужно построить функцию, подобную приведенной ниже. А затем используйте параллельную карту. (Я использую библиотеку pathos вместо multiprocessing b/c Я автор, ее можно использовать интерактивно из интерпретатора, и она легко принимает несколько аргументов).

>>> import sympy 
>>> price = sympy.Symbol('price') 
>>> def estate(x, y, z): 
... k = 2*price + x 
... return z*k**2 + y*k 
... 
>>> estate(1,2,3) 
4*price + 3*(2*price + 1)**2 + 2 
>>> 
>>> x = range(10) 
>>> y = range(-5,5) 
>>> z = range(20,0,-2) 
>>> 
>>> from pathos.pools import ProcessPool 
>>> pool = ProcessPool() 
>>> pool.map(estate, x, y, z) 
[80*price**2 - 10*price, -8*price + 18*(2*price + 1)**2 - 4, -6*price + 16*(2*price + 2)**2 - 6, -4*price + 14*(2*price + 3)**2 - 6, -2*price + 12*(2*price + 4)**2 - 4, 10*(2*price + 5)**2, 2*price + 8*(2*price + 6)**2 + 6, 4*price + 6*(2*price + 7)**2 + 14, 6*price + 4*(2*price + 8)**2 + 24, 8*price + 2*(2*price + 9)**2 + 36] 

Или, если вы хотите неблокирующая map:

>>> res = pool.imap(estate, x, y, z) 
>>> res.next() 
80*price**2 - 10*price 
>>> res.next() 
-8*price + 18*(2*price + 1)**2 - 4 
>>> res.next() 
-6*price + 16*(2*price + 2)**2 - 6 
>>> list(res)  
[-4*price + 14*(2*price + 3)**2 - 6, -2*price + 12*(2*price + 4)**2 - 4, 10*(2*price + 5)**2, 2*price + 8*(2*price + 6)**2 + 6, 4*price + 6*(2*price + 7)**2 + 14, 6*price + 4*(2*price + 8)**2 + 24, 8*price + 2*(2*price + 9)**2 + 36] 

И когда вы закончите, не забудьте закрыть вещи вниз:

>>> pool.close() 
>>> pool.join() 

Однако, если вы хотите использовать традиционный multiprocessing (скажем, у вас есть только один аргумент для вашего map), он будет выглядеть так:

>>> def doit(x): 
... return x+2*x 
... 
>>> # use the standard multiprocessing interface 
>>> import pathos.multiprocessing as mp 
>>> pool = mp.Pool() 
>>> pool.map(doit, x) 
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27] 
>>> pool.close() 
>>> pool.join() 

Там же пул потоков (то же самое доступен в multiprocessing.dummy), чтобы использовать потоки вместо процессов:

>>> from pathos.pools import ThreadPool 
>>> pool = ThreadPool() 
>>> pool.map(doit, x) 
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27] 
>>> pool.close() 
>>> pool.join() 

Есть и другие ароматы map (например, если порядок результатов не имеет значения, используйте uimap от pathos, что совпадает с imap_unordered от multiprocessing).