基于TensorFlow实现预测房价--回归问题

左手的ㄟ右手 2023-02-27 10:36 1阅读 0赞

## 写在前面 ##

分类问题的目标是预测输入数据点所对应的单一离散的标签。另一种常见的机器学习问题是回归问题，它预测一个连续值而不是离散的标签，例如，根据气象数据 预测明天的气温，或者根据软件说明书预测完成软件项目所需要的时间。

> 不要将回归问题与 logistic 回归算法混为一谈。令人困惑的是，logistic 回归不是回归算法， 而是分类算法。

## 波士顿房价数据集 ##

本文将要预测20 世纪70 年代中期波士顿郊区房屋价格的中位数，已知当时郊区的一些数据点，比如犯罪率、当地房产税率等。本节用到的数据集与前面两个例子有一个有趣的区别。 它包含的数据点相对较少，只有506 个，分为404 个训练样本和102 个测试样本。输入数据的 每个特征（比如犯罪率）都有不同的取值范围。例如，有些特性是比例，取值范围为0~ 1；有 的取值范围为 1 ~ 12；还有的取值范围为 0~100，等等。

from tensorflow.keras.datasets import boston_housing
    
    (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()
    
    
    print(train_data.shape )
    #(404, 13) 
    print(test_data.shape) 
    # (102, 13)

如你所见，我们有404 个训练样本和 102 个测试样本，每个样本都有13 个数值特征，比如 人均犯罪率、每个住宅的平均房间数、高速公路可达性等。 目标是房屋价格的中位数，单位是千美元。

print(train_targets)
    #array([ 15.2, 42.3, 50. ... 19.4, 19.4, 29.1])

## 准备数据 ##

将取值范围差异很大的数据输入到神经网络中，这是有问题的。网络可能会自动适应这种 取值范围不同的数据，但学习肯定变得更加困难。对于这种数据，普遍采用的最佳实践是对每 个特征做标准化，即对于输入数据的每个特征（输入数据矩阵中的列），减去特征平均值，再除 以标准差，这样得到的特征平均值为 0，标准差为 1。用 Numpy 可以很容易实现标准化。

mean = train_data.mean(axis=0)
    train_data -= mean
    std = train_data.std(axis=0)
    train_data /= std
    
    test_data -= mean
    test_data /= std

注意，用于测试数据标准化的均值和标准差都是在训练数据上计算得到的。在工作流程中，  
你不能使用在测试数据上计算得到的任何结果，即使是像数据标准化这么简单的事情也不行。

## 构建网络 ##

由于样本数量很少，我们将使用一个非常小的网络，其中包含两个隐藏层，每层有64 个单 元。一般来说，训练数据越少，过拟合会越严重，而较小的网络可以降低过拟合。

def build_model():
      model = models.Sequential()
      model.add(layers.Dense(64, activation='relu',
              input_shape=(train_data.shape[1],)))
      model.add(layers.Dense(64, activation='relu'))
      model.add(layers.Dense(1))
      model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
      return model

网络的最后一层只有一个单元，没有激活，是一个线性层。这是标量回归（标量回归是预 测单一连续值的回归）的典型设置。添加激活函数将会限制输出范围。例如，如果向最后一层 添加 sigmoid 激活函数，网络只能学会预测0~1 范围内的值。这里最后一层是纯线性的，所以 网络可以学会预测任意范围内的值。 注意，`编译网络用的是 mse 损失函数，即均方误差（MSE，mean squared error）`，预测值与 目标值之差的平方。这是回归问题常用的损失函数。 `在训练过程中还监控一个新指标：平均绝对误差（MAE，mean absolute error）`。它是预测值 与目标值之差的绝对值。比如，如果这个问题的MAE 等于0.5，就表示你预测的房价与实际价 格平均相差 500 美元。

## 利用 K 折验证来验证你的方法 ##

为了在调节网络参数（比如训练的轮数）的同时对网络进行评估，你可以将数据划分为训 练集和验证集，正如前面例子中所做的那样。但由于数据点很少，验证集会非常小（比如大约 100 个样本）。因此，验证分数可能会有很大波动，这取决于你所选择的验证集和训练集。也就 是说，验证集的划分方式可能会造成验证分数上有很大的方差，这样就无法对模型进行可靠的 评估。 在这种情况下，最佳做法是使用 K 折交叉验证。这种方法将可用数据划分为 K 个分区（K 通常取 4 或 5），实例化K 个相同的模型，将每个模型在 K-1 个分区上训练，并在剩 下的一个分区上进行评估。模型的验证分数等于K 个验证分数的平均值。这种方法的代码实现 很简单。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RCQ18xMjE_size_16_color_FFFFFF_t_70_pic_center]

import numpy as np 
    
    k = 4 
    num_val_samples = len(train_data) // k 
    num_epochs = 100 
    all_scores = [] 
    
    for i in range(k):
      print('processing fold #', i)     
      val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]      
      val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples] 
      
      partial_train_data = np.concatenate(           
          [train_data[:i * num_val_samples],          
           train_data[(i + 1) * num_val_samples:]],          
           axis=0)     
      partial_train_targets = np.concatenate(         
          [train_targets[:i * num_val_samples],          
           train_targets[(i + 1) * num_val_samples:]],          
           axis=0) 
     
      model = build_model()      
      model.fit(partial_train_data, partial_train_targets,
            epochs=num_epochs, batch_size=1, verbose=0)
      val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)      
      all_scores.append(val_mae) 
    
    print(all_scores)

![在这里插入图片描述][20200716235944754.png_pic_center]

print(np.mean(all_scores))
    #2.9947904173572462

每次运行模型得到的验证分数有很大差异，从2.6 到 3.2 不等。平均分数（3.0）是比单一 分数更可靠的指标——这就是K 折交叉验证的关键。在这个例子中，预测的房价与实际价格平 均相差 3000 美元，考虑到实际价格范围在 10 000~50 000 美元，这一差别还是很大的。 我们让训练时间更长一点，达到500 个轮次。为了记录模型在每轮的表现，我们需要修改 训练循环，以保存每轮的验证分数记录。

num_epochs = 500  
    all_mae_histories = []  
    for i in range(k):     
    	print('processing fold #', i)     
    	val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]        
    	val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples] 
     
        partial_train_data = np.concatenate(            
        			[train_data[:i * num_val_samples],          
        			train_data[(i + 1) * num_val_samples:]],          
        			axis=0) 
     
        partial_train_targets = np.concatenate(         
        			[train_targets[:i * num_val_samples],          
        			train_targets[(i + 1) * num_val_samples:]],         
        			axis=0) 
     
        model = build_model()       
        history = model.fit(partial_train_data, partial_train_targets,                           
        					validation_data=(val_data, val_targets),                         
        					epochs=num_epochs, batch_size=1, verbose=0)     
        mae_history = history.history['val_mean_absolute_error']     
        all_mae_histories.append(mae_history)

然后你可以计算每个轮次中所有折 MAE 的平均值。

average_mae_history = [     
      np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)] 
    
    plt.plot(range(1, len(average_mae_history) + 1), average_mae_history) 
    plt.xlabel('Epochs') 
    plt.ylabel('Validation MAE') 
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RCQ18xMjE_size_16_color_FFFFFF_t_70_pic_center 1]  
因为纵轴的范围较大，且数据方差相对较大，所以难以看清这张图的规律。我们来重新绘 制一张图。

*  删除前 10 个数据点，因为它们的取值范围与曲线上的其他点不同。
 *  将每个数据点替换为前面数据点的指数移动平均值，以得到光滑的曲线。

def smooth_curve(points, factor=0.9):   
    	smoothed_points = []   
    	for point in points:     
    		if smoothed_points:       
    			previous = smoothed_points[-1]       
    			smoothed_points.append(previous * factor + point * (1 - factor))     
    		else:       
    			smoothed_points.append(point)   
    	return smoothed_points 
     
    smooth_mae_history = smooth_curve(average_mae_history[10:]) 
     
    plt.plot(range(1, len(smooth_mae_history) + 1), smooth_mae_history) 
    plt.xlabel('Epochs') 
    plt.ylabel('Validation MAE') 
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RCQ18xMjE_size_16_color_FFFFFF_t_70_pic_center 2]  
完成模型调参之后（除了轮数，还可以调节隐藏层大小），你可以使用最佳参数在所有训练数据上训练最终的生产模型，然后观察模型在测试集上的性能。

model = build_model()    
    model.fit(train_data, train_targets,              
    		epochs=80, batch_size=16, verbose=0) 
    test_mse_score, test_mae_score = model.evaluate(test_data, test_targets)

## 完整代码 ##

from tensorflow.keras.datasets import boston_housing
    from tensorflow.keras import models
    from tensorflow.keras import layers
    import matplotlib.pyplot as plt
    import numpy as np
    
    (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()
    
    mean = train_data.mean(axis=0)
    train_data -= mean
    std = train_data.std(axis=0)
    train_data /= std
    
    test_data -= mean
    test_data /= std
    
    
    def build_model():     
      model = models.Sequential()       
      model.add(layers.Dense(64, activation='relu',                            
              input_shape=(train_data.shape[1],)))     
      model.add(layers.Dense(64, activation='relu'))     
      model.add(layers.Dense(1))     
      model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])     
      return model
    
    
    k = 4 
    num_val_samples = len(train_data) // k 
    # num_epochs = 100 
    # all_scores = [] 
    
    # for i in range(k):
    # print('processing fold #', i) 
    # val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples] 
    # val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples] 
      
    # partial_train_data = np.concatenate( 
    # [train_data[:i * num_val_samples], 
    # train_data[(i + 1) * num_val_samples:]], 
    # axis=0) 
    # partial_train_targets = np.concatenate( 
    # [train_targets[:i * num_val_samples], 
    # train_targets[(i + 1) * num_val_samples:]], 
    # axis=0) 
     
    # model = build_model() 
    # model.fit(partial_train_data, partial_train_targets,
    # epochs=num_epochs, batch_size=1, verbose=0)
    # val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0) 
    # all_scores.append(val_mae) 
    
    # print(all_scores)
    
    num_epochs = 500  
    all_mae_histories = []  
    for i in range(k):     
      print('processing fold #', i)     
      val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]      
      val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples] 
    
      partial_train_data = np.concatenate(           
          [train_data[:i * num_val_samples],          
           train_data[(i + 1) * num_val_samples:]],          
           axis=0)     
      partial_train_targets = np.concatenate(         
          [train_targets[:i * num_val_samples],          
           train_targets[(i + 1) * num_val_samples:]],          
           axis=0) 
    
      model = build_model()       
      history = model.fit(partial_train_data, partial_train_targets,                           
                validation_data=(val_data, val_targets),                         
                epochs=num_epochs, batch_size=1, verbose=0)     
      mae_history = history.history['val_mean_absolute_error']     
      all_mae_histories.append(mae_history) 
    
    average_mae_history = [     
      np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)] 
    
    plt.plot(range(1, len(average_mae_history) + 1), average_mae_history) 
    plt.xlabel('Epochs') 
    plt.ylabel('Validation MAE') 
    plt.show()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RCQ18xMjE_size_16_color_FFFFFF_t_70_pic_center]: /images/20230209/f983148ba2574aada3dc8505900549e6.png
[20200716235944754.png_pic_center]: https://img-blog.csdnimg.cn/20200716235944754.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RCQ18xMjE_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200717001251298.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RCQ18xMjE=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RCQ18xMjE_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200717001104640.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0RCQ18xMjE=,size_16,color_FFFFFF,t_70#pic_center