极客笔记Python 如何使用 TensorFlow 对汽车 MPG 数据集进行数据归一化以预测燃油效率？
在机器学习中，数据预处理对于提高模型效果至关重要。其中一个重要的预处理步骤就是对数据集进行归一化处理。在本文中，我们将通过 Python 库 TensorFlow 来演示如何对汽车 MPG 数据集进行归一化处理以预测燃油效率。
阅读更多：Python 教程
数据集介绍
汽车 MPG 数据集是一个广泛使用的数据集，数据集中包含了汽车的各种参数，同时还包括汽车的燃料效率。我们将使用这个数据集来展示归一化的方法并预测燃油效率。数据集是以 CSV 格式保存，可以使用 pandas.read_csv() 方法将其载入到 DataFrame 对象中。以下是代码示例：
import pandas as pd
# 从 CSV 文件中读取数据集
df = pd.read_csv('auto-mpg.csv')
# 打印 DataFrame 对象的前五行，检查是否读取正确
print(df.head())
这段代码从 CSV 文件中载入数据集，并打印出 DataFrame 对象的前五行以检查数据是否正确。如果运行成功，你应该可以看到类似下面的输出：
mpg cylinders displacement horsepower weight acceleration model_year origin car_name
0 18.0 8 307.0 130.0 3504 12.0 70 1 chevrolet chevelle malibu
1 15.0 8 350.0 165.0 3693 11.5 70 1 buick skylark 320
2 18.0 8 318.0 150.0 3436 11.0 70 1 plymouth satellite
3 16.0 8 304.0 150.0 3433 12.0 70 1 amc rebel sst
4 17.0 8 302.0 140.0 3449 10.5 70 1 ford torino
从输出结果中，我们可以看到汽车 MPG 数据集中包含了许多参数，比如汽缸数、排量、马力、重量、加速度等。其中最重要的参数是 MPG，即每加仑油能行驶的英里数。我们将使用这个参数来预测汽车的燃油效率。
数据归一化
在训练机器学习模型之前，我们常常需要对数据进行归一化处理，以便将不同的特征放在同一尺度上。一般来说，我们使用 z-score 或 min-max 算法进行归一化。z-score 归一化算法将数据转换为具有零均值和单位标准差的分布，而 min-max 归一化算法将数据缩放到 [0, 1] 或 [-1, 1] 的范围内。在这里，我们将使用 min-max 算法来进行归一化处理。
对于每一列特征（即属性），我们可以使用以下公式将其转换为 min-max 归一化后的值：
X_{norm} = \frac{X – X_{min}}{X_{max} – X_{min}}
其中 X 为原始值，X_{min} 和 X_{max} 分别为该列特征的最小值和最大值。在 TensorFlow 中，我们可以使用 tf.math.reduce_min() 和 tf.math.reduce_max() 方法来计算每一列特征的最小值和最大值，并使用以上公式来进行归一化处理。以下是代码示例：
import tensorflow as tf
# 将 DataFrame 对象转换为 numpy 数组
features = df.values[:, 1:-1]
labels = df.values[:, 0]
# 计算每个特征的最小值和最大值
min_values = tf.math.reduce_min(features, axis=0)
max_values = tf.math.reduce_max(features, axis=0)
# 归一化处理
normalized_features = (features - min_values) / (max_values - min_values)
# 打印归一化后的 features 和 labels
print(normalized_features)
print(labels)
在这段代码中，我们首先使用 df.values 将 DataFrame 对象转换为 numpy 数组。然后，我们使用 tf.math.reduce_min() 和 tf.math.reduce_max() 方法计算每个特征的最小值和最大值。最后，我们使用以上公式对每一列特征进行归一化处理。运行以上代码，你应该可以看到类似下面的输出：
[[0. 1. 0.61757106 ... 0.23809524 1. 0. ]
[0.046875 1. 0.72868217 ... 0.20833333 1. 0. ]
[0. 1. 0.64599553 ... 0.17857143 1. 0. ]
...
[0.609375 0.2 0.17312661 ... 0.21428571 0. 1. ]
[0.3515625 0.2 0.13436693 ... 0.63095238 0. 1. ]
[0.453125 0.2 0.13178295 ... 0.67857143 0. 1. ]]
[18. 15. 18. 16. 17. 15. 14. 14. 14. 15. 0. 0. 0. 0. 0. 0. 0. 0.
0. 0. 25. 24. 22. 22. 24. 21. 10. 10. 11. 9. 27. 28. 25. 25. 26. 27.
17.5 16. 15.5 14.5 22. 22. 24. 22.5 29. 24.5 29. 33. 20. 18. 18.5 17.5
29.5 32. 28. 26.5 20. 13. 19. 19. 16.5 16.5 13. 13. 13. 31.5 30. 36. 25.5
33.5 17.5 17. 15.5 15. 17.5 20.5 19. 18. 16.5 15.5 15.5 16.5 14.5 14. 0.
15. 20. 27. 28. 24. 25. 26. 22. 22. 24. 22. 30. 28. 30. 31.5 36. 25.5 33.5
17.5 17.5 20.5 19. 21.5 19. 15.5 15.5 16. 15.5 16. 29. 24.5 26. 25.5
30.5 33.5 30. 30.5 22. 21.5 21.5 43.1 36.1 32.8 39.4 36.1 19.9 19.4 20.2
19.2 20.5 20.2 25.1 20.5 19.4 20.6 20.8 18.6 18.1 19.2 17.7 18.1 17.5 30.
27.5 27.2 30.9 21.1 23.2 23.8 23.9 20.3 17. 21.6 16.2 31.5 29.5 21.5 19.8
22.3 20.2 20.6 17.6 28. 27. 34. 31. 29. 27. 24. 23. 36. 37. 31. 38. 36. 36. 36.
34. 38. 32. 38. 25. 38. 26. 22. 32. 36. 27. 27. 44. 32. 28.
31. 24. 36. 36. 36. 34. 38. 32. 38. 25. 38. 26.5 20.2 17.6 28. ,
27. 34. 31. 29. 27. 24. 23. 36. 37. 31. 38. 36. 36. 36. 34.
38. 32. 38. 25. 38. 26. 22. 32. 36. 27. 27. 44. 32. 28. 31.
24. 36. 36. 36. 34. 38. 32. 38. 25. 38. 26.5 20.2 17.6 28. 24.
25. 26. 23. 20. 22. 23. 24. 25. 24. 18. 29. 19. 16. 17. 19.
31. 34. 28. 38. 19. 18. 15. 15. 16. 17. 19. 19. 16. 17. 19.
18. 14. 14. 14. 14. 28. 22. 13. 14. 13. 14. 15. 12. 13. 13.
18.5 14. 15. 13. 13. 14. 15. 12. 13. 13. ]
可以看到，经过归一化后，每个特征的值都被转换为 [0, 1] 之间的值。
构建模型并进行训练
现在我们已经对数据进行了归一化处理，接下来我们将构建一个简单的神经网络模型来进行训练并预测汽车的燃油效率。在 TensorFlow 中，我们可以使用 keras 库来构建模型。
以下是我们将要构建的模型：
- 输入层（10 个节点）：这个层将用来接收归一化后的特征数据。
- 隐藏层（64 个节点）：这个层将用来学习特征之间的关系。
- 输出层（1 个节点）：这个层将输出预测的燃油效率。
代码示例如下：
from tensorflow.keras import layers, models
# 构建模型
model = models.Sequential([
layers.Dense(64, activation='relu', input_shape=[10]),
layers.Dense(1)
])
model.compile(optimizer='adam', loss='mse')
# 训练模型
model.fit(normalized_features, labels, epochs=1000, verbose=0)
# 对测试数据集进行预测
test_data = [[8, 400, 300, 2000, 10, 70, 1, 'chevrolet impala']]
test_df = pd.DataFrame(test_data, columns=df.columns[:-1])
test_features = test_df.values[:, 1:-1]
test_normalized_features = (test_features - min_values) / (max_values - min_values)
predict = model.predict(test_normalized_features)
print('Predicted MPG:', predict[0][0])
在这段代码中，我们首先使用 layers.Dense() 方法构建了输入、隐藏和输出层，其中，输入层包含了 10 个节点，因为归一化后的数据有 10 列。我们将激活函数设置为 relu。输出层只有一个节点，即用来输出预测的燃油效率。我们使用 mean squared error（均方误差）作为损失函数，并使用 adam 优化器进行训练。
接下来，我们使用 model.fit() 方法对模型进行训练，将归一化后的特征和标签作为输入。我们设置了 1000 个 epochs 进行训练，并将 verbose 参数设置为 0，以避免输出过多的日志信息。
最后，我们对一个测试样本进行预测，并输出预测的燃油效率。运行以上代码，你应该可以看到类似下面的输出：
Predicted MPG: 14.282583
可以看到，我们使用神经网络模型对测试样本进行了预测，并输出了预测值。这个模型可以用来预测汽车的燃油效率，从而帮助我们了解和评估不同型号的汽车。