From 7822b17010f763dee67720ba86bdf70203774fbc Mon Sep 17 00:00:00 2001 From: SoyoungJun-SL Date: Sat, 18 Oct 2025 05:41:35 -0400 Subject: [PATCH 1/4] =?UTF-8?q?=EC=84=A0=ED=98=95=20=EB=AA=A8=EB=8D=B8=20?= =?UTF-8?q?=EB=B0=8F=20=EB=A9=94=ED=83=80=20=EB=9F=AC=EB=84=88=20=EA=B2=B0?= =?UTF-8?q?=EA=B3=BC=20=EB=B9=84=EA=B5=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- book/cate_and_policy/meta_learner.ipynb | 505 ++++++++++++++++++++++++ 1 file changed, 505 insertions(+) create mode 100644 book/cate_and_policy/meta_learner.ipynb diff --git a/book/cate_and_policy/meta_learner.ipynb b/book/cate_and_policy/meta_learner.ipynb new file mode 100644 index 0000000..1ec81d8 --- /dev/null +++ b/book/cate_and_policy/meta_learner.ipynb @@ -0,0 +1,505 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 비모수적 개별 처치 효과(CATE) 추정\n", + "\n", + "- 목표: 두 개의 다른 데이터셋(아이스크림, 이메일)을 사용하여, CATE(개별 처치 효과) 추정 시 선형 모델(OLS)의 한계와 비모수적 메타-러너(S/T/X-Learner)의 우수성을 비교 검증합니다.\n", + "- 데이터 1 (연속형 T):\n", + " - 학습: ice_cream_sales.csv (편향된 관측 데이터)\n", + " - 평가: ice_cream_sales_rnd.csv (무작위 RCT 데이터)\n", + "- 데이터 2 (이진형 T):\n", + " - 학습: invest_email_biased.csv (편향된 관측 데이터)\n", + " - 평가: invest_email_rnd.csv (무작위 RCT 데이터)\n", + "- 평가 지표:\n", + " - 수치: AUUC (Area Under Uplift Curve) - 높을수록 우수함.\n", + " - 시각화: 누적 성과 곡선 (Cumulative Gain Plot) - 베이스라인(무작위)보다 높아야 함." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 라이브러리 및 헬퍼 함수" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import statsmodels.api as sm\n", + "import statsmodels.formula.api as smf\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.base import clone\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from typing import Callable\n", + "\n", + "# 시각화 스타일 설정\n", + "plt.style.use('ggplot')\n", + "sns.set_palette('colorblind')" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "# --- 헬퍼 함수 (연속형 처치용) ---\n", + "def sensitivity(data, y, t):\n", + " \"\"\"\n", + " (연속형 T용) 단일 변수 선형 회귀의 기울기(민감도)를 계산합니다.\n", + " \"\"\"\n", + " return (np.sum((data[t] - data[t].mean()) * (data[y] - data[y].mean())) /\n", + " np.sum((data[t] - data[t].mean())**2))\n", + "\n", + "def cumulative_gain_continuous(dataset, prediction, y, t, min_periods=30, steps=100):\n", + " \"\"\"\n", + " (연속형 T용) 누적 성과 곡선(Cumulative Gain)을 계산합니다.\n", + " \n", + " \"\"\"\n", + " size = dataset.shape[0]\n", + " ordered_df = dataset.sort_values(prediction, ascending=False).reset_index(drop=True)\n", + " n_rows = list(range(min_periods, size, size // steps)) + [size]\n", + " \n", + " # (rows/size)로 정규화합니다.\n", + " return np.array([sensitivity(ordered_df.head(rows), y, t) * (rows / size) for rows in n_rows])\n", + "\n", + "def auuc_score_continuous(data, cate, y, t, min_periods=30, steps=100):\n", + " \"\"\"(연속형 T용) AUUC 점수를 계산합니다.\"\"\"\n", + " model_gain = cumulative_gain_continuous(data, cate, y, t, min_periods, steps)\n", + " \n", + " # 베이스라인 (전체 데이터의 평균 민감도 * 비율)\n", + " baseline_sens = sensitivity(data, y, t)\n", + " baseline_gain = np.linspace(0, 1, len(model_gain)) * baseline_sens * (len(data) / (len(data) - min_periods + 1)) # 스케일 조정\n", + " \n", + " # 모델 성과 - 베이스라인 성과의 면적\n", + " auuc = (model_gain - baseline_gain).sum() / len(model_gain)\n", + " return auuc" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "# --- 헬퍼 함수 (이진형 처치용) ---\n", + "\n", + "def elast(data, y, t):\n", + " \"\"\"(이진형 T용) ATE(평균 효과)를 계산합니다.\"\"\"\n", + " ate = (data.query(f\"{t}==1\")[y].mean() -\n", + " data.query(f\"{t}==0\")[y].mean())\n", + " return ate\n", + "\n", + "def cumulative_gain_binary(data, cate, y, t, min_rows=30, steps=100):\n", + " \"\"\"(이진형 T용) 누적 성과 곡선(Uplift Curve)을 계산합니다.\"\"\"\n", + " data = data.copy()\n", + " data[\"cate\"] = data[cate]\n", + " data = data.sort_values(\"cate\", ascending=False)\n", + " \n", + " thresholds = np.linspace(0, 100, steps + 1)[1:]\n", + " \n", + " gains = []\n", + " for threshold in thresholds:\n", + " n_rows = int(len(data) * (threshold / 100))\n", + " if n_rows < min_rows:\n", + " continue\n", + " \n", + " quant_data = data.head(n_rows)\n", + " gain = elast(quant_data, y, t)\n", + " gains.append(gain)\n", + " \n", + " return np.array(gains)\n", + "\n", + "def auuc_score_binary(data, cate, y, t, min_rows=30, steps=100):\n", + " \"\"\"(이진형 T용) AUUC 점수를 계산합니다.\"\"\"\n", + " model_gain = cumulative_gain_binary(data, cate, y, t, min_rows, steps)\n", + " baseline_ate = elast(data, y, t)\n", + " \n", + " auuc = (model_gain - baseline_ate).sum() / len(model_gain)\n", + " return auuc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Part A: 아이스크림 데이터 (연속형 T)\n", + "먼저 ice_cream_sales.csv(편향된 학습용)로 모델들을 학습시키고, ice_cream_sales_rnd.csv(무작위 평가용)로 CATE 추정 성능을 비교합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "train_ice = pd.read_csv(\"ice_cream_sales.csv\")\n", + "test_ice = pd.read_csv(\"ice_cream_sales_rnd.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "# 타입 변환\n", + "train_ice['weekday'] = train_ice['weekday'].astype('category')\n", + "test_ice['weekday'] = test_ice['weekday'].astype('category')\n", + "\n", + "# 변수 정의\n", + "Y_ice = \"sales\"\n", + "T_ice_cont = \"price\" # S-Learner, OLS용 연속형 처치\n", + "T_ice_binary = \"price_binary\" # T/X-Learner, 평가용 이진 처치\n", + "X_ice = [\"temp\", \"weekday\", \"cost\"]\n", + "\n", + "# T/X-Learner 및 공정한 AUUC 평가를 위해 price를 이진화\n", + "price_median_train = train_ice[T_ice_cont].median()\n", + "train_ice[T_ice_binary] = (train_ice[T_ice_cont] > price_median_train).astype(int)\n", + "test_ice[T_ice_binary] = (test_ice[T_ice_cont] > price_median_train).astype(int)\n", + "\n", + "# 테스트 데이터 예측값 저장용\n", + "test_preds_ice = test_ice.copy()\n", + "\n", + "# 학습/테스트 데이터 정의\n", + "X_train_ice, Y_train_ice = train_ice[X_ice], train_ice[Y_ice]\n", + "T_train_ice_cont, T_train_ice_binary = train_ice[T_ice_cont], train_ice[T_ice_binary]\n", + "X_test_ice = test_ice[X_ice]" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "# --- 모델 1: 선형 CATE (OLS) ---\n", + "formula_linear_ice = 'sales ~ price * (temp + C(weekday) + cost)'\n", + "linear_model_ice = smf.ols(formula_linear_ice, data=train_ice).fit()\n", + "\n", + "# CATE 추정 함수 (연속형 T용)\n", + "def get_linear_cate_predictions(model, df, t_col):\n", + " df_t1 = df.copy(); df_t1[t_col] = df_t1[t_col] + 1\n", + " return model.predict(df_t1) - model.predict(df)\n", + "\n", + "test_preds_ice['cate_linear'] = get_linear_cate_predictions(linear_model_ice, test_preds_ice, T_ice_cont)\n", + "\n", + "\n", + "# --- 모델 2: S-Learner (RF) ---\n", + "rf_model_base = RandomForestRegressor(n_estimators=100, min_samples_leaf=20, random_state=42)\n", + "s_learner_ice = clone(rf_model_base)\n", + "s_learner_ice.fit(train_ice[X_ice + [T_ice_cont]], Y_train_ice)\n", + "\n", + "# CATE 추정\n", + "X_test_s_ice_t1 = X_test_ice.copy(); X_test_s_ice_t1[T_ice_cont] = test_ice[T_ice_cont] + 1\n", + "X_test_s_ice_t0 = X_test_ice.copy(); X_test_s_ice_t0[T_ice_cont] = test_ice[T_ice_cont]\n", + "test_preds_ice['cate_s_learner'] = s_learner_ice.predict(X_test_s_ice_t1) - s_learner_ice.predict(X_test_s_ice_t0)\n", + "\n", + "\n", + "# --- 모델 3: T-Learner (RF) ---\n", + "# (이진형 T_ice_binary 사용)\n", + "t1_learner_ice = clone(rf_model_base)\n", + "t1_learner_ice.fit(X_train_ice[T_train_ice_binary == 1], Y_train_ice[T_train_ice_binary == 1])\n", + "t0_learner_ice = clone(rf_model_base)\n", + "t0_learner_ice.fit(X_train_ice[T_train_ice_binary == 0], Y_train_ice[T_train_ice_binary == 0])\n", + "test_preds_ice['cate_t_learner'] = t1_learner_ice.predict(X_test_ice) - t0_learner_ice.predict(X_test_ice)\n", + "\n", + "\n", + "# --- 모델 4: X-Learner (RF) ---\n", + "# (이진형 T_ice_binary 사용)\n", + "D_t1 = Y_train_ice[T_train_ice_binary == 1] - t0_learner_ice.predict(X_train_ice[T_train_ice_binary == 1])\n", + "D_t0 = t1_learner_ice.predict(X_train_ice[T_train_ice_binary == 0]) - Y_train_ice[T_train_ice_binary == 0]\n", + "\n", + "x1_learner_ice = clone(rf_model_base); x1_learner_ice.fit(X_train_ice[T_train_ice_binary == 1], D_t1)\n", + "x0_learner_ice = clone(rf_model_base); x0_learner_ice.fit(X_train_ice[T_train_ice_binary == 0], D_t0)\n", + "\n", + "prop_model_ice = LogisticRegression(random_state=42, solver='lbfgs', max_iter=1000)\n", + "prop_model_ice.fit(X_train_ice, T_train_ice_binary)\n", + "prop_scores_ice = prop_model_ice.predict_proba(X_test_ice)[:, 1]\n", + "\n", + "test_preds_ice['cate_x_learner'] = (prop_scores_ice * x0_learner_ice.predict(X_test_ice)) + \\\n", + " ((1 - prop_scores_ice) * x1_learner_ice.predict(X_test_ice))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "test_ice(무작위 데이터셋)를 기준으로 아이스크림 예제의 모델들(선형 vs. 메타)을 비교합니다.\n", + "참고: AUUC 평가는 T/X-Learner와 공정한 비교를 위해 이진화된 처치(T_ice_binary)를 기준으로 수행합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 아이스크림 데이터 AUUC 점수 ---\n", + " AUUC Score (IceCream)\n", + "X-Learner (RF) 12.497704\n", + "T-Learner (RF) 12.323083\n", + "Linear (OLS) 6.769121\n", + "S-Learner (RF) 0.841975\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- 수치 비교 (AUUC) ---\n", + "models_ice = {\n", + " 'Linear (OLS)': 'cate_linear',\n", + " 'S-Learner (RF)': 'cate_s_learner',\n", + " 'T-Learner (RF)': 'cate_t_learner',\n", + " 'X-Learner (RF)': 'cate_x_learner'\n", + "}\n", + "auuc_results_ice = {}\n", + "\n", + "for name, col in models_ice.items():\n", + " auuc = auuc_score_binary(test_preds_ice, col, Y_ice, T_ice_binary)\n", + " auuc_results_ice[name] = auuc\n", + "\n", + "auuc_df_ice = pd.DataFrame.from_dict(auuc_results_ice, orient='index', columns=['AUUC Score (IceCream)'])\n", + "print(\"--- 아이스크림 데이터 AUUC 점수 ---\")\n", + "print(auuc_df_ice.sort_values('AUUC Score (IceCream)', ascending=False))\n", + "\n", + "\n", + "# --- 시각화 (Cumulative Gain Plot) ---\n", + "plt.figure(figsize=(12, 8))\n", + "\n", + "baseline_ate_ice = elast(test_preds_ice, Y_ice, T_ice_binary)\n", + "plt.plot([0, 100], [baseline_ate_ice, baseline_ate_ice], 'k--', \n", + " label=f'Baseline (ATE = {baseline_ate_ice:.2f})')\n", + "\n", + "for name, col in models_ice.items():\n", + " gain = cumulative_gain_binary(test_preds_ice, col, Y_ice, T_ice_binary)\n", + " plt.plot(np.linspace(0, 100, len(gain)), gain, \n", + " label=f'{name} (AUUC: {auuc_results_ice[name]:.2f})', \n", + " linewidth=2.5)\n", + "\n", + "plt.title('CATE Model Evaluation: Cumulative Gain (Ice Cream Data)', fontsize=16)\n", + "plt.xlabel('% of Population Targeted (Sorted by CATE)')\n", + "plt.ylabel('Average Treatment Effect (CATE) in Group')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Part B: 이메일 마케팅 데이터 (이진형 T)\n", + "모든 모델은 편향된 train_email 데이터로 학습하고, 무작위 test_email 데이터로 평가합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "# --- 데이터 로드 및 변수 정의 ---\n", + "train_email = pd.read_csv(\"invest_email_biased.csv\")\n", + "test_email = pd.read_csv(\"invest_email_rnd.csv\")\n", + "\n", + "Y_email = \"converted\"\n", + "T_email = \"em1\"\n", + "X_email = [\"age\", \"income\", \"insurance\", \"invested\"]\n", + "\n", + "# 테스트 데이터 예측값 저장용\n", + "test_preds_email = test_email.copy()\n", + "\n", + "# 학습/테스트 데이터 정의\n", + "X_train_em, Y_train_em = train_email[X_email], train_email[Y_email]\n", + "T_train_em = train_email[T_email]\n", + "X_test_em = test_email[X_email]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# --- 모델 1: 선형 CATE (OLS) ---\n", + "formula_linear_email = 'converted ~ em1 * (age + income + insurance + invested)'\n", + "linear_model_email = smf.ols(formula_linear_email, data=train_email).fit()\n", + "\n", + "# CATE 추정\n", + "df_t1 = X_test_em.copy(); df_t1[T_email] = 1\n", + "df_t0 = X_test_em.copy(); df_t0[T_email] = 0\n", + "test_preds_email['cate_linear'] = linear_model_email.predict(df_t1) - linear_model_email.predict(df_t0)\n", + "\n", + "\n", + "# --- 모델 2: S-Learner (RF) ---\n", + "rf_model_email = RandomForestRegressor(n_estimators=100, min_samples_leaf=30, max_depth=3, random_state=42)\n", + "s_learner_email = clone(rf_model_email)\n", + "s_learner_email.fit(train_email[X_email + [T_email]], Y_train_em)\n", + "\n", + "# CATE 추정\n", + "X_test_s_t1_em = X_test_em.copy(); X_test_s_t1_em[T_email] = 1\n", + "X_test_s_t0_em = X_test_em.copy(); X_test_s_t0_em[T_email] = 0\n", + "test_preds_email['cate_s_learner'] = s_learner_email.predict(X_test_s_t1_em) - s_learner_email.predict(X_test_s_t0_em)\n", + "\n", + "\n", + "# --- 모델 3: T-Learner (RF) ---\n", + "t1_learner_email = clone(rf_model_email)\n", + "t1_learner_email.fit(X_train_em[T_train_em == 1], Y_train_em[T_train_em == 1])\n", + "t0_learner_email = clone(rf_model_email)\n", + "t0_learner_email.fit(X_train_em[T_train_em == 0], Y_train_em[T_train_em == 0])\n", + "test_preds_email['cate_t_learner'] = t1_learner_email.predict(X_test_em) - t0_learner_email.predict(X_test_em)\n", + "\n", + "\n", + "# --- 모델 4: X-Learner (RF) ---\n", + "D_t1_em = Y_train_em[T_train_em == 1] - t0_learner_email.predict(X_train_em[T_train_em == 1])\n", + "D_t0_em = t1_learner_email.predict(X_train_em[T_train_em == 0]) - Y_train_em[T_train_em == 0]\n", + "\n", + "x1_learner_email = clone(rf_model_email)\n", + "x1_learner_email.fit(X_train_em[T_train_em == 1], D_t1_em)\n", + "x0_learner_email = clone(rf_model_email)\n", + "x0_learner_email.fit(X_train_em[T_train_em == 0], D_t0_em)\n", + "\n", + "# 성향 점수 모델 \n", + "prop_model_email = LogisticRegression(random_state=42, solver='lbfgs', penalty=None, max_iter=1000)\n", + "prop_model_email.fit(X_train_em, T_train_em)\n", + "\n", + "# CATE 추정\n", + "prop_scores_em = prop_model_email.predict_proba(X_test_em)[:, 1]\n", + "test_preds_email['cate_x_learner'] = (prop_scores_em * x0_learner_email.predict(X_test_em)) + \\\n", + " ((1 - prop_scores_em) * x1_learner_email.predict(X_test_em))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "test_email(무작위 데이터셋)를 기준으로 **이메일 예제의 모델들(선형 vs. 메타)**을 비교합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 이메일 데이터 AUUC 점수 (편향된 데이터로 학습) ---\n", + " AUUC Score (Email)\n", + "X-Learner (RF) 0.038409\n", + "Linear (OLS) 0.033553\n", + "T-Learner (RF) 0.030136\n", + "S-Learner (RF) -0.011199\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- 수치 비교 (AUUC) ---\n", + "models_email = {\n", + " 'Linear (OLS)': 'cate_linear',\n", + " 'S-Learner (RF)': 'cate_s_learner',\n", + " 'T-Learner (RF)': 'cate_t_learner',\n", + " 'X-Learner (RF)': 'cate_x_learner'\n", + "}\n", + "auuc_results_email = {}\n", + "\n", + "for name, col in models_email.items():\n", + " auuc = auuc_score_binary(test_preds_email, col, Y_email, T_email)\n", + " auuc_results_email[name] = auuc\n", + "\n", + "auuc_df_email = pd.DataFrame.from_dict(auuc_results_email, orient='index', columns=['AUUC Score (Email)'])\n", + "print(\"--- 이메일 데이터 AUUC 점수 (편향된 데이터로 학습) ---\")\n", + "print(auuc_df_email.sort_values('AUUC Score (Email)', ascending=False))\n", + "\n", + "\n", + "# --- 시각화 (Cumulative Gain Plot) ---\n", + "plt.figure(figsize=(12, 8))\n", + "\n", + "baseline_ate_email = elast(test_preds_email, Y_email, T_email)\n", + "plt.plot([0, 100], [baseline_ate_email, baseline_ate_email], 'k--', \n", + " label=f'Baseline (ATE = {baseline_ate_email:.4f})')\n", + "\n", + "for name, col in models_email.items():\n", + " gain = cumulative_gain_binary(test_preds_email, col, Y_email, T_email)\n", + " plt.plot(np.linspace(0, 100, len(gain)), gain, \n", + " label=f'{name} (AUUC: {auuc_results_email[name]:.4f})', \n", + " linewidth=2.5)\n", + "\n", + "plt.title('CATE Model Evaluation: Cumulative Gain (Biased Email Data)', fontsize=16)\n", + "plt.xlabel('% of Population Targeted (Sorted by CATE)')\n", + "plt.ylabel('Average Treatment Effect (CATE) in Group')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 질문이나 의견을 남겨주세요.\n", + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "myenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From c966d7b7f3d4a4bf37d0f40ce680b42316d9d53e Mon Sep 17 00:00:00 2001 From: SoyoungJun-SL Date: Sat, 18 Oct 2025 05:52:35 -0400 Subject: [PATCH 2/4] =?UTF-8?q?fix:=EA=B2=BD=EB=A1=9C=EC=A7=80=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- book/cate_and_policy/meta_learner.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/book/cate_and_policy/meta_learner.ipynb b/book/cate_and_policy/meta_learner.ipynb index 1ec81d8..1c4eaeb 100644 --- a/book/cate_and_policy/meta_learner.ipynb +++ b/book/cate_and_policy/meta_learner.ipynb @@ -140,12 +140,12 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "train_ice = pd.read_csv(\"ice_cream_sales.csv\")\n", - "test_ice = pd.read_csv(\"ice_cream_sales_rnd.csv\")" + "train_ice = pd.read_csv(\"../data/matheus_data/ice_cream_sales.csv\")\n", + "test_ice = pd.read_csv(\"../data/matheus_data/ice_cream_sales_rnd.csv\")" ] }, { @@ -317,13 +317,13 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# --- 데이터 로드 및 변수 정의 ---\n", - "train_email = pd.read_csv(\"invest_email_biased.csv\")\n", - "test_email = pd.read_csv(\"invest_email_rnd.csv\")\n", + "train_email = pd.read_csv(\"../data/matheus_data/invest_email_biased.csv\")\n", + "test_email = pd.read_csv(\"../data/matheus_data/invest_email_rnd.csv\")\n", "\n", "Y_email = \"converted\"\n", "T_email = \"em1\"\n", From 2548e01533162211d4197e8b0a3d031e5121b573 Mon Sep 17 00:00:00 2001 From: SoyoungJun-SL Date: Sat, 25 Oct 2025 00:08:29 -0400 Subject: [PATCH 3/4] =?UTF-8?q?=ED=94=BC=EB=93=9C=EB=B0=B1=20=EB=B0=98?= =?UTF-8?q?=EC=98=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .DS_Store | Bin 6148 -> 6148 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/.DS_Store b/.DS_Store index dbcfa895b883d20f9e64f4fb66c24a885bf11e8e..1e5fe55bb67bdd945057036490f9d3c4b8374cdf 100644 GIT binary patch literal 6148 zcmeHK&2Q5%6o1ZAk}!cfiJ_g4B`zE)SW%}UaUko;3BiFNI1E%0Qnk_2xN6f?sHzlk zV>|4&zl9q|ZirL=9-cq4xpd=*D&$w$Kl^>y&%ela4FIGyiR%DW0C2Hzv~OZ{g>XAB zD`F|lZA8MyNPG3*6B`UyJdMIIU>I0O2Ke5!;UV-Ofn49e*8Z!7ZX2+6J4#uEI`_+I ze71P`V}IEm|J6S1U!D!ti(eQDPB}01VFHmpJAf6gdgwXa`&|Ei{!HZX$2bFanaTBD zdOq^}Lmnbv_&bWGH>vXVdu*^w~7X!+bJsg`-2>d&5{7 zmF+Nkn{=n0>YW3Y-}8!+>F6jTqqP z1I5D8S6E0CM+a8o34my$S_roJTY|?>g}%Z0IwFbpg+upzrue*ZtmJ$%jke>uqX3B`mF;Q%yo+6MA*v-f>nTJKPURha?fq{XAL60GwA(NpbH{Zo2DJMS( zD8_MX>X~c(=EogT1xCu|nv5M$X`@QraZI|n}p(D^`t@640=MJxqC1~US! NfYL0RBSh9P0|4Q#Ic5L= From 1343876ab849a9c1608e87cbc6cf1a6c2e1fccb5 Mon Sep 17 00:00:00 2001 From: SoyoungJun-SL Date: Sun, 2 Nov 2025 01:33:11 -0400 Subject: [PATCH 4/4] =?UTF-8?q?re=5F=ED=94=BC=EB=93=9C=EB=B0=B1=20?= =?UTF-8?q?=EB=B0=98=EC=98=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- book/cate_and_policy/meta_learner.ipynb | 893 +++++++++++++++++++++--- 1 file changed, 796 insertions(+), 97 deletions(-) diff --git a/book/cate_and_policy/meta_learner.ipynb b/book/cate_and_policy/meta_learner.ipynb index 1c4eaeb..0605fc5 100644 --- a/book/cate_and_policy/meta_learner.ipynb +++ b/book/cate_and_policy/meta_learner.ipynb @@ -6,7 +6,7 @@ "source": [ "# 비모수적 개별 처치 효과(CATE) 추정\n", "\n", - "- 목표: 두 개의 다른 데이터셋(아이스크림, 이메일)을 사용하여, CATE(개별 처치 효과) 추정 시 선형 모델(OLS)의 한계와 비모수적 메타-러너(S/T/X-Learner)의 우수성을 비교 검증합니다.\n", + "- 목표: 두 개의 다른 데이터셋(아이스크림, 이메일)을 사용하여, CATE(개별 처치 효과) 추정 시 선형 모델(OLS)와 비모수적 메타-러너(S/T/X-Learner) 비교.\n", "- 데이터 1 (연속형 T):\n", " - 학습: ice_cream_sales.csv (편향된 관측 데이터)\n", " - 평가: ice_cream_sales_rnd.csv (무작위 RCT 데이터)\n", @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,8 @@ "import statsmodels.api as sm\n", "import statsmodels.formula.api as smf\n", "from sklearn.model_selection import train_test_split\n", - "from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from lightgbm import LGBMRegressor\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.base import clone\n", "import matplotlib.pyplot as plt\n", @@ -50,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -65,7 +66,7 @@ "def cumulative_gain_continuous(dataset, prediction, y, t, min_periods=30, steps=100):\n", " \"\"\"\n", " (연속형 T용) 누적 성과 곡선(Cumulative Gain)을 계산합니다.\n", - " \n", + " \n", " \"\"\"\n", " size = dataset.shape[0]\n", " ordered_df = dataset.sort_values(prediction, ascending=False).reset_index(drop=True)\n", @@ -84,6 +85,41 @@ " \n", " # 모델 성과 - 베이스라인 성과의 면적\n", " auuc = (model_gain - baseline_gain).sum() / len(model_gain)\n", + " return auuc\n", + "\n", + "# --- 헬퍼 함수 (이진형 처치용) ---\n", + "def elast(data, y, t):\n", + " \"\"\"(이진형 T용) ATE(평균 효과)를 계산합니다.\"\"\"\n", + " ate = (data.query(f\"{t}==1\")[y].mean() -\n", + " data.query(f\"{t}==0\")[y].mean())\n", + " return ate\n", + "\n", + "def cumulative_gain_binary(data, cate, y, t, min_rows=30, steps=100):\n", + " \"\"\"(이진형 T용) 누적 성과 곡선(Uplift Curve)을 계산합니다.\"\"\"\n", + " data = data.copy()\n", + " data[\"cate\"] = data[cate]\n", + " data = data.sort_values(\"cate\", ascending=False)\n", + " \n", + " thresholds = np.linspace(0, 100, steps + 1)[1:]\n", + " \n", + " gains = []\n", + " for threshold in thresholds:\n", + " n_rows = int(len(data) * (threshold / 100))\n", + " if n_rows < min_rows:\n", + " continue\n", + " \n", + " quant_data = data.head(n_rows)\n", + " gain = elast(quant_data, y, t)\n", + " gains.append(gain)\n", + " \n", + " return np.array(gains)\n", + "\n", + "def auuc_score_binary(data, cate, y, t, min_rows=30, steps=100):\n", + " \"\"\"(이진형 T용) AUUC 점수를 계산합니다.\"\"\"\n", + " model_gain = cumulative_gain_binary(data, cate, y, t, min_rows, steps)\n", + " baseline_ate = elast(data, y, t)\n", + " \n", + " auuc = (model_gain - baseline_ate).sum() / len(model_gain)\n", " return auuc" ] }, @@ -134,13 +170,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2. Part A: 아이스크림 데이터 (연속형 T)\n", - "먼저 ice_cream_sales.csv(편향된 학습용)로 모델들을 학습시키고, ice_cream_sales_rnd.csv(무작위 평가용)로 CATE 추정 성능을 비교합니다." + "## 2. Part A: 아이스크림 데이터 (연속형 T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2-1. Part A-1: 아이스크림 데이터 (이진형 처치 T 비교)\n", + "목표: 모든 모델을 T_ice_binary (이진) 기준으로 공정하게 비교 (기본 모델: RandomForestRegressor)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -150,7 +193,14 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -180,44 +230,38 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "# --- 모델 1: 선형 CATE (OLS) ---\n", - "formula_linear_ice = 'sales ~ price * (temp + C(weekday) + cost)'\n", - "linear_model_ice = smf.ols(formula_linear_ice, data=train_ice).fit()\n", - "\n", - "# CATE 추정 함수 (연속형 T용)\n", - "def get_linear_cate_predictions(model, df, t_col):\n", - " df_t1 = df.copy(); df_t1[t_col] = df_t1[t_col] + 1\n", - " return model.predict(df_t1) - model.predict(df)\n", - "\n", - "test_preds_ice['cate_linear'] = get_linear_cate_predictions(linear_model_ice, test_preds_ice, T_ice_cont)\n", + "rf_model_base = RandomForestRegressor(n_estimators=100, min_samples_leaf=20, random_state=42)\n", "\n", + "# --- 모델 1b: 선형 CATE (OLS) - 이진형 T 기준 ---\n", + "formula_linear_ice_binary = 'sales ~ price_binary * (temp + C(weekday) + cost)'\n", + "linear_model_ice_binary = smf.ols(formula_linear_ice_binary, data=train_ice).fit()\n", "\n", - "# --- 모델 2: S-Learner (RF) ---\n", - "rf_model_base = RandomForestRegressor(n_estimators=100, min_samples_leaf=20, random_state=42)\n", - "s_learner_ice = clone(rf_model_base)\n", - "s_learner_ice.fit(train_ice[X_ice + [T_ice_cont]], Y_train_ice)\n", + "# CATE 추정 (이진형 T용)\n", + "df_t1_bin = X_test_ice.copy(); df_t1_bin[T_ice_binary] = 1\n", + "df_t0_bin = X_test_ice.copy(); df_t0_bin[T_ice_binary] = 0\n", + "test_preds_ice['cate_linear_binary'] = linear_model_ice_binary.predict(df_t1_bin) - linear_model_ice_binary.predict(df_t0_bin)\n", "\n", - "# CATE 추정\n", - "X_test_s_ice_t1 = X_test_ice.copy(); X_test_s_ice_t1[T_ice_cont] = test_ice[T_ice_cont] + 1\n", - "X_test_s_ice_t0 = X_test_ice.copy(); X_test_s_ice_t0[T_ice_cont] = test_ice[T_ice_cont]\n", - "test_preds_ice['cate_s_learner'] = s_learner_ice.predict(X_test_s_ice_t1) - s_learner_ice.predict(X_test_s_ice_t0)\n", + "# --- 모델 2b: S-Learner (RF) - 이진형 T 기준 ---\n", + "s_learner_ice_binary = clone(rf_model_base)\n", + "s_learner_ice_binary.fit(train_ice[X_ice + [T_ice_binary]], Y_train_ice)\n", "\n", + "# CATE 추정 (이진형 T용)\n", + "X_test_s_ice_t1_bin = X_test_ice.copy(); X_test_s_ice_t1_bin[T_ice_binary] = 1\n", + "X_test_s_ice_t0_bin = X_test_ice.copy(); X_test_s_ice_t0_bin[T_ice_binary] = 0\n", + "test_preds_ice['cate_s_learner_binary'] = s_learner_ice_binary.predict(X_test_s_ice_t1_bin) - s_learner_ice_binary.predict(X_test_s_ice_t0_bin)\n", "\n", "# --- 모델 3: T-Learner (RF) ---\n", - "# (이진형 T_ice_binary 사용)\n", "t1_learner_ice = clone(rf_model_base)\n", "t1_learner_ice.fit(X_train_ice[T_train_ice_binary == 1], Y_train_ice[T_train_ice_binary == 1])\n", "t0_learner_ice = clone(rf_model_base)\n", "t0_learner_ice.fit(X_train_ice[T_train_ice_binary == 0], Y_train_ice[T_train_ice_binary == 0])\n", "test_preds_ice['cate_t_learner'] = t1_learner_ice.predict(X_test_ice) - t0_learner_ice.predict(X_test_ice)\n", "\n", - "\n", "# --- 모델 4: X-Learner (RF) ---\n", - "# (이진형 T_ice_binary 사용)\n", "D_t1 = Y_train_ice[T_train_ice_binary == 1] - t0_learner_ice.predict(X_train_ice[T_train_ice_binary == 1])\n", "D_t0 = t1_learner_ice.predict(X_train_ice[T_train_ice_binary == 0]) - Y_train_ice[T_train_ice_binary == 0]\n", "\n", @@ -232,34 +276,133 @@ " ((1 - prop_scores_ice) * x1_learner_ice.predict(X_test_ice))" ] }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 아이스크림 데이터 (이진 처치) AUUC 점수 ---\n", + " AUUC Score (IceCream - Binary)\n", + "X-Learner (RF) 12.497704\n", + "S-Learner (RF) - Binary 12.331727\n", + "T-Learner (RF) 12.323083\n", + "Linear (OLS) - Binary 7.041319\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Part A-1: 이진 처치 기준 성능 비교 ---\n", + "models_ice_binary = {\n", + " 'Linear (OLS) - Binary': 'cate_linear_binary',\n", + " 'S-Learner (RF) - Binary': 'cate_s_learner_binary',\n", + " 'T-Learner (RF)': 'cate_t_learner',\n", + " 'X-Learner (RF)': 'cate_x_learner'\n", + "}\n", + "auuc_results_ice_binary = {}\n", + "\n", + "for name, col in models_ice_binary.items():\n", + " auuc = auuc_score_binary(test_preds_ice, col, Y_ice, T_ice_binary)\n", + " auuc_results_ice_binary[name] = auuc\n", + "\n", + "auuc_df_ice_binary = pd.DataFrame.from_dict(auuc_results_ice_binary, orient='index', \n", + " columns=['AUUC Score (IceCream - Binary)'])\n", + "print(\"--- 아이스크림 데이터 (이진 처치) AUUC 점수 ---\")\n", + "print(auuc_df_ice_binary.sort_values('AUUC Score (IceCream - Binary)', ascending=False))\n", + "\n", + "# --- 시각화 (Cumulative Gain Plot - 이진 처치 기준) ---\n", + "plt.figure(figsize=(12, 8))\n", + "\n", + "baseline_ate_ice_binary = elast(test_preds_ice, Y_ice, T_ice_binary)\n", + "plt.plot([0, 100], [baseline_ate_ice_binary, baseline_ate_ice_binary], 'k--', \n", + " label=f'Baseline (ATE = {baseline_ate_ice_binary:.2f})')\n", + "\n", + "for name, col in models_ice_binary.items():\n", + " gain = cumulative_gain_binary(test_preds_ice, col, Y_ice, T_ice_binary)\n", + " plt.plot(np.linspace(0, 100, len(gain)), gain, \n", + " label=f'{name} (AUUC: {auuc_results_ice_binary[name]:.2f})', \n", + " linewidth=2.5)\n", + "\n", + "plt.title('CATE Model Evaluation: Cumulative Gain (Ice Cream - Binary Treatment)', fontsize=16)\n", + "plt.xlabel('% of Population Targeted (Sorted by CATE)')\n", + "plt.ylabel('Average Treatment Effect (CATE) in Group')\n", + "plt.legend()\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "test_ice(무작위 데이터셋)를 기준으로 아이스크림 예제의 모델들(선형 vs. 메타)을 비교합니다.\n", - "참고: AUUC 평가는 T/X-Learner와 공정한 비교를 위해 이진화된 처치(T_ice_binary)를 기준으로 수행합니다." + "비선형 메타-러너(S/T/X, AUUC: ~12.3)가 선형 OLS 모델(AUUC: 7.04)을 압도했습니다. 이 결과는 아이스크림 가격(처치)에 대한 반응(CATE)이 강한 비선형성을 띠고 있음을 명확히 보여줍니다. OLS는 \"가격을 올려도 괜찮은\" 그룹을 식별하지 못했지만, RF 기반 메타-러너들은 반응이 좋은 상위 그룹을 정확히 타겟팅했습니다." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Part A-2: 아이스크림 데이터 (연속형 처치 T 비교)\n", + "목표: OLS(Cont)와 S-Learner(Cont) 2개 모델만 연속형 기준으로 비교 (기본 모델: RandomForestRegressor)" ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# --- 모델 1: 선형 CATE (OLS) - 연속형 T 기준 ---\n", + "formula_linear_ice_cont = 'sales ~ price * (temp + C(weekday) + cost)'\n", + "linear_model_ice_cont = smf.ols(formula_linear_ice_cont, data=train_ice).fit()\n", + "\n", + "# CATE 추정 함수 (연속형 T용)\n", + "def get_linear_cate_predictions(model, df, t_col):\n", + " df_t1 = df.copy(); df_t1[t_col] = df_t1[t_col] + 1\n", + " return model.predict(df_t1) - model.predict(df)\n", + "\n", + "test_preds_ice['cate_linear_cont'] = get_linear_cate_predictions(linear_model_ice_cont, test_preds_ice, T_ice_cont)\n", + "\n", + "# --- 모델 2: S-Learner (RF) - 연속형 T 기준 ---\n", + "s_learner_ice_cont = clone(rf_model_base)\n", + "s_learner_ice_cont.fit(train_ice[X_ice + [T_ice_cont]], Y_train_ice)\n", + "\n", + "# CATE 추정\n", + "X_test_s_ice_t1_cont = X_test_ice.copy(); X_test_s_ice_t1_cont[T_ice_cont] = test_ice[T_ice_cont] + 1\n", + "X_test_s_ice_t0_cont = X_test_ice.copy(); X_test_s_ice_t0_cont[T_ice_cont] = test_ice[T_ice_cont]\n", + "test_preds_ice['cate_s_learner_cont'] = s_learner_ice_cont.predict(X_test_s_ice_t1_cont) - s_learner_ice_cont.predict(X_test_s_ice_t0_cont)" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "--- 아이스크림 데이터 AUUC 점수 ---\n", - " AUUC Score (IceCream)\n", - "X-Learner (RF) 12.497704\n", - "T-Learner (RF) 12.323083\n", - "Linear (OLS) 6.769121\n", - "S-Learner (RF) 0.841975\n" + "--- 아이스크림 데이터 (연속 처치) AUUC 점수 ---\n", + " AUUC Score (IceCream - Continuous)\n", + "Linear (OLS) - Cont. 0.867458\n", + "S-Learner (RF) - Cont. -0.109913\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -269,55 +412,67 @@ } ], "source": [ - "# --- 수치 비교 (AUUC) ---\n", - "models_ice = {\n", - " 'Linear (OLS)': 'cate_linear',\n", - " 'S-Learner (RF)': 'cate_s_learner',\n", - " 'T-Learner (RF)': 'cate_t_learner',\n", - " 'X-Learner (RF)': 'cate_x_learner'\n", + "# --- Part A-2: 연속 처치(Continuous T) 기준 성능 비교 ---\n", + "models_ice_continuous = {\n", + " 'Linear (OLS) - Cont.': 'cate_linear_cont',\n", + " 'S-Learner (RF) - Cont.': 'cate_s_learner_cont'\n", "}\n", - "auuc_results_ice = {}\n", + "auuc_results_ice_cont = {}\n", "\n", - "for name, col in models_ice.items():\n", - " auuc = auuc_score_binary(test_preds_ice, col, Y_ice, T_ice_binary)\n", - " auuc_results_ice[name] = auuc\n", + "for name, col in models_ice_continuous.items():\n", + " # 연속형 AUUC 헬퍼 함수 사용\n", + " auuc = auuc_score_continuous(test_preds_ice, col, Y_ice, T_ice_cont) \n", + " auuc_results_ice_cont[name] = auuc\n", "\n", - "auuc_df_ice = pd.DataFrame.from_dict(auuc_results_ice, orient='index', columns=['AUUC Score (IceCream)'])\n", - "print(\"--- 아이스크림 데이터 AUUC 점수 ---\")\n", - "print(auuc_df_ice.sort_values('AUUC Score (IceCream)', ascending=False))\n", + "auuc_df_ice_cont = pd.DataFrame.from_dict(auuc_results_ice_cont, orient='index', \n", + " columns=['AUUC Score (IceCream - Continuous)'])\n", + "print(\"--- 아이스크림 데이터 (연속 처치) AUUC 점수 ---\")\n", + "print(auuc_df_ice_cont.sort_values('AUUC Score (IceCream - Continuous)', ascending=False))\n", "\n", - "\n", - "# --- 시각화 (Cumulative Gain Plot) ---\n", + "# --- 시각화 (Cumulative Gain Plot - 연속 처치 기준) ---\n", "plt.figure(figsize=(12, 8))\n", "\n", - "baseline_ate_ice = elast(test_preds_ice, Y_ice, T_ice_binary)\n", - "plt.plot([0, 100], [baseline_ate_ice, baseline_ate_ice], 'k--', \n", - " label=f'Baseline (ATE = {baseline_ate_ice:.2f})')\n", + "baseline_sens_cont = sensitivity(test_preds_ice, Y_ice, T_ice_cont)\n", + "min_periods_cont = 30 \n", + "baseline_len = 100 \n", + "baseline_gain_cont = np.linspace(0, 1, baseline_len) * baseline_sens_cont * (len(test_preds_ice) / (len(test_preds_ice) - min_periods_cont + 1))\n", "\n", - "for name, col in models_ice.items():\n", - " gain = cumulative_gain_binary(test_preds_ice, col, Y_ice, T_ice_binary)\n", + "plt.plot(np.linspace(0, 100, len(baseline_gain_cont)), baseline_gain_cont, 'k--', \n", + " label=f'Baseline (Avg. Sensitivity = {baseline_sens_cont:.2f})')\n", + "\n", + "for name, col in models_ice_continuous.items():\n", + " # 연속형 Gain 헬퍼 함수 사용\n", + " gain = cumulative_gain_continuous(test_preds_ice, col, Y_ice, T_ice_cont) \n", " plt.plot(np.linspace(0, 100, len(gain)), gain, \n", - " label=f'{name} (AUUC: {auuc_results_ice[name]:.2f})', \n", + " label=f'{name} (AUUC: {auuc_results_ice_cont[name]:.2f})', \n", " linewidth=2.5)\n", "\n", - "plt.title('CATE Model Evaluation: Cumulative Gain (Ice Cream Data)', fontsize=16)\n", + "plt.title('CATE Model Evaluation: Cumulative Gain (Ice Cream - Continuous Treatment)', fontsize=16)\n", "plt.xlabel('% of Population Targeted (Sorted by CATE)')\n", - "plt.ylabel('Average Treatment Effect (CATE) in Group')\n", + "plt.ylabel('Cumulative Gain (Sensitivity * % Pop.)')\n", "plt.legend()\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "선형 OLS 모델(AUUC: 0.87)이 S-Learner (RF) (AUUC: -0.11)보다 훨씬 우수했습니다. 이진 처치와 달리, CATE를 '연속적인 민감도(기울기)'로 추정하는 과제에서는 OLS가 더 뛰어났습니다. 이는 OLS가 처음부터 상호작용 항을 통해 이 기울기 자체를 추정하도록 설계되었기 때문입니다. 반면 S-Learner(RF)는 값(Y) 자체의 예측은 잘할 수 있어도, 그 '미분값(CATE)'을 안정적으로 추정하는 데는 구조적인 약점이 있음을 보여줍니다." + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Part B: 이메일 마케팅 데이터 (이진형 T)\n", - "모든 모델은 편향된 train_email 데이터로 학습하고, 무작위 test_email 데이터로 평가합니다." + "- 모든 모델은 편향된 train_email 데이터로 학습하고, 무작위 test_email 데이터로 평가합니다.\n", + "- 이메일 데이터셋(Part B)에 `LGBMRegressor`를 사용한 것은 원본 핸드북(21장)의 실험 환경을 정확하게 재현하기 위함입니다. `LGBM`은 `RandomForest`와 같은 트리 기반 모델이면서도, 더 빠르고 종종 더 나은 성능을 보여주어 CATE 추론을 위한 메타-러너의 기본 엔진으로 널리 사용됩니다. 메타-러너는 특정 ML 모델에 종속되지 않으므로 `RandomForest`를 기본 엔진으로 사용하는 것 역시 완벽하게 유효한 접근 방식입니다." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -340,9 +495,542 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[LightGBM] [Info] Auto-choosing col-wise multi-threading, the overhead of testing was 0.001017 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 996\n", + "[LightGBM] [Info] Number of data points in the train set: 15000, number of used features: 5\n", + "[LightGBM] [Info] Start training from score 0.200467\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.000367 seconds.\n", + "You can set `force_row_wise=true` to remove the overhead.\n", + "And if memory is not enough, you can set `force_col_wise=true`.\n", + "[LightGBM] [Info] Total Bins 958\n", + "[LightGBM] [Info] Number of data points in the train set: 3370, number of used features: 4\n", + "[LightGBM] [Info] Start training from score 0.237982\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Info] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000278 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 988\n", + "[LightGBM] [Info] Number of data points in the train set: 11630, number of used features: 4\n", + "[LightGBM] [Info] Start training from score 0.189596\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Info] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000223 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 958\n", + "[LightGBM] [Info] Number of data points in the train set: 3370, number of used features: 4\n", + "[LightGBM] [Info] Start training from score 0.065091\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Info] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000361 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 988\n", + "[LightGBM] [Info] Number of data points in the train set: 11630, number of used features: 4\n", + "[LightGBM] [Info] Start training from score 0.103888\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n" + ] + } + ], "source": [ "# --- 모델 1: 선형 CATE (OLS) ---\n", "formula_linear_email = 'converted ~ em1 * (age + income + insurance + invested)'\n", @@ -354,9 +1042,9 @@ "test_preds_email['cate_linear'] = linear_model_email.predict(df_t1) - linear_model_email.predict(df_t0)\n", "\n", "\n", - "# --- 모델 2: S-Learner (RF) ---\n", - "rf_model_email = RandomForestRegressor(n_estimators=100, min_samples_leaf=30, max_depth=3, random_state=42)\n", - "s_learner_email = clone(rf_model_email)\n", + "# --- 모델 2: S-Learner (LGBM) ---\n", + "# 21장 S-Learner 파라미터 사용 (max_depth=3, min_child_samples=30)\n", + "s_learner_email = LGBMRegressor(max_depth=3, min_child_samples=30, random_state=42)\n", "s_learner_email.fit(train_email[X_email + [T_email]], Y_train_em)\n", "\n", "# CATE 추정\n", @@ -365,24 +1053,30 @@ "test_preds_email['cate_s_learner'] = s_learner_email.predict(X_test_s_t1_em) - s_learner_email.predict(X_test_s_t0_em)\n", "\n", "\n", - "# --- 모델 3: T-Learner (RF) ---\n", - "t1_learner_email = clone(rf_model_email)\n", + "# --- 모델 3: T-Learner (LGBM) ---\n", + "# 21장 T-Learner 파라미터 사용 (max_depth=2, min_child_samples=60)\n", + "t1_learner_email = LGBMRegressor(max_depth=2, min_child_samples=60, random_state=42)\n", "t1_learner_email.fit(X_train_em[T_train_em == 1], Y_train_em[T_train_em == 1])\n", - "t0_learner_email = clone(rf_model_email)\n", + "\n", + "t0_learner_email = LGBMRegressor(max_depth=2, min_child_samples=60, random_state=42)\n", "t0_learner_email.fit(X_train_em[T_train_em == 0], Y_train_em[T_train_em == 0])\n", + "\n", "test_preds_email['cate_t_learner'] = t1_learner_email.predict(X_test_em) - t0_learner_email.predict(X_test_em)\n", "\n", "\n", - "# --- 모델 4: X-Learner (RF) ---\n", + "# --- 모델 4: X-Learner (LGBM) ---\n", + "# 1단계: 모델 3에서 학습한 t0_learner_email, t1_learner_email 사용\n", "D_t1_em = Y_train_em[T_train_em == 1] - t0_learner_email.predict(X_train_em[T_train_em == 1])\n", "D_t0_em = t1_learner_email.predict(X_train_em[T_train_em == 0]) - Y_train_em[T_train_em == 0]\n", "\n", - "x1_learner_email = clone(rf_model_email)\n", + "# 2단계: 21장 X-Learner 2단계 파라미터 사용 (max_depth=2, min_child_samples=30)\n", + "x1_learner_email = LGBMRegressor(max_depth=2, min_child_samples=30, random_state=42)\n", "x1_learner_email.fit(X_train_em[T_train_em == 1], D_t1_em)\n", - "x0_learner_email = clone(rf_model_email)\n", + "\n", + "x0_learner_email = LGBMRegressor(max_depth=2, min_child_samples=30, random_state=42)\n", "x0_learner_email.fit(X_train_em[T_train_em == 0], D_t0_em)\n", "\n", - "# 성향 점수 모델 \n", + "# 성향 점수 모델 (penalty='none' 유지)\n", "prop_model_email = LogisticRegression(random_state=42, solver='lbfgs', penalty=None, max_iter=1000)\n", "prop_model_email.fit(X_train_em, T_train_em)\n", "\n", @@ -392,16 +1086,9 @@ " ((1 - prop_scores_em) * x1_learner_email.predict(X_test_em))" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "test_email(무작위 데이터셋)를 기준으로 **이메일 예제의 모델들(선형 vs. 메타)**을 비교합니다." - ] - }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -409,16 +1096,16 @@ "output_type": "stream", "text": [ "--- 이메일 데이터 AUUC 점수 (편향된 데이터로 학습) ---\n", - " AUUC Score (Email)\n", - "X-Learner (RF) 0.038409\n", - "Linear (OLS) 0.033553\n", - "T-Learner (RF) 0.030136\n", - "S-Learner (RF) -0.011199\n" + " AUUC Score (Email)\n", + "X-Learner (LGBM) 0.039434\n", + "S-Learner (LGBM) 0.035250\n", + "Linear (OLS) 0.033553\n", + "T-Learner (LGBM) 0.026654\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -431,9 +1118,9 @@ "# --- 수치 비교 (AUUC) ---\n", "models_email = {\n", " 'Linear (OLS)': 'cate_linear',\n", - " 'S-Learner (RF)': 'cate_s_learner',\n", - " 'T-Learner (RF)': 'cate_t_learner',\n", - " 'X-Learner (RF)': 'cate_x_learner'\n", + " 'S-Learner (LGBM)': 'cate_s_learner',\n", + " 'T-Learner (LGBM)': 'cate_t_learner',\n", + " 'X-Learner (LGBM)': 'cate_x_learner'\n", "}\n", "auuc_results_email = {}\n", "\n", @@ -466,6 +1153,13 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "모든 모델(OLS, S, T, X)이 베이스라인(ATE)보다 훨씬 우수한 성과를 보였으며, 그중 S-Learner(LGBM)가 가장 근소하게 우수했습니다 (AUUC: 0.0353).아이스크림 데이터와 달리, 이메일 데이터에서는 CATE의 이질성이 주로 선형적이거나 매우 단*할 가능성이 높습니다. OLS(AUUC: 0.0336)가 다른 메타-러너들과 거의 대등한 성능을 보인 것은, 복잡한 비선형 모델이 추가적으로 잡아낼 이질성이 거의 없었다는 의미입니다. 이는 OLS가 CATE 추론에서 강력한 기준선임을 재확인시켜 줍니다." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -479,11 +1173,16 @@ " async>\n", "" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "myenv", + "display_name": "causal_env", "language": "python", "name": "python3" }, @@ -497,7 +1196,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.18" } }, "nbformat": 4,