コード例 #1
0
class IPClusterEnsemble(SurveyEnsemble):
    """
    Parallelized suvey ensemble based on IPython parallal (ipcluster)

    Args: 
        \*\*specs: 
            user specified values
            
    Attributes: 
        

    Notes:  

    """

    def __init__(self, **specs):

        SurveyEnsemble.__init__(self, **specs)

        # access the cluster
        self.rc = Client()
        self.dview = self.rc[:]
        self.dview.block = True
        with self.dview.sync_imports(): import EXOSIMS,EXOSIMS.util.get_module
        r1 = self.dview.execute("SurveySim = EXOSIMS.util.get_module.get_module('%s', 'SurveySimulation')"%specs['modules']['SurveySimulation'])
        self.dview.push(dict(specs=specs))
        r2 = self.dview.execute("sim = SurveySim(**specs)")
        self.lview = self.rc.load_balanced_view()

    def run_ensemble(self,run_one,N=10):
        t1 = time.time()
        async_res = []
        for j in range(N):
            ar = self.lview.apply_async(run_one)
            async_res.append(ar)

        print "Submitted tasks: ", len(async_res)
        
        self.rc.wait(async_res)
        t2 = time.time()
        print "Completed in %d sec" %(t2-t1)

        res = [ar.get() for ar in async_res]

        return res
コード例 #2
0
    def parallel_combinatorialSelection(self,
                                        target,
                                        N=2,
                                        n_jobs=None,
                                        c=None):
        '''
        score_log:
            key - name of feature removed
            val - expected value of class1 withou the key feature
        This works with N=1, where expected vals with each feature
        is calculated.
        '''
        if N > self.num_features:
            print('Error: N has to be smaller than num_features')
            return

        def getExp2(combo):
            test_feature = self.data[list(combo)]
            jp = JointProbability()
            jp.fit(test_feature, target)
            contingency = jp.contingency
            E = np.sum(contingency[1] * contingency['cond_proba'])
            return E

        # Set up parallel calculation
        if c is None:
            c = Client(profile="default")
        else:
            c = c

        feature_combo = list(combinations(self.feature_list_, N))

        if n_jobs is None:
            vals = c[:].map(getExp2, feature_combo)
        else:
            vals = c[:n_jobs].map(getExp2, feature_combo)
        c.wait(vals)

        expected_vals = dict(zip(feature_combo, vals.get()))

        self.best_expected_value_ = np.max(vals.get())
        best_ind = np.argmax(vals.get())
        self.best_combination_ = feature_combo[best_ind]

        return expected_vals
コード例 #3
0
ファイル: clienttest.py プロジェクト: kapukiran94/ipyparallel
    def connect_client(self):
        """connect a client with my Context, and track its sockets for cleanup"""
        c = Client(profile='iptest', context=self.context)
        c.wait = lambda *a, **kw: self.client_wait(c, *a, **kw)

        for name in filter(lambda n: n.endswith('socket'), dir(c)):
            s = getattr(c, name)
            s.setsockopt(zmq.LINGER, 0)
            self.sockets.append(s)
        return c
コード例 #4
0
ファイル: clienttest.py プロジェクト: CaptainAL/Spyder
 def connect_client(self):
     """connect a client with my Context, and track its sockets for cleanup"""
     c = Client(profile='iptest', context=self.context)
     c.wait = lambda *a, **kw: self.client_wait(c, *a, **kw)
     
     for name in filter(lambda n:n.endswith('socket'), dir(c)):
         s = getattr(c, name)
         s.setsockopt(zmq.LINGER, 0)
         self.sockets.append(s)
     return c
コード例 #5
0
def par_value(n):
    """
    Parallel option valuation

    Parameters
    ==========
    n: int
        number of option valuations/strikes
    """
    import numpy as np
    from ipyparallel import Client
    
    c = Client(profile="default")
    view = c.load_balanced_view()

    strikes = np.linspace(80, 20, n)
    option_values = []
    for strike in strikes:
        values = view.apply_async(bsm_mcs_valuation, strike)
        option_values.append(values)
    c.wait(option_values)
    return strikes, option_values
コード例 #6
0
ファイル: clienttest.py プロジェクト: kapukiran94/ipyparallel
 def client_wait(self, client, jobs=None, timeout=-1):
     """my wait wrapper, sets a default finite timeout to avoid hangs"""
     if timeout < 0:
         timeout = self.timeout
     return Client.wait(client, jobs, timeout)
コード例 #7
0
ファイル: clienttest.py プロジェクト: CaptainAL/Spyder
 def client_wait(self, client, jobs=None, timeout=-1):
     """my wait wrapper, sets a default finite timeout to avoid hangs"""
     if timeout < 0:
         timeout = self.timeout
     return Client.wait(client, jobs, timeout)