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']
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'])))
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
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])
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
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()
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])
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
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
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')
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
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)
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
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()
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)
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')
def __init__(self, mu=0, sigma=1): Distribution.__init__(self, mu, sigma)
def create_distribution(self): self.distribution = Distribution(samples=self.model_evals_pred, rv_name=self.rv_name, label=self.label)
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):
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) ]
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()
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)
def __init__(self,mean,std): Distribution.__init__(self) self._std=std self._mean=mean
def gaussian_noise(lower=-0.5, upper=0.5): return Distribution(scipy.stats.truncnorm(a=lower, b=upper))
def standard(x=0): return 1 if Distribution.uniform(x) <= x else 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()
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
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)