Bank Customer Churn Using R

getwd()
churndata <- read.csv("Churn Data For Tree.csv", stringsAsFactors = TRUE)
View(churndata)
summary(churndata)
str(churndata)
RNGversion("3.5.2"); set.seed(123)
train_sample <- sample( 10000, 9000)
str(train_sample)

#We begin this model by loading the "Churn Data For Tree.csv" dataset into a data frame named churndata. The dataset contains information related to customer churn. After some data exploration, the data set is then split into training data and testing data to use for the model. 

churn_train <- churndata[train_sample, ]
churn_test <- churndata[-train_sample, ]

prop.table(table(churn_train$Exited))
prop.table(table(churn_test$Exited))

#When looking at these tables, we can see that in the training dataset, there were 20.2% of customer churn and there was 21.5% in the testing data.

table(churndata$Exited)
install.packages('libcoin', dependencies = T)
install.packages('C50', dependencies = T)
install.packages('inum')
library(inum)
library(libcoin)
library(C50)

churn_model <- C5.0(churn_train[-11], churn_train$Exited)

#After the appropriate packages were installed in order to start creating the model, the c5.0 algorithm was chosen in creating the decision tree. The model is created using the training data before using on the testing data. After this was done, a summary of the model was evaluated. After reviewing the results of the model, we can see that there is a 12.6% error rate overall. 

churn_model

summary(churn_model)

churn_predict <- predict(churn_model, churn_test)
library(gmodels)
CrossTable(churn_test$Exited, churn_predict, prop.chisq = FALSE, prop.c = FALSE, prop.r = FALSE, dnn = c('actual churn', 'predicted churn'))

#After running the original model on the testing data next, we can see that our model accurately predicted 85.4%. This is a good percentage for this model but there could still be some room for improvement and so pruning the tree was done next to see if there could be improved results. 

pruned_churn_model <- C5.0(churn_train[-11], churn_train$Exited, control = C5.0Control(winnow = TRUE))
pruned_churn_pred <- predict(pruned_churn_model, newdata = churn_test)
CrossTable(churn_test$Exited, pruned_churn_pred, prop.chisq = FALSE, prop.c = FALSE, prop.r = FALSE, dnn = c('actual churn', 'predicted churn'))

#Pruning the tree did not give us improvement in our results taking us from a 85.4% accuracy to a 85% accuracy overall. While there was only a slight decrease in the accuracy results, pruning the tree did not seem to be effective in this case. 

churn_boost10 <- C5.0(churn_train[-11], churn_train$Exited, trials = 15)
churn_boost10

summary(churn_boost10)

churn_boost_pred10 <- predict(churn_boost10, churn_test)
CrossTable(churn_test$Exited, churn_boost_pred10, prop.chisq = FALSE, prop.c = FALSE, prop.r = FALSE, dnn = c('actual churn', 'predicted churn'))

#A boost was then applied to the training model and after review of the results, it was applied to the testing data to see if we could achieve any increase improvements from our original model and there was a slight improvement up to 85.7% for the boosted model. From here, I was able to confirm my results with a confusion matrix showing these results while also taking a look at the accuracy level, precision level, and F1-score for this model. These results were then charted.While the accuracy level is not bad, the F1-score is only okay and could use some improvement with the precision score of 74% also needing some improvement as well. 

library(caret)
library(ggplot2)

confusion_matrix <- table(churn_test$Exited, churn_boost_pred10)
print(confusion_matrix)

true_positives <- confusion_matrix[2, 2]
true_negatives <- confusion_matrix[1, 1]
false_positives <- confusion_matrix[1, 2]
false_negatives <- confusion_matrix[2, 1]

accuracy <- (true_positives + true_negatives) / sum(confusion_matrix)
precision <- true_positives / (true_positives + false_positives)
recall <- true_positives / (true_positives + false_negatives)
f1_score <- 2 * (precision * recall) / (precision + recall)

cat("Accuracy:", accuracy, "\n")
cat("Precision:", precision, "\n")
cat("Recall:", recall, "\n")
cat("F1-Score:", f1_score, "\n")

metrics <- c("Accuracy", "Precision", "Recall", "F1-Score")
values <- c(0.857, 0.74, 0.5162791, 0.6082192)
performance_data <- data.frame(Metric = metrics, Value = values)

ggplot(performance_data, aes(x = Metric, y = Value, group = 1)) +
  geom_line(color = "blue") +
  geom_point(color = "blue", size = 3) +
  labs(title = "Model Performance Metrics",
       x = "Metric",
       y = "Value") +
  theme_minimal()


install.packages("pROC")
library(pROC)


roc_obj <- roc(churn_test$Exited, as.numeric(churn_boost_pred10))

plot(roc_obj, main = "ROC Curve",
     xlab = "False Positive Rate (FPR)", ylab = "True Positive Rate (TPR)",
     col = "blue", lwd = 2)

abline(a = 0, b = 1, col = "red", lwd = 1, lty = 2)
auc_value <- auc(roc_obj)
text(0.5, 0.3, paste("AUC =", round(auc_value, 2)), adj = c(0.5, 0.5), col = "blue")




getwd()
churndata_regress <- read.csv("Churn Data for Project.csv", stringsAsFactors = TRUE)
View(churndata_regress)
summary(churndata_regress)
summary(churndata_regress$Exited)

#When first starting to create the regression model for analyzing customer churn for the bank, I went over a summary of the data itself along with viewing the amount of customers that had churned from the bank. The amount of those that had churned was a total of 20.37%. I also created a table for both those that had exited, or churned from the bank and I wanted to take a look at how many people were located in each country to see if there was more of a chance of customer churn in specific countries due to the the mount of people that banked from each country. 

str(churndata_regress)
table(churndata_regress$Exited)
table(churndata_regress$Geography)

library("psych")


pairs.panels(churndata_regress[c("Age", "CreditScore", "Exited", "NumOfProducts", "Balance")])
plot(churndata_regress$CreditScore ~ churndata_regress$Exited)

#When viewing the panel, we can see that there is some correlation between those who have chosen to churn or exit and the number of products and balance within their account. We can tell this from the oval shape. We can also see that there is some slight correlation between those exiting and churning and the age of the customers. 

library(dplyr)

categorical <- c("Gender", "Geography")

total_churn_rate <- mean(churndata_regress$Exited)
for (c in categorical) {
  df_group <- churndata_regress %>%
    group_by(!!sym(c)) %>%
    summarise(
      mean_churn = mean(Exited),
      count = n()
    ) %>%
    mutate(
      diff = mean_churn - total_churn_rate,
      risk = mean_churn / total_churn_rate
    )
  
  print(paste("Analysis for", c))
  print(df_group)
  print("\n\n")
}

#The risk associated with those who may potentially churn when looking at gender and location, we can see that there is a higher risk for females to churn and that those living in Germany are more likely to churn compared to those living in Spain or France. 

library(rlang)
library(ggplot2)

set.seed(1234)
trainIndex <- createDataPartition(churndata_regress$Exited, p = 0.8, list = FALSE, times = 1)
training_data <- churndata_regress[ trainIndex,]
testing_data  <- churndata_regress[-trainIndex,]

#Here is where the data was split into training data and testing data before being able to create the model. 

churn_logmodel = glm(Exited ~ ., data = training_data, family = "binomial")
summary(churn_logmodel)

#When choosing the type of regression model, I initially went with a multiple linear regression model and was having a difficult time achieving the results I was aiming to achieve. Because of this, I chose to go with a logistical regression model working with the training data first. After reviewing the results of the model, I chose to eliminate Estimated Salary, Tenure, And Has Credit Card from the model due to it not having a significant impact on whether or not a customer will churn or not. 

churn_logmodel2 = glm(Exited ~ CreditScore + Age + Balance + Gender + NumOfProducts + IsActiveMember + Geography, data = training_data, family = "binomial") 
summary(churn_logmodel2)

#After reviewing the results of the first model, I created the second model and ran the summary on that and decided to keep this model as each of the independent variables that were kepy for this model held significance in customer churn for this bank. 

prediction <- predict(churn_logmodel2,testing_data,type="response")
churn_stop <- ifelse(prediction>=0.50, 1,0)
results_matrix <- confusionMatrix(as.factor(testing_data$Exited),as.factor(churn_stop),positive ='1')
results_matrix

#Running this model against the testing data gave me an accuracy level of 81.95%. While this could have been better, this is not necessarily a poor model. The sensitivity is at 61% and the specificity is at 83%. The area under the curve is at 77.8% which is decent result. 

library(pROC)
predicted_probs <- predict(churn_logmodel2, testing_data, type = "response")
roc_obj <- roc(testing_data$Exited, predicted_probs)
print(roc_obj$auc)
roc_plot <- ggroc(roc_obj)
print(roc_plot)



getwd()
churndata <- read.csv("Churn Data for Project.csv", stringsAsFactors = TRUE)
View(churndata)
summary(churndata)
summary(churndata$Exited)
table(churndata$Geography)
table(churndata$Gender)
table(churndata$Tenure)
str(churndata)
dim(churndata)
head(churndata)
tail(churndata)
names(churndata)
class(churndata)
par(mar = c(0.1, 0.1, 0.1, 0.1))
pairs(churndata)

#When creating the neural network, I first chose to load the data and then examine the data further making sure there were no missing values in preparation to normalize the data before creating my neural network. 

dummy_matrix <- model.matrix( ~ Gender -1, data = churndata)
churndata <- cbind(churndata, dummy_matrix)
dummy_matrix_1 <- model.matrix( ~ Geography -1, data = churndata)
churndata <- cbind(churndata, dummy_matrix_1)
dummy_matrix_2 <- model.matrix ( ~Exited -1, data = churndata)
churndata <- cbind(churndata, dummy_matrix_2)

#For the Gender, Geography, and Exited columns in the dataset, dummy variables needed to be created in order to normalize the data set.

columns_to_normalize <- c(1:5, 7:9, 11:16)
min_max_norm <- function(x) {
  (x-min(x)) / (max(x) - min(x))
}
churndata_norm <- as.data.frame(lapply(churndata[, columns_to_normalize], min_max_norm))
head(churndata_norm)
summary(churndata_norm$Exited)

#After normalizing the data for the model, I examined the data to make sure that everything had been normalized and was ready and prepared to be separated into testing and training datasets. As you can see, the training data was set to use 9000 of the 10000 and the testing was to use the remaining 1000 values. 

churndata_train <- churndata_norm[1:9000, ]
churndata_test <- churndata_norm[9001:10000, ]

install.packages("neuralnet")
library(neuralnet)

set.seed(1234)
churndata_model <- neuralnet(Exited ~ CreditScore + Age + Balance + EstimatedSalary + Tenure + NumOfProducts + HasCrCard + IsActiveMember + GenderFemale + GenderMale + GeographyFrance + GeographyGermany + GeographySpain, data = churndata_train)
plot(churndata_model)

#This first neural network model was set to include all of the data and did not include any hidden networks. The results from this first model was very poor with an accuracy rate of only 38.4%. This was really surprising to me with how poorly it performed and so I decided to add some hidden layers to my next model. 

model_results <- compute(churndata_model, churndata_test[1:14])
predicted_strength <- model_results$net.result
cor(predicted_strength, churndata_test$Exited)

set.seed(1234)
churndata_model2 <- neuralnet(Exited ~ CreditScore + Age + Balance + EstimatedSalary + Tenure + NumOfProducts + HasCrCard + IsActiveMember + GenderFemale + GenderMale + GeographyFrance + GeographyGermany + GeographySpain, data = churndata_train, hidden = 5)
plot(churndata_model2)

model_results2 <- compute(churndata_model2, churndata_test[1:14])
predicted_strength <- model_results2$net.result
cor(predicted_strength, churndata_test$Exited)

#After realizing that the first model performed so poorly, I decided to add hidden layers into my second neural network in hopes of making great improvements in my results. While it did boost my results up to 55.6%, it still was a far cry from being a model that could be used in predicting customer churn. The last model I created, I decided to use an activation function known as a rectifier. For this particular model, I chose to go with a softplus activation function. 

softplus <- function(x) { log(1 + exp(x)) }

set.seed(12345)
churndata_model3 <- neuralnet(Exited ~ CreditScore + Age + Balance + EstimatedSalary + Tenure + NumOfProducts + HasCrCard + IsActiveMember + GenderFemale + GenderMale + GeographyFrance + GeographyGermany + GeographySpain, data = churndata_train, hidden = c( 5, 1) , act.fct = softplus)

test_input <- as.matrix(churndata_test[, 1:14])
model_results3 <- compute(churndata_model3, test_input)
predicted_strength <- model_results3$net.result
cor(predicted_strength, churndata_test$Exited)

#After creating the softplus activation function for this third and final model, hidden layers and neurons were also added in order to see in more improvement could have been made. Unfortunately, every time I tried to run this code, it would run for about 30-40 minutes before my system would crash and I was unable to see if this would actually improve the models performance. Because of this, I would have to go with the results achieved from my second regression model. 




#After exploring all three models and their results, I believe that the decision tree or the logistic regression model would be best to use in predicting customer churn. While the decision tree can be helpful due to its high accuracy, the regression model was a great model in helping us to understand reasoning as to why a person may churn from the bank such as age. Those more likely to churn were the younger and older customers and so that may be a good indication of something that could be addressed marketing wise in order to maintain those customers business. 

Add a new chunk by clicking the Insert Chunk button on the toolbar or by pressing Ctrl+Alt+I.

When you save the notebook, an HTML file containing the code and output will be saved alongside it (click the Preview button or press Ctrl+Shift+K to preview the HTML file).

The preview shows you a rendered HTML copy of the contents of the editor. Consequently, unlike Knit, Preview does not run any R code chunks. Instead, the output of the chunk when it was last run in the editor is displayed.