如何使用Keras和TensorFlow构建深度学习模型来预测员工保留率

作为 Write for DOnations 计划的一部分，作者选择了 Girls Who Code 来接受捐赠。

介绍

Keras 是一个用 Python 编写的神经网络 API。它运行在 TensorFlow、CNTK 或 Theano 之上。它是这些深度学习框架的高级抽象，因此使实验更快、更容易。 Keras 是模块化的，这意味着实现是无缝的，因为开发人员可以通过添加模块来快速扩展模型。

TensorFlow 是一个用于机器学习的开源软件库。它可以有效地处理涉及数组的计算；因此，对于您将在本教程中构建的模型来说，这是一个不错的选择。此外，TensorFlow 允许在 CPU 或 GPU 上执行代码，这是一个有用的功能，尤其是在您处理海量数据集时。

在本教程中，您将构建一个深度学习模型，该模型将预测员工离开公司的概率。对于大多数组织来说，留住最优秀的员工是一个重要因素。要构建您的模型，您将使用这个可在 Kaggle 上获得的数据集，它具有衡量公司员工满意度的功能。要创建此模型，您将使用 Keras sequential 层为模型构建不同的层。

先决条件

在开始本教程之前，您需要以下内容：

您机器上的 Anaconda 开发环境。
Jupyter Notebook 安装。 Anaconda 将在安装期间为您安装 Jupyter Notebook。您还可以按照本教程获取有关如何导航和使用 Jupyter Notebook 的指南。
熟悉机器学习。

第 1 步——数据预处理

数据预处理 是必要的，以便以深度学习模型可以接受的方式准备数据。如果您的数据中有 分类变量，您必须将它们转换为数字，因为该算法只接受数字。 分类变量 表示由名称表示的量化数据。在此步骤中，您将使用 pandas 加载数据集，这是一个数据操作 Python 库。

在开始数据预处理之前，您将激活您的环境并确保您已将所有必要的软件包安装到您的机器上。使用 conda 安装 keras 和 tensorflow 是有利的，因为它将处理这些软件包的任何必要依赖项的安装，并确保它们与 [X198X 兼容] 和 tensorflow。这样，使用 Anaconda Python 发行版是数据科学相关项目的不错选择。

进入您在先决条件教程中创建的环境：

conda activate my_env

运行以下命令安装 keras 和 tensorflow：

conda install tensorflow keras

现在，打开 Jupyter Notebook 开始使用。通过在终端上键入以下命令打开 Jupyter Notebook：

jupyter notebook

注意： 如果你在远程服务器上工作，你需要使用 SSH 隧道来访问你的笔记本。请重新访问先决条件教程的步骤 2，以获取有关设置 SSH 隧道的详细说明。您可以在本地计算机上使用以下命令来启动 SSH 隧道：

ssh -L 8888:localhost:8888 your_username@your_server_ip

访问 Jupyter Notebook 后，点击 anaconda3 文件，然后点击屏幕顶部的 New，然后选择 Python 3 加载新的 notebook。

现在，您将导入项目所需的模块，然后将数据集加载到笔记本单元格中。您将加载 pandas 模块以操作数据，并加载 numpy 以将数据转换为 numpy 数组。您还将所有字符串格式的列转换为数值，以供您的计算机处理。

将以下代码插入笔记本单元格，然后单击 Run：

import pandas as pd
import numpy as np
df = pd.read_csv("https://raw.githubusercontent.com/mwitiderrick/kerasDO/master/HR_comma_sep.csv")

您已导入 numpy 和 pandas。然后，您使用 pandas 加载模型的数据集。

您可以通过使用 head() 了解正在使用的数据集。这是 pandas 中的一个有用功能，可让您查看数据帧的前五个记录。将以下代码添加到笔记本单元格，然后运行它：

df.head()

您现在将继续将分类列转换为数字。为此，您可以将它们转换为 虚拟变量 。虚拟变量通常是表示存在或不存在分类特征的 1 和 0。在这种情况下，您还可以通过删除第一个虚拟变量来避免 虚拟变量陷阱。

注：虚拟变量陷阱是两个或多个变量高度相关的情况。这会导致您的模型表现不佳。因此，您删除一个虚拟变量以始终保留 N-1 个虚拟变量。可以删除任何虚拟变量，因为只要您保留 N-1 个虚拟变量，就没有偏好。这方面的一个例子是如果你有一个开/关开关。创建虚拟变量时，您将获得两列：on 列和 off 列。您可以删除其中一列，因为如果开关未打开，则它已关闭。

将此代码插入下一个笔记本单元格并执行它：

feats = ['department','salary']
df_final = pd.get_dummies(df,columns=feats,drop_first=True)

feats = ['department','salary'] 定义要为其创建虚拟变量的两列。 pd.get_dummies(df,columns=feats,drop_first=True) 将生成您的员工保留模型所需的数值变量。它通过将您定义的 feats 从分类变量转换为数值变量来实现这一点。

您已加载数据集并将工资和部门列转换为 keras 深度学习模型可以接受的格式。在下一步中，您会将数据集拆分为训练和测试集。

第 2 步——分离训练和测试数据集

您将使用 scikit-learn 将数据集拆分为训练集和测试集。这是必要的，因此您可以使用部分员工数据来训练模型，并使用其中的一部分来测试其性能。在构建深度学习模型时，以这种方式拆分数据集是一种常见做法。

在数据集中实现这种拆分非常重要，这样您构建的模型在训练过程中就无法访问测试数据。这可确保模型仅从训练数据中学习，然后您可以使用测试数据测试其性能。如果您在训练过程中将模型暴露给测试数据，那么它会记住预期的结果。因此，它无法对它没有看到的数据做出准确的预测。

您将首先从 scikit-learn 包中导入 train_test_split 模块。这是将提供拆分功能的模块。将此代码插入下一个笔记本单元格并运行：

from sklearn.model_selection import train_test_split

导入 train_test_split 模块后，您将使用数据集中的 left 列来预测员工是否会离开公司。因此，你的深度学习模型不要接触到这个专栏是很重要的。将以下内容插入单元格以删除 left 列：

X = df_final.drop(['left'],axis=1).values
y = df_final['left'].values

您的深度学习模型期望以数组的形式获取数据。因此，您使用 numpy 将数据转换为具有 .values 属性的 numpy 数组。

您现在已准备好将数据集转换为测试和训练集。您将使用 70% of 数据进行训练和 30% f 或测试。训练比率大于测试比率，因为您需要将大部分数据用于训练过程。如果需要，您还可以使用 80% f 或训练集和 20% f 或测试集的比率进行试验。

现在将此代码添加到下一个单元格并运行以将您的训练和测试数据拆分为指定的比率：

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

您现在已将数据转换为 Keras 期望的类型（numpy 数组），并且您的数据被拆分为训练和测试集。您将在本教程后面将这些数据传递给 keras 模型。事先您需要转换数据，您将在下一步中完成。

第 3 步 — 转换数据

在构建深度学习模型时，通常对数据集进行缩放以提高计算效率是一种很好的做法。在这一步中，您将使用 StandardScaler 缩放数据；这将确保您的数据集值的平均值为零和单位变量。这会将数据集转换为正态分布。您将使用 scikit-learn StandardScaler 将要素缩放到相同范围内。这会将值转换为平均值为 0，标准差为 1。这一步很重要，因为您正在比较具有不同测量值的特征；所以它通常在机器学习中是必需的。

要扩展训练集和测试集，请将此代码添加到笔记本单元并运行它：

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

在这里，您首先导入 StandardScaler 并调用它的实例。然后使用它的 fit_transform 方法来扩展训练和测试集。

您已将所有数据集功能缩放到同一范围内。您可以在下一步开始构建人工神经网络。

第 4 步——构建人工神经网络

现在您将使用 keras 来构建深度学习模型。为此，您将导入 keras，默认情况下将使用 tensorflow 作为后端。然后从 keras 导入 Sequential 模块以初始化 人工神经网络 。 人工神经网络 是一种计算模型，其灵感来自人脑的工作原理。您还将导入 Dense 模块，这将为您的深度学习模型添加层。

在构建深度学习模型时，您通常会指定三种层类型：

输入层 是将数据集的特征传递到的层。在这一层中不发生任何计算。它用于将特征传递给隐藏层。
隐藏层通常是输入层和输出层之间的层——并且可以有多个。这些层执行计算并将信息传递给输出层。
输出层 代表你的神经网络层，它会在训练你的模型后给你结果。它负责产生输出变量。

要导入 Keras、Sequential 和 Dense 模块，请在笔记本单元格中运行以下代码：

import keras
from keras.models import Sequential
from keras.layers import Dense

您将使用 Sequential 来初始化层的线性堆栈。由于这是一个 分类问题，您将创建一个分类器变量。 分类问题 是您已标记数据并希望根据标记数据进行一些预测的任务。将此代码添加到您的笔记本以创建分类器变量：

classifier = Sequential()

您已经使用 Sequential 来初始化分类器。

您现在可以开始向网络添加层。在下一个单元格中运行此代码：

classifier.add(Dense(9, kernel_initializer = "uniform",activation = "relu", input_dim=18))

您使用分类器上的 .add() 函数添加层并指定一些参数：

第一个参数是您的网络应具有的节点数。不同节点之间的连接构成了神经网络。确定节点数的策略之一是取输入层和输出层节点的平均值。
第二个参数是 kernel_initializer. 当您拟合深度学习模型时，权重将被初始化为接近零但不为零的数字。为此，您使用统一分布初始化程序。 kernel_initializer 是初始化权重的函数。
第三个参数是activation函数。您的深度学习模型将通过此功能进行学习。通常有线性和非线性激活函数。您使用 relu 激活函数，因为它可以很好地概括您的数据。线性函数不适用于此类问题，因为它们形成一条直线。
最后一个参数是 input_dim，表示数据集中的特征数量。

现在您将添加将为您提供预测的输出层：

classifier.add(Dense(1, kernel_initializer = "uniform",activation = "sigmoid"))

输出层采用以下参数：

输出节点的数量。你期望得到一个输出：如果员工离开公司。因此，您指定一个输出节点。
对于 kernel_initializer，您使用 sigmoid 激活函数，以便您可以获得员工离开的概率。如果您要处理两个以上的类别，您将使用 softmax 激活函数，它是 sigmoid 激活函数的变体。

接下来，您将对神经网络应用 梯度下降 。这是一种优化策略，用于减少训练过程中的错误。梯度下降是如何通过减少 成本函数 来调整神经网络中随机分配的权重，这是基于预期输出的神经网络性能的衡量标准。

梯度下降的目的是得到误差最小的点。这是通过找到成本函数的最小值来完成的，这被称为 局部最小值 。在梯度下降中，您通过微分找到特定点的斜率，并确定斜率是负数还是正数——您正在下降到成本函数的最小值。有几种类型的优化策略，但在本教程中您将使用一种称为 adam 的流行策略。

将此代码添加到您的笔记本单元并运行它：

classifier.compile(optimizer= "adam",loss = "binary_crossentropy",metrics = ["accuracy"])

应用梯度下降是通过采用以下参数的 compile 函数完成的：

optimizer 是梯度下降。
loss 是您将在梯度下降中使用的函数。由于这是一个二元分类问题，您可以使用 binary_crossentropy loss 函数。
最后一个参数是 metric，您将使用它来评估您的模型。在这种情况下，您希望在进行预测时根据其准确性对其进行评估。

您已准备好将分类器适合您的数据集。 Keras 通过 .fit() 方法使这成为可能。为此，请将以下代码插入您的笔记本并运行它，以使模型适合您的数据集：

classifier.fit(X_train, y_train, batch_size = 10, epochs = 1)

.fit() 方法有几个参数：

第一个参数是具有特征的训练集。
第二个参数是您进行预测的列。
batch_size 表示在每一轮训练中将通过神经网络的样本数。
epochs 表示数据集将通过神经网络的次数。 epoch 越多，运行模型所需的时间就越长，这也会给你带来更好的结果。

您已经创建了深度学习模型，对其进行了编译，并将其拟合到您的数据集。您已准备好使用深度学习模型进行一些预测。在下一步中，您将开始使用模型尚未看到的数据集进行预测。

第 5 步——在测试集上运行预测

要开始进行预测，您将在您创建的模型中使用测试数据集。 Keras 使您可以使用 .predict() 函数进行预测。

在下一个笔记本单元格中插入以下代码以开始进行预测：

y_pred = classifier.predict(X_test)

由于您已经使用训练集训练了分类器，因此此代码将使用训练过程中的学习来对测试集进行预测。这将为您提供员工离职的概率。您将以 50% 及以上的概率工作，以表明员工离开公司的可能性很高。

在您的笔记本单元格中输入以下代码行以设置此阈值：

y_pred = (y_pred > 0.5)

您已经使用 predict 方法创建了预测，并设置了确定员工是否可能离开的阈值。为了评估模型在预测上的执行情况，您接下来将使用 混淆矩阵 。

第 6 步 - 检查混淆矩阵

在这一步中，您将使用 混淆矩阵 来检查正确和错误预测的数量。混淆矩阵，也称为误差矩阵，是一个方阵，用于报告分类器的真阳性（tp）、假阳性（fp）、真阴性（tn）和假阴性（fn）的数量。

真阳性 是模型正确预测阳性类别（也称为敏感性或召回率）的结果。
真负是模型正确预测负类的结果。
假阳性 是模型错误地预测正类的结果。
假阴性 是模型错误地预测负类的结果。

为此，您将使用 scikit-learn 提供的混淆矩阵。

将此代码插入下一个笔记本单元格以导入 scikit-learn 混淆矩阵：

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
cm

混淆矩阵输出意味着您的深度学习模型做出了 3305 + 375 正确预测和 106 + 714 错误预测。您可以使用以下命令计算精度：(3305 + 375) / 4500。数据集中的观察总数为 4500。这为您提供了 81.7% 的准确度。这是一个非常好的准确率，因为您可以从您的模型中获得至少 81% c 正确的预测。

Outputarray([[3305,  106],
       [ 714,  375]])

您已经使用混淆矩阵评估了您的模型。接下来，您将使用您开发的模型进行单个预测。

第 7 步 — 做出单一预测

在此步骤中，您将使用您的模型根据一名员工的详细信息进行单一预测。您将通过预测单个员工离开公司的可能性来实现这一点。您将把该员工的特征传递给 predict 方法。正如您之前所做的那样，您还将缩放特征并将它们转换为 numpy 数组。

要传递员工的特征，请在单元格中运行以下代码：

new_pred = classifier.predict(sc.transform(np.array([[0.26,0.7 ,3., 238., 6., 0.,0.,0.,0., 0.,0.,0.,0.,0.,1.,0., 0.,1.]])))

这些特征代表单个员工的特征。如步骤 1 中的数据集所示，这些特征表示：满意度、上次评估、项目数量等。正如您在第 3 步中所做的那样，您必须以深度学习模型可以接受的方式转换特征。

使用以下代码添加 50% 的阈值：

new_pred = (new_pred > 0.5)
new_pred

该阈值表明员工离开公司的概率高于 50%。

您可以在输出中看到员工不会离开公司：

Outputarray([[False]])

您可能决定为您的模型设置较低或较高的阈值。例如，您可以将阈值设置为 60%：

new_pred = (new_pred > 0.6)
new_pred

这个新的门槛仍然表明员工不会离开公司：

Outputarray([[False]])

在这一步中，您已经了解了如何根据单个员工的特征进行单个预测。在下一步中，您将致力于提高模型的准确性。

第 8 步——提高模型精度

如果您多次训练模型，您将不断得到不同的结果。每次训练的准确率都有很大的差异。为了解决这个问题，您将使用 K 折交叉验证。通常，K 设置为 10。在这种技术中，模型在前 9 折上进行训练，并在最后一折上进行测试。这个迭代一直持续到所有的折叠都用完为止。每次迭代都给出了自己的准确性。模型的准确度成为所有这些准确度的平均值。

keras 使您能够通过 KerasClassifier 包装器实现 K 折交叉验证。这个包装器来自 scikit-learn 交叉验证。您将从导入 cross_val_score 交叉验证函数和 KerasClassifier 开始。为此，请在笔记本单元格中插入并运行以下代码：

from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import cross_val_score

要创建将传递给 KerasClassifier 的函数，请将此代码添加到下一个单元格：

def make_classifier():
    classifier = Sequential()
    classifier.add(Dense(9, kernel_initializer = "uniform", activation = "relu", input_dim=18))
    classifier.add(Dense(1, kernel_initializer = "uniform", activation = "sigmoid"))
    classifier.compile(optimizer= "adam",loss = "binary_crossentropy",metrics = ["accuracy"])
    return classifier

在这里，您创建了一个将传递给 KerasClassifier 的函数——该函数是分类器期望的参数之一。该函数是您之前使用的神经网络设计的包装器。传递的参数也类似于本教程前面使用的参数。在函数中，首先使用 Sequential() 初始化分类器，然后使用 Dense 添加输入和输出层。最后，编译分类器并返回它。

要将您构建的函数传递给 KerasClassifier，请将以下代码行添加到您的笔记本中：

classifier = KerasClassifier(build_fn = make_classifier, batch_size=10, nb_epoch=1)

KerasClassifier 接受三个参数：

build_fn：用神经网络设计的函数
batch_size：每次迭代要通过网络的样本数
nb_epoch：网络将运行的 epoch 数

接下来，您使用 Scikit-learn 的 cross_val_score 应用交叉验证。将以下代码添加到您的笔记本单元格并运行它：

accuracies = cross_val_score(estimator = classifier,X = X_train,y = y_train,cv = 10,n_jobs = -1)

由于您已将折叠数指定为 10，因此此函数将为您提供 10 个精度。因此，您将其分配给准确度变量，然后使用它来计算平均准确度。它采用以下参数：

estimator：你刚刚定义的分类器
X：训练集特征
y：训练集中要预测的值
cv：折叠次数
n_jobs：要使用的 CPU 数量（指定为 -1 将使用所有可用的 CPU）

现在您已经应用了交叉验证，您可以计算精度的均值和方差。为此，请将以下代码插入到您的笔记本中：

mean = accuracies.mean()
mean

在您的输出中，您会看到平均值为 83%：

Output0.8343617910685696

要计算准确度的方差，请将此代码添加到下一个笔记本单元格：

variance = accuracies.var()
variance

您会看到方差为 0.00109。由于方差非常低，这意味着您的模型表现非常好。

Output0.0010935021002275425

您通过使用 K-Fold 交叉验证提高了模型的准确性。在下一步中，您将处理过度拟合问题。

第 9 步 - 添加 Dropout 正则化以对抗过度拟合

预测模型容易出现称为 过度拟合 的问题。在这种情况下，模型会记住训练集中的结果，并且无法概括它没有看到的数据。通常，当您的准确度差异非常大时，您会观察到过度拟合。为了帮助对抗模型中的过度拟合，您将在模型中添加一个层。

在神经网络中，dropout 正则化 是一种通过在神经网络中添加 Dropout 层来对抗过度拟合的技术。它有一个 rate 参数，表示在每次迭代中将停用的神经元数量。停用神经元的过程通常是随机的。在这种情况下，您指定 0.1 作为速率，这意味着 1% of 个神经元将在训练过程中停用。网络设计保持不变。

要添加 Dropout 图层，请将以下代码添加到下一个单元格：

from keras.layers import Dropout

classifier = Sequential()
classifier.add(Dense(9, kernel_initializer = "uniform", activation = "relu", input_dim=18))
classifier.add(Dropout(rate = 0.1))
classifier.add(Dense(1, kernel_initializer = "uniform", activation = "sigmoid"))
classifier.compile(optimizer= "adam",loss = "binary_crossentropy",metrics = ["accuracy"])

您在输入和输出层之间添加了一个 Dropout 层。将 dropout 率设置为 0.1 意味着在训练过程中 15 个神经元将停用，这样分类器就不会在训练集上过拟合。添加 Dropout 和输出层后，您可以像之前一样编译分类器。

在这一步中，您使用 Dropout 层来对抗过度拟合。接下来，您将通过调整创建模型时使用的参数来进一步改进模型。

第 10 步 — 超参数调整

网格搜索 是一种技术，您可以使用它来试验不同的模型参数，以获得最准确的参数。该技术通过尝试不同的参数并返回那些给出最佳结果的参数来做到这一点。您将使用网格搜索来为您的深度学习模型搜索最佳参数。这将有助于提高模型的准确性。 scikit-learn 提供 GridSearchCV 功能来启用此功能。您现在将继续修改 make_classifier 函数以尝试不同的参数。

将此代码添加到您的笔记本以修改 make_classifier 函数，以便您可以测试不同的优化器函数：

from sklearn.model_selection import GridSearchCV
def make_classifier(optimizer):
    classifier = Sequential()
    classifier.add(Dense(9, kernel_initializer = "uniform", activation = "relu", input_dim=18))
    classifier.add(Dense(1, kernel_initializer = "uniform", activation = "sigmoid"))
    classifier.compile(optimizer= optimizer,loss = "binary_crossentropy",metrics = ["accuracy"])
    return classifier

您已经开始导入 GridSearchCV。然后，您对 make_classifier 函数进行了更改，以便您可以尝试不同的优化器。您已经初始化了分类器，添加了输入和输出层，然后编译了分类器。最后，您返回了分类器，以便您可以使用它。

与第 4 步一样，插入这行代码来定义分类器：

classifier = KerasClassifier(build_fn = make_classifier)

您已经使用 KerasClassifier 定义了分类器，它需要一个通过 build_fn 参数的函数。您已经调用了 KerasClassifier 并传递了您之前创建的 make_classifier 函数。

您现在将继续设置您希望试验的几个参数。将此代码输入到单元格中并运行：

params = {
    'batch_size':[20,35],
    'epochs':[2,3],
    'optimizer':['adam','rmsprop']
}

在这里，您添加了不同的批量大小、时期数和不同类型的优化器函数。

对于像您这样的小型数据集，20-35 之间的批量大小是好的。对于大型数据集，尝试更大的批大小很重要。对 epoch 数使用较低的数字可确保您在短时间内获得结果。但是，您可以尝试更大的数字，这将需要一段时间才能完成，具体取决于服务器的处理速度。 keras 的 adam 和 rmsprop 优化器是此类神经网络的不错选择。

现在，您将使用已定义的不同参数，使用 GridSearchCV 函数搜索最佳参数。将其输入下一个单元格并运行它：

grid_search = GridSearchCV(estimator=classifier,
                           param_grid=params,
                           scoring="accuracy",
                           cv=2)

网格搜索功能需要以下参数：

estimator：您正在使用的分类器。
param_grid：您要测试的参数集。
scoring：您正在使用的指标。
cv：你要测试的折叠次数。

接下来，将此 grid_search 拟合到您的训练数据集：

grid_search = grid_search.fit(X_train,y_train)

您的输出将类似于以下内容，请稍等片刻以完成：

OutputEpoch 1/2
5249/5249 [==============================] - 1s 228us/step - loss: 0.5958 - acc: 0.7645
Epoch 2/2
5249/5249 [==============================] - 0s 82us/step - loss: 0.3962 - acc: 0.8510
Epoch 1/2
5250/5250 [==============================] - 1s 222us/step - loss: 0.5935 - acc: 0.7596
Epoch 2/2
5250/5250 [==============================] - 0s 85us/step - loss: 0.4080 - acc: 0.8029
Epoch 1/2
5249/5249 [==============================] - 1s 214us/step - loss: 0.5929 - acc: 0.7676
Epoch 2/2
5249/5249 [==============================] - 0s 82us/step - loss: 0.4261 - acc: 0.7864

将以下代码添加到笔记本单元格，以使用 best_params_ 属性从此搜索中获取最佳参数：

best_param = grid_search.best_params_
best_accuracy = grid_search.best_score_

您现在可以使用以下代码检查模型的最佳参数：

best_param

您的输出显示最佳批量大小是 20，最佳时期数是 2，并且 adam 优化器最适合您的模型：

Output{'batch_size': 20, 'epochs': 2, 'optimizer': 'adam'}

您可以检查模型的最佳精度。 best_accuracy number 表示运行网格搜索后从最佳参数中获得的最高精度：

best_accuracy

您的输出将类似于以下内容：

Output0.8533193637489285

您已经使用 GridSearch 为您的分类器找出最佳参数。您已经看到最好的 batch_size 是 20，最好的 optimizer 是 adam 优化器，最好的 epoch 数是 2。您还获得了分类器的最佳准确率，为 85%。您已经建立了一个员工保留模型，该模型能够以高达 85% 的准确度预测员工是留下还是离开。

结论

在本教程中，您使用 Keras 构建了一个人工神经网络，该网络可以预测员工离开公司的概率。您使用 scikit-learn 结合了您以前在机器学习方面的知识来实现这一目标。为了进一步改进您的模型，您可以从 keras 尝试不同的激活函数或优化函数。您还可以尝试不同数量的折叠，或者甚至使用不同的数据集构建模型。

对于机器学习领域的其他教程或使用TensorFlow，您可以尝试构建神经网络以识别手写数字或其他DigitalOcean 机器学习教程。