ML——基于梯度下降算法（SGD）下的多元线性回归问题

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
import numpy as np
from linear.simpleline import simplelinear as sim
#采用随机梯度下降算法解多元线性规划
class sgd:
    def __init__(self):
        self.theat_ = None
        self.theat_list = None
        self.last_dJ = None
    def dJ(self,theat,x_b_i,y_i):
        '''计算梯度(传入数据为单个样本)'''
        assert len(theat) == len(x_b_i)
        theat = np.array(theat)
        x_b_i = np.array(x_b_i)
        y_i = np.array(y_i)
        return  2 * (x_b_i.T) * (x_b_i .dot(theat) - y_i)
    def sgradient(self,x_b,y,i_iters):  #i_iters为次数
        assert len(x_b) == len(y)
        assert i_iters >= 1
        def Eta(t):
            t0 = 5
            t1 = 50
            return t0 / (t + t1)
        x_b = np.array(x_b)
        y = np.array(y)
        x_b = np.hstack([np.ones((len(x_b),1)),x_b])
        ini_theat = np.zeros(x_b.shape[1])
        theat = ini_theat
        self.theat_list = []
        self.theat_list.append(theat)
        for i in range(i_iters):
            index = np.random.permutation(len(x_b))
            x_b_new = x_b[index]
            y_new = y[index]
            for j in range(len(x_b)):
                g = self.dJ(theat,x_b_new[j],y_new[j])
                theat = theat - Eta(i * len(x_b) + j) * g
                self.theat_list.append(theat)
        self.last_dJ = g
        self.theat_ = theat
        return self.theat_list
    def score(self,x_test,y_test):   #计算线性相关程度R
        assert x_test.shape[0] == y_test.shape[0]
        x_test = np.hstack([np.ones((len(x_test),1)),x_test])
        y_predict = x_test .dot(self.theat_)
        def mse(y_test,y_predict):
            return np.sum((y_test - y_predict) ** 2) / len(y_predict)
        def R_R(y_test, y_predict):
            s = mse(y_test, y_predict)
            d = np.var(y_test)
            return 1 - s / d
        return R_R(y_test,y_predict)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from cyh.train_test_split import t_t_split  #这里用的是自己设计的数据分类函数，也可以采用sklearn里面的train_test_split
from sklearn.preprocessing import StandardScaler
data = datasets.load_boston()
t = data.data
r = data.target

x = t[r < 50]
y = r[r < 50]

x_train,y_train,x_test,y_test = t_t_split(x,y,0.2,666)   #自己做实验时最好设置一个随机种子，以免每次输出结果不一样

m = StandardScaler()
m.fit(x_train)
x_train = m.transform(x_train)
m.fit(x_test)
x_test = m.transform(x_test)

1
2
3
4
5
6
7
8
9
10
11
12
13
from linear.bgd import gd
from linear.sgd import sgd

n = gd()
n.gra(x_train,y_train,0.01)  #批量梯度下降算法
print(n.theat)


m = sgd()
m.sgradient(x_train,y_train,500)  #随机梯度下降算法
print(m.theat_)
print(m.score(x_test,y_test))  #计算线性相关程度R

1
2
3
4
5
6
7
[21.55382653 -1.0510041   0.90432038 -0.28228354  0.17807247 -1.5876832
  2.22136885 -0.68691468 -2.61226707  2.38322627 -2.36377392 -1.81554557
  0.4816466  -2.57338312]
[21.55396184 -1.04997861  0.9021548  -0.28909283  0.17894546 -1.58628975
  2.22141016 -0.68766406 -2.61303714  2.36859213 -2.34657215 -1.81477483
  0.48119676 -2.57290246]
0.801699511338954