def coreFunc(a): """runs the below for an angle, a""" i, a, n_samples = a model = Model( x0, pot=pot, spacing=spacing, # set up model rng=rng, step_size=step_size, n_steps=n_steps, rand_steps=rand_steps) c = acorr.Autocorrelations_1d(model) # set up autocorrs c.runModel( n_samples=n_samples, n_burn_in=n_burn_in, # run MCMC mixing_angle=a, verbose=explicit_prog, verb_pos=i) cfn = opFn(c.model.samples) # run func on HMC samples # get parameters generated p = c.model.p_acc # get acceptance rates at each M-H step # Calculating integrated autocorrelations ans = errors.uWerr(cfn) xx, f_diff, _, itau, itau_diff, itaus, _ = ans w = errors.getW(itau, itau_diff, n=cfn.shape[0]) out = itau, itau_diff, f_diff, w return xx, p, itau, itau_diff, f_diff, w
def coreFunc(a): """runs the below for an angle, a Allows multiprocessing across a range of values for a """ i,d,a = a model = Model(x0, pot=pot, rng=rng, step_size = d, n_steps = n_steps, rand_steps=False) c = acorr.Autocorrelations_1d(model) c.runModel(n_samples=n_samples, n_burn_in=n_burn_in, mixing_angle = a, verbose=False, verb_pos=i) acs = c.getAcorr(separations, opFn, norm = False) # get parameters generated pacc = c.model.p_acc pacc_err = np.std(c.model.sampler.accept.accept_rates) ans = errors.uWerr(c.op_samples, acorr=acs) # get errors op_av, op_diff, _, itau, itau_diff, _, acns = ans # extract data w = errors.getW(itau, itau_diff, n=n_samples) # get window length if not np.isnan(w): acns_err = errors.acorrnErr(acns, w, n_samples) # get error estimates acs = acns else: acns_err = np.full(acs.shape, np.nan) itau = itau_diff = np.nan return op_av, op_diff, acs, acns_err, itau, itau_diff, pacc, pacc_err, w
def core(i): """multiprocessing""" av = c.getTwoPoint(separation=i) ans = errors.uWerr(c.op_samples) # get errors f_aav, f_diff, _, itau, itau_diff, _, acns = ans # extract data return f_aav, f_diff, itau
def coreFunc(a): """runs the below for an angle, a""" i, a = a model = Model( x0, pot=pot, spacing=spacing, # set up model rng=rng, step_size=step_size, n_steps=n_steps, rand_steps=rand_steps) c = acorr.Autocorrelations_1d(model) # set up autocorrs c.runModel( n_samples=n_samples, n_burn_in=n_burn_in, # run MCMC mixing_angle=a, verbose=True, verb_pos=i) acs = c.getAcorr(separations, opFn, norm=False, prll_map=None, ac=acs, max_itau=max_itau) cfn = c.op_samples # get parameters generated p = c.model.p_acc # get acceptance rates at each M-H step xx = np.average( cfn) # get average of the function run over the samples ans = errors.uWerr(cfn, acorr=acs) if itauFunc: t = itauFunc(tau=n_steps * step_size, m=1, pa=p, theta=a) else: t = None if acTheory is not None: th_x = np.linspace(0, c.acorr_ficticous_time, 10000) ac_th = np.asarray([th_x, [acTheory(t, p, a) for t in th_x]]) else: ac_th = None x, gta, w = preparePlot(cfn, n=n_samples, itau_theory=t, mcore=True, acn_theory=ac_th) return xx, traj, p, x, gta, w
def coreFunc(a): """runs the below for an angle, a Allows multiprocessing across a range of values for a """ i, a = a model = Model(x0, pot=pot, spacing=spacing, rng=rng, step_size=step_size, n_steps=n_steps, rand_steps=rand_steps) c = acorr.Autocorrelations_1d(model) c.runModel(n_samples=n_samples, n_burn_in=n_burn_in, mixing_angle=a, verbose=True, verb_pos=i) store.store(c.model.samples, file_name, '_samples') store.store(c.model.traj, file_name, '_trajs') acs = c.getAcorr(separations, opFn, norm=False, prll_map=prll_map, max_sep=50) # non norm for uWerr # get parameters generated traj = np.cumsum(c.trajs) p = c.model.p_acc xx = c.op_mean acorr_seps = c.acorr_ficticous_time acorr_counts = c.acorr_counts store.store(p, file_name, '_probs') store.store(acs, file_name, '_acs') ans = errors.uWerr(c.op_samples, acorr=acs) # get errors _, _, _, itau, itau_diff, _, acns = ans # extract data w = errors.getW(itau, itau_diff, n=n_samples) # get window length acns_err = errors.acorrnErr(acns, w, n_samples) # get error estimates if rand_steps: # correct for N being different for each correlation acns_err *= np.sqrt(n_samples) / acorr_counts return xx, acns, acns_err, p, w, traj, acorr_seps
def minimise_func(arg): """runs the below for an angle, a Allows multiprocessing across a range of values for a """ mixing_angle, step_size = arg print 'angle:{:10.4f}; step size:{:10.4f}'.format(mixing_angle, step_size) model = Model(x0, pot=pot, rng=rng, step_size = step_size) model.run(n_samples=n_samples, n_burn_in=n_burn_in, mixing_angle = mixing_angle, verbose=True) op_samples = opFn(model.samples) # get parameters generated # pacc = c.model.p_acc # pacc_err = np.std(c.model.sampler.accept.accept_rates) ans = errors.uWerr(op_samples) # get errors op_av, op_diff, _, itau, itau_diff, _, _ = ans # extract data return itau#, itau_diff, pacc, pacc_err
aFn = lambda s: acorrMapped( op_samples, tsum, s, av_op, norm=1.0, tol=tolerance, counts=True) separations = np.linspace(min_sep, max_sep, (max_sep - min_sep) / res + 1) # multicore result = prll_map(aFn, separations, verbose=True) a, counts = zip(*result) a = np.asarray(a) # the autocorrelation array counts = np.array(counts) # the counts at each separation # mask = 1-np.isnan(a) # a = a[mask] a = a * counts # grab errors print 'getting errors...' ans = uWerr(op_samples, a) _, _, _, itau, itau_diff, _, acns = ans # extract data my_w = getW(itau, itau_diff, n=n_samples) # get window length my_err = acorrnErr(acns, my_w, n_samples) # get autocorr errors my_err *= np.sqrt(n_samples) / np.sqrt(counts) # theory calclations th_x = np.linspace(min_sep, max_sep, 1000) th = np.array([hmc(p, phi, r, i) for i in th_x]) from scipy.optimize import curve_fit fn = lambda x, a, b, c: a * np.cos(b * x)**2 + c expFn = lambda x, a, b, c: a * np.exp(-b * x) + c cos_sq = curve_fit(fn, separations[:50], acns[:50]) exp_fit = curve_fit(expFn, separations[1:80], counts[1:80])
del acs # calculate autocorrelations aFn = lambda s: acorrMapped( op_samples, tsum, s, av_op, norm=1.0, tol=tolerance, counts=True) separations = np.linspace(min_sep, max_sep, (max_sep - min_sep) / res + 1) # multicore result = prll_map(aFn, separations, verbose=True) a, counts = zip(*result) a = np.asarray(a) # the autocorrelation array counts = np.array(counts) # the counts at each separation # grab errors print 'getting errors...' ans = uWerr(op_samples, a * counts) _, _, _, itau, itau_diff, _, acns = ans # extract data my_w = getW(itau, itau_diff, n=n_samples) # get window length my_err = acorrnErr(acns, my_w, n_samples) # get autocorr errors my_err *= np.sqrt(n_samples) / np.sqrt(counts) from scipy.optimize import curve_fit fn = lambda x, a, b, c: a * np.exp(-b * x) + c f = curve_fit(fn, separations[1:100], counts[1:100]) th_x = np.linspace(min_sep, max_sep, 1000) pp = Pretty_Plotter() pp._teXify() pp._updateRC() fig = plt.figure(figsize=(8, 8)) # make plot
print 'Comparing autocorrelation calculations...' # assert that the autocorrelation routine is the same av_xx = comparison_xx.mean() norm = ((comparison_xx-av_xx)**2).mean() my_acorr = np.asarray(map(lambda s: myAcorr(comparison_xx, av_xx, s), np.asarray(separations))) christian_class = Christian_Autocorrelation(comparison_xx) christian_acorr = christian_class.acf()[:c_len] christian_acorr = np.asarray(christian_acorr) diffs = christian_acorr[:my_acorr.size] - my_acorr print " > av. difference: {}".format(diffs.mean()) print 'Checking integration window calculation:' christian_tint, christian_dtint, christian_w = christian_class.tauintW(False) _,_,my_w = windowing(comparison_xx, av_xx, 1.0, comparison_xx.size, fast=True) print "Christian Window:{}".format(christian_w) print "My Window:{}".format(my_w) ans = uWerr(comparison_xx, acorr=my_acorr) # get errors _, _, _, itau, itau_diff, _, acns = ans # extract data my_w = getW(itau, itau_diff, n=comparison_xx.size) # get window length my_err = acorrnErr(acns, my_w, comparison_xx.size) # get autocorr errors christian_acorr = np.asarray(christian_acorr) christian_err = acorrnErr(christian_acorr, christian_w, comparison_xx.size) all_plot = preparePlot(christian_acorr[:2*my_w], acns[:2*my_w], my_err[:2*my_w], christian_err[:2*my_w]) store(all_plot, file_name, '_allPlot') plot(save = saveOrDisplay(save, file_name+"_compareAc"), **all_plot)
def main(x0, pot, file_name, n_samples, n_burn_in, mixing_angle, angle_labels, opFn, op_name, rand_steps=False, step_size=.5, n_steps=1, spacing=1., itauFunc=None, separations=range(5000), acTheory=None, max_sep=None, save=False): """Takes a function: opFn. Runs HMC-MCMC. Runs opFn on HMC samples. Calculates Autocorrelation + Errors on opFn. Required Inputs x0 :: np.array :: initial position input to the HMC algorithm pot :: potential class :: defined in hmc.potentials file_name :: string :: final plot will be saved with a similar name if save=True n_samples :: int :: number of HMC samples n_burn_in :: int :: number of burn in samples mixing_angle :: iterable :: mixing angles for the HMC algorithm angle_labels :: list :: list of angle label text for legend plotting opFn :: func :: a function to run over samples op_name :: str :: label for the operator for plotting Optional Inputs rand_steps :: bool :: probability of with prob step_size :: float :: MDMC step size n_steps :: int :: number of MDMC steps spacing ::float :: lattice spacing save :: bool :: True saves the plot, False prints to the screen acTheory :: func :: acTheory(t, pa, theta) takes in acceptance prob., time, angle separations :: range / nparray :: the number of separations for A/C max_sep :: float :: the maximum separation tom consider for autocorrelations """ rng = np.random.RandomState() multi_angle = len(mixing_angle) > 1 # see if multiprocessing is needed print 'Running Model: {}'.format(file_name) # output to print to screen out = lambda p,x,a: '> measured at angle:{:3.1f}:'.format(a) \ + ' <x^2>_L = {}; <P_acc>_HMC = {:4.2f}'.format(x, p) if not multi_angle: mixing_angle = mixing_angle[0] model = Model( x0, pot=pot, spacing=spacing, # set up model rng=rng, step_size=step_size, n_steps=n_steps, rand_steps=rand_steps) c = acorr.Autocorrelations_1d(model) # set up autocorrs c.runModel( n_samples=n_samples, n_burn_in=n_burn_in, # run MCMC mixing_angle=mixing_angle, verbose=True) acs = c.getAcorr(separations, opFn, norm=False, prll_map=prll_map) cfn = c.op_samples # get parameters generated traj = c.model.traj # get trajectory lengths for each LF step p = c.model.p_acc # get acceptance rates at each M-H step xx = np.average( c.op_samples) # get average of the function run over the samples if itauFunc: t = itauFunc(tau=(n_steps * step_size), m=1, pa=p, theta=mixing_angle) else: t = None if acTheory is not None: ac_th = np.asarray( [acTheory(t, p, mixing_angle) for t in c.acorr_ficticous_time]) else: ac_th = None ans = errors.uWerr(cfn, acorr=acs) x, gta, w = preparePlot(cfn, ans, n=n_samples, itau_theory=t, mcore=False, acn_theory=ac_th) window_fns, int_ac_fns, acorr_fns = [[item] for item in gta] ws = [w] # makes compatible with multiproc x_lst = [x] # again same as last two lines print out(p, xx, mixing_angle) else: # use multicore support def coreFunc(a): """runs the below for an angle, a""" i, a = a model = Model( x0, pot=pot, spacing=spacing, # set up model rng=rng, step_size=step_size, n_steps=n_steps, rand_steps=rand_steps) c = acorr.Autocorrelations_1d(model) # set up autocorrs c.runModel( n_samples=n_samples, n_burn_in=n_burn_in, # run MCMC mixing_angle=a, verbose=True, verb_pos=i) acs = c.getAcorr(separations, opFn, norm=False, prll_map=None, ac=acs, max_itau=max_itau) cfn = c.op_samples # get parameters generated p = c.model.p_acc # get acceptance rates at each M-H step xx = np.average( cfn) # get average of the function run over the samples ans = errors.uWerr(cfn, acorr=acs) if itauFunc: t = itauFunc(tau=n_steps * step_size, m=1, pa=p, theta=a) else: t = None if acTheory is not None: th_x = np.linspace(0, c.acorr_ficticous_time, 10000) ac_th = np.asarray([th_x, [acTheory(t, p, a) for t in th_x]]) else: ac_th = None x, gta, w = preparePlot(cfn, n=n_samples, itau_theory=t, mcore=True, acn_theory=ac_th) return xx, traj, p, x, gta, w # # use multiprocessing l = len(mixing_angle) # number of mixing angles ans = prll_map(coreFunc, zip(range(l), mixing_angle), verbose=False) # unpack from multiprocessing xx, traj, ps, x_lst, gtas, ws = zip(*ans) print '\n' * l # hack to avoid text overlapping in terminal for p, x, a in zip( ps, xx, mixing_angle): # print intermediate results to screen print out(p, x, a) window_fns, int_ac_fns, acorr_fns = zip( *gtas) # separate out to respective lists lines = { 0: window_fns, 1: int_ac_fns, 2: acorr_fns } # create a dictionary for plotting # print 'Finished Running Model: {}'.format(file_name) subtitle = r"Potential: {}; Lattice Shape: ".format(pot.name) \ + r"${}$; $a={:.1f}; \delta\tau={:.1f}; n={}$".format( x0.shape, spacing, step_size, n_steps) # all_plot contains all necessary keyword arguments all_plot = { 'lines_d': lines, 'x_lst': x_lst, 'ws': ws, 'subtitle': subtitle, 'mcore': multi_angle, 'angle_labels': angle_labels, 'op_name': op_name } store.store(all_plot, file_name, '_allPlot') plot(lines_d=lines, x_lst=x_lst, ws=ws, subtitle=subtitle, mcore=multi_angle, angle_labels=angle_labels, op_name=op_name, save=saveOrDisplay(save, file_name)) pass
for i in ax: i.grid(True) pp.save_or_show(save, PLOT_LOC) pass if __name__ == '__main__': d = './correlations/ref_code/' # grab uWerr data from Matlab script with open(d + '/uWerr_out.dat') as f: actual = json.load(f) actual['itau_aav'] = np.loadtxt(d + 'uWerr_out_tauintFbb.dat') actual['acorr'] = np.loadtxt(d + 'uWerr_out_gammaFbb.dat') a = np.loadtxt(d + 'actime_tint20_samples.dat') # run the uWerr from here value, dvalue, ddvalue, tauint, dtauint, y, y2 = uWerr(a) res = { 'value': value, 'dvalue': dvalue, 'ddvalue': ddvalue, 'dtauint': dtauint, 'tauint': tauint, # 'CFbbopt':c_aav, 'itau_aav': y, 'acorr': y2 } w = np.around((ddvalue / dvalue)**2 * a.size - .5, 0) w2 = np.around((dtauint / tauint / 2.)**2 * a.size - .5 + tauint, 0) assert w == w2 # sanity check