Machine Learning Fraud Detection Using Python Training Course

Duration 10 days 20 modules · 65 contact hours
Level Intermediate Certificate on completion
Who attends Fraud Analysts, Financial Crime Analysts and others
Fee from USD 2,200 KSh 190,000 for Kenyan organisations
Where 52 cities + online See dates by city
Next start 16 Nov 2026 Course code SD-FFC-031

Before you join: Participants should understand basic fraud concepts such as suspicious activity, false positives, fraud losses and investigation queues.

Dates & prices

Two start dates a month in every city, and live online on weekdays or weekends. Fees are per participant; classroom fees include tuition, materials, lunch and refreshments, and the certificate.

Suggest a date or city

Showing the next six months. Later dates, other cities and private deliveries for your team are available on request.

Course overview

Fraud teams must identify suspicious payments, account activity and customer behaviour quickly while controlling false positives, investigation costs and customer friction. Machine learning can improve detection beyond fixed rules, but only when models are built on reliable labels, realistic time-based validation, suitable features and clear operational decision thresholds. Analysts also need to explain model outputs to investigators, risk managers, auditors and model governance teams.

This course teaches participants to build fraud detection workflows in Python for banking and financial-services use cases. Participants prepare transaction and customer data, investigate fraud patterns, engineer behavioural and network features, train supervised and unsupervised models, address severe class imbalance, and compare models using precision, recall, PR-AUC, expected loss and alert capacity. The course also covers model explainability, threshold setting, fraud-ring detection, drift monitoring, case-management feedback and model risk controls.

Teaching combines short technical briefings with instructor-led Python demonstrations, banking fraud cases, group analysis and structured model-building work. Participants work with realistic datasets representing card payments, account transfers, digital onboarding and account takeover. They leave with a documented fraud detection model package: data assumptions, feature definitions, validation evidence, threshold rationale, monitoring measures and an investigator-facing explanation of model alerts.

The course suits professionals who already work with fraud, risk, compliance, analytics or financial-crime data and need to apply machine learning responsibly. It is particularly relevant where fraud operations, data science and model risk teams must make defensible decisions together.

What you will be able to do

  • Prepare labelled transaction datasets for fraud modelling using Python and pandas
  • Engineer behavioural, transactional, device and network features for fraud detection
  • Train and compare logistic regression, tree-based and anomaly-detection models
  • Validate fraud models using time-based splits, leakage checks and out-of-time testing
  • Measure model performance using precision, recall, PR-AUC, alert capacity and expected loss
  • Set alert thresholds using investigation capacity, customer impact and fraud-loss assumptions
  • Explain individual fraud alerts using feature importance and SHAP values
  • Produce a documented fraud model package with monitoring and governance controls

Benefits of attending

For you

  • Build fraud models that improve on static rule-only detection approaches
  • Explain model alerts clearly to investigators and non-technical stakeholders
  • Assess fraud model performance using operationally meaningful measures
  • Contribute credible evidence to fraud model validation and governance reviews
  • Create a portfolio-quality fraud detection model package in Python

For your organisation

  • Improve identification of high-risk transactions within finite investigation capacity
  • Reduce avoidable false-positive alerts and customer contact volumes
  • Create repeatable fraud model validation and threshold-setting practices
  • Strengthen collaboration between fraud operations, analytics and model risk teams
  • Establish monitoring controls for fraud patterns, data quality and model drift

Course modules

20 modules over 10 days

Participants can map where machine learning supports fraud prevention, detection and investigation decisions.

  • Fraud lifecycle from attempted transaction through investigation and recovery
  • Card, transfer, account takeover and onboarding fraud typologies compared
  • Rules, scores and investigator judgement within layered fraud controls
  • False-positive costs, customer friction and missed-fraud loss trade-offs
  • Alert queues, service levels and investigator capacity constraints
  • Model decisions mapped to prevention, review and post-event recovery

Participants can assess fraud datasets, construct usable labels and document data limitations.

  • Transaction, customer, merchant, device and case-management data sources
  • Confirmed fraud labels, disputed transactions and delayed outcome windows
  • Chargeback, recovery and investigation outcomes reconciled into target labels
  • Label contamination caused by unresolved cases and manual-review decisions
  • Data dictionaries recording field meaning, timing, source and quality
  • Evidence lineage from raw events through modelling dataset construction

Participants can use a reproducible Python notebook workflow for fraud-data analysis.

  • Jupyter notebooks structured for reproducible fraud-model development
  • pandas DataFrames loaded, inspected and filtered using transaction identifiers
  • Data types corrected for timestamps, amounts, categories and binary flags
  • Missing values profiled by fraud outcome and operational data source
  • Versioned input files and random seeds recorded for repeatable results
  • Notebook outputs organised into analysis, modelling and review sections

Participants can identify fraud patterns, data defects and initial modelling hypotheses.

  • Fraud rates segmented by channel, country, merchant and payment type
  • Transaction amounts compared across legitimate and confirmed-fraud populations
  • Time-of-day and day-of-week patterns plotted for fraud events
  • Duplicate transactions, reversals and impossible timestamps identified systematically
  • Customer tenure and transaction velocity distributions examined for anomalies
  • Investigation outcomes compared with model-ready fraud labels

Participants can create predictive transaction and customer behaviour features without future-data leakage.

  • Transaction velocity features calculated across minutes, hours and days
  • Rolling customer spend, count and amount features built historically
  • Merchant novelty and geographic distance features derived from prior activity
  • Device, IP address and payment-token reuse indicators constructed
  • Ratio features comparing current amount with customer spending history
  • Feature timestamps checked against the fraud decision point

Participants can establish transparent baselines for comparing fraud detection models.

  • Existing fraud rules translated into measurable decision logic
  • Logistic regression fitted as an interpretable fraud-risk baseline
  • Odds ratios interpreted for selected transaction and behavioural features
  • Rule-only, model-only and combined strategies compared against labels
  • Score bands created for low, medium and high-risk transactions
  • Baseline assumptions documented before more complex model development

Participants can train tree-based fraud models and control their complexity.

  • Decision trees split transaction populations using fraud-predictive variables
  • Tree depth and minimum leaf size controlled against overfitting
  • Random forests trained using bootstrap samples and feature subsampling
  • Feature importance reviewed alongside fraud-domain plausibility checks
  • Partial dependence plots examined for major behavioural risk drivers
  • Tree models compared with logistic regression on validation data

Participants can address rare fraud events without distorting model evaluation.

  • Fraud prevalence quantified before selecting sampling or weighting methods
  • Class weights applied to penalise missed fraud more heavily
  • Random undersampling evaluated against lost legitimate transaction information
  • SMOTE synthetic examples assessed for suitability in transaction data
  • Training samples separated from untouched validation and test populations
  • Sampling effects measured using precision, recall and PR-AUC

Participants can validate fraud models under realistic future-use conditions.

  • Chronological train, validation and test periods defined before modelling
  • Out-of-time testing used to estimate future fraud detection performance
  • Target leakage identified in chargeback, case and post-event fields
  • Feature availability checked at transaction authorisation or review time
  • Customer overlap assessed across training and testing time windows
  • Validation findings recorded in a model development evidence log

Participants can select models using fraud-loss, workload and customer-impact measures.

  • Confusion matrices interpreted for fraud detection operational decisions
  • Precision, recall, specificity and false-positive rate calculated correctly
  • Precision-recall curves used for rare-event model comparison
  • ROC-AUC limitations recognised under severe class imbalance conditions
  • Expected fraud loss estimated using transaction value and recovery assumptions
  • Alert volumes compared with available investigator review capacity

Participants can set score thresholds that reflect financial and operational constraints.

  • Risk scores converted into ranked fraud investigation queues
  • Thresholds selected using precision targets and daily alert capacity
  • Different thresholds assigned to payment channels and customer segments
  • Decline, step-up authentication and review actions linked to scores
  • Score bands monitored for fraud rates and customer treatment
  • Threshold changes governed through documented approval and testing

Participants can apply unsupervised methods where confirmed fraud labels are incomplete.

  • Unsupervised detection positioned beside supervised fraud classification models
  • Isolation Forest scores calculated for unusual transaction behaviour
  • Local Outlier Factor applied to dense transaction feature spaces
  • Novelty detection separated from historical anomaly identification tasks
  • Anomaly alerts sampled for investigator review and feedback
  • Unsupervised results assessed without assuming anomalies are fraud

Participants can identify connected entities that indicate mule networks and organised fraud.

  • Customer, account, device and merchant links represented as graphs
  • Shared identifiers used to identify connected suspicious account clusters
  • Degree, centrality and connected-component features calculated for entities
  • Mule-account indicators derived from inbound and outbound transfer patterns
  • Network features combined with transaction-level risk scores carefully
  • Graph findings documented with supporting transaction and entity evidence

Participants can explain fraud scores at portfolio and individual-alert level.

  • Global feature importance assessed for model behaviour and plausibility
  • SHAP values used to explain individual transaction risk scores
  • Reason codes written for investigators using understandable fraud signals
  • Correlated features reviewed before relying on importance rankings
  • Explanation outputs checked against transaction facts and case evidence
  • Adverse customer actions distinguished from investigator-facing explanations

Participants can connect fraud model outputs to case management and label improvement.

  • Alert fields designed for rapid investigator triage and evidence gathering
  • Case outcomes standardised into confirmed, declined and inconclusive labels
  • Investigator feedback captured without introducing target leakage
  • Quality assurance samples reviewed for decision consistency and accuracy
  • Escalation paths defined for high-value and linked fraud alerts
  • Feedback cycles scheduled for feature review and model retraining

Participants can design monitoring measures for fraud performance, data quality and changing patterns.

  • Population Stability Index calculated for score and feature distributions
  • Fraud-rate shifts monitored by channel, segment and score band
  • Precision and recall tracked after delayed fraud outcomes mature
  • Data-quality controls detect missing fields, range changes and latency
  • Champion-challenger models compared using controlled production evidence
  • Retraining triggers defined for drift, loss deterioration and fraud changes

Participants can document fraud models for review, approval and accountable use.

  • Model purpose, intended users and prohibited uses documented clearly
  • Development, validation and approval responsibilities assigned through governance
  • Fairness tests compare error rates across relevant customer groups
  • Privacy minimisation applied to personal and device-related data
  • Model inventory entries record version, owner, inputs and limitations
  • Independent review evidence prepared for audit and model risk teams

Participants can specify a controlled production process for fraud scoring and alert delivery.

  • Batch and real-time scoring architectures compared for fraud use cases
  • Input data contracts specify fields, formats, timing and ownership
  • Score outputs routed to authorisation systems and case queues
  • Fallback rules defined for unavailable models and incomplete data
  • Release checklists cover testing, approvals, rollback and communications
  • Operational handover assigns monitoring, incident and threshold-change ownership

Participants can critically review a fraud model for technical, operational and governance weaknesses.

  • Problem statements checked against intended fraud decision and action
  • Data lineage reviewed for label quality, timing and missing fields
  • Validation evidence challenged using out-of-time results and leakage tests
  • Threshold rationale tested against losses, workload and customer outcomes
  • Explainability outputs reviewed for investigator usefulness and plausibility
  • Monitoring plans assessed for timely detection of performance deterioration

Participants can build, review and present a complete fraud detection model package for a banking use case.

  • Fraud use case defined with decision, loss and capacity assumptions
  • Transaction dataset prepared with documented labels and feature definitions
  • Python model trained using time-based validation and imbalance treatment
  • Threshold selected using precision, expected loss and queue capacity
  • Model explanations prepared for investigators, managers and governance reviewers
  • Monitoring plan, deployment controls and limitations presented for review

Exercises and examples are adapted to each cohort's sectors and roles.

What you take back to work

  1. Fraud data quality assessment template
  2. Python fraud detection notebook
  3. Feature engineering specification
  4. Time-based model validation plan
  5. Alert threshold decision matrix
  6. Fraud model governance pack

Who should attend

  • Fraud Analysts — need stronger methods for prioritising suspicious transactions and cases
  • Financial Crime Analysts — need machine learning methods alongside rules and investigations
  • Risk Analysts — need to assess fraud models, thresholds and loss assumptions
  • Data Analysts — need to build fraud-focused Python models from transaction data
  • Compliance Managers — need to understand model governance and explainability requirements
  • Model Risk Professionals — need evidence for validation, monitoring and model approval

Skills and tools covered

Fraud data preparationFeature engineeringImbalanced classificationModel validationAlert prioritisationModel monitoring

Tools and standards

Python, pandas, scikit-learn, SHAP

How the course runs

Training methodology

The course uses short instructor briefings followed by guided Python work, banking fraud cases, group interpretation tasks and decision simulations. Participants examine transaction-level data, construct features, train models and compare alert strategies under realistic capacity constraints. Cases include card-not-present fraud, account takeover, authorised push payment fraud and mule-account activity. Facilitated reviews focus on why a model produced an alert, whether its performance is credible and how investigators can act on its output. Each participant develops an application plan for their own fraud-data environment.

Requirements and prerequisites

Participants should understand basic fraud concepts such as suspicious activity, false positives, fraud losses and investigation queues. They should be comfortable working with tabular data and interpreting percentages, rates and simple charts. Prior Python exposure is helpful, including variables, tables or notebooks, but participants do not need to be software engineers or experienced data scientists. The course introduces the required Python workflow and machine learning concepts before applying them. Prior knowledge of advanced statistics, neural networks, cloud deployment, SQL programming or formal model validation is not required.

A typical training day

08:30 – 10:30First session
10:30 – 10:45Refreshment break
10:45 – 12:30Second session
12:30 – 13:30Lunch and networking
13:30 – 15:00Third session
15:00 – 15:15Refreshment break
15:15 – 16:30Workshop and daily review

Live online deliveries follow the same structure in East Africa Time, with shorter screen blocks and longer breaks.

What the fee includes

  • Instruction by a practitioner facilitator
  • Full course workbook and materials
  • Exercise files, templates and case studies
  • Refreshments and lunch on classroom deliveries
  • Certificate of completion
  • Post-course application plan

Frequently asked questions

You should understand basic fraud concepts and be comfortable with tabular data, percentages and simple charts. Some previous Python exposure is useful, but advanced programming, statistics and data science experience are not required.

Bring a laptop capable of running a modern web browser and Python notebook environment if attending in person. Training datasets and course materials are provided; do not bring confidential customer or transaction data unless agreed through the relevant course arrangements.

It is designed for fraud, financial-crime, risk, compliance and data professionals working with banking or payments data. It is also suitable for model risk staff who review fraud models and need to assess their evidence.

This course concentrates on fraud decisions rather than generic prediction examples. It addresses rare-event data, delayed labels, transaction velocity, alert queues, investigator capacity, fraud losses, explainability and model governance.

Participants can use the templates and Python workflow to assess an existing fraud rule set, improve a transaction dataset or test a candidate model. The course also provides documentation structures for discussions with operations, model risk and compliance teams.

Training days run from 08:30 to 16:30 and provide about 6.5 contact hours each. The first part builds data, feature and modelling capability; later modules focus on validation, operations, governance and the final fraud model capstone.

Questions about this course?

Ask about dates, fees, group bookings or running it for your team. Our training team replies by email.