Big Data Project: E-commerce Customer Churn Prediction¶

data= pd.read_csv('Projet.csv')
data.head()

data.info()

# Vérification des doublons
duplicate_rows = data.duplicated()
print(f'Nombre de doublons : {duplicate_rows.sum()}')

pourcentage_manquant = data.isnull().mean() * 100
# pourcentage des valeurs manquantes
colonnes_sans_donnees_manquantes = pourcentage_manquant[pourcentage_manquant == 0].index.tolist()

# Imprimer la liste des variables avec 0% de données manquantes
print("Variables avec 0% de données manquantes :")
for col in colonnes_sans_donnees_manquantes:
    print(col)

# Tracer le pourcentage de données manquantes
colonnes_avec_donnees_manquantes = pourcentage_manquant[pourcentage_manquant > 0]
plt.figure(figsize=(10, 6))
sns.barplot(x=colonnes_avec_donnees_manquantes, y=colonnes_avec_donnees_manquantes.index, palette='viridis')
plt.title('Pourcentage de valeurs manquantes par colonne')
plt.xlabel('Pourcentage')
plt.ylabel('Colonnes')
plt.show()

fig, axes = plt.subplots(3, 1, figsize=(8, 12))

#Tenure
sns.histplot(data['Tenure'].dropna(), kde=True, ax=axes[0], color=sns.color_palette('viridis')[1])
axes[0].set_title('Distribution de la Tenure')
axes[0].set_xlabel('Tenure')
axes[0].set_ylabel('Fréquence')

#HourSpendOnApp
sns.histplot(data['HourSpendOnApp'].dropna(), kde=True, ax=axes[1], color=sns.color_palette('viridis')[4])
axes[1].set_title('Distribution des Heures Passées sur l\'App')
axes[1].set_xlabel('Heures Passées sur l\'App')
axes[1].set_ylabel('Fréquence')

#DaySinceLastOrder
sns.histplot(data['DaySinceLastOrder'].dropna(), kde=True, ax=axes[2], color=sns.color_palette('viridis')[5])
axes[2].set_title('Distribution des Jours Depuis la Dernière Commande')
axes[2].set_xlabel('Jours Depuis la Dernière Commande')
axes[2].set_ylabel('Fréquence')

plt.tight_layout()
plt.show()

fig, axes = plt.subplots(4, 1, figsize=(8, 16))

# WarehouseToHome
sns.histplot(data['WarehouseToHome'].dropna(), kde=True, ax=axes[0], color=sns.color_palette('viridis')[1])
axes[0].set_title('Distribution de WarehouseToHome')
axes[0].set_xlabel('Distance entre entrepôt et domicile')
axes[0].set_ylabel('Fréquence')

# OrderAmountHikeFromlastYear
sns.histplot(data['OrderAmountHikeFromlastYear'].dropna(), kde=True, ax=axes[1], color=sns.color_palette('viridis')[2])
axes[1].set_title('Distribution de OrderAmountHikeFromlastYear')
axes[1].set_xlabel('Pourcentage d\'augmentation du montant de la commande par rapport à l\'année dernière')
axes[1].set_ylabel('Fréquence')

# CouponUsed
sns.histplot(data['CouponUsed'].dropna(), kde=True, ax=axes[2], color=sns.color_palette('viridis')[3])
axes[2].set_title('Distribution de CouponUsed')
axes[2].set_xlabel('Nombre de coupons utilisés')
axes[2].set_ylabel('Fréquence')

# OrderCount
sns.histplot(data['OrderCount'].dropna(), kde=True, ax=axes[3], color=sns.color_palette('viridis')[4])
axes[3].set_title('Distribution de OrderCount')
axes[3].set_xlabel('Nombre de commandes')
axes[3].set_ylabel('Fréquence')

plt.tight_layout()
plt.show()

# Calcul des médianes et moyennes pour les imputations
median_tenure = data['Tenure'].median()
median_day_since_last_order = data['DaySinceLastOrder'].median()
median_warehouse_to_home = data['WarehouseToHome'].median()
median_coupon_used = data['CouponUsed'].median()
median_order_count = data['OrderCount'].median()

mean_hour_spend_on_app = data['HourSpendOnApp'].mean()
mean_order_amount_hike_from_last_year = data['OrderAmountHikeFromlastYear'].mean()

# Application des imputations
data['Tenure'].fillna(median_tenure, inplace=True)
data['DaySinceLastOrder'].fillna(median_day_since_last_order, inplace=True)
data['WarehouseToHome'].fillna(median_warehouse_to_home, inplace=True)
data['CouponUsed'].fillna(median_coupon_used, inplace=True)
data['OrderCount'].fillna(median_order_count, inplace=True)

data['HourSpendOnApp'].fillna(mean_hour_spend_on_app, inplace=True)
data['OrderAmountHikeFromlastYear'].fillna(mean_order_amount_hike_from_last_year, inplace=True)

data.isnull().sum()

def addlabels(x, y):
    for i, v in enumerate(y):
        plt.text(i, v // 2, f"{v / sum(y) * 100:.1f}%", ha='center', va='center', fontsize=12, color='white')

categorical_cols = ['PreferredLoginDevice', 'CityTier', 'PreferredPaymentMode',
       'Gender', 'NumberOfDeviceRegistered', 'PreferedOrderCat',
       'SatisfactionScore', 'MaritalStatus', 'Complain','NumberOfAddress']

num_rows = (len(categorical_cols) + 1) // 2

plt.figure(figsize=(15, 5 * num_rows))

for i, col in enumerate(categorical_cols):
    ax = plt.subplot(num_rows, 2, i + 1)
    sns.countplot(data=data, x=col, palette='viridis', ax=ax)
    ax.set_title(f'Distribution de {col}')
    ax.set_xlabel('')
    ax.set_ylabel('')
    ax.tick_params(axis='x', rotation=45)

    addlabels(ax.patches, [p.get_height() for p in ax.patches])

    ax.set_yticklabels([])

    ax.set_ylim(0, ax.get_ylim()[1] * 1.1)

plt.tight_layout()
plt.show()

# Liste des colonnes numériques
numerical_cols = ['Tenure', 'WarehouseToHome', 'HourSpendOnApp', 
                  'OrderAmountHikeFromlastYear', 'CouponUsed', 
                  'OrderCount', 'DaySinceLastOrder', 'CashbackAmount']

data_c = data[data['Churn']==1].copy()
data_nc = data[data['Churn']==0].copy()

# Création de la figure avec les sous-graphiques
fig, ax = plt.subplots(2, 4, figsize=(20, 15))
fig.suptitle('Densité des variables numériques en fonction de Churn', fontsize=20)
ax = ax.flatten()

# Boucle sur les colonnes numériques
for idx, c in enumerate(numerical_cols):
    sns.kdeplot(data=data_c[c], linewidth=3, label='Churn', ax=ax[idx], color=sns.color_palette('viridis')[2], fill=True)
    sns.kdeplot(data=data_nc[c], linewidth=3, label='No Churn', ax=ax[idx], color=sns.color_palette('viridis')[5], fill=True)
    
    ax[idx].legend(loc='upper right')
    ax[idx].set_title(c)
    ax[idx].set_xlabel('')
    ax[idx].set_ylabel('Density')

plt.tight_layout()
plt.show()

fig, ax = plt.subplots(5,2,figsize=(20, 18))
fig.suptitle('DDensité des variables catégorielles en fonction de Churn', fontsize=20)
ax = ax.flatten()

for idx,c in enumerate(categorical_cols):
    sns.histplot(data_c[c], linewidth= 3,
             label = 'Churn',ax=ax[idx],color=sns.color_palette('viridis')[2], fill=True)
    sns.histplot(data_nc[c], linewidth= 3,
             label = 'No Churn',ax=ax[idx],color=sns.color_palette('viridis')[5], fill=True)

    ax[idx].legend(loc='upper right')

plt.show()

# Matrice de corrélation de Pearson
plt.figure(figsize=(12, 10))
corr_matrix = data.corr()
sns.heatmap(corr_matrix, annot=True, fmt=".2f", cmap='viridis')
plt.title('Matrice de Corrélation de Pearson')
plt.show()

# Corrélation de chaque variable avec la cible 'Churn'
pearson_corr = data.corr()['Churn'].sort_values(ascending=False)
print(pearson_corr)

# encodage One-Hot aux variables catégorielles
categorical_columns = ['PreferredLoginDevice', 'PreferredPaymentMode', 'Gender', 'PreferedOrderCat', 'MaritalStatus']
data_encoded = pd.get_dummies(data, columns=categorical_columns)

data_encoded.head(20)

data_encoded.head()

# Calcul de la corrélation des variables avec la variable cible 'Churn'
correlation_with_churn = data_encoded.corr()['Churn'].sort_values()

# Création d'un graphique en barres pour visualiser ces corrélations
plt.figure(figsize=(8, 12))
sns.barplot(x=correlation_with_churn.values, y=correlation_with_churn.index, palette='viridis')
plt.title('Corrélation avec Churn')
plt.xlabel('Coefficient de Corrélation')
plt.ylabel('Variables')
plt.show()

# Normalisation des données pour le test de Chi-carré
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Calcul des scores Chi-carré
chi_scores = chi2(X_scaled, y)
chi2_importance = pd.Series(chi_scores[0], index=X.columns).sort_values(ascending=False)

# Visualisation de l'importance des variables avec un graphique en barres
plt.figure(figsize=(8, 12))
sns.barplot(x=chi2_importance.values, y=chi2_importance.index, palette='viridis')
plt.title('Importance des variables (Test de Chi-carré)')
plt.xlabel('Score Chi-carré')
plt.ylabel('Variables')
plt.show()

# Variables à supprimer basées sur les résultats des analyses
columns_to_drop = ['PreferredLoginDevice_Phone', 'PreferredPaymentMode_Cash on Delivery', 'CouponUsed', 
                    'PreferredPaymentMode_Credit Card', 'MaritalStatus_Divorced', 
                   'OrderCount', 'WarehouseToHome', 'PreferredPaymentMode_Debit Card', 'OrderAmountHikeFromlastYear', 
                   'PreferredPaymentMode_UPI', 'PreferredLoginDevice_Mobile Phone', 
                   'PreferredLoginDevice_Computer', 'Gender_Male', 'Gender_Female']

# Suppression des colonnes du DataFrame
data_reduced = data_encoded.drop(columns=columns_to_drop)

# Affichage des premières lignes du DataFrame réduit
data_reduced.head()

# Entraînement du modèle de régression logistique
logreg = LogisticRegression()
logreg.fit(X_train, y_train)

# Prédictions et évaluation
y_pred_logreg = logreg.predict(X_test)
print("Régression Logistique:")
print(confusion_matrix(y_test, y_pred_logreg))
print(classification_report(y_test, y_pred_logreg))

# Entraînement du modèle de forêt aléatoire
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Prédictions et évaluation
y_pred_rf = rf.predict(X_test)
print("Forêt Aléatoire:")
print(confusion_matrix(y_test, y_pred_rf))
print(classification_report(y_test, y_pred_rf))

# Entraînement du modèle XGBoost
xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42)
xgb_model.fit(X_train, y_train)

# Prédictions et évaluation
y_pred_xgb = xgb_model.predict(X_test)
print("XGBoost:")
print(confusion_matrix(y_test, y_pred_xgb))
print(classification_report(y_test, y_pred_xgb))

svm_model = SVC(kernel='linear', random_state=42)
svm_model.fit(X_train, y_train) 
y_pred_svm = svm_model.predict(X_test)

# Affichage des résultats
print("SVM:")
print(confusion_matrix(y_test, y_pred_svm))
print(classification_report(y_test, y_pred_svm))

all_models = pd.DataFrame({
    'Train_Accuracy': train_acc_list,
    'Test_Accuracy': test_acc_list
}, index=list_name)
all_models

def create_train_accuracy_figure():
    fig = go.Figure()
    fig.add_trace(go.Bar(
        x=all_models['Train_Accuracy'],
        y=all_models.index,
        text=all_models['Train_Accuracy'],
        textposition='auto',
        marker=dict(
            color=all_models['Train_Accuracy'],
            colorscale='Viridis',
            colorbar=dict(title='Train Accuracy'),
        ),
        orientation='h',
    ))
    fig.update_layout(
        title='Models vs Train Accuracy',
        xaxis_title='Train Accuracy',
        yaxis_title='Model Names',
        template='plotly',
        title_font_size=20,
        title_font_color='black',
        hoverlabel_font_size=15,
        legend_title='<b>Train Accuracy</b>',
        legend=dict(
            title_font_size=15,
            font=dict(size=12),
        ),
    )
    return fig

def create_test_accuracy_figure():
    fig = go.Figure()
    fig.add_trace(go.Bar(
        x=all_models['Test_Accuracy'],
        y=all_models.index,
        text=all_models['Test_Accuracy'],
        textposition='auto',
        marker=dict(
            color=all_models['Test_Accuracy'],
            colorscale='Viridis',
            colorbar=dict(title='Test Accuracy'),
        ),
        orientation='h',
    ))
    fig.update_layout(
        title='Models vs Test Accuracy',
        xaxis_title='Test Accuracy',
        yaxis_title='Model Names',
        template='plotly',
        title_font_size=20,
        title_font_color='black',
        hoverlabel_font_size=15,
        legend_title='<b>Test Accuracy</b>',
        legend=dict(
            title_font_size=15,
            font=dict(size=12),
        ),
    )
    return fig

def create_roc_curve_figure():
    fig = go.Figure()

    # Logistic Regression
    fpr_logreg, tpr_logreg, _ = roc_curve(y_test, y_score_logreg)
    roc_auc_logreg = auc(fpr_logreg, tpr_logreg)
    fig.add_trace(go.Scatter(
        x=fpr_logreg,
        y=tpr_logreg,
        mode='lines',
        name=f'Logistic Regression (AUC = {roc_auc_logreg:.3f})',
        line=dict(color='rgba(50, 171, 96, 1)', width=2)
    ))

    # Random Forest
    fpr_rf, tpr_rf, _ = roc_curve(y_test, y_score_rf)
    roc_auc_rf = auc(fpr_rf, tpr_rf)
    fig.add_trace(go.Scatter(
        x=fpr_rf,
        y=tpr_rf,
        mode='lines',
        name=f'Random Forest (AUC = {roc_auc_rf:.3f})',
        line=dict(color='rgba(128, 0, 128, 1)', width=2)
    ))

    # XGBoost
    fpr_xgb, tpr_xgb, _ = roc_curve(y_test, y_score_xgb)
    roc_auc_xgb = auc(fpr_xgb, tpr_xgb)
    fig.add_trace(go.Scatter(
        x=fpr_xgb,
        y=tpr_xgb,
        mode='lines',
        name=f'XGBoost (AUC = {roc_auc_xgb:.3f})',
        line=dict(color='rgba(255, 140, 0, 1)', width=2)
    ))

    fig.update_layout(
        title='ROC Curves of Models',
        xaxis_title='False Positive Rate (FPR)',
        yaxis_title='True Positive Rate (TPR)',
        template='plotly',
        title_font_size=20,
        title_font_color='black',
        hoverlabel_font_size=15,
        legend=dict(
            title='Models',
            title_font_size=15,
            font=dict(size=12, color='black'),
        ),
    )
    return fig

def create_download_link(fig):
    buffer = io.StringIO()
    fig.write_html(buffer)
    html_bytes = buffer.getvalue().encode()
    encoded = b64encode(html_bytes).decode()
    return encoded

def create_dash_app(fig, encoded, filename, port):
    app = Dash(__name__)
    app.layout = html.Div([
        html.P("↓↓↓ try downloading the plot as HTML ↓↓↓", style={"text-align": "right", "font-weight": "bold"}),
        dcc.Graph(id="graph", figure=fig),
        html.A(
            html.Button("Download as HTML"), 
            id="download",
            href="data:text/html;base64," + encoded,
            download=filename
        )
    ])
    threading.Thread(target=app.run_server, kwargs={'debug': True, 'port': port}).start()

if __name__ == '__main__':
    # Create and run the train accuracy Dash app
    train_fig = create_train_accuracy_figure()
    train_encoded = create_download_link(train_fig)
    create_dash_app(train_fig, train_encoded, "train_plotly_graph.html", port=8050)

    # Create and run the test accuracy Dash app
    test_fig = create_test_accuracy_figure()
    test_encoded = create_download_link(test_fig)
    create_dash_app(test_fig, test_encoded, "test_plotly_graph.html", port=8051)

    # Create and run the ROC curve Dash app
    roc_fig = create_roc_curve_figure()
    roc_encoded = create_download_link(roc_fig)
    create_dash_app(roc_fig, roc_encoded, "roc_plotly_graph.html", port=8052)