├── README.md ├── notebooks ├── runs.npz ├── results_optim.npz ├── results_shower.npz └── 03_VisualizeSimulator.ipynb ├── utils.py ├── shower_sim_baseline.py ├── plots_optimization.py ├── plots_gradients.py ├── shower_sim_optimize.py ├── plot_loss_landscape.py ├── LossLandscape.ipynb ├── shower_sim_redone.py ├── GradientEstimates.ipynb └── VisualizeDesign.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # branches_of_a_tree 2 | -------------------------------------------------------------------------------- /notebooks/runs.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/makagan/branches_of_a_tree/main/notebooks/runs.npz -------------------------------------------------------------------------------- /notebooks/results_optim.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/makagan/branches_of_a_tree/main/notebooks/results_optim.npz -------------------------------------------------------------------------------- /notebooks/results_shower.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/makagan/branches_of_a_tree/main/notebooks/results_shower.npz -------------------------------------------------------------------------------- /utils.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import pandas as pd 3 | 4 | COLORS = { 5 | 'stad': 'maroon', 6 | 'scorebase': 'darkorange', 7 | 'numeric': 'forestgreen', 8 | 'score': 'steelblue' 9 | } 10 | 11 | def array_mean_and_quantiles(array, window = 5): 12 | mean = pd.DataFrame(np.mean(array, axis=1)).rolling(window).mean().to_numpy()[:,0] 13 | pup,pmn,pdn = [ 14 | pd.DataFrame(np.quantile(array,q, axis=1)).rolling(window).mean().to_numpy()[:,0] 15 | for q in [.10,.50,.90] 16 | ] 17 | return mean,(pup,pmn,pdn) 18 | 19 | -------------------------------------------------------------------------------- /shower_sim_baseline.py: -------------------------------------------------------------------------------- 1 | # shower_sim_baseline 2 | 3 | import numpy as np 4 | import jax 5 | 6 | def propagate_state(state): 7 | 8 | if state is None: 9 | return None 10 | 11 | if state['alive']==False: 12 | return state 13 | 14 | E,x,y,px,py = state['E'],state['x'],state['y'],state['px'],state['py'] 15 | pmag = np.sqrt(px**2 + py**2) 16 | time = 0.02 17 | next_x = x + time*px 18 | next_y = y + time*py 19 | next_E = E 20 | return { 21 | 'E': next_E, 22 | 'x': next_x, 23 | 'y': next_y, 24 | 'px': state['px'], 25 | 'py': state['py'], 26 | 'alive':True, 27 | } 28 | 29 | def sample_stop_prob(score, state, sim_parameters): 30 | r = np.sqrt(state['x']**2 + state['y']**2) 31 | E = state['E'] 32 | par_thresh_E = sim_parameters['thresh_E'] 33 | stop = False 34 | if (E < par_thresh_E): 35 | stop = True 36 | if (r > 20.): 37 | stop = True 38 | return stop 39 | 40 | def interact_prob(x,y,par): 41 | par_radial = 10 42 | par_azimutal = 10 43 | r = jax.numpy.sqrt(x**2+y**2) 44 | 45 | alpha = jax.numpy.arctan2(x,y) 46 | 47 | 48 | sampling1 = 1/(1+jax.numpy.exp(10*jax.numpy.sin(par_radial*(alpha+2*r)))) 49 | sampling2 = 1/(1+jax.numpy.exp(10*jax.numpy.cos(par_azimutal*(r-2)))) 50 | start = 1/(1+jax.numpy.exp(-10*(r-par))) 51 | end = 1/(1+jax.numpy.exp(10*(r-(par+10.0)))) 52 | 53 | return 0.5*start*sampling1*sampling2*end 54 | 55 | 56 | 57 | ########### Summary / Objective ########### 58 | 59 | def per_hit_summary(hits): 60 | return np.sqrt(hits[:,0]**2+hits[:,1]**2) 61 | 62 | def summary(generation): 63 | hits,active,*_ = generation 64 | return (np.mean(per_hit_summary(active)) - 2.0)**2 65 | 66 | def summary_metric(active): 67 | return (np.mean(per_hit_summary(active)) - 2.0)**2 68 | -------------------------------------------------------------------------------- /plots_optimization.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | import utils 3 | import numpy as np 4 | 5 | def moving_avg(array, window): 6 | return pd.DataFrame(array).rolling(window).mean() 7 | 8 | def plot_single_opt_comparison(ax, l_st, l_s, l_sb, l_n): 9 | window = 10 10 | ax.plot(moving_avg(l_st, window) , label = 'STAD', color = utils.COLORS['stad']) 11 | ax.plot(moving_avg(l_s, window), label = 'Score', color = utils.COLORS['score']) 12 | ax.plot(moving_avg(l_sb, window), label = 'Score Baseline', color = utils.COLORS['scorebase']) 13 | ax.plot(moving_avg(l_n, window), label = 'Numeric', color = utils.COLORS['numeric']) 14 | 15 | ax.set_ylabel('Loss') 16 | ax.set_xlabel('Epoch') 17 | ax.set_ylim(0,5) 18 | ax.legend() 19 | 20 | 21 | def plot_optimization_comparison( 22 | ax, 23 | l_st_list, 24 | l_s_list, 25 | l_n_list, 26 | l_sb_list 27 | 28 | ): 29 | 30 | st = utils.array_mean_and_quantiles(l_st_list.T) 31 | s = utils.array_mean_and_quantiles(l_s_list.T) 32 | n = utils.array_mean_and_quantiles(l_n_list.T) 33 | sb = utils.array_mean_and_quantiles(l_sb_list.T) 34 | 35 | xrange = np.arange(500) 36 | ax.plot(xrange,n[0],c = utils.COLORS['numeric'], label = 'numeric') 37 | ax.fill_between(xrange,n[1][0],n[1][2], facecolor = utils.COLORS['numeric'], alpha = 0.2) 38 | 39 | ax.plot(xrange,s[0],c = utils.COLORS['score'], label = 'SCORE') 40 | ax.fill_between(xrange,s[1][0],s[1][2], facecolor = utils.COLORS['score'], alpha = 0.2) 41 | 42 | ax.plot(xrange,sb[0],c = utils.COLORS['scorebase'], label = 'SCORB') 43 | ax.fill_between(xrange,sb[1][0],sb[1][2], facecolor = utils.COLORS['scorebase'], alpha = 0.2) 44 | 45 | ax.plot(xrange,st[0],c = utils.COLORS['stad'], label = 'STAD') 46 | ax.fill_between(xrange,st[1][0],st[1][2], facecolor = utils.COLORS['stad'], alpha = 0.2) 47 | 48 | 49 | ax.set_ylabel('Loss') 50 | ax.set_xlabel('Steps') 51 | ax.set_title('Design Optimization') 52 | ax.legend(loc = 'lower left') 53 | -------------------------------------------------------------------------------- /plots_gradients.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import seaborn as sns 3 | import utils 4 | 5 | def analyse_at_point(ax,runs1, eps=0.05, nsig = 50, nbins = 101, legend = True): 6 | values1 = np.array([r1['primal'] for r1 in runs1]) 7 | 8 | stad_grads1 = np.array([r['grad_dict']['stad'] for r in runs1]) 9 | score_grads1 = np.array([r['grad_dict']['score'] for r in runs1]) 10 | dlogp = np.array([r['dlogp'] for r in runs1]) 11 | numeric = np.array([r['grad_dict']['numeric'] for r in runs1]) 12 | score_baseline = score_grads1 - dlogp*values1.mean() 13 | 14 | 15 | print(f'stad {stad_grads1.mean():.2f},{stad_grads1.std():.2f}') 16 | print(f'scorb {score_baseline.mean():.2f},{score_baseline.std():.2f}') 17 | print(f'score {score_grads1.mean():.2f},{score_grads1.std():.2f}') 18 | print(f'numeric {numeric.mean():.2f},{numeric.std():.2f}') 19 | print('----') 20 | ax = sns.boxplot(ax = ax, data = np.column_stack( 21 | [stad_grads1,score_baseline, score_grads1, numeric]), orient = 'v', fliersize=1, meanline=True, showmeans=True, 22 | meanprops = {'c': 'k'}, 23 | palette = [ 24 | utils.COLORS['stad'], 25 | utils.COLORS['scorebase'], 26 | utils.COLORS['score'], 27 | utils.COLORS['numeric'], 28 | ] 29 | ) 30 | # ax.axhline(stad_grads1.mean(), c = 'k') 31 | 32 | 33 | 34 | return {'stad_m':stad_grads1.mean(), 'stad_s':stad_grads1.std(), 35 | 'score_m':score_grads1.mean(), 'score_s':score_grads1.std(), 36 | 'score_baseline_m':score_baseline.mean(), 'score_baseline_s':score_baseline.std(), 37 | 'numeric_m':numeric.mean(), 'numeric_s':numeric.std(), 38 | } 39 | 40 | 41 | def plot_variance_with_inset(axarr,runs): 42 | ax = axarr 43 | _ = analyse_at_point(ax,runs, nsig = 50, nbins = 101, legend = True) 44 | ax.set_ylim(-15,15) 45 | ax.set_xticklabels(['StochAD','Score w/ Baseline','Score','Numeric'], rotation = 20) 46 | ax.set_xlim(-0.5,2.5) 47 | ax.set_ylabel(r'$g \sim \partial_\theta\mathbb{E}[X(\theta)]}$') 48 | 49 | 50 | iax = ax.inset_axes([0.3,0.1,0.3,0.2]) 51 | _ = analyse_at_point(iax,runs, nsig = 50, nbins = 101, legend = True) 52 | iax.set_xticklabels(['ST','SB','Score','Numeric']) 53 | iax.set_xlim(1.5,3.5) 54 | iax.set_ylim(-60,60) 55 | -------------------------------------------------------------------------------- /shower_sim_optimize.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import tqdm 3 | import optax 4 | import jax.numpy as jnp 5 | 6 | def program_to_optimize(simulator, objective, sim_kwargs): 7 | def program_for_optimizer(theta, grad_type = "stad", eps=0.01, keep_all_grads=False): 8 | 9 | if grad_type not in ["stad","score","numeric"]: 10 | print("grad_type=",grad_type,"not recognized") 11 | return None 12 | 13 | hits,active,history,scores,out_st = simulator(theta, **sim_kwargs) 14 | primal = objective(active) 15 | 16 | grad_dict={} 17 | 18 | if grad_type == "stad" or keep_all_grads: 19 | alt = objective(out_st['y']['active']) 20 | grad_dict["stad"] = out_st['d'] + out_st['w']*(alt - primal) 21 | 22 | if grad_type == "score" or keep_all_grads: 23 | grad_dict["score"] = scores*primal 24 | 25 | if grad_type == "numeric" or keep_all_grads: 26 | _,active2,_,_,_ = simulator(theta+eps, **sim_kwargs) 27 | primal2 = objective(active2) 28 | grad_dict["numeric"] = (primal2 - primal) / eps 29 | 30 | grad_val = grad_dict[grad_type] 31 | 32 | return {"primal":primal, "grad":grad_val, "grad_type":grad_type, "grad_dict":grad_dict, "dlogp":scores} 33 | return program_for_optimizer 34 | 35 | def minibatch_primal_and_grad(program, theta, Nmini, grad_type = "stad", dobaseline=True): 36 | 37 | runs = [program(theta, grad_type) for _ in range(Nmini)] 38 | 39 | primal = np.mean([r["primal"] for r in runs]) 40 | 41 | if grad_type=="score" and dobaseline and Nmini > 1: 42 | grad = np.mean([ (r["grad"]-r["dlogp"]*primal) for r in runs]) 43 | else: 44 | grad = np.mean([r["grad"] for r in runs]) 45 | 46 | 47 | return primal, grad 48 | 49 | def optimize(program, init, LR, Nepoch, Nmini, grad_type, dobaseline=True, doprint=True): 50 | traj_theta = [] 51 | traj_v = [] 52 | traj_g = [] 53 | theta = jnp.array(init) 54 | 55 | optimizer = optax.adam(learning_rate=LR) 56 | adam_state = optimizer.init(theta) 57 | 58 | trainsteps = tqdm.tqdm(range(Nepoch)) 59 | for i in trainsteps: 60 | traj_theta.append(theta) 61 | v, g = minibatch_primal_and_grad(program, theta, Nmini, grad_type, dobaseline) 62 | updates, adam_state = optimizer.update(g, adam_state, theta) 63 | theta = optax.apply_updates(theta, updates) 64 | if theta < 0.: 65 | theta = 0. 66 | 67 | traj_v.append(v) 68 | traj_g.append(g) 69 | return theta, traj_theta, traj_v, traj_g 70 | -------------------------------------------------------------------------------- /plot_loss_landscape.py: -------------------------------------------------------------------------------- 1 | 2 | import numpy as np 3 | import pandas as pd 4 | import utils 5 | import numpy as np 6 | 7 | 8 | def plot_loss_landscape_primal(ax, numeric_fit, par_vals, primal_list): 9 | Nscan,NMC = primal_list.shape 10 | print(primal_list.shape) 11 | 12 | ax.scatter(np.tile(np.transpose(par_vals.reshape(1,par_vals.shape[0])), (1,20)), 13 | primal_list[:,:20],# + np.random.normal(0,0.01, size = score_list.shape), 14 | alpha = 0.1, label="per event primal", c = 'k') 15 | 16 | # ax.scatter(par_vals, primal_list_m, label = 'primal mean') 17 | 18 | mean, mean_q = utils.array_mean_and_quantiles(primal_list, window = 1) 19 | 20 | ax.plot(par_vals,np.array([mean_q[0],mean_q[2]]).T, color = 'k', alpha = 0.5) 21 | ax.plot(par_vals,mean, label = 'primal median', c = 'k') 22 | 23 | ax.plot(par_vals, numeric_fit(par_vals), color='maroon', label = 'poly. fit', linestyle = 'dashed') 24 | ax.axhline(0.0, c = 'k') 25 | ax.set_xlim(0.0,4.1) 26 | ax.set_ylim(-0.2,10) 27 | ax.set_ylabel('Loss') 28 | ax.set_xlabel('parameter') 29 | ax.legend() 30 | 31 | def plot_loss_landscape_gradients( 32 | ax, 33 | numeric_fit, 34 | par_vals, 35 | numeric_list, 36 | score_list, 37 | score_baseline_list, 38 | stad_list): 39 | window = 3 40 | 41 | grad_from_fit = numeric_fit.deriv() 42 | 43 | w = 1 44 | stad_mean, stad_q = utils.array_mean_and_quantiles(stad_list, window = w) 45 | scob_mean, scob_q = utils.array_mean_and_quantiles(score_baseline_list, window = w) 46 | scor_mean, scor_q = utils.array_mean_and_quantiles(score_list, window = w) 47 | numr_mean, numr_q = utils.array_mean_and_quantiles(numeric_list, window = w) 48 | 49 | ax.plot(par_vals, numr_mean, label = 'Numeric', color = utils.COLORS['numeric'], linestyle = 'dashed') 50 | ax.plot(par_vals,np.array([numr_q[0],numr_q[2]]).T, alpha = 1.0, color = utils.COLORS['numeric']) 51 | 52 | ax.plot(par_vals, stad_mean, label = 'StochAD', color = utils.COLORS['stad'], linestyle = 'dashed') 53 | ax.plot(par_vals,np.array([stad_q[0],stad_q[2]]).T, alpha = 1.0, color = utils.COLORS['stad']) 54 | 55 | ax.plot(par_vals, stad_mean, label = 'SCORB', color = utils.COLORS['scorebase'], linestyle = 'dashed') 56 | ax.plot(par_vals,np.array([scob_q[0],scob_q[2]]).T, alpha = 1.0, color = utils.COLORS['scorebase']) 57 | 58 | ax.plot(par_vals, scor_mean, label = 'SCORE', color = utils.COLORS['score'], linestyle = 'dashed') 59 | ax.plot(par_vals,np.array([scor_q[0],scor_q[2]]).T, alpha = 1.0, color = utils.COLORS['score']) 60 | 61 | 62 | ax.plot( 63 | par_vals, grad_from_fit(par_vals), color='black', linestyle = 'dashed', 64 | label = 'grad from fit' 65 | ) 66 | 67 | 68 | ax.set_xlim(0.0,4.0) 69 | ax.set_ylim(-15.0, 20.0) 70 | 71 | ax.set_ylabel('Grad') 72 | ax.set_xlabel('parameter') 73 | ax.legend(loc='upper left') 74 | -------------------------------------------------------------------------------- /LossLandscape.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "import matplotlib.pyplot as plt\n", 11 | "import jax\n", 12 | "import copy\n", 13 | "import queue\n", 14 | "from shower_sim_instrumented import simulator\n", 15 | "from shower_sim_baseline import summary_metric\n", 16 | "\n", 17 | "%load_ext autoreload\n", 18 | "%autoreload 2" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 2, 24 | "metadata": {}, 25 | "outputs": [ 26 | { 27 | "name": "stdout", 28 | "output_type": "stream", 29 | "text": [ 30 | "0.87279123 48.394210412632674 2736 2848\n" 31 | ] 32 | } 33 | ], 34 | "source": [ 35 | "hits,active,history,scores,out_st = simulator(3.5)\n", 36 | "print(scores, out_st['w'], hits.size, out_st['y']['hits'].size)" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 3, 42 | "metadata": {}, 43 | "outputs": [ 44 | { 45 | "name": "stdout", 46 | "output_type": "stream", 47 | "text": [ 48 | "############ par value= 0.25 ##################\n", 49 | "############ 0 ##################\n", 50 | "############ 100 ##################\n" 51 | ] 52 | } 53 | ], 54 | "source": [ 55 | "par_vals = np.arange(0.25, 4.0, 0.1)\n", 56 | "N=200\n", 57 | "eps = 0.01\n", 58 | "\n", 59 | "primal_list = []\n", 60 | "primal_st_list = []\n", 61 | "\n", 62 | "score_list = []\n", 63 | "stad_list = []\n", 64 | "numeric_list = []\n", 65 | "dlogp_list = []\n", 66 | "\n", 67 | "\n", 68 | "for par_v in par_vals:\n", 69 | " print(\"############ par value=\", par_v, \"##################\")\n", 70 | " \n", 71 | " primal = []\n", 72 | " primal_st = []\n", 73 | "\n", 74 | " score_val = []\n", 75 | " stad_val = []\n", 76 | " numeric_val = []\n", 77 | " dlogp_val = []\n", 78 | " \n", 79 | " for i in range(N):\n", 80 | " if i%100 == 0: print(\"############\", i, \"##################\")\n", 81 | " hits,active,history,scores,out_st = simulator(par_v)\n", 82 | " _, active2, _, _, _ = simulator(par_v+eps)\n", 83 | " \n", 84 | " _val = summary_metric(active)\n", 85 | " _val2 = summary_metric(active2)\n", 86 | " \n", 87 | " primal.append(_val)\n", 88 | " primal_st.append(summary_metric(out_st['y']['active']))\n", 89 | " \n", 90 | " numeric_val.append( (_val2 - _val)/eps )\n", 91 | " \n", 92 | " score_val.append(scores*primal[i])\n", 93 | " dlogp_val.append(scores)\n", 94 | " stad_val.append(out_st['d'] + out_st['w']*(primal_st[i] - primal[i]))\n", 95 | " \n", 96 | " primal_list.append(primal)\n", 97 | " primal_st_list.append(primal_st)\n", 98 | " \n", 99 | " score_list.append(score_val)\n", 100 | " stad_list.append(stad_val)\n", 101 | " numeric_list.append(numeric_val)\n", 102 | " dlogp_list.append(dlogp_val)\n", 103 | " \n", 104 | "\n", 105 | "primal_list = np.array(primal_list)\n", 106 | "primal_list_m = primal_list.mean(axis=1)\n", 107 | "primal_list_s = primal_list.std(axis=1)\n", 108 | "\n", 109 | "numeric_list = np.array(numeric_list)\n", 110 | "numeric_m = numeric_list.mean(axis=1)\n", 111 | "numeric_s = numeric_list.std(axis=1)\n", 112 | "\n", 113 | "score_list = np.array(score_list)\n", 114 | "score_m = score_list.mean(axis=1)\n", 115 | "score_s = score_list.std(axis=1)\n", 116 | "\n", 117 | "dlogp_list = np.array(dlogp_list)\n", 118 | "score_baseline_list = score_list - dlogp_list*primal_list_m.reshape(-1,1)\n", 119 | "score_baseline_m = score_baseline_list.mean(axis=1)\n", 120 | "score_baseline_s = score_baseline_list.std(axis=1)\n", 121 | "\n", 122 | "stad_list = np.array(stad_list)\n", 123 | "stad_m = stad_list.mean(axis=1)\n", 124 | "stad_s = stad_list.std(axis=1)" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [] 133 | } 134 | ], 135 | "metadata": { 136 | "kernelspec": { 137 | "display_name": "Python 3.11.4 64-bit ('stochad_env')", 138 | "language": "python", 139 | "name": "python3" 140 | }, 141 | "language_info": { 142 | "codemirror_mode": { 143 | "name": "ipython", 144 | "version": 3 145 | }, 146 | "file_extension": ".py", 147 | "mimetype": "text/x-python", 148 | "name": "python", 149 | "nbconvert_exporter": "python", 150 | "pygments_lexer": "ipython3", 151 | "version": "3.11.4" 152 | }, 153 | "orig_nbformat": 4, 154 | "vscode": { 155 | "interpreter": { 156 | "hash": "29b777788fad9121f9b4a41d949494280ba66b13a17f3ccd9e5dfa0de3270b9d" 157 | } 158 | } 159 | }, 160 | "nbformat": 4, 161 | "nbformat_minor": 2 162 | } 163 | -------------------------------------------------------------------------------- /shower_sim_redone.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import matplotlib.pyplot as plt 3 | import jax 4 | import copy 5 | import queue 6 | 7 | def make_simulator(): 8 | def stochasticTriple(d=0., y=None, w=0.): 9 | return { 10 | "d": d, 11 | "y": y, 12 | "w": w, 13 | } 14 | 15 | def bernoulli_basic(p, get_omega=False, u_input=None): 16 | def result_on_omega(omega,p): 17 | if omega > (1.-p): 18 | return 1 19 | else: 20 | return 0 21 | 22 | if u_input is not None: 23 | u = u_input 24 | else: 25 | u = np.random.uniform() 26 | 27 | b = result_on_omega(u,p) 28 | 29 | if get_omega: 30 | return b, u 31 | else: 32 | return b 33 | 34 | 35 | def compose_derivs(func,st1,st2): 36 | d1,y1,w1 = st1["d"], st1["y"], st1["w"] 37 | d2,y2,w2 = st2["d"], st2["y"], st2["w"] 38 | 39 | w1_iszero = (w1==0 or w1==0.) 40 | w2_iszero = (w2==0 or w2==0.) 41 | 42 | u = None 43 | 44 | if w1_iszero and w2_iszero: 45 | y=y2 46 | else: 47 | prob = 0 if w1_iszero else np.fabs(w1)/(np.fabs(w1)+np.fabs(d1)*np.fabs(w2)) 48 | option = bernoulli_basic(prob, get_omega=False) 49 | 50 | y = func(y1) if option == 1 else y2 51 | 52 | d = d1*d2 53 | w = np.fabs(w1) + np.fabs(d1)*np.fabs(w2) 54 | 55 | #print("C", st1, st2, (d,y,w)) 56 | 57 | return stochasticTriple(d,y,w) 58 | 59 | 60 | def do_prune_away_old(st_new, st_old): 61 | 62 | w_new = st_new["w"] 63 | w_old = st_old["w"] 64 | 65 | w_new_iszero = (w_new==0 or w_new==0.) 66 | w_old_iszero = (w_old==0 or w_old==0.) 67 | 68 | 69 | if w_new_iszero and w_old_iszero: 70 | keep_new_state = False 71 | else: 72 | prob = 0 if w_new_iszero else np.fabs(w_new)/(np.fabs(w_new)+np.fabs(w_old)) 73 | keep_new_state = bernoulli_basic(prob, get_omega=False) 74 | 75 | return keep_new_state 76 | 77 | def bernoulli(p, p_st, get_omega=False): 78 | 79 | def _fwd(p, get_omega=False): 80 | def result_on_omega(omega,p): 81 | if omega > (1.-p): 82 | return 1 83 | else: 84 | return 0 85 | 86 | u = np.random.uniform() 87 | b = result_on_omega(u,p) 88 | 89 | if get_omega: 90 | return b, u 91 | else: 92 | return b 93 | 94 | 95 | def _deriv(x,p, direction=1.0): 96 | if int(direction)==1: 97 | if x==0: 98 | #Right deriv 99 | st = stochasticTriple(0., 1, 1./(1.-p)) 100 | else: 101 | st = stochasticTriple(0., 0, 0.) 102 | 103 | else: 104 | if x == 1: 105 | #Left deriv 106 | st = stochasticTriple(0., 0, 1./p) 107 | else: 108 | st = stochasticTriple(0., 0, 0.) 109 | 110 | return st 111 | 112 | if get_omega: 113 | out, u = _fwd(p, get_omega=True) 114 | else: 115 | out = _fwd(p, get_omega=False) 116 | 117 | direction=1.0 #by default, choose right deriv, but switch if p deriv is negative 118 | if p_st is not None: 119 | if p_st['d'] < 0: 120 | direction = -1.0 121 | 122 | out_st = _deriv(out, p, direction) 123 | 124 | if p_st is not None: 125 | out_st = compose_derivs(_fwd, p_st, out_st) 126 | 127 | if get_omega: 128 | return out, out_st, u 129 | else: 130 | return out, out_st 131 | 132 | 133 | def propagate_state(state): 134 | 135 | if state is None: 136 | return None 137 | 138 | if state['alive']==False: 139 | return state 140 | 141 | E,x,y,px,py = state['E'],state['x'],state['y'],state['px'],state['py'] 142 | pmag = np.sqrt(px**2 + py**2) 143 | time = 0.02 144 | next_x = x + time*px 145 | next_y = y + time*py 146 | next_E = E 147 | return { 148 | 'E': next_E, 149 | 'x': next_x, 150 | 'y': next_y, 151 | 'px': state['px'], 152 | 'py': state['py'], 153 | 'alive':True, 154 | } 155 | 156 | 157 | 158 | def sample_stop_prob(score, state, sim_parameters): 159 | r = np.sqrt(state['x']**2 + state['y']**2) 160 | E = state['E'] 161 | par_thresh_E = sim_parameters['thresh_E'] 162 | #next_stop_prob = 1/(1+jax.numpy.exp((E - par_thresh_E)/0.5)) 163 | #stop = np.random.binomial(1,next_stop_prob) 164 | #return stop 165 | 166 | stop = False 167 | if (E < par_thresh_E): 168 | stop = True 169 | if (r > 20.): 170 | stop = True 171 | 172 | return stop 173 | 174 | score_bernoulli = jax.jit(jax.grad(jax.scipy.stats.bernoulli.logpmf, argnums=1)) 175 | score_bernoulli(1,0.5) 176 | 177 | def interact_prob(x,y,par): 178 | par_radial = 10 179 | par_azimutal = 10 180 | r = jax.numpy.sqrt(x**2+y**2) 181 | 182 | alpha = jax.numpy.arctan2(x,y) 183 | 184 | 185 | sampling1 = 1/(1+jax.numpy.exp(10*jax.numpy.sin(par_radial*(alpha+2*r)))) 186 | sampling2 = 1/(1+jax.numpy.exp(10*jax.numpy.cos(par_azimutal*(r-2)))) 187 | start = 1/(1+jax.numpy.exp(-10*(r-par))) 188 | end = 1/(1+jax.numpy.exp(10*(r-(par+10.0)))) 189 | 190 | return 0.5*start*sampling1*sampling2*end 191 | 192 | 193 | interact_prob_and_g = jax.jit(jax.value_and_grad(interact_prob, argnums = 2)) 194 | interact_prob_and_g(0.5,0.5,0.5) 195 | 196 | def interact_prob_and_grad(x,y,par): 197 | p,g = interact_prob_and_g(x,y,par) 198 | 199 | g = jax.lax.cond(jax.numpy.isnan(g), lambda x: 0., lambda x: x, g) 200 | #if jax.numpy.isnan(g): 201 | # g=0. 202 | 203 | return p, g 204 | 205 | interact_prob_and_grad = jax.jit(interact_prob_and_grad) 206 | interact_prob_and_grad(0.5,0.5,0.5) 207 | 208 | def sample_interact(score, state, sim_parameters, keep_derivs=True, fifos=None): 209 | x,y = state['x'], state['y'] 210 | par_thresh_x = sim_parameters['thresh_x'] 211 | 212 | interact_prob, interact_prob_grad = interact_prob_and_grad(x,y,par_thresh_x) 213 | 214 | if not keep_derivs: 215 | if fifos is not None and not fifos['interact'].empty(): 216 | u_input = fifos['interact'].get() 217 | interact = bernoulli_basic(interact_prob, get_omega=False, u_input=u_input) 218 | else: 219 | interact = bernoulli_basic(interact_prob, get_omega=False, u_input=None) 220 | 221 | return interact, None 222 | 223 | interact_prob_st = stochasticTriple(interact_prob_grad, 0., 0.) 224 | 225 | if fifos is not None: 226 | interact, interact_st, u_int = bernoulli(interact_prob, interact_prob_st, get_omega=True) 227 | fifos['interact'].put(u_int) 228 | else: 229 | interact, interact_st = bernoulli(interact_prob, interact_prob_st, get_omega=False) 230 | 231 | score['thresh_x'] += score_bernoulli(interact,interact_prob)*interact_prob_grad 232 | 233 | return interact, interact_st 234 | 235 | def sample_fate(score, state, program_st, sim_parameters, check_alts=True, fifos=None): 236 | stop = sample_stop_prob(score, state,sim_parameters) 237 | if stop: 238 | state['alive']=False 239 | return None 240 | 241 | if check_alts==False: 242 | interact, _ = sample_interact(None, state, sim_parameters, keep_derivs=False, fifos=fifos) 243 | interact_st = None 244 | keep_new_alt = False 245 | else: 246 | interact, interact_st = sample_interact(score, state, sim_parameters, keep_derivs=True, fifos=fifos) 247 | 248 | keep_new_alt = False 249 | if program_st['y']==None: 250 | keep_new_alt = True 251 | else: 252 | keep_new_alt = do_prune_away_old(interact_st, program_st) 253 | 254 | 255 | #keep_new_alt = True if program_st['y']==None else do_prune_away_old(interact_st, program_st) 256 | 257 | program_st['w'] += np.fabs(interact_st['w']) 258 | if keep_new_alt: 259 | program_st['d'] = interact_st['d'] 260 | 261 | if fifos is not None and not fifos['interact'].empty(): 262 | #_ = fifos['interact'].get() #remove this rv, as it was used to creat alternative 263 | fifos['interact'].queue.clear() 264 | 265 | 266 | bumpx = 0.05 267 | bumpy = 0.05#np.random.normal(0,.1) 268 | 269 | split = np.random.binomial(1, sim_parameters['split_prob']) 270 | 271 | if not interact: 272 | return { 273 | 'interact': False, 274 | 'interact_st': interact_st, 275 | 'keep_new_alt': keep_new_alt, 276 | 'split': split, 277 | 'eloss': 2.0, 278 | 'bumpx': bumpx, 279 | 'bumpy': bumpy, 280 | } 281 | 282 | 283 | 284 | if split: 285 | return { 286 | 'interact': True, 287 | 'interact_st': interact_st, 288 | 'keep_new_alt': keep_new_alt, 289 | 'split': True, 290 | 'eloss': 2.0, 291 | 'bumpx': bumpx, 292 | 'bumpy': bumpy 293 | } 294 | else: 295 | return { 296 | 'interact': True, 297 | 'interact_st': interact_st, 298 | 'keep_new_alt': keep_new_alt, 299 | 'split': False, 300 | 'eloss': 2.0, 301 | 'bumpx': bumpx, 302 | 'bumpy': bumpy 303 | }#np.random.uniform(0,0.1)} 304 | 305 | def fate2state(fate, state): 306 | 307 | def _update_stop(state): 308 | state1 = { 309 | 'E': state['E'], 310 | 'x': state['x'], 311 | 'y': state['y'], 312 | 'px': state['px'] + fate['bumpx'], 313 | 'py': state['py'] + fate['bumpy'], 314 | 'alive':False, 315 | } 316 | return state1 317 | 318 | def _update_split(state): 319 | 320 | norm1 = np.sqrt( (state['px'] + fate['bumpx'])**2 + (state['py'] + fate['bumpy'])**2 ) 321 | norm2 = np.sqrt( (state['px'] - fate['bumpx'])**2 + (state['py'] - fate['bumpy'])**2 ) 322 | 323 | 324 | state1 = { 325 | 'E': state['E']/2, 326 | 'x': state['x'], 327 | 'y': state['y'], 328 | 'px': (state['px'] + fate['bumpx']) / norm1, 329 | 'py': (state['py'] + fate['bumpy']) / norm1, 330 | 'alive':True, 331 | } 332 | state2 = { 333 | 'E': state['E']/2, 334 | 'x': state['x'], 335 | 'y': state['y'], 336 | 'px': (state['px'] - fate['bumpx']) / norm2, 337 | 'py': (state['py'] - fate['bumpy']) / norm2, 338 | 'alive':True, 339 | } 340 | return state1, state2 341 | 342 | def _update_eloss(state): 343 | new_E = state['E'] - fate['eloss'] 344 | if new_E < 0.: 345 | new_E = 0. 346 | 347 | bump_px = state['px'] + fate['bumpx']*(1.0 if np.random.binomial(1,0.5) else -1.0) 348 | bump_py = state['py'] + fate['bumpy']*(1.0 if np.random.binomial(1,0.5) else -1.0) 349 | 350 | #renomalize 351 | new_px = bump_px / np.sqrt(bump_px**2 + bump_py**2) 352 | new_py = bump_py / np.sqrt(bump_px**2 + bump_py**2) 353 | 354 | state1 = { 355 | 'E': new_E, 356 | 'x': state['x'], 357 | 'y': state['y'], 358 | 'px': new_px, 359 | 'py': new_py, 360 | 'alive':True, 361 | } 362 | return state1 363 | 364 | 365 | if fate is None: 366 | state1 = _update_stop(state) 367 | return state1, None, None, None 368 | 369 | if not fate['interact']: 370 | state1, state2 = state, None 371 | 372 | stateY1, stateY2 = None, None 373 | if fate['keep_new_alt']: 374 | if fate['split']: 375 | stateY1, stateY2 = _update_split(state) 376 | else: 377 | stateY1 = _update_eloss(state) 378 | stateY2 = None 379 | 380 | return state1,state2,stateY1,stateY2 381 | 382 | 383 | if fate['split']: 384 | state1, state2 = _update_split(state) 385 | 386 | stateY1, stateY2 = None, None 387 | if fate['keep_new_alt']: 388 | #stateY1 = _update_eloss(state) 389 | stateY1, stateY2 = state, None 390 | 391 | return state1,state2,stateY1,stateY2 392 | 393 | else: 394 | state1 = _update_eloss(state) 395 | state2 = None 396 | 397 | stateY1, stateY2 = None, None 398 | if fate['keep_new_alt']: 399 | #stateY1, stateY2 = _update_split(state) 400 | stateY1, stateY2 = state, None 401 | 402 | 403 | return state1,state2,stateY1,stateY2 404 | 405 | 406 | def run(score, history, hits, alive_states, program_st, sim_parameters, step_count, fifos = None): 407 | next_alive_states = [] 408 | next_alive_states_st = [] 409 | found_alt = False 410 | alt_index = None 411 | 412 | 413 | for state in alive_states: 414 | new_state = propagate_state(state) 415 | fate = sample_fate(score, new_state, program_st, sim_parameters, fifos = fifos) 416 | 417 | if fate is None: 418 | hits.append([state['x'],state['y'],state['E'],1]) 419 | else: 420 | #if fate is not None: 421 | hits.append([state['x'],state['y'],state['E'],fate['interact']]) 422 | history.append([[state['x'],state['y']],[new_state['x'],new_state['y']]]) 423 | next1, next2, nextY1, nextY2 = fate2state(fate, new_state) 424 | 425 | #print(step_count['n'], fate['keep_new_alt']) 426 | 427 | if fate['keep_new_alt']==True: 428 | found_alt = True 429 | alt_index = len(hits)-1 430 | next_alive_states_st = copy.deepcopy(next_alive_states) 431 | if nextY1 is not None: 432 | next_alive_states_st.append(nextY1) 433 | if nextY2 is not None: 434 | next_alive_states_st.append(nextY2) 435 | 436 | 437 | if next1 is not None: 438 | next_alive_states.append(next1) 439 | if found_alt and fate['keep_new_alt']==False: 440 | next_alive_states_st.append(next1) 441 | 442 | if next2 is not None: 443 | next_alive_states.append(next2) 444 | if found_alt and fate['keep_new_alt']==False: 445 | next_alive_states_st.append(next2) 446 | 447 | if found_alt: 448 | program_st['y'] = { 449 | 'history': copy.deepcopy(history), 450 | 'hits': copy.deepcopy(hits), 451 | 'alive_states': next_alive_states_st, 452 | } 453 | interact_primal = program_st['y']['hits'][alt_index][3] 454 | program_st['y']['hits'][alt_index][3] = (not interact_primal) 455 | 456 | 457 | else: 458 | if program_st['y'] is not None: 459 | next_alive_states_st = [] 460 | 461 | for state in program_st['y']['alive_states']: 462 | new_state = propagate_state(state) 463 | fate = sample_fate(None, new_state, None, sim_parameters, check_alts=False, fifos = fifos) 464 | 465 | if fate is None: 466 | program_st['y']['hits'].append([state['x'],state['y'],state['E'],1]) 467 | else: 468 | #if fate is not None: 469 | program_st['y']['hits'].append([state['x'],state['y'],state['E'],fate['interact']]) 470 | program_st['y']['history'].append([[state['x'],state['y']],[new_state['x'],new_state['y']]]) 471 | next1, next2, _, _ = fate2state(fate, new_state) 472 | 473 | 474 | if next1 is not None: 475 | next_alive_states_st.append(next1) 476 | if next2 is not None: 477 | next_alive_states_st.append(next2) 478 | 479 | program_st['y']['alive_states'] = next_alive_states_st 480 | 481 | run_again = (len(next_alive_states)>0) 482 | run_again_st = False 483 | if (program_st['y'] is None): 484 | run_again_st = False 485 | else: 486 | if(len(program_st['y']['alive_states'])>0): 487 | run_again_st = True 488 | 489 | step_count['n'] += 1 490 | 491 | if run_again or run_again_st: 492 | #print(len(next_alive_states)) 493 | try: 494 | run(score, history, hits, next_alive_states, program_st, sim_parameters, step_count, fifos) 495 | except RecursionError as e: 496 | print("####### Caught Recursion Error #######") 497 | print(len(next_alive_states), len(program_st['y']['alive_states']), step_count['n']) 498 | print("next_alive_states:") 499 | for state in next_alive_states: 500 | print(state) 501 | 502 | print("next_alive_states_st:") 503 | for state in program_st['y']['alive_states']: 504 | print(state) 505 | 506 | return 507 | 508 | 509 | def generate_random_init(): 510 | phi = np.random.uniform(-np.pi,np.pi) 511 | py = np.sin(phi) 512 | px = np.cos(phi) 513 | state = {'x': 0, 'y': 0, 'r': 0, 'px': px, 'py': py, 'E': 25, 'alive':True} 514 | return state 515 | 516 | 517 | def generate(init, program_st, sim_parameters, reuse_rvs=False): 518 | history, hits, score = [], [], {'thresh_x': 0.0, 'thresh_E': 0.0} 519 | step_count = {'n':0} 520 | 521 | fifos = None 522 | if reuse_rvs: 523 | fifos = { "interact":queue.Queue() } 524 | 525 | run(score, history, hits, alive_states = [init], 526 | program_st = program_st, sim_parameters=sim_parameters, 527 | step_count=step_count, fifos=fifos) 528 | 529 | hits = np.array(hits) 530 | act = hits[hits[:,3]==1] 531 | hits_st = np.array(program_st['y']['hits']) 532 | out_st = stochasticTriple(program_st['d'], 533 | {'hits':hits_st, 534 | 'active':hits_st[hits_st[:,3]==1], 535 | 'history':np.array(program_st['y']['history'])}, 536 | program_st['w']) 537 | return np.array(hits), act, np.array(history), {k:np.array(v) for k,v in score.items()}, out_st 538 | 539 | def simulator(par, split_prob, reuse_rvs = True): 540 | init = generate_random_init() 541 | program_st = stochasticTriple(0., None, 0.) 542 | 543 | sim_parameters = {'thresh_E': 0.5, 'split_prob':split_prob, 'thresh_x': par} 544 | 545 | hits,active,history,scores,out_st = generate(init, program_st, sim_parameters, reuse_rvs) 546 | scores = jax.lax.stop_gradient(scores['thresh_x']) 547 | return hits,active,history,scores,out_st 548 | 549 | 550 | return simulator -------------------------------------------------------------------------------- /GradientEstimates.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 13, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import matplotlib.pyplot as plt\n", 10 | "import seaborn as sns\n", 11 | "from shower_sim_baseline import summary_metric\n", 12 | "from shower_sim_instrumented import simulator\n", 13 | "from tqdm import tqdm\n", 14 | "import numpy as np\n", 15 | "from shower_sim_optimize import optimize, program_to_optimize\n", 16 | "\n", 17 | "%load_ext autoreload\n", 18 | "%autoreload 2\n" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": null, 24 | "metadata": {}, 25 | "outputs": [], 26 | "source": [ 27 | "the_program = program_to_optimize(simulator, summary_metric)\n", 28 | "\n", 29 | "def the_program_all_grads(theta):\n", 30 | " return the_program(theta, keep_all_grads=True)\n", 31 | "\n", 32 | "runs1 = [the_program_all_grads(2.5) for _ in tqdm(range(500))]" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 18, 38 | "metadata": {}, 39 | "outputs": [ 40 | { 41 | "data": { 42 | "image/png": "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", 43 | "text/plain": [ 44 | "
" 45 | ] 46 | }, 47 | "metadata": {}, 48 | "output_type": "display_data" 49 | } 50 | ], 51 | "source": [ 52 | "from plots_gradients import plot_variance_with_inset\n", 53 | "f,axarr = plt.subplots(1,1)\n", 54 | "f.set_size_inches(6,6)\n", 55 | "plot_variance_with_inset(axarr,runs1)\n", 56 | "f.savefig('gradient_variance.pdf')" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [] 65 | } 66 | ], 67 | "metadata": { 68 | "kernelspec": { 69 | "display_name": "Python 3.11.4 64-bit ('stochad_env')", 70 | "language": "python", 71 | "name": "python3" 72 | }, 73 | "language_info": { 74 | "codemirror_mode": { 75 | "name": "ipython", 76 | "version": 3 77 | }, 78 | "file_extension": ".py", 79 | "mimetype": "text/x-python", 80 | "name": "python", 81 | "nbconvert_exporter": "python", 82 | "pygments_lexer": "ipython3", 83 | "version": "3.11.4" 84 | }, 85 | "orig_nbformat": 4, 86 | "vscode": { 87 | "interpreter": { 88 | "hash": "29b777788fad9121f9b4a41d949494280ba66b13a17f3ccd9e5dfa0de3270b9d" 89 | } 90 | } 91 | }, 92 | "nbformat": 4, 93 | "nbformat_minor": 2 94 | } 95 | -------------------------------------------------------------------------------- /notebooks/03_VisualizeSimulator.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 6, 6 | "id": "726e1c72-9de8-4334-b8c9-c203da688e57", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "name": "stdout", 11 | "output_type": "stream", 12 | "text": [ 13 | "The autoreload extension is already loaded. To reload it, use:\n", 14 | " %reload_ext autoreload\n" 15 | ] 16 | } 17 | ], 18 | "source": [ 19 | "import sys\n", 20 | "sys.path.insert(1, os.path.join(sys.path[0], '..'))\n", 21 | "\n", 22 | "import numpy as np\n", 23 | "import matplotlib.pyplot as plt\n", 24 | "import jax\n", 25 | "import copy\n", 26 | "import queue\n", 27 | "from shower_sim_redone import make_simulator\n", 28 | "from shower_sim_baseline import summary_metric, interact_prob\n", 29 | "\n", 30 | "simulator = make_simulator()\n", 31 | "%load_ext autoreload\n", 32 | "%autoreload 2" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "id": "12874c6c", 38 | "metadata": {}, 39 | "source": [ 40 | "# Check it Runs" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 7, 46 | "id": "ac9ffd10-1148-4e73-82a6-bdad052d94df", 47 | "metadata": {}, 48 | "outputs": [ 49 | { 50 | "name": "stdout", 51 | "output_type": "stream", 52 | "text": [ 53 | "-6.4722357 26.9953502063654 2824 3088\n" 54 | ] 55 | } 56 | ], 57 | "source": [ 58 | "\n", 59 | "\n", 60 | "hits,active,history,scores,out_st = simulator(3.5, split_prob = 1.0, reuse_rvs=True)\n", 61 | "print(scores, out_st['w'], hits.size, out_st['y']['hits'].size)" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 8, 67 | "id": "45d0d360-cd91-4155-bc0b-520f87059b8e", 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [ 71 | "from shower_sim_optimize import optimize, program_to_optimize\n", 72 | "from shower_sim_baseline import per_hit_summary\n", 73 | "the_program = program_to_optimize(simulator, summary_metric, sim_kwargs=dict(split_prob = 1.0, reuse_rvs=True))" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 58, 79 | "id": "92181b2b-db93-40dc-9265-f4c959e56dcc", 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "########### Plotting ###########\n", 84 | "\n", 85 | "def _plot_bkg(ax,par,min = -5,max = 5):\n", 86 | " grid = np.mgrid[-min:min:701j,-min:min:701j]\n", 87 | " points = np.swapaxes(grid,0,-1).reshape(-1,2)\n", 88 | " vals = jax.vmap(interact_prob,in_axes = (0,0,None))(points[:,0],points[:,1],par)\n", 89 | " vals = vals.reshape(701,701).T\n", 90 | " ax.contourf(grid[0],grid[1],vals, cmap = 'Greys', vmin = 0,vmax = 1, alpha = 1.0) \n", 91 | " ax.set_xlabel('x')\n", 92 | " ax.set_ylabel('y')\n", 93 | " ax.set_ylim(-6,6)\n", 94 | " ax.set_xlim(-6,6)\n", 95 | "\n", 96 | "def _plot_event(ax,generation):\n", 97 | " hits,active,history,scores,out_st = generation\n", 98 | "\n", 99 | " alt_active = generation[-1]['y']['active']\n", 100 | " ax.plot(history[:,:,0].T,history[:,:,1].T, c = 'k', alpha = 0.2);\n", 101 | " # ax.scatter(hits[:,0],hits[:,1], c = hits[:,3], alpha = 0.4)\n", 102 | " ax.scatter(active[:,0],active[:,1], c = active[:,3], alpha = 0.4)\n", 103 | "\n", 104 | "def _plot_event_summary(ax,generation):\n", 105 | " hits,active,history,scores,out_st = generation\n", 106 | " ax.hist(per_hit_summary(active),bins = np.linspace(0,5,301), density=True)\n", 107 | " ax.set_ylim(0,3)\n", 108 | " ax.set_xlim(0,5)\n", 109 | " ax.set_xlabel('r')\n", 110 | " ax.set_ylabel('p_hits(r)')\n", 111 | "\n" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 59, 117 | "id": "3d0df2f6", 118 | "metadata": {}, 119 | "outputs": [], 120 | "source": [ 121 | "np.random.seed(8)\n", 122 | "generation = simulator(2.5, **dict(split_prob = 1.0))" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 60, 128 | "id": "514cd715", 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "data": { 133 | "image/png": "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", 134 | "text/plain": [ 135 | "
" 136 | ] 137 | }, 138 | "metadata": {}, 139 | "output_type": "display_data" 140 | } 141 | ], 142 | "source": [ 143 | "f,ax = plt.subplots(1,1)\n", 144 | "par = 2.5\n", 145 | "_plot_bkg(ax,par,-6,6)\n", 146 | "_plot_event(ax, generation)\n", 147 | "ax.set_xlim(-3,-1)\n", 148 | "ax.set_ylim(1.,3.)\n", 149 | "f.set_size_inches(4,4)" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": null, 155 | "id": "47b08e4d", 156 | "metadata": {}, 157 | "outputs": [], 158 | "source": [] 159 | } 160 | ], 161 | "metadata": { 162 | "kernelspec": { 163 | "display_name": "Python 3.11.4 64-bit ('stochad_env')", 164 | "language": "python", 165 | "name": "python3" 166 | }, 167 | "language_info": { 168 | "codemirror_mode": { 169 | "name": "ipython", 170 | "version": 3 171 | }, 172 | "file_extension": ".py", 173 | "mimetype": "text/x-python", 174 | "name": "python", 175 | "nbconvert_exporter": "python", 176 | "pygments_lexer": "ipython3", 177 | "version": "3.11.4" 178 | }, 179 | "vscode": { 180 | "interpreter": { 181 | "hash": "29b777788fad9121f9b4a41d949494280ba66b13a17f3ccd9e5dfa0de3270b9d" 182 | } 183 | } 184 | }, 185 | "nbformat": 4, 186 | "nbformat_minor": 5 187 | } 188 | -------------------------------------------------------------------------------- /VisualizeDesign.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 10, 6 | "id": "726e1c72-9de8-4334-b8c9-c203da688e57", 7 | "metadata": {}, 8 | "outputs": [ 9 | { 10 | "name": "stdout", 11 | "output_type": "stream", 12 | "text": [ 13 | "The autoreload extension is already loaded. To reload it, use:\n", 14 | " %reload_ext autoreload\n" 15 | ] 16 | } 17 | ], 18 | "source": [ 19 | "import numpy as np\n", 20 | "import matplotlib.pyplot as plt\n", 21 | "import jax\n", 22 | "import copy\n", 23 | "import queue\n", 24 | "from shower_sim_instrumented import simulator\n", 25 | "from shower_sim_baseline import summary_metric, interact_prob\n", 26 | "\n", 27 | "%load_ext autoreload\n", 28 | "%autoreload 2" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "id": "12874c6c", 34 | "metadata": {}, 35 | "source": [ 36 | "# Check it Runs" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 11, 42 | "id": "ac9ffd10-1148-4e73-82a6-bdad052d94df", 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "name": "stdout", 47 | "output_type": "stream", 48 | "text": [ 49 | "-9.576843 49.74283491693495 3440 3100\n" 50 | ] 51 | } 52 | ], 53 | "source": [ 54 | "hits,active,history,scores,out_st = simulator(3.5)\n", 55 | "print(scores, out_st['w'], hits.size, out_st['y']['hits'].size)" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 12, 61 | "id": "45d0d360-cd91-4155-bc0b-520f87059b8e", 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [ 65 | "from shower_sim_optimize import optimize, program_to_optimize\n", 66 | "from shower_sim_baseline import per_hit_summary\n", 67 | "the_program = program_to_optimize(simulator, summary_metric)" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 15, 73 | "id": "92181b2b-db93-40dc-9265-f4c959e56dcc", 74 | "metadata": {}, 75 | "outputs": [], 76 | "source": [ 77 | "########### Plotting ###########\n", 78 | "\n", 79 | "def _plot_bkg(ax,par,min = -5,max = 5):\n", 80 | " grid = np.mgrid[-min:min:701j,-min:min:701j]\n", 81 | " points = np.swapaxes(grid,0,-1).reshape(-1,2)\n", 82 | " vals = jax.vmap(interact_prob,in_axes = (0,0,None))(points[:,0],points[:,1],par)\n", 83 | " vals = vals.reshape(701,701).T\n", 84 | " ax.contourf(grid[0],grid[1],vals, cmap = 'Greys', vmin = 0,vmax = 1, alpha = 1.0) \n", 85 | " ax.set_xlabel('x')\n", 86 | " ax.set_ylabel('y')\n", 87 | " ax.set_ylim(-6,6)\n", 88 | " ax.set_xlim(-6,6)\n", 89 | "\n", 90 | "def _plot_event(ax,generation):\n", 91 | " hits,active,history,scores,out_st = generation\n", 92 | " ax.plot(history[:,:,0].T,history[:,:,1].T, c = 'k', alpha = 0.2);\n", 93 | " # ax.scatter(hits[:,0],hits[:,1], c = hits[:,3], alpha = 0.4)\n", 94 | " ax.scatter(active[:,0],active[:,1], c = active[:,3], alpha = 0.4)\n", 95 | "\n", 96 | "def _plot_event_summary(ax,generation):\n", 97 | " hits,active,history,scores,out_st = generation\n", 98 | " ax.hist(per_hit_summary(active),bins = np.linspace(0,5,301), density=True)\n", 99 | " ax.set_ylim(0,3)\n", 100 | " ax.set_xlim(0,5)\n", 101 | " ax.set_xlabel('r')\n", 102 | " ax.set_ylabel('p_hits(r)')\n", 103 | "\n", 104 | "def plot_config_and_summary_onax(axarr,par):\n", 105 | " ax = axarr[0]\n", 106 | "\n", 107 | " generation = simulator(par)\n", 108 | " _plot_bkg(ax,par,-6,6)\n", 109 | " _plot_event(ax, generation)\n", 110 | "\n", 111 | " ax = axarr[1]\n", 112 | " _plot_event_summary(ax,generation)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 16, 118 | "id": "514cd715", 119 | "metadata": {}, 120 | "outputs": [ 121 | { 122 | "data": { 123 | "image/png": "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", 124 | "text/plain": [ 125 | "
" 126 | ] 127 | }, 128 | "metadata": {}, 129 | "output_type": "display_data" 130 | } 131 | ], 132 | "source": [ 133 | "f,axarr = plt.subplots(1,2)\n", 134 | "f.set_size_inches(10,5)\n", 135 | "plot_config_and_summary_onax(axarr,2.5)" 136 | ] 137 | } 138 | ], 139 | "metadata": { 140 | "kernelspec": { 141 | "display_name": "Python 3.11.4 64-bit ('stochad_env')", 142 | "language": "python", 143 | "name": "python3" 144 | }, 145 | "language_info": { 146 | "codemirror_mode": { 147 | "name": "ipython", 148 | "version": 3 149 | }, 150 | "file_extension": ".py", 151 | "mimetype": "text/x-python", 152 | "name": "python", 153 | "nbconvert_exporter": "python", 154 | "pygments_lexer": "ipython3", 155 | "version": "3.11.4" 156 | }, 157 | "vscode": { 158 | "interpreter": { 159 | "hash": "29b777788fad9121f9b4a41d949494280ba66b13a17f3ccd9e5dfa0de3270b9d" 160 | } 161 | } 162 | }, 163 | "nbformat": 4, 164 | "nbformat_minor": 5 165 | } 166 | --------------------------------------------------------------------------------