精华内容
下载资源
问答
  • logistic回归python
    千次阅读
    2021-01-29 08:55:42

    为什么写这篇文章

    本人初学python,碰巧做的东西需要用一下Logistic回归,自觉这个很基础的东西应该已经有很多比较好的实现了,于是我就很自觉地问了下度娘。结果大囧==..出来的相关结果少得可怜,只有一个实现好的代码,但是看了下实现的比较粗糙,梯度下降部分用的是固定步长..于是抱着死马当活马医心态google了一下,结果发现有不少成熟的统计和科学计算的包里面已经实现好了,比如statsmodels,于是本文就讲一下怎么用statsmodels做Logistic回归好啦~

    吐槽下..学术上的事果然还是国外比国内靠谱得多..

    什么是Logistic回归

    用处

    Logistic回归主要用于分类,即给定一个用数值表示的特征向量X(粗体表示向量),求出这个向量所属的类别Y

    当然,可以用来分类的算法很多,比如SVM,神经网络等。但是这些算法都比较复杂,要掌握其细节有些难度。Logistic回归虽然简单,但是在很多情况下也能得到很好的效果

    函数形式及学习参数的算法

    Logistic回归的函数属于sigmoid函数,就相当于把sigmoid的自变量替换成多元线性回归的自变量部分(等号右边)即可

    学习自变量X的参数θ的方法是梯度下降法(GradientDescent),核心思想就是根据原函数的特性,构造出一个准则函数J(θ),这个准则函数的特性是J(θ)的值越小,原函数的拟合程度就越好。然后随机对θ赋初值,每一次迭代计算出J(θ)的梯度▽J(θ),我们知道函数的梯度是函数值上升最快的方向,所以这里取梯度的负方向-▽J(θ),再乘以一个步长η(k),就可以得到每次迭代后更新的参数θ=θ-η(k)▽J(θ)。其中k是当前迭代次数,这里取步长η(k)稍微有点复杂,初学时可以简单地取一个定值。

    这里写的比较简略,具体可以参考这个博文,如果还不太明白请百度Logistic回归或梯度下降吧~

    用statsmodels做Logistic回归

    statsmodels是python的一个做统计建模,计量经济学分析的扩展包,输出的结果真心相当舒服,跟各大统计软件的结果输出很像,比如拟合出来Logistic回归模型后:

    printresult.summary(),可以得到如下结果

    Logit Regression Results

    ==============================================================================

    Dep. Variable:                  admit   No. Observations:                  400

    Model:                          Logit   Df Residuals:                      394

    Method:                           MLE   Df Model:                            5

    Date:                Sun, 03 Mar 2013   Pseudo R-squ.:                 0.08292

    Time:                        12:34:59   Log-Likelihood:                -229.26

    converged:                       True   LL-Null:                       -249.99

    LLR p-value:                7.578e-08

    ==============================================================================

    coef    std err          z     P>|z|      [95.0% Conf.Int.]

    ------------------------------------------------------------------------------

    gre            0.0023      0.001     2.070      0.038         0.000     0.004

    gpa            0.8040      0.332     2.423      0.015         0.154     1.454

    prestige_2    -0.6754     0.316     -2.134      0.033        -1.296    -0.055

    prestige_3    -1.3402     0.345     -3.881      0.000        -2.017    -0.663

    prestige_4    -1.5515     0.418     -3.713      0.000        -2.370    -0.733

    intercept     -3.9900      1.140    -3.500      0.000        -6.224    -1.756

    ==============================================================================

    预测的话:

    combos['admit_pred']=result.predict(combos[train_cols])

    print combos.head()

    #    gre       gpa prestige  intercept  prestige_2 prestige_3  prestige_4  admit_pred

    # 0  220  2.260000         1          1           0           0           0   0.157801

    # 1  220  2.260000         2          1           1           0           0   0.087056

    # 2  220  2.260000         3          1           0           1           0   0.046758

    # 3  220  2.260000         4          1           0           0           1   0.038194

    # 4  220  2.453333         1          1           0           0           0   0.179574

    是不是很舒服呢?

    具体用法参考这篇博文吧,虽然是英文的,不过写的确实很好,直接看代码的话也能看懂~

    如果那篇博文打不开的话,试试国内转载的吧,就是排版没有原版的舒服

    另外,如果不想安装那篇博文提到的Enthought Free Distribution的话,可以参考我的一篇博文来安装对应的扩展包,如果不需要画图的话,可以不装matplotlib。另外,statsmodels还需要安装patsy

    更多相关内容
  • 统计学习:logistic回归 Python实现

    千次阅读 2021-12-12 16:09:04
    1. 最大熵模型 作用是从许多个模型中,选择一个最好的模型,选择的标准就是熵,即具有最大熵的P(Y∣X)P(Y|X)P(Y∣X)就是最好的模型。...2.Logistic回归 适用于多分类,二分类任务。分布函数是一个S形函数,

    1. 最大熵模型

    作用是从许多个模型中,选择一个最好的模型,选择的标准就是熵,即具有最大熵的 P ( Y ∣ X ) P(Y|X) P(YX)就是最好的模型。个人理解最大熵在这里起的作用类似于valid data 的作用。为什么最大熵的模型就是最好的呢?因为在自然界中,所有的分布都是趋于无序的、混乱的。最大熵准则则保留了每一种可能发生的情况,可以代表更多的可能发生的信息。比如你在猜抛掷一枚硬币,正面朝上的概率的时候,最好猜1/2而不是3/10.

    2.Logistic回归

    适用于多分类,二分类任务。注意:只适用于线性可分的任务,对于非线性的分类任务,logistic不能求解,此时可以适用svm等其它算法求解。分布函数是一个S形函数,记原始的训练集为 { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ( x 3 , y 3 ) , . . . , ( x m , y m ) } \{(x_1,y_1), (x_2,y_2), (x_3,y_3), ..., (x_m,y_m) \} {(x1,y1),(x2,y2),(x3,y3),...,(xm,ym)}, x i ∈ R n x_i\in \mathbb{R}^n xiRn, y i ∈ { 1 , 2 , . . . , K } y_i\in \{1,2, ..., K\} yi{1,2,...,K}。通过s函数,将 w T x + b w^T x +b wTx+b 的值域从 ( − ∞ , + ∞ ) (-\infty,+\infty) (,+)映射为(0,1)。

    3.代码实现

    使用梯度下降法更新参数w,b

    import numpy as np
    import matplotlib.pyplot as plt
    
    
    class LogisticClassifier:
        def __init__(self,learning_rate,epoch,delta):
            self.lr_rate = learning_rate
            self.epochs = epoch
            self.delta = delta
            self.w = None
    
        def sigmoid(self,x):
            return 1/(1+np.exp(-x))
    
        def fit(self,X_train,y_train):
            decent = 0
            y_train = y_train.T
            #print(y_train.shape)
            self.w = np.zeros(X_train.shape[1]).reshape(1,-1)  # 根据训练数据特征值的维数初始化参数w的维度以及形状
            for i in range(self.epochs):
                ## 计算W.T 点乘 x
                #print(i)        
                z = np.dot(X_train,self.w.T)  # M*N  (1*N).T
                h_theta = self.sigmoid(z)
                #print(h_theta.shape)
                error = h_theta - y_train  # y是一个列向量,计算误差 
                error_ = X_train*error
                # 计算梯度
                decent = error_.sum(axis=0)  ## 这个是梯度,并不是指的loss
                         
                if (np.abs(decent) <= self.delta).all():
                    break
                else:
                    self.w = self.w -self.lr_rate*decent
            print('Weight: ')
            print(self.w[0][:-1])
            print('bias:')
            print(self.w[0][-1])
    
        def predict(self,X_test):
            X_test = np.append(X_test,np.ones((X_test.shape[0],1)),axis=1)
            predic = self.sigmoid(np.dot(X_test,self.w.T))
            result = np.asarray((predic >= 0.5).astype(int))
            print('----------------------------')
            print('The predict label is :')
            print(result[0][0])
    
     if __name__ == '__main__':
        x1 = [3,3,3,1]
        x2 = [4,3,2,1]
        x3 = [2,1,2,1]
        x4 = [1,1,1,0]
        x5 = [-1,0,1,0]
        x6 = [2,-2,1,0]
        data = np.array([x1,x2,x3,x4,x5,x6]).reshape(6,-1)
        x_image = data[:,:-1] # 获得训练集中的特征值
        m,n = np.shape(x_image)                              # 获得feature的维度,m是样本个数,n是特征的维度
        x_image = np.append(x_image,np.ones((m,1)),axis = 1) # w.dot x + b 统一看作一个大的矩阵,用矩阵相乘表示这个运算过程。
        x_label = data[:,-1].reshape(1,-1)  # 获得训练集数据的标签值
    
        classifier = LogisticClassifier(learning_rate=0.1,epoch=100,delta=0.02)
        classifier.fit(x_image,x_label)
        X_test = np.array([1,2,-2]).reshape(1,-1)
        classifier.predict(X_test)
    

    运行结果:
    在这里插入图片描述

    展开全文
  • Python实现Logistic回归

    2017-05-19 11:41:19
    Python实现Logistic回归,《机器学习实战》中第五讲源码,包含测试数据
  • 使用python实现逻辑回归算法,该算法可以用来进行分类,通过具体例子熟练掌握
  • logistic回归——PYTHON实现

    千次阅读 2021-03-15 23:22:15
    logistic回归——PYTHON实现 概述: ​ logistic回归又称logistic回归分析,是一种线性回归模型。logistic回归应用最广泛的是处理二分类问题。比如,探讨引发疾病的危险因素,判断该病人是否患有该病;探讨房价的...

    logistic回归——PYTHON实现

    概述:

    logistic回归又称logistic回归分析,是一种线性回归模型。logistic回归应用最广泛的是处理二分类问题。比如,探讨引发疾病的危险因素,判断该病人是否患有该病;探讨房价的涨跌,进而给出在何时购买房子的最优决策。在logistic回归中,自变量可以是连续的,也可以是分立的。

    ​ 以预测房价涨跌为例,选择两种不同类型的房子,一种是涨价组,另一组是非涨价组,两组房子必定具有不同的占地面积、房屋位置、建筑年限等特征,因此因变量为是否涨价,自变量可以包括很多不同的特征,比如所在城市、占地面积等不同特征。

    ​ 通过logistic回归,可以得到自变量的权重,从而大致了解影响疾病发作、股票走势、房价涨跌的因素,同时根据这些权重值,预测发生某件事情的可能性。

    ​ 本文首先会介绍logistic回归所用到的基本的数学知识,接着会给出logistic回归在PYTHON中的编程实现。最后,会在大众比较熟悉且感兴趣的领域——股票预测方面应用logistic回归,观察其在量化投资方面的应用

    logistic回归与线性回归:

    ​ logistic回归与线性回归均属于广义的线性模型,只不过logistic回归将输出又输入到sigmoid函数中,通过引入非线性因素,给出二分类问题中不同类别的概率值。

    logistic回归所用到的基本数学原理:

    ​ 首先,与一般的机器学习算法一样,在输入参数时,首先应该选择输入的特征。比如,在预测房屋价格涨跌时,房屋面积可能是一个比较优秀的特征选择,而房屋所处小区的保安年龄可能就不是一个好的特征选择。因为特征提取、特征选择等特征工程是机器学习中的另一研究问题,本文在此不做赘述,仅选择能够获取到的数据当作其特征。

    ​ 选取好特征后,我们就可以构建一个线性函数:
    y = w 0 + w 1 x 1 + w 2 x 2 + . . . + w k x k y = w_0+w_1x_1+w_2x_2+...+w_kx_k y=w0+w1x1+w2x2+...+wkxk
    其中, w w w 为我们要寻找的各个参数值 x x x 为我们选取的各个特征值

    ​ 此时,假设我们已经寻找到所有 w w w 值,则可以将特征空间 x 1 , x 2 , . . . , x k x_1,x_2,...,x_k x1,x2,...,xk 上样本的特征值通过 w 1 , w 2 , . . . , w k w_1,w_2,...,w_k w1,w2,...,wk 映射到值域空间 y y y 上,但此时 y y y 可能为某巨大的数,也可能为某负数,因此,我们引入一个非线性函数,将 y y y映射 ( 0 , 1 ) (0,1) (0,1) 范围内的一个值。sigmoid函数如下图所示。

    在这里插入图片描述s

    `于是,我们就建立了概率值 P P P y y y关系:
    l n ( P 1 − P ) = y P = e y 1 + e y ln(\frac{P}{1-P})=y \\ P=\frac{e^y}{1+e^y} ln(1PP)=yP=1+eyey
    ​ 最终,我们就可以通过这样一个计算图计算出某个类别的概率值:
    在这里插入图片描述

    ​ 但是,目前我们只是应用了 W W W 的值,我们并没有通过大量样本计算其值。因此,我们引入一个新的概念——梯度下降,来计算,准确来说是纠正这个向量的值。

    ​ 梯度下降法,顾名思义,计算过程就是沿梯度下降的方向求解极小值。

    ​ 现在我们又有一个问题,何为极小值?准确来说,这个值到底是怎么算出来的?在机器学习中,对于每个算法,我们都会引入一个函数,称其为代价函数。该代价函数衡量了我们训练的模型的好坏,衡量了这个算法的性能。代价函数最小为0,最大为正无穷,当代价函数为0时,该算法在训练集上的准确度为100%,但我们在训练时不应让代价函数为0,因为当代价函数为0时,模型会将训练集中的噪声也学习进去,因而在测试集上可能表现并不好。

    ​ 介绍完代价函数的作用,代价函数到底该怎么选取?对于一般的拟合模型,在不考虑噪声的情况下,最优的结果即为通过那些点的一条曲线。当通过这些点时,拟合值与真实值相等,形象的说就是目标与当前所处位置重合。因此,在定义代价函数时,我们遵循的是:目前状态与当前状态之间的距离差。(该处类似于评估模型TOPSIS法中某方案与最优方案的相对接近程度,也就是TOPSIS中的评估值)

    ​ 对于这个问题,我们先定义一个样本的损失函数如下:
    L ( y ^ , y ) = − y l o g ( y ^ ) − ( 1 − y ) l o g ( 1 − y ^ ) L(\hat{y},y)=-ylog(\hat{y})-(1-y)log(1-\hat{y}) L(y^,y)=ylog(y^)(1y)log(1y^)
    ​ 然后定义算法的代价函数如下:
    J ( w ) = 1 k ∑ L ( y ^ ( i ) , y ( i ) ) J(w)=\frac{1}{k}\sum{L(\hat{y}^{(i)},y^{(i)})} J(w)=k1L(y^(i),y(i))
    ​ 该代价函数衡量了训练集整体的混乱度,即信息熵

    所以,梯度下降法就是沿着梯度的方向,寻找一个最优的权重向量 W W W ,使得代价函数的函数值最小(但不是越小越好)。

    ​ 至此,我们介绍完了logistic回归所要应用的所有数学公式。下面,展示logistic编程与调包。

    编程:

    # -*- coding: utf-8 -*-
    import numpy as np
    
    class Logistic():
        def __init__(self):
            # 生成训练样本,其中a为特征值,b为标签
            a=[[0.50, 0.75, 1.00, 1.25, 1.50, 1.75, 1.75, 2.00, 2.25,2.50, 2.75, 3.00, 3.25, 3.50, 4.00, 4.25, 4.50, 4.75, 5.00, 5.50]]
            a=np.array(a)
            a=a.T
            ones=np.ones((a.shape[0],1))
    
            a=np.column_stack((ones,a))
            b=[[0,0,0,0,0,0,0,0,1,0,0,1,1,1,1,1,1,1,1,1]]
            b=np.array(b)
            b=b.T
            self.data_set=a
            self.data_target=b
            self.feature_size=self.data_set.shape[1]
            self.number_size=self.data_set.shape[0]
            self.W=np.random.randn(self.feature_size)
            pass
    
        def LG_Linear(self):
            #线性层,将特征空间映射为值域空间
            y=np.dot(self.data_set,self.W.transpose())
            y=np.array([y])
            y=y.T
            return y
            pass
    
        def LG_sigmoid(self,y):
            #非线性层,将值域空间映射为(0,1)
            P=np.exp(y)/(1+np.exp(y))
            return P
            pass
    
        def LG_cost(self,P,target):
            #损失函数
            cost=-target*np.log(P)-(1-target)*np.log(1-P)
            return cost
            pass
    
        def BP(self,P,target):
            #反向传播函数
            learningrate=0.05
            for i in range(self.number_size):
                dz=P[i][0]-target[i][0]
                #dz为代价函数求导所得
                dw=self.data_set[i][:]*dz
                self.W=self.W-learningrate*dw
                print(self.W)
            return self.W
            pass
    
        def predict(self,x):
            #预测函数
            pre=np.dot(self.W,x.transpose())
            pre=self.LG_sigmoid(pre)
            return pre
            pass
        pass
    def main():
        lg=Logistic()
        y=lg.LG_Linear()
        P=lg.LG_sigmoid(y=y)
        # lg.LG_cost(P=P,target=lg.data_target)
        for _ in range(10):
            lg.BP(P=P,target=lg.data_target)
        pre=lg.predict(np.array([[1,5]]))
        print(lg.W)
        print(pre)
        pass
    
    
    if __name__ == '__main__':
        main()
    

    调包:

    # -*- coding: utf-8 -*-
    
    # 导包
    import numpy as np
    from sklearn.linear_model import LogisticRegression
    
    # 加载数据
    
    a = [[0.50, 0.75, 1.00, 1.25, 1.50, 1.75, 1.75, 2.00, 2.25, 2.50, 2.75, 3.00, 3.25, 3.50, 4.00, 4.25, 4.50, 4.75, 5.00,
          5.50]]
    a = np.array(a)
    a = a.T
    b = [[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
    b = np.array(b)
    b = b.T
    x=a
    y=b
    
    lr = LogisticRegression()
    
    # 训练数据
    lr.fit(x,y)
    
    #求出w斜率和b截距的值
    w = lr.coef_
    b = lr.intercept_
    print(w, b)
    
    # 预测一下概率
    predict= lr.predict_proba([[3]])
    print(predict)
    
    展开全文
  • 利用Logistic回归进行分类的主要思想是:根据现有数据对分类边界线建立回归公式,依次进行分类。Logistic回归的一般过程(1)收集数据:采用任意方法收集数据(2)准备数据:由于需要进行距离计算,因此要求数据类型...

    假设现在有一些点,我们用一条直线对这些点进行拟合(该线称为最佳拟合直线),这个拟合过程就称作回归。

    利用Logistic回归进行分类的主要思想是:根据现有数据对分类边界线建立回归公式,依次进行分类。

    Logistic回归的一般过程

    (1)收集数据:采用任意方法收集数据

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

    (3)分析数据:采用任意方法对数据进行分析

    (4)训练算法:大部分时间将用于训练,训练的目的是为了找到最佳的分类回归系数

    (5)测试算法:一旦训练步骤完成,分类将会很快

    (6)使用算法:首先,我们需要输入一些数据,并将其转换成对应的结构化数值;接着,

    基于训练好的回归系数就可以对这些数值进行简单的回归计算,判定他们属于哪个类别;在这之后,我们就可以

    在输出的类别上做一些其他分析工作

    优化算法:梯度上升

    优缺点:

    优点:计算代价不高,易于理解和实现

    缺点:容易欠拟合,分类精度可能不高。

    使用数据类型:数值型和标称型数据

    我们想要的函数应该是,能接受所有的输入然后预测出类别。例如,在两个类的情况下,

    上述函数输出0或1,我们之前也接触过这种性质的函数,该函数称为海维赛德阶跃函数,

    或者直接称为单位节约函数,然而,这些函数的问题在于:该函数在跳跃点上从0瞬间跳跃到1,这个瞬间过程有时很难处理,

    幸好,另一个函数也有类似的性质,且数学上更易理解,这就是sigmoid函数。

    因此为了实现Logistic回归分类器,我们可以在每个特征上都乘以一个回归系数,然后把所有的结果相加,

    将这个总和带入sigmoid函数中,进而得到一个范围为0-1之间的数值,任何大于0.5的数据被分为1类,小于0.5的即被归入0类。

    所以,Logistic回归也可以被看成是一种概率估计。

    确定了分类器的函数形式后,现在的问题就变成了:最佳回归系数是多少?如何确定他们的大小?

    逻辑斯蒂回归采用梯度上升法找到最优值,我们经常听到的是梯度下降法,实际上,只是公式中的加法变成减法,

    梯度上升算法用来求函数的最大值,而梯度下降法用来求函数的最小值

    训练算法:使用梯度上升算法找到最佳参数,在数据集上,我们将通过使用梯度上升算法找到最佳回归系数,

    也就是拟合logitic回归模型的最佳参数。

    梯度上升法的伪代码如下:

    每个回归系数初始化为1

    重复R次:

    计算整个数据集的梯度

    使用alpha*gradient更新回归系数的向量

    返回回归系数

    1 from numpy import *

    2

    3 #打开文本文件并逐行读取

    4 defloadDataSet():5 dataMat = []; labelMat =[]6 fr = open('testSet.txt')7 for line infr.readlines():8 lineArr =line.strip().split()9 dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])10 labelMat.append(int(lineArr[2]))11 returndataMat,labelMat12

    13 #sigmod函数

    14 defsigmoid(inX):15 return 1.0/(1+exp(-inX))16

    17 #梯度上升算法

    18

    19 defgradAscent(dataMatIn, classLabels):20 dataMatrix = mat(dataMatIn) #convert to NumPy matrix

    21 labelMat = mat(classLabels).transpose() #convert to NumPy matrix

    22 m,n =shape(dataMatrix)23 #目标移动的步长

    24 alpha = 0.001

    25 #迭代次数

    26 maxCycles = 500

    27 weights = ones((n,1))28 #在for循环迭代完成后,将返回训练好的回归系数。

    29 for k in range(maxCycles): #heavy on matrix operations

    30 h = sigmoid(dataMatrix*weights) #matrix mult

    31 error = (labelMat - h) #vector subtraction

    32 weights = weights + alpha * dataMatrix.transpose()* error #matrix mult

    33 returnweights34 #画出数据集和logistic回归最佳拟合直线函数

    35 defplotBestFit(weights):36 importmatplotlib.pyplot as plt37 dataMat,labelMat=loadDataSet()38 dataArr =array(dataMat)39 n =shape(dataArr)[0]40 xcord1 = []; ycord1 =[]41 xcord2 = []; ycord2 =[]42 for i inrange(n):43 if int(labelMat[i])== 1:44 xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])45 else:46 xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])47 fig =plt.figure()48 ax = fig.add_subplot(111)49 ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')50 ax.scatter(xcord2, ycord2, s=30, c='green')51 x = arange(-3.0, 3.0, 0.1)52 #最佳拟合直线

    53 y = (-weights[0]-weights[1]*x)/weights[2]54 ax.plot(x, y)55 plt.xlabel('X1'); plt.ylabel('X2');56 plt.show()

    梯度上升算法在每次更新回归系数时都需要遍历整个数据集,该方法在处理

    100个左右的数据集尚可,但如果有数十亿样本和成千上万的特征,那么该

    方法的计算复杂度就太高了。一种改进方法是依次仅用一个样本点来更新回

    归系数,该方法称为随机梯度上升算法。由于可以在新样本到来时对分类器

    进行增量式更新,因而随机梯度上升算法是一个在线学习算法。与‘在线学习’

    相对应,依次处理所有数据被称作是“批处理”

    '''

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

    所有回归系数初始化为1

    对数据集中每个样本

    计算该样本的梯度

    使用alpha*gradient更新回归系数值

    返回回归系数

    1 defstocGradAscent0(dataMatrix, classLabels):2 m,n =shape(dataMatrix)3 alpha = 0.01

    4 weights = ones(n) #initialize to all ones

    5 for i inrange(m):6 h = sigmoid(sum(dataMatrix[i]*weights))7 error = classLabels[i] -h8 weights = weights + alpha * error *dataMatrix[i]9 return weights

    改进梯度上升算法

    第一处改进:一方面,alpha在每次迭代的时候都会调整,这样可以缓解数据波动或者高频波动。

    另外,虽然alpha会随着迭代次数不断减小,但永远不会减小到0,这是因为式子中还存在一个常

    数项。必须这样做的原因是为了保证在多次迭代后新数据仍然具有一定的影响。

    第二处改进是这里通过随机选取样本来更新回归系数。这种方法将减少周期的波动,

    此外,改进算法还增加了一个迭代次数作为第3个参数,如果该参数没有给定的话,算法将默认迭代150次。

    如果给定,那么算法将按照新的参数值进行迭代

    1 def stocGradAscent1(dataMatrix, classLabels, numIter=150):2 m,n =shape(dataMatrix)3 weights = ones(n) #initialize to all ones

    4 for j inrange(numIter):5 dataIndex =range(m)6 for i inrange(m):7 alpha = 4/(1.0+j+i)+0.0001 #apha decreases with iteration, does not

    8 #使用logistic回归进行分类并不需要做很多宫祖宗,所需要的知识把测试集上的每个特征向量

    9 #乘以最优化方法的来的回归系数,再将该乘积结果求和,最后输入到sigmoid函数中即可。

    10 randIndex = int(random.uniform(0,len(dataIndex)))#go to 0 because of the constant

    11 h = sigmoid(sum(dataMatrix[randIndex]*weights))12 error = classLabels[randIndex] -h13 weights = weights + alpha * error *dataMatrix[randIndex]14 del(randIndex)15 returnweights16

    17 dataArr,labelMat=loadDataSet()18 weights=stocGradAscent1(array(dataArr),labelMat)19 plotBestFit(weights)

    小结:logistic回归的目的是寻找一个非线性函数sigmoid的最佳拟合参数,求解过程可以由最优化算法来完成。在最优化算法中,最常用的就是梯度上升算法,而梯度上升算法又可以简化为随机梯度上升算法

    随机梯度上升算法与梯度上升算法的效果相当,但占用更少的计算资源,此外,随机梯度上升是一个在线算法,它可以在新数据到来时就完成参数更新,而不需要重新读取整个数据集来进行批处理运算。

    机器学习的一个重要问题就是如何处理缺失数据。这个问题没有标准的答案,取决于实际应用中的需求。现有的一些解决方案,每种方案都各有优缺点。

    展开全文
  • 本文件是网易云课堂吴恩达老师机器学习课程课后作业的Python实现,本部分是逻辑回归的作业,其他部分的作用也会陆续上传。
  • Logistic回归 Python实现

    2020-12-10 11:55:09
    Logistic回归 Logistic函数 f(x)=11+e−x 其函数图像为: 绘图方法 >>> import numpy as np>>> x = np.arange(-10,10,0.1)>>> y = 1/(1+np.exp(-x))>>> import matplotlib....
  • 机器学习之 Logistic回归算法及其 Python实现 前言:机器学习分类算法初步 感知器 自适应线性神经元及其学习的收敛性 逻辑斯蒂( Logistic)回归 基本模型介绍 通过代价函数获得权重 ogistic I的 Python实现 实现方式...
  • 使用 python 实现 Logistic 回归

    千次阅读 多人点赞 2021-04-04 17:55:46
    使用 python 实现 Logistic 回归原理回顾预测函数代价函数参数更新代码分析算法的实现算法的使用算法的对比全部代码 这节课我们将使用 numpy 实现逻辑回归算法,然后利用我们自己写的算法在乳腺癌数据集上进行癌症...
  • python实现Logistic回归

    2021-02-03 15:15:02
    本文不涉及逻辑回归的具体原理,只通过python代码实现算法,并且没有用到机器学习库,根据算法流程一步一步实现。 目录逻辑回归数据准备sigmoid函数权重更新分类绘制决策边界 逻辑回归 数据准备 文件中没条数据有两...
  • Logistic回归本质上是在线性回归基础上,将预测值映射到概率区间内的分类学习方法。本文图文详解Logistic回归算法原理+手推公式,附Python代码实战加深理解
  • umpy是利用pyhon进行科学化编程计算中的一个主要的模块。下面我们就来先构建深度学习中的一些基本的函数吧! 1.sigmoid 函数,np.exp() ...(Logistic函数或Logistic曲线是一种常见的S形函数,它是皮埃尔·弗朗索瓦·韦
  • logistic回归分析matlab代码逻辑回归-机器学习 客观的开发机器学习算法,无需使用Octave或Matlab即可在python中进行逻辑回归。 Logistic回归是一种估计事件发生概率的回归类型。 例如,电子邮件是否为垃圾邮件,情绪...
  • Logistic回归模型和Python实现

    千次阅读 2020-12-09 20:32:55
    回归分析是研究变量之间定量关系的一种统计学方法,具有广泛的应用。Logistic回归模型线性回归先从线性回归模型开始,线性回归是最基本的回归模型,它使用线性函数描述两个变量之间的...Logistic回归logistic回归(L...
  • Logistic回归——二分类 —— python

    千次阅读 2022-03-25 12:37:14
    1.简介 2.应用范围 3.分类 3.应用条件 4.原理详解 4.1sigmod分类函数 4.2 建立目标函数 4.3 求解相关参数 5.实列分析 5.1 导入库 5.2 读取数据(excel文件) ...6. python中sklearn函数
  • 逻辑回归python无框架实现
  • python统计分析--4.Logistic回归

    千次阅读 2021-09-14 16:04:46
    python数据处理标准流程2. 混淆矩阵与预测3. 交叉验证4. 网格搜索5. pipeline管道 #导入包 import numpy as np import pandas as pd import statsmodels.formula.api as smf from sklearn import linear_model ...
  • python 数据分析之logistic(逻辑)回归1 环境准备2 读取数据集3 sigmoid函数和误差函数设计4 梯度下降方法设计5 读取数据设置参数6 绘制决策边界7 绘制误差曲线和参数theta变化 1 环境准备 import numpy as np ...
  • Python进行Logistic回归

    千次阅读 2019-05-25 21:55:08
    Python进行Logistic回归第一步,导入库和数据;第二步,处理数据;第三步,数据建模;最后,模型评价。 第一步,导入库和数据; # 导入库 from sklearn import datasets import numpy as np import pandas as pd ...
  • Logistic Regression Classifier逻辑回归主要思想就是用最大似然概率方法构建出方程,为最大化方程,利用牛顿梯度上升求解方程参数。 优点:计算代价不高,易于理解和实现。 缺点:容易欠拟合,分类精度可能不高。...
  • Logistic回归及其python代码实现

    千次阅读 2020-01-05 11:19:05
    导录:引言引入sigmoid函数二元逻辑回归的损失函数梯度下降法求...之所以叫Logistic回归, 是因为它的算法和线性回归基本上是完全一致的,不同之处在于Logistic回归在线性回归的最后一步的基础上引入了激活函数—sig...
  • 然后带到逻辑回归公式当中,代数时算出的是最后结果的概率,也就是如下公式 如果再ln的话,就回到原本的线性公式,然后再取对数,就可以求出可能比 优秀论文中用到的公式: 代码: 但不知道为什么只有aconda可以...
  • 通俗讲解logistic回归原理。 python实现logistic回归过程。
  • 思路:如果食品寒热属性与其成分之间都是线性关系,那么可以考虑采用多元 Logistic回归 模型来分类,后续查看其模型预测准确率,若准确率高,则进一步进行线性检验,若较低,用另外的模型。.........
  • 逻辑回归Logistic Regression) 逻辑回归:是一个非常经典的算法。是一种用于解决二分类(0 or 1)问题的机器学习方法,用于估计某种事物的可能性。 注:这里用的是“可能性”,而非数学上的“概率”,logisitc...
  • 逻辑回归 Logistic Regressionsigmoid/logistic function逻辑回归实际上是分类问题,二分类或者多分类问题。其中逻辑回归logistic公式表达为:y = 1/1+e^{-z}此公式也可以叫做sigmoid函数。该式子中,z取值为0时,...
  • 本文主要研究的是Python机器学习logistic回归的相关内容,同时介绍了一些机器学习中的概念,具体如下。拟合、插值和逼近是数值分析的三大工具回归:对一直公式的位置参数进行估计拟合:把平面上的一些系列点,用一条...
  • 前面一个博客机器学习之路——logistic回归讲了logistic回归的理论知识,现在咱们来看一下logistic回归如何用python来实现,代码、数据参考《机器学习实战》。   首先看下我们要处理的数据, 我们要做的就是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,954
精华内容 11,181
关键字:

logistic回归python