क्लस्टर

Question

पर पाइथन और पीबीएस का उपयोग करके "शर्मनाक समानांतर" प्रोग्रामिंग मेरे पास एक फ़ंक्शन (तंत्रिका नेटवर्क मॉडल) है जो आंकड़े उत्पन्न करता है। मैं टॉर्क के साथ मानक क्लस्टर पर पीबीएस का उपयोग करके पाइथन से कई पैरामीटर, विधियों और विभिन्न इनपुट (फ़ंक्शन के सैकड़ों रन) का परीक्षण करना चाहता हूं।

नोट: मैंने समानांतर, आईपीथॉन और ऐसा करने की कोशिश की और कभी भी पूरी तरह से संतुष्ट नहीं था, क्योंकि मुझे कुछ आसान चाहिए। क्लस्टर एक दिए गए कॉन्फ़िगरेशन में है कि मैं नहीं बदल सकता और पाइथन + qsub को एकीकृत करने वाला ऐसा समाधान निश्चित रूप से समुदाय को लाभान्वित करेगा।

चीजों को आसान बनाने के लिए, मैं इस तरह के रूप में एक सरल कार्य है:

import myModule 
def model(input, a= 1., N=100): 
    do_lots_number_crunching(input, a,N) 
    pylab.savefig('figure_' + input.name + '_' + str(a) + '_' + str(N) + '.png') 

जहां input एक वस्तु इनपुट का प्रतिनिधित्व करता है, input.name एक स्ट्रिंग है, और do_lots_number_crunching घंटे तक चल सकता है।

मेरे सवाल यह है: इस तरह के

for a in pylab.linspace(0., 1., 100): 
    model(input, a) 

"कुछ" है कि model समारोह के लिए हर कॉल के लिए एक पीबीएस स्क्रिप्ट शुरू करेगा में के रूप में मानकों के स्कैन की तरह कुछ को बदलने के लिए एक सही तरीका है?

#PBS -l ncpus=1 
#PBS -l mem=i1000mb 
#PBS -l cput=24:00:00 
#PBS -V 
cd /data/work/ 
python experiment_model.py 

मैं एक समारोह है कि पीबीएस टेम्पलेट शामिल है और यह अजगर स्क्रिप्ट से कहेंगे, लेकिन अभी तक यह समझ नहीं सकता है बाहर की सोच रहा था (डेकोरेटर?)।

Answer 1

pbs_python [1] इसके लिए काम कर सकता है। experiment_model.py तो 'एक' एक तर्क के रूप तुम कर सकते हो

import pbs, os 

server_name = pbs.pbs_default() 
c = pbs.pbs_connect(server_name) 

attopl = pbs.new_attropl(4) 
attropl[0].name = pbs.ATTR_l 
attropl[0].resource = 'ncpus' 
attropl[0].value = '1' 

attropl[1].name = pbs.ATTR_l 
attropl[1].resource = 'mem' 
attropl[1].value = 'i1000mb' 

attropl[2].name = pbs.ATTR_l 
attropl[2].resource = 'cput' 
attropl[2].value = '24:00:00' 

attrop1[3].name = pbs.ATTR_V 

script=''' 
cd /data/work/ 
python experiment_model.py %f 
''' 

jobs = [] 

for a in pylab.linspace(0.,1.,100): 
    script_name = 'experiment_model.job' + str(a) 
    with open(script_name,'w') as scriptf: 
     scriptf.write(script % a) 
    job_id = pbs.pbs_submit(c, attropl, script_name, 'NULL', 'NULL') 
    jobs.append(job_id) 
    os.remove(script_name) 

print jobs 

[1]

: https://oss.trac.surfsara.nl/pbs_python/wiki/TorqueUsage pbs_python

Answer 2

आप आसानी से jug का उपयोग कर ऐसा कर सकते हैं (जो मैं एक समान सेटअप के लिए विकसित किया गया)।

आप फ़ाइल में लिखते हैं (उदाहरण के लिए, model.py):

@TaskGenerator 
def model(param1, param2): 
    res = complex_computation(param1, param2) 
    pyplot.coolgraph(res) 


for param1 in np.linspace(0, 1.,100): 
    for param2 in xrange(2000): 
     model(param1, param2) 

और बस हो गया!

अब आप अपनी कतार पर "जुग नौकरियां" लॉन्च कर सकते हैं: jug execute model.py और यह स्वचालित रूप से समानांतर होगा।

while not all_done(): 
    for t in tasks in tasks_that_i_can_run(): 
     if t.lock_for_me(): t.run() 

(यह वास्तव में है कि तुलना में अधिक जटिल है, लेकिन आप समझ गए होंगे): क्या होता है कि हर काम में, एक पाश, की तरह कुछ कर देगा।

यह लॉकिंग के लिए फाइल सिस्टम का उपयोग करता है (यदि आप एनएफएस सिस्टम पर हैं) या यदि आप चाहें तो एक रेडिस सर्वर। यह कार्यों के बीच निर्भरताओं को भी संभाल सकता है।

यह वही नहीं है जो आपने पूछा था, लेकिन मेरा मानना ​​है कि यह नौकरी कतार प्रणाली से अलग करने के लिए एक क्लीनर आर्किटेक्चर है।

Answer 3

ऐसा लगता है कि मैं पार्टी के लिए थोड़ा देर हो चुकी हूं, लेकिन कुछ साल पहले पाइथन में क्लस्टर पर शर्मनाक समानांतर समस्याओं को मैप करने के तरीके के बारे में भी यही सवाल था और मैंने अपना स्वयं का समाधान लिखा था।मैं हाल ही में अपलोड इसे यहाँ GitHub के लिए: https://github.com/plediii/pbs_util

pbs_util के साथ अपने प्रोग्राम लिखने के लिए, मैं पहली बार काम कर निर्देशिका युक्त एक pbs_util.ini बनाना होगा

[PBSUTIL] 
numnodes=1 
numprocs=1 
mem=i1000mb 
walltime=24:00:00 

फिर

इस तरह एक अजगर स्क्रिप्ट

import pbs_util.pbs_map as ppm 

import pylab 
import myModule 

class ModelWorker(ppm.Worker): 

    def __init__(self, input, N): 
     self.input = input 
     self.N = N 

    def __call__(self, a): 
     myModule.do_lots_number_crunching(self.input, a, self.N) 
     pylab.savefig('figure_' + self.input.name + '_' + str(a) + '_' + str(self.N) + '.png') 



# You need "main" protection like this since pbs_map will import this file on the  compute nodes 
if __name__ == "__main__": 
    input, N = something, picklable 
    # Use list to force the iterator 
    list(ppm.pbs_map(ModelWorker, pylab.linspace(0., 1., 100), 
        startup_args=(input, N), 
        num_clients=100)) 

और वह ऐसा करेगा।

Answer 4

मैंने अभी क्लस्टर और ईपी अनुप्रयोगों के साथ काम करना शुरू कर दिया है। मेरा लक्ष्य (मैं लाइब्रेरी के साथ हूं) ईपी अनुप्रयोगों के साथ कैंपस पहुंच एचपीसी पर अन्य शोधकर्ताओं की मदद करने के लिए पर्याप्त सीखना है ... विशेष रूप से एसटीईएम के बाहर शोधकर्ता। मैं अभी भी बहुत नया हूं, लेकिन सोचा कि यह विभिन्न प्रश्नों के साथ मूल पायथन स्क्रिप्ट लॉन्च करने के लिए पीबीएस स्क्रिप्ट में GNU Parallel के उपयोग को इंगित करने के लिए इस प्रश्न की सहायता कर सकता है। .pbs फ़ाइल में, वहाँ बाहर बात करने के लिए दो पंक्तियां हैं:

module load gnu-parallel # this is required on my environment 

parallel -j 4 --env PBS_O_WORKDIR --sshloginfile $PBS_NODEFILE \ 
--workdir $NODE_LOCAL_DIR --transfer --return 'output.{#}' --clean \ 
`pwd`/simple.py '{#}' '{}' ::: $INPUT_DIR/input.* 

# `-j 4` is the number of processors to use per node, will be cluster-specific 
# {#} will substitute the process number into the string 
# `pwd`/simple.py `{#}` `{}` this is the command that will be run multiple times 
# ::: $INPUT_DIR/input.* all of the files in $INPUT_DIR/ that start with 'input.' 
#  will be substituted into the python call as the second(3rd) argument where the 
#  `{}` resides. These can be simple text files that you use in your 'simple.py' 
#  script to pass the parameter sets, filenames, etc. 

ईपी सुपर कम्प्यूटिंग के लिए एक newby के रूप में, भले ही मैं अभी तक "समांतर" पर अन्य सभी विकल्पों को समझ में नहीं है, इस आदेश मुझे करने की अनुमति दी विभिन्न मानकों के साथ समानांतर में पायथन स्क्रिप्ट लॉन्च करें। यह अच्छी तरह से काम करेगा यदि आप समय से पहले कई पैरामीटर फाइलें उत्पन्न कर सकते हैं जो आपकी समस्या को समानांतर करेंगे। उदाहरण के लिए, पैरामीटर स्पेस में सिमुलेशन चलाना। या एक ही कोड के साथ कई फाइलों को संसाधित करना।