【深度学习】DNN房价预测

前言

我们使用深度学习网络实现波士顿房价预测，深度学习的目的就是寻找一个合适的函数输出我们想要的结果。深度学习实际上是机器学习领域中一个研究方向，深度学习的目标是让机器能够像人一样具有分析学习的能力，能够识别文字、图像、声音等数据。我认为深度学习与机器学习最主要的区别就是神经元。
深度学习中重要内容

建立模型——神经元

• 基本构造
  
  
  
  
  • 一个神经元对应一组权重w，a代表输入，我们把输入与权重相乘再相加，再加上偏置b，最后通过激活函得到对应的输出。
    
  • 我们不看激活函数，只看前面的部分会发现其实就是一个线性函数f=kx+b（k表示斜率，b表示截距）
    
  • w和b就是我们需要在训练中需要寻找的，
    
  • 学习网络就是通过很多个这样的神经元组合而成。
    
  
  

建立模型——激活函数

• 为什么引入激活函数
  
  
  
  • 激活函数是为了增强网络的表达能力，我们需要激活函数来将线性函数转变为非线性函数。
    
  • 非线性的激活函数需要有连续性，因为连续非线性激活函数可导的，所以可以用最优化的方法来求解
    
  
  
• 激活函数的种类
  

建立模型——前馈神经网络

• 我们输入1和-1分别和每一组的权重相乘相加得到4和-2的结果，然后经过激活函数（激活函数实际上也是一个简单函数，但是具有某些特性，可以用来解决问题的目的，例如激活函数是y=x-1,我们输入4，输出结果就是3。）得到0.98和0.12.依次往后计算就是前馈神经网络。
  

建立模型——深度神经网络

• 神经网络解决的问题有很多，例如分类、预测、回归等。这里我们给出两个解决类型。
  
• 分类
  
  
  
  • 输出层就是输入的数据维度，例如我们要分类图形是正方型还是长方形，那我们可以是3维的输入，一个内角，两条临边。就可以判断。也可以是五维的，一个内角，4条边）
    
  • 输出层y就是结果，就上面举例的图形分类，那结果可以有2个，长方形和正方形，例如y1代表长方形，y2代表正方形，输出的结果那个数值大就是那种类型，也可以增加一个都不是的结果）
    
  
  

• 预测
  
  
  
  • 今天的波士顿房价预测就是预测模型，我们通过地段，房屋面积等等，预测房价的多少。
    
  
  

损失函数

• 常用损失函数
  平方损失函数、交叉熵损失函数，不同的问题运用不同的损失函数
  
• 用于衡量我们输入结果和真实结果的差异
  
• 目的通过损失去修正我们的参数是我们的模型更完美
  

实践——波士顿房价预测

数据集

使用paddle飞桨波士顿数据集
https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/text/UCIHousing_cn.html
绘图

1. ## 绘图
3. Batch = 0
4. Batchs = []
5. all_train_accs = []
6. def draw_train_acc(Batchs,train_accs):
7.     title = "training accs"
8.     plt.title(title)
9.     plt.xlabel("batch")
10.     plt.ylabel("acc")
11.     plt.plot(Batchs, train_accs, color = 'green', label = 'training accs')
12.     plt.legend()
13.     plt.grid()
14.     plt.show()
17. all_train_loss = []
18. def draw_train_loss(Batchs,train_loss):
19.     title = "training loss"
20.     plt.title(title)
21.     plt.xlabel("batch")
22.     plt.ylabel("loss")
23.     plt.plot(Batchs, train_loss, color = 'red', label = 'training loss')
24.     plt.legend()
25.     plt.grid()
26.     plt.show()
28. ## 绘制真实值与预测值的对比图
29. def draw_infer_result(groud_truths, infer_results):
30.     title = 'Boston'
31.     plt.title(title)
32.     x = np.arange(1,20)
33.     y = x
34.     plt.plot(x,y);
35.     plt.xlabel("ground truth")
36.     plt.ylabel("infer result")
37.     plt.scatter(groud_truths,infer_results,color='green',label='training cost')
38.     plt.grid()
39.     plt.show()

复制代码

网络搭建

1. '''
2. 核心
4. 网络搭建
5. '''
7. class MyDNN(paddle.nn.Layer):
8.     def __init__(self):
9.         super(MyDNN, self).__init__()
11.         #self.linear1 = paddle.nn.Linear(13,1,None) #全连接层，paddle.nn.Linear(in_features,out_features,weight)
13.         self.linear1 = paddle.nn.Linear(13, 32, None)
15.         self.linear2 = paddle.nn.Linear(32, 64, None)
17.         self.linear3 = paddle.nn.Linear(64, 32, None)
19.         self.linear4 = paddle.nn.Linear(32, 1, None)
20.     def forward(self, inputs): ## 传播函数
21.         x = self.linear1(inputs)
22.         x = self.linear2(x)
23.         x = self.linear3(x)
24.         x = self.linear4(x)
25.         return x

复制代码

模型训练与测试

1. '''
2. 网络训练与测试
3. '''
6. ## 实例化
7. model = MyDNN()
8. model.train()
9. mse_loss = paddle.nn.MSELoss()
10. opt = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())
11. epochs_num = 100
14. for epochs in range(epochs_num):
15.     for batch_id,data in enumerate(train_loader()):
16.         feature = data[0]
17.         label = data[1]
18.         predict = model(feature)
19.         loss = mse_loss(predict, label)
20.         loss.backward()
21.         opt.step()
22.         opt.clear_grad()
23.         if batch_id!=0 and batch_id%10 == 0:
24.             Batch = Batch+10
25.             Batchs.append(Batch)
26.             all_train_loss.append(loss.numpy()[0])
27.             print("epoch{},step:{},train_loss:{}".format(epochs,batch_id,loss.numpy()[0]))
29. paddle.save(model.state_dict(),"UCIHousingDNN")
30. draw_train_loss(Batchs,all_train_loss)
34. para_state = paddle.load("UCIHousingDNN")
35. model = MyDNN()
36. model.eval()
37. model.set_state_dict(para_state)
38. losses = []
41. for batch_id,data in enumerate(eval_loader()):
42.     feature = data[0]
43.     label = data[1]
44.     predict = model(feature)
45.     loss = mse_loss(predict,label)
46.     losses.append(loss.numpy()[0])
47. avg_loss = np.mean(losses)
49. print(avg_loss)
52. draw_infer_result(label,predict)

复制代码

代码

1. ## 深度学习框架import paddleimport numpy as npimport osimport matplotlib.pyplot as plt## 绘图
3. Batch = 0
4. Batchs = []
5. all_train_accs = []
6. def draw_train_acc(Batchs,train_accs):
7.     title = "training accs"
8.     plt.title(title)
9.     plt.xlabel("batch")
10.     plt.ylabel("acc")
11.     plt.plot(Batchs, train_accs, color = 'green', label = 'training accs')
12.     plt.legend()
13.     plt.grid()
14.     plt.show()
17. all_train_loss = []
18. def draw_train_loss(Batchs,train_loss):
19.     title = "training loss"
20.     plt.title(title)
21.     plt.xlabel("batch")
22.     plt.ylabel("loss")
23.     plt.plot(Batchs, train_loss, color = 'red', label = 'training loss')
24.     plt.legend()
25.     plt.grid()
26.     plt.show()
28. ## 绘制真实值与预测值的对比图
29. def draw_infer_result(groud_truths, infer_results):
30.     title = 'Boston'
31.     plt.title(title)
32.     x = np.arange(1,20)
33.     y = x
34.     plt.plot(x,y);
35.     plt.xlabel("ground truth")
36.     plt.ylabel("infer result")
37.     plt.scatter(groud_truths,infer_results,color='green',label='training cost')
38.     plt.grid()
39.     plt.show()'''数据集加载'''train_dataset = paddle.text.datasets.UCIHousing(mode="train")eval_dataset = paddle.text.datasets.UCIHousing(mode="test")train_loader = paddle.io.DataLoader(train_dataset,batch_size=32, shuffle=True)eval_loader = paddle.io.DataLoader(eval_dataset,batch_size=8,shuffle=False)print(train_dataset[1])'''
40. 核心
42. 网络搭建
43. '''
45. class MyDNN(paddle.nn.Layer):
46.     def __init__(self):
47.         super(MyDNN, self).__init__()
49.         #self.linear1 = paddle.nn.Linear(13,1,None) #全连接层，paddle.nn.Linear(in_features,out_features,weight)
51.         self.linear1 = paddle.nn.Linear(13, 32, None)
53.         self.linear2 = paddle.nn.Linear(32, 64, None)
55.         self.linear3 = paddle.nn.Linear(64, 32, None)
57.         self.linear4 = paddle.nn.Linear(32, 1, None)
58.     def forward(self, inputs): ## 传播函数
59.         x = self.linear1(inputs)
60.         x = self.linear2(x)
61.         x = self.linear3(x)
62.         x = self.linear4(x)
63.         return x'''
64. 网络训练与测试
65. '''
68. ## 实例化
69. model = MyDNN()
70. model.train()
71. mse_loss = paddle.nn.MSELoss()
72. opt = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())
73. epochs_num = 100
76. for epochs in range(epochs_num):
77.     for batch_id,data in enumerate(train_loader()):
78.         feature = data[0]
79.         label = data[1]
80.         predict = model(feature)
81.         loss = mse_loss(predict, label)
82.         loss.backward()
83.         opt.step()
84.         opt.clear_grad()
85.         if batch_id!=0 and batch_id%10 == 0:
86.             Batch = Batch+10
87.             Batchs.append(Batch)
88.             all_train_loss.append(loss.numpy()[0])
89.             print("epoch{},step:{},train_loss:{}".format(epochs,batch_id,loss.numpy()[0]))
91. paddle.save(model.state_dict(),"UCIHousingDNN")
92. draw_train_loss(Batchs,all_train_loss)
96. para_state = paddle.load("UCIHousingDNN")
97. model = MyDNN()
98. model.eval()
99. model.set_state_dict(para_state)
100. losses = []
103. for batch_id,data in enumerate(eval_loader()):
104.     feature = data[0]
105.     label = data[1]
106.     predict = model(feature)
107.     loss = mse_loss(predict,label)
108.     losses.append(loss.numpy()[0])
109. avg_loss = np.mean(losses)
111. print(avg_loss)
114. draw_infer_result(label,predict)

复制代码

结果展示




免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！