《统计学习方法》第六章,逻辑斯蒂回归

? 使用逻辑地模型来进行分类,可以算出每个测试样本分属于每个类别的概率

● 二分类代码

  1 import numpy as np
  2 import matplotlib.pyplot as plt
  3 from mpl_toolkits.mplot3d import Axes3D
  4 from mpl_toolkits.mplot3d.art3d import Poly3DCollection
  5 from matplotlib.patches import Rectangle
  6
  7 dataSize = 10000
  8 trainRatio = 0.3
  9 ita = 0.03
 10 epsilon = 0.01
 11 defaultTurn = 500
 12 colors = [[0.5,0.25,0],[1,0,0],[0,0.5,0],[0,0,1],[1,0.5,0]]                         # 棕红绿蓝橙
 13 trans = 0.5
 14
 15 def sigmoid(x):
 16     return 1.0 / (1 + np.exp(-x))
 17
 18 def function(x, para):                                                               # 回归函数
 19     return sigmoid(np.sum(x * para[0]) + para[1])
 20
 21 def judge(x, para):                                                                 # 分类函数,由乘加部分和阈值部分组成
 22     return int(function(x, para) > 0.5)
 23
 24 def dataSplit(x, y, part):
 25     return x[:part], y[:part],x[part:],y[part:]
 26
 27 def createData(dim, count = dataSize):                                              # 创建数据集
 28     np.random.seed(103)
 29     X = np.random.rand(count, dim)
 30     Y = ((3 - 2 * dim)*X[:,0] + 2 * np.sum(X[:,1:], 1) > 0.5).astype(int)           # 只考虑 {0,1} 的二分类
 31     class1Count = 0
 32     for i in range(count):
 33         class1Count += (Y[i] + 1)>>1
 34     print("dim = %d, dataSize = %d, class 1 ratio -> %4f"%(dim, count, class1Count / count))
 35     return X, Y
 36
 37 def stochasticGradientDescent(dataX, dataY, turn = defaultTurn):
 38     count, dim = np.shape(dataX)
 39     xE = np.concatenate((dataX, np.ones(count)[:,np.newaxis]), axis = 1)
 40     w = np.ones(dim + 1)
 41
 42     for t in range(turn):
 43         y = sigmoid(np.dot(xE, w).T)
 44         error = dataY - y
 45         w += ita * np.dot(error, xE)
 46         if np.sum(error * error) < count * epsilon:
 47             break
 48     return (w[:-1], w[-1])
 49
 50 def test(dim):
 51     allX, allY = createData(dim)
 52     trainX, trainY, testX, testY = dataSplit(allX, allY, int(dataSize * trainRatio))    # 分离训练集
 53
 54     para = stochasticGradientDescent(testX, testY)  # 训练
 55
 56     myResult = [ judge(x, para) for x in testX]                                     # 测试结果
 57     errorRatio = np.sum((np.array(myResult) - testY)**2) / (dataSize * (1 - trainRatio))
 58     print("dim = %d, errorRatio = %4f\n"%(dim, errorRatio))
 59
 60     if dim >= 4:                                                                    # 4维以上不画图,只输出测试错误率
 61         return
 62     errorPX = []                                                                    # 测试数据集分为错误类,1 类和 0 类
 63     errorPY = []
 64     class1 = []
 65     class0 = []
 66     for i in range(len(testX)):
 67         if myResult[i] != testY[i]:
 68             errorPX.append(testX[i])
 69             errorPY.append(testY[i])
 70         elif myResult[i] == 1:
 71             class1.append(testX[i])
 72         else:
 73             class0.append(testX[i])
 74     errorPX = np.array(errorPX)
 75     errorPY = np.array(errorPY)
 76     class1 = np.array(class1)
 77     class0 = np.array(class0)
 78
 79     fig = plt.figure(figsize=(10, 8))
 80
 81     if dim == 1:
 82         plt.xlim(0.0,1.0)
 83         plt.ylim(-0.25,1.25)
 84         plt.plot([0.5, 0.5], [-0.5, 1.25], color = colors[0],label = "realBoundary")
 85         plt.plot([0, 1], [ function(i, para) for i in [0,1] ],color = colors[4], label = "myF")
 86         plt.scatter(class1, np.ones(len(class1)), color = colors[1], s = 2,label = "class1Data")
 87         plt.scatter(class0, np.zeros(len(class0)), color = colors[2], s = 2,label = "class0Data")
 88         if len(errorPX) != 0:
 89             plt.scatter(errorPX, errorPY,color = colors[3], s = 16,label = "errorData")
 90         plt.text(0.21, 1.12, "realBoundary: 2x = 1\nmyF(x) = " + str(round(para[0][0],2)) + " x + " + str(round(para[1],2)) + "\n errorRatio = " + str(round(errorRatio,4)), 91             size=15, ha="center", va="center", bbox=dict(boxstyle="round", ec=(1., 0.5, 0.5), fc=(1., 1., 1.)))
 92         R = [Rectangle((0,0),0,0, color = colors[k]) for k in range(5)]
 93         plt.legend(R, ["realBoundary", "class1Data", "class0Data", "errorData", "myF"], loc=[0.81, 0.2], ncol=1, numpoints=1, framealpha = 1)
 94
 95     if dim == 2:
 96         plt.xlim(0.0,1.0)
 97         plt.ylim(0.0,1.0)
 98         plt.plot([0,1], [0.25,0.75], color = colors[0],label = "realBoundary")
 99         xx = np.arange(0, 1 + 0.1, 0.1)
100         X,Y = np.meshgrid(xx, xx)
101         contour = plt.contour(X, Y, [ [ function((X[i,j],Y[i,j]), para) for j in range(11)] for i in range(11) ])
102         plt.clabel(contour, fontsize = 10,colors=‘k‘)
103         plt.scatter(class1[:,0], class1[:,1], color = colors[1], s = 2,label = "class1Data")
104         plt.scatter(class0[:,0], class0[:,1], color = colors[2], s = 2,label = "class0Data")
105         if len(errorPX) != 0:
106             plt.scatter(errorPX[:,0], errorPX[:,1], color = colors[3], s = 8,label = "errorData")
107         plt.text(0.71, 0.92, "realBoundary: -x + 2y = 1/2\nmyF(x,y) = " + str(round(para[0][0],2)) + " x + " + str(round(para[0][1],2)) + " y + " + str(round(para[1],2)) + "\n errorRatio = " + str(round(errorRatio,4)), 108             size = 15, ha="center", va="center", bbox=dict(boxstyle="round", ec=(1., 0.5, 0.5), fc=(1., 1., 1.)))
109         R = [Rectangle((0,0),0,0, color = colors[k]) for k in range(4)]
110         plt.legend(R, ["realBoundary", "class1Data", "class0Data", "errorData"], loc=[0.81, 0.2], ncol=1, numpoints=1, framealpha = 1)
111
112     if dim == 3:
113         ax = Axes3D(fig)
114         ax.set_xlim3d(0.0, 1.0)
115         ax.set_ylim3d(0.0, 1.0)
116         ax.set_zlim3d(0.0, 1.0)
117         ax.set_xlabel(‘X‘, fontdict={‘size‘: 15, ‘color‘: ‘k‘})
118         ax.set_ylabel(‘Y‘, fontdict={‘size‘: 15, ‘color‘: ‘k‘})
119         ax.set_zlabel(‘W‘, fontdict={‘size‘: 15, ‘color‘: ‘k‘})
120         v = [(0, 0, 0.25), (0, 0.25, 0), (0.5, 1, 0), (1, 1, 0.75), (1, 0.75, 1), (0.5, 0, 1)]
121         f = [[0,1,2,3,4,5]]
122         poly3d = [[v[i] for i in j] for j in f]
123         ax.add_collection3d(Poly3DCollection(poly3d, edgecolor = ‘k‘, facecolors = colors[0]+[trans], linewidths=1))
124         ax.scatter(class1[:,0], class1[:,1],class1[:,2], color = colors[1], s = 2, label = "class1")
125         ax.scatter(class0[:,0], class0[:,1],class0[:,2], color = colors[2], s = 2, label = "class0")
126         if len(errorPX) != 0:
127             ax.scatter(errorPX[:,0], errorPX[:,1],errorPX[:,2], color = colors[3], s = 8, label = "errorData")
128         ax.text3D(0.74, 0.95, 1.15, "realBoundary: -3x + 2y +2z = 1/2\nmyF(x,y,z) = " + str(round(para[0][0],2)) + " x + " + 129             str(round(para[0][1],2)) + " y + " + str(round(para[0][2],2)) + " z + " + str(round(para[1],2)) + "\n errorRatio = " + str(round(errorRatio,4)), 130             size = 12, ha="center", va="center", bbox=dict(boxstyle="round", ec=(1, 0.5, 0.5), fc=(1, 1, 1)))
131         R = [Rectangle((0,0),0,0, color = colors[k]) for k in range(4)]
132         plt.legend(R, ["realBoundary", "class1Data", "class0Data", "errorData"], loc=[0.83, 0.1], ncol=1, numpoints=1, framealpha = 1)
133
134     fig.savefig("R:\\dim" + str(dim) + ".png")
135     plt.close()
136
137 if __name__==‘__main__‘:
138     test(1)
139     test(2)
140     test(3)
141     test(4)
142     test(5)   

● 输出结果

dim = 1, dataSize = 10000, class 1 ratio -> 0.509000
dim = 1, errorRatio = 0.015000

dim = 2, dataSize = 10000, class 1 ratio -> 0.496000
dim = 2, errorRatio = 0.008429

dim = 3, dataSize = 10000, class 1 ratio -> 0.498200
dim = 3, errorRatio = 0.012429

dim = 4, dataSize = 10000, class 1 ratio -> 0.496900
dim = 4, errorRatio = 0.012857

dim = 5, dataSize = 10000, class 1 ratio -> 0.500000
dim = 5, errorRatio = 0.012143

● 画图

● 多分类代码(坑)

原文地址:https://www.cnblogs.com/cuancuancuanhao/p/11251632.html

时间: 2024-10-08 08:24:18

《统计学习方法》第六章,逻辑斯蒂回归的相关文章

第六章 逻辑斯蒂回归与最大熵模型

书中重要定义及一些理解 先通过介绍逻辑史蒂的分布来引出logist模型 而通过极大似然法来推导模型的参数估计问题 通过对模型参数的似然函数通过求导来得到递归方程 通过公式可以看出logist是对前面的感知机的升级版,感知机的判断方式过于简单.而其梯度下降的时候也将sign的去掉了,否则无法微分. 后通过方程来写出公式,代码如下 import numpy as np from read_data import get_2_kind_data def logistic_Regression(tra_

逻辑斯蒂回归

1,逻辑斯蒂回归问题有一组病人的数据,我们需要预测他们在一段时间后患上心脏病的“可能性”,就是我们要考虑的问题.通过二值分类,我们仅仅能够预测病人是否会患上心脏病,不同于此的是,现在我们还关心患病的可能性,即 f(x) = P(+1|x),取值范围是区间 [0,1]. 然而,我们能够获取的训练数据却与二值分类完全一样,x 是病人的基本属性,y 是+1(患心脏病)或 -1(没有患心脏病).输入数据并没有告诉我们有关“概率” 的信息. 在二值分类中,我们通过w*x 得到一个"score"

用二项逻辑斯蒂回归解决二分类问题

逻辑斯蒂回归: 逻辑斯蒂回归是统计学习中的经典分类方法,属于对数线性模型.logistic回归的因变量可以是二分类的, 也可以是多分类的 基本原理 logistic 分布 折X是连续的随机变量,X服从logistic分布是指X具有下列分布函数和密度函数: 其中为位置参数,为形状参数.与图像如下,其中分布函数是以为中心对阵,越小曲线变化越快 二项logistic回归模型: 二项logistic回归模型如下: 其中是输入,输出,W称为权值向量,b称为偏置, 是w和x的内积 参数估计 ? 假设: ?

梯度下降法解逻辑斯蒂回归

梯度下降法解逻辑斯蒂回归 本文是Andrew Ng在Coursera的机器学习课程的笔记. Logistic回归属于分类模型.回顾线性回归,输出的是连续的实数,而Logistic回归输出的是[0,1]区间的概率值,通过概率值来判断因变量应该是1还是0.因此,虽然名字中带着"回归"(输出范围常为连续实数),但Logistic回归属于分类模型(输出范围为一组离散值构成的集合). 整体步骤 假如我们的自变量是"数学课和英语课的成绩",x={x1,x2},因变量是"

逻辑斯蒂回归(logisic regression)和SVM的异同

逻辑斯蒂回归主要用于二分类,推广到多分类的话是类似于softmax分类.求 上述问题可以通过最大化似然函数求解. 上述问题可以采用最小化logloss进行求解. 一般地,我们还需要给目标函数加上正则项,参数w加上l1或者l2范数. LR适合大规模数据,数据量太小的话可能会欠拟合(考虑到数据通常比较稀疏).另外,我们可以将连续型属性转化成离散型属性,这样可以提升模型的鲁棒性,防止模型过拟合. LR和SVM的异同点 相同点 1.他们都是分类算法,是监督学习算法. 2.如果不考虑核函数,LR和SVM都

逻辑斯蒂回归模型

http://blog.csdn.net/hechenghai/article/details/46817031 主要参照统计学习方法.机器学习实战来学习.下文作为参考. 第一节中说了,logistic 回归和线性回归的区别是:线性回归是根据样本X各个维度的Xi的线性叠加(线性叠加的权重系数wi就是模型的参数)来得到预测值的Y,然后最小化所有的样本预测值Y与真实值y‘的误差来求得模型参数.我们看到这里的模型的值Y是样本X各个维度的Xi的线性叠加,是线性的. Y=WX (假设W>0),Y的大小是随

逻辑斯蒂回归(Logistic Regression)

逻辑回归名字比较古怪,看上去是回归,却是一个简单的二分类模型. 逻辑回归的目标函数是如下形式: 其中x是features,θ是feature的权重,σ是sigmoid函数.将θ0视为θ0*x0(x0取值为常量1),那么 这里我们取阈值为0.5,那么二分类的判别公式为: 下面说一下参数θ的求解: 为啥子这样去损失函数呢? 当y=1的时候,显然hθ(x)越接近1我们的预测越靠谱:y=0时同理.所以应该在y=1时,使损失韩式-log(hθ(x))越小越好,y=0时,同样使损失函数-log(1-hθ(x

[转]逻辑斯蒂回归 via python

# -*- coding:UTF-8 -*-import numpydef loadDataSet(): return dataMat,labelMat def sigmoid(inX): return 1.0/(1+numpy.exp(-inX)) def gradAscent(dataMatIn,classLabels): dataMatrix=numpy.mat(damaMatIn) labelMat=numpy.mat(classLabels).transpose() #上升梯度 alp

逻辑斯蒂和最大熵-李航

1.逻辑斯蒂分布 sigmoid 曲线 二项逻辑斯蒂回归模型,实际上是二项判别模型. 基于逻辑斯蒂的似然函数等于每个取值的概率之积.对数似然是对他们取log 多项逻辑斯蒂回归,实际是二项的扩展. 2.最大熵模型 由5.2.2节的熵模型.使我们需要的公式. 所谓最大熵,是指83页定义的条件熵的最大熵. 我们知道这个熵模型实际上是带负号的,负号变边,将求最大问题变成求最小问题,即凸函数问题. A.引进拉格朗日问题,将该问题变换为拉格朗日问题,由对偶性质,得到求最小值的最大值,最小值可由求导得到,最大