11、机器学习实战案例：普通最小二乘法求线性回归_笔记

东方耀

11、机器学习实战案例：普通最小二乘法求线性回归_笔记

1. # -*- coding: utf-8 -*-
   
2. __author__ = 'dongfangyao'
   
3. __date__ = '2018/3/29 下午4:17'
   
4. __product__ = 'PyCharm'
   
5. __filename__ = 'least_squares1'
   
6. 
   
7. 
   
8. 
   
9. # 线性回归的类
   
10. from sklearn.linear_model import LinearRegression
    
11. # 原始数据= 训练数据 + 测试数据  数据划分的类
    
12. from sklearn.model_selection import train_test_split
    
13. # 数据标准化
    
14. from sklearn.preprocessing import StandardScaler
    
15. 
    
16. import numpy as np
    
17. import pandas as pd
    
18. import matplotlib as mpl
    
19. import matplotlib.pyplot as plt
    
20. from pandas import DataFrame
    
21. import time
    
22. 
    
23. ## 设置字符集，防止中文乱码
    
24. mpl.rcParams['font.family'] = 'sans-serif'
    
25. mpl.rcParams['font.sans-serif'] = 'SimHei'
    
26. mpl.rcParams['axes.unicode_minus'] = False
    
27. 
    
28. # 加载数据
    
29. # 日期、时间、有功功率、无功功率、电压、电流、厨房用电功率、洗衣服用电功率、热水器用电功率
    
30. path1 = 'datas/household_power_consumption_1000.txt'
    
31. df = pd.read_csv(path1, sep=';', low_memory=False)
    
32. # 没有混合类型的时候可以通过low_memory=False调用更多内存，加快效率）
    
33. 
    
34. # print(df.head(2))
    
35. # print(df.index)
    
36. # print(df.columns)
    
37. 
    
38. # 查看数据结构
    
39. # print(df.info())
    
40. 
    
41. # 异常数据处理(异常数据过滤)
    
42. # 替换非法字符为np.nan
    
43. new_df = df.replace('?', np.nan)
    
44. # 只要有一个数据为空，就进行行删除操作
    
45. datas = new_df.dropna(axis=0, how='any')
    
46. # 观察数据的多种统计指标(只能看数值型的 本来9个的变7个了)
    
47. # print(datas.describe().T)
    
48. 
    
49. 
    
50. # 需求：构建时间和功率之间的映射关系，可以认为：特征属性为时间；目标属性为功率值。
    
51. # 获取x和y变量, 并将时间转换为数值型连续变量
    
52. 
    
53. # 创建一个时间函数格式化字符串
    
54. def date_format(dt):
    
55.     # dt显示是一个Series
    
56.     # print(dt.index)
    
57.     # print(dt)
    
58.     t = time.strptime(' '.join(dt), '%d/%m/%Y %H:%M:%S')
    
59.     return (t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec)
    
60. 
    
61. X = datas.iloc[:, 0:2]
    
62. # print(X)
    
63. X = X.apply(lambda x: pd.Series(date_format(x)), axis=1)
    
64. Y = datas['Global_active_power']
    
65. # print(Y.head(4))
    
66. # print(X.head(4))
    
67. # print(type(X))
    
68. # print(type(Y))
    
69. 
    
70. 
    
71. # 对数据集进行测试集、训练集划分
    
72. # X：特征矩阵(类型一般是DataFrame)
    
73. # Y：特征对应的Label标签或目标属性(类型一般是Series)
    
74. 
    
75. # test_size: 对X/Y进行划分的时候，测试集合的数据占比, 是一个(0,1)之间的float类型的值
    
76. # random_state: 数据分割是基于随机器进行分割的，该参数给定随机数种子；
    
77. # 给一个值(int类型)的作用就是保证每次分割所产生的数数据集是完全相同的
    
78. # 默认的随机数种子是当前时间戳 random_state=None的情况下
    
79. X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=0)
    
80. 
    
81. # print(X_train.shape)
    
82. # print(X_test.shape)
    
83. # print(Y_train.shape)
    
84. # print(Y_test.shape)
    
85. 
    
86. # 查看训练集上的数据信息(X)
    
87. print(X_train.describe().T)
    
88. 
    
89. # 特征数据标准化（也可以说是正常化、归一化、正规化）
    
90. # StandardScaler：将数据转换为标准差为1的数据集(有一个数据的映射)
    
91. # scikit-learn中：如果一个API名字有fit，那么就有模型训练的含义，没法返回值
    
92. # scikit-learn中：如果一个API名字中有transform， 那么就表示对数据具有转换的含义操作
    
93. # scikit-learn中：如果一个API名字中有predict，那么就表示进行数据预测，会有一个预测结果输出
    
94. # scikit-learn中：如果一个API名字中既有fit又有transform的情况下，那就是两者的结合(先做fit，再做transform)
    
95. 
    
96. # 模型对象创建
    
97. ss = StandardScaler()
    
98. # 训练模型并转换训练集
    
99. X_train = ss.fit_transform(X_train)
    
100. # 直接使用在模型构建数据上进行一个数据标准化操作 (测试集)
     
101. X_test = ss.transform(X_test)
     
102. 
     
103. # print(X_train.describe().T)
     
104. # print(type(X_train))
     
105. # print(X_train.shape, X_train.ndim)
     
106. print(pd.DataFrame(X_train).describe().T)
     
107. 
     
108. 
     
109. # 模型训练
     
110. # 模型对象构建
     
111. # fit_intercept fit训练 intercept截距
     
112. # LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1)
     
113. # n_jobs模型训练的任务数 是否并行 并行需要至少2个cpu的 基本没什么用这个参数
     
114. lr = LinearRegression(fit_intercept=True)
     
115. # 训练模型
     
116. lr.fit(X_train, Y_train)
     
117. # 模型校验
     
118. # 预测结果
     
119. y_predict = lr.predict(X_test)
     
120. 
     
121. # 回归中的R^2就是准确率 后面会说
     
122. print("训练集上R^2:", lr.score(X_train, Y_train))
     
123. print("测试集上R^2:", lr.score(X_test, Y_test))
     
124. # 预测值与实际值的差值 平方和 再求均值
     
125. mse = np.average((y_predict-Y_test)**2)
     
126. rmse = np.sqrt(mse)
     
127. print("rmse:", rmse)
     
128. 
     
129. # 输出模型训练得到的相关参数
     
130. # 注意：第1、2、6个系数为0
     
131. print("模型的系数(θ):", end="")
     
132. print(lr.coef_)
     
133. print("模型的截距:", end='')
     
134. print(lr.intercept_)
     
135. 
     
136. 
     
137. # 模型保存/持久化（跳过）
     
138. # 加载模型 并进行预测（跳过）
     
139. 
     
140. # 预测值和实际值画图比较
     
141. t = np.arange(len(X_test))
     
142. # 建一个画布，facecolor是背景色
     
143. plt.figure(facecolor='w')
     
144. plt.plot(t, Y_test, 'r-', linewidth=2, label='真实值')
     
145. plt.plot(t, y_predict, 'g-', linewidth=2, label='预测值')
     
146. # 显示图例，设置图例的位置
     
147. plt.legend(loc = 'upper left')
     
148. plt.title("线性回归预测时间和功率之间的关系", fontsize=20)
     
149. # 加网格
     
150. plt.grid(b=True)
     
151. plt.show()
     
152. 
     
153. 
     
154. 
     

复制代码

1. ## 功率和电流之间的关系
   
2. X = datas.iloc[:,2:4]
   
3. Y2 = datas.iloc[:,5]
   
4. 
   
5. ## 数据分割
   
6. X2_train,X2_test,Y2_train,Y2_test = train_test_split(X, Y2, test_size=0.2, random_state=0)
   
7. 
   
8. ## 数据归一化
   
9. scaler2 = StandardScaler()
   
10. X2_train = scaler2.fit_transform(X2_train) # 训练并转换
    
11. X2_test = scaler2.transform(X2_test) ## 直接使用在模型构建数据上进行一个数据标准化操作
    
12. 
    
13. ## 模型训练
    
14. lr2 = LinearRegression()
    
15. lr2.fit(X2_train, Y2_train) ## 训练模型
    
16. 
    
17. ## 结果预测
    
18. Y2_predict = lr2.predict(X2_test)
    
19. 
    
20. ## 模型评估
    
21. print("电流预测准确率: ", lr2.score(X2_test,Y2_test))
    
22. print("电流参数:", lr2.coef_)
    
23. 
    
24. ## 绘制图表
    
25. #### 电流关系
    
26. t=np.arange(len(X2_test))
    
27. plt.figure(facecolor='w')
    
28. plt.plot(t, Y2_test, 'r-', linewidth=2, label=u'真实值')
    
29. plt.plot(t, Y2_predict, 'g-', linewidth=2, label=u'预测值')
    
30. plt.legend(loc = 'lower right')
    
31. plt.title(u"线性回归预测功率与电流之间的关系", fontsize=20)
    
32. plt.grid(b=True)
    
33. plt.show()

复制代码

东方耀

1. import numpy as np
   
2. from .metrics import r2_score
   
3. 
   
4. class LinearRegression:
   
5. 
   
6.     def __init__(self):
   
7.         """初始化Linear Regression模型"""
   
8.         self.coef_ = None
   
9.         self.intercept_ = None
   
10.         self._theta = None
    
11. 
    
12.     def fit_normal(self, X_train, y_train):
    
13.         """根据训练数据集X_train, y_train训练Linear Regression模型"""
    
14.         assert X_train.shape[0] == y_train.shape[0], \
    
15.             "the size of X_train must be equal to the size of y_train"
    
16. 
    
17.         X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
    
18.         self._theta = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y_train)
    
19. 
    
20.         self.intercept_ = self._theta[0]
    
21.         self.coef_ = self._theta[1:]
    
22. 
    
23.         return self
    
24. 
    
25.     def fit_gd(self, X_train, y_train, eta=0.01, n_iters=1e4):
    
26.         """根据训练数据集X_train, y_train, 使用梯度下降法训练Linear Regression模型"""
    
27.         assert X_train.shape[0] == y_train.shape[0], \
    
28.             "the size of X_train must be equal to the size of y_train"
    
29. 
    
30.         def J(theta, X_b, y):
    
31.             try:
    
32.                 return np.sum((y - X_b.dot(theta)) ** 2) / len(y)
    
33.             except:
    
34.                 return float('inf')
    
35. 
    
36.         def dJ(theta, X_b, y):
    
37.             # res = np.empty(len(theta))
    
38.             # res[0] = np.sum(X_b.dot(theta) - y)
    
39.             # for i in range(1, len(theta)):
    
40.             #     res[i] = (X_b.dot(theta) - y).dot(X_b[:, i])
    
41.             # return res * 2 / len(X_b)
    
42.             return X_b.T.dot(X_b.dot(theta) - y) * 2. / len(X_b)
    
43. 
    
44.         def gradient_descent(X_b, y, initial_theta, eta, n_iters=1e4, epsilon=1e-8):
    
45. 
    
46.             theta = initial_theta
    
47.             cur_iter = 0
    
48. 
    
49.             while cur_iter < n_iters:
    
50.                 gradient = dJ(theta, X_b, y)
    
51.                 last_theta = theta
    
52.                 theta = theta - eta * gradient
    
53.                 if (abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon):
    
54.                     break
    
55. 
    
56.                 cur_iter += 1
    
57. 
    
58.             return theta
    
59. 
    
60.         X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
    
61.         initial_theta = np.zeros(X_b.shape[1])
    
62.         self._theta = gradient_descent(X_b, y_train, initial_theta, eta, n_iters)
    
63. 
    
64.         self.intercept_ = self._theta[0]
    
65.         self.coef_ = self._theta[1:]
    
66. 
    
67.         return self
    
68. 
    
69.     def fit_sgd(self, X_train, y_train, n_iters=5, t0=5, t1=50):
    
70.         """根据训练数据集X_train, y_train, 使用梯度下降法训练Linear Regression模型"""
    
71.         assert X_train.shape[0] == y_train.shape[0], \
    
72.             "the size of X_train must be equal to the size of y_train"
    
73.         assert n_iters >= 1
    
74. 
    
75.         def dJ_sgd(theta, X_b_i, y_i):
    
76.             return X_b_i * (X_b_i.dot(theta) - y_i) * 2.
    
77. 
    
78.         def sgd(X_b, y, initial_theta, n_iters, t0=5, t1=50):
    
79. 
    
80.             def learning_rate(t):
    
81.                 return t0 / (t + t1)
    
82. 
    
83.             theta = initial_theta
    
84.             m = len(X_b)
    
85. 
    
86.             for cur_iter in range(n_iters):
    
87.                 indexes = np.random.permutation(m)
    
88.                 X_b_new = X_b[indexes]
    
89.                 y_new = y[indexes]
    
90.                 for i in range(m):
    
91.                     gradient = dJ_sgd(theta, X_b_new[i], y_new[i])
    
92.                     theta = theta - learning_rate(cur_iter * m + i) * gradient
    
93. 
    
94.             return theta
    
95. 
    
96.         X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
    
97.         initial_theta = np.random.randn(X_b.shape[1])
    
98.         self._theta = sgd(X_b, y_train, initial_theta, n_iters, t0, t1)
    
99. 
    
100.         self.intercept_ = self._theta[0]
     
101.         self.coef_ = self._theta[1:]
     
102. 
     
103.         return self
     
104. 
     
105.     def predict(self, X_predict):
     
106.         """给定待预测数据集X_predict，返回表示X_predict的结果向量"""
     
107.         assert self.intercept_ is not None and self.coef_ is not None, \
     
108.             "must fit before predict!"
     
109.         assert X_predict.shape[1] == len(self.coef_), \
     
110.             "the feature number of X_predict must be equal to X_train"
     
111. 
     
112.         X_b = np.hstack([np.ones((len(X_predict), 1)), X_predict])
     
113.         return X_b.dot(self._theta)
     
114. 
     
115.     def score(self, X_test, y_test):
     
116.         """根据测试数据集 X_test 和 y_test 确定当前模型的准确度"""
     
117. 
     
118.         y_predict = self.predict(X_test)
     
119.         return r2_score(y_test, y_predict)
     
120. 
     
121.     def __repr__(self):
     
122.         return "LinearRegression()"

复制代码

fglbee

this is good idea

fglbee

this is good idea

口果微笑

66666666666

栀子花

66666666666

zxyza

非常好非常好，very good

万物皆虚

非常好非常好，very good

万物皆虚

非常好非常好，very
good

万物皆虚

非常好非常好，very good