diff --git a/notebooks/vonmises.ipynb b/notebooks/vonmises.ipynb new file mode 100644 index 0000000..a447db6 --- /dev/null +++ b/notebooks/vonmises.ipynb @@ -0,0 +1,1159 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pedrof/miniconda3/envs/py310/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "/Users/pedrof/miniconda3/envs/py310/lib/python3.10/site-packages/anndata/_core/aligned_df.py:67: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/pedrof/miniconda3/envs/py310/lib/python3.10/site-packages/anndata/_core/aligned_df.py:67: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import scatrex\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "seed = 12345\n", + "\n", + "# Create SCATrEx object for the simulation\n", + "sim_sca = scatrex.SCATrEx(model=scatrex.models.TrajectoryTree, \n", + " model_args={'obs_variance':0.2,\n", + " 'event_mean':2.,\n", + " 'event_concentration':100.,\n", + " 'angle_concentration':5.,\n", + " 'loc_variance':.1,\n", + " 'root_event_mean':10.,\n", + " 'n_factors': 0,\n", + " 'obs_weight_variance':1.,\n", + " 'factor_variance':.1},\n", + " seed=seed) # Use the Trajectory model here for simplicity\n", + "\n", + "# Simulate an observed tree with 10 nodes\n", + "full_observed_tree = scatrex.models.TrajectoryTree(**{'n_nodes':10, 'seed':1234,\n", + " 'add_root': False})\n", + "full_observed_tree.generate_tree()\n", + "full_observed_tree.add_node_params(n_genes=2,min_dist=0.5, **{'event_mean': 4.,\n", + " 'event_concentration':100.,\n", + " 'angle_concentration': 2.,\n", + " 'loc_variance': .1})\n", + "\n", + "# Simulate data from this tree without any extra nodes\n", + "sim_sca.simulate_tree(observed_tree=full_observed_tree, \n", + " n_extra_per_observed=0,)\n", + "\n", + "# Simulate data from the tree\n", + "sim_sca.simulate_data(n_cells=3000)\n", + "\n", + "# Inspect the SCATrEx object\n", + "print(sim_sca)\n", + "\n", + "# See the tree and data\n", + "sim_sca.plot_data(draw=False, alpha=0.4, remove_noise=True)\n", + "ax = plt.gca()\n", + "sim_sca.plot_tree_projection(level=1, ax=ax, node_size=500)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "A\n", + "\n", + "A\n", + "8 cells\n", + "\n", + "\n", + "\n", + "B\n", + "\n", + "B\n", + "11 cells\n", + "\n", + "\n", + "\n", + "A->B\n", + "\n", + "\n", + "\n", + "\n", + "C\n", + "\n", + "C\n", + "11 cells\n", + "\n", + "\n", + "\n", + "B->C\n", + "\n", + "\n", + "\n", + "\n", + "G\n", + "\n", + "G\n", + "11 cells\n", + "\n", + "\n", + "\n", + "B->G\n", + "\n", + "\n", + "\n", + "\n", + "D\n", + "\n", + "D\n", + "8 cells\n", + "\n", + "\n", + "\n", + "C->D\n", + "\n", + "\n", + "\n", + "\n", + "E\n", + "\n", + "E\n", + "8 cells\n", + "\n", + "\n", + "\n", + "C->E\n", + "\n", + "\n", + "\n", + "\n", + "J\n", + "\n", + "J\n", + "10 cells\n", + "\n", + "\n", + "\n", + "C->J\n", + "\n", + "\n", + "\n", + "\n", + "I\n", + "\n", + "I\n", + "9 cells\n", + "\n", + "\n", + "\n", + "D->I\n", + "\n", + "\n", + "\n", + "\n", + "F\n", + "\n", + "F\n", + "9 cells\n", + "\n", + "\n", + "\n", + "E->F\n", + "\n", + "\n", + "\n", + "\n", + "H\n", + "\n", + "H\n", + "9 cells\n", + "\n", + "\n", + "\n", + "F->H\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "full_observed_tree.plot_tree()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "A\n", + "\n", + "A\n", + "8 cells\n", + "\n", + "\n", + "\n", + "B\n", + "\n", + "B\n", + "22 cells\n", + "\n", + "\n", + "\n", + "A->B\n", + "\n", + "\n", + "\n", + "\n", + "C\n", + "\n", + "C\n", + "19 cells\n", + "\n", + "\n", + "\n", + "B->C\n", + "\n", + "\n", + "\n", + "\n", + "D\n", + "\n", + "D\n", + "8 cells\n", + "\n", + "\n", + "\n", + "C->D\n", + "\n", + "\n", + "\n", + "\n", + "G\n", + "\n", + "G\n", + "10 cells\n", + "\n", + "\n", + "\n", + "C->G\n", + "\n", + "\n", + "\n", + "\n", + "H\n", + "\n", + "H\n", + "9 cells\n", + "\n", + "\n", + "\n", + "C->H\n", + "\n", + "\n", + "\n", + "\n", + "E\n", + "\n", + "E\n", + "9 cells\n", + "\n", + "\n", + "\n", + "D->E\n", + "\n", + "\n", + "\n", + "\n", + "F\n", + "\n", + "F\n", + "9 cells\n", + "\n", + "\n", + "\n", + "E->F\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "full_observed_tree.seed = 1\n", + "observed_tree = full_observed_tree.subsample(keep_prob=0.8, force=True)\n", + "observed_tree.plot_tree()\n", + "observed_tree.change_names()\n", + "observed_tree.set_colors(root_node='root')\n", + "observed_tree.plot_tree()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "A\n", + "\n", + "A\n", + "85 cells\n", + "\n", + "\n", + "\n", + "B\n", + "\n", + "B\n", + "9 cells\n", + "\n", + "\n", + "\n", + "A->B\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "full_observed_tree.seed = 14\n", + "observed_tree = full_observed_tree.subsample(keep_prob=.2, force=False)\n", + "observed_tree.change_names()\n", + "observed_tree.set_colors(root_node='root')\n", + "observed_tree.plot_tree()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/pedrof/miniconda3/envs/py310/lib/python3.10/site-packages/anndata/_core/aligned_df.py:67: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/pedrof/miniconda3/envs/py310/lib/python3.10/site-packages/anndata/_core/aligned_df.py:67: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n" + ] + } + ], + "source": [ + "from scatrex.ntssb import NTSSB\n", + "\n", + "sca = scatrex.SCATrEx(model=scatrex.models.TrajectoryTree, \n", + " model_args={'obs_variance':.2,\n", + " 'event_mean':4.,\n", + " 'event_concentration': 1.,\n", + " 'angle_concentration':5.,\n", + " 'loc_variance':.1,\n", + " 'root_event_mean':4.,\n", + " 'n_factors': 0,\n", + " 'obs_weight_variance':1.,\n", + " 'factor_variance':.1},\n", + " seed=12) # Use the Trajectory model here for simplicity\n", + "sca.add_data(np.array(sim_sca.ntssb.data))\n", + "\n", + "sca.set_observed_tree(observed_tree)\n", + "sca.ntssb = NTSSB(\n", + " sca.observed_tree, node_hyperparams=sca.model_args, seed=2,\n", + " use_weights=True,\n", + " weights_concentration=1e3\n", + " )\n", + "sca.ntssb.set_pivot_priors()\n", + "sca.ntssb.add_data(\n", + " np.array(sim_sca.ntssb.data)\n", + ")\n", + "sca.ntssb.make_batches(None, 42)\n", + "sca.ntssb.reset_variational_parameters()\n", + "sca.ntssb.sample_variational_distributions(n_samples=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sca.ntssb.show_tree()\n", + "sca.plot_data(alpha=.1, zorder=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Finding NTSSB (10 nodes, elbo: -9852.60546875): 100%|██████████| 20/20 [03:58<00:00, 11.90s/it] \n" + ] + } + ], + "source": [ + "from scatrex.ntssb import StructureSearch\n", + "from copy import deepcopy\n", + "\n", + "searcher = StructureSearch(sca.ntssb)\n", + "searcher.tree.set_tssb_params(dp_alpha=1., dp_gamma=1.)\n", + "searcher.tree.sample_variational_distributions(n_samples=10)\n", + "searcher.tree.reset_sufficient_statistics()\n", + "for batch_idx in range(len(searcher.tree.batch_indices)):\n", + " searcher.tree.update_sufficient_statistics(batch_idx=batch_idx)\n", + "searcher.tree.learn_params(50, update_roots=False, mc_samples=10, \n", + " step_size=.1, memoized=True, update_outer_ass=True, ass_anneal=1.) \n", + "searcher.tree.compute_elbo(memoized=True)\n", + "searcher.proposed_tree = deepcopy(searcher.tree) \n", + "searcher.run_search(n_iters=20, n_epochs=20, mc_samples=10, step_size=.1, \n", + " memoized=True, seed=4,\n", + " update_outer_ass=True,\n", + " update_roots=False,\n", + " moves_per_tssb=2,\n", + " pr_freq=0)\n", + "# searcher.run_search(n_iters=50, n_epochs=20, mc_samples=10, step_size=.1, \n", + "# memoized=True, seed=4,\n", + "# update_outer_ass=True,\n", + "# update_roots=False,\n", + "# moves_per_tssb=3,\n", + "# pr_freq=1)\n", + "sca.ntssb = deepcopy(searcher.tree)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(-9852.605, dtype=float32)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "searcher.tree.elbo" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sca.ntssb = deepcopy(searcher.best_tree)\n", + "sca.ntssb.show_tree(edge_labels=True, font_size=10)\n", + "sca.plot_data(alpha=.1, zorder=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "MCMC for A: iteration: 499, acceptance ratio: 0.1202, best: -8769 (at 248): 100%|██████████| 500/500 [04:33<00:00, 1.83it/s]\n" + ] + } + ], + "source": [ + "searcher.run_mcmc(n_samples=500, n_burnin=50, n_thin=1, store_trees=False, memoized=True, n_opt_steps=50, step_size=0.1, seed=42)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AA-0A-2A-0-0A-0-0-0A-1A-2-0A-1-0A-1-0-0
ANaNNaNNaNNaNNaNNaNNaNNaNNaN
A-01.0000000.0000000.0000000.000000.00.0000000.0000000.0000000.0
A-20.8374160.1625840.0000000.000000.00.0000000.0000000.0000000.0
A-0-00.0000000.6102450.0000000.000000.00.3897550.0000000.0000000.0
A-0-0-00.0000000.0000000.0000001.000000.00.0000000.0000000.0000000.0
A-10.4899780.5100220.0000000.000000.00.0000000.0000000.0000000.0
A-2-00.0267260.5968820.3719380.000000.00.0044540.0000000.0000000.0
A-1-00.0000000.0000000.0000000.000000.01.0000000.0000000.0000000.0
A-1-0-00.0000000.0000000.0000000.086860.00.3674830.0356350.5100220.0
\n", + "
" + ], + "text/plain": [ + " A A-0 A-2 A-0-0 A-0-0-0 A-1 A-2-0 \\\n", + "A NaN NaN NaN NaN NaN NaN NaN \n", + "A-0 1.000000 0.000000 0.000000 0.00000 0.0 0.000000 0.000000 \n", + "A-2 0.837416 0.162584 0.000000 0.00000 0.0 0.000000 0.000000 \n", + "A-0-0 0.000000 0.610245 0.000000 0.00000 0.0 0.389755 0.000000 \n", + "A-0-0-0 0.000000 0.000000 0.000000 1.00000 0.0 0.000000 0.000000 \n", + "A-1 0.489978 0.510022 0.000000 0.00000 0.0 0.000000 0.000000 \n", + "A-2-0 0.026726 0.596882 0.371938 0.00000 0.0 0.004454 0.000000 \n", + "A-1-0 0.000000 0.000000 0.000000 0.00000 0.0 1.000000 0.000000 \n", + "A-1-0-0 0.000000 0.000000 0.000000 0.08686 0.0 0.367483 0.035635 \n", + "\n", + " A-1-0 A-1-0-0 \n", + "A NaN NaN \n", + "A-0 0.000000 0.0 \n", + "A-2 0.000000 0.0 \n", + "A-0-0 0.000000 0.0 \n", + "A-0-0-0 0.000000 0.0 \n", + "A-1 0.000000 0.0 \n", + "A-2-0 0.000000 0.0 \n", + "A-1-0 0.000000 0.0 \n", + "A-1-0-0 0.510022 0.0 " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "probs = dict()\n", + "for node in searcher.mcmc:\n", + " if 'posterior_freqs' in searcher.mcmc[node]:\n", + " probs[node] = searcher.mcmc[node]['posterior_freqs']\n", + " else:\n", + " probs[node] = searcher.mcmc[node]['posterior_counts']\n", + "probs['A']" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sca.ntssb = deepcopy(searcher.best_tree)\n", + "sca.ntssb.show_tree(labels=True, edge_labels=False, subtree_parent_probs=probs, font_size=8)\n", + "sca.plot_data(alpha=.1, zorder=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(searcher.mcmc['A']['elbos'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ABB-0B-1-0CC-0C-0-0DEE-0
A238000000000
B035300000000
C000036500000
D000002970000
E000243000000
F000000002940
G003530000000
H000000000281
I000000275000
J000000030100
\n", + "
" + ], + "text/plain": [ + " A B B-0 B-1-0 C C-0 C-0-0 D E E-0\n", + "A 238 0 0 0 0 0 0 0 0 0\n", + "B 0 353 0 0 0 0 0 0 0 0\n", + "C 0 0 0 0 365 0 0 0 0 0\n", + "D 0 0 0 0 0 297 0 0 0 0\n", + "E 0 0 0 243 0 0 0 0 0 0\n", + "F 0 0 0 0 0 0 0 0 294 0\n", + "G 0 0 353 0 0 0 0 0 0 0\n", + "H 0 0 0 0 0 0 0 0 0 281\n", + "I 0 0 0 0 0 0 275 0 0 0\n", + "J 0 0 0 0 0 0 0 301 0 0" + ] + }, + "execution_count": 492, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sca.ntssb.assign_samples()\n", + "\n", + "node_assignments = [\n", + " sca.ntssb.root[\"node\"].root[\"node\"].label\n", + "] * sca.adata.shape[0]\n", + "for i, idx in enumerate(range(3000)):\n", + " node_assignments[idx] = sca.ntssb.assignments[i].label\n", + "\n", + "true_assignments = [\n", + " sim_sca.ntssb.root[\"node\"].root[\"node\"].label\n", + "] * sim_sca.adata.shape[0]\n", + "for i, idx in enumerate(range(3000)):\n", + " true_assignments[idx] = sim_sca.ntssb.assignments[i].label \n", + "\n", + "true_labels = np.unique(true_assignments)\n", + "inf_labels = np.unique(node_assignments)\n", + "mat = []\n", + "for tr in true_labels:\n", + " inmat = []\n", + " tr_cells = set(np.where(np.array(true_assignments) == tr)[0])\n", + " for inf in inf_labels:\n", + " inf_cells = set(np.where(np.array(node_assignments) == inf)[0])\n", + " inmat.append(len(set(tr_cells).intersection(set(inf_cells))))\n", + "\n", + " mat.append(inmat)\n", + "\n", + "import pandas as pd\n", + "pd.DataFrame(np.array(mat), index=true_labels, columns=inf_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import jax\n", + "for i in range(5):\n", + " searcher.merge(jax.random.PRNGKey(0+i))\n", + "sca.ntssb = deepcopy(searcher.tree)\n", + "sca.ntssb.show_tree()\n", + "sca.plot_data(alpha=.1, zorder=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Weird! What is B-1 in doing there? It improves the ELBO somehow?!\n", + "\n", + "searcher.proposed_tree.root['node'].root['node'].set_learned_parameters()\n", + "\n", + "sca.ntssb = searcher.proposed_tree\n", + "searcher.proposed_tree.show_tree()\n", + "sca.plot_data(alpha=.1, zorder=-1, remove_noise=False)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "py310", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/scatrex/models/trajectory/node.py b/scatrex/models/trajectory/node.py index 40c192c..a5c872c 100644 --- a/scatrex/models/trajectory/node.py +++ b/scatrex/models/trajectory/node.py @@ -22,9 +22,10 @@ class TrajectoryNode(AbstractNode): def __init__( self, observed_parameters, # subtree root location and angle - root_loc_mean=2., - loc_mean=.5, + root_event_mean=2., + event_mean=.5, angle_concentration=10., + event_concentration=.1, loc_variance=.1, obs_variance=.1, n_factors=2, @@ -45,9 +46,10 @@ def __init__( # Node hyperparameters if self.parent() is None: self.node_hyperparams = dict( - root_loc_mean=root_loc_mean, + root_event_mean=root_event_mean, angle_concentration=angle_concentration, - loc_mean=loc_mean, + event_mean=event_mean, + event_concentration=event_concentration, loc_variance=loc_variance, obs_variance=obs_variance, n_factors=n_factors, @@ -102,9 +104,10 @@ def set_node_hyperparams(self, **kwargs): def reset_parameters( self, - root_loc_mean=2., - loc_mean=.5, + root_event_mean=2., + event_mean=.5, angle_concentration=10., + event_concentration=.1, loc_variance=.1, obs_variance=.1, n_factors=2, @@ -112,9 +115,10 @@ def reset_parameters( factor_variance=1., ): self.node_hyperparams = dict( - root_loc_mean=root_loc_mean, + root_event_mean=root_event_mean, angle_concentration=angle_concentration, - loc_mean=loc_mean, + event_mean=event_mean, + event_concentration=event_concentration, loc_variance=loc_variance, obs_variance=obs_variance, n_factors=n_factors, @@ -153,16 +157,18 @@ def reset_parameters( self.params = self.observed_parameters # loc and angle else: # Non-root node: inherits everything from upstream node self.depth = parent.depth + 1 - loc_mean = self.node_hyperparams['loc_mean'] + event_mean = self.node_hyperparams['event_mean'] + event_concentration = self.node_hyperparams['event_concentration'] angle_concentration = self.node_hyperparams['angle_concentration'] * self.depth rng = np.random.default_rng(seed=self.seed) sampled_angle = rng.vonmises(parent.params[1], angle_concentration) - sampled_loc = rng.normal( - loc_mean, + sampled_event = rng.gamma(event_concentration, event_mean/event_concentration) + state_mean = parent.params[0] + np.array([np.cos(sampled_angle)*np.abs(sampled_event), np.sin(sampled_angle)*np.abs(sampled_event)]) + sampled_state = rng.normal( + state_mean, self.node_hyperparams['loc_variance'] ) - sampled_loc = parent.params[0] + np.array([np.cos(sampled_angle)*np.abs(sampled_loc), np.sin(sampled_angle)*np.abs(sampled_loc)]) - self.params = [sampled_loc, sampled_angle] + self.params = [sampled_state, sampled_angle, sampled_event] self.set_mean() @@ -222,26 +228,29 @@ def reset_variational_parameters(self): return # no variational parameters for root nodes of TSSBs in this model else: # only the non-root nodes have variational parameters # Kernel - radius = self.node_hyperparams['loc_mean'] - if "direction" not in parent.variational_parameters["kernel"]: mean_angle = jnp.array([parent.observed_parameters[1]]) - parent_loc = jnp.array(parent.observed_parameters[0]) + parent_state = jnp.array(parent.observed_parameters[0]) else: mean_angle = parent.variational_parameters["kernel"]["direction"]["mean"] - parent_loc = parent.variational_parameters["kernel"]["state"]["mean"] + parent_state = parent.variational_parameters["kernel"]["state"]["mean"] + + event_concentration = self.node_hyperparams['event_concentration'] * 10. rng = np.random.default_rng(self.seed+2) mean_angle = rng.vonmises(mean_angle, self.node_hyperparams['angle_concentration'] * self.depth) - mean_loc = parent_loc + jnp.array([np.cos(mean_angle[0])*radius, jnp.sin(mean_angle[0])*radius]) + mean_event = rng.gamma(event_concentration, self.node_hyperparams['event_mean']/event_concentration) + mean_state = parent_state + jnp.array([np.cos(mean_angle[0])*mean_event, jnp.sin(mean_angle[0])*mean_event]) rng = np.random.default_rng(self.seed+3) - mean_loc = rng.normal(mean_loc, self.node_hyperparams['loc_variance']) + mean_state = rng.normal(mean_state, self.node_hyperparams['loc_variance']) self.variational_parameters["kernel"] = { 'direction': {'mean': jnp.array(mean_angle), 'log_kappa': jnp.array([-1.])}, - 'state': {'mean': jnp.array(mean_loc), 'log_std': jnp.array([-1., -1.])} + 'state': {'mean': jnp.array(mean_state), 'log_std': jnp.array([-1., -1.])}, + 'event': {'log_alpha': jnp.array([jnp.log(event_concentration)]), 'log_beta': jnp.array([jnp.log(event_concentration/mean_event)])} } self.params = [self.variational_parameters["kernel"]["state"]["mean"], - self.variational_parameters["kernel"]["direction"]["mean"]] + self.variational_parameters["kernel"]["direction"]["mean"], + jnp.exp(self.variational_parameters["kernel"]["event"]["log_alpha"]-self.variational_parameters["kernel"]["event"]["log_beta"])] def set_learned_parameters(self): if self.parent() is None and self.tssb.parent() is None: @@ -252,7 +261,8 @@ def set_learned_parameters(self): self.params = self.observed_parameters else: self.params = [self.variational_parameters["kernel"]["state"]["mean"], - self.variational_parameters["kernel"]["direction"]["mean"]] + self.variational_parameters["kernel"]["direction"]["mean"], + jnp.exp(self.variational_parameters["kernel"]["event"]["log_alpha"]-self.variational_parameters["kernel"]["event"]["log_beta"])] def reset_sufficient_statistics(self, num_batches=1): self.suff_stats = { @@ -386,12 +396,15 @@ def get_noise_sample(self, idx): factor_weights = self.get_factor_weights_sample() return jax.vmap(sample_prod, in_axes=(0,0))(obs_weights,factor_weights) - def get_direction_sample(self): - return self.samples[1] - def get_state_sample(self): return self.samples[0] + def get_direction_sample(self): + return self.samples[1] + + def get_event_sample(self): + return self.samples[2] + def get_prior_angle_concentration(self, depth=None): if depth is None: depth = self.depth @@ -455,13 +468,17 @@ def sample_kernel(self, n_samples=10, store=True): return self._sample_root_kernel(n_samples=n_samples, store=store) key = jax.random.PRNGKey(self.seed) + + key, sample_grad = self.state_sample_and_grad(key, n_samples=n_samples) + sampled_state, _ = sample_grad + key, sample_grad = self.direction_sample_and_grad(key, n_samples=n_samples) sampled_angle, _ = sample_grad - - key, sample_grad = self.state_sample_and_grad(key, n_samples=n_samples) - sampled_loc, _ = sample_grad - samples = [sampled_loc, sampled_angle] + key, sample_grad = self.event_sample_and_grad(key, n_samples=n_samples) + sampled_event, _ = sample_grad + + samples = [sampled_state, sampled_angle, sampled_event] if store: self.samples = samples else: @@ -469,11 +486,15 @@ def sample_kernel(self, n_samples=10, store=True): def _sample_root_kernel(self, n_samples=10, store=True): # In this model the root is just the known parameters, so just store n_samples copies of them to mimic a sample + observed_state = jnp.array([self.observed_parameters[0]]) # Observed location observed_angle = jnp.array([self.observed_parameters[1]]) # Observed angle - observed_loc = jnp.array([self.observed_parameters[0]]) # Observed location + observed_event = jnp.array([self.observed_parameters[2]]) # Observed event + + sampled_state = jnp.vstack(jnp.repeat(observed_state, n_samples, axis=0)) sampled_angle = jnp.vstack(jnp.repeat(observed_angle, n_samples, axis=0)) - sampled_loc = jnp.vstack(jnp.repeat(observed_loc, n_samples, axis=0)) - samples = [sampled_loc, sampled_angle] + sampled_event = jnp.vstack(jnp.repeat(observed_event, n_samples, axis=0)) + + samples = [sampled_state, sampled_angle, sampled_event] if store: self.samples = samples else: @@ -507,31 +528,41 @@ def compute_kernel_prior(self): angle_samples = self.get_direction_sample() angle_logpdf = mc_angle_logp_val_and_grad(angle_samples, prior_mean_angle, prior_angle_concentration)[0] - radius = self.node_hyperparams['loc_mean'] - parent_loc = self.parent().get_state_sample() + event_mean = self.node_hyperparams['event_mean'] + event_concentration = self.node_hyperparams['event_concentration'] + event_samples = self.get_event_sample() + event_logpdf = mc_event_logp_val_and_grad(event_samples, event_mean, event_concentration)[0] + log_std = jnp.log(jnp.sqrt(self.node_hyperparams['loc_variance'])) - loc_samples = self.get_state_sample() - loc_logpdf = mc_loc_logp_val_and_grad(loc_samples, parent_loc, angle_samples, log_std, radius)[0] + state_samples = self.get_state_sample() + parent_state_samples = self.parent().get_state_sample() + state_logpdf = mc_loc_logp_val_and_grad(state_samples, parent_state_samples, angle_samples, log_std, event_samples)[0] - return jnp.mean(angle_logpdf + loc_logpdf) + return jnp.mean(state_logpdf + angle_logpdf + event_logpdf) def compute_root_direction_prior(self, parent_alpha): concentration = self.get_prior_angle_concentration() alpha = self.get_direction_sample() return jnp.mean(mc_angle_logp_val_and_grad(alpha, parent_alpha, concentration)[0]) + def compute_root_event_prior(self): + event_concentration = self.node_hyperparams['event_concentration'] + root_event_mean = self.node_hyperparams['event_mean'] + return jnp.mean(mc_event_logp_val_and_grad(self.get_event_sample(), root_event_mean, event_concentration)[0]) + def compute_root_state_prior(self, parent_psi): log_std = jnp.log(jnp.sqrt(self.node_hyperparams['loc_variance'])) - radius = self.node_hyperparams['root_loc_mean'] psi = self.get_state_sample() alpha = self.get_direction_sample() - return jnp.mean(mc_loc_logp_val_and_grad(psi, parent_psi, alpha, log_std, radius)[0]) + event = self.get_event_sample() + return jnp.mean(mc_loc_logp_val_and_grad(psi, parent_psi, alpha, log_std, event)[0]) def compute_root_kernel_prior(self, samples): parent_alpha = samples[0] logp = self.compute_root_direction_prior(parent_alpha) parent_psi = samples[1] logp += self.compute_root_state_prior(parent_psi) + logp += self.compute_root_event_prior() return logp def compute_root_prior(self): @@ -542,19 +573,25 @@ def compute_kernel_entropy(self): if parent is None: return self.compute_root_entropy() + # Location + state_logpdf = tfd.Normal(self.variational_parameters['kernel']['state']['mean'], + jnp.exp(self.variational_parameters['kernel']['state']['log_std']) + ).entropy() + state_logpdf = jnp.sum(state_logpdf) # Sum across features + # Angle angle_logpdf = tfd.VonMises(np.exp(self.variational_parameters['kernel']['direction']['mean']), jnp.exp(self.variational_parameters['kernel']['direction']['log_kappa']) ).entropy() angle_logpdf = jnp.sum(angle_logpdf) - # Location - loc_logpdf = tfd.Normal(self.variational_parameters['kernel']['state']['mean'], - jnp.exp(self.variational_parameters['kernel']['state']['log_std']) - ).entropy() - loc_logpdf = jnp.sum(loc_logpdf) # Sum across features + # Event + event_logpdf = tfd.Gamma(np.exp(self.variational_parameters['kernel']['event']['log_alpha']), + jnp.exp(self.variational_parameters['kernel']['event']['log_beta']) + ).entropy() + event_logpdf = jnp.sum(event_logpdf) - return angle_logpdf + loc_logpdf + return state_logpdf + angle_logpdf + event_logpdf def compute_root_entropy(self): # In this model the root nodes have no unknown parameters @@ -607,12 +644,12 @@ def direction_sample_and_grad(self, key, n_samples): key, *sub_keys = jax.random.split(key, n_samples+1) return key, mc_sample_angle_val_and_grad(jnp.array(sub_keys), mu, log_kappa) - def state_sample_and_grad(self, key, n_samples): - """Sample and take gradient of state""" - mu = self.variational_parameters['kernel']['state']['mean'] - log_std = self.variational_parameters['kernel']['state']['log_std'] + def event_sample_and_grad(self, key, n_samples): + """Sample and take gradient of event""" + log_alpha = self.variational_parameters['kernel']['event']['log_alpha'] + log_beta = self.variational_parameters['kernel']['event']['log_beta'] key, *sub_keys = jax.random.split(key, n_samples+1) - return key, mc_sample_loc_val_and_grad(jnp.array(sub_keys), mu, log_std) + return key, mc_sample_event_val_and_grad(jnp.array(sub_keys), log_alpha, log_beta) def compute_direction_prior_grad(self, alpha, parent_alpha, parent_loc): """Gradient of logp(alpha|parent_alpha,parent_loc)""" @@ -640,29 +677,36 @@ def compute_direction_prior_child_grad(self, child_alpha, alpha): concentration = self.get_prior_angle_concentration(depth=self.depth+1) return mc_angle_logp_val_and_grad_wrt_parent(child_alpha, alpha, concentration)[1] - def compute_state_prior_grad(self, psi, parent_psi, alpha): + def compute_state_prior_grad(self, psi, parent_psi, alpha, event): """Gradient of logp(psi|parent_psi,new_alpha) wrt this psi""" log_std = jnp.log(jnp.sqrt(self.node_hyperparams['loc_variance'])) - radius = self.node_hyperparams['loc_mean'] - return mc_loc_logp_val_and_grad(psi, parent_psi, alpha, log_std, radius)[1] + return mc_loc_logp_val_and_grad(psi, parent_psi, alpha, log_std, event)[1] - def compute_state_prior_child_grad(self, child_psi, psi, child_alpha): - """Gradient of logp(child_psi|psi,child_alpha) wrt this psi""" + def compute_state_prior_child_grad(self, child_psi, psi, child_alpha, child_event): + """Gradient of logp(child_psi|psi,child_alpha,child_event) wrt this psi""" log_std = jnp.log(jnp.sqrt(self.node_hyperparams['loc_variance'])) - radius = self.node_hyperparams['loc_mean'] - return mc_loc_logp_val_and_grad_wrt_parent(child_psi, psi, child_alpha, log_std, radius)[1] + return mc_loc_logp_val_and_grad_wrt_parent(child_psi, psi, child_alpha, log_std, child_event)[1] - def compute_root_state_prior_child_grad(self, child_psi, psi, child_alpha): + def compute_root_state_prior_child_grad(self, child_psi, psi, child_alpha, child_event): """Gradient of logp(child_psi|psi,child_alpha) wrt this psi""" log_std = jnp.log(jnp.sqrt(self.node_hyperparams['loc_variance'])) - radius = self.node_hyperparams['root_loc_mean'] - return mc_loc_logp_val_and_grad_wrt_parent(child_psi, psi, child_alpha, log_std, radius)[1] + return mc_loc_logp_val_and_grad_wrt_parent(child_psi, psi, child_alpha, log_std, child_event)[1] - def compute_state_prior_grad_wrt_direction(self, psi, parent_psi, alpha): + def compute_state_prior_grad_wrt_direction(self, psi, parent_psi, alpha, event): """Gradient of logp(psi|parent_psi,alpha) wrt this alpha""" log_std = jnp.log(jnp.sqrt(self.node_hyperparams['loc_variance'])) - radius = self.node_hyperparams['loc_mean'] - return mc_loc_logp_val_and_grad_wrt_angle(psi, parent_psi, alpha, log_std, radius)[1] + return mc_loc_logp_val_and_grad_wrt_angle(psi, parent_psi, alpha, log_std, event)[1] + + def compute_state_prior_grad_wrt_event(self, psi, parent_psi, alpha, event): + """Gradient of logp(psi|parent_psi,alpha) wrt this event""" + log_std = jnp.log(jnp.sqrt(self.node_hyperparams['loc_variance'])) + return mc_loc_logp_val_and_grad_wrt_event(psi, parent_psi, alpha, log_std, event)[1] + + def compute_event_prior_grad(self, event): + """Gradient of logp(event|parent_psi,new_alpha) wrt this psi""" + event_mean = self.node_hyperparams['event_mean'] + event_concentration = self.node_hyperparams['event_concentration'] + return mc_event_logp_val_and_grad(event, event_mean, event_concentration)[1] def compute_direction_entropy_grad(self): """Gradient of logq(alpha) wrt this alpha""" @@ -676,6 +720,12 @@ def compute_state_entropy_grad(self): log_std = self.variational_parameters['kernel']['state']['log_std'] return loc_logq_val_and_grad(mu, log_std)[1] + def compute_event_entropy_grad(self): + """Gradient of logq(mu) wrt this mu""" + log_alpha = self.variational_parameters['kernel']['event']['log_alpha'] + log_beta = self.variational_parameters['kernel']['event']['log_beta'] + return event_logq_val_and_grad(log_alpha, log_beta)[1] + def compute_ll_state_grad(self, x, weights, psi): """Gradient of logp(x|psi,noise) wrt this psi""" log_std = jnp.log(jnp.sqrt(self.node_hyperparams['obs_variance'])) @@ -715,6 +765,20 @@ def update_direction_params(self, direction_params_grad, direction_sample_grad, angle_log_kappa_grad = mc_grad + direction_params_entropy_grad[1] self.variational_parameters['kernel']['direction']['log_kappa'] += angle_log_kappa_grad * step_size + def update_event_params(self, event_params_grad, event_sample_grad, event_params_entropy_grad, step_size=0.001): + param = 'log_alpha' + param_idx = 0 + + mc_grad = jnp.mean(event_params_grad[param_idx] * event_sample_grad, axis=0) + g = mc_grad + event_params_entropy_grad[param_idx] + self.variational_parameters['kernel']['event'][param] += g * step_size + + param = 'log_beta' + param_idx = 1 + mc_grad = jnp.mean(event_params_grad[param_idx] * event_sample_grad, axis=0) + g = mc_grad + event_params_entropy_grad[param_idx] + self.variational_parameters['kernel']['event'][param] += g * step_size + def update_state_params(self, state_params_grad, state_sample_grad, state_params_entropy_grad, step_size=0.001): mc_grad = jnp.mean(state_params_grad[0] * state_sample_grad, axis=0) loc_mean_grad = mc_grad + state_params_entropy_grad[0] @@ -858,4 +922,55 @@ def update_direction_adaptive(self, direction_params_grad, direction_sample_grad self.variational_parameters['kernel']['direction']['log_kappa'] += step_size * mhat / (jnp.sqrt(vhat) + eps) states = (state1, state2) - self.direction_states = states \ No newline at end of file + self.direction_states = states + + def initialize_event_states(self): + m = jnp.zeros((1,)) + v = jnp.zeros((1,)) + state1 = (m,v) + m = jnp.zeros((1,)) + v = jnp.zeros((1,)) + state2 = (m,v) + states = (state1, state2) + return states + + def update_event_adaptive(self, event_params_grad, event_sample_grad, event_params_entropy_grad, i, b1=0.9, + b2=0.999, eps=1e-8, step_size=0.001): + states = self.event_states + + param = 'log_alpha' + param_idx = 0 + mc_grad = jnp.mean(event_params_grad[param_idx] * event_sample_grad, axis=0) + param_grad = mc_grad + event_params_entropy_grad[param_idx] + + m, v = states[param_idx] + m = (1 - b1) * param_grad + b1 * m # First moment estimate. + v = (1 - b2) * jnp.square(param_grad) + b2 * v # Second moment estimate. + mhat = m / (1 - jnp.asarray(b1, m.dtype) ** (i + 1)) # Bias correction. + vhat = v / (1 - jnp.asarray(b2, m.dtype) ** (i + 1)) + state1 = (m, v) + self.variational_parameters['kernel']['event'][param] += step_size * mhat / (jnp.sqrt(vhat) + eps) + + param = 'log_beta' + param_idx = 1 + mc_grad = jnp.mean(event_params_grad[param_idx] * event_sample_grad, axis=0) + param_grad = mc_grad + event_params_entropy_grad[param_idx] + + m, v = states[param_idx] + m = (1 - b1) * param_grad + b1 * m # First moment estimate. + v = (1 - b2) * jnp.square(param_grad) + b2 * v # Second moment estimate. + mhat = m / (1 - jnp.asarray(b1, m.dtype) ** (i + 1)) # Bias correction. + vhat = v / (1 - jnp.asarray(b2, m.dtype) ** (i + 1)) + state2 = (m, v) + self.variational_parameters['kernel']['event'][param] += step_size * mhat / (jnp.sqrt(vhat) + eps) + + states = (state1, state2) + self.event_states = states + + + def update_event_and_angle(self): + parent_state = self.parent().variational_parameters['kernel']['state']['mean'] + this_state = self.variational_parameters['kernel']['state']['mean'] + direction_mean = jnp.arctan((this_state[0] - parent_state[0]) / (this_state[1] - parent_state[1])) + event_mean = (this_state[0] - parent_state[0]) / jnp.cos(direction_mean) + \ No newline at end of file diff --git a/scatrex/models/trajectory/node_opt.py b/scatrex/models/trajectory/node_opt.py index 756b431..b3685c8 100644 --- a/scatrex/models/trajectory/node_opt.py +++ b/scatrex/models/trajectory/node_opt.py @@ -8,6 +8,13 @@ def sample_angle(key, mu, log_kappa): # univariate: one sample sample_angle_val_and_grad = jax.vmap(jax.value_and_grad(sample_angle, argnums=(1,2)), in_axes=(None, 0, 0)) # per-dimension val and grad mc_sample_angle_val_and_grad = jax.jit(jax.vmap(sample_angle_val_and_grad, in_axes=(0,None,None))) # Multiple sample value_and_grad +@jax.jit +def sample_event(key, log_alpha, log_beta): # univariate: one sample + return tfd.Gamma(jnp.exp(log_alpha), jnp.exp(log_beta)).sample(seed=key) +sample_event_val_and_grad = jax.vmap(jax.value_and_grad(sample_event, argnums=(1,2)), in_axes=(None, 0, 0)) # per-dimension val and grad +mc_sample_event_val_and_grad = jax.jit(jax.vmap(sample_event_val_and_grad, in_axes=(0,None,None))) # Multiple sample value_and_grad + + @jax.jit def sample_loc(key, mu, log_std): # univariate: one sample return tfd.Normal(mu, jnp.exp(log_std)).sample(seed=key) @@ -28,21 +35,36 @@ def angle_logq(mu, log_kappa): return jnp.sum(tfd.VonMises(mu, jnp.exp(log_kappa)).entropy()) angle_logq_val_and_grad = jax.jit(jax.value_and_grad(angle_logq, argnums=(0,1))) # Take grad wrt to parameters +@jax.jit +def event_logp(this_event, mean, concentration): # single sample + return jnp.sum(tfd.Gamma(concentration, concentration / mean).log_prob(this_event)) +event_logp_val_and_grad = jax.jit(jax.value_and_grad(event_logp, argnums=0)) # Take grad wrt to this +mc_event_logp_val_and_grad = jax.jit(jax.vmap(event_logp_val_and_grad, in_axes=(0,None,None))) # Multiple sample value_and_grad + +@jax.jit +def event_logq(log_alpha, log_beta): + return jnp.sum(tfd.Gamma(jnp.exp(log_alpha), jnp.exp(log_beta)).entropy()) +event_logq_val_and_grad = jax.jit(jax.value_and_grad(event_logq, argnums=(0,1))) # Take grad wrt to parameters + @jax.jit def loc_logp(this_loc, parent_loc, this_angle, log_std, radius): # single sample mean = parent_loc + jnp.hstack([jnp.cos(this_angle)*radius, jnp.sin(this_angle)*radius]) # Use samples from parent return jnp.sum(tfd.Normal(mean, jnp.exp(log_std)).log_prob(this_loc)) # sum across dimensions loc_logp_val = jax.jit(loc_logp) -mc_loc_logp_val = jax.jit(jax.vmap(loc_logp_val, in_axes=(0,0,0, None, None))) # Multiple sample +mc_loc_logp_val = jax.jit(jax.vmap(loc_logp_val, in_axes=(0,0,0, None, 0))) # Multiple sample loc_logp_val_and_grad = jax.jit(jax.value_and_grad(loc_logp, argnums=0)) # Take grad wrt to this -mc_loc_logp_val_and_grad = jax.jit(jax.vmap(loc_logp_val_and_grad, in_axes=(0,0,0, None, None))) # Multiple sample value_and_grad +mc_loc_logp_val_and_grad = jax.jit(jax.vmap(loc_logp_val_and_grad, in_axes=(0,0,0, None, 0))) # Multiple sample value_and_grad loc_logp_val_and_grad_wrt_parent = jax.jit(jax.value_and_grad(loc_logp, argnums=1)) # Take grad wrt to parent -mc_loc_logp_val_and_grad_wrt_parent = jax.jit(jax.vmap(loc_logp_val_and_grad_wrt_parent, in_axes=(0,0,0, None, None))) # Multiple sample value_and_grad +mc_loc_logp_val_and_grad_wrt_parent = jax.jit(jax.vmap(loc_logp_val_and_grad_wrt_parent, in_axes=(0,0,0, None, 0))) # Multiple sample value_and_grad loc_logp_val_and_grad_wrt_angle = jax.jit(jax.value_and_grad(loc_logp, argnums=2)) # Take grad wrt to angle -mc_loc_logp_val_and_grad_wrt_angle = jax.jit(jax.vmap(loc_logp_val_and_grad_wrt_angle, in_axes=(0,0,0, None, None))) # Multiple sample value_and_grad +mc_loc_logp_val_and_grad_wrt_angle = jax.jit(jax.vmap(loc_logp_val_and_grad_wrt_angle, in_axes=(0,0,0, None, 0))) # Multiple sample value_and_grad + +loc_logp_val_and_grad_wrt_event = jax.jit(jax.value_and_grad(loc_logp, argnums=4)) # Take grad wrt to event +mc_loc_logp_val_and_grad_wrt_event = jax.jit(jax.vmap(loc_logp_val_and_grad_wrt_event, in_axes=(0,0,0, None, 0))) # Multiple sample value_and_grad + @jax.jit def loc_logq(mu, log_std): diff --git a/scatrex/models/trajectory/tree.py b/scatrex/models/trajectory/tree.py index 7ba9268..2a44937 100644 --- a/scatrex/models/trajectory/tree.py +++ b/scatrex/models/trajectory/tree.py @@ -8,18 +8,19 @@ def __init__(self, **kwargs): super(TrajectoryTree, self).__init__(**kwargs) self.node_constructor = TrajectoryNode - def sample_kernel(self, parent_params, mean_dist=1., angle_concentration=1., loc_variance=.1, seed=42, depth=1., **kwargs): + def sample_kernel(self, parent_params, event_mean=1., event_concentration=1., angle_concentration=1., loc_variance=.1, seed=42, depth=1., **kwargs): rng = np.random.default_rng(seed=seed) parent_loc = parent_params[0] parent_angle = parent_params[1] angle_concentration = angle_concentration * depth sampled_angle = rng.vonmises(parent_angle, angle_concentration) - sampled_loc = rng.normal(mean_dist, loc_variance) - sampled_loc = parent_loc + np.array([np.cos(sampled_angle)*np.abs(sampled_loc), np.sin(sampled_angle)*np.abs(sampled_loc)]) - return [sampled_loc, sampled_angle] + sampled_event = rng.gamma(event_concentration, event_mean/event_concentration) + loc_mean = parent_loc + np.array([np.cos(sampled_angle)*sampled_event, np.sin(sampled_angle)*sampled_event]) + sampled_loc = rng.normal(loc_mean, loc_variance) + return [sampled_loc, sampled_angle, sampled_event] def sample_root(self, **kwargs): - return [np.array([0., 0.]), 0.] + return [np.array([0., 0.]), 0., 0.] def get_param_size(self): return self.tree["param"][0].size diff --git a/scatrex/ntssb/node.py b/scatrex/ntssb/node.py index 343954a..8b95ae0 100644 --- a/scatrex/ntssb/node.py +++ b/scatrex/ntssb/node.py @@ -232,13 +232,11 @@ def get_top_obs(self, q=70, idx=None): top_obs = idx[np.where(lls > np.percentile(lls, q=q))[0]] return top_obs - def reset_variational_state(self, **kwargs): - return - def reset_opt(self): # For adaptive optimization self.direction_states = self.initialize_direction_states() self.state_states = self.initialize_state_states() + self.event_states = self.initialize_event_states() def init_new_node_kernel(self, **kwargs): return \ No newline at end of file diff --git a/scatrex/ntssb/ntssb.py b/scatrex/ntssb/ntssb.py index 90c2fca..fd6a2a5 100644 --- a/scatrex/ntssb/ntssb.py +++ b/scatrex/ntssb/ntssb.py @@ -1201,7 +1201,7 @@ def compute_elbo_batch(self, batch_idx=None): idx = self.batch_indices[batch_idx] def descend(root, depth=0, local_contrib=0, global_contrib=0, psi_priors=None): # Traverse inner TSSB - subtree_ll_contrib, subtree_ass_contrib, subtree_node_contrib = root['node'].compute_elbo(idx) + subtree_ll_contrib, subtree_ass_contrib, subtree_node_contrib = root['node'].compute_elbo_batch(idx) ll_contrib = subtree_ll_contrib * root['node'].variational_parameters['q_c'][idx] # Assignments @@ -1244,7 +1244,7 @@ def descend(root, depth=0, local_contrib=0, global_contrib=0, psi_priors=None): # Auxiliary quantities ## Branches E_log_psi = E_log_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) - child['node'].variational_parameters['E_log_phi'] = E_log_psi + sum_E_log_1_psi + child['node'].variational_parameters['E_log_phi'] = root['node'].variational_parameters['E_log_phi'] + E_log_psi + sum_E_log_1_psi E_log_1_psi = E_log_1_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) sum_E_log_1_psi += E_log_1_psi @@ -1306,7 +1306,7 @@ def descend(root, depth=0, local_contrib=0, global_contrib=0, psi_priors=None): # Auxiliary quantities ## Branches E_log_psi = E_log_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) - child['node'].variational_parameters['E_log_phi'] = E_log_psi + sum_E_log_1_psi + child['node'].variational_parameters['E_log_phi'] = root['node'].variational_parameters['E_log_phi'] + E_log_psi + sum_E_log_1_psi E_log_1_psi = E_log_1_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) sum_E_log_1_psi += E_log_1_psi @@ -1474,7 +1474,7 @@ def descend(root, local_grads=None): sum_E_log_1_psi = 0. for child in root['children']: E_log_psi = E_log_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) - child['node'].variational_parameters['E_log_phi'] = E_log_psi + sum_E_log_1_psi + child['node'].variational_parameters['E_log_phi'] = root['node'].variational_parameters['E_log_phi'] + E_log_psi + sum_E_log_1_psi E_log_1_psi = E_log_1_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) sum_E_log_1_psi += E_log_1_psi @@ -2888,13 +2888,14 @@ def descend(root): descend(child) descend(self.root) - def show_tree(self, **kwargs): + def show_tree(self, ax=None, **kwargs): self.set_learned_parameters() self.set_node_names() self.set_expected_weights() self.assign_samples() self.set_ntssb_colors() tree = self.get_param_dict() - plt.figure(figsize=(4,4)) - ax = plt.gca() + if ax is None: + plt.figure(figsize=(4,4)) + ax = plt.gca() plot_full_tree(tree, ax=ax, node_size=101, **kwargs) \ No newline at end of file diff --git a/scatrex/ntssb/search.py b/scatrex/ntssb/search.py index 70d96a4..0b17882 100644 --- a/scatrex/ntssb/search.py +++ b/scatrex/ntssb/search.py @@ -3,6 +3,7 @@ from tqdm.auto import trange from time import time import matplotlib.pyplot as plt +import pandas as pd from ..utils.math_utils import * @@ -28,6 +29,92 @@ def __init__(self, ntssb): self.traces["n_nodes"] = [] self.traces["elbos"] = [] self.best_tree = deepcopy(self.tree) + self.mcmc = dict() + + def run_mcmc(self, n_samples=100, n_burnin=10, n_thin=10, store_trees=False, memoized=True, n_opt_steps=50, seed=42, **pr_kwargs): + """ + Run MCMC chain for each TSSB where we proposed prune-reattach moves, update the marginal likelihood of the tree and accept/reject with metropolis-hastings acceptance ratio. + Run each TSSB in parallel? + """ + # Do not store the tree objects, just store the current and best tree objects, and keep the trace of number of times each node is parent of every other node, and the node_dict traces + # For fixed roots and fixed node-subtree attachments... + for ref_tssb in self.best_tree.get_tree_roots(): # Parallelize here across different processes... Maybe one GPU per chain for the param opts + tssb = deepcopy(ref_tssb["node"]) + tssb.compute_elbo(memoized=memoized) + proposed_tssb = deepcopy(tssb) + if tssb.label not in self.mcmc: + self.mcmc[tssb.label] = dict( + elbos=[], + node_dicts=[], + trees=[], + best_tree=deepcopy(tssb), + ar=0. + ) + node_dict = tssb.get_node_dict() + nodes = node_dict.keys() + self.mcmc[tssb.label]["posterior_counts"] = pd.DataFrame(index=nodes, columns=nodes, data=np.zeros((len(nodes), len(nodes))).astype(int)) #dict(zip(nodes, [dict(zip(nodes, [0] * len(nodes)))] * len(nodes))) + self.mcmc[tssb.label]["posterior_freqs"] = pd.DataFrame(index=nodes, columns=nodes, data=np.zeros((len(nodes), len(nodes))).astype(float)) + + if tssb.n_nodes <= 2: + continue + + i = 0 + best_i = 0 + n_accepted = 0 + key = jax.random.PRNGKey(seed) + t = trange(n_samples, desc=f'Running MCMC on tree {tssb.label}', leave=True) + while i < n_samples: + # Sample + key, valid, accepted, proposed_tssb, tssb = self.prune_reattach(key, proposed_tssb, tssb, update_names=False, memoized=memoized, n_steps=n_opt_steps, **pr_kwargs) + if not valid: + continue + + # MCMC info + if accepted: + n_accepted += 1 + node_dict = tssb.get_node_dict() + self.mcmc[tssb.label]["elbos"].append(tssb.elbo) + self.mcmc[tssb.label]["node_dicts"].append(node_dict) + if tssb.elbo > self.mcmc[tssb.label]["best_tree"].elbo: + best_i = i + self.mcmc[tssb.label]["best_tree"] = deepcopy(tssb) + if store_trees: + self.mcmc[tssb.label]["trees"].append(deepcopy(tssb)) + + if i > n_burnin: + self.mcmc[tssb.label]["ar"] = n_accepted / i + t.set_description(f'MCMC for {tssb.label}: iteration: {i}, acceptance ratio: {self.mcmc[tssb.label]["ar"]:0.4g}, best: {self.mcmc[tssb.label]["best_tree"].elbo:0.4g} (at {best_i})') + + # Compute tree statistics from sample + if i % n_thin == 0: + for node_src in node_dict: + for node_prt in node_dict: + if node_dict[node_src]['parent'] == node_prt: + self.mcmc[tssb.label]["posterior_counts"].loc[node_src, node_prt] += 1 + + i += 1 + t.update() + t.refresh() + + # Update names in table to use the ones in the best tree + old_to_new = self.mcmc[tssb.label]["best_tree"].set_node_names(root_name=tssb.label, return_map=True) + self.mcmc[tssb.label]["posterior_counts"] = self.mcmc[tssb.label]["posterior_counts"].rename(columns=old_to_new, index=old_to_new) + + # Normalize + self.mcmc[tssb.label]["posterior_freqs"] = self.mcmc[tssb.label]["posterior_counts"]/np.sum(self.mcmc[tssb.label]["posterior_counts"],axis=1).values[:,None] + + logger.info(f"MCMC for {tssb.label} completed") + + # Re-assemble NTSSB from the best TSSBs + def descend(root): + for tssb_label in self.mcmc: + if root["label"] == tssb_label: + root["node"] = deepcopy(self.mcmc[tssb_label]["best_tree"]) + for child in root['children']: + descend(child) + break + descend(self.best_tree.root) + def run_search(self, n_iters=10, n_epochs=10, mc_samples=10, step_size=0.01, moves_per_tssb=1, pr_freq=0., global_freq=0, memoized=True, update_roots=True, seed=42, swap_freq=0, update_outer_ass=True): """ @@ -54,7 +141,8 @@ def run_search(self, n_iters=10, n_epochs=10, mc_samples=10, step_size=0.01, mov if pr_freq != 0 and i % pr_freq == 0: # Do prune-reattach move # Prune and reattach: traverse the tree and propose pruning nodes and reattaching somewhere else inside their TSSB - self.prune_reattach(subkey, moves_per_tssb=moves_per_tssb) + self.pr_merge(subkey, n_epochs=n_epochs, memoized=memoized, mc_samples=mc_samples, step_size=step_size, moves_per_tssb=moves_per_tssb, update_roots=update_roots, update_globals=update_globals, + update_outer_ass=update_outer_ass) else: # Birth: traverse the tree and spawn a bunch of nodes (quick and helps escape local optima) @@ -115,18 +203,38 @@ def birth_merge(self, key, moves_per_tssb=1, n_epochs=100, update_roots=False, m update_outer_ass=False): # Birth: traverse the tree and spawn a bunch of nodes (quick and helps escape local optima) self.birth(key, moves_per_tssb=moves_per_tssb) - + self.traces['tree'].append(deepcopy(self.tree)) # Update parameters in n_epochs passes through the data, interleaving node updates with local batch updates - self.tree.learn_params(int(n_epochs/2), update_roots=update_roots, mc_samples=mc_samples, - step_size=step_size, memoized=memoized, update_outer_ass=update_outer_ass, ass_anneal=.1) - self.tree.learn_params(int(n_epochs/2), update_roots=update_roots, mc_samples=mc_samples, - step_size=step_size, memoized=memoized, update_outer_ass=update_outer_ass, ass_anneal=1.) + self.tree.learn_params(int(n_epochs), update_roots=update_roots, mc_samples=mc_samples, + step_size=step_size, memoized=memoized, update_outer_ass=update_outer_ass, ass_anneal=1.) + # self.tree.learn_params(int(n_epochs/2), update_roots=update_roots, mc_samples=mc_samples, + # step_size=step_size, memoized=memoized, update_outer_ass=update_outer_ass, ass_anneal=1.) self.tree.compute_elbo(memoized=memoized) + self.traces['tree'].append(deepcopy(self.tree)) self.proposed_tree = deepcopy(self.tree) # Merge: traverse the tree and propose merges and accept/reject based on their summary statistics (reliable) - self.merge(key, moves_per_tssb=moves_per_tssb, memoized=memoized, update_globals=update_globals, + self.merge(key, moves_per_tssb=int(moves_per_tssb*10), memoized=memoized, update_globals=update_globals, n_epochs=n_epochs, mc_samples=mc_samples, step_size=step_size) + self.traces['tree'].append(deepcopy(self.tree)) + + def pr_merge(self, key, moves_per_tssb=1, n_epochs=100, update_roots=False, mc_samples=10, step_size=0.01, memoized=True, update_globals=False, + update_outer_ass=False): + # PR: move nodes around and accept + changed = self.prune_reattach(key, moves_per_tssb=moves_per_tssb, n_epochs=n_epochs, mc_samples=mc_samples, step_size=step_size) + # if changed: + # self.traces['tree'].append(deepcopy(self.tree)) + # # Update parameters in n_epochs passes through the data, interleaving node updates with local batch updates + # self.tree.learn_params(int(n_epochs), update_roots=update_roots, mc_samples=mc_samples, + # step_size=step_size, memoized=memoized, update_outer_ass=update_outer_ass, ass_anneal=1.) + # self.tree.compute_elbo(memoized=memoized) + # self.traces['tree'].append(deepcopy(self.tree)) + # self.proposed_tree = deepcopy(self.tree) + + # # Merge: traverse the tree and propose merges and accept/reject based on their summary statistics (reliable) + # self.merge(key, moves_per_tssb=int(moves_per_tssb*2), memoized=memoized, update_globals=update_globals, + # n_epochs=n_epochs, mc_samples=mc_samples, step_size=step_size) + # self.traces['tree'].append(deepcopy(self.tree)) def birth(self, key, moves_per_tssb=1): """ @@ -134,11 +242,13 @@ def birth(self, key, moves_per_tssb=1): """ n_births = self.proposed_tree.n_nodes * moves_per_tssb targets = [] - for _ in range(n_births): - key, subkey = jax.random.split(key) - u = jax.random.uniform(subkey) - target = self.proposed_tree.get_node(u, key=subkey, uniform=True, variational=True) - targets.append(target) + for root in self.proposed_tree.get_tree_roots(): + tssb = root['node'] + for _ in range(moves_per_tssb): + key, subkey = jax.random.split(key) + _, _, target = tssb.find_node_uniform(subkey, include_leaves=True, return_parent=False) + # target = self.proposed_tree.get_node(u, key=subkey, uniform=True, variational=True) + targets.append(target) for target in targets: key, subkey = jax.random.split(key) @@ -193,96 +303,181 @@ def merge_root(self, key, memoized=True, n_epochs=10, **learn_kwargs): def merge(self, key, moves_per_tssb=1, memoized=True, update_globals=False, n_epochs=10, **learn_kwargs): """ - Traverse the trees and propose and accept/reject merges as we go using local suff stats + Traverse the trees and propose and accept/reject merges as we go using local suff stats. + Parallelize over TSSBs """ - n_merges = int(0.7 * self.proposed_tree.n_total_nodes * moves_per_tssb * 2) - if update_globals: - n_merges = int(0.7 * self.proposed_tree.n_total_nodes * moves_per_tssb) - for _ in range(n_merges): - key, subkey = jax.random.split(key) - u = jax.random.uniform(subkey) - parent = self.proposed_tree.get_node(u, key=subkey, uniform=True, include_leaves=False) # get non-leaf node, without accounting for weights - tssb = parent['node'].tssb - # Choose either couple of children to merge or a child to merge with parent - n_children = len(parent['children']) - if n_children == 0: - continue - if n_children > 1: - # Choose - if jax.random.bernoulli(subkey, 0.5) == 1: - # Merge sibling-sibling - # Choose a child - source_idx, target_idx = jax.random.choice(subkey, n_children, shape=(2,), replace=False) - # Choose most similar sibling - source = parent['children'][source_idx] - target = parent['children'][target_idx] - else: - # Merge parent-child - # Choose most similar child - source_idx = jax.random.choice(subkey, n_children) - source = parent['children'][source_idx] - target = parent - else: - # Merge parent-child - source = parent['children'][0] - target = parent - - source_label = source['node'].label - target_label = target['node'].label - # print(f"Will merge {source_label} to {target_label}") - # Merge, updating suff stats - tssb.merge_nodes(parent, source, target) - # Update node sticks - tssb.update_stick_params(parent) - # Update pivot probs - tssb.update_pivot_probs() - # Compute ELBO of new tree - self.proposed_tree.compute_elbo(memoized=memoized) - # print(f"{self.tree.elbo} -> {self.proposed_tree.elbo}") - # Update if ELBO improved - if self.proposed_tree.elbo > self.tree.elbo: - # print(f"Merged {source_label} to {target_label}") - self.tree = deepcopy(self.proposed_tree) - else: - # Maybe update other locals - if update_globals: - # print("Inference") - # print(self.tree.elbo) - self.proposed_tree.learn_params(n_epochs, memoized=memoized, **learn_kwargs) + proposed_tssbs = self.proposed_tree.get_tree_roots() + for tssb_label in [a['label'] for a in proposed_tssbs]: + for _ in range(moves_per_tssb): + # Get tssb + proposed_tssbs = self.proposed_tree.get_tree_roots() + proposed_tssbs = dict(zip([a['label'] for a in proposed_tssbs], [a['node'] for a in proposed_tssbs])) + tssb = proposed_tssbs[tssb_label] + if tssb.n_nodes > 1: + key, subkey = jax.random.split(key) + # u = jax.random.uniform(subkey) + # parent = self.proposed_tree.get_node(u, key=subkey, uniform=True, include_leaves=False) # get non-leaf node, without accounting for weights + _, _, parent = tssb.find_node_uniform(subkey, include_leaves=False) + # proposed_tssb = parent['node'].tssb + # Choose either couple of children to merge or a child to merge with parent + n_children = len(parent['children']) + if n_children == 0: + continue + if n_children > 1: + # Choose + if jax.random.bernoulli(subkey, 0.5) == 1: + # Merge sibling-sibling + # Choose a child + source_idx, target_idx = jax.random.choice(subkey, n_children, shape=(2,), replace=False) + # Choose most similar sibling + source = parent['children'][source_idx] + target = parent['children'][target_idx] + else: + # Merge parent-child + # Choose most similar child + source_idx = jax.random.choice(subkey, n_children) + source = parent['children'][source_idx] + target = parent + else: + # Merge parent-child + source = parent['children'][0] + target = parent + + source_label = source['node'].label + target_label = target['node'].label + # print(f"Will merge {source_label} to {target_label}") + # Merge, updating suff stats + tssb.merge_nodes(parent, source, target) + # Update node sticks + tssb.update_stick_params(parent) + # Update pivot probs + tssb.update_pivot_probs() + # Compute ELBO of new tree self.proposed_tree.compute_elbo(memoized=memoized) - # print(self.proposed_tree.elbo) + # print(f"{self.tree.elbo} -> {self.proposed_tree.elbo}") + # Update if ELBO improved if self.proposed_tree.elbo > self.tree.elbo: + # print(f"Merged {source_label} to {target_label}") self.tree = deepcopy(self.proposed_tree) else: - self.proposed_tree = deepcopy(self.tree) + # Maybe update other locals + if update_globals: + # print("Inference") + # print(self.tree.elbo) + self.proposed_tree.learn_params(n_epochs, memoized=memoized, **learn_kwargs) + self.proposed_tree.compute_elbo(memoized=memoized) + # print(self.proposed_tree.elbo) + if self.proposed_tree.elbo > self.tree.elbo: + self.tree = deepcopy(self.proposed_tree) + else: + self.proposed_tree = deepcopy(self.tree) + else: + self.proposed_tree = deepcopy(self.tree) + + def prune_reattach(self, key, proposed_tssb, tssb, n_tries=5, memoized=True, update_names=True, **learn_kwargs): + changed = False + accepted = False + if tssb.n_nodes > 1: + for _ in range(n_tries): + key, subkey = jax.random.split(key) + _, source_path, source, source_parent = proposed_tssb.find_node_uniform(subkey, include_leaves=True, return_parent=True) + if len(source_path) == 0: # Can't do root + continue + + key, subkey = jax.random.split(key) + _, target_path, target = proposed_tssb.find_node_uniform(subkey, include_leaves=True) + if len(target_path) >= len(source_path): + if source_path == target_path[:len(source_path)]: # Can't swap parent-child + continue + + if target == source_parent: # Don't re-attach to same place + continue + + # print(source['node'].label, target['node'].label) + proposed_tssb.prune_reattach(source_parent, source, target, update_names=update_names) + + # Quick parameter update + proposed_tssb.update_stick_params(memoized=memoized) + proposed_tssb.update_node_kernel_params(key, root=source, memoized=memoized, update_state=False, return_trace=False, **learn_kwargs) + proposed_tssb.update_pivot_probs() + + proposed_tssb.compute_elbo(memoized=memoized) + + # MH acceptance probability + key, subkey = jax.random.split(key) + u = jax.random.uniform(key) + + if u < jnp.exp(proposed_tssb.elbo - tssb.elbo): + tssb = deepcopy(proposed_tssb) + accepted = True else: - self.proposed_tree = deepcopy(self.tree) - - - def prune_reattach(self, moves_per_tssb=1): - """ - Prune subtree and reattach somewhere else within the same TSSB - """ - n_prs = self.proposed_tree.n_nodes * moves_per_tssb - for _ in range(n_prs): - key, subkey = jax.random.split(key) - u = jax.random.uniform(subkey) - parent, source, target = self.proposed_tree.get_nodes(u, n_nodes=2) # find two nodes in the same TSSB - tssb = parent['node'].tssb - tssb.prune_reattach(parent, source, target) - # Update node stick parameters to account for changed mass distribution - tssb.update_stick_params(parent) - tssb.update_stick_params(target) - - # Optimize kernel parameters of root of moved subtree - tssb.update_node_params(source) - - # Compute ELBO of new tree - self.proposed_tree.compute_elbo() - # Update if ELBO improved - if self.proposed_tree.elbo > self.tree.elbo: - self.tree = self.proposed_tree - + proposed_tssb = deepcopy(tssb) + + changed = True + + break + + return key, changed, accepted, proposed_tssb, tssb + + + # def prune_reattach(self, key, moves_per_tssb=1, memoized=True, n_epochs=10, **learn_kwargs): + # """ + # Prune subtree and reattach somewhere else within the same TSSB. + # """ + # changed = False + # for _ in range(5): + # for root in self.proposed_tree.get_tree_roots(): + # tssb = root['node'] + # if tssb.n_nodes > 1: + # for _ in range(moves_per_tssb): + # key, subkey = jax.random.split(key) + # _, source_path, source, source_parent = tssb.find_node_uniform(subkey, include_leaves=True, return_parent=True) + # if len(source_path) == 0: # Can't do root + # continue + + # key, subkey = jax.random.split(key) + # _, target_path, target = tssb.find_node_uniform(subkey, include_leaves=True) + # if len(target_path) >= len(source_path): + # if source_path == target_path[:len(source_path)]: # Can't swap parent-child + # continue + + # if target == source_parent: # Don't re-attach to same place + # continue + + # self.traces['tree'].append(deepcopy(self.proposed_tree)) + # print("Doing prune reattach!") + # print(source['node'].label, target['node'].label) + # tssb.prune_reattach(source_parent, source, target) + + # self.traces['tree'].append(deepcopy(self.proposed_tree)) + + # # Quick parameter update + # tssb.update_stick_params(memoized=memoized) + # tssb.update_node_kernel_params(key, root=source, memoized=memoized, n_steps=50, update_state=False, return_trace=False, **learn_kwargs) + + # # tssb.update_stick_params(memoized=memoized) + # # for i in range(n_epochs): + # # key, subkey = jax.random.split(key) + # # tssb.update_node_params(key, root=target, memoized=memoized, i=i, **learn_kwargs) + # self.proposed_tree.compute_elbo(memoized=memoized) + + # # MH acceptance probability + # key, subkey = jax.random.split(key) + # u = jax.random.uniform(key) + + # if u < jnp.exp(self.proposed_tree.elbo - self.tree.elbo): + # self.tree = deepcopy(self.proposed_tree) + # print("Accepted") + # else: + # self.proposed_tree = deepcopy(self.tree) + + # self.traces['tree'].append(deepcopy(self.tree)) + + # changed = True + # if changed: + # break + + # return changed def plot_traces( self, diff --git a/scatrex/ntssb/tssb.py b/scatrex/ntssb/tssb.py index f46f378..39fc82a 100644 --- a/scatrex/ntssb/tssb.py +++ b/scatrex/ntssb/tssb.py @@ -87,6 +87,7 @@ def __init__( self.ew = -1e6 self.kl = -1e6 self._data = set() + self.elbo = 0. self.n_nodes = 1 @@ -136,6 +137,21 @@ def descend(root, root_new): descend(self.root, param_dict) return param_dict + def get_node_dict(self): + self.node_dict = dict() + + def descend(node): + self.node_dict[node.label] = dict() + if node.parent() is not None: + self.node_dict[node.label]["parent"] = node.parent().label + else: + self.node_dict[node.label]["parent"] = "NULL" + for child in list(node.children()): + descend(child) + + descend(self.root["node"]) + return self.node_dict + def add_datum(self, id): self._data.add(id) @@ -500,7 +516,35 @@ def merge_nodes(self, parent_root, source_root, target_root): self.n_nodes -= 1 - def compute_elbo(self, idx): + def prune_reattach(self, parent_node_root, source_node_root, target_parent_root, update_names=True): + """ + TODO: Don't necessarily reattach as last child of target. Also for the births, maybe + """ + # Move subtree + source_node_root['node'].set_parent(target_parent_root['node']) + + # Update dict: copy dict into new parent + target_parent_root["children"].append(source_node_root) + target_parent_root["sticks"] = np.vstack([target_parent_root["sticks"], 1.0]) + + # Remove dict from previous parent + children_nodes = np.array([r['node'] for r in parent_node_root['children']]) + tokeep = np.where(children_nodes != source_node_root['node'])[0].astype(int).ravel() + parent_node_root["sticks"] = parent_node_root["sticks"][tokeep] + parent_node_root["children"] = list( + np.array(parent_node_root["children"])[tokeep] + ) + + if update_names: + self.set_node_names(root_name=self.label) + + def compute_elbo(self, memoized=True, batch_idx=None, **kwargs): + if memoized: + return self.compute_elbo_suff() + else: + return self.compute_elbo_batch(batch_idx) + + def compute_elbo_batch(self, idx): """ Compute the ELBO of the model in a tree traversal, abstracting away the likelihood and kernel specific functions for the model. The seed is used for MC sampling from the variational distributions for which Eq[logp] is not analytically @@ -580,7 +624,7 @@ def descend(root, depth=0, ll_contrib=0, ass_contrib=0, global_contrib=0): for child in root['children']: # Auxiliary quantities E_log_psi = E_log_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) - child['node'].variational_parameters['E_log_phi'] = E_log_psi + sum_E_log_1_psi + child['node'].variational_parameters['E_log_phi'] = root['node'].variational_parameters['E_log_phi'] + E_log_psi + sum_E_log_1_psi E_log_1_psi = E_log_1_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) sum_E_log_1_psi += E_log_1_psi @@ -593,7 +637,10 @@ def descend(root, depth=0, ll_contrib=0, ass_contrib=0, global_contrib=0): return ll_contrib, ass_contrib, global_contrib self.n_nodes = 0 - return descend(self.root) + ll_contrib, ass_contrib, global_contrib = descend(self.root) + + self.elbo = ll_contrib + ass_contrib + global_contrib + return ll_contrib, ass_contrib, global_contrib def compute_elbo_suff(self): """ @@ -672,7 +719,7 @@ def descend(root, depth=0, ll_contrib=0, ass_contrib=0, global_contrib=0): for child in root['children']: # Auxiliary quantities E_log_psi = E_log_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) - child['node'].variational_parameters['E_log_phi'] = E_log_psi + sum_E_log_1_psi + child['node'].variational_parameters['E_log_phi'] = root['node'].variational_parameters['E_log_phi'] + E_log_psi + sum_E_log_1_psi E_log_1_psi = E_log_1_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) sum_E_log_1_psi += E_log_1_psi @@ -685,7 +732,10 @@ def descend(root, depth=0, ll_contrib=0, ass_contrib=0, global_contrib=0): return ll_contrib, ass_contrib, global_contrib self.n_nodes = 0 - return descend(self.root) + ll_contrib, ass_contrib, global_contrib = descend(self.root) + + self.elbo = ll_contrib + ass_contrib + global_contrib + return ll_contrib, ass_contrib, global_contrib def update_sufficient_statistics(self, batch_idx=None): @@ -754,7 +804,7 @@ def descend(root, local_grads=None): sum_E_log_1_psi = 0. for child in root['children']: E_log_psi = E_log_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) - child['node'].variational_parameters['E_log_phi'] = E_log_psi + sum_E_log_1_psi + child['node'].variational_parameters['E_log_phi'] = root['node'].variational_parameters['E_log_phi'] + E_log_psi + sum_E_log_1_psi E_log_1_psi = E_log_1_beta(child['node'].variational_parameters['sigma_1'], child['node'].variational_parameters['sigma_2']) sum_E_log_1_psi += E_log_1_psi @@ -837,7 +887,7 @@ def descend(root, depth=0): root = self.root descend(root) - def update_node_params(self, key, root=None, memoized=True, step_size=0.0001, mc_samples=10, i=0, adaptive=True, **kwargs): + def update_node_params(self, key, root=None, memoized=True, step_size=0.0001, mc_samples=10, i=0, adaptive=True, update_state=True, **kwargs): """ Update variational parameters for kernels, sticks and pivots @@ -881,37 +931,51 @@ def descend(root): """ def descend(root, key, depth=0): direction_sample_grad = 0. + event_sample_grad = 0. state_sample_grad = 0. if depth != 0: key, sample_grad = root['node'].direction_sample_and_grad(key, n_samples=mc_samples) direction_curr_sample, direction_params_grad = sample_grad + key, sample_grad = root['node'].event_sample_and_grad(key, n_samples=mc_samples) + event_curr_sample, event_params_grad = sample_grad key, sample_grad = root['node'].state_sample_and_grad(key, n_samples=mc_samples) state_curr_sample, state_params_grad = sample_grad else: root['node'].sample_kernel(n_samples=mc_samples) direction_curr_sample = root['node'].get_direction_sample() - state_curr_sample = root['node'].get_state_sample() + event_curr_sample = root['node'].get_event_sample() + state_curr_sample = root['node'].get_state_sample() + if not update_state: + state_curr_sample = root['node'].get_state_sample() + + if depth != 0: direction_parent_sample = root["node"].parent().get_direction_sample() state_parent_sample = root["node"].parent().get_state_sample() direction_sample_grad += root["node"].compute_direction_prior_grad(direction_curr_sample, direction_parent_sample, state_parent_sample) - direction_sample_grad += root["node"].compute_state_prior_grad_wrt_direction(state_curr_sample, state_parent_sample, direction_curr_sample) + direction_sample_grad += root["node"].compute_state_prior_grad_wrt_direction(state_curr_sample, state_parent_sample, direction_curr_sample, event_curr_sample) + event_sample_grad += root["node"].compute_event_prior_grad(event_curr_sample) + event_sample_grad += root["node"].compute_state_prior_grad_wrt_event(state_curr_sample, state_parent_sample, direction_curr_sample, event_curr_sample) + direction_params_entropy_grad = root["node"].compute_direction_entropy_grad() - state_params_entropy_grad = root["node"].compute_state_entropy_grad() + event_params_entropy_grad = root["node"].compute_event_entropy_grad() + if update_state: + state_params_entropy_grad = root["node"].compute_state_entropy_grad() - if memoized: - state_sample_grad += root["node"].compute_ll_state_grad_suff(state_curr_sample) - else: - weights = root['node'].variational_parameters['q_z'] * self.variational_parameters['q_c'] - state_sample_grad += root["node"].compute_ll_state_grad(self.ntssb.data, weights, state_curr_sample) + if update_state: + if memoized: + state_sample_grad += root["node"].compute_ll_state_grad_suff(state_curr_sample) + else: + weights = root['node'].variational_parameters['q_z'] * self.variational_parameters['q_c'] + state_sample_grad += root["node"].compute_ll_state_grad(self.ntssb.data, weights, state_curr_sample) mass_down = 0 for child in root['children'][::-1]: - child_mass, direction_child_sample, state_child_sample = descend(child, key, depth=depth+1) + child_mass, direction_child_sample, state_child_sample, event_child_sample = descend(child, key, depth=depth+1) child['node'].variational_parameters['sigma_1'] = 1.0 + child_mass child['node'].variational_parameters['sigma_2'] = self.dp_gamma + mass_down @@ -919,14 +983,16 @@ def descend(root, key, depth=0): if depth != 0: direction_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_direction(direction_child_sample, direction_curr_sample, state_curr_sample) - state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(direction_child_sample, direction_curr_sample, state_curr_sample) - state_sample_grad += root["node"].compute_state_prior_child_grad(state_child_sample, state_curr_sample, direction_child_sample) + # state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(direction_child_sample, direction_curr_sample, state_curr_sample) + if update_state: + state_sample_grad += root["node"].compute_state_prior_child_grad(state_child_sample, state_curr_sample, direction_child_sample, event_child_sample) if depth != 0: for ii, child_root in enumerate(self.children_root_nodes): direction_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_direction(child_root.get_direction_sample(), direction_curr_sample, state_curr_sample) * root['node'].variational_parameters['q_rho'][ii] - state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(child_root.get_direction_sample(), direction_curr_sample, state_curr_sample) * root['node'].variational_parameters['q_rho'][ii] - state_sample_grad += root["node"].compute_root_state_prior_child_grad(child_root.get_state_sample(), state_curr_sample, child_root.get_direction_sample()) * root['node'].variational_parameters['q_rho'][ii] + # state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(child_root.get_direction_sample(), direction_curr_sample, state_curr_sample) * root['node'].variational_parameters['q_rho'][ii] + if update_state: + state_sample_grad += root["node"].compute_root_state_prior_child_grad(child_root.get_state_sample(), state_curr_sample, child_root.get_direction_sample(), child_root.get_event_sample()) * root['node'].variational_parameters['q_rho'][ii] if depth != 0: if adaptive and i == 0: @@ -942,18 +1008,31 @@ def descend(root, key, depth=0): key, sample_grad = root['node'].direction_sample_and_grad(key, n_samples=mc_samples) direction_curr_sample, _ = sample_grad - state_sample_grad += root["node"].compute_state_prior_grad(state_curr_sample, state_parent_sample, direction_curr_sample) - if adaptive: - root['node'].update_state_adaptive(state_params_grad, state_sample_grad, state_params_entropy_grad, - step_size=step_size, i=i) + root['node'].update_event_adaptive(event_params_grad, event_sample_grad, event_params_entropy_grad, + step_size=step_size, i=i) else: - root['node'].update_state_params(state_params_grad, state_sample_grad, state_params_entropy_grad, + root['node'].update_event_params(event_params_grad, event_sample_grad, event_params_entropy_grad, step_size=step_size) - key, sample_grad = root['node'].state_sample_and_grad(key, n_samples=mc_samples) - state_curr_sample, _ = sample_grad - root['node'].samples[0] = state_curr_sample + key, sample_grad = root['node'].event_sample_and_grad(key, n_samples=mc_samples) + event_curr_sample, _ = sample_grad + + if update_state: + state_sample_grad += root["node"].compute_state_prior_grad(state_curr_sample, state_parent_sample, direction_curr_sample, event_curr_sample) + + if update_state: + if adaptive: + root['node'].update_state_adaptive(state_params_grad, state_sample_grad, state_params_entropy_grad, + step_size=step_size, i=i) + else: + root['node'].update_state_params(state_params_grad, state_sample_grad, state_params_entropy_grad, + step_size=step_size) + key, sample_grad = root['node'].state_sample_and_grad(key, n_samples=mc_samples) + state_curr_sample, _ = sample_grad + if update_state: + root['node'].samples[0] = state_curr_sample root['node'].samples[1] = direction_curr_sample + root['node'].samples[2] = event_curr_sample if memoized: mass_here = root['node'].suff_stats['mass']['total'] @@ -962,13 +1041,163 @@ def descend(root, key, depth=0): root['node'].variational_parameters['delta_1'] = 1.0 + mass_here root['node'].variational_parameters['delta_2'] = (self.alpha_decay**depth) * self.dp_alpha + mass_down - return mass_here + mass_down, direction_curr_sample, state_curr_sample + return mass_here + mass_down, direction_curr_sample, state_curr_sample, event_curr_sample # Update kernels and sticks if root is None: root = self.root - descend(root, key) + depth = root['node'].depth + descend(root, key, depth=depth) + + + def update_node_kernel_params(self, key, root=None, memoized=True, step_size=0.0001, mc_samples=10, n_steps=10, adaptive=True, update_state=True, return_trace=False, **kwargs): + """ + Update variational parameters for kernels using variational inference with moment matching + + Each node must have two parameters for the kernel: a direction and a state. + We assume the tree kernel, regardless of the model, is always defined as + P(direction|parent_direction) and P(state|direction,parent_state). + For each node, we first update the direction and then the state, taking one gradient step for each + parameter and then moving on to the next nodes in the tree traversal + + PSEUDOCODE: + def descend(root): + alpha, alpha_grad = sample_grad_alpha + psi, psi_grad = sample_grad_psi + + alpha_grad += Gradient of logp(alpha|parent_alpha) wrt this alpha + alpha_grad += Gradient of logp(psi|parent_psi,alpha) wrt this alpha + + alpha_grad += Gradient of logq(alpha) wrt this alpha + psi_grad += Gradient of logq(psi) wrt this psi + + psi_grad += Gradient of logp(x|psi) wrt this psi + + for each child: + child_alpha, child_psi = descend(child) + alpha_grad += Gradient of logp(child_alpha|alpha) wrt this alpha + psi_grad += Gradient of logp(child_psi|psi,child_alpha) wrt this psi + for each child_root: + alpha_grad += Gradient of logp(child_root_alpha|alpha) wrt this alpha + psi_grad += Gradient of logp(child_root_psi|psi,child_root_alpha) wrt this psi + + new_alpha_params = alpha_params + alpha_grad * step_size + new_alpha = sample_alpha + + psi_grad += Gradient of logp(psi|parent_psi,new_alpha) wrt this psi + new_psi_params = psi_params + psi_grad * step_size + new_psi = sample_psi + + return new_alpha, new_psi + + """ + # Update kernels and sticks + if root is None: + root = self.root + + elbos = [] + for i in range(n_steps): + direction_sample_grad = 0. + event_sample_grad = 0. + state_sample_grad = 0. + + key, sample_grad = root['node'].direction_sample_and_grad(key, n_samples=mc_samples) + direction_curr_sample, direction_params_grad = sample_grad + key, sample_grad = root['node'].event_sample_and_grad(key, n_samples=mc_samples) + event_curr_sample, event_params_grad = sample_grad + if update_state: + key, sample_grad = root['node'].state_sample_and_grad(key, n_samples=mc_samples) + state_curr_sample, state_params_grad = sample_grad + else: + state_curr_sample = root['node'].get_state_sample() + + direction_parent_sample = root["node"].parent().get_direction_sample() + state_parent_sample = root["node"].parent().get_state_sample() + + direction_sample_grad += root["node"].compute_direction_prior_grad(direction_curr_sample, direction_parent_sample, state_parent_sample) + direction_sample_grad += root["node"].compute_state_prior_grad_wrt_direction(state_curr_sample, state_parent_sample, direction_curr_sample, event_curr_sample) + + event_sample_grad += root["node"].compute_event_prior_grad(event_curr_sample) + event_sample_grad += root["node"].compute_state_prior_grad_wrt_event(state_curr_sample, state_parent_sample, direction_curr_sample, event_curr_sample) + + direction_params_entropy_grad = root["node"].compute_direction_entropy_grad() + event_params_entropy_grad = root["node"].compute_event_entropy_grad() + if update_state: + state_params_entropy_grad = root["node"].compute_state_entropy_grad() + + if update_state: + if memoized: + state_sample_grad += root["node"].compute_ll_state_grad_suff(state_curr_sample) + else: + weights = root['node'].variational_parameters['q_z'] * self.variational_parameters['q_c'] + state_sample_grad += root["node"].compute_ll_state_grad(self.ntssb.data, weights, state_curr_sample) + + for child in root['children'][::-1]: + direction_child_sample = child['node'].get_direction_sample() + state_child_sample = child['node'].get_state_sample() + event_child_sample = child['node'].get_event_sample() + + direction_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_direction(direction_child_sample, direction_curr_sample, state_curr_sample) + # state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(direction_child_sample, direction_curr_sample, state_curr_sample) + if update_state: + state_sample_grad += root["node"].compute_state_prior_child_grad(state_child_sample, state_curr_sample, direction_child_sample, event_child_sample) + + for ii, child_root in enumerate(self.children_root_nodes): + direction_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_direction(child_root.get_direction_sample(), direction_curr_sample, state_curr_sample) * root['node'].variational_parameters['q_rho'][ii] + # state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(child_root.get_direction_sample(), direction_curr_sample, state_curr_sample) * root['node'].variational_parameters['q_rho'][ii] + if update_state: + state_sample_grad += root["node"].compute_root_state_prior_child_grad(child_root.get_state_sample(), state_curr_sample, child_root.get_direction_sample(), child_root.get_event_sample()) * root['node'].variational_parameters['q_rho'][ii] + + if adaptive and i == 0: + root['node'].reset_opt() + + # Combine gradients of functions wrt sample with gradient of sample wrt var params + if adaptive: + root['node'].update_direction_adaptive(direction_params_grad, direction_sample_grad, direction_params_entropy_grad, + step_size=step_size, i=i) + else: + root['node'].update_direction_params(direction_params_grad, direction_sample_grad, direction_params_entropy_grad, + step_size=step_size) + key, sample_grad = root['node'].direction_sample_and_grad(key, n_samples=mc_samples) + direction_curr_sample, _ = sample_grad + + if adaptive: + root['node'].update_event_adaptive(event_params_grad, event_sample_grad, event_params_entropy_grad, + step_size=step_size, i=i) + else: + root['node'].update_event_params(event_params_grad, event_sample_grad, event_params_entropy_grad, + step_size=step_size) + key, sample_grad = root['node'].event_sample_and_grad(key, n_samples=mc_samples) + event_curr_sample, _ = sample_grad + + if update_state: + state_sample_grad += root["node"].compute_state_prior_grad(state_curr_sample, state_parent_sample, direction_curr_sample, event_curr_sample) + + if update_state: + if adaptive: + root['node'].update_state_adaptive(state_params_grad, state_sample_grad, state_params_entropy_grad, + step_size=step_size, i=i) + else: + root['node'].update_state_params(state_params_grad, state_sample_grad, state_params_entropy_grad, + step_size=step_size) + key, sample_grad = root['node'].state_sample_and_grad(key, n_samples=mc_samples) + state_curr_sample, _ = sample_grad + + if update_state: + root['node'].samples[0] = state_curr_sample + + root['node'].samples[1] = direction_curr_sample + root['node'].samples[2] = event_curr_sample + + if return_trace: + self.ntssb.compute_elbo(memoized=memoized) + elbos.append(self.ntssb.elbo) + + if return_trace: + return elbos + + def sample_grad_root_node(self, key, memoized=True, mc_samples=10, **kwargs): """ @@ -980,14 +1209,18 @@ def sample_grad_root_node(self, key, memoized=True, mc_samples=10, **kwargs): root = self.root direction_sample_grad = 0. state_sample_grad = 0. + event_sample_grad = 0. key, sample_grad = root['node'].direction_sample_and_grad(key, n_samples=mc_samples) direction_curr_sample, direction_params_grad = sample_grad key, sample_grad = root['node'].state_sample_and_grad(key, n_samples=mc_samples) state_curr_sample, state_params_grad = sample_grad + key, sample_grad = root['node'].event_sample_and_grad(key, n_samples=mc_samples) + event_curr_sample, event_params_grad = sample_grad # Gradient of entropy direction_params_entropy_grad = root["node"].compute_direction_entropy_grad() + event_params_entropy_grad = root["node"].compute_event_entropy_grad() state_params_entropy_grad = root["node"].compute_state_entropy_grad() # Gradient of likelihood @@ -1001,23 +1234,26 @@ def sample_grad_root_node(self, key, memoized=True, mc_samples=10, **kwargs): for child in root['children'][::-1]: direction_child_sample = child['node'].get_direction_sample() state_child_sample = child['node'].get_state_sample() + event_child_sample = child['node'].get_event_sample() direction_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_direction(direction_child_sample, direction_curr_sample, state_curr_sample) - state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(direction_child_sample, direction_curr_sample, state_curr_sample) - state_sample_grad += root["node"].compute_state_prior_child_grad(state_child_sample, state_curr_sample, direction_child_sample) + # state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(direction_child_sample, direction_curr_sample, state_curr_sample) + state_sample_grad += root["node"].compute_state_prior_child_grad(state_child_sample, state_curr_sample, direction_child_sample, event_child_sample) # Gradient of roots of children TSSB for i, child_root in enumerate(self.children_root_nodes): direction_child_sample = child_root.get_direction_sample() state_child_sample = child_root.get_state_sample() + event_child_sample = child_root.get_event_sample() # Gradient of the root nodes of children TSSBs wrt to their parameters using this TSSB root as parent direction_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_direction(direction_child_sample, direction_curr_sample, state_curr_sample) * root['node'].variational_parameters['q_rho'][i] - state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(direction_child_sample, direction_curr_sample, state_curr_sample) * root['node'].variational_parameters['q_rho'][i] - state_sample_grad += root["node"].compute_state_prior_child_grad(state_child_sample, state_curr_sample, direction_child_sample) * root['node'].variational_parameters['q_rho'][i] + # state_sample_grad += root["node"].compute_direction_prior_child_grad_wrt_state(direction_child_sample, direction_curr_sample, state_curr_sample) * root['node'].variational_parameters['q_rho'][i] + state_sample_grad += root["node"].compute_state_prior_child_grad(state_child_sample, state_curr_sample, direction_child_sample, event_child_sample) * root['node'].variational_parameters['q_rho'][i] direction_locals_grads = [direction_params_grad, direction_params_entropy_grad] state_locals_grads = [state_params_grad, state_params_entropy_grad] + event_locals_grads = [event_params_grad, event_params_entropy_grad] - return ll_grad, [direction_locals_grads, state_locals_grads], [direction_sample_grad, state_sample_grad] + return ll_grad, [direction_locals_grads, state_locals_grads, event_locals_grads], [direction_sample_grad, state_sample_grad, event_sample_grad] def compute_children_root_node_grads(self, **kwargs): """ @@ -1027,19 +1263,23 @@ def compute_children_root_node_grads(self, **kwargs): def descend(root, children_grads=None): direction_curr_sample = root['node'].samples[1] state_curr_sample = root['node'].samples[0] + event_curr_sample = root['node'].samples[2] # Compute gradient of children roots wrt their params if children_grads is None: - children_grads = [[0., 0.]] * len(self.children_root_nodes) + children_grads = [[0., 0., 0.]] * len(self.children_root_nodes) for i, child_root in enumerate(self.children_root_nodes): # Gradient of the root nodes of children TSSBs wrt to their parameters using this direction_child_sample = child_root.get_direction_sample() state_child_sample = child_root.get_state_sample() + event_child_sample = child_root.get_event_sample() direction_sample_grad = root["node"].compute_direction_prior_grad(direction_child_sample, direction_curr_sample, state_curr_sample) * root['node'].variational_parameters['q_rho'][i] - direction_sample_grad += root["node"].compute_state_prior_grad_wrt_direction(state_child_sample, state_curr_sample, direction_child_sample) * root['node'].variational_parameters['q_rho'][i] - state_sample_grad = root["node"].compute_state_prior_grad(state_child_sample, state_curr_sample, direction_child_sample) * root['node'].variational_parameters['q_rho'][i] + direction_sample_grad += root["node"].compute_state_prior_grad_wrt_direction(state_child_sample, state_curr_sample, direction_child_sample, event_child_sample) * root['node'].variational_parameters['q_rho'][i] + event_sample_grad += root["node"].compute_state_prior_grad_wrt_event(state_child_sample, state_curr_sample, direction_child_sample, event_child_sample) * root['node'].variational_parameters['q_rho'][i] + state_sample_grad = root["node"].compute_state_prior_grad(state_child_sample, state_curr_sample, direction_child_sample, event_child_sample) * root['node'].variational_parameters['q_rho'][i] children_grads[i][0] += direction_sample_grad children_grads[i][1] += state_sample_grad + children_grads[i][2] += event_sample_grad for child in root['children']: descend(child, children_grads=children_grads) @@ -1074,6 +1314,20 @@ def update_root_node_params(self, key, ll_grad, local_grads, children_grads, par direction_curr_sample, _ = sample_grad self.root['node'].samples[1] = direction_curr_sample + + event_params_grad, event_params_entropy_grad = local_grads[2] + event_sample_grad = children_grads[2] + parent_grads[2] + + if adaptive: + self.root['node'].update_event_adaptive(event_params_grad, event_sample_grad, event_params_entropy_grad, + step_size=step_size, i=i) + else: + self.root['node'].update_direction_params(event_params_grad, event_sample_grad, event_params_entropy_grad, + step_size=step_size) + key, sample_grad = self.root['node'].event_sample_and_grad(key, n_samples=mc_samples) + event_curr_sample, _ = sample_grad + self.root['node'].samples[2] = event_curr_sample + state_params_grad, state_params_entropy_grad = local_grads[1] state_sample_grad = children_grads[1] + parent_grads[1] state_sample_grad += ll_grad @@ -1580,7 +1834,7 @@ def descend(root, u, depth=0): return descend(self.root, u) - def find_node_uniform(self, key, include_leaves=True): + def find_node_uniform(self, key, root=None, include_leaves=True, return_parent=False): def descend(root, key, depth=0): if depth >= self.max_depth: return (root["node"], [], root) @@ -1605,7 +1859,16 @@ def descend(root, key, depth=0): return (node, path, root) - return descend(self.root, key) + if root is None: + root = self.root + parent_root = root + n, p, r = descend(root, key) + if return_parent: + for i in p[:-1]: + parent_root = parent_root['children'][i] + return n, p, r, parent_root + else: + return n, p, r def get_expected_mixture(self, reset_names=False): """ @@ -2070,21 +2333,26 @@ def label_nodes(self, counts=False, names=False): elif not names or counts is True: self.label_nodes_counts() - def set_node_names(self, root=None, root_name="X"): + def set_node_names(self, root=None, root_name="X", return_map=False): if root is None: root = self.root + old_to_new = {} + old_to_new[root["label"]] = str(root_name) root["label"] = str(root_name) root["node"].label = str(root_name) def descend(root, name): for i, child in enumerate(root["children"]): child_name = f"{name}-{i}" + old_to_new[child["label"]] = str(child_name) root["children"][i]["label"] = child_name root["children"][i]["node"].label = child_name descend(child, child_name) descend(root, root_name) + if return_map: + return old_to_new def set_subcluster_node_names(self): # Assumes the other fixed nodes have already been named, and ignores the root diff --git a/scatrex/plotting/scatterplot.py b/scatrex/plotting/scatterplot.py index 8aab3d4..79bb60a 100644 --- a/scatrex/plotting/scatterplot.py +++ b/scatrex/plotting/scatterplot.py @@ -8,12 +8,15 @@ from ..utils.tree_utils import tree_to_dict -def plot_full_tree(tree, ax=None, figsize=(6,6), **kwargs): +def plot_full_tree(tree, ax=None, figsize=(6,6), subtree_parent_probs=None, edge_labels=True, font_size=12, **kwargs): if ax is None: plt.figure(figsize=figsize) ax = plt.gca() def descend(root, graph, pos={}): - pos_out = plot_tree(root['node'], G=graph, ax=ax, alpha=1., draw=False, **kwargs) # Draw subtree + if subtree_parent_probs is not None: + pos_out = plot_tree(root['node'], G=graph, ax=ax, alpha=1., draw=False, parent_probs=subtree_parent_probs[root['label']], edge_labels=edge_labels, font_size=font_size, **kwargs) # Draw subtree + else: + pos_out = plot_tree(root['node'], G=graph, ax=ax, alpha=1., draw=False, edge_labels=edge_labels, font_size=font_size, **kwargs) # Draw subtree pos.update(pos_out) for child in root['children']: descend(child, graph, pos) @@ -22,8 +25,11 @@ def sub_descend(sub_root, graph): parent = sub_root['label'] for i, super_child in enumerate(root['children']): child = super_child['label'] - graph.add_edge(parent, child, alpha=sub_root['pivot_probs'][i], ls='--') - nx.draw_networkx_edges(graph, pos, edgelist=[(parent, child)], edge_color=sub_root['color'], alpha=sub_root['pivot_probs'][i], style='--') + prob = sub_root['pivot_probs'][i] + graph.add_edge(parent, child, alpha=prob, ls='--') + nx.draw_networkx_edges(graph, pos, edgelist=[(parent, child)], edge_color=sub_root['color'], alpha=prob, style='--') + if edge_labels and prob > 0.01: + nx.draw_networkx_edge_labels(graph, pos, font_color=sub_root['color'], edge_labels={(parent, child):f"{prob:.3f}"}, font_size=int(font_size/2), alpha=float(prob)) for child in sub_root['children']: sub_descend(child, graph) @@ -39,7 +45,10 @@ def sub_descend(sub_root, graph): ax.spines['top'].set_visible(False) -def plot_tree(tree, G = None, param_key='param', data=None, labels=True, alpha=0.5, font_size=12, node_size=1500, edge_width=1., arrows=True, draw=True, ax=None): +def plot_tree(tree, G = None, param_key='param', data=None, labels=True, alpha=0.5, font_size=12, node_size=1500, edge_width=1., arrows=True, draw=True, ax=None, parent_probs=None, edge_labels=True): + """ + parent_probs is a pandas dataframe containing the probability of each node being the child of every other node + """ tree_dict = tree_to_dict(tree, param_key=param_key) # Get all positions @@ -52,8 +61,7 @@ def plot_tree(tree, G = None, param_key='param', data=None, labels=True, alpha=0 # Draw graph node_options = {'alpha': alpha, 'node_size': node_size,} - edge_options = {'alpha': alpha, - 'width': edge_width, + edge_options = {'width': edge_width, 'node_size':node_size, 'arrows': arrows} label_options = {'alpha': alpha, @@ -64,13 +72,23 @@ def plot_tree(tree, G = None, param_key='param', data=None, labels=True, alpha=0 if G is None: G = nx.DiGraph() + for node in tree_dict: nx.draw_networkx_nodes(G, pos, nodelist=[node], node_color=tree_dict[node]['color'], **node_options) if tree_dict[node]['parent'] != '-1': - parent = tree_dict[node]['parent'] - G.add_edge(parent, node) - nx.draw_networkx_edges(G, pos, edgelist=[(parent, node)], edge_color=tree_dict[parent]['color'],**edge_options) + if parent_probs is not None: + for parent in tree_dict: + G.add_edge(parent, node) + nx.draw_networkx_edges(G, pos, edgelist=[(parent, node)], edge_color=tree_dict[parent]['color'], alpha=parent_probs.loc[node, parent]*alpha, **edge_options) + if edge_labels and parent_probs.loc[node, parent] > 0.01: + nx.draw_networkx_edge_labels(G, pos, edge_labels={(parent, node):f'{parent_probs.loc[node, parent]:.3f}'}, font_color=tree_dict[parent]['color'], + font_size=int(font_size/2), alpha=parent_probs.loc[node, parent]*alpha) + else: + parent = tree_dict[node]['parent'] + G.add_edge(parent, node) + nx.draw_networkx_edges(G, pos, edgelist=[(parent, node)], edge_color=tree_dict[parent]['color'], alpha=alpha, **edge_options) + if labels: labs = dict(zip(list(tree_dict.keys()), list(tree_dict.keys()))) nx.draw_networkx_labels(G, pos, labs, **label_options) diff --git a/scatrex/scatrex.py b/scatrex/scatrex.py index fcdbaef..2b37410 100644 --- a/scatrex/scatrex.py +++ b/scatrex/scatrex.py @@ -674,7 +674,7 @@ def learn_clonemap_corr( ] ids = [clone for clone in self.observed_tree.tree_dict] clones = [ - self.observed_tree.tree_dict[clone]["params"] + self.observed_tree.tree_dict[clone]["param"] for clone in self.observed_tree.tree_dict ] clones = np.array(clones)