精华内容
下载资源
问答
  • 线性模型是什么? 线性模型是监督学习的各类学习算法最基本的一类学习算法,它的基本特性在于“线性”性质。线性是我们能处理的一类最简单的情况,同时其用处也非常广泛。其假设我们的样本空间χ\chiχ到标记空间...

    简单线性模型及局部加权线性模型的基本原理和python实现(参数估计的两个基本角度:几何直观和概率直观。函数最值问题的两大基本算法:梯度方法与迭代方法)


    线性模型是什么?

    线性模型是监督学习的各类学习算法最基本的一类学习算法,所谓线性值得是模型的输出与数据的各个属性值之间的关系是线性的。线性是我们最擅长处理的(无论是工程实现还是数学分析),同时利用线性进行拓展,我们还可以处理很多非线性的情况。
    简单线性模型假设我们的样本空间χ\chi与参数θ\theta之间的关系是线性的,如下所示:
    y^=θ0x0+θ1x1+...+θnxn \hat{y} = \theta_0x_0+\theta_1x_1+...+\theta_nx_n记之为y^=hθ(x)=θTx\hat{y} = h_{\theta}(x) = \theta^Tx,简单线性模型是后面我们将学习的广义线性模型的基础。

    求解参数θ\theta的两种角度:几何直观和概率直观

    估计上述参数θ\theta的方式,主要有两种,一种是从几何直观,一种是从概率直观。它们分别是:

    • 最小二乘方法 (Ordinary Squart Least, OSL)
    • 极大似然估计 (Maximum Liklihood Estimate, MLE)
    1. 最小二乘方法从几何的角度出发,认为拟合值与原值之间的平方误差和应该最小化,因此我们定义了一个损失函数(cost function) 如下:
      J(θ)=12i=1m[hθ(x(i))y(i)]2J(\theta) = \frac{1}{2}\sum_{i=1}^{m}[h_{\theta}(x^{(i)})-y^{(i)}]^2 参数θ\theta需要使得损失函数最小化

    2. 极大似然估计是从概率的角度出发,认为样本数据既然发生了,其背后的概率应该最大化。因此我们首先对模型进行概率解释,即
      y=θ0x0+θ1x1+...+θnxn+ϵy = \theta_0x_0+\theta_1x_1+...+\theta_nx_n + \epsilon然后我们做一个比较合理的假设,即误差的零均值同方差正态假设,因此有
      ϵN(0,σ2)\epsilon \sim{N(0,\sigma^2)}所以标签值yy的分布为yN(θTx,σ2)y\sim{N(\theta^Tx,\sigma^2)}因此整个样本数据的概率似然函数为
      L(θ)=i=1m12πσexp((y(i)hθ(x(i)))2σ2)L(\theta) = \sum_{i=1}^{m}\frac{1}{\sqrt{2\pi}\sigma}exp(-\frac{(y^{(i)}-h_{\theta}(x^{(i)}))^2}{\sigma^2})那么参数θ\theta需要使得似然函数最大化。

    以上两种参数估计的方法最终都归结为某个函数形式的最值问题,下面我们讨论如何求解非线性函数的最值。

    函数最值问题的两大数值算法

    • 梯度方法
      • 批量梯度下降(Batch Gradient Descent, BGD)
      • 随机梯度下降(Stochastic Gradient Descent, SGD)
    • 迭代方法
      • 一般迭代法
      • 牛顿迭代法

    梯度方法

    梯度是微积分中概念。在映射f:RnRf:R^n \rightarrow R中,它是一个nn维向量,其方向是该点处切平面增长最快的方向,在微分中,因为我们用切平面的增量近似函数的增量,所以梯度的方向也是该点函数增长最快的方向。从而利用自变量空间中关于ff的梯度场,就可以保证达到某个极值,在凸性的保证,还可以保证其达到最值。

    迭代方法

    我们详细介绍迭代方法。首先我们知道最值点的必要条件是稳定点,即导数为0。因此我们实际上需要一个寻找函数零点的方法。一般来讲,迭代方法可以分为两类:

    • 直接法(连续函数的中值定理)
    • 间接法

    直接法有我们熟悉的二分法等,我们略去不谈。这里要重点介绍间接法。我们首先谈迭代法的一般理论,然后再谈广泛使用的牛顿迭代法及其多元形式。
    在一维情况下,由f(x)=0f(x)=0可以尝试得到:
    x=φ(x)x=\varphi(x)φ(x)<1\mid \varphi^{'}(x)\mid < 1在区间[a,b][a,b]成立时,则可以证明在由迭代式xn=φ(xn1)x_{n}=\varphi(x_{n-1})产生的迭代序列{xn}\{x_{n}\}收敛于xx^*,其中x0[a,b]x_0\in[a,b]。从而有
    limnxn=limnφ(xn1)=x\lim_{n\to\infty}x_{n}=\lim_{n\to\infty}\varphi(x_{n-1})=x^*
    现在我们讨论牛顿迭代法。其基本思想在于做切线不断逼近零点。假设我们面对的函数为f(x)f(x),则在初始值x0x_0处的切线为yy0=f(x0)(xx0)y-y_0 = f^{'}(x_0)(x-x_0)y=0y=0得到x1x_1,从而不断迭代逼近真实值,其迭代式为
    xn=φ(xn1)=xn1f(xn1)f(xn1)x_n = \varphi(x_{n-1}) = x_{n-1}-\frac{f(x_{n-1})}{f^{'}(x_{n-1})}当求最值问题时,则迭代式为
    xn=xn1f(xn1)f(xn1)x_n = x_{n-1}-\frac{f_{'}(x_{n-1})}{f^{''}(x_{n-1})}牛顿迭代法在一定的条件下可以证明收敛 (参见《计算方法》,凹凸性),其收敛条件一般采用事后判断法,即
    xnxn1<ϵ\mid x_{n}-x_{n-1}\mid < \epsilon当自变量为多元情况的时候,其迭代式的形式仍是一致的。根据多元微积分,此时的一阶偏导数为一个向量,即梯度,记为xf(x)\bigtriangledown_{x}f(x),二阶偏导数为一个矩阵,即海森矩阵(Hessian)HH,每一个元素为Hi,j=2f(x)xixjH_{i,j} = \frac{\partial^2{f(x)}}{\partial{x_{i}}\partial{x_{j}}}因此多元情况下的牛顿迭代法的迭代式为
    xn=φ(xn1)=xn1H1xf(x)x_n = \varphi(x_{n-1}) = x_{n-1}-H^{-1}\bigtriangledown_{x}f(x)注:一般情况下牛顿迭代法会比梯度下降迭代次数更少,收敛速度更快。然而每一次迭代牛顿迭代法需要需要计算的量更多,因为其中有一个海森矩阵。但只要维度n不是很大,总体上牛顿迭代的速度更快。

    Newton’s method typically enjoys faster convergence than (batch) gra-dient descent, and requires many fewer iterations to get very close to the minimum. One iteration of Newton’s can, however, be more expensive than one iteration of gradient descent, since it requires finding and inverting an n-by-n Hessian; but so long as n is not too large, it is usually much faster overall. When Newton’s method is applied to maximize the logistic regres-sion log likelihood function ℓ(θ), the resulting method is also called Fisher scoring.——Andrew Ng

    殊途同归:简单线性模型下几何直观和概率直观的统一汇合

    前面我们讨论了θ\theta的两个求解角度,得到了两个函数,即损失函数和似然函数。接下来我们将看到,最小化损失函数和最大化似然函数实际上是等价的。然后我们会讨论在简单线性模型下,两种角度下的函数最值求解,其实不同数值算法也可以,因为我们可以直接进行代数分析给出最值点的数学解析式。

    注意,从OSL和MLE两个角度出发,得到损失函数和似然函数,其最值问题等价,这个事情并不平凡。在后面介绍广义线性模型的时候,我们会看到基于各种指数簇分布的回归特例(简单线性模型只是基于正态分布下的回归特例),这个事情并不成立,即它们在理论上可能得到不同的参数θ\theta。BTW,后面我们采用的都是MLE的角度,因为从MLE出发,利用梯度方法,各个回归特例的梯度更新公式都有统一的优美形式,此为后话。

    几何直观角度下(OSL)的BGD、SGD梯度方法

    OSL定义的损失函数(cost function) 如下:
    J(θ)=12i=1m[hθ(x(i))y(i)]2J(\theta) = \frac{1}{2}\sum_{i=1}^{m}[h_{\theta}(x^{(i)})-y^{(i)}]^2其关于参数的导数为J(θ)θ=i=1m(hθ(x(i))y(i))x(i)\frac{\partial{J(\theta)}}{\partial\theta}=\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})x^{(i)}在BSD中,每一次对θ\theta的更新需要遍历全部训练集的数据,其更新规则如下:θ:=θ+αi=1m(y(i)hθ(x(i)))x(i)\theta:=\theta+\alpha\sum_{i=1}^{m}(y^{(i)}-h_{\theta}(x^{(i)}))x^{(i)}而在SGD中,每一次仅从训练集中挑出一个训练样本对θ\theta进行更新,因此其更新规则为:
    θ:=θ+α(y(i)hθ(x(i)))x(i)\theta:=\theta+\alpha(y^{(i)}-h_{\theta}(x^{(i)}))x^{(i)}其中α\alpha表示的是学习率,或者形象地认为其为更新的步长。
    注:从更高的角度来看,我们要降低不仅仅是训练数据集中的整体误差,而是整个样本空间的泛化误差,因此真正的损失函数为J(θ)=12xχ[hθ(x(i))y(i)]2p(x)dxJ(\theta) = \frac{1}{2}\int_{x\in\chi}[h_{\theta}(x^{(i)})-y^{(i)}]^2p(x)dx而由于事实上我们无法知道总体的分布,因此按照蒙特卡洛模拟算法,应该抽取一定的样本进行近似,若取样本量M=mM = m,则为BGD,若取样本量M=1M = 1时,则为SGD,显然还可以取1<M<m1 < M < m,此时则为小批量梯度下降算法 (Mini-Batch Gradient Descent)。
    至此其实可以看到BGD与SGD本质上是一致的,即从总体中抽出样本来降低模拟误差。实际中SGD的应用会更多一些,特别是在训练数据量m较大时,其收敛速度更快,同时一定程度上能避免陷入局部最小值。

    概率直观下(MLE)的 BGD、SGD方法

    概率直观下定义的似然函数为
    L(θ)=i=1m12πσexp((yihθ(x))2σ2)L(\theta) = \sum_{i=1}^{m}\frac{1}{\sqrt{2\pi}\sigma}exp(-\frac{(y_{i}-h_{\theta}(x))^2}{\sigma^2})对数之并约简,即可得到
    (θ)=lnL(θ)=mln(2πσ)1σ2i=1m(yihθ(x))2\ell(\theta) = lnL(\theta)=-mln(\sqrt{2\pi}\sigma)-\frac{1}{\sigma^2}\sum_{i=1}^{m}(y^{i}-h_{\theta}(x))^2可以看到,求(θ)\ell(\theta)的最大值,等价于求i=1m[hθ(x(i))y(i)]2\sum_{i=1}^{m}[h_{\theta}(x^{(i)})-y^{(i)}]^2的最小值,这正是OLS的损失函数的形式。因此MLE对参数θ\theta的求解,理论上同OLS就是等价的。由此也可以领悟到OLS是一个非常自然的方法,它实际上是在一组假设下做极大似然估计(我们其实更偏爱概率直观,所以用MLE来解释OSL)。

    This is thus one set of assumptions under which least-squares re-gression can be justified as a very natural method that’s just doing maximum likelihood estimation.----Andrew Ng

    两种角度下最优参数的数学解析式

    通过代数分析,我们可以直接在理论上给出θ=argminθΘJ/L(θ)\theta = {\arg\min}_{\theta\in\Theta}J/L(\theta)时的数学表达式。为了方便进行代数分析,我们引入下列记号:

    • 样本矩阵XX
      [1x1(1)x2(1)xn(1)1x1(2)x2(2)xn(2)1x1(3)x2(3)xn(3)1x1(m)x2(m)xn(m)] \left[ \begin{matrix} 1 & x_1^{(1)} & x_2^{(1)} & \cdots & x_n^{(1)}\\ 1 & x_1^{(2)} & x_2^{(2)} & \cdots & x_n^{(2)}\\ 1 & x_1^{(3)} & x_2^{(3)} & \cdots & x_n^{(3)}\\ \vdots & & & \ddots & \vdots\\ 1 & x_1^{(m)} & x_2^{(m)} & \cdots & x_n^{(m)} \end{matrix} \right]

    • 对参数向量θ\theta的求导运算:

    1. 向量求导:ATθθ=A\frac{\partial{A^T\theta}}{\partial{\theta}}=A,其中AA是一个常数列向量。
    2. 向量求导:θTBθθ=2Bθ\frac{\partial{\theta^TB\theta}}{\partial{\theta}}=2B\theta,其中BB是一个对称矩阵。

    至此,则损失函数可以表示为矩阵代数的形式:
    J(θ)=12u^Tu^=12(yXθ)T(yXθ)=12(yTy2yTXθ+θTXTXθ)\begin{aligned} J(\theta)=& \frac{1}{2}\hat{u}^T\hat{u} \\ =&\frac{1}{2}(y-X\theta)^T(y-X\theta)\\ =&\frac{1}{2}( y^Ty-2y^TX\theta+\theta^TX^TX\theta) \end{aligned}J(θ)=XTXθXTy=0J^{'}(\theta) = X^TX\theta-X^Ty = 0,即可解出
    θ=(XTX)1XTy\theta = (X^TX)^{-1}X^Ty

    简单线性模型的进一步拓展:局部加权线性回归(Local Weighted Liner Regression,LWLR)

    局部加权线性回归采用一种非参数的方法来预测未知的样本。在之前的方法中,一旦参数向量θ\theta学习出来后,则可以将历史的样本抛弃。而在LWLR中,历史收集到的样本需要始终保留下来,每一次对新样本进行估计时,都会动态得到结合样本数据和新样本的位置,给出一个参数θ\theta的一个新的估计结果。换言之,θ\theta是为新样本量身定做的。下面我们主要从几何直观的角度讨论LWLR。
    注:我们其实仍然可以从概率直观的角度来解释LWLR,有兴趣的读者可以自己思考(从异方差的角度)。

    下面讨论LWLR的具体做法。对于一个新进的样本x(j)x^{(j)}

    • 利用已有的数据(经验),最小化i=1mw(i)(hθ(x(i))y(i))2\sum_{i=1}^{m}w^{(i)}(h_{\theta}(x^{(i)})-y^{(i)})^2,得到θj^\hat{\theta_j}
    • 给出预测值y^(j)=θj^Tx(j)\hat{y}^{(j)} = \hat{\theta_j}^{T}x^{(j)}

    其中,w(i)w^{(i)}可以由核光滑函数来确定,即:
    w(i)=exp((x(i)x(j))22τ2)w^{(i)} = exp(-\frac{(x^{(i)}-x^{(j)})^2}{2\tau^2})其中τ\tau称为宽度(bandwidth),控制了权重随距离下降的快慢。从几何直观的角度看,越靠近x(j)x^{(j)}x(i)x^{(i)},其误差平方将会被给予更大的权重。
    总体上可以认为对y(j)y^{(j)}的估计时,不同的训练样本不在被一视同仁,越靠近x(j)x^{(j)}的样本点越被重视,从而得到的直线将会更好地符合x(j)x^{(j)}周围的样本点的情况。

    在局部加权最小二乘法中,利用梯度方法进行θ\theta的迭代求解,此时的更新公式是:

    • BGD:θ:=θ+αi=1m(y(i)hθ(x(i)))x(i)w(i)\theta:=\theta+\alpha\sum_{i=1}^{m}(y^{(i)}-h_{\theta}(x^{(i)}))x^{(i)}w^{(i)}
    • SGD:θ:=θ+α(y(i)hθ(x(i)))x(i)w(i)\theta:=\theta+\alpha(y^{(i)}-h_{\theta}(x^{(i)}))x^{(i)}w^{(i)}

    利用矩阵代数分析,同样可以得到θj^\hat{\theta_{j}}的数学解析式。首先令
    权重矩阵WW
    [w(1)000w(2)000w(m)] \left[ \begin{matrix} w^{(1)} & 0 & \cdots & 0\\ 0 & w^{(2)} & \cdots & 0\\ \vdots & & \ddots & \vdots \\ 0 & 0 & \cdots & w^{(m)} \end{matrix} \right] 则此时的损失函数可以表示为:
    J(θ)=12i=1mw(i)(hθ(x(i))y(i))2=12i=1m(w(i)hθ(x(i))w(i)y(i))2=12i=1m(hθ(w(i)x(i))w(i)y(i))2\begin{aligned} J(\theta) = & \frac{1}{2}\sum_{i=1}^{m}w^{(i)}(h_{\theta}(x^{(i)})-y^{(i)})^2\\ = & \frac{1}{2}\sum_{i=1}^{m}(\sqrt{w^{(i)}}h_{\theta}(x^{(i)})-\sqrt{w^{(i)}}y^{(i)})^2\\ = & \frac{1}{2}\sum_{i=1}^{m}(h_{\theta}(\sqrt{w^{(i)}}x^{(i)})-\sqrt{w^{(i)}}y^{(i)})^2 \end{aligned}因此原来的样本数据等价变换后的样本数据,其属性值为w(i)x(i)\sqrt{w^{(i)}}x^{(i)},标记值为w(i)y(i)\sqrt{w^{(i)}}y^{(i)}。利用矩阵的记法,则样本矩阵记为W12XW^{\frac{1}{2}}X,标记矩阵记为W12yW^{\frac{1}{2}}\vec{y},故代入原来的解析式
    θ=(XTX)1XTy\theta = (X^TX)^{-1}X^T\vec{y}可得
    θj^=(XTWX)1XTWy\hat{\theta_{j}} = (X^TWX)^{-1}X^TW\vec{y}一般的,当样本属性空间是多维度的时候,即xx是多维向量时,根据高维欧式空间距离的推广式:xy=(xy)T(xy) \parallel x-y \parallel = (x-y)^T(x-y) 核光滑函数可以表示为:
    w(i)=exp((x(i)x(j))T(x(i)x(j))2τ2)w^{(i)} = exp(-\frac{(x^{(i)}-x^{(j)})^T(x^{(i)}-x^{(j)})}{2\tau^2})

    实战项目:简单线性模型下BGD、SGD、Mini-Batch GD、数学解析式的实现和LWLR的实现 (python)

    特别说明:在梯度下降算法中,需要特别留意学习率α\alpha(步长)的大小设置。以BGD为例,如果α\alpha设置过大,则会出现总误差不减反增的现象,最终导致溢出。通过查看中间输出可看到,其过程中误差函数的偏导数出现正负号轮流出现的规律,可以推断这是由于α\alpha过大导致的震荡现象,从而使得偏导数越来越大,总误差趋向无穷。
    SGD中步长更合适的方法应该是采取自适应方式,即不应当将其设为一个常值,原因在于在最后收敛处,较大的步长会影响其得到稳定的优解,而在一开始迭代时,较小的步长会影响到其迭代的速度,因此总体上步长的设置应该逐步减小。

    myLm.py

    import numpy as np
    from numpy import dot
    from numpy.linalg import inv
    import random
    
    def Lm(X,Y,method,alpha = 0.001,epsilon = 0.0000001,o = None,tau = None):
        '''
        X:样本矩阵 [1,x1,x2,x3,...,xn]
        Y:样本标签值向量 [y]
        method:训练参数时使用的方法,有OLS、BGD、SGD、MBGD、LWLM
        alpha: 学习速率(步长)
        epsilon:迭代终止阈值
        return:本函数通过使用相应的算法,给出简单线性回归模型的参数估计值
        '''
        if(method == 'OLS'):
            theta_0 = dot(dot(inv(dot(X.T,X)),X.T),Y)
            return theta_0
        elif(method == 'BGD'):
            #初始值设置
            theta_0 = np.ones(shape = X.shape[1])
            #计算当前损失函数的总误差
            error_0 = 0.5*dot((dot(X,theta_0)-Y).T,dot(X,theta_0)-Y)
            #启动循环
            error = epsilon+1
            #迭代次数n
            n = 0
            while(error > epsilon):       
                #计算全部样本误差函数的梯度
                G = dot(dot(X.T,X),theta_0)-dot(X.T,Y)
                #更新theta
                theta_0 = theta_0 - alpha*G
                #计算步长更新后的损失函数的总误差
                error_1 = 0.5*dot((dot(X,theta_0)-Y).T,dot(X,theta_0)-Y)
                #计算前后二者的差
                error = abs(error_1-error_0)
                #将新一轮的误差保存用于下一轮
                error_0 = error_1
                # 输出迭代过程
                # print('---------------第',n,'轮迭代--------------')
                # print('theta:',theta_0)
                # print('error:',error)
                # print('G:',G,'\n')
                n = n + 1
            print('BGD Iteration Times: ',n)
            return theta_0
            
        elif(method == 'SGD'):
            #初始值设置
            theta_0 = np.ones(shape = X.shape[1])
            #计算当前初始值下损失函数的总误差
            error_0 = 0.5*dot((dot(X,theta_0)-Y).T,dot(X,theta_0)-Y)
            #启动循环
            error = epsilon+1
            #样本量
            m = X.shape[0]
            #遍历列表
            k = list(range(m))
            #迭代次数
            n = 0
            while(error > epsilon):
                #选择一个随机数[] r = random.randint(0,m-1)
                #遍历乱序列表
                random.shuffle(k)
                #计算当前样本下的梯度
                for r in k:
                    G = (dot(X[r,:],theta_0)-Y[r])*X[r,:]
                    #更新theta的值
                    theta_0 = theta_0 - alpha*G
                #计算步长更新后theta_1下损失函数的总误差
                error_1 = 0.5*dot((dot(X,theta_0)-Y).T,dot(X,theta_0)-Y)
                #计算误差修正值大小
                error = abs(error_1-error_0)
                #将新一轮的误差保存用于下一轮
                error_0 = error_1
                # 输出迭代过程
                # if(n%100 == 0):
                    # print('---------------第',n,'轮迭代--------------')
                    # print('theta:',theta_0)
                    # print('error:',error)
                    # if(n > 8000):
                        # alpha = 0.00001
                    # print('r:',r)
                    # print('G:',G,'\n')
                n = n + 1
            print('SGD Iteration Times: ',n)
            return theta_0
        elif(method == 'MBGD'):
            #初始值设置
            theta_0 = np.ones(shape = X.shape[1])
            #计算当前损失函数的总误差
            error_0 = 0.5*dot((dot(X,theta_0)-Y).T,dot(X,theta_0)-Y)
            #启动循环
            error = epsilon+1
            #样本量
            m = X.shape[0]
            #遍历列表
            k = list(range(m))        
            #迭代次数n
            n = 0
            while(error > epsilon):       
                #随机选取一定批量的样本
                random.shuffle(k)
                minBatch = k[:m//10]
                minX = X[minBatch]
                minY = Y[minBatch]  
                #计算小批量样本误差函数的梯度
                G = dot(dot(minX.T,minX),theta_0)-dot(minX.T,minY)
                #更新theta
                theta_0 = theta_0 - alpha*G
                #计算步长更新后的损失函数的总误差
                error_1 = 0.5*dot((dot(X,theta_0)-Y).T,dot(X,theta_0)-Y)
                #计算前后二者的差
                error = abs(error_1-error_0)
                #将新一轮的误差保存用于下一轮
                error_0 = error_1
                # 输出迭代过程
                # print('---------------第',n,'轮迭代--------------')
                # print('theta:',theta_0)
                # print('error:',error)
                # print('G:',G,'\n')
                n = n + 1
            print('MBGD Iteration Times: ',n)
            return theta_0
        elif(method == 'LWLM'):
        	#局部加权线性回归
            XCopy = X[:,1:]-o
            d = []
            for i in range(XCopy.shape[0]):
                d.append(dot(XCopy[i],XCopy[i]))
            d = np.array(d)
            w = np.exp(-d**2/(2*tau**2))
            W = np.diag(w)
            theta_0 = dot(dot(dot(inv(dot(dot(X.T,W),X)),X.T),W),Y)
            return theta_0
        else:
            print('No Such Method In this Func.')
    

    myLmtest.py

    import myLm
    import numpy as np
    import pandas as pd
    
    if __name__ == '__main__':
        samData = pd.read_table('mlData/regreData/simpleRegre.txt',header = None)
        #转换为二维数组
        sample = np.array(samData)
        #将属性值与标签值分开
        sampleX = sample[:,:np.shape(sample)[1]-1]
        sampleY = sample[:,sample.shape[1]-1]
        x = np.array([0])
        #Testing
        theta = myLm.Lm(sampleX,sampleY,method = 'LWLM',o = x,tau = 1)
        print('LWLM:',theta)
        theta = myLm.Lm(sampleX,sampleY,method = 'SGD')
        print('SGD:',theta)
        theta = myLm.Lm(sampleX,sampleY,method = 'BGD')
        print('BGD:',theta)
        theta = myLm.Lm(sampleX,sampleY,method = 'MBGD')
        print('MBGD:',theta)
        theta = myLm.Lm(sampleX,sampleY,method = 'OLS')
        print('OLS:',theta)
    
    展开全文
  • 模型假设数据服从Logistic分布,然后使用极大似然估计参数的估计。 首先我们需要了解什么是Logistic分布: 设X连续随机变量,X服从逻辑斯谛分布指X具有下列分布函数和密度函数: F(x)=P(X≤x)=11+e−(x−μ)/...

    逻辑回归

    基本概念

    Logistic Regression 逻辑斯谛回归,属于对数线性模型,亦属于分类模型的一种。模型假设数据服从Logistic分布,然后使用极大似然估计做参数的估计。

    首先我们需要了解什么是Logistic分布:

    设X是连续随机变量,X服从逻辑斯谛分布是指X具有下列分布函数和密度函数:
    F(x)=P(Xx)=11+e(xμ)/γF(x) = P(X \leq x) = \frac{1}{1+e^{-(x-\mu)/\gamma}}
    f(x)=F(x)=e(xμ)/γγ(1+e(xμ)/γ)2f(x) = F'(x) = \frac{e^{-(x-\mu)/\gamma}}{\gamma(1+e^{-(x-\mu)/\gamma})^2}
    公式中,μ\mu是位置参数,γ\gamma是形状参数。

    密度函数和分布函数的走势如下:

    密度函数 分布函数 其中,分布函数是以点$(\mu,\frac{1}{2})$为中心对称的S形曲线,满足:

    F(x+μ)12=F(x+μ)+12F(-x+\mu)-\frac{1}{2} = -F(x+\mu)+\frac{1}{2}

    什么是概率函数、什么是分布函数呢?

    • 概率密度函数:区间内的面积除以总面积,即为该区间的概率密度。

    对于一维实随机变量X,设它的累积分布函数是FX(x)F_X(x),如果存在可测函数fX(x)f_X(x)满足:FX(x)=xfX(t)dtF_X(x)=\int^{x}_{-\infty}{f_X(t)}dt,那么X是一个连续型随机变量,并且是它的概率密度函数。

    概率密度
    • 分布函数:
      分布函数就是变量小于等于某个特定值a的概率(或者频率,如果是用数据统计出来的话),也即F(a)=P{X<a}F(a)=P\{X<a\}

    逻辑回归模型

    二项逻辑斯谛回归模型

    定义:满足如下条件概率分布:
    P(Y=1x)=exp(wx+b)1+exp(wx+b)P(Y= 1|x)=\frac{exp(w\cdot x+b)}{1+exp(w \cdot x+b)}
    P(Y=0x)=11+exp(wx+b)P(Y= 0|x)=\frac{1}{1+exp(w \cdot x+b)}
    其中,x为输入,Y为输出。w为权重参数,b为偏置。
    exp,以自然常数e为底的指数函数

    当实例xx输入模型后,会计算出Y=1Y=1Y=0Y=0时候的概率值,模型将比较两个数值的大小,并将实例xx分到概率值较大的那一类。从输出上,也可以看出该模型是典型的0,1二分类模型。

    从事件发生几率的角度上来说(该事件发生的概率与不发生的概率的比值),输出Y=1Y=1的对数几率是由输入xx的线性函数来表示的模型:
    logit(p)=logp1p=logP(Y=1x)1P(Y=1x)=wxlogit(p) = log \frac{p}{1-p}=log \frac{P(Y=1|x)}{1-P(Y=1|x)}=w\cdot x

    多项逻辑斯谛回归模型

    在二分类的基础上进行推广可以得到多分类模型。这里需要将输出的Y进行推广,从0,1推广至K。

    定义:满足如下条件概率分布:
    P(Y=kx)=exp(wkx)1+k=1K1exp(wkx),k=1,2,...,K1P(Y= k|x)=\frac{exp(w_k\cdot x)}{1+\sum^{K-1}_{k=1}exp(w_k \cdot x)},k=1,2,...,K-1
    P(Y=0x)=11+k=1K1exp(wkx)P(Y= 0|x)=\frac{1}{1+\sum^{K-1}_{k=1}exp(w_k \cdot x)}
    其中,x为输入,Y为输出。w为权重参数,K为总的输出类个数。
    exp,以自然常数e为底的指数函数

    展开全文
  • 这里讨论下RIP和OSPF的基本算法,在CISCO课程中讨论RIP和OSPF的区别有...PS:这就说明了为什么RIP要采用跳数,而OSPF用的cost,也就是带宽作为主要参数,因为估计在具体实现中不大可行的,故采用不同的具体度量值。

    这里讨论下RIP和OSPF的基本算法,在CISCO课程中讨论RIP和OSPF的区别有不少,但是回溯源头,它们理论算法里面的原理差不多,比较大的区别主要有三点

    1.Bellman-ford的链路距离是估算的,Dijkstra是传输链路距离给邻居的PS:这就说明了为什么RIP要采用跳数,而OSPF用的是cost,也就是带宽作为主要参数,因为估计在具体实现中是不大可行的,故采用不同的具体度量值。

    2.Bellman-ford的持续进行链路距离的计算,而Dijkstra只进行一次计算就可以了,这点可能表达的不是太准确,大致意思

    3.还有点就是Bellman-ford是不停在从目标出发所有相邻的节点上计算最小的路径,然后往前推进,而Dijkstra是从最小标记的节点往前推进,这里看后面解释:

    这里用图例解释下(直接抓的是jean walrand的书上的图)


    首先这是Bell-man算法的一个收敛图,图中解释了一个收敛的过程。

    Bell-man算法采用节点间链路长度估算的方式,公式为L( i ) = min { d( i , j )+ L( j ) },其中d( i , j ) 表示节点 i 到 j 的链路长度,L( j )是从节点 j 收到的最短长度的估算。

    即每一个节点初始时候以∞作为标识,从目标点向源点收敛,目标点作为0,然后相邻的标记为链路长度,当出现到目标点更短的链路长度时候,重新进行标记,直到到达源,从而得出最短的路径,每个节点都向它的邻居节点发送到所有节点的估算值


    这是Dijkstra算法的收敛图,具体过程有点相似Bell-man。

    首先还是从根(也就是目标)出发,根标记为0,其他节点标记为∞,然后按照标号最小的走,比如第一步2最小,然后从2往前走,其相邻节点原来是5,现在由于2+2=4,故更新下,然后再比较所有节点里面,标记最小的是3,然后从3走,发现11,大了,然后返回最小的4继续走,这样一路一路从最小标记的节点往相邻走,最终达到收敛。

    PS:这里还有点区别在于Bell-man一直从相邻节点往前走,然后进行比较,把节点的标记逐步最小往前推进,从前往后看,每一个节点都是相对最小的。而Dijkstra是每次从标记值最小的节点往前走,每次都是走最小,所以它走的顺序和Bell-man的顺序是不一样的。


    展开全文
  • 极大似然估计-大白话

    2021-04-11 09:56:56
    极大似然估计-大白话预备知识——排列组合极大似然估计预备...(一种使用最广泛的参数估计方法) 例子: 参考链接已知实验结果,求小球概率。 问题: 这个函数为什么是凸函数,为什么求导=0,就可找到使这个函数最

    预备知识——排列组合

    排列组合

    参考资料:
    如何通俗的解释排列公式和组合公式的含义?


    极大似然估计

    基本原理:
    根据实验结果 去 推测参数。(是一种使用最广泛的参数估计方法)
    例子:
    参考链接的已知实验结果,求小球概率。
    问题:
    这个函数为什么是凸函数,为什么求导=0,就可找到使这个函数最大的p?
    答案:
    一阶导数只有一个点=0,所以是极值点
    二阶导数<0,所以是凸函数
    参考:
    最大似然估计(Maximum likelihood estimation)(通过例子理解)


    预备知识——分布函数和密度函数区别

    注意分布函数和密度函数的区别,
    参考:《李永乐概率论辅导讲义2018》p27均匀分布,密度函数的积分就是分布函数

    例题

    例题1——高斯分布 求最大似然估计

    答案:
    注意:
    1、根据 分布函数 写密度函数 (求导即可
    2、根据 一个样本的密度函数 写 多个样本的似然函数 (就是从1到n带入,连乘即可
    3、 对似然函数 求个log,求对数不改变单调性,不改变极值点。 因为对数是单调递增的,所以输入大的值,输出还是大的值。 输入小的值,输出还是小的值。
    4、估计 单个参数时,求导数。 估计 多个参数求偏导
    5、令 导数等于零,求出参数即可。
    注意:需要 凸函数 且是驻点才能这样求解。有时候不是驻点
    意思是 极少数情况 最大值不一定是驻点)(参考——《李永乐概率论辅导讲义2018》p134 )
    参考资料:
    极大似然估计(Maximum Likelihood Estimation)

    最大似然估计-通过例子理解)

    极大似然估计(Maximum likelihood estimation)

    极大似然估计详解

    (机器学习)概率统计-极大似然估计MLE原理+python实现 【这个好】

    高斯分布参数的极大似然估计 【这个就是 考研公式的那样,就是把上边的公式,精炼一下,装x,装高手】

    例题二:

    《李永乐概率论辅导讲义2018》p141 例7.9
    注意:这题只有一个参数,所以是求导数,不是偏导数

    展开全文
  • 极大似然思想原理

    千次阅读 2015-08-14 19:39:00
    极大似然估计,顾名思义一种估计方法。既然一种估计方法,我们至少必须搞清楚几个问题:估计什么?需要什么前提或假设?...这一方法基于这样的思想:我们所估计的模型参数,要使得产生这个给定样本的可能性最大
  • LMS自适应滤波FPGA实现(一)

    千次阅读 2019-07-26 18:28:00
    文章目录LMS自适应滤波FPGA实现(一)原理-最优估计技术术语/模型定义和基本假设代价函数最优维纳估计实践-维纳-霍夫算法matlab仿真结果Widrow-Hoff最小二乘算法原理推导参数限定最后一些碎碎念结语参考文献 原理-...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 171
精华内容 68
关键字:

参数估计的基本原理是什么