ML Returns Management: Fraud Detection, Forecasting, Optimization

Returns are a headache for any retailer: 10–15% of revenue goes to operational costs, product depreciation, and fraud. We've built more than one system that solves this triad: detecting fraudulent schemes, optimizing return decisions, and forecasting return volume. In this article we break down the architecture on a real stack: LightGBM, Prophet, NLP classifiers, SHAP for interpretation.

A typical retailer loses up to 30% of the return value on processing. An AI model can cut costs by 20–40% through automation and early fraud detection. Average savings: up to 1.5 million rubles per year for a 50-store network. For a network of 200 stores we reduced manual processing by 60%. If you want to cut returns costs, contact us for a data audit — we'll find the optimal solution.

Why AI models outperform rules for returns management?

Fraudulent returns come in many forms:

• Wardrobing: purchase for one-time use (e.g., a dress for an event) then return.
• Price arbitrage: buy at discount → return → rebuy at even bigger discount.
• Receipt fraud: return without receipt with inflated "purchase price".
• Bricking: return a broken or swapped item.
• Return-to-shelf fraud: employee fake-returns and pockets the money.

Indicators of fraudulent return: customer return rate >30%, receiptless returns >50%, multiple returns per week, return amount >3x average check, purchase >60 days ago, serial number mismatch, cross-channel return (bought online — returns in store), purchase on Dec 25 — return on Jan 2.

Rules (if-else) are easy to write but miss complex combinations and become outdated quickly. LightGBM finds nonlinear dependencies and gives 15–20% higher accuracy. We use scale_pos_weight=50 to balance the rare fraud class.

def extract_return_features(return_event, customer_history, item_data):
    customer_returns = customer_history[customer_history['type'] == 'return']
    
    return {
        'customer_lifetime_return_rate': len(customer_returns) / len(customer_history),
        'customer_return_value_total': customer_returns['amount'].sum(),
        'days_since_first_purchase': (today - customer_history['date'].min()).days,
        'return_to_purchase_ratio_90d': calculate_return_ratio(customer_history, 90),
        'days_since_purchase': (today - return_event['purchase_date']).days,
        'return_amount_usd': return_event['amount'],
        'return_amount_vs_avg_purchase': return_event['amount'] / customer_history['amount'].mean(),
        'has_receipt': return_event['receipt_present'],
        'original_channel': return_event['purchase_channel'],
        'return_channel': return_event['return_channel'],
        'cross_channel': return_event['purchase_channel'] != return_event['return_channel'],
        'item_category_return_rate': item_data['category_avg_return_rate'],
        'item_price_tier': item_data['price_tier'],
        'item_is_seasonal': item_data['is_seasonal'],
        'item_sale_item': item_data['was_on_sale']
    }

from lightgbm import LGBMClassifier
import shap

fraud_model = LGBMClassifier(
    scale_pos_weight=50,
    n_estimators=300
)
fraud_model.fit(X_train, y_fraud_train)

def evaluate_return_fraud(return_features):
    score = fraud_model.predict_proba([return_features])[0][1]
    if score > 0.7:
        explainer = shap.TreeExplainer(fraud_model)
        shap_values = explainer.shap_values(return_features)
        top_reason = get_top_shap_feature(shap_values)
        return {
            'decision': 'manual_review',
            'fraud_score': score,
            'primary_reason': top_reason,
            'recommended_action': 'verify_serial_number_and_condition'
        }
    return {'decision': 'approve', 'fraud_score': score}

LightGBM is 2–3 times more accurate than rules at detecting wardrobing and receipt fraud. SHAP (SHapley Additive exPlanations) is an interpretation method based on cooperative game theory. For each prediction, SHAP calculates the contribution of each feature to the final score. This explains why a specific return is flagged as fraudulent: e.g., "high customer return rate" and "return without receipt". The analyst sees the top 3 reasons and makes an informed decision.

How the Decision Engine optimizes outcomes?

def return_decision_engine(return_request, fraud_score, business_rules):
    customer_tier = get_customer_tier(return_request['customer_id'])
    item_category = return_request['item_category']
    if fraud_score < 0.2 and customer_tier == 'gold':
        return 'auto_approve'
    elif fraud_score > 0.7:
        return 'manual_review_required'
    elif item_category in ['consumables', 'digital', 'underwear']:
        return 'restricted_return_policy'
    else:
        return 'standard_return_process'

Instead of full refund: exchange, partial refund, store credit. For high-LTV customers — extended policy as a retention tool.

The threshold 0.7 was chosen based on ROC analysis: at this threshold, precision on fraud is 0.85 with recall 0.6. For premium customers, the threshold can be lowered to 0.9 to minimize false positives. The model is retrained monthly to catch new schemes.

How NLP reduces return rates?

from transformers import pipeline

return_reason_classifier = pipeline(
    'text-classification',
    model='fine_tuned_return_reason_classifier'
)

return_categories = {
    'wrong_size': 'sizing issue',
    'not_as_described': 'product quality/description mismatch',
    'changed_mind': 'buyer remorse',
    'damaged': 'quality defect',
    'wrong_item': 'fulfillment error',
    'price_change': 'found cheaper elsewhere'
}

def analyze_return_reasons(return_comments):
    predictions = return_reason_classifier(return_comments)
    return [{'text': text, 'category': pred['label'], 'confidence': pred['score']}
            for text, pred in zip(return_comments, predictions)]

Feedback: many "not_as_described" — fix product descriptions/photos; many "wrong_size" — improve size guide; many "damaged" — packaging issue. This cuts returns by 10–15%.

Forecasting return volume

Forecasting returns is needed for staffing planning, inventory management, and financial reserves.

def forecast_returns_volume(sales_history, return_rates_by_category, promo_calendar):
    seasonal_return_multiplier = {
        1: 1.8,
        2: 1.2,
        11: 1.3,
        12: 1.5
    }
    sales_forecast = prophet_sales_model.predict(forecast_horizon=30)
    return_forecast = {}
    for category, sales in sales_forecast.items():
        base_rate = return_rates_by_category[category]
        season_factor = seasonal_return_multiplier.get(forecast_month, 1.0)
        return_forecast[category] = sales * base_rate * season_factor
    return return_forecast

Combining methods yields the best result.

How we implement the system: step by step

1. Data & process analysis (1–2 weeks): collect return history, audit data quality, define metrics.
2. ML model development (2–3 weeks): build baseline, iterative improvement, validate on historical data.
3. Decision engine integration (1–2 weeks): set up API, connect to CRM, test on real transactions.
4. A/B testing & deploy (1–2 weeks): run on part of the flow, monitor quality, full rollout.
5. Operator training & support (ongoing).

What's included

• API documentation for model and decision engine
• LightGBM model with SHAP explanations for each decision
• NLP classifier for return reasons
• Integration with CRM via REST (1–2 weeks)
• Operator training on the system
• Model warranty: 6 months with retraining option

Estimated timelines

• Fraud detection + decision engine: 4 to 5 weeks
• NLP reason analysis, volume forecasting, customer tier policies: 2 to 3 months
• Cost is calculated individually after data audit.

We are a team of AI/ML engineers with 8+ years of experience. We have delivered 30+ projects for retailers, including networks with a turnover of 10 billion rubles. We automated returns for 5+ retailers, reducing processing time by 60% and cutting fraud rate in half. Get a consultation and we'll evaluate your project and offer a turnkey solution. Contact us for a data audit.