精华内容
下载资源
问答
  • 数据归一处理方法 数据处理之标准/归一方法
    千次阅读
    2020-12-28 20:28:46

    主要是为了数据处理方便提出来的,把数据映射到0~1范围之内处理,更加便捷快速,应该归到数字信号处理范畴之内。 归一化方法(Normalization Method)

    1。把数变为(0,1)之间的小数 主要是为了数据处理方便提出来的,把数据映射到0~1范围之内处理,更加便捷快速,应该归到数字信号处理范畴之内。

    2 。把有量纲表达式变为无量纲表达式归一化是一种简化计算的方式,即将有量纲的表达式,经过变换,化为无量纲的表达式,成为纯量。

    比如,复数阻抗可以归一化书写:Z = R + jωL = R(1 + jωL/R) ,复数部分变成了纯数量了,没有量纲。

    标准化方法(Normalization Method)

    数据的标准化是将数据按比例缩放,使之落入一个小的特定区间。由于信用指标体系的各个指标度量单位是不同的,为了能够将指标参与评价计算,需要对指标进行规范化处理,通过函数变换将其数值映射到某个数值区间。

    关于神经网络(matlab)归一化的整理

    关于神经网络归一化方法的整理

    由于采集的各数据单位不一致,因而须对数据进行[-1,1]归一化处理,归一化方法主要有如下几种,供大家参考:(by james)

    1、线性函数转换,表达式如下:

    y=(x-MinValue)/(MaxValue-MinValue)

    说明:x、y分别为转换前、后的值,MaxValue、MinValue分别为样本的最大值和最小值。

    2、对数函数转换,表达式如下:

    y=log10(x)

    说明:以10为底的对数函数转换。

    3、反余切函数转换,表达式如下:

    y=atan(x)*2/PI

    归一化是为了加快训练网络的收敛性,可以不进行归一化处理

    归一化的具体作用是归纳统一样本的统计分布性。归一化在0-1之间是统计的概率分布,归一化在-1--+1之间是统计的坐标分布。归一化有同一、统一和合一的意思。无论是为了建模还是为了计算,首先基本度量单位要同一,神经网络是以样本在事件中的统计分别几率来进行训练(概率计算)和预测的,归一化是同一在0-1之间的统计概率分布;

    当所有样本的输入信号都为正值时,与第一隐含层神经元相连的权值只能同时增加或减小,从而导致学习速度很慢。为了避免出现这种情况,加快网络学习速度,可以对输入信号进行归一化,使得所有样本的输入信号其均值接近于0或与其均方差相比很小。

    归一化是因为sigmoid函数的取值是0到1之间的,网络最后一个节点的输出也是如此,所以经常要对样本的输出归一化处理。所以这样做分类的问题时用[0.9 0.1 0.1]就要比用[1 0 0]要好。

    但是归一化处理并不总是合适的,根据输出值的分布情况,标准化等其它统计变换方法有时可能更好。

    关于用premnmx语句进行归一化:

    premnmx语句的语法格式是:[Pn,minp,maxp,Tn,mint,maxt]=premnmx(P,T)

    其中P,T分别为原始输入和输出数据,minp和maxp分别为P中的最小值和最大值。mint和maxt分别为T的最小值和最大值。

    premnmx函数用于将网络的输入数据或输出数据进行归一化,归一化后的数据将分布在[-1,1]区间内。

    我们在训练网络时如果所用的是经过归一化的样本数据,那么以后使用网络时所用的新数据也应该和样本数据接受相同的预处理,这就要用到tramnmx。

    下面介绍tramnmx函数:

    [Pn]=tramnmx(P,minp,maxp)

    其中P和Pn分别为变换前、后的输入数据,maxp和minp分别为premnmx函数找到的最大值和最小值。

    (by terry2008)

    matlab中的归一化处理有三种方法

    1. premnmx、postmnmx、tramnmx

    2. restd、poststd、trastd

    3. 自己编程

    具体用那种方法就和你的具体问题有关了

    (by happy)

    pm=max(abs(p(i,:))); p(i,:)=p(i,:)/pm;

    for i=1:27

    p(i,:)=(p(i,:)-min(p(i,:)))/(max(p(i,:))-min(p(i,:)));

    end 可以归一到0 1 之间

    0.1+(x-min)/(max-min)*(0.9-0.1)其中max和min分别表示样本最大值和最小值。

    这个可以归一到0.1-0.9

    矩阵归一化

    归一化化定义:我是这样认为的,归一化化就是要把你需要处理的数据经过处理后(通过某种算法)限制在你需要的一定范围内。首先归一化是为了后面数据处理的方便,其次是保正程序运行时收敛加快。

    在matlab里面,用于归一化的方法共有三中,(1)premnmx、postmnmx、tramnmx(2)prestd、poststd、trastd(3)是用matlab语言自己编程。premnmx指的是归一到[-1 1],prestd归一到单位方差和零均值。(3)关于自己编程一般是归一到[0.1 0.9]

    为什么要用归一化呢?首先先说一个概念,叫做奇异样本数据,所谓奇异样本数据数据指的是相对于其他输入样本特别大或特别小的样本矢量。

    下面举例:

    m=[0.11 0.15 0.32 0.45 30;

    0.13 0.24 0.27 0.25 45];

    其中的第五列数据相对于其他4列数据就可以成为奇异样本数据(下面所说的网络均值bp)。奇异样本数据存在所引起的网络训练时间增加,并可能引起网络无法收敛,所以对于训练样本存在奇异样本数据的数据集在训练之前,最好先进形归一化,若不存在奇异样本数据,则不需要事先归一化。

    一个小程序:

    p=[1.3711 1.3802 1.3636 1.3598 1.3502 1.3404 1.3284 1.3160 1.3118 1.3032 1.2989 1.2945 1.2923 1.2923 1.2856 1.2788 1.2742 1.2672 1.2577 1.2279 1.1903 1.0864 0.9956 ];t=[0 1.38 1.68 1.98 2.08 2.23 2.53 2.83 2.93 3.13 3.23 3.33 3.43 3.53 3.63 3.73 3.83 3.93 4.03 4.13 4.23 4.33 4.43];u=p;tt=t;p=(p-min(p))/(max(p)-min(p));%g归一化t=(t-min(t))/(max(t)-min(t));net=newff(minmax(p),[23 1],{'tansig' 'purelin'},'traingdx');net.trainParam.epochs=1000;net.trainParam.goal=0.001;net.trainParam.show=10;net.trainParam.lr=0.05;[net,tr,Y,E]=train(net,p,t);a=sim(net,p);out=a*(max(tt)-min(tt))+min(tt);%反归一化x=u;y=tt;figure(1)plot(x,y,'k*',x,y,'-k',u,out,'ko')title('70°EPDM的压缩永久变形')legend('*试验数据 o预测结果')xlabel('压缩变形保持率')ylabel('时间的对数log10(t)')grid on

    更多相关内容
  • 从线性到非线性模型-对数线性模型

    千次阅读 2018-08-25 17:41:30
    线性到非线性模型 1、线性回归,岭回归,Lasso回归,局部加权线性回归 2、logistic回归,softmax回归,最大熵模型 3、广义线性模型 4、Fisher线性判别和线性感知机 5、三层...

    从线性到非线性模型

    1、线性回归,岭回归,Lasso回归,局部加权线性回归
    2、logistic回归,softmax回归,最大熵模型
    3、广义线性模型
    4、Fisher线性判别和线性感知机
    5、三层神经网络
    6、支持向量机

    code: https://github.com/myazi/myLearn

    二、Logistic回归和SoftMax回归,最大熵模型

    一、Logistic回归

    分类问题可以看作是在回归函数上的一个分类。一般情况下定义二值函数,然而二值函数不易优化,一般采用sigmoid函数平滑拟合(当然也可以看作是一种软划分,概率划分):从函数图像我们能看出,该函数有很好的特性,适合二分类问题。至于为何选择Sigmoid函数,后面可以从广义线性模型推导出Sigmoid函数。

    逻辑回归可以看作是在线性回归的基础上构建的分类模型,理解的角度有多种,最直接的理解是考虑逻辑回归是将线性回归值离散化。即一个二分类问题如下:(二值函数)

    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split}…

    sigmoid函数

    g ( z ) = 1 1 + e − z , g ‘ ( z ) = g ( z ) ( 1 − g ( z ) ) g(z)=\frac{1}{1+e^{-z}},g^{‘}(z)=g(z)(1-g(z)) g(z)=1+ez1,g(z)=g(z)(1g(z))

    二分类问题属于一种硬划分,即是与否的划分,而sigmoid函数则将这种硬划分软化,以一定的概率属于某一类(且属于两类的加和为1)。Sigmoid函数将线性回归值映射到 [ 0 , 1 ] [0,1] [0,1]区间,从函数图像我们能看出,该函数有很好的特性,适合二分类问题。 因此逻辑回归模型如下:

    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split}…
    这里对于目标函数的构建不再是最小化函数值与真实值的平方误差了,按分类原则来讲最直接的损失因该是0-1损失,即分类正确没有损失,分类错误损失计数加1。但是0-1损失难以优化,存在弊端。结合sigmoid函数将硬划分转化为概率划分的特点,采用概率$h_{\theta}(x^{(i)}) $的对数损失(概率解释-N次伯努利分布加最大似然估计),其目标函数如下:
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split} …

    同样采用梯度下降的方法有:
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split} …
    又:
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split} …
    所以有:
    θ j = θ j − α ( y ( i ) − h θ ( x ( i ) ) ) x \theta_{j}=\theta_{j}-\alpha \left(y^{(i)}-h_{\theta}(x^{(i)})\right)x θj=θjα(y(i)hθ(x(i)))x

    概率解释

    逻辑回归的概率解释同线性回归模型一致,只是假设不再是服从高斯分布,而是 p ( y ∣ x ; θ ) p\left ( y|x;\theta \right ) p(yx;θ)服从0-1分布,由于 ,假设随机变量y服从伯努利分布是合理的 。即:
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split} …
    所以最大化似然估计有:
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split} …

    logistic采用对数损失原因

    采用对数损失的原因有二:

    ​ 1)从概率解释来看,多次伯努利分布是指数的形式。由于最大似然估计导出的结果是概率连乘,而概率(sigmoid函数)恒小于1,为了防止计算下溢,取对数将连乘转换成连加的形式,而且目标函数和对数函数具备单调性,取对数不会影响目标函数的优化值。

    ​ 2)从对数损失目标函数来看,取对数之后在求导过程会大大简化计算量。

    二、SoftMax回归

    Softmax回归可以看作是Logistic回归在多分类上的一个推广。考虑二分类的另一种表示形式:

    [ k 1 , 1 − k 1 ] → [ k 1 k 2 ] \left [ k_{1},1-k_{1} \right ]\rightarrow \begin{bmatrix} k_{1}\\ k_{2} \end{bmatrix} [k1,1k1][k1k2]
    当logistic回归采用二维表示的话,那么其损失函数如下:
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split} …
    其中,在逻辑回归中两类分别为 k 1 k_{1} k1 1 − k 1 1-k_{1} 1k1,二在softmax中采用 k 1 , k_{1}, k1 k 2 k_{2} k2两个随机变量组成二维向量表示,当然隐含约束 k 1 + k 2 = 1 k_{1}+k_{2}=1 k1+k2=1.为了更好的表示多分类问题,将 y ∈ { 1 , 2 , . . K } y\in \left \{ 1,2,..K \right \} y{1,2,..K}(不一定理解为y的取值为k,更应该理解为y可以取k类)多分类问题进行如下表示。
    T ( k ) = [ 0 0 . 1 . 0 ] T(k)=\begin{bmatrix} 0\\ 0\\ .\\ 1\\ .\\ 0 \end{bmatrix} T(k)=00.1.0
    其中向量的第k位为1,其他位为0,也就是当 y = k y=k y=k 时将其映射成向量时对应第k位为1。采用多维表示之后,那么对于每一维就变成了一个单独的二分类问题了,所以softmax函数形式如下:
    h θ ( x ( i ) ) = 1 ∑ k = 1 K e x p ( θ k T x ( i ) ) [ e x p ( θ k T x ( i ) ) e x p ( θ k T x ( i ) ) . e x p ( θ k T x ( i ) ) ] h_{\theta}(x^{(i)})=\frac{1}{\sum_{ k=1}^{K}exp\left ( \theta _{k}^{T}x^{(i)} \right )}\begin{bmatrix} exp\left ( \theta _{k}^{T}x^{(i)} \right )\\ exp\left ( \theta _{k}^{T}x^{(i)} \right )\\ .\\ exp\left ( \theta _{k}^{T}x^{(i)} \right ) \end{bmatrix} hθ(x(i))=k=1Kexp(θkTx(i))1exp(θkTx(i))exp(θkTx(i)).exp(θkTx(i))
    其中函数值是一个 K K K维的向量,同样采用对数损失(多项式分布和最大似然估计),目标函数形式是logistic回归的多维形式。
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split} …
    其中 y i k y^{ik} yik表示第 i i i个样本的标签向量化后第k维的取值0或者1.可以看出Softmax的损失是对每一类计算其概率的对数损失,而logistic回归是计算两类的回归,其本质是一样。Logistic回归和Softmax回归都是基于线性回归的分类模型,两者无本质区别,都是从二项分布和多项式分布结合最大对数似然估计。只是Logistic回归常用于二分类,而Softmax回归常用于多分类。而且Logistic回归在考虑多分类时只考虑n-1类。

    概率解释

    ​ 二分类与多分类可以看作是N次伯努利分布的二项分布到多项分布的一个推广,概率解释同Logistic回归一致。详细解释放到广义线性模型中。

    二分类转多分类思想

    对于多分类问题,同样可以借鉴二分类学习方法,在二分类学习基础上采用一些策略以实现多分类,基本思路是“拆解法”,假设N个类别 C 1 , C 2 , . C i . , C n C_{1},C_{2},.C_{i}.,C_{n} C1,C2,.Ci.,Cn,经典的拆分算法有“一对一”,“一对多”,“多对多”,

    一对一的基本思想是从所有类别中选出两类来实现一个两分类学习器,即学习出 C N 2 = N ( N − 1 ) / 2 C_{N}^{2}=N(N-1)/2 CN2=N(N1)/2个二分类器,然后对新样本进行预测时,对这 C N 2 C_{N}^{2} CN2个分类器进行投票最终决定属于那一类。

    一对多的基本思想是把所有类别进行二分类,即属于 C i C_{i} Ci类和非 C i C_{i} Ci两类,这样我们就需要N个分类器,然后对新样本进行预测时,与每一个分类器比较,最终决定属于哪一类。这其实就是Softmax的思想,也是SVM多分类的思想。

    //多对多的基本思想是

    三、最大熵模型

    ​ 很奇怪,为什么会把最大熵模型放到这,原因很简单,它和Logistic回归和SoftMax回归实在是惊人的相似,同属于对数线性模型。

    熵的概念

    这里写图片描述

    信息熵:熵是一种对随机变量不确定性的度量,不确定性越大,熵越大。若随机变量退化成定值,熵为0。均匀分布是“最不确定”的分布 。

    假设离散随机变量X的概率分布为 P ( X ) P(X) P(X),则其熵为:
    H ( X ) = − ∑ x P ( x ) l o g P ( x ) H(X)=-\sum_{x}P(x)logP(x) H(X)=xP(x)logP(x)
    其中熵满足不等式 0 ≤ H ( P ) ≤ l o g ∣ X ∣ 0\leq H(P) \leq log|X| 0H(P)logX

    联合熵:对于多个随机变量的不确定性可以用联合熵度量

    假设离散随机变量 X , Y X,Y X,Y的联合概率分布为 P ( X , Y ) P(X,Y) P(X,Y),则其熵为:
    H ( X , Y ) = − ∑ x ∑ y P ( x , y ) l o g P ( x , y ) H(X,Y)=-\sum_{x}\sum_{y}P(x,y)logP(x,y) H(X,Y)=xyP(x,y)logP(x,y)
    条件熵:在给定条件下描述随机变量的不确定性

    假设离散随机变量 X , Y X,Y X,Y,在给定 Y Y Y的条件下 X X X的不确定性为条件熵H(X|Y),也就等于 H ( X , Y ) − H ( Y ) H(X,Y)-H(Y) H(X,Y)H(Y)
    H ( X ∣ Y ) = − ∑ x , y P ( x , y ) l o g ( P ( x ∣ y ) ) H(X|Y)=-\sum_{x,y}P(x,y)log(P(x|y)) H(XY)=x,yP(x,y)log(P(xy))
    互信息:衡量两个随机变量相关性的大小 I ( X , Y ) = H ( X ) + H ( Y ) − H ( X , Y ) I(X,Y)=H(X)+H(Y)-H(X,Y) I(X,Y)=H(X)+H(Y)H(X,Y)
    I ( X , Y ) = − ∑ x , y P ( x , y ) l o g P ( x , y ) P ( x ) P ( y ) I(X,Y)=-\sum_{x,y}P(x,y)log\frac{P(x,y)}{P(x)P(y)} I(X,Y)=x,yP(x,y)logP(x)P(y)P(x,y)
    相对熵(KL散度):衡量对于同一个随机变量两个概率分布 p ( x ) , q ( x ) p(x),q(x) p(x),q(x)的差异性
    D ( p ∣ ∣ q ) = ∑ x p ( x ) l o g p ( x ) q ( x ) = E p ( x ) l o g p ( x ) q ( x ) D(p||q)=\sum_{x}p(x)log\frac{p(x)}{q(x)}=E_{p(x)}log\frac{p(x)}{q(x)} D(pq)=xp(x)logq(x)p(x)=Ep(x)logq(x)p(x)
    有互信息和相对熵的定义有下式:
    I ( X , Y ) = D ( P ( X , Y ) ∣ ∣ P ( X ) P ( Y ) ) I(X,Y)=D(P(X,Y)||P(X)P(Y)) I(X,Y)=D(P(X,Y)P(X)P(Y))
    关于熵的介绍就到此,不细究,虽然上面的这些定义在机器学习中都会遇到,不过后面涉及到的主要还是熵和条件熵。

    最大熵模型

    最大熵原理是概率模型学习中的一个准则。最大熵原理认为,学习概率模型时,在所有可能的概率模型分布中(满足所有条件下),熵最大的模型是最好的模型。熵最大即为最均匀的分布,从某种角度讲 均匀分布总是符合我们理解的损失风险最小,也就是“不要不所有的鸡蛋放到一个篮子里,均匀的放置”。

    给定训练集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) . . ( x m , y m ) } T=\{ (x_{1},y_{1}),(x_{2},y_{2})..(x_{m},y_{m})\} T={(x1,y1),(x2,y2)..(xm,ym)},假设 X ∈ χ ⊆ R n X \in \chi \subseteq R^{n} XχRn表示输入, y ∈ ϕ y\in \phi yϕ表示输出,分类模型是一个以条件概率分布 P ( Y ∣ X ) P(Y|X) P(YX)输出 Y Y Y,也就是说在满足条件的所有可能集中,条件熵 P ( Y ∣ X ) P(Y|X) P(YX)最大的模型即为最好的模型。其中条件为隐藏在数据的期望。

    一般来讲,最大熵模型常用于处理离散化数据集,定义随机变量 X , Y X,Y X,Y的特征模板,从数据中统计他们的期望作为最大熵模型的条件

    特征函数:
    f ( x , y ) = { 1 , x , y 满 足 某 一 事 实 0 , 否 则 f(x,y)=\left\{\begin{matrix} 1,x,y满足某一事实\\ 0,否则 \end{matrix}\right. f(x,y)={1xy0
    约束条件:对于任意的特征函数 f f f,我们可以统计其在数据中的经验分布 P ~ ( x , y ) \widetilde{P}(x,y) P (x,y)的期望
    E p ~ ( f ) = ∑ x , y P ~ ( x , y ) f ( x , y ) E_{\widetilde{p}}(f)=\sum_{x,y}\widetilde{P}(x,y)f(x,y) Ep (f)=x,yP (x,y)f(x,y)
    特征函数 f f f关于模型 P ( Y ∣ X ) P(Y|X) P(YX)和先验 P ~ ( X ) \widetilde{P}(X) P (X)的期望
    E p ( f ) = ∑ x , y P ~ ( x ) P ( y ∣ x ) f ( x , y ) E_{p}(f)=\sum_{x,y}\widetilde{P}(x)P(y|x)f(x,y) Ep(f)=x,yP (x)P(yx)f(x,y)
    所以,满足约束条件的模型集合为:
    Ω ≡ { P ∈ P ∣ E p ( f i ) = E p ~ ( f i ) , i = 1.. n } \Omega \equiv \{ P\in \boldsymbol{P}| E_{p}(f_{i})=E_{\widetilde{p}}(f_{i}),i=1..n\} Ω{PPEp(fi)=Ep (fi),i=1..n}
    因此最大熵模型的形式化表示如下:
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split}…
    由拉格让日乘子法,引入拉格让日乘子,定义拉格让日函数:
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split} …
    根据拉格朗日乘子法, L ( P ) ≥ L ( P , w ) L(P) \geq L(P,w) L(P)L(P,w),当且仅当满足拉格朗日乘子法的所有必要条件等式成立,原问题也就是一个最小化最大问题
    min ⁡ P ∈ C max ⁡ w L ( P , w ) \min_{P \in C}\max_{w}L(P,w) PCminwmaxL(P,w)
    对偶问题是:
    max ⁡ w min ⁡ P ∈ C L ( P , w ) \max_{w} \min_{P \in C}L(P,w) wmaxPCminL(P,w)
    求解对偶问题,第一步最小化内部 min ⁡ P ∈ C L ( P , w ) \min_{P \in C}L(P,w) minPCL(P,w) min ⁡ P ∈ C L ( P , w ) \min_{P \in C}L(P,w) minPCL(P,w)是我们需要求解的模型,也是关于 w w w的函数。将模型的最优解记为 P w P_{w} Pw
    P w = a r g max ⁡ P ∈ C L ( P , w ) = P w ( y ∣ x ) P_{w}=arg\max_{P \in C}L(P,w)=P_{w}(y|x) Pw=argPCmaxL(P,w)=Pw(yx)
    那么外层最大化目标函数为:
    max ⁡ w Φ ( w ) Φ ( w ) = min ⁡ p ∈ C L ( P , w ) = L ( P w , w ) \max_{w}\Phi(w)\\ \Phi(w)=\min_{p \in C}L(P,w)=L(P_{w},w) wmaxΦ(w)Φ(w)=pCminL(P,w)=L(Pw,w)
    为了求解 P w ( y ∣ x ) P_{w}(y|x) Pw(yx),根据KKT条件对 P ( y ∣ x ) P(y|x) P(yx)求偏导:
    KaTeX parse error: No such environment: equation at position 8: \begin{̲e̲q̲u̲a̲t̲i̲o̲n̲}̲ \begin{split} …
    求解得:
    P ( y ∣ x ) = e x p ( ∑ i w i f i ( x , y ) + w 0 − 1 ) = ( e x p ∑ i w i f i ( x , y ) ) e x p ( 1 − w 0 ) P(y|x)=exp\left( \sum_{i} w_{i}f_{i}(x,y) +w_{0}-1 \right)=\frac{ \left(exp \sum_{i} w_{i}f_{i}(x,y)\right)}{exp(1-w_{0})} P(yx)=exp(iwifi(x,y)+w01)=exp(1w0)(expiwifi(x,y))
    这里,虽然我们不知道 w 0 w_{0} w0,但是由于 ∑ y P ( y ∣ x ) = 1 \sum_{y}P(y|x)=1 yP(yx)=1,所以分母一定是对 y y y的所有可能的归一化因子
    P w ( y ∣ x ) = 1 z w ( x ) ( e x p ∑ i w i f i ( x , y ) ) z w ( x ) = ∑ y e x p ( ∑ i w i f i ( x , y ) ) P_{w}(y|x)=\frac{1}{z_{w}(x)} \left(exp \sum_{i} w_{i}f_{i}(x,y)\right)\\ z_{w}(x)=\sum_{y}exp(\sum_{i}w_{i}f_{i}(x,y)) Pw(yx)=zw(x)1(expiwifi(x,y))zw(x)=yexp(iwifi(x,y))
    到此,内部最小化求解得到了 P w ( y ∣ x ) P_{w}(y|x) Pw(yx),回到外部目标 max ⁡ w Φ ( w ) \max_{w}\Phi(w) maxwΦ(w),将 P w ( y ∣ x ) P_{w}(y|x) Pw(yx)代回拉格朗日函数有:
    Φ ( w ) = ∑ x , y P ~ ( x ) P w ( y ∣ x ) l o g P w ( y ∣ x ) + ∑ i = 1 n w i ( ∑ x , y P ~ ( x , y ) f ( x , y ) − ∑ x , y P ~ ( x ) P w ( y ∣ x ) f ( x , y ) ) = ∑ x , y P ~ ( x , y ) ∑ i = 1 n w i f i ( x , y ) + ∑ x , y P ~ ( x ) P w ( y ∣ x ) ( l o g P w ( y ∣ x ) − ∑ i = 1 n w i f i ( x , y ) ) = ∑ x , y P ~ ( x , y ) ∑ i = 1 n w i f i ( x , y ) + ∑ x , y P ~ ( x ) P w ( y ∣ x ) l o g Z w ( x ) = ∑ x , y P ~ ( x , y ) ∑ i = 1 n w i f i ( x , y ) + ∑ x P ~ ( x ) l o g Z w ( x ) ∑ y P w ( y ∣ x ) = ∑ x , y P ~ ( x , y ) ∑ i = 1 n w i f i ( x , y ) + ∑ x P ~ ( x ) l o g Z w ( x ) \begin{aligned} \Phi(w) &=\sum_{x,y}\widetilde{P}(x)P_w(y|x)logP_w(y|x) + \sum^n_{i=1}w_i\left (\sum_{x,y}\widetilde{P}(x ,y)f(x,y) -\sum_{x,y}\widetilde{P}(x)P_w(y|x)f(x,y) \right )\\ &= \sum_{x,y} \widetilde{P}(x,y)\sum_{i=1}^nw_if_i(x,y) +\sum_{x,y}\widetilde{P}(x)P_w(y|x)\left (logP_w(y|x) - \sum_{i=1}^nw_if_i(x,y) \right) \\ &=\sum_{x,y} \widetilde{P}(x,y)\sum_{i=1}^nw_if_i(x,y) +\sum_{x,y}\widetilde{P}(x)P_w(y|x)logZ_w(x)\\ &=\sum_{x,y} \widetilde{P}(x,y)\sum_{i=1}^nw_if_i(x,y) +\sum_x\widetilde{P}(x)logZ_w(x)\sum_yP_w(y|x)\\ &=\sum_{x,y} \widetilde{P}(x,y)\sum_{i=1}^nw_if_i(x,y) +\sum_x\widetilde{P}(x)logZ_w(x)\\ \end{aligned} Φ(w)=x,yP (x)Pw(yx)logPw(yx)+i=1nwi(x,yP (x,y)f(x,y)x,yP (x)Pw(yx)f(x,y))=x,yP (x,y)i=1nwifi(x,y)+x,yP (x)Pw(yx)(logPw(yx)i=1nwifi(x,y))=x,yP (x,y)i=1nwifi(x,y)+x,yP (x)Pw(yx)logZw(x)=x,yP (x,y)i=1nwifi(x,y)+xP (x)logZw(x)yPw(yx)=x,yP (x,y)i=1nwifi(x,y)+xP (x)logZw(x)
    因此, max ⁡ w Φ ( w ) \max_{w} \Phi(w) maxwΦ(w)的最优解为:
    w ∗ = a r g max ⁡ w Φ ( w ) w^* = arg \max_w \Phi(w) w=argwmaxΦ(w)
    代回 P w ( y ∣ x ) P_{w}(y|x) Pw(yx),我们可以得到最终的分类模型,同样我们发现最大熵模型也是一个对数线性模型。

    概率解释:

    已知训练集的经验概率分布 P ~ ( x , y ) \widetilde{P}(x,y) P (x,y),条件概率分布 P ( y ∣ x ) P(y|x) P(yx)的对数似然函数为:
    L P ~ ( P w ) = l o g ∏ x , y P ( y ∣ x ) P ~ ( x , y ) = ∑ x , y P ~ ( x , y ) l o g P ( y ∣ x ) L_{\widetilde{P}}(P_w) = log\prod_{x,y}P(y|x)^{\widetilde{P}(x,y)} = \sum_{x,y}\widetilde{P}(x,y)logP(y|x) LP (Pw)=logx,yP(yx)P (x,y)=x,yP (x,y)logP(yx)
    其中,我们发现对数似然函数与条件熵的形式一致,最大熵模型目标函数前面有负号(这与最大化对数似然函数完全相反),同时最大熵模型中有约束条件。也正是因为约束条件,我们将原问题转化为对偶问题后发现,在满足约束条件的对偶函数的极大化等价于最大化对数似然函数。

    当条件概率 P ( y ∣ x ) P(y|x) P(yx)满足约束条件,在对偶问题求解过程中我们有:
    P w ( y ∣ x ) = 1 z w ( x ) ( e x p ∑ i w i f i ( x , y ) ) z w ( x ) = ∑ y e x p ( ∑ i w i f i ( x , y ) ) P_{w}(y|x)=\frac{1}{z_{w}(x)} \left(exp \sum_{i} w_{i}f_{i}(x,y)\right)\\ z_{w}(x)=\sum_{y}exp(\sum_{i}w_{i}f_{i}(x,y)) Pw(yx)=zw(x)1(expiwifi(x,y))zw(x)=yexp(iwifi(x,y))
    代入到对数似然函数,同样有:
    L P ~ ( P w ) = ∑ x , y P ~ ( x , y ) l o g P ( y ∣ x ) = ∑ x , y P ~ ( x , y ) ( ∑ i = 1 n w i f i ( x , y ) − l o g Z w ( x ) ) = ∑ x , y P ~ ( x , y ) ∑ i = 1 n w i f i ( x , y ) − ∑ x , y P ~ ( x , y ) l o g Z w ( x ) = ∑ x , y P ~ ( x , y ) ∑ i = 1 n w i f i ( x , y ) − ∑ x P ~ ( x ) l o g Z w ( x ) \begin{aligned} L_{\widetilde{P}}(P_w) &= \sum_{x,y}\widetilde{P}(x,y)logP(y|x)\\ &= \sum_{x,y}\widetilde{P}(x,y)\left ( \sum_{i=1}^n w_if_i(x,y) -logZ_w(x)\right )\\ &= \sum_{x,y}\widetilde{P}(x,y)\sum_{i=1}^n w_if_i(x,y) - \sum_{x,y}\widetilde{P}(x,y)logZ_w(x)\\ &= \sum_{x,y}\widetilde{P}(x,y)\sum_{i=1}^n w_if_i(x,y) - \sum_{x}\widetilde{P}(x)logZ_w(x)\\ \end{aligned} LP (Pw)=x,yP (x,y)logP(yx)=x,yP (x,y)(i=1nwifi(x,y)logZw(x))=x,yP (x,y)i=1nwifi(x,y)x,yP (x,y)logZw(x)=x,yP (x,y)i=1nwifi(x,y)xP (x)logZw(x)
    最后,我们再来看对偶函数表达式,我们发现,第一项其实是 X , Y X,Y X,Y的联合熵 H ( X , Y ) H(X,Y) H(X,Y),第二项是X的信息熵 H ( X ) H(X) H(X),回看熵的示意图,我们发现,我们最大化的目标还是条件熵 H ( Y ∣ X ) H(Y|X) H(YX)

    这里写图片描述

    下面再来对比下Logistic回归,SoftMax回归,最大熵模型

    1)同属于对数线性模型

    2)Logistic回归和SoftMax回归都基于条件概率 P ( y ∣ x ) P(y|x) P(yx)满足一个伯努利分布,N重伯努利分布,而最大熵模型以期望为准,没有该假设

    3)由于都采用线性模型,三者都假设特征之间是独立的

    最大熵模型的优化问题

    最大熵模型从拉格朗日乘子法最大化对偶函数,还是从最大化对数似然函数,其目标函数如下:
    L P ~ ( P w ) = ∑ x , y P ~ ( x , y ) ∑ i = 1 n w i f i ( x , y ) − ∑ x P ~ ( x ) l o g Z w ( x ) L_{\widetilde{P}}(P_w)= \sum_{x,y}\widetilde{P}(x,y)\sum_{i=1}^n w_if_i(x,y) - \sum_{x}\widetilde{P}(x)logZ_w(x)\\ LP (Pw)=x,yP (x,y)i=1nwifi(x,y)xP (x)logZw(x)
    常用的梯度优化算法都可以,另外对于最大熵模型也有专门的算法有GIS IIS 算法 。

    展开全文
  • 跟着博主的脚步,每天进步一点点本文介绍对数线性分类模型,在线性模型的基础上通过复合函数(sigmoid,softmax,entropy )将其映射到概率...

    跟着博主的脚步,每天进步一点点

    本文介绍对数线性分类模型,在线性模型的基础上通过复合函数(sigmoid,softmax,entropy )将其映射到概率区间,使用对数损失构建目标函数。首先以概率的方式解释了logistic回归为什么使用sigmoid函数和对数损失,然后将二分类扩展到多分类,导出sigmoid函数的高维形式softmax函数对应softmax回归,最后最大熵模型可以看作是softmax回归的离散型版本,logistic回归和softmax回归处理数值型分类问题,最大熵模型对应处理离散型分类问题。

    作者 | 文杰

    编辑 | yuquanle

    Logistic回归

    A、Logistic回归

    分类问题可以看作是在回归函数上的一个分类。一般情况下定义二值函数,然而二值函数构成的损失函数非凸,一般采用sigmoid函数平滑拟合(当然也可以看作是一种软划分,概率划分):从函数图像我们能看出,该函数有很好的特性,适合二分类问题。至于为何选择Sigmoid函数,后面可以从广义线性模型导出为什么是Sigmoid函数。

    逻辑回归可以看作是在线性回归的基础上构建的分类模型,理解的角度有多种(最好的当然是概率解释和最小对数损失),而最直接的理解是考虑逻辑回归是将线性回归值离散化。即一个二分类问题(二值函数)如下:

    Sigmoid函数:

    0-1损失的二分类问题属于一种硬划分,即是与否的划分,而sigmoid函数则将这种硬划分软化,以一定的概率属于某一类(且属于两类的加和为1)。

    Sigmoid函数将线性回归值映射到  的概率区间,从函数图像我们能看出,该函数有很好的特性,适合二分类问题。 因此逻辑回归模型如下:

    这里对于目标函数的构建不再是最小化函数值与真实值的平方误差了,按分类原则来讲最直接的损失因该是0-1损失,即分类正确没有损失,分类错误损失计数加1。但是0-1损失难以优化,存在弊端。结合sigmoid函数将硬划分转化为概率划分的特点,采用概率 的对数损失(概率解释-N次伯努利分布加最大似然估计),其目标函数如下:

    同样采用梯度下降的方法有:

    又:

    所以有:

    B、概率解释

    逻辑回归的概率解释同线性回归模型一致,只是假设不再是服从高斯分布,而是 服从0-1分布,由于 ,假设随机变量y服从伯努利分布是合理的 。即:

    所以最大化似然估计有:

    logistic采用对数损失(对数似然函数)原因:

    1) 从概率解释来看,多次伯努利分布是指数的形式。由于最大似然估计导出的结果是概率连乘,而概率(sigmoid函数)恒小于1,为了防止计算下溢,取对数将连乘转换成连加的形式,而且目标函数和对数函数具备单调性,取对数不会影响目标函数的优化值。

    2)从对数损失目标函数来看,取对数之后在求导过程会大大简化计算量。

    Softmax回归

    A、Softmax回归

    Softmax回归可以看作是Logistic回归在多分类上的一个推广。考虑二分类的另一种表示形式:

    当logistic回归采用二维表示的话,那么其损失函数如下:

    其中,在逻辑回归中两类分别为 二在softmax中采用 两个随机变量组成二维向量表示,当然隐含约束 .为了更好的表示多分类问题,将 (不一定理解为 的取值为 ,更应该理解为 可以取 类)多分类问题进行如下表示:

    其中向量的第 位为1,其他位为 ,也就是当  时将其映射成向量时对应第 位为 。采用多维向量表示之后,那么对于每一维就变成了一个单独的二分类问题了,所以softmax函数形式如下:

    其中函数值是一个 维的向量,同样采用对数损失(N元伯努利分布和最大似然估计),目标函数形式是logistic回归的多维形式。

    其中 表示第 个样本的标签向量化后第 维的取值 或者 .可以看出Softmax的损失是对每一类计算其概率的对数损失,而logistic回归是计算两类的回归,其本质是一样。Logistic回归和Softmax回归都是基于线性回归的分类模型,两者无本质区别,都是从伯努利分结合最大对数似然估计。只是Logistic回归常用于二分类,而Softmax回归常用于多分类。而且Logistic回归在考虑多分类时只考虑 类。

    概率解释(求导推导):

    二分类与多分类可以看作是二元伯努利分布到多元伯努利分布的一个推广,概率解释同Logistic回归一致。详细解释放到广义线性模型中。

    B、二分类转多分类思想

    对于多分类问题,同样可以借鉴二分类学习方法,在二分类学习基础上采用一些策略以实现多分类,基本思路是“拆解法”,假设N个类别 ,经典的拆分算法有“一对一”,“一对多”,“多对多”,

    一对一的基本思想是从所有类别中选出两类来实现一个两分类学习器,即学习出 个二分类器,然后对新样本进行预测时,对这  个分类器进行投票最终决定属于那一类。

    一对多的基本思想是把所有类别进行二分类,即属于 类和非 两类,这样我们就需要N个分类器,然后对新样本进行预测时,与每一个分类器比较,最终决定属于哪一类。这其实就是Softmax的思想,也是SVM多分类的思想。

    最大熵模型

    很奇怪,为什么会把最大熵模型放到这,原因很简单,它和Logistic回归和SoftMax回归实在是惊人的相似,同属于对数线性模型。

    A、熵的概念

    信息熵:熵是一种对随机变量不确定性的度量,不确定性越大,熵越大。若随机变量退化成定值,熵为0。均匀分布是“最不确定”的分布 。

    假设离散随机变量X的概率分布为 ,则其熵为:

    其中熵满足不等式 取值数。

    联合熵:对于多个随机变量的不确定性可以用联合熵度量。

    假设离散随机变量 的联合概率分布为 ,则其熵为:

    条件熵:在给定条件下描述随机变量的不确定性。

    假设离散随机变量 ,在给定 的条件下 的不确定性为条件熵H(X|Y),也就等于

    互信息:衡量两个随机变量相关性的大小。

    相对熵(KL散度):衡量对于同一个随机变量两个概率分布 的差异性。

    有互信息和相对熵的定义有下式:

    关于熵的介绍就到此,不细究,虽然上面的这些定义在机器学习中都会遇到,不过后面涉及到的主要还是熵和条件熵,互信息。

    B、最大熵模型

    最大熵原理是概率模型学习中的一个准则。最大熵原理认为,学习概率模型时,在所有可能的概率模型分布中(满足所有条件下),熵最大的模型是最好的模型。熵最大即为最均匀的分布,从某种角度讲均匀分布总是符合我们理解的损失风险最小,也就是“不要不所有的鸡蛋放到一个篮子里,均匀的放置”。

    给定训练集:

    假设 表示输入, 表示输出,分类模型是一个以条件概率分布 输出 ,也就是说在满足条件的所有可能集中,条件熵 最大的模型即为最好的模型。其中条件为隐藏在数据的期望。

    一般来讲,最大熵模型常用于处理离散化数据集,定义随机变量 的特征模板,从数据中统计他们的期望作为最大熵模型的条件

    特征函数:

    满足某一事实 否则

    约束条件:对于任意的特征函数 ,我们可以统计其在数据中的经验分布 的期望:

    特征函数 关于模型 和先验 的条件期望:

    所以,满足约束条件的模型集合为:

    因此最大熵模型的形式化表示如下:

    由拉格让日乘子法,引入拉格让日乘子,定义拉格让日函数:

    根据拉格朗日乘子法, ,当且仅当满足拉格朗日乘子法的所有必要条件等式成立,原问题也就是一个最小化最大问题:

    里层是 最大化 ,外层的 最小化

    对偶问题是:

    求解对偶问题,第一步最小化内部:

    是关于 的函数,最优解记为

    那么外层最大化目标函数为:

    为了求解 ,根据KKT条件对 求偏导:

    求解得:

    这里,虽然我们不知道 ,但是由于 ,所以分母一定是对 的所有可能的归一化因子:

    因此, 的最优解为:

    代回 ,我们可以得到最终的分类模型,同样我们发现最大熵模型也是一个对数线性模型。

    回顾对偶函数,内部最小化求解得到了 ,回到外部目标 ,将 代回拉格朗日函数有:

    C、概率解释

    已知训练集的经验概率分布 ,条件概率分布 的对数似然函数为:

    其中,我们发现对数似然函数与条件熵的形式一致,最大熵模型目标函数前面有负号(这与最大化对数似然函数完全相反),同时最大熵模型中有约束条件。也正是因为约束条件,我们将原问题转化为对偶问题后发现,在满足约束条件的对偶函数的极大化等价于最大化对数似然函数。

    当条件概率 满足约束条件,在对偶问题求解过程中我们有:

    代入到对数似然函数,同样有:

    最后,我们再来看对偶函数表达式,我们发现,第一项其实是 的联合熵 ,第二项是 的信息熵 ,回看熵的示意图,我们发现,我们的目标还是最大化条件熵

    下面再来对比下Logistic回归,SoftMax回归,最大熵模型:

    1)同属于对数线性模型。

    2)Logistic回归和SoftMax回归都基于条件概率 ,满足一个伯努利分布,N重伯努利分布;而最大熵模型以期望为准,没有该假设。

    3)由于都采用线性模型,三者都假设特征之间是独立的。

    最大熵模型的优化问题:

    最大熵模型从拉格朗日乘子法最大化对偶函数,还是从最大化对数似然函数,其目标函数如下:

    常用的梯度优化算法都可以,另外对于最大熵模型也有专门的算法有GIS IIS 算法 。

    代码实战

    A、Logistic回归

    int LogReg()
    {
        const char *file="data\\LogReg.txt";
        const string model="gradAscent";
        const double alpha=0.01;
        Matrix x;
        cout<<"loadData"<<endl;
        cout<<"----------------------"<<endl;
        x.LoadData(file);
        Matrix y;
        y=x.getOneCol(x.col-1);
        x.deleteOneCol(x.col-1);
    
        if(model=="gradAscent")
            gradAscent_Log(x,y);
        if(model=="stoGradAscent")
            stoGradAscent_Log(x,y);
    
        return 0;
    }
    
      int gradAscent_Log(Matrix x,Matrix y)  
          {
              if(y.col!=1)
              {
                  cout<<"logReg is two class"<<endl;
                  return -1;
              }
              Matrix weights(x.col,y.col,0.1,"T");
              Matrix xT = x.transposeMatrix();
      
              float alpha=0.01;///迭代步长
              float error=0;///记录错误率
              int iter=0;
              int i,j;
              Matrix z(y.row,y.col,0,"T");//最好确定矩阵的大小
              Matrix grad(x.col,y.col,0,"T");
              for(iter=0; iter<5000; iter++)
              {
                  z = x * weights;
                  for(i=0; i<z.row; i++)
                  {
                      z.data[i][0]=sigmoid(z.data[i][0]);
                  }
                  z = y - z;
                  error=0;
                  for(i=0; i<x.row; i++)///统计错误率
                      error+=z.data[i][0];
                  grad = xT * z;///计算负梯度方向
                  for(i=0; i<grad.row; i++)
                      grad.data[i][0]*= alpha;///负梯度方向与步长的乘积确定迭代值
                  weights = weights + grad;///往负梯度方向走一个步长
              }
      
              /**
              验证算法的正确性
              **/  
              int er1=0,er2=0;
              Matrix train=x * weights;
              cout<<"test"<<endl;
              for(i=0; i<y.row; i++)
              {
                  if(train.data[i][0]>0)
                  {
                      cout<<1-y.data[i][0]<<endl;
                      er1+=(1-y.data[i][0]);
                  }
                  else  
                  {
                      cout<<0-y.data[i][0]<<endl;
                      er2-=(0-y.data[i][0]);
                  }
              }
          }

    B、SoftMax回归

    int SoftMaxReg()
    {
        const char *file="data\\LogReg.txt";
        const string model="gradAscent";
        const double alpha=0.01;
        Matrix x;
        cout<<"loadData"<<endl;
        cout<<"----------------------"<<endl;
        x.LoadData(file);
        Matrix y;
        y=x.getOneCol(x.col-1);
        y=one_hot(y,2);
        x.deleteOneCol(x.col-1);
    
        if(model=="gradAscent")
            gradAscent_SoftMax(x,y);
        if(model=="stoGradAscent")
            stoGradAscent_SoftMax(x,y);
    
        return 0;
    }
    
    
      /**
          随机梯度下降与梯度下降法不同的是在负梯度方向的确定,梯度下降是根据所有的样本来确定负梯度方向,
          而随机梯度下降每次只看一个样本点来确定负梯度方向,虽然不完全可信,但随着迭代次数增加,同样收敛
            
     **/  
    int stoGradAscent_SoftMax(Matrix x,Matrix y)//随机梯度下降每一次选择m个样本进行求梯度下降方向,该代码中只选择一个样本进行求解梯度下降方向与数值
          {
              Matrix xOneRow(1,x.col,0,"T");
              Matrix xOneRowT(x.col,1,0,"T");
      
              Matrix weights(x.col,y.col,0.1,"T");
              Matrix z(1,y.col,0,"T");//最好确定矩阵的大小
              Matrix grad(x.col,y.col,0,"T");
              double zRowSum=0;
              double alpha=0.001;///步长
              double error;
              int i,j,k,iter;
              for(iter=0; iter<5000; iter++)
              {
                  for(i=0; i<x.row; i++)
                  {
                      xOneRow=x.getOneRow(i);///随机选择一个样本点,这里没有作随机选择,而是按序选择
                      z = xOneRow * weights;
                      zRowSum=0;
                      for(j=0;j<z.col;j++)
                      {
                          z.data[0][j]=sigmoid(z.data[0][j]);
                          zRowSum+=z.data[0][j];//求和
                      }
                      for(j=0;j<z.col;j++)
                      {
                          z.data[0][j]/=zRowSum;//归一化
                          if(iter%1000==0)
                              cout<<z.data[0][j] <<" s ";
                      }
                      if(iter%1000==0)
                          cout<<endl;
                      for(j=0;j<y.col;j++)
                      {
                          z.data[0][j]=y.data[i][j]-z.data[0][j];
                      }
                      xOneRowT = xOneRow.transposeMatrix();
                      grad = xOneRowT * z;///根据一样样本的预测误差来确定负梯度方向
                      for(k=0; k<grad.row;k++)
                      {
                          for(j=0;j<grad.col; j++)
                          {
                              grad.data[k][j]*= alpha;///负梯度方向与步长的乘积确定迭代值
                          }
                      }
                      weights = weights + grad; ///迭代
                  }
              }
              //验证算法的正确性
              /**
              验证算法的正确性
              **/  
              Matrix test=x * weights;
              cout<<"test"<<endl;
              for(i=0; i<y.row; i++)
              {
                  if(test.data[i][0]>test.data[i][1])
                      cout<<0-y.data[i][1]<<" ";
                  else  
                      cout<<1-y.data[i][1]<<" ";
                  cout<<endl;
              }
          }

    请注意:详细代码请点击阅读原文。

    The End

    来和小伙伴们一起向上生长呀!

    扫描下方二维码,添加小詹微信,可领取千元大礼包并申请加入 Python 学习交流群,群内仅供学术交流,日常互动,如果是想发推文、广告、砍价小程序的敬请绕道!一定记得备注「交流学习」,我会尽快通过好友申请哦!

    ????长按识别,添加微信

    (添加人数较多,请耐心等待)

    ????长按识别,关注小詹

    (扫码回复 1024 领取程序员大礼包)

    展开全文
  • alpha: 归一后灰度像素最小值,一般为0 beta: 归一后灰度像素最大值,一般为255 norm_type: 归一的类型,可以取以下值 (1) cv2.NORM_MINMAX: 数组的数值被平移或缩放到一个指定的范围,线性归一,一般较...

    本系列python版本:python3.5.4
    本系列opencv-python版本:opencv-python3.4.2.17
    本系列使用的开发环境是jupyter notebook,是一个python的交互式开发环境,测试十分方便,并集成了vim操作,安装教程可参考:windows上jupyter notebook主题背景、字体及扩展插件配置(集成vim环境)


    前言:原创不易,转载请告知并注明出处!扫码关注公众号【机器学习与自然语言处理】,定期发布知识图谱,自然语言处理、机器学习等知识,添加微信号【17865190919】进讨论群,加好友时备注来自CSDN。
    在这里插入图片描述

    上文【数字图像处理系列二】基本概念:亮度、对比度、饱和度、锐化、分辨率 中我们一起学习了数字图像概念和形成原理,并在实践和对比中一起分析了图像亮度、对比度、饱和度、锐化、分辨率等属性。图像的基础知识介绍完毕,此后将开始着重介绍数字图像处理和分析,本文便从 图像灰度变换增强 开始说起,这在图像预处理中也可以说是很重要的了,杠~~

    老规矩,先上图:
    在这里插入图片描述

    经过图像增强后的图片:
    在这里插入图片描述





    一、图像增强知识预热



    1、为啥要做图像增强

    在图像形成的过程中,存在很多因素影响图像的清晰度,列举几个常见影响图像清晰度因素如下:

    • 光照不够均匀,这会造成图像灰度过于集中
    • 由CCD(摄像头)获得图像时金A/D(数模)转换、线路传送时产生噪声污染,影响图像质量

    因此必须在图像处理分析之前对图像的质量进行改善,改善方法分为两类:

    • 图像增强
    • 图像复原

    图像增强不考虑图像质量下降的原因,只将图像中感兴趣的特征有选择的突出,而衰减不需要的特征,它的目的主要是提高图像的可懂度; 图像复原技术与增强技术不同,它需要了解图像质量下降的原因,首先要建立"降质模型",再利用该模型,恢复原始图像。

    本文便重点研究一下图像增强技术,图像增强主要是以对比度和阈值处理为目的,且都是在空间域进行的操作。我们假设 f(x,y) 是输入图像,g(x,y) 为经过增强变换处理后的图像,则有:

    这里的 T 便是在点 (x,y) 的邻域定义的关于 f 的算子,根据邻域的不同,图像增强分为两种:

    • 邻域处理技术
    • 点处理技术,又称 图像灰度变换增强技术,本文重点将讨论


    2、图像增强邻域处理技术

    空间域处理 g(x,y) = T[f(x, y)] 中点 (x,y) 便是图像的像素坐标,而邻域是中心在 (x,y) 的矩形,其尺寸比图像要小得多,如下图所示:
    在这里插入图片描述

    图像增强邻域处理技术的核心思想便是: 当对 (x,y) 做变换时,变换算子 T 是对以 (x,y) 为中心的邻域作用然后得出变换结果,如上图,假如该邻域的大小是3*3的正方形,算子 T 定义为 计算该邻域的平均灰度,如 (x,y) = (100,200),则 g(100,200) 的结果便是计算 f(100,200) 和它的8个邻点的和,然后在除以9 (即是由邻域包围的像素灰度的平均值),当然这种邻域处理思想在后续的图像滤波处理中是基本应用,如均值滤波、中值滤波和高斯滤波等都是采用邻域处理技术。



    3、图像增强点处理技术

    点处理技术,既是当邻域的大小为 1*1 时,此时 g 的值仅仅取决于点 (x,y) 处的值,此时 T 称为灰度变换函数,此种图像增强方式就是图像灰度变换增强,定义公式如下:

    其中 s 是变换后的像素,r 是变换前的像素,此后讨论的线性变换、 分段线性变换、 对数变换、 反对数变换、 幂律(伽马)变换均是基于此公式为基础进行的,因此图像灰度变换便是基于点的增强方式,它将每一个像素的灰度值按照一定的数学变换公式转换为一个新的灰度值,达到增强图像的效果。





    二、图像灰度变换增强



    说在前面: 线性变换和分段线性变换一般对灰度图像进行处理,也可以直接对RGB图像进行处理;对数变换、 反对数变换、 幂律(伽马)变换则是直接对RGB图像进行相应的图像增强,达到自己想要的结果

    如果对RGB图像进行变换之后需要多两部操作:(1) 图像归一化、(2) 图像像素值类型转化为np.uint8,需要用到两个函数,在这里做简单介绍,后续示例程序中将会使用到:

    函数cv2.normalize()

    #数字图像归一化操作
    cv2.normalize(src, dst, alpha, beta, norm_type, dtype, mask) → dst
    

    参数解释:

    • src: 原图像对象

    • dst: 经过转化后的图像对象

    • alpha: 归一化后灰度像素最小值,一般为0

    • beta: 归一化后灰度像素最大值,一般为255

    • norm_type: 归一化的类型,可以取以下值

      (1) cv2.NORM_MINMAX: 数组的数值被平移或缩放到一个指定的范围,线性归一化,一般较常用
      (2) cv2.NORM_INF:此类型的定义没有查到,根据OpenCV 1的对应项,可能是归一化数组的C-范数(绝对值的最大值)
      (3) cv2.NORM_L1 : 归一化数组的L1-范数(绝对值的和)
      (4) cv2.NORM_L2: 归一化数组的(欧几里德)L2-范数

    • dtype: 为负数时,输出图像像素值的type与输入相同,一般使用默认

    • mask: 操作掩膜,用于指示函数是否仅仅对指定的元素进行操作,一般使用默认


    函数cv2.convertScaleAbs()

    #该函数较简单,便是将原图像的像素值均转化成类型为np.uint8
    dst = cv2.convertScaleAbs(src)
    



    1、线性变换

    图像增强线性变换主要可以对图像的对比度和亮度进行调整,线性变换公式如下:

    参数 a 影响图像的对比度,参数 b 影响图像的亮度,具体分为可分为以下几种情况:

    • a>1: 增强图像的对比度,图像看起来更加清晰
    • a<1: 减小了图像的对比度, 图像看起来变暗
    • a<0 and b=0:图像的亮区域变暗,暗区域变亮
    • a=1 and b≠0:图像整体的灰度值上移或者下移,也就是图像整体变亮或者变暗,不会改变图像的对比度,b>0时图像变亮,b<0时图像变暗
    • a=-1 and b=255:图像翻转

    上代码:

    import cv2
    import random
    import imutils
    import numpy as np
    
    #彩色图像每个像素值是[x,y,z], 灰度图像每个像素值便是一个np.uint8
    image = cv2.imread('E:/peking_rw/ocr_project/base_prehandle/img/ali.jpg')
    gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    #图像大小调整
    ori_h, ori_w = image.shape[:2]
    height, width = gray_img.shape[:2]
    image = cv2.resize(image, (int(ori_w/ori_h*400), 400), interpolation=cv2.INTER_CUBIC)
    gray_img = cv2.resize(gray_img, (int(width/height*400), 400), interpolation=cv2.INTER_CUBIC)
    
    #a<0 and b=0: 图像的亮区域变暗,暗区域变亮
    a, b = -0.5, 0
    new_img1 = np.ones((gray_img.shape[0], gray_img.shape[1]), dtype=np.uint8)
    for i in range(new_img1.shape[0]):
        for j in range(new_img1.shape[1]):
            new_img1[i][j] = gray_img[i][j]*a + b
            
    #a>1: 增强图像的对比度,图像看起来更加清晰
    a, b = 1.5, 20
    new_img2 = np.ones((gray_img.shape[0], gray_img.shape[1]), dtype=np.uint8)
    for i in range(new_img2.shape[0]):
        for j in range(new_img2.shape[1]):
            if gray_img[i][j]*a + b > 255:
                new_img2[i][j] = 255
            else:
                new_img2[i][j] = gray_img[i][j]*a + b
    
    #a<1: 减小了图像的对比度, 图像看起来变暗
    a, b = 0.5, 0
    new_img3 = np.ones((gray_img.shape[0], gray_img.shape[1]), dtype=np.uint8)
    for i in range(new_img3.shape[0]):
        for j in range(new_img3.shape[1]):
            new_img3[i][j] = gray_img[i][j]*a + b
    
    #a=1且b≠0, 图像整体的灰度值上移或者下移, 也就是图像整体变亮或者变暗, 不会改变图像的对比度
    a, b = 1, -50
    new_img4 = np.ones((gray_img.shape[0], gray_img.shape[1]), dtype=np.uint8)
    for i in range(new_img4.shape[0]):
        for j in range(new_img4.shape[1]):
            pix = gray_img[i][j]*a + b
            if pix > 255:
                new_img4[i][j] = 255
            elif pix < 0:
                new_img4[i][j] = 0
            else:
                new_img4[i][j] = pix
    
    #a=-1, b=255, 图像翻转
    new_img5 = 255 - gray_img
    
    cv2.imshow('origin', imutils.resize(image, 800))
    cv2.imshow('gray', imutils.resize(gray_img, 800))
    cv2.imshow('a<0 and b=0', imutils.resize(new_img1, 800))
    cv2.imshow('a>1 and b>=0', imutils.resize(new_img2, 800))
    cv2.imshow('a<1 and b>=0', imutils.resize(new_img3, 800))
    cv2.imshow('a=1 and b><0', imutils.resize(new_img4, 800))
    cv2.imshow('a=-1 and b=255', imutils.resize(new_img5, 800))
    if cv2.waitKey(0) == 27:
        cv2.destroyAllWindows()
    

    代码运行效果,原灰度图像:
    在这里插入图片描述

    通过对图像对比度、亮度增强之后效果如下:

    在这里插入图片描述

    注: 明白一点就是图像增强从来没有通用的理论,在不同的场景下会有不同的需求,图像灰度增强最简单的线性变换可以满足对图像对比度和亮度进行随意的调整,得到自己想要的结果




    2、分段线性变换

    分段线性变换函数来增强图像对比度的方法实际是增强原图各部分的反差,即增强输入图像中感兴趣的灰度区域,相对抑制那些不感兴趣的灰度区域。增分段线性函数的主要优势在于它的形式可任意合成,而其缺点是需要更多的用户输入。分段线性函数通用公式如下:

    下面我们便通过实例来感受一下分段线性函数对于图像增强的几个方面的应用,并体会上面公式的含义!


    2.1 分段线性变换应用之对比度拉伸、阈值处理

    低对比度图像一般由光照不足,成像传感器动态范围太小,图像获取过程中镜头光圈设置错误引起,对比度拉伸是扩展图像灰度级动态范围的处理。变换算子 T 如下所示:

    在这里插入图片描述

    根据r1、s1、r2、s2可分为以下两种增强情况:

    • r1 <= r2、s1 <= s2: 对比度拉伸,增强感兴趣区域
    • r1 = r2: 阈值处理,产生一个二值图像


    (1) 对比度拉伸实例演示

    下面令(r1, s1) = (rmin,0)、(r2, s2) = (rmax,L-1),其中 rmin、rmax 分别代表数字图像中最小灰度级和最大灰度级,此变换函数将灰度级由原来范围线性拉伸到整个范围[0,L-1], 上示例代码:

    import cv2
    import imutils
    import numpy as np
    
    image = cv2.imread('E:/peking_rw/ocr_project/base_prehandle/img/pollen.jpg')
    gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    #在灰度图进行分段线性对比度拉伸
    #此种方式变换函数把灰度级由原来的线性拉伸到整个范围[0, 255]
    r_min, r_max = 255, 0
    for i in range(gray_img.shape[0]):
        for j in range(gray_img.shape[1]):
            if gray_img[i, j] > r_max:
                r_max = gray_img[i, j]
            if gray_img[i, j] < r_min:
                r_min = gray_img[i, j]
    r1, s1 = r_min, 0
    r2, s2 = r_max, 255
    
    precewise_img = np.zeros((gray_img.shape[0], gray_img.shape[1]), dtype=np.uint8)
    k1 = s1/r1
    k3 = (255-s2)/(255-r2)
    k2 = (s2 - s1)/(r2 - r1)
    for i in range(gray_img.shape[0]):
        for j in range(gray_img.shape[1]):
            if r1 <= gray_img[i, j] <= r2:
                precewise_img[i, j] = k2*(gray_img[i, j] - r1)
            elif gray_img[i, j] < r1:
                precewise_img[i, j] = k1*gray_img[i, j]
            elif gray_img[i, j] > r2:
                precewise_img[i, j] = k3*(gray_img[i, j] - r2)
                
    cv2.imshow('origin image', imutils.resize(image, 480))
    cv2.imshow('precewise image', imutils.resize(precewise_img, 480))
    if cv2.waitKey(0) == 27:
        cv2.destroyAllWindows()
    

    上述代码是在灰度图片上进行的图像增强,我们也可以直接在原图上进行图像增强,显示出来的效果都是相同的,代码如下:

    import cv2
    import imutils
    import numpy as np
    
    image = cv2.imread('E:/peking_rw/ocr_project/base_prehandle/img/pollen.jpg')
    
    #直接在原图上进行分段线性对比度拉伸
    #此种方式变换函数把灰度级由原来的线性拉伸到整个范围[0, 255] 
    r_min, r_max = 255, 0
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            for k in range(image.shape[2]):
                if image[i, j, k] > r_max:
                    r_max = image[i, j, k]
                if image[i, j, k] < r_min:
                    r_min = image[i, j, k]
    r1, s1 = r_min, 0
    r2, s2 = r_max, 255
    k1 = s1/r1
    k3 = (255-s2)/(255-r2)
    k2 = (s2 - s1)/(r2 - r1)
    
    precewise_img = np.zeros((image.shape[0], image.shape[1], 3), dtype=np.float32)
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            for k in range(image.shape[2]):
                if r1 <= image[i, j, k] <= r2:
                    precewise_img[i, j, k] = k2*(image[i, j, k] - r1)
                elif image[i, j, k] < r1:
                    precewise_img[i, j, k] = k1*gray_img[i, j, k]
                elif image[i, j, k] > r2:
                    precewise_img[i, j, k] = k3*(gray_img[i, j, k] - r2)
    
    #原图中做分段线性变化后需要对图像进行归一化操作,并将数据类型转换到np.uint8
    cv2.normalize(precewise_img, precewise_img, 0, 255, cv2.NORM_MINMAX)
    precewise_img = cv2.convertScaleAbs(precewise_img)
    
    cv2.imshow('origin image', imutils.resize(image, 480))
    cv2.imshow('precewise image', imutils.resize(precewise_img, 480))
    if cv2.waitKey(0) == 27:
        cv2.destroyAllWindows()
    

    花粉原图和经过对比度拉伸后的图像效果如下:
    在这里插入图片描述



    (2) 阈值处理实例演示

    import cv2
    import imutils
    import numpy as np
    
    image = cv2.imread('E:/peking_rw/ocr_project/base_prehandle/img/pollen.jpg')
    gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    #阈值处理函数:当r1=r2, s1=0, s2=L-1时,此时分段线性函数便是阈值处理函数
    plist = []
    for i in range(gray_img.shape[0]):
        for j in range(gray_img.shape[1]):
            plist.append(gray_img[i, j])
    r_avg = int(sum(plist)/len(plist))
    thresh_img = np.zeros((gray_img.shape[0], gray_img.shape[1]), dtype=np.uint8)
    for i in range(gray_img.shape[0]):
        for j in range(gray_img.shape[1]):
            if gray_img[i, j] < r_avg:
                thresh_img[i, j] = 0
            else:
                thresh_img[i, j] = 255
    
    cv2.imshow('origin image', imutils.resize(image, 480))
    cv2.imshow('thresh image', imutils.resize(thresh_img, 480))
    if cv2.waitKey(0) == 27:
        cv2.destroyAllWindows()
    

    经过阈值处理后的花粉图像如下所示:



    2.2 分段线性变换应用之灰度级分层

    为了在数字图像中突出我们感兴趣的灰度级区域 [A,B],在实际情况下可以有两种处理方式,对应下图:

    • 突出灰度范围在 [A,B] 的区域,将其他区域灰度级降低到一个更低的级别
    • 突出灰度范围在 [A,B] 的区域,其他区域保持原灰度级不变

    在这里插入图片描述

    上示例代码(下面展示的是:其他区域保持原灰度级不变的情况)

    import cv2
    import imutils
    import numpy as np
    
    #在某一范围(A, B)突出灰度,其他灰度值保持不变
    image = cv2.imread('E:/peking_rw/ocr_project/base_prehandle/img/kidney.jpg')
    gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    r_left, r_right = 150, 230
    r_min, r_max = 0, 255
    level_img = np.zeros((gray_img.shape[0], gray_img.shape[1]), dtype=np.uint8)
    for i in range(gray_img.shape[0]):
        for j in range(gray_img.shape[1]):
            if r_left <= gray_img[i, j] <= r_right:
                level_img[i, j] = r_max
            else:
                level_img[i, j] = gray_img[i, j]
                
    cv2.imshow('origin image', imutils.resize(image, 480))
    cv2.imshow('level image', imutils.resize(level_img, 480))
    if cv2.waitKey(0) == 27:
        cv2.destroyAllWindows()
    

    原图和效果图如下所示:
    在这里插入图片描述




    3、对数变换

    对数变换将图像的低灰度值部分扩展,将其高灰度值部分压缩,以达到强调图像低灰度部分的目的;同时可以很好的压缩像素值变化较大的图像的动态范围,目的是突出我们需要的细节。反对数变换则与对数函数不同的是,强调的是图像的高灰度部分,对数变换公式如下:

    下面示例将演示对数变换:

    import cv2
    import imutils
    import numpy as np
    
    image = cv2.imread('E:/peking_rw/ocr_project/base_prehandle/img/DFT_no_log.jpg')
    log_img = np.zeros((image.shape[0], image.shape[1], 3), dtype=np.float32)
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            log_img[i, j, 0] = math.log(1 + image[i, j, 0])
            log_img[i, j, 1] = math.log(1 + image[i, j, 1])
            log_img[i, j, 2] = math.log(1 + image[i, j, 2])
    cv2.normalize(log_img, log_img, 0, 255, cv2.NORM_MINMAX)
    log_img = cv2.convertScaleAbs(log_img)
    cv2.imshow('image', imutils.resize(image, 400))
    cv2.imshow('log transform', imutils.resize(log_img, 400))
    if cv2.waitKey(0) == 27:
        cv2.destroyAllWindows()
    

    傅里叶频谱和经过对数变换增强后的频谱图像
    在这里插入图片描述




    4、幂律变换

    幂律变换主要用于图像的校正,对漂白的图片或者是过黑的图片进行修正,幂律变换的公式如下:

    根据 φ 的大小,主要可分为一下两种情况:

    • φ > 1: 处理漂白的图片,进行灰度级压缩
    • φ < 1: 处理过黑的图片,对比度增强,使得细节看的更加清楚

    4.1 当φ > 1时示例如下:

    #幂律变换 φ>1
    image = cv2.imread('E:/peking_rw/ocr_project/base_prehandle/img/aerial.jpg')
    gamma_img1 = np.zeros((image.shape[0], image.shape[1], 3), dtype=np.float32)
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            gamma_img1[i, j, 0] = math.pow(image[i, j, 0], 5)
            gamma_img1[i, j, 1] = math.pow(image[i, j, 1], 5)
            gamma_img1[i, j, 2] = math.pow(image[i, j, 2], 5)
    cv2.normalize(gamma_img1, gamma_img1, 0, 255, cv2.NORM_MINMAX)
    gamma_img1 = cv2.convertScaleAbs(gamma_img1)
    cv2.imshow('image', imutils.resize(image, 400))
    cv2.imshow('gamma1 transform', imutils.resize(gamma_img1, 400))
    if cv2.waitKey(0) == 27:
        cv2.destroyAllWindows()
    

    漂白图片和经过幂律变换后图像对比效果:
    在这里插入图片描述


    4.2 当φ< 1时示例如下:

    #幂律变换,φ<1
    image = cv2.imread('E:/peking_rw/ocr_project/base_prehandle/img/fractured_spine.jpg')
    gamma_img2 = np.zeros((image.shape[0], image.shape[1], 3), dtype=np.float32)
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            gamma_img2[i, j, 0] = math.pow(image[i, j, 0], 0.4)
            gamma_img2[i, j, 1] = math.pow(image[i, j, 1], 0.4)
            gamma_img2[i, j, 2] = math.pow(image[i, j, 2], 0.4)
    cv2.normalize(gamma_img2, gamma_img2, 0, 255, cv2.NORM_MINMAX)
    gamma_img2 = cv2.convertScaleAbs(gamma_img2)
    cv2.imshow('image', imutils.resize(image, 400))
    cv2.imshow('gamma2 transform', imutils.resize(gamma_img2, 400))
    if cv2.waitKey(0) == 27:
        cv2.destroyAllWindows()
    

    过黑图片和经过幂律变换后效果展示图:
    在这里插入图片描述





    三、直方图均衡化


    说在前面: 数字图像直方图均衡化目的就是提升图像的对比度,将较亮或者较暗区域的输入像素映射到整个区域的输出像素,是图像增强一种很好的且方便的方式,因此单独列为一节进行讲解



    1、认识图像的直方图

    图像直方图:反应图像强度分布的总体概念,宽泛的来说直方图给出了图像对比度、亮度和强度分布信息。下面从理论的角度阐述一下图像直方图的公式定义

    对于灰度级范围为[0,L-1]的数字图像的直方图是离散函数:

    其中 rk 是第k级灰度值,nk 便是图像中灰度为 rk 的像素个数。当然如果数字图像长宽维度为MN,则对直方图归一化之后的公式为:

    下面我们先从直观的角度来感受一下不同图像对应的直方图的区别,这对后续直方图均衡化增强图像理解有很大的帮助

    在这里插入图片描述


    从上图中我们注意到: 在暗图像中,直方图的分布都集中在灰度级的低(暗)端; 亮图像直方图的分布集中在灰度级的高端;低对比度图像具有较窄的直方图,且都集中在灰度级的中部;而高对比度的图像直方图的分量覆盖了很宽的灰度范围,且像素分布也相对均匀,此时图片的效果也相对很不错。于是我们可以得出结论:若一幅图像的像素倾向于占据整个可能的灰度级并且分布均匀,则该图像有较高的对比度并且图像展示效果会相对好,于是便引出图像直方图均衡化,对图像会有很强的增强效果



    2、图像增强之直方图均衡化

    这里不详细介绍直方图均衡化原理,想了解请看博客: 直方图均衡化原理

    下面给出直方图均衡化的实现:

    import cv2
    import imutils
    import numpy as np
    import matplotlib.pyplot as plt
    
    wiki_img = cv2.imread('E:/peking_rw/ocr_project/base_prehandle/img/wiki.jpg')
    wiki_gray = cv2.cvtColor(wiki_img, cv2.COLOR_BGR2GRAY)
    
    #对图像进行均衡化处理,增强图像对比度
    wiki_equ = cv2.equalizeHist(wiki_gray)
    
    hist = cv2.calcHist([wiki_gray], [0], None, [256], [0, 256])
    equ_hist = cv2.calcHist([wiki_equ], [0], None, [256], [0, 256])
    fig = plt.figure()
    ax1 = fig.add_subplot(1, 2, 1)
    ax1.plot(hist)
    ax2 = fig.add_subplot(1, 2, 2)
    ax2.plot(equ_hist)
    plt.show()
    
    cv2.imshow('wiki_origin', imutils.resize(wiki_img, 400))
    cv2.imshow('wiki_gray', imutils.resize(wiki_gray, 400))
    cv2.imshow('wiki_equ', imutils.resize(wiki_equ, 400))
    if cv2.waitKey(0) == 27:
        cv2.destroyAllWindows()
    

    直方图均衡化斥候:直方图前后对比图、图像前后对比图
    在这里插入图片描述





    四、总结



    不总结了,本篇分享到此结束,码字码到眼睛疼,如果诸位看管觉得还可以帮忙点个赞,后续将持续更新数字图像处理和分析等操作,也欢迎关注博主微信公众号

    在这里插入图片描述

    展开全文
  • 图像的灰度非线性变换之对数变换、伽马变换发布时间:2019-03-31 15:31,浏览次数:2077, 标签:Python该系列文章是讲解PythonOpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种...
  • 文章目录通用形式简介重要概念指数族分布线性回归简介正则基扩展和核函数对数几率回归简介多分类策略[4]凸函数求解一些问题# 参考链接 通用形式 简介 ​ 广义线性模型(Generalized Linear Model),将线性模型...
  • 图像归一化概念和作用

    千次阅读 2021-06-18 09:55:51
    图像归一化概念 图像归一化是指对图像进行了一系列标准的处理变换,使之变换为一固定标准形式的过程,该标准图像称作归一化图像。 图像归一化是利用图像的不变矩寻找一组参数使其能够消除其他变换函数对图像变换的...
  • 对数可能性:可能性的自然对数 边际模型:一种线性模型,说明对同一主题的重复响应措施。一般线性模型的五个扩展: : 。 稳健的标准误差:一种在异方差下获得OLS系数的无偏标准误差的技术 。 Bonferonni校正:将...
  • 特征工程的基础介绍和常用方法总结,包括对数转换、特征标准、离散、Label Encoder、OneHot Encoder 以及 Dummy Variables。
  • 1、概念线性模型试图学习得到一个通过属性的线性组合来进行预测的函数,即 优点是简单,易于建模。 2、分类任务和回归任务 回归问题和分类问题的本质一样,都是针对一个输入做出一个输出预测,其区别在于...
  • 机器学习专题(一)梯度下降法实现对数几率回归模型优化 文章目录机器学习专题(一)梯度下降法实现对数几率回归模型优化一、梯度下降算法二、使用步骤1.引入库2.读入数据总结 一、梯度下降算法 示例:pandas 是基于...
  • python中取对数

    千次阅读 2020-12-19 19:30:38
    ”因此,可视是一个宝贵的工具,有助于读者快速理解相应的概念。然而,与其说数据可视是一种技能,还不如说它是一门艺术。这是因为,如过... 文章 华章计算机 2017-05-02 2193浏览量 放弃“for循环”,教你用...
  • 线性回归的最小函数

    千次阅读 2017-03-03 14:55:28
    当看到下面这个公式时:这个就是一个变量的线性回归最优化函数,NG当时没有解释为什么这样定义的,只是让这个J函数最小,就可以达到最优化的线性方程回归了。同时,你如果看过我前面的文章,也会发现Ten
  • 回归线性 可以方便地在模型上进行自动建模,也可以在variate的基础上使用python并可以在python上使用lenguaje ... 对数线性对数和对数线性对数 co科动物 信息无用信息(VIF) 虚拟变量(变量ficticias) Regr
  • 机器学习基本概念线性模型
  • 永磁电机极对数一般是多少You probably learned about them in your high school math class and then never thought about them again. I admit, to this day, logarithms (logs for short) are not my best friend...
  • 1. 线性回归 假设 特征 和 结果 都满足线性。即不大于一次方。这个是针对 收集的数据而言。 收集的数据中,每一个分量,就可以看做一个特征数据。每个特征至少对应一个未知的参数。这样就形成了一个线性模型函数,...
  • 对比度概念:  对比度指的是一幅图像中明暗区域最亮的白和最暗的黑之间不同亮度层级的测量,即指一幅图像灰度反差的大小。 图像可视性对数增强 为了增强图像的可视信息,对图像中的像素进行...
  • 对数几率回归的定义 1.1 广义线性模型 在之前的机器学习(一):深入解析线性回归模型一文中所介绍的线性模型都是基于y=wTx+by=w^Tx+by=wTx+b这种形式的。但对于某些数据集虽然其自变量xxx与因变量yyy并不满足一元函数...
  • 交叉熵的介绍见...使用交叉熵损失函数也不能避免反向传播带来的梯度消失,此时规避梯度消失的方法有使用ReLU、输入归一、层归一等。
  • 经历最大似然估计的推导,就能导出一般线性回归的 误差分析模型(最小误差模型)。 softmax回归就是 一般线性回归的一个例子。 有监督学习回归,针对多类问题(逻辑回归,解决的是二类划分问题),如...
  • 从这篇博客开始将介绍机器学习中的比较重要的内容——回归,期间会穿插着涉及到的知识点,如正则。本篇是回归大家族中最简单的一种——线性回归,采用最小二乘法来求得最优解。
  • 虽然我希望近可能地系统讲解,但是以下基本概念不会做任何讲解,不懂的同学可以查到大量的相关资料,它们包括: 素数、带余除法、模运算、幂运算、欧拉函数 φ ( n ) 、渐进复杂度分析    首先...
  • 一、对数转换 对数函数可以对大数值的范围进行压缩,对小数值的范围进行扩展。x越大,log(x)增长得越慢。如下图: 我们以如下数据为例。 biz_file = open('精通特征工程/精通特征工程/data/yelp_academic_...
  • 数模学习(七)--- 多元线性回归

    千次阅读 2020-07-09 17:13:52
    Abstract ...常见的回归分析有五类:线性回归、0-1回归、定序回归、计数回归和生存回归,它们划分的依据是因变量Y的类型,这里我们主要讲线性回归。 一 引入 1.1 回归的思想1 回归分析: 研究X和Y之间
  • 回归的线性模型

    千次阅读 2017-07-08 11:29:32
    但是,通过将一组输入变量的非线性函数进行线性组合,我们可以获得一类更加有用的函数,被称为基函数( basis function )。这样的模型是参数的线性函数,这使得其具有一些简单的分析性质,同时关于输入变量是非线性
  • R 中进行对数变换

    万次阅读 2018-07-20 18:59:14
    R 中进行对数变换 说明:这篇文章是我在学习 R 时看到的,感觉很有用,就翻译了过来。原文:Log Transformations for Skewed and Wide Distributions —– 正文分割线 —– 当数据分布大致对称时,用均值和标准...
  • 归一与标准概念和区别 1. 归一与标准概念和区别 1. 归一: 1) 把数据变成(0,1)或者(-1,1)之间的小数。主要是为了数据处理方便提出来的,把数据映射到0~1范围之内处理,更加便捷快速。 2) 把有...
  • 权重不确定的概率线性回归

    千次阅读 2020-11-03 22:33:00
    但在此之前,让我们简要讨论一下确定性线性回归的概念,以便快速了解本文的主要讨论要点。 线性回归是一种基本的统计方法,用来建立一个或多个输入变量(或自变量)与一个或多个输出变量(或因变量)之间的线性关系。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,294
精华内容 7,717
关键字:

对数线性化概念