app push

README.md

@@ -1,10 +1,10 @@
 ---
-title: ComfyCausalAI
-emoji: 📈
-colorFrom: gray
-colorTo: pink
+title: Example2
+emoji: 🐨
+colorFrom: blue
+colorTo: yellow
 sdk: gradio
-sdk_version: 4.40.0
+sdk_version: 4.39.0
 app_file: app.py
 pinned: false
 ---

app.py

@@ -0,0 +1,334 @@
+import gradio as gr
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+import plotly
+import plotly.graph_objs as go
+from plotly.subplots import make_subplots
+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
+
+# Global variables to store generated data and RCT results
+generated_data = None
+rct_results = None
+
+def perform_eda(discount_level):
+    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
+
+    transactions_df, variant_assignments_df = rct_results
+
+    # Merge data
+    merged_df = pd.merge(generated_data, variant_assignments_df, on='customer_id', how='inner')
+    merged_df = pd.merge(merged_df, transactions_df, on=['customer_id', 'variant'], how='left')
+    merged_df['purchase'] = merged_df['purchase'].fillna(0)
+    merged_df['profit'] = merged_df['profit'].fillna(0)
+
+    # Filter for control and selected discount level
+    filtered_df = merged_df[merged_df['variant'].isin(['Control', discount_level])]
+
+    # Analyze newsletter_subscription
+    newsletter_results = analyze_feature(filtered_df, 'newsletter_subscription')
+
+    # Analyze preferred_payment_method
+    payment_results = analyze_feature(filtered_df, 'preferred_payment_method')
+
+    # Create plots
+    newsletter_fig = create_bar_plot(newsletter_results, 'newsletter_subscription', discount_level)
+    payment_fig = create_bar_plot(payment_results, 'preferred_payment_method', discount_level)
+
+    return (f"EDA completed for {discount_level}",
+            newsletter_results, payment_results, newsletter_fig, payment_fig)
+
+def analyze_feature(df, feature):
+    control_df = df[df['variant'] == 'Control']
+    treatment_df = df[df['variant'] != 'Control']
+
+    control_stats = control_df.groupby(feature).agg({
+        'purchase': 'sum',
+        'profit': 'sum'
+    }).reset_index()
+
+    treatment_stats = treatment_df.groupby(feature).agg({
+        'purchase': 'sum',
+        'profit': 'sum'
+    }).reset_index()
+
+    results = pd.merge(control_stats, treatment_stats, on=feature, suffixes=('_control', '_treatment'))
+    results['incremental_purchases'] = results['purchase_treatment'] - results['purchase_control']
+    results['incremental_profit'] = results['profit_treatment'] - results['profit_control']
+
+    return results
+
+def create_bar_plot(data, feature, discount_level):
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+    
+    data[feature] = data[feature].astype(str)  # Ensure the feature is treated as a string
+    
+    ax1.bar(data[feature], data['incremental_purchases'])
+    ax1.set_title(f'Incremental Purchases by {feature}\n({discount_level})', fontsize=14)
+    ax1.set_xlabel(feature)
+    ax1.set_ylabel('Incremental Purchases')
+    ax1.tick_params(axis='x', rotation=45)
+
+    ax2.bar(data[feature], data['incremental_profit'])
+    ax2.set_title(f'Incremental Profit by {feature}\n({discount_level})', fontsize=14)
+    ax2.set_xlabel(feature)
+    ax2.set_ylabel('Incremental Profit')
+    ax2.tick_params(axis='x', rotation=45)
+
+    plt.tight_layout()
+    return fig
+
+    
+def generate_and_display_data(num_customers):
+    global generated_data
+    generated_data = generate_synthetic_data(num_customers=num_customers)
+    
+    df_basic_info = generated_data[['customer_id', 'name', 'email', 'age', 'gender', 'region', 'city',
+                        'registration_date', 'phone_number', 'preferred_language',
+                        'newsletter_subscription', 'preferred_payment_method']]
+    
+    df_extra_info = generated_data[['customer_id', 'loyalty_level', 'main_browsing_device', 
+                        'product_categories_of_interest', 'average_order_value', 
+                        'total_orders', 'last_order_date']]
+    
+    sample_basic = df_basic_info.sample(n=min(10, len(df_basic_info)))
+    sample_extra = df_extra_info.sample(n=min(10, len(df_extra_info)))
+    
+    return (sample_basic, sample_extra,
+            f"Generated {num_customers} records. Displaying samples of 10 rows for each dataset.")
+
+def run_and_display_rct(experiment_duration):
+    global generated_data, rct_results
+    if generated_data is None:
+        return None, None, "Please generate customer data first."
+    
+    transactions_df, variant_assignments_df = run_rct_simulation(generated_data, experiment_duration)
+    rct_results = (transactions_df, variant_assignments_df)  # Store both DataFrames as a tuple
+    
+    sample_assignments = variant_assignments_df.sample(n=min(10, len(variant_assignments_df)))
+    sample_transactions = transactions_df.sample(n=min(10, len(transactions_df)))
+    
+    return (sample_assignments, sample_transactions, 
+            f"Ran RCT simulation for {experiment_duration} days. Displaying samples of 10 rows for each dataset.")
+
+def analyze_and_display_results():
+    global rct_results
+    if rct_results is None:
+        return None, None, None, "Please run the RCT simulation first."
+    
+    transactions_df, variant_assignments_df = rct_results
+    overall_df, variant_df, fig = analyze_rct_results(transactions_df, variant_assignments_df)
+    return overall_df, variant_df, fig, "Analysis complete. Displaying results and visualizations."
+
+def build_uplift_model(data, features, treatment, control):
+    # Prepare the data
+    treatment_data = data[data['variant'] == treatment]
+    control_data = data[data['variant'] == control]
+    combined_data = pd.concat([treatment_data, control_data])
+    
+    # Create dummy variables for categorical features
+    categorical_features = [f for f in features if data[f].dtype == 'object']
+    X = pd.get_dummies(data[features], columns=categorical_features)
+    
+    # Standardize numerical features
+    numerical_features = [f for f in features if data[f].dtype in ['int64', 'float64']]
+    scaler = StandardScaler()
+    X[numerical_features] = scaler.fit_transform(X[numerical_features])
+    
+    # Prepare y and treatment for the combined data
+    y = combined_data['purchase']
+    t = (combined_data['variant'] == treatment).astype(int)
+    
+    # Create and fit the RandomForestClassifier directly
+    rf_model = RandomForestClassifier(n_estimators=50, max_depth=4)
+    rf_model.fit(X.loc[combined_data.index], y)
+    
+    # Get feature importances from the RandomForestClassifier
+    feature_importances = rf_model.feature_importances_
+    
+    # Create a dataframe with feature names and their importances
+    feature_importance_df = pd.DataFrame({
+        'feature': X.columns,
+        'importance': feature_importances
+    }).sort_values('importance', ascending=False)
+    
+    # Create and fit the BaseTClassifier model
+    model = BaseTClassifier(RandomForestClassifier(n_estimators=50, max_depth=4))
+    model.fit(X=X.loc[combined_data.index].values, treatment=t, y=y)
+    
+    # Predict for all data
+    uplift_scores = model.predict(X.values)
+    
+    # Handle 2D output if necessary
+    if uplift_scores.ndim == 2:
+        if uplift_scores.shape[1] == 2:
+            uplift_scores = uplift_scores[:, 1] - uplift_scores[:, 0]
+        elif uplift_scores.shape[1] == 1:
+            uplift_scores = uplift_scores.flatten()
+    
+    return uplift_scores, feature_importance_df
+
+def build_model_and_display(selected_features, treatment):
+    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
+    
+    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)
+        ]
+    })
+    
+    # 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')
+    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)}"
+    
+    return info, stats, fig
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Causal AI - Synthetic Customer Data Generator and RCT Simulator")
+    
+    with gr.Tab("Generate Customer Data"):
+        gr.Markdown("# Generate Synthetic Customers data")
+        gr.Markdown("In this section we generate typical data of customers that are registered to our store.")
+        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")
+        generate_btn = gr.Button("Generate Customer Data")
+        gr.Markdown("## Basic Customer Info Sample")
+        basic_info_output = gr.DataFrame()
+        gr.Markdown("## Extra Customer Info Sample")
+        extra_info_output = gr.DataFrame()
+        generate_info = gr.Textbox(label="Generation Info")
+        
+        generate_btn.click(fn=generate_and_display_data, 
+                           inputs=num_customers_input, 
+                           outputs=[basic_info_output, extra_info_output, generate_info])
+    
+    with gr.Tab("Run RCT Simulation"):
+        gr.Markdown("# Run a Randomized Control Experiment for data collection and analysis")
+        gr.Markdown("In this section we simulate running an Experiment where we offer customers different levels of discounts in the Electronics department.")
+        gr.Markdown("We randomly split the customers in 4 groups: Control, 5% discount, 10% discount and 15% discount")
+        gr.Markdown("During the experiment runtime we record all the purchases made by the customers. We can decide how long to run the experiment for, where longer periods lead to less noise and more significance in the results.")
+        experiment_duration_input = gr.Slider(minimum=10, maximum=60, value=30, step=1, label="Experiment Duration (days)")
+        rct_btn = gr.Button("Run RCT Simulation")
+        gr.Markdown("## Customer assigment to experiment group:")
+        assignments_output = gr.DataFrame()
+        gr.Markdown("## Purchases made during experiment runtime:")
+        transactions_output = gr.DataFrame()
+        rct_info = gr.Textbox(label="RCT Simulation Info")
+        rct_btn.click(fn=run_and_display_rct, 
+                      inputs=experiment_duration_input, 
+                      outputs=[assignments_output, transactions_output, rct_info])
+
+    with gr.Tab("Analyze RCT Results"):
+        gr.Markdown("# Experiment Analysis")
+        gr.Markdown("In this section we analyze the experiment results. We measure, per each discount value (5%, 10%, 15%) what is the incremental number of Purchases and the incremental Profit compared to the Control group.")
+        analyze_btn = gr.Button("Analyze RCT Results")
+        gr.Markdown("## Overall metrics")
+        overall_metrics_output = gr.DataFrame()
+        gr.Markdown("## Metrics by Variant")
+        variant_metrics_output = gr.DataFrame()
+        gr.Markdown("## Metrics per Variant visualization")
+        gr.Markdown("## To-Do: Add confidence intervals")
+        plot_output = gr.Plot()
+        analysis_info = gr.Textbox(label="Analysis Info")
+        
+        analyze_btn.click(fn=analyze_and_display_results,
+                          inputs=[],
+                          outputs=[overall_metrics_output, variant_metrics_output, plot_output, analysis_info])
+
+    with gr.Tab("Exploratory Data Analysis"):
+        gr.Markdown("# Exploratory Data Analysis")
+        gr.Markdown("In this section, we explore the impact of discounts on different customer segments.")
+        
+        discount_dropdown = gr.Dropdown(
+            choices=['5% discount', '10% discount', '15% discount'],
+            label="Select discount level to analyze",
+            value='10% discount'
+        )
+        
+        eda_btn = gr.Button("Perform EDA")
+        
+        eda_info = gr.Textbox(label="EDA Information")
+        
+        gr.Markdown("## Newsletter Subscription Analysis")
+        newsletter_results = gr.DataFrame(label="Newsletter Subscription Results")
+        newsletter_plot = gr.Plot(label="Newsletter Subscription Plot")
+        
+        gr.Markdown("## Preferred Payment Method Analysis")
+        payment_results = gr.DataFrame(label="Preferred Payment Method Results")
+        payment_plot = gr.Plot(label="Preferred Payment Method Plot")
+        
+        eda_btn.click(
+            fn=perform_eda,
+            inputs=[discount_dropdown],
+            outputs=[eda_info, newsletter_results, payment_results, newsletter_plot, payment_plot]
+        ) 
+        
+    with gr.Tab("Build Uplift Model"):
+        gr.Markdown("## Build Uplift Model")
+        
+        # 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",
+            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")
+        
+        model_info = gr.Textbox(label="Model Information")
+        uplift_stats = gr.Dataframe(label="Uplift Score Statistics")
+        feature_importance_plot = gr.Plot(label="Feature Importance")
+        
+        build_model_btn.click(
+            fn=build_model_and_display,
+            inputs=[feature_checklist, treatment_dropdown],
+            outputs=[model_info, uplift_stats, feature_importance_plot]
+        )
+
+demo.launch()

data_generator.py

@@ -0,0 +1,172 @@
+import pandas as pd
+import numpy as np
+from faker import Faker
+from datetime import datetime, timedelta, date
+import random
+
+def generate_synthetic_data(num_customers=1000):
+    # Set up Faker for Ukrainian locale
+    fake = Faker('uk_UA')
+    Faker.seed(42)
+    np.random.seed(42)
+
+    # Define constants
+    NUM_CUSTOMERS = num_customers
+    START_DATE = date(2019, 1, 1)
+    END_DATE = date(2024, 7, 31)
+
+    # Helper functions
+    def generate_phone_number():
+        return f"+380{random.randint(50, 99)}{fake.msisdn()[6:]}"
+
+    def generate_email(name):
+        username = name.lower().replace(' ', '.').replace('\'', '')
+        domain = random.choice(['gmail.com', 'ukr.net', 'i.ua', 'meta.ua', 'yahoo.com'])
+        return f"{username}@{domain}"
+
+    # Define regions and their characteristics
+    REGIONS = {
+        'Київська': {'avg_age': 40, 'urbanization': 0.8, 'tech_adoption': 0.7},
+        'Львівська': {'avg_age': 38, 'urbanization': 0.7, 'tech_adoption': 0.6},
+        'Харківська': {'avg_age': 42, 'urbanization': 0.8, 'tech_adoption': 0.65},
+        'Одеська': {'avg_age': 41, 'urbanization': 0.7, 'tech_adoption': 0.6},
+        'Дніпропетровська': {'avg_age': 43, 'urbanization': 0.75, 'tech_adoption': 0.6},
+        'Запорізька': {'avg_age': 44, 'urbanization': 0.7, 'tech_adoption': 0.55},
+        'Вінницька': {'avg_age': 42, 'urbanization': 0.6, 'tech_adoption': 0.5},
+        'Полтавська': {'avg_age': 43, 'urbanization': 0.65, 'tech_adoption': 0.55},
+        'Чернігівська': {'avg_age': 45, 'urbanization': 0.6, 'tech_adoption': 0.5},
+        'Сумська': {'avg_age': 44, 'urbanization': 0.65, 'tech_adoption': 0.5}
+    }
+
+    # Generate initial customer data
+    data = []
+    for i in range(NUM_CUSTOMERS):
+        customer_id = f"C{str(i+1).zfill(6)}"
+
+        # Region and City
+        region = np.random.choice(list(REGIONS.keys()))
+        region_info = REGIONS[region]
+        is_urban = np.random.random() < region_info['urbanization']
+        city = fake.city()
+        if not is_urban:
+            city = f"смт {city}"
+
+        # 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
+
+        # Gender (slight dependency on age and region)
+        gender_prob = 0.49 + 0.02 * (age - 40) / 40  # Slight increase in male probability with age
+        gender_prob += 0.02 * (region_info['urbanization'] - 0.7) / 0.3  # Slight increase in urban areas
+        gender = np.random.choice(['Male', 'Female', 'Other'], p=[gender_prob, 1-gender_prob-0.01, 0.01])
+
+        # Preferred Language (dependent on age and region)
+        ukrainian_prob = 0.8 - 0.2 * (age - 40) / 40  # Younger people more likely to prefer Ukrainian
+        ukrainian_prob += 0.1 * (1 - region_info['urbanization'])  # Rural areas more likely to prefer Ukrainian
+        preferred_language = np.random.choice(['Ukrainian', 'Russian'], p=[min(1, max(0, ukrainian_prob)), 1-min(1, max(0, ukrainian_prob))])
+
+        # Registration date
+        registration_date = fake.date_between(start_date=START_DATE, end_date=END_DATE)
+
+        # Determine if the customer is active (has made orders)
+        is_active = np.random.random() < 0.6  # 60% chance of being an active customer
+
+        if is_active:
+            # Total orders and average order value (dependent on various factors)
+            base_orders = np.random.poisson(5)
+            order_multiplier = 1 + 0.2 * (age - 40) / 40  # Age factor
+            order_multiplier *= 1 + 0.1 * (region_info['tech_adoption'] - 0.6) / 0.2  # Tech adoption factor
+            order_multiplier *= 1.1 if gender == 'Female' else 0.9  # Gender factor
+            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
+
+            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
+
+            # Last order date
+            last_order_date = fake.date_between(start_date=registration_date, end_date=END_DATE)
+        else:
+            total_orders = 0
+            average_order_value = 0
+            last_order_date = None
+
+        # Loyalty level based on total orders
+        loyalty_level = min(5, max(1, int(total_orders+1 / 2)))
+
+        # 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_subscription = np.random.random() < newsletter_prob
+
+        # Preferred payment method (dependent on age and urbanization)
+        payment_probs = [
+            0.5 - 0.2 * (age - 40) / 40 + 0.2 * region_info['urbanization'],  # Credit Card
+            0.3 + 0.2 * (age - 40) / 40 - 0.2 * region_info['urbanization'],  # Cash on Delivery
+            0.15,  # Bank Transfer
+            0.05 + 0.1 * region_info['tech_adoption']  # PayPal
+        ]
+        payment_probs = [max(0, min(p, 1)) for p in payment_probs]
+        payment_probs = [p / sum(payment_probs) for p in payment_probs]
+        preferred_payment_method = np.random.choice(
+            ['Credit Card', 'Cash on Delivery', 'Bank Transfer', 'PayPal'],
+            p=payment_probs
+        )
+
+        # 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
+            0.4 - 0.2 * (age - 40) / 40 + 0.1 * region_info['tech_adoption'],  # Mobile
+            0.2 - 0.1 * (age - 40) / 40 + 0.1 * region_info['tech_adoption']   # App
+        ]
+        device_probs = [max(0, min(p, 1)) for p in device_probs]
+        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)
+        all_categories = ['Electronics', 'Home Appliances', 'Computers', 'Smartphones', 'TV & Audio']
+        category_probs = [0.2] * 5
+        if age < 30:
+            category_probs[2] += 0.1  # Increase Computers
+            category_probs[3] += 0.1  # Increase Smartphones
+        elif age > 60:
+            category_probs[1] += 0.1  # Increase Home Appliances
+            category_probs[4] += 0.1  # Increase TV & Audio
+        if gender == 'Male':
+            category_probs[0] += 0.05  # Slight increase in Electronics
+            category_probs[2] += 0.05  # Slight increase in Computers
+        if main_browsing_device == 'Mobile':
+            category_probs[3] += 0.1  # Increase Smartphones
+        category_probs = [p / sum(category_probs) for p in category_probs]
+        num_categories = np.random.randint(1, 4)
+        product_categories = np.random.choice(all_categories, size=num_categories, replace=False, p=category_probs)
+
+        data.append({
+            'customer_id': customer_id,
+            'name': fake.name(),
+            'email': generate_email(fake.name()),
+            'age': age,
+            'gender': gender,
+            'region': region,
+            'city': city,
+            'registration_date': registration_date,
+            'phone_number': generate_phone_number(),
+            'preferred_language': preferred_language,
+            'newsletter_subscription': newsletter_subscription,
+            'preferred_payment_method': preferred_payment_method,
+            'loyalty_level': loyalty_level,
+            'main_browsing_device': main_browsing_device,
+            'product_categories_of_interest': ', '.join(product_categories),
+            'average_order_value': round(average_order_value, 2),
+            'total_orders': total_orders,
+            'last_order_date': last_order_date
+        })
+
+    # Create DataFrame
+    df = pd.DataFrame(data)
+    return df
+
+if __name__ == "__main__":
+    df = generate_synthetic_data()
+    print(df.head())

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

rct_analyzer.py

@@ -0,0 +1,69 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+
+def calculate_metrics(df):
+    total_customers = len(df['customer_id'].unique())
+    total_purchases = len(df)
+    total_revenue = df['discounted_price'].sum()
+    total_profit = df['profit'].sum()
+    conversion_rate = total_purchases / total_customers
+    average_order_value = total_revenue / total_purchases if total_purchases > 0 else 0
+
+    return pd.Series({
+        'Total Converted Customers': total_customers,
+        'Total Purchases': total_purchases,
+        'Total Revenue': total_revenue,
+        'Total Profit': total_profit,
+        'Conversion Rate': conversion_rate,
+        'Average Order Value': average_order_value
+    })
+
+def analyze_rct_results(transactions_df, variant_assignments_df):
+    overall_metrics = calculate_metrics(transactions_df)
+    variant_metrics = transactions_df.groupby('variant').apply(calculate_metrics).reset_index()
+
+    # Calculate incremental metrics
+    control_metrics = variant_metrics[variant_metrics['variant'] == 'Control'].iloc[0]
+    variant_metrics['Incremental Purchases'] = variant_metrics['Total Purchases'] - control_metrics['Total Purchases']
+    variant_metrics['Incremental Profit'] = variant_metrics['Total Profit'] - control_metrics['Total Profit']
+    variant_metrics['Profit per Incremental Purchase'] = variant_metrics['Incremental Profit'] / variant_metrics['Incremental Purchases']
+
+    # Prepare overall metrics table
+    overall_df = pd.DataFrame([overall_metrics])
+
+    # Prepare variant metrics table
+    variant_order = ['Control', '5% discount', '10% discount', '15% discount']
+    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, 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'])
+    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)
+    
+    plt.tight_layout()
+    return overall_df, variant_metrics, fig

rct_simulator.py

@@ -0,0 +1,138 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import random
+
+# Define the Electronics products
+electronics_products = [
+    {"name": "4K Smart TV", "cost": 500, "price": 699},
+    {"name": "Wireless Headphones", "cost": 100, "price": 139},
+    {"name": "Gaming Console", "cost": 300, "price": 419},
+    {"name": "Digital Camera", "cost": 400, "price": 559},
+    {"name": "Bluetooth Speaker", "cost": 50, "price": 69},
+    {"name": "Smartwatch", "cost": 150, "price": 209},
+    {"name": "Laptop", "cost": 600, "price": 839},
+    {"name": "Tablet", "cost": 200, "price": 279},
+    {"name": "Drone", "cost": 250, "price": 349},
+    {"name": "Home Theater System", "cost": 350, "price": 489},
+    {"name": "E-reader", "cost": 80, "price": 109},
+    {"name": "Portable Power Bank", "cost": 30, "price": 41},
+    {"name": "Wireless Earbuds", "cost": 80, "price": 109},
+    {"name": "Action Camera", "cost": 150, "price": 209},
+    {"name": "Smart Home Hub", "cost": 70, "price": 97},
+    {"name": "Gaming Mouse", "cost": 40, "price": 55},
+    {"name": "External Hard Drive", "cost": 60, "price": 83},
+    {"name": "Graphic Tablet", "cost": 180, "price": 249},
+    {"name": "Noise-Canceling Headphones", "cost": 200, "price": 279},
+    {"name": "Portable Projector", "cost": 300, "price": 419}
+]
+
+# Define the RCT variants
+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):
+    prob = base_prob
+
+    # Age factor (younger customers more sensitive to discounts)
+    age_factor = (60 - customer['age']) / 60
+    prob += 0.02 * age_factor
+
+    # Loyalty factor (more loyal customers less sensitive to discounts)
+    loyalty_factor = (6 - customer['loyalty_level']) / 5
+    prob += 0.02 * loyalty_factor
+
+    # Past behavior factor (customers with more orders more likely to buy, but less sensitive to discounts)
+    order_factor = min(customer['total_orders'] / 20, 1)
+    prob += 0.03 * order_factor
+
+    # Newsletter subscription factor (subscribed customers more sensitive to discounts)
+    if customer['newsletter_subscription']:
+        prob += 0.03
+
+    # Browsing device factor (mobile and app users more sensitive to discounts)
+    if customer['main_browsing_device'] == 'Mobile':
+        prob += 0.02
+    elif customer['main_browsing_device'] == 'App':
+        prob += 0.03
+
+    # Average order value factor (higher AOV customers less sensitive to discounts)
+    aov_factor = min(customer['average_order_value'] / 1000, 1)
+    prob -= 0.02 * aov_factor
+
+    # Gender factor (assume slightly different sensitivity to discounts)
+    if customer['gender'] == 'Female':
+        prob += 0.01
+    elif customer['gender'] == 'Male':
+        prob -= 0.01
+
+    # Preferred payment method factor
+    if customer['preferred_payment_method'] == 'Credit Card':
+        prob += 0.02  # Credit card users might be more likely to make impulse purchases
+
+    # 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)
+    elif discount == 0.1:
+      prob *= (1 + discount * 4.5 * discount_sensitivity)
+    elif discount == 0.15:
+      prob *= (1 + discount * 4.3 * discount_sensitivity)
+
+    return min(max(prob, 0), 1)  # Ensure probability is between 0 and 1
+
+# Function to simulate purchases
+def simulate_purchase(customer, variant_index, product):
+    discount = discount_rates[variant_index]
+    prob = calculate_purchase_probability(customer, discount)
+
+    if np.random.random() < prob:
+        discounted_price = product['price'] * (1 - discount)
+        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']
+        }
+    return None
+
+def run_rct_simulation(df, experiment_duration=30):
+    # Set random seed for reproducibility
+    np.random.seed(42)
+    random.seed(42)
+
+    # Set up experiment dates
+    start_date = datetime(2024, 7, 1)
+    end_date = start_date + timedelta(days=experiment_duration)
+
+    results = []
+    variant_assignments = []  # New list to store variant assignments
+
+    for _, customer in df.iterrows():
+        variant_index = np.random.randint(0, 4)  # Randomly assign variant
+            
+        # Record variant assignment for all eligible customers
+        variant_assignments.append({
+            'customer_id': customer['customer_id'],
+            'variant': variants[variant_index]
+        })
+
+        # Simulate multiple purchase opportunities
+        for _ in range(round(experiment_duration/10)):
+            product = random.choice(electronics_products)
+            purchase = simulate_purchase(customer, variant_index, product)
+            if purchase:
+                results.append(purchase)
+
+    # Create DataFrame from results
+    transactions_df = pd.DataFrame(results)
+    transactions_df['purchase'] = 1
+    
+    # Create DataFrame from variant assignments
+    variant_assignments_df = pd.DataFrame(variant_assignments)
+    
+    return transactions_df, variant_assignments_df

requirements.txt

@@ -0,0 +1,9 @@
+plotly==5.14.1
+gradio==3.50.2
+pandas==1.5.3
+numpy==1.24.3
+faker==18.9.0
+matplotlib==3.7.1
+tabulate==0.8.10
+causalml
+scikit-learn