统计学习方法-逻辑斯蒂回归

最新推荐文章于 2022-12-25 23:11:01 发布
最新推荐文章于 2022-12-25 23:11:01 发布
阅读量271 收藏
点赞数
分类专栏： Algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuichudeheart/article/details/79396802
版权
本文探讨了逻辑斯蒂回归中常用的优化方法，包括梯度下降法、牛顿法及其改进的拟牛顿法，如BFGS和DFP算法。
摘要由CSDN通过智能技术生成

梯度下降法

import numpy as np
import math
"""逻辑斯蒂回归算法 梯度下降方法"""
def L_W(X, y, w, b):
	wx = np.dot(w, X.T) + b
	return np.dot(y, wx) - np.sum( np.log(1+np.exp(wx) ), axis=0)

def update_w(X, y, w, b, delta=1):
	#wx = np.dot(w, X.T) + b
	#w = w + delta * ( np.sum( (y*X.T).T, axis=0) - 
	#	np.sum((np.exp(wx)/(np.exp(wx)+1) * X.T).T, axis=0) )
	wx = np.exp( np.dot(w, X.T) + b )
	w = w + delta * np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
	return w

def update_b(X, y, w, b, delta=1):
	#wx = np.dot(w, X.T) + b
	#b = b + delta * ( np.sum(y, axis=0) -  np.sum(np.exp(wx)/( 1 + np.exp(wx)), axis=0))
	wx = np.exp( np.dot(w, X.T) + b )
	b = b + delta * ( np.sum(y - wx/( 1 + wx), axis=0))
	return b

def Loggistics(X, y, delta = 1, maxIter=500000):
	import copy
	w = np.zeros(X.shape[1])
	b = 0
	iter = 0
	old_value = -math.inf
	old_w = copy.deepcopy(w)
	old_b = copy.deepcopy(b)
	while (iter<maxIter) and old_value< L_W(X, y, w, b):
		old_value = L_W(X, y, w, b)
		#print("old_value", old_value)
		old_w = copy.deepcopy(w)
		old_b = b#copy.deepcopy(b)
		w = update_w(X, y, old_w, old_b, delta = 0.1245)
		b = update_b(X, y, old_w, old_b, delta = 0.1245)	
		if iter%10000==0:
			print(L_W(X, y, w, b))
			print("iteration number %d" % iter)
		iter += 1
		#break
	return old_w, old_b

def predict(x, w, b):
	wx = np.dot(w, x) + b
	#print(wx)
	return math.exp(wx) / (1 + math.exp(wx))

w, b =Loggistics(np.array([[3,3],[4,3],[1,1], [3,4]]), np.array([1,1, 0, 0]), delta=1)

print(predict(np.array([3,3]), w, b))
print(predict(np.array([4,3]), w, b))
print(predict(np.array([1,1]), w, b))
print(predict(np.array([3,4]), w, b))

牛顿法

'''
def NewtonMethod(maxIter = 100):
	"""2x^2 - 10x + 1"""
	b = 0
	iter = 0
	x1 = 0
	while (iter<maxIter):
		x2 = x1 - (2*x1*x1 - 10 *x1 + 1) / (4*x1 - 10 )
		#x2 = x1 - (4*x1 - 10 ) / (4)
		x1 = x2
		iter += 1
		print(2*x1*x1 - 10 *x1 + 1)
	return x1

x = NewtonMethod()
print(2*x*x - 10 *x + 1)
'''


import numpy as np
import math
"""逻辑斯蒂回归 牛顿法"""

#对数似然函数为目标函数
def L_W(X, y, w):
	wx = np.dot(w, X.T)
	return np.dot(y, wx) - np.sum(np.log(1+np.exp(wx)), axis=0)

#计算Hesse矩阵
def update_H(X, y, w):
	wx = np.exp(np.dot(w, X.T))
	c = wx/((1+wx)*(1+wx))
	#H = np.zeros((X.shape[1], X.shape[1]))
	#for i in range(X.shape[1]):
	#	for j in range(X.shape[1]):
	#		H[i,j] = -np.sum(X[:,i] * X[:,j] * c, axis=0)
	#print(-np.dot(X.T, (X.T*c).T)-H)
	H = -np.dot(X.T, (X.T*c).T)
	return H

def update_w(X, y, w, H, delta=1):
	wx = np.exp( np.dot(w, X.T) )
	#gx目标函数的梯度
	gx =  np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
	H_ = np.linalg.inv(H)
	w = w - np.dot(H_, gx)
	return w


def Loggistics(X, y, delta = 1, maxIter=70):
	import copy
	w = np.zeros(X.shape[1])
	H = np.zeros((X.shape[1], X.shape[1])) 
	iter = 0
	old_value = -math.inf
	old_w = copy.deepcopy(w)
	while (iter<maxIter) and old_value<= L_W(X, y, w):
		old_value = L_W(X, y, w)
		old_w = copy.deepcopy(w)
		H = update_H(X, y, w)
		w = update_w(X, y, old_w, H, delta = 0.1245)
		if iter%10==0:
			print("iteration number %d" % iter)
			print("old_value", old_value)
		iter += 1
	return old_w

def predict(x, w):
	wx = math.exp(np.dot(w, x))
	return wx / (1 + wx)

w =Loggistics(np.array([[3,3, 1],[4,3, 1],[1,1, 1], [3,4, 1]]), np.array([1,1, 0, 0]), delta=1)

print(predict(np.array([3,3, 1]), w))
print(predict(np.array([4,3, 1]), w))
print(predict(np.array([1,1, 1]), w))
print(predict(np.array([3,4, 1]), w))


拟牛顿法-BFGS 算法

import numpy as np
import math
"""逻辑斯蒂回归 拟牛顿法， BFGS算法"""

#对数似然函数为目标函数
def L_W(X, y, w):
	wx = np.dot(w, X.T)
	return np.dot(y, wx) - np.sum(np.log(1+np.exp(wx)), axis=0)

#计算Hesse近似矩阵， BFGS算法
def update_B(X, y, B, gx, old_gx, w, old_w):
	delta_k = np.mat(w - old_w)
	y_k = np.mat(gx - old_gx)
	B = B + y_k.T*y_k/(y_k*delta_k.T) - B *delta_k.T*delta_k*B/(delta_k*B*delta_k.T)
	return B

def update_w(X, y, w, B, delta=1):
	wx = np.exp( np.dot(w, X.T) )
	#gx目标函数的梯度
	gx =  np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
	B_ = np.linalg.inv(B)
	lam1 = 0
	lam2 = 1
	while L_W(X, y, w - lam2* np.dot(np.array(B_), gx)) < L_W(X, y, w - 2* lam2* np.dot(np.array(B_), gx)):
		lam2 = 2*lam2
	lam1 = lam2
	lam2 = lam2+2

	x1 = (lam2 - lam1)*0.382 + lam1
	x2 = (lam2 - lam1)*0.618 + lam1
	print("lam2",lam2, x1, x2)
	#一维搜索lam,0.618法
	while x2>x1:
		if L_W(X, y, w - x1* np.dot(np.array(B_), gx)) < L_W(X, y, w - x2* np.dot(np.array(B_), gx)):
			lam2 = x2
		else:
			lam1 = x1
		#x1 = (lam2 - lam1)*0.382 + lam1
		#x2 = (lam2 - lam1)*0.618 + lam1	
		x1 = (lam2 - lam1)*0.382 + lam1
		x2 = (lam2 - lam1)*0.618 + lam1	
	print("x2",x2)
	w = w - x2*np.dot(np.array(B_), gx)
	return w


def Loggistics(X, y, delta = 1, maxIter=7000):
	import copy
	w = np.zeros(X.shape[1])
	wx = np.exp(np.dot(w, X.T))
	c = wx/((1+wx)*(1+wx))
	B = -np.dot(X.T, (X.T*c).T)
	old_gx = np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
	#gx = np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
	old_value = -math.inf
	iter = 0
	while (iter<maxIter) and old_value< L_W(X, y, w) and np.dot(old_gx, old_gx)>=1e-300:
		old_value = L_W(X, y, w)
		old_w = copy.deepcopy(w)
		w = update_w(X, y, w, B, delta=1)
		
		wx = np.exp(np.dot(w, X.T))
		gx = np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
		
		B = update_B(X, y, B, gx, old_gx, w, old_w)
		old_gx = gx 

		if iter%1==0:
			print("iteration number %d" % iter)
			print("old_value", old_value)
		iter += 1
	return old_w

def predict(x, w):
	wx = math.exp(np.dot(w, x))
	return wx / (1 + wx)

w =Loggistics(np.array([[3,3, 1],[4,3, 1],[1,1, 1], [3,4, 1], [2,2, 1], [3,2, 1]]), np.array([1,1, 0, 0, 0, 1]), delta=1)

print(predict(np.array([3,3, 1]), w))
print(predict(np.array([4,3, 1]), w))
print(predict(np.array([1,1, 1]), w))
print(predict(np.array([3,4, 1]), w))
print(predict(np.array([2,2, 1]), w))
print(predict(np.array([3,2, 1]), w))

拟牛顿法-DFP算法

import numpy as np
import math
"""逻辑斯蒂回归 拟牛顿法， DFP算法"""

#对数似然函数为目标函数
def L_W(X, y, w):
	wx = np.dot(w, X.T)
	return np.dot(y, wx) - np.sum(np.log(1+np.exp(wx)), axis=0)

#计算Hesse近似矩阵， DFP算法
def update_G(X, y, G, gx, old_gx, w, old_w):
	delta_k = np.mat(w - old_w)
	y_k = np.mat(gx - old_gx)
	G = G + delta_k.T*delta_k/(delta_k*y_k.T) - G *y_k.T*y_k*G/(y_k*G*y_k.T)
	#print("14",delta_k, y_k, delta_k*y_k.T, y_k*G*y_k.T)
	return G

def update_w(X, y, w, H, delta=1):
	wx = np.exp( np.dot(w, X.T) )
	#gx目标函数的梯度
	gx =  np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
	lam1 = 0
	lam2 = 1
	while L_W(X, y, w - lam2* np.dot(np.array(H), gx)) < L_W(X, y, w - 2* lam2* np.dot(np.array(H), gx)):
		lam2 = 2*lam2
	lam1 = lam2
	lam2 = lam2+2

	x1 = (lam2 - lam1)*0.382 + lam1
	x2 = (lam2 - lam1)*0.618 + lam1
	print("lam2",lam2, x1, x2)
	#一维搜索lam,0.618法
	while x2>x1:
		if L_W(X, y, w - x1* np.dot(np.array(H), gx)) < L_W(X, y, w - x2* np.dot(np.array(H), gx)):
			lam2 = x2
		else:
			lam1 = x1
		x1 = (lam2 - lam1)*0.382 + lam1
		x2 = (lam2 - lam1)*0.618 + lam1	
		#x1 = (lam2 - lam1)*0.382 + lam1
		#x2 = (lam2 - lam1)*0.618 + lam1	
	print("x2",x2)
	w = w - x2*np.dot(np.array(H), gx)
	return w


def Loggistics(X, y, delta = 1, maxIter=7000):
	import copy
	w = np.zeros(X.shape[1])
	wx = np.exp(np.dot(w, X.T))
	c = wx/((1+wx)*(1+wx))
	G = -np.dot(X.T, (X.T*c).T)
	G = np.linalg.inv(G)
	old_gx = np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
	#gx = np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
	old_value = -math.inf
	iter = 0
	while (iter<maxIter) and old_value< L_W(X, y, w) and np.dot(old_gx, old_gx)>=1e-300:
		old_value = L_W(X, y, w)
		old_w = copy.deepcopy(w)
		w = update_w(X, y, w, G, delta=1)
		
		wx = np.exp(np.dot(w, X.T))
		gx = np.sum(( (y - wx/(wx + 1) )* X.T).T, axis=0)
		
		G = update_G(X, y, G, gx, old_gx, w, old_w)
		old_gx = gx 

		if iter%1==0:
			print("iteration number %d" % iter)
			print("old_value", old_value)
		iter += 1
	return old_w

def predict(x, w):
	wx = math.exp(np.dot(w, x))
	return wx / (1 + wx)

w =Loggistics(np.array([[3,3, 1],[4,3, 1],[1,1, 1], [3,4, 1], [2,2, 1], [3,2, 1], [2,3,1]]), np.array([1,1, 0, 0, 0, 1, 0]), delta=1)

print(predict(np.array([3,3, 1]), w))
print(predict(np.array([4,3, 1]), w))
print(predict(np.array([1,1, 1]), w))
print(predict(np.array([3,4, 1]), w))
print(predict(np.array([2,2, 1]), w))
print(predict(np.array([3,2, 1]), w))
print(predict(np.array([2,3, 1]), w))

Jeffrey-Heart
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【统计学习方法】logistic regression 逻辑斯蒂回归
遍地跑小鸡的博客
05-06 200
统计学习方法第六章I 参考资料 LR回归的核心在于引入了新的平滑函数sigmoid函数，这种函数相比于感知机的符号函数sgn函数好处在于可以求导，可以求导意味着可以进行梯度下降。（在感知机中实际上是最小化 yi(w∗xi+b)y_i(w*x_i+b)yi​(w∗xi​+b)） 并且相对于感知机算法，只要wx+b>0wx+b>0wx+b>0就判定为1的策略。再sigmoid的函数帮...
《统计学习方法》笔记（五）逻辑斯蒂回归与最大熵模型
05-23
《统计学习方法》笔记（五）逻辑斯蒂回归与最大熵模型
统计学习方法 第6章：逻辑斯蒂回归
zhanzi1538的博客
06-10 583
算法总结： 补充知识： 提出模型 学习策略 最大熵模型 代码附录
统计学习方法之逻辑斯蒂回归
weixin_45342593的博客
02-18 228
首先，有逻辑斯蒂分布，及其概率密度函数 -> 二项逻辑斯蒂回归模型 将u及常数γ换为w*x+b形式（当y = 0 时） 二项事件概率为p 则几率为可能发生与不可能发生的比值：p/(1-p) 逻辑斯蒂回归中，输入x对y=1的几率的对数是x的线性函数 可用似然函数估计逻辑斯蒂模型参数 概率描述了已知参数时的随机变量的输出结果；似然则用来描述已知随机变量输出结果时，未知参数的可能取值。例如，对于“...
《统计学习方法》1——逻辑斯蒂回归
老笨妞
09-19 857
1. 模型二项逻辑斯蒂回归模型是由逻辑斯蒂分布的条件概率分布表示的分类模型。 逻辑斯蒂分布函数为 其中，u是位置参数，是中心点（对称点）的位置；r是形状函数。 其分布图形是一条S形曲线，也就是sigmoid曲线,S形曲线的范围是(0,1)。 二项逻辑斯蒂回归模型的输出只有0和1两个值，即一件事情发生或者不发生。定义基于x，事件发生的概率分布如下： 由于是二值的，当事件发生的概率
统计学习方法逻辑斯蒂回归
一枝韩独秀的博客
12-26 1565
逻辑斯谛回归（logistic regression） 是统计学习中的经典分类方法。 最大熵是概率模型学习的一个准则， 将其推广到分类问题得到最大熵模型（maximum entropy model） 。逻辑斯谛回归模型与最大熵模型都属于对数线性模型。本文只介绍逻辑斯谛回归。 设X是连续随机变量， X服从Logistic distribution， 分布函数： 密度函数： μ为位置参数， γ大于0为...
逻辑斯蒂回归实例-matlab
06-30
10. **MATLAB编程**：MATLAB提供了一系列的数学函数和工具箱支持机器学习算法的实现，如统计和机器学习工具箱，使得逻辑斯蒂回归的编程变得相对简单。 以上就是关于“逻辑斯蒂回归实例-matlab”的详细知识解析，...
逻辑斯蒂回归的PPT展示
03-09
二项逻辑斯蒂回归模型(Binomial logistic regression model)是一种用于解决二分类问题的统计模型。它假设输出变量 \( y \) 的条件概率分布为逻辑斯蒂分布的形式，并且通过监督学习的方法来估计模型参数。 模型可以...
Python实现逻辑斯蒂回归
01-03
逻辑斯蒂回归（Logistic Regression）是一种用于解决分类问题的统计学习方法，尽管名字中带有"回归"，但实际上是一种分类算法。它是一种基于概率的模型，适用于二分类问题，也可以通过一些技巧扩展到多分类问题上。 ...
hd_log_reg：使用心脏病数据集的逻辑回归
02-12
使用心脏病数据集进行Logistic回归 该项目是将Logistic回归应用于心脏病患者的数据集，并使用Rstudio创建回归模型以预测潜在患者。 使用的技术/框架 RStudio Rmarkdown 电子表格 使用的RStudio库 图书馆（MASS） 图书馆（插入符号） 图书馆（阿米莉亚） 库（caTools） 图书馆（pROC） 图书馆（ROCR） 图书馆（plyr） 图书馆（GGally） 图书馆（ggsci） 图书馆（cowplot） 图书馆（ggpubr） 安装R软件包 rpack <- c("MASS", "caret", "Amelia", "caTools", "pROC", "ROCR", "plyr", "GGally", "ggsci", "cowplot", "ggpubr") install.packages(rpack) 数据集 来
统计学习方法——逻辑斯蒂回归模型
刘炫320的博客
04-22 2064
1. 写在前面 本文主要针对一个简单的机器学习算法逻辑斯蒂回归模型进行相关的讲解。主要内容包括：逻辑斯蒂回归模型定义及来源、二项逻辑斯蒂回归模型形式与推导、二项逻辑斯蒂回归模型的参数估计与多项逻辑斯蒂回归模型推广。 2. 逻辑斯蒂回归模型定义及来源 逻辑斯蒂回归模型主要是来源于逻辑斯蒂分布与逻辑斯蒂函数。当然，如果换一个名字，你对它应当相当熟悉，那就是sigmoid函数。它的形式如下： ...
统计学习方法-Logistic（逻辑斯蒂）回归
u010140338的专栏
11-11 5462
reference： http://f.dataguru.cn/thread-128261-1-1.html 我们在做线性回归分析时，其实是用y=mx+b直线去拟合我们的样本点，如果样本点和直线拟合很好，我们就可以得出样本点的线性相关性很强，通常用决定系数R2来表示。在寻找拟合直线的方法是最小二乘法，其实质就是找样本点离直线距离的最小平方和。这个我在白话线性回归中已经讲到。前面我都参考KHA
使用牛顿法确定逻辑斯谛回归（Logistic Regression）最佳回归系数
yupenjin的专栏
02-08 5231
逻辑斯谛回归 关于逻辑斯谛回归，这篇文章http://blog.csdn.net/zouxy09/article/details/20319673 讲的很好；Andrew Ng的机器学习公开课也很不错（中文笔记也很好http://blog.csdn.net/stdcoutzyx ）；还有《机器学习实战》，都是不错资料。   在逻辑斯谛回归中，因为使用梯度上升(gradient ascent)
牛顿法logistic回归
swilliamss的博客
10-17 690
牛顿法求解Logistic Regression 1、Logistic回归模型、牛顿法推导公式 Logistic模型为（xi\mathbf{x_i}xi​是第iii个样本，为行向量，w\mathbf{w}w是特征向量，为一个列向量） KaTeX parse error: Unknown column alignment: * at position 60: … \begin{array}{*̲*lr**} p(y_{i}… 其损失函数为 l=Loss(w)=−1mln⁡p(y∣x,w)=−[yTl
机器学习练习之逻辑斯谛回归和牛顿方法
freeliao的专栏 在路上奔跑。。。
01-18 4179
做完前面的线性回归练习后，这里继续练习逻辑斯蒂回归模型http://openclassroom.stanford.edu/MainFolder/DocumentPage.php?course=MachineLearning&doc=exercises/ex4/ex4.html。         给出的数据是40个被大学接收的学生和40个被拒绝的学生的数据，输入是一个二维向量，表示2门科目成绩，输
逻辑斯谛回归（Logistic回归）最详解
热门推荐
笼中鸟
03-14 5万+
Logistic回归学习思路 一.逻辑回归模型的原理与定义（主要思想） 逻辑斯谛回归是经典的分类方法，它属于对数线性模型，原理是根据现有的数据对分类边界线建立回归公式，以此进行分类。（主要思想） 定义： 在线性回归模型的基础上，使用Sigmoid函数，将线性模型的结果压缩到[0,1]之间，使其拥有概率意义，它可以将任意输入映射到[0,1]...
逻辑斯蒂回归算法详解
Chandler_Liu的博客
12-25 1105
逻辑斯蒂回归算法原理及其可用寻求最优解相关迭代算法
【李航-统计学习方法笔记】逻辑斯蒂回归（Logistic Regression）
qq_41977459的博客
08-02 1515
逻辑斯蒂回归是一种经典的分类方法。 它包括二项逻辑斯蒂回归和多项逻辑斯蒂回归。多项逻辑斯蒂回归的实现仍然基于二分类的思想，例如，现有数据集可分为三类A、B、C，多项分类的思想就是把数据先分为属于A的和不属于A的，再在不属于A的数据集B和C中将数据继续分为属于B(或C)和不属于B(或 C)的。以此循环往复，多分类的任务就简化成了一小块一小块的二分类任务。 本文主要介绍逻辑斯蒂回归的二项模型原理...
逻辑斯蒂回归模型的基本原理
最新发布
05-03
逻辑斯蒂回归模型是一种用于分类问题的统计学习方法。其基本原理如下： 1. 假设函数：逻辑斯蒂回归模型假设输入变量X与输出变量Y之间存在着一个非线性的关系，通过一个假设函数来描述这种关系。假设函数采用sigmoid...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值