【笔记】简单的线性回归的实现以及向量化的实现

简单的线性回归的实现以及向量化的实现

简单的线性回归的实现

首先我们在notebook上先加载上相应的库

  import numpy as np
  import matplotlib.pyplot as plt

我们先使用自己设计的一个假的数据来实验

  x = np.array([1,2,3,4,5])
  y = np.array([1,3,2,3,5])

在将x和y都设计出来以后，我们再用散点图的方式将这个数据集可视化出来

  plt.scatter(x,y)
  plt.axis([0,6,0,6])

可视化以后的图片如下

然后我们推导一下这个公式，看看是如何实现的

我们首先是计算x和y相应的均值

  x_mean = np.mean(x)
  y_mean = np.mean(y)

然后我们开始具体的计算a和b，重点是a的计算，从公式来看，a相当于由一个分子一个分母构成的，分子分母部分都是求和得出的，将分子设为num，分母为d，进行初始化，都初始化为0

  num = 0.0
  d = 0.0

在循环中，我们每次都从x和y中取出一个值，我们设这个值为x_i和y_i，使用zip方式将这两个放在一起，每次都各取一个值，然后分子分母部分就按照公式计算

  for x_i,y_i in zip(x,y):
      num += (x_i - x_mean) * (y_i - y_mean)
      d += (x_i - x_mean) ** 2

那么a就是分子除以分母

  a = num /d

相应的，b就是用y的均值减去a乘上x的均值

  b = y_mean - a * x_mean

a和b如下

我们可以将这条直线可视化出来，我们可以设其为y_hat

  y_hat = a * x + b

在绘制方面，首先我们使用散点图的方式将数据绘制出来，然后我们使用plot将直线再绘制出来，设其颜色为红色，坐标轴范围0-6

  plt.scatter(x,y)
  plt.plot(x,y_hat,color='r')
  plt.axis([0,6,0,6])

图像如下图所示

现在，如果来了一个新的x

  x_predict = 6

那么y就等于ax+b

  y_predict = a * x_predict + b

预测结果可得

  y_predict

那么我们可以在python chame中写出属于自己的简单的线性回归算法，思想与上面无异
代码如下

  import numpy as np
  from metrics import r2_score


        class SimpleLinearRegression1:

      def __init__(self):
          """初始化Simple linear Regression模型"""
          self.a_ = None
          self.b_ = None

      def fit(self, x_train, y_train):
          """根据训练数据集x_train,y_train训练Simple Linear Regression模型"""
          assert x_train.ndim == 1, 
              "simple Linear Regression can only solve single"
          assert len(x_train) == len(y_train), 
              "the size of x train must be equal to the size of y_train"

          x_mean = np.mean(x_train)
          y_mean = np.mean(y_train)

          num = 0.0
          d = 0.0
          for x_i, y_i in zip(x_train, y_train):
              num += (x_i - x_mean) * (y_i - y_mean)
              d += (x_i - x_mean) ** 2

          self.a_ = num / d
          self.b_ = y_mean - self.a_ * x_mean

          return self

      def predict(self, x_predict):
          """给定待预测数掘集x_predict,返同表示x_predict的结果向量"""
          assert x_predict.ndim == 1, 
              "simple Linear Regression can only solve single feature training data."
          assert self.a_ is not None and self.b_ is not None, 
              "must fit before predict! "

          return np.array([self._predict(x) for x in x_predict])

      def _predict(self, x_single):
         "给定单个待预测数据x_single,返同x_single的阿测结果值"""
          return self.a_ * x_single + self.b_

      def score(self, x_test, y_test):
          """根据给定的测试数据集确定当前的模型"""

          y_predict = self.predict(x_test)
          return r2_score(y_test, y_predict)

      def __repr__(self):
          return "SimpleLinearRegression1()"

使用自己的算法
首先我们在notebook中引用自己写好的

  from SimpleLinearRegression import SimpleLinearRegression1

然后我们对其进行实例化

  reg1 = SimpleLinearRegression1()

然后我们fit一下x和y就可以了

  reg1.fit(x,y)

之后我们进行预测，因为要求是一个数组，因此使用np.array进行包装一下

  reg1.predict(np.array([x_predict]))

然后我们可以看一下具体学到的a和b的参数

  reg1.a_
  reg1.b_

然后我们再绘制一下这条直线，方法很简单，和上面操作没有什么差别，依然是设置直线，绘制散点图，再绘制出直线即可

  y_hat1 = reg1.predict(x)
  plt.scatter(x,y)
  plt.plot(x,y_hat1,color='r')
  plt.axis([0,6,0,6])

图像如下

我们如果想使其效率更高一些的话，可以使用向量化这个技巧

向量化的实现

上面我们使用循环的方式将a给求出来的，使用for循环的话，性能是不高的，如果可以将其改成向量的运算，那么性能将会有一定的提升的

我们可以将上述的a变换成两个向量之间的计算

对于这个式子，我们是可以不使用for循环一直计算的
w可以表示成（w1，w2，…，wm）
v可以表示成（v1，v2，…，vm）
那么其就变成了w点乘v

这样我们就可以直接使用numpy中向量的运算
这样的性能是比for循环高很多的

实现方面

我们先将SimpleLinearRegression中的代码进行修改，增添一个类SimpleLinearRegression2，将其修改成向量的运算方式，我们只需要改变fit函数的逻辑就可以，将num分子改成点乘的方式，由于出来的是一个数，那么我们使用.dot的方法，对d也同理

代码如下

  import numpy as np
  from metrics import r2_score


  class SimpleLinearRegression2:

      def __init__(self):
          """初始化Simple linear Regression模型"""
          self.a_ = None
          self.b_ = None

      def fit(self, x_train, y_train):
          """根据训练数据集x_train,y_train训练Simple Linear Regression模型"""
          assert x_train.ndim == 1, 
              "simple Linear Regression can only solve single"
          assert len(x_train) == len(y_train), 
              "the size of x train must be equal to the size of y_train"

          x_mean = np.mean(x_train)
          y_mean = np.mean(y_train)
  
          num = (x_train - x_mean).dot(y_train - y_mean)
          d = (x_train - x_mean).dot(x_train - x_mean)

          self.a_ = num / d
          self.b_ = y_mean - self.a_ * x_mean

          return self

      def predict(self, x_predict):
          """给定待预测数掘集x_predict,返同表示x_predict的结果向量"""
          assert x_predict.ndim == 1, 
              "simple Linear Regression can only solve single feature training data."
          assert self.a_ is not None and self.b_ is not None, 
              "must fit before predict! "

          return np.array([self._predict(x) for x in x_predict])

      def _predict(self, x_single):
          "给定单个待预测数据x_single,返同x_single的结果值"""
          return self.a_ * x_single + self.b_

      def score(self, x_test, y_test):
          """根据给定的测试数据集确定当前的模型"""

          y_predict = self.predict(x_test)
          return r2_score(y_test, y_predict)

      def __repr__(self):
          return "SimpleLinearRegression2()"

那么我们在notebook中来实现一下

首先还是引用新的类

  from SimpleLinearRegression import SimpleLinearRegression2

然后实例化，然后操作同上

  reg2 = SimpleLinearRegression2()
  reg2.fit(x,y)
  reg2.a_
  reg2.b_

同样绘制一个图片用来可视化

  y_hat2 = reg2.predict(x)
  plt.scatter(x,y)
  plt.plot(x,y_hat2,color='r')
  plt.axis([0,6,0,6])

图像如下

向量化实现的性能测试
我们通过创建一个相对于更大的数据，进而再创建一个向量big_x，然后我们再创建一个big_y，使其与big_x产生一个线性关系，但是我们不能让其完全呈现出，在后面添加一个符合正态分布的一个噪音np.random.normal(size=m)

  m = 1000000
  big_x = np.random.random(size=m)
  big_y = big_x * 2.0 + 3.0 + np.random.normal(size=m)

然后我们测试一下两个版本所对应的性能，通过对比就可以知道两者的性能差距是多少

  %timeit reg1.fit(big_x,big_y)
  %timeit reg2.fit(big_x,big_y)

结果如下

很明显，向量带来的性能提升是很巨大的，所以一般可以向量化就要向量化，不过要基于公式的基础上更深入才可以

然后我们看一下训练出来的两种a和b的情况

  reg1.a_
  reg1.b_
  reg2.a_
  reg2.b_

输出结果如下