Domain Features

# Load ecommerce data for temporal analysis
import pandas as pd
import numpy as np

# Read the dataset
df = pd.read_csv('dataplexa_ecommerce.csv')

# Convert date column to datetime for feature extraction
df['date'] = pd.to_datetime(df['date'])

# Extract multiple time features from single date column
# Each feature captures different shopping patterns

# Day of week (0=Monday, 6=Sunday)
df['day_of_week'] = df['date'].dt.dayofweek

# Weekend indicator - shopping behavior differs
df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)

# Month for seasonal trends
df['month'] = df['date'].dt.month

# Create festival season features for Indian market
# These periods show 300-500% revenue increases

def get_festival_season(date):
    month = date.month
    # Diwali season (Oct-Nov)
    if month in [10, 11]:
        return 'diwali'
    # Wedding season (Dec-Feb)
    elif month in [12, 1, 2]:
        return 'wedding'
    # Summer sale season (Mar-May)
    elif month in [3, 4, 5]:
        return 'summer'
    else:
        return 'regular'

# Apply festival season to dataset
df['festival_season'] = df['date'].apply(get_festival_season)

# Convert categorical to dummy variables for ML models
festival_dummies = pd.get_dummies(df['festival_season'], prefix='season')

# Display the new features
print(df[['date', 'festival_season']].head())

# Create customer-level behavioral features
# Group by customer to calculate their historical patterns

customer_behavior = df.groupby('customer_age').agg({
    'order_id': 'count',    # Total orders per customer
    'revenue': ['sum', 'mean'],  # Total spent and avg order value
    'quantity': 'sum',      # Total items purchased
    'returned': 'mean'      # Return rate as percentage
}).round(2)

# Create purchase frequency features
# Calculate days since last purchase for each customer

df_sorted = df.sort_values(['customer_age', 'date'])

# Days between consecutive purchases
df_sorted['days_since_last'] = df_sorted.groupby('customer_age')['date'].diff().dt.days

# Fill first purchase with 0
df_sorted['days_since_last'] = df_sorted['days_since_last'].fillna(0)

# Create loyalty and value segmentation features
# Categorize customers based on behavior patterns

def create_customer_segment(row):
    avg_order = row['revenue']
    frequency = row['quantity']
    
    # High-value frequent buyers
    if avg_order > 50000 and frequency > 5:
        return 'premium'
    # Regular customers
    elif avg_order > 20000 and frequency > 2:
        return 'regular'
    # Price-sensitive buyers
    else:
        return 'budget'

# Apply customer segmentation to dataset
df['customer_segment'] = df.apply(create_customer_segment, axis=1)

# Show segment distribution
segment_counts = df['customer_segment'].value_counts()
print("Customer Segments:")
print(segment_counts)

# Calculate product performance metrics
# These reveal which products drive business success

product_metrics = df.groupby('product_category').agg({
    'revenue': ['sum', 'mean', 'std'],  # Financial performance
    'rating': 'mean',                   # Customer satisfaction
    'returned': 'mean',                 # Quality indicator
    'quantity': 'sum'                   # Popularity measure
}).round(2)

# Create price positioning features
# Categorize products by price range for targeted marketing

def price_tier(revenue, quantity):
    unit_price = revenue / quantity if quantity > 0 else 0
    
    if unit_price > 15000:
        return 'premium'
    elif unit_price > 5000:
        return 'mid-range'
    else:
        return 'economy'

# Apply price tier classification
df['price_tier'] = df.apply(lambda x: price_tier(x['revenue'], x['quantity']), axis=1)

# Analyze price tier distribution and performance
price_analysis = df.groupby(['product_category', 'price_tier']).agg({
    'order_id': 'count',
    'revenue': 'mean',
    'rating': 'mean'
}).round(2)

print("Price Tier Performance by Category:")
print(price_analysis.head(8))

# Create city-based purchasing power indicators
# Different cities have different economic profiles

city_profiles = df.groupby('city').agg({
    'revenue': ['mean', 'std'],         # Average spending and variance
    'customer_age': 'mean',             # Demographics
    'rating': 'mean',                   # Satisfaction levels
    'returned': 'mean'                  # Return behavior
}).round(2)

print("City Purchasing Profiles:")
print(city_profiles)

# Create city tier classification
# Metro cities behave differently than smaller cities

def classify_city_tier(city_name, avg_revenue):
    # Tier 1 cities with highest purchasing power
    tier1_cities = ['Mumbai', 'Delhi', 'Bangalore']
    
    if city_name in tier1_cities and avg_revenue > 4000:
        return 'tier1_high'
    elif city_name in tier1_cities:
        return 'tier1_medium'
    else:
        return 'tier2'

# Apply city classification
city_data = city_profiles.reset_index()
city_data['city_tier'] = city_data.apply(
    lambda x: classify_city_tier(x['city'], x[('revenue', 'mean')]), axis=1
)

# Map city tiers back to original dataset
city_tier_map = dict(zip(city_data['city'], city_data['city_tier']))

df['city_tier'] = df['city'].map(city_tier_map)

# Show city tier distribution
tier_distribution = df['city_tier'].value_counts()
print("City Tier Distribution:")
print(tier_distribution)

# Create feature importance comparison
# Test which domain features actually improve predictions

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

# Prepare features for modeling
feature_columns = ['customer_age', 'day_of_week', 'is_weekend', 
                   'month', 'days_since_last', 'quantity']

# Convert categorical features to numeric
le = LabelEncoder()
df['city_encoded'] = le.fit_transform(df['city'])
df['category_encoded'] = le.fit_transform(df['product_category'])