DEV Community: Maik Paixao

Customer segmentation using RFM and K-Means

Maik Paixao — Sat, 02 Sep 2023 12:04:55 +0000

Welcome! In this tutorial, we will guide you in clustering bank customers based on their transaction behaviors using the RFM (Recency, Frequency, Monetary) model and K-Means clustering in Python.

Prerequisites:

Python Installed.
Familiarity with Python Programming.
Basic Understanding of Clustering

1.Install required libraries

Install the necessary packages for data processing and clustering.

pip install pandas scikit-learn

2. Import Libraries

Import the necessary modules.

import pandas as pd
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

3. Upload bank details

The dataset has around 10,000 records. Each record addresses a financial transaction carried out by a customer.

The main columns that stand out include client_id, transaction_date, and transaction_amount. The client_id is a unique identifier assigned to each client, ensuring data consistency and facilitating reference. Meanwhile, transaction_date records the timestamp of each transaction performed, serving as an essential marker for evaluating transaction patterns and behaviors over time.

The transaction_amount, on the other hand, is a numeric field that quantifies the monetary value associated with each transaction. This field has immense significance as it provides a direct window into understanding an individual's consumption habits, financial capabilities and, to some extent, economic stratum.

We use the pandas read_csv() function to read the csv containing the transactions.

data = pd.read_csv('banking_data.csv')
print(data.head())

4. Calculate RFM metrics

The acronym RFM stands for Recency, Frequency and Monetary Value, each representing a unique facet of a customer's transactional pattern.

Recency: This metric addresses the question of how long ago a customer engaged in a transaction. A shorter time since last transaction typically indicates a more active customer. In our dataset, this is calculated by subtracting the date of each transaction from the date of the last transaction in the dataset, resulting in the number of days elapsed.

Frequency: Representing the total number of transactions a customer has performed during a specific period, frequency offers information about how often customers interact with banking services. It is a direct measure of customer engagement and loyalty.

Monetary Value: This metric encapsulates the total amount a customer spent during a period. It is a reflection of customer value, with higher values indicating customers who bring more financial value.

# Recency
max_date = data['transaction_date'].max()
data['recency'] = (max_date - data['transaction_date']).dt.days

# Frequency & Monetary Value
rfm = data.groupby('client_id').agg({
     'recency': 'min',
     'client_id': 'count',
     'transaction_amount': 'sum'
}).rename(columns={
     'client_id': 'frequency',
     'transaction_amount': 'monetary'
})

print(rfm.head())

5. Data preprocessing

The “Data Preprocessing” section plays a key role in the analytical pipeline. While raw data often contains a plethora of valuable information, it is also riddled with inconsistencies, discrepancies, and varying scales that, if not addressed, can skew the results of subsequent analysis.

In the context of our tutorial focusing on grouping bank customers using RFM metrics, preprocessing becomes especially crucial. Clustering algorithms like K-Means are sensitive to the scale of the data. Different magnitudes between variables can disproportionately influence the algorithm, leading to misleading clusters.

To address this, the preprocessing phase employs scikit-learn's StandardScaler, a renowned Python library for data science. StandardScaler normalizes each variable to have a mean of zero and a standard deviation of one. This ensures that all variables, whether Recency, Frequency or Monetary, contribute equally to the grouping process.

The transformed data, called rfm_scaled in our tutorial, represents standardized RFM values ready for clustering. In essence, the preprocessing phase acts as a bridge, converting raw, irregular data into a refined, standardized format, ensuring that the subsequent clustering algorithm works efficiently and provides accurate, interpretable clusters. This section highlights the adage, “Garbage in, garbage out,” emphasizing the importance of clean, standardized input data for quality results.

scaler = StandardScaler()
rfm_scaled = scaler.fit_transform(rfm)

6. Determine the number of clusters

This part of the tutorial addresses one of the most critical decisions in the clustering process: identifying the ideal number of clusters. Although clustering aims to segment data into distinct groups based on similarities, the number of these groups is not always evident in advance.

In our tutorial, the Elbow Method is presented as the technique of choice for discerning this ideal number. This method involves plotting the sum of squared distances (often referred to as "inertia") for various cluster counts. As the number of clusters increases, inertia typically decreases; each data point is closest to its respective centroid. However, beyond a certain point, adding more clusters does not lead to a substantial decrease in inertia. This inflection point, similar to an “elbow” in the plotted curve, suggests an ideal number of clusters.

By employing the Elbow or Elbow method, our tutorial iteratively tunes the K-Means algorithm with a range of cluster counts. By viewing the resulting inertia values, analysts can discern the “elbow” and subsequently the suggested cluster count.

In summary, this section highlights the importance of selecting an appropriate cluster count, offering a systematic approach to making this critical decision, ensuring that the resulting clusters are meaningful, distinct and actionable.

distortions = []
for i in range(1, 11):
     km = KMeans(n_clusters=i)
     km.fit(rfm_scaled)
     distortions.append(km.inertia_)

7. Apply K-Means clustering

The K-Means clustering algorithm works by partitioning data into distinct clusters. This is done by assigning each data point to the cluster whose centroid (or center) is closest. These centroids are iteratively recalculated until they stabilize, meaning that an optimal clustering arrangement has been achieved.

For our tutorial, the standardized RFM values, derived in the Data Preprocessing phase, serve as input. Leveraging Python's scikit-learn library, a KMeans object is instantiated with the optimal number of clusters deduced from the previous section. This object is then trained using the fit_predict method on our scaled RFM values, and the resulting cluster labels are stored back into the original RFM dataframe according to the following code:

kmeans = KMeans(n_clusters=3, random_state=0)
rfm['cluster'] = kmeans.fit_predict(rfm_scaled)
print(rfm.head())

8. Interpretation of Segments

In the end, we need to examine the centroids and characteristics of each generated cluster to understand the segments.

You can do this with the code below:

cluster_summary = rfm.groupby('cluster').agg({
     'recency': ['mean', 'std'],
     'frequency': ['mean', 'std'],
     'monetary': ['mean', 'std']
})

print(cluster_summary)

With this tutorial we were able to segment customers based on their transactional behavior using the RFM model and K-Means clustering. This segmentation allows the development of targeted marketing strategies, personalized services and also better customer management.

Download dataset and Jupyter Notebook

Hi, I'm Maik. I hope you liked the article. If you have any questions or want to connect with me and access more content, follow my channels:

LinkedIn: https://www.linkedin.com/in/maikpaixao/
Twitter: https://twitter.com/maikpaixao
Youtube: https://www.youtube.com/@maikpaixao
Instagram: https://www.instagram.com/prof.maikpaixao/
Github: https://github.com/maikpaixao

Creating an Image Classification Model with PyTorch

Maik Paixao — Fri, 18 Aug 2023 15:14:31 +0000

Welcome!

In this tutorial, I will walk you through creating a simple image classification model using PyTorch, a popular deep learning library in Python.

Prerequisites:

Python Installed.
Familiarity with Python Programming.
Basic understanding of neural networks.

1. Installation:

Before we begin, make sure you have installed the necessary packages:

It's about setting up your environment and installing PyTorch, which is a widely used library for deep learning tasks, while archvision provides utilities for computer vision.

PyTorch: The core library for implementing deep learning architectures such as neural networks.
Torchvision: A helper library for PyTorch that provides access to popular datasets, model architectures, and image transformations for computer vision.



pip install torch torchvision

2. Import Libraries:

Before you can use the features of a package, you need to import it.

toch: the main PyTorch module.

Torchvision: As mentioned, this helps with datasets and models specifically for computer vision tasks.

transforms: This provides common image transformations. In deep learning, input data often requires preprocessing to improve training efficiency and performance.

nn: This module provides all the building blocks for neural networks.
optim: Contains common optimization algorithms for tuning model parameters.



import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.optim as optim

3. Read and Preprocess the Data:

We will use the CIFAR-10 dataset, a set of 60,000 32 x 32 color images in 10 classes.

CIFAR-10 dataset: A well-known dataset in computer vision, consisting of 60,000 32 x 32 color images spanning 10 classes.

transform.Compose(): chains multiple image transformations. In this example, images are first converted to tensors and then normalized to have values between -1 and 1.

DataLoader: Helps in feeding data in batches, shuffling it and loading it in parallel, making the training process more efficient.



transform = transforms.Compose([
     transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # Normalize the images
])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

4. Define the Neural Network:

We define a simple Convolutional Neural Network (CNN) framework.

Here, we are defining our Convolutional Neural Network (CNN). CNNs are the standard neural network type for image processing tasks.

nn.Conv2d(): Represents a convolutional layer. It expects (input_channels, output_channels, kernel_size) among other parameters.

nn.MaxPool2d(): Represents maximum pooling, which reduces the spatial size of the representation, making calculations faster and extracting dominant features.

nn.Linear(): Represents a fully connected layer that connects each neuron from the previous layer to the next.

The forward function specifies how data flows across the network. This flow is essential for forward and backward propagation.



class Net(nn.Module):
     def __init__(self):
         super(Net, self).__init__()
         self.conv1 = nn.Conv2d(3, 6, 5) # 3 input channels, 6 output channels, 5x5 kernel
         self.pool = nn.MaxPool2d(2, 2) # 2x2 max pooling
         self.conv2 = nn.Conv2d(6, 16, 5)
         self.fc1 = nn.Linear(16 * 5 * 5, 120)
         self.fc2 = nn.Linear(120, 84)
         self.fc3 = nn.Linear(84, 10) # 10 output classes

     def forward(self, x):
         x = self.pool(F.relu(self.conv1(x)))
         x = self.pool(F.relu(self.conv2(x)))
         x = x.view(-1, 16 * 5 * 5)
         x = F.relu(self.fc1(x))
         x = F.relu(self.fc2(x))
         x = self.fc3(x)
         return x

net = Net()

5. Define the Loss Function and Optimizer:

Let's use Cross-Entropy loss and SGD optimizer.

Cross-Entropy loss: Commonly used in classification tasks. It measures the difference between predicted probabilities and true class labels.

SGD (Stochastic Gradient Descent): An optimization method used to minimize loss by adjusting model weights.



criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

6. Training the Network:

Here, we will train the model for a few epochs.

The essence of deep learning is this iterative process of adjusting model weights to minimize loss:

Clear gradients: Since PyTorch accumulates gradients, you need to clear them before each step.

Forward Propagation: Pass input through the model to obtain predictions.

Calculate loss: compare predictions with actual labels.
Backward Propagation: Backpropagate the loss throughout the network to calculate the gradient of the loss with respect to each weight.

Optimize: Adjust weights in the direction that minimizes loss.
The loop ensures that the model sees the data multiple times (epochs) and adjusts its weights.



for epoch in range(5): # Loop over the dataset multiple times

     running_loss = 0.0
     for i, data in enumerate(trainloader, 0):
         inputs, labels = data

         optimizer.zero_grad() # Zero the parameter gradients

         outputs = net(inputs) # Forward
         loss = criterion(outputs, labels) # Calculate loss
         loss.backward() # Backward
         optimizer.step() # Optimize

         running_loss += loss.item()
         if i % 2000 == 1999: # Print every 2000 mini-batches
             print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))
             running_loss = 0.0

print('Finished Training')

7. Testing the Network:

After training, it is crucial to evaluate the model's performance on unseen data:

torch.no_grad(): Disables gradient computation, which is not needed during evaluation, saving memory and computation.

Outputs: These are the predicted probabilities for each class.
Prediction: By choosing the class with the highest probability, we obtain the predicted class label.

Calculate Accuracy: Count how many predictions match the actual labels and calculate the percentage.

At the end of this process, you will have a trained neural network model capable of classifying images from the CIFAR-10 dataset. Remember, this is a basic tutorial. For better accuracy and efficiency in real-world applications, more advanced techniques and fine-tuning are required.



correct = 0
total = 0
with torch.no_grad():
     for data in testloader:
         images, labels = data
         outputs = net(images)
         _, predicted = outputs.max(1)
         total += labels.size(0)
         correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))

And that's it! In just 10 minutes, you learned how to create and train a simple image classification model using PyTorch. With more time and tweaking, you can improve this model further or dive deeper into advanced architectures and techniques!

Hi, I'm Maik. I hope you liked the article. If you have any questions or want to connect with me and access more content, follow my channels:

Building Great Credit Scoring Models

Maik Paixao — Thu, 27 Jul 2023 21:19:32 +0000

Granting credit is a decision taken under conditions of uncertainty. In loans, installment sales, provision of services, etc., there is always the possibility of losing the amount borrowed. If a creditor is able to estimate the probability of a certain loss occurring, the decision-making process becomes more assertive, reducing possible losses. Because of this, several companies and financial institutions invest in Credit Scoring models. These models aim to predict, on the date of the decision, a possible granting of credit, if the granted operation implies losses for the creditor. The probability of this happening is called credit risk in the industry.

Therefore, Credit Score is a measure of credit risk. Credit scoring models is the market's common generic determination for credit score calculation formulas.
Quantitative Credit Score

The risk of a credit application can be assessed subjectively or measured objectively through quantitative analysis methodologies. The subjective assessment, despite incorporating the experience of a financial analyst, does not quantify credit risk. It is necessary to accurately estimate possible losses and expected gains for each operation and consequently make a decision. This measurement using quantitative methods has some advantages:

Consistency in Decisions

If we submit the same credit operation to different analysts, different subjective assessments can be obtained, as the experience and engagement with the customer differ between them. Furthermore, the same financial analyst may give different assessments to the same proposal if it is presented at different times. We humans are like that. However, this does not occur when using a quantitative Credit Scoring model. Keeping the initial characteristics of the proposal unchanged, the calculated score will always be the same.

Quick Decisions

The computational resources available today allow the score calculation to be computed almost instantly, right after data registration for a given request has been carried out. Hundreds or thousands of decisions can be made in just one day, with security and consistency. This short customer response time allows investment banks to have a competitive advantage.

Remote Decisions

Currently, with the data transmission resources available, the lender does not need to allocate a financial credit analyst in each office or in each branch. The credit seller can record the data at the point of sale, and after sending that data, the model can almost instantly calculate the customer's credit score.

Portfolio Monitoring

The quantification of individual risks allows continuous monitoring of the analysis of credit portfolios. This, in addition to ensuring the security of the portfolio's cash flow, also allows analyzing trends within the institution itself, an important step in building forecasting models.

Credit Scoring Model

The idea behind credit scoring techniques is simple. Suppose that, in car financing, the lender analyzes only three characteristics of the applicants. The type of residence at the date of the request, whether the applicant has debts and whether the vehicle subject to the credit operation is new or used. As the number of variables increases, the complexity of the analysis increases. In this case, analysis is only viable with the help of advanced quantitative techniques.

The effectiveness of a credit scoring model directly depends on the information used to assess customer and transaction risks. Choosing this information correctly is extremely important for obtaining a good model.

We initially identified a set of predictor variables that we believe have the potential to discriminate whether a customer is eligible to receive a loan. These variables are used in the score calculation formula.

One way to begin identifying potential variables is by analyzing available databases. When analyzing these variables, ideas may arise to combine two or more of them to generate a new variable that provides information for the model. In large banks, customer and transaction data are commonly stored in different databases.
When identifying the team of experts, keep in mind the objective you hope to achieve with the Credit Scoring model. Data that can differentiate whether a client is able to honor their debts must be analyzed.
In general, you can classify information by following descriptions:

Sociodemographic data of the applicant

Sociodemographic information of the spouse or partner
Applicant's financial information
Lender Relationship Information
Behavioral information

Legal concerns

The first point concerns legal certainty. It is important to inform the customer that when requesting credit, they are authorizing consultation with credit protection bodies. Furthermore, the information obtained is confidential and should not be disclosed or shared under any circumstances, restricting its use exclusively to support the granting of credit.

This conduct should be done as a good practice in your company's routines. After all, it is customer data that can be exposed to criminal action. To do this, you need to train your team well, implement security tools and use secure applications.

Financial management software includes technologies that strengthen information security, such as cloud computing and blockchain (anchor blocks). It is worth remembering that, in isolation, the credit score is not a parameter for granting, its information needs to be cross-referenced with internal data from its customers, evaluating their payment capacity and their relationship with the company in order to reduce default rates.

Hi, I'm Maik. I hope you liked the article. If you have any questions or want to connect with me and access more content, follow my channels: