Change 'values' to 'value' in estimators.py

Author: christopher-wild

causal_testing/testing/causal_test_engine.py

@@ -172,8 +172,8 @@ def _return_causal_test_results(self, estimate_type, estimator, causal_test_case
                 causal_test_result = CausalTestResult(
                     treatment=estimator.treatment,
                     outcome=estimator.outcome,
-                    treatment_value=estimator.treatment_values,
-                    control_value=estimator.control_values,
+                    treatment_value=estimator.treatment_value,
+                    control_value=estimator.control_value,
                     adjustment_set=estimator.adjustment_set,
                     ate=cates_df,
                     effect_modifier_configuration=causal_test_case.effect_modifier_configuration,
@@ -185,8 +185,8 @@ def _return_causal_test_results(self, estimate_type, estimator, causal_test_case
             causal_test_result = CausalTestResult(
                 treatment=estimator.treatment,
                 outcome=estimator.outcome,
-                treatment_value=estimator.treatment_values,
-                control_value=estimator.control_values,
+                treatment_value=estimator.treatment_value,
+                control_value=estimator.control_value,
                 adjustment_set=estimator.adjustment_set,
                 ate=risk_ratio,
                 effect_modifier_configuration=causal_test_case.effect_modifier_configuration,
@@ -198,8 +198,8 @@ def _return_causal_test_results(self, estimate_type, estimator, causal_test_case
             causal_test_result = CausalTestResult(
                 treatment=estimator.treatment,
                 outcome=estimator.outcome,
-                treatment_value=estimator.treatment_values,
-                control_value=estimator.control_values,
+                treatment_value=estimator.treatment_value,
+                control_value=estimator.control_value,
                 adjustment_set=estimator.adjustment_set,
                 ate=ate,
                 effect_modifier_configuration=causal_test_case.effect_modifier_configuration,
@@ -213,8 +213,8 @@ def _return_causal_test_results(self, estimate_type, estimator, causal_test_case
             causal_test_result = CausalTestResult(
                 treatment=estimator.treatment,
                 outcome=estimator.outcome,
-                treatment_value=estimator.treatment_values,
-                control_value=estimator.control_values,
+                treatment_value=estimator.treatment_value,
+                control_value=estimator.control_value,
                 adjustment_set=estimator.adjustment_set,
                 ate=ate,
                 effect_modifier_configuration=causal_test_case.effect_modifier_configuration,

causal_testing/testing/estimators.py

@@ -42,8 +42,8 @@ def __init__(
         effect_modifiers: dict[Variable:Any] = None,
     ):
         self.treatment = treatment
-        self.treatment_values = treatment_value
-        self.control_values = control_value
+        self.treatment_value = treatment_value
+        self.control_value = control_value
         self.adjustment_set = adjustment_set
         self.outcome = outcome
         self.df = df
@@ -90,15 +90,15 @@ class LogisticRegressionEstimator(Estimator):
     def __init__(
         self,
         treatment: tuple,
-        treatment_values: float,
-        control_values: float,
+        treatment_value: float,
+        control_value: float,
         adjustment_set: set,
         outcome: tuple,
         df: pd.DataFrame = None,
         effect_modifiers: dict[Variable:Any] = None,
         intercept: int = 1,
     ):
-        super().__init__(treatment, treatment_values, control_values, adjustment_set, outcome, df, effect_modifiers)
+        super().__init__(treatment, treatment_value, control_value, adjustment_set, outcome, df, effect_modifiers)
 
         for term in self.effect_modifiers:
             self.adjustment_set.add(term)
@@ -155,7 +155,7 @@ def estimate_control_treatment(self) -> tuple[pd.Series, pd.Series]:
         self.model = model
 
         x = pd.DataFrame()
-        x[self.treatment[0]] = [self.treatment_values, self.control_values]
+        x[self.treatment[0]] = [self.treatment_value, self.control_value]
         x["Intercept"] = self.intercept
         for k, v in self.effect_modifiers.items():
             x[k] = v
@@ -212,16 +212,16 @@ class LinearRegressionEstimator(Estimator):
     def __init__(
         self,
         treatment: tuple,
-        treatment_values: float,
-        control_values: float,
+        treatment_value: float,
+        control_value: float,
         adjustment_set: set,
         outcome: tuple,
         df: pd.DataFrame = None,
         effect_modifiers: dict[Variable:Any] = None,
         product_terms: list[tuple[Variable, Variable]] = None,
         intercept: int = 1,
     ):
-        super().__init__(treatment, treatment_values, control_values, adjustment_set, outcome, df, effect_modifiers)
+        super().__init__(treatment, treatment_value, control_value, adjustment_set, outcome, df, effect_modifiers)
 
         if product_terms is None:
             product_terms = []
@@ -304,7 +304,7 @@ def estimate_unit_ate(self) -> float:
         unit_effect = model.params[list(self.treatment)].values[0]  # Unit effect is the coefficient of the treatment
         [ci_low, ci_high] = self._get_confidence_intervals(model)
 
-        return unit_effect * self.treatment_values - unit_effect * self.control_values, [ci_low, ci_high]
+        return unit_effect * self.treatment_value - unit_effect * self.control_value, [ci_low, ci_high]
 
     def estimate_ate(self) -> tuple[float, list[float, float], float]:
         """Estimate the average treatment effect of the treatment on the outcome. That is, the change in outcome caused
@@ -315,8 +315,8 @@ def estimate_ate(self) -> tuple[float, list[float, float], float]:
         model = self._run_linear_regression()
         # Create an empty individual for the control and treated
         individuals = pd.DataFrame(1, index=["control", "treated"], columns=model.params.index)
-        individuals.loc["control", list(self.treatment)] = self.control_values
-        individuals.loc["treated", list(self.treatment)] = self.treatment_values
+        individuals.loc["control", list(self.treatment)] = self.control_value
+        individuals.loc["treated", list(self.treatment)] = self.treatment_value
         # This is a temporary hack
         for t in self.square_terms:
             individuals[t + "^2"] = individuals[t] ** 2
@@ -338,7 +338,7 @@ def estimate_control_treatment(self) -> tuple[pd.Series, pd.Series]:
         self.model = model
 
         x = pd.DataFrame()
-        x[self.treatment[0]] = [self.treatment_values, self.control_values]
+        x[self.treatment[0]] = [self.treatment_value, self.control_value]
         x["Intercept"] = self.intercept
         for k, v in self.effect_modifiers.items():
             x[k] = v
@@ -389,7 +389,7 @@ def estimate_cates(self) -> tuple[float, list[float, float]]:
             self.effect_modifiers
         ), f"Must have at least one effect modifier to compute CATE - {self.effect_modifiers}."
         x = pd.DataFrame()
-        x[self.treatment[0]] = [self.treatment_values, self.control_values]
+        x[self.treatment[0]] = [self.treatment_value, self.control_value]
         x["Intercept"] = self.intercept
         for k, v in self.effect_modifiers.items():
             self.adjustment_set.add(k)
@@ -485,8 +485,8 @@ def estimate_ate(self) -> float:
         model.fit(outcome_df, treatment_df, X=effect_modifier_df, W=confounders_df)
 
         # Obtain the ATE and 95% confidence intervals
-        ate = model.ate(effect_modifier_df, T0=self.control_values, T1=self.treatment_values)
-        ate_interval = model.ate_interval(effect_modifier_df, T0=self.control_values, T1=self.treatment_values)
+        ate = model.ate(effect_modifier_df, T0=self.control_value, T1=self.treatment_value)
+        ate_interval = model.ate_interval(effect_modifier_df, T0=self.control_value, T1=self.treatment_value)
         ci_low, ci_high = ate_interval[0], ate_interval[1]
         return ate, [ci_low, ci_high]
 
@@ -525,9 +525,9 @@ def estimate_cates(self) -> pd.DataFrame:
         model.fit(outcome_df, treatment_df, X=effect_modifier_df, W=confounders_df)
 
         # Obtain CATES and confidence intervals
-        conditional_ates = model.effect(effect_modifier_df, T0=self.control_values, T1=self.treatment_values).flatten()
+        conditional_ates = model.effect(effect_modifier_df, T0=self.control_value, T1=self.treatment_value).flatten()
         [ci_low, ci_high] = model.effect_interval(
-            effect_modifier_df, T0=self.control_values, T1=self.treatment_values, alpha=0.05
+            effect_modifier_df, T0=self.control_value, T1=self.treatment_value, alpha=0.05
         )
 
         # Merge results into a dataframe (CATE, confidence intervals, and effect modifier values)

examples/poisson-line-process/causal_test_poisson.py

@@ -7,6 +7,7 @@
 from causal_testing.testing.causal_test_outcome import ExactValue, Positive
 from causal_testing.testing.causal_test_engine import CausalTestEngine
 from causal_testing.testing.estimators import LinearRegressionEstimator, Estimator
+from causal_testing.testing.base_test_case import BaseTestCase
 
 import pandas as pd
 
@@ -26,10 +27,10 @@ def estimate_ate(self) -> float:
         :return: The empirical average treatment effect.
         """
         control_results = self.df.where(
-            self.df[self.treatment[0]] == self.control_values
+            self.df[self.treatment[0]] == self.control_value
         )[self.outcome].dropna()
         treatment_results = self.df.where(
-            self.df[self.treatment[0]] == self.treatment_values
+            self.df[self.treatment[0]] == self.treatment_value
         )[self.outcome].dropna()
         return treatment_results.mean()[0] - control_results.mean()[0], None
 
@@ -38,10 +39,10 @@ def estimate_risk_ratio(self) -> float:
         :return: The empirical average treatment effect.
         """
         control_results = self.df.where(
-            self.df[self.treatment[0]] == self.control_values
+            self.df[self.treatment[0]] == self.control_value
         )[self.outcome].dropna()
         treatment_results = self.df.where(
-            self.df[self.treatment[0]] == self.treatment_values
+            self.df[self.treatment[0]] == self.treatment_value
         )[self.outcome].dropna()
         return treatment_results.mean()[0] / control_results.mean()[0], None
 
@@ -75,6 +76,10 @@ def estimate_risk_ratio(self) -> float:
 # 4. Construct a causal specification from the scenario and causal DAG
 causal_specification = CausalSpecification(scenario, causal_dag)
 
+observational_data_path = "data/random/data_random_1000.csv"
+
+intensity_num_shapes_results = []
+
 
 def test_intensity_num_shapes(
     observational_data_path,
@@ -92,24 +97,20 @@ def test_intensity_num_shapes(
     )
 
     # 8. Obtain the minimal adjustment set for the causal test case from the causal DAG
-    causal_test_engine.identification(causal_test_case)
+    minimal_adjustment_set = causal_dag.identification(causal_test_case.base_test_case)
 
     # 9. Set up an estimator
     data = pd.read_csv(observational_data_path)
 
-    treatment = list(causal_test_case.control_input_configuration)[0].name
-    outcome = list(causal_test_case.outcome_variables)[0].name
+    treatment = causal_test_case.get_treatment_variable()
+    outcome = causal_test_case.get_outcome_variable()
 
     estimator = None
     if empirical:
         estimator = EmpiricalMeanEstimator(
             treatment=[treatment],
-            control_values=list(causal_test_case.control_input_configuration.values())[
-                0
-            ],
-            treatment_values=list(
-                causal_test_case.treatment_input_configuration.values()
-            )[0],
+            control_value=causal_test_case.control_value,
+            treatment_value=causal_test_case.treatment_value,
             adjustment_set=set(),
             outcome=[outcome],
             df=data,
@@ -118,12 +119,8 @@ def test_intensity_num_shapes(
     else:
         estimator = LinearRegressionEstimator(
             treatment=[treatment],
-            control_values=list(causal_test_case.control_input_configuration.values())[
-                0
-            ],
-            treatment_values=list(
-                causal_test_case.treatment_input_configuration.values()
-            )[0],
+            control_value=causal_test_case.control_value,
+            treatment_value=causal_test_case.treatment_value,
             adjustment_set=set(),
             outcome=[outcome],
             df=data,
@@ -143,9 +140,6 @@ def test_intensity_num_shapes(
     return causal_test_result
 
 
-observational_data_path = "data/random/data_random_1000.csv"
-
-intensity_num_shapes_results = []
 
 for wh in range(1, 11):
     smt_data_path = f"data/smt_100/data_smt_wh{wh}_100.csv"
@@ -154,14 +148,14 @@ def test_intensity_num_shapes(
         print(f"WIDTH = HEIGHT = {wh}")
 
         print("Identifying")
-        # 5. Create a causal test case
+        base_test_case = BaseTestCase(treatment_variable=intensity,
+                                      outcome_variable=num_shapes_unit)
         causal_test_case = CausalTestCase(
-            control_input_configuration={intensity: control_value},
-            treatment_input_configuration={intensity: treatment_value},
+            base_test_case=base_test_case,
             expected_causal_effect=ExactValue(4, tolerance=0.5),
-            outcome_variables={num_shapes_unit},
-            estimate_type="risk_ratio",
-            # effect_modifier_configuration={width: wh, height: wh}
+            treatment_value=treatment_value,
+            control_value=control_value,
+            estimate_type="risk_ratio"
         )
         obs_causal_test_result = test_intensity_num_shapes(
             observational_data_path,
@@ -199,13 +193,17 @@ def test_intensity_num_shapes(
         # 5. Create a causal test case
         control_value = w
         treatment_value = w + 1
+        base_test_case = BaseTestCase(
+            treatment_variable=width,
+            outcome_variable=num_shapes_unit
+        )
         causal_test_case = CausalTestCase(
-            control_input_configuration={width: control_value},
-            treatment_input_configuration={width: treatment_value},
+            base_test_case=base_test_case,
             expected_causal_effect=Positive(),
-            outcome_variables={num_shapes_unit},
+            control_value=control_value,
+            treatment_value=treatment_value,
             estimate_type="ate_calculated",
-            effect_modifier_configuration={intensity: i},
+            effect_modifier_configuration={intensity: i}
         )
         causal_test_result = test_intensity_num_shapes(
             observational_data_path,