Harnessing AI/ML for Fraud Detection in Fintech App: A Developer’s Guide | by DheerajRathore | Jul, 2024

Introduction:

Within the fast-paced world of fintech, staying one step forward of fraudsters is essential. Synthetic Intelligence (AI) and Machine Studying (ML) — game-changers which might be revolutionizing how we detect and stop monetary fraud. This information will stroll you thru the method of constructing, coaching, and deploying a fraud detection mannequin in an iOS app utilizing Core ML. Buckle up as we dive into the thrilling intersection of AI, finance, and cell know-how!

Goal of This Article:

My major purpose is to showcase the method of integrating a machine studying mannequin into an iOS app utilizing Core ML. Think about this a place to begin for exploring AI in apps. Actual-world implementations would require extra refined fashions, bigger datasets, and adherence to monetary laws and finest practices. By strolling by means of this instance, intention is to encourage builders to consider how they will leverage AI and machine studying to boost decision-making processes in their very own functions. Keep in mind, the important thing takeaway is the method of integrating AI into your iOS app, not the particular fraud detection implementation.

The AI/ML Revolution in Fintech: Earlier than we roll up our sleeves, let’s rapidly discover how AI/ML is reworking varied elements of fintech:

1. Smarter Credit score Scoring: AI algorithms crunch huge quantities of information to evaluate creditworthiness, making lending choices sooner and extra correct.
2. 24/7 Buyer Service: AI-powered chatbots tirelessly deal with buyer queries, releasing up human brokers for extra complicated points.
3. Algorithmic Buying and selling: AI analyses market tendencies at lightning pace, executing trades to maximise income and decrease dangers.
4. Fraud Detection: Our star of the present! AI fashions analyze transaction patterns in real-time, flagging suspicious actions earlier than they trigger hurt.

Fraud Detection in Motion: A Step-by-Step Information Let’s construct a fraud detection mannequin that analyzes transaction quantity, time, location, transaction distance and machine sort to identify potential fraudsters. We’ll practice it with PyTorch, convert it to Core ML, and deploy it in an iOS app.

Tech Stack Breakdown:

1. Python: Our trusty sidekick for information wrangling and mannequin coaching.
2. PyTorch: The powerhouse behind our ML mannequin.
3. Core ML: Apple’s framework for on-device machine studying.
4. Xcode: The place our iOS app involves life.

Strategy to Mannequin Coaching and Fraud Detection Logic:

In our instance, we’ve simplified the fraud detection course of to show the idea. Right here’s the method we took:

1. Knowledge Technology: We created artificial information to coach our mannequin. In a real-world situation, you’d use precise transaction information, however for this demonstration, we generated information based mostly on sure guidelines.
2. Fraud Indicators: We thought of a transaction doubtlessly fraudulent if it met any of those standards:

• Transaction quantity is larger than 1,00,000
• Transaction happens between 1 AM and 5 AM
• Transaction location is considerably completely different from the person’s ordinary transaction places.

3. Fraud Prediction Threshold: After coaching, our mannequin outputs a likelihood between 0 and 1 for every transaction. We set a threshold of 0.5 for classifying a transaction as doubtlessly fraudulent. This implies:

• If the mannequin’s output is higher than 0.5, we think about the transaction doubtlessly fraudulent.
• If the mannequin’s output is 0.5 or much less, we think about the transaction doubtless legit.

This threshold may be adjusted based mostly in your particular wants.

Discover beneath code snippet for producing the info set and coaching the mannequin.

import pandas as pd
import numpy as np
np.random.seed(42)
device_types = ['iOS', 'Android']
# Generate non-fraudulent transactions
n_non_fraud = 800
non_fraud_transactions = pd.DataFrame({
'transaction_amount': np.random.uniform(100, 50000, n_non_fraud),
'transaction_time': np.random.uniform(0, 24, n_non_fraud),
'transaction_distance': np.random.uniform(0, 50, n_non_fraud),
'latitude': np.random.uniform(-90, 90, n_non_fraud),
'longitude': np.random.uniform(-180, 180, n_non_fraud),
'device_type': np.random.selection(device_types, n_non_fraud),
'is_fraud': np.zeros(n_non_fraud, dtype=int)
})
# Generate fraudulent transactions
n_fraud = 200
fraud_transactions = pd.DataFrame({
'transaction_amount': np.random.uniform(50000, 100000, n_fraud),
'transaction_time': np.random.uniform(1, 4, n_fraud),
'transaction_distance': np.random.uniform(50, 100, n_fraud),
'latitude': np.random.uniform(-90, 90, n_fraud),
'longitude': np.random.uniform(-180, 180, n_fraud),
'device_type': np.random.selection(device_types, n_fraud),
'is_fraud': np.ones(n_fraud, dtype=int)
})
# Mix datasets
transactions = pd.concat([non_fraud_transactions, fraud_transactions]).pattern(frac=1).reset_index(drop=True)
# Save to CSV
transactions.to_csv('transactions_data.csv', index=False)
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.information import Dataset, DataLoader
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import classification_report, confusion_matrix
# Customized Dataset class
class TransactionsDataset(Dataset):
def __init__(self, information):
self.information = information
self.label_encoder = LabelEncoder()
self.information['device_type'] = self.label_encoder.fit_transform(self.information['device_type'])
self.X = self.information.drop(columns=['is_fraud']).values
self.y = self.information['is_fraud'].values
def __len__(self):
return len(self.information)
def __getitem__(self, idx):
return torch.tensor(self.X[idx], dtype=torch.float32), torch.tensor(self.y[idx], dtype=torch.float32)
# Load dataset
information = pd.read_csv('transactions_data.csv')
dataset = TransactionsDataset(information)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)
# Outline mannequin
class FraudDetectionModel(nn.Module):
def __init__(self):
tremendous(FraudDetectionModel, self).__init__()
self.fc1 = nn.Linear(6, 16)
self.fc2 = nn.Linear(16, 32)
self.fc3 = nn.Linear(32, 1)
self.sigmoid = nn.Sigmoid()
def ahead(self, x):
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = self.fc3(x)
x = self.sigmoid(x)
return x
mannequin = FraudDetectionModel()
criterion = nn.BCELoss()
optimizer = optim.Adam(mannequin.parameters(), lr=0.001)
# Coaching loop
num_epochs = 20
for epoch in vary(num_epochs):
for inputs, labels in dataloader:
optimizer.zero_grad()
outputs = mannequin(inputs)
loss = criterion(outputs.squeeze(), labels)
loss.backward()
optimizer.step()
print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.merchandise()}')
# Save the mannequin
torch.save(mannequin.state_dict(), 'transactions_fraud_detection_model.pth')

Consider the Mannequin

# Consider the mannequin
mannequin.eval()
all_labels = []
all_preds = []
with torch.no_grad():
for inputs, labels in dataloader:
outputs = mannequin(inputs)
preds = outputs.squeeze().spherical()
all_labels.lengthen(labels.numpy())
all_preds.lengthen(preds.numpy())
print(classification_report(all_labels, all_preds))
print(confusion_matrix(all_labels, all_preds))

2. Changing to Core ML: Subsequent, we’ll remodel our PyTorch mannequin into Core ML format, prepared for iOS deployment.

# Code snippet for changing to Core ML
pip set up coremltools
import coremltools as ct
# Load the skilled PyTorch mannequin
mannequin = FraudDetectionModel()
mannequin.load_state_dict(torch.load('transactions_fraud_detection_model.pth'))
mannequin.eval()
# Instance enter for tracing
example_input = torch.rand(1, 6)
# Convert the mannequin to Core ML
example_input = torch.rand(1, 6)
traced_model = torch.jit.hint(mannequin, example_input)
mlmodel = ct.convert(
traced_model,
inputs=[ct.TensorType(shape=example_input.shape)]
)
mlmodel.save('TransactionFraudDetectionModel.mlpackage')

Voila! Our mannequin is now packaged as TransactionFraudDetectionModel.mlpackage, able to detect fraud on iOS units.

3. Constructing the iOS App: Now comes the thrilling half — bringing our mannequin to life in an iOS app.

Earlier than we dive into the code, let’s add our ML mannequin to Xcode:

a) Including the ML Mannequin to Xcode:

• Open your Xcode undertaking
• Proper-click in your undertaking within the navigator
• Choose “Add Recordsdata to [Your Project Name]”
• Navigate to and choose your TransactionFraudDetectionModel.mlpackage file
• Guarantee “Copy gadgets if wanted” is checked
• Click on “Add”

Right here’s a Swift snippet to get you began:

import Basis
import CoreML
class TransactionFraudDetector{
personal func  getModel() -> TransactionFraudDetectionModel? {
// Load the mannequin
guard let modelURL = Bundle.major.url(forResource: "TransactionFraudDetectionModel", withExtension: "mlmodelc"),
let mannequin = attempt? TransactionFraudDetectionModel(contentsOf: modelURL) else {
fatalError("Didn't load mannequin")
}
return mannequin
}
public func testForFraudTransaction(_ inputArray: MLMultiArray) {
// Create the mannequin enter
let enter = TransactionFraudDetectionModelInput(x: inputArray)
// get the mannequin
guard let mannequin = getModel() else {
return
}
// Make prediction
guard let prediction = attempt? mannequin.prediction(enter: enter) else {
fatalError("Didn't make prediction")
}
print(prediction)
// Output consequence
print("Is Fraud: (prediction.var_16[0].doubleValue)")
let fraudProbability = prediction.var_16[0].doubleValue
// Output consequence
print("Transaction quantity: (inputArray[0])")
print("Transaction time: (inputArray[1])")
print("Transaction distance: (inputArray[2])")
print("Latitude: (inputArray[3])")
print("Longitude: (inputArray[4])")
print("Machine sort: (inputArray[5])")
print("Fraud likelihood: (fraudProbability)")
print("Is Fraud: (fraudProbability > 0.5 ? "Sure" : "No")")
}
}

Code snippet for calling the TransactionFraudDetector class.

import Basis
import CoreML
class ContentViewModel {
init(){
// name for
detectFraudTransaction()
}
func detectFraudTransaction(){
do {
let inputArray = attempt MLMultiArray(form: [1, 6], dataType: .double)
// Fill the enter array with instance values
inputArray[0] = 150000 // transaction_amount
inputArray[1] = 4 // transaction_time
inputArray[2] = 600 // transaction_distance
inputArray[3] = 45 // latitude
inputArray[4] = 90 // longitude
inputArray[5] = 1 // device_type (1 for 'iOS', 0 for 'Android')
TransactionFraudDetector().testForFraudTransaction(inputArray)
}
catch let error{
print(error)
}
}
}

Console output:

Word: On this tutorial, we’re focusing totally on the right way to use the Core ML mannequin to detect fraud in an iOS app. We’re not protecting iOS app structure, finest practices for Swift improvement, or person interface design. In a real-world utility, you’d want to contemplate these elements rigorously, together with error dealing with, person suggestions, and integration together with your app’s general construction and design.

Responding to Potential Fraud:

As soon as our mannequin flags a transaction as doubtlessly fraudulent, it’s essential to have a strong response system in place. Listed here are some measures we will implement to stop fraud and guarantee account safety:

1. Biometric Verification: If the transaction is flagged as suspicious, we will immediate the person for added biometric authentication. This might embrace:

• Fingerprint scan
• Facial recognition
• Voice recognition

2. Two-Issue Authentication (2FA): Implement 2FA for high-risk. transactions, sending a verification code by way of SMS or e-mail.

3. Financial institution Affirmation Name: For transactions above a sure threshold or with very excessive fraud likelihood, provoke an automatic name from the financial institution to substantiate the transaction.

4. Transaction Blocking: Briefly block the transaction and notify the person by way of push notification or in-app alert.

5. Step-Up Authentication: Implement a tiered authentication system. As an illustration, if the fraud likelihood is between 0.5 and 0.7, request biometric authentication. If it’s above 0.7, provoke a financial institution affirmation name.

GitHub Repository:

For individuals who wish to dive deeper into the code or attempt it out themselves, I hosted each the Python undertaking (for mannequin coaching and conversion) and the Xcode undertaking (for the iOS app) on GitHub. You could find the entire supply code on the following hyperlink:

Conclusion: And there you’ve it — we’ve journeyed from uncooked information to a complicated, on-device fraud detection system. By harnessing the facility of PyTorch, Core ML, and iOS, we’ve created a robust protect towards monetary fraud.

It’s necessary to notice that this instance is simply the tip of the iceberg. We’ve targeted on fraud detection, however that is only the start. The world of AI in fintech is brimming with potentialities. Maybe your subsequent undertaking might discover real-time transaction monitoring, or perhaps dive into anomaly detection in buying and selling patterns?

Keep in mind, as we push the boundaries of what’s attainable with AI in finance, we should all the time steadiness innovation with moral issues and person privateness. The way forward for fintech is in your arms — what is going to you construct subsequent?

Glad coding, and should your fashions all the time be correct and your false positives low!