From 8eff987a9c42d2952f0d24339397ca05b6af7868 Mon Sep 17 00:00:00 2001
From: Caio Guirado <caioguirado@yahoo.com.br>
Date: Wed, 24 Aug 2022 14:39:07 +0200
Subject: [PATCH 1/5] Add BART logic

---
 causalml/inference/tree/__init__.py |   1 +
 causalml/inference/tree/bart.py     | 547 ++++++++++++++++++++++++++++
 2 files changed, 548 insertions(+)
 create mode 100644 causalml/inference/tree/bart.py

diff --git a/causalml/inference/tree/__init__.py b/causalml/inference/tree/__init__.py
index 0830b7a0..5a8cb4b5 100644
--- a/causalml/inference/tree/__init__.py
+++ b/causalml/inference/tree/__init__.py
@@ -1,6 +1,7 @@
 from .causal.causaltree import CausalTreeRegressor, CausalRandomForestRegressor
 from .plot import uplift_tree_string, uplift_tree_plot, plot_dist_tree_leaves_values
 from .uplift import DecisionTree, UpliftTreeClassifier, UpliftRandomForestClassifier
+from .bart import BART
 from .utils import (
     cat_group,
     cat_transform,
diff --git a/causalml/inference/tree/bart.py b/causalml/inference/tree/bart.py
new file mode 100644
index 00000000..475f26a7
--- /dev/null
+++ b/causalml/inference/tree/bart.py
@@ -0,0 +1,547 @@
+import copy
+import random
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+import scipy.stats as ss
+import statsmodels.api as sm
+from typing import List, Tuple, Dict
+
+class Data:
+    def __init__(self, 
+                 X:np.ndarray, 
+                 y:np.ndarray, 
+                 treatment:np.ndarray=None, 
+                 R:np.ndarray=None, 
+                 index:np.ndarray=None, 
+                 available_values_per_col:Dict[int, np.ndarray]=None, 
+                 available_predictors_for_split:List[int]=None):
+        self.X = X
+        self.treatment = treatment
+        self.y = y
+        self.R = R
+        self.index = index
+        self.get_available_predictors_for_split()
+    
+    def get_available_predictors_for_split(self):
+        self.available_predictors_for_split = []
+        for i in range(self.X.shape[1]):
+            if self.X[:, i].size > 1:
+                self.available_predictors_for_split.append(i)
+                
+#         if self.treatment is not None:
+#             self.available_predictors_for_split[-1] = discrete_unique_values(self.treatment)
+            
+class Node:
+    def __init__(self, 
+                 type_:str = 'terminal', 
+                 left:'Node' = None, 
+                 right:'Node' = None, 
+                 feature:int = None, 
+                 threshold:float = 0., 
+                 value:float = 0., 
+                 depth:int = 0, 
+                 parent:'Node' = None, 
+                 data:Data = None):
+        self.type_ = type_
+        self.left = left
+        self.right = right
+        self.feature = feature
+        self.threshold = threshold 
+        self.value = value
+        self.depth = depth
+        self.parent = parent
+        self.data = data
+        if data:
+            self.nobs = self.data.X.shape[0]
+      
+    def apply_rule(self, x:np.ndarray) -> 'Node':
+        if x[self.feature] < self.threshold:
+            return self.left
+        else:
+            return self.right
+    
+    def predict(self) -> float:
+        return self.value
+        
+class Tree:
+    def __init__(self, root: Node):
+        self.root = root
+        self.nodes = []
+        self.leaves = []
+        self.leaves_parents = []
+        self.update()
+        self.predictors = list(range(self.root.data.X.shape[1]))
+        self.root.predictors_used = []
+    
+    def predict(self, X:np.ndarray) -> np.ndarray:
+        predictions = []
+        for x in X:
+            node = self.root
+            while node.left:
+                node = node.apply_rule(x=x)
+            predictions.append(node.predict())
+        return np.array(predictions).reshape(-1, 1)
+    
+    def update_residuals(self, residuals:np.ndarray) -> None:
+        self.root.data.R = residuals
+        self.traverse(self.root, type_='update_residuals')
+        
+    def traverse(self, root:Node, type_:str = 'update_leaves'):
+        if type_ == 'update_leaves':
+            if not root.left and not root.right:
+                self.leaves.append(root)
+                return
+        elif type_ == 'get_second_gen_nodes':
+            if not root.left and not root.right:
+                return
+            if root.left.type_ == 'terminal' and root.right.type_ == 'terminal':
+                self.second_gen_internal_nodes.append(root)
+                return
+        elif type_ == 'get_leaves_parents':
+            if not root.left and not root.right:
+                return
+            if root.left.type_ == 'terminal' and root.right.type_ == 'terminal':
+                self.leaves_parents.append(root)
+                return
+        elif type_ == 'update_residuals':
+            if not root.left and not root.right:
+                return
+            if root.left.type_ == 'terminal' and root.right.type_ == 'terminal':
+                root.data.R = self.root.data.R[root.data.index]
+                return
+        self.traverse(root.left, type_=type_)
+        self.traverse(root.right, type_=type_)
+        
+    def get_leaves(self) -> List[Node]:
+        self.leaves = []
+        self.traverse(self.root, type_='update_leaves')
+        return self.leaves
+
+    def get_n_second_gen_internal_nodes(self, return_nodes:bool=False) -> int:
+        if len(self.leaves) == 1:
+            return 1
+        self.second_gen_internal_nodes = []
+        self.traverse(self.root, type_='get_second_gen_nodes')
+        if return_nodes:
+            return self.second_gen_internal_nodes
+        else:
+            return len(self.second_gen_internal_nodes)
+    
+    def get_leaves_parents(self) -> List[Node]:
+        self.leaves_parents = []
+        self.traverse(self.root, type_='get_leaves_parents')
+        return self.leaves_parents
+    
+    def get_nodes(self) -> List[Node]:
+        return self._get_nodes(self.root)
+    
+    def _get_nodes(self, root:Node) -> List[Node]:
+        self.nodes = []
+        self._get_nodes(root.left)
+        if root.left and root.right:
+            self.nodes.append(root)
+        self._get_nodes(root.right)
+        return self.nodes
+    
+    def update(self) -> None:
+        self.leaves = []
+        self.leaves_parents = []
+        self.traverse(self.root, type_='update_leaves')
+        self.traverse(self.root, type_='get_leaves_parents')
+
+class Proposal:
+    def __init__(self, 
+                 type_,
+                 tree, 
+                 problem_type,
+                 p_grow, 
+                 p_prune, 
+                 sigma, 
+                 sigma_mu, 
+                 alpha, 
+                 beta):
+        self.type_ = type_
+        self.tree = tree
+        self.problem_type = problem_type
+        self.beta = beta
+        self.alpha = alpha
+        self.p_grow = p_grow
+        self.p_prune = p_prune
+        self.sigma_mu = sigma_mu
+        self.sigma = sigma
+        if self.problem_type == 'uplift_modeling':
+            self.predictors = self.tree.predictors[:-1] + [-1]
+        else:
+            self.predictors = self.tree.predictors
+        if self.type_ == 'grow':
+            self.b = len(tree.leaves)
+            self.node_to_modify = np.random.choice(tree.leaves)
+        else:
+            self.b = len(tree.leaves) - 1
+            self.node_to_modify = np.random.choice(tree.get_n_second_gen_internal_nodes(return_nodes=True))
+        self.r = None
+        # if root, choose treatment variable when problem type is uplift modeling
+        if len(self.tree.leaves) == 1 and self.problem_type == 'uplift_modeling':
+            # set split to be the treatment variable
+            self.proposed_predictor = -1
+            self.proposed_value = 0.5
+            self.r = 1 # accept grow always
+        else:
+            self.proposed_predictor = np.random.choice(self.node_to_modify.data.available_predictors_for_split)
+            self.proposed_value = np.random.normal(self.node_to_modify.data.X[:, self.proposed_predictor].mean(), self.node_to_modify.data.X[:, self.proposed_predictor].std())
+            self.p_adj_eta = self.get_p_adj()
+            self.nj_adj_eta = self.get_n_adj()
+            self.w2 = tree.get_n_second_gen_internal_nodes()
+        if self.type_ == 'grow':
+            self.left_node, self.right_node = self.create_split()
+        else:
+            self.left_node, self.right_node = self.node_to_modify.left, self.node_to_modify.right
+
+    def get_p_adj(self) -> int:
+        return len(self.node_to_modify.data.available_predictors_for_split)
+
+    def get_n_adj(self) -> int:
+        return self.node_to_modify.data.X[:, self.proposed_predictor].size
+    
+    def get_transition_ratio(self) -> float:
+        return (self.p_prune * self.b * self.p_adj_eta * self.nj_adj_eta) / (self.p_grow * self.w2)
+
+    def get_node_weighted_averate(self, node:Node) -> float:
+        return node.data.R.sum()**2 / (self.sigma**2 + node.nobs * self.sigma_mu**2)    
+
+    def create_split(self) -> Tuple[Node]:
+        X_data = self.node_to_modify.data.X
+        y_data = self.node_to_modify.data.y
+        R_data = self.node_to_modify.data.R
+        t_data = self.node_to_modify.data.treatment
+        i_data = self.node_to_modify.data.index
+        mask_left = X_data[:, self.proposed_predictor] < self.proposed_value
+        mask_right = X_data[:, self.proposed_predictor] >= self.proposed_value
+        
+        if (X_data[np.where(mask_left)].shape[0] <= 1 or X_data[np.where(mask_right)].shape[0] <= 1):
+            self.r = 0 # reject always if data in leaf is not minimum size
+            return None, None
+            
+        available_values_per_col = None
+        available_predictors_for_split = None
+        left_data = Data(X=X_data[np.where(mask_left)], 
+                         y=y_data[np.where(mask_left)], 
+                         R=R_data[np.where(mask_left)], 
+                         index= i_data[np.where(mask_left)], 
+                         treatment=t_data[np.where(mask_left)] if self.problem_type == 'uplift_modeling' else None,                      
+                         available_values_per_col=available_values_per_col,
+                         available_predictors_for_split=available_predictors_for_split)
+        right_data = Data(X=X_data[np.where(mask_right)], 
+                          y=y_data[np.where(mask_right)], 
+                          R=R_data[np.where(mask_right)], 
+                          index= i_data[np.where(mask_right)], 
+                          treatment=t_data[np.where(mask_right)] if self.problem_type == 'uplift_modeling' else None,                      
+                          available_values_per_col=available_values_per_col,
+                          available_predictors_for_split=available_predictors_for_split)
+        depth = self.node_to_modify.depth + 1
+        return (
+                Node(data=left_data, 
+                     depth=depth, 
+                     type_='terminal',
+                     parent=self.node_to_modify, 
+                    ), 
+                Node(data=right_data, 
+                     depth=depth, 
+                     type_='terminal',
+                     parent=self.node_to_modify,
+                    )
+        )
+
+    def get_likelihood_ratio(self) -> float:
+        nl = self.node_to_modify.nobs
+        nll = self.left_node.nobs
+        nlr = self.right_node.nobs
+        sv = self.sigma**2 
+        left_term = np.sqrt((sv * (sv + nl*sv)) / ( (sv + nll*self.sigma_mu**2) * (sv + nlr*self.sigma_mu**2)))
+        nlwa = self.get_node_weighted_averate(node=self.left_node)
+        nrwa = self.get_node_weighted_averate(node=self.right_node)
+        nwa = self.get_node_weighted_averate(node=self.node_to_modify)
+        likelihood_ratio = left_term * np.exp((self.sigma_mu**2 / (2*sv)) * (nlwa + nrwa - nwa))
+        
+        return likelihood_ratio
+    
+    def get_tree_structure_ratio(self) -> float:
+        numerator = self.alpha * (1 - (self.alpha / (2 + self.node_to_modify.depth)**self.beta) )**2
+        denominator = ((1 + self.node_to_modify.depth)**self.beta - self.alpha) * self.p_adj_eta * self.nj_adj_eta
+        return numerator / denominator
+    
+    def compute_r(self) -> float:
+        if self.r is None:
+            tr = self.get_transition_ratio()
+            lr = self.get_likelihood_ratio()
+            tsr = self.get_tree_structure_ratio()
+            if self.type_ == 'grow':
+                r = tr * lr * tsr
+            elif self.type_ == 'prune':
+                r = 1/tr * 1/lr * 1/tsr
+            return r
+        else:
+            return self.r
+    
+    def accept(self) -> Tree:
+        if self.type_ == 'grow':
+            self.node_to_modify.type_ = 'split'
+            self.node_to_modify.left = self.left_node
+            self.node_to_modify.right = self.right_node
+            self.node_to_modify.feature = self.proposed_predictor
+            self.node_to_modify.threshold = self.proposed_value
+            self.tree.update()
+        else:
+            self.node_to_modify.type_ = 'terminal'
+            self.node_to_modify.left = None
+            self.node_to_modify.right = None
+            self.tree.update()
+        return self.tree
+
+class BART:
+    """A class that implements the logic for Bayesian Additive Regression Trees for both causal
+    inference and classic ML settings.
+    
+    References:
+    [1] Chipman et al. (2010) (https://arxiv.org/abs/0806.3286)
+    [2] Hill (2011) (https://www.researchgate.net/publication/236588890_Bayesian_Nonparametric_Modeling_for_Causal_Inference)
+    [3] Kapelner and Bleich (2014) (https://arxiv.org/abs/1312.2171)
+    [4] Tan and Roy (2019) (https://arxiv.org/abs/1901.07504)
+    """
+    
+    def __init__(self, v:int = 3, q:float = 0.9, k:int = 2, m:int = 200, alpha:float = 0.95, beta:float = 2) -> None:
+        """Initialize BART.
+        Args:
+            v (optional): Parameter for sigma prior's alpha and beta calculation. Default = 3.
+            q (optional): Parameter for sigma prior's definition. Default = 0.9.
+            k (optional): Parameter initializing sigma_mu. Default = 2.
+            m (optional): Number of trees. Default = 200.
+            alpha (optional): Parameter used for calculating the probability of selecting a leaf node to be modified. 
+                                Default = 0.95
+            beta (optional): Parameter used for calculating the probability of selecting a leaf node to be modified. 
+                                Default = 2
+        """        
+        self.v = v
+        self.q = q
+        self.k = k
+        self.m = m
+        self.alpha = alpha
+        self.beta = beta
+        self.available_mutations = ['grow', 'prune']
+        self.available_mutations_prob = [0.5, 0.5]
+
+    def sample_ig(self, alpha:float, beta:float) -> float:
+        """A method to sample from the inverse gamma distribution.
+        """
+        return ss.invgamma(alpha, beta).rvs()
+    
+    def grow_prune(self, sigma:float, sigma_mu:float, tree:Tree) -> Tree:
+        """A method to sample a new tree.
+        """
+        mutation_type = 'grow' if len(tree.leaves) == 1 else np.random.choice(self.available_mutations, p=self.available_mutations_prob)
+        tree_copy = copy.deepcopy(tree)
+        p = Proposal(tree=tree_copy,
+                     type_=mutation_type,
+                     problem_type=self.problem_type,
+                     p_grow=self.available_mutations_prob[0], 
+                     p_prune=self.available_mutations_prob[1],
+                     sigma=sigma,
+                     sigma_mu=sigma_mu,
+                     alpha=self.alpha,
+                     beta=self.beta)
+        r = p.compute_r()
+        unif_sample = np.random.uniform(0, 1)
+        if unif_sample < r:
+            tree = p.accept()
+            return tree
+        else:
+            return tree
+
+    def get_all_other_trees_predictions(self, X:np.ndarray, trees:List[Tree], j:int) -> np.ndarray:
+        """Computes the predictions of all trees but j
+        """
+        predictions = np.zeros((X.shape[0], 1))
+        for i in range(len(trees)):
+            if i != j:
+                predictions += trees[i].predict(X)
+        return predictions
+
+    def compute_residual(self, X:np.ndarray, y:np.ndarray, trees:List[Tree], j:int) -> np.ndarray:
+        """Computes the residual Rj according to eq.12 from [1]
+        """
+        predictions = self.get_all_other_trees_predictions(X, trees, j)
+        return y.reshape(-1, 1) - predictions
+    
+    def get_lambda(self, X:np.ndarray, y:np.ndarray) -> float:
+        """Calculates the lambda parameter to be used for sigma's prior definition
+        """
+        X = sm.add_constant(X)
+        model = sm.OLS(y, X)
+        results = model.fit()
+        return results.resid.std().item()**2 * 0.9
+        
+    def sample_gd(self, mu:float, sigma:float) -> float:
+        """Sample from gaussian distribution
+        """
+        return np.random.normal(loc=mu, scale=sigma)
+
+    def sample_leaves(self, tree:Tree, sigma_mu:float, sigma:float) -> None:
+        """Sample leaf values according to eq.16 from [1]
+        """
+        for leaf in tree.leaves:
+            sms = sigma_mu**2
+            ss = sigma**2 / leaf.nobs
+            residuals_mean = leaf.data.R.sum() / leaf.nobs
+            sms = 1. / (1. / sms + 1. / ss)
+            pm = residuals_mean * (sms / (ss + sms))
+            leaf.value = pm + (np.random.normal() * np.sqrt(sms / self.m))
+
+    def rescale_y(self, transformed_y:np.ndarray) -> np.ndarray:
+        """Transform response from [-0.5, 0.5] to original scale
+        """
+        return (transformed_y + 0.5) * (self.y_max - self.y_min) + self.y_min
+    
+    def sigmoid(self, x:np.ndarray) -> np.ndarray:
+        """Calculates the lambda parameter to be used for sigma's prior definition
+        """
+        return 1 / (1 + np.exp(-x))
+    
+    def transform_y(self, y:np.ndarray) -> np.ndarray:
+        """Transform response to a [-0.5, 0.5] interval
+        """
+        return ((y - self.y_min) / (self.y_max - self.y_min)) - 0.5
+        
+    def min_el(self, x:np.ndarray) -> np.ndarray:
+        """Clip values greater than 0
+        """
+        return np.array(list(map(lambda z: min(z, 0), x.flatten()))).reshape(-1, 1)
+
+    def max_el(self, x:np.ndarray) -> np.ndarray:
+        """Clip values less than 0
+        """
+        return np.array(list(map(lambda z: max(z, 0), x.flatten()))).reshape(-1, 1)
+    
+    def fit(self, X:np.ndarray, y:np.ndarray, treatment:np.ndarray = None, max_iter:int = 100) -> None:
+        """Fit the BART for either uplift modeling or classic ML setting.
+        Args:
+            X (np.array): a feature matrix
+            y (np.array): an outcome vector
+            treatment (np.array): a treatment vector
+            max_ter (int): maximum number of iterations. Stopping criteria 
+        """
+
+        if treatment is not None:
+            self.problem_type = 'uplift_modeling'
+            if np.unique(treatment).size > 2:
+                raise Exception('Number of treatments greater than 2. Currently this method only supports binary treatment.')
+            self.treatments = np.unique(treatment).astype(int)
+            X = np.concatenate([X, treatment], axis=1)
+        else:
+            self.problem_type = 'classic_ml'
+            
+        self.task = 'regression' if len(np.unique(y)) > 2 else 'classification'
+        self.y_min = y.min()
+        self.y_max = y.max()
+        
+        if self.task == 'regression':
+            sigma_mu = 0.5 / (self.k * np.sqrt(self.m))
+            transformed_y = self.transform_y(y=y)
+            self.lambda_ = self.get_lambda(X, transformed_y)
+            alpha_ig = self.v / 2 
+            beta_ig = self.v * self.lambda_ / 2
+            sigma = self.sample_ig(alpha=alpha_ig, beta=beta_ig)
+        else:
+            transformed_y = y
+            sigma_mu = 3 / (self.k * np.sqrt(self.m))
+            sigma = 1
+            
+        mean_value_per_tree = transformed_y.mean() / self.m
+        self.sum_of_trees = transformed_y.mean()
+        self.trees = [Tree(root=Node(value=mean_value_per_tree, 
+                                     type_='terminal', 
+                                     data=Data(X=X, 
+                                               treatment=treatment,
+                                               y=transformed_y, 
+                                               R=transformed_y-mean_value_per_tree*(self.m-1),
+                                               index=np.array(list(range(len(X)))))), 
+                          ) for i in range(self.m)]
+    
+        for i in tqdm(range(max_iter), position=0, leave=True):
+            if self.task == 'regression':
+                response = transformed_y
+            else:
+                sample = np.random.normal(loc=self.sum_of_trees, scale=1, size=(len(transformed_y), 1))
+                max_els = self.max_el(sample)
+                min_els = self.min_el(sample)
+                response = np.where(y.reshape(-1, 1) == 1, max_els, min_els) # Z in the paper
+
+            for j in range(len(self.trees)):
+                residuals = self.compute_residual(X=X, y=response, trees=self.trees, j=j) # opportunity to parallelize according to Pratola et al. (2013) (https://arxiv.org/abs/1309.1906)
+                self.trees[j].update_residuals(residuals)
+                new_tree = self.grow_prune(sigma=sigma, sigma_mu=sigma_mu, tree=self.trees[j])
+                self.sample_leaves(tree=new_tree, sigma_mu=sigma_mu, sigma=sigma)
+                self.trees[j] = new_tree
+
+            y_pred = self.predict(X, train=True) # opportunity to parallelize according to Pratola et al. (2013) (https://arxiv.org/abs/1309.1906)
+            self.sum_of_trees = y_pred
+            if self.task == 'regression':
+                squared_error = (transformed_y.reshape(-1, 1) - y_pred)**2
+                p_alpha = (alpha_ig + len(y_pred)) / 2
+                p_beta = (beta_ig + squared_error.sum()) / 2
+                sigma = 1. / np.sqrt(np.random.gamma(p_alpha, 1./p_beta))
+
+    def _predict(self, X:np.ndarray, rescale:bool) -> np.ndarray:
+        """Private method for prediction that works equally for Classic ML and Uplift Modeling
+        """
+        # predict for each tree and aggregate
+        predictions = np.zeros((X.shape[0], 1))
+        for tree in self.trees:
+            predictions += tree.predict(X)
+            
+        if self.task == 'classification':
+            return self.sigmoid(predictions)
+        
+        if rescale:
+            predictions = self.rescale_y(predictions)
+        
+        return predictions
+    
+    def predict(self, X:np.ndarray, train:bool = False, rescale:bool = False, full_output:bool = False) -> np.ndarray:
+        """Predict treatment effects if the problem type is uplift modeling or one-dimensional response if 
+        problem type is classic ml.
+        Args:
+            X (np.array): A feature matrix
+            train (bool): Optional. To be used only by private methods. Distinguishes if prediction to be done for
+                            each treatment in case of uplift modeling setting.
+            rescale (bool): True if output wanted to be in the same scale as the original y.
+            full_output (bool): True if the predictions for each treatment, alongside with the deltas with control
+                                    as baseline. False if only deltas to be returned.
+        Returns:
+            (pd.DataFrame): Predictions of treatment effects if the problem type is uplift modeling or one-dimensional 
+                                response if problem type is classic ml.
+        """
+        if self.problem_type == 'uplift_modeling' and not train:
+            columns = []
+            predictions = []
+            for treatment in self.treatments:
+                treatment_predictions = self._predict(np.concatenate([X, np.ones((len(X), 1)) * treatment], axis=1), rescale)
+                predictions.append(treatment_predictions.flatten().tolist())
+                columns.append(f'treatment_{treatment}' if treatment > 0 else 'control')
+            
+            df_res = pd.DataFrame(np.array(predictions).T, columns=columns)
+            
+            # From: https://github.com/uber/causalml/blob/c42e873061eb74ec9c3ca6ea991e113b886245ae/causalml/inference/tree/uplift.pyx
+            df_res['recommended_treatment'] = df_res.apply(np.argmax, axis=1)
+
+            # Calculate delta
+            for treatment in self.treatments[1:]:
+                df_res[f'delta_{treatment}'] = df_res[f'treatment_{treatment}'] - df_res['control']
+
+            if full_output:
+                return df_res
+            else:
+                return df_res[[col for col in df_res.columns if 'delta' in col]].values
+        else:
+            predictions = self._predict(X, rescale)
+        return predictions
\ No newline at end of file

From 7f937dc7e5e4bb924c751efda49299203fb70a34 Mon Sep 17 00:00:00 2001
From: Caio Guirado <caioguirado@yahoo.com.br>
Date: Wed, 24 Aug 2022 14:39:43 +0200
Subject: [PATCH 2/5] Add tests for BART

---
 tests/test_bart.py | 50 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 tests/test_bart.py

diff --git a/tests/test_bart.py b/tests/test_bart.py
new file mode 100644
index 00000000..b305c0b3
--- /dev/null
+++ b/tests/test_bart.py
@@ -0,0 +1,50 @@
+import numpy as np
+import pandas as pd
+from causalml.inference.tree import BART
+from causalml.inference.tree.bart import Data, Node, Tree
+from sklearn.model_selection import train_test_split
+from causalml.metrics import get_cumgain
+
+def test_Second_gen_internal_nodes(generate_regression_data):
+    y, X, treatment, tau, b, e = generate_regression_data()
+    n9 = Node(data=Data(X=X, y=y), left=None, right=None, value=9, feature='f9', threshold=0.5, type_='terminal')
+    n8 = Node(data=Data(X=X, y=y), left=None, right=None, value=8, feature='f8', threshold=0.5, type_='terminal')    
+    n7 = Node(data=Data(X=X, y=y), left=None, right=None, value=7, feature='f7', threshold=0.5, type_='terminal')
+    n6 = Node(data=Data(X=X, y=y), left=n8, right=n9, value=6, feature='f6', threshold=0.5, type_='split')
+    n5 = Node(data=Data(X=X, y=y), left=None, right=None, value=5, feature='f5', threshold=0.5, type_='terminal')
+    n4 = Node(data=Data(X=X, y=y), left=None, right=None, value=4, feature='f4', threshold=0.5, type_='terminal')
+    n3 = Node(data=Data(X=X, y=y), left=n6, right=n7, value=3, feature='f3', threshold=0.5, type_='split')
+    n2 = Node(data=Data(X=X, y=y), left=n4, right=n5, value=2, feature='f2', threshold=0.5, type_='split')
+    n1 = Node(data=Data(X=X, y=y), left=n2, right=n3, value=1, feature='f1', threshold=0.5, type_='split')
+
+    t = Tree(root=n1)
+    assert t.get_n_second_gen_internal_nodes() == 2
+    
+def test_BART(generate_regression_data):
+    y, X, w, tau, b, e = generate_regression_data()
+    X_train, X_test, y_train, y_test = train_test_split(np.concatenate([X, w.reshape(-1, 1), tau.reshape(-1, 1)], axis=1), 
+                                                        y, 
+                                                        stratify=pd.qcut(y, 10), 
+                                                        test_size=0.25, 
+                                                        random_state=42)
+    tau_train = X_train[:, -1].reshape(-1, 1)
+    w_train = X_train[:, -2].reshape(-1, 1)
+    X_train = X_train[:, :-2]
+    tau_test = X_test[:, -1].reshape(-1, 1)
+    w_test = X_test[:, -2].reshape(-1, 1)
+    X_test = X_test[:, :-2]
+    
+    bart = BART(m=35)
+    bart.fit(X=X_train, treatment=w_train, y=y_train, max_iter=50)
+    
+    y_pred = bart.predict(X_test, rescale=True)
+    auuc_metrics = pd.DataFrame({'cate_p':y_pred.flatten(), 
+                                'tau':tau_test.flatten(), 
+                                'w':w_test.flatten(), 
+                                'y': y_test.flatten()})
+    
+    cumgain = get_cumgain(
+        auuc_metrics, outcome_col='y', treatment_col='w', treatment_effect_col='tau'
+    )
+
+    assert cumgain['cate_p'].sum() > cumgain['Random'].sum()
\ No newline at end of file

From e37cd0aaffb89a470d1502c7d07960ead4e1fedf Mon Sep 17 00:00:00 2001
From: Caio Guirado <caioguirado@yahoo.com.br>
Date: Wed, 24 Aug 2022 14:40:37 +0200
Subject: [PATCH 3/5] Add notebook example for BART

---
 examples/bart_with_synthetic_data.ipynb | 1377 +++++++++++++++++++++++
 1 file changed, 1377 insertions(+)
 create mode 100644 examples/bart_with_synthetic_data.ipynb

diff --git a/examples/bart_with_synthetic_data.ipynb b/examples/bart_with_synthetic_data.ipynb
new file mode 100644
index 00000000..f2ff03f3
--- /dev/null
+++ b/examples/bart_with_synthetic_data.ipynb
@@ -0,0 +1,1377 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0c1c57d8",
+   "metadata": {},
+   "source": [
+    "## BART for classical ML and uplift modeling"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43f8a932",
+   "metadata": {},
+   "source": [
+    "This notebook shows how to use the BART implementation for both a classic ML setting and causal inference. \n",
+    "References:\n",
+    "\n",
+    "[[1] Chipman et al. (2010)](https://arxiv.org/abs/0806.3286)\\\n",
+    "[[2] Hill (2011)](https://www.researchgate.net/publication/236588890_Bayesian_Nonparametric_Modeling_for_Causal_Inference)\\\n",
+    "[[3] Kapelner and Bleich (2014)](https://arxiv.org/abs/1312.2171)\\\n",
+    "[[4] Tan and Roy (2019)](https://arxiv.org/abs/1901.07504)\\\n",
+    "[BartPy](https://github.com/JakeColtman/bartpy)\n",
+    "\n",
+    "Remarks:\n",
+    " - Current implementation for uplift modeling only handles binary treatment.\n",
+    " - Also, only regression and binary classification problems. \n",
+    "     [Kindo et al. (2014)](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.756.2187&rep=rep1&type=pdf) proposes an extension to multiclass.\n",
+    " - Parallelization \n",
+    "     [Pratola et al. (2013)](https://arxiv.org/abs/1309.1906)\n",
+    " - Include support for confidence intervals on predictions\n",
+    " - Add support for MCMC statistics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "84c0a49c",
+   "metadata": {},
+   "source": [
+    "## 1 Classic ML setting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "9f648b5f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Only if running this notebook inside the repository tree\n",
+    "import os\n",
+    "import sys\n",
+    "module_path = os.path.abspath(os.path.join('..'))\n",
+    "if module_path not in sys.path:\n",
+    "    sys.path.append(module_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6047cbdd",
+   "metadata": {},
+   "source": [
+    "### 1.1 Regression problem "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1093bf83",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Failed to import duecredit due to No module named 'duecredit'\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "from causalml.inference.tree import BART\n",
+    "from causalml.metrics import get_cumgain\n",
+    "from causalml.dataset import synthetic_data\n",
+    "from causalml.metrics import plot_gain\n",
+    "\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.datasets import make_regression, make_classification\n",
+    "from sklearn.metrics import mean_squared_error, classification_report\n",
+    "\n",
+    "SEED = 42\n",
+    "FIGSIZE = (15, 5)\n",
+    "\n",
+    "np.random.seed(SEED)\n",
+    "plt.rcParams['figure.figsize'] = FIGSIZE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6a15bc17",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████| 50/50 [00:32<00:00,  1.54it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "X, y = make_regression(n_samples=1000, n_features=1, n_informative=1, random_state=SEED)\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=pd.qcut(y, 10), test_size=0.25, random_state=SEED)\n",
+    "\n",
+    "bart = BART(m=35)\n",
+    "bart.fit(X=X_train, y=y_train, max_iter=50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "01bc3b20",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1500x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "f, (ax1, ax2) = plt.subplots(1, 2)\n",
+    "\n",
+    "y_pred = bart.predict(X_test, rescale=True)\n",
+    "sns.distplot(y_test, label='ground_truth', ax=ax1)\n",
+    "sns.distplot(y_pred.flatten(), label='predictions', ax=ax1)\n",
+    "ax1.set_title('[Density] Predictions vs Actual')\n",
+    "\n",
+    "ax2.scatter(X_test, y_test, label='_nolegend_')\n",
+    "ax2.scatter(X_test, y_pred, label='_nolegend_')\n",
+    "ax2.set_title('[Data] Predictions vs Actual')\n",
+    "ax2.set_xlabel('x')\n",
+    "ax2.set_ylabel('y')\n",
+    "f.legend(loc='upper center', bbox_to_anchor=(0.5, -0.05),\n",
+    "          fancybox=True, shadow=True, ncol=5)\n",
+    "plt.tight_layout()\n",
+    "plt.show();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9738ac0b",
+   "metadata": {},
+   "source": [
+    "### 1.2 Binary classification problem"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e71dd86b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████| 50/50 [00:27<00:00,  1.79it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.91      0.74      0.82       125\n",
+      "           1       0.78      0.93      0.85       125\n",
+      "\n",
+      "    accuracy                           0.84       250\n",
+      "   macro avg       0.85      0.84      0.83       250\n",
+      "weighted avg       0.85      0.84      0.83       250\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "X, y = make_classification(n_samples=1000, \n",
+    "                           n_features=2, \n",
+    "                           n_informative=2, \n",
+    "                           n_redundant=0, \n",
+    "                           n_classes=2, \n",
+    "                           random_state=SEED) \n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, test_size=0.25, random_state=SEED)\n",
+    "\n",
+    "bart = BART(m=35)\n",
+    "bart.fit(X=X_train, y=y_train, max_iter=50)\n",
+    "\n",
+    "print(classification_report(y_test, np.rint(bart.predict(X_test))))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b801466",
+   "metadata": {},
+   "source": [
+    "## 2 Uplift Modeling"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d11b47e",
+   "metadata": {},
+   "source": [
+    "It's possible to use this implementation of BART for uplift modeling too. The only requirement is to pass an argument to the `treatment` parameter of the `fit` method. Then, the model will automatically switch from a classical ML setting to uplift modeling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f58c32b0",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████| 50/50 [00:28<00:00,  1.73it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "y, X, w, tau, b, e = synthetic_data()\n",
+    "X_train, X_test, y_train, y_test = train_test_split(np.concatenate([X, \n",
+    "                                                                    w.reshape(-1, 1), \n",
+    "                                                                    tau.reshape(-1, 1)], \n",
+    "                                                                   axis=1), \n",
+    "                                                    y, \n",
+    "                                                    stratify=pd.qcut(y, 10), \n",
+    "                                                    test_size=0.25, \n",
+    "                                                    random_state=SEED)\n",
+    "tau_train = X_train[:, -1].reshape(-1, 1)\n",
+    "w_train = X_train[:, -2].reshape(-1, 1)\n",
+    "X_train = X_train[:, :-2]\n",
+    "tau_test = X_test[:, -1].reshape(-1, 1)\n",
+    "w_test = X_test[:, -2].reshape(-1, 1)\n",
+    "X_test = X_test[:, :-2]\n",
+    "\n",
+    "bart = BART(m=35)\n",
+    "bart.fit(X=X_train, treatment=w_train, y=y_train, max_iter=50)\n",
+    "\n",
+    "y_pred = bart.predict(X_test, rescale=True)\n",
+    "df_preds = pd.DataFrame({'BART':y_pred.flatten(), \n",
+    "                         'tau':tau_test.flatten(), \n",
+    "                         'w':w_test.flatten(), \n",
+    "                         'y': y_test.flatten()})\n",
+    "\n",
+    "plot_gain(df_preds, figsize=FIGSIZE, normalize=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "72b6a5ae",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>BART</th>\n",
+       "      <th>tau</th>\n",
+       "      <th>w</th>\n",
+       "      <th>y</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.658087</td>\n",
+       "      <td>0.717919</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.630888</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1.113596</td>\n",
+       "      <td>0.576265</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.371893</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.261420</td>\n",
+       "      <td>0.652550</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.934398</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.281276</td>\n",
+       "      <td>0.904366</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.169660</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-0.653968</td>\n",
+       "      <td>0.308311</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.191269</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       BART       tau    w         y\n",
+       "0  0.658087  0.717919  1.0  2.630888\n",
+       "1  1.113596  0.576265  1.0  1.371893\n",
+       "2  1.261420  0.652550  1.0  2.934398\n",
+       "3  0.281276  0.904366  1.0  2.169660\n",
+       "4 -0.653968  0.308311  0.0  0.191269"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_preds.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fc4afbd3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>control</th>\n",
+       "      <th>treatment_1</th>\n",
+       "      <th>recommended_treatment</th>\n",
+       "      <th>delta_1</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2.469308</td>\n",
+       "      <td>3.127394</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.658087</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1.639152</td>\n",
+       "      <td>2.752749</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.113596</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.901441</td>\n",
+       "      <td>3.162860</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.261420</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1.588156</td>\n",
+       "      <td>1.869432</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.281276</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.721001</td>\n",
+       "      <td>0.067033</td>\n",
+       "      <td>0</td>\n",
+       "      <td>-0.653968</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>245</th>\n",
+       "      <td>0.689043</td>\n",
+       "      <td>2.181622</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.492579</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>246</th>\n",
+       "      <td>1.455704</td>\n",
+       "      <td>2.615783</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.160079</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>247</th>\n",
+       "      <td>1.435684</td>\n",
+       "      <td>2.461155</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.025471</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>248</th>\n",
+       "      <td>1.413157</td>\n",
+       "      <td>3.113892</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.700735</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>249</th>\n",
+       "      <td>1.347076</td>\n",
+       "      <td>2.576665</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.229589</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>250 rows × 4 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      control  treatment_1  recommended_treatment   delta_1\n",
+       "0    2.469308     3.127394                      1  0.658087\n",
+       "1    1.639152     2.752749                      1  1.113596\n",
+       "2    1.901441     3.162860                      1  1.261420\n",
+       "3    1.588156     1.869432                      1  0.281276\n",
+       "4    0.721001     0.067033                      0 -0.653968\n",
+       "..        ...          ...                    ...       ...\n",
+       "245  0.689043     2.181622                      1  1.492579\n",
+       "246  1.455704     2.615783                      1  1.160079\n",
+       "247  1.435684     2.461155                      1  1.025471\n",
+       "248  1.413157     3.113892                      1  1.700735\n",
+       "249  1.347076     2.576665                      1  1.229589\n",
+       "\n",
+       "[250 rows x 4 columns]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_res = bart.predict(X_test, rescale=True, full_output=True)\n",
+    "df_res"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46461e6a",
+   "metadata": {},
+   "source": [
+    "### Optimization oportunities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "5e4639a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cProfile, pstats, io\n",
+    "\n",
+    "def profile(fnc):\n",
+    "    \n",
+    "    \"\"\"Source: https://gist.github.com/jmeisele/703f7ebd9280baf757bc7c228a3a9f9c\n",
+    "        A decorator that uses cProfile to profile a function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def inner(*args, **kwargs):\n",
+    "        \n",
+    "        pr = cProfile.Profile()\n",
+    "        pr.enable()\n",
+    "        retval = fnc(*args, **kwargs)\n",
+    "        pr.disable()\n",
+    "        s = io.StringIO()\n",
+    "        sortby = 'cumulative'\n",
+    "        ps = pstats.Stats(pr, stream=s).sort_stats(sortby)\n",
+    "        ps.print_stats()\n",
+    "        print(s.getvalue())\n",
+    "        return retval\n",
+    "\n",
+    "    return inner"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8ca0a0c",
+   "metadata": {},
+   "source": [
+    "By analyzing the optimization opportunities, both `predict` and `compute_residual` BART's methods comes first with respect to processing time spent. Both steps have a similar logic, and are proposed to be parallelized according to [Pratola et al. (2013)](https://arxiv.org/abs/1309.1906)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7a6729c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████| 50/50 [00:47<00:00,  1.06it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "         214248992 function calls (213393010 primitive calls) in 47.126 seconds\n",
+      "\n",
+      "   Ordered by: cumulative time\n",
+      "\n",
+      "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
+      "        1    0.000    0.000   47.126   47.126 /var/folders/bd/l9rxhc417tx5blpgx4wfbd700000gn/T/ipykernel_38801/1086717040.py:1(run_bart_for_classical_ml)\n",
+      "        1    0.008    0.008   47.111   47.111 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:427(fit)\n",
+      "    61250   23.119    0.000   45.339    0.001 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:77(predict)\n",
+      "     1750    0.004    0.000   44.306    0.025 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:372(compute_residual)\n",
+      "     1750    0.264    0.000   44.302    0.025 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:363(get_all_other_trees_predictions)\n",
+      "116648792   18.188    0.000   18.188    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:58(apply_rule)\n",
+      " 45937500    1.800    0.000    1.800    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:64(predict)\n",
+      "     1750    0.013    0.000    1.356    0.001 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:341(grow_prune)\n",
+      "       50    0.000    0.000    1.312    0.026 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:512(predict)\n",
+      "       50    0.007    0.000    1.312    0.026 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:496(_predict)\n",
+      " 46198687    1.244    0.000    1.244    0.000 {method 'append' of 'list' objects}\n",
+      "750016/1750    0.482    0.000    1.084    0.001 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/copy.py:128(deepcopy)\n",
+      "39662/1750    0.071    0.000    1.073    0.001 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/copy.py:258(_reconstruct)\n",
+      "39662/1750    0.110    0.000    1.061    0.001 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/copy.py:226(_deepcopy_dict)\n",
+      "    61292    0.989    0.000    0.989    0.000 {built-in method numpy.array}\n",
+      "     1750    0.012    0.000    0.165    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:154(__init__)\n",
+      "     5208    0.080    0.000    0.107    0.000 {method 'choice' of 'numpy.random.mtrand.RandomState' objects}\n",
+      "    75824    0.103    0.000    0.103    0.000 {method '__deepcopy__' of 'numpy.ndarray' objects}\n",
+      "  1506859    0.072    0.000    0.072    0.000 {method 'get' of 'dict' objects}\n",
+      "   213310    0.048    0.000    0.071    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/copy.py:242(_keep_alive)\n",
+      "     1750    0.029    0.000    0.063    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:391(sample_leaves)\n",
+      "  1073756    0.047    0.000    0.047    0.000 {built-in method builtins.id}\n",
+      "    24417    0.040    0.000    0.040    0.000 {method 'reduce' of 'numpy.ufunc' objects}\n",
+      "    29353    0.016    0.000    0.036    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/copy.py:200(_deepcopy_list)\n",
+      "    79324    0.010    0.000    0.035    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/copy.py:263(<genexpr>)\n",
+      "11785/11758    0.009    0.000    0.035    0.000 {built-in method numpy.core._multiarray_umath.implement_array_function}\n",
+      "     1751    0.001    0.000    0.035    0.000 {method 'std' of 'numpy.ndarray' objects}\n",
+      "     1751    0.004    0.000    0.034    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:262(_std)\n",
+      "37224/5386    0.033    0.000    0.033    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:90(traverse)\n",
+      "      910    0.018    0.000    0.033    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:215(create_split)\n",
+      "       51    0.000    0.000    0.032    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1174(__iter__)\n",
+      "     1750    0.002    0.000    0.032    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:276(compute_r)\n",
+      "       50    0.000    0.000    0.032    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1212(update)\n",
+      "       51    0.000    0.000    0.032    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1339(refresh)\n",
+      "       52    0.000    0.000    0.031    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1478(display)\n",
+      "     1751    0.022    0.000    0.030    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:195(_var)\n",
+      "    15624    0.004    0.000    0.029    0.000 {method 'sum' of 'numpy.ndarray' objects}\n",
+      "     1750    0.003    0.000    0.027    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:86(update_residuals)\n",
+      "     1644    0.011    0.000    0.026    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:258(get_likelihood_ratio)\n",
+      "       52    0.000    0.000    0.025    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:348(print_status)\n",
+      "    15625    0.002    0.000    0.025    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:46(_sum)\n",
+      "       52    0.000    0.000    0.024    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:342(fp_write)\n",
+      "      106    0.000    0.000    0.024    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:143(inner)\n",
+      "     3500    0.002    0.000    0.024    0.000 <__array_function__ internals>:177(prod)\n",
+      "    12386    0.022    0.000    0.022    0.000 {method 'normal' of 'numpy.random.mtrand.RandomState' objects}\n",
+      "    28809    0.020    0.000    0.020    0.000 {method '__deepcopy__' of 'numpy.generic' objects}\n",
+      "     3500    0.003    0.000    0.020    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2970(prod)\n",
+      "   502150    0.020    0.000    0.020    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/copy.py:182(_deepcopy_atomic)\n",
+      "   187671    0.018    0.000    0.018    0.000 {built-in method builtins.getattr}\n",
+      "     3510    0.005    0.000    0.017    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:69(_wrapreduction)\n",
+      "       54    0.000    0.000    0.017    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/ipykernel/iostream.py:463(flush)\n",
+      "     1753    0.001    0.000    0.016    0.000 {method 'mean' of 'numpy.ndarray' objects}\n",
+      "    63052    0.016    0.000    0.016    0.000 {method 'reshape' of 'numpy.ndarray' objects}\n",
+      "       54    0.000    0.000    0.016    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:540(wait)\n",
+      "       54    0.000    0.000    0.015    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:270(wait)\n",
+      "      431    0.015    0.000    0.015    0.000 {method 'acquire' of '_thread.lock' objects}\n",
+      "     1753    0.006    0.000    0.015    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:162(_mean)\n",
+      "     4932    0.005    0.000    0.015    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:212(get_node_weighted_averate)\n",
+      "    39662    0.012    0.000    0.012    0.000 {method '__reduce_ex__' of 'object' objects}\n",
+      "    39662    0.007    0.000    0.011    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/copyreg.py:90(__newobj__)\n",
+      "     8194    0.002    0.000    0.010    0.000 <__array_function__ internals>:177(where)\n",
+      "    39717    0.009    0.000    0.009    0.000 {method 'update' of 'dict' objects}\n",
+      "     2590    0.002    0.000    0.009    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:121(get_n_second_gen_internal_nodes)\n",
+      "   151395    0.009    0.000    0.009    0.000 {built-in method builtins.issubclass}\n",
+      "    43174    0.008    0.000    0.008    0.000 {method 'items' of 'dict' objects}\n",
+      "     3504    0.007    0.000    0.008    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:66(_count_reduce_items)\n",
+      "        1    0.000    0.000    0.007    0.007 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/model_selection/_split.py:2321(train_test_split)\n",
+      "    87078    0.007    0.000    0.007    0.000 {built-in method builtins.isinstance}\n",
+      "      161    0.000    0.000    0.007    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/ipykernel/iostream.py:202(schedule)\n",
+      "       54    0.000    0.000    0.007    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/ipykernel/iostream.py:518(write)\n",
+      "       54    0.000    0.000    0.007    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/ipykernel/iostream.py:448(_schedule_flush)\n",
+      "      161    0.006    0.000    0.006    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/zmq/sugar/socket.py:543(send)\n",
+      "        1    0.000    0.000    0.006    0.006 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:307(qcut)\n",
+      "       52    0.000    0.000    0.006    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1164(__str__)\n",
+      "        2    0.000    0.000    0.005    0.003 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/model_selection/_split.py:1569(split)\n",
+      "        3    0.000    0.000    0.005    0.002 {built-in method builtins.next}\n",
+      "       52    0.001    0.000    0.005    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:355(format_meter)\n",
+      "        2    0.000    0.000    0.005    0.002 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/model_selection/_split.py:1920(_iter_indices)\n",
+      "        1    0.001    0.001    0.005    0.005 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:391(_bins_to_cuts)\n",
+      "     1751    0.004    0.000    0.004    0.000 {method 'uniform' of 'numpy.random.mtrand.RandomState' objects}\n",
+      "        6    0.000    0.000    0.004    0.001 <__array_function__ internals>:177(unique)\n",
+      "        6    0.000    0.000    0.004    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/arraysetops.py:138(unique)\n",
+      "     1802    0.004    0.000    0.004    0.000 {built-in method numpy.zeros}\n",
+      "        6    0.000    0.000    0.004    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/arraysetops.py:320(_unique1d)\n",
+      "    39682    0.004    0.000    0.004    0.000 {built-in method __new__ of type object at 0x104f02858}\n",
+      "      509    0.000    0.000    0.003    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:289(accept)\n",
+      "     1709    0.003    0.000    0.003    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/getlimits.py:457(__new__)\n",
+      "    45143    0.003    0.000    0.003    0.000 {built-in method builtins.hasattr}\n",
+      "      544    0.000    0.000    0.003    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:147(update)\n",
+      "        3    0.003    0.001    0.003    0.001 {method 'argsort' of 'numpy.ndarray' objects}\n",
+      "     1643    0.001    0.000    0.003    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:11(__init__)\n",
+      "      156    0.000    0.000    0.003    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:333(disp_len)\n",
+      "      156    0.000    0.000    0.003    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:329(_text_width)\n",
+      "     1644    0.003    0.000    0.003    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:271(get_tree_structure_ratio)\n",
+      "      156    0.001    0.000    0.002    0.000 {built-in method builtins.sum}\n",
+      "        2    0.000    0.000    0.002    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:494(check_array)\n",
+      "        1    0.001    0.001    0.002    0.002 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:463(<listcomp>)\n",
+      "        1    0.000    0.000    0.002    0.002 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/model_selection/_split.py:1988(split)\n",
+      "        1    0.000    0.000    0.002    0.002 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:559(_format_labels)\n",
+      "     1643    0.002    0.000    0.002    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:26(get_available_predictors_for_split)\n",
+      "    12462    0.001    0.000    0.002    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:330(<genexpr>)\n",
+      "    41/31    0.000    0.000    0.002    0.000 {built-in method numpy.asarray}\n",
+      "        1    0.000    0.000    0.002    0.002 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/datasets/_samples_generator.py:506(make_regression)\n",
+      "        1    0.000    0.000    0.002    0.002 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/_mixins.py:81(method)\n",
+      "        1    0.000    0.000    0.002    0.002 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/categorical.py:1492(__array__)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:846(__init__)\n",
+      "     3510    0.001    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:70(<dictcomp>)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/categorical.py:365(__init__)\n",
+      "        2    0.001    0.001    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:1421(__array__)\n",
+      "     1643    0.001    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:36(__init__)\n",
+      "13638/13628    0.001    0.000    0.001    0.000 {built-in method builtins.len}\n",
+      "        5    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:1043(check_random_state)\n",
+      "       52    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:341(disp_trim)\n",
+      "     1644    0.001    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:209(get_transition_ratio)\n",
+      "      418    0.001    0.000    0.001    0.000 {method 'format' of 'str' objects}\n",
+      "        2    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:251(_simple_new)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:336(sample_ig)\n",
+      "     1750    0.001    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:205(get_n_adj)\n",
+      "      5/2    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/array_algos/take.py:57(take_nd)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:230(from_breaks)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:858(__call__)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:838(freeze)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:434(__init__)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:1892(__init__)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:389(from_breaks)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:466(from_arrays)\n",
+      "       22    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:623(_round_frac)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:638(_infer_precision)\n",
+      "    12306    0.001    0.000    0.001    0.000 {built-in method unicodedata.east_asian_width}\n",
+      "     1750    0.001    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:202(get_p_adj)\n",
+      "     5284    0.001    0.000    0.001    0.000 {built-in method numpy.asanyarray}\n",
+      "       44    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:51(_wrapfunc)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/__init__.py:602(shuffle)\n",
+      "        2    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:90(_assert_all_finite)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/__init__.py:452(resample)\n",
+      "        1    0.000    0.000    0.001    0.001 <__array_function__ internals>:177(quantile)\n",
+      "        2    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/algorithms.py:336(unique)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:4143(quantile)\n",
+      "       55    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:104(acquire)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:378(get_lambda)\n",
+      "        2    0.001    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/fixes.py:45(_object_dtype_isnan)\n",
+      "     8194    0.001    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/multiarray.py:341(where)\n",
+      "        7    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:6987(ensure_index)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:1002(take)\n",
+      "      103    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:288(format_interval)\n",
+      "     3504    0.001    0.000    0.001    0.000 {built-in method numpy.core._multiarray_umath.normalize_axis_index}\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/categorical.py:2755(_get_codes_for_values)\n",
+      "        3    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:318(check_consistent_length)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:4375(_quantile_unchecked)\n",
+      "        4    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:672(_with_infer)\n",
+      "        9    0.000    0.000    0.001    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:397(__new__)\n",
+      "        1    0.000    0.000    0.001    0.001 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:3651(_ureduce)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:4527(_quantile_ureduce_func)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:329(status_printer)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:4595(_quantile)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:785(_construct_doc)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:182(__init__)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/__init__.py:307(_safe_indexing)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:205(_from_values_or_dtype)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:331(_finalize)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:5744(get_indexer_for)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:643(<listcomp>)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:504(validate_categories)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/doccer.py:13(docformat)\n",
+      "      215    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:1071(is_alive)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(linspace)\n",
+      "       51    0.000    0.000    0.000    0.000 {built-in method now}\n",
+      "       22    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(around)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/algorithms.py:1356(take)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/function_base.py:23(linspace)\n",
+      "       54    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:505(__init__)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/__init__.py:193(_array_indexing)\n",
+      "       55    0.000    0.000    0.000    0.000 {method 'acquire' of '_multiprocessing.SemLock' objects}\n",
+      "     3500    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2965(_prod_dispatcher)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:358(indexable)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:386(is_unique)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1279(close)\n",
+      "        2    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/contextlib.py:72(inner)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/__init__.py:594(<listcomp>)\n",
+      "       22    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:3257(around)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:581(<listcomp>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/_mixins.py:147(take)\n",
+      "       11    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:578(<lambda>)\n",
+      "       50    0.000    0.000    0.000    0.000 {method 'gamma' of 'numpy.random.mtrand.RandomState' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:606(_shallow_copy)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/externals/_packaging/version.py:65(parse)\n",
+      "       22    0.000    0.000    0.000    0.000 {method 'round' of 'numpy.generic' objects}\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/externals/_packaging/version.py:284(__init__)\n",
+      "       55    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:108(release)\n",
+      "        2    0.000    0.000    0.000    0.000 {function SeedSequence.generate_state at 0x1101af040}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/algorithms.py:271(_get_hashtable_algo)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:253(fit)\n",
+      "       52    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1460(format_dict)\n",
+      "       54    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:222(__init__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:749(_index_as_unique)\n",
+      "        2    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(argsort)\n",
+      "      104    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:222(_is_ascii)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:410(is_overlapping)\n",
+      "        5    0.000    0.000    0.000    0.000 {method 'sort' of 'numpy.ndarray' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:1012(argsort)\n",
+      "        2    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/random.py:721(getrandbits)\n",
+      "        8    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/missing.py:67(isna)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:3706(get_indexer)\n",
+      "      301    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:233(__call__)\n",
+      "        8    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/missing.py:150(_isna)\n",
+      "        2    0.000    0.000    0.000    0.000 {built-in method posix.urandom}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:321(_engine)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/algorithms.py:237(_ensure_arraylike)\n",
+      "       12    0.000    0.000    0.000    0.000 {method 'permutation' of 'numpy.random.mtrand.RandomState' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/base.py:744(__iter__)\n",
+      "        2    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(any)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:1958(_attach_methods)\n",
+      "       12    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:54(_any)\n",
+      "      156    0.000    0.000    0.000    0.000 {method 'sub' of 're.Pattern' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:577(_validate)\n",
+      "      215    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:1017(_wait_for_tstate_lock)\n",
+      "       52    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:188(__format__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:690(_attach_argparser_methods)\n",
+      "        1    0.000    0.000    0.000    0.000 {pandas._libs.lib.infer_dtype}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:884(__init__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2305(any)\n",
+      "        1    0.000    0.000    0.000    0.000 {built-in method builtins.exec}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:700(__init__)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/model_selection/_split.py:2444(<genexpr>)\n",
+      "       55    0.000    0.000    0.000    0.000 {method 'release' of '_multiprocessing.SemLock' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:190(__init__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/tools/tools.py:330(pinv_extended)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/algorithms.py:115(_ensure_data)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:464(rvs)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:1026(rvs)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/model.py:266(__init__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/model.py:89(__init__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/missing.py:288(notna)\n",
+      "        2    0.000    0.000    0.000    0.000 {method 'any' of 'numpy.generic' objects}\n",
+      "       14    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/base.py:286(is_dtype)\n",
+      "      2/1    0.000    0.000    0.000    0.000 {built-in method builtins.iter}\n",
+      "       29    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1587(_is_dtype_type)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/array_algos/take.py:120(_take_nd_ndarray)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:638(__iter__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:791(left)\n",
+      "       10    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:254(_num_samples)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/model.py:131(_handle_data)\n",
+      "      161    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/ipykernel/iostream.py:90(_event_pipe)\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'partition' of 'numpy.ndarray' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'randn' of 'numpy.random.mtrand.RandomState' objects}\n",
+      "        9    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/numeric.py:139(_ensure_array)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:1214(left)\n",
+      "       35    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:68(__init__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:665(handle_data)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:638(__init__)\n",
+      "        2    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(svd)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/doccer.py:180(indentcount_lines)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/algorithms.py:308(_check_object_for_strings)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:60(__init__)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_dtype.py:328(_name_get)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:1470(svd)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/_util.py:343(getfullargspec_no_self)\n",
+      "       54    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/ipykernel/iostream.py:429(_is_master_process)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/tools/tools.py:230(add_constant)\n",
+      "       52    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:155(__init__)\n",
+      "        4    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/warnings.py:130(filterwarnings)\n",
+      "        2    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(cumsum)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/missing.py:227(_isna_array)\n",
+      "        2    0.000    0.000    0.000    0.000 {method 'unique' of 'pandas._libs.hashtable.Float64HashTable' objects}\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexers/utils.py:197(validate_indices)\n",
+      "      115    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/generic.py:43(_check)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:1057(__new__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:795(right)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:560(__new__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:4396(_quantile_is_valid)\n",
+      "        5    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(all)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:123(_handle_constant)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:475(_coerce_to_type)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:329(<listcomp>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:4560(_get_indexes)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2495(cumsum)\n",
+      "       10    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/numerictypes.py:356(issubdtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:2232(is_unique)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:161(is_object_dtype)\n",
+      "        9    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:554(_dtype_to_subclass)\n",
+      "       54    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:1306(current_thread)\n",
+      "      108    0.000    0.000    0.000    0.000 {built-in method _thread.allocate_lock}\n",
+      "        9    0.000    0.000    0.000    0.000 {method 'any' of 'numpy.ndarray' objects}\n",
+      "       15    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1240(is_float_dtype)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:970(isna)\n",
+      "       11    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:497(is_categorical_dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:1093(_validate_scalar)\n",
+      "       17    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/abc.py:96(__instancecheck__)\n",
+      "       52    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:57(__init__)\n",
+      "        2    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(result_type)\n",
+      "       12    0.000    0.000    0.000    0.000 {pandas._libs.lib.is_scalar}\n",
+      "       64    0.000    0.000    0.000    0.000 {method 'splitlines' of 'str' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/__init__.py:1021(_approximate_mode)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:3103(signature)\n",
+      "        4    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(concatenate)\n",
+      "    12/11    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:581(is_dtype_equal)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2851(from_callable)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(split)\n",
+      "      2/1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2218(_signature_from_callable)\n",
+      "     1092    0.000    0.000    0.000    0.000 {built-in method builtins.ord}\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2404(all)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/shape_base.py:799(split)\n",
+      "       24    0.000    0.000    0.000    0.000 {method 'extend' of 'list' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'searchsorted' of 'numpy.ndarray' objects}\n",
+      "       14    0.000    0.000    0.000    0.000 {built-in method numpy.empty}\n",
+      "       17    0.000    0.000    0.000    0.000 {built-in method _abc._abc_instancecheck}\n",
+      "        2    0.000    0.000    0.000    0.000 {method 'shuffle' of 'numpy.random.mtrand.RandomState' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(array_split)\n",
+      "      202    0.000    0.000    0.000    0.000 {built-in method time.time}\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:1693(_maybe_convert_platform_interval)\n",
+      "       10    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:654(_simple_new)\n",
+      "        2    0.000    0.000    0.000    0.000 {method 'cumsum' of 'numpy.ndarray' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/shape_base.py:739(array_split)\n",
+      "        7    0.000    0.000    0.000    0.000 {method 'flatten' of 'numpy.ndarray' objects}\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:112(__enter__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_ufunc_config.py:429(__enter__)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_dtype.py:34(__str__)\n",
+      "        6    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/warnings.py:477(__exit__)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(matrix_rank)\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:42(_amin)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_ufunc_config.py:32(seterr)\n",
+      "       20    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/numerictypes.py:282(issubclass_)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:1792(matrix_rank)\n",
+      "        3    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(take)\n",
+      "        4    0.000    0.000    0.000    0.000 {method 'min' of 'numpy.ndarray' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:845(_engine)\n",
+      "        9    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/construction.py:379(extract_array)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/__init__.py:237(_determine_key_type)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:282(_screen_shape_linux)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:6004(_should_compare)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:38(_amax)\n",
+      "        2    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(may_share_memory)\n",
+      "        5    0.000    0.000    0.000    0.000 {method 'max' of 'numpy.ndarray' objects}\n",
+      "        5    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(dot)\n",
+      "       64    0.000    0.000    0.000    0.000 {method 'expandtabs' of 'str' objects}\n",
+      "      105    0.000    0.000    0.000    0.000 {built-in method builtins.max}\n",
+      "        2    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(amin)\n",
+      "        6    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/warnings.py:181(_add_filter)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:348(is_datetime64tz_dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:1224(right)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/externals/_packaging/version.py:467(_cmpkey)\n",
+      "        9    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:7082(maybe_extract_name)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:996(_rvs)\n",
+      "      258    0.000    0.000    0.000    0.000 {built-in method builtins.divmod}\n",
+      "      108    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:1047(ident)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2800(amin)\n",
+      "        1    0.000    0.000    0.000    0.000 <string>:5(_parse_args_rvs)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:93(take)\n",
+      "       13    0.000    0.000    0.000    0.000 {method 'take' of 'numpy.ndarray' objects}\n",
+      "       65    0.000    0.000    0.000    0.000 {method 'join' of 'str' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:484(_maybe_convert_i8)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:4472(_lerp)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1148(needs_i8_conversion)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:1182(__eq__)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_dtype.py:314(_name_includes_bit_suffix)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:877(_argcheck_rvs)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/missing.py:626(is_valid_na_for_dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:783(_is_comparable_dtype)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:680(is_integer_dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/categorical.py:1461(_validate_scalar)\n",
+      "        1    0.000    0.000    0.000    0.000 {pandas._libs.algos.take_1d_int8_int8}\n",
+      "        6    0.000    0.000    0.000    0.000 {method 'search' of 're.Pattern' objects}\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1274(is_bool_dtype)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/algorithms.py:193(_reconstruct_data)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2124(_signature_from_function)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:2665(hasnans)\n",
+      "      216    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:513(is_set)\n",
+      "       33    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1552(get_dtype)\n",
+      "       55    0.000    0.000    0.000    0.000 {method 'acquire' of '_thread.RLock' objects}\n",
+      "       14    0.000    0.000    0.000    0.000 <frozen importlib._bootstrap>:1017(_handle_fromlist)\n",
+      "      215    0.000    0.000    0.000    0.000 {method 'append' of 'collections.deque' objects}\n",
+      "       11    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(swapaxes)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:5917(_maybe_promote)\n",
+      "       54    0.000    0.000    0.000    0.000 {method 'write' of '_io.StringIO' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:583(_decr_instances)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:460(_needs_i8_conversion)\n",
+      "       54    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:246(__enter__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:541(update_dtype)\n",
+      "       54    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:258(_acquire_restore)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:412(transform_y)\n",
+      "        4    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/re.py:250(compile)\n",
+      "        6    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/warnings.py:458(__enter__)\n",
+      "       18    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1483(is_ea_or_datetimelike_dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:110(<lambda>)\n",
+      "        4    0.000    0.000    0.000    0.000 {built-in method numpy.arange}\n",
+      "       54    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:255(_release_save)\n",
+      "        1    0.000    0.000    0.000    0.000 {built-in method fcntl.ioctl}\n",
+      "        5    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/re.py:289(_compile)\n",
+      "       12    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/abc.py:100(__subclasscheck__)\n",
+      "       16    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1747(pandas_dtype)\n",
+      "       16    0.000    0.000    0.000    0.000 {pandas._libs.lib.is_list_like}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/cast.py:1789(find_common_type)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/model_selection/_split.py:2026(_validate_shuffle_split)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:459(is_interval_dtype)\n",
+      "      2/1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/wrapper.py:21(__getattribute__)\n",
+      "       54    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:261(_is_owned)\n",
+      "       57    0.000    0.000    0.000    0.000 {built-in method builtins.abs}\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:60(_all)\n",
+      "        3    0.000    0.000    0.000    0.000 {method 'replace' of 'str' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:704(_construct_argparser)\n",
+      "       54    0.000    0.000    0.000    0.000 {built-in method posix.getpid}\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(amax)\n",
+      "        3    0.000    0.000    0.000    0.000 {method 'all' of 'numpy.ndarray' objects}\n",
+      "       52    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:169(colour)\n",
+      "       54    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/threading.py:249(__exit__)\n",
+      "       60    0.000    0.000    0.000    0.000 {method 'group' of 're.Match' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/cast.py:939(coerce_indexer_dtype)\n",
+      "      114    0.000    0.000    0.000    0.000 {built-in method builtins.min}\n",
+      "       54    0.000    0.000    0.000    0.000 {built-in method _thread.get_ident}\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:540(is_string_dtype)\n",
+      "       11    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:550(swapaxes)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1399(is_1d_only_ea_obj)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2675(amax)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(ptp)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(broadcast_arrays)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:162(__init__)\n",
+      "        1    0.000    0.000    0.000    0.000 {pandas._libs.lib.dtypes_all_equal}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/cast.py:1962(construct_1d_object_array_from_listlike)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:377(<listcomp>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:4450(_get_gamma)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:1575(__init__)\n",
+      "        7    0.000    0.000    0.000    0.000 {method 'remove' of 'list' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 {pandas._libs.algos.take_1d_float64_float64}\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(column_stack)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:1206(is_dtype)\n",
+      "       12    0.000    0.000    0.000    0.000 {built-in method _abc._abc_subclasscheck}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1300(fp_write)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_ufunc_config.py:131(geterr)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(squeeze)\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/inference.py:184(is_array_like)\n",
+      "        9    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:229(disallow_kwargs)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2576(ptp)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_continuous_distns.py:3992(_ppf)\n",
+      "       23    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:147(<lambda>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/extension.py:170(_isnan)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/stride_tricks.py:479(broadcast_arrays)\n",
+      "        2    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/warnings.py:165(simplefilter)\n",
+      "       15    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/sparse/_base.py:1301(isspmatrix)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(count_nonzero)\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:338(_make_indexable)\n",
+      "        6    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/warnings.py:437(__init__)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(bincount)\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:1327(closed)\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:884(__len__)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/array_algos/take.py:554(_take_preprocess_indexer_and_fill_value)\n",
+      "       12    0.000    0.000    0.000    0.000 {method 'astype' of 'numpy.ndarray' objects}\n",
+      "      149    0.000    0.000    0.000    0.000 {method 'lstrip' of 'str' objects}\n",
+      "        3    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2489(__init__)\n",
+      "       18    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/externals/_packaging/version.py:294(<genexpr>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/numeric.py:425(count_nonzero)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/__init__.py:593(<listcomp>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/shape_base.py:612(column_stack)\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'rand' of 'numpy.random.mtrand.RandomState' objects}\n",
+      "       52    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:61(__format__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_methods.py:276(_ptp)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/array_algos/take.py:326(_get_take_nd_function)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:115(__exit__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_ufunc_config.py:434(__exit__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:1812(_signature_bound_method)\n",
+      "        6    0.000    0.000    0.000    0.000 <string>:1(__new__)\n",
+      "       23    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:145(classes)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:315(is_datetime64_dtype)\n",
+      "        2    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2772(__init__)\n",
+      "       55    0.000    0.000    0.000    0.000 {method 'release' of '_thread.RLock' objects}\n",
+      "        9    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/inference.py:321(is_hashable)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(ndim)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/arraysetops.py:125(_unpack_tuple)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(repeat)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:952(_argcheck)\n",
+      "        7    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:574(categories)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/externals/_packaging/version.py:92(__lt__)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1528(_is_dtype)\n",
+      "        3    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(transpose)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:1429(is_extension_array_dtype)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/_config.py:24(get_config)\n",
+      "       10    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:834(_reset_identity)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:436(repeat)\n",
+      "       52    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:165(colour)\n",
+      "        2    0.000    0.000    0.000    0.000 {pandas._libs.algos.ensure_int8}\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:533(is_string_or_object_np_dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:493(unwrap)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:1655(resid)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/numeric.py:149(ones)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/model.py:1339(__init__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:3823(_check_indexing_method)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(diag)\n",
+      "       54    0.000    0.000    0.000    0.000 {method '__enter__' of '_thread.lock' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'copy' of 'numpy.ndarray' objects}\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/cast.py:468(maybe_promote)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:1478(squeeze)\n",
+      "        2    0.000    0.000    0.000    0.000 {method 'all' of 'numpy.generic' objects}\n",
+      "        4    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/types.py:171(__get__)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(putmask)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/_weakrefset.py:106(remove)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:2244(__init__)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:389(is_timedelta64_dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:215(_supports_unicode)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/contextlib.py:238(helper)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/twodim_base.py:234(diag)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/_monitor.py:94(report)\n",
+      "        4    0.000    0.000    0.000    0.000 {built-in method numpy.seterrobj}\n",
+      "        2    0.000    0.000    0.000    0.000 <frozen importlib._bootstrap>:389(parent)\n",
+      "        1    0.000    0.000    0.000    0.000 {method '_from_backing_data' of 'pandas._libs.arrays.NDArrayBacked' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:135(_commonType)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/model_selection/_split.py:1909(__init__)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/_dtype.py:24(_kind_name)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:601(transpose)\n",
+      "       11    0.000    0.000    0.000    0.000 {method 'swapaxes' of 'numpy.ndarray' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/_weakrefset.py:81(add)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:111(_makearray)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/re.py:188(match)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/_weakrefset.py:58(__iter__)\n",
+      "       54    0.000    0.000    0.000    0.000 {method 'release' of '_thread.lock' objects}\n",
+      "       22    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:3253(_around_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:579(<lambda>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2865(replace)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:589(_preprocess_for_cut)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/missing.py:572(na_value_for_dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:315(_convert_endog_exog)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/contextlib.py:108(__enter__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:793(<genexpr>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:355(predict)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:890(__array__)\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'repeat' of 'numpy.ndarray' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/_util.py:389(<dictcomp>)\n",
+      "        2    0.000    0.000    0.000    0.000 {method 'remove' of 'set' objects}\n",
+      "       10    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:937(dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/tools/data.py:94(_is_using_pandas)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/numeric.py:1859(isscalar)\n",
+      "       54    0.000    0.000    0.000    0.000 {method '__exit__' of '_thread.lock' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/contextlib.py:82(__init__)\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:641(__len__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:105(__init__)\n",
+      "        9    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/numeric.py:199(_ensure_dtype)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(copyto)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/stride_tricks.py:415(_broadcast_shape)\n",
+      "        1    0.000    0.000    0.000    0.000 {built-in method utcfromtimestamp}\n",
+      "       18    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/externals/_packaging/version.py:416(_parse_letter_version)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:485(validate_ordered)\n",
+      "        7    0.000    0.000    0.000    0.000 {method 'split' of 'str' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/categorical.py:716(categories)\n",
+      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:177(copy)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/reshape/tile.py:606(_postprocess_for_cut)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:201(_is_utf)\n",
+      "        9    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:1120(closed)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:136(disable_on_exception)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/model.py:1040(__init__)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:155(<lambda>)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/construction.py:438(ensure_wrapped_if_datetimelike)\n",
+      "        2    0.000    0.000    0.000    0.000 {built-in method from_bytes}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/stride_tricks.py:537(<listcomp>)\n",
+      "       18    0.000    0.000    0.000    0.000 {built-in method _warnings._filters_mutated}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/utils/validation.py:484(_ensure_no_complex_data)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/contextlib.py:117(__exit__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:2272(is_boolean)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:101(wrapper_setattr)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/_config.py:16(_get_threadlocal_config)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/extension.py:58(cached)\n",
+      "        2    0.000    0.000    0.000    0.000 {built-in method pandas._libs.missing.checknull}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/missing.py:911(clean_reindex_fill_method)\n",
+      "        8    0.000    0.000    0.000    0.000 {built-in method numpy.geterrobj}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:414(_get_yarr)\n",
+      "        6    0.000    0.000    0.000    0.000 {method 'insert' of 'list' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:194(initialize)\n",
+      "       10    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:4820(_values)\n",
+      "        1    0.000    0.000    0.000    0.000 {pandas._libs.lib.is_integer}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:1980(_updated_ctor_param)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/model_selection/_split.py:1560(__init__)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:150(classes_and_not_datetimelike)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:3164(ndim)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/categorical.py:476(dtype)\n",
+      "        5    0.000    0.000    0.000    0.000 {method 'copy' of 'dict' objects}\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:228(__init__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:5178(equals)\n",
+      "        4    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/enum.py:748(value)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/_util.py:365(<listcomp>)\n",
+      "        9    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/numeric.py:188(_validate_dtype)\n",
+      "        2    0.000    0.000    0.000    0.000 {method 'add' of 'set' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/inference/tree/bart.py:315(__init__)\n",
+      "        7    0.000    0.000    0.000    0.000 {method 'keys' of 'dict' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:2624(_is_multi)\n",
+      "        4    0.000    0.000    0.000    0.000 {method 'squeeze' of 'numpy.ndarray' objects}\n",
+      "       13    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/base.py:326(ndim)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/wrapper.py:22(<lambda>)\n",
+      "        1    0.000    0.000    0.000    0.000 {built-in method math.ceil}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/shape_base.py:608(_column_stack_dispatcher)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:171(__eq__)\n",
+      "        2    0.000    0.000    0.000    0.000 {built-in method builtins.all}\n",
+      "        4    0.000    0.000    0.000    0.000 {pandas._libs.algos.ensure_platform_int}\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:129(_realType)\n",
+      "        8    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:1124(subtype)\n",
+      "        7    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/interval.py:622(dtype)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/arraysetops.py:133(_unique_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:4846(_get_engine_target)\n",
+      "        9    0.000    0.000    0.000    0.000 {built-in method builtins.hash}\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/common.py:569(condition)\n",
+      "        3    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/enum.py:313(__call__)\n",
+      "        2    0.000    0.000    0.000    0.000 {method 'ravel' of 'numpy.ndarray' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:846(copy)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:7168(unpack_nested_dtype)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/_util.py:380(<genexpr>)\n",
+      "        8    0.000    0.000    0.000    0.000 {method 'values' of 'mappingproxy' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:88(__getattr__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:646(handle_data_class_factory)\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2399(_all_dispatcher)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/tools/data.py:114(_is_recarray)\n",
+      "        4    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2821(<genexpr>)\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'item' of 'numpy.generic' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/base.py:143(na_value)\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/externals/_packaging/version.py:455(_parse_local_version)\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'encode' of 'str' objects}\n",
+      "        6    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/sklearn/externals/_packaging/version.py:482(<lambda>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:6293(_maybe_cast_listlike_indexer)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/model.py:115(_check_kwargs)\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:1166(type)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:116(isComplexType)\n",
+      "        5    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/multiarray.py:736(dot)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:74(__eq__)\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'match' of 're.Pattern' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:907(<listcomp>)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/tools/data.py:31(_is_structured_ndarray)\n",
+      "        5    0.000    0.000    0.000    0.000 {method 'pop' of 'dict' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/_weakrefset.py:26(__exit__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/cycler.py:239(__iter__)\n",
+      "       16    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2551(kind)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:657(get_lock)\n",
+      "        4    0.000    0.000    0.000    0.000 {built-in method builtins.setattr}\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/multiarray.py:148(concatenate)\n",
+      "        2    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/contextlib.py:59(_recreate_cm)\n",
+      "        3    0.000    0.000    0.000    0.000 {method 'transpose' of 'numpy.ndarray' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/_util.py:209(check_random_state)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/shape_base.py:207(_arrays_for_stack_dispatcher)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:106(get_linalg_error_extobj)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/util/_exceptions.py:8(rewrite_exception)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/_util.py:370(<listcomp>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/_weakrefset.py:20(__enter__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/multiarray.py:664(result_type)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/tools/decorators.py:106(__set__)\n",
+      "       11    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:546(_swapaxes_dispatcher)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2300(_any_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:431(_check_integrity)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/ipykernel/iostream.py:304(fileno)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:1650(name)\n",
+      "        2    0.000    0.000    0.000    0.000 {method 'rpartition' of 'str' objects}\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:89(_take_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:2677(isna)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/_util.py:385(<listcomp>)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1171(__hash__)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/model.py:1047(initialize)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:436(wrap_output)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/stride_tricks.py:541(<genexpr>)\n",
+      "        4    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/interval.py:365(inferred_type)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:426(_get_xarr)\n",
+      "        2    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:158(isfunction)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:1474(_squeeze_dispatcher)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2491(_cumsum_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:4138(_quantile_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/_util.py:392(<dictcomp>)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1167(_comparable)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/missing.py:107(clean_fill_method)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/_lib/_util.py:375(<listcomp>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:936(<listcomp>)\n",
+      "        2    0.000    0.000    0.000    0.000 {built-in method _weakref.proxy}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/function_base.py:18(_linspace_dispatcher)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:193(_assert_stacked_2d)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/utils.py:231(_screen_shape_wrapper)\n",
+      "        1    0.000    0.000    0.000    0.000 <string>:2(<module>)\n",
+      "        8    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2857(parameters)\n",
+      "        4    0.000    0.000    0.000    0.000 {pandas._libs.lib.is_iterator}\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:513(_is_wrapper)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/compat/numpy/function.py:49(__call__)\n",
+      "        7    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2539(name)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/tools/data.py:84(_is_using_ndarray_type)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/model.py:1396(use_t)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/wrapper.py:14(__init__)\n",
+      "        3    0.000    0.000    0.000    0.000 {method 'isidentifier' of 'str' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 {method '__array_prepare__' of 'numpy.ndarray' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:3160(_ndim_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/indexes/base.py:803(is_)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1161(__del__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:1008(_argsort_dispatcher)\n",
+      "        3    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/enum.py:631(__new__)\n",
+      "        1    0.000    0.000    0.000    0.000 {built-in method _operator.index}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/multiarray.py:1106(putmask)\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'conjugate' of 'numpy.ndarray' objects}\n",
+      "        3    0.000    0.000    0.000    0.000 {pandas._libs.lib.is_bool}\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:891(squeeze_left)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/_weakrefset.py:16(__init__)\n",
+      "        2    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/typing.py:1149(cast)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/dtypes/dtypes.py:581(ordered)\n",
+      "        5    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2543(default)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/multiarray.py:883(bincount)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:111(<lambda>)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/pandas/core/arrays/categorical.py:1934(_codes)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:205(df_model)\n",
+      "        1    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/_weakrefset.py:52(_commit_removals)\n",
+      "        1    0.000    0.000    0.000    0.000 {method '__contains__' of 'frozenset' objects}\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/multiarray.py:1368(may_share_memory)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2795(_amin_dispatcher)\n",
+      "        3    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:597(_transpose_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 {pandas._libs.lib.is_float}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:223(df_resid)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:1466(_svd_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 {built-in method from_iterable}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2670(_amax_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/shape_base.py:735(_array_split_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:964(_get_support)\n",
+      "        2    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:930(whiten)\n",
+      "        1    0.000    0.000    0.000    0.000 <string>:2(_parse_args)\n",
+      "        2    0.000    0.000    0.000    0.000 {built-in method builtins.callable}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/model.py:123(<listcomp>)\n",
+      "        2    0.000    0.000    0.000    0.000 /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.8/lib/python3.8/inspect.py:2547(annotation)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/multiarray.py:1071(copyto)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:432(_repeat_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/fromnumeric.py:2572(_ptp_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/regression/linear_model.py:238(df_resid)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/linalg/linalg.py:1788(_matrix_rank_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/twodim_base.py:230(_diag_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/stride_tricks.py:475(_broadcast_arrays_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/function_base.py:842(_copy_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 {built-in method sys.getrecursionlimit}\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/core/numeric.py:421(_count_nonzero_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/numpy/lib/shape_base.py:795(_split_dispatcher)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/statsmodels/base/data.py:472(attach_rows)\n",
+      "        1    0.000    0.000    0.000    0.000 /Users/caio.guirado/Desktop/causalml/causalml/lib/python3.8/site-packages/tqdm/std.py:1315(<lambda>)\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "@profile\n",
+    "def run_bart_for_classical_ml():\n",
+    "    X, y = make_regression(n_samples=1000, n_features=1, n_informative=1, random_state=SEED)\n",
+    "    X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=pd.qcut(y, 10), test_size=0.25, random_state=SEED)\n",
+    "\n",
+    "    bart = BART(m=35)\n",
+    "    bart.fit(X=X_train, y=y_train, max_iter=50)\n",
+    "    \n",
+    "run_bart_for_classical_ml()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8efac2a8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.8.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 04330c9a0ffcb23d1a68f41158f1eb10089976f1 Mon Sep 17 00:00:00 2001
From: Caio Guirado <caioguirado@yahoo.com.br>
Date: Wed, 24 Aug 2022 14:41:19 +0200
Subject: [PATCH 4/5] Update README.md with BART method and references

---
 README.md | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index 8c3fedad..7e516f17 100644
--- a/README.md
+++ b/README.md
@@ -31,19 +31,20 @@ The package currently supports the following methods
     * Uplift tree/random forests on KL divergence, Euclidean Distance, and Chi-Square [[2]](#Literature)
     * Uplift tree/random forests on Contextual Treatment Selection [[3]](#Literature)
     * Causal Tree [[4]](#Literature) - Work-in-progress
+    * Bayesian Additive Regression Trees (BART) [[5]](#Literature) - Work-in-progress
 * **Meta-learner algorithms**
-    * S-learner [[5]](#Literature)
-    * T-learner [[5]](#Literature)
-    * X-learner [[5]](#Literature)
-    * R-learner [[6]](#Literature)
-    * Doubly Robust (DR) learner [[7]](#Literature)
-    * TMLE learner [[8]](#Literature)
+    * S-learner [[6]](#Literature)
+    * T-learner [[6]](#Literature)
+    * X-learner [[6]](#Literature)
+    * R-learner [[7]](#Literature)
+    * Doubly Robust (DR) learner [[8]](#Literature)
+    * TMLE learner [[9]](#Literature)
 * **Instrumental variables algorithms**
     * 2-Stage Least Squares (2SLS)
-    * Doubly Robust (DR) IV [[9]](#Literature)
+    * Doubly Robust (DR) IV [[10]](#Literature)
 * **Neural-network-based algorithms**
-    * CEVAE [[10]](#Literature)
-    * DragonNet [[11]](#Literature) - with `causalml[tf]` installation (see [Installation](#installation))
+    * CEVAE [[11]](#Literature)
+    * DragonNet [[12]](#Literature) - with `causalml[tf]` installation (see [Installation](#installation))
 
 
 # Installation
@@ -273,15 +274,16 @@ Bibtex:
 2. Radcliffe, Nicholas J., and Patrick D. Surry. "Real-world uplift modelling with significance-based uplift trees." White Paper TR-2011-1, Stochastic Solutions (2011): 1-33.
 3. Zhao, Yan, Xiao Fang, and David Simchi-Levi. "Uplift modeling with multiple treatments and general response types." Proceedings of the 2017 SIAM International Conference on Data Mining. Society for Industrial and Applied Mathematics, 2017.
 4. Athey, Susan, and Guido Imbens. "Recursive partitioning for heterogeneous causal effects." Proceedings of the National Academy of Sciences 113.27 (2016): 7353-7360.
-5. Künzel, Sören R., et al. "Metalearners for estimating heterogeneous treatment effects using machine learning." Proceedings of the national academy of sciences 116.10 (2019): 4156-4165.
-6. Nie, Xinkun, and Stefan Wager. "Quasi-oracle estimation of heterogeneous treatment effects." arXiv preprint arXiv:1712.04912 (2017).
-7. Bang, Heejung, and James M. Robins. "Doubly robust estimation in missing data and causal inference models." Biometrics 61.4 (2005): 962-973.
-8. Van Der Laan, Mark J., and Daniel Rubin. "Targeted maximum likelihood learning." The international journal of biostatistics 2.1 (2006).
-9. Kennedy, Edward H. "Optimal doubly robust estimation of heterogeneous causal effects." arXiv preprint arXiv:2004.14497 (2020).
-10. Louizos, Christos, et al. "Causal effect inference with deep latent-variable models." arXiv preprint arXiv:1705.08821 (2017).
-11. Shi, Claudia, David M. Blei, and Victor Veitch. "Adapting neural networks for the estimation of treatment effects." 33rd Conference on Neural Information Processing Systems (NeurIPS 2019), 2019.
-12. Zhao, Zhenyu, Yumin Zhang, Totte Harinen, and Mike Yung. "Feature Selection Methods for Uplift Modeling." arXiv preprint arXiv:2005.03447 (2020).
-13. Zhao, Zhenyu, and Totte Harinen. "Uplift modeling for multiple treatments with cost optimization." In 2019 IEEE International Conference on Data Science and Advanced Analytics (DSAA), pp. 422-431. IEEE, 2019.
+5. Hill, Jennifer. "Bayesian Nonparametric Modeling for Causal Inference." Journal of Computational and Graphical Statistics (2011): 217–240.
+6. Künzel, Sören R., et al. "Metalearners for estimating heterogeneous treatment effects using machine learning." Proceedings of the national academy of sciences 116.10 (2019): 4156-4165.
+7. Nie, Xinkun, and Stefan Wager. "Quasi-oracle estimation of heterogeneous treatment effects." arXiv preprint arXiv:1712.04912 (2017).
+8. Bang, Heejung, and James M. Robins. "Doubly robust estimation in missing data and causal inference models." Biometrics 61.4 (2005): 962-973.
+9. Van Der Laan, Mark J., and Daniel Rubin. "Targeted maximum likelihood learning." The international journal of biostatistics 2.1 (2006).
+10. Kennedy, Edward H. "Optimal doubly robust estimation of heterogeneous causal effects." arXiv preprint arXiv:2004.14497 (2020).
+11. Louizos, Christos, et al. "Causal effect inference with deep latent-variable models." arXiv preprint arXiv:1705.08821 (2017).
+12. Shi, Claudia, David M. Blei, and Victor Veitch. "Adapting neural networks for the estimation of treatment effects." 33rd Conference on Neural Information Processing Systems (NeurIPS 2019), 2019.
+13. Zhao, Zhenyu, Yumin Zhang, Totte Harinen, and Mike Yung. "Feature Selection Methods for Uplift Modeling." arXiv preprint arXiv:2005.03447 (2020).
+14. Zhao, Zhenyu, and Totte Harinen. "Uplift modeling for multiple treatments with cost optimization." In 2019 IEEE International Conference on Data Science and Advanced Analytics (DSAA), pp. 422-431. IEEE, 2019.
  
 
 ## Related projects

From a32f2cee276d2b8266d837f0ae3ae0b7677469de Mon Sep 17 00:00:00 2001
From: Caio Guirado <caioguirado@yahoo.com.br>
Date: Wed, 24 Aug 2022 14:54:31 +0200
Subject: [PATCH 5/5] Remove commented lines

---
 causalml/inference/tree/bart.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/causalml/inference/tree/bart.py b/causalml/inference/tree/bart.py
index 475f26a7..ac8ee673 100644
--- a/causalml/inference/tree/bart.py
+++ b/causalml/inference/tree/bart.py
@@ -28,9 +28,6 @@ def get_available_predictors_for_split(self):
         for i in range(self.X.shape[1]):
             if self.X[:, i].size > 1:
                 self.available_predictors_for_split.append(i)
-                
-#         if self.treatment is not None:
-#             self.available_predictors_for_split[-1] = discrete_unique_values(self.treatment)
             
 class Node:
     def __init__(self,