Confounding_Example_Finding_causal_effects_from_observed_data.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyP4NDcy2CLFZtJQjJ5xNCmV",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SuRak35/Causal_Inference__ISI-Kolkata/blob/main/Confounding_Example_Finding_causal_effects_from_observed_data.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Confounding Example: Finding causal effects from observed data\n",
        "Suppose we are given some data with treatment and outcome. Can we determine whether the treatment causes the outcome, or the correlation is purely due to another common cause?"
      ],
      "metadata": {
        "id": "fuedU4Rjwlxr"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MsThoVdHRhn1",
        "outputId": "f2dbfed9-826a-4068-9b6f-c621c3c95870"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting dowhy\n",
            "  Downloading dowhy-0.11.1-py3-none-any.whl.metadata (17 kB)\n",
            "Collecting causal-learn>=0.1.3.0 (from dowhy)\n",
            "  Downloading causal_learn-0.1.3.8-py3-none-any.whl.metadata (4.2 kB)\n",
            "Requirement already satisfied: cvxpy<2.0.0,>=1.2.2 in /usr/local/lib/python3.10/dist-packages (from dowhy) (1.5.3)\n",
            "Requirement already satisfied: cython>=0.29.32 in /usr/local/lib/python3.10/dist-packages (from dowhy) (3.0.11)\n",
            "Requirement already satisfied: joblib>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from dowhy) (1.4.2)\n",
            "Requirement already satisfied: networkx>=2.8.5 in /usr/local/lib/python3.10/dist-packages (from dowhy) (3.3)\n",
            "Requirement already satisfied: numpy>=1.20 in /usr/local/lib/python3.10/dist-packages (from dowhy) (1.26.4)\n",
            "Requirement already satisfied: pandas>=1.4.3 in /usr/local/lib/python3.10/dist-packages (from dowhy) (2.1.4)\n",
            "Requirement already satisfied: scikit-learn>1.0 in /usr/local/lib/python3.10/dist-packages (from dowhy) (1.5.2)\n",
            "Requirement already satisfied: scipy>=1.4.1 in /usr/local/lib/python3.10/dist-packages (from dowhy) (1.13.1)\n",
            "Requirement already satisfied: statsmodels>=0.13.5 in /usr/local/lib/python3.10/dist-packages (from dowhy) (0.14.3)\n",
            "Requirement already satisfied: sympy>=1.10.1 in /usr/local/lib/python3.10/dist-packages (from dowhy) (1.13.3)\n",
            "Requirement already satisfied: tqdm>=4.64.0 in /usr/local/lib/python3.10/dist-packages (from dowhy) (4.66.5)\n",
            "Requirement already satisfied: graphviz in /usr/local/lib/python3.10/dist-packages (from causal-learn>=0.1.3.0->dowhy) (0.20.3)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from causal-learn>=0.1.3.0->dowhy) (3.7.1)\n",
            "Requirement already satisfied: pydot in /usr/local/lib/python3.10/dist-packages (from causal-learn>=0.1.3.0->dowhy) (3.0.1)\n",
            "Requirement already satisfied: osqp>=0.6.2 in /usr/local/lib/python3.10/dist-packages (from cvxpy<2.0.0,>=1.2.2->dowhy) (0.6.7.post0)\n",
            "Requirement already satisfied: ecos>=2 in /usr/local/lib/python3.10/dist-packages (from cvxpy<2.0.0,>=1.2.2->dowhy) (2.0.14)\n",
            "Requirement already satisfied: clarabel>=0.5.0 in /usr/local/lib/python3.10/dist-packages (from cvxpy<2.0.0,>=1.2.2->dowhy) (0.9.0)\n",
            "Requirement already satisfied: scs>=3.2.4.post1 in /usr/local/lib/python3.10/dist-packages (from cvxpy<2.0.0,>=1.2.2->dowhy) (3.2.7)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.4.3->dowhy) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.4.3->dowhy) (2024.2)\n",
            "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.4.3->dowhy) (2024.1)\n",
            "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>1.0->dowhy) (3.5.0)\n",
            "Requirement already satisfied: patsy>=0.5.6 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.13.5->dowhy) (0.5.6)\n",
            "Requirement already satisfied: packaging>=21.3 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.13.5->dowhy) (24.1)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.10.1->dowhy) (1.3.0)\n",
            "Requirement already satisfied: qdldl in /usr/local/lib/python3.10/dist-packages (from osqp>=0.6.2->cvxpy<2.0.0,>=1.2.2->dowhy) (0.1.7.post4)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from patsy>=0.5.6->statsmodels>=0.13.5->dowhy) (1.16.0)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->causal-learn>=0.1.3.0->dowhy) (1.3.0)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->causal-learn>=0.1.3.0->dowhy) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->causal-learn>=0.1.3.0->dowhy) (4.53.1)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->causal-learn>=0.1.3.0->dowhy) (1.4.7)\n",
            "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->causal-learn>=0.1.3.0->dowhy) (10.4.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->causal-learn>=0.1.3.0->dowhy) (3.1.4)\n",
            "Downloading dowhy-0.11.1-py3-none-any.whl (383 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m383.4/383.4 kB\u001b[0m \u001b[31m8.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading causal_learn-0.1.3.8-py3-none-any.whl (174 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m174.5/174.5 kB\u001b[0m \u001b[31m11.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: causal-learn, dowhy\n",
            "Successfully installed causal-learn-0.1.3.8 dowhy-0.11.1\n"
          ]
        }
      ],
      "source": [
        "!pip install dowhy"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "import dowhy\n",
        "from dowhy import CausalModel\n",
        "import dowhy.datasets, dowhy.plotter\n",
        "\n",
        "# Config dict to set the logging level\n",
        "import logging.config\n",
        "DEFAULT_LOGGING = {\n",
        "    'version': 1,\n",
        "    'disable_existing_loggers': False,\n",
        "    'loggers': {\n",
        "        '': {\n",
        "            'level': 'INFO',\n",
        "        },\n",
        "    }\n",
        "}\n",
        "\n",
        "logging.config.dictConfig(DEFAULT_LOGGING)"
      ],
      "metadata": {
        "id": "_840_tvtvJ1k"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Let’s create a mystery dataset for which we need to determine whether there is a causal effect.\n",
        "Creating the dataset. It is generated from either one of two models: * Model 1: Treatment does cause outcome. * Model 2: Treatment does not cause outcome. All observed correlation is due to a common cause.\n",
        "\n"
      ],
      "metadata": {
        "id": "rw26fyEKw3Fk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rvar = 1 if np.random.uniform() >0.5 else 0\n",
        "data_dict = dowhy.datasets.xy_dataset(10000, effect=rvar,\n",
        "                                      num_common_causes=1,\n",
        "                                      sd_error=0.2)\n",
        "df = data_dict['df']\n",
        "print(df[[\"Treatment\", \"Outcome\", \"w0\"]].head())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fPGbqGCOvOen",
        "outputId": "fc381080-f63a-46c3-ceab-3b219ab144a0"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   Treatment    Outcome        w0\n",
            "0   9.702215  19.939761  3.982427\n",
            "1   2.228242   4.130962 -3.851937\n",
            "2   8.579046  17.214985  2.649680\n",
            "3   6.164065  12.195432  0.127349\n",
            "4   3.369755   7.361409 -2.466822\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dowhy.plotter.plot_treatment_outcome(df[data_dict[\"treatment_name\"]], df[data_dict[\"outcome_name\"]],\n",
        "                             df[data_dict[\"time_val\"]])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 582
        },
        "id": "APUZ5tvKvPxC",
        "outputId": "ff17fce3-e19b-4985-94e5-336a4d3b5794"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Using DoWhy to resolve the mystery: Does Treatment cause Outcome?"
      ],
      "metadata": {
        "id": "J54hEkbWxBNo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###STEP 1: Model the problem as a causal graph\n",
        "Initializing the causal model."
      ],
      "metadata": {
        "id": "St9ROtLMxmo2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model= CausalModel(\n",
        "        data=df,\n",
        "        treatment=data_dict[\"treatment_name\"],\n",
        "        outcome=data_dict[\"outcome_name\"],\n",
        "        common_causes=data_dict[\"common_causes_names\"],\n",
        "        instruments=data_dict[\"instrument_names\"])\n",
        "model.view_model(layout=\"dot\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 636
        },
        "id": "JFb_833-vTgD",
        "outputId": "3ba0d3eb-6582-4be2-d27e-1f3a658032d3"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Showing the causal model stored in the local file “causal_model.png”\n",
        "\n"
      ],
      "metadata": {
        "id": "K8eVZ0_yxSeJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.display import Image, display\n",
        "display(Image(filename=\"causal_model.png\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 617
        },
        "id": "uvZqFvxKvXVQ",
        "outputId": "65f91349-bd8f-4b21-cc34-55efc26bc17d"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###STEP 2: Identify causal effect using properties of the formal causal graph\n",
        "Identify the causal effect using properties of the causal graph.\n",
        "\n"
      ],
      "metadata": {
        "id": "nKo7iyYlxa0b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "identified_estimand = model.identify_effect(proceed_when_unidentifiable=True)\n",
        "print(identified_estimand)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a5QZrs1vvbGE",
        "outputId": "f5959d29-2741-4416-c3ea-dc56848dc4cf"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estimand type: EstimandType.NONPARAMETRIC_ATE\n",
            "\n",
            "### Estimand : 1\n",
            "Estimand name: backdoor\n",
            "Estimand expression:\n",
            "     d                     \n",
            "────────────(E[Outcome|w0])\n",
            "d[Treatment]               \n",
            "Estimand assumption 1, Unconfoundedness: If U→{Treatment} and U→Outcome then P(Outcome|Treatment,w0,U) = P(Outcome|Treatment,w0)\n",
            "\n",
            "### Estimand : 2\n",
            "Estimand name: iv\n",
            "No such variable(s) found!\n",
            "\n",
            "### Estimand : 3\n",
            "Estimand name: frontdoor\n",
            "No such variable(s) found!\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###STEP 3: Estimate the causal effect\n",
        "Once we have identified the estimand, we can use any statistical method to estimate the causal effect.\n",
        "\n",
        "Let’s use Linear Regression for simplicity."
      ],
      "metadata": {
        "id": "AIkFt4mtxxTP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "estimate = model.estimate_effect(identified_estimand,\n",
        "        method_name=\"backdoor.linear_regression\")\n",
        "print(\"Causal Estimate is \" + str(estimate.value))\n",
        "\n",
        "# Plot Slope of line between treamtent and outcome =causal effect\n",
        "dowhy.plotter.plot_causal_effect(estimate, df[data_dict[\"treatment_name\"]], df[data_dict[\"outcome_name\"]])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 654
        },
        "id": "pqtILiigveSr",
        "outputId": "8f9ddf07-a9c3-4c2b-a0ca-c093196bab17"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Causal Estimate is -0.0026495046978798342\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Checking if the estimate is correct"
      ],
      "metadata": {
        "id": "AEqs9-0Jx74e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"DoWhy estimate is \" + str(estimate.value))\n",
        "print (\"Actual true causal effect was {0}\".format(rvar))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aC9PIedevhvH",
        "outputId": "44086920-35e7-480f-956a-8abc8fc97a79"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "DoWhy estimate is -0.0026495046978798342\n",
            "Actual true causal effect was 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Step 4: Refuting the estimate\n",
        "We can also refute the estimate to check its robustness to assumptions (aka sensitivity analysis, but on steroids).\n",
        "\n"
      ],
      "metadata": {
        "id": "jFfObJ4NyF-F"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Adding a random common cause variable\n"
      ],
      "metadata": {
        "id": "ATaUbxVoypL-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "res_random=model.refute_estimate(identified_estimand, estimate, method_name=\"random_common_cause\")\n",
        "print(res_random)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WwwN_-3tvhiR",
        "outputId": "b669add0-95e3-4839-ff02-bb395260342b"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Refute: Add a random common cause\n",
            "Estimated effect:-0.0026495046978798342\n",
            "New effect:-0.0026448548877299415\n",
            "p value:0.94\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Replacing treatment with a random (placebo) variable\n"
      ],
      "metadata": {
        "id": "G65H6kdayNzp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "res_placebo=model.refute_estimate(identified_estimand, estimate,\n",
        "        method_name=\"placebo_treatment_refuter\", placebo_type=\"permute\")\n",
        "print(res_placebo)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qh6iMVAXvhSb",
        "outputId": "bfbdd17d-b67d-4028-9e24-8dabcefb519c"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Refute: Use a Placebo Treatment\n",
            "Estimated effect:-0.0026495046978798342\n",
            "New effect:-1.8554418201812693e-05\n",
            "p value:1.0\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####Removing a random subset of the data\n"
      ],
      "metadata": {
        "id": "N1vWRfeEyTz-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "res_subset=model.refute_estimate(identified_estimand, estimate,\n",
        "        method_name=\"data_subset_refuter\", subset_fraction=0.9)\n",
        "print(res_subset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CSysPQdGvsze",
        "outputId": "0369f443-996a-469c-9d2c-36f0fe222e32"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Refute: Use a subset of data\n",
            "Estimated effect:-0.0026495046978798342\n",
            "New effect:-0.0027297581867083308\n",
            "p value:0.94\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n",
            "/usr/local/lib/python3.10/dist-packages/dowhy/causal_estimators/regression_estimator.py:179: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
            "  intercept_parameter = self.model.params[0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see, our causal estimator is robust to simple refutations."
      ],
      "metadata": {
        "id": "VW-FdS8Ky8sz"
      }
    }
  ]
}