Exemple de classificateur d'arbre de décision pour prédire le désabonnement du client

Aperçu

Ce projet montre comment prédire le désabonnement du client (si un client quitte un service) à l'aide d'un classificateur d'arbre de décision. L'ensemble de données comprend des fonctionnalités comme Âge , Frais mensuels , et appels de service client , dans le but de prédire si un client se transformera ou non.

Le modèle est formé à l'aide du classificateur d'arbre de décision de Scikit-Learn, et le code visualise l'arborescence de décision pour mieux comprendre comment le modèle prend des décisions.

Technologies utilisées

• python 3.x : langue principale utilisée pour construire le modèle.
• pandas : pour la manipulation des données et la gestion des ensembles de données.
• matplotlib : pour la visualisation des données (tracer l'arborescence de décision).
• scikit-learn : pour l'apprentissage automatique, y compris la formation et l'évaluation du modèle.

Étapes expliquées

1. Importer les bibliothèques nécessaires

import pandas as pd
import matplotlib.pyplot as plt
import warnings
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn import tree

• pandas (pd):

  • Ceci est utilisé pour la manipulation des données et le chargement des données au format DataFrame. DataFrames vous permet d'organiser et de manipuler des données structurées comme des tables (lignes et colonnes).

• matplotlib (plt):

  • Il s'agit d'une bibliothèque de traçage utilisée pour visualiser les données. Ici, il est utilisé pour tracer l'arbre de décision graphiquement, ce qui aide à comprendre comment les décisions sont prises à chaque nœud de l'arbre.

• avertissements (avertissements):

  • Le module d'avertissements est utilisé pour supprimer ou gérer les avertissements. Dans ce code, nous ignorons les avertissements inutiles pour garder la sortie propre et lisible.

• bibliothèques Scikit-Learn :

  • Train_test_split : Cette fonction divise l'ensemble de données en sous-ensembles de formation et de test. Les données de formation sont utilisées pour ajuster le modèle, et le test des données est utilisé pour évaluer ses performances.
  • DecisionTreEClassifier : Il s'agit du modèle qui sera utilisé pour classer les données et prédire le désabonnement du client. Les arbres de décision fonctionnent en créant un modèle de décisions en forme d'arbre basé sur les fonctionnalités.
  • précision_score : Cette fonction calcule la précision du modèle en comparant les valeurs prédites avec les valeurs réelles de la variable cible (Churn).
  • arbre : Ce module comprend des fonctions pour visualiser l'arborescence de décision une fois qu'il est formé.

2. supprimer les avertissements

warnings.filterwarnings("ignore")

• Cette ligne indique à Python à ignorer tous les avertissements . Il peut être utile lorsque vous exécutez des modèles et que vous ne voulez pas d'avertissements (tels que ceux des fonctions obsolètes) pour encombrer la sortie.

3. Création d'un ensemble de données synthétique

data = {
    'CustomerID': range(1, 101),  # Unique ID for each customer
    'Age': [20, 25, 30, 35, 40, 45, 50, 55, 60, 65]*10,  # Age of customers
    'MonthlyCharge': [50, 60, 70, 80, 90, 100, 110, 120, 130, 140]*10,  # Monthly bill amount
    'CustomerServiceCalls': [1, 2, 3, 4, 0, 1, 2, 3, 4, 0]*10,  # Number of customer service calls
    'Churn': ['No', 'No', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'No', 'Yes']*10  # Churn status
}

df = pd.DataFrame(data)
print(df.head())

• Ici, nous créons un ensemble de données synthétique pour le projet. Cet ensemble de données simule les informations clients pour une entreprise de télécommunications, avec des fonctionnalités telles que l'âge, le mois de la carrosserie, le service de clients et le désabonnement de la variable cible (que le client soit acheminé ou non).

  • CustomerId : identifiant unique pour chaque client.
  • Âge : l'âge du client.
  • MonthlyCHACK : facture mensuelle du client.
  • CustomerServiceCalls : le nombre de fois un client appelé service client.
  • churn : si le client a été tourné (oui / non).

• pandas dataframe : les données sont structurées comme un dataframe (df), une structure de données étiquetée en 2 dimensions, permettant une manipulation et une analyse faciles des données.

4. Diviser les données en fonctionnalités et variable cible

X = df[['Age', 'MonthlyCharge', 'CustomerServiceCalls']]  # Features
y = df['Churn']  # Target Variable

• fonctionnalités (x) : les variables indépendantes qui sont utilisées pour prédire la cible. Dans ce cas, il inclut l'âge, le mois mensuel et le service de clients.
• Variable cible (y) : la variable dépendante, qui est la valeur que vous essayez de prédire. Ici, c'est la colonne de désabonnement, qui indique si un client se déroulera ou non.

5. Diviser les données en ensembles de formation et de test

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

• Train_test_split divise l'ensemble de données en deux parties: un ensemble de formation (utilisé pour former le modèle) et un ensemble de tests (utilisé pour évaluer le modèle).
  • test_size = 0.3 : 30% des données sont réservées pour les tests, et les 70% restants sont utilisés pour la formation.
  • random_state = 42 assure la reproductibilité des résultats en fixant la graine du générateur de nombres aléatoires.

6. Formation du modèle d'arbre de décision

clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)

• DecisionTreEClassifier () Initialise le modèle d'arbre de décision.
• clf.fit (x_train, y_train) forme le modèle à l'aide des données de formation. Le modèle apprend les modèles des fonctionnalités X_Train pour prédire la variable cible Y_Train.

7. faire des prédictions

y_pred = clf.predict(X_test)

• clf.predict (x_test) : Une fois le modèle formé, il est utilisé pour faire des prédictions sur le jeu de test (x_test). Ces valeurs prévues sont stockées dans y_pred, et nous les comparerons avec les valeurs réelles (y_test) pour évaluer le modèle.

8. évaluer le modèle

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy}")

• précision_score (y_test, y_pred) calcule la précision du modèle en comparant les étiquettes de churn prévues (y_pred) avec les étiquettes de churn réelles (y_test) de l'ensemble de test.
• La précision est une mesure du nombre de prédictions correctes. Il est imprimé pour évaluation.

9. Visualiser l'arbre de décision

plt.figure(figsize=(12, 8))
tree.plot_tree(clf, filled=True, feature_names=['Age', 'MonthlyCharge', 'CustomerServiceCalls'], class_names=['no churn', 'churn'])
plt.show()

• arbre.plot_tree (clf, rempli = true) : visualise le modèle d'arbre de décision formé. L'argument FOLM = True colore les nœuds en fonction de l'étiquette de classe (Churn / No Churn).
• fonctionnalités_names : spécifie les noms des fonctionnalités (variables indépendantes) à afficher dans l'arborescence.
• class_names : spécifie les étiquettes de classe pour la variable cible (Churn).
• plt.show () : affiche la visualisation de l'arborescence.

Exécution du code

1. cloner le référentiel ou télécharger le script.
2. Installez les dépendances:

   pip install pandas matplotlib scikit-learn

1. Exécutez le script Python ou le cahier Jupyter pour former le modèle et visualiser l'arborescence de décision.