पाइथन

Question

में समांतर प्रसंस्करण क्या एक साधारण कोड है जो अजगर 2.7 में समानांतर प्रसंस्करण करता है? ऑनलाइन मिले सभी उदाहरणों को संकलित कर दिया गया है और अनावश्यक कोड शामिल हैं।

मैं एक साधारण ब्रूट फोर्स इंटीजर फैक्टरिंग प्रोग्राम कैसे करूं जहां मैं प्रत्येक कोर (4) पर 1 पूर्णांक कारक कर सकता हूं? मेरे असली कार्यक्रम को केवल 2 कोर की जरूरत है, और जानकारी साझा करने की आवश्यकता है।

मुझे पता है कि समानांतर-अजगर और अन्य पुस्तकालयों मौजूद हैं, लेकिन मैं कम से कम करने के लिए इस्तेमाल पुस्तकालयों की संख्या में रखना चाहते हैं, इस प्रकार मैं thread और/या multiprocessing पुस्तकालयों का उपयोग करना चाहते हैं, क्योंकि वे अजगर के साथ आते हैं

Answer 1

पाइथन में समांतर प्रसंस्करण के साथ शुरू करने का एक अच्छा आसान तरीका म्यूटिप्रोसेसिंग में पूल मैपिंग है - यह सामान्य पायथन मानचित्रों की तरह है लेकिन अलग-अलग फ़ंक्शन कॉल अलग-अलग प्रक्रियाओं में फैलती हैं।

फैक्टरिंग इस का एक अच्छा उदाहरण है - आप जानवर बल सब डिवीजनों सभी उपलब्ध कार्यों से अधिक बाहर फैलने की जाँच कर सकते हैं:

from multiprocessing import Pool 
import numpy 

numToFactor = 976 

def isFactor(x): 
    result = None 
    div = (numToFactor/x) 
    if div*x == numToFactor: 
     result = (x,div) 
    return result 

if __name__ == '__main__': 
    pool = Pool(processes=4) 
    possibleFactors = range(1,int(numpy.floor(numpy.sqrt(numToFactor)))+1) 
    print 'Checking ', possibleFactors 
    result = pool.map(isFactor, possibleFactors) 
    cleaned = [x for x in result if not x is None] 
    print 'Factors are', cleaned 

यह मैं

Checking [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31] 
Factors are [(1, 976), (2, 488), (4, 244), (8, 122), (16, 61)] 

Answer 2

mincemeat सबसे सरल मानचित्र/कार्यान्वयन को कम करता है जो मैंने पाया है। साथ ही, यह निर्भरताओं पर बहुत हल्का है - यह एक ही फाइल है और मानक पुस्तकालय के साथ सब कुछ करता है।

Answer 3

देता है मैं मानता हूँ कि Pool का उपयोग कर यदि आप मानक पुस्तकालय में रहना चाहते हैं तो multiprocessing से शायद सबसे अच्छा मार्ग है। यदि आप अन्य प्रकार के समांतर प्रसंस्करण करने में रुचि रखते हैं, लेकिन कुछ भी नया नहीं सीख रहे हैं (यानी अभी भी multiprocessing के समान इंटरफ़ेस का उपयोग कर रहे हैं), तो आप pathos को आजमा सकते हैं, जो समानांतर मानचित्रों के कई रूप प्रदान करता है और multiprocessing के समान इंटरफ़ेस कर देता है।

Python 2.7.6 (default, Nov 12 2013, 13:26:39) 
[GCC 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66))] on darwin 
Type "help", "copyright", "credits" or "license" for more information. 
>>> import numpy 
>>> numToFactor = 976 
>>> def isFactor(x): 
... result = None 
... div = (numToFactor/x) 
... if div*x == numToFactor: 
...  result = (x,div) 
... return result 
... 
>>> from pathos.multiprocessing import ProcessingPool as MPool 
>>> p = MPool(4) 
>>> possible = range(1,int(numpy.floor(numpy.sqrt(numToFactor)))+1) 
>>> # standard blocking map 
>>> result = [x for x in p.map(isFactor, possible) if x is not None] 
>>> print result 
[(1, 976), (2, 488), (4, 244), (8, 122), (16, 61)] 
>>> 
>>> # asynchronous map (there's also iterative maps too) 
>>> obj = p.amap(isFactor, possible)     
>>> obj 
<processing.pool.MapResult object at 0x108efc450> 
>>> print [x for x in obj.get() if x is not None] 
[(1, 976), (2, 488), (4, 244), (8, 122), (16, 61)] 
>>> 
>>> # there's also parallel-python maps (blocking, iterative, and async) 
>>> from pathos.pp import ParallelPythonPool as PPool 
>>> q = PPool(4) 
>>> result = [x for x in q.map(isFactor, possible) if x is not None] 
>>> print result 
[(1, 976), (2, 488), (4, 244), (8, 122), (16, 61)] 

इसके अलावा, pathos एक ही इंटरफ़ेस के साथ एक बहन पैकेज, pyina कहा जाता है, जो mpi4py चलाता है, लेकिन समानांतर नक्शे कि एमपीआई में चलाने के लिए और कई शेड्यूलर का उपयोग कर चलाया जा सकता है के साथ प्रदान करता है।

एक अन्य लाभ यह है कि pathos मानक पायथन में प्राप्त करने के मुकाबले एक बेहतर सीरिएलाइज़र के साथ आता है, इसलिए यह multiprocessing से अधिक कार्यों और अन्य चीजों को क्रमबद्ध करने में अधिक सक्षम है। और आप दुभाषिया से सब कुछ कर सकते हैं।

>>> class Foo(object): 
... b = 1 
... def factory(self, a): 
...  def _square(x): 
...  return a*x**2 + self.b 
...  return _square 
... 
>>> f = Foo() 
>>> f.b = 100 
>>> g = f.factory(-1) 
>>> p.map(g, range(10)) 
[100, 99, 96, 91, 84, 75, 64, 51, 36, 19] 
>>> 

यहाँ कोड प्राप्त करें: https://github.com/uqfoundation