StochTree

https://stochtree.ai/
Admin
StochTree is a flexible Bayesian decision tree modeling library in R and Python, implementing...
Tokens:480,892
Snippets:3,908
Trust Score:6.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Get Bin Start Index

Source: https://stochtree.ai/docs/cpp_docs/doxygen/cutpoint__candidates_8h_source.html

Returns the beginning index of a specified bin for a given feature.

```cpp
int32_t BinStartIndex(int i, int feature_index) {return feature_cutpoint_grid_[feature_index]->BinStartIndex(i);}
```

--------------------------------

### R Setup for Multi-Chain MCMC

Source: https://stochtree.ai/vignettes/multi-chain.html

Loads necessary R libraries for MCMC analysis, plotting, and parallel processing. Ensure these packages are installed before running.

```R
library(stochtree)
library(ggplot2)
library(coda)
library(bayesplot)
library(foreach)
library(doParallel)
```

--------------------------------

### Install Python Package from PyPI

Source: https://stochtree.ai/getting-started.html

Install the stochtree Python package from the Python Package Index (PyPI).

```python
pip install stochtree
```

--------------------------------

### Install StochTree from Local CRAN Directory

Source: https://stochtree.ai/development/contributing.html

Install the StochTree R package after bootstrapping the CRAN-friendly directory.

```r
devtools::install_local("stochtree_cran")
```

--------------------------------

### Install Python Development Version from Source

Source: https://stochtree.ai/getting-started.html

Install the development version of the stochtree Python package from its GitHub repository using pip.

```python
pip install numpy scipy pytest pandas scikit-learn pybind11
pip install git+https://github.com/StochasticTree/stochtree.git
```

--------------------------------

### Install Additional Conda Packages for Notebooks

Source: https://stochtree.ai/getting-started.html

Install matplotlib and seaborn using Conda, and jupyterlab using pip, for running notebook examples.

```bash
conda install matplotlib seaborn
pip install jupyterlab
```

--------------------------------

### Get Node Begin Index (Feature Specific)

Source: https://stochtree.ai/docs/cpp_docs/doxygen/partition__tracker_8h_source.html

Retrieves the starting index for a given node and feature. This allows querying node boundaries for specific features.

```cpp
data_size_t NodeBegin(int node_id, int feature_index) {
    return feature_partitions_[feature_index]->NodeBegin(node_id);
}
```

--------------------------------

### Install stochtree Development Version from GitHub

Source: https://stochtree.ai/docs/R_docs/pkgdown/index.html

Use this command to install the latest development version of the stochtree package directly from its GitHub repository.

```r
remotes::install_github("StochasticTree/stochtree", ref="r-dev")
```

--------------------------------

### Install Dependencies for StochTree (Venv)

Source: https://stochtree.ai/development/contributing.html

Install all necessary Python dependencies for the StochTree package and demo notebooks when using a venv environment.

```bash
pip install numpy scipy pytest pandas pybind11 scikit-learn matplotlib seaborn jupyterlab
```

--------------------------------

### Example of using sampleBCFPosteriorPredictive

Source: https://stochtree.ai/docs/R_docs/pkgdown/reference/sampleBCFPosteriorPredictive.html

An example demonstrating how to fit a BCF model and then use `sampleBCFPosteriorPredictive` to obtain posterior predictive samples.

```R
n <- 100
p <- 5
X <- matrix(rnorm(n * p), nrow = n, ncol = p)
pi_X <- pnorm(X[,1] / 2)
Z <- rbinom(n, 1, pi_X)
y <- 2 * X[,2] + 0.5 * X[,2] * Z + rnorm(n)
bcf_model <- bcf(X_train = X, Z_train = Z, y_train = y, propensity_train = pi_X)
ppd_samples <- sampleBCFPosteriorPredictive(
  model_object = bcf_model, X = X,
  Z = Z, propensity = pi_X
)

```

--------------------------------

### BART Model Training and Prediction Example

Source: https://stochtree.ai/docs/R_docs/pkgdown/reference/bart.html

This example demonstrates how to prepare training and testing data, then fit a BART model using the bart function. It includes data generation, splitting, and model fitting.

```R
n <- 100
p <- 5
X <- matrix(runif(n*p), ncol = p)
f_XW <- (
    ((0 <= X[,1]) & (0.25 > X[,1])) * (-7.5) +
    ((0.25 <= X[,1]) & (0.5 > X[,1])) * (-2.5) +
    ((0.5 <= X[,1]) & (0.75 > X[,1])) * (2.5) +
    ((0.75 <= X[,1]) & (1 > X[,1])) * (7.5)
)
noise_sd <- 1
y <- f_XW + rnorm(n, 0, noise_sd)
test_set_pct <- 0.2
n_test <- round(test_set_pct*n)
n_train <- n - n_test
test_inds <- sort(sample(1:n, n_test, replace = FALSE))
train_inds <- (1:n)[!((1:n) %in% test_inds)]
X_test <- X[test_inds,]
X_train <- X[train_inds,]
y_test <- y[test_inds]
y_train <- y[train_inds]

bart_model <- bart(X_train = X_train, y_train = y_train, X_test = X_test,
                   num_gfr = 10, num_burnin = 0, num_mcmc = 10)


```

--------------------------------

### Load Vector from JSON Example

Source: https://stochtree.ai/docs/R_docs/pkgdown/reference/loadVectorJson.html

Demonstrates how to create a CppJson object, add a vector to it, and then load that vector back using loadVectorJson. This is an example of the advanced workflow for controlling sampling algorithms and data structures.

```R
example_vec <- runif(10)
example_json <- createCppJson()
example_json$add_vector("myvec", example_vec)
roundtrip_vec <- loadVectorJson(example_json, "myvec")
```

--------------------------------

### Run Simulation with 50 Trees (Python)

Source: https://stochtree.ai/vignettes/calibration.html

Sets up and runs a coverage simulation with 50 trees and max depth 10. Use this to assess interval calibration when intervals might be too wide.

```python
# Data generating process parameters
n = 250
p = 50
snr = 2

# Modeling parameters
num_gfr = 5
num_burnin = 100
num_mcmc = 500
num_trees = 50
max_depth = 10

# Simulation setup
mc = 50
interval_levels = [0.5, 0.6, 0.7, 0.8, 0.9, 0.95]

# Run simulation
average_coverage_rates = run_coverage_simulation(
    n,
    p,
    snr,
    num_gfr,
    num_burnin,
    num_mcmc,
    num_trees,
    max_depth,
    mc,
    interval_levels,
    mean_fn=continuous_dgp,
)
```

--------------------------------

### Install Additional Pip Packages for Notebooks in Venv

Source: https://stochtree.ai/getting-started.html

Install matplotlib, seaborn, and jupyterlab using pip into the active venv environment for running notebook examples.

```python
pip install matplotlib seaborn jupyterlab
```

--------------------------------

### InitializeRoot() (2/2)

Source: https://stochtree.ai/docs/cpp_docs/doxygen/classStochTree_1_1ForestContainer.html

Initializes a "root" forest of multivariate trees as the first element in the container, setting all root node values to a specified vector of values.

```APIDOC
## InitializeRoot() [2/2]

### Description
Initialize a "root" forest of multivariate trees as the first element of the container, setting all root node values in every tree to `leaf_vector`.

### Parameters
- **_leaf_vector_** (std::vector< double > &) - Required - Vector of values to assign to the root node of every tree.
```

--------------------------------

### Node Offset Begin

Source: https://stochtree.ai/docs/cpp_docs/doxygen/partition__tracker_8h_source.html

Gets the starting offset of the node's data.

```APIDOC
## Begin

### Description
Returns the starting index (offset) of the data range for this node.

### Signature
data_size_t Begin()

### Returns
The starting offset of the node's data.
```

--------------------------------

### Run Simulation with 200 Trees (Python)

Source: https://stochtree.ai/vignettes/calibration.html

Sets up and runs a coverage simulation with 200 trees and max depth 10. Use this to assess interval calibration when intervals might be too narrow.

```python
# Data generating process parameters
n = 250
p = 50
snr = 2

# Modeling parameters
num_gfr = 5
num_burnin = 100
num_mcmc = 500
num_trees = 200
max_depth = 10

# Simulation setup
mc = 50
interval_levels = [0.5, 0.6, 0.7, 0.8, 0.9, 0.95]

# Run simulation
average_coverage_rates = run_coverage_simulation(
    n,
    p,
    snr,
    num_gfr,
    num_burnin,
    num_mcmc,
    num_trees,
    max_depth,
    mc,
    interval_levels,
    mean_fn=continuous_dgp,
)
```

--------------------------------

### Classic BART Model Setup (R)

Source: https://stochtree.ai/about/bart.html

Sets up the classic BART model using the `bart` function in R. Requires `X_train` and `y_train` as input.

```R
bart(
  X = X_train,
  y = y_train
)
```

--------------------------------

### prepare_for_sampler

Source: https://stochtree.ai/python-api/reference/sampler.ForestSampler.html

Initializes forest and tracking data structures with constant root values before running a sampler.

```APIDOC
## prepare_for_sampler

### Description
Initialize forest and tracking data structures with constant root values before running a sampler

### Parameters
- **dataset** (Dataset) - Required - `stochtree` dataset object storing covariates / bases / weights.
- **residual** (Residual) - Required - `stochtree` object storing continuously updated partial / full residual.
- **forest** (Forest) - Required - `stochtree` object storing tree ensemble.
- **leaf_model** (LeafModel) - Required - The leaf model to use for initialization.
- **initial_values** (InitialValues) - Required - The initial values for the sampler.
```

--------------------------------

### InitializeRoot

Source: https://stochtree.ai/docs/cpp_docs/doxygen/functions_func_i.html

Initializes the root of a StochTree::ForestContainer.

```APIDOC
## InitializeRoot()

### Description
Initializes the root of a StochTree::ForestContainer.

### Method
Not specified (likely a member function of StochTree::ForestContainer).

### Parameters
None explicitly listed.

### Response
Initializes the root node of the forest container.
```

--------------------------------

### Get Node Begin Index

Source: https://stochtree.ai/docs/cpp_docs/doxygen/partition__tracker_8h_source.html

Retrieves the starting index for a given node within the sorted feature indices. Used to access the subset of observations belonging to a specific node.

```cpp
data_size_t NodeBegin(int32_t node_id) {return node_offset_sizes_[node_id].Begin();}
```

--------------------------------

### Example Usage of createForestModelConfig

Source: https://stochtree.ai/docs/R_docs/pkgdown/reference/createForestModelConfig.html

Demonstrates basic usage of createForestModelConfig by setting the number of trees, features, and observations. Note that feature_types and variable_weights are not provided and will be assumed to be numeric and equal-weighted, respectively.

```R
config <- createForestModelConfig(num_trees = 10, num_features = 5, num_observations = 100)
#> Warning: `feature_types` not provided, will be assumed to be numeric
#> Warning: `variable_weights` not provided, will be assumed to be equal-weighted
```

--------------------------------

### InitializeRoot (double)

Source: https://stochtree.ai/docs/cpp_docs/doxygen/classStochTree_1_1ForestContainer.html

Initializes a "root" forest of univariate trees as the first element in the container, setting all root node values to a specified leaf value.

```APIDOC
## InitializeRoot (double)

### void InitializeRoot(double leaf_value)

Initialize a "root" forest of univariate trees as the first element of the container, setting all root node values in every tree to `leaf_value`.
```

--------------------------------

### Get Node Begin Index

Source: https://stochtree.ai/docs/cpp_docs/doxygen/partition__tracker_8h_source.html

Retrieves the starting index of the data samples associated with a specific node in a given tree. This is useful for accessing the subset of data points that belong to that node.

```cpp
data_size_t NodeBegin(int tree_id, int node_id) {
 return feature_partitions_[tree_id]->NodeBegin(node_id);
 }
```

--------------------------------

### SamplePredMapper Constructor

Source: https://stochtree.ai/docs/cpp_docs/doxygen/partition__tracker_8h_source.html

Initializes the SamplePredMapper with the number of trees and observations. It pre-allocates storage for predictions.

```cpp
SamplePredMapper(int num_trees, data_size_t num_observations) {
num_trees_ = num_trees;
num_observations_ = num_observations;
// Initialize the vector of vectors of leaf indices for each tree
tree_preds_.resize(num_trees_);
for (int j = 0; j < num_trees_; j++) {
tree_preds_[j].resize(num_observations_);
}
}
```

--------------------------------

### Run Simulation with 50 Trees (R)

Source: https://stochtree.ai/vignettes/calibration.html

Sets up and runs a coverage simulation with 50 trees and max depth 10. Use this to assess interval calibration when intervals might be too wide.

```r
# Data generating process parameters
n <- 250
p <- 50
snr <- 2

# Modeling parameters
num_gfr <- 5
num_burnin <- 100
num_mcmc <- 500
num_trees <- 50
max_depth <- 10

# Simulation setup
mc <- 50
interval_levels <- c(0.5, 0.6, 0.7, 0.8, 0.9, 0.95)

# Run simulation
average_coverage_rates <- run_coverage_simulation(
  n,
  p,
  snr,
  num_gfr,
  num_burnin,
  num_mcmc,
  num_trees,
  max_depth,
  mc,
  interval_levels,
  mean_fn = continuous_dgp
)
```

--------------------------------

### Python: Configure and Run Forest Model Sampler

Source: https://stochtree.ai/vignettes/custom-sampling.html

This snippet demonstrates the Python implementation for setting up a forest model, initializing data structures, and executing the MCMC sampler.

```Python
# Initial value of global error variance parameter
sigma2_init = 1.0

# Initialize data objects
forest_dataset = Dataset()
forest_dataset.add_covariates(X)
residual = Residual(y_standardized)

# Random number generator (std::mt19937)
cpp_rng = RNG(random_seed)

# Model configuration
outcome_model_type = 0
leaf_dimension = 1
num_trees = 200
feature_types = np.repeat(0, p).astype(int)  # 0 = numeric
var_weights = np.repeat(1 / p, p)
global_model_config = GlobalModelConfig(global_error_variance=sigma2_init)
forest_model_config = ForestModelConfig(
    feature_types=feature_types,
    num_trees=num_trees,
    num_features=p,
    num_observations=n,
    variable_weights=var_weights,
    leaf_dimension=leaf_dimension,
    leaf_model_type=outcome_model_type,
)

# Forest model object
forest_sampler = ForestSampler(forest_dataset, global_model_config, forest_model_config)

# "Active forest" (which gets updated by the sample) and
# container of forest samples (which is written to when
# a sample is not discarded due to burn-in / thinning)
active_forest = Forest(num_trees, leaf_dimension, True, False)
forest_container = ForestContainer(num_trees, leaf_dimension, True, False)

# Initialize the leaves of each tree in the mean forest
leaf_init = np.mean(y_standardized, keepdims=True)
forest_sampler.prepare_for_sampler(
    forest_dataset,
    residual,
    active_forest,
    outcome_model_type,
    leaf_init,
)

# Global error variance model
global_var_model = GlobalVarianceModel()

# Prepare to run the sampler
num_burnin = 3000
num_mcmc = 1000
sigma2_samples_non_robust = np.empty(num_mcmc)
rmse_samples_non_robust = np.empty(num_mcmc)
fhat_samples_non_robust = np.empty((n, num_mcmc))
current_sigma2 = sigma2_init

```

--------------------------------

### Install Python Package in Conda Environment

Source: https://stochtree.ai/getting-started.html

Install the stochtree Python package from GitHub into the currently active Conda environment.

```python
pip install git+https://github.com/StochasticTree/stochtree.git
```

--------------------------------

### Get Sample Prediction

Source: https://stochtree.ai/docs/cpp_docs/doxygen/partition__tracker_8h_source.html

Retrieves the prediction for a given sample ID. Can get the overall prediction or prediction from a specific tree.

```cpp
double GetSamplePrediction(data_size_t sample_id);
double GetTreeSamplePrediction(data_size_t sample_id, int tree_id);
```

--------------------------------

### Prepare Sampler for Custom Sampling

Source: https://stochtree.ai/vignettes/custom-sampling.html

Initializes the sampler with necessary data and model configurations. This is a prerequisite for running custom MCMC iterations.

```python
leaf_init = np.mean(y_standardized, keepdims=True)
forest_sampler.prepare_for_sampler(
    forest_dataset,
    residual,
    active_forest,
    outcome_model_type,
    leaf_init,
)
```

--------------------------------

### R Example Usage

Source: https://stochtree.ai/docs/R_docs/pkgdown/reference/sample_without_replacement.html

Demonstrates how to use the sample_without_replacement function with a sample population, probabilities, and desired sample size.

```R
a <- as.integer(c(4,3,2,5,1,9,7))
p <- c(0.7,0.2,0.05,0.02,0.01,0.01,0.01)
num_samples <- 5
sample_without_replacement(a, p, num_samples)
#> [1] 4 3 2 1 7


```

--------------------------------

### Prepare Forest Sampler Initialization

Source: https://stochtree.ai/python-api/reference/sampler.ForestSampler.html

Initialize the forest and its tracking data structures with constant root values before starting the sampling process. This sets up the initial state for the sampler.

```python
sampler.ForestSampler.prepare_for_sampler(
    dataset,
    residual,
    forest,
    leaf_model,
    initial_values,
)
```

--------------------------------

### Install Dependencies for Venv Environment

Source: https://stochtree.ai/getting-started.html

Install core Python dependencies required for stochtree and its demo notebooks into the active venv environment.

```python
pip install numpy scipy pytest pandas scikit-learn pybind11
```

--------------------------------

### Preprocessing Training Data and Applying to Prediction Data

Source: https://stochtree.ai/docs/R_docs/pkgdown/reference/DataPreprocessing.html

Demonstrates how to preprocess training data using `preprocessTrainData` and then apply the same preprocessing steps to new data using `preprocessPredictionData` to ensure consistency. It also shows how to serialize and deserialize the preprocessing metadata.

```R
n <- 100
x1 <- rnorm(n)
x2 <- factor(sample(1:3, n, replace = TRUE), ordered = TRUE)
x3 <- factor(sample(1:3, n, replace = TRUE), ordered = FALSE)
df1 <- data.frame(x1 = x1, x2 = x2, x3 = x3)
df2 <- data.frame(x1 = x1, x2 = x2, x3 = x3)
preprocess_train_list <- preprocessTrainData(df1)
df1_process <- preprocess_train_list$data
df1_metadata <- preprocess_train_list$metadata
df2_process <- preprocessPredictionData(df2, df1_metadata)
all.equal(df1_process, df2_process)
#> [1] TRUE

# Save to in-memory JSON
metadata_json <- savePreprocessorToJson(df1_metadata)
# Save to JSON string
metadata_json_string <- savePreprocessorToJsonString(df1_metadata)

# Reload metadata list from in-memory JSON object
metadata_roundtrip <- createPreprocessorFromJson(metadata_json)
# Reload metadata list from JSON string
metadata_roundtrip <- createPreprocessorFromJsonString(metadata_json_string)
```

--------------------------------

### Init

Source: https://stochtree.ai/docs/cpp_docs/doxygen/functions_func_i.html

Initializes a StochTree::Tree object.

```APIDOC
## Init()

### Description
Initializes a StochTree::Tree object.

### Method
Not specified (likely a member function of StochTree::Tree).

### Parameters
None explicitly listed.

### Response
Initializes the tree structure.
```

--------------------------------

### Install stochtree from CRAN

Source: https://stochtree.ai/docs/R_docs/pkgdown/index.html

Use this command to install the stable version of the stochtree package from the Comprehensive R Archive Network (CRAN).

```r
install.packages("stochtree")
```

--------------------------------

### Fit and Predict with StochTreeBARTRegressor

Source: https://stochtree.ai/python-api/reference/sklearn.StochTreeBARTRegressor.html

Demonstrates how to load data, initialize the StochTreeBARTRegressor, fit it to the data, and make predictions.

```python
>>> from sklearn.datasets import load_diabetes
>>> from stochtree import StochTreeBARTRegressor
>>> data = load_diabetes()
>>> X = data.data
>>> y = data.target
>>> reg = StochTreeBARTRegressor()
>>> reg.fit(X, y)
>>> reg.predict(X)
```

--------------------------------

### Classic BART Model Setup (Python)

Source: https://stochtree.ai/about/bart.html

Sets up the classic BART model using the `BARTModel` class in Python. Requires `X_train` and `y_train` as input.

```Python
BARTModel.sample(
    X = X_train,
    y = y_train
)
```

--------------------------------

### Install StochTree with Pip (Conda)

Source: https://stochtree.ai/development/contributing.html

Install the StochTree Python package using pip after setting up the conda environment. Navigate to the stochtree directory first.

```bash
pip install .
```

--------------------------------

### R: Setting up Forest Models for Monotonicity Constraint

Source: https://stochtree.ai/vignettes/iv.html

This R snippet illustrates the setup of forest models and datasets for enforcing monotonicity constraints. It includes creating forest dataset configurations, model configurations, and preparing data for sampling.

```r
X_h  <- as.matrix(X[z == 0, ])
n0   <- sum(z == 0);  n1 <- sum(z == 1)
num_trees_f <- 50;  num_trees_h <- 20
feature_types_mono <- as.integer(rep(0, 1)) # Assuming p_X - 2 = 1 for simplicity in example
var_weights_mono   <- rep(1, 1) # Assuming p_X - 2 = 1 for simplicity in example
tau_h <- 1 / num_trees_h
leaf_scale_h <- matrix(tau_h, ncol = 1)
leaf_scale_f <- matrix(1 / num_trees_f, ncol = 1)

forest_dataset_f <- createForestDataset(X)
forest_dataset_h <- createForestDataset(X_h)

fmc_f <- createForestModelConfig(
  feature_types = feature_types_mono, num_trees = num_trees_f,
  num_features = ncol(X), num_observations = nrow(X),
  variable_weights = var_weights_mono, leaf_dimension = 1,
  alpha = alpha, beta = beta, min_samples_leaf = min_samples_leaf,
  max_depth = max_depth, leaf_model_type = 0,
  leaf_model_scale = leaf_scale_f, cutpoint_grid_size = cutpoint_grid_size
)
fmc_h <- createForestModelConfig(
  feature_types = feature_types_mono, num_trees = num_trees_h,
  num_features = ncol(X_h), num_observations = nrow(X_h),
  variable_weights = var_weights_mono, leaf_dimension = 1,
  alpha = alpha, beta = beta, min_samples_leaf = min_samples_leaf,
  max_depth = max_depth, leaf_model_type = 0,
  leaf_model_scale = leaf_scale_h, cutpoint_grid_size = cutpoint_grid_size
)
gmc_mono <- createGlobalModelConfig(global_error_variance = 1)
fm_f <- createForestModel(forest_dataset_f, fmc_f, gmc_mono)
fm_h <- createForestModel(forest_dataset_h, fmc_h, gmc_mono)

fs_f <- createForestSamples(num_trees_f, 1, TRUE)
fs_h <- createForestSamples(num_trees_h, 1, TRUE)
af_f <- createForest(num_trees_f, 1, TRUE)
af_h <- createForest(num_trees_h, 1, TRUE)

v1 <- v[z == 1];  v0 <- v[z == 0]
R1 <- rep(NA, n0);  R0 <- rep(NA, n0)
R1[v0 == 1] <- 1;   R0[v0 == 1] <- 1
R1[v0 == 0] <- 0;   R0[v0 == 0] <- sample(c(0, 1), sum(v0 == 0), replace = TRUE)
vaug <- c(v1, R1)

z_f <- (2 * as.numeric(vaug) - 1);  z_f <- z_f / sd(z_f)
z_h <- (2 * as.numeric(R0)  - 1);   z_h <- z_h / sd(z_h)
out_f <- createOutcome(z_f);  out_h <- createOutcome(z_h)
af_f$prepare_for_sampler(forest_dataset_f, out_f, fm_f, 0, 0.0)
af_h$prepare_for_sampler(forest_dataset_h, out_h, fm_h, 0, 0.0)
af_f$adjust_residual(forest_dataset_f, out_f, fm_f, FALSE, FALSE)
af_h$adjust_residual(forest_dataset_h, out_h, fm_h, FALSE, FALSE)

gfr_flag <- TRUE
for (i in seq_len(num_samples)) {
  if (i > num_warmstart) gfr_flag <- FALSE
  fm_f$sample_one_iteration(forest_dataset_f, out_f, fs_f, af_f,
    rng_r, fmc_f, gmc_mono, keep_forest = TRUE, gfr = gfr_flag, num_threads = 1)
  fm_h$sample_one_iteration(forest_dataset_h, out_h, fs_h, af_h,
    rng_r, fmc_h, gmc_mono, keep_forest = TRUE, gfr = gfr_flag, num_threads = 1)

  eta_f <- fs_f$predict_raw_single_forest(forest_dataset_f, i - 1)
  eta_h <- fs_h$predict_raw_single_forest(forest_dataset_h, i - 1)

  idx0  <- which(v0 == 0)
  w1 <- (1 - pnorm(eta_h[idx0])) * (1 - pnorm(eta_f[n1 + idx0]))
  w2 <- (1 - pnorm(eta_h[idx0])) *      pnorm(eta_f[n1 + idx0])
  w3 <-      pnorm(eta_h[idx0])  * (1 - pnorm(eta_f[n1 + idx0]))
  s_w <- w1 + w2 + w3
  u   <- runif(length(idx0))
  temp <- 1*(u < w1/s_w) + 2*(u > w1/s_w & u < (w1+w2)/s_w) + 3*(u > (w1+w2)/s_w)
  R1[v0 == 0] <- 1*(temp == 2);  R0[v0 == 0] <- 1*(temp == 3)
  vaug <- c(v1, R1)

  U1 <- runif(sum(R0),    pnorm(0, eta_h[R0 == 1], 1), 1)
  z_h[R0 == 1] <- qnorm(U1, eta_h[R0 == 1], 1)
  U0 <- runif(n0 - sum(R0), 0, pnorm(0, eta_h[R0 == 0], 1))
  z_h[R0 == 0] <- qnorm(U0, eta_h[R0 == 0], 1)

  U1 <- runif(sum(vaug),    pnorm(0, eta_f[vaug == 1], 1), 1)
  z_f[vaug == 1] <- qnorm(U1, eta_f[vaug == 1], 1)
  U0 <- runif(n - sum(vaug), 0, pnorm(0, eta_f[vaug == 0], 1))
  z_f[vaug == 0] <- qnorm(U0, eta_f[vaug == 0], 1)

  out_h$update_data(z_h);  fm_h$propagate_residual_update(out_h)
  out_f$update_data(z_f);  fm_f$propagate_residual_update(out_f)
}

```

--------------------------------

### NodeBegin()

Source: https://stochtree.ai/docs/cpp_docs/doxygen/functions_n.html

Marks the beginning of a node in various partition and tracker classes.

```APIDOC
## NodeBegin()

### Description
Marks the beginning of a node.

### Classes
StochTree::FeaturePresortPartition, StochTree::FeatureUnsortedPartition, StochTree::SortedNodeSampleTracker, StochTree::UnsortedNodeSampleTracker
```

--------------------------------

### Get Variance Forest Scale

Source: https://stochtree.ai/docs/R_docs/pkgdown/reference/ForestModelConfig.html

Query the scale parameter for IG leaf models. Use this to get the scale setting for Inverse Gaussian leaf models.

```r
ForestModelConfig$get_variance_forest_scale()
```

--------------------------------

### InitializeRoot

Source: https://stochtree.ai/docs/cpp_docs/doxygen/container_8h_source.html

Initializes a "root" forest, which serves as the first element in the container, with either a single leaf value or a vector of leaf values.

```APIDOC
## InitializeRoot (Overload 1)

### Description
Initializes a "root" forest of univariate trees as the first element of the container, setting all leaf nodes to a specified constant value.

### Method
`void InitializeRoot(double leaf_value)`

### Parameters
- **leaf_value** (double) - Required - The constant value to set for all leaf nodes in the root forest.

### Endpoint
N/A (Method)
```

```APIDOC
## InitializeRoot (Overload 2)

### Description
Initializes a "root" forest of multivariate trees as the first element of the container, setting all leaf nodes to the values provided in the leaf vector.

### Method
`void InitializeRoot(std::vector< double > &leaf_vector)`

### Parameters
- **leaf_vector** (std::vector< double >&) - Required - A vector of values to set for the leaf nodes in the root forest.

### Endpoint
N/A (Method)
```

--------------------------------

### Load Scalar from JSON Example

Source: https://stochtree.ai/docs/R_docs/pkgdown/reference/loadScalarJson.html

Demonstrates how to add a scalar to a CppJson object and then load it back using loadScalarJson. This is an example of advanced usage for detailed control of sampling algorithms.

```R
example_scalar <- 5.4
example_json <- createCppJson()
example_json$add_scalar("myscalar", example_scalar)
roundtrip_scalar <- loadScalarJson(example_json, "myscalar")

```

--------------------------------

### Class Members starting with 'h'

Source: https://stochtree.ai/docs/cpp_docs/doxygen/functions_h.html

This section lists functions and methods within StochTree classes that start with the letter 'h'. Each entry includes the member name and the class(es) it belongs to.

```APIDOC
## Class Members starting with 'h'

This section lists functions and methods within StochTree classes that start with the letter 'h'. Each entry includes the member name and the class(es) it belongs to.

### - h -
  * HasBasis() : StochTree::ForestDataset, StochTree::RandomEffectsDataset
  * HasCategoricalSplit() : StochTree::Tree
  * HasCovariates() : StochTree::ForestDataset
  * HasGroupLabels() : StochTree::RandomEffectsDataset
  * HasLeafVector() : StochTree::Tree
  * HasVarWeights() : StochTree::ForestDataset, StochTree::RandomEffectsDataset
  * HasVectorOutput() : StochTree::Tree
```

--------------------------------

### Run Simulation with 200 Trees (R)

Source: https://stochtree.ai/vignettes/calibration.html

Sets up and runs a coverage simulation with 200 trees and max depth 10. Use this to assess interval calibration when intervals might be too narrow.

```r
# Data generating process parameters
n <- 250
p <- 50
snr <- 2

# Modeling parameters
num_gfr <- 5
num_burnin <- 100
num_mcmc <- 500
num_trees <- 200
max_depth <- 10

# Simulation setup
mc <- 50
interval_levels <- c(0.5, 0.6, 0.7, 0.8, 0.9, 0.95)

# Run simulation
average_coverage_rates <- run_coverage_simulation(
  n,
  p,
  snr,
  num_gfr,
  num_burnin,
  num_mcmc,
  num_trees,
  max_depth,
  mc,
  interval_levels,
  mean_fn = continuous_dgp
)
```

--------------------------------

### BCFModel Initialization Parameters

Source: https://stochtree.ai/python-api/reference/bcf.BCFModel.html

Details the `previous_model_warmstart_sample_num` parameter for initializing BCFModel samplers from previous model outputs.

```APIDOC
## BCFModel Initialization Parameters

### Description

This section describes the `previous_model_warmstart_sample_num` parameter, which allows for warm-starting a BCF sampler using samples from a previously generated model.

### Parameters

#### Query Parameters

- **previous_model_warmstart_sample_num** (int) - Optional - Sample number from `previous_model_json` that will be used to warmstart this BCF sampler. Zero-indexed (so that the first sample is used for warm-start by setting `previous_model_warmstart_sample_num = 0`). Defaults to `None`. If `num_chains` in the `general_params` list is > 1, then each successive chain will be initialized from a different sample, counting backwards from `previous_model_warmstart_sample_num`. That is, if `previous_model_warmstart_sample_num = 10` and `num_chains = 4`, then chain 1 will be initialized from sample 10, chain 2 from sample 9, chain 3 from sample 8, and chain 4 from sample 7. If `previous_model_json` is provided but `previous_model_warmstart_sample_num` is NULL, the last sample in the previous model will be used to initialize the first chain, counting backwards as noted before. If more chains are requested than there are samples in `previous_model_json`, a warning will be raised and only the last sample will be used.

### Default Value

`None`
```

--------------------------------

### NodeOffsetSize Begin Method in C++

Source: https://stochtree.ai/docs/cpp_docs/doxygen/partition__tracker_8h_source.html

Returns the starting index (offset) of the node's data within the larger dataset.

```cpp
data_size_t Begin() {return node_begin_;}
```

--------------------------------

### StochTree Functions Starting with 'n'

Source: https://stochtree.ai/docs/cpp_docs/doxygen/functions_func_n.html

This section details various functions available in the StochTree library, categorized by their starting letter 'n'. Each entry provides the function name and the classes where these functions are defined or used.

```APIDOC
## Functions Starting with 'n'

This section lists documented functions within the StochTree library that begin with the letter 'n'. For each function, the associated classes are also provided.

### - n -

*   **NodeBegin()**: Belongs to `StochTree::FeaturePresortPartition`, `StochTree::FeatureUnsortedPartition`, `StochTree::SortedNodeSampleTracker`, `StochTree::UnsortedNodeSampleTracker`.
*   **NodeCutpointEvaluated()**: Belongs to `StochTree::NodeCutpointTracker`.
*   **NodeEnd()**: Belongs to `StochTree::FeaturePresortPartition`, `StochTree::FeatureUnsortedPartition`, `StochTree::SortedNodeSampleTracker`, `StochTree::UnsortedNodeSampleTracker`.
*   **NodeIndices()**: Belongs to `StochTree::FeaturePresortPartition`, `StochTree::FeatureUnsortedPartition`, `StochTree::SortedNodeSampleTracker`.
*   **NodeSize()**: Belongs to `StochTree::FeaturePresortPartition`, `StochTree::FeatureUnsortedPartition`, `StochTree::SortedNodeSampleTracker`, `StochTree::UnsortedNodeSampleTracker`.
*   **NodeType()**: Belongs to `StochTree::Tree`.
*   **NoSplitLogMarginalLikelihood()**: Belongs to `StochTree::CloglogOrdinalLeafModel`, `StochTree::GaussianConstantLeafModel`, `StochTree::GaussianMultivariateRegressionLeafModel`, `StochTree::GaussianUnivariateRegressionLeafModel`, `StochTree::LogLinearVarianceLeafModel`.
*   **NumBases()**: Belongs to `StochTree::RandomEffectsDataset`.
*   **NumBasis()**: Belongs to `StochTree::ForestDataset`.
*   **NumCols()**: Belongs to `StochTree::ColumnMatrix`.
*   **NumCovariates()**: Belongs to `StochTree::ForestDataset`.
*   **NumCutpoints()**: Belongs to `StochTree::CutpointGridContainer`, `StochTree::FeatureCutpointGrid`, `StochTree::NodeCutpointTracker`.
*   **NumDeletedNodes()**: Belongs to `StochTree::Tree`.
*   **NumericSplit()**: Belongs to `StochTree::TreeSplit`.
*   **NumNodes()**: Belongs to `StochTree::Tree`.
*   **NumObservations()**: Belongs to `StochTree::ForestDataset`, `StochTree::RandomEffectsDataset`.
*   **NumRows()**: Belongs to `StochTree::ColumnMatrix`, `StochTree::ColumnVector`.
*   **NumTrees()**: Belongs to `StochTree::UnsortedNodeSampleTracker`.
*   **NumValidNodes()**: Belongs to `StochTree::Tree`.
```

--------------------------------

### GaussianProcessRegressor Initialization Parameters

Source: https://stochtree.ai/vignettes/ensemble-kernel.html

This displays the parameters of a fitted GaussianProcessRegressor, highlighting the kernel configuration and optimizer settings. It's useful for understanding the model's state after fitting.

```python
GaussianProcessRegressor(kernel=RBF(length_scale=1) + WhiteKernel(noise_level=0.01),
                         n_restarts_optimizer=5,
                         random_state=101)
```

--------------------------------

### R: Full Random Effect State Management Example

Source: https://stochtree.ai/docs/R_docs/pkgdown/reference/RandomEffectStateManagement.html

This snippet demonstrates a comprehensive workflow for setting up and managing random effects models in R. It covers creating datasets, initializing model parameters, sampling random effects, and resetting the model and tracker states.

```R
n <- 100
p <- 10
rfx_group_ids <- sample(1:2, size = n, replace = TRUE)
rfx_basis <- matrix(rep(1.0, n), ncol=1)
rfx_dataset <- createRandomEffectsDataset(rfx_group_ids, rfx_basis)
y <- (-2*(rfx_group_ids==1)+2*(rfx_group_ids==2)) + rnorm(n)
y_std <- (y-mean(y))/sd(y)
outcome <- createOutcome(y_std)
rng <- createCppRNG(1234)
num_groups <- length(unique(rfx_group_ids))
num_components <- ncol(rfx_basis)
rfx_model <- createRandomEffectsModel(num_components, num_groups)
rfx_tracker <- createRandomEffectsTracker(rfx_group_ids)
rfx_samples <- createRandomEffectSamples(num_components, num_groups, rfx_tracker)
alpha_init <- rep(1,num_components)
xi_init <- matrix(rep(alpha_init, num_groups),num_components,num_groups)
sigma_alpha_init <- diag(1,num_components,num_components)
sigma_xi_init <- diag(1,num_components,num_components)
sigma_xi_shape <- 1
sigma_xi_scale <- 1
rfx_model$set_working_parameter(alpha_init)
rfx_model$set_group_parameters(xi_init)
rfx_model$set_working_parameter_cov(sigma_alpha_init)
rfx_model$set_group_parameter_cov(sigma_xi_init)
rfx_model$set_variance_prior_shape(sigma_xi_shape)
rfx_model$set_variance_prior_scale(sigma_xi_scale)
for (i in 1:3) {
    rfx_model$sample_random_effect(rfx_dataset=rfx_dataset, residual=outcome,
                                   rfx_tracker=rfx_tracker, rfx_samples=rfx_samples,
                                   keep_sample=TRUE, global_variance=1.0, rng=rng)
}
resetRandomEffectsModel(rfx_model, rfx_samples, 0, 1.0)
resetRandomEffectsTracker(rfx_tracker, rfx_model, rfx_dataset, outcome, rfx_samples)
rootResetRandomEffectsModel(rfx_model, alpha_init, xi_init, sigma_alpha_init,
                            sigma_xi_init, sigma_xi_shape, sigma_xi_scale)
rootResetRandomEffectsTracker(rfx_tracker, rfx_model, rfx_dataset, outcome)

```

--------------------------------

### Class Members starting with 'p'

Source: https://stochtree.ai/docs/cpp_docs/doxygen/functions_p.html

This section lists functions and methods available in the StochTree library whose names start with the letter 'p'. Each entry includes the function signature and the classes it belongs to, providing direct links for further details.

```APIDOC
## Class Members starting with 'p'

This section lists functions and methods available in the StochTree library whose names start with the letter 'p'. Each entry includes the function signature and the classes it belongs to, providing direct links for further details.

### Functions and Methods

- **Parent()**: Belongs to StochTree::FeatureUnsortedPartition, StochTree::Tree, StochTree::UnsortedNodeSampleTracker.
- **PartitionNode()**: Belongs to StochTree::FeatureUnsortedPartition, StochTree::SortedNodeSampleTracker.
- **PartitionTreeNode()**: Belongs to StochTree::UnsortedNodeSampleTracker.
- **PosteriorParameterMean()**: Belongs to StochTree::GaussianConstantLeafModel, StochTree::GaussianMultivariateRegressionLeafModel, StochTree::GaussianUnivariateRegressionLeafModel.
- **PosteriorParameterRate()**: Belongs to StochTree::CloglogOrdinalLeafModel.
- **PosteriorParameterScale()**: Belongs to StochTree::LogLinearVarianceLeafModel.
- **PosteriorParameterShape()**: Belongs to StochTree::CloglogOrdinalLeafModel, StochTree::LogLinearVarianceLeafModel.
- **PosteriorParameterVariance()**: Belongs to StochTree::GaussianConstantLeafModel, StochTree::GaussianMultivariateRegressionLeafModel, StochTree::GaussianUnivariateRegressionLeafModel.
- **Predict()**: Belongs to StochTree::ForestContainer.
- **PredictLeafIndexInplace()**: Belongs to StochTree::Tree.
- **PredictLeafIndices()**: Belongs to StochTree::TreeEnsemble.
- **PredictLeafIndicesInplace()**: Belongs to StochTree::TreeEnsemble.
- **PredictRaw()**: Belongs to StochTree::ForestContainer.
- **PruneNodeToLeaf()**: Belongs to StochTree::FeatureUnsortedPartition.
- **PruneTreeNodeToLeaf()**: Belongs to StochTree::UnsortedNodeSampleTracker.
```

--------------------------------

### Initialize ForestSampler

Source: https://stochtree.ai/python-api/reference/sampler.ForestSampler.html

Instantiate a ForestSampler with dataset, global configuration, and forest configuration.

```python
sampler.ForestSampler(dataset, global_config, forest_config)
```

--------------------------------

### SplitIndex

Source: https://stochtree.ai/docs/cpp_docs/doxygen/functions_s.html

Gets the split index. Associated with Tree.

```APIDOC
## SplitIndex()

### Description
Retrieves the index associated with a split in a tree. This can be used to identify which feature or condition was used for the split.

### Method
N/A (Function Signature)

### Endpoint
N/A (Class Member)

### Parameters
N/A (Specific parameters depend on the class context)

### Request Example
N/A

### Response
N/A (Return type depends on the class context)
```

--------------------------------

### Sample from BCF Model (Python)

Source: https://stochtree.ai/vignettes/bcf.html

Samples from a BCF model using Python, requiring pre-defined training and testing datasets and general sampling parameters. Initializes and calls the sample method on a BCFModel instance.

```python
general_params = {"num_threads": 1, "num_chains": 4, "random_seed": random_seed}
bcf_model = BCFModel()
bcf_model.sample(
    X_train=X_train,
    Z_train=Z_train,
    y_train=y_train,
    propensity_train=pi_train,
    X_test=X_test,
    Z_test=Z_test,
    propensity_test=pi_test,
    num_gfr=10,
    num_burnin=1000,
    num_mcmc=100,
    general_params=general_params,
)
```

--------------------------------

### RightNode

Source: https://stochtree.ai/docs/cpp_docs/doxygen/functions_func_r.html

Gets the right node in a partition or tracker.

```APIDOC
## RightNode()

### Description
Retrieves the right node from a `StochTree::FeatureUnsortedPartition` or `StochTree::UnsortedNodeSampleTracker`.

### Method
(Member Function)

### Endpoint
N/A (Class Method)

### Parameters
None

### Response
- Returns a reference to the right node.
```

--------------------------------

### RightChild

Source: https://stochtree.ai/docs/cpp_docs/doxygen/functions_func_r.html

Gets the right child of a Tree node.

```APIDOC
## RightChild()

### Description
Retrieves the right child node of the current node in a `StochTree::Tree`.

### Method
(Member Function)

### Endpoint
N/A (Class Method)

### Parameters
None

### Response
- Returns a reference to the right child node.
```

--------------------------------

### InitializeRoot (std::vector<double>)

Source: https://stochtree.ai/docs/cpp_docs/doxygen/classStochTree_1_1ForestContainer.html

Initializes a "root" forest of multivariate trees as the first element in the container, setting all root node values to a specified vector of leaf values.

```APIDOC
## InitializeRoot (std::vector<double>)

### void InitializeRoot(std::vector< double > &leaf_vector)

Initialize a "root" forest of multivariate trees as the first element of the container, setting all root node values in every tree to `leaf_vector`.
```

--------------------------------

### BinStartIndex

Source: https://stochtree.ai/docs/cpp_docs/doxygen/classStochTree_1_1FeatureCutpointGrid.html

Retrieves the starting index of a specified bin.

```APIDOC
## BinStartIndex

### Description
Retrieves the starting index of a specified bin.

### Method
int32_t

### Signature
int32_t BinStartIndex(int i)

### Parameters
* `i` (int): The index of the bin.

### Returns
An integer representing the starting index of the specified bin.
```

--------------------------------

### add_sample

Source: https://stochtree.ai/python-api/reference/forest.ForestContainer.html

Adds a new all-root ensemble to the container, initializing all leaves with a specified value or vector.

```APIDOC
## add_sample

### Description
Adds a new all-root ensemble to the container, initializing all leaves with a specified value or vector.

### Method
`forest.ForestContainer.add_sample(leaf_value)`

### Parameters
#### Path Parameters
- **leaf_value** (float or np.array) - Required - Value (or vector of values) to initialize root nodes of every tree in a forest.
```

--------------------------------

### Get Feature Presort

Source: https://stochtree.ai/docs/cpp_docs/doxygen/partition__tracker_8h_source.html

Retrieves a pointer to a FeaturePresortRoot object.

```APIDOC
## GetFeaturePresort

### Description
Returns a pointer to a `FeaturePresortRoot` object for a specified feature number.

### Signature
FeaturePresortRoot* GetFeaturePresort(int feature_num)

### Parameters
* **feature_num** (int) - The index of the feature for which to retrieve the `FeaturePresortRoot`.

### Returns
A pointer to the `FeaturePresortRoot` object.
```

--------------------------------

### Number of Trees

Source: https://stochtree.ai/docs/cpp_docs/doxygen/partition__tracker_8h_source.html

Gets the total number of trees managed.

```APIDOC
## NumTrees

### Description
Returns the total count of trees currently managed.

### Signature
int NumTrees()

### Returns
The total number of trees.
```

--------------------------------

### Sample BCF Model (Python)

Source: https://stochtree.ai/vignettes/serialization.html

Trains a BCF model using the BCFModel class. Note the use of dictionaries for forest parameters.

```python
num_gfr = 10
num_burnin = 0
num_mcmc = 100
bcf_model = BCFModel()
bcf_model.sample(
    X_train=X_train, Z_train=Z_train, y_train=y_train, propensity_train=pi_train,
    rfx_group_ids_train=rfx_group_ids_train, rfx_basis_train=rfx_basis_train,
    X_test=X_test, Z_test=Z_test, propensity_test=pi_test,
    rfx_group_ids_test=rfx_group_ids_test, rfx_basis_test=rfx_basis_test,
    num_gfr=num_gfr, num_burnin=num_burnin, num_mcmc=num_mcmc,
    general_params={"num_threads": 1},
    prognostic_forest_params={"sample_sigma2_leaf": False},
    treatment_effect_forest_params={"sample_sigma2_leaf": False},
)
```

--------------------------------

### Get Number of Groups

Source: https://stochtree.ai/docs/cpp_docs/doxygen/random__effects_8h_source.html

Returns the number of groups in the model.

```cpp
inline int32_t NumGroups() {return num_groups_;}
```

--------------------------------

### Get Number of Components

Source: https://stochtree.ai/docs/cpp_docs/doxygen/random__effects_8h_source.html

Returns the number of components in the model.

```cpp
inline int32_t NumComponents() {return num_components_;}
```

--------------------------------

### Get Group Parameters

Source: https://stochtree.ai/docs/cpp_docs/doxygen/random__effects_8h_source.html

Retrieves the matrix containing parameters for all groups.

```cpp
Eigen::MatrixXd& GetGroupParameters() {
    return group_parameters_;
}
```
Tokens:
Raw