精华内容
下载资源
问答
  • 提出了一获取BPA非参数方法。 该方法可以处理分类问题中多属性数据集。 数据集样本每个属性值都被视为随机量。 使用训练数据计算其非参数概率密度函数(PDF),可以将其视为对应属性的概率模型。 然后,...
  • 前置知识:高斯消元法 博主理解浅显,只能膜piao别人总结 ...咳咳……还是简单介绍两句...表示方法:矩阵 tips:一般情况下高斯消元可能出现无解、无穷解情况,我做法里面没有判断,由于矩阵对角线上不会出现0。 ...

    前置知识:高斯消元法
    博主理解浅显,只能膜piao别人的总结
    戳别人家的题解
    咳咳……还是简单介绍两句
    它可以用 O(n3)O(n^3) 的复杂度解出 n 元方程组
    表示方法:矩阵
    tips:一般情况下高斯消元可能出现无解、无穷解的情况,我的做法里面没有判断,由于矩阵对角线上不会出现0。

    概率与期望:

    概率:发生的可能性
    期望:概率的加权平均数(表示对权值的一个预期值)
    eg. 某图中从起点经过 i 步到达终点的可能性为p[i],则到达终点的期望步数为p[i]i\sum p[i]*i

    对于期望的小理解:
    其实很简单,在物理中,我们学习过重心的概念,可以把一个物体当作一个质点来考虑,对于期望其实有着类似的道理。期望与权值本身是不同的,但是期望表达的是权值的一个大概分布位置,权值可能有很多很多个,但是期望只有一个。同样可以说,重心就是物质质量的期望分布位置。

    期望的好处在于,当我们求的东西(如期望)与物体本身权值无关时,我们可以用期望代替计算这个物体的权值。(想想那句话,当研究对象与物体的形状(质量分布)无关时,我们可以把它当作质点处理)
    于是我们可以借助物理的知识来比较好的理解期望!

    用一道题来结合期望与高斯消元

    [Hnoi2013]游走(高斯消元)

    不解释题意差评
    vjudge
    bzoj
    还是解释一下吧
    无向图,随机游走,从1号点走到nn号点 ,给每条边编号,经过代价即为编号,求最小期望代价。

    假如能够求出每条边的期望经过次数,剩下的部分就很水了(排序编号直接算)。

    关键是求每条边的期望经过次数
    发现:除了终点以外,其余的点只要被经过1次,就必然会出去一次,出去的这一次由于是随机游走,则有可能对这个点连接的任意一条边造成贡献。
    设一条边 (u,v)(u,v)连接了不是终点的两个点uvu、v
    siz[u]siz[u]表示u连接了siz[u]siz[u]条边
    f[u]f[u]表示uu点的期望经过次数。
    (这里的经过指一定要从那个点出来的经过)
    E(u,v)=f[u]siz[u]+f[v]siz[v]E(u,v)=\frac{f[u]}{siz[u]}+\frac{f[v]}{siz[v]}
    对于终点:直接f[n]=0f[n]=0就好了

    关键是求每个点的期望经过次数
    对于每个点,它们都有可能从任何一个相邻点转移过来
    因此有 f[u]=f[v]siz[v](vu)f[u]=\sum\frac{f[v]}{siz[v]}(v与u相邻)
    此时想要单独解出任何一个点都是不行的,但是可以发现我们得到了n1n-1个(除去终点)方程组,再加上f[n]=0其实一共是n个,也就是解的出来。
    构造矩阵进行高斯消元即可。

    (丢出一只又奇怪又慢的代码,InitInit打的之丑陋,泪奔.jpg)
    fc数组就是构造出来的方程矩阵,InitInit是把它传进去……
    主要是这样子的话就可以连着一个structstruct直接Ctrl c下来粘到另一份代码上面搞高斯消元了(懒人操作
    (如果数组大小不同InitInit里x+=N;那里需要修改)
    主函数专心构造fcfc矩阵就好啦,把它丢进去就不管了。

    #include<cstdio>
    #include<vector>
    #include<algorithm>
    using namespace std;
    typedef long long LL;
    const int INF=0x3f3f3f3f;
    const int N=505;
    const int M=N*N/2;
    #define eps 1e-7
    int read(){
    	bool f=0;int x=0;char c=getchar();
    	while(c<'0'||'9'<c){if(c=='-')f=1;c=getchar();}
    	while('0'<=c&&c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
    	return !f?x:-x;
    }
    struct GAUSS {
    	int n; double *a[N];
    	double ans[N];
    	void Init(int _n,double *x) {
    		n=_n;
    		for(int i=0;i<=n;i++) {
    			a[i]=x;
    			x+=N;
    		}
    	}
    	inline double Abs(double x){return x>0?x:-x;}
    	bool Guass(){
    		double tmp;
    		for(int i=1;i<=n;i++) {
    			int p=i;
    			for(int j=i+1;j<=n;j++)
    				if(Abs(a[j][i])>Abs(a[p][i]))
    					p=j;
    			swap(a[p],a[i]);
    			if(Abs(a[i][i])<eps)
    				return false;
    			for(int j=1;j<=n;j++)
    				if(j!=i) {
    					tmp=a[j][i]/a[i][i];
    					a[j][i]=0;
    					for(int k=i+1;k<=n+1;k++)
    						a[j][k]-=tmp*a[i][k];
    				}
    		}
    		for(int i=1;i<=n;i++)
    			ans[i]=a[i][n+1]/a[i][i];
    		return true;
    	}
    }GE;
    int n,m,siz[N];
    vector<int>G[N];
    double fc[N][N];
    int s[M],t[M];
    double edge[M];
    int main(){
    	n=read(); m=read();
    	for(int i=1;i<=m;i++) {
    		s[i]=read(),t[i]=read();
    		G[s[i]].push_back(t[i]);
    		G[t[i]].push_back(s[i]);
    		siz[s[i]]++,siz[t[i]]++;
    	}
    	for(int u=1;u<n;u++) {
    		for(int i=0;i<siz[u];i++)
    			fc[u][G[u][i]]=-1.0/siz[G[u][i]];
    		fc[u][u]=1;
    	}
    	siz[n]=1; fc[n][n]=1;
    	fc[1][n+1]=1;
    	GE.Init(n,&fc[0][0]);
    	GE.Guass();
    	for(int i=1;i<=m;i++)
    		edge[i]=GE.ans[s[i]]/siz[s[i]]+GE.ans[t[i]]/siz[t[i]];
    	sort(edge+1,edge+m+1);
    	double tot=0;
    	for(int i=1;i<=m;i++)
    		tot+=edge[i]*(m-i+1);
    	printf("%.3lf\n",tot);
    	return 0;
    }
    

    扯明白了一道题,可以再扯一道

    [CF963E]Circles of Waiting(带状矩阵)

    从坐标轴上(0,0)(0,0)开始,已知向上左下右的概率是p1,p2,p3,p4p1,p2,p3,p4(满足p1+p2+p3+p4=1p1+p2+p3+p4=1
    问期望走多少步后与原点距离大于r (x2+y2>r2)(x^2+y^2>r^2)
    (r<=50)( r<=50 )
    f[i]=p1(f[]+1)+p2(f[]+1)+p3(f[]+1)+p4(f[]+1)f[i]=p1*(f[上]+1)+p2*(f[左]+1)+p3*(f[下]+1)+p4*(f[右]+1)
    f[i]=p1f[]+p2f[]+p3f[]+p4f[]+1f[i]=p1*f[上]+p2*f[左]+p3*f[下]+p4*f[右]+1

    假设半径为rr 的圆内有n个点,那么必然有nn个方程
    但是半径为50的圆内有7000+的点,O(n3)O(n^3)的级别太大

    将所有点按照横纵坐标排序编号,发现任意一个点和它的转移点的编号差为最大为2r2r,这时候构造出来的方程矩阵为:
    ii行表示编号为ii的点列出来的方程,此处 d=2rd=2r,灰色部分都不可能会有值,因为第i行的任何一个元与 ii 的编号差不会大于dd
    这样的矩阵被称为 带状矩阵(常见于网格图!)
    在这里插入图片描述
    面对一个带状矩阵,首先明确我们最终目的是消除矩阵内的元素到只留下对角线,特别注意不能破坏矩阵的带状性质(交换两行)。
    先考虑消除红色部分:step1
    枚举每一行,使用这一行的去消以后的行:
    可以发现当前行只需要枚举dd个(因为这一行后面都是0了)
    还可以发现往后只需要枚举dd行(因为再下面的这一列也没了)
    step2
    这样子做下来是 O(d2n)O(d^2n)
    变成这样:
    在这里插入图片描述
    此时第nn行已经只有一个元,得到解,把它回代到前面的dd个方程里面去即可得到每一个解,这个过程O(dn)O(dn)
    细节是常数项那一列不在带状里面,运算需要单独写出来。

    代码还是丢出来:

    #include<cstdio>
    #include<algorithm>
    using namespace std;
    typedef long long LL;
    #define ID(x,y) id[x+R][y+R]
    const int MOD=1e9+7;
    const int R=52;
    
    int r,a1,a2,a3,a4;
    int id[R*2][R*2],idcnt;
    LL p1,p2,p3,p4;
    LL Pow(LL x,int p) {
    	if(p==0) return 1;
    	if(p&1) return x*Pow(x*x%MOD,p>>1)%MOD;
    	return Pow(x*x%MOD,p>>1);
    }
    int fc[8000][8000];
    struct GAUSS {
    	int n; int *a[8000];
    	void Init(int _n,int *x) {
    		n=_n;
    		for(int i=0;i<=n;i++) {
    			a[i]=x;
    			x+=8000;
    		}
    	}
    	inline double Abs(double x){return x>0?x:-x;}
    	LL Guass(){
    		LL tmp;
    		int d=2*r;
    		for(int i=1;i<=n;i++) {
    			//if(Abs(a[i][i])<eps) return false;
    			LL inv=Pow(a[i][i],MOD-2);
    			for(int j=i+1;j<=i+d&&j<=n;j++)
    				if(j!=i&&a[j][i]) {
    					tmp=a[j][i]*inv%MOD;
    					a[j][i]=0;
    					for(int k=i+1;k<=i+d&&k<=n;k++)
    						a[j][k]=(a[j][k]-tmp*a[i][k])%MOD;
    					a[j][n+1]=(a[j][n+1]-tmp*a[i][n+1])%MOD;
    				}
    		}
    		int goal=ID(0,0);
    		for(int i=n;i>=goal;i--) {
    			LL inv=Pow(a[i][i],MOD-2);
    			int &t=a[i][n+1];
    			t=inv*t%MOD;
    			for(int j=i-1;j>=goal;j--)
    				a[j][n+1]=(a[j][n+1]-(LL)a[j][i]*t)%MOD;
    		}
    		return a[goal][n+1];
    	}
    }GE;
    int main() {
    	scanf("%d %d %d %d %d",&r,&a1,&a2,&a3,&a4);
    	LL inv=Pow(((LL)a1+a2+a3+a4)%MOD,MOD-2);
    	p1=a1*inv%MOD; p2=a2*inv%MOD; p3=a3*inv%MOD; p4=a4*inv%MOD;
    	for(int x=-r;x<=r;x++)
    		for(int y=-r;y<=r;y++)
    			if(x*x+y*y<=r*r)
    				ID(x,y)=++idcnt;
    	for(int x=-r;x<=r;x++)
    		for(int y=-r;y<=r;y++)
    			if(int f=ID(x,y)) {
    				fc[f][f]=-1;
    				if(int t=ID(x-1,y))
                        fc[f][t]=p1;
                    if(int t=ID(x,y-1))
                        fc[f][t]=p2;
                    if(int t=ID(x+1,y))
                        fc[f][t]=p3;
                    if(int t=ID(x,y+1))
                        fc[f][t]=p4;
                    fc[f][idcnt+1]=-1;
    			}
    	GE.Init(idcnt,&fc[0][0]);
    	printf("%d\n",(GE.Guass()+MOD)%MOD);
    	return 0;
    }
    

    做完题后:说实话确实没有想到去考虑什么无解、无穷解的东西
    毕竟……你说一个期望它无解或者无穷解会怎么样
    一脸懵逼.jpg

    [Topcoder12984]TorusSailing(主元法)

    vjudge
    Topcoder
    Topcoder12984
    在这个东西上面再次开始向右或向下等概率随机游走,问从(0,0)(0,0)走到(gx,gy)的期望步数,nmn、m为行列数
    nm<=100(n、m<=100)
    (强烈建议化终点为最右下角的点,起点按相对位置平移)

    刚看到这个网格图,令f[i]f[i]表示编号为i的点走到终点的期望步数

    f[i]=(f[]+f[])/2+1f[i]=(f[右]+f[下])/2+1
    我刷的一下掏出了带状矩阵:从左到右从上到下编号,d=md=m不是带状矩阵
    但是光是元的个数就达到了nmnm级别,这个的平方的内存吃不消啊。况且这个矩阵的左下角貌似有毒——它破坏了带状性质后,原先那样O(d2s)O(d^2s)的做法就不行了,还是得O(s3)O(s^3),送命了
    (其实我在想有没有一种编号方法可以保留带状性质,但我没构造出来……咕了它吧)

    回到题目背景,可以发现一点就是列出来的方程十分简单,而且只跟右下角方向的有关,如果只设下图中的红色部分为元,则所有格子都可以被表示出来
    solution
    Solution!
    单次表示的复杂度是O(n+m)O(n+m),转移O(nm)O(nm)次,复杂度O(n3)O(n^3)
    这样子表示出来之后,对于每个红色格子的转移式来列方程,元的个数被优化到了O(n)O(n)级别,直接高斯消元也就可以接受了。

    #include<cstdio>
    #include<iostream>
    #include<algorithm>
    using namespace std;
    typedef long double LD;
    #define eps 1e-9
    const int N=102;
    
    using namespace std;
    struct GAUSS {
    	int n; LD *a[N<<1];
    	LD ans[N<<1];
    	void Init(int _n,LD *x) {
    		n=_n;
    		for(int i=0;i<=n;i++) {
    			a[i]=x;
    			x+=(N<<1);
    		}
    	}
    	inline LD Abs(LD x){return x>0?x:-x;}
    	bool Guass() {
    		LD tmp;
    		for(int i=1;i<=n;i++) {
    			int p=i;
    			for(int j=i+1;j<=n;j++)
    				if(Abs(a[j][i])>Abs(a[p][i]))
    					p=j;
    			swap(a[p],a[i]);
    			if(Abs(a[i][i])<eps)
    				return false;
    			for(int j=1;j<=n;j++)
    				if(j!=i) {
    					tmp=a[j][i]/a[i][i];
    					a[j][i]=0;
    					for(int k=i+1;k<=n+1;k++)
    					a[j][k]-=tmp*a[i][k];
    				}
    		}
    		for(int i=1;i<=n;i++)
    			ans[i]=a[i][n+1]/a[i][i];
    			return true;
    	}
    }GE;
    int id;
    LD ep[N][N][N<<1];
    LD fc[N<<1][N<<1];
    class TorusSailing {
    	public:
    	LD expectedTime(int n,int m,int gx,int gy) {
    		int sx=n-1-gx,sy=m-1-gy;
    		for(int j=m-2;j>=0;j--)
    			ep[n-1][j][++id]=1;
    		for(int i=n-2;i>=0;i--)
    			ep[i][m-1][++id]=1;
    		for(int i=n-2;i>=0;i--)
    			for(int j=m-2;j>=0;j--) {
    				for(int k=1;k<=id+1;k++)
    					ep[i][j][k]=(ep[i+1][j][k]+ep[i][j+1][k])/2;
    				ep[i][j][id+1]++;
    			}
    		//ep[n-1][m-1]=(ep[n-1][0]+ep[0][m-1])/2+1
    		for(int j=1;j<m;j++) {
    			for(int k=1;k<=id+1;k++)
    				fc[j][k]=ep[n-1][m-1-j][k]-(ep[n-1][m-1-j+1][k]+ep[0][m-1-j][k])/2;
    			fc[j][id+1]=1-fc[j][id+1];
    		}
    		for(int i=1;i<n;i++) {
    			for(int k=1;k<=id+1;k++)
    				fc[m-1+i][k]=ep[n-1-i][m-1][k]-(ep[n-1-i][0][k]+ep[n-1-i+1][m-1][k])/2;
    			fc[m-1+i][id+1]=1-fc[m-1+i][id+1];
    		}
    		GE.Init(id,&fc[0][0]);
    		GE.Guass();
    		LD ans=0;
    		for(int k=1;k<=id;k++)
    			ans+=GE.ans[k]*ep[sx][sy][k];
    		ans+=ep[sx][sy][id+1];
    		cout<<ans<<endl;
    		return ans;
    	}
    };
    

    总结

    无向图or有向图带环的随机游走:思考转移方向+高斯消元
    带状矩阵可用于优化网格图(实际上我觉得可以在编号上做文章)
    主元法的本质即把消元的过程手动做了,从而使元的个数减少,往往是根据于比较特殊的转移(不会出现互相有关),最好是每一个位置都可以直接用元来表示,才使用主元法。

    展开全文
  • 文章目录0. 概率图模型家族族谱1. 条件随机场定义与形式1.1 定义1.1.1 CRF随机场定义:1.1.2 线性链CRF定义1.1.2.1 第一线性链CRF定义1.1.2.2 线性链CRF表达方式1...与族谱中个模型关系: 生成模型...

    0. 概率图模型家族族谱

    在这里插入图片描述
    与族谱中几个模型的关系:

    1. 生成模型,主要是为了计算P(X,Y)P(X,Y)
    2. 判别模型,主要是为了计算P(YX)P(Y|X)
      在这里插入图片描述

    1. 条件随机场的定义与形式

    有了马尔可夫随机场的基本知识后,来看一看它的一种典型代表:条件随机场(CRF)

    1.1 定义

    首先看三种链式模型
    在这里插入图片描述
    在上图中,设XXYY是随机变量,其中XX是观测变量,YY是目标变量(标记序列/状态序列)
    其中:
    (c)是我们之前提到的HMM模型。
    (a)是今天的主角——CRF.中的X与Y有相同图结构的线性链条件随机场
    (b)是(a)类型CRF的一个变种,也是一种条件随机场

    1.1.1 CRF随机场的定义:

    X\boldsymbol{X}Y\boldsymbol{Y}是随机变量,其中P(YX)P(\boldsymbol{Y|X})是在给定X\boldsymbol{X}的条件下Y\boldsymbol{Y}的分布,如果Y\boldsymbol{Y}构成了一个马尔可夫随机场,即:
    (1.1)P(YvX,Yw,wv)=P(YvX,Yw,wv) \begin{aligned} P(\boldsymbol{Y}_v|\boldsymbol{X},\boldsymbol{Y}_w,w \neq v)=P(\boldsymbol{Y}_v|\boldsymbol{X},\boldsymbol{Y}_w,w \sim v) \tag{1.1} \end{aligned} 在这里插入图片描述

    1.1.2 线性链CRF的定义

    1.1.2.1 第一种线性链CRF的定义

    在这里插入图片描述
    根据马尔可夫随机场-基本概念中的因子、MRF的概念,X与Y有相同图结构的线性链条件随机场的线性链条件随机场可以看作是:

    1.1.2.2 线性链CRF的表达方式

    1. 因子表示法

    (1.2)P(YX)=1Z(X)P~(YX)P~(YX)=t=2Tϕ(yt1,yt,xt)Z(X)=YP~(YX) \begin{aligned} P(\boldsymbol{Y}|\boldsymbol{X})=&amp;\frac{1}{Z(\boldsymbol{X})}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})\\ \widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})=&amp;\prod_{t=2}^{T}\phi(y_{t-1},y_t,x_t)\\ Z(\boldsymbol{X})=&amp;\sum_{\boldsymbol{Y}}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) \tag{1.2} \end{aligned}

    2. 参数化形式

    首先要明确俩个概念:

    1. 在这里,由于涉及到状态变量观测变量,我们把因子定义为:
      (1.3)ϕ(Yt1,Yt,Xt)=ϕ1(Yt1,Yt,Xt)ϕ2i(Yt,Xt) \phi(Y_{t-1},Y_t,X_t)=\phi_1(Y_{t-1},Y_t,X_t)*\phi_2i(Y_t,X_t) \tag{1.3}
      其中,ϕ1(Yt1,Yt,Xt)\phi_1(Y_{t-1},Y_t,X_t)表示转移的操作,相当于图中的边,ϕ2(Yt,Xt)\phi_2(Y_t,X_t)表示状态的操作,相当于图中的点。
    2. 马尔可夫随机场-基本概念中提到了一种很牛逼的表示法:对数表示法

    综上,我们把P~(YX)\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})写成以下形式:
    (1.4)P~(YX)=exp(ikλikfi1,iik(yi1,yi,x)+ilμlfi1,iil(yi,x)) \begin{aligned} \widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) =&amp;\exp(\sum_{ik}\lambda_{ik}f^{ik}_{i-1,i}(y_{i-1},y_i,x)+\sum_{il}\mu_lf^{il}_{i-1,i}(y_i,x))\\ \tag{1.4} \end{aligned}

    注:李航老师的《统计学习方法中》把特征函数定义成了以下形式,其实意思是一样的。

    1. tkt_k为转移特征,对应fi1,iik(yi1,yi,x)f^{ik}_{i-1,i}(y_{i-1},y_i,x)。取值为0或1,依赖于前一时刻当前时刻输入变量
    2. sls_l为状态特征,对应fi1,iil(yi,x)f^{il}_{i-1,i}(y_i,x)。取值为0或1,依赖于当前时刻输入变量
    3. λk\lambda_ktkt_k的权值。
    4. μl\mu_lsls_l的权值。

    P(YX)P(Y|X)为线性链条件随机场,则在随机变量XX取值为xx的条件下,随机变量Y取值为yy的条件概率具有如下形式:
    (1.5)P(YX)=1Z(X)P~(YX)P~(YX)=exp(ikλktk(yi1,yi,x,i)+ilμlsl(yi,x,i))Z(X)=YP~(YX) \begin{aligned} P(\boldsymbol{Y}|\boldsymbol{X})=&amp;\frac{1}{Z(\boldsymbol{X})}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})\\ \widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) =&amp;\exp(\sum_{ik}\lambda_{k}t_k(y_{i-1},y_i,x,i)+\sum_{il}\mu_ls_l(y_i,x,i))\\ Z(\boldsymbol{X})=&amp;\sum_{\boldsymbol{Y}}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) \tag{1.5} \end{aligned}

    式中,tkt_ksls_l是特征函数,λk\lambda_kμl\mu_l是对应的权值,Z(x)Z(x)是规范化因子,求和是在所有可能的输出序列上进行的。

    举个栗子:
    在这里插入图片描述
    解:

    ii Yi1Y_{i-1} YiY_{i} tt λ\lambda ss μ\mu
    1 Y1=1Y_{1}=1 0 s1s_1 1
    2 Y1=1Y_{1}=1 Y2=2Y_{2}=2 t1t_1 1 s2s_2 0.5
    3 Y2=2Y_{2}=2 Y3=2Y_{3}=2 t5t_5 0.2 s4s_4 0.5

    在这里插入图片描述

    3. 简化形式

    这种表示法没有什么难以理解的,通俗的说就是做了一个列表的拼接
    假设有K1K_1个转移特征,K2K_2个状态特征,总的特征记为KK,则有K=K1+K2K=K_1+K_2

    (1.6)fk(yi1,yi,x,i)={tk(yi1,yi,x,i)k=1,2,...,K1sl(si,x,i)l=K1+l;l=1,2,...,K2 f_k(y_{i-1},y_i,x,i)= \left\{\begin{matrix} t_k(y_{i-1},y_i,x,i) &amp; k=1,2,...,K_1 \\ s_l(s_i,x,i) &amp; l=K_1+l; l=1,2,...,K_2 \end{matrix}\right. \tag{1.6}
    fk(yi1,yi,x,i)f_k(y_{i-1},y_i,x,i)的理解:

    state f1(yi1,yi,x,i)f_1(y_{i-1},y_i,x,i) fK1(yi1,yi,x,i)f_{K_1}(y_{i-1},y_i,x,i) fK1+1(yi1,yi,x,i)f_{K_1+1}(y_{i-1},y_i,x,i) fK(yi1,yi,x,i)f_{K}(y_{i-1},y_i,x,i)
    t1(yi1,yi,x,i)t_1(y_{i-1},y_i,x,i) tK1(yi1,yi,x,i)t_{K_1}(y_{i-1},y_i,x,i) s1(yi,x,i)s_1(y_i,x,i) sl(yi,x,i)s_l(y_i,x,i)
    i=1
    i=2
    i=n

    所以,有nn个状态的线性链CRF可以表示为:
    (1.7)f(x,y)=i=1nfk(yi1,yi,x,i),k=1,2,...,K \begin{aligned} f(x,y)=\sum_{i=1}^{n}f_k(y_{i-1},y_i,x,i) , k=1,2,...,K \tag{1.7} \end{aligned}
    同样的,将转移特征状态特征的权重也做上述类似处理有:
    (1.8)wk={λkk=1,2,....,K1μll=K1+l;l=1,2,...,K2 w_k= \left\{\begin{matrix} \lambda_k &amp; k=1,2,....,K_1\\ \mu_l &amp; l=K_1+l; l=1,2,...,K_2 \end{matrix}\right. \tag{1.8}
    wkw_k的理解:

    w1w_1 wkw_k wk+1w_{k+1} wKw_K
    λ1\lambda_1 λK1\lambda_{K_1} μ1\mu_1 μl\mu_l

    综上所述:
    (1.9)P(YX)=1Z(X)P~(YX)P~(YX)=exp(k=1Kwkfk(y,x))Z(X)=YP~(YX) \begin{aligned} P(\boldsymbol{Y}|\boldsymbol{X})=&amp;\frac{1}{Z(\boldsymbol{X})}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})\\ \widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})=&amp;\exp(\sum_{k=1}^Kw_kf_k(y,x))\\ Z(\boldsymbol{X})=&amp;\sum_{\boldsymbol{Y}}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) \tag{1.9} \end{aligned}

    公式(1.8)中,ww表示权值向量:
    w=(w1,w2,...,wK)T \boldsymbol{w}=(w_1,w_2,...,w_K)^T
    公式(1.8)中,F(y,x)F(y,x)表示全局特征向量
    F(y,x)=(f1(y,x),fx(y,x),..,fk(y,x))T \boldsymbol{F}(y,x)=(f_1(y,x),f_x(y,x),..,f_k(y,x))^T
    所以,条件随机场写成w\boldsymbol{w}F(y,x)\boldsymbol{F}(y,x)的內积的形式有:
    (1.10)Pw(YX)=1Z(X)P~(YX)P~(YX)=exp(wF(y,x))Z(X)=YP~(YX) \begin{aligned} P_w(\boldsymbol{Y}|\boldsymbol{X})=&amp;\frac{1}{Z(\boldsymbol{X})}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})\\ \widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})=&amp;\exp(\boldsymbol{w}\boldsymbol{F}(y,x))\\ Z(\boldsymbol{X})=&amp;\sum_{\boldsymbol{Y}}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) \tag{1.10} \end{aligned}

    4. 矩阵形式

    在理解矩阵形式之前,需要换一个角度去思考:

    • 简化形式中,把特征表达为向量的形式。
    • 矩阵形式中,把状态表达为矩阵的形式。

    同样的,回到CRF的定义:
    (1.5)P(YX)=1Z(X)P~(YX)P~(YX)=exp(ikλktk(yi1,yi,x,i)+ilμlsl(yi,x,i))Z(X)=YP~(YX) \begin{aligned} P(\boldsymbol{Y}|\boldsymbol{X})=&amp;\frac{1}{Z(\boldsymbol{X})}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})\\ \widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) =&amp;\exp(\sum_{ik}\lambda_{k}t_k(y_{i-1},y_i,x,i)+\sum_{il}\mu_ls_l(y_i,x,i))\\ Z(\boldsymbol{X})=&amp;\sum_{\boldsymbol{Y}}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) \tag{1.5} \end{aligned}
    对于P~(YX)\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})来说,如果从每个状态转移的角度去看,会发现存在这样一个问题,那就是开始状态结束状态二者相对于中间状态都少了一个来源去处。因此,引入特殊的起点和终点状态标记y0=starty_0=starty1=stopy_1=stop

    那么,就可以列举出n+1n+1转移矩阵。其中,每个转移状态所“携带的概率” 应该为所有特征函数在该状态上所有取值的和,也就是转移矩阵,记为Wi(yi1,yix)W_i(y_{i-1},y_i|x),其取对数的结果记为MiM_i

    (1.11)Wi(yi1,yix)=k=1Kwkfk(yi1,yi,x,i) W_i(y_{i-1},y_i|x)=\sum_{k=1}^Kw_kf_k(y_{i-1},y_i,x,i) \tag{1.11}
    所以,另Mi(yi1,yix)M_i(y_{i-1},y_i|x)为:
    (1.12)Mi(yi1,yix)=exp(k=1Kwkfk(yi1,yi,x,i)) M_i(y_{i-1},y_i|x)=\exp(\sum_{k=1}^Kw_kf_k(y_{i-1},y_i,x,i)) \tag{1.12}
    则矩阵MiM_i为:
    (1.13)Mi(x)=[Mi(yi1,yix)] M_i(x)=[M_i(y_{i-1},y_i|x)] \tag{1.13}
    于是有:
    (1.5)P(YX)=1Z(X)P~(YX)P~(YX)=i=1n+1Mi(yi1,yix)Z(X)=(M1(x)M2(x)...Mn+1(x)) \begin{aligned} P(\boldsymbol{Y}|\boldsymbol{X})=&amp;\frac{1}{Z(\boldsymbol{X})}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})\\ \widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) =&amp;\prod_{i=1}^{n+1}M_i(y_{i-1},y_i|x)\\ Z(\boldsymbol{X})=&amp;(M_1(x)M_2(x)...M_{n+1}(x)) \tag{1.5} \end{aligned}

    举个栗子:

    在这里插入图片描述
    在这里插入图片描述
    解答:
    对于状态i1,i2,i3i_1,i_2,i_3y1,y2,y3y_1,y_2,y_3的取值均可以为1,21, 2

    记由状态startstart到状态i1i_1中,y1=1,y1=2y_1=1, y_1=2的概率分别为a01,a02a_{01},a_{02},以此类推,于是有:

    【机器学习】【条件随机场CRF-1】CRF的矩阵形式表示的示例讲解 + Python实现
    在这里插入图片描述

    解疑:为什么矩阵MiM_i的连乘为Z(X)Z(\boldsymbol{X})?
    矩阵MiM_i其实是各个状态转移概率所构成的矩阵,在矩阵的连乘过程中,实际上完成了对所有可能的输出序列上的求和操作。
    这也是上述例题第1行第1列的元素为所有路径的非规范化概率之和的原因。

    1.1.2.2 第二种线性链CRF的定义(X、Y具有相同结构)

    拥有T1T-1YtYt+1Y_t-Y_{t+1}条边和TTYtXtY_t-X_{t}的一个条件随机场,该网络的分布表示为:
    P(YX)=1Z(X)P~(YX)P~(YX)=t=1T1ϕ(Yt,Yt+1)t=1Tϕ(Yt,Xt)Z(X)=YP~(YX) \begin{aligned} P(\boldsymbol{Y}|\boldsymbol{X})=&amp;\frac{1}{Z(\boldsymbol{X})}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})\\ \widetilde{P}(\boldsymbol{Y}|\boldsymbol{X})=&amp;\prod_{t=1}^{T-1}\phi(Y_t,Y_{t+1})\prod_{t=1}^{T}\phi(Y_t,X_t)\\ Z(\boldsymbol{X})=&amp;\sum_{\boldsymbol{Y}}\widetilde{P}(\boldsymbol{Y}|\boldsymbol{X}) \end{aligned}

    2. 参考文献

    展开全文
  • 利用时间前后人脸表情变化信息,提出了一基于概率协作表示的多视频序列融合表情识别方法。先采用主动外观模型(AAM)定位出人脸表情68个特征点,利用提出融合策略将相邻3帧表情图像AAM特征进行融合,最后利用...
  • 图嵌入的几种方法

    千次阅读 2019-08-05 16:22:07
    2.概率图模型,涉及图的表示 3.图神经网络,包括图嵌入(graph embedding(基于随机游走))和GCN(基于邻居汇聚)两部分 图嵌入: 将图中节点以低维稠密形式表达,要求在原始图中相似节点在地位表达空间也接近...

    目前的图算法一般指:
    1.数据结构中的,最小生成树(Prim算法),最短路径(迪杰斯特拉,佛洛依德),拓扑排序,关键路径
    2.概率图模型,涉及图的表示
    3.图神经网络,包括图嵌入(graph embedding(基于随机游走))和GCN(基于邻居汇聚)两部分
    图嵌入:
    将图中的节点以低维稠密的形式表达,要求在原始图中相似的节点在地位表达空间也接近。得到的表达向量可以用于下游任务
    主要有:deepWalk

    deepWalk算法

    在这里插入图片描述
    首先从顶点矩阵选取一个样本,假设n个顶点
    构造一个二叉树,应该是类似w2v里的哈夫曼树,为了快速寻找到最终的结果。
    循环num_walks次:
    遍历每个节点,进行深度随机游走,每个节点获得walk_length作为序列。
    这里的深度随机游走,是可重复访问已访问节点。
    获得所有节点num_walks次的深度随机游走的序列共num_walks*n个序列
    将这些序列作为语料放入w2v中使用skim_gram训练。
    deepWalk只适用于无权图,因为它是随机选取领域进行DFS.

    LINE:

    LINE也是基于领域相似假设的方法,可以看作是使用BFS构造领域的算法,还可以使用在带权图。
    在这里插入图片描述
    对于这样一个图,如何衡量两个点的相似度?
    一:两个点直接相连
    二:有一些共同的相连的节点
    对于第一个两个直接相连,我们可以用一阶相似来度量。

    一阶相似度

    首先需要了解一下散度的概念
    一阶相似度:
    在这里插入图片描述
    使用权重的分布来去拟合两个点之间的联合概率分布,使用散度来度量两者概率分布之间的相似情况。
    注:一阶相似度只能用于无向图。

    二阶相似度:

    在这里插入图片描述
    NODE2VC:
    其实和deepwalk算法非常相似,是deepwalk算法的一种扩展。NODE2VEC是将DFS和BFS结合起来的随机游走,通过两个超参数,p和q进行控制游走。
    算法流程:
    在这里插入图片描述
    这里面其实主要的还是如何进行有偏采样,即根据顶点邻居节点不同的权重,进行采样。
    首先,遍历所有顶点,对当前顶点的邻居节点构建对应的采样accept和alias表,此时accept表里全是1,alias表全为0,生成alias_node字典存放aceept和alias表.
    然后,遍历所有的边,(node1,node2),找到node2的所有邻居顶点,按照邻居顶点与node1的关系,给以不同的权重,如果与node1相连,给1,如果邻居顶点是node2,给1/p,如果邻居顶点与node1无关,与node2有边,则给1/q;这样就获得了顶点node2与邻居顶点的权重列表,依据权重列表创建采样表accept和alias表,生成alias_edges字典;
    Alias算法采样
    总共迭代num_walks次:
    接着,遍历每个顶点进行随机游走:当当前的游走序列只有一个顶点时,对当前顶点找到它的所有邻居顶点,对邻接顶点依照alias_node表进行有偏采样
    当当前游走序列超过1个顶点,则将序列中最近访问的点对应的边,依照alias_edges字典进行采样
    最后生成当前node的随机游走序列
    最后:将迭代了num_walks次,生成的num_walks*num(v)个随机游走序列,放入w2v进行训练,生成各个顶点的向量表示。
    (未完待续~)
    参考链接:
    https://zhuanlan.zhihu.com/weichennote

    展开全文
  • 到目前为止,该存储库仅支持性能最高变体:用于学习动力学模型的概率集合,用于运动优化TSinf轨迹采样和交叉熵方法。 该代码结构具有与原始TF实现相同抽象级别,但TF动态模型已被Pytorch动力学模型代替...
  • 它还包括我们在实验中使用脚本,用于将我们的方法几种最新线提取程序进行比较。 简而言之,算法 我们的方法从二维激光测距扫描中提取折线。 与流行线提取技术相比,它不依赖于几何启发法,而是最大化了扫描...
  • 这个 再有其他 key 到来,再用同样 方法计算 hash 值,判断bit数组该位置是否为 1,都为 1 表示已存在(可能误判),不为 1,表示一定不存在. 应用场景: 1. 判断一个数据是否在数据库存在, 不存在再插入.(爬虫场景幂...

    布隆过滤器(概率型数据结构): 某样东西一定不存在或可能存在

    布隆过滤器原理?
    把一个 key 进行好几个 hash 运算后,得到的 hash 值,对一个 bit 数组取模放进去,用 1 表示, 比如下面示例:
    在这里插入图片描述
    在这里插入图片描述
    这个 再有其他 key 到来,再用同样的 方法计算 hash 值,判断bit数组的该位置是否为 1,都为 1 表示已存在(可能误判),不为 1,表示一定不存在.

    应用场景:
    1. 判断一个数据是否在数据库存在, 不存在再插入.(爬虫场景的幂等性入库操作)(对已经爬取过的 URL 去重)
    2. 统计一个系统的当天的登录用户数(同一个人登录多次算一次)
    3. 应对缓存穿透. (为了避免恶意用户频繁请求缓存中不存在DB也不存在的值,会导致缓存失效、DB负载过大,可以使用BloomFilter把所有数据放到bit数组中,当布隆过滤器报告不存在时直接返回,当布隆过滤器报告存在时再去查缓存,缓存不存在再去查数据库。)

    布隆过滤器存在的问题: 不支持反向删除,不支持计数

    布隆过滤器的升级版: 布谷鸟过滤器

    参考链接:
    https://zhuanlan.zhihu.com/p/43263751 - 详解布隆过滤器的原理,使用场景和注意事项
    https://zhuanlan.zhihu.com/p/68418134 - 布隆过滤器过时了,未来属于布谷鸟过滤器?

    展开全文
  • 统计学:概率计算

    2019-11-29 14:32:29
    一、概率 概率的量度尺度是0-1,如果某件事不可能发生,则其概率为...“A不发生”事件有一简便表示方法——A′。A′被称为A的对立事件。且P(A′) = 1 – P(A)。 如果两个事件是互斥事件,则只有其中一个事件会...
  • 选择性函子和概率 ... 结果,提供了一Haskell类型安全矩阵库,它能够将概率分布和概率计算表示为类型化矩阵,以及一种概率编程eDSL,它探索了各种技术,以便为概率函数编程提供新颖,高效解决方案。
  • 概率图模型(probabilistic graphical models)在概率模型基础上,使用了基于图的方法表示概率分布(或者概率密度、密度函数),是一通用化不确定性知识表示和处理方法。 根据图模型边是否有向,概率图...
  • 提出了一基于稀疏表示模型线性贝叶斯极大后验(MAP)估计图像去噪算法。 从在表示向量中构造先验概率分布开始,构建线性贝叶斯MAP估计器,以获取观测值背后最可能一个,这适用于解决广义图像逆问题。 此外,...
  • 目前数据融合方法主要有以下几种方法:1)贝叶斯估计,这是融合静态环境中多传感器底层数据一种常用方法,其信息描述为概率积分,适用于具有高斯噪声不确定性;2)多贝叶斯估计,将任务环境表示为不确定集合多...
  • 经营决策基本方法

    2019-11-15 18:37:29
    □——表示决策点,是对几种方案选择结果,即最后选择最优方案。 ○ ——状态节点,表示各个可行方案自然状态节点,由状态结点引出线叫概率分枝或状态分枝,表示方案在未来可能遇到不同自然状态。 △ ...
  • 针对机器学习中训练样本和测试样本概率分布不一致问题,提出了一基于dropout正则化半监督域自适应方法来实现将神经网络特征表示从标签丰富源域转移到无标签目标域。此方法从半监督学习角度出发,在源...
  • 概率法——利用激光传感器构建占据栅格...“本篇主要介绍:机器人世界的几种地图;占据栅格地图的表示方法与更新方法;利用激光传感器数据构建占据栅格地图。     1. 机器人地图的分类    ...
  • 6.2 二叉搜索的几种形式 6.2.1 纯二叉搜索 6.2.2 循环序列的二叉搜索 6.2.3 二叉搜索特殊下标 6.2.4 二叉搜索长度未知的序列 6.2.5 重叠子序列问题 6.2.6 解方程 6.3 内插搜索 6.4 排序 6.4.1 桶排序和...
  • 期望/概率dp入门+题单

    2021-03-30 11:15:29
    几种常见设转移方程数组的方法 1、设f [ i ]表示的是由i 状态变成 最终状态期望 2、按照题意直接设 3、把选择东西加入数组,如f [ i ] [ j ]表示第i个物品选j个期望 或f [ i ] [ j ]表示有i个A 物品,j个B物品...
  • 单从对\xa0、\t、\u3000等含空白字符处理来说,有以下几种方法可行: 使用re.sub 使用正则表达式可以轻松匹配所有空白字符,它对于Unicode字符也是有效,比如: import re s = ‘T-shirt\xa0\xa0短袖圆领衫,\...
  • (9)在退火遗传算法的基础上提出一个新的自 适应退火策 略,将自适应退火策略用于选择概率的计算以增强算 法的收敛性, 在交叉和变异概率的选取上也进行了自适应处理,以 进一步改善 算法的稳定性和收敛性,并将此...
  • 多线程设置优先级方法

    千次阅读 2019-05-10 22:42:39
    其实实现的方法有很多,这里主要介绍几种。 首先,线程Thread有一个设置优先级属性Priority,默认数值为5,设置越高优先级越高,最高为10。但是这里需要注意是,优先级作用只是表示了执行的概率,也就是说...
  • 阈值分割是一常用图像分割方法,基于灰度阈值选取将图像灰度划分为一个或个集合,实现图像分割。阈值分割方法的关键是阈值选取准则,常用准则有最大类间方差(OTSU 大津法)和信息熵。信息熵包括很多...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 221
精华内容 88
关键字:

概率的几种表示方法