diff --git a/docs/source/_static/hillstorm_subgroup_men_dte.png b/docs/source/_static/hillstorm_subgroup_men_dte.png new file mode 100644 index 0000000..fd8fab0 Binary files /dev/null and b/docs/source/_static/hillstorm_subgroup_men_dte.png differ diff --git a/docs/source/_static/hillstorm_subgroup_men_pte.png b/docs/source/_static/hillstorm_subgroup_men_pte.png new file mode 100644 index 0000000..438e4aa Binary files /dev/null and b/docs/source/_static/hillstorm_subgroup_men_pte.png differ diff --git a/docs/source/_static/hillstorm_subgroup_women_dte.png b/docs/source/_static/hillstorm_subgroup_women_dte.png new file mode 100644 index 0000000..55dcc22 Binary files /dev/null and b/docs/source/_static/hillstorm_subgroup_women_dte.png differ diff --git a/docs/source/_static/hillstorm_subgroup_women_pte.png b/docs/source/_static/hillstorm_subgroup_women_pte.png new file mode 100644 index 0000000..cfb4fe8 Binary files /dev/null and b/docs/source/_static/hillstorm_subgroup_women_pte.png differ diff --git a/docs/source/tutorials/hillstrom.rst b/docs/source/tutorials/hillstrom.rst index 294be28..90f15bd 100644 --- a/docs/source/tutorials/hillstrom.rst +++ b/docs/source/tutorials/hillstrom.rst @@ -332,6 +332,327 @@ The side-by-side bar charts show probability treatment effects across different **Conclusion**: Using the real Hillstrom dataset with 64,000 customers, the distributional analysis reveals nuanced patterns in how email campaigns affect customer spending. The analysis goes beyond simple average comparisons to show how treatment effects vary across the entire spending distribution, providing insights into which customer segments respond best to different campaign types. This demonstrates the power of distribution treatment effect analysis for understanding heterogeneous responses in digital marketing experiments. +Subgroup Analysis by Purchase History +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Beyond comparing email campaigns overall, we can examine how campaign effectiveness varies by customer purchase history. This analysis segments customers based on their past purchasing behavior: + +- **Male Purchaser Segment** (``mens=1``): Customers who previously purchased men's merchandise (35,266 customers, 55.1%) +- **Female Purchaser Segment** (``womens=1``): Customers who previously purchased women's merchandise (35,182 customers, 55.0%) + +Note that these segments overlap (6,448 customers purchased both categories), so a customer can appear in both analyses. + +**Research Question**: Does the effectiveness of men's vs women's email campaigns vary by the type of merchandise customers have historically purchased? + +Defining Subgroups +^^^^^^^^^^^^^^^^^^^ + +.. code-block:: python + + # Define subgroup masks based on purchase history + male_purchasers = (df['mens'] == 1) + female_purchasers = (df['womens'] == 1) + + print(f"Male purchaser segment: {male_purchasers.sum():,} customers") + print(f"Female purchaser segment: {female_purchasers.sum():,} customers") + print(f"Overlap: {(male_purchasers & female_purchasers).sum():,} customers") + +Average Treatment Effects by Subgroup +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Let's first compute the average treatment effects (ATEs) to quantify the overall impact: + +.. code-block:: python + + # Compute ATEs for each campaign-subgroup combination + # Women's Email Campaign + ate_women_male = (revenue[(D==2) & male_purchasers].mean() - + revenue[(D==0) & male_purchasers].mean()) + ate_women_female = (revenue[(D==2) & female_purchasers].mean() - + revenue[(D==0) & female_purchasers].mean()) + + # Men's Email Campaign + ate_men_male = (revenue[(D==1) & male_purchasers].mean() - + revenue[(D==0) & male_purchasers].mean()) + ate_men_female = (revenue[(D==1) & female_purchasers].mean() - + revenue[(D==0) & female_purchasers].mean()) + + print("Average Treatment Effects by Subgroup:") + print("\nWomen's Email Campaign:") + print(f" Male Purchasers: ATE = ${ate_women_male:.4f}") + print(f" Female Purchasers: ATE = ${ate_women_female:.4f}") + print("\nMen's Email Campaign:") + print(f" Male Purchasers: ATE = ${ate_men_male:.4f}") + print(f" Female Purchasers: ATE = ${ate_men_female:.4f}") + +Expected output:: + + Average Treatment Effects by Subgroup: + + Women's Email Campaign: + Male Purchasers: ATE = $0.2564 + Female Purchasers: ATE = $0.5442 + + Men's Email Campaign: + Male Purchasers: ATE = $0.8966 + Female Purchasers: ATE = $0.8412 + +These results reveal important patterns: + +- **Women's Email Campaign**: Shows 2× stronger effect for female purchasers ($0.54) vs male purchasers ($0.26) +- **Men's Email Campaign**: Demonstrates consistent strong effects across both segments ($0.84-$0.89) + +While these averages provide a useful summary, they don't tell us *how* customer spending distributions change. The distributional and probability treatment effect analyses that follow reveal the complete picture of campaign effectiveness. + +Distribution Treatment Effects: Women's Email Campaign +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Beyond the average effects, let's examine how the Women's Email campaign shifts the entire spending distribution for each subgroup: + +.. code-block:: python + + # Analyze male purchaser segment + estimator_male = dte_adj.SimpleDistributionEstimator() + estimator_male.fit(X[male_purchasers], D[male_purchasers], revenue[male_purchasers]) + + # Analyze female purchaser segment + estimator_female = dte_adj.SimpleDistributionEstimator() + estimator_female.fit(X[female_purchasers], D[female_purchasers], revenue[female_purchasers]) + + # Define evaluation points + locations = np.linspace(0, 500, 51) + + # Compute DTE for Women's Email vs Control in each subgroup + dte_women_male, lower_women_male, upper_women_male = estimator_male.predict_dte( + target_treatment_arm=2, # Women's Email + control_treatment_arm=0, # No Email + locations=locations, + variance_type="moment" + ) + + dte_women_female, lower_women_female, upper_women_female = estimator_female.predict_dte( + target_treatment_arm=2, # Women's Email + control_treatment_arm=0, # No Email + locations=locations, + variance_type="moment" + ) + + # Visualize side-by-side + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6)) + + plot(locations, dte_women_male, lower_women_male, upper_women_male, + title="Women's Email vs Control\nMale Purchaser Segment", + xlabel="Spending ($)", ylabel="Distribution Treatment Effect", + color="purple", ax=ax1) + ax1.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5) + + plot(locations, dte_women_female, lower_women_female, upper_women_female, + title="Women's Email vs Control\nFemale Purchaser Segment", + xlabel="Spending ($)", ylabel="Distribution Treatment Effect", + color="green", ax=ax2) + ax2.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5) + + plt.tight_layout() + plt.show() + +.. image:: ../_static/hillstorm_subgroup_women_dte.png + :alt: Women's Email Campaign Subgroup Analysis + :width: 800px + :align: center + +**Key Finding for Women's Email Campaign**: The distributional treatment effects reveal that women's email campaigns are significantly more effective for the female purchaser segment (right panel) compared to the male purchaser segment (left panel). The DTE curves show that women's emails reduce the probability of low spending levels (negative DTE at lower thresholds) for female purchasers, indicating a shift toward higher spending. In contrast, the male purchaser segment shows minimal or non-significant effects across most of the spending distribution, with confidence intervals overlapping zero. + +Distribution Treatment Effects: Men's Email Campaign +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Now let's examine how the Men's Email campaign affects spending distributions: + +.. code-block:: python + + # Compute DTE for Men's Email vs Control in each subgroup + dte_men_male, lower_men_male, upper_men_male = estimator_male.predict_dte( + target_treatment_arm=1, # Men's Email + control_treatment_arm=0, # No Email + locations=locations, + variance_type="moment" + ) + + dte_men_female, lower_men_female, upper_men_female = estimator_female.predict_dte( + target_treatment_arm=1, # Men's Email + control_treatment_arm=0, # No Email + locations=locations, + variance_type="moment" + ) + + # Visualize side-by-side + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6)) + + plot(locations, dte_men_male, lower_men_male, upper_men_male, + title="Men's Email vs Control\nMale Purchaser Segment", + xlabel="Spending ($)", ylabel="Distribution Treatment Effect", + color="purple", ax=ax1) + ax1.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5) + + plot(locations, dte_men_female, lower_men_female, upper_men_female, + title="Men's Email vs Control\nFemale Purchaser Segment", + xlabel="Spending ($)", ylabel="Distribution Treatment Effect", + color="green", ax=ax2) + ax2.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5) + + plt.tight_layout() + plt.show() + +.. image:: ../_static/hillstorm_subgroup_men_dte.png + :alt: Men's Email Campaign Subgroup Analysis + :width: 800px + :align: center + +**Key Finding for Men's Email Campaign**: In contrast to women's email campaigns, men's email campaigns show consistent effectiveness across both purchase history segments. The DTE curves in both panels show similar patterns, with negative values at lower spending levels indicating reduced probability of low spending for both male and female purchasers. This suggests that men's emails have broad appeal regardless of whether customers historically purchased men's or women's merchandise. + +Probability Treatment Effects: Women's Email Campaign +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +While DTE shows how cumulative distributions shift, Probability Treatment Effects (PTE) reveal which specific spending intervals are most affected by the campaign. PTE measures the change in probability mass within each spending category: + +.. code-block:: python + + # Compute PTE for Women's Email vs Control in each subgroup + pte_locations = np.insert(locations, 0, -1) # Add -1 at beginning for intervals + + pte_women_male, pte_lower_women_male, pte_upper_women_male = estimator_male.predict_pte( + target_treatment_arm=2, # Women's Email + control_treatment_arm=0, # No Email + locations=pte_locations, + variance_type="moment" + ) + + pte_women_female, pte_lower_women_female, pte_upper_women_female = estimator_female.predict_pte( + target_treatment_arm=2, # Women's Email + control_treatment_arm=0, # No Email + locations=pte_locations, + variance_type="moment" + ) + + # Visualize side-by-side with bar charts + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6)) + + plot(locations, pte_women_male, pte_lower_women_male, pte_upper_women_male, + chart_type="bar", + title="Women's Email vs Control\nMale Purchaser Segment", + xlabel="Spending Category ($)", ylabel="Probability Treatment Effect", + color="purple", ax=ax1) + ax1.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5) + + plot(locations, pte_women_female, pte_lower_women_female, pte_upper_women_female, + chart_type="bar", + title="Women's Email vs Control\nFemale Purchaser Segment", + xlabel="Spending Category ($)", ylabel="Probability Treatment Effect", + color="green", ax=ax2) + ax2.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5) + + plt.tight_layout() + plt.show() + +.. image:: ../_static/hillstorm_subgroup_women_pte.png + :alt: Women's Email Campaign PTE Subgroup Analysis + :width: 800px + :align: center + +**Interval-Specific Insights**: The PTE bar charts reveal the mechanism behind the average treatment effect. For female purchasers (right panel), women's emails significantly reduce the probability of zero spending (non-purchasers converting to purchasers), which is the primary driver of the positive ATE. However, no significant increase in high spending categories is observed. For male purchasers (left panel), the effects are much smaller and less consistent, confirming the limited impact suggested by the ATE and DTE analyses. + +Probability Treatment Effects: Men's Email Campaign +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Let's examine which spending categories are most affected by men's email campaigns: + +.. code-block:: python + + # Compute PTE for Men's Email vs Control in each subgroup + pte_men_male, pte_lower_men_male, pte_upper_men_male = estimator_male.predict_pte( + target_treatment_arm=1, # Men's Email + control_treatment_arm=0, # No Email + locations=pte_locations, + variance_type="moment" + ) + + pte_men_female, pte_lower_men_female, pte_upper_men_female = estimator_female.predict_pte( + target_treatment_arm=1, # Men's Email + control_treatment_arm=0, # No Email + locations=pte_locations, + variance_type="moment" + ) + + # Visualize side-by-side with bar charts + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6)) + + plot(locations, pte_men_male, pte_lower_men_male, pte_upper_men_male, + chart_type="bar", + title="Men's Email vs Control\nMale Purchaser Segment", + xlabel="Spending Category ($)", ylabel="Probability Treatment Effect", + color="purple", ax=ax1) + ax1.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5) + + plot(locations, pte_men_female, pte_lower_men_female, pte_upper_men_female, + chart_type="bar", + title="Men's Email vs Control\nFemale Purchaser Segment", + xlabel="Spending Category ($)", ylabel="Probability Treatment Effect", + color="green", ax=ax2) + ax2.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5) + + plt.tight_layout() + plt.show() + +.. image:: ../_static/hillstorm_subgroup_men_pte.png + :alt: Men's Email Campaign PTE Subgroup Analysis + :width: 800px + :align: center + +**Interval-Specific Insights**: Men's email campaigns show similar PTE patterns across both segments (left and right panels). The key mechanism is twofold: (1) significant reduction in zero spending probability (converting non-purchasers to purchasers), and (2) increased probability in the $40-100 spending range. This dual effect—both purchase conversion and mid-range spending increases—occurs consistently across both male and female purchaser segments, confirming the broad effectiveness of men's campaigns. + +Key Insights from Subgroup Analysis +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Combining Average Treatment Effects (ATE), Distribution Treatment Effects (DTE), and Probability Treatment Effects (PTE) provides a comprehensive understanding of campaign effectiveness: + +**1. Campaign Targeting Effectiveness (from ATE)** + +- Women's email campaigns show 2× stronger average effects for female purchasers ($0.54) vs male purchasers ($0.26) +- Men's email campaigns demonstrate consistent strong effects across both segments ($0.89-$0.84) +- This suggests women's campaigns benefit from precise targeting, while men's campaigns have broader appeal + +**2. Distributional Shifts Beyond Averages (from DTE)** + +- For women's emails, the female purchaser segment shows negative DTE at lower spending thresholds, indicating a systematic shift away from low-spending behavior +- Male purchasers show minimal distributional changes from women's emails, with confidence intervals overlapping zero at most thresholds +- Men's emails produce similar distributional patterns across both segments, confirming broad effectiveness + +**3. Spending Category Changes (from PTE)** + +- PTE analysis reveals *which specific spending intervals* change in response to campaigns, particularly identifying the mechanisms behind average effects +- **Women's emails**: For female purchasers, the primary effect is converting non-purchasers to purchasers (significant reduction in zero spending probability). No significant increase in high spending categories was observed. +- **Men's emails**: Show a dual mechanism across both segments: (1) converting non-purchasers to purchasers (zero spending reduction), and (2) increasing purchases in the $40-100 range +- PTE enables identification of behavioral change mechanisms that are invisible in average treatment effects alone—specifically revealing that lift comes primarily from purchase conversion (0→1 effect) rather than spending increases among existing purchasers + +**4. Strategic Implications** + +Based on these findings, several practical implications emerge: + +- **For Women's Campaigns**: Target customers with history of purchasing women's merchandise to maximize ROI. The PTE analysis reveals that effectiveness comes primarily from converting non-purchasers to purchasers among female purchaser segments, rather than increasing spending among existing buyers. +- **For Men's Campaigns**: Deploy broadly as they produce consistent positive effects across diverse customer segments. Both male and female purchasers show both purchase conversion and mid-range spending increases, suggesting broader appeal. +- **Resource Allocation**: One practical implication is to prioritize precise targeting for gender-specific content (women's emails) but invest confidently in broad deployment for broadly appealing content (men's emails). + +**5. Methodological Value** + +This three-tier analysis demonstrates why distributional methods matter: + +- **ATE alone** would show that both campaigns have positive effects, but with varying magnitudes across subgroups +- **Adding DTE** reveals *how* spending distributions shift, not just average changes +- **Adding PTE** pinpoints *which spending categories* are most affected, enabling precise business decisions + +By examining effects at average, distributional, and interval-specific levels, we gain actionable insights that would be invisible to traditional mean-comparison approaches. This demonstrates the power of distribution treatment effect methods for understanding heterogeneous responses in digital marketing experiments. + +For the complete reproducible code including helper functions and visualizations, see `example/hillstrom.ipynb `_. + Next Steps ~~~~~~~~~~ diff --git a/example/hillstrom.ipynb b/example/hillstrom.ipynb new file mode 100644 index 0000000..4df1493 --- /dev/null +++ b/example/hillstrom.ipynb @@ -0,0 +1,783 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hillstrom Email Marketing Dataset - Subgroup Analysis\n", + "\n", + "This notebook reproduces the subgroup analysis from Section 3.4 of the JSAI paper, \n", + "analyzing how email campaign effectiveness varies by customer purchase history.\n", + "\n", + "We segment customers into:\n", + "- **Male purchaser segment** (`mens=1`): Customers who previously bought men's merchandise\n", + "- **Female purchaser segment** (`womens=1`): Customers who previously bought women's merchandise\n", + "\n", + "Note: These segments overlap - some customers purchased both categories." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Libraries and Load Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/a13375/Documents/GitHub/python-dte-adjustment/.venv/lib/python3.13/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset shape: (64000, 12)\n", + "\n", + "Subgroup sizes:\n", + " Male purchasers (mens=1): 35,266 (55.1%)\n", + " Female purchasers (womens=1): 35,182 (55.0%)\n", + " Overlap (both): 6,448 (10.1%)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.linear_model import LinearRegression\n", + "import dte_adj\n", + "from dte_adj.plot import plot\n", + "\n", + "# Load the Hillstrom dataset\n", + "url = \"http://www.minethatdata.com/Kevin_Hillstrom_MineThatData_E-MailAnalytics_DataMiningChallenge_2008.03.20.csv\"\n", + "df = pd.read_csv(url)\n", + "\n", + "print(f\"Dataset shape: {df.shape}\")\n", + "print(f\"\\nSubgroup sizes:\")\n", + "print(f\" Male purchasers (mens=1): {(df['mens']==1).sum():,} ({(df['mens']==1).mean():.1%})\")\n", + "print(f\" Female purchasers (womens=1): {(df['womens']==1).sum():,} ({(df['womens']==1).mean():.1%})\")\n", + "print(f\" Overlap (both): {((df['mens']==1) & (df['womens']==1)).sum():,} ({((df['mens']==1) & (df['womens']==1)).mean():.1%})\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset size: 64,000 customers\n", + "Control group (No Email): 21,306 (33.3%)\n", + "Men's Email group: 21,307 (33.3%)\n", + "Women's Email group: 21,387 (33.4%)\n" + ] + } + ], + "source": [ + "# Create treatment indicator: 0=No E-Mail, 1=Mens E-Mail, 2=Womens E-Mail\n", + "treatment_mapping = {'No E-Mail': 0, 'Mens E-Mail': 1, 'Womens E-Mail': 2}\n", + "D = df['segment'].map(treatment_mapping).values\n", + "\n", + "# Use spend as the outcome variable (revenue)\n", + "revenue = df['spend'].values\n", + "\n", + "# Encode categorical variables\n", + "zip_code_mapping = {'Surburban': 0, 'Rural': 1, 'Urban': 2} # Note: typo in original data\n", + "channel_mapping = {'Phone': 0, 'Web': 1, 'Multichannel': 2}\n", + "\n", + "# Create feature matrix\n", + "features = pd.DataFrame({\n", + " 'recency': df['recency'],\n", + " 'history': df['history'],\n", + " 'history_segment': df['history_segment'].map(lambda s: int(s[0])),\n", + " 'mens': df['mens'],\n", + " 'womens': df['womens'],\n", + " 'zip_code': df['zip_code'].map(zip_code_mapping),\n", + " 'newbie': df['newbie'],\n", + " 'channel': df['channel'].map(channel_mapping)\n", + "})\n", + "\n", + "X = features.values\n", + "\n", + "print(f\"\\nDataset size: {len(D):,} customers\")\n", + "print(f\"Control group (No Email): {(D==0).sum():,} ({(D==0).mean():.1%})\")\n", + "print(f\"Men's Email group: {(D==1).sum():,} ({(D==1).mean():.1%})\")\n", + "print(f\"Women's Email group: {(D==2).sum():,} ({(D==2).mean():.1%})\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define Subgroups" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Subgroup composition by treatment:\n", + "\n", + "Male purchaser segment (mens=1):\n", + " No E-Mail: 11,787\n", + " Men's E-Mail: 11,739\n", + " Women's E-Mail: 11,740\n", + "\n", + "Female purchaser segment (womens=1):\n", + " No E-Mail: 11,668\n", + " Men's E-Mail: 11,749\n", + " Women's E-Mail: 11,765\n" + ] + } + ], + "source": [ + "# Define subgroup masks based on past purchase history\n", + "male_purchasers = (df['mens'] == 1)\n", + "female_purchasers = (df['womens'] == 1)\n", + "\n", + "print(\"Subgroup composition by treatment:\")\n", + "print(\"\\nMale purchaser segment (mens=1):\")\n", + "for segment, arm in [('No E-Mail', 0), (\"Men's E-Mail\", 1), (\"Women's E-Mail\", 2)]:\n", + " count = ((D == arm) & male_purchasers).sum()\n", + " print(f\" {segment}: {count:,}\")\n", + "\n", + "print(\"\\nFemale purchaser segment (womens=1):\")\n", + "for segment, arm in [('No E-Mail', 0), (\"Men's E-Mail\", 1), (\"Women's E-Mail\", 2)]:\n", + " count = ((D == arm) & female_purchasers).sum()\n", + " print(f\" {segment}: {count:,}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Helper Function for Subgroup Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def analyze_subgroup(X_sub, D_sub, Y_sub, subgroup_name, campaign_name, \n", + " target_arm, control_arm=0):\n", + " \"\"\"\n", + " Analyze treatment effects for a specific subgroup.\n", + " \n", + " Parameters:\n", + " -----------\n", + " X_sub : array\n", + " Features for the subgroup\n", + " D_sub : array\n", + " Treatment assignments for the subgroup\n", + " Y_sub : array\n", + " Outcomes for the subgroup\n", + " subgroup_name : str\n", + " Name of the subgroup (e.g., \"Male Purchasers\")\n", + " campaign_name : str\n", + " Name of the campaign being analyzed\n", + " target_arm : int\n", + " Target treatment arm (1=Men's Email, 2=Women's Email)\n", + " control_arm : int\n", + " Control treatment arm (default: 0=No Email)\n", + " \n", + " Returns:\n", + " --------\n", + " dict with keys: 'ate', 'ate_se', 'dte', 'dte_lower', 'dte_upper', \n", + " 'pte', 'pte_lower', 'pte_upper', 'locations', etc.\n", + " \"\"\"\n", + " # Initialize estimator\n", + " estimator = dte_adj.SimpleDistributionEstimator()\n", + " estimator.fit(X_sub, D_sub, Y_sub)\n", + " \n", + " # Define evaluation points\n", + " locations = np.linspace(0, 500, 51)\n", + " \n", + " # Compute DTE with confidence intervals\n", + " dte, dte_lower, dte_upper = estimator.predict_dte(\n", + " target_treatment_arm=target_arm,\n", + " control_treatment_arm=control_arm,\n", + " locations=locations,\n", + " variance_type=\"moment\"\n", + " )\n", + " \n", + " # Compute PTE with confidence intervals (h=20 based on paper)\n", + " pte_locations = np.insert(locations, 0, -1) # Add -1 at beginning for intervals\n", + " pte, pte_lower, pte_upper = estimator.predict_pte(\n", + " target_treatment_arm=target_arm,\n", + " control_treatment_arm=control_arm,\n", + " locations=pte_locations,\n", + " variance_type=\"moment\"\n", + " )\n", + " \n", + " # Compute ATE (average treatment effect)\n", + " # ATE is the difference in means\n", + " ate = Y_sub[D_sub == target_arm].mean() - Y_sub[D_sub == control_arm].mean()\n", + " \n", + " # Standard error of ATE using moment-based approach\n", + " n_treat = (D_sub == target_arm).sum()\n", + " n_control = (D_sub == control_arm).sum()\n", + " var_treat = Y_sub[D_sub == target_arm].var()\n", + " var_control = Y_sub[D_sub == control_arm].var()\n", + " ate_se = np.sqrt(var_treat / n_treat + var_control / n_control)\n", + " \n", + " print(f\"\\n{subgroup_name} - {campaign_name} vs Control:\")\n", + " print(f\" Sample size: Treatment={n_treat:,}, Control={n_control:,}\")\n", + " print(f\" ATE: ${ate:.4f} (SE: ${ate_se:.4f})\")\n", + " print(f\" 95% CI: [${ate - 1.96*ate_se:.4f}, ${ate + 1.96*ate_se:.4f}]\")\n", + " p_value = 2 * (1 - np.minimum(1, np.abs(ate / ate_se))) # Rough approximation\n", + " significance = \"***\" if p_value < 0.001 else \"**\" if p_value < 0.01 else \"*\" if p_value < 0.05 else \"n.s.\"\n", + " print(f\" Significance: {significance}\")\n", + " \n", + " return {\n", + " 'ate': ate,\n", + " 'ate_se': ate_se,\n", + " 'dte': dte,\n", + " 'dte_lower': dte_lower,\n", + " 'dte_upper': dte_upper,\n", + " 'pte': pte,\n", + " 'pte_lower': pte_lower,\n", + " 'pte_upper': pte_upper,\n", + " 'locations': locations,\n", + " 'pte_locations': pte_locations,\n", + " 'n_treat': n_treat,\n", + " 'n_control': n_control\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyze Women's Email Campaign by Subgroup" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "WOMEN'S EMAIL CAMPAIGN ANALYSIS BY SUBGROUP\n", + "============================================================\n", + "\n", + "Male Purchasers (mens=1) - Women's Email vs Control:\n", + " Sample size: Treatment=11,740, Control=11,787\n", + " ATE: $0.2564 (SE: $0.1906)\n", + " 95% CI: [$-0.1172, $0.6300]\n", + " Significance: ***\n", + "\n", + "Female Purchasers (womens=1) - Women's Email vs Control:\n", + " Sample size: Treatment=11,765, Control=11,668\n", + " ATE: $0.5442 (SE: $0.1673)\n", + " 95% CI: [$0.2164, $0.8720]\n", + " Significance: ***\n" + ] + } + ], + "source": [ + "print(\"=\" * 60)\n", + "print(\"WOMEN'S EMAIL CAMPAIGN ANALYSIS BY SUBGROUP\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Male purchaser segment\n", + "results_women_male = analyze_subgroup(\n", + " X[male_purchasers], \n", + " D[male_purchasers], \n", + " revenue[male_purchasers],\n", + " subgroup_name=\"Male Purchasers (mens=1)\",\n", + " campaign_name=\"Women's Email\",\n", + " target_arm=2,\n", + " control_arm=0\n", + ")\n", + "\n", + "# Female purchaser segment\n", + "results_women_female = analyze_subgroup(\n", + " X[female_purchasers], \n", + " D[female_purchasers], \n", + " revenue[female_purchasers],\n", + " subgroup_name=\"Female Purchasers (womens=1)\",\n", + " campaign_name=\"Women's Email\",\n", + " target_arm=2,\n", + " control_arm=0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyze Men's Email Campaign by Subgroup" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================================================\n", + "MEN'S EMAIL CAMPAIGN ANALYSIS BY SUBGROUP\n", + "============================================================\n", + "\n", + "Male Purchasers (mens=1) - Men's Email vs Control:\n", + " Sample size: Treatment=11,739, Control=11,787\n", + " ATE: $0.8966 (SE: $0.2207)\n", + " 95% CI: [$0.4641, $1.3292]\n", + " Significance: ***\n", + "\n", + "Female Purchasers (womens=1) - Men's Email vs Control:\n", + " Sample size: Treatment=11,749, Control=11,668\n", + " ATE: $0.8412 (SE: $0.1915)\n", + " 95% CI: [$0.4660, $1.2165]\n", + " Significance: ***\n" + ] + } + ], + "source": [ + "print(\"\\n\" + \"=\" * 60)\n", + "print(\"MEN'S EMAIL CAMPAIGN ANALYSIS BY SUBGROUP\")\n", + "print(\"=\" * 60)\n", + "\n", + "# Male purchaser segment\n", + "results_men_male = analyze_subgroup(\n", + " X[male_purchasers], \n", + " D[male_purchasers], \n", + " revenue[male_purchasers],\n", + " subgroup_name=\"Male Purchasers (mens=1)\",\n", + " campaign_name=\"Men's Email\",\n", + " target_arm=1,\n", + " control_arm=0\n", + ")\n", + "\n", + "# Female purchaser segment\n", + "results_men_female = analyze_subgroup(\n", + " X[female_purchasers], \n", + " D[female_purchasers], \n", + " revenue[female_purchasers],\n", + " subgroup_name=\"Female Purchasers (womens=1)\",\n", + " campaign_name=\"Men's Email\",\n", + " target_arm=1,\n", + " control_arm=0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create Summary Table" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "================================================================================\n", + "SUBGROUP ANALYSIS SUMMARY TABLE\n", + "================================================================================\n", + " Campaign Subgroup ATE Std Error Sample Size (Treatment) Sample Size (Control) 95% CI Lower 95% CI Upper\n", + "Women's Email Male Purchasers 0.256416 0.190627 11740 11787 -0.117214 0.630045\n", + "Women's Email Female Purchasers 0.544214 0.167259 11765 11668 0.216386 0.872042\n", + " Men's Email Male Purchasers 0.896638 0.220700 11739 11787 0.464065 1.329211\n", + " Men's Email Female Purchasers 0.841211 0.191451 11749 11668 0.465967 1.216455\n", + "\n", + "Note: Comparison against control group (No Email)\n" + ] + } + ], + "source": [ + "# Create summary table matching paper's Table 2 format\n", + "summary_data = {\n", + " 'Campaign': [\"Women's Email\", \"Women's Email\", \"Men's Email\", \"Men's Email\"],\n", + " 'Subgroup': ['Male Purchasers', 'Female Purchasers', 'Male Purchasers', 'Female Purchasers'],\n", + " 'ATE': [\n", + " results_women_male['ate'],\n", + " results_women_female['ate'],\n", + " results_men_male['ate'],\n", + " results_men_female['ate']\n", + " ],\n", + " 'Std Error': [\n", + " results_women_male['ate_se'],\n", + " results_women_female['ate_se'],\n", + " results_men_male['ate_se'],\n", + " results_men_female['ate_se']\n", + " ],\n", + " 'Sample Size (Treatment)': [\n", + " results_women_male['n_treat'],\n", + " results_women_female['n_treat'],\n", + " results_men_male['n_treat'],\n", + " results_men_female['n_treat']\n", + " ],\n", + " 'Sample Size (Control)': [\n", + " results_women_male['n_control'],\n", + " results_women_female['n_control'],\n", + " results_men_male['n_control'],\n", + " results_men_female['n_control']\n", + " ]\n", + "}\n", + "\n", + "summary_df = pd.DataFrame(summary_data)\n", + "summary_df['95% CI Lower'] = summary_df['ATE'] - 1.96 * summary_df['Std Error']\n", + "summary_df['95% CI Upper'] = summary_df['ATE'] + 1.96 * summary_df['Std Error']\n", + "\n", + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"SUBGROUP ANALYSIS SUMMARY TABLE\")\n", + "print(\"=\" * 80)\n", + "print(summary_df.to_string(index=False))\n", + "print(\"\\nNote: Comparison against control group (No Email)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize DTE by Subgroup - Women's Email Campaign" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Image saved to: ../docs/source/_static/hillstorm_subgroup_women_dte.png\n" + ] + } + ], + "source": [ + "# Create 1x2 subplot for Women's Email campaign\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))\n", + "\n", + "# Male purchaser segment\n", + "plot(\n", + " results_women_male['locations'], \n", + " results_women_male['dte'], \n", + " results_women_male['dte_lower'], \n", + " results_women_male['dte_upper'],\n", + " title=\"Women's Email vs Control\\nMale Purchaser Segment (mens=1)\",\n", + " xlabel=\"Spending ($)\", \n", + " ylabel=\"Distribution Treatment Effect\",\n", + " color=\"purple\",\n", + " ax=ax1\n", + ")\n", + "ax1.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "\n", + "# Female purchaser segment\n", + "plot(\n", + " results_women_female['locations'], \n", + " results_women_female['dte'], \n", + " results_women_female['dte_lower'], \n", + " results_women_female['dte_upper'],\n", + " title=\"Women's Email vs Control\\nFemale Purchaser Segment (womens=1)\",\n", + " xlabel=\"Spending ($)\", \n", + " ylabel=\"Distribution Treatment Effect\",\n", + " color=\"green\",\n", + " ax=ax2\n", + ")\n", + "ax2.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('../docs/source/_static/hillstorm_subgroup_women_dte.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "\n", + "print(\"\\nImage saved to: ../docs/source/_static/hillstorm_subgroup_women_dte.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize DTE by Subgroup - Men's Email Campaign" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Image saved to: ../docs/source/_static/hillstorm_subgroup_men_dte.png\n" + ] + } + ], + "source": [ + "# Create 1x2 subplot for Men's Email campaign\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))\n", + "\n", + "# Male purchaser segment\n", + "plot(\n", + " results_men_male['locations'], \n", + " results_men_male['dte'], \n", + " results_men_male['dte_lower'], \n", + " results_men_male['dte_upper'],\n", + " title=\"Men's Email vs Control\\nMale Purchaser Segment (mens=1)\",\n", + " xlabel=\"Spending ($)\", \n", + " ylabel=\"Distribution Treatment Effect\",\n", + " color=\"purple\",\n", + " ax=ax1\n", + ")\n", + "ax1.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "\n", + "# Female purchaser segment\n", + "plot(\n", + " results_men_female['locations'], \n", + " results_men_female['dte'], \n", + " results_men_female['dte_lower'], \n", + " results_men_female['dte_upper'],\n", + " title=\"Men's Email vs Control\\nFemale Purchaser Segment (womens=1)\",\n", + " xlabel=\"Spending ($)\", \n", + " ylabel=\"Distribution Treatment Effect\",\n", + " color=\"green\",\n", + " ax=ax2\n", + ")\n", + "ax2.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('../docs/source/_static/hillstorm_subgroup_men_dte.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "\n", + "print(\"\\nImage saved to: ../docs/source/_static/hillstorm_subgroup_men_dte.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize PTE by Subgroup - Women's Email Campaign" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Image saved to: ../docs/source/_static/hillstorm_subgroup_women_pte.png\n" + ] + } + ], + "source": [ + "# Create 1x2 subplot for Women's Email campaign PTE\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))\n", + "\n", + "# Male purchaser segment PTE\n", + "plot(\n", + " results_women_male['locations'], # Use all locations for x-axis\n", + " results_women_male['pte'], \n", + " results_women_male['pte_lower'], \n", + " results_women_male['pte_upper'],\n", + " chart_type=\"bar\",\n", + " title=\"Women's Email vs Control\\nMale Purchaser Segment (mens=1)\",\n", + " xlabel=\"Spending Category ($)\", \n", + " ylabel=\"Probability Treatment Effect\",\n", + " color=\"purple\",\n", + " ax=ax1\n", + ")\n", + "ax1.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "\n", + "# Female purchaser segment PTE\n", + "plot(\n", + " results_women_female['locations'], # Use all locations for x-axis\n", + " results_women_female['pte'], \n", + " results_women_female['pte_lower'], \n", + " results_women_female['pte_upper'],\n", + " chart_type=\"bar\",\n", + " title=\"Women's Email vs Control\\nFemale Purchaser Segment (womens=1)\",\n", + " xlabel=\"Spending Category ($)\", \n", + " ylabel=\"Probability Treatment Effect\",\n", + " color=\"green\",\n", + " ax=ax2\n", + ")\n", + "ax2.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('../docs/source/_static/hillstorm_subgroup_women_pte.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "\n", + "print(\"\\nImage saved to: ../docs/source/_static/hillstorm_subgroup_women_pte.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize PTE by Subgroup - Men's Email Campaign" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Image saved to: ../docs/source/_static/hillstorm_subgroup_men_pte.png\n" + ] + } + ], + "source": [ + "# Create 1x2 subplot for Men's Email campaign PTE\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))\n", + "\n", + "# Male purchaser segment PTE\n", + "plot(\n", + " results_men_male['locations'], # Use all locations for x-axis\n", + " results_men_male['pte'], \n", + " results_men_male['pte_lower'], \n", + " results_men_male['pte_upper'],\n", + " chart_type=\"bar\",\n", + " title=\"Men's Email vs Control\\nMale Purchaser Segment (mens=1)\",\n", + " xlabel=\"Spending Category ($)\", \n", + " ylabel=\"Probability Treatment Effect\",\n", + " color=\"purple\",\n", + " ax=ax1\n", + ")\n", + "ax1.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "\n", + "# Female purchaser segment PTE\n", + "plot(\n", + " results_men_female['locations'], # Use all locations for x-axis\n", + " results_men_female['pte'], \n", + " results_men_female['pte_lower'], \n", + " results_men_female['pte_upper'],\n", + " chart_type=\"bar\",\n", + " title=\"Men's Email vs Control\\nFemale Purchaser Segment (womens=1)\",\n", + " xlabel=\"Spending Category ($)\", \n", + " ylabel=\"Probability Treatment Effect\",\n", + " color=\"green\",\n", + " ax=ax2\n", + ")\n", + "ax2.axhline(y=0, color='black', linestyle='--', linewidth=0.8, alpha=0.5)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('../docs/source/_static/hillstorm_subgroup_men_pte.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "\n", + "print(\"\\nImage saved to: ../docs/source/_static/hillstorm_subgroup_men_pte.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dte-adj", + "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.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}