updated

README.md

@@ -1,5 +1,5 @@
 ---
-title: ComfyCausalAI
+title: Example2
 emoji: 🐨
 colorFrom: blue
 colorTo: yellow
@@ -9,4 +9,68 @@ app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Causal AI - Synthetic Customer Data Generator and RCT Simulator
+
+## Project Overview
+
+This project provides a comprehensive toolkit for generating synthetic e-commerce customer data, simulating Randomized Control Trials (RCTs), and analyzing the results using causal inference techniques. It's designed to help data scientists and analysts explore the impact of various discount strategies on customer behavior and business metrics.
+
+## Key Features
+
+1. **Synthetic Data Generation**: Create realistic customer profiles with various attributes.
+2. **RCT Simulation**: Run experiments with different discount levels.
+3. **Results Analysis**: Analyze the impact of discounts on key business metrics.
+4. **Uplift Modeling**: Build and evaluate uplift models to predict individual treatment effects.
+5. **Targeted Policy Simulation**: Test targeting strategies based on uplift model predictions.
+
+## Project Structure
+
+- `app.py`: Main application file with Gradio interface
+- `data_generator.py`: Synthetic customer data generation
+- `rct_simulator.py`: Randomized Control Trial simulation
+- `rct_analyzer.py`: Analysis of RCT results
+- `requirements.txt`: List of required Python packages
+
+## Installation
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/neurons-lab/causal-ai.git
+   cd causal-ai
+   ```
+
+2. Create a virtual environment (optional but recommended):
+   ```
+   python -m venv venv
+   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
+   ```
+
+3. Install the required packages:
+   ```
+   pip install -r requirements.txt
+   ```
+
+## Usage
+
+Run the main application:
+
+```
+python app.py
+```
+
+This will start the Gradio interface, which you can access through your web browser. The interface is divided into several tabs:
+
+1. **Generate Customer Data**: Create synthetic customer profiles.
+2. **Run RCT Simulation**: Simulate a Randomized Control Trial with different discount levels.
+3. **Analyze RCT Results**: View and analyze the results of the RCT.
+4. **Exploratory Data Analysis**: Explore the impact of discounts on different customer segments.
+5. **Build Uplift Model**: Create uplift models to predict individual treatment effects.
+6. **Run Targeting Policy**: Test targeting strategies based on uplift model predictions.
+
+## Customization
+
+You can customize various aspects of the simulation:
+
+- Modify the `electronics_products` list in `rct_simulator.py` to change the available products.
+- Adjust the `calculate_purchase_probability` function in `rct_simulator.py` to alter how customer attributes affect purchase likelihood.
+- Update the `REGIONS` dictionary in `data_generator.py` to change the demographic characteristics of different regions.

app.py

@@ -6,18 +6,34 @@ import numpy as np
 import plotly
 import plotly.graph_objs as go
 from plotly.subplots import make_subplots
+import plotly.subplots as sp
 from sklearn.preprocessing import StandardScaler
 from causalml.inference.meta import BaseTClassifier
 from sklearn.ensemble import RandomForestClassifier
 from data_generator import generate_synthetic_data
-from rct_simulator import run_rct_simulation
 from rct_analyzer import analyze_rct_results
+from sklearn.model_selection import train_test_split
+from rct_simulator import run_rct_simulation, electronics_products, calculate_purchase_probability
 
 # Global variables to store generated data and RCT results
 generated_data = None
 rct_results = None
+uplift_models = {}
+last_used_features = None
 
 def perform_eda(discount_level):
+    """
+    Perform Exploratory Data Analysis on the RCT results for a specific discount level.
+    
+    This function analyzes the impact of newsletter subscription and preferred payment method
+    on purchase behavior and profitability for the selected discount level.
+    
+    Args:
+        discount_level (str): The discount level to analyze ('5% discount', '10% discount', or '15% discount')
+    
+    Returns:
+        tuple: Contains EDA results, including newsletter and payment method analysis dataframes and plots
+    """
     global rct_results, generated_data
     if rct_results is None or generated_data is None:
         return "Please generate customer data and run RCT simulation first.", None, None, None, None
@@ -47,6 +63,19 @@ def perform_eda(discount_level):
             newsletter_results, payment_results, newsletter_fig, payment_fig)
 
 def analyze_feature(df, feature):
+    """
+    Analyze the impact of a specific feature on purchase behavior and profitability.
+    
+    This function calculates incremental purchases and profits for different values of the feature,
+    comparing the treatment group (discount) to the control group.
+    
+    Args:
+        df (pandas.DataFrame): The dataset containing customer and transaction data
+        feature (str): The feature to analyze (e.g., 'newsletter_subscription' or 'preferred_payment_method')
+    
+    Returns:
+        pandas.DataFrame: Results of the feature analysis, including incremental purchases and profits
+    """
     control_df = df[df['variant'] == 'Control']
     treatment_df = df[df['variant'] != 'Control']
 
@@ -67,6 +96,17 @@ def analyze_feature(df, feature):
     return results
 
 def create_bar_plot(data, feature, discount_level):
+    """
+    Create a bar plot to visualize the impact of a feature on incremental purchases and profits.
+    
+    Args:
+        data (pandas.DataFrame): The data to plot
+        feature (str): The feature being analyzed
+        discount_level (str): The discount level being analyzed
+    
+    Returns:
+        matplotlib.figure.Figure: The created bar plot
+    """
     fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
     
     data[feature] = data[feature].astype(str)  # Ensure the feature is treated as a string
@@ -86,8 +126,16 @@ def create_bar_plot(data, feature, discount_level):
     plt.tight_layout()
     return fig
 
-    
 def generate_and_display_data(num_customers):
+    """
+    Generate synthetic customer data and display samples of basic and extra customer information.
+    
+    Args:
+        num_customers (int): The number of customer records to generate
+    
+    Returns:
+        tuple: Contains sample dataframes of basic and extra customer information, and generation info
+    """
     global generated_data
     generated_data = generate_synthetic_data(num_customers=num_customers)
     
@@ -106,6 +154,15 @@ def generate_and_display_data(num_customers):
             f"Generated {num_customers} records. Displaying samples of 10 rows for each dataset.")
 
 def run_and_display_rct(experiment_duration):
+    """
+    Run a Randomized Control Trial (RCT) simulation and display sample results.
+    
+    Args:
+        experiment_duration (int): The duration of the experiment in days
+    
+    Returns:
+        tuple: Contains sample dataframes of variant assignments and transactions, and simulation info
+    """
     global generated_data, rct_results
     if generated_data is None:
         return None, None, "Please generate customer data first."
@@ -120,6 +177,12 @@ def run_and_display_rct(experiment_duration):
             f"Ran RCT simulation for {experiment_duration} days. Displaying samples of 10 rows for each dataset.")
 
 def analyze_and_display_results():
+    """
+    Analyze the results of the RCT simulation and display overall metrics, variant metrics, and visualizations.
+    
+    Returns:
+        tuple: Contains overall metrics dataframe, variant metrics dataframe, visualization, and analysis info
+    """
     global rct_results
     if rct_results is None:
         return None, None, None, "Please run the RCT simulation first."
@@ -129,6 +192,21 @@ def analyze_and_display_results():
     return overall_df, variant_df, fig, "Analysis complete. Displaying results and visualizations."
 
 def build_uplift_model(data, features, treatment, control):
+    """
+    Build an uplift model to predict the impact of a treatment on customer behavior.
+    
+    This function prepares the data, creates dummy variables for categorical features,
+    standardizes numerical features, and fits a RandomForestClassifier and a BaseTClassifier model.
+    
+    Args:
+        data (pandas.DataFrame): The dataset containing customer and transaction data
+        features (list): List of features to use in the model
+        treatment (str): The treatment variant (e.g., '10% discount')
+        control (str): The control variant
+    
+    Returns:
+        tuple: Contains the fitted model, uplift scores, feature importance dataframe, and prepared features
+    """
     # Prepare the data
     treatment_data = data[data['variant'] == treatment]
     control_data = data[data['variant'] == control]
@@ -174,50 +252,325 @@ def build_uplift_model(data, features, treatment, control):
         elif uplift_scores.shape[1] == 1:
             uplift_scores = uplift_scores.flatten()
     
-    return uplift_scores, feature_importance_df
+    return model, uplift_scores, feature_importance_df, X
 
-def build_model_and_display(selected_features, treatment):
-    global rct_results, generated_data
+def calculate_incremental_metrics(data, uplift_scores, treatment, threshold):
+    """
+    Calculate incremental purchases and profits based on uplift scores and a threshold.
+    
+    Args:
+        data (pandas.DataFrame): The dataset containing customer and transaction data
+        uplift_scores (numpy.array): The uplift scores for each customer
+        treatment (str): The treatment variant (e.g., '10% discount')
+        threshold (float): The uplift score threshold for targeting
+    
+    Returns:
+        tuple: Contains incremental purchases and incremental profits
+    """
+    treated = data[data['variant'] == treatment]
+    control = data[data['variant'] == 'Control']
+    
+    targeted = data[uplift_scores > threshold]
+    targeted_treated = targeted[targeted['variant'] == treatment]
+    targeted_control = targeted[targeted['variant'] == 'Control']
+    
+    inc_purchases = (targeted_treated['purchase'].mean() - targeted_control['purchase'].mean()) * len(targeted)
+    inc_profit = (targeted_treated['profit'].mean() - targeted_control['profit'].mean()) * len(targeted)
+    
+    return inc_purchases, inc_profit
+
+
+def build_models_and_display(selected_features):
+    """
+    Build uplift models for all discount levels and display results.
+    
+    This function builds uplift models for 5%, 10%, and 15% discounts, calculates feature importance,
+    and creates visualizations to compare model performance.
+    
+    Args:
+        selected_features (list): List of features to use in the models
+    
+    Returns:
+        tuple: Contains model information, feature importance plot, and uplift plot
+    """
+    global rct_results, generated_data, uplift_models, last_used_features
     if rct_results is None or generated_data is None:
         return "Please generate customer data and run RCT simulation first.", None, None
-    
+
     transactions_df, variant_assignments_df = rct_results
     
     # Prepare the data
     df_with_variant = pd.merge(generated_data, variant_assignments_df, on='customer_id', how='inner')
     transactions_df['purchase'] = 1
     final_df = pd.merge(df_with_variant, transactions_df, on=['customer_id', 'variant'], how='left')
-    columns_to_fill = ['purchase', 'price', 'discounted_price', 'cost', 'profit']
-    final_df[columns_to_fill] = final_df[columns_to_fill].fillna(0)
-    
-    # Build the model
-    uplift_scores, feature_importance_df = build_uplift_model(final_df, selected_features, treatment, 'Control')
-    
-    # Calculate statistics
-    stats = pd.DataFrame({
-        'Metric': ['Mean', 'Std', 'Min', 'Max'],
-        'Value': [
-            np.mean(uplift_scores),
-            np.std(uplift_scores),
-            np.min(uplift_scores),
-            np.max(uplift_scores)
-        ]
-    })
+    final_df[['purchase', 'price', 'discounted_price', 'cost', 'profit']] = final_df[['purchase', 'price', 'discounted_price', 'cost', 'profit']].fillna(0)
+    
+    # Perform train/test split at customer ID level
+    train_ids, test_ids = train_test_split(final_df['customer_id'].unique(), test_size=0.5, random_state=42)
+    train_df = final_df[final_df['customer_id'].isin(train_ids)]
+    test_df = final_df[final_df['customer_id'].isin(test_ids)]
+    
+    treatments = ['5% discount', '10% discount', '15% discount']
+    colors = ['blue', 'green', 'purple']
+    
+    all_feature_importance = []
+    uplift_models = {}  # Store models for each treatment
+    
+    # Create subplots for train and test
+    fig_uplift = make_subplots(rows=2, cols=1, subplot_titles=("Train Set Performance", "Test Set Performance"),
+                               vertical_spacing=0.1, row_heights=[0.5, 0.5])
+    
+    for treatment, color in zip(treatments, colors):
+        model, train_uplift_scores, feature_importance_df, X_train = build_uplift_model(train_df, selected_features, treatment, 'Control')
+        uplift_models[treatment] = model  # Store the model
+        
+        feature_importance_df['treatment'] = treatment
+        all_feature_importance.append(feature_importance_df)
+        
+        X_test = pd.get_dummies(test_df[selected_features], columns=[f for f in selected_features if test_df[f].dtype == 'object'])
+        X_test = X_test.reindex(columns=X_train.columns, fill_value=0)
+        
+        scaler = StandardScaler()
+        X_test.loc[:, X_test.dtypes != 'uint8'] = scaler.fit_transform(X_test.loc[:, X_test.dtypes != 'uint8'])
+        
+        test_uplift_scores = model.predict(X_test.values)
+        if test_uplift_scores.ndim == 2:
+            test_uplift_scores = test_uplift_scores[:, 1] - test_uplift_scores[:, 0] if test_uplift_scores.shape[1] == 2 else test_uplift_scores.flatten()
+        
+        for i, (dataset, uplift_scores) in enumerate([(train_df, train_uplift_scores), (test_df, test_uplift_scores)]):
+            thresholds = np.linspace(np.min(uplift_scores), np.max(uplift_scores), 100)
+            inc_purchases, inc_profits = zip(*[calculate_incremental_metrics(dataset, uplift_scores, treatment, threshold) for threshold in thresholds])
+            
+            fig_uplift.add_trace(go.Scatter(x=inc_purchases, y=inc_profits, mode='lines', name=f'{treatment} Model', line=dict(color=color, width=2)), row=i+1, col=1)
+            fig_uplift.add_trace(go.Scatter(x=[0, inc_purchases[0]], y=[0, inc_profits[0]], mode='lines', name=f'{treatment} Random', line=dict(color=color, width=2, dash='dash')), row=i+1, col=1)
     
     # Create feature importance plot
-    fig, ax = plt.subplots(figsize=(10, 6))
-    sns.barplot(x='importance', y='feature', data=feature_importance_df.head(10), ax=ax)
-    ax.set_title(f'Top 10 Feature Importance for {treatment} vs Control')
+    fig_importance, ax = plt.subplots(figsize=(12, 8))
+    combined_feature_importance = pd.concat(all_feature_importance)
+    treatment_order = ['5% discount', '10% discount', '15% discount']
+    feature_order = combined_feature_importance[combined_feature_importance['treatment'] == '5% discount'].sort_values('importance', ascending=False)['feature'].unique()
+    
+    sns.barplot(x='importance', y='feature', hue='treatment', data=combined_feature_importance,
+                hue_order=treatment_order, order=feature_order, ax=ax)
+    
+    ax.set_title('Feature Importance for All Treatments vs Control (Train Set)')
     ax.set_xlabel('Importance')
     ax.set_ylabel('Feature')
     plt.tight_layout()
     
-    info = f"Uplift model built using {len(selected_features)} features.\n"
-    info += f"Treatment: {treatment} vs Control\n"
-    info += f"Number of samples: {len(uplift_scores)}"
+    # Improve uplift plot appearance
+    fig_uplift.update_layout(
+        height=1200, width=1000,
+        title={'text': 'Incremental Profit vs Incremental Purchases (All Treatments)', 'y':0.98, 'x':0.5, 'xanchor': 'center', 'yanchor': 'top'},
+        legend=dict(orientation='v', yanchor='bottom', y=0.02, xanchor='left', x=0.02, bgcolor='rgba(255, 255, 255, 0.5)')
+    )
+
+    for i in range(1, 3):
+        fig_uplift.update_xaxes(title_text="Incremental Purchases", row=i, col=1)
+        fig_uplift.update_yaxes(title_text="Incremental Profit", row=i, col=1)
+        fig_uplift.update_xaxes(showgrid=True, gridwidth=1, gridcolor='lightgray', row=i, col=1)
+        fig_uplift.update_yaxes(showgrid=True, gridwidth=1, gridcolor='lightgray', row=i, col=1)
+    
+    last_used_features = selected_features  # Store the last used features
+    
+    info = f"Uplift models built using {len(selected_features)} features.\n"
+    info += f"Treatments: 5%, 10%, and 15% discounts vs Control\n"
+    info += f"Number of samples: Train set - {len(train_df)}, Test set - {len(test_df)}\n"
+    info += f"Displaying results for both Train and Test sets"
+    
+    return info, fig_importance, fig_uplift
+    
+
+def run_targeting_policy(discount_level, target_percentage, experiment_duration):
+    """
+    Run a targeting policy experiment based on the uplift model predictions.
+
+    This function applies the uplift model to predict customer responses to a discount,
+    targets a specified percentage of customers, and simulates the experiment results.
+
+    Args:
+        discount_level (str): The discount level to apply (e.g., '10% discount')
+        target_percentage (float): The percentage of customers to target with the discount
+        experiment_duration (int): The duration of the experiment in days
+
+    Returns:
+        tuple: Contains the experiment results DataFrame, transactions DataFrame, and experiment info
+    """
+    global generated_data, uplift_models, last_used_features
+    if generated_data is None or not uplift_models:
+        return None, "Please generate customer data and build uplift models first."
+    
+    # Prepare the data
+    df = generated_data.copy()
+    
+    # Use the uplift model to make predictions
+    model = uplift_models.get(discount_level)
+    if model is None:
+        return None, f"No uplift model found for {discount_level}. Please build the model first."
+    
+    # Prepare features for prediction
+    X = pd.get_dummies(df[last_used_features], columns=[f for f in last_used_features if df[f].dtype == 'object'])
+    
+    # Standardize numerical features
+    numerical_features = [f for f in last_used_features if df[f].dtype in ['int64', 'float64']]
+    scaler = StandardScaler()
+    X[numerical_features] = scaler.fit_transform(X[numerical_features])
+    
+    # Get uplift scores
+    uplift_scores = model.predict(X.values)
+    if uplift_scores.ndim == 2:
+        uplift_scores = uplift_scores[:, 1] - uplift_scores[:, 0] if uplift_scores.shape[1] == 2 else uplift_scores.flatten()
+    
+    # Calculate the threshold based on the target percentage
+    model_threshold = get_threshold_for_percentage(uplift_scores, target_percentage)
+    
+    # Assign variants
+    all_variants = ['Control', '5% discount', '10% discount', '15% discount', 'Targeted']
+    variant_probabilities = [0.2] * 5  # Equal probability for all variants
+    
+    df['experiment_variant'] = np.random.choice(all_variants, size=len(df), p=variant_probabilities)
+    
+    # For customers in the Targeted group, determine if they get a discount
+    df['gets_targeted_discount'] = (df['experiment_variant'] == 'Targeted') & (uplift_scores > model_threshold)
+    
+    # Run simulation
+    transactions_df = run_targeted_simulation(df, experiment_duration, discount_level)
+    
+    return df, transactions_df, f"Ran targeting policy simulation for {experiment_duration} days with {discount_level} and targeting {target_percentage}% of the audience."
+
+def run_targeted_simulation(df, experiment_duration, discount_level):
+    """
+    Run a targeted simulation based on the assigned variants and uplift scores.
+
+    This function simulates customer purchases during the experiment period,
+    taking into account the assigned variants and whether customers receive targeted discounts.
+
+    Args:
+        df (pandas.DataFrame): The customer data with assigned variants and targeting information
+        experiment_duration (int): The duration of the experiment in days
+        discount_level (str): The discount level being applied (e.g., '10% discount')
+
+    Returns:
+        pandas.DataFrame: A DataFrame containing the simulated transactions
+    """
+    transactions = []
+    for _, customer in df.iterrows():
+        variant = customer['experiment_variant']
+        if variant == 'Targeted':
+            discount = float(discount_level.split('%')[0]) / 100 if customer['gets_targeted_discount'] else 0
+        elif '%' in variant:
+            discount = float(variant.split('%')[0]) / 100
+        else:
+            discount = 0
+        
+        # Simulate purchases
+        num_purchases = np.random.poisson(experiment_duration / 10)
+        for _ in range(num_purchases):
+            product = np.random.choice(electronics_products)
+            if np.random.random() < calculate_purchase_probability(customer, discount):
+                price = product['price']
+                discounted_price = price * (1 - discount)
+                cost = product['cost']
+                profit = discounted_price - cost
+                transactions.append({
+                    'customer_id': customer['customer_id'],
+                    'variant': variant,
+                    'product': product['name'],
+                    'price': price,
+                    'discounted_price': discounted_price,
+                    'cost': cost,
+                    'profit': profit
+                })
+    
+    return pd.DataFrame(transactions)
+
+def analyze_targeting_results(assignment_df, transactions_df):
+    """
+    Analyze the results of the targeting policy experiment.
+
+    This function calculates various metrics for each variant, including conversion rates,
+    average revenue and profit per customer, and incremental purchases and profits.
+
+    Args:
+        assignment_df (pandas.DataFrame): The DataFrame containing variant assignments
+        transactions_df (pandas.DataFrame): The DataFrame containing transaction data
+
+    Returns:
+        tuple: Contains a DataFrame with variant metrics and a plotly Figure object
+    """
+    # Calculate metrics for assigned customers
+    assigned_customers = assignment_df.groupby('experiment_variant')['customer_id'].nunique().reset_index()
+    assigned_customers.columns = ['variant', 'assigned_customers']
     
-    return info, stats, fig
+    # Calculate metrics for purchases
+    purchase_metrics = transactions_df.groupby('variant').agg({
+        'customer_id': 'nunique',
+        'discounted_price': 'sum',
+        'profit': 'sum'
+    }).reset_index()
+    purchase_metrics.columns = ['variant', 'purchasing_customers', 'revenue', 'profit']
+    
+    # Merge assigned customers with purchase metrics
+    variant_metrics = pd.merge(assigned_customers, purchase_metrics, on='variant', how='left')
+    variant_metrics = variant_metrics.fillna(0)  # Fill NaN values with 0 for variants with no purchases
+    
+    # Calculate additional metrics
+    variant_metrics['conversion_rate'] = variant_metrics['purchasing_customers'] / variant_metrics['assigned_customers']
+    variant_metrics['avg_revenue_per_customer'] = variant_metrics['revenue'] / variant_metrics['assigned_customers']
+    variant_metrics['avg_profit_per_customer'] = variant_metrics['profit'] / variant_metrics['assigned_customers']
+    
+    # Calculate incremental metrics compared to control
+    control_metrics = variant_metrics[variant_metrics['variant'] == 'Control'].iloc[0]
+    variant_metrics['incremental_purchases'] = variant_metrics['purchasing_customers'] - control_metrics['purchasing_customers']
+    variant_metrics['incremental_profit'] = variant_metrics['profit'] - control_metrics['profit']
+    
+    # Create visualization
+    fig = go.Figure()
+    
+    colors = {'Control': 'blue', '5% discount': 'green', '10% discount': 'orange', 
+              '15% discount': 'red', 'Targeted': 'purple'}
+    
+    for variant in variant_metrics['variant']:
+        variant_data = variant_metrics[variant_metrics['variant'] == variant]
+        fig.add_trace(go.Scatter(
+            x=[variant_data['incremental_purchases'].values[0]],
+            y=[variant_data['incremental_profit'].values[0]],
+            mode='markers+text',
+            name=variant,
+            text=[variant],
+            textposition="top center",
+            marker=dict(size=12, color=colors.get(variant, 'gray'))
+        ))
+    
+    fig.update_layout(
+        title='Incremental Profit vs Incremental Purchases by Variant',
+        xaxis_title='Incremental Purchases',
+        yaxis_title='Incremental Profit',
+        showlegend=True
+    )
+    
+    return variant_metrics, fig
 
+def get_threshold_for_percentage(uplift_scores, percentage):
+    """
+    Calculate the threshold that targets the specified percentage of the audience.
+
+    Args:
+        uplift_scores (numpy.array): Array of uplift scores for all customers
+        percentage (float): The desired percentage of customers to target
+
+    Returns:
+        float: The uplift score threshold that targets the specified percentage of customers
+    """
+    if percentage == 100:
+        return np.min(uplift_scores) - 1e-10  # Return a value slightly lower than the minimum
+    elif percentage == 0:
+        return np.max(uplift_scores) + 1e-10  # Return a value slightly higher than the maximum
+    else:
+        sorted_scores = np.sort(uplift_scores)[::-1]  # Sort in descending order
+        index = int(len(sorted_scores) * (percentage / 100)) - 1  # Subtract 1 to avoid index out of bounds
+        return sorted_scores[index]
+    
 with gr.Blocks() as demo:
     gr.Markdown("# Causal AI - Synthetic Customer Data Generator and RCT Simulator")
     
@@ -227,7 +580,7 @@ with gr.Blocks() as demo:
         gr.Markdown("First we generate some basic attributes that are defined when the customer first registers, such as Name, City or Preferred Language.")
         gr.Markdown("Then we add some extra information that is usually the result of the customer past behavior, such as Loyalty Level, Past Purchases or Categories of interest.")
         gr.Markdown("## Select the number of customers that you want to Generate")
-        num_customers_input = gr.Slider(minimum=10000, maximum=500000, value=50000, step=1000, label="Number of Customer Records")
+        num_customers_input = gr.Slider(minimum=10000, maximum=500000, value=200000, step=1000, label="Number of Customer Records")
         generate_btn = gr.Button("Generate Customer Data")
         gr.Markdown("## Basic Customer Info Sample")
         basic_info_output = gr.DataFrame()
@@ -301,34 +654,60 @@ with gr.Blocks() as demo:
         ) 
         
     with gr.Tab("Build Uplift Model"):
-        gr.Markdown("## Build Uplift Model")
+        gr.Markdown("## Build Uplift Models for All Discount Levels")
         
         # Feature selection
         feature_checklist = gr.CheckboxGroup(
             choices=['age', 'gender', 'region', 'preferred_language', 'newsletter_subscription', 
                      'preferred_payment_method', 'loyalty_level', 'main_browsing_device', 
                      'average_order_value', 'total_orders'],
-            label="Select features for the model",
+            label="Select features for the models",
             value=['age', 'gender', 'loyalty_level', 'average_order_value', 'total_orders']
         )
         
-        # Dropdown for selecting treatment
-        treatment_dropdown = gr.Dropdown(
-            choices=['5% discount', '10% discount', '15% discount'],
-            label="Select treatment",
-            value='10% discount'
-        )
-        
-        build_model_btn = gr.Button("Build Uplift Model")
+        build_model_btn = gr.Button("Build Uplift Models")
         
         model_info = gr.Textbox(label="Model Information")
-        uplift_stats = gr.Dataframe(label="Uplift Score Statistics")
-        feature_importance_plot = gr.Plot(label="Feature Importance")
+        feature_importance_plot = gr.Plot(label="Feature Importance for All Models (Train Set)")
+        uplift_plot = gr.Plot(label="Incremental Profit vs Incremental Purchases (All Models)")
         
         build_model_btn.click(
-            fn=build_model_and_display,
-            inputs=[feature_checklist, treatment_dropdown],
-            outputs=[model_info, uplift_stats, feature_importance_plot]
+            fn=build_models_and_display,
+            inputs=[feature_checklist],
+            outputs=[model_info, feature_importance_plot, uplift_plot]
         )
 
-demo.launch()
+    with gr.Tab("Run Targeting Policy"):
+        gr.Markdown("# Run Targeting Policy Experiment")
+        gr.Markdown("In this section, we run an experiment using a targeted policy based on the uplift models.")
+        
+        discount_level = gr.Dropdown(
+            choices=['5% discount', '10% discount', '15% discount'],
+            label="Select discount level for targeting",
+            value='10% discount',
+            interactive=True
+        )
+        target_percentage = gr.Slider(minimum=0, maximum=100, value=40, step=1, label="Percentage of Audience Targeted", interactive=True)
+        experiment_duration = gr.Slider(minimum=10, maximum=60, value=30, step=1, label="Experiment Duration (days)", interactive=True)
+        
+        run_targeting_btn = gr.Button("Run Targeting Policy Experiment")
+        targeting_info = gr.Textbox(label="Targeting Experiment Info")
+        
+        gr.Markdown("## Experiment Results")
+        targeting_results = gr.DataFrame(label="Targeting Experiment Results")
+        targeting_plot = gr.Plot(label="Incremental Profit vs Incremental Purchases by Variant")
+        
+        def run_and_analyze_targeting(discount, percentage, duration):
+            assignment_df, transactions_df, info = run_targeting_policy(discount, percentage, duration)
+            if transactions_df is None:
+                return info, None, None
+            results, plot = analyze_targeting_results(assignment_df, transactions_df)
+            return info, results, plot
+        
+        run_targeting_btn.click(
+            fn=run_and_analyze_targeting,
+            inputs=[discount_level, target_percentage, experiment_duration],
+            outputs=[targeting_info, targeting_results, targeting_plot]
+        )
+        
+demo.launch()

data_generator.py

@@ -5,6 +5,19 @@ from datetime import datetime, timedelta, date
 import random
 
 def generate_synthetic_data(num_customers=1000):
+    """
+    Generate synthetic customer data for e-commerce analysis.
+
+    This function creates a dataset of customers with various attributes such as
+    demographics, purchase history, and preferences. It uses the Faker library to
+    generate realistic-looking data for Ukrainian customers.
+
+    Args:
+        num_customers (int): The number of customer records to generate (default: 1000)
+
+    Returns:
+        pandas.DataFrame: A DataFrame containing the generated customer data
+    """
     # Set up Faker for Ukrainian locale
     fake = Faker('uk_UA')
     Faker.seed(42)
@@ -17,9 +30,11 @@ def generate_synthetic_data(num_customers=1000):
 
     # Helper functions
     def generate_phone_number():
+        """Generate a realistic Ukrainian phone number."""
         return f"+380{random.randint(50, 99)}{fake.msisdn()[6:]}"
 
     def generate_email(name):
+        """Generate an email address based on the customer's name."""
         username = name.lower().replace(' ', '.').replace('\'', '')
         domain = random.choice(['gmail.com', 'ukr.net', 'i.ua', 'meta.ua', 'yahoo.com'])
         return f"{username}@{domain}"
@@ -45,7 +60,7 @@ def generate_synthetic_data(num_customers=1000):
 
         # Region and City
         region = np.random.choice(list(REGIONS.keys()))
-        region_info = REGIONS[region]
+        region_info = REGIONS[region].copy()  # Create a copy to avoid modifying the original
         is_urban = np.random.random() < region_info['urbanization']
         city = fake.city()
         if not is_urban:
@@ -53,7 +68,14 @@ def generate_synthetic_data(num_customers=1000):
 
         # Age (dependent on region)
         age = int(np.random.normal(region_info['avg_age'], 10))
-        age = max(18, min(80, age))  # Clamp between 18 and 80
+        age_noise = np.random.normal(0, 2)  # Add noise with mean 0 and std dev 2
+        age = max(18, min(80, int(age + age_noise)))
+
+        # Add noise to urbanization and tech adoption
+        urbanization_noise = np.random.normal(0, 0.05)
+        tech_adoption_noise = np.random.normal(0, 0.05)
+        region_info['urbanization'] = max(0, min(1, region_info['urbanization'] + urbanization_noise))
+        region_info['tech_adoption'] = max(0, min(1, region_info['tech_adoption'] + tech_adoption_noise))
 
         # Gender (slight dependency on age and region)
         gender_prob = 0.49 + 0.02 * (age - 40) / 40  # Slight increase in male probability with age
@@ -80,12 +102,20 @@ def generate_synthetic_data(num_customers=1000):
             order_multiplier *= 1.1 if preferred_language == 'Ukrainian' else 0.9  # Language factor
             total_orders = max(1, int(base_orders * order_multiplier))  # Ensure at least 1 order for active customers
 
+            # Add noise to total orders
+            total_orders_noise = np.random.poisson(2)
+            total_orders = max(1, total_orders + total_orders_noise)
+
             base_aov = np.random.gamma(shape=5, scale=100)
             aov_multiplier = 1 + 0.3 * (age - 40) / 40  # Age factor
             aov_multiplier *= 1 + 0.2 * (region_info['urbanization'] - 0.7) / 0.3  # Urbanization factor
             aov_multiplier *= 1.1 if gender == 'Male' else 0.9  # Gender factor
             average_order_value = base_aov * aov_multiplier
 
+            # Add noise to average order value
+            aov_noise = np.random.normal(0, average_order_value * 0.1)  # 10% noise
+            average_order_value = max(0, average_order_value + aov_noise)
+
             # Last order date
             last_order_date = fake.date_between(start_date=registration_date, end_date=END_DATE)
         else:
@@ -94,10 +124,16 @@ def generate_synthetic_data(num_customers=1000):
             last_order_date = None
 
         # Loyalty level based on total orders
-        loyalty_level = min(5, max(1, int(total_orders+1 / 2)))
+        loyalty_level = min(5, max(1, int(total_orders / 2)))
+
+        # Add some randomness to loyalty level
+        loyalty_noise = np.random.randint(-1, 2)  # -1, 0, or 1
+        loyalty_level = max(1, min(5, loyalty_level + loyalty_noise))
 
         # Newsletter subscription (dependent on age, loyalty, and tech adoption)
         newsletter_prob = 0.5 + 0.1 * loyalty_level / 5 - 0.2 * (age - 40) / 40 + 0.2 * region_info['tech_adoption']
+        newsletter_noise = np.random.normal(0, 0.1)
+        newsletter_prob = max(0, min(1, newsletter_prob + newsletter_noise))
         newsletter_subscription = np.random.random() < newsletter_prob
 
         # Preferred payment method (dependent on age and urbanization)
@@ -114,6 +150,10 @@ def generate_synthetic_data(num_customers=1000):
             p=payment_probs
         )
 
+        # Add some inconsistency to preferred payment method
+        if np.random.random() < 0.1:  # 10% chance of inconsistent preference
+            preferred_payment_method = np.random.choice(['Credit Card', 'Cash on Delivery', 'Bank Transfer', 'PayPal'])
+
         # Main browsing device (dependent on age and tech adoption)
         device_probs = [
             0.4 + 0.3 * (age - 40) / 40 - 0.2 * region_info['tech_adoption'],  # Web
@@ -122,6 +162,12 @@ def generate_synthetic_data(num_customers=1000):
         ]
         device_probs = [max(0, min(p, 1)) for p in device_probs]
         device_probs = [p / sum(device_probs) for p in device_probs]
+
+        # Add noise to main browsing device probabilities
+        device_noise = np.random.normal(0, 0.05, size=3)
+        device_probs = [max(0, min(1, p + n)) for p, n in zip(device_probs, device_noise)]
+        device_probs = [p / sum(device_probs) for p in device_probs]
+
         main_browsing_device = np.random.choice(['Web', 'Mobile', 'App'], p=device_probs)
 
         # Product categories (dependent on age, gender, and browsing device)
@@ -169,4 +215,4 @@ def generate_synthetic_data(num_customers=1000):
 
 if __name__ == "__main__":
     df = generate_synthetic_data()
-    print(df.head())
+    print(df.head())

rct_analyzer.py

@@ -2,6 +2,18 @@ import pandas as pd
 import matplotlib.pyplot as plt
 
 def calculate_metrics(df):
+    """
+    Calculate key metrics from the RCT results.
+
+    This function computes various metrics such as total customers, purchases,
+    revenue, profit, conversion rate, and average order value.
+
+    Args:
+        df (pandas.DataFrame): The DataFrame containing RCT results
+
+    Returns:
+        pandas.Series: A series containing calculated metrics
+    """
     total_customers = len(df['customer_id'].unique())
     total_purchases = len(df)
     total_revenue = df['discounted_price'].sum()
@@ -19,6 +31,19 @@ def calculate_metrics(df):
     })
 
 def analyze_rct_results(transactions_df, variant_assignments_df):
+    """
+    Analyze the results of the Randomized Control Trial (RCT).
+
+    This function calculates overall metrics, metrics per variant, and creates
+    visualizations to compare the performance of different discount levels.
+
+    Args:
+        transactions_df (pandas.DataFrame): DataFrame containing transaction data
+        variant_assignments_df (pandas.DataFrame): DataFrame containing variant assignments
+
+    Returns:
+        tuple: Contains overall metrics DataFrame, variant metrics DataFrame, and a matplotlib Figure
+    """
     overall_metrics = calculate_metrics(transactions_df)
     variant_metrics = transactions_df.groupby('variant').apply(calculate_metrics).reset_index()
 
@@ -36,34 +61,20 @@ def analyze_rct_results(transactions_df, variant_assignments_df):
     variant_metrics['variant'] = pd.Categorical(variant_metrics['variant'], categories=variant_order, ordered=True)
     variant_metrics = variant_metrics.sort_values('variant')
 
-#    # Create plots
-#    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 12))
+    # Create plots
+    fig, ax1 = plt.subplots(1, 1, figsize=(10, 6))
 
-#    # Create plots
-    fig, ax2 = plt.subplots(1, 1, figsize=(10, 6))
-#
     # Incremental Total Profit vs Incremental Total Purchases
     non_control = variant_metrics[variant_metrics['variant'] != 'Control']
-#    ax1.scatter(non_control['Incremental Purchases'], non_control['Incremental Profit'])
-#    for _, row in non_control.iterrows():
-#        ax1.annotate(row['variant'], (row['Incremental Purchases'], row['Incremental Profit']))
-#    ax1.set_xlabel('Incremental Total Purchases')
-#    ax1.set_ylabel('Incremental Total Profit')
-#    ax1.set_title('Incremental Total Profit vs Incremental Total Purchases')
-#    ax1.axhline(y=0, color='r', linestyle='--')
-#    ax1.axvline(x=0, color='r', linestyle='--')
-#    ax1.grid(True, linestyle=':', alpha=0.7)
-
-#    # Incremental Total Profit per Incremental Purchases vs Incremental Total Purchases
-    ax2.scatter(non_control['Incremental Purchases'], non_control['Profit per Incremental Purchase'])
+    ax1.scatter(non_control['Incremental Purchases'], non_control['Incremental Profit'])
     for _, row in non_control.iterrows():
-        ax2.annotate(row['variant'], (row['Incremental Purchases'], row['Profit per Incremental Purchase']))
-    ax2.set_xlabel('Incremental Total Purchases')
-    ax2.set_ylabel('Incremental Total Profit per Incremental Purchase')
-    ax2.set_title('Incremental Profit per Purchase vs Incremental Purchases')
-    ax2.axhline(y=0, color='r', linestyle='--')
-    ax2.axvline(x=0, color='r', linestyle='--')
-    ax2.grid(True, linestyle=':', alpha=0.7)
-    
+        ax1.annotate(row['variant'], (row['Incremental Purchases'], row['Incremental Profit']))
+    ax1.set_xlabel('Incremental Total Purchases')
+    ax1.set_ylabel('Incremental Total Profit')
+    ax1.set_title('Incremental Total Profit vs Incremental Total Purchases')
+    ax1.axhline(y=0, color='r', linestyle='--')
+    ax1.axvline(x=0, color='r', linestyle='--')
+    ax1.grid(True, linestyle=':', alpha=0.7)
+
     plt.tight_layout()
-    return overall_df, variant_metrics, fig
+    return overall_df, variant_metrics, fig

rct_simulator.py

@@ -31,8 +31,21 @@ electronics_products = [
 variants = ['Control', '5% discount', '10% discount', '15% discount']
 discount_rates = [0, 0.05, 0.10, 0.15]
 
-# Function to calculate purchase probability with increased feature dependency
 def calculate_purchase_probability(customer, discount, base_prob=0.1):
+    """
+    Calculate the probability of a customer making a purchase based on various factors.
+
+    This function considers customer attributes such as age, loyalty, past behavior,
+    and the applied discount to determine the likelihood of a purchase.
+
+    Args:
+        customer (dict): A dictionary containing customer attributes
+        discount (float): The discount rate applied (e.g., 0.05 for 5% discount)
+        base_prob (float): The base probability of purchase (default: 0.1)
+
+    Returns:
+        float: The calculated probability of purchase
+    """
     prob = base_prob
 
     # Age factor (younger customers more sensitive to discounts)
@@ -74,33 +87,70 @@ def calculate_purchase_probability(customer, discount, base_prob=0.1):
     # Adjust probability based on discount with increased sensitivity
     discount_sensitivity = 1 + age_factor - loyalty_factor + (0.5 if customer['newsletter_subscription'] else 0)
     if discount == 0.05:
-      prob *= (1 + discount * 3.5 * discount_sensitivity)
+        prob *= (1 + discount * 3.5 * discount_sensitivity)
     elif discount == 0.1:
-      prob *= (1 + discount * 4.5 * discount_sensitivity)
+        prob *= (1 + discount * 4.5 * discount_sensitivity)
     elif discount == 0.15:
-      prob *= (1 + discount * 4.3 * discount_sensitivity)
+        prob *= (1 + discount * 4.3 * discount_sensitivity)
 
-    return min(max(prob, 0), 1)  # Ensure probability is between 0 and 1
+    # Add random noise to the probability
+    noise = np.random.normal(0, 0.02)  # Add noise with mean 0 and std dev 0.02
+    prob = max(0, min(1, prob + noise))
+
+    return prob
 
-# Function to simulate purchases
 def simulate_purchase(customer, variant_index, product):
+    """
+    Simulate a purchase based on the customer, variant, and product.
+
+    This function determines if a purchase is made, and if so, calculates
+    the discounted price, cost, and profit.
+
+    Args:
+        customer (dict): A dictionary containing customer attributes
+        variant_index (int): The index of the variant (discount level)
+        product (dict): A dictionary containing product information
+
+    Returns:
+        dict or None: A dictionary with purchase details if a purchase is made, None otherwise
+    """
     discount = discount_rates[variant_index]
     prob = calculate_purchase_probability(customer, discount)
 
     if np.random.random() < prob:
-        discounted_price = product['price'] * (1 - discount)
+        # Add some noise to the discounted price
+        price_noise = np.random.normal(0, product['price'] * 0.05)  # 5% noise
+        discounted_price = max(0, product['price'] * (1 - discount) + price_noise)
+        
+        # Add some noise to the cost
+        cost_noise = np.random.normal(0, product['cost'] * 0.03)  # 3% noise
+        adjusted_cost = max(0, product['cost'] + cost_noise)
+
         return {
             'customer_id': customer['customer_id'],
             'variant': variants[variant_index],
             'product': product['name'],
             'price': product['price'],
             'discounted_price': discounted_price,
-            'cost': product['cost'],
-            'profit': discounted_price - product['cost']
+            'cost': adjusted_cost,
+            'profit': discounted_price - adjusted_cost
         }
     return None
 
 def run_rct_simulation(df, experiment_duration=30):
+    """
+    Run a Randomized Control Trial (RCT) simulation.
+
+    This function simulates an RCT by assigning customers to different variants
+    and simulating purchases over the experiment duration.
+
+    Args:
+        df (pandas.DataFrame): The customer data
+        experiment_duration (int): The duration of the experiment in days (default: 30)
+
+    Returns:
+        tuple: Contains two DataFrames - transactions and variant assignments
+    """
     # Set random seed for reproducibility
     np.random.seed(42)
     random.seed(42)
@@ -110,10 +160,14 @@ def run_rct_simulation(df, experiment_duration=30):
     end_date = start_date + timedelta(days=experiment_duration)
 
     results = []
-    variant_assignments = []  # New list to store variant assignments
+    variant_assignments = []
 
     for _, customer in df.iterrows():
-        variant_index = np.random.randint(0, 4)  # Randomly assign variant
+        # Add some randomness to variant assignment
+        if np.random.random() < 0.05:  # 5% chance of random assignment
+            variant_index = np.random.randint(0, 4)
+        else:
+            variant_index = np.random.randint(0, 4)  # Original random assignment
             
         # Record variant assignment for all eligible customers
         variant_assignments.append({
@@ -121,8 +175,9 @@ def run_rct_simulation(df, experiment_duration=30):
             'variant': variants[variant_index]
         })
 
-        # Simulate multiple purchase opportunities
-        for _ in range(round(experiment_duration/10)):
+        # Simulate multiple purchase opportunities with varying frequency
+        num_opportunities = np.random.poisson(experiment_duration / 10)
+        for _ in range(num_opportunities):
             product = random.choice(electronics_products)
             purchase = simulate_purchase(customer, variant_index, product)
             if purchase:
@@ -135,4 +190,4 @@ def run_rct_simulation(df, experiment_duration=30):
     # Create DataFrame from variant assignments
     variant_assignments_df = pd.DataFrame(variant_assignments)
     
-    return transactions_df, variant_assignments_df
+    return transactions_df, variant_assignments_df