示例#1
0
 def __init__(self, *args,**kwargs):
     Distribution.__init__(self)
     # parse parameters correctly
     param = None
     if len(args) > 0:
         param = args[0]
     if kwargs.has_key('param'):
         if param == None:
             param = kwargs['param']
         else:
             for k,v in kwargs['param'].items():
                 param[k] = v
     if len(kwargs)>0:
         if param == None:
             param = kwargs
         else:
             for k,v in kwargs.items():
                 if k != 'param':
                     param[k] = v
     
     # set default parameters
     self.name = 'Gamma Distribution'
     self.param = {'u':1.0,'s':1.0}
     if param != None:
         for k in param.keys():
             self.param[k] = float(param[k])
     self.primary = ['u','s']
示例#2
0
 def __setitem__(self,key,value):
     Distribution.__setitem__(self,key,value)
     if key == 'mu':
         self.param['mu'] = value
     if key == 'sigma':
         self.param['sigma'] = value
         self.cholP = solve_triangular(cholesky(self.param['sigma']).T,eye(self['n'])).T
     if key == 'CholP':
         self.cholP = value
         self.param['sigma'] = solve(self.cholP.T,solve(self.cholP,eye(self.param['n'])))
示例#3
0
    def create_from_bucket(col_name, buckets):
        b = {}
        for val in buckets:
            if 'grades' not in buckets[val]:
                b[val] = buckets[val]
                continue
            grades = []
            for g in buckets[val]['grades']:
                a = np.array([])
                for split in g['split_count']:
                    a = np.append(a, split)
                grades.append(Distribution(a))

            salaries = []
            for s in buckets[val]['salaries']:
                a = np.array([])
                for split in s['split_count']:
                    a = np.append(a, split)
                salaries.append(Distribution(a))

            b[val] = Bucket(col_name, val, grades, salaries)
        return b
 def set_simulation_distributions(self):
     """
     Método de clase
     Se inicializan cada una de las simulaciones y sus respectivos parámetros
     """
     # Se crea un diccionario para manejar los identificadores de cada distribución
     distribution_dictionary = {
         1: "Direct",
         2: "TLC",
         3: "Uniform",
         4: "Exponential",
         5: "Density"
     }
     # Se realiza la solicitud de los datos de cada una de las 6 distribuciones
     for i in range(6):
         dist = Distribution()
         # Se pregunta cual distribución desa asignar a la distribución de la simulación: D_i
         option = self.interface.ask_distribution("D" + str(i + 1))
         # Según la distribución señalada entonces se asígna el identificador
         dist.id = distribution_dictionary[option]
         # Se piden los parámetros que necesita la distribución elegida
         self.set_dist_parameters(dist)
         # Agrega la distribución al diccionario de distribuciones en su ubicación asociada
         self.distribution_list["D" + str(i + 1)] = dist
示例#5
0
    def test_oosDistribution(self):
        np.random.seed(100)
        expected = self.dist['oos'].getEvent()

        np.random.seed(100)
        actual = self.server._oosDistribution.getEvent()
        self.assertAlmostEqual(expected, actual)

        # replace the downtime distribution and check
        np.random.seed(200)
        expected = np.random.normal(100, 30)

        np.random.seed(200)
        self.server.oosDistribution = Distribution("normal(100,30)")
        actual = self.server._oosDistribution.getEvent()
        self.assertAlmostEqual(expected, actual)
 async def appendfrom(self, content, i):
     distribution = None
     while i < len(content):
         if await is_emoji(content[i][0]):
             if distribution:
                 await Distribution.load(distribution, content[start:i])
             if content[i][0] in self.distributions:
                 distribution = self.distributions[content[i][0]]
             else:
                 distributionid = content[i].split(" ")
                 if len(distributionid) > 1:
                     distribution = Distribution(distributionid[1])
                     self.distributions[content[i][0]] = distribution
             start = i+1
         i += 1
     if distribution:
         await Distribution.load(distribution, content[start:i])
示例#7
0
def readDistributions(iFilename):
    """Read JSON file *iFileName* and return its list of distributions."""
    try:
        file = open(iFilename)
    except IOError:
        print('Cannot open file : ', iFilename)
        exit()

    n = 1
    lDistList = []
    for lDist in json.load(file):
        lDistList.append(Distribution(lDist, n))
        n += 1

    if gAbort: exit()

    return lDistList
示例#8
0
    def init(self):
        self.cfg = RebuilddConfig()

        # Init log system
        RebuilddLog()

        self._sqlconnection = sqlobject.connectionForURI(
            self.cfg.get('build', 'database_uri'))
        sqlobject.sqlhub.processConnection = self._sqlconnection

        # Create distributions
        for dist in self.cfg.get('build', 'dists').split(' '):
            for arch in self.cfg.arch:
                Dists().add_dist(Distribution(dist, arch))

        self.do_quit = threading.Event()
        self.jobs_locker = threading.Lock()
        self.job_finished = threading.Event()
示例#9
0
    def test_setArrivalTimeDistribution(self):
        # save the state, Distribution will have generated it's first RV
        rstate = np.random.get_state()

        # add a valid destination to the SourcePopulation
        dest = SimQueue('test_dest', Assigner().assignInSequence)
        self.sp.addCustomerDestination(dest)

        # set seed and generate expected results
        np.random.seed(100)
        expected = list(np.cumsum(np.random.triangular(10, 20, 40, 10)))
        print(f'expected near line {sys._getframe().f_lineno}: {expected}')

        # reset state and generate test values
        np.random.set_state(rstate)
        actual = list()

        for i in range(10):
            with self.subTest(i=i):
                actual.append(self.sp.getNextEventTime())
                self.sp.processEvent(self.sp.getNextEventTime())
                self.assertAlmostEqual(expected[i], actual[i])

        # capture seed state
        rstate = np.random.get_state()
        temp = np.zeros(10)
        temp[1:10] = np.random.uniform(10, 20, 9)
        expected = self.sp.getNextEventTime() + np.cumsum(temp)
        print(f'expected near line {sys._getframe().f_lineno}: {expected}')

        # restore the random state
        np.random.set_state(rstate)
        self.sp.setArrivalTimeDistribution(Distribution("uniform(10, 20)"))

        # reset state and generate test values
        np.random.set_state(rstate)
        actual = list()

        for i in range(10):
            with self.subTest(i=i):
                actual.append(self.sp.getNextEventTime())
                self.sp.processEvent(self.sp.getNextEventTime())
                self.assertAlmostEqual(expected[i], actual[i])
示例#10
0
    def __movement(self, particle):

        dvest = self.__dynamicDvest()
        media = 1

        isValid = False

        #Exploracion de una particula o salto Gausseano
        while( not isValid ):

            new_particle = []

            #Se generan un arreglo [0,0,1,1,0,...] segun la distribucion Gaussiana
            for element in particle.get_elements():
                newElement = Binarization.toBinary(Distribution.gaussian(Distribution, media, dvest))
                new_particle.append(newElement)

            new_particle = Particle(new_particle, self._weightParticle(new_particle) ,self._fitness(new_particle))
            isValid = self._isValid(new_particle)


        return new_particle
示例#11
0
 def __getdistributions(self):
     distributions = self.__doc.getElementsByTagName("distributions")
     distribution = distributions[0].getElementsByTagName("distribution")
     output = []
     retester = re.compile('\(([^)]+)\)')
     for x in distribution:
         completestring = x.getAttribute("type")
         auxiliarstring = retester.search(completestring)
         params = None
         if (auxiliarstring != None):
             params = auxiliarstring.group(0)[1:-1]
             firstbrack = auxiliarstring.regs[0][0]
             name = completestring[0:firstbrack]
         else:
             name = completestring
         classesids = []
         for classaux in x.getElementsByTagName("class"):
             classesids.append(int(classaux.getAttribute("id"), 10))
         reqpen = x.getAttribute("required")
         if (reqpen == ''):
             reqpen = int(x.getAttribute("penalty"), 10)
         output.append(Distribution(name, params, classesids, reqpen))
     return output
示例#12
0
    def writeSelectedVars(data, filename):
        outf = open(filename, 'w')
        outf.write('PSUADE\n')

        #Write inputs
        outf.write('INPUT\n')
        outf.write('   dimension = %d\n' % data.getNumInputs())
        names = data.getInputNames()
        mins = data.getInputMins()
        maxs = data.getInputMaxs()
        indices = range(data.getNumInputs())
        for i, name, minimum, maximum in zip(indices, names, mins, maxs):
            outf.write('   variable %d %s = %e %e\n' %
                       (i + 1, name, minimum, maximum))
        distributions = data.getInputDistributions()
        for i, dist in zip(indices, distributions):
            distType = dist.getDistributionType()
            distParams = dist.getParameterValues()
            if distType != Distribution.UNIFORM:
                outf.write('   PDF %d %c %e' %
                           (i + 1, Distribution.getPsuadeName(distType),
                            distParams[0]))
                if distParams[1] is not None:
                    outf.write(' %e' % distParams[1])
                outf.write('\n')
        outf.write('END\n')

        #Write outputs
        outf.write('OUTPUT\n')
        outf.write('   dimension = %d\n' % data.getNumOutputs())
        names = data.getOutputNames()
        indices = range(data.getNumOutputs())
        for i, name in zip(indices, names):
            outf.write('   variable %d %s\n' % (i + 1, name))
        outf.write('END\n')

        outf.write('END\n')
示例#13
0
def apply_relation(target_dist, landmark_dist, relation, negated, objects):
    global relation_word_classifiers
    if relation  not in relation_word_classifiers: 
        relation = "UNK_REL"
        negated = False
        
    combined = Distribution()
    for t in objects:
        for l in objects:
            if t == l: continue
            if negated:
                features = get_relational_features(objects[l], objects[t])
            else:
                features = get_relational_features(objects[t], objects[l])
                
            p = logreg.classify_obj(relation, relation_word_classifiers, features.values())
            combined.add(make_id(t,l), target_dist.get(t) * landmark_dist.get(l) * p)    
            
    combined.marginalise()
    return combined
示例#14
0
 def dist(self, distribution):
     if distribution == 'expon':
         time_beta1 = Distribution(stats.expon(
             scale=(self.beta1)))  #time in private room by mobile patients
         time_beta2 = Distribution(stats.expon(scale=(
             self.beta2)))  # time in private room by immobile patients
         time_delta1 = Distribution(stats.expon(
             scale=(self.delta1)))  # time in common room by mobile patients
         time_delta2 = Distribution(stats.expon(scale=(
             self.delta2)))  # time in common room by immobile patients
         time_tau = Distribution(
             stats.expon(scale=(self.tau)))  # time in gym
         time_mu = Distribution(
             stats.expon(scale=(self.mu)))  # serving time
     elif distribution == 'uniform':
         time_beta1 = Distribution(
             stats.uniform(
                 (0.25 * self.beta1),
                 (1.75 *
                  self.beta1)))  #time in private room by mobile patients
         time_beta2 = Distribution(
             stats.uniform(
                 (0.25 * self.beta2),
                 (1.75 *
                  self.beta2)))  # time in private room by immobile patients
         time_delta1 = Distribution(
             stats.uniform(
                 (0.25 * self.delta1),
                 (1.75 *
                  self.delta1)))  # time in common room by mobile patients
         time_delta2 = Distribution(
             stats.uniform(
                 (0.25 * self.delta2),
                 (1.75 *
                  self.delta2)))  # time in common room by immobile patients
         time_tau = Distribution(
             stats.uniform((0.25 * self.tau),
                           (1.75 * self.tau)))  # time in gym
         time_mu = Distribution(
             stats.uniform((0.25 * self.mu),
                           (1.75 * self.mu)))  # serving time
     return (time_beta1, time_beta2, time_delta1, time_delta2, time_tau,
             time_mu)
示例#15
0
    def readSampleFromPsuadeFile(fileName, returnModelOnly = False):
        f = open(fileName, 'r')
        lines = f.readlines()
        f.close()

        model = Model()
        path, fname = os.path.split(fileName)  # exclude path from file name
        model.setName(fname)

        namesIncludeNodes = False
        hasSampleData = False
        readData = False
        readInputs = False
        readOutputs = False
        numInputs = None
        driverName = None
        optDriverName = None
        auxDriverName = None
        sampleType = None
        legendreOrder = None
        sampleMethod = None
        inputData = None
        outputData = None
        runState = None

        inputNames = []
        outputNames = []
        inputTypes = []
        inputMins = []
        inputMaxs = []
        inputDefaults = []
        inputDists = []
        inputDistParam1s = []
        inputDistParam2s = []
    
        for line in lines:
            if line[0] == '#' and 'NAMESHAVENODES' in line:
                namesIncludeNodes = True
            if len(line) > 0 and line[0] != '#': #Not comment
                if line.startswith('PSUADE_IO'):
                    readData = not readData
                    hasSampleData = True
                elif line.startswith('INPUT'):
                    readInputs = True
                elif line.startswith('OUTPUT'):
                    readOutputs = True
                elif line.startswith('END'):
                    if readInputs:
                        readInputs = False
                    elif readOutputs:
                        readOutputs = False
                elif readData: # Read samples
                    if numInputs is None: #Have not read number of inputs
                        nums = line.split()
                        numInputs = int(nums[0])
                        numOutputs = int(nums[1])
                        numSamples = int(nums[2])
                        runState = [False]*numSamples
                        inputData = [0]*numSamples
                        outputData = [0]*numSamples
                        readSampleData = False
                    elif not readSampleData: # Sample number and run state
                        nums = line.split()
                        sampleNum = int(nums[0]) - 1
                        runState[sampleNum] = bool(int(nums[1]))
                        readSampleData = True
                        numValuesRead = 0
                        sampleInputs = [0] * numInputs
                        sampleOutputs = [0] * numOutputs
                    else:
                        if numValuesRead < numInputs: #Input value
                            if line.strip() in ['9.9999999999999997e+34', '9.9999999999999997e+034']:
                                line = 'nan'
                            sampleInputs[numValuesRead] = float(line)
                            numValuesRead = numValuesRead + 1
                        else: #Output value
                            if line.strip() in ['9.9999999999999997e+34', '9.9999999999999997e+034']:
                                line = 'nan'
                            sampleOutputs[numValuesRead - numInputs] = float(line)
                            numValuesRead = numValuesRead + 1
                            if numValuesRead - numInputs == numOutputs:
                                inputData[sampleNum] = sampleInputs
                                outputData[sampleNum] = sampleOutputs
                                readSampleData = False
                elif readInputs: # Read inputs
                    stripped = line.strip()
                    values = stripped.split()
                    if values[0] == 'variable': # Variable name min max
                        inputNames = inputNames + [values[2]]
                        inputTypes = inputTypes + [Model.VARIABLE]
                        inputMins = inputMins + [float(values[4])]
                        inputMaxs = inputMaxs + [float(values[5])]
                        inputDefaults = inputDefaults + [(float(values[4]) + float(values[5])) / 2]
                        inputDists = inputDists + ['U']
                        inputDistParam1s = inputDistParam1s + [None]
                        inputDistParam2s = inputDistParam2s + [None]
                    elif values[0] == 'fixed': # Fixed variable
                        inputNames = inputNames + [values[2]]
                        inputTypes = inputTypes + [Model.FIXED]
                        fixedVal = float(values[4])
                        inputMins = inputMins + [fixedVal]
                        inputMaxs = inputMaxs + [fixedVal]
                        inputDefaults = inputDefaults + [fixedVal]
                        inputDists = inputDists + ['U']
                        inputDistParam1s = inputDistParam1s + [None]
                        inputDistParam2s = inputDistParam2s + [None]
                        # Insert input values
                        if hasSampleData:
                            for i in xrange(len(inputData)):
                                inputRow = inputData[i]
                                inputRow.insert(len(inputNames) - 1, fixedVal)
                                inputData[i] = inputRow
                    elif values[0] == 'PDF': # Distribution
                        index = int(values[1]) - 1
                        inputDists[index] = values[2]
                        if len(values) > 3:
                            if values[2] == Distribution.getPsuadeName(Distribution.SAMPLE):
                                inputDistParam1s[index] = values[3]
                            else:
                                inputDistParam1s[index] = float(values[3])
                            if len(values) > 4:
                                inputDistParam2s[index] = float(values[4])
                            
                elif readOutputs: # Read outputs
                    stripped = line.strip() # Variable name
                    if stripped.startswith('variable'):
                        values = stripped.split()
                        outputNames = outputNames + [values[2]]
                else:
                    stripped = line.strip()
                    values = stripped.split()
                    if values[0] == 'sampling': #Sampling method
                        sampleMethod = values[2]
                    elif values[0] == 'driver': #Driver
                        if values[2] == 'NONE':
                            values[2] = None
                        driverName = values[2]
                        if values[2] is not None and values[2] != 'PSUADE_LOCAL' and not os.path.exists(driverName):
                            # Check if driver exists in same directory as this file
                            if os.path.exists(os.path.join(path, driverName)):
                                driverName = os.path.join(path, driverName)
                            else: # Don't set the name because the file does not exist
                                driverName = None
                    elif values[0] == 'opt_driver': #Optimization driver
                        if values[2] == 'NONE':
                            values[2] = None
                        optDriverName = values[2]
                        if values[2] is not None and values[2] != 'PSUADE_LOCAL' and not os.path.exists(optDriverName):
                            # Check if driver exists in same directory as this file
                            if os.path.exists(os.path.join(path, optDriverName)):
                                optDriverName = os.path.join(path, optDriverName)
                            else: # Don't set the name because the file does not exist
                                optDriverName = None
                    elif values[0] == 'aux_opt_driver': #Batch simulation driver
                        if values[2] == 'NONE':
                            values[2] = None
                        auxDriverName = values[2]
                        if values[2] is not None and not os.path.exists(auxDriverName):
                            # Check if driver exists in same directory as this file
                            if os.path.exists(os.path.join(path, auxDriverName)):
                                auxDriverName = os.path.join(path, auxDriverName)
                            else: # Don't set the name because the file does not exist
                                auxDriverName = None
                    elif values[0] == 'num_samples': #Number of samples
                        numSamples = int(values[2])
                    elif values[0] == 'analyzer': # Analysis values
                        if values[1] == 'rstype':
                            sampleType = values[3]
                            sampleType = ResponseSurfaces.getEnumValue(sampleType)
                        elif values[1] == 'rs_legendre_order':
                            legendreOrder = int(values[3])
                            
                        
        model.setInputNames(inputNames)
        model.setOutputNames(outputNames)
        model.setNamesIncludeNodes(namesIncludeNodes)
        model.setInputTypes(inputTypes)
        model.setInputMins(inputMins)
        model.setInputMaxs(inputMaxs)
        model.setInputDefaults(inputDefaults)
        model.setSelectedOutputs(range(len(outputNames)))
        model.setDriverName(driverName)
        model.setOptDriverName(optDriverName)
        model.setAuxDriverName(auxDriverName)
        model.setRunType(Model.LOCAL) 
##        print model.getInputNames()
##        print model.getOutputNames()
##        print model.getInputDistributions()
##        print model.getNumSamples()
##        print model.getNumInputs()
##        print model.getNumOutputs()
##        print model.getInputMins()
##        print model.getInputMaxs()
##        from SamplingMethods import SamplingMethods
##        print SamplingMethods.getFullName(model.getSampleMethod())
##        print model.getDriver()
        if returnModelOnly:
            return model

        data = SampleData(model)
        data.setFromFile(True)
        data.setNumSamples(numSamples)
        if sampleMethod is None:
            data.setSampleMethod(SamplingMethods.MC)
        else:
            data.setSampleMethod(sampleMethod)
        data.setInputDistributions(inputDists, inputDistParam1s, inputDistParam2s)
        data.setSampleRSType(sampleType)
        data.setLegendreOrder(legendreOrder)
        if inputData:
            data.setInputData(inputData)
        if outputData:
            data.setOutputData(outputData)
        if runState:
            data.setRunState(runState)
        return data
示例#16
0
class CBayesPosterior:

    # Class attributes:
    # - p_obs: the observed density
    # - p_prior: the prior
    # - p_prior_pf: the push-forward of the prior
    # - p_post: the posterior
    # - p_post_pf: the push-forward of the posterior
    # - r: the ratio between p_obs and p_prior_pf evaluations
    # - acc_rate: the acceptance rate of the sampling algorithm

    # Constructor
    def __init__(self, p_obs, p_prior, p_prior_pf):

        assert type(
            p_obs
        ) is Distribution, "p_obs is not of type Distribution: %r" % p_obs
        assert type(
            p_prior
        ) is Distribution, "p_prior is not of type Distribution: %r" % p_prior
        assert type(
            p_prior_pf
        ) is Distribution, "p_prior_pf is not of type Distribution: %r" % p_prior_pf

        if p_obs.n_dim > 3:
            print('Framework has only been tested with up to 3 QoIs.')
            exit()

        self.p_obs = p_obs
        self.p_prior = p_prior
        self.p_prior_pf = p_prior_pf
        self.p_post = None
        self.p_post_pf = None
        self.r = None
        self.acc_rate = None
        self.acc_idx = None

    # Perform accept/reject sampling on a set of proposal samples using the weights r associated with the set of
    # samples and return the indices idx of the proposal sample set that are accepted.
    def generate_posterior_samples(self):

        # Calculate the weights
        r = np.divide(
            self.p_obs.kernel_density(np.squeeze(self.p_prior_pf.samples).T) +
            1e-10,
            self.p_prior_pf.kernel_density(
                np.squeeze(self.p_prior_pf.samples).T))

        # Check against
        check = np.random.uniform(low=0, high=1, size=r.size)

        # Normalize weights
        r_scaled = r / np.max(r)

        # Evaluate criterion
        idx = np.where(r_scaled >= check)[0]

        self.r = r
        self.acc_rate = idx.size / r.shape[0]

        if self.acc_rate < 1.0e-2:
            warnings.warn('Small acceptance rate: %f / %d accepted samples.' %
                          (self.acc_rate, idx.size))

        return self.p_prior.samples[idx], self.p_prior_pf.samples[idx]

    # Create the posterior and its push-forward
    def setup_posterior_and_pf(self):

        # Sample the posterior
        post_samples, post_pf_samples = self.generate_posterior_samples()

        # Create a posterior distribution
        self.p_post = Distribution(samples=post_samples,
                                   rv_name=self.p_prior.rv_name,
                                   rv_transform=self.p_prior.rv_transform,
                                   label='Updated',
                                   kde=False)

        # Create the posterior push-forward distribution
        self.p_post_pf = Distribution(samples=post_pf_samples,
                                      rv_name=self.p_obs.rv_name,
                                      rv_transform=self.p_obs.rv_transform,
                                      label='PF Updated')

    # Get the KL between prior and posterior
    def get_prior_post_kl(self):
        return np.mean(self.r * np.log(self.r))

    # Print a bunch of output diagnostics
    def print_stats(self):

        print('')
        print('########### CBayes statistics ##########')
        print('')

        # The rejection sampling acceptance rate
        print('Acceptance rate:\t\t\t\t%f' % self.acc_rate)

        # The posterior push-forward mean and std
        # (these should match the observed density)
        print('Posterior push-forward mean:\t%s' % self.p_post_pf.mean())
        print('Posterior push-forward std:\t\t%s' % self.p_post_pf.std())

        # The KL between the push-forward of the posterior and the observed density
        # (this should be very close to zero)
        print('Posterior-PF-Obs KL:\t\t\t%f' %
              self.p_post_pf.calculate_kl_divergence(self.p_obs))

        # The posterior integral
        # (this should be very close to 1.0)
        print('Posterior integral:\t\t\t\t%f' % np.mean(self.r))

        # The KL between posterior and prior (i.e. how informative is the data?)
        # This is done via r / doing KDE for the prior and posterior densities is infeasible when the number of
        # random variables is large.
        print('Posterior-Prior KL:\t\t\t\t%f' %
              np.mean(self.r * np.log(self.r)))

        print('')
        print('########################################')
        print('')

    # Plot results
    def plot_results(self, model_tag='hf'):

        # Determine bounds
        xmin = np.min(
            [np.min(self.p_prior_pf.samples),
             np.min(self.p_obs.samples)])
        xmax = np.max(
            [np.max(self.p_prior_pf.samples),
             np.max(self.p_obs.samples)])

        # Plot
        if self.p_obs.n_dim == 1:
            self.p_prior_pf.plot_kde(color='C0', xmin=xmin, xmax=xmax)
            self.p_obs.plot_kde(color='C1', xmin=xmin, xmax=xmax)
            self.p_post_pf.plot_kde(color='C2',
                                    linestyle='--',
                                    xmin=xmin,
                                    xmax=xmax)

        elif self.p_obs.n_dim == 2:
            sns.kdeplot(self.p_prior_pf.samples[:, 0],
                        self.p_prior_pf.samples[:, 1],
                        shade=True,
                        shade_lowest=False,
                        cmap='Blues',
                        label='PF-initial',
                        color='C0')
            sns.kdeplot(self.p_obs.samples[:, 0],
                        self.p_obs.samples[:, 1],
                        shade=True,
                        shade_lowest=False,
                        cmap='Reds',
                        label='Observed density',
                        color='C3')
            sns.kdeplot(self.p_post_pf.samples[:, 0],
                        self.p_post_pf.samples[:, 1],
                        cmap='Greys',
                        alpha=1.0,
                        label='PF-updated',
                        color='Black')
            plt.legend(loc='upper right')
            plt.xlabel('$Q_1$')
            plt.ylabel('$Q_2$')
        else:
            return

        plt.grid(b=True)
        plt.gcf().savefig('output/cbayes_dists_%s.pdf' % model_tag, dpi=300)

        # Plot some bivariate distributions
        if self.p_obs.n_dim == 2 and model_tag == 'hf':
            self.p_obs.plot_kde()
            plt.grid(b=True)
            plt.gcf().savefig('output/cbayes_dists_obs.pdf', dpi=300)
            plt.clf()
            self.p_post_pf.plot_kde()
            plt.grid(b=True)
            plt.gcf().savefig('output/cbayes_dists_hf_post_pf.pdf', dpi=300)

        plt.clf()

    # Plot posterior
    def plot_posterior(self,
                       fignum=1,
                       color='C0',
                       linestyle='-',
                       label='Posterior',
                       save_fig=False):

        if self.p_obs.n_dim == 1 and self.p_post.n_dim == 1:
            self.p_post.create_kernel_density()
            xmin = np.min(self.p_prior.samples, axis=0)
            xmax = np.max(self.p_prior.samples, axis=0)
            self.p_post.plot_kde(fignum=fignum,
                                 color=color,
                                 linestyle=linestyle,
                                 label=label,
                                 xmin=xmin,
                                 xmax=xmax)
            if save_fig:
                plt.grid(b=True)
                plt.gcf().savefig('output/cbayes_post_densities.pdf', dpi=300)

        elif self.p_post.n_dim == 2:
            self.p_post.create_kernel_density()
            self.p_post.plot_kde(fignum=fignum,
                                 color=color,
                                 linestyle=linestyle,
                                 label=label)
            if save_fig:
                xmin = np.min(self.p_prior.samples[:, 0], axis=0)
                xmax = np.max(self.p_prior.samples[:, 0], axis=0)
                ymin = np.min(self.p_prior.samples[:, 1], axis=0)
                ymax = np.max(self.p_prior.samples[:, 1], axis=0)
                plt.xlim([xmin, xmax])
                plt.ylim([ymin, ymax])
                plt.grid(b=True)
                plt.gcf().savefig('output/cbayes_post_densities.pdf', dpi=300)
                plt.clf()
示例#17
0
def perform_eval(eid, data):
    global word_classifiers
    global relation_word_classifiers
    global results_outfile
    
    target_dist = Distribution(data['objects'])
    landmark_dist = Distribution(data['objects'])
    target = data['target']
    increment_data = []
    relation = None

    relation_is_negated = False
    inc = 1
    prev_rank = len(data['objects'])
    for w,tags in [(w['word'],w['tags']) for w in data['speech']]:
        utt = {}
        word = None
        c_rank = None
        relation_dist = None
        prepare_word(utt, w, tags)
        objects = data['objects']
        if 't' in utt:
            word = utt['t'][0]
            target_dist.update(logreg.classify(word, word_classifiers, objects))
        if 'l' in utt:
            word = utt['l'][0]
            landmark_dist.update(logreg.classify(word, word_classifiers, objects))
        if 'r' in utt:
            word = utt['r'][0]
            if relation is not None: relation += '_' + word 
            else: relation = word
        if 'r-' in utt:
            word = utt['r-'][0]
            if relation is not None: relation += '_' + word 
            else: relation = word
            relation_is_negated = True            
                
        if relation is not None: # indent this with above for loop to make it incremental
            tdist = target_dist.copy()
            ldist = landmark_dist.copy()
            relation_dist = apply_relation(tdist, ldist, relation, relation_is_negated, objects)
            
    if relation_dist is not None:      
        return relation_dist.rank(target)
    else:
        target_dist.normalise()
        return target_dist.rank(target) 
示例#18
0
    p_hf = 5
    p_mf = 3
    p_lf = 1
    ref_model = Model(eval_fun=lambda x: lambda_p.lambda_p(x, p_hf),
                      rv_samples=prior_samples,
                      n_evals=n_mc_ref,
                      n_qoi=n_qoi,
                      rv_name='$Q$',
                      label='MC reference')

    # Brute force Monte Carlo
    ref_prior_pf_samples = ref_model.evaluate()

    # Prior
    p_prior = Distribution(prior_samples,
                           rv_name='$\lambda$',
                           label='Prior',
                           kde=False)

    # Prior push-forward
    ref_p_prior_pf = Distribution(ref_prior_pf_samples,
                                  rv_name='$Q$',
                                  label='Prior-PF')
    ref_p_prior_pf.eval_kernel_density()

    # Observed density
    obs_loc = [0.25]
    obs_scale = [0.1]
    obs_samples = np.random.randn(n_mc_ref,
                                  len(obs_scale)) * obs_scale + obs_loc
    obs_samples = np.reshape(obs_samples, (n_mc_ref, np.shape(obs_samples)[1]))
    p_obs = Distribution(obs_samples, rv_name='$Q$', label='Observed')
示例#19
0
    def __init__(self, mu=0, sigma=1):

        Distribution.__init__(self, mu, sigma)
示例#20
0
    def create_distribution(self):

        self.distribution = Distribution(samples=self.model_evals_pred,
                                         rv_name=self.rv_name,
                                         label=self.label)
示例#21
0
 def uniform_noise(loc=0, scale=1):
     return Distribution(scipy.stats.uniform(loc=loc, scale=scale))
    total_costs_2lf = (costs_hf + costs_mf) * n_evals_mfmc_hf_2lf + costs_mf * n_evals_mfmc_mf_2lf + costs_lf * n_evals_mfmc_lf_2lf
    total_costs_2lf = np.round(total_costs_2lf).astype(int)

    # Load data
    n_qoi = 3
    prior_pf_samples = elliptic_pde.load_data()
    prior_pf_samples_hf = prior_pf_samples[-1][:, 0:n_qoi]
    prior_pf_samples_mf = prior_pf_samples[1][:, 0:n_qoi] ** 1.1
    prior_pf_samples_lf = prior_pf_samples[0][:, 0:n_qoi] ** 1.2
    prior_samples = np.reshape(range(n_mc_ref), (n_mc_ref, 1))  # we only need some id here

    # Create the MC reference samples
    ref_prior_pf_samples = prior_pf_samples_hf[:n_mc_ref]

    # Prior
    p_prior = Distribution(prior_samples, rv_name='$\lambda$', label='Prior', kde=False)

    # Prior push-forward
    ref_p_prior_pf = Distribution(ref_prior_pf_samples, rv_name='$Q$', label='Prior-PF')
    ref_p_prior_pf.eval_kernel_density()

    l1_prior_pf_1hf_avg = np.zeros((n_grid,))
    l1_prior_pf_1hf_1lf_avg = np.zeros((n_grid,))
    l1_prior_pf_1hf_2lf_avg = np.zeros((n_grid,))
    for k in range(n_avg):
        print('\nRun %d / %d' % (k + 1, n_avg))

        # -------------- 1 HF

        l1_prior_pf_1hf = []
        for idx, n_evals in enumerate(n_evals_mc):
示例#23
0
from Assigner import Assigner
from Server import Server
from SystemExit import SystemExit
from Experience import Experience
from QueueEvent import QueueEvent
from ServerState import ServerState
from ServerEvent import ServerEvent
import copy

np.random.seed(100)
# first setup a queue
testq_org = SimQueue('Q1', Assigner().assignInSequence)

# then setup servers
dist = {}
dist['dt'] = Distribution("triangular(14400, 14400, 18000)")
dist['oos'] = Distribution("triangular(300, 600, 1200)")
dist['st'] = Distribution("exponential(1/300)")

# uncomment to test validity of server construction
# for k, v in self.dist.items():
#     with self.subTest(dist=k):
#         self.assertTrue(v.isValid())

dist['invalid'] = Customer('teddy', 0)

servers = [
    Server(f'Server{i}', 100 * i, dist['dt'], dist['oos'], dist['st'])
    for i in range(1, 4)
]
示例#24
0
    def writeToPsuade(self, filename, fixedAsVariables=False):
        outf = open(filename, 'w')
        if self.getNamesIncludeNodes():
            outf.write('# NAMESHAVENODES\n')
        outf.write('PSUADE_IO (Note : inputs not true inputs if pdf ~=U)\n')
        types = self.getInputTypes()

        if fixedAsVariables:
            numInputs = self.getNumInputs()
        else:
            numInputs = types.count(Model.VARIABLE)
        outf.write('%d %d %d\n' %
                   (numInputs, self.getNumOutputs(), self.getNumSamples()))

        #Write out data
        hasOutputData = False
        if self.outputData is not None:
            if isinstance(self.outputData, numpy.ndarray):
                if self.outputData.size > 0:
                    hasOutputData = True
            elif self.outputData:
                if isinstance(self.outputData[0], list) and len(
                        self.outputData[0]) == 0:
                    hasOutputData = False
                else:
                    hasOutputData = True
        for i in xrange(self.getNumSamples()):
            outf.write('%d %d\n' % (i + 1, self.runState[i]))
            for j in xrange(self.getNumInputs()):
                if types[j] == Model.VARIABLE or fixedAsVariables:
                    outf.write(' % .16e\n' % self.inputData[i][j])
            for j in xrange(self.getNumOutputs()):
                if hasOutputData and not numpy.isnan(self.outputData[i][j]):
                    outf.write(' % .16e\n' % self.outputData[i][j])
                else:
                    outf.write(' 9.9999999999999997e+34\n')

        outf.write('PSUADE_IO\n')
        outf.write('PSUADE\n')

        #Write inputs
        outf.write('INPUT\n')
        numFixed = self.getNumInputs() - numInputs
        if numFixed > 0:
            outf.write('   num_fixed %d\n' % numFixed)
        #outf.write('   dimension = %d\n' % self.getNumInputs())
        outf.write('   dimension = %d\n' % numInputs)
        names = self.getInputNames()
        mins = self.getInputMins()
        maxs = self.getInputMaxs()
        defaults = self.getInputDefaults()
        distributions = self.getInputDistributions()
        if not distributions or len(distributions) == 0:
            self.setInputDistributions([Distribution.UNIFORM] *
                                       self.getNumInputs())
            distributions = self.getInputDistributions()
            self.setInputDistributions([])

        fixedIndex = 1
        variableIndex = 1
        for name, minimum, maximum, inType, dist, default in map(
                None, names, mins, maxs, types, distributions, defaults):
            if not fixedAsVariables and inType == Model.FIXED:
                outf.write('   fixed %d %s =  % .16e\n' %
                           (fixedIndex, name, default))
                fixedIndex = fixedIndex + 1
            else:
                outf.write('   variable %d %s  =  % .16e  % .16e\n' %
                           (variableIndex, name, minimum, maximum))
                if dist is not None:
                    distType = dist.getDistributionType()
                    distParams = dist.getParameterValues()
                    if distType != Distribution.UNIFORM:
                        outf.write('   PDF %d %c' %
                                   (variableIndex,
                                    Distribution.getPsuadeName(distType)))
                        if distType == Distribution.SAMPLE:
                            fileString = distParams[0]
                            import platform
                            if platform.system() == 'Windows':
                                import win32api
                                fileString = win32api.GetShortPathName(
                                    fileString)
                            outf.write(' %s %d' % (fileString, distParams[1]))
                        else:
                            if distParams[0] is not None:
                                outf.write(' % .16e' % distParams[0])
                            if distParams[1] is not None:
                                outf.write(' % .16e' % distParams[1])
                        outf.write('\n')
                variableIndex = variableIndex + 1
        outf.write('END\n')

        #Write outputs
        outf.write('OUTPUT\n')
        outf.write('   dimension = %d\n' % self.getNumOutputs())
        names = self.getOutputNames()
        indices = range(self.getNumOutputs())
        for i, name in zip(indices, names):
            outf.write('   variable %d %s\n' % (i + 1, name))
        outf.write('END\n')

        #Write Method
        outf.write('METHOD\n')
        if self.getSampleMethod() != None:
            outf.write('   sampling = %s\n' %
                       SamplingMethods.getPsuadeName(self.getSampleMethod()))
        outf.write('   num_samples = %d\n' % self.getNumSamples())
        outf.write('   num_replications = 1\n')
        outf.write('   num_refinements = 0\n')
        outf.write('   refinement_size = 10000000\n')
        outf.write('   reference_num_refinements = 0\n')
        outf.write('END\n')

        #Write Application
        outf.write('APPLICATION\n')
        driverString = self.getDriverName()
        if driverString is None or not os.path.exists(driverString):
            driverString = 'NONE'
        else:
            import platform
            if platform.system() == 'Windows':
                import win32api
                driverString = win32api.GetShortPathName(driverString)
        outf.write('   driver = %s\n' % driverString)
        driverString = self.getOptDriverName()
        if driverString != 'PSUADE_LOCAL':
            if driverString is None or not os.path.exists(driverString):
                driverString = 'NONE'
            else:
                import platform
                if platform.system() == 'Windows':
                    import win32api
                    driverString = win32api.GetShortPathName(driverString)
        outf.write('   opt_driver = %s\n' % driverString)
        driverString = self.getEnsembleOptDriverName()
        if driverString != 'PSUADE_LOCAL':
            if driverString is None or not os.path.exists(driverString):
                driverString = 'NONE'
            else:
                import platform
                if platform.system() == 'Windows':
                    import win32api
                    driverString = win32api.GetShortPathName(driverString)
        outf.write('   ensemble_opt_driver = %s\n' % driverString)
        driverString = self.getAuxDriverName()
        if driverString is None or not os.path.exists(driverString):
            driverString = 'NONE'
        else:
            import platform
            if platform.system() == 'Windows':
                import win32api
                driverString = win32api.GetShortPathName(driverString)
        outf.write('   aux_opt_driver = %s\n' % driverString)
        outf.write('   max_job_wait_time = 1000000\n')
        outf.write('   save_frequency = 1\n')
        outf.write('END\n')

        #Write Analysis
        outf.write('ANALYSIS\n')
        outf.write('   analyzer output_id  = 1\n')
        rs = self.getSampleRSType()
        if rs == None:
            rs = 'MARS'
        else:
            rs = ResponseSurfaces.getPsuadeName(rs)
        outf.write('   analyzer rstype = %s\n' % rs)

        order = self.getLegendreOrder()
        if order is not None:
            outf.write('   analyzer rs_legendre_order = %d\n' %
                       self.getLegendreOrder())
        outf.write('   analyzer threshold = 1.000000e+00\n')
        outf.write('   diagnostics 1\n')
        outf.write('END\n')

        outf.write('END\n')
        outf.close()
示例#25
0
    def loadDict(self, sd):
        self.model = Model()
        try:
            self.model.loadDict(sd['model'])
        except:
            pass

        self.setID(sd.get('ID', ''))
        self.setNumSamples(sd.get('numSamples', 0))
        self.origNumSamples = sd.get('origNumSamples', self.getNumSamples())
        self.setNumSamplesAdded(sd.get('numSamplesAdded', 0))
        self.setFromFile(sd.get('fromFile', False))
        self.setSampleMethod(sd.get('sampleMethod', None))
        self.setInputData(sd.get('inputData', None))
        self.setOutputData(sd.get('outputData', None))
        self.setRunState(sd.get('runState', None))
        self.legendreOrder = sd.get('legendreOrder', None)
        self.fromFile = sd.get('fromFile', False)
        self.sampleRSType = ResponseSurfaces.getEnumValue(
            sd.get('sampleRSType'))
        self.turbineJobIds = sd.get("turbineJobIds", [])
        self.turbineSession = sd.get("turbineSession", None)
        self.turbineResub = sd.get("turbineResub", [])
        inputDists = []
        if 'inputDists' in sd:
            for distDict in sd['inputDists']:
                distr = Distribution(Distribution.UNIFORM)
                distr.loadDict(distDict)
                inputDists.append(distr)
        self.setInputDistributions(inputDists)
        self.analyses = []
        if 'analyses' in sd:
            for analDict in sd['analyses']:
                type = UQAnalysis.getTypeEnumValue(analDict['type'])
                if type == UQAnalysis.PARAM_SCREEN:
                    from ParameterScreening import ParameterScreening
                    anal = ParameterScreening(self, analDict['outputs'],
                                              analDict['subType'])
                elif type == UQAnalysis.UNCERTAINTY:
                    from UncertaintyAnalysis import UncertaintyAnalysis
                    anal = UncertaintyAnalysis(self, analDict['outputs'])
                elif type == UQAnalysis.CORRELATION:
                    from CorrelationAnalysis import CorrelationAnalysis
                    anal = CorrelationAnalysis(self, analDict['outputs'])
                elif type == UQAnalysis.SENSITIVITY:
                    from SensitivityAnalysis import SensitivityAnalysis
                    anal = SensitivityAnalysis(self, analDict['outputs'],
                                               analDict['subType'])
                elif type == UQAnalysis.VISUALIZATION:
                    from Visualization import Visualization
                    anal = Visualization(self, analDict['outputs'],
                                         analDict['inputs'])
                else:  #RS Analyses
                    userRegressionFile = analDict[
                        'userRegressionFile'] if 'userRegressionFile' in analDict else None
                    if type == UQAnalysis.RS_VALIDATION:
                        from RSValidation import RSValidation
                        testFile = analDict[
                            'testFile'] if 'testFile' in analDict else None
                        anal = RSValidation(self, analDict['outputs'],
                                            analDict['rs'],
                                            analDict['rsOptions'],
                                            analDict['genCodeFile'],
                                            analDict['nCV'],
                                            userRegressionFile, testFile)
                    elif type == UQAnalysis.RS_UNCERTAINTY:
                        from RSUncertaintyAnalysis import RSUncertaintyAnalysis
                        anal = RSUncertaintyAnalysis(self, analDict['outputs'],
                                                     analDict['subType'],
                                                     analDict['rs'],
                                                     analDict['rsOptions'],
                                                     userRegressionFile,
                                                     analDict['xprior'])
                    elif type == UQAnalysis.RS_SENSITIVITY:
                        from RSSensitivityAnalysis import RSSensitivityAnalysis
                        anal = RSSensitivityAnalysis(self, analDict['outputs'],
                                                     analDict['subType'],
                                                     analDict['rs'],
                                                     analDict['rsOptions'],
                                                     userRegressionFile,
                                                     analDict['xprior'])
                    elif type == UQAnalysis.INFERENCE:
                        from RSInference import RSInference
                        anal = RSInference(
                            self,
                            analDict['ytable'],
                            analDict['xtable'],
                            analDict['obsTable'],
                            analDict['genPostSample'],
                            analDict['addDisc'],
                            analDict['showList'],
                            userRegressionFile=userRegressionFile)
                    elif type == UQAnalysis.RS_VISUALIZATION:
                        from RSVisualization import RSVisualization
                        anal = RSVisualization(
                            self, analDict['outputs'], analDict['inputs'],
                            analDict['rs'], analDict['minVal'],
                            analDict['maxVal'], analDict['rsOptions'],
                            userRegressionFile)

                anal.loadDict(analDict)
                self.analyses.append(anal)
示例#26
0
	def __init__(self,mean,std):
		Distribution.__init__(self)
		self._std=std
		self._mean=mean
示例#27
0
 def gaussian_noise(lower=-0.5, upper=0.5):
     return Distribution(scipy.stats.truncnorm(a=lower, b=upper))
示例#28
0
 def standard(x=0):
   return 1 if Distribution.uniform(x) <= x else 0
示例#29
0
#!/usr/bin/env python3
import numpy as np
import matplotlib.pyplot as plt
from Distribution import Distribution
from IOTools import print_xml
from TileSet import TileSet

if __name__ == '__main__':
    # ts = TileSet('unittest/1.png', tile_dim=(16, 16))

    ts = TileSet('samples/tiled_images/Circuit.png', tile_dim=(14, 14))
    symmetries = [x.sym for x in ts.tile_dict.values()]

    dist = Distribution(ts)

    freq = dist.frequencies()
    neighbours = dist.allowed_neighbours(verbose=True)

    print_xml(symmetries, neighbours, freq)
    ts.save()
from enum import Enum
from ServerState import ServerState
from ServerEvent import ServerEvent
from Experience import Experience
from Customer import Customer
from Distribution import Distribution
from Server import Server
import numpy as np
import copy as cp

dist = {}
dist['dt'] = Distribution("triangular(14400, 14400, 18000)")
dist['oos'] = Distribution("triangular(300, 600, 1200)")
dist['st'] = Distribution("exponential(1/300)")
dist['invalid'] = Customer('teddy', 0)
server = Server('S1', 100, dist['dt'], dist['oos'], dist['st'])

ServerState.AVAILABLE == server.status

rstate = np.random.get_state()
svcEntryTime = 200
expSvcCompTime = svcEntryTime + dist['st'].getEvent()
np.random.set_state(rstate)

# next, transition to Busy
cust1 = Customer('test1', 100)
cust1.logArrival(100, 'Q1')
server.acceptCustomer(200, cust1)
ServerState.BUSY == server.status
expSvcCompTime == server.getNextEventTime()
示例#31
0
class Simulation:

    def __init__(self, s, m, h):
        #init simulations
        self.mainArrDist = Distribution(stats.expon(scale=1/m))
        self.sideArrDist = Distribution(stats.expon(scale=1/s))

        self.s = s
        self.m = m
        self.h = h

    def simulate(self, T, verbose=False, immediate_departure=False):
        #start simulation untill time reaches T

        fes = FES()
        simres = SimulationResults(self.s, self.m, self.h, T)
        
        queue = deque()
        t = 0
        prev_gap_time = 0

        #schedule first arrival
        c0 = Car(self.sideArrDist.rvs())
        fes.add(Event(c0.arrTime, Event.ARRIVAL, car=c0))

        #schedule first gap
        fes.add( Event(self.mainArrDist.rvs(), Event.GAP))

        simres.registerQueue(t, len(queue))

        while t < T:
            if verbose:
                print(fes.getTypesList(), fes.events)
            
            #next event
            e = fes.next()
            
            if e.type == Event.GAP:
                t = e.time
                #register the transitionprobability if there is no immediate_departure
                if not immediate_departure:
                    simres.registerQueue(t, len(queue))
                
                #depart the right amount of cars from the queue
                duration = e.time - prev_gap_time
                prev_gap_time = e.time
                departures = int(duration // self.h)
                
                for _ in range(departures):
                    #a car leaves the queue, we save their waitingtime
                    if len(queue) != 0:
                        c = queue.popleft()       

                #register the transitionprobability if there is immediate_departure
                if immediate_departure:
                    simres.registerQueue(t, len(queue))             

                # schedule next gap
                fes.add( Event(t+self.mainArrDist.rvs(), Event.GAP) )

            if e.type == Event.ARRIVAL:
                #add car to the queue
                t = e.time
                queue.append(e.car)

                #schedule next car 
                c1 = Car(t + self.sideArrDist.rvs())
                fes.add(Event(c1.arrTime,Event.ARRIVAL, car=c1))

        simres.registerQueue(t, len(queue))
        return simres
示例#32
0
    def plot_results(self, mc=False):

        if self.models[0].n_qoi == 1:

            # Determine bounds
            xmin = np.min([
                np.min(self.models[-1].model_evals_pred),
                np.min(self.models[0].model_evals_pred)
            ])
            xmax = np.max([
                np.max(self.models[-1].model_evals_pred),
                np.max(self.models[0].model_evals_pred)
            ])

            for i in range(self.n_models):
                # Plot
                color = 'C' + str(i)
                self.models[i].distribution.plot_kde(fignum=1,
                                                     color=color,
                                                     xmin=xmin,
                                                     xmax=xmax)

            if mc and self.mc_model is not None:
                self.mc_model.distribution.plot_kde(fignum=1,
                                                    color='k',
                                                    linestyle='--',
                                                    xmin=xmin,
                                                    xmax=xmax)

            elif mc and self.mc_model is None:
                print(
                    'No Monte Carlo reference samples available. Call calculate_mc_reference() first.'
                )
                exit()

            # plt.legend(loc='center left', bbox_to_anchor=(1.01, 0.51))
            plt.legend(loc='best')
            plt.grid(b=True)
            plt.gcf().savefig('output/mfmc_densities.pdf', dpi=300)
            # plt.gcf().savefig('output/mfmc_densities.pdf', dpi=300, bbox_inches='tight')

        else:
            # Seaborn pairplot of the high-fidelity push-forward
            utils.plot_multi_qoi(samples=self.models[-1].model_evals_pred)
            plt.grid(b=True)
            plt.gcf().savefig('output/mfmc_hf_pairplot.pdf', dpi=300)
            plt.clf()

            # Plot marginals
            for k in range(self.models[-1].n_qoi):
                # Determine bounds
                xmin = np.min([
                    np.min(self.models[-1].model_evals_pred[:, k]),
                    np.min(self.models[0].model_evals_pred[:, k])
                ])
                xmax = np.max([
                    np.max(self.models[-1].model_evals_pred[:, k]),
                    np.max(self.models[0].model_evals_pred[:, k])
                ])

                if k is 0:
                    rms = 'I'
                elif k is 1:
                    rms = 'II'
                elif k is 2:
                    rms = 'III'
                else:
                    rms = ''

                rv_name = '$Q^{\mathrm{(%s)}}$' % rms

                for i in range(self.n_models):
                    if i is 0:
                        label = 'Low-Fidelity'
                    elif i is self.n_models - 1:
                        label = 'High-Fidelity'
                    elif i is 1 and self.n_models is 3:
                        label = 'Mid-Fidelity'
                    else:
                        label = 'Mid-%d-Fidelity' % (i + 1)
                    # Plot
                    color = 'C' + str(i)
                    samples = self.models[i].distribution.samples[:, k]
                    samples = np.expand_dims(samples, axis=1)
                    marginal = Distribution(samples,
                                            label=label,
                                            rv_name=rv_name)
                    marginal.plot_kde(fignum=1,
                                      color=color,
                                      xmin=xmin,
                                      xmax=xmax)

                if mc and self.mc_model is not None:
                    samples = self.mc_model.distribution.samples[:, k]
                    samples = np.expand_dims(samples, axis=1)
                    marginal = Distribution(samples,
                                            label='MC reference',
                                            rv_name=rv_name)
                    marginal.plot_kde(fignum=1,
                                      color='k',
                                      linestyle='--',
                                      xmin=xmin,
                                      xmax=xmax)

                elif mc and self.mc_model is None:
                    print(
                        'No Monte Carlo reference samples available. Call calculate_mc_reference() first.'
                    )
                    exit()

                plt.grid(b=True)
                plt.gcf().savefig('output/mfmc_densities_q%d.pdf' % (k + 1),
                                  dpi=300)
                plt.clf()

        if self.models[0].n_qoi == 2:

            sns.kdeplot(self.models[0].distribution.samples[:, 0],
                        self.models[0].distribution.samples[:, 1],
                        shade=True,
                        shade_lowest=False,
                        cmap='Blues',
                        label='Low-fidelity',
                        color='C0')
            sns.kdeplot(self.models[-1].distribution.samples[:, 0],
                        self.models[-1].distribution.samples[:, 1],
                        shade=True,
                        shade_lowest=False,
                        cmap='Reds',
                        label='High-fidelity',
                        color='C3')

            if mc and self.mc_model is not None:
                sns.kdeplot(self.mc_model.distribution.samples[:, 0],
                            self.mc_model.distribution.samples[:, 1],
                            cmap='Greys',
                            alpha=1.0,
                            label='MC reference',
                            color='Black')
            elif mc and self.mc_model is None:
                print(
                    'No Monte Carlo reference samples available. Call calculate_mc_reference() first.'
                )
                exit()
            plt.xlabel('$Q_1$')
            plt.ylabel('$Q_2$')
            plt.legend(loc='upper left')
            plt.grid(b=True)

            plt.gcf().savefig('output/mfmc_dists.pdf', dpi=300)
            xmin, xmax = plt.xlim()
            ymin, ymax = plt.ylim()
            plt.clf()

            self.models[0].distribution.plot_kde()
            plt.xlim([xmin, xmax])
            plt.ylim([ymin, ymax])
            plt.gcf().savefig('output/mfmc_lf.pdf', dpi=300)
            plt.clf()

            self.models[-1].distribution.plot_kde()
            plt.xlim([xmin, xmax])
            plt.ylim([ymin, ymax])
            plt.gcf().savefig('output/mfmc_hf.pdf', dpi=300)

            if mc and self.mc_model is not None:
                self.mc_model.distribution.plot_kde()
                plt.xlim([xmin, xmax])
                plt.ylim([ymin, ymax])
                plt.gcf().savefig('output/mfmc_mc.pdf', dpi=300)
            elif mc and self.mc_model is None:
                print(
                    'No Monte Carlo reference samples available. Call calculate_mc_reference() first.'
                )
                exit()

        plt.clf()
from unittest import TestCase, main
from SourcePopulation import SourcePopulation
from Distribution import Distribution
from Assigner import Assigner
from CustomerDestination import CustomerDestination
from SimulationStage import SimulationStage
from SimQueue import SimQueue
import numpy as np
import math

# setUp
dist = Distribution('triangular(10, 20, 40)')

# SourcePopulation generates the first arrival time on construction
# so we have to set the random number before creating the source population

np.random.seed(100)
sp = SourcePopulation("Source1", dist, Assigner().assignInSequence)

# __init__

# addCustomerDestination
sp.isValid() == False
dest = CustomerDestination('test_dest')
sp.addCustomerDestination(dest)
sp.isValid() == True
sp.addCustomerDestination(list())

##### processEvent
# add a valid destination to the SourcePopulation
dest = SimQueue('test_dest', Assigner().assignInSequence)