Credit Card Fraud Detection Using Machine Learning

In the financial industry, identifying fraudulent credit card transactions is a crucial task. In this project, we use machine learning-powered credit card fraud detection techniques to address the issue. 

Our goal is to identify fraudulent and legitimate activity with a high degree of accuracy and few false alarms by examining patterns in transaction data. This project demonstrates how data science can help reduce risk and promote financial safety.

For more project ideas like this one, check out our blog post - Top 25+ Essential Data Science Projects GitHub to Explore in 2025.

Prerequisites For Credit Card Fraud Detection Project

Before you begin, you should be comfortable with:

• Python programming
• Basics of Machine Learning (classification)
• Understanding of evaluation metrics, such as precision, recall, and accuracy
• Familiarity with Pandas, NumPy, Matplotlib, Seaborn, and scikit-learn

Note: the project is of intermediate level, so you need 4-5 hours to complete the project.

Now, in the next section, we will see how to build a credit card fraud detection model using the above.

How to Build a Credit Card Fraud Detection Model

Let’s start building the project from scratch. So, without wasting any more time, let’s begin!

Step 1: Download the Dataset

We use KaggleHub to directly fetch the dataset from Kaggle's repository. Here is the code to do so:

import kagglehub

# Download dataset
path = kagglehub.dataset_download("mlg-ulb/creditcardfraud")

print("Path to dataset files:", path)

Output:

Path to dataset files: /kaggle/input/creditcardfraud

Step 2: Import Required Libraries

In this step, we will load essential libraries needed for analysis and model training. To do so, use the below-mentioned code:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib import gridspec

Step 3: Load and Inspect the Data

Now, in this step, we will load the .csv file. Once loaded, we will inspect the first few entries. 

Use the below-mentioned code to do so:

data = pd.read_csv("/kaggle/input/creditcardfraud/creditcard.csv")
print(data.head())
print(data.describe())

Output:

[8 rows x 31 columns]

The dataset has 284,807 transactions and 31 columns, including time, amount, anonymized features (V1–V28), and a Class column. The Class column indicates fraud (1) or not (0).

Step 4: Check Class Distribution

In this step, we will understand how many transactions are fraudulent. Use the below-mentioned code:

fraud = data[data['Class'] == 1]
valid = data[data['Class'] == 0]
outlierFraction = len(fraud) / float(len(valid))

print("Outlier Fraction:", outlierFraction)
print(f"Fraud Cases: {len(fraud)}")
print(f"Valid Transactions: {len(valid)}")

Output:

Outlier Fraction: 0.0017304750013189597
Fraud Cases: 492
Valid Transactions: 284315

We are dealing with an imbalanced classification problem. How can we say this? It is because fraudulent transactions make up only a tiny fraction of the dataset, as we can see from the output. 

Step 5: Explore Transaction Amounts

In this step, we will explore the transaction amounts. By doing so, we will be able to identify if frauds tend to involve higher or lower amounts.

Use the below-mentioned code to accomplish the same:

print("Fraudulent Transactions Amount Stats:")
print(fraud['Amount'].describe())

print("Valid Transactions Amount Stats:")
print(valid['Amount'].describe())

Output:

Fraudulent Transactions Amount Stats:

Name: Amount, dtype: float64

Valid Transactions Amount Stats:

Name: Amount, dtype: float64

Step 6: Visualize Feature Correlations

In this step, we will identify patterns and redundancy in features using a correlation matrix. Use the below-mentioned code to do so:

corrmat = data.corr()
plt.figure(figsize=(12, 9))
sns.heatmap(corrmat, vmax=0.8, square=True)
plt.title("Correlation Matrix")
plt.show()

Output:

Through the output, we get to know that:

• Most features do not correlate strongly with others.
• Features like V2 and V5 have a negative correlation with the Amount feature.

Step 7: Prepare the Data

In this step, we will prepare the data. We will do it by splitting the data into features (X) and target (Y). Once done, the train-test split.

Use the below-mentioned code:

from sklearn.model_selection import train_test_split

X = data.drop(['Class'], axis=1)
Y = data['Class']

xData = X.values
yData = Y.values

xTrain, xTest, yTrain, yTest = train_test_split(
    xData, yData, test_size=0.2, random_state=42
)

Step 8: Train the Model

In this step, we will train the Random Forest Classifier model. It is a robust model for tabular data. 

Use the below-mentioned code to do so:

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier()
rfc.fit(xTrain, yTrain)

yPred = rfc.predict(xTest)

Step 9: Evaluate Model Performance

In this step, we will evaluate model performance. We will assess accuracy, precision, recall, F1-score, and MCC for a holistic view.

Use the below-mentioned code to do the same:

from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, 
    f1_score, matthews_corrcoef, confusion_matrix
)

accuracy = accuracy_score(yTest, yPred)
precision = precision_score(yTest, yPred)
recall = recall_score(yTest, yPred)
f1 = f1_score(yTest, yPred)
mcc = matthews_corrcoef(yTest, yPred)

print("Model Evaluation Metrics:")
print(f"Accuracy: {accuracy:.4f}")
print(f"Precision: {precision:.4f}")
print(f"Recall: {recall:.4f}")
print(f"F1-Score: {f1:.4f}")
print(f"MCC: {mcc:.4f}")

Output:

Model Evaluation Metrics:

Use the code mentioned below to visualize the confusion matrix.

conf_matrix = confusion_matrix(yTest, yPred)
plt.figure(figsize=(8, 6))
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues",
            xticklabels=['Normal', 'Fraud'], yticklabels=['Normal', 'Fraud'])
plt.title("Confusion Matrix")
plt.xlabel("Predicted Class")
plt.ylabel("True Class")
plt.show()

Output:

Conclusion

For this project, we created a machine learning model using the random forest classifier to detect fraudulent transactions from a highly imbalanced dataset. The model was found to be highly accurate - 99.96%. The real success lies in precision (95.06%) and recall (78.57%), which indicate it performs well in detecting actual frauds while keeping false alarms low

The confusion matrix shows:

• 77 fraud cases correctly detected (true positives),
• 21 fraud cases missed (false negatives),
• Only 4 valid transactions were wrongly flagged as fraud (false positives),
• And 56,860 normal transactions were correctly identified.

These results suggest that the model is not only accurate but also maintains a strong balance between detecting true fraud and minimizing disruption to genuine users.

Expand your expertise with the best resources available. Browse the programs below to find your ideal fit in Best Machine Learning and AI Courses Online.

Best Machine Learning and AI Courses Online

Discover in-demand Machine Learning skills to expand your expertise. Explore the programs below to find the perfect fit for your goals.

In-demand Machine Learning Skills

Discover popular AI and ML blogs and free courses to deepen your expertise. Explore the programs below to find your perfect fit.

Popular AI and ML Blogs & Free Courses

Colab Link:
https://colab.research.google.com/drive/1q_lwxweIUaY-y4z-zyjxTo4Fgm9WJere?usp=sharing