From 7d3f3ee4d1f21b87f1694d6b0a393bd72fff2fc7 Mon Sep 17 00:00:00 2001 From: Richard Posert Date: Thu, 4 Jan 2024 15:39:47 -0500 Subject: [PATCH] Generalize 3dflex custom traj to >2 dimensions --- .../3dflex-custom-latent-trajectory.ipynb | 509 +++++++++++++----- 1 file changed, 382 insertions(+), 127 deletions(-) diff --git a/docs/examples/3dflex-custom-latent-trajectory.ipynb b/docs/examples/3dflex-custom-latent-trajectory.ipynb index 5cb154fa..f70ceade 100644 --- a/docs/examples/3dflex-custom-latent-trajectory.ipynb +++ b/docs/examples/3dflex-custom-latent-trajectory.ipynb @@ -81,122 +81,373 @@ " \n", " \n", " \n", - " components_mode_0/component\n", - " components_mode_0/value\n", - " components_mode_1/component\n", - " components_mode_1/value\n", + " alignments2D/alpha\n", + " alignments2D/alpha_min\n", + " alignments2D/class\n", + " alignments2D/class_ess\n", + " alignments2D/class_posterior\n", + " alignments2D/cross_cor\n", + " alignments2D/error\n", + " alignments2D/error_min\n", + " alignments2D/image_pow\n", + " alignments2D/pose\n", + " ...\n", + " pick_stats/power\n", + " pick_stats/template_idx\n", + " sym_expand/helix_num_rises\n", + " sym_expand/helix_rise_A\n", + " sym_expand/helix_twist_rad\n", + " sym_expand/idx\n", + " sym_expand/is_helix\n", + " sym_expand/src_uid\n", + " sym_expand/symmetry\n", " uid\n", " \n", " \n", " \n", " \n", " 0\n", + " 1.0\n", + " 1.067518\n", + " 8\n", + " 1.000261\n", + " 0.999869\n", + " 76.271484\n", + " 9163.180664\n", + " 0.0\n", + " 9203.728516\n", + " 4.744446\n", + " ...\n", + " 781.205933\n", + " 3\n", " 0\n", - " 0.016000\n", - " 1\n", - " 0.314667\n", - " 3070975014664207456\n", + " 0.0\n", + " 0.0\n", + " 0\n", + " 0\n", + " 6947839038024507105\n", + " C2\n", + " 6947839038024507105\n", " \n", " \n", " 1\n", + " 1.0\n", + " 1.067518\n", + " 8\n", + " 1.000261\n", + " 0.999869\n", + " 76.271484\n", + " 9163.180664\n", + " 0.0\n", + " 9203.728516\n", + " 4.744446\n", + " ...\n", + " 781.205933\n", + " 3\n", " 0\n", - " -0.122667\n", + " 0.0\n", + " 0.0\n", " 1\n", - " -0.293333\n", - " 4618435520677801850\n", + " 0\n", + " 6947839038024507105\n", + " C2\n", + " 13932325671802011693\n", " \n", " \n", " 2\n", + " 1.0\n", + " 0.868515\n", + " 2\n", + " 1.006742\n", + " 0.996642\n", + " 62.421875\n", + " 8964.066406\n", + " 0.0\n", + " 8990.552734\n", + " 3.205707\n", + " ...\n", + " 596.804443\n", + " 3\n", " 0\n", - " -0.496000\n", - " 1\n", - " 0.048000\n", - " 5473205460946538064\n", + " 0.0\n", + " 0.0\n", + " 0\n", + " 0\n", + " 18174470766076440683\n", + " C2\n", + " 18174470766076440683\n", " \n", " \n", " 3\n", + " 1.0\n", + " 0.868515\n", + " 2\n", + " 1.006742\n", + " 0.996642\n", + " 62.421875\n", + " 8964.066406\n", + " 0.0\n", + " 8990.552734\n", + " 3.205707\n", + " ...\n", + " 596.804443\n", + " 3\n", " 0\n", - " 0.357333\n", + " 0.0\n", + " 0.0\n", " 1\n", - " 0.133333\n", - " 16310523440862460071\n", + " 0\n", + " 18174470766076440683\n", + " C2\n", + " 16990665930294442579\n", " \n", " \n", " 4\n", + " 1.0\n", + " 1.158005\n", " 0\n", - " 0.698667\n", - " 1\n", - " 0.048000\n", - " 13340786341065263892\n", + " 1.656703\n", + " 0.749064\n", + " 47.288086\n", + " 8603.187500\n", + " 0.0\n", + " 8630.057617\n", + " 5.385587\n", + " ...\n", + " 758.841248\n", + " 3\n", + " 0\n", + " 0.0\n", + " 0.0\n", + " 0\n", + " 0\n", + " 10868047345897440647\n", + " C2\n", + " 10868047345897440647\n", " \n", " \n", " 5\n", + " 1.0\n", + " 1.158005\n", + " 0\n", + " 1.656703\n", + " 0.749064\n", + " 47.288086\n", + " 8603.187500\n", + " 0.0\n", + " 8630.057617\n", + " 5.385587\n", + " ...\n", + " 758.841248\n", + " 3\n", " 0\n", - " -0.464000\n", + " 0.0\n", + " 0.0\n", " 1\n", - " 0.645333\n", - " 7620063338136754589\n", + " 0\n", + " 10868047345897440647\n", + " C2\n", + " 13431911868430011898\n", " \n", " \n", " 6\n", + " 1.0\n", + " 0.992612\n", + " 6\n", + " 1.032084\n", + " 0.984298\n", + " 39.340820\n", + " 8956.469727\n", + " 0.0\n", + " 8975.994141\n", + " 0.000000\n", + " ...\n", + " 601.065002\n", + " 3\n", " 0\n", - " 0.261333\n", - " 1\n", - " 0.624000\n", - " 8503060922953376810\n", + " 0.0\n", + " 0.0\n", + " 0\n", + " 0\n", + " 11087656592019060700\n", + " C2\n", + " 11087656592019060700\n", " \n", " \n", " 7\n", + " 1.0\n", + " 0.992612\n", + " 6\n", + " 1.032084\n", + " 0.984298\n", + " 39.340820\n", + " 8956.469727\n", + " 0.0\n", + " 8975.994141\n", + " 0.000000\n", + " ...\n", + " 601.065002\n", + " 3\n", " 0\n", - " -0.389333\n", + " 0.0\n", + " 0.0\n", " 1\n", - " 0.240000\n", - " 5615192081528122837\n", + " 0\n", + " 11087656592019060700\n", + " C2\n", + " 3521966667339501106\n", " \n", " \n", " 8\n", + " 1.0\n", + " 0.992270\n", + " 8\n", + " 1.000796\n", + " 0.999602\n", + " 71.224609\n", + " 8801.692383\n", + " 0.0\n", + " 8837.027344\n", + " 0.128228\n", + " ...\n", + " 669.910767\n", + " 3\n", " 0\n", - " 0.506667\n", - " 1\n", - " 0.090667\n", - " 11043336177950782473\n", + " 0.0\n", + " 0.0\n", + " 0\n", + " 0\n", + " 10759805808414285613\n", + " C2\n", + " 10759805808414285613\n", " \n", " \n", " 9\n", + " 1.0\n", + " 0.992270\n", + " 8\n", + " 1.000796\n", + " 0.999602\n", + " 71.224609\n", + " 8801.692383\n", + " 0.0\n", + " 8837.027344\n", + " 0.128228\n", + " ...\n", + " 669.910767\n", + " 3\n", " 0\n", - " -0.890667\n", + " 0.0\n", + " 0.0\n", " 1\n", - " 0.410667\n", - " 16147356686061724833\n", + " 0\n", + " 10759805808414285613\n", + " C2\n", + " 2825550586744122481\n", " \n", " \n", "\n", + "

10 rows × 110 columns

\n", "" ], "text/plain": [ - " components_mode_0/component components_mode_0/value \\\n", - "0 0 0.016000 \n", - "1 0 -0.122667 \n", - "2 0 -0.496000 \n", - "3 0 0.357333 \n", - "4 0 0.698667 \n", - "5 0 -0.464000 \n", - "6 0 0.261333 \n", - "7 0 -0.389333 \n", - "8 0 0.506667 \n", - "9 0 -0.890667 \n", + " alignments2D/alpha alignments2D/alpha_min alignments2D/class \\\n", + "0 1.0 1.067518 8 \n", + "1 1.0 1.067518 8 \n", + "2 1.0 0.868515 2 \n", + "3 1.0 0.868515 2 \n", + "4 1.0 1.158005 0 \n", + "5 1.0 1.158005 0 \n", + "6 1.0 0.992612 6 \n", + "7 1.0 0.992612 6 \n", + "8 1.0 0.992270 8 \n", + "9 1.0 0.992270 8 \n", + "\n", + " alignments2D/class_ess alignments2D/class_posterior \\\n", + "0 1.000261 0.999869 \n", + "1 1.000261 0.999869 \n", + "2 1.006742 0.996642 \n", + "3 1.006742 0.996642 \n", + "4 1.656703 0.749064 \n", + "5 1.656703 0.749064 \n", + "6 1.032084 0.984298 \n", + "7 1.032084 0.984298 \n", + "8 1.000796 0.999602 \n", + "9 1.000796 0.999602 \n", + "\n", + " alignments2D/cross_cor alignments2D/error alignments2D/error_min \\\n", + "0 76.271484 9163.180664 0.0 \n", + "1 76.271484 9163.180664 0.0 \n", + "2 62.421875 8964.066406 0.0 \n", + "3 62.421875 8964.066406 0.0 \n", + "4 47.288086 8603.187500 0.0 \n", + "5 47.288086 8603.187500 0.0 \n", + "6 39.340820 8956.469727 0.0 \n", + "7 39.340820 8956.469727 0.0 \n", + "8 71.224609 8801.692383 0.0 \n", + "9 71.224609 8801.692383 0.0 \n", + "\n", + " alignments2D/image_pow alignments2D/pose ... pick_stats/power \\\n", + "0 9203.728516 4.744446 ... 781.205933 \n", + "1 9203.728516 4.744446 ... 781.205933 \n", + "2 8990.552734 3.205707 ... 596.804443 \n", + "3 8990.552734 3.205707 ... 596.804443 \n", + "4 8630.057617 5.385587 ... 758.841248 \n", + "5 8630.057617 5.385587 ... 758.841248 \n", + "6 8975.994141 0.000000 ... 601.065002 \n", + "7 8975.994141 0.000000 ... 601.065002 \n", + "8 8837.027344 0.128228 ... 669.910767 \n", + "9 8837.027344 0.128228 ... 669.910767 \n", + "\n", + " pick_stats/template_idx sym_expand/helix_num_rises \\\n", + "0 3 0 \n", + "1 3 0 \n", + "2 3 0 \n", + "3 3 0 \n", + "4 3 0 \n", + "5 3 0 \n", + "6 3 0 \n", + "7 3 0 \n", + "8 3 0 \n", + "9 3 0 \n", "\n", - " components_mode_1/component components_mode_1/value uid \n", - "0 1 0.314667 3070975014664207456 \n", - "1 1 -0.293333 4618435520677801850 \n", - "2 1 0.048000 5473205460946538064 \n", - "3 1 0.133333 16310523440862460071 \n", - "4 1 0.048000 13340786341065263892 \n", - "5 1 0.645333 7620063338136754589 \n", - "6 1 0.624000 8503060922953376810 \n", - "7 1 0.240000 5615192081528122837 \n", - "8 1 0.090667 11043336177950782473 \n", - "9 1 0.410667 16147356686061724833 " + " sym_expand/helix_rise_A sym_expand/helix_twist_rad sym_expand/idx \\\n", + "0 0.0 0.0 0 \n", + "1 0.0 0.0 1 \n", + "2 0.0 0.0 0 \n", + "3 0.0 0.0 1 \n", + "4 0.0 0.0 0 \n", + "5 0.0 0.0 1 \n", + "6 0.0 0.0 0 \n", + "7 0.0 0.0 1 \n", + "8 0.0 0.0 0 \n", + "9 0.0 0.0 1 \n", + "\n", + " sym_expand/is_helix sym_expand/src_uid sym_expand/symmetry \\\n", + "0 0 6947839038024507105 C2 \n", + "1 0 6947839038024507105 C2 \n", + "2 0 18174470766076440683 C2 \n", + "3 0 18174470766076440683 C2 \n", + "4 0 10868047345897440647 C2 \n", + "5 0 10868047345897440647 C2 \n", + "6 0 11087656592019060700 C2 \n", + "7 0 11087656592019060700 C2 \n", + "8 0 10759805808414285613 C2 \n", + "9 0 10759805808414285613 C2 \n", + "\n", + " uid \n", + "0 6947839038024507105 \n", + "1 13932325671802011693 \n", + "2 18174470766076440683 \n", + "3 16990665930294442579 \n", + "4 10868047345897440647 \n", + "5 13431911868430011898 \n", + "6 11087656592019060700 \n", + "7 3521966667339501106 \n", + "8 10759805808414285613 \n", + "9 2825550586744122481 \n", + "\n", + "[10 rows x 110 columns]" ] }, "execution_count": 2, @@ -207,8 +458,8 @@ "source": [ "import pandas as pd\n", "\n", - "project = cs.find_project(\"P251\")\n", - "particles = project.find_job(\"J21\").load_output(\"particles\")\n", + "project = cs.find_project(\"P312\")\n", + "particles = project.find_job(\"J243\").load_output(\"particles\")\n", "\n", "# only display the first ten rows, since creating an entire dataframe is slow\n", "pd.DataFrame(particles.rows()[:10])" @@ -218,7 +469,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Create an interative plot that responds to on-click events. \n", + "In this notebook, we create a plot of two of the dimensions and click to generate the trajectory through latent space. This approach necessarily allows only the creation of a trajectory through two of the latent coordinates. If you need to change three or more coordinates simultaneously, you will have to manually create a list of the coordinates you want to use." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "selected_dimensions = [0,2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we create an interative plot that responds to on-click events.\n", "\n", "Once the plot is drawn, click repeatedly on the plot along a trajectory you wish to sample in the latent space. The points along this trajectory will form the output of the notebook and be used in 3D Flex Generator.\n", "\n", @@ -233,35 +500,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e674ad0299ae4e5288d8815889abf9c1", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%matplotlib widget\n", "from matplotlib import pyplot as plt\n", @@ -271,8 +512,8 @@ "\n", "def do_plot():\n", " plt.plot(\n", - " particles[\"components_mode_0/value\"][::10],\n", - " particles[\"components_mode_1/value\"][::10],\n", + " particles[f\"components_mode_{selected_dimensions[0]}/value\"][::10],\n", + " particles[f\"components_mode_{selected_dimensions[1]}/value\"][::10],\n", " \".\",\n", " alpha=0.5,\n", " color=\"gray\",\n", @@ -281,8 +522,6 @@ "\n", "\n", "do_plot()\n", - "\n", - "chain = True\n", "pts = []\n", "\n", "\n", @@ -291,14 +530,8 @@ " do_plot()\n", " pts.append([event.xdata, event.ydata])\n", " apts = n.array(pts)\n", - " if chain:\n", - " plt.plot(apts[0, 0], apts[0, 1], \"xk\")\n", - " plt.plot(apts[:, 0], apts[:, 1], \".-r\")\n", - " else:\n", - " for k, i in enumerate(range(0, len(apts), 2)):\n", - " plt.plot(apts[i, 0], apts[i, 1], \"xk\")\n", - " plt.plot(apts[i : i + 2, 0], apts[i : i + 2, 1], \".-\", label=str(k))\n", - " plt.legend()\n", + " plt.plot(apts[0, 0], apts[0, 1], \"xk\")\n", + " plt.plot(apts[:, 0], apts[:, 1], \".-r\")\n", "\n", "\n", "cid = plt.gcf().canvas.mpl_connect(\"button_press_event\", onclick)" @@ -316,26 +549,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Print out the selected trajectory points." + "Print out the selected trajectory points. Each column corresponds to the position along that selected coordinate, i.e., in this example column 1 is coordinate 0 and column 2 is coordinate 2." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "-0.26, 0.52\n", - "-0.49, 0.10\n", - "-0.29, -0.33\n", - " 0.22, -0.46\n", - " 0.67, -0.12\n", - " 0.42, 0.27\n", - "-0.04, 0.27\n", - "-0.27, -0.01\n" + "-0.35, 0.67\n", + "-0.78, 0.09\n", + "-0.50, -0.67\n", + " 0.77, -0.86\n", + " 1.06, -0.18\n", + " 0.95, 0.56\n", + " 0.04, 0.43\n", + "-0.27, -0.11\n" ] } ], @@ -354,13 +587,31 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "job = project.create_external_job(\"W4\", \"Custom Latents\")\n", - "slot_spec = [{\"dtype\": \"components\", \"prefix\": f\"components_mode_{k}\", \"required\": True} for k in range(2)]\n", - "job.connect(\"particles\", \"J21\", \"particles\", slots=slot_spec)" + "# each component has a components_mode_n/component and components_mode_n/value field,\n", + "# so we need to divide the components_mode fields by two to get the total number of components\n", + "num_components = int(len([x for x in particles.fields() if 'components_mode' in x])/2)\n", + "\n", + "slot_spec = [\n", + " {\"dtype\": \"components\", \"prefix\": f\"components_mode_{k}\", \"required\": True}\n", + " for k in range(num_components)\n", + "]\n", + "job = project.create_external_job(\"W5\", \"Custom Latents\")\n", + "job.connect(\"particles\", \"J243\", \"particles\", slots=slot_spec)" ] }, { @@ -372,14 +623,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "latents_dset = job.add_output(\n", " type=\"particle\",\n", " name=\"latents\",\n", - " slots=[{\"prefix\": \"components_mode_%d\" % k, \"dtype\": \"components\", \"required\": True} for k in range(2)],\n", + " slots=slot_spec,\n", " title=\"Latents\",\n", " alloc=len(latent_pts),\n", ")" @@ -394,13 +645,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "for k in range(2):\n", - " latents_dset[\"components_mode_%d/component\" % k] = k\n", - " latents_dset[\"components_mode_%d/value\" % k] = latent_pts[:, k]" + "for k in range(num_components):\n", + " latents_dset[f\"components_mode_{k}/component\"] = k\n", + " try:\n", + " latents_dset[f\"components_mode_{k}/value\"] = latent_pts[:, selected_dimensions.index(k)]\n", + " except ValueError:\n", + " # if a coordinate is not in our selected_dimensions, set the trajectory to zero in that coordinate\n", + " latents_dset[f\"components_mode_{k}/value\"] = 0" ] }, { @@ -412,7 +667,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -438,7 +693,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.0" + "version": "3.8.18" } }, "nbformat": 4,