diff --git a/notebooks/save_dataframe.ipynb b/notebooks/save_dataframe.ipynb index d27cc64..7a1e0c0 100644 --- a/notebooks/save_dataframe.ipynb +++ b/notebooks/save_dataframe.ipynb @@ -6,12 +6,12 @@ "metadata": {}, "source": [ "## Static dataset creation\n", - "This notebook walks through how to use the modules to create and save a static dataset for use in all of the statistical and ML methods. The method-focused notebooks show how to import and utilize this static dataset in inference." + "This notebook walks through how to use the modules to create and save a static dataset for use in all of the statistical and ML methods. The method-focused notebooks show how to import and utilize this static dataset in inference. This notebook saves two datasets - one for the hierarchical pendulum, and one for the non-hierarchical pendulum. Both are the same size." ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 1, "id": "47611152-0598-4d26-ac4d-d1f243dd0736", "metadata": {}, "outputs": [], @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 2, "id": "91e28762-3307-499d-bfbb-a3ffecf8b3e7", "metadata": {}, "outputs": [], @@ -37,16 +37,18 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 10, "id": "4ca50a6f-8f0e-469f-9993-e1e082133a7f", "metadata": {}, "outputs": [], "source": [ - "\n", - "def save_thetas_and_xs_multiple(params_in):\n", - " # except length will have 4 elements\n", + "def save_thetas_and_xs_hierarchical(params_in):\n", + " # this function creates the fully hierarchical dataset\n", + " # note that μ_a_g and σ_a_g are inputs and a_g is drawn from these\n", + " \n", " lengths, thetas, μ_a_g, σ_a_g = params_in\n", "\n", + " # draw two different values of a_g, one for each planet\n", " ag0 = rs.normal(loc=μ_a_g, scale=σ_a_g)\n", " ag1 = rs.normal(loc=μ_a_g, scale=σ_a_g)\n", " ags = np.array([np.repeat(ag0,int(len(lengths)/2)), np.repeat(ag1,int(len(lengths)/2))]).flatten()\n", @@ -70,12 +72,44 @@ " x = pendulum.create_object(0.75, noiseless=False)\n", " xs.append(x)\n", " del pendulum\n", + " return ags, xs\n", + "\n", + "def save_thetas_and_xs_non_hierarchical(params_in):\n", + " # this function creates the fully hierarchical dataset\n", + " # note that μ_a_g and σ_a_g are inputs and a_g is drawn from these\n", + " \n", + " lengths, thetas = params_in\n", + "\n", + " ag0 = rs.normal(loc=10, scale=1)\n", + " ag1 = rs.normal(loc=10, scale=1)\n", + " \n", + " ags = np.array([np.repeat(ag0,int(len(lengths)/2)), np.repeat(ag1,int(len(lengths)/2))]).flatten()\n", + " #ags = np.array([rs.normal(loc=μ_a_g, scale=σ_a_g, size = int(len(lengths)/2)),\n", + " # rs.normal(loc=μ_a_g, scale=σ_a_g, size = int(len(lengths)/2))]).flatten()\n", + " \n", + " \n", + " xs = []\n", + " for i in range(len(lengths)):\n", + " #print(lengths[i], thetas[i], ags[i])\n", + " pendulum = Pendulum(\n", + " pendulum_arm_length=float(lengths[i]),\n", + " starting_angle_radians=float(thetas[i]),\n", + " acceleration_due_to_gravity=float(ags[i]),\n", + " noise_std_percent={\n", + " \"pendulum_arm_length\": 0.0,\n", + " \"starting_angle_radians\": 0.1,\n", + " \"acceleration_due_to_gravity\": 0.0,\n", + " },\n", + " )\n", + " x = pendulum.create_object(0.75, noiseless=False)\n", + " xs.append(x)\n", + " del pendulum\n", " return ags, xs" ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 5, "id": "9fdc1f49-e453-4526-b18b-814b68f92aca", "metadata": {}, "outputs": [], @@ -102,7 +136,7 @@ "#y_noisy = []\n", "\n", " \n", - "rs = np.random.RandomState()#2147483648)# \n", + "rs = np.random.RandomState(666)# \n", "\n", "\n", "lengths_draw = abs(rs.normal(loc=5, scale=2, size = pendulums_per_planet))\n", @@ -116,13 +150,13 @@ " thetas_draw,\n", " μ_a_g, σ_a_g]\n", "\n", - "a_gs, xs_out = save_thetas_and_xs_multiple(params_in)\n", + "a_gs, xs_out = save_thetas_and_xs_hierarchical(params_in)\n", "\n" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 6, "id": "9714134e-53a2-42df-b254-e942a2a41314", "metadata": {}, "outputs": [ @@ -157,43 +191,43 @@ " \n", " \n", " 0\n", - " 5.939540\n", - " 0.040323\n", - " 10.348500\n", + " 6.648376\n", + " 0.035245\n", + " 6.656893\n", " 0.75\n", - " 0.126648\n", + " 0.159997\n", " \n", " \n", " 1\n", - " 3.645948\n", - " 0.041587\n", - " 10.348500\n", + " 5.959932\n", + " 0.035125\n", + " 6.656893\n", " 0.75\n", - " 0.046904\n", + " 0.164784\n", " \n", " \n", " 2\n", - " 4.494573\n", - " 0.032681\n", - " 10.348500\n", + " 7.346936\n", + " 0.027426\n", + " 6.656893\n", " 0.75\n", - " 0.066548\n", + " 0.148472\n", " \n", " \n", " 3\n", - " 3.691717\n", - " 0.032449\n", - " 10.348500\n", + " 6.818096\n", + " 0.043121\n", + " 6.656893\n", " 0.75\n", - " 0.036753\n", + " 0.224570\n", " \n", " \n", " 4\n", - " 8.463276\n", - " 0.026023\n", - " 10.348500\n", + " 3.856557\n", + " 0.025951\n", + " 6.656893\n", " 0.75\n", - " 0.124928\n", + " 0.058967\n", " \n", " \n", " ...\n", @@ -205,43 +239,43 @@ " \n", " \n", " 95\n", - " 3.287364\n", - " 0.027606\n", - " 9.821157\n", + " 8.139616\n", + " 0.021888\n", + " 6.431957\n", " 0.75\n", - " 0.027284\n", + " 0.118812\n", " \n", " \n", " 96\n", - " 4.901377\n", - " 0.031559\n", - " 9.821157\n", + " 4.816909\n", + " 0.032708\n", + " 6.431957\n", " 0.75\n", - " 0.080431\n", + " 0.097864\n", " \n", " \n", " 97\n", - " 6.374146\n", - " 0.028311\n", - " 9.821157\n", + " 3.206136\n", + " 0.033854\n", + " 6.431957\n", " 0.75\n", - " 0.102336\n", + " 0.058675\n", " \n", " \n", " 98\n", - " 1.075661\n", - " 0.030635\n", - " 9.821157\n", + " 7.266712\n", + " 0.023045\n", + " 6.431957\n", " 0.75\n", - " -0.023095\n", + " 0.113172\n", " \n", " \n", " 99\n", - " 5.731387\n", - " 0.023705\n", - " 9.821157\n", + " 8.444094\n", + " 0.040042\n", + " 6.431957\n", " 0.75\n", - " 0.071557\n", + " 0.302359\n", " \n", " \n", "\n", @@ -249,23 +283,23 @@ "" ], "text/plain": [ - " length theta a_g time pos\n", - "0 5.939540 0.040323 10.348500 0.75 0.126648\n", - "1 3.645948 0.041587 10.348500 0.75 0.046904\n", - "2 4.494573 0.032681 10.348500 0.75 0.066548\n", - "3 3.691717 0.032449 10.348500 0.75 0.036753\n", - "4 8.463276 0.026023 10.348500 0.75 0.124928\n", - ".. ... ... ... ... ...\n", - "95 3.287364 0.027606 9.821157 0.75 0.027284\n", - "96 4.901377 0.031559 9.821157 0.75 0.080431\n", - "97 6.374146 0.028311 9.821157 0.75 0.102336\n", - "98 1.075661 0.030635 9.821157 0.75 -0.023095\n", - "99 5.731387 0.023705 9.821157 0.75 0.071557\n", + " length theta a_g time pos\n", + "0 6.648376 0.035245 6.656893 0.75 0.159997\n", + "1 5.959932 0.035125 6.656893 0.75 0.164784\n", + "2 7.346936 0.027426 6.656893 0.75 0.148472\n", + "3 6.818096 0.043121 6.656893 0.75 0.224570\n", + "4 3.856557 0.025951 6.656893 0.75 0.058967\n", + ".. ... ... ... ... ...\n", + "95 8.139616 0.021888 6.431957 0.75 0.118812\n", + "96 4.816909 0.032708 6.431957 0.75 0.097864\n", + "97 3.206136 0.033854 6.431957 0.75 0.058675\n", + "98 7.266712 0.023045 6.431957 0.75 0.113172\n", + "99 8.444094 0.040042 6.431957 0.75 0.302359\n", "\n", "[100 rows x 5 columns]" ] }, - "execution_count": 50, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -297,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 7, "id": "482e2844-2ea2-4a8c-868b-8b798a36b296", "metadata": {}, "outputs": [ @@ -333,48 +367,48 @@ " \n", " \n", " 0\n", - " 5.939540\n", - " 0.040323\n", - " 10.348500\n", + " 6.648376\n", + " 0.035245\n", + " 6.656893\n", " 0.75\n", - " 0.126648\n", - " 0.013138\n", + " 0.159997\n", + " 0.017132\n", " \n", " \n", " 1\n", - " 3.645948\n", - " 0.041587\n", - " 10.348500\n", + " 5.959932\n", + " 0.035125\n", + " 6.656893\n", " 0.75\n", - " 0.046904\n", - " 0.004585\n", + " 0.164784\n", + " 0.014691\n", " \n", " \n", " 2\n", - " 4.494573\n", - " 0.032681\n", - " 10.348500\n", + " 7.346936\n", + " 0.027426\n", + " 6.656893\n", " 0.75\n", - " 0.066548\n", - " 0.006160\n", + " 0.148472\n", + " 0.015226\n", " \n", " \n", " 3\n", - " 3.691717\n", - " 0.032449\n", - " 10.348500\n", + " 6.818096\n", + " 0.043121\n", + " 6.656893\n", " 0.75\n", - " 0.036753\n", - " 0.003712\n", + " 0.224570\n", + " 0.021679\n", " \n", " \n", " 4\n", - " 8.463276\n", - " 0.026023\n", - " 10.348500\n", + " 3.856557\n", + " 0.025951\n", + " 6.656893\n", " 0.75\n", - " 0.124928\n", - " 0.014872\n", + " 0.058967\n", + " 0.005529\n", " \n", " \n", " ...\n", @@ -387,48 +421,48 @@ " \n", " \n", " 95\n", - " 3.287364\n", - " 0.027606\n", - " 9.821157\n", + " 8.139616\n", + " 0.021888\n", + " 6.431957\n", " 0.75\n", - " 0.027284\n", - " 0.002459\n", + " 0.118812\n", + " 0.013999\n", " \n", " \n", " 96\n", - " 4.901377\n", - " 0.031559\n", - " 9.821157\n", + " 4.816909\n", + " 0.032708\n", + " 6.431957\n", " 0.75\n", - " 0.080431\n", - " 0.007539\n", + " 0.097864\n", + " 0.010197\n", " \n", " \n", " 97\n", - " 6.374146\n", - " 0.028311\n", - " 9.821157\n", + " 3.206136\n", + " 0.033854\n", + " 6.431957\n", " 0.75\n", - " 0.102336\n", - " 0.010773\n", + " 0.058675\n", + " 0.005284\n", " \n", " \n", " 98\n", - " 1.075661\n", - " 0.030635\n", - " 9.821157\n", + " 7.266712\n", + " 0.023045\n", + " 6.431957\n", " 0.75\n", - " -0.023095\n", - " 0.002111\n", + " 0.113172\n", + " 0.012745\n", " \n", " \n", " 99\n", - " 5.731387\n", - " 0.023705\n", - " 9.821157\n", + " 8.444094\n", + " 0.040042\n", + " 6.431957\n", " 0.75\n", - " 0.071557\n", - " 0.007547\n", + " 0.302359\n", + " 0.026810\n", " \n", " \n", "\n", @@ -436,23 +470,23 @@ "" ], "text/plain": [ - " length theta a_g time pos pos_err\n", - "0 5.939540 0.040323 10.348500 0.75 0.126648 0.013138\n", - "1 3.645948 0.041587 10.348500 0.75 0.046904 0.004585\n", - "2 4.494573 0.032681 10.348500 0.75 0.066548 0.006160\n", - "3 3.691717 0.032449 10.348500 0.75 0.036753 0.003712\n", - "4 8.463276 0.026023 10.348500 0.75 0.124928 0.014872\n", - ".. ... ... ... ... ... ...\n", - "95 3.287364 0.027606 9.821157 0.75 0.027284 0.002459\n", - "96 4.901377 0.031559 9.821157 0.75 0.080431 0.007539\n", - "97 6.374146 0.028311 9.821157 0.75 0.102336 0.010773\n", - "98 1.075661 0.030635 9.821157 0.75 -0.023095 0.002111\n", - "99 5.731387 0.023705 9.821157 0.75 0.071557 0.007547\n", + " length theta a_g time pos pos_err\n", + "0 6.648376 0.035245 6.656893 0.75 0.159997 0.017132\n", + "1 5.959932 0.035125 6.656893 0.75 0.164784 0.014691\n", + "2 7.346936 0.027426 6.656893 0.75 0.148472 0.015226\n", + "3 6.818096 0.043121 6.656893 0.75 0.224570 0.021679\n", + "4 3.856557 0.025951 6.656893 0.75 0.058967 0.005529\n", + ".. ... ... ... ... ... ...\n", + "95 8.139616 0.021888 6.431957 0.75 0.118812 0.013999\n", + "96 4.816909 0.032708 6.431957 0.75 0.097864 0.010197\n", + "97 3.206136 0.033854 6.431957 0.75 0.058675 0.005284\n", + "98 7.266712 0.023045 6.431957 0.75 0.113172 0.012745\n", + "99 8.444094 0.040042 6.431957 0.75 0.302359 0.026810\n", "\n", "[100 rows x 6 columns]" ] }, - "execution_count": 58, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -478,13 +512,13 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 8, "id": "1cbd3f6f-26f6-4786-bb8c-f9fc220da8b4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -504,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 9, "id": "44c6292d-fea9-4693-9173-913fd396bbd5", "metadata": {}, "outputs": [], @@ -514,10 +548,76 @@ "df.to_csv(filepath+'static_hierarchical_df.csv')" ] }, + { + "cell_type": "markdown", + "id": "5b2c4470-fc92-4c9b-882b-ebe58cce2431", + "metadata": {}, + "source": [ + "## Make the static dataframe for the non-hierarchical case\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "be3710d9-4708-4dfd-b718-dc534acffdf4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ag0 9.74335976685576 ag1 10.666861788545654\n" + ] + }, + { + "ename": "NameError", + "evalue": "name 'STOP' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[12], line 28\u001b[0m\n\u001b[1;32m 23\u001b[0m thetas_draw \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mabs\u001b[39m(rs\u001b[38;5;241m.\u001b[39mnormal(loc\u001b[38;5;241m=\u001b[39mjnp\u001b[38;5;241m.\u001b[39mpi\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m100\u001b[39m, scale\u001b[38;5;241m=\u001b[39mjnp\u001b[38;5;241m.\u001b[39mpi\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m500\u001b[39m, size \u001b[38;5;241m=\u001b[39m pendulums_per_planet))\n\u001b[1;32m 25\u001b[0m params_in \u001b[38;5;241m=\u001b[39m [lengths_draw,\n\u001b[1;32m 26\u001b[0m thetas_draw]\n\u001b[0;32m---> 28\u001b[0m a_gs, xs_out \u001b[38;5;241m=\u001b[39m \u001b[43msave_thetas_and_xs_non_hierarchical\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams_in\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[10], line 42\u001b[0m, in \u001b[0;36msave_thetas_and_xs_non_hierarchical\u001b[0;34m(params_in)\u001b[0m\n\u001b[1;32m 40\u001b[0m ag1 \u001b[38;5;241m=\u001b[39m rs\u001b[38;5;241m.\u001b[39mnormal(loc\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, scale\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mag0\u001b[39m\u001b[38;5;124m'\u001b[39m, ag0, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mag1\u001b[39m\u001b[38;5;124m'\u001b[39m, ag1)\n\u001b[0;32m---> 42\u001b[0m \u001b[43mSTOP\u001b[49m\n\u001b[1;32m 43\u001b[0m ags \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([np\u001b[38;5;241m.\u001b[39mrepeat(ag0,\u001b[38;5;28mint\u001b[39m(\u001b[38;5;28mlen\u001b[39m(lengths)\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m2\u001b[39m)), np\u001b[38;5;241m.\u001b[39mrepeat(ag1,\u001b[38;5;28mint\u001b[39m(\u001b[38;5;28mlen\u001b[39m(lengths)\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m2\u001b[39m))])\u001b[38;5;241m.\u001b[39mflatten()\n\u001b[1;32m 44\u001b[0m \u001b[38;5;66;03m#ags = np.array([rs.normal(loc=μ_a_g, scale=σ_a_g, size = int(len(lengths)/2)),\u001b[39;00m\n\u001b[1;32m 45\u001b[0m \u001b[38;5;66;03m# rs.normal(loc=μ_a_g, scale=σ_a_g, size = int(len(lengths)/2))]).flatten()\u001b[39;00m\n", + "\u001b[0;31mNameError\u001b[0m: name 'STOP' is not defined" + ] + } + ], + "source": [ + "length_percent_error_all = 0.0\n", + "theta_percent_error_all = 0.1\n", + "a_g_percent_error_all = 0.0\n", + "pos_err = 0.0\n", + "\n", + "time = 0.75\n", + "\n", + "total_length = 1000\n", + "length_df = int(total_length/4) # divide by four because we want the same total size as above\n", + "\n", + "pendulums_per_planet = 100\n", + "\n", + "# and we get four pendulums per iteration of the below\n", + "thetas = np.zeros((total_length, 3))\n", + "# this needs to have the extra 1 so that SBI is happy\n", + "xs = np.zeros((total_length,1))\n", + "\n", + "# use same rs as above, which is: \n", + "#rs = np.random.RandomState(666)# \n", + "\n", + "\n", + "lengths_draw = abs(rs.normal(loc=5, scale=2, size = pendulums_per_planet))\n", + "thetas_draw = abs(rs.normal(loc=jnp.pi/100, scale=jnp.pi/500, size = pendulums_per_planet))\n", + "\n", + "params_in = [lengths_draw,\n", + " thetas_draw]\n", + "\n", + "a_gs, xs_out = save_thetas_and_xs_non_hierarchical(params_in)\n", + "\n" + ] + }, { "cell_type": "code", "execution_count": null, - "id": "4efa4d17-45d1-4505-a111-13bcc479452a", + "id": "f13bcfcb-8281-4def-aa3c-6739fffe27e3", "metadata": {}, "outputs": [], "source": []