Exemplo de classificador de árvore de decisão para prever a rotatividade de clientes

Visão geral

Este projeto demonstra como prever a rotatividade de clientes (se um cliente deixa um serviço) usando um classificador de árvore de decisão. O conjunto de dados inclui recursos como AGE , cobranças mensais e chamadas de atendimento ao cliente , com o objetivo de prever se um cliente agitará ou não.

O modelo é treinado usando o classificador de árvore de decisão do Scikit-Learn, e o código visualiza a árvore de decisão para entender melhor como o modelo está tomando decisões.

---

Tecnologias usadas

• python 3.x : idioma primário usado para criar o modelo.
• pandas : para manipulação de dados e manuseio de dados.
• matplotlib : para visualização de dados (plotando a árvore de decisão).
• scikit-learn : para aprendizado de máquina, incluindo treinamento e avaliação de modelo.

---

Etapas explicadas

1.

importar bibliotecas necessárias

Importar pandas como PD importar matplotlib.pyplot como pLT alertas de importação de sklearn.model_selection importar trem_test_split De Sklearn.tree importar DecisionAclassifier de Sklearn.Metrics Importar Precuracy_Score da árvore de importação de Sklearn

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):

  Isso é usado para manipulação de dados e carregar dados no formato de quadro de dados. DataFrames permitem que você organize e manipule dados estruturados, como tabelas (linhas e colunas).

• matplotlib (plt):

  Esta é uma biblioteca de plotagem usada para visualizar dados. Aqui, é usado para plotar a árvore de decisão graficamente, o que ajuda a entender como as decisões são tomadas em cada nó da árvore.

• avisos (avisos):

  O módulo de avisos é usado para suprimir ou lidar com avisos. Neste código, estamos ignorando avisos desnecessários para manter a saída limpa e legível.

• scikit-learn bibliotecas:

  • TRAIN_TEST_SPLIT : Esta função divide o conjunto de dados em subconjuntos de treinamento e teste. Os dados de treinamento são usados ​​para ajustar o modelo e os dados de teste são usados ​​para avaliar seu desempenho.
  • DecisionTreeClassifier : Este é o modelo que será usado para classificar os dados e prever a rotatividade do cliente. As árvores de decisão funcionam criando um modelo de decisões semelhantes a árvores com base nos recursos.
  • precuracy_score : Esta função calcula a precisão do modelo comparando os valores previstos com os valores reais da variável de destino (Churn).
  • árvore : Este módulo inclui funções para visualizar a árvore de decisão assim que for treinada.

2.

suprimindo avisos

Warnings.filterwarnings ("ignorar")

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

Esta linha informa Python para
• ignorar todos os avisos . Pode ser útil quando você está executando modelos e não deseja avisos (como os sobre funções depreciados) para desordem a saída.

3.

criando um conjunto de dados sintético

data = { 'CustomerId': Range (1, 101), # ID exclusivo para cada cliente 'Idade': [20, 25, 30, 35, 40, 45, 50, 55, 60, 65]*10, # idade dos clientes 'MonthlyCharge': [50, 60, 70, 80, 90, 100, 110, 120, 130, 140]*10, # Valor mensal da fatura 'CustomerServiceCalls': [1, 2, 3, 4, 0, 1, 2, 3, 4, 0]*10, # Número de chamadas de atendimento ao cliente 'Agitação': ['não', 'não', 'sim', 'não', 'sim', 'não', 'sim', 'sim', 'não', 'sim']*10 # status de rotatividade } df = pd.dataframe (dados) Imprimir (df.head ())

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

• aqui, criamos um conjunto de dados sintéticos

  para o projeto. Esse conjunto de dados simula as informações do cliente para uma empresa de telecomunicações, com recursos como idade, carcaça mensal, consumidores de serviços e a variável de destino (se o cliente agitou ou não).

  CustomerId
  • : identificador exclusivo para cada cliente.
  Age
  • : idade do cliente.
  MonthlyCharge
  • : fatura mensal do cliente. CustomerViceCalls
  : o número de vezes que um cliente chamou de atendimento ao cliente.
  • churn
  : se o cliente agitou (sim/não).
pandas dataframe
• : os dados são estruturados como um dataframe (df), uma estrutura de dados marcada bidimensional, permitindo manipulação e análise fácil de dados.
  4.
dividindo os dados em recursos e variável de destino

x = df [['Age', 'MonthlyCharge', 'CustomerViceCalls']] # Recursos y = df ['rotatividade'] # Variável de destino

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

Recursos (x)

: as variáveis ​​independentes usadas para prever o destino. Nesse caso, inclui idade, mensal, e CustomerviceCalls.
• Variável de destino (y)
: a variável dependente, que é o valor que você está tentando prever. Aqui, é a coluna de rotatividade, que indica se um cliente agitará ou não.
• 5.
dividindo os dados em conjuntos de treinamento e teste

x_train, x_test, y_train, y_test = trens_test_split (x, y, test_size = 0.3, random_state = 42)

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

TRANHO_TEST_SPLIT

divide o conjunto de dados em duas partes: A
• Conjunto de treinamento (usado para treinar o modelo) e um conjunto de testes test_size = 0.3 : 30% dos dados são reservados para teste e os 70% restantes são usados ​​para treinamento.
  • random_state = 42 garante a reprodutibilidade dos resultados corrigindo a semente para o gerador de números aleatórios.
  6.
  Treinando o modelo da árvore de decisão

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

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

inicializa o modelo da árvore de decisão.

• clf.fit (x_train, y_train) treina o modelo usando os dados de treinamento. O modelo aprende padrões dos recursos x_train para prever a variável de destino y_train.
• 7. fazendo previsões

y_pred = clf.predict (x_test)

y_pred = clf.predict(X_test)

: Depois que o modelo for treinado, ele é usado para fazer previsões no conjunto de testes (x_test). Esses valores previstos são armazenados em y_pred, e nós os compararemos com os valores reais (y_test) para avaliar o modelo.

• 8. avaliando o modelo

precisão = precisão_score (y_test, y_pred) print (f "Precisão: {precisão}")

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

calcula a precisão do modelo comparando os rótulos previstos de rotatividade (y_pred) com os rótulos reais de rotatividade (y_test) do teste.

• A precisão é uma medida de quantas previsões estavam corretas. É impresso para avaliação.
• 9. visualizando a árvore de decisão

plt.figure (figSize = (12, 8)) TREE.PLOT_TREE (CLF, preenchido = true, feste_names = ['Age', 'MonthlyCharge', 'CustomerViceCalls'], Class_Names = ['No Churn', 'Churn']))) plt.show ()

árvore.plot_tree (clf, preenchido = true)

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

• Feecher_Names : Especifica os nomes dos recursos (variáveis ​​independentes) para exibir na árvore.
• class_names : especifica os rótulos da classe para a variável de destino (churn).
• plt.show () : exibe a visualização da árvore.
• Executando o código

clone o repositório ou faça o download do script.

---

Instale dependências:

1. Instale os pandas matplotlib scikit-learn
Execute o script python ou o notebook Jupyter para treinar o modelo e visualizar a árvore de decisão.

   pip install pandas matplotlib scikit-learn