def cost(rv): c = product_measure().load(rv, npts) #XXX: apply 'filters' to catch errors in constraints solver (necessary ?) ##################### begin function-specific ##################### E = float(c.expect(model)) if E > (target[0] + error[0]) or E < (target[0] - error[0]): if debug: print("skipping expect: %s" % E) return inf #XXX: FORCE TO SATISFY E CONSTRAINTS # E = float(c[0].var) # var(h) # if E > (target[1] + error[1]) or E < (target[1] - error[1]): # if debug: print("skipping variance: %s" % E) # return inf #XXX: FORCE TO SATISFY E CONSTRAINTS E = float(c[0].mean) # mean(h) if E > (target[2] + error[2]) or E < (target[2] - error[2]): if debug: print("skipping expect: %s" % E) return inf #XXX: FORCE TO SATISFY E CONSTRAINTS E = float(c[2].mean) # mean(v) if E > (target[3] + error[3]) or E < (target[3] - error[3]): if debug: print("skipping expect: %s" % E) return inf #XXX: FORCE TO SATISFY E CONSTRAINTS ###################### end function-specific ###################### return MINMAX * c.pof(model)
def objective(self, rv, axis=None, iter=True): """calculate probability of failure for model, under uncertainty Input: rv: list of input parameters axis: int, the index of output to calculate (all, by default) iter: bool, if True, calculate per axis, else calculate for all axes Returns: the probability of failure for the specified axis (or all axes) NOTE: respects constraints on input parameters and product measure model is a function returning a boolean (True for success) NOTE: for product_measure, use sampled_pof(model) if samples, else pof(model) """ # check constraints c = product_measure().load(rv, self.npts) if not self.cvalid(c) or not self.xvalid(rv): import numpy as np return np.inf # get probability of failure if iter and axis is None and self.axes is not None: model = (lambda x: self.model(x,axis=i) for i in range(self.axes)) if self.samples is None: return tuple(c.pof(m) for m in model) # else use sampled support return tuple(c.sampled_pof(m, self.samples) for m in model) # else, get probability of failure for the given axis model = lambda x: self.model(x, axis=axis) if self.samples is None: return c.pof(model) return c.sampled_pof(model, self.samples)
def cost(rv): c = product_measure().load(rv, npts) E = float(c.expect(model)) if E > (target[0] + error[0]) or E < (target[0] - error[0]): if debug: print("skipping expect: %s" % E) return inf #XXX: FORCE TO SATISFY E CONSTRAINTS return MINMAX * c.pof(model)
def objective(self, rv, axis=None): """calculate value at risk of model, under uncertainty Input: rv: list of input parameters axis: int, the index of output to calculate (all, by default) Returns: the value at risk for the specified axis NOTE: respects constraints on input parameters and product measure NOTE: for product_measure, use sampled_ptp if samples, else ess_ptp """ # check constraints c = product_measure().load(rv, self.npts) if not self.cvalid(c) or not self.xvalid(rv): import numpy as np return np.inf # get value at risk if axis is None and self.axes is not None: model = (lambda x: self.model(x, axis=i) for i in range(self.axes)) if self.samples is None: return tuple(c.ess_ptp(m) for m in model) # else use sampled support return tuple(c.sampled_ptp(m, self.samples) for m in model) # else, get value at risk for the given axis model = lambda x: self.model(x, axis=axis) if self.samples is None: from mystic.math.measures import ess_ptp #TODO: c.ess_ptp return ess_ptp(model, c.positions, c.weights) return c.sampled_ptp(model, self.samples)
def objective(self, rv, axis=None): """calculate expected value of model, under uncertainty Input: rv: list of input parameters axis: int, the index of output to calculate (all, by default) Returns: the expected value for the specified axis NOTE: respects constraints on input parameters and product measure NOTE: for product_measure, use sampled_expect if samples, else expect """ # check constraints c = product_measure().load(rv, self.npts) if not self.cvalid(c) or not self.xvalid(rv): import numpy as np return np.inf # get expected value if axis is None and self.axes is not None: model = (lambda x: self.model(x, axis=i) for i in range(self.axes)) if self.samples is None: return tuple(c.expect(m) for m in model) # else use sampled support return tuple(c.sampled_expect(m, self.samples) for m in model) # else, get expected value for the given axis model = lambda x: self.model(x, axis=axis) if self.samples is None: return c.expect(model) return c.sampled_expect(model, self.samples)
def cost(rv): c = product_measure().load(rv, npts) #XXX: apply 'filters' to catch errors in constraints solver (necessary ?) ##################### begin function-specific ##################### E = float(c.expect(model)) if E > (target[0] + error[0]) or E < (target[0] - error[0]): if debug: print("skipping expect: %s" % E) return inf #XXX: FORCE TO SATISFY E CONSTRAINTS # E = float(c[0].var) # var(h) # if E > (target[1] + error[1]) or E < (target[1] - error[1]): # if debug: print("skipping variance: %s" % E) # return inf #XXX: FORCE TO SATISFY E CONSTRAINTS E = float(c[0].mean) # mean(h) if E > (target[2] + error[2]) or E < (target[2] - error[2]): if debug: print("skipping expect: %s" % E) return inf #XXX: FORCE TO SATISFY E CONSTRAINTS E = float(c[2].mean) # mean(v) if E > (target[3] + error[3]) or E < (target[3] - error[3]): if debug: print("skipping expect: %s" % E) return inf #XXX: FORCE TO SATISFY E CONSTRAINTS ###################### end function-specific ###################### return MINMAX * c.pof(model)
def cost(rv): c = product_measure().load(rv, npts) E = float(c.expect(model)) if E > (target[0] + error[0]) or E < (target[0] - error[0]): if debug: print("skipping expect: %s" % E) return inf #XXX: FORCE TO SATISFY E CONSTRAINTS return MINMAX * c.pof(model)
def func(x, *args, **kwds): # populate a product measure with params c = product_measure() c.load(x, npts) # apply all collapses for clps in tracking: for k,v in getattr(clps, 'iteritems', clps.items)(): c[k].positions, c[k].weights = \ impose_collapse(v, c[k].positions, c[k].weights) for clps in noweight: for k,v in getattr(clps, 'iteritems', clps.items)(): c[k].positions, c[k].weights = \ impose_unweighted(v, c[k].positions, c[k].weights, False) # convert to params and apply function return f(c.flatten(), *args, **kwds)
def func(x, *args, **kwds): # populate a product measure with params c = product_measure() c.load(x, npts) # apply all collapses for clps in tracking: for k, v in getattr(clps, 'iteritems', clps.items)(): c[k].positions, c[k].weights = \ impose_collapse(v, c[k].positions, c[k].weights) for clps in noweight: for k, v in getattr(clps, 'iteritems', clps.items)(): c[k].positions, c[k].weights = \ impose_unweighted(v, c[k].positions, c[k].weights, False) # convert to params and apply function return f(c.flatten(), *args, **kwds)
def constraints(rv): c = product_measure().load(rv, npts) # NOTE: bounds wi in [0,1] enforced by filtering # impose norm on each discrete measure for measure in c: if not almostEqual(float(measure.mass), 1.0, tol=atol, rel=rtol): measure.normalize() # impose expectation on product measure ##################### begin function-specific ##################### E = float(c.expect(model)) if not (E <= float(target[0] + error[0])) \ or not (float(target[0] - error[0]) <= E): c.set_expect(target[0], model, (x_lb,x_ub), tol=error[0]) ###################### end function-specific ###################### # extract weights and positions return c.flatten()
def constraints(rv): c = product_measure().load(rv, npts) # NOTE: bounds wi in [0,1] enforced by filtering # impose norm on each discrete measure for measure in c: if not almostEqual(float(measure.mass), 1.0, tol=atol, rel=rtol): measure.normalize() # impose expectation on product measure ##################### begin function-specific ##################### E = float(c.expect(model)) if not (E <= float(target[0] + error[0])) \ or not (float(target[0] - error[0]) <= E): c.set_expect(target[0], model, (x_lb, x_ub), tol=error[0]) ###################### end function-specific ###################### # extract weights and positions return c.flatten()
def objective(self, rv, axis=None, idx=0): #FIXME: idx != None, is fixed """calculate mean value of input, under uncertainty Input: rv: list of input parameters axis: int, the index of output to calculate (all, by default) idx: int, the index of input to calculate (all, by default) #FIXME Returns: the mean value for the specified index NOTE: respects constraints on input parameters and product measure NOTE: for product_measure, use sampled_expect if samples, else expect """ # check constraints c = product_measure().load(rv, self.npts) if not self.cvalid(c) or not self.xvalid(rv): #FIXME: set model,samples in constraints import numpy as np return np.inf # get mean value if axis is None and self.axes is not None: model = (lambda x: self.model(x, axis=i) for i in range(self.axes)) if self.samples is None: return NotImplemented #FIXME: set model,samples in constraints # else use sampled support return NotImplemented #FIXME: set model,samples in constraints # else, get mean value for the given axis if axis is None: model = lambda x: self.model(x) else: model = lambda x: self.model(x, axis=axis) if self.samples is None: if idx is None: res = (c[i].mean for i in self.nx) return tuple(res) return c[idx].mean #FIXME: set model,samples in constraints return NotImplemented #FIXME: set model,samples in constraints
for i in range(ny): param_string += "'wy%s', " % str(i+1) for i in range(ny): param_string += "'y%s', " % str(i+1) for i in range(nz): param_string += "'wz%s', " % str(i+1) for i in range(nz): param_string += "'z%s', " % str(i+1) param_string = param_string[:-2] + "]" print(" parameters: %s" % param_string) print(" lower bounds: %s" % lower_bounds) print(" upper bounds: %s" % upper_bounds) # print(" ...") pars = (target,error) npts = (nx,ny,nz) bounds = (lower_bounds,upper_bounds) solved, diameter = maximize(pars,npts,bounds) from numpy import array from mystic.math.discrete import product_measure c = product_measure() c.load(solved,npts) print("solved: [wx,x]\n%s" % array(list(zip(c[0].weights,c[0].positions)))) print("solved: [wy,y]\n%s" % array(list(zip(c[1].weights,c[1].positions)))) print("solved: [wz,z]\n%s" % array(list(zip(c[2].weights,c[2].positions)))) print("expect: %s" % str( c.expect(model) )) # EOF
for i in range(ny): param_string += "'y%s', " % str(i + 1) for i in range(nz): param_string += "'wz%s', " % str(i + 1) for i in range(nz): param_string += "'z%s', " % str(i + 1) param_string = param_string[:-2] + "]" print(" parameters: %s" % param_string) print(" lower bounds: %s" % lower_bounds) print(" upper bounds: %s" % upper_bounds) # print(" ...") pars = (target, error) npts = (nx, ny, nz) bounds = (lower_bounds, upper_bounds) solved, diameter = maximize(pars, npts, bounds) from numpy import array from mystic.math.discrete import product_measure c = product_measure().load(solved, npts) print("solved: [wx,x]\n%s" % array(list(zip(c[0].weights, c[0].positions)))) print("solved: [wy,y]\n%s" % array(list(zip(c[1].weights, c[1].positions)))) print("solved: [wz,z]\n%s" % array(list(zip(c[2].weights, c[2].positions)))) print("expect: %s" % str(c.expect(model))) # EOF
param_string += "'y%s', " % str(i+1) for i in range(nz): param_string += "'wz%s', " % str(i+1) for i in range(nz): param_string += "'z%s', " % str(i+1) param_string = param_string[:-2] + "]" print(" parameters: %s" % param_string) print(" lower bounds: %s" % lower_bounds) print(" upper bounds: %s" % upper_bounds) # print(" ...") pars = (target,error) npts = (nx,ny,nz) bounds = (lower_bounds,upper_bounds) solved, diameter = maximize(pars,npts,bounds) from numpy import array from mystic.math.discrete import product_measure c = product_measure().load(solved,npts) print("solved: [wx,x]\n%s" % array(list(zip(c[0].weights,c[0].positions)))) print("solved: [wy,y]\n%s" % array(list(zip(c[1].weights,c[1].positions)))) print("solved: [wz,z]\n%s" % array(list(zip(c[2].weights,c[2].positions)))) # XXX: 4D-expect print("expect: %s" % str( c.expect(model) )) print("var (x): %s" % str( c[0].var )) # var(h) print("mean(x): %s" % str( c[0].mean )) # mean(h) print("mean(z): %s" % str( c[2].mean )) # mean(v) # EOF
def func(rv): c = product_measure().load(rv, npts) c = f(c) return c.flatten()
def func(rv): c = product_measure().load(rv, npts) return f(c)
for i in range(nz): param_string += "'z%s', " % str(i + 1) param_string = param_string[:-2] + "]" print(" parameters: %s" % param_string) print(" lower bounds: %s" % lower_bounds) print(" upper bounds: %s" % upper_bounds) # print(" ...") pars = (target, error) npts = (nx, ny, nz) bounds = (lower_bounds, upper_bounds) solved, diameter = maximize(pars, npts, bounds) from numpy import array from mystic.math.discrete import product_measure c = product_measure() c.load(solved, npts) print("solved: [wx,x]\n%s" % array(list(zip(c[0].weights, c[0].positions)))) print("solved: [wy,y]\n%s" % array(list(zip(c[1].weights, c[1].positions)))) print("solved: [wz,z]\n%s" % array(list(zip(c[2].weights, c[2].positions)))) # XXX: 4D-expect print("expect: %s" % str(c.expect(model))) print("var (x): %s" % str(c[0].var)) # var(h) print("mean(x): %s" % str(c[0].mean)) # mean(h) print("mean(z): %s" % str(c[2].mean)) # mean(v) # EOF