关于数据挖掘:Python中用PyTorch机器学习神经网络分类预测银行客户流失模型附代码数据

6次阅读

共计 9437 个字符，预计需要花费 24 分钟才能阅读完成。

最近咱们被客户要求撰写对于神经网络的钻研报告，包含一些图形和统计输入。

分类问题属于机器学习问题的类别，其中给定一组特色，工作是预测离散值。分类问题的一些常见示例是，预测肿瘤是否为癌症，或者学生是否可能通过考试

在本文中，鉴于银行客户的某些特色，咱们将预测客户在 6 个月后是否可能来到银行。客户来到组织的景象也称为客户散失。因而，咱们的工作是依据各种客户特色预测客户散失。

$ pip install pytorch

让咱们将所需的库和数据集导入到咱们的 Python 应用程序中：

import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

咱们能够应用 pandas 库的 read_csv() 办法来导入蕴含咱们的数据集的 CSV 文件。

dataset = pd.read_csv(r'E:Datasetscustomer_data.csv')

让咱们输入数据集：

dataset.shape

输入：

(10000, 14)

输入显示该数据集具备 1 万条记录和 14 列。咱们能够应用 head() 数据框的办法来输入数据集的前五行。

dataset.head()

输入：

您能够在咱们的数据集中看到 14 列。依据前 13 列，咱们的工作是预测第 14 列的值，即Exited。

让咱们对数据集进行一些探索性数据分析。咱们将首先预测 6 个月后理论来到银行并应用饼图进行可视化的客户比例。让咱们首先减少图形的默认绘图大小：

 fig_size = plt.rcParams["figure.figsize"]
fig_size[0] = 10
fig_size[1] = 8
plt.rcParams["figure.figsize"] = fig_size

以下脚本绘制该 Exited 列的饼图。

dataset.Exited.value_counts().plot(kind='pie', autopct='%1.0f%%', colors=['skyblue', 'orange'], explode=(0.05, 0.05))

输入：

输入显示，在咱们的数据集中，有 20%的客户来到了银行。这里 1 代表客户来到银行的状况，0 代表客户没有来到银行的状况。让咱们绘制数据集中所有地理位置的客户数量：

输入显示，简直一半的客户来自法国，而西班牙和德国的客户比例别离为 25%。

点击题目查阅往期内容

用 R 语言实现神经网络预测股票实例

左右滑动查看更多

01

02

03

04

当初，让咱们绘制来自每个惟一地理位置的客户数量以及客户散失信息。咱们能够应用库中的 countplot() 函数 seaborn 来执行此操作。

输入显示，只管法国客户总数是西班牙和德国客户总数的两倍，但法国和德国客户来到银行的客户比例是雷同的。同样，德国和西班牙客户的总数雷同，然而来到银行的德国客户数量是西班牙客户的两倍，这表明德国客户在 6 个月后来到银行的可能性更大。

在训练 PyTorch 模型之前，咱们须要预处理数据。如果查看数据集，您将看到它具备两种类型的列：数值列和分类列。数字列蕴含数字信息。CreditScore，Balance，Age等。相似地，Geography和 Gender 是分类列，因为它们含有分类信息，如客户的地位和性别。有几列能够视为数字列和类别列。例如，该 HasCrCard 列的值能够为 1 或 0。然而，那 HasCrCard 列蕴含无关客户是否领有信用卡的信息。

让咱们再次输入数据集中的所有列，并找出哪些列能够视为数字列，哪些列应该视为类别列。columns数据框的属性显示所有列名称：

Index(['RowNumber', 'CustomerId', 'Surname', 'CreditScore', 'Geography', 'Gender', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'HasCrCard', 'IsActiveMember', 'EstimatedSalary', 'Exited'], dtype='object')

从咱们的数据列，咱们将不应用的 RowNumber，CustomerId 以及 Surname 列，因为这些列的值是齐全随机的，并与输入无关。例如，客户的姓氏对客户是否来到银行没有影响。其中列的其余部分，Geography，Gender，HasCrCard，和 IsActiveMember 列能够被视为类别列。让咱们创立这些列的列表：除该列外，其余所有列均可视为数字列。

numerical_columns = ['CreditScore', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'EstimatedSalary']

最初，输入（Exited列中的值）存储在 outputs 变量中。

咱们曾经创立了分类，数字和输入列的列表。然而，目前，分类列的类型不是分类的。您能够应用以下脚本检查数据集中所有列的类型：
输入：

 RowNumber            int64
CustomerId           int64
Surname             object
CreditScore          int64
Geography           object
Gender              object
Age                  int64
Tenure               int64
Balance            float64
NumOfProducts        int64
HasCrCard            int64
IsActiveMember       int64
EstimatedSalary    float64
Exited               int64
dtype: object

您能够看到 Geography 和Gender列的类型是 object，HasCrCard和 IsActive 列的类型是 int64。咱们须要将分类列的类型转换为 category。咱们能够应用astype() 函数来做到这一点，

当初，如果再次绘制数据集中各列的类型，您将看到以下后果：

输出量

 RowNumber             int64
CustomerId            int64
Surname              object
CreditScore           int64
Geography          category
Gender             category
Age                   int64
Tenure                int64
Balance             float64
NumOfProducts         int64
HasCrCard          category
IsActiveMember     category
EstimatedSalary     float64
Exited                int64
dtype: object

当初让咱们查看 Geography 列中的所有类别：

Index(['France', 'Germany', 'Spain'], dtype='object')

当您将列的数据类型更改为类别时，该列中的每个类别都会调配一个惟一的代码。例如，让咱们绘制列的前五行，Geography并输入前五行的代码值：

输入：

 0    France
1     Spain
2    France
3    France
4     Spain
Name: Geography, dtype: category
Categories (3, object): [France, Germany, Spain]

以下脚本在该列的前五行中绘制了值的代码Geography：

输入：

 0    0
1    2
2    0
3    0
4    2
dtype: int8

输入显示法国已编码为 0，西班牙已编码为 2。

将分类列与数字列离开的根本目标是，能够将数字列中的值间接输出到神经网络中。然而，必须首先将类别列的值转换为数字类型。分类列中的值的编码局部地解决了分类列的数值转换的工作。

因为咱们将应用 PyTorch 进行模型训练，因而须要将分类列和数值列转换为张量。首先让咱们将分类列转换为张量。在 PyTorch 中，能够通过 numpy 数组创立张量。咱们将首先将四个分类列中的数据转换为 numpy 数组，而后将所有列程度重叠，如以下脚本所示：

 geo = dataset['Geography'].cat.codes.values
...

下面的脚本输入分类列中前十条记录。输入如下：输入：

 array([[0, 0, 1, 1],
       [2, 0, 0, 1],
       [0, 0, 1, 0],
       [0, 0, 0, 0],
       [2, 0, 1, 1],
       [2, 1, 1, 0],
       [0, 1, 1, 1],
       [1, 0, 1, 0],
       [0, 1, 0, 1],
       [0, 1, 1, 1]], dtype=int8)

当初要从上述 numpy 数组创立张量，您只需将数组传递给模块的 tensor 类torch。

输入：

 tensor([[0, 0, 1, 1],
        [2, 0, 0, 1],
        [0, 0, 1, 0],
        [0, 0, 0, 0],
        [2, 0, 1, 1],
        [2, 1, 1, 0],
        [0, 1, 1, 1],
        [1, 0, 1, 0],
        [0, 1, 0, 1],
        [0, 1, 1, 1]])

在输入中，您能够看到类别数据的 numpy 数组当初已转换为 tensor 对象。同样，咱们能够将数值列转换为张量：

 numerical_data = np.stack([dataset[col].values for col in numerical_columns], 1)
...

输入：

 tensor([[6.1900e+02, 4.2000e+01, 2.0000e+00, 0.0000e+00, 1.0000e+00, 1.0135e+05],
        [6.0800e+02, 4.1000e+01, 1.0000e+00, 8.3808e+04, 1.0000e+00, 1.1254e+05],
        [5.0200e+02, 4.2000e+01, 8.0000e+00, 1.5966e+05, 3.0000e+00, 1.1393e+05],
        [6.9900e+02, 3.9000e+01, 1.0000e+00, 0.0000e+00, 2.0000e+00, 9.3827e+04],
        [8.5000e+02, 4.3000e+01, 2.0000e+00, 1.2551e+05, 1.0000e+00, 7.9084e+04]])

在输入中，您能够看到前五行，其中蕴含咱们数据集中六个数字列的值。最初一步是将输入的 numpy 数组转换为 tensor 对象。输入：

tensor([1, 0, 1, 0, 0])

当初，让咱们绘制分类数据，数值数据和相应输入的形态：输入：

 torch.Size([10000, 4])
torch.Size([10000, 6])
torch.Size([10000])

在训练模型之前，有一个十分重要的步骤。咱们将分类列转换为数值，其中惟一值由单个整数示意。例如，在该 Geography 列中，咱们看到法国用 0 示意，德国用 1 示意。咱们能够应用这些值来训练咱们的模型。然而，更好的办法是以 N 维向量的模式示意分类列中的值，而不是单个整数。

咱们须要为所有分类列定义矢量大小。对于维数没有严格的规定。定义列的嵌入大小的一个好的教训法令是将列中惟一值的数量除以 2（但不超过 50）。例如，对于该 Geography 列，惟一值的数量为 3。该 Geography 列的相应嵌入大小将为 3 /2 = 1.5 = 2（四舍五入）。以下脚本创立一个元组，其中蕴含所有类别列的惟一值数量和维度大小：

 categorical_column_sizes = [len(dataset[column].cat.categories) for column in categorical_columns]
...

输入：

[(3, 2), (2, 1), (2, 1), (2, 1)]

应用训练数据对监督型深度学习模型（例如咱们在本文中开发的模型）进行训练，并在测试数据集上评估模型的性能。因而，咱们须要将数据集分为训练集和测试集，如以下脚本所示：

 total_records = 10000
....

咱们的数据集中有 1 万条记录，其中 80%的记录（即 8000 条记录）将用于训练模型，而其余 20%的记录将用于评估模型的性能。留神，在下面的脚本中，分类和数字数据以及输入已分为训练集和测试集。为了验证咱们已正确地将数据分为训练和测试集：

 print(len(categorical_train_data))
print(len(numerical_train_data))
print(len(train_outputs))

print(len(categorical_test_data))
print(len(numerical_test_data))
print(len(test_outputs))

输入：

咱们将数据分为训练集和测试集，当初是时候定义训练模型了。为此，咱们能够定义一个名为的类Model，该类将用于训练模型。看上面的脚本：

 class Model(nn.Module):

    def __init__(self, embedding_size, num_numerical_cols, output_size, layers, p=0.4):
        super().__init__()
        self.all_embeddings = nn.ModuleList([nn.Embedding(ni, nf) for ni, nf in embedding_size])
        self.embedding_dropout = nn.Dropout(p)
        self.batch_norm_num = nn.BatchNorm1d(num_numerical_cols)



        return x

接下来，要查找输出层的大小，将类别列和数字列的数量加在一起并存储在 input_size 变量中。之后，for循环迭代，并将相应的层增加到 all_layers 列表中。增加的层是：

Linear：用于计算输出和权重矩阵之间的点积
ReLu：用作激活函数
BatchNorm1d：用于对数字列利用批量归一化
Dropout：用于防止过拟合

在后 for 循环中，输入层被附加到的层的列表。因为咱们心愿神经网络中的所有层都按程序执行，因而将层列表传递给 nn.Sequential 该类。

接下来，在该 forward 办法中，将类别列和数字列都作为输出传递。类别列的嵌入在以下几行中进行。

–
–

embeddings = []

数字列的批量归一化可通过以下脚本利用：

“

–

x_numerical = self.batch_norm_num(x_numerical)

最初，将嵌入的分类列 x 和数字列 x_numerical 连贯在一起，并传递给 sequence layers。

要训练模型，首先咱们必须创立 Model 在上一节中定义的类的对象。

您能够看到咱们传递了分类列的嵌入大小，数字列的数量，输入大小（在咱们的例子中为 2）以及暗藏层中的神经元。您能够看到咱们有三个别离具备 200、100 和 50 个神经元的暗藏层。
让咱们输入模型并查看：

print(model)

输入：

 Model((all_embeddings): ModuleList(...)
)

您能够看到，在第一线性层中，in_features变量的值为 11，因为咱们有 6 个数字列，并且类别列的嵌入维数之和为 5，因而 6 + 5 = 11。out_features的值为 2，因为咱们只有 2 个可能的输入。

在理论训练模型之前，咱们须要定义损失函数和将用于训练模型的优化器。以下脚本定义了损失函数和优化器：

loss_function = nn.CrossEntropyLoss()

当初，咱们训练模型。以下脚本训练模型：

 epochs = 300
aggregated_losses = []

for i in range(epochs):


print(f'epoch: {i:3} loss: {single_loss.item():10.10f}')

神经元元数设置为 300，这意味着要训练模型，残缺的数据集将应用 300 次。for为每次迭代期间循环的执行形式，损失是应用损耗函数来计算。每次迭代过程中的损失将增加到 aggregated_loss 列表中。

下面脚本的输入如下：

epoch: 1 loss: 0.71847951epoch: 26 loss: 0.57145703epoch: 51 loss: 0.48110831epoch: 76 loss: 0.42529839epoch: 101 loss: 0.39972275epoch: 126 loss: 0.37837571epoch: 151 loss: 0.37133673epoch: 176 loss: 0.36773482epoch: 201 loss: 0.36305946epoch: 226 loss: 0.36079505epoch: 251 loss: 0.35350436epoch: 276 loss: 0.35540250epoch: 300 loss: 0.3465710580

以下脚本绘制了各个期间的损失函数：

–
–
–

plt.plot(range(epochs), aggregated_losses)plt.ylabel('Loss')plt.xlabel('epoch');`

输入：

输入显示，最后损失函数迅速升高。在 250 个步长之后，损失简直没有缩小。

最初一步是对测试数据进行预测。为此，咱们只须要将 categorical_test_data 和numerical_test_data传递给 model 该类。而后能够将返回的值与理论测试输入值进行比拟。以下脚本对测试类进行预测，并输入测试数据的穿插熵损失。

 with torch.no_grad():

输入：

Loss: 0.36855841

测试集上的损失为 0.3685，比训练集上取得的 0.3465 略多，这表明咱们的模型有些过拟合。因为咱们指定输入层将蕴含 2 个神经元，因而每个预测将蕴含 2 个值。例如，前 5 个预测值如下所示：

print(y_val[:5])

输入：

 tensor([[1.2045, -1.3857],
        [1.3911, -1.5957],
        [1.2781, -1.3598],
        [0.6261, -0.5429],
        [2.5430, -1.9991]])

这种预测的思维是，如果理论输入为 0，则索引 0 处的值应大于索引 1 处的值，反之亦然。咱们能够应用以下脚本检索列表中最大值的索引：

y_val = np.argmax(y_val, axis=1)

输入：当初让咱们再次输入 y_val 列表的前五个值：

print(y_val[:5])

输入：

tensor([0, 0, 0, 0, 0])

因为在最后预测的输入列表中，对于前五个记录，零索引处的值大于第一索引处的值，因而能够在已解决输入的前五行中看到 0。

最初，咱们能够应用从 sklearn.metrics 模块 confusion_matrix，accuracy_score 以及 classification_report 类找到了准确度，精密度和召回值，混同矩阵。

`from sklearn.metrics import classification_report, confusion_matrix, accuracy_scoreprint(confusion_matrix(test_outputs,y_val))print(classification_report(test_outputs,y_val))print(accuracy_score(test_outputs, y_val))`

输入：

–
–

[[1527 83][224 166]]

          precision    recall  f1-score   support

       0       0.87      0.95      0.91      1610
       1       0.67      0.43      0.52       390

micro avg 0.85 0.85 0.85 2000macro avg 0.77 0.69 0.71 2000weighted avg 0.83 0.85 0.83 20000.8465`

输入结果表明，咱们的模型达到了 84.65%的精度，思考到咱们随机抉择神经网络模型的所有参数这一事实，这十分令人印象粗浅。我建议您尝试更改模型参数，例如训练 / 测试比例，暗藏层的数量和大小等，以查看是否能够取得更好的后果。

PyTorch 是 Facebook 开发的罕用深度学习库，可用于各种工作，例如分类，回归和聚类。本文介绍了如何应用 PyTorch 库对表格数据进行分类。

点击文末 “浏览原文”

获取全文残缺材料。

本文选自《Python 中用 PyTorch 机器学习神经网络分类预测银行客户散失模型》。

点击题目查阅往期内容

R 语言实现神经网络预测股票实例数据分析可视化
Python 应用神经网络进行简略文本分类
Python TensorFlow 循环神经网络 RNN-LSTM 神经网络预测股票市场价格工夫序列和 MSE 评估准确性
【视频】Python 用 LSTM 长短期记忆神经网络对不稳固降雨量工夫序列进行预测剖析 | 数据分享
数据分享 | R 语言用 Keras 长短期记忆 LSTM 神经网络分类剖析问答文本数据
Python TensorFlow 循环神经网络 RNN-LSTM 神经网络预测股票市场价格工夫序列和 MSE 评估准确性
数据分享 |PYTHON 用 KERAS 的 LSTM 神经网络进行工夫序列预测天然气价格例子
Python 对商店数据进行 lstm 和 xgboost 销售量工夫序列建模预测剖析
Matlab 用深度学习长短期记忆（LSTM）神经网络对文本数据进行分类
RNN 循环神经网络、LSTM 长短期记忆网络实现工夫序列长期利率预测
联合新冠疫情 COVID-19 股票价格预测：ARIMA，KNN 和神经网络工夫序列剖析
深度学习：Keras 应用神经网络进行简略文本分类剖析新闻组数据
用 PyTorch 机器学习神经网络分类预测银行客户散失模型
PYTHON 用 LSTM 长短期记忆神经网络的参数优化办法预测工夫序列洗发水销售数据
Python 用 Keras 神经网络序列模型回归拟合预测、准确度检查和后果可视化
Python 用 LSTM 长短期记忆神经网络对不稳固降雨量工夫序列进行预测剖析
R 语言中的神经网络预测工夫序列：多层感知器（MLP）和极限学习机（ELM）数据分析报告
R 语言深度学习：用 keras 神经网络回归模型预测工夫序列数据
Matlab 用深度学习长短期记忆（LSTM）神经网络对文本数据进行分类
R 语言 KERAS 深度学习 CNN 卷积神经网络分类辨认手写数字图像数据（MNIST）
MATLAB 中用 BP 神经网络预测人体脂肪百分比数据
Python 中用 PyTorch 机器学习神经网络分类预测银行客户散失模型
R 语言实现 CNN（卷积神经网络）模型进行回归数据分析
SAS 应用鸢尾花 (iris) 数据集训练人工神经网络 (ANN) 模型
【视频】R 语言实现 CNN（卷积神经网络）模型进行回归数据分析
Python 应用神经网络进行简略文本分类
R 语言用神经网络改良 Nelson-Siegel 模型拟合收益率曲线剖析
R 语言基于递归神经网络 RNN 的温度工夫序列预测
R 语言神经网络模型预测车辆数量工夫序列
R 语言中的 BP 神经网络模型剖析学生问题
matlab 应用长短期记忆（LSTM）神经网络对序列数据进行分类
R 语言实现拟合神经网络预测和后果可视化
用 R 语言实现神经网络预测股票实例
应用 PYTHON 中 KERAS 的 LSTM 递归神经网络进行工夫序列预测
python 用于 NLP 的 seq2seq 模型实例: 用 Keras 实现神经网络机器翻译
用于 NLP 的 Python：应用 Keras 的多标签文本 LSTM 神经网络分类