Money Laundering Detection

Solution Background and Business Value

Financial institutions and law enforcement agencies need to detect and prevent money laundering before illicit funds leave an account. Undetected laundering exposes institutions to legal liability and enables continued criminal activity. The challenge is compounded in cryptocurrency transactions, where users can create multiple accounts easily and single transactions may involve multiple parties.

Graph Neural Networks (GNNs) are effective for identifying suspicious patterns in transaction networks that traditional fraud detection methods miss.

This document outlines how to:

• Structure your data for money laundering detection.

• Train a classifier using Kumo AI.

• Deploy the model in real-world fraud detection systems.

Data Requirements and Schema

Core Tables

1. Accounts Table

   • Stores account details.

   • Key attributes:

     • account_id: Unique identifier for each account.

     • Optional: Location, phone number, creation timestamp, account type, risk score.

2. Transactions Table

   • Records all transactions (deposits, withdrawals, transfers).

   • Key attributes:

     • transaction_id: Unique identifier.

     • timestamp: Transaction time.

     • amount: Transaction value.

3. Inputs Table

   • Tracks the source accounts for each transaction.

   • Key attributes:

     • transaction_id: Links to a transaction.

     • account_id: Links to the sender’s account.

     • timestamp: Time of transaction.

4. Outputs Table

   • Tracks the destination accounts for each transaction.

   • Key attributes:

     • transaction_id: Links to a transaction.

     • account_id: Links to the receiver’s account.

     • timestamp: Time of transaction.

5. Reports Table

   • Tracks accounts reported for money laundering.

   • Key attributes:

     • account_id: Links to an account.

     • timestamp: Time of report.

     • Optional: Reason, severity, reporting entity.

Entity Relationship Diagram (ERD)

Predictive Queries

Detecting money laundering requires predicting fraud risk as soon as funds enter an account.

Money Laundering Prediction

This model predicts the probability that an account will be reported for money laundering in the next N days:

PREDICT COUNT(reports.*, 0, N, days ) > 0
FOR EACH accounts.account_id
WHERE COUNT(inputs.*, -1, 0, days) > 0

Different Time Horizons

To detect different fraud patterns, train models for various time windows:

// Likely to be reported within 10 days
PREDICT COUNT(reports.*, 0, 10, days ) > 0
FOR EACH accounts.account_id
WHERE COUNT(inputs.*, -1, 0, days) > 0
// Likely to be reported in 10-30 days
PREDICT COUNT(reports.*, 10, 30, days ) > 0
FOR EACH accounts.account_id
WHERE COUNT(inputs.*, -1, 0, days) > 0
// Likely to be reported in 30-90 days
PREDICT COUNT(reports.*, 30, 90, days ) > 0
FOR EACH accounts.account_id
WHERE COUNT(inputs.*, -1, 0, days) > 0

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
transactions = kumo.Table.from_source_table(
7
    source_table=connector.table('transactions'),
8
    time_column='timestamp',
9
).infer_metadata()
10
11
inputs = kumo.Table.from_source_table(
12
    source_table=connector.table('inputs'),
13
    time_column='timestamp',
14
).infer_metadata()
15
16
outputs = kumo.Table.from_source_table(
17
    source_table=connector.table('outputs'),
18
    time_column='timestamp',
19
).infer_metadata()
20
21
reports = kumo.Table.from_source_table(
22
    source_table=connector.table('reports'),
23
    time_column='timestamp',
24
).infer_metadata()

4. Define graph schema

1
graph = kumo.Graph(
2
    tables={
3
        'accounts': accounts,
4
        'transactions': transactions,
5
        'inputs': inputs,
6
        'outputs': outputs,
7
        'reports': reports,
8
    },
9
    edges=[
10
        dict(src_table='inputs', fkey='transaction_id', dst_table='transactions'),
11
        dict(src_table='inputs', fkey='account_id', dst_table='accounts'),
12
        dict(src_table='outputs', fkey='transaction_id', dst_table='transactions'),
13
        dict(src_table='outputs', fkey='account_id', dst_table='accounts'),
14
        dict(src_table='reports', fkey='account_id', dst_table='accounts'),
15
    ],
16
)
17
18
graph.validate(verbose=True)

5. Train the model

1
pquery = kumo.PredictiveQuery(
2
    graph=graph,
3
    query="PREDICT COUNT(reports.*, 0, N, days ) > 0 FOR EACH accounts.account_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()}")