Credit Card Fraud Detection

Credit card fraud is one of the main concerns of financial institutions. In Brazil, around 12 million people have already been victims of fraud, with losses exceeding R$ 1.8 billion in 2019 alone.

However, undetected fraud should not be a concern for financial institutions only, since this problem can cause major losses that reach other financial sectors and even consumers. Because of this, numerous techniques are used to detect fraud, which raises concerns such as false positives, which embarrass countless users when their card is declined and blocked while making a purchase.

There is growing investment in Artificial Intelligence applications, and with large volumes of data as a historical base, a machine learning algorithm that is only slightly better than the previous ones already represents savings of millions of reais. So, as a hands-on exercise of Carlos Melo's Data Science na Prática course, we were challenged to keep improving the use of algorithms to inhibit or prevent fraudulent transactions. Since this is a challenge, Carlos provided the data already organized and without categorical variables, so that this work could focus on building the best possible model.

The data in question was made available by some European credit card companies and represents the financial operations that took place over a two-day period, during which 290 thousand transactions were recorded.

A nice thing about this dataset is that its features are all numeric and anonymized (to protect the users). So the columns are represented as V1, V2 ... V28, and the remaining columns represent the following:

• Time - Number of seconds elapsed between this transaction and the first transaction in the dataset;
• Amount - Transaction amount;
• Class - 1 for fraudulent transactions, 0 otherwise.

As we can see in the first and last five entries.

First entries

Last entries

The original data can be found on Kaggle, and it has been transformed with a technique known as Principal Component Analysis (PCA). This technique reduces dimensionality while retaining as much information as possible. To achieve this, the algorithm finds a new set of features, the so-called components, whose number is less than or equal to that of the original variables.

With the data loaded into a DataFrame structure and no further adjustment or configuration needed at this stage, I was able to go straight to the exploratory data analysis and, finally, to building the Machine Learning model.

I started by analyzing the basic statistics. This is an important part of the work, where we look at the distribution and balance of each column.

However, since this is a large dataset, the basic statistics do not convey much information, except that the data shows imbalanced distributions, which we will look at further ahead.

Before that, the next step checked the quality of the dataset, an important metric that tells us whether we can move forward with the project. When computing missing values, none were found.

Then I began evaluating the class balance: 0 (Non-fraudulent) with 284,315 entries and 1 (Fraudulent) with 492. Both graphically and in percentage terms, it was clear that the number of fraudulent transactions is much smaller than the number of normal ones, accounting for only 0.17% of the entire dataset.

Next, I created histograms of the two classes with different scales, plotting Time for each Class.

However, it was not possible to extract any information from these two frequency distributions. So I plotted histograms of the classes with respect to Amount.

For this data, the histogram distributions show an imbalance and a large presence of possible outliers. So we need to evaluate them with a boxplot for a more in-depth analysis.

The box plot showed many outliers and clearly a very high imbalance, with a mean of 118.13 and a median of 9.21.

With the balance assessment done, I computed the correlation by plotting a correlation matrix, hiding the upper triangle.

#Criando uma máscara da diagonal superior
mask = np.zeros_like(df.corr())
mask[np.triu_indices_from(mask)] = True

#Plotar matriz de correlação
plt.figure(figsize=(10,6))plt.title("Matriz de Correlação")sns.heatmap(df.corr(),mask=mask,cmap='Blues')plt.show()

This matrix showed little relationship between the variables, caused by the class imbalance.

To feed the Logistic Regression model we will build, in this preparation step we will:

• Standardize the Time and Amount features, which are on a different order of magnitude.
• Split the data into training and test sets.
• Balance the data to avoid poor performance on class 1 and overfitting.

First I normalized the data, as I have done before here on the blog (link). This technique puts all the model's data on the same scale; in this case I used StandardScaler from the scikit learn library.

#Nomalizar os dados
standert=StandardScaler()X.Time=standert.fit_transform(X.Time.values.reshape(-1,1))X.Amount=standert.fit_transform(X.Amount.values.reshape(-1,1))

After that, I split the data into training and test sets, which made it possible to balance the data using the RandomUnderSampler algorithm from the imblearn library, ending up with 369 entries for each class.

#Balancear os dados
rUS = RandomUnderSampler()
X_rus, y_rus = rUS.fit_sample(X_train, y_train)

After balancing, I computed the correlation again, and it turned out to be much stronger, showing how important data balancing is when building a good model.

#Criando uma mascara da diagonal superior
mask = np.zeros_like(X_new_df.corr())
mask[np.triu_indices_from(mask)] = True

#Plotar matriz de correlação
plt.figure(figsize = (10,6))
plt.title("Matriz de Correlação Balanceada")

sns.heatmap(X_new_df.corr(), mask= mask, cmap = 'Blues')
plt.show()

With everything ready and a solid exploratory analysis done, we can easily build the Logistic Regression model. This regression model relies on the concept of likelihood, which makes it possible to estimate the probability associated with the occurrence of certain events given a set of explanatory variables.

#Construir modelo de regressão logistica
model = LogisticRegression()
model.fit(X_rus, y_rus)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
                   intercept_scaling=1, l1_ratio=None, max_iter=100,
                   multi_class='auto', n_jobs=None, penalty='l2',
                   random_state=None, solver='lbfgs', tol=0.0001, verbose=0,
                   warm_start=False)

With the model trained and the predictions made, I could then analyze its performance. However, in situations like this one, where the data is imbalanced, we cannot use accuracy as a metric. So we need to build a confusion matrix and a classification report.

Relatório de Classificação:               precision    recall  f1-score   support

           0    0.99975   0.96127   0.98013     71079
           1    0.03708   0.86179   0.07109       123

    accuracy                        0.96110     71202
   macro avg    0.51841   0.91153   0.52561     71202
weighted avg    0.99809   0.96110   0.97856     71202

We obtained quite interesting results, with few false negatives and false positives, reaching 96% true negatives and 86% true positives.

Note that this project is not a typical problem: even though it was done with clean, well-prepared data provided by the course instructor, it was necessary to balance and normalize the data and apply PCA before building the model, which then delivered excellent results for the goal at hand. However, this is a didactic project, which had no categorical variables or missing data. That leaves open the gap of building the model with the full Kaggle dataset. You can see the complete project and all the code in my repository.

If you liked it, share it ;)