数据可视化是所有人工智能和机器学习应用的重要组成部分。通过不同的图形表示，您可以获得对数据的关键洞察。在本教程中，我们将讨论在 Python 中进行数据可视化的几种选择。我们将使用 MNIST 数据集和 Tensorflow 库进行数值计算和数据处理。为了说明创建不同类型图表的各种方法，我们将使用 Python 的绘图库，即 Matplotlib、Seaborn 和 Bokeh。
完成本教程后，您将了解：
- 如何在 Matplotlib 中可视化图像
- 如何在 Matplotlib、Seaborn 和 Bokeh 中制作散点图
- 如何在 Matplotlib、Seaborn 和 Bokeh 中制作多线图
通过我的新书《Python 机器学习》开启您的项目，其中包括逐步教程和所有示例的 Python 源代码文件。
让我们开始吧。
使用 Matplotlib、Seaborn 和 Bokeh 在 Python 中进行数据可视化
图片由 Mehreen Saeed 拍摄，保留部分权利。
教程概述
本教程分为七个部分，它们是：
- 散点数据准备
- Matplotlib 中的图形
- Matplotlib 和 Seaborn 中的散点图
- Bokeh 中的散点图
- 折线图数据准备
- Matplotlib、Seaborn 和 Bokeh 中的折线图
- 更多可视化内容
散点数据准备
在本文中，我们将使用 Matplotlib、Seaborn 和 Bokeh。它们都是需要安装的外部库。要使用 pip 安装它们，请运行以下命令
|
1 |
pip install matplotlib seaborn bokeh |
为了演示目的，我们还将使用 MNIST 手写数字数据集。我们将从 TensorFlow 加载它并对其运行 PCA 算法。因此，我们还需要安装 TensorFlow 和 pandas
|
1 |
pip install tensorflow pandas |
之后的代码将假定已执行以下导入
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
# 从 TensorFlow 和 Keras 导入 from tensorflow.keras.datasets import mnist from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Reshape from tensorflow.keras import utils from tensorflow import dtypes, tensordot from tensorflow import convert_to_tensor, linalg, transpose # 用于数学运算 import numpy as np # 用于 Matplotlib 绘图 import matplotlib.pyplot as plt # 用于 Seaborn 绘图 import seaborn as sns # 用于 Bokeh 绘图 from bokeh.plotting import figure, show from bokeh.models import Legend, LegendItem # 用于 Pandas DataFrame import pandas as pd |
我们从 keras.datasets 库加载 MNIST 数据集。为简单起见，我们将只保留包含前三位数字的数据子集。我们暂时也将忽略测试集。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
... # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 训练数据形状 total_examples, img_length, img_width = x_train.shape # 打印统计信息 print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) |
|
1 2 |
训练数据包含 18623 张图片 每张图片的大小为 28 x 28 |
想开始学习机器学习 Python 吗？
立即参加我为期7天的免费电子邮件速成课程（附示例代码）。
点击注册，同时获得该课程的免费PDF电子书版本。
Matplotlib 中的图形
Seaborn 确实是 Matplotlib 的一个附加组件。因此，即使使用 Seaborn，您也需要了解 Matplotlib 如何处理绘图。
Matplotlib 将其画布称为 figure。您可以将 figure 分为几个称为 subplots 的部分，这样您就可以将两个可视化并排放置。
例如，让我们使用 Matplotlib 可视化 MNIST 数据集的前 16 张图像。我们将使用 subplots() 函数创建 2 行 8 列。subplots() 函数将为每个单元创建坐标轴对象。然后我们将使用 imshow() 方法在每个坐标轴对象上显示每张图像。最后，将使用 show() 函数显示 figure。
|
1 2 3 4 5 6 7 8 |
img_per_row = 8 fig,ax = plt.subplots(nrows=2, ncols=img_per_row, figsize=(18,4), subplot_kw=dict(xticks=[], yticks=[])) for row in [0, 1]: for col in range(img_per_row): ax[row, col].imshow(x_train[row*img_per_row + col].astype('int')) plt.show() |
训练数据集的前 16 张图像以 2 行 8 列显示
这里我们可以看到 Matplotlib 的一些属性。Matplotlib 中有默认的 figure 和默认的 axes。Matplotlib 在 pyplot 子模块下定义了许多函数用于在默认 axes 上绘图。如果要在特定 axes 上绘图，可以使用 axes 对象下的绘图函数。操作 figure 的过程是程序性的。这意味着 Matplotlib 内部会记住一个数据结构，我们的操作会改变它。show() 函数只是显示一系列操作的结果。因此，我们可以逐步微调 figure 中的许多细节。在上面的示例中，我们通过将 xticks 和 yticks 设置为空列表来隐藏“刻度”（即坐标轴上的标记）。
Matplotlib 和 Seaborn 中的散点图
我们在机器学习项目中常用的可视化之一是散点图。
例如，我们将 PCA 应用于 MNIST 数据集并提取每个图像的前三个主成分。在下面的代码中，我们从数据集中计算特征向量和特征值，然后将每个图像的数据沿特征向量方向投影并将结果存储在 x_pca 中。为简单起见，在计算特征向量之前，我们没有将数据归一化为零均值和单位方差。这种省略不影响我们的可视化目的。
|
1 2 3 4 5 6 7 8 9 10 |
... # 将数据集转换为 18623 x 784 形状的二维数组 x = convert_to_tensor(np.reshape(x_train, (x_train.shape[0], -1)), dtype=dtypes.float32) # 从 784 x 784 矩阵进行特征分解 eigenvalues, eigenvectors = linalg.eigh(tensordot(transpose(x), x, axes=1)) # 打印三个最大的特征值 print('3 个最大的特征值: ', eigenvalues[-3:]) # 将数据投影到特征向量上 x_pca = tensordot(x, eigenvectors, axes=1) |
打印的特征值如下
|
1 |
3 最大的 特征值: tf.Tensor([5.1999642e+09 1.1419439e+10 4.8231231e+10], shape=(3,), dtype=float32) |
数组 x_pca 的形状为 18623 x 784。让我们将最后两列视为 x 和 y 坐标，并在图中绘制每行的点。我们可以根据其对应的数字进一步为点着色。
以下代码使用 Matplotlib 生成散点图。该图是使用 axes 对象的 scatter() 函数创建的，该函数将 x 和 y 坐标作为前两个参数。scatter() 方法的 c 参数指定一个将成为其颜色的值。s 参数指定其大小。该代码还创建了一个图例并为图添加了一个标题。
|
1 2 3 4 5 6 7 |
fig, ax = plt.subplots(figsize=(12, 8)) scatter = ax.scatter(x_pca[:, -1], x_pca[:, -2], c=train_labels, s=5) legend_plt = ax.legend(*scatter.legend_elements(), loc="左下", title="数字") ax.add_artist(legend_plt) plt.title('应用 PCA 后投影数据的前两个维度') plt.show() |
使用 Matplotlib 生成的 2D 散点图
将以上代码整合起来，下面是使用 Matplotlib 生成 2D 散点图的完整代码
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
from tensorflow.keras.datasets import mnist from tensorflow import dtypes, tensordot from tensorflow import convert_to_tensor, linalg, transpose import numpy as np import matplotlib.pyplot as plt # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 验证训练数据的形状 total_examples, img_length, img_width = x_train.shape print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) # 将数据集转换为 18623 x 784 形状的二维数组 x = convert_to_tensor(np.reshape(x_train, (x_train.shape[0], -1)), dtype=dtypes.float32) # 从 784 x 784 矩阵进行特征分解 eigenvalues, eigenvectors = linalg.eigh(tensordot(transpose(x), x, axes=1)) # 打印三个最大的特征值 print('3 个最大的特征值: ', eigenvalues[-3:]) # 将数据投影到特征向量上 x_pca = tensordot(x, eigenvectors, axes=1) # 创建绘图 fig, ax = plt.subplots(figsize=(12, 8)) scatter = ax.scatter(x_pca[:, -1], x_pca[:, -2], c=train_labels, s=5) legend_plt = ax.legend(*scatter.legend_elements(), loc="左下", title="数字") ax.add_artist(legend_plt) plt.title('应用 PCA 后投影数据的前两个维度') plt.show() |
Matplotlib 也允许生成 3D 散点图。为此，您需要首先创建一个具有 3D 投影的 axes 对象。然后使用 scatter3D() 函数创建 3D 散点图，其中 x、y 和 z 坐标作为前三个参数。下面的代码使用沿对应于三个最大特征值的特征向量投影的数据。此代码不是创建图例，而是创建颜色条
|
1 2 3 4 5 |
fig = plt.figure(figsize=(12, 8)) ax = plt.axes(projection='3d') plt_3d = ax.scatter3D(x_pca[:, -1], x_pca[:, -2], x_pca[:, -3], c=train_labels, s=1) plt.colorbar(plt_3d) plt.show() |
使用 Matplotlib 生成的 3D 散点图
scatter3D() 函数只是将点放置到 3D 空间中。之后，我们仍然可以修改图的显示方式，例如每个轴的标签和背景颜色。但在 3D 图中，一个常见的调整是视口，即我们观察 3D 空间的角度。视口由 axes 对象中的 view_init() 函数控制
|
1 |
ax.view_init(elev=30, azim=-60) |
视口由仰角（即与水平面的夹角）和方位角（即在水平面上的旋转）控制。默认情况下，Matplotlib 使用 30 度仰角和 -60 度方位角，如上所示。
将所有内容整合起来，下面是使用 Matplotlib 创建 3D 散点图的完整代码
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
from tensorflow.keras.datasets import mnist from tensorflow import dtypes, tensordot from tensorflow import convert_to_tensor, linalg, transpose import numpy as np import matplotlib.pyplot as plt # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 验证训练数据的形状 total_examples, img_length, img_width = x_train.shape print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) # 将数据集转换为 18623 x 784 形状的二维数组 x = convert_to_tensor(np.reshape(x_train, (x_train.shape[0], -1)), dtype=dtypes.float32) # 从 784 x 784 矩阵进行特征分解 eigenvalues, eigenvectors = linalg.eigh(tensordot(transpose(x), x, axes=1)) # 打印三个最大的特征值 print('3 个最大的特征值: ', eigenvalues[-3:]) # 将数据投影到特征向量上 x_pca = tensordot(x, eigenvectors, axes=1) # 创建绘图 fig = plt.figure(figsize=(12, 8)) ax = plt.axes(projection='3d') ax.view_init(elev=30, azim=-60) plt_3d = ax.scatter3D(x_pca[:, -1], x_pca[:, -2], x_pca[:, -3], c=train_labels, s=1) plt.colorbar(plt_3d) plt.show() |
在 Seaborn 中创建散点图同样简单。scatterplot() 方法在绘制点时会自动创建图例并为不同的类别使用不同的符号。默认情况下，该图是在 Matplotlib 的“当前轴”上创建的，除非由 ax 参数指定了轴对象。
|
1 2 3 4 5 6 |
fig, ax = plt.subplots(figsize=(12, 8)) sns.scatterplot(x_pca[:, -1], x_pca[:, -2], style=train_labels, hue=train_labels, palette=["red", "green", "blue"]) plt.title('应用 PCA 后投影数据的前两个维度') plt.show() |
使用 Seaborn 生成的 2D 散点图
Seaborn 相对于 Matplotlib 的好处有两方面：首先，我们有一个精美的默认样式。例如，如果我们比较上面两个散点图中的点样式，Seaborn 的点周围有一个边框，以防止许多点混在一起。实际上，如果我们在调用任何 Matplotlib 函数之前运行以下行
|
1 |
sns.set(style = "darkgrid") |
我们仍然可以使用 Matplotlib 函数，但通过使用 Seaborn 的样式可以获得更好看的图形。其次，如果我们使用 pandas DataFrame 来保存数据，使用 Seaborn 会更方便。例如，让我们将 MNIST 数据从张量转换为 pandas DataFrame
|
1 2 3 |
df_mnist = pd.DataFrame(x_pca[:, -3:].numpy(), columns=["pca3","pca2","pca1"]) df_mnist["label"] = train_labels print(df_mnist) |
现在，DataFrame 看起来像这样
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
pca3 pca2 pca1 标签 0 -537.730103 926.885254 1965.881592 0 1 167.375885 -947.360107 1070.359375 1 2 553.685425 -163.121826 1754.754272 2 3 -642.905579 -767.283020 1053.937988 1 4 -651.812988 -586.034424 662.468201 1 ... ... ... ... ... 18618 415.358948 -645.245972 853.439209 1 18619 754.555786 7.873116 1897.690552 2 18620 -321.809357 665.038086 1840.480225 0 18621 643.843628 -85.524895 1113.795166 2 18622 94.964279 -549.570984 561.743042 1 [18623 行 x 4 列] |
然后，我们可以使用以下代码重现 Seaborn 的散点图
|
1 2 3 4 5 6 |
fig, ax = plt.subplots(figsize=(12, 8)) sns.scatterplot(data=df_mnist, x="pca1", y="pca2", style="标签", hue="标签", palette=["red", "green", "blue"]) plt.title('应用 PCA 后投影数据的前两个维度') plt.show() |
我们不将数组作为坐标传递给 scatterplot() 函数，而是使用 data 参数的列名。
以下是使用 Seaborn 生成散点图的完整代码，数据存储在 pandas 中
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
from tensorflow.keras.datasets import mnist from tensorflow import dtypes, tensordot from tensorflow import convert_to_tensor, linalg, transpose import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 验证训练数据的形状 total_examples, img_length, img_width = x_train.shape print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) # 将数据集转换为 18623 x 784 形状的二维数组 x = convert_to_tensor(np.reshape(x_train, (x_train.shape[0], -1)), dtype=dtypes.float32) # 从 784 x 784 矩阵进行特征分解 eigenvalues, eigenvectors = linalg.eigh(tensordot(transpose(x), x, axes=1)) # 打印三个最大的特征值 print('3 个最大的特征值: ', eigenvalues[-3:]) # 将数据投影到特征向量上 x_pca = tensordot(x, eigenvectors, axes=1) # 创建 pandas DataFrame df_mnist = pd.DataFrame(x_pca[:, -3:].numpy(), columns=["pca3","pca2","pca1"]) df_mnist["label"] = train_labels # 创建绘图 fig, ax = plt.subplots(figsize=(12, 8)) sns.scatterplot(data=df_mnist, x="pca1", y="pca2", style="标签", hue="标签", palette=["red", "green", "blue"]) plt.title('应用 PCA 后投影数据的前两个维度') plt.show() |
Seaborn 作为某些 Matplotlib 函数的包装器，并没有完全取代 Matplotlib。例如，Seaborn 不支持 3D 绘图，我们仍然需要借助 Matplotlib 函数来实现此目的。
Bokeh 中的散点图
Matplotlib 和 Seaborn 创建的图是静态图像。如果您需要放大、平移或切换图的某些部分的显示，您应该改用 Bokeh。
在 Bokeh 中创建散点图也很容易。以下代码生成一个散点图并添加一个图例。Bokeh 库的 show() 方法会打开一个新浏览器窗口来显示图像。您可以使用渲染图旁边的工具栏中显示的选项进行缩放、平移、滚动等操作。您还可以通过单击图例来隐藏散点图的一部分。
|
1 2 3 4 5 6 7 8 9 10 11 |
colormap = {0: "red", 1:"green", 2:"blue"} my_scatter = figure(title="应用 PCA 后投影数据的前两个维度", x_axis_label="维度 1", y_axis_label="维度 2") for digit in [0, 1, 2]: selection = x_pca[train_labels == digit] my_scatter.scatter(selection[:,-1].numpy(), selection[:,-2].numpy(), color=colormap[digit], size=5, legend_label="数字 "+str(digit)) my_scatter.legend.click_policy = "隐藏" show(my_scatter) |
Bokeh 将使用 Javascript 生成 HTML 中的图。您控制图的所有操作都由一些 Javascript 函数处理。其输出将如下所示
使用 Bokeh 在新浏览器窗口中生成的 2D 散点图。请注意右侧工具栏中用于与图交互的各种选项。
以下是使用 Bokeh 生成上述散点图的完整代码
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
from tensorflow.keras.datasets import mnist from tensorflow import dtypes, tensordot from tensorflow import convert_to_tensor, linalg, transpose import numpy as np from bokeh.plotting import figure, show # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 验证训练数据的形状 total_examples, img_length, img_width = x_train.shape print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) # 将数据集转换为 18623 x 784 形状的二维数组 x = convert_to_tensor(np.reshape(x_train, (x_train.shape[0], -1)), dtype=dtypes.float32) # 从 784 x 784 矩阵进行特征分解 eigenvalues, eigenvectors = linalg.eigh(tensordot(transpose(x), x, axes=1)) # 打印三个最大的特征值 print('3 个最大的特征值: ', eigenvalues[-3:]) # 将数据投影到特征向量上 x_pca = tensordot(x, eigenvectors, axes=1) # 在 Bokeh 中创建散点图 colormap = {0: "red", 1:"green", 2:"blue"} my_scatter = figure(title="应用 PCA 后投影数据的前两个维度", x_axis_label="维度 1", y_axis_label="维度 2") for digit in [0, 1, 2]: selection = x_pca[train_labels == digit] my_scatter.scatter(selection[:,-1].numpy(), selection[:,-2].numpy(), color=colormap[digit], size=5, alpha=0.5, legend_label="数字 "+str(digit)) my_scatter.legend.click_policy = "隐藏" show(my_scatter) |
如果您在 Jupyter 笔记本中渲染 Bokeh 图，您可能会看到该图是在新浏览器窗口中生成的。要将该图放入 Jupyter 笔记本中，您需要在 Bokeh 函数之前运行以下代码，以告知 Bokeh 您处于笔记本环境中
|
1 2 |
from bokeh.io import output_notebook output_notebook() |
另外，请注意，我们是循环创建三个数字的散点图，一次一个数字。这是使图例具有交互性所必需的，因为每次调用 scatter() 都会创建一个新对象。如果我们将所有散点同时创建，如下所示，单击图例将隐藏和显示所有内容，而不是只隐藏和显示其中一个数字的点。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
colormap = {0: "red", 1:"green", 2:"blue"} colors = [colormap[i] for i in train_labels] my_scatter = figure(title="应用 PCA 后投影数据的前两个维度", x_axis_label="维度 1", y_axis_label="维度 2") scatter_obj = my_scatter.scatter(x_pca[:, -1].numpy(), x_pca[:, -2].numpy(), color=colors, size=5) legend = Legend(items=[ LegendItem(label="数字 0", renderers=[scatter_obj], index=0), LegendItem(label="数字 1", renderers=[scatter_obj], index=1), LegendItem(label="数字 2", renderers=[scatter_obj], index=2), ]) my_scatter.add_layout(legend) my_scatter.legend.click_policy = "隐藏" show(my_scatter) |
折线图数据准备
在继续展示如何可视化折线图数据之前，让我们生成一些数据进行说明。下面是使用 Keras 库的简单分类器，我们训练它来学习手写数字分类。fit() 方法返回的 history 对象是一个字典，其中包含训练阶段的所有学习历史。为简单起见，我们将模型只训练 10 个 epoch。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
epochs = 10 y_train = utils.to_categorical(train_labels) input_dim = img_length*img_width # 创建 Sequential 模型 model = Sequential() # 将输入图像从 2D 重新塑形为 1D 的第一层 model.add(Reshape((input_dim, ), input_shape=(img_length, img_width))) # 8 个神经元的全连接层 model.add(Dense(8, activation='relu')) # 输出层 model.add(Dense(total_classes, activation='softmax')) # 编译模型 model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) history = model.fit(x_train, y_train, validation_split=0.33, epochs=epochs, batch_size=10, verbose=0) print('学习历史: ', history.history) |
上面的代码将生成一个字典，其中包含键 loss、accuracy、val_loss 和 val_accuracy，如下所示
|
1 2 3 4 |
学习历史: {'损失': [0.5362154245376587, 0.08184114843606949, ...], '准确率': [0.9426144361495972, 0.9763565063476562, ...], 'val_loss': [0.09874073415994644, 0.07835448533296585, ...], 'val_accuracy': [0.9716889262199402, 0.9788480401039124, ...]} |
Matplotlib、Seaborn 和 Bokeh 中的折线图
让我们看看可视化从训练分类器获得的学习历史的各种选项。
在 Matplotlib 中创建多线图就像下面这样简单。我们从历史中获取训练和验证准确率的值列表，默认情况下，Matplotlib 会将其视为顺序数据（即 x 坐标是从 0 开始计数的整数）。
|
1 2 3 4 5 6 7 |
plt.plot(history.history['accuracy'], label="训练准确率") plt.plot(history.history['val_accuracy'], label="验证准确率") plt.title('训练和验证准确率') plt.xlabel('Epochs') plt.ylabel('准确率') plt.legend() plt.show() |
使用 Matplotlib 绘制的多线图
创建多线图的完整代码如下
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
from tensorflow.keras.datasets import mnist from tensorflow.keras import utils from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Reshape import numpy as np import matplotlib.pyplot as plt # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 验证训练数据的形状 total_examples, img_length, img_width = x_train.shape print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) # 准备分类器网络 epochs = 10 y_train = utils.to_categorical(train_labels) input_dim = img_length*img_width # 创建 Sequential 模型 model = Sequential() # 将输入图像从 2D 重新塑形为 1D 的第一层 model.add(Reshape((input_dim, ), input_shape=(img_length, img_width))) # 8 个神经元的全连接层 model.add(Dense(8, activation='relu')) # 输出层 model.add(Dense(total_classes, activation='softmax')) # 编译模型 model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) history = model.fit(x_train, y_train, validation_split=0.33, epochs=epochs, batch_size=10, verbose=0) print('学习历史: ', history.history) # 在 Matplotlib 中绘制准确率 plt.plot(history.history['accuracy'], label="训练准确率") plt.plot(history.history['val_accuracy'], label="验证准确率") plt.title('训练和验证准确率') plt.xlabel('Epochs') plt.ylabel('准确率') plt.legend() plt.show() |
类似地，我们可以在 Seaborn 中做同样的事情。正如我们在散点图示例中看到的，我们可以将数据显式地作为一系列值传递给 Seaborn，或者通过 pandas DataFrame 传递。下面我们将使用 pandas DataFrame 绘制训练损失和验证损失。
|
1 2 3 4 5 6 7 8 9 10 11 |
# 创建 pandas DataFrame df_history = pd.DataFrame(history.history) print(df_history) # 使用 Seaborn 绘制 my_plot = sns.lineplot(data=df_history[["loss","val_loss"]]) my_plot.set_xlabel('Epochs') my_plot.set_ylabel('Loss') plt.legend(labels=["训练", "验证"]) plt.title('训练和验证损失') plt.show() |
它将打印以下表格，这是我们从历史中创建的 DataFrame
|
1 2 3 4 5 6 7 8 9 10 11 |
损失 准确率 val_loss val_accuracy 0 0.536215 0.942614 0.098741 0.971689 1 0.081841 0.976357 0.078354 0.978848 2 0.064002 0.978841 0.080637 0.972991 3 0.055695 0.981726 0.064659 0.979987 4 0.054693 0.984371 0.070817 0.983729 5 0.053512 0.985173 0.069099 0.977709 6 0.053916 0.983089 0.068139 0.979662 7 0.048681 0.985093 0.064914 0.977709 8 0.052084 0.982929 0.080508 0.971363 9 0.040484 0.983890 0.111380 0.982590 |
它生成的图如下所示
使用 Seaborn 绘制的多线图
默认情况下，Seaborn 将从 DataFrame 中理解列标签并将其用作图例。在上面，我们为每个绘图提供了新的标签。此外，折线图的 x 轴默认取自 DataFrame 的索引，在我们的例子中是一个从 0 到 9 的整数，如上所示。
在 Seaborn 中生成图的完整代码如下
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
from tensorflow.keras.datasets import mnist from tensorflow.keras import utils from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Reshape import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 验证训练数据的形状 total_examples, img_length, img_width = x_train.shape print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) # 准备分类器网络 epochs = 10 y_train = utils.to_categorical(train_labels) input_dim = img_length*img_width # 创建 Sequential 模型 model = Sequential() # 将输入图像从 2D 重新塑形为 1D 的第一层 model.add(Reshape((input_dim, ), input_shape=(img_length, img_width))) # 8 个神经元的全连接层 model.add(Dense(8, activation='relu')) # 输出层 model.add(Dense(total_classes, activation='softmax')) # 编译模型 model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) history = model.fit(x_train, y_train, validation_split=0.33, epochs=epochs, batch_size=10, verbose=0) # 准备 pandas DataFrame df_history = pd.DataFrame(history.history) print(df_history) # 在 Seaborn 中绘制损失 my_plot = sns.lineplot(data=df_history[["loss","val_loss"]]) my_plot.set_xlabel('Epochs') my_plot.set_ylabel('Loss') plt.legend(labels=["训练", "验证"]) plt.title('训练和验证损失') plt.show() |
正如您所料，如果我们需要精确控制 x 坐标和 y 坐标，我们也可以像上面的 Seaborn 散点图示例中那样，在调用 lineplot() 时同时提供 x 和 y 参数以及 data 参数。
Bokeh 也可以生成多线图，如下面的代码所示。正如我们在散点图示例中看到的，我们需要明确提供 x 和 y 坐标，并一次绘制一条线。同样，show() 方法会打开一个新浏览器窗口来显示图，您可以与它进行交互。
|
1 2 3 4 5 6 7 8 9 10 |
p = figure(title="训练和验证准确率", x_axis_label="Epochs", y_axis_label="准确率") epochs_array = np.arange(epochs) p.line(epochs_array, df_history['accuracy'], legend_label="训练", color="蓝色", line_width=2) p.line(epochs_array, df_history['val_accuracy'], legend_label="验证", color="绿色") p.legend.click_policy = "隐藏" p.legend.location = '右下' show(p) |
使用 Bokeh 绘制的多线图。请注意右侧工具栏上显示的用户交互选项。
制作 Bokeh 图的完整代码如下
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
from tensorflow.keras.datasets import mnist from tensorflow.keras import utils from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Reshape import numpy as np import pandas as pd from bokeh.plotting import figure, show # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 验证训练数据的形状 total_examples, img_length, img_width = x_train.shape print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) # 准备分类器网络 epochs = 10 y_train = utils.to_categorical(train_labels) input_dim = img_length*img_width # 创建 Sequential 模型 model = Sequential() # 将输入图像从 2D 重新塑形为 1D 的第一层 model.add(Reshape((input_dim, ), input_shape=(img_length, img_width))) # 8 个神经元的全连接层 model.add(Dense(8, activation='relu')) # 输出层 model.add(Dense(total_classes, activation='softmax')) # 编译模型 model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) history = model.fit(x_train, y_train, validation_split=0.33, epochs=epochs, batch_size=10, verbose=0) # 准备 pandas DataFrame df_history = pd.DataFrame(history.history) print(df_history) # 在 Bokeh 中绘制准确率 p = figure(title="训练和验证准确率", x_axis_label="Epochs", y_axis_label="准确率") epochs_array = np.arange(epochs) p.line(epochs_array, df_history['accuracy'], legend_label="训练", color="蓝色", line_width=2) p.line(epochs_array, df_history['val_accuracy'], legend_label="验证", color="绿色") p.legend.click_policy = "隐藏" p.legend.location = '右下' show(p) |
更多可视化内容
我们上面介绍的每个工具都有更多的功能，可以让我们控制可视化的细节。搜索它们各自的文档以了解如何完善您的图表非常重要。同样重要的是查看其文档中的示例代码，以了解如何使您的可视化效果更好。
无需提供太多细节，这里有一些您可能希望添加到可视化中的想法
- 添加辅助线，例如在时间序列数据上标记训练和验证数据集。Matplotlib 的
axvline()函数可以为此目的在图表上绘制垂直线。 - 添加注释，例如箭头和文本标签，以识别图上的关键点。请参阅 Matplotlib 坐标轴对象中的
annotate()函数。 - 在图形元素重叠的情况下控制透明度级别。我们上面介绍的所有绘图函数都允许使用
alpha参数，提供一个介于 0 和 1 之间的值来表示我们可以透过图形看到多少。 - 如果数据通过这种方式更好地说明，我们可能会以对数刻度显示一些轴。它通常被称为对数图或半对数图。
在结束本文之前，以下是一个在 Matplotlib 中创建并排可视化的示例，其中一个使用 Seaborn 创建
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
from tensorflow.keras.datasets import mnist from tensorflow.keras import utils from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Reshape from tensorflow import dtypes, tensordot from tensorflow import convert_to_tensor, linalg, transpose import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 验证训练数据的形状 total_examples, img_length, img_width = x_train.shape print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) # 将数据集转换为 18623 x 784 形状的二维数组 x = convert_to_tensor(np.reshape(x_train, (x_train.shape[0], -1)), dtype=dtypes.float32) # 从 784 x 784 矩阵进行特征分解 eigenvalues, eigenvectors = linalg.eigh(tensordot(transpose(x), x, axes=1)) # 打印三个最大的特征值 print('3 个最大的特征值: ', eigenvalues[-3:]) # 将数据投影到特征向量上 x_pca = tensordot(x, eigenvectors, axes=1) # 准备分类器网络 epochs = 10 y_train = utils.to_categorical(train_labels) input_dim = img_length*img_width # 创建 Sequential 模型 model = Sequential() # 将输入图像从 2D 重新塑形为 1D 的第一层 model.add(Reshape((input_dim, ), input_shape=(img_length, img_width))) # 8 个神经元的全连接层 model.add(Dense(8, activation='relu')) # 输出层 model.add(Dense(total_classes, activation='softmax')) # 编译模型 model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) history = model.fit(x_train, y_train, validation_split=0.33, epochs=epochs, batch_size=10, verbose=0) # 准备 pandas DataFrame df_history = pd.DataFrame(history.history) print(df_history) # 并排绘图 fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(15,6)) # 左图 scatter = ax[0].scatter(x_pca[:, -1], x_pca[:, -2], c=train_labels, s=5) legend_plt = ax[0].legend(*scatter.legend_elements(), loc="左下", title="数字") ax[0].add_artist(legend_plt) ax[0].set_title('应用 PCA 后投影数据的前两个维度') # 右图 my_plot = sns.lineplot(data=df_history[["loss","val_loss"]], ax=ax[1]) my_plot.set_xlabel('Epochs') my_plot.set_ylabel('Loss') ax[1].legend(labels=["训练", "验证"]) ax[1].set_title('训练和验证损失') plt.show() |
使用 Matplotlib 和 Seaborn 创建的并排可视化
Bokeh 中的等效操作是分别创建每个子图，然后在显示时指定布局
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
from tensorflow.keras.datasets import mnist from tensorflow.keras import utils from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Reshape from tensorflow import dtypes, tensordot from tensorflow import convert_to_tensor, linalg, transpose import numpy as np import pandas as pd from bokeh.plotting import figure, show from bokeh.layouts import row # 加载数据集 (x_train, train_labels), (_, _) = mnist.load_data() # 只选择数字 0, 1, 2 total_classes = 3 ind = np.where(train_labels < total_classes) x_train, train_labels = x_train[ind], train_labels[ind] # 验证训练数据的形状 total_examples, img_length, img_width = x_train.shape print('训练数据包含 ', total_examples, '张图片') print('每张图片的大小为 ', img_length, 'x', img_width) # 将数据集转换为 18623 x 784 形状的二维数组 x = convert_to_tensor(np.reshape(x_train, (x_train.shape[0], -1)), dtype=dtypes.float32) # 从 784 x 784 矩阵进行特征分解 eigenvalues, eigenvectors = linalg.eigh(tensordot(transpose(x), x, axes=1)) # 打印三个最大的特征值 print('3 个最大的特征值: ', eigenvalues[-3:]) # 将数据投影到特征向量上 x_pca = tensordot(x, eigenvectors, axes=1) # 准备分类器网络 epochs = 10 y_train = utils.to_categorical(train_labels) input_dim = img_length*img_width # 创建 Sequential 模型 model = Sequential() # 将输入图像从 2D 重新塑形为 1D 的第一层 model.add(Reshape((input_dim, ), input_shape=(img_length, img_width))) # 8 个神经元的全连接层 model.add(Dense(8, activation='relu')) # 输出层 model.add(Dense(total_classes, activation='softmax')) # 编译模型 model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) history = model.fit(x_train, y_train, validation_split=0.33, epochs=epochs, batch_size=10, verbose=0) # 准备 pandas DataFrame df_history = pd.DataFrame(history.history) print(df_history) # 在 Bokeh 中创建散点图 colormap = {0: "red", 1:"green", 2:"blue"} my_scatter = figure(title="应用 PCA 后投影数据的前两个维度", x_axis_label="维度 1", y_axis_label="维度 2", width=500, height=400) for digit in [0, 1, 2]: selection = x_pca[train_labels == digit] my_scatter.scatter(selection[:,-1].numpy(), selection[:,-2].numpy(), color=colormap[digit], size=5, alpha=0.5, legend_label="数字 "+str(digit)) my_scatter.legend.click_policy = "隐藏" # 在 Bokeh 中绘制准确率 p = figure(title="训练和验证准确率", x_axis_label="Epochs", y_axis_label="准确率", width=500, height=400) epochs_array = np.arange(epochs) p.line(epochs_array, df_history['accuracy'], legend_label="训练", color="蓝色", line_width=2) p.line(epochs_array, df_history['val_accuracy'], legend_label="验证", color="绿色") p.legend.click_policy = "隐藏" p.legend.location = '右下' show(row(my_scatter, p)) |
在 Bokeh 中创建的并排图
进一步阅读
如果您想深入了解，本节提供了更多关于该主题的资源。
书籍
- 《像计算机科学家一样思考 Python》 作者：Allen B. Downey
- 《Python 3 编程：Python 语言完整介绍》作者：Mark Summerfield
- 《Python 编程：计算机科学入门》作者：John Zelle
- 《Python 数据分析》第 2 版，作者：Wes McKinney
文章
API 参考
- matplotlib.pyplot.scatter
- matplotlib.pyplot.plot
- seaborn.scatterplot
- seaborn.lineplot
- Bokeh 基本图形绘图
- Bokeh 散点图
- Bokeh 折线图
总结
在本教程中，您了解了在 Python 中进行数据可视化的各种选项。
具体来说，你学到了：
- 如何创建不同行和列的子图
- 如何使用 Matplotlib 渲染图像
- 如何使用matplotlib生成2D和3D散点图
- 如何使用Seaborn和Bokeh创建2D图表
- 如何使用matplotlib、Seaborn和Bokeh创建多行图表
您对本文讨论的数据可视化选项有任何疑问吗？请在下面的评论中提出您的问题，我将尽力回答。
掌握机器学习 Python！
更自信地用 Python 编写代码
...从学习实用的 Python 技巧开始
在我的新电子书中探索如何实现
用于机器学习的 Python
它提供自学教程和数百个可运行的代码，为您提供包括以下技能：
调试、性能分析、鸭子类型、装饰器、部署等等...
致Jason Brownlee和团队，
我阅读了你们YouTube频道上所有关于GAN的博客，非常有趣且解释得很完整。只想说，你们能否在生成模型演进方面进行一些扩展，简单来说就是，“如何找到生成模型的收敛性？”目前我正在做一个CGAN项目。我也在尝试这个扩展。所以如果您有任何建议，请告诉我。
谢谢你。
我认为第一行代码有拼写错误，‘boken’而不是‘bokeh’。
感谢您的反馈，Richard！
愿上帝保佑您，
如何在我们的论文中引用您的博客
我觉得“可视化”这个标题有点误导。您只是简单地绘制了准确度曲线并显示了原始数据。对我来说，机器学习可视化通常是实际机器学习的视觉表现。聚类图、热图、PDFs…
这里有一些不错的知识，但我真的不认为这是可视化
感谢您的反馈，Perri！