Customer Transaction Data Analysis: Seasonal Patterns & Customer Segmentation

I'll help you build a systematic, well-structured analysis. Let me walk through a complete approach with clean, production-ready code.

Step 1: Data Loading & Quality Assessment

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
from scipy import stats
import warnings
warnings.filterwarnings('ignore')

def load_and_validate_data(filepath: str) -> pd.DataFrame:
    """Load data with immediate quality assessment."""
    df = pd.read_csv(filepath, parse_dates=['date'])
    
    print("=== DATA QUALITY REPORT ===")
    print(f"Shape: {df.shape}")
    print(f"\nColumn Types:\n{df.dtypes}")
    print(f"\nMissing Values:\n{df.isnull().sum()}")
    print(f"\nDuplicates: {df.duplicated().sum()}")
    print(f"\nDate Range: {df['date'].min()} to {df['date'].max()}")
    print(f"\nPurchase Amount Stats:\n{df['purchase_amount'].describe()}")
    
    # Flag potential issues
    issues = []
    if df['purchase_amount'].min() < 0:
        issues.append(f"WARNING: {(df['purchase_amount'] < 0).sum()} negative purchase amounts")
    if df['date'].isnull().sum() > 0:
        issues.append(f"WARNING: {df['date'].isnull().sum()} missing dates")
    
    for issue in issues:
        print(f"\n{issue}")
    
    return df

# Adjust column names to match your actual CSV headers
df = load_and_validate_data('transactions.csv')

Step 2: Feature Engineering

def engineer_features(df: pd.DataFrame) -> pd.DataFrame:
    """
    Create temporal and behavioral features.
    Assumes columns: customer_id, date, purchase_amount, category, 
                     age, gender, location (adjust as needed)
    """
    df = df.copy()
    
    # --- Temporal features ---
    df['year']        = df['date'].dt.year
    df['month']       = df['date'].dt.month
    df['quarter']     = df['date'].dt.quarter
    df['week_of_year']= df['date'].dt.isocalendar().week.astype(int)
    df['day_of_week'] = df['date'].dt.dayofweek      # 0=Monday
    df['is_weekend']  = df['day_of_week'].isin([5, 6]).astype(int)
    df['month_name']  = df['date'].dt.strftime('%B')
    
    # Season assignment (Northern Hemisphere — adjust if needed)
    season_map = {12: 'Winter', 1: 'Winter', 2: 'Winter',
                  3: 'Spring', 4: 'Spring', 5: 'Spring',
                  6: 'Summer', 7: 'Summer', 8: 'Summer',
                  9: 'Fall',   10: 'Fall',  11: 'Fall'}
    df['season'] = df['month'].map(season_map)
    
    # Holiday proximity flags (extend list as needed)
    holidays = pd.to_datetime(['2023-12-25', '2023-11-24', '2023-07-04',
                               '2023-01-01', '2023-02-14', '2023-11-11'])
    df['days_to_holiday'] = df['date'].apply(
        lambda d: min(abs((d - h).days) for h in holidays)
    )
    df['near_holiday'] = (df['days_to_holiday'] <= 7).astype(int)
    
    return df

df = engineer_features(df)
print("Features added:", df.columns.tolist())

Step 3: Seasonal Pattern Analysis

def analyze_seasonal_patterns(df: pd.DataFrame) -> dict:
    """Comprehensive seasonal analysis with statistical validation."""
    results = {}
    
    # --- 3a. Revenue by season ---
    seasonal_revenue = df.groupby('season').agg(
        total_revenue    = ('purchase_amount', 'sum'),
        avg_transaction  = ('purchase_amount', 'mean'),
        transaction_count= ('purchase_amount', 'count'),
        unique_customers = ('customer_id', 'nunique')
    ).round(2)
    
    seasonal_revenue['revenue_per_customer'] = (
        seasonal_revenue['total_revenue'] / seasonal_revenue['unique_customers']
    ).round(2)
    
    results['seasonal_revenue'] = seasonal_revenue
    print("=== SEASONAL REVENUE ===")
    print(seasonal_revenue.to_string())
    
    # --- 3b. Month-over-month trends ---
    monthly = df.groupby(['year', 'month']).agg(
        revenue = ('purchase_amount', 'sum'),
        orders  = ('purchase_amount', 'count')
    ).reset_index()
    
    monthly['mom_growth'] = monthly['revenue'].pct_change() * 100
    results['monthly_trends'] = monthly
    
    # --- 3c. Category seasonality ---
    cat_season = df.groupby(['category', 'season'])['purchase_amount'].agg(
        ['sum', 'mean', 'count']
    ).round(2)
    cat_season.columns = ['total', 'avg', 'count']
    
    # Seasonality index: category's share in each season vs baseline
    season_totals = df.groupby('season')['purchase_amount'].sum()
    cat_season['season_index'] = cat_season['total'] / season_totals
    results['category_seasonality'] = cat_season
    
    # --- 3d. Statistical test: Are seasonal differences significant? ---
    season_groups = [
        df[df['season'] == s]['purchase_amount'].values
        for s in ['Winter', 'Spring', 'Summer', 'Fall']
    ]
    f_stat, p_value = stats.f_oneway(*season_groups)
    print(f"\n=== ANOVA TEST (Seasonal Differences) ===")
    print(f"F-statistic: {f_stat:.4f}, p-value: {p_value:.4f}")
    print("Result:", "SIGNIFICANT difference" if p_value < 0.05 
          else "No significant difference")
    
    # --- 3e. Weekly patterns ---
    day_names = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
    daily_patterns = df.groupby('day_of_week').agg(
        avg_revenue = ('purchase_amount', 'mean'),
        order_count = ('purchase_amount', 'count')
    )
    daily_patterns.index = day_names
    results['daily_patterns'] = daily_patterns
    
    return results

seasonal_results = analyze_seasonal_patterns(df)

Step 4: Customer Segmentation (RFM + Clustering)

def build_rfm_features(df: pd.DataFrame) -> pd.DataFrame:
    """
    RFM = Recency, Frequency, Monetary
    These three metrics capture the most predictive buying behavior signals.
    """
    snapshot_date = df['date'].max() + pd.Timedelta(days=1)
    
    rfm = df.groupby('customer_id').agg(
        recency   = ('date',            lambda x: (snapshot_date - x.max()).days),
        frequency = ('purchase_amount', 'count'),
        monetary  = ('purchase_amount', 'sum')
    ).reset_index()
    
    # Additional behavioral features
    customer_stats = df.groupby('customer_id').agg(
        avg_order_value   = ('purchase_amount', 'mean'),
        std_order_value   = ('purchase_amount', 'std'),
        unique_categories = ('category',        'nunique'),
        weekend_ratio     = ('is_weekend',      'mean'),
        holiday_ratio     = ('near_holiday',    'mean'),
        preferred_season  = ('season',          lambda x: x.mode()[0]),
        customer_lifespan = ('date',            lambda x: (x.max() - x.min()).days)
    ).reset_index()
    
    rfm = rfm.merge(customer_stats, on='customer_id')
    rfm['std_order_value'] = rfm['std_order_value'].fillna(0)  # single-purchase customers
    rfm['purchase_regularity'] = rfm['frequency'] / (rfm['customer_lifespan'] + 1)
    
    print(f"RFM dataset shape: {rfm.shape}")
    print(rfm.describe().round(2).to_string())
    
    return rfm

rfm_df = build_rfm_features(df)

def find_optimal_clusters(data_scaled: np.ndarray, k_range: range) -> int:
    """
    Use elbow method + silhouette score to choose k.
    Don't just pick a number — validate it.
    """
    from sklearn.metrics import silhouette_score
    
    inertias, silhouettes = [], []
    
    for k in k_range:
        km = KMeans(n_clusters=k, random_state=42, n_init=10)
        labels = km.fit_predict(data_scaled)
        inertias.append(km.inertia_)
        silhouettes.append(silhouette_score(data_scaled, labels))
    
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
    
    ax1.plot(k_range, inertias, 'bo-')
    ax1.set(xlabel='Number of Clusters (k)', ylabel='Inertia',
            title='Elbow Method')
    
    ax2.plot(k_range, silhouettes, 'rs-')
    ax2.set(xlabel='Number of Clusters (k)', ylabel='Silhouette Score',
            title='Silhouette Analysis (higher = better)')
    
    plt.tight_layout()
    plt.savefig('cluster_selection.png', dpi=150)
    plt.show()
    
    # Best k = highest silhouette score (use this, not just elbow)
    best_k = k_range[np.argmax(silhouettes)]
    print(f"\nRecommended k: {best_k} (silhouette: {max(silhouettes):.3f})")
    return best_k


def segment_customers(rfm_df: pd.DataFrame) -> pd.DataFrame:
    """Full clustering pipeline with interpretation."""
    
    # Features for clustering (exclude IDs and categoricals)
    cluster_features = [
        'recency', 'frequency', 'monetary',
        'avg_order_value', 'unique_categories',
        'weekend_ratio', 'purchase_regularity'
    ]
    
    X = rfm_df[cluster_features].copy()
    
    # Log-transform skewed monetary features
    for col in ['recency', 'frequency', 'monetary', 'avg_order_value']:
        X[col] = np.log1p(X[col])
    
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    
    # Find optimal k
    best_k = find_optimal_clusters(X_scaled, range(2, 9))
    
    # Fit final model
    km = KMeans(n_clusters=best_k, random_state=42, n_init=20)
    rfm_df['segment'] = km.fit_predict(X_scaled)
    
    return rfm_df, X_scaled, cluster_features
    
rfm_df, X_scaled, cluster_features = segment_customers(rfm_df)

Step 5: Segment Profiling & Labeling

def profile_segments(rfm_df: pd.DataFrame) -> pd.DataFrame:
    """
    Give each cluster a meaningful business label.
    Adjust labels based on YOUR actual cluster characteristics.
    """
    profile = rfm_df.groupby('segment').agg(
        count             = ('customer_id',       'count'),
        avg_recency       = ('recency',            'mean'),
        avg_frequency     = ('frequency',          'mean'),
        avg_monetary      = ('monetary',           'mean'),
        avg_order_value   = ('avg_order_value',    'mean'),
        avg_categories    = ('unique_categories',  'mean'),
        avg_regularity    = ('purchase_regularity','mean'),
        top_season        = ('preferred_season',   lambda x: x.mode()[0])
    ).round(2)
    
    profile['pct_of_customers'] = (profile['count'] / profile['count'].sum() * 100).round(1)
    profile['pct_of_revenue']   = (
        rfm_df.groupby('segment')['monetary'].sum() / rfm_df['monetary'].sum() * 100
    ).round(1)
    
    print("=== SEGMENT PROFILES ===")
    print(profile.to_string())
    
    # --- Label logic (update thresholds after seeing YOUR data) ---
    def assign_label(row):
        if row['avg_recency'] < 30 and row['avg_frequency'] > 10:
            return 'Champions'          # Recent, frequent, high-value
        elif row['avg_monetary'] > rfm_df['monetary'].quantile(0.75):
            return 'High-Value Loyalists'
        elif row['avg_recency'] > 180:
            return 'At-Risk / Churned'  # Haven't bought in 6+ months
        elif row['avg_frequency'] < 2:
            return 'One-Time Buyers'
        elif row['avg_regularity'] > rfm_df['purchase_regularity'].median():
            return 'Regulars'
        else:
            return 'Occasional Buyers'
    
    profile['label'] = profile.apply(assign_label, axis=1)
    rfm_df['segment_label'] = rfm_df['segment'].map(profile['label'])
    
    return rfm_df, profile

rfm_df, segment_profile = profile_segments(rfm_df)

Step 6: Visualization Dashboard

def create_analysis_dashboard(df: pd.DataFrame, rfm_df: pd.DataFrame,
                               X_scaled: np.ndarray, seasonal_results: dict):
    
    fig = plt.figure(figsize=(20, 16))
    fig.suptitle('Customer Transaction Analysis', fontsize=16, fontweight='bold', y=0.98)
    
    # --- Plot 1: Monthly Revenue Trend ---
    ax1 = fig.add_subplot(3, 3, 1)
    monthly = seasonal_results['monthly_trends']
    ax1.plot(range(len(monthly)), monthly['revenue'], 'b-o', markersize=4)
    ax1.set_title('Monthly Revenue Trend')
    ax1.set_ylabel('Revenue ($)')
    ax1.tick_params(axis='x', rotation=45)
    
    # --- Plot 2: Seasonal Revenue Comparison ---
    ax2 = fig.add_subplot(3, 3, 2)
    season_data = seasonal_results['seasonal_revenue']
    colors = ['#4e79a7', '#59a14f', '#f28e2b', '#e15759']
    bars = ax2.bar(season_data.index, season_data['total_revenue'], color=colors)
    ax2.set_title('Revenue by Season')
    ax2.set_ylabel('Total Revenue ($)')
    for bar, val in zip(bars, season_data['total_revenue']):
        ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height(),
                 f'${val:,.0f}', ha='center', va='bottom', fontsize=9)
    
    # --- Plot 3: Day-of-Week Patterns ---
    ax3 = fig.add_subplot(3, 3, 3)
    daily = seasonal_results['daily_patterns']
    ax3.bar(daily.index, daily['avg_revenue'], 
            color=['#4e79a7' if d < 5 else '#e15759' for d in range(7)])
    ax3.set_title('Avg Revenue by Day of Week')
    ax3.set_ylabel('Avg Revenue ($)')
    
    # --- Plot 4: Category Heatmap by Season ---
    ax4 = fig.add_subplot(3, 3, 4)
    cat_pivot = df.groupby(['category', 'season'])['purchase_amount'].sum().unstack()
    sns.heatmap(cat_pivot, annot=True, fmt='.0f', cmap='YlOrRd',
                ax=ax4, cbar_kws={'shrink': 0.8})
    ax4.set_title('Category Revenue by Season')
    
    # --- Plot 5: PCA Cluster Visualization ---
    ax5 = fig.add_subplot(3, 3, 5)
    pca = PCA(n_components=2, random_state=42)
    coords = pca.fit_transform(X_scaled)
    scatter = ax5.scatter(coords[:, 0], coords[:, 1],
                          c=rfm_df['segment'], cmap='tab10', alpha=0.6, s=10)
    ax5.set_title(f'Customer Segments (PCA)\n'
                  f'Variance explained: {pca.explained_variance_ratio_.sum():.1%}')
    ax5.set_xlabel('PC1'); ax5.set_ylabel('PC2')
    plt.colorbar(scatter, ax=ax5)
    
    # --- Plot 6: Segment Size & Revenue ---
    ax6 = fig.add_subplot(3, 3, 6)
    seg_labels = rfm_df['segment_label'].value_counts().index
    sizes = rfm_df['segment_label'].value_counts().values
    ax6.pie(sizes, labels=seg_labels, autopct='%1.1f%%', startangle=90)
    ax6.set_title('Customer Segment Distribution')
    
    # --- Plot 7: RFM Distributions ---
    ax7 = fig.add_subplot(3, 3, 7)
    rfm_df.boxplot(column='monetary', by='segment_label', ax=ax7)
    ax7.set_title('Spend Distribution by Segment')
    ax7.set_xlabel('Segment')
    ax7.set_ylabel('Total Spend ($)')
    plt.sca(ax7); plt.xticks(rotation=30, ha='right')
    
    # --- Plot 8: Recency vs Frequency ---
    ax8 = fig.add_subplot(3, 3, 8)
    scatter2 = ax8.scatter(rfm_df['recency'], rfm_df['frequency'],
                           c=rfm_df['segment'], cmap='tab10',
                           alpha=0.5, s=15)
    ax8.set_xlabel('Recency (days)'); ax8.set_ylabel('Frequency')
    ax8.set_title('Recency vs Frequency by Segment')
    
    # --- Plot 9: Month-over-Month Growth ---
    ax9 = fig.add_subplot(3, 3, 9)
    mom = monthly['mom_growth'].dropna()
    colors_mom = ['green' if x >= 0 else 'red' for x in mom]
    ax9.bar(range(len(mom)), mom, color=colors_mom)
    ax9.axhline(y=0, color='black', linewidth=0.8)
    ax9.set_title('Month-over-Month Revenue Growth (%)')
    ax9.set_ylabel('Growth (%)')
    
    plt.tight_layout()
    plt.savefig('transaction_analysis_dashboard.png', dpi=150, bbox_inches='tight')
    plt.show()
    print("Dashboard saved to 'transaction_analysis_dashboard.png'")

create_analysis_dashboard(df, rfm_df, X_scaled, seasonal_results)

Step 7: Actionable Output & Export

def generate_business_report(rfm_df: pd.DataFrame, 
                              segment_profile: pd.DataFrame,
                              seasonal_results: dict):
    """Generate concrete, actionable recommendations."""
    
    print("\n" + "="*60)
    print("BUSINESS INTELLIGENCE REPORT")
    print("="*60)
    
    # Top seasonal insights
    season_rev = seasonal_results['seasonal_revenue']
    peak_season = season_rev['total_revenue'].idxmax()
    low_season  = season_rev['total_revenue'].idxmin()
    peak_lift   = season_rev.loc[peak_season, 'total_revenue'] / \
                  season_rev.loc[low_season, 'total_revenue']
    
    print(f"\n📈 SEASONAL INSIGHTS:")
    print(f"  • Peak season: {peak_season} "
          f"(${season_rev.loc[peak_season, 'total_revenue']:,.0f})")
    print(f"  • Low season:  {low_season} "
          f"(${season_rev.loc[low_season, 'total_revenue']:,.0f})")
    print(f"  • Peak/trough ratio: {peak_lift:.1f}x — "
          f"{'HIGH seasonality, plan inventory carefully' if peak_lift > 2 else 'Moderate seasonality'}")
    
    print(f"\n👥 SEGMENT RECOMMENDATIONS:")
    for _, row in segment_profile.iterrows():
        label = row['label']
        pct_rev = row['pct_of_revenue']
        
        actions = {
            'Champions':           f"Reward & retain — {pct_rev:.1f}% of revenue. "
                                   "Create VIP program, early access offers.",
            'High-Value Loyalists':f"Protect at all costs — {pct_rev:.1f}% of revenue. "
                                   "Personalized outreach, loyalty perks.",
            'At-Risk / Churned':   f"Win-back campaign needed — {pct_rev:.1f}% of revenue. "
                                   "Targeted discount, 'we miss you' email.",
            'One-Time Buyers':     f"Activation priority — {pct_rev:.1f}% of revenue. "
                                   "Post-purchase follow-up, second-purchase incentive.",
            'Regulars':            f"Upsell opportunity — {pct_rev:.1f}% of revenue. "
                                   "Premium product recommendations.",
            'Occasional Buyers':   f"Engagement campaign — {pct_rev:.1f}% of revenue. "
                                   "Seasonal reminders, category expansion offers."
        }
        print(f"\n  [{label}]: {actions.get(label, 'Review segment manually')}")
    
    # Export enriched data
    output_cols = ['customer_id', 'recency', 'frequency', 'monetary',
                   'avg_order_value', 'segment', 'segment_label', 'preferred_season']
    rfm_df[output_cols].to_csv('customer_segments.csv', index=False)
    print(f"\n✅ Segment data exported to 'customer_segments.csv'")

generate_business_report(rfm_df, segment_profile, seasonal_results)

---

Key Adjustments You'll Need to Make

What to Check	Why It Matters
Column names	Match your actual CSV headers in engineer_features()
Date range	Update holiday dates to match your data's year range
Season mapping	Flip for Southern Hemisphere
Label thresholds	Base on your actual RFM percentiles after seeing data
Cluster count	Let the silhouette score decide, don't hardcode

Common Pitfalls to Avoid

• Don't skip the ANOVA test — seasonal differences might not be statistically real
• Don't use raw monetary values for clustering — log-transform first (skewness kills KMeans)
• Don't pick k arbitrarily — silhouette score > elbow method for ambiguous cases
• Don't label segments before profiling — let the data tell you what each cluster is

Share your actual column names and I can adjust the code precisely for your dataset.

Yes, I can guide you through identifying seasonal purchasing patterns and segmenting customers using your 50,000-row CSV dataset. This involves data preparation, time-series analysis for seasonality, and clustering for segmentation, primarily using Python libraries like pandas, matplotlib, and scikit-learn.

Step 1: Data Preparation

Load and preprocess your CSV to handle dates, amounts, categories, and demographics. Standardize dates, aggregate by time periods (e.g., month, quarter), remove outliers, and create features like total spend per customer.[3][4]

import pandas as pd
import numpy as np
from datetime import datetime
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Load data (adjust path)
df = pd.read_csv('your_transactions.csv')

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

# Aggregate by customer and time for analysis
monthly_sales = df.groupby([df['date'].dt.to_period('M'), 'product_category'])['purchase_amount'].sum().unstack(fill_value=0)
customer_summary = df.groupby('customer_id').agg({
    'purchase_amount': ['sum', 'count', 'mean'],
    'date': ['min', 'max'],
    'product_category': lambda x: x.mode().iloc  # Most common category
}).round(2)

Step 2: Identify Seasonal Purchasing Patterns

Decompose sales data into trends, seasonality, and residuals using time-series methods. Visualize with heat maps, trend lines, and year-over-year comparisons to spot peaks (e.g., holidays, back-to-school).[1][3][4][5]

• Group by month/quarter and category to reveal recurring spikes.
• Apply moving averages or STL decomposition for patterns tied to weather, events, or demographics.[2][4]

# Monthly total sales by category
monthly_total = monthly_sales.sum(axis=1)
plt.figure(figsize=(12, 6))
monthly_total.plot(kind='line')
plt.title('Seasonal Sales Trends')
plt.ylabel('Total Purchase Amount')
plt.show()

# Heat map for categories
monthly_sales.plot(kind='bar', stacked=True, figsize=(12, 8))
plt.title('Seasonal Patterns by Product Category')
plt.show()

# Year-over-year comparison (pivot by year-month)
df['year_month'] = df['date'].dt.to_period('M')
yoy = df.groupby(['year_month', 'product_category'])['purchase_amount'].sum().unstack()
yoy.plot(kind='line', figsize=(12, 6))
plt.title('Year-over-Year Seasonal Comparison')
plt.show()

Key insights to look for: High-season categories (e.g., holiday spikes), evergreen items, and demographic/geographic variations.[1][2]

Step 3: Segment Customers by Buying Behavior

Use clustering on features like total spend, purchase frequency, recency, average amount, preferred categories, and demographics. K-means works well for behavioral RFM (Recency, Frequency, Monetary) segments.[1][2][6]

• Engineer RFM scores: Recency (days since last purchase), Frequency (transaction count), Monetary (total spend).
• Scale and cluster into 3-6 groups (e.g., high-value seasonal buyers, infrequent shoppers).[3]

# RFM segmentation features
customer_summary.columns = ['_'.join(col).strip() if col[1] else col for col in customer_summary.columns]
customer_summary['recency'] = (datetime.now() - pd.to_datetime(customer_summary['date_min_'])).dt.days
customer_summary['frequency'] = customer_summary['purchase_amount_count']
customer_summary['monetary'] = customer_summary['purchase_amount_sum']

rfm = customer_summary[['recency', 'frequency', 'monetary']].fillna(0)

# Scale and cluster
scaler = StandardScaler()
rfm_scaled = scaler.fit_transform(rfm)

kmeans = KMeans(n_clusters=4, random_state=42)
customer_summary['segment'] = kmeans.fit_predict(rfm_scaled)

# Visualize segments
customer_summary.groupby('segment')['monetary'].mean().plot(kind='bar')
plt.title('Average Spend by Customer Segment')
plt.show()

Common segments: High-spenders (frequent, high-value), seasonal buyers (peak-period active), loyal evergreen shoppers, at-risk low-frequency.[2][6]

Step 4: Advanced Analysis and Forecasting

• Correlate with demographics: Group segments by age/gender/location to tailor strategies.[2]
• Forecast demand: Use Prophet or ARIMA for predictions, incorporating external factors like weather.[4][5]
• Validate: Compare segments' seasonal patterns (e.g., high-spenders spike in Q4).[1]

# Segment seasonal heat map example
for segment in customer_summary['segment'].unique():
    seg_data = df[df['customer_id'].isin(customer_summary[customer_summary['segment'] == segment].index)]
    # Repeat monthly aggregation and plot for each segment

Run this on your data for tailored insights. Tools like Inventory Planner or machine learning platforms enhance visualization.[1][4] If sharing a data sample, I can refine the code.