def __init__(self, X=None, Y=None, order=(2,1), fname=None, initDict=None, strategy=1, scale_min=-1, scale_max=1, pnames=None, set_structures=True): """ Multivariate rational approximation f(x)_mn = g(x)_m/h(x)_n kwargs: fname --- to read in previously calculated Pade approximation X --- anchor points Y --- function values order --- tuple (m,n) m being the order of the numerator polynomial --- if omitted: auto """ self._vmin=None self._vmax=None self._xmin = None self._xmax = None if initDict is not None: self.mkFromDict(initDict, set_structures=set_structures) elif fname is not None: self.mkFromJSON(fname, set_structures=set_structures) elif X is not None and Y is not None: self._m=order[0] self._n=order[1] self._scaler = apprentice.Scaler(np.atleast_2d(np.array(X, dtype=np.float64)), a=scale_min, b=scale_max, pnames=pnames) self._X = self._scaler.scaledPoints self._dim = self._X[0].shape[0] self._Y = np.array(Y, dtype=np.float64) self._trainingsize=len(X) if self._dim==1: self.recurrence=apprentice.monomial.recurrence1D else : self.recurrence=apprentice.monomial.recurrence self.fit(strategy=strategy) else: raise Exception("Constructor not called correctly, use either fname, initDict or X and Y")
def mkFromDict(self, pdict): self._scaler = apprentice.Scaler(pdict["scaler"]) self._pcoeff = np.array(pdict["pcoeff"]) self._qcoeff = np.array(pdict["qcoeff"]) self._iterationinfo = pdict["iterationinfo"] self._dim = pdict["dim"] self._m = pdict["m"] self._n = pdict["n"] self._M = pdict["M"] self._N = pdict["N"] self._fittime = pdict["log"]["fittime"] self._strategy = pdict["strategy"] self._roboptstrategy = pdict["roboptstrategy"] self._localoptsolver = pdict["localoptsolver"] self._fitstrategy = pdict["fitstrategy"] self._trainingscale = pdict["trainingscale"] self._trainingsize = pdict["trainingsize"] self._penaltyparam = 0.0 if (self.strategy == 1 or self.strategy == 2): self._ppenaltybin = pdict['chosenppenalty'] self._qpenaltybin = pdict['chosenqpenalty'] if (self.strategy == 2): self._penaltyparam = pdict['lambda'] self._struct_p = apprentice.monomialStructure(self.dim, self.m) self._struct_q = apprentice.monomialStructure(self.dim, self.n)
def mkFromDict(self, RDict): self._pcoeff = np.array(RDict["pcoeff"]) self._qcoeff = np.array(RDict["qcoeff"]) self._m = int(RDict["m"]) self._n = int(RDict["n"]) self._scaler = apprentice.Scaler(RDict["scaler"]) self._ONB = apprentice.ONB(RDict["ONB"])
def __init__(self, X=None, Y=None, order=2, fname=None, initDict=None, strategy=2, scale_min=-1, scale_max=1, pnames=None, set_structures=True, computecov=False): """ Multivariate polynomial approximation kwargs: fname --- to read in previously calculated Pade approximation X --- anchor points Y --- function values fname --- JSON file to read pre-calculated info from initDict --- dict to read pre-calculated info from order --- int being the order of the polynomial """ self._vmin = None self._vmax = None self._xmin = None self._xmax = None if initDict is not None: self.mkFromDict(initDict, set_structures=set_structures) elif fname is not None: self.mkFromJSON(fname, set_structures=set_structures) elif X is not None and Y is not None: self._m = order self._scaler = apprentice.Scaler(np.atleast_2d( np.array(X, dtype=np.float64)), a=scale_min, b=scale_max, pnames=pnames) self._X = self._scaler.scaledPoints self._dim = self._X[0].shape[0] self._Y = np.array(Y, dtype=np.float64) self._trainingsize = len(X) if self._dim == 1: self.recurrence = apprentice.monomial.recurrence1D else: self.recurrence = apprentice.monomial.recurrence self.fit(strategy=strategy, computecov=computecov) else: raise Exception( "Constructor not called correctly, use either fname, initDict or X and Y" )
def __init__(self, X=None, Y=None, order=(2, 1), fname=None, initDict=None, strategy=2, scale_min=-1, scale_max=1, pnames=None, tol=1e-14, debug=False, validateSVD=True): """ Multivariate rational approximation f(x)_mn = g(x)_m/h(x)_n kwargs: fname --- to read in previously calculated Pade approximation X --- anchor points Y --- function values tol --- singular value tolerance order --- tuple (m,n) m being the order of the numerator polynomial --- if omitted: auto strategy --- 1 is denominator first, 2 is enumerator first reduction """ self._debug = debug self._strategy = strategy self.tol = tol self.validateSVD = validateSVD if initDict is not None: self.mkFromDict(initDict) elif fname is not None: self.mkFromJSON(fname) elif X is not None and Y is not None: self._m = order[0] self._n = order[1] self._scaler = apprentice.Scaler(np.atleast_2d( np.array(X, dtype=np.float64)), a=scale_min, b=scale_max, pnames=pnames) self._X = self._scaler.scaledPoints self._dim = self._X[0].shape[0] self._F = np.diag(Y) self._trainingsize = len(X) self._ONB = apprentice.ONB(self._X) self.fit() else: raise Exception( "Constructor not called correctly, use either fname, initDict or X and Y" )
def __init__(self, *args, **kwargs): """ Multivariate rational approximation p(x)_m/q(x)_n args: X --- anchor points Y --- function values kwargs: order (tuple m,n) --- order of the numerator polynomial --- if omitted: auto 1 used --- order of the denominator polynomial --- if omitted: auto 1 used pnames --- list of parameter names to pass to the scaler to scale """ self._vmin = None self._vmax = None self._debug = kwargs["debug"] if kwargs.get( "debug") is not None else False self._ftol = float( kwargs["ftol"]) if kwargs.get("ftol") is not None else 1e-9 self._slsqp_iter = int( kwargs["itslsqp"]) if kwargs.get("itslsqp") is not None else 200 self._m = kwargs["order"][0] self._n = kwargs["order"][1] import os if len(args) == 0: pass else: # Scaler related kwargs _pnames = kwargs["pnames"] if kwargs.get( "pnames") is not None else None _scale_min = kwargs["scalemin"] if kwargs.get( "scalemin") is not None else -1 _scale_max = kwargs["scalemax"] if kwargs.get( "scalemax") is not None else 1 self._scaler = apprentice.Scaler(np.array(args[0], dtype=np.float64), a=_scale_min, b=_scale_max, pnames=_pnames) self._X = self._scaler.scaledPoints self._trainingsize = len(self._X) self._dim = self._X[0].shape[0] self._Y = np.array(args[1], dtype=np.float64) if self._dim == 1: self.recurrence = apprentice.monomial.recurrence1D else: self.recurrence = apprentice.monomial.recurrence self.setStructures() self.setIPO() self.fit()
def mkFromDict(self, pdict, set_structures=True): self._pcoeff = np.array(pdict["pcoeff"]) self._qcoeff = np.array(pdict["qcoeff"]) self._m = int(pdict["m"]) self._n = int(pdict["n"]) self._dim = int(pdict["dim"]) self._scaler = apprentice.Scaler(pdict["scaler"]) if "vmin" in pdict: self._vmin = pdict["vmin"] if "vmax" in pdict: self._vmax = pdict["vmax"] if self._dim==1: self.recurrence=apprentice.monomial.recurrence1D else : self.recurrence=apprentice.monomial.recurrence try: self._trainingsize = int(pdict["trainingsize"]) except: pass if set_structures: self.setStructures()
def getresults(farr, noisearr, tarr, ts, allsamples): import apprentice m = 5 n = 5 thresholdvalarr = np.array([float(t) for t in tarr]) thresholdvalarr = np.sort(thresholdvalarr) results = {} for fnum, fname in enumerate(farr): results[fname] = {} dim = getdim(fname) infile = [ "results/plots/poledata_corner" + str(dim) + "D.csv", "results/plots/poledata_inside" + str(dim) + "D.csv" ] X_testfc = np.loadtxt(infile[0], delimiter=',') X_testin = np.loadtxt(infile[1], delimiter=',') # X_testall = np.vstack(X_test,X_testin) print(len(X_testfc), len(X_testin)) minarr, maxarr = getbox(fname) s = apprentice.Scaler(np.array(X_testfc, dtype=np.float64), a=minarr, b=maxarr) X_testfc = s.scaledPoints s = apprentice.Scaler(np.array(X_testin, dtype=np.float64), a=minarr, b=maxarr) X_testin = s.scaledPoints Y_testfc = np.array(getData(X_testfc, fname, 0)) maxY_testfc = max(1, abs(np.max(Y_testfc))) Y_testin = np.array(getData(X_testin, fname, 0)) maxY_testin = max(1, abs(np.max(Y_testin))) print(fname, maxY_testfc, maxY_testin) results[fname]['npoints_face'] = len(Y_testfc) results[fname]['npoints_inside'] = len(Y_testin) for snum, sample in enumerate(allsamples): results[fname][sample] = {} for noise in noisearr: results[fname][sample][noise] = {} noisestr, noisepct = getnoiseinfo(noise) resdata = {} resdata['papp'] = {} resdata['rapp'] = {} resdata['rapprd'] = {} resdata['rappsip'] = {} resdata['papp']['l2all'] = [] resdata['rapp']['l2all'] = [] resdata['rapprd']['l2all'] = [] resdata['rappsip']['l2all'] = [] for tval in thresholdvalarr: for method in ['papp', 'rapp', 'rapprd', 'rappsip']: resdata[method][str(tval)] = {} resdata[method][str(tval)]['no'] = [] resdata[method][str(tval)]['no_face'] = [] resdata[method][str(tval)]['no_inside'] = [] resdata[method][str(tval)]['l2count'] = [] resdata[method][str(tval)]['l2notcount'] = [] for rnum, run in enumerate( ["exp1", "exp2", "exp3", "exp4", "exp5"]): fndesc = "%s%s_%s_%s" % (fname, noisestr, sample, ts) folder = "results/%s/%s" % (run, fndesc) # print(folder) pq = "p%d_q%d" % (m, n) # print(run, fname,noisestr,sample,m,n) rappsipfile = "%s/outrasip/%s_%s_ts%s.json" % ( folder, fndesc, pq, ts) rappfile = "%s/outra/%s_%s_ts%s.json" % (folder, fndesc, pq, ts) rapprdfile = "%s/outrard/%s_%s_ts%s.json" % ( folder, fndesc, pq, ts) pappfile = "%s/outpa/%s_%s_ts%s.json" % (folder, fndesc, pq, ts) if not os.path.exists(rappsipfile): print("rappsipfile %s not found" % (rappsipfile)) if (knowmissing(rappsipfile) == 1): if (sample == "sg"): break continue exit(1) if not os.path.exists(rappfile): print("rappfile %s not found" % (rappfile)) if (knowmissing(rappfile) == 1): if (sample == "sg"): break continue exit(1) if not os.path.exists(rapprdfile): print("rappfile %s not found" % (rapprdfile)) if (knowmissing(rapprdfile) == 1): if (sample == "sg"): break continue exit(1) if not os.path.exists(pappfile): print("rappfile %s not found" % (pappfile)) if (knowmissing(pappfile) == 1): if (sample == "sg"): break continue exit(1) print(fndesc + " " + run + " Start") papp = PolynomialApproximation(fname=pappfile) try: Y_pred_pappfc = np.array([papp(x) for x in X_testfc]) Y_pred_pappin = np.array([papp(x) for x in X_testin]) except: Y_pred_pappfc = findpredval(X_testfc, papp) Y_pred_pappin = findpredval(X_testin, papp) rappsip = RationalApproximationSIP(rappsipfile) try: Y_pred_rappsipfc = rappsip.predictOverArray(X_testfc) Y_pred_rappsipin = rappsip.predictOverArray(X_testin) except: Y_pred_rappsipfc = findpredval(X_testfc, rappsip) Y_pred_rappsipin = findpredval(X_testin, rappsip) rapp = RationalApproximationONB(fname=rappfile) try: Y_pred_rappfc = np.array([rapp(x) for x in X_testfc]) Y_pred_rappin = np.array([rapp(x) for x in X_testin]) except: Y_pred_rappfc = findpredval(X_testfc, rapp) Y_pred_rappin = findpredval(X_testin, rapp) rapprd = RationalApproximationONB(fname=rapprdfile) try: Y_pred_rapprdfc = np.array( [rapprd(x) for x in X_testfc]) Y_pred_rapprdin = np.array( [rapprd(x) for x in X_testin]) except: Y_pred_rapprdfc = findpredval(X_testfc, rapprd) Y_pred_rapprdin = findpredval(X_testin, rapprd) print(fndesc + " " + run + " Done ") sys.stdout.flush() Y_testall = np.concatenate((Y_testfc, Y_testin), axis=None) Y_pred_pappall = np.concatenate( (Y_pred_pappfc, Y_pred_pappin), axis=None) Y_pred_rappsipall = np.concatenate( (Y_pred_rappsipfc, Y_pred_rappsipin), axis=None) Y_pred_rappall = np.concatenate( (Y_pred_rappfc, Y_pred_rappin), axis=None) Y_pred_rapprdall = np.concatenate( (Y_pred_rapprdfc, Y_pred_rapprdin), axis=None) l2allrapp = np.sum((Y_pred_rappall - Y_testall)**2) l2allrapprd = np.sum((Y_pred_rapprdall - Y_testall)**2) l2allrappsip = np.sum((Y_pred_rappsipall - Y_testall)**2) l2allpapp = np.sum((Y_pred_pappall - Y_testall)**2) # print(l2allrapp,l2allrapprd,l2allrappsip) resdata['rapp']['l2all'].append(np.sqrt(l2allrapp)) resdata['rapprd']['l2all'].append(np.sqrt(l2allrapprd)) resdata['rappsip']['l2all'].append(np.sqrt(l2allrappsip)) resdata['papp']['l2all'].append(np.sqrt(l2allpapp)) for tnum, tval in enumerate(thresholdvalarr): for method in ['papp', 'rapp', 'rapprd', 'rappsip']: resdata[method][str(tval)]['no_face'].append(0) resdata[method][str(tval)]['no_inside'].append(0) resdata[method][str(tval)]['no'].append(0) resdata[method][str(tval)]['l2count'].append(0.) resdata[method][str(tval)]['l2notcount'].append(0.) for num, yt in enumerate(Y_testfc): for method, pred in zip( ['papp', 'rapp', 'rapprd', 'rappsip'], [ Y_pred_pappfc, Y_pred_rappfc, Y_pred_rapprdfc, Y_pred_rappsipfc ]): yp = pred[num] for tnum, tval in enumerate(thresholdvalarr): if (abs(yp) / maxY_testfc > tval): resdata[method][str(tval)]['no'][rnum] += 1 resdata[method][str( tval)]['no_face'][rnum] += 1 resdata[method][str( tval)]['l2count'][rnum] += (yp - yt)**2 for num, yt in enumerate(Y_testin): for method, pred in zip( ['papp', 'rapp', 'rapprd', 'rappsip'], [ Y_pred_pappin, Y_pred_rappin, Y_pred_rapprdin, Y_pred_rappsipin ]): yp = pred[num] for tnum, tval in enumerate(thresholdvalarr): if (abs(yp) / maxY_testin > tval): resdata[method][str(tval)]['no'][rnum] += 1 resdata[method][str( tval)]['no_inside'][rnum] += 1 resdata[method][str( tval)]['l2count'][rnum] += (yp - yt)**2 for tnum, tval in enumerate(thresholdvalarr): for method, l2all in zip( ['papp', 'rapp', 'rapprd', 'rappsip'], [l2allpapp, l2allrapp, l2allrapprd, l2allrappsip]): l2count = resdata[method][str( tval)]['l2count'][rnum] resdata[method][str( tval)]['l2notcount'][rnum] = np.sqrt(l2all - l2count) resdata[method][str( tval)]['l2count'][rnum] = np.sqrt(l2count) if (sample == "sg"): break missingmean = -1 for method in ['papp', 'rapp', 'rapprd', 'rappsip']: l2allarr = resdata[method]['l2all'] results[fname][sample][noise][method] = {} if (len(l2allarr) != 0): results[fname][sample][noise][method]['l2all'] = float( getstats(l2allarr, 'amean')) results[fname][sample][noise][method][ 'l2allgm'] = float(getstats(l2allarr, 'gmean')) results[fname][sample][noise][method][ 'l2allmed'] = float(getstats(l2allarr, 'median')) results[fname][sample][noise][method][ 'l2allra'] = float(getstats(l2allarr, 'range')) results[fname][sample][noise][method][ 'l2allsd'] = float(np.std(l2allarr)) else: results[fname][sample][noise][method][ 'l2all'] = missingmean results[fname][sample][noise][method][ 'l2allgm'] = missingmean results[fname][sample][noise][method][ 'l2allmed'] = missingmean results[fname][sample][noise][method][ 'l2allra'] = missingmean results[fname][sample][noise][method]['l2allsd'] = 0 for tval in thresholdvalarr: for method in ['papp', 'rapp', 'rapprd', 'rappsip']: results[fname][sample][noise][method][str(tval)] = {} for key in [ 'l2notcount', 'l2count', 'no', 'no_face', 'no_inside' ]: arr = resdata[method][str(tval)][key] if (len(arr) != 0): results[fname][sample][noise][method][str( tval)][key] = float(getstats(arr, 'amean')) results[fname][sample][noise][method][str( tval)][key + 'gm'] = float( getstats(arr, 'gmean')) results[fname][sample][noise][method][str( tval)][key + 'med'] = float( getstats(arr, 'median')) results[fname][sample][noise][method][str( tval)][key + 'ra'] = float( getstats(arr, 'range')) results[fname][sample][noise][method][str( tval)][key + 'sd'] = float(np.std(arr)) else: results[fname][sample][noise][method][str( tval)][key] = missingmean results[fname][sample][noise][method][str( tval)][key + 'gm'] = missingmean results[fname][sample][noise][method][str( tval)][key + 'med'] = missingmean results[fname][sample][noise][method][str( tval)][key + 'ra'] = missingmean results[fname][sample][noise][method][str( tval)][key + 'sd'] = 0 print("done with fn: %s" % (fname)) return results
def plotminimizeranderror(usejson=0): def getData(X_train, fn, noisepct): """ TODO use eval or something to make this less noisy """ from apprentice import testData if fn == "f17": Y_train = [testData.f17(x) for x in X_train] else: raise Exception("function {} not implemented, exiting".format(fn)) return Y_train import json import apprentice from apprentice import RationalApproximationSIP folder = "results" samplearr = ['lhs', 'splitlhs', 'sg'] noise = "0" fname = "f17" noisestr, noisepct = getnoiseinfo(noise) dim = 3 infile = [ "results/plots/poledata_corner" + str(dim) + "D.csv", "results/plots/poledata_inside" + str(dim) + "D.csv" ] if (usejson == 0): minarr = [80, 5, 90] maxarr = [100, 10, 93] X_testfc = np.loadtxt(infile[0], delimiter=',') X_testin = np.loadtxt(infile[1], delimiter=',') s = apprentice.Scaler(np.array(X_testfc, dtype=np.float64), a=minarr, b=maxarr) X_testfc = s.scaledPoints s = apprentice.Scaler(np.array(X_testin, dtype=np.float64), a=minarr, b=maxarr) X_testin = s.scaledPoints Y_testfc = np.array(getData(X_testfc, fname, 0)) Y_testin = np.array(getData(X_testin, fname, 0)) Y_testall = np.concatenate((Y_testfc, Y_testin), axis=None) maxiterexp = [0, 0, 0] for snum, sample in enumerate(samplearr): maxiter = 0 for exp in ['exp1', 'exp2', 'exp3', 'exp4', 'exp5']: file = "%s/%s/%s%s_%s_2x/outrasip/%s%s_%s_2x_p5_q5_ts2x.json" % ( folder, exp, fname, noisestr, sample, fname, noisestr, sample) if not os.path.exists(file): print("rappsipfile %s not found" % (file)) exit(1) if file: with open(file, 'r') as fn: datastore = json.load(fn) if len(datastore['iterationinfo']) > maxiter: maxiter = len(datastore['iterationinfo']) maxiterexp[snum] = exp if (sample == 'sg'): break data = {} for snum, sample in enumerate(samplearr): data[sample] = {} exp = maxiterexp[snum] file = "%s/%s/%s%s_%s_2x/outrasip/%s%s_%s_2x_p5_q5_ts2x.json" % ( folder, exp, fname, noisestr, sample, fname, noisestr, sample) if not os.path.exists(file): print("rappsipfile %s not found" % (file)) exit(1) if file: with open(file, 'r') as fn: datastore = json.load(fn) data[sample]['x'] = [ i for i in range(len(datastore['iterationinfo'])) ] data[sample]['minimizer'] = [] data[sample]['error'] = [] print('starting error calc for %s' % (sample)) for inum, iter in enumerate(datastore['iterationinfo']): print('staring iter %d' % (inum)) data[sample]['minimizer'].append( iter['robOptInfo']['info'][0]['robustObj']) pcoeff = iter['pcoeff'] qcoeff = iter['qcoeff'] if file: with open(file, 'r') as fn: tempds = json.load(fn) tempds['pcoeff'] = pcoeff tempds['qcoeff'] = qcoeff rappsip = RationalApproximationSIP(tempds) Y_pred_rappsipfc = rappsip.predictOverArray(X_testfc) Y_pred_rappsipin = rappsip.predictOverArray(X_testin) Y_pred_rappsipall = np.concatenate( (Y_pred_rappsipfc, Y_pred_rappsipin), axis=None) l2allrappsip = np.sum((Y_pred_rappsipall - Y_testall)**2) data[sample]['error'].append(np.sqrt(l2allrappsip)) print('ending iter %d' % (inum)) print(data) import json with open('results/plots/Jminimizeranderror.json', "w") as f: json.dump(data, f, indent=4, sort_keys=True) elif (usejson == 1): outfilejson = "results/plots/Jminimizeranderror.json" import matplotlib as mpl import matplotlib.pyplot as plt import matplotlib.text as text mpl.rc('text', usetex=True) mpl.rc('font', family='serif', size=12) mpl.rc('font', weight='bold') mpl.rcParams['text.latex.preamble'] = [ r'\usepackage{sfmath} \boldmath' ] # mpl.style.use("ggplot") f, axarr = plt.subplots(2, 1, sharex=True, sharey=False, figsize=(15, 8)) f.subplots_adjust(hspace=0) f.subplots_adjust(wspace=0) style = ['b--', 'r-.', 'g-'] linewidth = [1, 1, 2] labelarr = ['$LHS$', '$\\mathrm{d-LHD}$', '$SG$'] marker = ['x', '*', 'o'] index = 0 if outfilejson: with open(outfilejson, 'r') as fn: data = json.load(fn) for snum, sample in enumerate(samplearr): x = data[sample]['x'] y = data[sample]['minimizer'] x.insert(0, -1) y.insert(0, -2.5) x = np.array(x) + 1 axarr[index].plot(x, y, style[snum], label=labelarr[snum], lineWidth=linewidth[snum], markevery=(1, 1), marker=marker[snum]) axarr[index].axhline(0, linestyle=":", linewidth='1', color='k') axarr[index].legend(fontsize=18, frameon=False) axarr[index].set_ylabel('$min\\quad q(x)$', fontsize=24) axarr[index].tick_params(labelsize=20) index = 1 if outfilejson: with open(outfilejson, 'r') as fn: data = json.load(fn) for snum, sample in enumerate(samplearr): x = data[sample]['x'] y = data[sample]['error'] x.insert(0, -1) y.insert(0, 10**2) x = np.array(x) + 1 axarr[index].plot(x, y, style[snum], label=labelarr[snum], lineWidth=linewidth[snum], markevery=(1, 1), marker=marker[snum]) if (sample == 'splitlhs'): min = np.min(y) axarr[index].axhline(min, linestyle=":", linewidth='1', color='k') axarr[index].set_yscale('log') axarr[index].legend(fontsize=18, frameon=False) axarr[index].set_xlabel('$\\mathrm{Iteration\\ number}$', fontsize=24) axarr[index].set_ylabel('$\\Delta_r$', fontsize=24) axarr[index].tick_params(labelsize=20) # plt.yscale("log") plt.savefig("../../log/minimizererror.pdf", bbox_inches='tight')
def __init__(self, *args, **kwargs): """ Multivariate rational approximation p(x)_m/q(x)_n args: fname --- to read in previously calculated Pade approximation stored as the JSON file dict --- to read in previously calculated Pade approximation stored as the dictionary object obtained after parsing the JSON file X --- anchor points Y --- function values kwargs: m --- order of the numerator polynomial --- if omitted: auto 1 used n --- order of the denominator polynomial --- if omitted: auto 1 used trainingscale --- size of training data to use --- if omitted: auto 1x used .5x is the half the numbner of coeffs in numerator and denominator, 1x is the number of coeffs in numerator and denominator, 2x is twice the number of coeffecients, Cp is 100% of the data box --- box (2D array of dim X [min,max]) within which to perform the approximation --- if omitted: auto dim X [-1, 1] used pnames --- list of parameter names to pass to the scaler to scale scalemin --- scalar or list of shape = dimension of minimum scale value for X --- if omitted: auto -1 used on all dimensions scalemax --- scalar or list of shape = dimension of maximum scale value for X --- if omitted: auto 1 used on all dimensions strategy --- strategy to use --- if omitted: auto 0 used 0: min ||f*q(x)_n - p(x)_m||^2_2 sub. to q(x)_n >=1 1: min ||f*q(x)_n - p(x)_m||^2_2 sub. to q(x)_n >=1 and some p and/or q coeffecients set to 0 2: min ||f*q(x)_n - p(x)_m||^2_2 + lambda*||c_pq||_1 sub. to q(x)_n >=1 fitstrategy --- strategy to perform the fitting (least squares and sparse) --- if omitted: auto 'scipy' used scipy: SLSQP optimization solver in scipy (scipy.SLSQP) filter: filterSQP solver through pyomo (REQUIRED: pyomo and filter executable in PATH) roboptstrategy --- strategy to optimize robust objective --- if omitted: auto 'ms' used ss: single start algorithm using scipy.L-BFGS-B local optimizer ms: multistart algorithm (with 10 restarts at random points from the box) using scipy.L-BFGS-B local optimizer msbarontime: multistart algorithm using scipy.L-BFGS-B local optimizer that restarts for the amount of time baron would run for the no. of nonlinearities baron: baron through pyomo (REQUIRED: Pyomo and baron executable in PATH) solve: solve q(x) at random points in the box of X ss_ms_so_ba: runs single start, multistart, baron and solve, and logs the different objective function values obtained mlsl: multi-level single-linkage multistart algorithm from nlopt using nlopt.LD_LBFGS local optimizer localoptsolver --- strategy to perform local optimization in robust optimization with single start and multistart approaches --- if omitted: auto 'scipy' used scipy: L-BFGS-B optimization solver in scipy (scipy.L-BFGS-B) filter: filterSQP solver through pyomo (REQUIRED: pyomo and filter executable in PATH) penaltyparam --- lambda to use for strategy 2 --- if omitted: auto 0.1 used penaltybin --- penalty binary array for numberator and denomintor of the bits to keep active in strategy 1 and put in penalty term for activity 2 represented in a 2D array of shape(2,(m/n)+1) where for each numberator and denominator, the bits represent penalized coeffecient degrees and constant (1: not peanlized, 0 penalized) required for strategy 1 and 2 """ import os if len(args) == 0: pass else: if type(args[0]) == dict: self.mkFromDict(args[0]) elif type(args[0]) == str: self.mkFromJSON(args[0]) else: # Scaler related kwargs _pnames = kwargs["pnames"] if kwargs.get( "pnames") is not None else None _scale_min = kwargs["scalemin"] if kwargs.get( "scalemin") is not None else -1 _scale_max = kwargs["scalemax"] if kwargs.get( "scalemax") is not None else 1 self._scaler = apprentice.Scaler(np.array(args[0], dtype=np.float64), a=_scale_min, b=_scale_max, pnames=_pnames) self._X = self._scaler.scaledPoints # ONB in scaled world self._ONB = apprentice.ONB(self._X) self._dim = self._X[0].shape[0] self._Y = np.array(args[1], dtype=np.float64) self.mkFromData(kwargs=kwargs)
def ploterrorbars(fff, baseline=13.5, usejson=0): import matplotlib as mpl import json import apprentice if not os.path.exists('results/plots/'): os.makedirs('results/plots/', exist_ok=True) # mpl.use('pgf') # pgf_with_custom_preamble = { # "text.usetex": True, # use inline math for ticks # "pgf.rcfonts": False, # don't setup fonts from rc parameters # "pgf.preamble": [ # "\\usepackage{amsmath}", # load additional packages # ] # } # mpl.rcParams.update(pgf_with_custom_preamble) # fff = getfarr() # pqqq = ['p4_q3','p2_q3','p3_q3','p3_q7','p2_q7','p3_q6','p2_q3','p3_q3'] width = 0.15 # import matplotlib.pyplot as plt # fig, ax = plt.subplots(1,2,figsize=(15,10),sharey=True) data = {} noiselevels = ['0', '10-6', '10-2'] # noiselevels = ['0'] # allsamples = ['mc','lhs','so','sg'] allsamples = ['lhs', 'splitlhs', 'sg'] # allsamples = ['mc','lhs'] # allsamples = ['sg'] if (usejson == 0): for snum, sample in enumerate(allsamples): data[sample] = {} # first = sample for nnum, noise in enumerate(noiselevels): data[sample][noise] = {} second = noise noisestr, noisepct = getnoiseinfo(noise) for fnum, fname in enumerate(fff): data[sample][noise][fname] = {} # IF USING TESTFILE # testfile = "../benchmarkdata/"+fname+"_test.txt" # # testfile = "../benchmarkdata/"+fname+".txt" # print(testfile) # bottom_or_all = all # try: # X, Y = readData(testfile) # except: # DATA = tools.readH5(testfile, [0]) # X, Y= DATA[0] # # if(bottom_or_all == "bottom"): # testset = [i for i in range(trainingsize,len(X_test))] # X_test = X[testset] # Y_test = Y[testset] # else: # X_test = X # Y_test = Y # IF USING POLEDATA FILES dim = getdim(fname) infile = "results/plots/poledata_corner" + str( dim) + "D.csv" X_test_1 = np.loadtxt(infile, delimiter=',') infile = "results/plots/poledata_inside" + str( dim) + "D.csv" X_test_2 = np.loadtxt(infile, delimiter=',') X_test = np.vstack([X_test_1, X_test_2]) minarr, maxarr = getbox(fname) s = apprentice.Scaler(np.array(X_test, dtype=np.float64), a=minarr, b=maxarr) X_test = s.scaledPoints # print(np.shape(X_test_1),np.shape(X_test_2),np.shape(X_test)) Y_test = np.array(getData(X_test, fname, 0)) # print(np.shape(np.array(Y_test))) # exit(1) ts = "2x" datapa = [] datara = [] datarard = [] datarasip = [] for run in ["exp1", "exp2", "exp3", "exp4", "exp5"]: # for run in ["./"]: fndesc = "%s%s_%s_%s" % (fname, noisestr, sample, ts) folder = "results/%s/%s" % (run, fndesc) m = 5 n = 5 pq = "p%d_q%d" % (m, n) print(run, fname, noisestr, sample, m, n) rappsipfile = "%s/outrasip/%s_%s_ts%s.json" % ( folder, fndesc, pq, ts) rappfile = "%s/outra/%s_%s_ts%s.json" % ( folder, fndesc, pq, ts) rapprdfile = "%s/outrard/%s_%s_ts%s.json" % ( folder, fndesc, pq, ts) pappfile = "%s/outpa/%s_%s_ts%s.json" % ( folder, fndesc, pq, ts) if not os.path.exists(rappsipfile): print("rappsipfile %s not found" % (rappsipfile)) if (knowmissing(rappsipfile)): if (sample == "sg"): break continue exit(1) if not os.path.exists(rappfile): print("rappfile %s not found" % (rappfile)) if (knowmissing(rappfile)): if (sample == "sg"): break continue exit(1) if not os.path.exists(rapprdfile): print("rappfile %s not found" % (rapprdfile)) if (knowmissing(rapprdfile)): if (sample == "sg"): break continue exit(1) if not os.path.exists(pappfile): print("pappfile %s not found" % (pappfile)) if (knowmissing(pappfile)): if (sample == "sg"): break continue exit(1) rappsip = RationalApproximationSIP(rappsipfile) Y_pred_rappsip = rappsip.predictOverArray(X_test) rapp = RationalApproximationONB(fname=rappfile) Y_pred_rapp = np.array([rapp(x) for x in X_test]) rapprd = RationalApproximationONB(fname=rapprdfile) Y_pred_rapprd = np.array([rapprd(x) for x in X_test]) papp = PolynomialApproximation(fname=pappfile) Y_pred_papp = np.array([papp(x) for x in X_test]) datapa.append( np.log10(np.sqrt(np.sum( (Y_pred_papp - Y_test)**2)))) datara.append( np.log10(np.sqrt(np.sum( (Y_pred_rapp - Y_test)**2)))) datarard.append( np.log10( np.sqrt(np.sum((Y_pred_rapprd - Y_test)**2)))) datarasip.append( np.log10( np.sqrt(np.sum((Y_pred_rappsip - Y_test)**2)))) if (sample == "sg"): break missingmean = -15 if (len(datapa) == 0): data[sample][noise][fname]['pamean'] = missingmean data[sample][noise][fname]['pasd'] = 0 else: data[sample][noise][fname]['pamean'] = np.average( datapa) data[sample][noise][fname]['pasd'] = np.std(datapa) if (len(datara) == 0): data[sample][noise][fname]['ramean'] = missingmean data[sample][noise][fname]['rasd'] = 0 else: data[sample][noise][fname]['ramean'] = np.average( datara) data[sample][noise][fname]['rasd'] = np.std(datara) if (len(datarard) == 0): data[sample][noise][fname]['rardmean'] = missingmean data[sample][noise][fname]['rardsd'] = 0 else: data[sample][noise][fname]['rardmean'] = np.average( datarard) data[sample][noise][fname]['rardsd'] = np.std(datarard) if (len(datarasip) == 0): data[sample][noise][fname]['rasipmean'] = missingmean data[sample][noise][fname]['rasipsd'] = 0 else: data[sample][noise][fname]['rasipmean'] = np.average( datarasip) data[sample][noise][fname]['rasipsd'] = np.std( datarasip) if (sample == "sg"): data[sample][noise][fname]['pasd'] = 0 data[sample][noise][fname]['rasd'] = 0 data[sample][noise][fname]['rardsd'] = 0 data[sample][noise][fname]['rasipsd'] = 0 outfile111 = "results/plots/Jerrors_" + fff[0] + ".json" import json with open(outfile111, "w") as f: json.dump(data, f, indent=4, sort_keys=True) exit(0) # else: # import json # outfile111 = "results/plots/Jerrors.json" # if outfile111: # with open(outfile111, 'r') as fn: # data = json.load(fn) ecolor = 'black' # if(plottype == 'persample' or plottype == 'pernoiselevel'): # if(plottype == 'persample'): # minval = np.Infinity methodarr = ['ra', 'rard', 'rasip', 'pa'] import matplotlib.pyplot as plt ffffff = plt.figure(0, figsize=(25, 20)) # totalrow = 5 # totalcol = 4 totalrow = 2 totalcol = 2 baseline = baseline # color = ['#900C3F','#C70039','#FF5733','#FFC300'] color = ['#FFC300', '#FF5733', '#900C3F'] width = 0.2 ecolor = 'black' plt.rc('ytick', labelsize=14) plt.rc('xtick', labelsize=14) props = dict(boxstyle='square', facecolor='wheat', alpha=0.5) X111 = np.arange(len(noiselevels) * len(methodarr)) # color100 = ['#FFC300','#FF5733','#900C3F'] # color1k = ['yellow','wheat','r'] axarray = [] for fnum, fname in enumerate(fff): import json outfile111 = "results/plots/Jerrors_" + fname + ".json" if outfile111: with open(outfile111, 'r') as fn: data = json.load(fn) plotd = {} for snum, sample in enumerate(allsamples): plotd[sample] = {} plotd[sample]['mean'] = [] plotd[sample]['sd'] = [] for nnum, noise in enumerate(noiselevels): for method in methodarr: meankey = method + 'mean' sdkey = method + 'sd' plotd[sample]['mean'].append( data[sample][noise][fname][meankey]) plotd[sample]['sd'].append( data[sample][noise][fname][sdkey]) if (len(axarray) > 0): ax = plt.subplot2grid((totalrow, totalcol), (int(fnum / totalcol), int(fnum % totalcol)), sharex=axarray[0], sharey=axarray[0]) axarray.append(ax) else: ax = plt.subplot2grid((totalrow, totalcol), (int(fnum / totalcol), int(fnum % totalcol))) axarray.append(ax) ax.set_xlim(-.3, 11.7) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) plt.axvspan(-.3, 3.7, alpha=0.5, color='pink') plt.axvspan(3.7, 7.7, alpha=0.5, color='lightgrey') plt.axvspan(7.7, 11.7, alpha=0.5, color='cyan') plt.title(fname) # plt.text(1,3.35, "$\\epsilon = 0$", fontsize=10) # plt.text(4,3.35, "$\\epsilon = 10^{-6}$", fontsize=10) # plt.text(7,3.35, "$\\epsilon = 10^{-2}$", fontsize=10) labels = [ 'Latin hypercube sampling', 'Split latin hypercube sampling', 'Sparse grids' ] legendarr = [ '$\\epsilon=0$', '$\\epsilon=10^{-6}$', '$\\epsilon=10^{-2}$' ] # plt.tight_layout() for snum, sample in enumerate(allsamples): if (sample == 'sg'): ax.bar(X111 + snum * width, np.array(plotd[sample]['mean']) + baseline, width, color=color[snum], label=labels[snum]) else: ax.bar(X111 + snum * width, np.array(plotd[sample]['mean']) + baseline, width, color=color[snum], yerr=np.array(plotd[sample]['sd']), align='center', ecolor=ecolor, capsize=3, label=labels[snum]) if (fnum == 0): l1 = ffffff.legend(loc='upper center', ncol=3, fontsize=20) l2 = ffffff.legend(legendarr, loc='upper center', ncol=4, bbox_to_anchor=(0.435, 0.83), fontsize=20, borderaxespad=0., shadow=False) # ax.label_outer() # if(fnum==0): # l222 = ffffff.legend(loc='upper center', ncol=4,bbox_to_anchor=(0.5, 0.92), fontsize = 20,borderaxespad=0.,shadow=False) ax.set_xticks(X111 + (len(allsamples) - 1) * width / 2) xlab = [ 'Algorithm \\ref{ALG:MVVandQR} w/o DR', 'Algorithm \\ref{ALG:MVVandQR}', 'Algorithm \\ref{A:Polyak}', 'Poly. Approx.', 'Algorithm \\ref{ALG:MVVandQR} w/o DR', 'Algorithm \\ref{ALG:MVVandQR}', 'Algorithm \\ref{A:Polyak}', 'Poly. Approx.', 'Algorithm \\ref{ALG:MVVandQR} w/o DR', 'Algorithm \\ref{ALG:MVVandQR}', 'Algorithm \\ref{A:Polyak}', 'Poly. Approx.' ] methodlabel = ['$r_1$', '$r_2$', '$r_3$', '$r_4$'] xlab1 = np.concatenate((methodlabel, methodlabel, methodlabel), axis=None) ax.set_xticklabels(xlab1, fontsize=22) # ax.set_xlabel("Approach",fontsize=22) ax.set_ylabel("$\\log_{10}\\left[\\Delta_r\\right]$", fontsize=22) # ax.label_outer() # ffffff.text(0.08, 0.5, "$\\log_{10}\\left[\\Delta_r\\right]$", fontsize=22,va='center', rotation='vertical') # plt.show() plt.gca().yaxis.set_major_formatter( mtick.FuncFormatter(lambda x, _: x - baseline)) # plt.tight_layout() # plt.savefig("../../log/errors.png", bbox_extra_artists=(l1,l111,), bbox_inches='tight') ffffff.savefig('../../log/errors.png', bbox_extra_artists=( l1, l2, ), bbox_inches='tight') # plt.savefig("../../log/errors.png") plt.clf() plt.close('all') exit(0) for snum, sample in enumerate(allsamples): import matplotlib.pyplot as plt plt.rc('ytick', labelsize=14) fig, axarr = plt.subplots(3, 1, sharey=True, figsize=(21, 20)) for nnum, noise in enumerate(noiselevels): pa = [] ra = [] rard = [] rasip = [] paerror = [] raerror = [] rarderror = [] rasiperror = [] for fnum, fname in enumerate(fff): pa.append(data[sample][noise][fname]['pamean']) paerror.append(data[sample][noise][fname]['pasd']) ra.append(data[sample][noise][fname]['ramean']) raerror.append(data[sample][noise][fname]['rasd']) rard.append(data[sample][noise][fname]['rardmean']) rarderror.append(data[sample][noise][fname]['rardsd']) rasip.append(data[sample][noise][fname]['rasipmean']) rasiperror.append(data[sample][noise][fname]['rasipsd']) p1 = axarr[nnum].bar(X111, np.array(pa) + baseline, width, color=color[0], yerr=np.array(paerror), align='center', ecolor=ecolor, capsize=3) p2 = axarr[nnum].bar(X111 + width, np.array(ra) + baseline, width, color=color[1], yerr=np.array(raerror), align='center', ecolor=ecolor, capsize=3) p3 = axarr[nnum].bar(X111 + 2 * width, np.array(rard) + baseline, width, color=color[2], yerr=np.array(rarderror), align='center', ecolor=ecolor, capsize=3) p4 = axarr[nnum].bar(X111 + 3 * width, np.array(rasip) + baseline, width, color=color[3], yerr=np.array(rasiperror), align='center', alpha=0.5, ecolor=ecolor, capsize=3) axarr[nnum].legend( (p1[0], p2[0], p3[0], p4[0]), ('Polynomial Approx. ', 'Algorithm \\ref{ALG:MVVandQR}', 'Algorithm \\ref{ALG:MVVandQR} w/ DR', 'Algorithm \\ref{A:Polyak}'), loc='upper right', fontsize=15) for ax in axarr.flat: ax.set_xticks(X111 + 3 * width / 2) xlab = [] for f in fff: print(f) # xlab.append("\\ref{fn:%s}"%(f)) xlab.append("%s" % (f)) ax.set_xticklabels(xlab, fontsize=14) ax.set_ylabel('$log_{10}(\\Delta_r)$', fontsize=17) ax.label_outer() plt.gca().yaxis.set_major_formatter( mtick.FuncFormatter(lambda x, _: x - baseline)) plt.tight_layout() print(xlab) # plt.show() # plt.savefig("plots/Perrorbars.pgf", bbox_inches="tight") # outfile111 = "results/plots/Perrorbars_for_%s.pdf"%(sample) outfile111 = "results/plots/Perrorbars_for_%s.pgf" % (sample) plt.savefig(outfile111, bbox_inches="tight") plt.clf() plt.close('all') # elif(plottype == 'pernoiselevel'): # FOR FUTURE # approxqqq = ["Polynomial Approximation", 'RA (linear algebra) without degree reduction', 'RA (linear algebra) with degree reduction', 'Pole-free RA'] # for nnum,noise in enumerate(noiselevels): # import matplotlib.pyplot as plt # plt.rc('ytick',labelsize=14) # fig, axarr = plt.subplots(4, 1, sharey=True,figsize=(21,20)) # for anum,approx in enumerate(["pa","ra","rard","rasip"]): # barobj = {} # for snum,sample in enumerate(allsamples): # mean = [] # sd = [] # for fnum,fname in enumerate(fff): # mean.append(data[sample][noise][fname][approx+"mean"]) # sd.append(data[sample][noise][fname][approx+"sd"]) # barobj[snum] = axarr[anum].bar(X111+snum*width, np.array(mean)+baseline, width,color=color[snum], yerr=np.array(sd),align='center', ecolor=ecolor, capsize=3) # # axarr[anum].legend((barobj[0][0],barobj[1][0],barobj[2][0],barobj[3][0]),('Uniform Random','Latin Hypercube','Sobol Sequence', 'Sparse Grids'),loc = 'upper right',fontsize = 15) # axarr[anum].set_title(" approx = "+approxqqq[anum],fontsize = 15) for nnum, noise in enumerate(noiselevels): import matplotlib.pyplot as plt plt.rc('ytick', labelsize=14) fig, axarr = plt.subplots(4, 1, sharey=True, figsize=(21, 20)) for anum, approx in enumerate(["pa", "ra", "rard", "rasip"]): for snum, sample in enumerate(allsamples): barobj = [] mean = [] sd = [] for fnum, fname in enumerate(fff): mean.append(data[sample][noise][fname][approx + "mean"]) sd.append(data[sample][noise][fname][approx + "sd"]) barobj.append(axarr[anum].bar(X111 + snum * width, np.array(mean) + baseline, width, color=color[snum], yerr=np.array(sd), align='center', ecolor=ecolor, capsize=3)) # axarr[anum].legend(barobj,('Polynomial Approx. ', 'Algorithm \\ref{ALG:MVVandQR}','Algorithm \\ref{A:Polyak}'),loc = 'upper right',fontsize = 15) axarr[anum].set_title(str(allsamples) + " approx = " + approx) for ax in axarr.flat: ax.set_xticks(X111 + (len(allsamples) - 1) * width / 2) xlab = [] for f in fff: print(f) # xlab.append("\\ref{fn:%s}"%(f)) xlab.append("%s" % (f)) ax.set_xticklabels(xlab, fontsize=14) ax.set_ylabel('$log_{10}(\\Delta_r)$', fontsize=17) ax.label_outer() plt.gca().yaxis.set_major_formatter( mtick.FuncFormatter(lambda x, _: x - baseline)) plt.tight_layout() print(xlab) # plt.show() # plt.savefig("plots/Perrorbars.pgf", bbox_inches="tight") # outfile111 = "results/plots/Perrorbars_for_%s.pdf"%(noise) outfile111 = "results/plots/Perrorbars_for_%s.pgf" % (noise) plt.savefig(outfile111, bbox_inches="tight") plt.clf() plt.close('all')
def runfacevsinner(): def getData(X_train, fn, noisepct, seed): """ TODO use eval or something to make this less noisy """ from apprentice import testData if fn == "f18": Y_train = [testData.f18(x) for x in X_train] elif fn == "f20": Y_train = [testData.f20(x) for x in X_train] else: raise Exception("function {} not implemented, exiting".format(fn)) np.random.seed(seed) stdnormalnoise = np.zeros(shape=(len(Y_train)), dtype=np.float64) for i in range(len(Y_train)): stdnormalnoise[i] = np.random.normal(0, 1) # return Y_train return np.atleast_2d( np.array(Y_train) * (1 + noisepct * stdnormalnoise)) def getbox(f): minbox = [] maxbox = [] if (f == "f18"): minbox = [-0.95, -0.95, -0.95, -0.95] maxbox = [0.95, 0.95, 0.95, 0.95] elif (f == "f20"): minbox = [10**-6, 10**-6, 10**-6, 10**-6] maxbox = [4 * np.pi, 4 * np.pi, 4 * np.pi, 4 * np.pi] else: minbox = [-1, -1] maxbox = [1, 1] return minbox, maxbox from apprentice import tools data = {'info': []} import apprentice dim = 4 seedarr = [54321, 456789, 9876512, 7919820, 10397531] m = 5 n = 5 tstimes = 2 ts = "2x" # fname = "f20-"+str(dim)+"D_ts"+ts fname = "f20-" + str(dim) + "D" from apprentice import tools from pyDOE import lhs npoints = tstimes * tools.numCoeffsRapp(dim, [m, n]) print(npoints) epsarr = [] for d in range(dim): #epsarr.append((maxarr[d] - minarr[d])/10) epsarr.append(10**-6) facespctarr = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] folder = "f18_f20_facevsinner" for numex, ex in enumerate(["exp1", "exp2", "exp3", "exp4", "exp5"]): seed = seedarr[numex] for facenum, facepct in enumerate(facespctarr): facepoints = int(np.ceil(npoints * facepct)) insidepoints = int(npoints - facepoints) # print(insidepoints) # Generate inside points for fname in ['f18', 'f20']: Xmain = np.empty([0, dim]) minarrinside = [] maxarrinside = [] minarr, maxarr = getbox(fname) if (insidepoints > 1): for d in range(dim): minarrinside.append(minarr[d] + epsarr[d]) maxarrinside.append(maxarr[d] - epsarr[d]) X = lhs(dim, samples=insidepoints, criterion='maximin') s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarrinside, b=maxarrinside) X = s.scaledPoints Xmain = np.vstack((Xmain, X)) #Generate face points perfacepoints = int(np.ceil(facepoints / (2 * dim))) if (perfacepoints > 1): index = 0 for d in range(dim): for e in [minarr[d], maxarr[d]]: index += 1 np.random.seed(seed + index * 100) X = lhs(dim, samples=perfacepoints, criterion='maximin') minarrface = np.empty(shape=dim, dtype=np.float64) maxarrface = np.empty(shape=dim, dtype=np.float64) for p in range(dim): if (p == d): if e == maxarr[d]: minarrface[p] = e - epsarr[d] maxarrface[p] = e else: minarrface[p] = e maxarrface[p] = e + epsarr[d] else: minarrface[p] = minarr[p] maxarrface[p] = maxarr[p] s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarrface, b=maxarrface) X = s.scaledPoints Xmain = np.vstack((Xmain, X)) Xmain = np.unique(Xmain, axis=0) X = Xmain # formatStr = "{0:0%db}"%(dim) # for d in range(2**dim): # binArr = [int(x) for x in formatStr.format(d)[0:]] # val = [] # for i in range(dim): # if(binArr[i] == 0): # val.append(minarr[i]) # else: # val.append(maxarr[i]) # X[d] = val if not os.path.exists(folder + "/" + ex + '/benchmarkdata'): os.makedirs(folder + "/" + ex + '/benchmarkdata', exist_ok=True) noise = "0" noisestr, noisepct = getnoiseinfo(noise) Y = getData(X, fn=fname, noisepct=noisepct, seed=seed) infile = "%s/%s/benchmarkdata/%s%s_splitlhs_f%d_i%d.txt" % ( folder, ex, fname, noisestr, facepoints, insidepoints) print(infile) np.savetxt(infile, np.hstack((X, Y.T)), delimiter=",") folderplus = "%s/%s/%s%s_splitlhs" % (folder, ex, fname, noisestr) fndesc = "%s%s_splitlhs_f%d_i%d" % (fname, noisestr, facepoints, insidepoints) if not os.path.exists(folderplus + "/outrasip"): os.makedirs(folderplus + "/outrasip", exist_ok=True) if not os.path.exists(folderplus + "/log/consolelograsip"): os.makedirs(folderplus + "/log/consolelograsip", exist_ok=True) m = str(m) n = str(n) consolelog = folderplus + "/log/consolelograsip/" + fndesc + "_p" + m + "_q" + n + "_ts2x.log" outfile = folderplus + "/outrasip/" + fndesc + "_p" + m + "_q" + n + "_ts2x.json" data['info'].append({ 'exp': ex, 'fname': fname, 'outfile': outfile, 'facepoints': facepoints, 'insidepoints': insidepoints }) penaltyparam = 0 cmd = 'nohup python runrappsip.py %s %s %s %s Cp %f %s %s >%s 2>&1 &' % ( infile, fndesc, m, n, penaltyparam, folderplus, outfile, consolelog) # print(cmd) # exit(1) os.system(cmd) import json with open(folder + "/data.json", "w") as f: json.dump(data, f, indent=4, sort_keys=True)
def cubeplot(): from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt import numpy as np from itertools import product, combinations fig = plt.figure() ax = fig.gca(projection='3d') ax.set_aspect("equal") vertices = np.empty(shape=(0, 3)) # draw cube r = [-1, 1] coord = combinations(np.array(list(product(r, r, r))), 2) for s, e in coord: if np.sum(np.abs(s - e)) == r[1] - r[0]: ax.plot3D(*zip(s, e), color="b") # print(s) vertices = np.append(vertices, [s], axis=0) vertices = np.append(vertices, [e], axis=0) vertices = np.unique(vertices, axis=0) print(np.shape(vertices)) print(vertices) npoints = 50 eps = 0.2 dim = 3 from pyDOE import lhs import apprentice # for v in vertices: # minarr = [] # maxarr = [] # for p in v: # if(p==1): # maxarr.append(p) # minarr.append(p-eps) # elif(p==-1): # maxarr.append(p+eps) # minarr.append(p) # for d in range(dim): # if minarr[d] == -1+eps: # maxarr[d] == 1 # elif maxarr[d] == 1-eps: # minarr[d] == -1 # print(v,minarr,maxarr) # s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarr, b=maxarr) # X = s.scaledPoints # # ax.scatter3D(X[:,0],X[:,1],X[:,2]) ax.set_xlabel("x") ax.set_ylabel("y") ax.set_zlabel("z") # plt.show() # exit(1) Xmain = np.empty([0, 3]) index = -1 for d in range(dim): for x in [-1, 1]: index += 1 seedarr = [221, 323, 545, 435, 944, 664] np.random.seed(seedarr[index]) X = lhs(dim, samples=npoints, criterion='maximin') minarr = [0, 0, 0] maxarr = [0, 0, 0] for p in range(dim): if (p == d): if x == 1: minarr[p] = x + ((-1 * x) / np.abs(x)) * eps maxarr[p] = x else: minarr[p] = x maxarr[p] = x + ((-1 * x) / np.abs(x)) * eps else: minarr[p] = -1 maxarr[p] = 1 print(minarr, maxarr) s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarr, b=maxarr) X = s.scaledPoints # X = np.append(X,[[0,0,0]],axis = 0) Xmain = np.vstack((Xmain, X)) ax.scatter3D(X[:, 0], X[:, 1], X[:, 2]) # if(index == 4): break # print(Xmain) print(np.shape(Xmain)) Xmain = np.unique(Xmain, axis=0) print(np.shape(Xmain)) # minarr = [-1, 1-eps, -1] # maxarr = [1, 1, 1] # print(minarr,maxarr) # s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarr, b=maxarr) # X = s.scaledPoints # ax.scatter3D(X[:,0],X[:,1],X[:,2]) # minarr = [-1, -1, -1] # maxarr = [1, 1, -1+eps] # s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarr, b=maxarr) # X = s.scaledPoints # ax.scatter3D(X[:,0],X[:,1],X[:,2]) plt.show()
def generatebenchmarkdata(m, n): seedarr = [54321, 456789, 9876512, 7919820, 10397531] folder = "results" samplearr = ["mc", "lhs", "so", "sg", "splitlhs"] # samplearr = ["lhs","sg","splitlhs"] # samplearr = ["lhs","splitlhs"] # samplearr = ["splitlhs"] from apprentice import tools from pyDOE import lhs import apprentice ts = 2 farr = getfarr() for fname in farr: dim = getdim(fname) minarr, maxarr = getbox(fname) npoints = ts * tools.numCoeffsRapp(dim, [int(m), int(n)]) print(npoints) for sample in samplearr: for numex, ex in enumerate( ["exp1", "exp2", "exp3", "exp4", "exp5"]): seed = seedarr[numex] np.random.seed(seed) if (sample == "mc"): Xperdim = () for d in range(dim): Xperdim = Xperdim + (np.random.rand(npoints, ) * (maxarr[d] - minarr[d]) + minarr[d], ) X = np.column_stack(Xperdim) formatStr = "{0:0%db}" % (dim) for d in range(2**dim): binArr = [int(x) for x in formatStr.format(d)[0:]] val = [] for i in range(dim): if (binArr[i] == 0): val.append(minarr[i]) else: val.append(maxarr[i]) X[d] = val elif (sample == "sg"): from dolo.numeric.interpolation.smolyak import SmolyakGrid s = 0 l = 1 while (s < npoints): sg = SmolyakGrid(a=minarr, b=maxarr, l=l) s = sg.grid.shape[0] l += 1 X = sg.grid elif (sample == "so"): X = my_i4_sobol_generate(dim, npoints, seed) s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarr, b=maxarr) X = s.scaledPoints elif (sample == "lhs"): X = lhs(dim, samples=npoints, criterion='maximin') s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarr, b=maxarr) X = s.scaledPoints elif (sample == "splitlhs"): epsarr = [] for d in range(dim): #epsarr.append((maxarr[d] - minarr[d])/10) epsarr.append(10**-6) facepoints = int( 2 * tools.numCoeffsRapp(dim - 1, [int(m), int(n)])) insidepoints = int(npoints - facepoints) Xmain = np.empty([0, dim]) # Generate inside points minarrinside = [] maxarrinside = [] for d in range(dim): minarrinside.append(minarr[d] + epsarr[d]) maxarrinside.append(maxarr[d] - epsarr[d]) X = lhs(dim, samples=insidepoints, criterion='maximin') s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarrinside, b=maxarrinside) X = s.scaledPoints Xmain = np.vstack((Xmain, X)) #Generate face points perfacepoints = int(np.ceil(facepoints / (2 * dim))) index = 0 for d in range(dim): for e in [minarr[d], maxarr[d]]: index += 1 np.random.seed(seed + index * 100) X = lhs(dim, samples=perfacepoints, criterion='maximin') minarrface = np.empty(shape=dim, dtype=np.float64) maxarrface = np.empty(shape=dim, dtype=np.float64) for p in range(dim): if (p == d): if e == maxarr[d]: minarrface[p] = e - epsarr[d] maxarrface[p] = e else: minarrface[p] = e maxarrface[p] = e + epsarr[d] else: minarrface[p] = minarr[p] maxarrface[p] = maxarr[p] s = apprentice.Scaler(np.array(X, dtype=np.float64), a=minarrface, b=maxarrface) X = s.scaledPoints Xmain = np.vstack((Xmain, X)) Xmain = np.unique(Xmain, axis=0) X = Xmain formatStr = "{0:0%db}" % (dim) for d in range(2**dim): binArr = [int(x) for x in formatStr.format(d)[0:]] val = [] for i in range(dim): if (binArr[i] == 0): val.append(minarr[i]) else: val.append(maxarr[i]) X[d] = val if not os.path.exists(folder + "/" + ex + '/benchmarkdata'): os.makedirs(folder + "/" + ex + '/benchmarkdata', exist_ok=True) for noise in ["0", "10-2", "10-4", "10-6"]: noisestr, noisepct = getnoiseinfo(noise) Y = getData(X, fn=fname, noisepct=noisepct, seed=seed) outfile = "%s/%s/benchmarkdata/%s%s_%s.txt" % ( folder, ex, fname, noisestr, sample) print(outfile) np.savetxt(outfile, np.hstack((X, Y.T)), delimiter=",") if (sample == "sg"): break
def generatespecialdata(): from apprentice import tools from pyDOE import lhs m = 5 n = 5 dim = 2 farr = ["f8", "f9", "f12"] noisearr = ["0", "10-12", "10-10", "10-8", "10-6", "10-4"] ts = 2 npoints = ts * tools.numCoeffsRapp(dim, [int(m), int(n)]) # sample = "sg" # from dolo.numeric.interpolation.smolyak import SmolyakGrid # s = 0 # l = 2 # while(s < npoints): # sg = SmolyakGrid(a=[-1,-1],b=[1,1], l=l) # s = sg.grid.shape[0] # l+=1 # X = sg.grid # lennn = sg.grid.shape[0] # import apprentice # sample = "lhs" # X = lhs(dim, samples=npoints, criterion='maximin') # s = apprentice.Scaler(np.array(X, dtype=np.float64), a=[-1,-1], b=[1,1]) # X = s.scaledPoints # lennn = npoints import apprentice seed = 54321 sample = "so" X = my_i4_sobol_generate(dim, npoints, seed) s = apprentice.Scaler(np.array(X, dtype=np.float64), a=[-1, -1], b=[1, 1]) X = s.scaledPoints lennn = npoints stdnormalnoise = np.zeros(shape=(lennn), dtype=np.float64) for i in range(lennn): stdnormalnoise[i] = np.random.normal(0, 1) for fname in farr: minarr, maxarr = getbox(fname) for noise in noisearr: noisestr = "" noisepct = 0 if (noise != "0"): noisestr = "_noisepct" + noise if (noise == "10-4"): noisepct = 10**-4 elif (noise == "10-6"): noisepct = 10**-6 elif (noise == "10-8"): noisepct = 10**-8 elif (noise == "10-10"): noisepct = 10**-10 elif (noise == "10-12"): noisepct = 10**-12 print(noisepct) Y = getData(X, fn=fname, noisepct=0, seed=seed) Y_train = np.atleast_2d( np.array(Y) * (1 + noisepct * stdnormalnoise)) outfolder = "/Users/mkrishnamoorthy/Desktop/Data" outfile = "%s/%s%s_%s.txt" % (outfolder, fname, noisestr, sample) print(outfile) np.savetxt(outfile, np.hstack((X, Y_train.T)), delimiter=",")
def getresults(farr, noisearr, tarr, ts, allsamples, usecornerpoints): import apprentice m = 5 n = 5 thresholdvalarr = np.array([float(t) for t in tarr]) thresholdvalarr = np.sort(thresholdvalarr) results = {} for fnum, fname in enumerate(farr): results[fname] = {} dim = getdim(fname) if (usecornerpoints == 1): infile = "results/plots/poledata_corner" + str(dim) + "D.csv" else: infile = "results/plots/poledata_inside" + str(dim) + "D.csv" X_test = np.loadtxt(infile, delimiter=',') print(len(X_test)) minarr, maxarr = getbox(fname) s = apprentice.Scaler(np.array(X_test, dtype=np.float64), a=minarr, b=maxarr) X_test = s.scaledPoints Y_test = np.array(getData(X_test, fname, 0)) maxY_test = max(1, abs(np.max(Y_test))) print(fname, maxY_test) results[fname]['npoints'] = len(Y_test) for snum, sample in enumerate(allsamples): results[fname][sample] = {} for noise in noisearr: results[fname][sample][noise] = {} noisestr, noisepct = getnoiseinfo(noise) resdata = {} resdata['rapp'] = {} resdata['rapprd'] = {} resdata['rappsip'] = {} resdata['rapp']['l2all'] = [] resdata['rapprd']['l2all'] = [] resdata['rappsip']['l2all'] = [] for tval in thresholdvalarr: for method in ['rapp', 'rapprd', 'rappsip']: resdata[method][str(tval)] = {} resdata[method][str(tval)]['no'] = [] resdata[method][str(tval)]['l2count'] = [] resdata[method][str(tval)]['l2notcount'] = [] for rnum, run in enumerate( ["exp1", "exp2", "exp3", "exp4", "exp5"]): fndesc = "%s%s_%s_%s" % (fname, noisestr, sample, ts) folder = "results/%s/%s" % (run, fndesc) # print(folder) pq = "p%d_q%d" % (m, n) # print(run, fname,noisestr,sample,m,n) rappsipfile = "%s/outrasip/%s_%s_ts%s.json" % ( folder, fndesc, pq, ts) rappfile = "%s/outra/%s_%s_ts%s.json" % (folder, fndesc, pq, ts) rapprdfile = "%s/outrard/%s_%s_ts%s.json" % ( folder, fndesc, pq, ts) if not os.path.exists(rappsipfile): print("rappsipfile %s not found" % (rappsipfile)) if (knowmissing(rappsipfile) == 1): if (sample == "sg"): break continue exit(1) if not os.path.exists(rappfile): print("rappfile %s not found" % (rappfile)) if (knowmissing(rappfile) == 1): if (sample == "sg"): break continue exit(1) if not os.path.exists(rapprdfile): print("rappfile %s not found" % (rapprdfile)) if (knowmissing(rapprdfile) == 1): if (sample == "sg"): break continue exit(1) print(fndesc + " Start") rappsip = RationalApproximationSIP(rappsipfile) try: Y_pred_rappsip = rappsip.predictOverArray(X_test) except: Y_pred_rappsip = findpredval(X_test, rappsip) rapp = RationalApproximationONB(fname=rappfile) try: Y_pred_rapp = np.array([rapp(x) for x in X_test]) except: Y_pred_rapp = findpredval(X_test, rapp) rapprd = RationalApproximationONB(fname=rapprdfile) try: Y_pred_rapprd = np.array([rapprd(x) for x in X_test]) except: Y_pred_rapprd = findpredval(X_test, rapprd) print(fndesc + " Done") sys.stdout.flush() l2allrapp = np.sum((Y_pred_rapp - Y_test)**2) l2allrapprd = np.sum((Y_pred_rapprd - Y_test)**2) l2allrappsip = np.sum((Y_pred_rappsip - Y_test)**2) # print(l2allrapp,l2allrapprd,l2allrappsip) resdata['rapp']['l2all'].append(np.sqrt(l2allrapp)) resdata['rapprd']['l2all'].append(np.sqrt(l2allrapprd)) resdata['rappsip']['l2all'].append(np.sqrt(l2allrappsip)) for tnum, tval in enumerate(thresholdvalarr): for method in ['rapp', 'rapprd', 'rappsip']: resdata[method][str(tval)]['no'].append(0) resdata[method][str(tval)]['l2count'].append(0.) resdata[method][str(tval)]['l2notcount'].append(0.) for num, yt in enumerate(Y_test): for method, pred in zip( ['rapp', 'rapprd', 'rappsip'], [Y_pred_rapp, Y_pred_rapprd, Y_pred_rappsip]): yp = pred[num] for tnum, tval in enumerate(thresholdvalarr): if (abs(yp) / maxY_test > tval): resdata[method][str(tval)]['no'][rnum] += 1 resdata[method][str( tval)]['l2count'][rnum] += (yp - yt)**2 for tnum, tval in enumerate(thresholdvalarr): for method, l2all in zip( ['rapp', 'rapprd', 'rappsip'], [l2allrapp, l2allrapprd, l2allrappsip]): l2count = resdata[method][str( tval)]['l2count'][rnum] resdata[method][str( tval)]['l2notcount'][rnum] = np.sqrt(l2all - l2count) resdata[method][str( tval)]['l2count'][rnum] = np.sqrt(l2count) if (sample == "sg"): break missingmean = -1 for method in ['rapp', 'rapprd', 'rappsip']: l2allarr = resdata[method]['l2all'] results[fname][sample][noise][method] = {} if (len(l2allarr) != 0): results[fname][sample][noise][method][ 'l2all'] = np.average(l2allarr) results[fname][sample][noise][method][ 'l2allsd'] = np.std(l2allarr) else: results[fname][sample][noise][method][ 'l2all'] = missingmean results[fname][sample][noise][method]['l2allsd'] = 0 for tval in thresholdvalarr: for method in ['rapp', 'rapprd', 'rappsip']: results[fname][sample][noise][method][str(tval)] = {} for key in ['l2notcount', 'l2count', 'no']: arr = resdata[method][str(tval)][key] if (len(arr) != 0): results[fname][sample][noise][method][str( tval)][key] = np.average(arr) results[fname][sample][noise][method][str( tval)][key + 'sd'] = np.std(arr) else: results[fname][sample][noise][method][str( tval)][key] = missingmean results[fname][sample][noise][method][str( tval)][key + 'sd'] = 0 print("done with fn: %s for usecornerpoints = %d" % (fname, usecornerpoints)) return results
import sys assert (sys.argv[1] != sys.argv[2]) binids, P = app.io.readApprox(sys.argv[1]) SC = [p._scaler for p in P] DIM = SC[0].dim xmin, xmax = [], [] for d in range(DIM): xmin.append(max([s.box[d][0] for s in SC])) xmax.append(min([s.box[d][1] for s in SC])) # New scaler sc = app.Scaler([xmin, xmax]) sc._pnames = SC[0].pnames NC = app.tools.numCoeffsPoly(P[0].dim, P[0].m) X = P[0]._scaler.drawSamples(NC) A = np.prod(np.power(sc.scale(X), P[0]._struct_p[:, np.newaxis]), axis=2).T Z = [] import time t0 = time.time() for num, p in enumerate(P): # cnew = app.tools.refitPoly(p, sc) cnew = app.tools.refitPolyAX(p, A, X) Z.append(cnew) if (num + 1) % 50 == 0: print("{}/{} after {} seconds".format(num + 1, len(P),
#!/usr/bin/env python import json import apprentice import numpy as np if __name__ == "__main__": import sys M=json.load(open(sys.argv[1])) X = np.array(M["x"]) Y = np.array(M["fun"]) S=apprentice.Scaler(sys.argv[2]) # Trivial new box based on min/max of results M_min = np.min(X, axis=0) M_max = np.max(X, axis=0) # Extra width allowance=0.25 # new_box = [] # Figure out if we hit the wall for num, (r, l) in enumerate(zip(np.isclose(S.sbox[:,0], S(M_min, unscale=True), rtol=1e-2), np.isclose(S.sbox[:,1], S(M_max, unscale=True), rtol=1e-2) )): # print(num, r,l) dist = M_max[num] - M_min[num] if not r and not l: new_box.append( [ M_min[num] - allowance*dist, M_max[num] + allowance*dist ]) elif r and not l: new_box.append( [ M_min[num] - dist, M_max[num] + allowance*dist ]) elif l and not r: new_box.append( [ M_min[num] - allowance*dist, M_max[num] + dist ])
def mkCov(yerrs): return np.atleast_2d(yerrs).T * np.atleast_2d(yerrs) * np.eye( yerrs.shape[0]) if __name__ == "__main__": import sys # At the moment, the object selection for the chi2 minimisation is # simply everything that is in the approximation file binids, RA = readApprox(sys.argv[1]) Y, E = readExpData(sys.argv[2], [str(b) for b in binids]) E2 = [e**2 for e in E] S = apprentice.Scaler("{}.scaler".format(sys.argv[1])) # NOTE: all evaluations are happening in the scaled world def chi2(x): return sum([(Y[i] - RA[i](x))**2 / E2[i] for i in range(len(binids))]) from scipy import optimize res = optimize.minimize(chi2, S.center, bounds=S.sbox) print("Minimum found at {}".format(S(res["x"], unscale=True))) # Now do some more universes NSAMPLES = 1000 COV = mkCov(E) import scipy.stats as st