Python基于Tensorflow2.X实现汽车油耗预测

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, datasets, losses
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

import matplotlib
print(matplotlib.matplotlib_fname())

# 在线下载汽车效能数据集
dataset_path = keras.utils.get_file("auto-mpg.data", 
"http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
# 字段有效能（公里数每加仑） 气缸数 排量 马力 重量 加速度 型号年份 产地
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
 'Acceleration', 'Model Year', 'Origin']
raw_dataset = pd.read_csv(dataset_path, names=column_names,
 na_values = "?", comment='\t',
 sep=" ", skipinitialspace=True)

dataset = raw_dataset.copy()
# 查看部分数据
dataset.head(8)

begin = dataset.isna().sum()  # 统计空白数据
dataset = dataset.dropna()  # 删除空白数据项
end = dataset.isna().sum()  # 再次统计空白数据
print(f'========统计前:========\n{begin}\n========统计后:========\n{end}')
# 输出结果:
========统计前:========
MPG             0
Cylinders       0
Displacement    0
Horsepower      6
Weight          0
Acceleration    0
Model Year      0
Origin          0
dtype: int64
========统计后:========
MPG             0
Cylinders       0
Displacement    0
Horsepower      0
Weight          0
Acceleration    0
Model Year      0
Origin          0
dtype: int64

# 先弹出（删除并返回）Origin这一列
origin = dataset.pop('Origin')
# 根据origin列的数据来写入新的3个列
dataset['USA'] = (origin == 1) * 1.0
dataset['Europe'] = (origin == 2) * 1.0
dataset['Japan'] = (origin == 3) * 1.0
dataset.tail()

# 切分为训练集和测试集
train_dataset = dataset.sample(frac=0.8, random_state=0)
test_dataset = dataset.drop(train_dataset.index)

# 查看训练集的输入x的统计数据
train_stats = train_dataset.describe()
train_stats = train_stats.transpose()  # 转置
train_stats

# 移动MPG油耗效能这一列为真实标签Y
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')

# 标准化数据
def norm(x):
    # 减去每个字段的均值并除以标准差
    return (x - train_stats['mean']) / train_stats['std']
 
normed_train_data = norm(train_dataset)  # 标准化训练集
normed_test_data = norm(test_dataset)  # 标准化测试集
print(f'训练集大小:{normed_train_data.shape}  {train_labels.shape}')
print(f"测试集大小:{normed_test_data.shape}  {test_labels.shape}")
normed_train_data  # 查看数据处理后的训练集
# 利用切分的训练集构建数据集对象
train_db = tf.data.Dataset.from_tensor_slices((normed_train_data.values, train_labels.values))  # 构建Dataset对象
# 为防止数据标准化后出现梯度弥散，切分训练集，分为几个batch，加速计算
train_db = train_db.shuffle(100).batch(32)  # 随机打散，批量化
 
# 输出结果:
训练集大小:(314, 9)  (314,)
测试集大小:(78, 9)  (78,)

# 创建同y轴的上下三联图，需要plt.subplots()
fig, axes = plt.subplots(nrows=1,ncols=3,sharey=True,figsize=(20,6)) 
fig.suptitle('各个字段对MPG的影响', fontsize=16)
#subplot1
axes[0].scatter(train_dataset['Cylinders'].to_numpy(), train_labels.to_numpy(), color='b',s=20)
axes[0].set_xlabel('Cylinders', fontsize=13)
axes[0].set_ylabel('MPG', fontsize=14)
#subplot2
axes[1].scatter(train_dataset['Displacement'].to_numpy(), train_labels.to_numpy(), color='b',s=20)
axes[1].set_xlabel('Displacement', fontsize=13)
#subplot3
axes[2].scatter(train_dataset['Weight'].to_numpy(), train_labels.to_numpy(), color='b',s=20)
axes[2].set_xlabel('Weight', fontsize=13)
 
#展示图片
plt.show()

class Network(keras.Model):
    # 回归网络模型
    def __init__(self):
        super(Network, self).__init__()
        # 创建3个全连接层
        self.fc1 = layers.Dense(64, activation='relu', name='Layer1')
        self.fc2 = layers.Dense(64, activation='relu', name='Layer2')
        self.fc3 = layers.Dense(1, name='OutputLayer')
        
    def call(self, inputs, training=None, mask=None):
        # 依次通过3个全连接层
        x = self.fc1(inputs)
        x = self.fc2(x)
        x = self.fc3(x)
        return x

# 创建网络类实例
model = Network()
# 通过build函数完成内部张量的创建（其中4为任意设置的batch量，9为输入特征长度）
model.build(input_shape=(4, 9))
# 打印网络信息
model.summary()
# 创建优化器，指定学习率为0.001
optimizers = tf.keras.optimizers.RMSprop(0.001)

# 接下来实现网络训练部分。通过 Epoch 和 Step 组成的双层循环训练网络，共训练 200 个 Epoch
Epoch =  np.arange(0, 200)
train_MAE = np.zeros(200)
test_MAE = np.zeros(200)
 
for epoch in range(200):
    for step, (x, y) in enumerate(train_db):  # 遍历依次训练集
        # 梯度记录器
        with tf.GradientTape() as tape:
            out = model(x)  # 通过网络获得输出
            loss = tf.reduce_mean(losses.MSE(y, out))
            mae_loss = tf.reduce_mean(losses.MAE(y, out)) # 计算 MAE
            # 计算梯度并更新
            grads = tape.gradient(loss, model.trainable_variables)
            Optimizers.apply_gradients(zip(grads, model.trainable_variables))
    train_MAE[epoch] = float(mae_loss)
    out = model(tf.constant(normed_test_data.values))
    test_MAE[epoch] = tf.reduce_mean(losses.MAE(test_labels, out))

plt.xlabel('Epoch')
plt.ylabel('MAE')
plt.plot(Epoch, train_MAE, label="Train")
plt.plot(Epoch, test_MAE, label="Test")
plt.title('汽车油耗实战')
plt.legend(['Train', 'Test'])  # 设置折线名称
plt.show()