• 逻辑回归Logistic

    回归 概念

    假设现在有一些数据点，我们用一条直线对这些点进行拟合（这条直线称为最佳拟合直线），这个拟合的过程就叫做回归。进而可以得到对这些点的拟合直线方程。

    最后结果用sigmoid函数输出\sigma (z)=\frac{1}{1+e^{-z}}

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

    逻辑回归实际上就是一层神经网络

    sigmoid函数的输入

    z=w_{0}x_{0}+w_{1}x_{1}+w_{2}x_{2}+.....+w_{n}x_{n}

    梯度上升

    梯度=梯度值+梯度方向

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

    \triangledown f(x,y)=\begin{cases} \frac{\partial f(x,y)}{\partial x} & \text{ } \\ \frac{\partial f(x,y)}{\partial y} & \text{ } \end{cases}

    上式表示要沿x的方向移动\frac{\partial f(x,y)}{\partial x}，沿y方向移动\frac{\partial f(x,y)}{\partial y}。其中，函数f(x,y)必须要在待计算的点上有定义并且可微。

    w=w+\alpha \bigtriangledown _{x}f(w)

    梯度下降和梯度上升：

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

    只需要在迭代公式中的加法变成减法。因此，对应的公式可以写成w=w-\alpha \bigtriangledown _{x}f(w)

    1. from __future__ import print_function
    2. from numpy import *
    3. import matplotlib.pyplot as plt
    4.  
    5. # ---------------------------------------------------------------------------
    6. # 使用 Logistic 回归在简单数据集上的分类
    7.  
    8.  
    9. # 解析数据
    10. def loadDataSet(file_name):
    11.     '''
    12.     Desc: 
    13.         加载并解析数据
    14.     Args:
    15.         file_name -- 文件名称，要解析的文件所在磁盘位置
    16.     Returns:
    17.         dataMat -- 原始数据的特征
    18.         labelMat -- 原始数据的标签，也就是每条样本对应的类别
    19.     '''
    20.     # dataMat为原始数据， labelMat为原始数据的标签
    21.     dataMat = []
    22.     labelMat = []
    23.     fr = open(file_name)
    24.     for line in fr.readlines():
    25.         lineArr = line.strip().split()
    26.         if len(lineArr) == 1:
    27.             continue    # 这里如果就一个空的元素，则跳过本次循环
    28.         # 为了方便计算，我们将 X0 的值设为 1.0 ，也就是在每一行的开头添加一个 1.0 作为 X0
    29.         dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
    30.         labelMat.append(int(lineArr[2]))
    31.     return dataMat, labelMat
    32.  
    33.  
    34. # sigmoid跳跃函数
    35. def sigmoid(inX):
    36.     # return 1.0 / (1 + exp(-inX))
    37.  
    38.     # Tanh是Sigmoid的变形，与 sigmoid 不同的是，tanh 是0均值的。因此，实际应用中，tanh 会比 sigmoid 更好。
    39.     return 2 * 1.0/(1+exp(-2*inX)) - 1
    40.  
    41.  
    42. # 正常的处理方案
    43. # 两个参数: 第一个参数==> dataMatIn 是一个2维NumPy数组，每列分别代表每个不同的特征，每行则代表每个训练样本。
    44. # 第二个参数==> classLabels 是类别标签，它是一个 1*100 的行向量。为了便于矩阵计算，需要将该行向量转换为列向量，做法是将原向量转置，再将它赋值给labelMat。
    45. def gradAscent(dataMatIn, classLabels):
    46.     '''
    47.     Desc:
    48.         正常的梯度上升法
    49.     Args:
    50.         dataMatIn -- 输入的 数据的特征 List
    51.         classLabels -- 输入的数据的类别标签
    52.     Returns:
    53.         array(weights) -- 得到的最佳回归系数
    54.     '''
    55.  
    56.     # 转化为矩阵[[1,1,2],[1,1,2]....]
    57.     dataMatrix = mat(dataMatIn)  # 转换为 NumPy 矩阵
    58.     # 转化为矩阵[[0,1,0,1,0,1.....]]，并转制[[0],[1],[0].....]
    59.     # transpose() 行列转置函数
    60.     # 将行向量转化为列向量   =>  矩阵的转置
    61.     labelMat = mat(classLabels).transpose()  # 首先将数组转换为 NumPy 矩阵，然后再将行向量转置为列向量
    62.     # m->数据量，样本数 n->特征数
    63.     m, n = shape(dataMatrix)
    64.     # print m, n, '__'*10, shape(dataMatrix.transpose()), '__'*100
    65.     # alpha代表向目标移动的步长
    66.     alpha = 0.001
    67.     # 迭代次数
    68.     maxCycles = 500
    69.     # 生成一个长度和特征数相同的矩阵，此处n为3 -> [[1],[1],[1]]
    70.     # weights 代表回归系数， 此处的 ones((n,1)) 创建一个长度和特征数相同的矩阵，其中的数全部都是 1
    71.     weights = ones((n, 1))
    72.     for k in range(maxCycles):  # heavy on matrix operations
    73.         # m*3 的矩阵 * 3*1 的单位矩阵 ＝ m*1的矩阵
    74.         # 那么乘上单位矩阵的意义，就代表: 通过公式得到的理论值
    75.         # 参考地址:  矩阵乘法的本质是什么？ https://www.zhihu.com/question/21351965/answer/31050145
    76.         # print 'dataMatrix====', dataMatrix 
    77.         # print 'weights====', weights
    78.         # n*3   *  3*1  = n*1
    79.         h = sigmoid(dataMatrix * weights)  # 矩阵乘法
    80.         # print 'hhhhhhh====', h
    81.         # labelMat是实际值
    82.         error = (labelMat - h)  # 向量相减
    83.         # 0.001* (3*m)*(m*1) 表示在每一个列上的一个误差情况，最后得出 x1,x2,xn的系数的偏移量
    84.         weights = weights + alpha * dataMatrix.transpose() * error  # 矩阵乘法，最后得到回归系数
    85.     return array(weights)
    86.  
    87.  
    88. # 随机梯度下降
    89. # 梯度下降优化算法在每次更新数据集时都需要遍历整个数据集，计算复杂都较高
    90. # 随机梯度下降一次只用一个样本点来更新回归系数
    91. def stocGradAscent0(dataMatrix, classLabels):
    92.     '''
    93.     Desc:
    94.         随机梯度下降，只使用一个样本点来更新回归系数
    95.     Args:
    96.         dataMatrix -- 输入数据的数据特征（除去最后一列）
    97.         classLabels -- 输入数据的类别标签（最后一列数据）
    98.     Returns:
    99.         weights -- 得到的最佳回归系数
    100.     '''
    101.     m, n = shape(dataMatrix)
    102.     alpha = 0.01
    103.     # n*1的矩阵
    104.     # 函数ones创建一个全1的数组
    105.     weights = ones(n)  # 初始化长度为n的数组，元素全部为 1
    106.     for i in range(m):
    107.         # sum(dataMatrix[i]*weights)为了求 f(x)的值， f(x)=a1*x1+b2*x2+..+nn*xn,此处求出的 h 是一个具体的数值，而不是一个矩阵
    108.         h = sigmoid(sum(dataMatrix[i] * weights))
    109.         # print 'dataMatrix[i]===', dataMatrix[i]
    110.         # 计算真实类别与预测类别之间的差值，然后按照该差值调整回归系数
    111.         error = classLabels[i] - h
    112.         # 0.01*(1*1)*(1*n)
    113.         # print weights, "*" * 10, dataMatrix[i], "*" * 10, error
    114.         weights = weights + alpha * error * dataMatrix[i]
    115.     return weights
    116.  
    117.  
    118. # 随机梯度下降算法（随机化）
    119. def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    120.     '''
    121.     Desc:
    122.         改进版的随机梯度下降，使用随机的一个样本来更新回归系数
    123.     Args:
    124.         dataMatrix -- 输入数据的数据特征（除去最后一列数据）
    125.         classLabels -- 输入数据的类别标签（最后一列数据）
    126.         numIter=150 --  迭代次数
    127.     Returns:
    128.         weights -- 得到的最佳回归系数
    129.     '''
    130.     m, n = shape(dataMatrix)
    131.     weights = ones(n)  # 创建与列数相同的矩阵的系数矩阵，所有的元素都是1
    132.     # 随机梯度, 循环150,观察是否收敛
    133.     for j in range(numIter):
    134.         # [0, 1, 2 .. m-1]
    135.         dataIndex = range(m)
    136.         for i in range(m):
    137.             # i和j的不断增大，导致alpha的值不断减少，但是不为0
    138.             alpha = 4 / (
    139.                 1.0 + j + i
    140.             ) + 0.0001  # alpha 会随着迭代不断减小，但永远不会减小到0，因为后边还有一个常数项0.0001
    141.             # 随机产生一个 0～len()之间的一个值
    142.             # random.uniform(x, y) 方法将随机生成下一个实数，它在[x,y]范围内,x是这个范围内的最小值，y是这个范围内的最大值。
    143.             randIndex = int(random.uniform(0, len(dataIndex)))
    144.             # sum(dataMatrix[i]*weights)为了求 f(x)的值， f(x)=a1*x1+b2*x2+..+nn*xn
    145.             h = sigmoid(sum(dataMatrix[dataIndex[randIndex]] * weights))
    146.             error = classLabels[dataIndex[randIndex]] - h
    147.             # print weights, '__h=%s' % h, '__'*20, alpha, '__'*20, error, '__'*20, dataMatrix[randIndex]
    148.             weights = weights + alpha * error * dataMatrix[dataIndex[randIndex]]
    149.             del (dataIndex[randIndex])
    150.     return weights
    151.  
    152.  
    153. # 可视化展示
    154. def plotBestFit(dataArr, labelMat, weights):
    155.     '''
    156.         Desc:
    157.             将我们得到的数据可视化展示出来
    158.         Args:
    159.             dataArr:样本数据的特征
    160.             labelMat:样本数据的类别标签，即目标变量
    161.             weights:回归系数
    162.         Returns:
    163.             None
    164.     '''
    165.  
    166.     n = shape(dataArr)[0]
    167.     xcord1 = []
    168.     ycord1 = []
    169.     xcord2 = []
    170.     ycord2 = []
    171.     for i in range(n):
    172.         if int(labelMat[i]) == 1:
    173.             xcord1.append(dataArr[i, 1])
    174.             ycord1.append(dataArr[i, 2])
    175.         else:
    176.             xcord2.append(dataArr[i, 1])
    177.             ycord2.append(dataArr[i, 2])
    178.     fig = plt.figure()
    179.     ax = fig.add_subplot(111)
    180.     ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
    181.     ax.scatter(xcord2, ycord2, s=30, c='green')
    182.     x = arange(-3.0, 3.0, 0.1)
    183.     """
    184.     y的由来，卧槽，是不是没看懂？
    185.     首先理论上是这个样子的。
    186.     dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
    187.     w0*x0+w1*x1+w2*x2=f(x)
    188.     x0最开始就设置为1叻， x2就是我们画图的y值，而f(x)被我们磨合误差给算到w0,w1,w2身上去了
    189.     所以:  w0+w1*x+w2*y=0 => y = (-w0-w1*x)/w2   
    190.     """
    191.     y = (-weights[0] - weights[1] * x) / weights[2]
    192.     ax.plot(x, y)
    193.     plt.xlabel('X')
    194.     plt.ylabel('Y')
    195.     plt.show()
    196.  
    197.  
    198. def simpleTest():
    199.     # 1.收集并准备数据
    200.     dataMat, labelMat = loadDataSet("data/5.Logistic/TestSet.txt")
    201.  
    202.     # print dataMat, '---\n', labelMat
    203.     # 2.训练模型，  f(x)=a1*x1+b2*x2+..+nn*xn中 (a1,b2, .., nn).T的矩阵值
    204.     # 因为数组没有是复制n份， array的乘法就是乘法
    205.     dataArr = array(dataMat)
    206.     # print dataArr
    207.     # weights = gradAscent(dataArr, labelMat)
    208.     # weights = stocGradAscent0(dataArr, labelMat)
    209.     weights = stocGradAscent1(dataArr, labelMat)
    210.     # print '*'*30, weights
    211.  
    212.     # 数据可视化
    213.     plotBestFit(dataArr, labelMat, weights)
    1. # --------------------------------------------------------------------------------
    2. # 从疝气病症预测病马的死亡率
    3. # 分类函数，根据回归系数和特征向量来计算 Sigmoid的值
    4. def classifyVector(inX, weights):
    5.     '''
    6.     Desc: 
    7.         最终的分类函数，根据回归系数和特征向量来计算 Sigmoid 的值，大于0.5函数返回1，否则返回0
    8.     Args:
    9.         inX -- 特征向量，features
    10.         weights -- 根据梯度下降/随机梯度下降 计算得到的回归系数
    11.     Returns:
    12.         如果 prob 计算大于 0.5 函数返回 1
    13.         否则返回 0
    14.     '''
    15.     prob = sigmoid(sum(inX * weights))
    16.     if prob > 0.5: return 1.0
    17.     else: return 0.0
    18.  
    19.  
    20. # 打开测试集和训练集,并对数据进行格式化处理
    21. def colicTest():
    22.     '''
    23.     Desc:
    24.         打开测试集和训练集，并对数据进行格式化处理
    25.     Args:
    26.         None
    27.     Returns:
    28.         errorRate -- 分类错误率
    29.     '''
    30.     frTrain = open('data/5.Logistic/horseColicTraining.txt')
    31.     frTest = open('data/5.Logistic/horseColicTest.txt')
    32.     trainingSet = []
    33.     trainingLabels = []
    34.     # 解析训练数据集中的数据特征和Labels
    35.     # trainingSet 中存储训练数据集的特征，trainingLabels 存储训练数据集的样本对应的分类标签
    36.     for line in frTrain.readlines():
    37.         currLine = line.strip().split('\t')
    38.         lineArr = []
    39.         for i in range(21):
    40.             lineArr.append(float(currLine[i]))
    41.         trainingSet.append(lineArr)
    42.         trainingLabels.append(float(currLine[21]))
    43.     # 使用 改进后的 随机梯度下降算法 求得在此数据集上的最佳回归系数 trainWeights
    44.     trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 500)
    45.     # trainWeights = stocGradAscent0(array(trainingSet), trainingLabels)
    46.     errorCount = 0
    47.     numTestVec = 0.0
    48.     # 读取 测试数据集 进行测试，计算分类错误的样本条数和最终的错误率
    49.     for line in frTest.readlines():
    50.         numTestVec += 1.0
    51.         currLine = line.strip().split('\t')
    52.         lineArr = []
    53.         for i in range(21):
    54.             lineArr.append(float(currLine[i]))
    55.         if int(classifyVector(array(lineArr), trainWeights)) != int(
    56.                 currLine[21]):
    57.             errorCount += 1
    58.     errorRate = (float(errorCount) / numTestVec)
    59.     print("the error rate of this test is: %f" % errorRate)
    60.     return errorRate
    61.  
    62.  
    63. # 调用 colicTest() 10次并求结果的平均值
    64. def multiTest():
    65.     numTests = 10
    66.     errorSum = 0.0
    67.     for k in range(numTests):
    68.         errorSum += colicTest()
    69.     print("after %d iterations the average error rate is: %f" % (numTests, errorSum / float(numTests)))
    70.  
    71. simpleTest()
    72. # multiTest()

     

    1. # 逻辑回归中的 L1 惩罚和稀缺性 L1 Penalty and Sparsity in Logistic Regression
    2. print(__doc__)
    3.  
    4. import numpy as np
    5. import matplotlib.pyplot as plt
    6.  
    7. from sklearn.linear_model import LogisticRegression
    8. from sklearn import datasets
    9. from sklearn.preprocessing import StandardScaler
    10.  
    11. digits = datasets.load_digits()
    12.  
    13. X, y = digits.data, digits.target
    14. X = StandardScaler().fit_transform(X)
    15.  
    16. # 将大小数字分类为小
    17. y = (y > 4).astype(np.int)
    18.  
    19.  
    20. # 设置正则化参数
    21. for i, C in enumerate((100, 1, 0.01)):
    22.     # 减少训练时间短的容忍度
    23.     clf_l1_LR = LogisticRegression(C=C, penalty='l1', tol=0.01)
    24.     clf_l2_LR = LogisticRegression(C=C, penalty='l2', tol=0.01)
    25.     clf_l1_LR.fit(X, y)
    26.     clf_l2_LR.fit(X, y)
    27.  
    28.     coef_l1_LR = clf_l1_LR.coef_.ravel()
    29.     coef_l2_LR = clf_l2_LR.coef_.ravel()
    30.  
    31.     # coef_l1_LR contains zeros due to the
    32.     # L1 sparsity inducing norm
    33.     # 由于 L1 稀疏诱导规范，coef_l1_LR 包含零
    34.  
    35.     sparsity_l1_LR = np.mean(coef_l1_LR == 0) * 100
    36.     sparsity_l2_LR = np.mean(coef_l2_LR == 0) * 100
    37.  
    38.     print("C=%.2f" % C)
    39.     print("Sparsity with L1 penalty: %.2f%%" % sparsity_l1_LR)
    40.     print("score with L1 penalty: %.4f" % clf_l1_LR.score(X, y))
    41.     print("Sparsity with L2 penalty: %.2f%%" % sparsity_l2_LR)
    42.     print("score with L2 penalty: %.4f" % clf_l2_LR.score(X, y))
    43.  
    44.     l1_plot = plt.subplot(3, 2, 2 * i + 1)
    45.     l2_plot = plt.subplot(3, 2, 2 * (i + 1))
    46.     if i == 0:
    47.         l1_plot.set_title("L1 penalty")
    48.         l2_plot.set_title("L2 penalty")
    49.  
    50.     l1_plot.imshow(np.abs(coef_l1_LR.reshape(8, 8)), interpolation='nearest',
    51.                    cmap='binary', vmax=1, vmin=0)
    52.     l2_plot.imshow(np.abs(coef_l2_LR.reshape(8, 8)), interpolation='nearest',
    53.                    cmap='binary', vmax=1, vmin=0)
    54.     plt.text(-8, 3, "C = %.2f" % C)
    55.  
    56.     l1_plot.set_xticks(())
    57.     l1_plot.set_yticks(())
    58.     l2_plot.set_xticks(())
    59.     l2_plot.set_yticks(())
    60.  
    61. plt.show()
    62. # 具有 L1-逻辑回归的路径
    63. from datetime import datetime
    64. import numpy as np
    65. import matplotlib.pyplot as plt
    66.  
    67. from sklearn import linear_model
    68. from sklearn import datasets
    69. from sklearn.svm import l1_min_c
    70.  
    71. iris = datasets.load_iris()
    72. X = iris.data
    73. y = iris.target
    74.  
    75. X = X[y != 2]
    76. y = y[y != 2]
    77.  
    78. X -= np.mean(X, 0)
    79.  
    80. cs = l1_min_c(X, y, loss='log') * np.logspace(0, 3)
    81.  
    82.  
    83. print("Computing regularization path ...")
    84. start = datetime.now()
    85. clf = linear_model.LogisticRegression(C=1.0, penalty='l1', tol=1e-6)
    86. coefs_ = []
    87. for c in cs:
    88.     clf.set_params(C=c)
    89.     clf.fit(X, y)
    90.     coefs_.append(clf.coef_.ravel().copy())
    91. print("This took ", datetime.now() - start)
    92.  
    93. coefs_ = np.array(coefs_)
    94. plt.plot(np.log10(cs), coefs_)
    95. ymin, ymax = plt.ylim()
    96. plt.xlabel('log(C)')
    97. plt.ylabel('Coefficients')
    98. plt.title('Logistic Regression Path')
    99. plt.axis('tight')
    100. plt.show()
    101. # 绘制多项式和一对二的逻辑回归 Plot multinomial and One-vs-Rest Logistic Regression
    102. print(__doc__)
    103.  
    104. import numpy as np
    105. import matplotlib.pyplot as plt
    106. from sklearn.datasets import make_blobs
    107. from sklearn.linear_model import LogisticRegression
    108.  
    109. # 制作 3 类数据集进行分类
    110. centers = [[-5, 0], [0, 1.5], [5, -1]]
    111. X, y = make_blobs(n_samples=1000, centers=centers, random_state=40)
    112. transformation = [[0.4, 0.2], [-0.4, 1.2]]
    113. X = np.dot(X, transformation)
    114.  
    115. for multi_class in ('multinomial', 'ovr'):
    116.     clf = LogisticRegression(solver='sag', max_iter=100, random_state=42,
    117.                              multi_class=multi_class).fit(X, y)
    118.  
    119.     # 打印训练分数
    120.     print("training score : %.3f (%s)" % (clf.score(X, y), multi_class))
    121.  
    122.     # 创建一个网格来绘制
    123.     h = .02  # 网格中的步长
    124.     x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    125.     y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    126.     xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
    127.                          np.arange(y_min, y_max, h))
    128.  
    129.     # 绘制决策边界。为此，我们将为网格 [x_min, x_max]x[y_min, y_max]中的每个点分配一个颜色。
    130.     Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    131.     # 将结果放入彩色图
    132.     Z = Z.reshape(xx.shape)
    133.     plt.figure()
    134.     plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
    135.     plt.title("Decision surface of LogisticRegression (%s)" % multi_class)
    136.     plt.axis('tight')
    137.  
    138.     # 将训练点也绘制进入
    139.     colors = "bry"
    140.     for i, color in zip(clf.classes_, colors):
    141.         idx = np.where(y == i)
    142.         plt.scatter(X[idx, 0], X[idx, 1], c=color, cmap=plt.cm.Paired)
    143.  
    144.     # 绘制三个一对数分类器
    145.     xmin, xmax = plt.xlim()
    146.     ymin, ymax = plt.ylim()
    147.     coef = clf.coef_
    148.     intercept = clf.intercept_
    149.  
    150.     def plot_hyperplane(c, color):
    151.         def line(x0):
    152.             return (-(x0 * coef[c, 0]) - intercept[c]) / coef[c, 1]
    153.         plt.plot([xmin, xmax], [line(xmin), line(xmax)],
    154.                  ls="--", color=color)
    155.  
    156.     for i, color in zip(clf.classes_, colors):
    157.         plot_hyperplane(i, color)
    158.  
    159. plt.show()
    160.  
    161. from __future__ import print_function
    162.  
    163. # Logistic Regression 3-class Classifier 逻辑回归 3-类 分类器 
    164.  
    165. print(__doc__)
    166.  
    167. import numpy as np
    168. import matplotlib.pyplot as plt
    169. from sklearn import linear_model, datasets
    170.  
    171. # 引入一些数据来玩
    172. iris = datasets.load_iris()
    173. # 我们只采用样本数据的前两个feature
    174. X = iris.data[:, :2]  
    175. Y = iris.target
    176.  
    177. h = .02  # 网格中的步长
    178.  
    179. logreg = linear_model.LogisticRegression(C=1e5)
    180.  
    181. # 我们创建了一个 Neighbours Classifier 的实例，并拟合数据。
    182. logreg.fit(X, Y)
    183.  
    184. # 绘制决策边界。为此我们将为网格 [x_min, x_max]x[y_min, y_max] 中的每个点分配一个颜色。
    185. x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    186. y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    187. xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    188. Z = logreg.predict(np.c_[xx.ravel(), yy.ravel()])
    189.  
    190. # 将结果放入彩色图中
    191. Z = Z.reshape(xx.shape)
    192. plt.figure(1, figsize=(4, 3))
    193. plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Paired)
    194.  
    195. # 将训练点也同样放入彩色图中
    196. plt.scatter(X[:, 0], X[:, 1], c=Y, edgecolors='k', cmap=plt.cm.Paired)
    197. plt.xlabel('Sepal length')
    198. plt.ylabel('Sepal width')
    199.  
    200. plt.xlim(xx.min(), xx.max())
    201. plt.ylim(yy.min(), yy.max())
    202. plt.xticks(())
    203. plt.yticks(())
    204.  
    205. plt.show()
    206.  
    207. # Logistic function 逻辑回归函数
    208. # 这个类似于咱们之前讲解 logistic 回归的 Sigmoid 函数，模拟的阶跃函数
    209. print(__doc__)
    210.  
    211. import numpy as np
    212. import matplotlib.pyplot as plt
    213.  
    214. from sklearn import linear_model
    215.  
    216. # 这是我们的测试集，它只是一条直线，带有一些高斯噪声。
    217. xmin, xmax = -5, 5
    218. n_samples = 100
    219. np.random.seed(0)
    220. X = np.random.normal(size=n_samples)
    221. y = (X > 0).astype(np.float)
    222. X[X > 0] *= 4
    223. X += .3 * np.random.normal(size=n_samples)
    224.  
    225. X = X[:, np.newaxis]
    226. # 运行分类器
    227. clf = linear_model.LogisticRegression(C=1e5)
    228. clf.fit(X, y)
    229.  
    230. # 并且画出我们的结果
    231. plt.figure(1, figsize=(4, 3))
    232. plt.clf()
    233. plt.scatter(X.ravel(), y, color='black', zorder=20)
    234. X_test = np.linspace(-5, 10, 300)
    235.  
    236.  
    237. def model(x):
    238.     return 1 / (1 + np.exp(-x))
    239. loss = model(X_test * clf.coef_ + clf.intercept_).ravel()
    240. plt.plot(X_test, loss, color='red', linewidth=3)
    241.  
    242. ols = linear_model.LinearRegression()
    243. ols.fit(X, y)
    244. plt.plot(X_test, ols.coef_ * X_test + ols.intercept_, linewidth=1)
    245. plt.axhline(.5, color='.5')
    246.  
    247. plt.ylabel('y')
    248. plt.xlabel('X')
    249. plt.xticks(range(-5, 10))
    250. plt.yticks([0, 0.5, 1])
    251. plt.ylim(-.25, 1.25)
    252. plt.xlim(-4, 10)
    253. plt.legend(('Logistic Regression Model', 'Linear Regression Model'),
    254.            loc="lower right", fontsize='small')
    255. plt.show()

  • 相关阅读:
    悲观模式下分库分表合并迁移
    网络工程师的关键任务：构建可靠的出海网络架构
    nginx几个常见的配置项
    【Oracle】Oracle系列之八--SQL查询
    CEC2018：动态多目标测试函数DF6~DF9的PS及PF
    【SSM框架 三】SpringMVC
    Windows11安装SQL Server2019操作手册
    Python编程 列表的操作（上）
    【无标题】
    ES6-解构赋值
  • 原文地址：https://blog.csdn.net/qq_36973725/article/details/132627315