精华内容
下载资源
问答
  • 基于Matlab的Parzen Window函数。简单实用。
  • PARZEN窗和K近邻算法的python实现。 现实生活中常常会有这样的问题:缺乏足够的先验知识,因此难以人工标注类别或进行人工类别标注的成本太高。很自然地,我们希望计算机能代我们完成这些工作,或至少提供一些帮助...
  • parzen窗估计概率密度

    2020-12-15 13:30:46
    此matlab代码是parzen窗非参数估计概率密度函数的,以及parzen窗做分类器
  • 模式识别课程的课后作业——parzen窗模拟正态函数MATLAB实现
  • 模式识别作业,parzen窗的参数选择对分类性质的探究
  • 这个小包包含一个 Parzen 神经网络分类器,可以在 D 维的 N 类之间对数据进行分类。 分类器非常快速且易于学习。 对于某类数据分布可以获得良好的分类性能。 在 PPNN 分类器无法获得良好性能的情况下,必须使用其他...
  • 实验一:使用 了非参数估计中的parzen窗和Kn近邻方法 求出用身高体重特征判别男女的正确率并与参数估计的方法做比较;实验二:使用fisher线性判别的方法,将数据投影到一维中,进行判别 并与贝叶斯分类器相比较;...
  • 这是 Parzen 分类器的 mex 实现
  • 它通过 Parzen 窗口而不是虚线构建代表区域来替换脚本“PVA 模拟与 Montecarlo”的结尾部分
  • 需要讲解Parzen窗方法的,需要理解的可以自行查看,完整的PPT
  • Parzen窗法

    2021-09-20 20:18:23
    Parzen窗法 1. 方法综述 假设x∈Rdx \in R^dx∈Rd是ddd维特征向量,并假设每个小舱是一个超立方体,它在每一维的棱长都为hhh,则小舱的体积是: V=hd(1) V=h^d \tag 1 V=hd(1)

    Parzen窗法

    1. 方法综述

    假设 x ∈ R d x \in R^d xRd d d d维特征向量,并假设每个小舱是一个超立方体,它在每一维的棱长都为 h h h,则小舱的体积是:
    V = h d (1) V=h^d \tag 1 V=hd(1)
    要计算每个小舱内落入的样本数目,可以定义如下的 d d d维单位方窗函数:
    φ ( [ u 1 , u 2 , . . . , u d ] T ) = { 1 若 ∣ u j ∣ ≤ 1 2 , j = 1 , 2 , . . . , d 0 其 他 (2) \varphi([u_1,u_2,...,u_d]^T) = \left\{ \begin{array}{cc} 1 & 若|u_j| \leq \frac{1}{2},j=1,2,...,d \\ 0 & 其他 \end{array} \right. \tag 2 φ([u1,u2,...,ud]T)={10uj21,j=1,2,...,d(2)
    该函数在以原点为中心的 d d d维单位超正方体内取值为1,而其他地方取值都为0。对于每个 x x x,要考查某个样本 x i x_i xi是否在这个 x x x为中心、 h h h为棱长的立方小舱内,就可以通过计算 φ ( x − x i h ) \varphi(\frac{x-x_i}{h}) φ(hxxi)来进行。现在共有 N N N个观测样本 { x 1 , x 2 , . . . , x N } \{x_1,x_2,...,x_N\} {x1,x2,...,xN},那么落入以 x x x为中心的超立方体内的样本数就可以写成:
    k N = ∑ i = 1 N φ ( x − x i h ) (3) k_N=\sum_{i=1}^{N} \varphi(\frac{x-x_i}{h}) \tag 3 kN=i=1Nφ(hxxi)(3)
    将上式代入 ρ ( x ) ^ = k N V \hat{\rho(x)}=\frac{k}{NV} ρ(x)^=NVk中有:
    ρ ( x ) ^ = 1 N V ∑ i = 1 N φ ( x − x i h ) (4) \hat{\rho(x)}=\frac{1}{NV} \sum_{i=1}^{N} \varphi(\frac{x-x_i}{h}) \tag 4 ρ(x)^=NV1i=1Nφ(hxxi)(4)
    或者写成:
    ρ ( x ) ^ = 1 N ∑ i = 1 N 1 V φ ( x − x i h ) (5) \hat{\rho(x)}=\frac{1}{N} \sum_{i=1}^{N} \frac{1}{V} \varphi(\frac{x-x_i}{h}) \tag 5 ρ(x)^=N1i=1NV1φ(hxxi)(5)
    定义核函数(也称窗函数)如下:
    K ( x , x i ) = 1 V φ ( x − x i h ) (6) K(x,x_i)=\frac{1}{V} \varphi(\frac{x-x_i}{h}) \tag 6 K(x,xi)=V1φ(hxxi)(6)
    它反映了一个观测样本 x i x_i xi对在 x x x处的概率密度估计的贡献,与样本 x i x_i xi x x x的距离有关,也可记作 K ( x − x i ) K(x-x_i) K(xxi)。概率密度估计就是在每一点上把所有观测样本的贡献进行平均:
    ρ ( x ) ^ = 1 N ∑ i = 1 N K ( x , x i ) (7) \hat{\rho(x)}=\frac{1}{N} \sum_{i=1}^{N} K(x,x_i) \tag 7 ρ(x)^=N1i=1NK(x,xi)(7)
    几种常见核函数
    (1)方窗
    k ( x , x i ) = { 1 h d 若 ∣ x j − x i j ∣ ≤ h 2 , j = 1 , 2 , . . . , d 0 其 他 (8) k(x,x_i)= \left\{ \begin{array}{cc} \frac{1}{h^d} & 若|x_j-x_i^j| \leq \frac{h}{2},j=1,2,...,d \\ 0 & 其他 \end{array} \right. \tag 8 k(x,xi)={hd10xjxij2h,j=1,2,...,d(8)
    其中, h h h为超立方体的棱长。
    (2)高斯窗(正态窗)
    k ( x , x i ) = 1 ( 2 π ) d ρ 2 d ∣ Q ∣ exp ⁡ { − 1 2 ( x − x i ) T Q − 1 ( x − x i ) ρ 2 } (9) k(x,x_i)=\frac{1}{\sqrt{(2\pi)^d\rho^{2d} |Q|}} \exp\{-\frac{1}{2} \frac{(x-x_i)^T Q^{-1} (x-x_i)}{\rho^2}\} \tag 9 k(x,xi)=(2π)dρ2dQ 1exp{21ρ2(xxi)TQ1(xxi)}(9)
    即以样本 x i x_i xi为均值、协方差矩阵为 Σ = ρ 2 Q \Sigma=\rho^2 Q Σ=ρ2Q的正态分布函数。一维情况下则为:
    ρ ( x ) = 1 2 π σ e − 1 2 ( x − μ σ ) 2 (10) \rho(x)=\frac{1}{\sqrt{2\pi \sigma}} e^{-\frac{1}{2} (\frac{x- \mu}{\sigma})^2} \tag {10} ρ(x)=2πσ 1e21(σxμ)2(10)
    (3)超球窗
    k ( x , x i ) = { V − 1 若 ∣ ∣ x − x i ∣ ∣ ≤ ρ 0 其 他 (11) k(x,x_i)= \left\{ \begin{array}{cc} V^{-1} & 若||x-x_i|| \leq \rho \\ 0 & 其他 \end{array} \right. \tag {11} k(x,xi)={V10xxiρ(11)
    其中 V V V是超球体的体积, ρ \rho ρ是超球体半径。

    2. 代码实战

    σ = h 1 / N \sigma=h_1/\sqrt{N} σ=h1/N h 1 h_1 h1为例子中可调节的参量。
    主函数

    function p = Parsen(Samples,H,N,interval)
    % Samples 表示总样本
    % h 表示Parsen窗口大小
    % N 是随机采样的样本大小(1,10,100)
    % x 是密度估计的点
    
    p = zeros(length(interval),1);
    h = (H/sqrt(N)); % 半径
    
    for i = 1 : length(interval)
        b = 0;
        for j = 1 : N
            u = (interval(i) - Samples(j))/h;
            b = b + exp(-u.^2/2)/(sqrt(2*pi)*h); % 一维高斯分布
        end
        p(i) = b / N;
    end
    end
    

    Parsen.m

    function p = Parsen(Samples,H,N,interval)
    % Samples 表示总样本
    % h 表示Parsen窗口大小
    % N 是随机采样的样本大小(1,10,100)
    % x 是密度估计的点
    
    p = zeros(length(interval),1);
    h = (H/sqrt(N)); % 半径
    
    for i = 1 : length(interval)
        b = 0;
        for j = 1 : N
            u = (interval(i) - Samples(j))/h;
            b = b + exp(-u.^2/2)/(sqrt(2*pi)*h); % 一维高斯分布
        end
        p(i) = b / N;
    end
    end
    

    图示
    在这里插入图片描述

    展开全文
  • parzen窗.rar

    2019-06-12 19:36:32
    贝叶斯估计理论中的PARZEN窗估计方法,估计概率密度函数,代码简单可实现,附带仿真图,如需解答可联系
  • parzen窗的非参数估计

    2018-12-01 16:32:29
    本实验的目的是学习Parzen窗估计方法。在之前的模式识别研究中,我们假设概率密度函数的参数形式已知,即判别函数J(.)的参数是已知的。本节使用非参数化的方法来处理任意形式的概率分布而不必事先考虑概率密度的参数...
  • 采用Parzen窗技术来估计图像灰度值的空间概率分布,再用Renyi熵来构造目标函数,最后在图像灰度范围内搜索,使此目标函数最小的灰度值作为最佳全局阈值。实验结果表明,此方法对图像分割的精度非常高,且适应性强。
  • 针对小样本选煤数据分类问题,文章提出了一种基于概率密度...由于Parzen窗算法可以较为精确的进行概率密度估计,生成的额外训练样本的真实性较高,所以该算法可以有效的提高分类器在的小样本选煤数据分类问题上的性能。
  • Parzen 窗估计

    2014-04-30 10:27:35
    其中经典的算法有:Parzen 窗估计 本实验的目的是学习和掌握非参数估计——Parzen 窗估计。对表格3 中的数据,进行 Parzen 窗估计和设计分类器,本实验的窗函数为一个球形的高斯函数,如下: (( ) / ) exp[ ( )t ( ...
  • kernel density estimation是在概率论中用来估计未知的密度函数,属于非参数检验方法之一,由Rosenblatt (1955)和Emanuel Parzen(1962)提出,又名Parzen窗(Parzen window) 本文翻译自英国雷丁大学(Reading ...

    kernel density estimation是在概率论中用来估计未知的密度函数,属于非参数检验方法之一,由Rosenblatt (1955)和Emanuel Parzen(1962)提出,又名Parzen窗(Parzen window)
    本文翻译自英国雷丁大学(Reading University)Xia Hong老师的讲义材料

    [统计寓于生活.jpg)]

    1 概率密度函数

    连续概率函数 p ( x ) p(x) p(x)的数学定义满足以下特性:

    1. x x x介于 a a a b b b两点之间的概率为 P ( a < x < b ) = ∫ a b p ( x ) d x P(a<x<b)=\int_a^bp(x)dx P(a<x<b)=abp(x)dx
    2. x是非负实数
    3. 概率函数的积分: ∫ − ∞ ∞ p ( x ) d x = 1 \int_{-\infty}^\infty p(x)dx=1 p(x)dx=1

    最常见的概率函数是高斯函数(Gaussian Function,又称为正态分布): p ( x ) = 1 2 π σ exp ⁡ ( − ( x − c ) 2 2 σ 2 ) p(x)=\frac{1}{\sqrt{2\pi\sigma}}\exp(-\frac{(x-c)^2}{2\sigma^2}) p(x)=2πσ 1exp(2σ2(xc)2),这里 c c c是均值, σ \sigma σ是标准差

    Guassian-Function.

    拓展到对于向量 x \mathbf{x} x,非负函数 p ( x ) p(\mathbf{x}) p(x)有以下特性:

    1. x \mathbf{x} x在区域 R R R里的概率为 P = ∫ R p ( x ) d x P=\int_R p(\mathbf{x})d\mathbf{x} P=Rp(x)dx
    2. 概率函数的积分为 ∫ p ( x ) d x = 1 \int p(\mathbf{x})d\mathbf{x}=1 p(x)dx=1

    2D-Gaussian-

    2 密度估计

    密度估计:给定的一系列数量为 n n n的样本 x 1 , ⋅ ⋅ ⋅ , x n \mathbf{x}_1, \cdot\cdot\cdot,\mathbf{x}_n x1,,xn,可以估计密度函数 p ( x ) p(\mathbf{x}) p(x),从而根据任意新样本 x \mathbf{x} x可以得到输出 p ( x ) p(\mathbf{x}) p(x)
    大部分未知密度函数估计方法的基本思想都很简单,主要是依赖于样本落在区域 R R R的概率 P P P,即有 P = ∫ R p ( x ) d x P=\int_R p(\mathbf{x})d\mathbf{x} P=Rp(x)dx
    假设区域 R R R很小, P ( x ) P(\mathbf{x}) P(x)在区域内波动很小,上式可以写做 P = ∫ R p ( x ) d x ≈ p ( x ) ∫ R d x = p ( x ) V P=\int_R p(\mathbf{x})d\mathbf{x}\approx p(\mathbf{x})\int_R d\mathbf{x}=p(\mathbf{x})V P=Rp(x)dxp(x)Rdx=p(x)V,这里 V V V是区域 R R R的“量”(二维即为面积)
    从另一方面看,假设 n n n个样本 x 1 , ⋅ ⋅ ⋅ , x n \mathbf{x}_1, \cdot\cdot\cdot,\mathbf{x}_n x1,,xn都是独立且服从概率密度函数 p ( x ) p(\mathbf{x}) p(x),且 n n n个样本中有 k k k个落在区域 R R R里面,则有 P = k / n P=k/n P=k/n,因此 p ( x ) p(\mathbf{x}) p(x)的估计式为 p ( x ) = k / n V p(\mathbf{x})=\frac{k/n}{V} p(x)=Vk/n

    3 Parzen窗密度估计

    考虑 R R R是中心在 x \mathbf{x} x的超立方体(例如二维平面),令 h h h为超立方体的边缘长度,所以对于二维平面有有 V = h 2 V=h^2 V=h2,对于三维立体有 V = h 3 V=h^3 V=h3

    Parzen-Window

    引入 ϕ ( x i − x h ) = { 1 ∣ x i k − x k ∣ h < = 1 / 2 , k = 1 , 2 0 o t h e r w i s e \phi(\frac{\mathbf{x}_i-\mathbf{x}}{h})=\left\{ \begin{aligned} 1\quad& \frac{|x_{ik}-x_{k}|}{h}<=1/2, k=1,2 \\ 0\quad& otherwise \end{aligned} \right. ϕ(hxix)=10hxikxk<=1/2,k=1,2otherwise
    Parzen概率密度公式(二维)为 p ( x ) = k / n V = 1 n ∑ i = 1 n 1 h 2 ϕ ( x i − x h ) p(\mathbf{x})=\frac{k/n}{V}=\frac{1}{n}\sum_{i=1}^n {\frac{1}{h^2}\phi(\frac{\mathbf{x}_i-\mathbf{x}}{h})} p(x)=Vk/n=n1i=1nh21ϕ(hxix) ϕ ( x i − x h ) \phi(\frac{\mathbf{x}_i-\mathbf{x}}{h}) ϕ(hxix)即为窗函数
    我们归纳这个思想并拓展到其他Parzen窗密度估计法中
    例如,如果使用高斯函数,对于一维有: p ( x ) = 1 n ∑ i = 1 n 1 2 π σ exp ⁡ ( − ( x i − x ) 2 2 σ 2 ) p(x)=\frac{1}{n}\sum_{i=1}^{n}{\frac{1}{\sqrt{2\pi\sigma}}\exp(-\frac{(x_i-x)^2}{2\sigma^2})} p(x)=n1i=1n2πσ 1exp(2σ2(xix)2),这是对 n n n个将数据点作为中心的高斯函数的简单求平均,公式中的 σ \sigma σ需要再做确定


    例子
    给定一个系列的5个数据点 x 1 = 2 x_1=2 x1=2 x 2 = 2.5 x_2=2.5 x2=2.5 x 3 = 3 x_3=3 x3=3 x 4 = 1 x_4=1 x4=1 x 5 = 6 x_5=6 x5=6,参数 σ = 1 \sigma=1 σ=1,中心 x = 3 x=3 x=3的高斯函数作为窗函数,求出Parzen概率密度估计(pdf)
    解答
    1 2 π exp ⁡ ( − ( x 1 − x ) 2 2 ) = 1 2 π exp ⁡ ( − ( 2 − 3 ) 2 2 ) = 0.2420 \frac{1}{\sqrt{2\pi}}\exp(-\frac{(x_1-x)^2}{2})=\frac{1}{\sqrt{2\pi}}\exp(-\frac{(2-3)^2}{2})=0.2420 2π 1exp(2(x1x)2)=2π 1exp(2(23)2)=0.2420
    1 2 π exp ⁡ ( − ( x 2 − x ) 2 2 ) = 1 2 π exp ⁡ ( − ( 2.5 − 3 ) 2 2 ) = 0.3521 \frac{1}{\sqrt{2\pi}}\exp(-\frac{(x_2-x)^2}{2})=\frac{1}{\sqrt{2\pi}}\exp(-\frac{(2.5-3)^2}{2})=0.3521 2π 1exp(2(x2x)2)=2π 1exp(2(2.53)2)=0.3521
    1 2 π exp ⁡ ( − ( x 3 − x ) 2 2 ) = 1 2 π exp ⁡ ( − ( 3 − 3 ) 2 2 ) = 0.3989 \frac{1}{\sqrt{2\pi}}\exp(-\frac{(x_3-x)^2}{2})=\frac{1}{\sqrt{2\pi}}\exp(-\frac{(3-3)^2}{2})=0.3989 2π 1exp(2(x3x)2)=2π 1exp(2(33)2)=0.3989
    1 2 π exp ⁡ ( − ( x 4 − x ) 2 2 ) = 1 2 π exp ⁡ ( − ( 1 − 3 ) 2 2 ) = 0.0540 \frac{1}{\sqrt{2\pi}}\exp(-\frac{(x_4-x)^2}{2})=\frac{1}{\sqrt{2\pi}}\exp(-\frac{(1-3)^2}{2})=0.0540 2π 1exp(2(x4x)2)=2π 1exp(2(13)2)=0.0540
    1 2 π exp ⁡ ( − ( x 5 − x ) 2 2 ) = 1 2 π exp ⁡ ( − ( 6 − 3 ) 2 2 ) = 0.0044 \frac{1}{\sqrt{2\pi}}\exp(-\frac{(x_5-x)^2}{2})=\frac{1}{\sqrt{2\pi}}\exp(-\frac{(6-3)^2}{2})=0.0044 2π 1exp(2(x5x)2)=2π 1exp(2(63)2)=0.0044
    因此, p ( x = 3 ) = ( 0.2420 + 0.3521 + 0.3989 + 0.0540 + 0.0044 ) / 5 = 0.2103 p(x=3)=(0.2420 + 0.3521 + 0.3989+0.0540 + 0.0044)/5 = 0.2103 p(x=3)=(0.2420+0.3521+0.3989+0.0540+0.0044)/5=0.2103


    下面用图形化语言表示Parzen窗,每个数据点密度函数(虚线)对于最终的概率密度函数(实线)有相同的贡献度

    lines-of-data-points

    line-of-pdf.

    展开全文
  • 模式识别非参数估计的parzen窗法和Kn近邻法的matlab算法实现
  • Parzen窗方法

    2020-12-20 14:13:38
    前言本文主要分两个部分来讨论 Parzen 窗,第一个部分讨论其基本思想,第二个部分则将 Parzen 窗的基本形式展示出来正文一、Parzen窗方法的基本概念一名老师召集了几名学生玩一个游戏。老师告诉这些学生们:“现在在...

    前言本文主要分两个部分来讨论 Parzen 窗,第一个部分讨论其基本思想,第二个部分则将 Parzen 窗的基本形式展示出来

    正文

    一、Parzen窗方法的基本概念

    一名老师召集了几名学生玩一个游戏。

    老师告诉这些学生们:“现在在你们每个人的面前有一纸箱子,里面有三种颜色的衣服,分别是:红、黄、蓝。现在请你们各自挑选一件自己喜欢的衣服穿在身上,然后到我这儿来统计一下。”

    当学生选好自己的衣服,并穿上之后,老师便开始一个个的记录同学们所选择的衣服。我们现在假设有

    名同学。这

    名同学中,有

    人穿了红衣服,

    人穿了黄衣服,剩下的都穿了蓝衣服。

    接下来,我们把这

    名学生陆续编号为

    。最后,我们构建一个函数

    满足条件:当

    为红衣服时,该函数的值为

    ,否则,函数值为

    。同理,构建一个函数

    满足:当

    为黄衣服时,该函数的值为

    ,否则,函数值为

    听到这儿,感觉挺无聊吧?请再稍微忍一下,因为我已经开始揭露谜底了。

    通过以上的定义,我们可以直接近似估计出这

    名学生选择红衣服的概率密度:

    ,穿黄衣服的概率:

    ,以及穿蓝衣服的概率

    看到这儿了,读者可能会想:这不扯犊子吗?讲这么简单的东西,这不就是小学时求概率所用到的直方图吗?

    先别急,我会告诉你,这就是 Parzen 窗。

    上面所提到的例子,若是花在直方图上,也只会有三根孤零零的直方柱。这是因为上述例子只有三类,所以我们也只求出三种概率密度。

    如果我们现在引入更多的类别,那么直方图里就会有更多根直方柱。进一步想,如果我们引入无数个类别,那么直方柱的顶点将会形成一条光滑的曲线!一条光滑的概率密度曲线。

    在现实生活中,我们往往都是通过将许多跟直方柱的顶点连上线条,从而近似成一根概率密度曲线的。直方柱的原始数量越多,曲线就会越精确。

    这意味着什么?

    因为在现实世界中,面对错综复杂的数据,如果将它们化成直方图,并近似成一根曲线。最终也可能会是一根特别复杂的曲线,它可能会凹凸不平,对应一个特别复杂的概率分布。那么,要对这样的数据进行建模是很困难的。这个时候,我们便可以直接利用 Parzen 窗方法估计出概率密度。

    怎么做?

    假设在一组数据

    中,这组数据可以分成许多个不同的类别。现在我们考虑其中一个类别

    ,我们需要知道数据

    属于

    的概率密度。那么我们构建一个函数

    ,使得它满足:当

    属于类别

    时,

    的值为

    否则,

    的值为

    那么,概率密度

    就会满足:

    是不是很简单?先别急着兴奋,我们现在所看到的 Parzen 窗还不能算是完全体。我们还需要再考虑稍微复杂一丢丢的东西。

    二、完整的 Parzen 窗

    讨论了这部分内容之后,我们的 Parzen 窗方法就可以起到更大的作用。

    我们之前讨论过,现实世界中的概率分布曲线可能是很复杂的。我们之前所讨论到的直方图,它内部的直方柱是由多个矩形堆砌而来的。但是现实生活中的概率分布曲线可能是更加复杂的东西。比如说,如果我们将一条线段从左到右按顺序分成

    四个部分,其中,

    的高度可能是

    个高斯分布曲线堆砌而成的,

    的高度是由

    个高斯分布曲线堆砌而成的,

    则是由

    个高斯分布曲线堆砌而成的。就类似于下图( 只是“类似”而已 ,并不符合我所描述的情况):很明显这张图左右两条曲线是由不同倍数的高斯分布曲线堆砌而成的

    当然,不仅仅只有高斯分布曲线,其他的分布曲线也是可能的。

    上述讨论意味着什么?意味着我们可能要重新修改一下函数

    的定义:当

    属于类别

    时,

    的值为

    ;否则,

    的值为

    。这里的

    ,代表的是分布曲线下所包含的面积。我们之前所讨论的直方图中,直方柱就是由无数面积为

    的矩形曲线所堆砌起来的。引入了

    的概念后,我们的公式便会更加接近完善:

    还不够哦。我们还需要注意到最后一个信息,那就是:看下一段。

    现实生活中的概率密度曲线,还有可能是被拉伸或缩短过的,是吧?所以我们还要再加入最后一个细节:若该曲线被拉长了

    倍,则公式变为:

    对了,还要注意最后一个。。。。。读者:够了!你有完没完!

    真的。。真的是最后一个了。大家要注意坐标系的平移,所以最终的式子可能会变成:

    。关于这个式子,我相信大家一看就懂啦。

    看了这么久,总算是将 Parzen 窗的基础知识讲完了。大家可能注意到了,这方法能否奏效,函数

    是一个关键。事实上,我们习惯称这个函数为“核函数”。核函数的话,网上有很多现成的函数给大家免费使用,这里就不详细讨论了。Parzen 窗又被称之为“核密度估计”,所以大家百度搜索核密度估计,在百度词条里会介绍几个相关的核函数的。

    返回原文

    展开全文
  • parzen窗的matlab实现 本文档实现的是用简单的matlab程序实现parzen窗的设计
  • parzen窗估计

    2012-02-14 19:35:13
    通过matlab语言实现Parzen窗估计法,实现结果良好,可供大家使用,互相学习。
  • 提出了一种多尺度的谱聚类算法。与传统谱聚类算法不同,多尺度谱聚类算法用改进的k-means算法对未经规范的Laplacian矩阵的特征向量进行聚类。与传统k-means算法不同,改进的k-means算法提出一种新颖的划分数据点到...
  • Parzen_parzen_parzenwindowmatlab_parzenwindow.zip
  • Parzen Window and Likelihood

    千次阅读 2018-01-30 23:05:04
    Kernel density estimation via the Parzen-Rosenblatt window method Generative Adversarial Nets code Nice explanation 对Ian提到的采用Gassian Parzen Window 去拟合G产生的样本并估计对数似然性(即给予观察...

    Kernel density estimation via the Parzen-Rosenblatt window method

    Generative Adversarial Nets code

    Nice explanation

    对Ian提到的采用Gassian Parzen Window 去拟合G产生的样本并估计对数似然性(即给予观察样本,判断模型正确的可能性)如何实现的原理很感兴趣?
    于是找到源代码parzen_ll.py来看,
    但是苦于并没有学过theano及pylearn2所以看起来不是明白,本来想尝试安装py2learn来测试,结果看了官网的安装要求,请卸载python,清除所有组件。这个代价有点大
    ,毕竟我是要做Tensorflow的。因此只能破罐破摔来,硬着头皮看代码,有些东西只能靠google,看了一个大概。首先来说一下Parzen Window

    2 Defining the Region Rn

    Parzen windown 是一种应用广泛的非参数估计方法,从采样的样本 p(xn) p ( x n ) 中估计概率密度函数 p(x) p ( x )
    这种方法最基本的思想是给定一个特定的区域(Window)对落入其中的样本进行计数,可以得到样本落入该区域的概率大约为:

    p(x)=knn p ( x ) = k n n

    从数学的角度来求取在区域R里k个观察样本的概率,我们可以考虑一个Binomial(二项式分布):

    pk=[nk]pk(1p)nk p k = [ n k ] ⋅ p k ⋅ ( 1 − p ) n − k

    然后在二项式分布假设的情况下, 所以我们可以求得其均值为:

    E[k]=np E [ k ] = n ⋅ p

    在连续性假设条件下:

    p(x)=Rf(x)dx=f(x)V p ( x ) = ∫ R f ( x ) d x = f ( x ) ⋅ V

    其中v为区域R的体积,我们可以对公式进行变形,可以得到:

    f(x)=p(x)V=k/nV f ( x ) = p ( x ) V = k / n V

    上面简单的公式可以让计算给定点 x x 的概率密度,通过计算有多少点落入确定性区域。

    确定区域的两种不同的方法

    一种方法是固定体积(volume)如下图,原理是取一个固定大小的区域R,观察有多少样本落入其中。

    这里写图片描述
    另外一种方法是样本数目K固定;k近邻算法就是这个原理,即是,对于一定大小的样本总数,我们取能框住k个样本的区域R
    这里写图片描述

    3D- hypercubes

    这里写图片描述

    The window function

    如上面所示,我们可以可视化区域R,也就很容易计算出多少点在区域内,数学表达上是:

    ϕ(u)=[10|uj|1/2;j=1,2,...,dotherwise ϕ ( u ) = [ 1 | u j | ≤ 1 / 2 ; j = 1 , 2 , . . . , d 0 o t h e r w i s e

    扩展概念(立方体核,hyercube window)我们可以得到下面的概念:
    通过下面的公式可以获得落入该区域的样本个数Kn

    kn=i=1nϕ(xxi,hn) k n = ∑ i = 1 n ϕ ( x − x i , h n )

    式中:

    u=(xxihn) u = ( x − x i h n )

    也就是:

    ϕ(xxi,hn)=[10xxihn1/2;j=1,2,...,dotherwise ϕ ( x − x i , h n ) = [ 1 | x − x i h n | ≤ 1 / 2 ; j = 1 , 2 , . . . , d 0 o t h e r w i s e

    进而我们可以的得到Rn的概率

    而将将简单的立方体核函数替换掉,采用高斯核:

    ϕ(xxi,hn)=1(2π)d/2|Σ|1/2exp((xxi)TΣ1(xxi)2h2) ϕ ( x − x i , h n ) = 1 ( 2 π ) d / 2 | Σ | 1 / 2 exp ⁡ ( − ( x − x i ) T Σ − 1 ( x − x i ) 2 h 2 )

    效果图

    Parzen window estimation

    基于上述公式,我们可以得到:

    pn(x)=1ni=1n1hdϕ[xxi,hn] p n ( x ) = 1 n ∑ i = 1 n 1 h d ϕ [ x − x i , h n ]

    式中有:

    Vn=hd V n = h d

    k=i=1nϕ[xxi,hn] k = ∑ i = 1 n ϕ [ x − x i , h n ]

    Parzen-window技术的关键性参数

    这有两个关键性参数:
    - 核函数(kernel function)
    - 核宽度(window width)

    核密度估计需要满足如下条件:
    1) 有限值非负密度函数:

    f(y,h)dy=1 ∫ f ( y , h ) d y = 1

    2) 对于核宽度的要求

    limnnhd(n)= lim n → ∞ ⁡ n h d ( n ) = ∞

    limnhd=0 lim n → ∞ ⁡ h d = 0

    limnkn= lim n → ∞ ⁡ k n = ∞

    一式原因在于:
    limnpn(x)=p(x) lim n → ∞ ⁡ p n ( x ) = p ( x )

    limnknnV=p(x) lim n → ∞ ⁡ k n n ⋅ V = p ( x )

    构造Parzen window估计函数

    def parzen_estimation(mu, sigma, mode='gauss'):
        """
        Implementation of a parzen-window estimation
        Keyword arguments:
            x: A "nxd"-dimentional numpy array, which each sample is
                      stored in a separate row (=training example)
            mu: point x for density estimation, "dx1"-dimensional numpy array
            sigma: window width
        Return the density estimate p(x)
        """
    
        def log_mean_exp(a):
            max_ = a.max(axis=1)
            return max_ + np.log(np.exp(a - np.expand_dims(max_, axis=0)).mean(1))
    
        def gaussian_window(x, mu, sigma):
            a = (np.expand_dims(x, axis=1) - np.expand_dims(mu, axis=0)) / sigma
            b = np.sum(- 0.5 * (a ** 2), axis=-1)
            E = log_mean_exp(b)
            Z = mu.shape[1] * np.log(sigma * np.sqrt(np.pi * 2))
            return np.exp(E - Z)
    
        def hypercube_kernel(x, mu, h):
            n, d = mu.shape
            a = (np.expand_dims(x, axis=1) - np.expand_dims(mu, axis=0)) / h
            b = np.all(np.less(np.abs(a), 1/2), axis=-1)
            kn = np.sum(b.astype(int), axis=-1)
            return kn / (n * h**d)
    
        if mode is 'gauss':
            return lambda x: gaussian_window(x, mu, sigma)
        elif mode is 'hypercube':
            return lambda x: hypercube_kernel(x, mu, h=sigma)

    将Parzen Window 方法应用于高斯数据集

    我们构造如下数据集:

    f(x)=1(2π)d/2|Σ|1/2exp((xxi)TΣ1(xxi)2) f ( x ) = 1 ( 2 π ) d / 2 | Σ | 1 / 2 exp ⁡ ( − ( x − x i ) T Σ − 1 ( x − x i ) 2 )

    设定:
    u=[00]Σ=[1001] u = [ 0 0 ] Σ = [ 1 0 0 1 ]

    import numpy as np
    
    # Generate 10,000 random 2D-patterns
    mu_vec = np.array([0,0])
    cov_mat = np.array([[1,0],[0,1]])
    x_2Dgauss = np.random.multivariate_normal(mu_vec, cov_mat, 10000)
    
    print(x_2Dgauss.shape)

    这里写图片描述

    不同核函数对于pdf的估计效果不同

    这里写图片描述

    可以看到高斯核函数的概率密度估计过渡更加自然,而超维度的高斯估计则虽然相比较精度较高一些但是毛刺比较严重。

    模型[0, 0]
    真实值0.15915494309189535
    hypercube(h=0.3)0.15444444
    Gauss(h=0.3)0.14109129
    import matplotlib.pyplot as plt
        from mpl_toolkits.mplot3d import Axes3D
        from matplotlib import cm
        from matplotlib.ticker import LinearLocator, FormatStrFormatter
    
        # Make data
        mu_vec = np.array([0, 0])
        cov_mat = np.array([[1, 0], [0, 1]])
        x_2Dgauss = np.random.multivariate_normal(mu_vec, cov_mat, 10000)
    
        # Pdf estimation
        def pdf_multivaraible_gauss(x, mu, cov):
            part1 = 1 / ((2 * np.pi) ** (len(mu)/2) * (np.linalg.det(cov)**(1/2)))
            part2 = (-1/2) * (x-mu).T.dot(np.linalg.inv(cov)).dot((x-mu))
            return float(part1 * np.exp(part2))
    
        ph = parzen_estimation(x_2Dgauss, 0.3, mode='hypercube')
        pg = parzen_estimation(x_2Dgauss, 0.3, mode='gauss')
        print(pdf_multivaraible_gauss(np.array([[0], [0]]), np.array([[0], [0]]), cov_mat))
        print(ph([[0, 0]]))
        print(pg([[0, 0]]))
    
        x = np.linspace(-5, 5, 100)
        x, y = np.meshgrid(x, x)
        zg = []
        zt = []
        zh = []
        for i, j in zip(x.ravel(), y.ravel()):
            zg.append(pg([[i, j]]))
            zh.append(ph([[i, j]]))
            zt.append(pdf_multivaraible_gauss(np.array([[i], [j]]), np.array([[0], [1]]), cov_mat))
        zg = np.asarray(zg).reshape(100, 100)
        zh = np.asarray(zh).reshape(100, 100)
        zt = np.asarray(zt).reshape(100, 100)
    
        # Plot the surface
        fig = plt.figure(figsize=(18, 6))
        ax1 = fig.add_subplot(131, projection='3d')
        surf = ax1.plot_surface(x, y, zg, rstride=1, cstride=1,
                                cmap=cm.coolwarm, antialiased=False)
        # Customize the z axis
        ax1.zaxis.set_major_locator(LinearLocator(10))
        ax1.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
        ax1.set(zlim=[0, 0.2], xlabel='x', ylabel='y', zlabel='p(x,y)',
                title="Gauss Bivariate Gaussian density")
    
        # Re-Plot
        ax2 = fig.add_subplot(132, projection='3d')
        ax2.plot_surface(x, y, zt, rstride=1, cstride=1, cmap=cm.coolwarm, antialiased=False)
    
        # Customize the z axis
        ax2.zaxis.set_major_locator(LinearLocator(10))
        ax2.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
        ax2.set(zlim=[0, 0.2], xlabel='x', ylabel='y', zlabel='p(x,y)',
                title="True Bivariate Gaussian density")
    
        # Re-Plot
        ax3 = fig.add_subplot(133, projection='3d')
        ax3.plot_surface(x, y, zh, rstride=1, cstride=1, cmap=cm.coolwarm, antialiased=False)
    
        # Customize the z axis
        ax3.zaxis.set_major_locator(LinearLocator(10))
        ax3.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
        ax3.set(zlim=[0, 0.2], xlabel='x', ylabel='y', zlabel='p(x,y)',
                title="Hypercube Bivariate Gaussian density")
    
        # Add a color bar which maps values to colors.
        fig.savefig("./Gauss_kernel_{}.png".format('Bivariate_Gaussian'))
        plt.show()

    不同核宽度对pdf估计的影响

    这里写图片描述
    这里写图片描述

    可以看到当核宽度非常小(0.01)时, pdf已经不可控, 而当h=0.5, 估计效果又有所下降。因此如何能根据数据样本来确定核宽度大小,是一个非常重要的问题。

        import matplotlib.pyplot as plt
        from mpl_toolkits.mplot3d import Axes3D
        from matplotlib import cm
        from matplotlib.ticker import LinearLocator, FormatStrFormatter
    
        # Make data
        mu_vec = np.array([0, 0])
        cov_mat = np.array([[1, 0], [0, 1]])
        x_2Dgauss = np.random.multivariate_normal(mu_vec, cov_mat, 10000)
    
        # Pdf estimation
        def pdf_multivaraible_gauss(x, mu, cov):
            part1 = 1 / ((2 * np.pi) ** (len(mu)/2) * (np.linalg.det(cov)**(1/2)))
            part2 = (-1/2) * (x-mu).T.dot(np.linalg.inv(cov)).dot((x-mu))
            return float(part1 * np.exp(part2))
    
        pg1 = parzen_estimation(x_2Dgauss, 0.01, mode='gauss')
        pg2 = parzen_estimation(x_2Dgauss, 0.1, mode='gauss')
        pg3 = parzen_estimation(x_2Dgauss, 0.5, mode='gauss')
        x = np.linspace(-5, 5, 100)
        x, y = np.meshgrid(x, x)
        zg = []
        zh = []
        zt = []
        for i, j in zip(x.ravel(), y.ravel()):
            zg.append(pg1([[i, j]]))
            zh.append(pg2([[i, j]]))
            zt.append(pg3([[i, j]]))
        zg = np.asarray(zg).reshape(100, 100)
        zh = np.asarray(zh).reshape(100, 100)
        zt = np.asarray(zt).reshape(100, 100)
    
        # Plot the surface
        fig = plt.figure(figsize=(18, 6))
        ax1 = fig.add_subplot(131, projection='3d')
        surf = ax1.plot_surface(x, y, zg, rstride=1, cstride=1,
                                cmap=cm.coolwarm, antialiased=False)
        # Customize the z axis
        ax1.zaxis.set_major_locator(LinearLocator(10))
        ax1.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
        ax1.set(zlim=[0, 0.2], xlabel='x', ylabel='y', zlabel='p(x,y)',
                title="Bivariate Gaussian density-0.01")
    
        # Re-Plot
        ax2 = fig.add_subplot(132, projection='3d')
        ax2.plot_surface(x, y, zh, rstride=1, cstride=1, cmap=cm.coolwarm, antialiased=False)
    
        # Customize the z axis
        ax2.zaxis.set_major_locator(LinearLocator(10))
        ax2.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
        ax2.set(zlim=[0, 0.2], xlabel='x', ylabel='y', zlabel='p(x,y)',
                title="Bivariate Gaussian density-0.1")
    
        # Re-Plot
        ax3 = fig.add_subplot(133, projection='3d')
        ax3.plot_surface(x, y, zt, rstride=1, cstride=1, cmap=cm.coolwarm, antialiased=False)
    
        # Customize the z axis
        ax3.zaxis.set_major_locator(LinearLocator(10))
        ax3.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
        ax3.set(zlim=[0, 0.2], xlabel='x', ylabel='y', zlabel='p(x,y)',
                title="Bivariate Gaussian density-0.5")
    
        # Add a color bar which maps values to colors.
        fig.savefig("./Gauss_kernel_{}.png".format('Gauss_width'))
        plt.show()

    已知真实分布情况下

    我们可以计算出最好的核宽度为,通过误差图来观察
    这里写图片描述

    可以看到 h = 0.21529369369369367

    当然大多数情况下并不知道真实的概率分布,那可以通过最大似然法来选择核宽度

    首先介绍似然性

    Likelihood

    可能性其实就是所有采的样本在你所建立的模型中概率的乘积,让这个乘积最大就是最大似然法,而为了计算方便,采用对数的方法,将
    乘积运算转换为加法运算。

    对parzen_ll的理解

    终于到了主题:

    def theano_parzen(mu, sigma):
        """
        Credit: Yann N. Dauphin
        """
    
        x = T.matrix()
        mu = theano.shared(mu)
        a = ( x.dimshuffle(0, 'x', 1) - mu.dimshuffle('x', 0, 1) ) / sigma
        E = log_mean_exp(-0.5*(a**2).sum(2))
        Z = mu.shape[1] * T.log(sigma * numpy.sqrt(numpy.pi * 2))
    
        return theano.function([x], E - Z)

    这个函数用于创造一个parzen的计算器,其中x的大小为2D向量,通过dimshuffule来变为Ax1xB 这样的向量,mu为图像的所有像素的值,sigma对于所有维都是固定的均为sigma。通过创造一个log_mean_exp函数计算平均值

    def log_mean_exp(a):
        """
        Credit: Yann N. Dauphin
        """
    
        max_ = a.max(1)
    
        return max_ + T.log(T.exp(a - max_.dimshuffle(0, 'x')).mean(1))

    定义好Parzen函数之后,通过get_nll函数获得似然值,其中的操作是每次输入一个batch_size,最后对各个batch_size求取平均值

    def get_nll(x, parzen, batch_size=10):
        """
        Credit: Yann N. Dauphin
        """
    
        inds = range(x.shape[0])
        n_batches = int(numpy.ceil(float(len(inds)) / batch_size))
    
        times = []
        nlls = []
        for i in range(n_batches):
            begin = time.time()
            nll = parzen(x[inds[i::n_batches]])
            end = time.time()
            times.append(end-begin)
            nlls.extend(nll)
    
            if i % 10 == 0:
                print i, numpy.mean(times), numpy.mean(nlls)
    
        return numpy.array(nlls)

    其中可以追查mu的来源,mu ==samples ,于是在下面我们可以发现出mu的蛛丝马迹,reshape函数将三个通道的图片扁平为一维向量,而整个空间定格为整个图片的像素点数。

    samples = model.generator.sample(args.num_samples).eval()
        output_space = model.generator.mlp.get_output_space()
        if 'Conv2D' in str(output_space):
            samples = output_space.convert(samples, output_space.axes, ('b', 0, 1, 'c'))
            samples = samples.reshape((samples.shape[0], numpy.prod(samples.shape[1:])))
        del model
        gc.collect()

    值得一提的是为了获得较好的估计值,他采用验证集来确定最大的似然值对应的sigma,验证集采用的是50000-60000的MNIST字体。

    def cross_validate_sigma(samples, data, sigmas, batch_size):
    
        lls = []
        for sigma in sigmas:
            print sigma
            parzen = theano_parzen(samples, sigma)
            tmp = get_nll(data, parzen, batch_size = batch_size)
            lls.append(numpy.asarray(tmp).mean())
            del parzen
            gc.collect()
    
        ind = numpy.argmax(lls)
        return sigmas[ind]

    Parzen Window的公式大致对的上,明确了输入(对于MNIST)是60000x1x784的一个批次,大约10个,主要可能考虑到对于高达784的多变量高斯分布计算量必然很大。
    然后考虑到likelihood的计算公式4

    将Parzen Window估计概率并应用于求解最大似然法,目前来说,对求解似然性于不是最好的办法,但是也没有更好的办法。其基本思路大致是,产生的样本通过高斯核Parzen窗口法计算出一个概率模型Pg(784维的高斯分布),然后估计测试样本的概率,从而计算出在该分布下的对数似然性,方差参数采用交叉验证来获得。

    最大似然法

    import matplotlib.pyplot as plt
        from mpl_toolkits.mplot3d import Axes3D
        from matplotlib import cm
        from matplotlib.ticker import LinearLocator, FormatStrFormatter
    
        # Make data
        np.random.seed(2017)
        mu_vec = np.array([0, 0])
        cov_mat = np.array([[1, 0], [0, 1]])
        x_2Dgauss = np.random.multivariate_normal(mu_vec, cov_mat, 10000)
        x_test = np.random.multivariate_normal(mu_vec, cov_mat, 1000)
    
        pg = parzen_estimation(x_2Dgauss, 0.01, mode='gauss')
        sigma, nll = cross_validate_sigma(x_2Dgauss, x_test, np.linspace(1e-4, 1, 20), batch_size=100)
        fig = plt.figure(figsize=(6, 6))
        ax = fig.gca()
        ax.plot(np.linspace(1e-4, 1, 20), nll,  '-*r')
        ax.set(xlabel='log likelihood', ylabel='\sigma value', title='NLL method ')
        print(sigma)
        fig.savefig('./{}.png'.format('NLL_method'))
        plt.show()
        # Pdf estimation
        def pdf_multivaraible_gauss(x, mu, cov):
            part1 = 1 / ((2 * np.pi) ** (len(mu)/2) * (np.linalg.det(cov)**(1/2)))
            part2 = (-1/2) * (x-mu).T.dot(np.linalg.inv(cov)).dot((x-mu))
            return float(part1 * np.exp(part2))
    
    
        tr = pdf_multivaraible_gauss(np.array([[0], [0]]), np.array([[0], [0]]), cov_mat)
        errs = []
        sigmas = np.linspace(1e-4, 1, 1000)
        for sigma in sigmas:
            pg = parzen_estimation(x_2Dgauss, sigma, mode='gauss')
            err = np.abs(pg(np.array([[0, 0]]))-tr)
            errs.append(err)
        fig = plt.figure(figsize=(6, 6))
        ax = fig.gca()
        ax.plot(sigmas, errs, '-*b')
        ax.set(xlabel='AE', ylabel='\sigma value', title='AE method ')
        ind = np.argmin(errs)
        print(sigmas[ind])
        fig.savefig('./{}.png'.format('AE_method'))
        plt.show()

    最大似然法

    可以看到在h = 0.21060526315789474, 附近似然性取得最大值

    方法最优值
    最大似然法0.21060526315789474
    误差法0.21529369369369367

    可以看到极大似然法可以有效估计核宽度。

    Parzen window 技术的优缺点:

    Parzen window技术作为一种非参数方法,有着和其他方法一样的缺点,就是每次估计需要整个样本参与运算,而并非是参数估计,只是带入参数计算。
    几个挑战:
    1) 数据样本的大小, Parzen window的计算复杂度为 n2d n 2 d , 其中 n n 为训练样本数目, 而d为样本维度。

    2) 合适的核宽度的选择, 一般来说:

    hn1n h n ∝ 1 n

    hn1logn h n ∝ 1 l o g ( n )

    3) 核函数的选择

    4) 应用于两个方面:Bayes估计与互信息的求取

    展开全文
  • 本文介绍了非参数估计的原理,着重介绍了Parzen窗法和K近邻法以及他们的Matlab实现,定性地讨论了Parzen窗法的h参数和K近邻法的k参数的选取方法,比较了两种算法的优劣之处。
  • 在基于熵的音频相似度度量中,用到Parzen窗法对所提取的MFCC参数进行概率密度函数估计,其MATLAB实现如下:function p=Parzen(xi,x,h1,f)%xi为样本,x为概率密度函数的自变量的取值,%h1为样本数为1时的窗宽,f为窗...
  • P(ωj​∣x) 文章目录 一 概率密度的估计 二 Parzen窗方法 2.1 原理 2.2 窗宽 h n h_n hn​的影响 三 K-Nearest Neighbor方法 四 后验概率的估计 五 最近邻规则 参考 一 概率密度的估计 估计类条件概率密度的最基本...
  • 用于实现parzen窗分类的matlab代码
  • matlab中提供了核平滑密度估计函数... %红色为参考 PRML上核密度估计(parzen窗密度估计)的实现: %% Demonstrate a non-parametric (parzen) density estimator in 1D %% % This file is from pmtk3.googlecode....
  • Parzen_parzen_parzenwindowmatlab_parzenwindow_源码.zip

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,417
精华内容 566
关键字:

parzen

友情链接: LockScreen.zip