Pytorch100例 | 用深度学习处理分类问题实战教程
Posted K同学啊
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Pytorch100例 | 用深度学习处理分类问题实战教程相关的知识，希望对你有一定的参考价值。
PyTorch和TensorFlow库是用于深度学习的两个最常用的 Python 库。PyTorch 是 Facebook 开发的，而 TensorFlow 是 Google 的项目。在本文中，你将看到如何使用 PyTorch 库来解决分类问题。
分类问题属于机器学习问题的范畴，其中给定一组特征，任务是预测离散值。预测肿瘤是否癌变，或者学生是否可能通过考试，是分类问题的一些常见示例。
在本文中，我们将根据银行客户的某些特征，预测客户是否有可能在 6 个月后离开银行。客户离开的现象也称为客户流失。因此，我们的任务是根据各种客户特征来预测客户流失。
在你继续之前，假定你对 Python 编程语言具有中级水平，并且你已经安装了 PyTorch 库。此外，了解了基本机器学习概念的知识可能会对理解本文有所帮助。如果你尚未安装 PyTorch，则可以使用以下 pip 命令进行安装：
$ pip install pytorch
数据集
我们将在本文中使用的数据集可通过此Kaggle 链接免费获得，也可以添加我微信获取。让我们将所需的库和数据集导入我们的 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
我们可以使用第三方库的read_csv()方法pandas导入包含我们数据集的 CSV 文件。
dataset = pd.read_csv(r'E:Datasets\\customer_data.csv')
让我们打印数据集的形状：
dataset.shape
输出：
(10000, 14)
输出显示数据集有 10,000 条记录和 14 列。
我们可以使用.head()方法打印数据集的前五行。
dataset.head()
输出：
你可以在我们的数据集中看到 14 列。我们的任务是基于前 13 列预测第 14 列的值，即Exited。需要注意的是，前 13 列的值是在Exited获取该列的值之前 6 个月记录的，因为任务是预测自记录客户信息起 6 个月后的客户流失。
探索性数据分析
让我们对我们的数据集执行一些探索性数据分析。我们将首先预测 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代表客户没有离开银行的情况。
让我们绘制数据集中所有地理位置的客户数量：
sns.countplot(x='Geography', data=dataset)
输出：
输出显示，几乎一半的客户属于法国，而属于西班牙和德国的客户比例各为 25%。
现在让我们绘制每个独特地理位置的客户数量以及客户流失信息。我们可以使用seaborn库中的countplot()函数来做到这一点。
sns.countplot(x='Exited', hue='Geography', data=dataset)
输出：
输出显示，尽管法国客户的总数是西班牙和德国客户的两倍，但法国和德国客户离开银行的客户比例相同。同样，德国和西班牙客户的总体数量相同，但德国客户离开银行的数量是西班牙客户的两倍，这表明德国客户更有可能在 6 个月后离开银行。
数据预处理
在我们训练我们的 PyTorch 模型之前，我们需要预处理我们的数据。如果查看数据集，你会看到它有两种类型的列：数值列和分类列。数字列包含数字信息。CreditScore、Balance、Age等。类似地，Geography和Gender是分类列，因为它们包含分类信息，例如客户的位置和性别。有一些列可以被视为数字列和分类列。例如，该HasCrCard列的值可以是 1 或 0。但是，那HasCrCard列包含有关客户是否拥有信用卡的信息。建议将既可被视为分类又可被视为数值的列视为分类。
让我们再次打印数据集中的所有列，并找出哪些列可以被视为数字列，哪些列应该被视为分类列。数据框的columns属性打印所有列名：
dataset.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列可以视为分类列。让我们创建这些列的列表：
categorical_columns = ['Geography', 'Gender', 'HasCrCard', 'IsActiveMember']
除Exited列外的所有剩余列都可以视为数字列。
numerical_columns = ['CreditScore', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'EstimatedSalary']
最后，输出（Exited列）存储在outputs变量中。
outputs = ['Exited']
我们已经创建了分类、数字和输出的列表。但是，目前分类列的类型不是分类的。你可以使用以下脚本检查数据集中所有列的类型：
dataset.dtypes
输出：
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，我们可以使用函数来做到这一点，如下所示：
for category in categorical_columns:
dataset[category] = dataset[category].astype('category')
现在，如果您再次绘制数据集中列的类型，您应该会看到以下结果：
dataset.dtypes
输出
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列中的所有类别：
dataset['Geography'].cat.categories
输出：
Index(['France', 'Germany', 'Spain'], dtype='object')
当你将列的数据类型更改为类别时，列中的每个类别都会分配一个唯一代码。例如，让我们绘制该Geography列的前五行并打印前五行的代码值：
dataset['Geography'].head()
输出：
0 France
1 Spain
2 France
3 France
4 Spain
Name: Geography, dtype: category
Categories (3, object): [France, Germany, Spain]
以下脚本绘制Geography列前五行中值的编号：
dataset['Geography'].head().cat.codes
输出：
0 0
1 2
2 0
3 0
4 2
dtype: int8
输出显示法国已编码为 0，西班牙已编码为 2。
由于我们将使用 PyTorch 进行模型训练，因此我们需要将分类列和数值列转换为张量。让我们首先将分类列转换为张量。在 PyTorch 中，可以通过 numpy 数组创建张量。我们首先将四个分类列中的数据转换为 numpy 数组，然后水平堆叠所有列，如以下脚本所示：
geo = dataset['Geography'].cat.codes.values
gen = dataset['Gender'].cat.codes.values
hcc = dataset['HasCrCard'].cat.codes.values
iam = dataset['IsActiveMember'].cat.codes.values
categorical_data = np.stack([geo, gen, hcc, iam], 1)
categorical_data[:10]
上面的脚本打印分类列中水平堆叠的前十条记录。输出如下：
输出：
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 数组创建一个张量，你可以简单地将数组传递给模块的torch类的tensor模块。对于分类列，数据类型应为torch.int64.
categorical_data = torch.tensor(categorical_data, dtype=torch.int64)
categorical_data[:10]
输出：
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)
numerical_data = torch.tensor(numerical_data, dtype=torch.float)
numerical_data[:5]
输出：
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对象。
outputs = torch.tensor(dataset[outputs].values).flatten()
outputs[:5]
输出：
tensor([1, 0, 1, 0, 0])
现在让我们绘制分类数据、数值数据和相应输出的形状：
print(categorical_data.shape)
print(numerical_data.shape)
print(outputs.shape)
输出：
torch.Size([10000, 4])
torch.Size([10000, 6])
torch.Size([10000])
在我们训练模型之前有一个非常重要的步骤。我们将分类列转换为数字列（类别数字化），其中唯一值由整数表示。例如，在Geography列中，我们看到法国用 0 表示，德国用 1 表示。我们可以使用这些值来训练我们的模型。但是，更好的方法是以 N 维向量的形式表示分类列中的值，而不是整数。向量能够捕获更多信息，并能以更合适的方式找到不同分类值之间的关系。因此，我们将以 N 维向量的形式表示分类列中的值。这个过程称为嵌入。
我们需要为所有分类列定义嵌入大小（向量维度）。关于维数没有硬性规定。定义列的嵌入大小的一个好的经验法则是将列中唯一值的数量除以 2（但不超过 50）。例如，对于该Geography列，唯一值的数量为 3。该Geography列的相应嵌入大小将为 3/2 = 1.5 = 2（四舍五入）。
以下脚本创建一个元组，其中包含唯一值的数量和所有分类列的维度大小：
categorical_column_sizes = [len(dataset[column].cat.categories) for column in categorical_columns]
categorical_embedding_sizes = [(col_size, min(50, (col_size+1)//2)) for col_size in categorical_column_sizes]
print(categorical_embedding_sizes)
输出：
[(3, 2), (2, 1), (2, 1), (2, 1)]
对于有监督的深度学习模型，例如我们在本文中开发的模型，需要使用训练数据进行训练，并在测试数据集上评估模型性能。因此，我们需要将我们的数据集划分为训练集和测试集，如下面的脚本所示：
total_records = 10000
test_records = int(total_records * .2)
categorical_train_data = categorical_data[:total_records-test_records]
categorical_test_data = categorical_data[total_records-test_records:total_records]
numerical_train_data = numerical_data[:total_records-test_records]
numerical_test_data = numerical_data[total_records-test_records:total_records]
train_outputs = outputs[:total_records-test_records]
test_outputs = outputs[total_records-test_records:total_records]
我们的数据集中有 10,000 条记录，其中 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))
输出：
8000
8000
8000
2000
2000
2000
创建预测模型
我们已将数据分为训练集和测试集，现在是时候定义我们的训练模型了。为此，我们可以定义一个名为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)
all_layers = []
num_categorical_cols = sum((nf for ni, nf in embedding_size))
input_size = num_categorical_cols + num_numerical_cols
for i in layers:
all_layers.append(nn.Linear(input_size, i))
all_layers.append(nn.ReLU(inplace=True))
all_layers.append(nn.BatchNorm1d(i))
all_layers.append(nn.Dropout(p))
input_size = i
all_layers.append(nn.Linear(layers[-1], output_size))
self.layers = nn.Sequential(*all_layers)
def forward(self, x_categorical, x_numerical):
embeddings = []
for i,e in enumerate(self.all_embeddings):
embeddings.append(e(x_categorical[:,i]))
x = torch.cat(embeddings, 1)
x = self.embedding_dropout(x)
x_numerical = self.batch_norm_num(x_numerical)
x = torch.cat([x, x_numerical], 1)
x = self.layers(x)
return x
如果你以前从未使用过 PyTorch，上面的代码可能看起来会有些难度，我尽力为你分解。
在第一行中，我们声明了一个Model继承自Module的类。在类的构造函数（__init__()方法）中传递以下参数：
embedding_size：包含分类列的嵌入大小（embedding size）num_numerical_cols：存储数字列的总数output_size：输出层的大小或可能输出的数量。layers：包含所有层的神经元数量的列表。p：Dropout值，默认值为0.5
在构造函数内部，初始化了一些变量。首先，该all_embeddings变量包含所有分类列的ModuleList对象列表。embedding_dropout存储所有层的丢失值。最后，batch_norm_num存储所有数字列的BatchNorm1d对象列表。
接下来，为了找到输入层的大小，将分类列数和数字列数相加并存储在input_size变量中。之后，for循环迭代并将相应的层添加到all_layers列表中。添加的层是：
Linear：用于计算输入和权重矩阵之间的点积ReLu：用作激活函数BatchNorm1d: 用于对数值列应用批量归一化Dropout：用于避免过拟合
for循环后，输出层将附加到层列表。由于我们希望神经网络中的所有层按顺序执行，因此将层列表传递给nn.Sequential类。
接下来，在该forward方法中，分类列和数字列都作为输入传递。分类列的嵌入发生在以下几行中。
embeddings = []
for i, e in enumerate(self.all_embeddings):
embeddings.append(e(x_categorical[:,i]))
x = torch.cat(embeddings, 1)
x = self.embedding_dropout(x)
数字列的批量归一化应用以下脚本：
x_numerical = self.batch_norm_num(x_numerical)
最后，嵌入的分类列x和数字列x_numerical连接在一起并传递给 sequential layers。
训练模型
要训练模型，首先我们必须创建一个Model（我们在上一节中定义的类的对象）。
model = Model(categorical_embedding_sizes, numerical_data.shape[1], 2, [200,100,50], p=0.4)
你可以看到我们传递了分类列的嵌入大小、数字列的数量、输出大小（在我们的例子中为 2）和隐藏层中的神经元。你可以看到我们有三个隐藏层，分别有 200、100 和 50 个神经元。如果需要，你可以选择任何其他尺寸。
让我们打印我们的模型，看看它的外观：
print(model)
输出：
Model(
(all_embeddings): ModuleList(
(0): Embedding(3, 2)
(1): Embedding(2, 1)
(2): Embedding(2, 1)
(3): Embedding(2, 1)
)
(embedding_dropout): Dropout(p=0.4)
(batch_norm_num): BatchNorm1d(6, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(layers): Sequential(
(0): Linear(in_features=11, out_features=200, bias=True)
(1): ReLU(inplace)
(2): Batch以上是关于Pytorch100例 | 用深度学习处理分类问题实战教程的主要内容，如果未能解决你的问题，请参考以下文章
PyTorch深度学习项目实战100例—— 基于LeNet5实现交通标志分类任务 | 第50例
PyTorch深度学习项目实战100例—— 基于AlexNet实现宠物小精灵（宝可梦）分类任务 | 第49例
深度学习100例 | 第4例：水果识别 - PyTorch实现