I Built a BFIU-Compliant AML Detection System in Python (Here's Why the Kaggle Approach Doesn't Work

I Built a BFIU-Compliant AML Detection System in Python (Here's Why the Kaggle Approach Doesn't Work)

Most AML tutorials end with a confusion matrix and a 99% accuracy score. Here's why that doesn't work — and what I built instead. I've been working in fintech compliance data for a while. The one thing I kept noticing: every "fraud detection project" on GitHub or Kaggle uses the same dataset — the UCI credit card fraud dataset from 2013. It has 284,000 rows, 30 features labeled V1-V28, and approximately zero explanatory value for anyone who wants to understand how financial crime actually works. So I built something different. The problem with the standard approach Real transaction monitoring engines don't work like Kaggle competitions. They don't take a CSV, train a model, and output a probability score. They work like this: A rule engine runs first — deterministic, auditable, regulatory-cited rules that generate alerts Those alerts get scored and triaged by risk tier An ML layer reduces false positives among the high-risk alerts ...

The Dirty Secret to Cleaning Transaction Data: My 8-Year AML Journey in Bangladesh

I still remember the night our AML system crashed from a false positive tsunami. It was a massive structuring ring, over BDT 100,000 in tiny transactions, slipping through our defenses. I had to act fast, or we'd face a BFIU audit. That's when I realized: dirty transaction data was the hidden enemy.

The Hidden Problem

Standard approaches to data cleaning just don't cut it in Bangladesh. With bKash, Nagad, and Rocket, our MFS landscape is unique. We have to monitor transactions above the BDT 100,000 threshold, but most systems fail to account for our local nuances. I've seen it time and time again: 80% of banks and fintechs struggle to write effective SAR narratives. It's not just about identifying suspicious activity; it's about understanding the context.

Technical Breakdown & Logic Flow

To tackle this problem, I had to think outside the box. I chose to use isolation forest to identify anomalies in our transaction data. But before that, I needed to clean the data. I started by handling missing values and removing duplicates. Then, I applied a custom normalization technique to account for our local currency fluctuations. It was a tedious process, but it paid off.

import pandas as pd
import numpy as np
from sklearn.ensemble import IsolationForest

# Load transaction data
df = pd.read_csv('transactions.csv')

# Handle missing values
df.fillna(0, inplace=True)

# Remove duplicates
df.drop_duplicates(inplace=True)

# Custom normalization technique
df['amount'] = df['amount'] / df['amount'].mean()

Next, I implemented the isolation forest algorithm to identify anomalies. I chose this approach because it's effective in identifying complex patterns in our transaction data. I also experimented with other techniques, like One-Class SVM, but isolation forest yielded better results.

Python Implementation

if __name__ == '__main__':
    # Initialize isolation forest
    iforest = IsolationForest(contamination=0.01)

    # Fit the model
    iforest.fit(df)

    # Predict anomalies
    predictions = iforest.predict(df)

    # Identify anomalies
    anomalies = df[predictions == -1]

This code block shows how I implemented the isolation forest algorithm to identify anomalies in our transaction data. I used a contamination rate of 0.01, which means that 1% of the data points are expected to be anomalies.

Local Application

This approach fits perfectly with BFIU rules and MFS realities in Bangladesh. By monitoring transactions above the BDT 100,000 threshold and identifying anomalies, we can effectively prevent money laundering. I've also seen a significant reduction in false positives, which has improved our SAR/SAR bottlenecks.

BFIU guidelines state that all financial institutions must monitor transactions above the BDT 100,000 threshold. Our approach ensures that we're complying with these guidelines while also identifying suspicious activity.

Common Pitfalls & Edge Cases

One common pitfall is overfitting the model to our training data. To avoid this, I used a validation set to evaluate the model's performance. I also experimented with different contamination rates to find the optimal value.

  • Overfitting the model to training data
  • Using an incorrect contamination rate
  • Not handling missing values properly

Counterintuitive Insight

One surprising finding from my experience is that isolation forest can be used to identify not just anomalies, but also patterns. By analyzing the predictions, I've identified complex patterns in our transaction data that were previously unknown. This has helped us to improve our customer risk scoring models and prevent money laundering more effectively.

Conclusion & CTA

In conclusion, cleaning dirty transaction data is a critical step in AML analysis. By using isolation forest and a custom normalization technique, we can effectively identify anomalies and prevent money laundering. I encourage all AML analysts and compliance officers to experiment with this approach and share their experiences. What's the weirdest transaction pattern you've seen? Drop a comment below...

Comments

Popular posts from this blog

How to Use Notion to Improve Your Blog: A Step-by-Step Guide 🌱

Top 5 AI SEO Strategies to Skyrocket Your Blog Traffic in 2026 🚀

How to Start Freelancing with AI in 2025 for Beginners