Deep Learning波士顿房价数据回归分析

代码实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from sklearn.datasets import load_boston

from pandas import DataFrame,Series

import pandas as pd

from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import PolynomialFeatures

import numpy as np

import matplotlib.pyplot as plt

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
# In[5]:

  
  

dataset = load_boston()

x_data = dataset.data

y_data = dataset.target # price

name_data = dataset.feature_names # 13个列名

  
  

# In[25]:

  
  

print(x_data)

print(y_data)

print(name_data)

  
  

# In[163]:

  
  

x_data = pd.DataFrame(x_data,columns=name_data)

y_data = pd.DataFrame(y_data,columns=['price'])

  
  

# In[164]:

  
  

data = pd.concat((x_data,y_data),axis=1)

print(data)

  
  

# In[171]:

  
  

print(data.describe())

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 城市人均犯罪率与房价的分析

  

# In[165]:

  
  

# 计算相关系数

corr = x_data["CRIM"].corr(y_data["price"])  

print(corr)            # 低度相关

  
  

# In[170]:

  
  

# 绘制散点图

x=data[["CRIM"]]  

y=data['price']

data.plot(x='CRIM',y='price',kind='scatter')  

  
  

# In[192]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

  
  

# In[193]:

  
  

X = np.linspace(0,100,100)

Y = a*X+b

  
  

# In[194]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['CRIM'],y=data['price'])

  
  

# In[195]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[196]:

  
  

# 预测

px = pd.DataFrame(

    {'CRIM':[0.4,0.5,0.6]}

)

p = lrModel.predict(px)

print(p)

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 住宅用地所占比例与房价的分析

  

# In[211]:

  
  

# 计算相关系数

corr = x_data["ZN"].corr(y_data["price"])  

print(corr)            # 低度相关

  
  

# In[212]:

  
  

# 绘制散点图

x=data[["ZN"]]  

y=data['price']

data.plot(x='ZN',y='price',kind='scatter')

  
  

# In[213]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

  
  

# In[214]:

  
  

X = np.linspace(0,100,100)

Y = a*X+b

  
  

# In[215]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['ZN'],y=data['price'])

  
  

# In[216]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[217]:

  
  

# 预测

px = pd.DataFrame(

    {'ZN':[20,21,22]}

)

p = lrModel.predict(px)

print(p)

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 城镇中非住宅用地所占比例与房价的分析

  

# In[218]:

  
  

# 计算相关系数

corr = x_data["INDUS"].corr(y_data["price"])  

print(corr)            # 低度相关

  
  

# In[219]:

  
  

# 绘制散点图

x=data[["INDUS"]]  

y=data['price']

data.plot(x='INDUS',y='price',kind='scatter')

  
  

# In[220]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

  
  

# In[229]:

  
  

X = np.linspace(0,30,30)

Y = a*X+b

  
  

# In[230]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['INDUS'],y=data['price'])

  
  

# In[231]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[232]:

  
  

# 预测

px = pd.DataFrame(

    {'INDUS':[9,10,11]}

)

p = lrModel.predict(px)

print(p)

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
# ### 环保指数与房价的分析

  

# In[257]:

  
  

# 计算相关系数

corr = x_data["NOX"].corr(y_data["price"])  

print(corr)            # 低度相关

  
  

# In[258]:

  
  

# 绘制散点图

x=data[["NOX"]]  

y=data['price']

data.plot(x='NOX',y='price',kind='scatter')

  
  

# In[259]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

b = lrModel.intercept_

  
  

# In[272]:

  
  

X = np.linspace(0,1,10)

Y = a*X+b

  
  

# In[273]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['NOX'],y=data['price'])

  
  

# In[274]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[275]:

  
  

# 预测

px = pd.DataFrame(

    {'NOX':[0.4,0.5,0.6]}

)

p = lrModel.predict(px)

print(p)

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 每栋住宅的房间数与房价的分析

  

# In[276]:

  
  

# 计算相关系数

corr = x_data["RM"].corr(y_data["price"])  

print(corr)            # 显著相关

  
  

# In[277]:

  
  

x=data[["RM"]]  

y=data['price']

data.plot(x='RM',y='price',kind='scatter')

  
  

# In[278]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

b = lrModel.intercept_

  
  

# In[284]:

  
  

X = np.linspace(0,10,10)

Y = a*X+b

  
  

# In[285]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['RM'],y=data['price'])

  
  

# In[286]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[287]:

  
  

# 预测

px = pd.DataFrame(

    {'RM':[6,7,8]}

)

p = lrModel.predict(px)

print(p)

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 1940年以前建成的自住单位的比例与房价的分析

  

# In[288]:

  
  

# 计算相关系数

corr = x_data["AGE"].corr(y_data["price"])  

print(corr)            # 低度相关

  
  

# In[289]:

  
  

x=data[["AGE"]]  

y=data['price']

data.plot(x='AGE',y='price',kind='scatter')

  
  

# In[290]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

b = lrModel.intercept_

  
  

# In[299]:

  
  

X = np.linspace(0,100,100)

Y = a*X+b

  
  

# In[300]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['AGE'],y=data['price'])

  
  

# In[301]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[302]:

  
  

# 预测

px = pd.DataFrame(

    {'AGE':[60,70,80]}

)

p = lrModel.predict(px)

print(p)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# ### 距离5个波士顿的就业中心的加权距离与房价的分析

  

# In[157]:

  
  

# 计算相关系数

corr = x_data["DIS"].corr(y_data["price"])  

print(corr)            # 无相关

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 距离高速公路的便利指数与房价的分析

  

# In[303]:

  
  

# 计算相关系数

corr = x_data["RAD"].corr(y_data["price"])  

print(corr)            # 低度相关

  
  

# In[304]:

  
  

x=data[["RAD"]]  

y=data['price']

data.plot(x='RAD',y='price',kind='scatter')

  
  

# In[305]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

b = lrModel.intercept_

  
  

# In[306]:

  
  

X = np.linspace(0,25,25)

Y = a*X+b

  
  

# In[309]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['RAD'],y=data['price'])

  
  

# In[310]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[311]:

  
  

# 预测

px = pd.DataFrame(

    {'RAD':[1,2,3]}

)

p = lrModel.predict(px)

print(p)

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 每一万美元的不动产税率与房价的分析

  

# In[312]:

  
  

# 计算相关系数

corr = x_data["TAX"].corr(y_data["price"])  

print(corr)            # 低度相关

  
  

# In[313]:

  
  

x=data[["TAX"]]  

y=data['price']

data.plot(x='TAX',y='price',kind='scatter')

  
  

# In[314]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

b = lrModel.intercept_

  
  

# In[317]:

  
  

X = np.linspace(0,750,750)

Y = a*X+b

  
  

# In[318]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['TAX'],y=data['price'])

  
  

# In[319]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[320]:

  
  

# 预测

px = pd.DataFrame(

    {'TAX':[220,230,240]}

)

p = lrModel.predict(px)

print(p)

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 城镇中的教师学生比例与房价的分析

  

# In[322]:

  
  

# 计算相关系数

corr = x_data["PTRATIO"].corr(y_data["price"])  

print(corr)            # 显著相关

  
  

# In[323]:

  
  

x=data[["PTRATIO"]]  

y=data['price']

data.plot(x='PTRATIO',y='price',kind='scatter')

  
  

# In[324]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

b = lrModel.intercept_

  
  

# In[325]:

  
  

X = np.linspace(0,25,25)

Y = a*X+b

  
  

# In[326]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['PTRATIO'],y=data['price'])

  
  

# In[327]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[328]:

  
  

# 预测

px = pd.DataFrame(

    {'PTRATIO':[19,20,21]}

)

p = lrModel.predict(px)

print(p)

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 城镇中的黑人比例与房价的分析

  

# In[329]:

  
  

# 计算相关系数

corr = x_data["B"].corr(y_data["price"])  

print(corr)            # 低度相关

  
  

# In[330]:

  
  

x=data[["B"]]  

y=data['price']

data.plot(x='B',y='price',kind='scatter')

  
  

# In[331]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

b = lrModel.intercept_

  
  

# In[332]:

  
  

X = np.linspace(0,400,400)

Y = a*X+b

  
  

# In[333]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['B'],y=data['price'])

  
  

# In[334]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[335]:

  
  

# 预测

px = pd.DataFrame(

    {'B':[380,390,400]}

)

p = lrModel.predict(px)

print(p)

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
# ### 地区中有多少房东属于低收入人群与房价的分析

  

# In[336]:

  
  

# 计算相关系数

corr = x_data["LSTAT"].corr(y_data["price"])  

print(corr)            # 显著相关

  
  

# In[337]:

  
  

x=data[["LSTAT"]]  

y=data['price']

data.plot(x='LSTAT',y='price',kind='scatter')

  
  

# In[338]:

  
  

# 根据模型参数，建立线性回归模型

lrModel=LinearRegression()

lrModel.fit(x,y)   # 训练模型

a = lrModel.coef_[0]

b = lrModel.intercept_

  
  

# In[341]:

  
  

X = np.linspace(0,40,40)

Y = a*X+b

  
  

# In[342]:

  
  

plt.figure()

plt.plot(X,Y)

plt.scatter(x=data['LSTAT'],y=data['price'])

  
  

# In[343]:

  
  

# 验证模型

s = lrModel.score(x,y)

print(s)

  
  

# In[344]:

  
  

# 预测

px = pd.DataFrame(

    {'LSTAT':[5,6,7]}

)

p = lrModel.predict(px)

print(p)

尾巴