Chargeback Fraud Detection

Solution Background and Business Value

Chargeback fraud occurs when a customer disputes a completed credit card purchase with their bank, claiming it was unauthorized. If the bank approves the claim, the transaction is reversed and the merchant bears the financial loss. This is a significant problem for e-commerce platforms and online retailers.

Machine learning models can detect and prevent chargeback fraud, allowing businesses to:

• Reduce fraudulent transactions by identifying high-risk purchases early.

• Minimize financial losses by preventing chargebacks before they occur.

Data Requirements and Schema

Kumo analyzes data in its raw relational form: you connect your existing tables directly, without joining them or engineering features in advance. Kumo uses Graph Neural Networks (GNNs) to learn from the relationships between entities (such as users, orders, and chargebacks), which improves fraud detection accuracy compared to single-table models.

Core Tables

1. Accounts Table

   • Stores user account details.

   • Key attributes:

     • account_id: Unique identifier.

     • Optional: Creation date, location, age, account type.

2. Orders Table

   • Stores details of each order.

   • Key attributes:

     • order_id: Unique order identifier.

     • account_id: Links the order to a user.

     • timestamp: Time of purchase.

     • Optional: Order value, payment method, shipping details.

3. Chargebacks Table

   • Stores information about chargeback claims.

   • Key attributes:

     • chargeback_id: Unique identifier.

     • order_id: Links the chargeback to an order.

     • timestamp: Time of chargeback request.

     • label: Indicates whether the chargeback was fraudulent (1) or legitimate (0).

Additional Tables (Optional)

• Items Table: Stores item-level details within an order.

• Order-Items Table: Links orders to specific items purchased.

• Payment Methods Table: Stores payment details (for example, card type or account linkage).

• Merchants Table: Information on merchants selling products.

• Account Events Table: Tracks user account activity.

Entity Relationship Diagram (ERD)

Predictive Queries

Kumo uses Predictive Query Language (PQL) to define what to predict and over which entities. Choose the query that matches where your fraud labels are most reliably recorded:

1. Predict Fraudulent Chargebacks

This model predicts whether a chargeback is fraudulent:

PREDICT chargebacks.LABEL
FOR EACH chargebacks.chargeback_id

• At inference time, leave LABEL empty for new chargebacks to generate fraud risk scores.

2. Predict Fraud Risk at the Order Level

To anticipate fraud before a chargeback is filed, add a fraud label column to the orders table and predict at the order level:

PREDICT orders.LABEL
FOR EACH orders.order_id

3. Predict Future Chargeback Fraud

For proactive fraud detection, predict whether an order or account will experience a fraudulent chargeback in the next X days:

-- Predict if an order will receive a fraudulent chargeback
PREDICT FIRST(chargebacks.LABEL = 1, 0, X) > 0
FOR EACH orders.order_id
ASSUMING COUNT(chargebacks.*, 0, X) > 0
-- Predict if an account will be associated with at least one fraudulent chargeback
PREDICT COUNT(chargebacks.LABEL = 1, 0, X) > 0
FOR EACH accounts.account_id
ASSUMING COUNT(orders.*, 0, X) > 0

Deployment Strategy

The right deployment strategy depends on your fraud detection system’s maturity:

1. Batch Predictions for Fraud Analysts

• Fraud teams manually review and label chargebacks.

• ML model predictions prioritize high-risk chargebacks for faster action.

• Predictions are generated daily or hourly in batch mode. Add this filter to your batch query to process only recent chargebacks:

WHERE chargebacks.TIMESTAMP > MIN_TIMESTAMP

2. Real-Time Chargeback Fraud Detection

• The system generates real-time risk scores when an order is placed.

• If a transaction is high risk, additional verification or manual review is triggered.

• ML embeddings are used to enhance rule-based fraud detection.

Building Models in Kumo Fine-Tune SDK

1. Initialize the Kumo Fine-Tune SDK

1
import kumoai as kumo
2
3
kumo.init(url="https://<customer_id>.kumoai.cloud/api", api_key=API_KEY)

2. Connect data

1
connector = kumo.S3Connector("s3://your-dataset-location/")

3. Select tables

1
accounts = kumo.Table.from_source_table(
2
    source_table=connector.table('accounts'),
3
    primary_key='account_id',
4
).infer_metadata()
5
6
orders = kumo.Table.from_source_table(
7
    source_table=connector.table('orders'),
8
    time_column='timestamp',
9
).infer_metadata()
10
11
chargebacks = kumo.Table.from_source_table(
12
    source_table=connector.table('chargebacks'),
13
    time_column='timestamp',
14
).infer_metadata()

4. Create graph schema

1
graph = kumo.Graph(
2
    tables={
3
        'accounts': accounts,
4
        'orders': orders,
5
        'chargebacks': chargebacks,
6
    },
7
    edges=[
8
        dict(src_table='orders', fkey='account_id', dst_table='accounts'),
9
        dict(src_table='chargebacks', fkey='order_id', dst_table='orders'),
10
    ],
11
)
12
13
graph.validate(verbose=True)

5. Train the model

1
pquery = kumo.PredictiveQuery(
2
    graph=graph,
3
    query="PREDICT chargebacks.LABEL FOR EACH chargebacks.chargeback_id"
4
)
5
pquery.validate(verbose=True)
6
7
model_plan = pquery.suggest_model_plan()
8
trainer = kumo.Trainer(model_plan)
9
training_job = trainer.fit(
10
    graph=graph,
11
    train_table=pquery.generate_training_table(non_blocking=True),
12
    non_blocking=False,
13
)
14
print(f"Training metrics: {training_job.metrics()}")