python基於numpy的線性迴歸

import numpy as np
from sklearn.utils import shuffle
from sklearn.datasets import load_diabetes
import matplotlib.pyplot as plt

#基於numpy實現一個簡單的線性迴歸模型
#用class進行簡單封裝
class lr_model():
    def __init__(self):
        pass

    # diabetes 是一個關於糖尿病的資料集， 該資料集包括442個病人的生理資料及一年以後的病情發展情況。
    # 資料集中的特徵值總共10項, 如下:
    # 年齡
    # 性別
    # 體質指數
    # 血壓
    # s1,s2,s3,s4,s4,s6  (六種血清的化驗資料)
    # 但請注意，以上的資料是經過特殊處理， 10個資料中的每個都做了均值中心化處理，然後又用標準差乘以個體數量調整了數值範圍。驗證就會發現任何一列的所有數值平方和為1.
    def prepare_data(self):
        data = load_diabetes().data
        target = load_diabetes().target
        #資料打亂
        X, y = shuffle(data, target, random_state=42)
        X = X.astype(np.float32)
        y = y.reshape((-1, 1))#標籤變成列向量形式
        data = np.concatenate((X, y), axis=1)#橫向變為資料標籤的行向量
        return data
     #初始化引數，權值與偏執初始化
    def initialize_params(self, dims):
        w = np.zeros((dims, 1))
        b = 0
        return w, b

    def linear_loss(self, X, y, w, b):
        num_train = X.shape[0]#行數訓練數目
        num_feature = X.shape[1]#列數表示特徵值數目
        y_hat = np.dot(X, w) + b#y=w*x+b
        loss = np.sum((y_hat - y) ** 2) / num_train#計算損失函數
        dw = np.dot(X.T, (y_hat - y)) / num_train#計算梯度
        db = np.sum((y_hat - y)) / num_train
        return y_hat, loss, dw, db

    def linear_train(self, X, y, learning_rate, epochs):
        w, b = self.initialize_params(X.shape[1])#引數初始化
        loss_list = []
        for i in range(1, epochs):
            y_hat, loss, dw, db = self.linear_loss(X, y, w, b)
            w += -learning_rate * dw
            b += -learning_rate * db#引數更新
            loss_list.append(loss)
        if i % 10000 == 0:#每到一定輪數進行列印輸出
            print('epoch %d loss %f' % (i, loss))
        #引數儲存
        params = {
            'w': w,
            'b': b
        }
        grads = {
            'dw': dw,
            'db': db
        }
        return loss, params, grads,loss_list

    #預測函數
    def predict(self, X, params):
        w = params['w']
        b = params['b']
        y_pred = np.dot(X, w) + b
        return y_pred

   #隨機交叉驗證函數，如何選測試集、訓練集
    def linear_cross_validation(self, data, k, randomize=True):
        if randomize:
            data = list(data)
            shuffle(data)
        slices = [data[i::k] for i in range(k)]#k為step
        for i in range(k):
            validation = slices[i]
            train = [data for s in slices if s is not validation for data in s]#將不為測試集的資料作為訓練集
            train = np.array(train)
            validation = np.array(validation)
            yield train, validation#yield 變為可迭代,每次返回


if __name__ == '__main__':
    lr = lr_model()
    data = lr.prepare_data()
    for train, validation in lr.linear_cross_validation(data, 5):
        X_train = train[:, :10]
        y_train = train[:, -1].reshape((-1, 1))
        X_valid = validation[:, :10]
        y_valid = validation[:, -1].reshape((-1, 1))
        loss5 = []
        loss, params, grads,loss_list = lr.linear_train(X_train, y_train, 0.001, 100000)

        plt.plot(loss_list, color='blue')
        plt.xlabel('epochs')
        plt.ylabel('loss')
        plt.show()

        loss5.append(loss)
        score = np.mean(loss5)

        print('five kold cross validation score is', score)#5類資料的測試分數
        y_pred = lr.predict(X_valid, params)
        plt.scatter(range(X_valid.shape[0]),y_valid)
        plt.scatter(range(X_valid.shape[0]),y_pred,color='red')
        plt.xlabel('x')
        plt.ylabel('y')
        plt.show()

        valid_score = np.sum(((y_pred - y_valid) ** 2)) / len(X_valid)
        print('valid score is', valid_score)