Investissement_bank_MachineLearning_avecR.Rmd

---
title: "Bank_MachineLearning_avecR"
author: "Nisrine Bennor"
output: html_document
---
```{r}
### Appeler les librairies
```

```{r , include=FALSE}
library(dplyr)
library(ggplot2)
library(plotly)
library(caret)
library(e1071)
library(rpart)
library(randomForest)
```
On cherche à comprendre quels les élements qui font qu'un client accepte d'investir dans la banque 

### Lecture de fichier de donnée
```{r}
#lecture de fichier de donnée
bank_data=read.csv2("bank.csv",sep = ";")
summary(bank_data)

```

### Visualisation des données

```{r}
#visualisation des données
library("ggplot2")
library("plotly")

## souscription en fonction de la durée d'appel
g<- ggplot(bank_data,aes(x=y,y=duration,fill=y))+geom_boxplot()
g
ggplotly(g)

### Plus la durée d'appel est longue plus le client est intéréssé.

## souscription en fonction de l'age 
g<- ggplot(bank_data,aes(x=y,y=age,fill=y))+geom_boxplot()
g

## variables catégorielles :contact 
g<- ggplot(bank_data,aes(y,fill=contact))+geom_bar()
g


## il y a beaucoup plus de non que de oui. 

```

### Géneration d'un jeu de donnée d'entrainement et d'un jeu de donnée test

```{r}
#création d'un jeu de données d'entrainement et de test
install.packages("caret")
library("caret")


## Transformer les variables catégorielles aux variables numériques 
dummy_variables=dummyVars(~.,data = bank_data)
dummy_variables_data=predict(dummy_variables,newdata=bank_data)
class(dummy_variables_data)
dummy_variables_data=as.data.frame(dummy_variables_data)

## variable à prédire 
dummy_variables_data$"souscription"=ifelse(dummy_variables_data$"y.no"==1, "no", "yes")

## supprimer les 2 colonnes 
dummy_variables_data$"y.no"=NULL
dummy_variables_data$"y.yes"=NULL

# Création d'un jeu de donnée d'entrainement et de test

## Je détermine un paramètre 
set.seed(3033)

## Création du jeu de données d'entrainement: 70% données d'entrainement et 30% pour les données test 
set.seed(3033)
taille_du_jeu_entrainement=floor(0.7*nrow(dummy_variables_data))
head(taille_du_jeu_entrainement)

### récuperer aléatoirment 3164 clients 70% du jeu de données 
indices=sample(seq_len(nrow(dummy_variables_data)), size = taille_du_jeu_entrainement)
length(indices)
head(indices)

## je distingue mes 2 jeu de données : train et test 
data_bank_entrainement=dummy_variables_data[indices,]
data_bank_test=dummy_variables_data[-indices,]
dim(data_bank_entrainement)
dim(data_bank_test)
```
### Normalisation du jeu de données

```{r}
#normalisation des données 

## je crée les valeurs de normalisation
data_preprocess_value=preProcess(data_bank_entrainement,method = c("center","scale"))

## Normalisé le jeu de données d'entrainement et de test: jeu de données normalisé càd à l'échelle
data_bank_entrainement_scaled=predict(data_preprocess_value,data_bank_entrainement)
data_bank_test_scaled=predict(data_preprocess_value,data_bank_test)
head(data_bank_entrainement_scaled)


table(data_bank_entrainement_scaled[,"souscription"])
set.seed(3033)
## opérateur
'%ni%' = Negate("%in%")

#downsample
data_bank_entrainement_scaled_downsample=downSample(x=data_bank_entrainement_scaled[,colnames(data_bank_entrainement_scaled) %ni% "souscription"] ,y=as.factor(data_bank_entrainement_scaled$"souscription"))
head(data_bank_entrainement_scaled[,colnames(data_bank_entrainement_scaled) %ni% "souscription"])
head(data_bank_entrainement_scaled_downsample)
dim(data_bank_entrainement_scaled_downsample)
dim(data_bank_entrainement_scaled)
names(data_bank_entrainement_scaled_downsample)[names(data_bank_entrainement_scaled_downsample)=="Class"]="souscription"
table(data_bank_entrainement_scaled_downsample[,"souscription"])

#upsample
data_bank_entrainement_scaled_upsample=upSample(data_bank_entrainement_scaled
                                                  [,colnames(data_bank_entrainement_scaled) %ni% "souscription"]
                                                    ,y=as.factor(data_bank_entrainement_scaled$"souscription"))
head(data_bank_entrainement_scaled[,colnames(data_bank_entrainement_scaled) %ni% "souscription"])
head(data_bank_entrainement_scaled_upsample)
dim(data_bank_entrainement_scaled_upsample)
dim(data_bank_entrainement_scaled)
names(data_bank_entrainement_scaled_upsample)[names(data_bank_entrainement_scaled_upsample)=="Class"]="souscription"
table(data_bank_entrainement_scaled_upsample[,"souscription"])
```

### Modélisation avec Naives Bayes
```{r}
# modélisation avec Naives Bayes (3 fois)
## j'utilise le modèle de cross validation ou validation croisée.

set.seed(3033)
trainControl_data=trainControl(method = "repeatedcv", number = 10,repeats = 3)

naives_bayes_desequilibree=train(souscription ~., data=data_bank_entrainement_scaled, method="nb", preProcess=NULL)
print(naives_bayes_desequilibree)

#prédiction avec notre modèle sur le jeu de donnée tests

prediction_naive_bayes_desequilibree=predict(naives_bayes_desequilibree,newdata =data_bank_test_scaled[,-ncol(data_bank_test_scaled)])

#création de matrice de confusion 
head(prediction_naive_bayes_desequilibree)
confusionMatrix(prediction_naive_bayes_desequilibree,as.factor(data_bank_test_scaled[,ncol(data_bank_test_scaled)]))
head(data_bank_test_scaled[,ncol(data_bank_test_scaled)])
```

### Modélisation avec Naives Bayes sur les données desequilibree (5 fois)
```{r}
#modélisation avec Naives Bayes sur les données desequilibree
set.seed(3033)
trainControl_data=trainControl(method = "repeatedcv", number = 10,repeats = 5)
naives_bayes_desequilibree=train(souscription ~., data=data_bank_entrainement_scaled, method="nb", preProcess=NULL)
print(naives_bayes_desequilibree)

#prédiction avec notre modèle sur le jeu de donnée tests
prediction_naive_bayes_desequilibree=predict(naives_bayes_desequilibree,newdata =data_bank_test_scaled[,-ncol(data_bank_test_scaled)])
head(prediction_naive_bayes_desequilibree)

# création de matrice de confusion: savoir si le modèle a bien prédit ou pas afin de comparer la prédiction au vrai réponse qui se trouve dans le jeu de données tests et dans la dernière colonne.  
confusionMatrix(prediction_naive_bayes_desequilibree,as.factor(data_bank_test_scaled[,ncol(data_bank_test_scaled)]))
head(data_bank_test_scaled[,ncol(data_bank_test_scaled)])

## ce modèle n'arrive pas vraiement à trouver les clients qui peuvent souscrire au service de la banque. 
## le modèle prédit mal puisqu'il n'arrive pas à detecter certains clients qui peuvent souscrire au service de la banque être appeler et qui peuvent souscrire.

## et donc on teste sur les données équilibrées . 
```

### Modélisation avec Naives Bayes sur les données downsamplé
```{r}
#modélisation avec Naives Bayes sur les données downsamplé
set.seed(3033)
trainControl_data=trainControl(method = "repeatedcv", number = 10,repeats = 5)
naives_bayes_downsample=train(souscription ~., data=data_bank_entrainement_scaled_downsample, method="nb", preProcess=NULL)
print(naives_bayes_downsample)

#prédiction avec notre modèle sur le jeu de donnée tests
prediction_naive_bayes_downsample=predict(naives_bayes_downsample,newdata =data_bank_test_scaled[,-ncol(data_bank_test_scaled)])
head(prediction_naive_bayes_downsample)

# création de matrice de confusion  
confusionMatrix(prediction_naive_bayes_downsample,as.factor(data_bank_test_scaled[,ncol(data_bank_test_scaled)]))
head(data_bank_test_scaled[,ncol(data_bank_test_scaled)])

## en regardant l'accuracy, le modèle se trompe moins sur les données déséquilibrées 


```

### Modèle SVM

```{r}
#modélisation du jeu de donnée avec SVM(données deséquilibrées)
set.seed(3033)
trainControl_data=trainControl(method = "repeatedcv", number = 10,repeats = 5)
SVM_desequilibree=train(souscription ~., data=data_bank_entrainement_scaled, method="svmLinear", preProcess=NULL)
print(SVM_desequilibree)

#prédiction avec notre modèle sur le jeu de donnée tests

prediction_SVM_desequilibree=predict(SVM_desequilibree,newdata =data_bank_test_scaled[,-ncol(data_bank_test_scaled)])
head(prediction_SVM_desequilibree)

#création de matrice de confusion 

confusionMatrix(prediction_SVM_desequilibree,as.factor(data_bank_test_scaled[,ncol(data_bank_test_scaled)]))
head(data_bank_test_scaled[,ncol(data_bank_test_scaled)])

### Le modèle SVM prédit mieux que le modèle précedent de Naive Bayes. 
```
### Modèle Random Forest

```{r}
set.seed(3033)
trainControl_data=trainControl(method = "repeatedcv", number = 10,repeats = 3)
RF_desequilibree=train(souscription ~., data=data_bank_entrainement_scaled, method="svmLinear", preProcess=NULL)
print(RF_desequilibree)

#prédiction avec notre modèle sur le jeu de donnée tests

prediction_RF_desequilibree=predict(RF_desequilibree,newdata =data_bank_test_scaled[,-ncol(data_bank_test_scaled)])

#création de matrice de confusion 

head(prediction_RF_desequilibree)
confusionMatrix(prediction_RF_desequilibree,as.factor(data_bank_test_scaled[,ncol(data_bank_test_scaled)]))
head(data_bank_test_scaled[,ncol(data_bank_test_scaled)])

## même le modèle Random Forest prédit aussi bien et on obtient des résultats satisfaisants. 
```
### Quels variables jouent vraiment pour dire oui ou non à propos de la souscription?
### les variables prédictives qui ont plus d'impact sur la variable à prédire càd la souscription

```{r}
varImp(naives_bayes_downsample, scale = F)

### la durée d'appel est une variable qui joue sur la souscription
### La manière de contacter: par telephone , par fixe ou unknown  
### ce dataset pourra être aussi améliorer puisqu'il contient beucoup de valeurs unknown
### par présence de crédit de maison ou non.....
### donc il existe plusieurs variables. 
```