05机器学习实战之Logistic 回归

短命女 2022-01-09 04:09 306阅读 0赞

Logistic 回归 概述

Logistic 回归 或者叫逻辑回归 虽然名字有回归，但是它是用来做分类的。其主要思想是: 根据现有数据对分类边界线(Decision Boundary)建立回归公式，以此进行分类。

须知概念

Sigmoid 函数

回归 概念

假设现在有一些数据点，我们用一条直线对这些点进行拟合（这条直线称为最佳拟合直线），这个拟合的过程就叫做回归。进而可以得到对这些点的拟合直线方程，那么我们根据这个回归方程，怎么进行分类呢？请看下面。

二值型输出分类函数

我们想要的函数应该是: 能接受所有的输入然后预测出类别。例如，在两个类的情况下，上述函数输出 0 或 1.或许你之前接触过具有这种性质的函数，该函数称为 海维塞得阶跃函数(Heaviside step function)，或者直接称为 单位阶跃函数。然而，海维塞得阶跃函数的问题在于: 该函数在跳跃点上从 0 瞬间跳跃到 1，这个瞬间跳跃过程有时很难处理。幸好，另一个函数也有类似的性质（可以输出 0 或者 1 的性质），且数学上更易处理，这就是 Sigmoid 函数。 Sigmoid 函数具体的计算公式如下:

Sigmoid 函数计算公式

下图给出了 Sigmoid 函数在不同坐标尺度下的两条曲线图。当 x 为 0 时，Sigmoid 函数值为 0.5 。随着 x 的增大，对应的 Sigmoid 值将逼近于 1 ; 而随着 x 的减小， Sigmoid 值将逼近于 0 。如果横坐标刻度足够大， Sigmoid 函数看起来很像一个阶跃函数。

Sigmoid 函数在不同坐标下的图片

因此，为了实现 Logistic 回归分类器，我们可以在每个特征上都乘以一个回归系数（如下公式所示），然后把所有结果值相加，将这个总和代入 Sigmoid 函数中，进而得到一个范围在 0~1 之间的数值。任何大于 0.5 的数据被分入 1 类，小于 0.5 即被归入 0 类。所以，Logistic 回归也是一种概率估计，比如这里Sigmoid 函数得出的值为0.5，可以理解为给定数据和参数，数据被分入 1 类的概率为0.5。想对Sigmoid 函数有更多了解，可以点开此链接跟此函数互动。

基于最优化方法的回归系数确定

Sigmoid 函数的输入记为 z ，由下面公式得到:

Sigmoid 函数计算公式

如果采用向量的写法，上述公式可以写成 Sigmoid 函数计算公式向量形式 ，它表示将这两个数值向量对应元素相乘然后全部加起来即得到 z 值。其中的向量 x 是分类器的输入数据，向量 w 也就是我们要找到的最佳参数（系数），从而使得分类器尽可能地精确。为了寻找该最佳参数，需要用到最优化理论的一些知识。我们这里使用的是——梯度上升法（Gradient Ascent）。

梯度上升法

梯度上升法的思想

要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。如果梯度记为 ▽ ，则函数 f(x, y) 的梯度由下式表示:

梯度上升计算公式

这个梯度意味着要沿 x 的方向移动 f(x, y)对x求偏导 ，沿 y 的方向移动 f(x, y)对y求偏导 。其中，函数f(x, y) 必须要在待计算的点上有定义并且可微。下图是一个具体的例子。

梯度上升

上图展示的，梯度上升算法到达每个点后都会重新估计移动的方向。从 P0 开始，计算完该点的梯度，函数就根据梯度移动到下一点 P1。在 P1 点，梯度再次被重新计算，并沿着新的梯度方向移动到 P2 。如此循环迭代，直到满足停止条件。迭代过程中，梯度算子总是保证我们能选取到最佳的移动方向。

上图中的梯度上升算法沿梯度方向移动了一步。可以看到，梯度算子总是指向函数值增长最快的方向。这里所说的是移动方向，而未提到移动量的大小。该量值称为步长，记作 α 。用向量来表示的话，梯度上升算法的迭代公式如下:

梯度上升迭代公式

该公式将一直被迭代执行，直至达到某个停止条件为止，比如迭代次数达到某个指定值或者算法达到某个可以允许的误差范围。

介绍一下几个相关的概念：

  1. 例如：y = w0 + w1x1 + w2x2 + ... + wnxn
  2. 梯度：参考上图的例子，二维图像，x方向代表第一个系数，也就是 w1，y方向代表第二个系数也就是 w2，这样的向量就是梯度。
  3. α：上面的梯度算法的迭代公式中的阿尔法，这个代表的是移动步长（step length）。移动步长会影响最终结果的拟合程度，最好的方法就是随着迭代次数更改移动步长。
  4. 步长通俗的理解，100米，如果我一步走10米，我需要走10步；如果一步走20米，我只需要走5步。这里的一步走多少米就是步长的意思。
  5. ▽f(w)：代表沿着梯度变化的方向。

问：有人会好奇为什么有些书籍上说的是梯度下降法（Gradient Decent）?

答： 其实这个两个方法在此情况下本质上是相同的。关键在于代价函数（cost function）或者叫目标函数（objective function）。如果目标函数是损失函数，那就是最小化损失函数来求函数的最小值，就用梯度下降。 如果目标函数是似然函数（Likelihood function），就是要最大化似然函数来求函数的最大值，那就用梯度上升。在逻辑回归中， 损失函数和似然函数无非就是互为正负关系。

只需要在迭代公式中的加法变成减法。因此，对应的公式可以写成

梯度下降迭代公式

局部最优现象 （Local Optima）

梯度下降图\_4

上图表示参数 θ 与误差函数 J(θ) 的关系图 (这里的误差函数是损失函数，所以我们要最小化损失函数)，红色的部分是表示 J(θ) 有着比较高的取值，我们需要的是，能够让 J(θ) 的值尽量的低。也就是深蓝色的部分。θ0，θ1 表示 θ 向量的两个维度（此处的θ0，θ1是x0和x1的系数，也对应的是上文w0和w1）。

可能梯度下降的最终点并非是全局最小点，可能是一个局部最小点，如我们上图中的右边的梯度下降曲线，描述的是最终到达一个局部最小点，这是我们重新选择了一个初始点得到的。

看来我们这个算法将会在很大的程度上被初始点的选择影响而陷入局部最小点。

Logistic 回归 原理

Logistic 回归 工作原理

  1. 每个回归系数初始化为 1
  2. 重复 R 次:
  3.     计算整个数据集的梯度
  4.     使用 步长 x 梯度 更新回归系数的向量
  5. 返回回归系数

Logistic 回归 开发流程

  1. 收集数据: 采用任意方法收集数据
  2. 准备数据: 由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳。
  3. 分析数据: 采用任意方法对数据进行分析。
  4. 训练算法: 大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数。
  5. 测试算法: 一旦训练步骤完成，分类将会很快。
  6. 使用算法: 首先，我们需要输入一些数据，并将其转换成对应的结构化数值；接着，基于训练好的回归系数就可以对这些数值进行简单的回归计算，判定它们属于哪个类别；在这之后，我们就可以在输出的类别上做一些其他分析工作。

Logistic 回归 算法特点

  1. 优点: 计算代价不高，易于理解和实现。
  2. 缺点: 容易欠拟合，分类精度可能不高。
  3. 适用数据类型: 数值型和标称型数据。

附加 方向导数与梯度

方向导数与梯度

Logistic 回归 项目案例

项目概述

在一个简单的数据集上，采用梯度上升法找到 Logistic 回归分类器在此数据集上的最佳回归系数

开发流程

  1. 收集数据: 可以使用任何方法
  2. 准备数据: 由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳
  3. 分析数据: 画出决策边界
  4. 训练算法: 使用梯度上升找到最佳参数
  5. 测试算法: 使用 Logistic 回归进行分类
  6. 使用算法: 对简单数据集中数据进行分类

收集数据: 可以使用任何方法

我们采用存储在 TestSet.txt 文本文件中的数据，存储格式如下:

  1. -0.017612    14.053064    0
  2. -1.395634    4.662541    1
  3. -0.752157    6.538620    0
  4. -1.322371    7.152853    0
  5. 0.423363    11.054677    0

绘制在图中，如下图所示:

简单数据集绘制在图上

准备数据: 由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳

  1. import numpy as np
  3. data_arr = []
  4. label_arr = []
  5. f = open('D:\\mlInAction\\data\\5.Logistic\\TestSet.txt', 'r')
  6. for line in f.readlines():
  7.     line_arr = line.strip().split()
  8.     # 为了方便计算，我们将 X0 的值设为 1.0 ，也就是在每一行的开头添加一个 1.0 作为 X0
  9.     data_arr.append([1.0, np.float(line_arr[0]), np.float(line_arr[1])])
  10.     label_arr.append(int(line_arr[2]))

分析数据: 采用任意方法对数据进行分析，此处不需要

训练算法: 使用梯度上升找到最佳参数

定义sigmoid阶跃函数

  1. def sigmoid(x):
  2.     # 这里其实非常有必要解释一下，会出现的错误 RuntimeWarning: overflow encountered in exp
  3.     # 这个错误在学习阶段虽然可以忽略，但是我们至少应该知道为什么
  4.     # 这里是因为我们输入的有的 x 实在是太小了，比如 -6000之类的，那么计算一个数字 np.exp(6000)这个结果太大了，没法表示，所以就溢出了
  5.     # 如果是计算 np.exp（-6000），这样虽然也会溢出，但是这是下溢，就是表示成零
  6.     # 去网上搜了很多方法，比如 使用bigfloat这个库（我竟然没有安装成功，就不尝试了，反正应该是有用的
  7.     return 1.0 / (1 + np.exp(-x))

Logistic 回归梯度上升优化算法

  1. def grad_ascent(data_arr, class_labels):
  2.     """
  3.     梯度上升法，其实就是因为使用了极大似然估计，这个大家有必要去看推导，只看代码感觉不太够
  4.     :param data_arr: 传入的就是一个普通的数组，当然你传入一个二维的ndarray也行
  5.     :param class_labels: class_labels 是类别标签，它是一个 1*100 的行向量。
  6.                     为了便于矩阵计算，需要将该行向量转换为列向量，做法是将原向量转置，再将它赋值给label_mat
  7.     :return: 
  8.     """
  9.     # 注意一下，我把原来 data_mat_in 改成data_arr,因为传进来的是一个数组，用这个比较不容易搞混
  10.     # turn the data_arr to numpy matrix
  11.     data_mat = np.mat(data_arr)
  12.     # 变成矩阵之后进行转置
  13.     label_mat = np.mat(class_labels).transpose()
  14.     # m->数据量，样本数 n->特征数
  15.     m, n = np.shape(data_mat)
  16.     # 学习率，learning rate
  17.     alpha = 0.001
  18.     # 最大迭代次数，假装迭代这么多次就能收敛2333
  19.     max_cycles = 500
  20.     # 生成一个长度和特征数相同的矩阵，此处n为3 -> [[1],[1],[1]]
  21.     # weights 代表回归系数， 此处的 ones((n,1)) 创建一个长度和特征数相同的矩阵，其中的数全部都是 1
  22.     weights = np.ones((n, 1))
  23.     for k in range(max_cycles):
  24.         # 这里是点乘  m x 3 dot 3 x 1
  25.         h = sigmoid(data_mat * weights)
  26.         error = label_mat - h
  27.         # 这里比较建议看一下推导，为什么这么做可以，这里已经是求导之后的
  28.         weights = weights + alpha * data_mat.transpose() * error
  29.     return weights

大家看到这儿可能会有一些疑惑，就是，我们在迭代中更新我们的回归系数，后边的部分是怎么计算出来的？为什么会是 alpha * dataMatrix.transpose() * error ?因为这就是我们所求的梯度，也就是对 f(w) 对 w 求一阶导数。具体推导如下:

f(w)对w求一阶导数

可参考http://blog.csdn.net/achuo/article/details/51160101

画出数据集和 Logistic 回归最佳拟合直线的函数

  1. import matplotlib.pyplot as plt
  3. def plot_best_fit(data_mat, label_mat, weights):
  4.     """
  5.     可视化
  6.     :param weights: 
  7.     :return: 
  8.     """
  9.     data_arr = np.array(data_mat)
  10.     n = np.shape(data_mat)[0]
  11.     x_cord1 = []
  12.     y_cord1 = []
  13.     x_cord2 = []
  14.     y_cord2 = []
  15.     for i in range(n):
  16.         if int(label_mat[i]) == 1:
  17.             x_cord1.append(data_arr[i, 1])
  18.             y_cord1.append(data_arr[i, 2])
  19.         else:
  20.             x_cord2.append(data_arr[i, 1])
  21.             y_cord2.append(data_arr[i, 2])
  22.     fig = plt.figure()
  23.     ax = fig.add_subplot(111)
  24.     ax.scatter(x_cord1, y_cord1, s=30, color='k', marker='^')
  25.     ax.scatter(x_cord2, y_cord2, s=30, color='red', marker='s')
  26.     x = np.arange(-3.0, 3.0, 0.1)
  27.     # print(x)
  28.     y = (-weights[0] - weights[1] * x) / weights[2]
  29.     # type(y)
  30.     y = np.ravel(y)  # y原来是一个二维，需要转化为1维
  31.     """
  32.     y的由来，卧槽，是不是没看懂？
  33.     首先理论上是这个样子的。
  34.     dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
  35.     w0*x0+w1*x1+w2*x2=f(x)
  36.     x0最开始就设置为1叻， x2就是我们画图的y值，而f(x)被我们磨合误差给算到w0,w1,w2身上去了
  37.     所以： w0+w1*x+w2*y=0 => y = (-w0-w1*x)/w2   
  38.     """
  39.     ax.plot(x, y)
  40.     plt.xlabel('x1')
  41.     plt.ylabel('y1')
  42.     plt.show()

注意

梯度上升算法在每次更新回归系数时都需要遍历整个数据集，该方法在处理 100 个左右的数据集时尚可，但如果有数十亿样本和成千上万的特征，那么该方法的计算复杂度就太高了。一种改进方法是一次仅用一个样本点来更新回归系数，该方法称为 随机梯度上升算法。由于可以在新样本到来时对分类器进行增量式更新，因而随机梯度上升算法是一个在线学习(online learning)算法。与 “在线学习” 相对应，一次处理所有数据被称作是 “批处理” （batch） 。

随机梯度上升算法可以写成如下的伪代码:

  1. 所有回归系数初始化为 1
  2. 对数据集中每个样本
  3.     计算该样本的梯度
  4.     使用 alpha * gradient 更新回归系数值
  5. 返回回归系数值
  7. 以下是随机梯度上升算法的实现代码:
  9. def stoc_grad_ascent0(data_mat, class_labels):
  10.     """
  11.     随机梯度上升，只使用一个样本点来更新回归系数
  12.     :param data_mat: 输入数据的数据特征（除去最后一列）,ndarray
  13.     :param class_labels: 输入数据的类别标签（最后一列数据）
  14.     :return: 得到的最佳回归系数
  15.     """
  16.     m, n = np.shape(data_mat)
  17.     alpha = 0.01
  18.     weights = np.ones(n)
  19.     for i in range(m):
  20.         # sum(data_mat[i]*weights)为了求 f(x)的值， f(x)=a1*x1+b2*x2+..+nn*xn,
  21.         # 此处求出的 h 是一个具体的数值，而不是一个矩阵
  22.         h = sigmoid(sum(data_mat[i] * weights))
  23.         error = class_labels[i] - h
  24.         # 还是和上面一样，这个先去看推导，再写程序
  25.         weights = weights + alpha * error * data_mat[i]
  26.     return weights

可以看到，随机梯度上升算法与梯度上升算法在代码上很相似，但也有一些区别: 第一，后者的变量 h 和误差 error 都是向量，而前者则全是数值；第二，前者没有矩阵的转换过程，所有变量的数据类型都是 NumPy 数组。

判断优化算法优劣的可靠方法是看它是否收敛，也就是说参数是否达到了稳定值，是否还会不断地变化？下图展示了随机梯度上升算法在 200 次迭代过程中回归系数的变化情况。其中的系数2，也就是 X2 只经过了 50 次迭代就达到了稳定值，但系数 1 和 0 则需要更多次的迭代。如下图所示:

回归系数与迭代次数的关系图

针对这个问题，我们改进了之前的随机梯度上升算法，如下:

  1. def stoc_grad_ascent1(data_mat, class_labels, num_iter=150):
  2.     """
  3.     改进版的随机梯度上升，使用随机的一个样本来更新回归系数
  4.     :param data_mat: 输入数据的数据特征（除去最后一列）,ndarray
  5.     :param class_labels: 输入数据的类别标签（最后一列数据
  6.     :param num_iter: 迭代次数
  7.     :return: 得到的最佳回归系数
  8.     """
  9.     m, n = np.shape(data_mat)
  10.     weights = np.ones(n)
  11.     for j in range(num_iter):
  12.         # 这里必须要用list，不然后面的del没法使用
  13.         data_index = list(range(m))
  14.         for i in range(m):
  15.             # i和j的不断增大，导致alpha的值不断减少，但是不为0
  16.             alpha = 4 / (1.0 + j + i) + 0.01
  17.             # 随机产生一个 0～len()之间的一个值
  18.             # random.uniform(x, y) 方法将随机生成下一个实数，它在[x,y]范围内,x是这个范围内的最小值，y是这个范围内的最大值。
  19.             rand_index = int(np.random.uniform(0, len(data_index)))
  20.             h = sigmoid(np.sum(data_mat[data_index[rand_index]] * weights))
  21.             error = class_labels[data_index[rand_index]] - h
  22.             weights = weights + alpha * error * data_mat[data_index[rand_index]]
  23.             del(data_index[rand_index])
  24.     return weights

In [54]:

  1. import numpy as np
  3. data_arr = []
  4. label_arr = []
  5. f = open('D:\\mlInAction\\data\\5.Logistic\\TestSet.txt', 'r')
  6. for line in f.readlines():
  7.     line_arr = line.strip().split()
  8.     # 为了方便计算，我们将 X0 的值设为 1.0 ，也就是在每一行的开头添加一个 1.0 作为 X0
  9.     data_arr.append([1.0, np.float(line_arr[0]), np.float(line_arr[1])])
  10.     label_arr.append(int(line_arr[2]))

In [55]:

  1. data_arr

Out[55]:

  1. [[1.0, -0.017612, 14.053064],
  2.  [1.0, -1.395634, 4.662541],
  3.  [1.0, -0.752157, 6.53862],
  4.  [1.0, -1.322371, 7.152853],
  5.  [1.0, 0.423363, 11.054677],
  6.  [1.0, 0.406704, 7.067335],
  7.  [1.0, 0.667394, 12.741452],
  8.  [1.0, -2.46015, 6.866805],
  9.  [1.0, 0.569411, 9.548755],
  10.  [1.0, -0.026632, 10.427743],
  11.  [1.0, 0.850433, 6.920334],
  12.  [1.0, 1.347183, 13.1755],
  13.  [1.0, 1.176813, 3.16702],
  14.  [1.0, -1.781871, 9.097953],
  15.  [1.0, -0.566606, 5.749003],
  16.  [1.0, 0.931635, 1.589505],
  17.  [1.0, -0.024205, 6.151823],
  18.  [1.0, -0.036453, 2.690988],
  19.  [1.0, -0.196949, 0.444165],
  20.  [1.0, 1.014459, 5.754399],
  21.  [1.0, 1.985298, 3.230619],
  22.  [1.0, -1.693453, -0.55754],
  23.  [1.0, -0.576525, 11.778922],
  24.  [1.0, -0.346811, -1.67873],
  25.  [1.0, -2.124484, 2.672471],
  26.  [1.0, 1.217916, 9.597015],
  27.  [1.0, -0.733928, 9.098687],
  28.  [1.0, -3.642001, -1.618087],
  29.  [1.0, 0.315985, 3.523953],
  30.  [1.0, 1.416614, 9.619232],
  31.  [1.0, -0.386323, 3.989286],
  32.  [1.0, 0.556921, 8.294984],
  33.  [1.0, 1.224863, 11.58736],
  34.  [1.0, -1.347803, -2.406051],
  35.  [1.0, 1.196604, 4.951851],
  36.  [1.0, 0.275221, 9.543647],
  37.  [1.0, 0.470575, 9.332488],
  38.  [1.0, -1.889567, 9.542662],
  39.  [1.0, -1.527893, 12.150579],
  40.  [1.0, -1.185247, 11.309318],
  41.  [1.0, -0.445678, 3.297303],
  42.  [1.0, 1.042222, 6.105155],
  43.  [1.0, -0.618787, 10.320986],
  44.  [1.0, 1.152083, 0.548467],
  45.  [1.0, 0.828534, 2.676045],
  46.  [1.0, -1.237728, 10.549033],
  47.  [1.0, -0.683565, -2.166125],
  48.  [1.0, 0.229456, 5.921938],
  49.  [1.0, -0.959885, 11.555336],
  50.  [1.0, 0.492911, 10.993324],
  51.  [1.0, 0.184992, 8.721488],
  52.  [1.0, -0.355715, 10.325976],
  53.  [1.0, -0.397822, 8.058397],
  54.  [1.0, 0.824839, 13.730343],
  55.  [1.0, 1.507278, 5.027866],
  56.  [1.0, 0.099671, 6.835839],
  57.  [1.0, -0.344008, 10.717485],
  58.  [1.0, 1.785928, 7.718645],
  59.  [1.0, -0.918801, 11.560217],
  60.  [1.0, -0.364009, 4.7473],
  61.  [1.0, -0.841722, 4.119083],
  62.  [1.0, 0.490426, 1.960539],
  63.  [1.0, -0.007194, 9.075792],
  64.  [1.0, 0.356107, 12.447863],
  65.  [1.0, 0.342578, 12.281162],
  66.  [1.0, -0.810823, -1.466018],
  67.  [1.0, 2.530777, 6.476801],
  68.  [1.0, 1.296683, 11.607559],
  69.  [1.0, 0.475487, 12.040035],
  70.  [1.0, -0.783277, 11.009725],
  71.  [1.0, 0.074798, 11.02365],
  72.  [1.0, -1.337472, 0.468339],
  73.  [1.0, -0.102781, 13.763651],
  74.  [1.0, -0.147324, 2.874846],
  75.  [1.0, 0.518389, 9.887035],
  76.  [1.0, 1.015399, 7.571882],
  77.  [1.0, -1.658086, -0.027255],
  78.  [1.0, 1.319944, 2.171228],
  79.  [1.0, 2.056216, 5.019981],
  80.  [1.0, -0.851633, 4.375691],
  81.  [1.0, -1.510047, 6.061992],
  82.  [1.0, -1.076637, -3.181888],
  83.  [1.0, 1.821096, 10.28399],
  84.  [1.0, 3.01015, 8.401766],
  85.  [1.0, -1.099458, 1.688274],
  86.  [1.0, -0.834872, -1.733869],
  87.  [1.0, -0.846637, 3.849075],
  88.  [1.0, 1.400102, 12.628781],
  89.  [1.0, 1.752842, 5.468166],
  90.  [1.0, 0.078557, 0.059736],
  91.  [1.0, 0.089392, -0.7153],
  92.  [1.0, 1.825662, 12.693808],
  93.  [1.0, 0.197445, 9.744638],
  94.  [1.0, 0.126117, 0.922311],
  95.  [1.0, -0.679797, 1.22053],
  96.  [1.0, 0.677983, 2.556666],
  97.  [1.0, 0.761349, 10.693862],
  98.  [1.0, -2.168791, 0.143632],
  99.  [1.0, 1.38861, 9.341997],
  100.  [1.0, 0.317029, 14.739025]]

In [56]:

  1. label_arr

Out[56]:

  1. [0,
  2.  1,
  3.  0,
  4.  0,
  5.  0,
  6.  1,
  7.  0,
  8.  1,
  9.  0,
  10.  0,
  11.  1,
  12.  0,
  13.  1,
  14.  0,
  15.  1,
  16.  1,
  17.  1,
  18.  1,
  19.  1,
  20.  1,
  21.  1,
  22.  1,
  23.  0,
  24.  1,
  25.  1,
  26.  0,
  27.  0,
  28.  1,
  29.  1,
  30.  0,
  31.  1,
  32.  1,
  33.  0,
  34.  1,
  35.  1,
  36.  0,
  37.  0,
  38.  0,
  39.  0,
  40.  0,
  41.  1,
  42.  1,
  43.  0,
  44.  1,
  45.  1,
  46.  0,
  47.  1,
  48.  1,
  49.  0,
  50.  0,
  51.  0,
  52.  0,
  53.  0,
  54.  0,
  55.  1,
  56.  1,
  57.  0,
  58.  1,
  59.  0,
  60.  1,
  61.  1,
  62.  1,
  63.  0,
  64.  0,
  65.  0,
  66.  1,
  67.  1,
  68.  0,
  69.  0,
  70.  0,
  71.  0,
  72.  1,
  73.  0,
  74.  1,
  75.  0,
  76.  0,
  77.  1,
  78.  1,
  79.  1,
  80.  1,
  81.  0,
  82.  1,
  83.  0,
  84.  1,
  85.  1,
  86.  1,
  87.  1,
  88.  0,
  89.  1,
  90.  1,
  91.  1,
  92.  0,
  93.  0,
  94.  1,
  95.  1,
  96.  1,
  97.  0,
  98.  1,
  99.  0,
  100.  0]

In [57]:

  1. def sigmoid(x):
  2.     # 这里其实非常有必要解释一下，会出现的错误 RuntimeWarning: overflow encountered in exp
  3.     # 这个错误在学习阶段虽然可以忽略，但是我们至少应该知道为什么
  4.     # 这里是因为我们输入的有的 x 实在是太小了，比如 -6000之类的，那么计算一个数字 np.exp(6000)这个结果太大了，没法表示，所以就溢出了
  5.     # 如果是计算 np.exp（-6000），这样虽然也会溢出，但是这是下溢，就是表示成零
  6.     # 去网上搜了很多方法，比如 使用bigfloat这个库（我竟然没有安装成功，就不尝试了，反正应该是有用的
  7.     return 1.0 / (1 + np.exp(-x))

In [58]:

  1. def grad_ascent(data_arr, class_labels):
  2.     """
  3.     梯度上升法，其实就是因为使用了极大似然估计，这个大家有必要去看推导，只看代码感觉不太够
  4.     :param data_arr: 传入的就是一个普通的数组，当然你传入一个二维的ndarray也行
  5.     :param class_labels: class_labels 是类别标签，它是一个 1*100 的行向量。
  6.                     为了便于矩阵计算，需要将该行向量转换为列向量，做法是将原向量转置，再将它赋值给label_mat
  7.     :return: 
  8.     """
  9.     # 注意一下，我把原来 data_mat_in 改成data_arr,因为传进来的是一个数组，用这个比较不容易搞混
  10.     # turn the data_arr to numpy matrix
  11.     data_mat = np.mat(data_arr)
  12.     # 变成矩阵之后进行转置
  13.     label_mat = np.mat(class_labels).transpose()
  14.     # m->数据量，样本数 n->特征数
  15.     m, n = np.shape(data_mat)
  16.     # 学习率，learning rate
  17.     alpha = 0.001
  18.     # 最大迭代次数，假装迭代这么多次就能收敛2333
  19.     max_cycles = 500
  20.     # 生成一个长度和特征数相同的矩阵，此处n为3 -> [[1],[1],[1]]
  21.     # weights 代表回归系数， 此处的 ones((n,1)) 创建一个长度和特征数相同的矩阵，其中的数全部都是 1
  22.     weights = np.ones((n, 1))
  23.     for k in range(max_cycles):
  24.         # 这里是点乘  m x 3 dot 3 x 1
  25.         h = sigmoid(data_mat * weights)
  26.         error = label_mat - h
  27.         # 这里比较建议看一下推导，为什么这么做可以，这里已经是求导之后的
  28.         weights = weights + alpha * data_mat.transpose() * error
  29.     return weights

In [69]:

  1. weights = grad_ascent(data_arr, label_arr)
  2. weights

Out[69]:

  1. matrix([[ 4.12414349],
  2.         [ 0.48007329],
  3.         [-0.6168482 ]])

In [76]:

  1. import matplotlib.pyplot as plt
  4. def plot_best_fit(data_mat, label_mat, weights):
  5.     """
  6.     可视化
  7.     :param weights: 
  8.     :return: 
  9.     """
  10.     data_arr = np.array(data_mat)
  11.     n = np.shape(data_mat)[0]
  12.     x_cord1 = []
  13.     y_cord1 = []
  14.     x_cord2 = []
  15.     y_cord2 = []
  16.     for i in range(n):
  17.         if int(label_mat[i]) == 1:
  18.             x_cord1.append(data_arr[i, 1])
  19.             y_cord1.append(data_arr[i, 2])
  20.         else:
  21.             x_cord2.append(data_arr[i, 1])
  22.             y_cord2.append(data_arr[i, 2])
  23.     fig = plt.figure()
  24.     ax = fig.add_subplot(111)
  25.     ax.scatter(x_cord1, y_cord1, s=30, color='k', marker='^')
  26.     ax.scatter(x_cord2, y_cord2, s=30, color='red', marker='s')
  27.     x = np.arange(-3.0, 3.0, 0.1)
  28.     # print(x)
  29.     y = (-weights[0] - weights[1] * x) / weights[2]
  30.     # type(y)
  31.     y = np.ravel(y)  # y原来是一个二维，需要转化为1维
  32.     """
  33.     y的由来，卧槽，是不是没看懂？
  34.     首先理论上是这个样子的。
  35.     dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
  36.     w0*x0+w1*x1+w2*x2=f(x)
  37.     x0最开始就设置为1叻， x2就是我们画图的y值，而f(x)被我们磨合误差给算到w0,w1,w2身上去了
  38.     所以： w0+w1*x+w2*y=0 => y = (-w0-w1*x)/w2   
  39.     """
  40.     ax.plot(x, y)
  41.     plt.xlabel('x1')
  42.     plt.ylabel('y1')
  43.     plt.show()

In [77]:

  1. plot_best_fit(data_arr, label_arr, weights)

![Image 1][]

In [72]:

  1. def stoc_grad_ascent0(data_mat, class_labels):
  2.     """
  3.     随机梯度上升，只使用一个样本点来更新回归系数
  4.     :param data_mat: 输入数据的数据特征（除去最后一列）,ndarray
  5.     :param class_labels: 输入数据的类别标签（最后一列数据）
  6.     :return: 得到的最佳回归系数
  7.     """
  8.     m, n = np.shape(data_mat)
  9.     alpha = 0.01
  10.     weights = np.ones(n)
  11.     for i in range(m):
  12.         # sum(data_mat[i]*weights)为了求 f(x)的值， f(x)=a1*x1+b2*x2+..+nn*xn,
  13.         # 此处求出的 h 是一个具体的数值，而不是一个矩阵
  14.         h = sigmoid(sum(data_mat[i] * weights))
  15.         error = class_labels[i] - h
  16.         # 还是和上面一样，这个先去看推导，再写程序
  17.         weights = weights + alpha * error * data_mat[i]
  18.     return weights

In [78]:

  1. def stoc_grad_ascent1(data_mat, class_labels, num_iter=150):
  2.     """
  3.     改进版的随机梯度上升，使用随机的一个样本来更新回归系数
  4.     :param data_mat: 输入数据的数据特征（除去最后一列）,ndarray
  5.     :param class_labels: 输入数据的类别标签（最后一列数据
  6.     :param num_iter: 迭代次数
  7.     :return: 得到的最佳回归系数
  8.     """
  9.     m, n = np.shape(data_mat)
  10.     weights = np.ones(n)
  11.     for j in range(num_iter):
  12.         # 这里必须要用list，不然后面的del没法使用
  13.         data_index = list(range(m))
  14.         for i in range(m):
  15.             # i和j的不断增大，导致alpha的值不断减少，但是不为0
  16.             alpha = 4 / (1.0 + j + i) + 0.01
  17.             # 随机产生一个 0～len()之间的一个值
  18.             # random.uniform(x, y) 方法将随机生成下一个实数，它在[x,y]范围内,x是这个范围内的最小值，y是这个范围内的最大值。
  19.             rand_index = int(np.random.uniform(0, len(data_index)))
  20.             h = sigmoid(np.sum(data_mat[data_index[rand_index]] * weights))
  21.             error = class_labels[data_index[rand_index]] - h
  22.             weights = weights + alpha * error * data_mat[data_index[rand_index]]
  23.             del(data_index[rand_index])
  24.     return weights

In [81]:

  1. weights1 = stoc_grad_ascent1(np.array(data_arr), np.array(label_arr))
  2. weights1

Out[81]:

  1. array([13.97204276,  1.24615972, -1.9102347 ])

In [82]:

  1. plot_best_fit(data_arr, label_arr, weights1)

![Image 1][]

转载于:https://www.cnblogs.com/xinmomoyan/p/10502770.html

[Image 1]:

发表评论

表情：
评论列表 （有 0 条评论，306人围观）

还没有评论，来说两句吧...

相关阅读

    相关 机器学习实战笔记5(logistic回归)

    1：简单概念描述 假设现在有一些数据点，我们用一条直线对这些点进行拟合(该线称为最佳拟合直线)，这个拟合过程就称为回归。训练分类器就是为了寻找最佳拟合参数，使用的是最优化算法

    叁歲伎倆叁歲伎倆/ 0 赞/ 313 阅读