Real-time fraud detection inside the transaction flow

• A payments platform has to decide for every payment, while it is being processed, whether it looks like fraud.
• Sending each payment to a separate Python scoring service added a network hop, more infrastructure and a second stack to run.
• With Deep Netts the fraud model runs inside the Java payment service itself: it is loaded once and scores each payment in the same JVM.
• The customer reports 30% lower fraud losses, decisions in milliseconds and no extra Python infrastructure.

Fraud is a tiny fraction of all payments, and its patterns keep changing. The talk quotes a projection of $33 billion lost to payment-card fraud worldwide every year (The Nilson Report).

Fixed rules ("block payments over X from country Y") are simple, but they age fast and fraudsters learn to step around them. A machine learning model learns the patterns from the transaction history instead, and can be retrained when they change.

A model does not see a payment – it sees numbers built from it. The talk groups the usual inputs for fraud detection into four families:

The 8 inputs of the example service

The Spring Boot service shown in the talk builds 8 numbers for every payment – the same 8 the animation shows next to the network:

Everything happens in one process – the payment never leaves the JVM to be scored:

1. Payment arrives

   The Java payment service receives the transaction.

   ↓→

2. Features

   The service turns it into the 8 numbers above.

   ↓→
3. Deep Netts

   Fraud model

   A feed-forward network, loaded once at start-up, returns a probability 0–1.

   ↓→

4. Decision

   0.70 or more: block. Below: approve and continue.

Before, the third box was a separate Python service: one more network call per payment, one more deployment, one more runtime to monitor. Now it is a method call.

Deep Netts has the three models the talk recommends for fraud out of the box. All three are built with the same builder and answer the same question: how likely is it that this payment is fraud.

Logistic regression – the baseline

The simplest classifier: one weight per input, a probability out. Easy to explain (each weight says how much an input matters) and a good first baseline.

FeedForwardNetwork logReg = FeedForwardNetwork.builder()
      .addInputLayer(numInputs)
      .addOutputLayer(1, SIGMOID)
      .lossFunction(CROSS_ENTROPY)
      .build();

Feed-forward neural network – the one in the animation

Logistic regression with hidden layers in between. The hidden layers let the model combine inputs (a small amount, but abroad, the fifth attempt in ten minutes …) and catch patterns a single weight per input cannot – higher precision and fewer missed frauds.

FeedForwardNetwork neuralNet = FeedForwardNetwork.builder()
      .addInputLayer(numInputs)
      .addFullyConnectedLayer(32, ActivationType.RELU)
      .addFullyConnectedLayer(16, ActivationType.RELU)
      .addOutputLayer(numOutputs, ActivationType.SIGMOID)
      .lossFunction(LossType.CROSS_ENTROPY)
      .build();

Auto-encoder – anomaly detection

Learns only from normal payments what "normal" looks like, and flags what it cannot reproduce. Useful when there are too few labelled frauds to train a classifier.

FeedForwardNetwork autoencoder = FeedForwardNetwork.builder()
      .addInputLayer(numInputs)
      .addFullyConnectedLayer(5)
      .addFullyConnectedLayer(3)
      .addFullyConnectedLayer(5)
      .addOutputLayer(numInputs, SIGMOID)
      .lossFunction(MEAN_SQUARED_ERROR)
      .build();

Training shows the model past payments with the answer (fraud or not) and lets it reduce its error step by step. Three settings decide when it stops and how big each step is:

neuralNet.getTrainer()
      .setStopEpochs(10000)    // at most this many passes over the data
      .setStopError(0.15f)     // or stop when the error is this low
      .setLearningRate(0.01f); // how big each correction is
neuralNet.train(trainingSet);

The trained model is a file. The service loads it once when it starts, and from then on every payment is one predict call in memory. The threshold is configuration, so it can change without a new release.

@Service
public class FraudDetectionService implements AutoCloseable {

    private final String modelPath;
    private final double threshold;
    private FeedForwardNetwork network;

    public FraudDetectionService(@Value("${fraud.model-path}") String modelPath,
                                 @Value("${fraud.threshold:0.70}") double threshold) {
        this.modelPath = modelPath;
        this.threshold = threshold;
    }

    @PostConstruct
    public void loadModel() throws IOException {
        network = NeuralNetwork.load(modelPath, FeedForwardNetwork.class);
    }

    public FraudResponse predict(FraudRequest request) {
        float[] features = new float[] {
            request.amount().floatValue(),
            request.crossBorder() ? 1.0f : 0.0f,
            request.attemptsLast30Min().floatValue(),
            request.minutesSincePreviousTransaction().floatValue(),
            request.distanceFromPreviousTransactionKm().floatValue(),
            request.differentMerchantsLast30Min().floatValue(),
            request.customerCategory().floatValue(),
            request.productCategory().floatValue()
        };
        float[] output = network.predict(features);
        double prob = output[0];
        return new FraudResponse(prob, prob >= threshold, threshold);
    }
}

The talk tests the example network on 200,000 payments it did not see in training. Every payment ends in one of four boxes:

The network does not say "fraud" or "not fraud" – it gives a probability. The service turns it into a decision with a threshold, 0.70 by default in the example.

• A lower threshold blocks more: more frauds caught (higher recall), but more good customers stopped (lower precision).
• A higher threshold blocks less: fewer false alarms, but more frauds slip through.
• Because the threshold is a configuration value, the fraud team can move it without retraining or redeploying the model.

Deep Netts can use the Java Vector API (CPU) or an Nvidia GPU through CUDA – switched on with a JVM option and one line of code:

// Vector API – JVM option: --add-modules jdk.incubator.vector
DeepNetts.getInstance().setUseVectorAPI(true);

// Nvidia GPU / CUDA – JVM option: --enable-native-access=ALL-UNNAMED
DeepNetts.getInstance().setUseCuda(true);

In-process

Running inside the same program (here: the same JVM), so no network call is needed.

Feature

A number the model gets as input, built from the payment and its history.

Feed-forward network

The classic neural network: numbers in, layers of neurons, a score out.

ReLU, sigmoid

Activation functions. ReLU in the hidden layers; sigmoid squeezes the output into 0–1.

Cross-entropy

The error measure used to train a yes/no classifier.

Threshold

The probability above which a payment is blocked (0.70 in the example).

Precision

Of the blocked payments, the share that really were fraud.

Recall

Of all frauds, the share the model caught.

Auto-encoder

A network that learns to reproduce normal data; what it cannot reproduce is suspicious.

Vector API

A Java API that uses the CPU's vector instructions to do many calculations at once.

• Deep Netts, "AI in Java for the Financial Industry", talk at ING, Amsterdam – models, code, test results and benchmark on this page.
• The Nilson Report, as quoted in the talk – the $33B annual payment-card fraud projection.
• The customer's case (the customer is not named) – 30% lower fraud losses, in-process decisions, no Python service.