LinearRegression --- python实现

import numpy as np


class LinearRegression:

  def __int__(self):
    '''初始化lineargression 模型参数'''

    # theta除第一个后的矩阵
    self.coef_ = None
    # 截距，第一个theta值
    self.intercept_ = None
    # theta矩阵
    self._theta = None

  # 使用正规方程解
  def fit_normal(self, X_train, y_train):
    '''根据训练集训练模型'''
    assert X_train.shape[0] == y_train.shape[0], \
      "the size of X_train must be equal to the size of y_train"
    # 生成X_b为 n+1 维的矩阵，在第一列加上1
    X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
    # 正规方程求解公式
    self._theta = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y_train)

    # 截距
    self.intercept_ = self._theta[0]
    self.coef_ = self._theta[1:]

    return self

  # 使用梯度下降法求theta
  def fit_gd(self, X_train, y_trian, eta=0.1, n_iters=1e4):
    '''使用梯度下降法训练Linear Regression模型'''
    assert X_train.shape[0] == y_trian.shape[0], \
      "the size of X_train must be equal to the size of y_train"

    # 损失函数
    def J(theta, X_b, y):
      try:
        return np.sum((y - X_b.dot(theta)) ** 2) / len(y)
      except:
        return float('inf')

    # 梯度下降法求theta
    def dJ(theta, X_b, y):
      # res = np.empty(len(theta))
      # res[0] = np.sum(X_b.dot(theta) - y)
      #
      # for i in range(1, len(theta)):
      #   res[i] = np.sum((X_b.dot(theta) - y).dot(X_b[:, i]))
      # return res * 2 / len(X_b)

      #   直接进行矩阵运算
      return X_b.T.dot(X_b.dot(theta) - y) * 2 / len(y)

    def gradient_descent(X_b, y, initial_theta, eta, n_iters=1e4, epsilon=1e-8):
      # 现在的theta 是个矩阵
      theta = initial_theta
      n_iter = 0

      while n_iter <= n_iters:
        gradient = dJ(theta, X_b, y)

        last_theta = theta

        theta = theta - eta * gradient

        if (abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon):
          break

        n_iter += 1

      return theta

    # 将X_b 组成位N+1，第一列全为1的矩阵，
    X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
    initial_theta = np.zeros(X_b.shape[1])
    eta = 0.01

    self._theta = gradient_descent(X_b, y_trian, initial_theta, eta)
    self.intercept_ = self._theta[0]
    self.coef_ = self._theta[1:]

  def predcit(self, X_predict):
    '''给定向量集预测数据，返回预测后的矩阵'''
    assert self.intercept_ is not None and self.coef_ is not None, \
      "must fit before predict"

    assert X_predict.shape[1] == len(self.coef_), \
      "the feature number of X_predict must be equal to X_train"
    X_b = np.hstack([np.ones((len(X_predict), 1)), X_predict])
    #
    return X_b.dot(self._theta)

  def score(self, X_test, y_test):
    '''判断模型准确度'''
    y_predict = self.predcit(X_test)
    return 1 - (np.sum((y_predict - y_test) ** 2) / len(y_test)) / np.var(y_test)

  def __repr__(self):
    return 'LinearRegression'


# x = 2 * np.random.random(size=100)
# y = x * 3. + 4. + np.random.normal(size=100)
# X = x.reshape(-1, 1)
#
# lin_reg = LinearRegression()
# lin_reg.fit_gd(X, y)
# print(lin_reg.coef_)
# print(lin_reg.intercept_)