From 29b6238f3b43e129d2c24f8e6edbde1f0451ae94 Mon Sep 17 00:00:00 2001 From: Drew Herren Date: Tue, 11 Feb 2025 16:03:32 -0600 Subject: [PATCH 1/4] Updated C++ docs --- include/stochtree/leaf_model.h | 2 +- include/stochtree/mainpage.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/stochtree/leaf_model.h b/include/stochtree/leaf_model.h index 78a7011a..0e5234b5 100644 --- a/include/stochtree/leaf_model.h +++ b/include/stochtree/leaf_model.h @@ -239,7 +239,7 @@ namespace StochTree { * \beta \sim N\left(0, \tau\right) * \f] * - * Allowing for case / variance weights $w_i$ as above, we derive a reduced log marginal likelihood of + * Allowing for case / variance weights \f$w_i\f$ as above, we derive a reduced log marginal likelihood of * * \f[ * L(y) \propto \frac{1}{2} \log\left(\frac{\sigma^2}{s_{wxx,\ell} \tau + \sigma^2}\right) + \frac{\tau s_{wyx,\ell}^2}{2\sigma^2(s_{wxx,\ell} \tau + \sigma^2)} diff --git a/include/stochtree/mainpage.h b/include/stochtree/mainpage.h index 71da0945..dc39f162 100644 --- a/include/stochtree/mainpage.h +++ b/include/stochtree/mainpage.h @@ -33,7 +33,7 @@ * - Leaf Model: `stochtree`'s data structures are generalized to support a wide range of models, which are defined via specialized classes in the \ref leaf_model_group "leaf model layer". * - Sampler: helper functions that sample forests from training data comprise the \ref sampling_group "sampling layer" of `stochtree`. * - * \section extending-stochtree Extending `stochtree` + * \section extending-stochtree Extending stochtree * * \subsection custom-leaf-models Custom Leaf Models * From daa0fc79dc4aee4a786a796edd526697c799575a Mon Sep 17 00:00:00 2001 From: Drew Herren Date: Wed, 12 Feb 2025 17:34:23 -0600 Subject: [PATCH 2/4] Updated readme / news and python setup file --- NEWS.md | 4 ++++ README.md | 8 +++++++- setup.py | 7 ++++--- 3 files changed, 15 insertions(+), 4 deletions(-) diff --git a/NEWS.md b/NEWS.md index 0d2fa75b..ce97e9a0 100644 --- a/NEWS.md +++ b/NEWS.md @@ -1,3 +1,7 @@ +# stochtree 0.1.1 + +* Fixed initialization bug in several R package code examples for random effects models + # stochtree 0.1.0 * Initial release on CRAN. diff --git a/README.md b/README.md index 2726b7cd..36481f44 100644 --- a/README.md +++ b/README.md @@ -90,7 +90,13 @@ pip install matplotlib seaborn jupyterlab # R Package -The package can be installed in R via +The R package can be installed from CRAN via + +``` +install.packages("stochtree") +``` + +The development version of `stochtree` can be installed from Github via ``` remotes::install_github("StochasticTree/stochtree", ref="r-dev") diff --git a/setup.py b/setup.py index f6b87312..88a156ac 100644 --- a/setup.py +++ b/setup.py @@ -36,6 +36,7 @@ def build_extension(self, ext: CMakeExtension) -> None: debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug cfg = "Debug" if debug else "Release" + use_dbg = "ON" if debug else "OFF" # CMake lets you override the generator - we need to check this. # Can be set with Conda-Build, for example. @@ -48,8 +49,8 @@ def build_extension(self, ext: CMakeExtension) -> None: f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}{os.sep}", f"-DPYTHON_EXECUTABLE={sys.executable}", f"-DCMAKE_BUILD_TYPE={cfg}", # not used on MSVC, but no harm - "-DUSE_DEBUG=OFF", - "-DUSE_SANITIZER=OFF", + f"-DUSE_DEBUG={use_dbg}", + "-DUSE_SANITIZER=OFF", "-DBUILD_TEST=OFF", "-DBUILD_DEBUG_TARGETS=OFF", "-DBUILD_PYTHON=ON", @@ -151,7 +152,7 @@ def run(self): # The information here can also be placed in setup.cfg - better separation of # logic and declaration, and simpler if you include description/version in a file. -__version__ = "0.0.1" +__version__ = "0.1.1" setup( name="stochtree", From 256b9fc96abe29f9a2994e1cfb7ee842d0f2f572 Mon Sep 17 00:00:00 2001 From: Drew Herren Date: Wed, 12 Feb 2025 18:23:18 -0600 Subject: [PATCH 3/4] Updated python notebooks --- .../heteroskedastic_supervised_learning.ipynb | 16 +- ...tivariate_treatment_causal_inference.ipynb | 2 +- demo/notebooks/prototype_interface.ipynb | 26 ++- demo/notebooks/serialization.ipynb | 4 +- demo/notebooks/tree_inspection.ipynb | 166 +++--------------- 5 files changed, 48 insertions(+), 166 deletions(-) diff --git a/demo/notebooks/heteroskedastic_supervised_learning.ipynb b/demo/notebooks/heteroskedastic_supervised_learning.ipynb index 9fe170ae..580ff304 100644 --- a/demo/notebooks/heteroskedastic_supervised_learning.ipynb +++ b/demo/notebooks/heteroskedastic_supervised_learning.ipynb @@ -118,13 +118,6 @@ "s_x_test = s_x[test_inds]\n" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Demo 1: Using `W` in a linear leaf regression" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -139,9 +132,12 @@ "outputs": [], "source": [ "bart_model = BARTModel()\n", - "bart_params = {'num_trees_mean': 100, 'num_trees_variance': 50, 'sample_sigma_global': True, 'sample_sigma_leaf': False}\n", + "global_params = {'sample_sigma2_global': True}\n", + "mean_params = {'num_trees': 100, 'sample_sigma2_leaf': False}\n", + "variance_params = {'num_trees': 50}\n", "bart_model.sample(X_train=X_train, y_train=y_train, X_test=X_test, basis_train=basis_train, basis_test=basis_test,\n", - " num_gfr=10, num_mcmc=100, params=bart_params)" + " num_gfr=10, num_mcmc=100, general_params=global_params, mean_forest_params=mean_params, \n", + " variance_forest_params=variance_params)" ] }, { @@ -171,7 +167,7 @@ "metadata": {}, "outputs": [], "source": [ - "forest_preds_s_x_mcmc = bart_model.sigma_x_test\n", + "forest_preds_s_x_mcmc = np.sqrt(bart_model.sigma2_x_test)\n", "s_x_avg_mcmc = np.squeeze(forest_preds_s_x_mcmc).mean(axis = 1, keepdims = True)\n", "s_x_df_mcmc = pd.DataFrame(np.concatenate((np.expand_dims(s_x_test,1), s_x_avg_mcmc), axis = 1), columns=[\"True standard deviation\", \"Average estimated standard deviation\"])\n", "sns.scatterplot(data=s_x_df_mcmc, x=\"Average estimated standard deviation\", y=\"True standard deviation\")\n", diff --git a/demo/notebooks/multivariate_treatment_causal_inference.ipynb b/demo/notebooks/multivariate_treatment_causal_inference.ipynb index 6e175bd5..4fdd482e 100644 --- a/demo/notebooks/multivariate_treatment_causal_inference.ipynb +++ b/demo/notebooks/multivariate_treatment_causal_inference.ipynb @@ -45,7 +45,7 @@ "rng = np.random.default_rng()\n", "\n", "# Generate covariates and basis\n", - "n = 5000\n", + "n = 500\n", "p_X = 5\n", "X = rng.uniform(0, 1, (n, p_X))\n", "pi_X = np.c_[0.25 + 0.5*X[:,0], 0.75 - 0.5*X[:,1]]\n", diff --git a/demo/notebooks/prototype_interface.ipynb b/demo/notebooks/prototype_interface.ipynb index 881e8f87..19b112e1 100644 --- a/demo/notebooks/prototype_interface.ipynb +++ b/demo/notebooks/prototype_interface.ipynb @@ -106,7 +106,7 @@ "rng = np.random.default_rng(random_seed)\n", "\n", "# Generate covariates and basis\n", - "n = 1000\n", + "n = 500\n", "p_X = 10\n", "p_W = 1\n", "X = rng.uniform(0, 1, (n, p_X))\n", @@ -383,14 +383,14 @@ "rng = np.random.default_rng(random_seed)\n", "\n", "# Generate covariates and basis\n", - "n = 1000\n", + "n = 500\n", "p_X = 5\n", "X = rng.uniform(0, 1, (n, p_X))\n", - "pi_X = 0.25 + 0.5*X[:,0]\n", + "pi_X = 0.35 + 0.3*X[:,0]\n", "Z = rng.binomial(1, pi_X, n).astype(float)\n", "\n", "# Define the outcome mean functions (prognostic and treatment effects)\n", - "mu_X = pi_X*5\n", + "mu_X = (pi_X - 0.5)*30\n", "# tau_X = np.sin(X[:,1]*2*np.pi)\n", "tau_X = X[:,1]*2\n", "\n", @@ -423,24 +423,24 @@ "min_samples_leaf_mu = 1\n", "num_trees_mu = 200\n", "cutpoint_grid_size_mu = 100\n", - "tau_init_mu = 1/200\n", + "tau_init_mu = 1/num_trees_mu\n", "leaf_prior_scale_mu = np.array([[tau_init_mu]], order='C')\n", "a_leaf_mu = 3.\n", - "b_leaf_mu = 1/200\n", + "b_leaf_mu = 1/num_trees_mu\n", "leaf_regression_mu = False\n", "feature_types_mu = np.repeat(0, p_X).astype(int) # 0 = numeric\n", "var_weights_mu = np.repeat(1/(p_X + 1), p_X + 1)\n", "\n", "# Treatment forest parameters\n", - "alpha_tau = 0.25\n", + "alpha_tau = 0.75\n", "beta_tau = 3.\n", "min_samples_leaf_tau = 1\n", "num_trees_tau = 50\n", "cutpoint_grid_size_tau = 100\n", - "tau_init_tau = 1/50\n", + "tau_init_tau = 1/num_trees_tau\n", "leaf_prior_scale_tau = np.array([[tau_init_tau]], order='C')\n", "a_leaf_tau = 3.\n", - "b_leaf_tau = 1/50\n", + "b_leaf_tau = 1/num_trees_tau\n", "leaf_regression_tau = True\n", "feature_types_tau = np.repeat(0, p_X).astype(int) # 0 = numeric\n", "var_weights_tau = np.repeat(1/p_X, p_X)\n", @@ -466,7 +466,7 @@ "source": [ "# Prognostic Forest Dataset (covariates)\n", "dataset_mu = Dataset()\n", - "dataset_mu.add_covariates(np.c_[X,pi_X])\n", + "dataset_mu.add_covariates(np.c_[X, pi_X])\n", "\n", "# Treatment Forest Dataset (covariates and treatment variable)\n", "dataset_tau = Dataset()\n", @@ -521,7 +521,7 @@ "outputs": [], "source": [ "num_warmstart = 10\n", - "num_mcmc = 500\n", + "num_mcmc = 100\n", "num_samples = num_warmstart + num_mcmc\n", "global_var_samples = np.concatenate((np.array([global_variance_init]), np.repeat(0, num_samples)))\n", "leaf_scale_samples_mu = np.concatenate((np.array([tau_init_mu]), np.repeat(0, num_samples)))\n", @@ -562,8 +562,6 @@ " forest_sampler_tau.sample_one_iteration(forest_container_tau, active_forest_tau, dataset_tau, residual, cpp_rng, \n", " feature_types_tau, cutpoint_grid_size_tau, leaf_prior_scale_tau, var_weights_tau, \n", " 0.0, 0.0, global_var_samples[i], 1, True, True, False)\n", - " # leaf_scale_samples_tau[i+1] = leaf_var_model_tau.sample_one_iteration(forest_container_tau, cpp_rng, a_leaf_tau, b_leaf_tau)\n", - " # leaf_prior_scale_tau[0,0] = leaf_scale_samples_tau[i+1]\n", " tau_x = np.squeeze(active_forest_tau.predict_raw(dataset_tau))\n", " s_tt0 = np.sum(tau_x*tau_x*(Z==0))\n", " s_tt1 = np.sum(tau_x*tau_x*(Z==1))\n", @@ -606,8 +604,6 @@ " forest_sampler_tau.sample_one_iteration(forest_container_tau, active_forest_tau, dataset_tau, residual, cpp_rng, \n", " feature_types_tau, cutpoint_grid_size_tau, leaf_prior_scale_tau, var_weights_tau, \n", " 0.0, 0.0, global_var_samples[i], 1, True, False, False)\n", - " # leaf_scale_samples_tau[i+1] = leaf_var_model_tau.sample_one_iteration(forest_container_tau, cpp_rng, a_leaf_tau, b_leaf_tau, i)\n", - " # leaf_prior_scale_tau[0,0] = leaf_scale_samples_tau[i+1]\n", " tau_x = np.squeeze(active_forest_tau.predict_raw(dataset_tau))\n", " s_tt0 = np.sum(tau_x*tau_x*(Z==0))\n", " s_tt1 = np.sum(tau_x*tau_x*(Z==1))\n", diff --git a/demo/notebooks/serialization.ipynb b/demo/notebooks/serialization.ipynb index b5672b27..fab75022 100644 --- a/demo/notebooks/serialization.ipynb +++ b/demo/notebooks/serialization.ipynb @@ -120,7 +120,7 @@ "outputs": [], "source": [ "bart_model = BARTModel()\n", - "bart_model.sample(X_train=X_train, y_train=y_train, basis_train=basis_train, X_test=X_test, basis_test=basis_test, num_gfr=10, num_mcmc=100)" + "bart_model.sample(X_train=X_train, y_train=y_train, basis_train=basis_train, X_test=X_test, basis_test=basis_test, num_gfr=10, num_mcmc=10)" ] }, { @@ -150,7 +150,7 @@ "metadata": {}, "outputs": [], "source": [ - "sigma_df_mcmc = pd.DataFrame(np.concatenate((np.expand_dims(np.arange(bart_model.num_samples - bart_model.num_gfr),axis=1), np.expand_dims(bart_model.global_var_samples,axis=1)), axis = 1), columns=[\"Sample\", \"Sigma\"])\n", + "sigma_df_mcmc = pd.DataFrame(np.concatenate((np.expand_dims(np.arange(bart_model.num_samples),axis=1), np.expand_dims(bart_model.global_var_samples,axis=1)), axis = 1), columns=[\"Sample\", \"Sigma\"])\n", "sns.scatterplot(data=sigma_df_mcmc, x=\"Sample\", y=\"Sigma\")\n", "plt.show()" ] diff --git a/demo/notebooks/tree_inspection.ipynb b/demo/notebooks/tree_inspection.ipynb index ba58fe37..1c55e139 100644 --- a/demo/notebooks/tree_inspection.ipynb +++ b/demo/notebooks/tree_inspection.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -55,7 +55,7 @@ "rng = np.random.default_rng(random_seed)\n", "\n", "# Generate covariates and basis\n", - "n = 1000\n", + "n = 500\n", "p_X = 10\n", "X = rng.uniform(0, 1, (n, p_X))\n", "\n", @@ -91,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -112,13 +112,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "bart_model = BARTModel()\n", "param_dict = {\"keep_gfr\": True}\n", - "bart_model.sample(X_train=X_train, y_train=y_train, X_test=X_test, num_gfr=10, num_mcmc=100, params=param_dict)" + "bart_model.sample(X_train=X_train, y_train=y_train, X_test=X_test, num_gfr=10, num_mcmc=10, mean_forest_params=param_dict)" ] }, { @@ -130,20 +130,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "forest_preds_y_mcmc = bart_model.y_hat_test[:,bart_model.num_gfr:]\n", "y_avg_mcmc = np.squeeze(forest_preds_y_mcmc).mean(axis = 1, keepdims = True)\n", @@ -155,20 +144,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sigma_df_mcmc = pd.DataFrame(np.concatenate((np.expand_dims(np.arange(bart_model.num_samples),axis=1), np.expand_dims(bart_model.global_var_samples,axis=1)), axis = 1), columns=[\"Sample\", \"Sigma\"])\n", "sns.scatterplot(data=sigma_df_mcmc, x=\"Sample\", y=\"Sigma\")\n", @@ -184,20 +162,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.2202176097944513" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "np.sqrt(np.mean(np.power(y_test - np.squeeze(y_avg_mcmc),2)))" ] @@ -211,41 +178,18 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([25, 30, 21, 30, 24, 26, 25, 32, 18, 30], dtype=int32)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "bart_model.forest_container_mean.get_forest_split_counts(9, p_X)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([3068, 3063, 2401, 2770, 2372, 2522, 2260, 2606, 2239, 3620],\n", - " dtype=int32)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "bart_model.forest_container_mean.get_overall_split_counts(p_X)" ] @@ -259,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -268,20 +212,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1], dtype=int32)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "splits[9,0,:]" ] @@ -295,20 +228,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 2], dtype=int32)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "splits[9,1,:]" ] @@ -322,40 +244,18 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 0, 1, 0, 0, 0, 0, 0, 0, 0], dtype=int32)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "splits[9,20,:]" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int32)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "splits[9,30,:]" ] @@ -376,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -386,19 +286,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "node=0 is a split node, which tells us to go to node 1 if X[:, 9] <= 0.49719406595027094 else to node 2.\n", - "\tnode=1 is a leaf node with value=[-0.355].\n", - "\tnode=2 is a leaf node with value=[0.464].\n" - ] - } - ], + "outputs": [], "source": [ "nodes = np.sort(bart_model.forest_container_mean.nodes(forest_num,tree_num))\n", "for nid in nodes:\n", From 3906791c6c05f052a67305772776da3fb914ed09 Mon Sep 17 00:00:00 2001 From: Drew Herren Date: Wed, 12 Feb 2025 19:24:39 -0600 Subject: [PATCH 4/4] Updated jupyter notebook demo titles --- demo/notebooks/causal_inference.ipynb | 2 +- .../causal_inference_feature_subsets.ipynb | 2 +- .../heteroskedastic_supervised_learning.ipynb | 2 +- ...tivariate_treatment_causal_inference.ipynb | 2 +- demo/notebooks/prototype_interface.ipynb | 2 +- demo/notebooks/serialization.ipynb | 19 ++++++++++++++++++- demo/notebooks/supervised_learning.ipynb | 2 +- demo/notebooks/tree_inspection.ipynb | 2 +- 8 files changed, 25 insertions(+), 8 deletions(-) diff --git a/demo/notebooks/causal_inference.ipynb b/demo/notebooks/causal_inference.ipynb index 4c5eb17c..92d58528 100644 --- a/demo/notebooks/causal_inference.ipynb +++ b/demo/notebooks/causal_inference.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Causal Inference Demo Notebook" + "# Causal Inference" ] }, { diff --git a/demo/notebooks/causal_inference_feature_subsets.ipynb b/demo/notebooks/causal_inference_feature_subsets.ipynb index f746baec..b391a33f 100644 --- a/demo/notebooks/causal_inference_feature_subsets.ipynb +++ b/demo/notebooks/causal_inference_feature_subsets.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Causal Inference with Feature Subsets Demo Notebook\n", + "# Causal Inference with Feature Subsets\n", "\n", "This is a duplicate of the main causal inference demo which shows how a user might decide to use only a subset of covariates in the treatment effect forest. \n", "Why might we want to do that? Well, in many cases it is plausible that some covariates (for example age, income, etc...) influence the outcome of interest \n", diff --git a/demo/notebooks/heteroskedastic_supervised_learning.ipynb b/demo/notebooks/heteroskedastic_supervised_learning.ipynb index 580ff304..427d9984 100644 --- a/demo/notebooks/heteroskedastic_supervised_learning.ipynb +++ b/demo/notebooks/heteroskedastic_supervised_learning.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Supervised Learning with Heteroskedasticity Demo Notebook" + "# Heteroskedastic Supervised Learning" ] }, { diff --git a/demo/notebooks/multivariate_treatment_causal_inference.ipynb b/demo/notebooks/multivariate_treatment_causal_inference.ipynb index 4fdd482e..60741e33 100644 --- a/demo/notebooks/multivariate_treatment_causal_inference.ipynb +++ b/demo/notebooks/multivariate_treatment_causal_inference.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Causal Inference with Multivariate Treatments Demo Notebook" + "# Multivariate Treatment Causal Inference" ] }, { diff --git a/demo/notebooks/prototype_interface.ipynb b/demo/notebooks/prototype_interface.ipynb index 19b112e1..ef220c6e 100644 --- a/demo/notebooks/prototype_interface.ipynb +++ b/demo/notebooks/prototype_interface.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Demo of the `StochTree` Prototype Interface" + "# Low-Level Interface" ] }, { diff --git a/demo/notebooks/serialization.ipynb b/demo/notebooks/serialization.ipynb index fab75022..646b0be4 100644 --- a/demo/notebooks/serialization.ipynb +++ b/demo/notebooks/serialization.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Serialization Demo Notebook" + "# Model Serialization" ] }, { @@ -29,6 +29,7 @@ "source": [ "import json\n", "import numpy as np\n", + "import os\n", "import pandas as pd\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", @@ -321,6 +322,22 @@ "plt.axline((0, 0), slope=1, color=\"black\", linestyle=(0, (3,3)))\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Clean up JSON file" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "os.remove('bart.json')" + ] } ], "metadata": { diff --git a/demo/notebooks/supervised_learning.ipynb b/demo/notebooks/supervised_learning.ipynb index 9a49289a..ff96872f 100644 --- a/demo/notebooks/supervised_learning.ipynb +++ b/demo/notebooks/supervised_learning.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Supervised Learning Demo Notebook" + "# Supervised Learning" ] }, { diff --git a/demo/notebooks/tree_inspection.ipynb b/demo/notebooks/tree_inspection.ipynb index 1c55e139..0c9149c4 100644 --- a/demo/notebooks/tree_inspection.ipynb +++ b/demo/notebooks/tree_inspection.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Deeper Dive on Fitted Forests in StochTree\n", + "# Internal Tree Inspection\n", "\n", "While out of sample evaluation and MCMC diagnostics on parametric BART components (i.e. $\\sigma^2$, the global error variance) are helpful, it's important to be able to inspect the trees in a BART / BCF model (or a custom tree ensemble model). This vignette walks through some of the features `stochtree` provides to query and understand the forests / trees in a model." ]