精华内容
下载资源
问答
  • 主要介绍了python矩阵运算,转置,逆运算,共轭矩阵实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • #先定义两个矩阵X=np.array([[1,2104,5,1,45],[1,1416,3,2,40],[1,1534,3,2,30],[1,852,2,1,36]])y=np.array([45,40,30,36])#内积以后发现c=np.dot(X.T,X)carray([[ 4, 5906, 13, 6, 151],[ 5906, 951093...

    我就废话不多说了,大家还是直接看代码吧!

    #先定义两个矩阵

    X=np.array([[1,2104,5,1,45],[1,1416,3,2,40],[1,1534,3,2,30],[1,852,2,1,36]])

    y=np.array([45,40,30,36])

    #内积以后发现

    c=np.dot(X.T,X)

    c

    array([[ 4, 5906, 13, 6, 151],

    [ 5906, 9510932, 21074, 8856, 228012],

    [ 13, 21074, 47, 19, 507],

    [ 6, 8856, 19, 10, 221],

    [ 151, 228012, 507, 221, 5821]])

    c.I

    d=np.dot(c.I,X.T)

    Traceback (most recent call last):

    File "", line 1, in

    d=np.dot(c.I,X.T)

    AttributeError: 'numpy.ndarray' object has no attribute 'I'

    #说明array进行内积以后已经不是array对象,成为ndarray对象,不能再进行.I,.T,.M的操作。

    #解决方法:把结果转为matrix就可以

    a=np.matrix([[ 4, 5906, 13, 6, 151],

    [ 5906, 9510932, 21074, 8856, 228012],

    [ 13, 21074, 47, 19, 507],

    [ 6, 8856, 19, 10, 221],

    [ 151, 228012, 507, 221, 5821]])

    a.I

    matrix([[ -4.12181049e+13, 1.93633440e+11, -8.76643127e+13,

    -3.06844458e+13, 2.28487459e+12],

    [ 1.93633440e+11, -9.09646601e+08, 4.11827338e+11,

    1.44148665e+11, -1.07338299e+10],

    [ -8.76643127e+13, 4.11827338e+11, -1.86447963e+14,

    -6.52609055e+13, 4.85956259e+12],

    [ -3.06844458e+13, 1.44148665e+11, -6.52609055e+13,

    -2.28427584e+13, 1.70095424e+12],

    [ 2.28487459e+12, -1.07338299e+10, 4.85956259e+12,

    1.70095424e+12, -1.26659193e+11]])

    补充知识:矩阵和向量共轭

    矩阵包括实数矩阵和复数矩阵。

    矩阵的转置是将其行列互换位置,

    矩阵的共轭转置则是在矩阵转置的基础上(行列互换位置)对其每一个元素取共轭。

    形如 a+bi的复数,其共轭为a-bi。实数的共轭等于它本身。

    所以,实数矩阵的共轭转置矩阵就是转置矩阵,复数矩阵的共轭转置矩阵就是行列互换位置后每个元素取共轭。

    在Fortran中,其调用函数为:

    CONJG(x)

    求x的共轭复数。x:C, 结果:C

    以上这篇python矩阵运算,转置,逆运算,共轭矩阵实例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持python博客。

    展开全文
  • matlab中关于矩阵转置的学习日记

    千次阅读 2018-10-19 09:25:29
    在matlab做矩阵运算时经常要用到转置运算,如果是复矩阵还需要共轭转置。之前对这两者的认识有误,今天mark一下。 1: ’ %该符号表示共轭转置,当矩阵为实矩阵时表示转置 2: .’ %该符号表示转置运算 运算实例: a...

    在matlab做矩阵运算时经常要用到转置运算,如果是复矩阵还需要共轭转置。之前对这两者的认识有误,今天mark一下。

    1: ’
    %该符号表示共轭转置,当矩阵为实矩阵时表示转置

    2: .’
    %该符号表示转置运算

    运算实例:
    a=[1 1+1i;0 1]

    a =

      1 + 0i      1 + 1i
      0 + 0i      1 + 0i
    

    a.’

    ans =

      1 + 0i      0 + 0i
      1 + 1i      1 + 0i
    

    a’

    ans =

      1 + 0i      0 + 0i
      1 - 1i      1 + 0i
    
    展开全文
  • GPU高性能计算之CUDA》实例

    热门讨论 2013-10-29 23:41:25
    共轭梯度算法,CUBLAS实现 cudaMPI 2.7.3 CUDA+MPI管理GPU集群 cudaOpenMP 2.7.2 CUDA+OpenMP管理多GPU deviceQuery 2.1.4 设备查询 histKernel 2.4.3 亮度直方图统计 matrixAssign ...
  • 《GPU高性能计算之CUDA》实例

    热门讨论 2009-10-19 17:45:02
    共轭梯度算法,CUBLAS实现 cudaMPI 2.7.3 CUDA+MPI管理GPU集群 cudaOpenMP 2.7.2 CUDA+OpenMP管理多GPU deviceQuery 2.1.4 设备查询 histKernel 2.4.3 亮度直方图统计 matrixAssign ...
  • 基于Visual C#的DirectX开发实例教程

    千次下载 热门讨论 2010-03-21 11:33:35
    3、四元数的共轭、矩、迹、模、倒数 42 4、四元数的三角形式 43 5、在三维计算机图形中的应用 44 十、摄像机变换 46 1、准备场景 46 2、旋转摄像机 53 3、通过键盘控制摄像机旋转 54 4、通过键盘控制摄像机缩放 57 5...
  • 4.13 求解对称正定方程组的共轭梯度法 4.14 求解线性最小二乘问题的豪斯荷尔德变换法 4.]5 求解线性最小二乘问题的广义逆法 4.16 病态方程组的求解 第5章 非线性方程与方程组的求解 5.1 非线性方程与方程组类设计 ...
  • PCA与SVD

    2019-08-31 12:49:43
    Outline 预备知识 样本实例 :表示第i个样本,它的特征维度为D; 样本矩阵 :, 其中N表示样本个数,D表示样本维数; 內积矩阵 :,元素 表示样本与样本 的相似度;... Hermite矩阵:, 若,其中表示共轭矩阵; SVD...

    Outline

    预备知识

    • 样本实例 : x_{i}\in R^{D} 表示第i个样本,它的特征维度为D;
    • 样本矩阵 : X\in R^{N\times D}, 其中N表示样本个数,D表示样本维数;
    • 內积矩阵 : K\in R^{N\times N}元素 K_{ij} 表示样本 x_{i} 与样本 x_{j} 的相似度;
    • 协方差矩阵: S \in R^{D\times D}元素 S _{ij} 表示维度 i 与维度 j 的 协方差;
    • 正交矩阵U\in R^{m\times m}, 满足:UU^{T}=U^{T}U=I_{n}
    • 酉矩阵:    U\in C^{m\times m}, 满足:UU^{+}=U^{+}U=I_{n}U^{+}表示U的共轭转置;
    • Hermite矩阵X\in R^{N\times N}, 若 X = X^{+},其中\overline{A}表示共轭矩阵;

    SVD

          设A是一个阶矩阵,其中元素均属于数域K(即实数域或者复数域),则存在一个分解使得:

                                                                                                A = U \Sigma V^{T}

    其中,其中U是m×m阶酉矩阵;Σ是半正定m×n阶对角矩阵;而V*,即V的共轭转置,是n×n阶酉矩阵。这样的分解就称作M的奇异值分解。Σ对角线上的元素Σi,其中Σi即为M的奇异值。

                                                                  

    PCA

              

    • View-1:最大化投影方差

           假定对于数据集X\in R^{N\times D} 我们打算把数据投影到一个一维空间(维度降为1维),因此需要寻找一个投影向量u\in R^{ D}。为了唯一确定该投影向量,我们对其加以限制:u^{ T}u=1.首先,计算样本均值:

                                                                                                 

    然后,计算投影后样本的方差:

                                                                                  

    其中,S表示样本协方差矩阵,定义如下:

                                                                                    

    考虑到投影向量u1的约束条件,我们可通过引入拉格朗日乘子,将带约束的优化问题转为无约束的优化问题:

                                                                                   

    上述优化目标关于u1求导置零,得到:

                                                                               , 即   

    从而,所求投影向量即为样本协方差矩阵最大的特征值对应的特征向量!一般地,假设我们想要把数据投影到一个M+1维子空间,而我们已经得到了M个投影向量,则第M+1个投影向量必须与已有的M个向量线性无关,为了保证这一点,我们可以让u_{M+1}u1, ... ,uM正交【为什么?如果不正交呢?】。类似地,我们可以得到如下的目标函数:

                                                          

    上述优化目标关于u_{M+1}求导置零,得到:

                                                                     

    上式依次乘以u_{j}^{T} (j=1,2, ..., M),可得 \eta_{j} = 0 , (j=1,2, ..., M).因此,有:

                                                                               

    即,所求的第M+1个投影向量为样本协方差矩阵的第M+1个特征值对应的特征向量。

    • View-2:最小化投影误差

           对于数据集X\in R^{N\times D}我们引入一组完备的正交基u_{i} (i=1,2, ..., D), 对于样本x_{n}而言,它在原来的坐标系(基向量)下的的坐标为{{}x_{n1}, ..., x_{nD}},则它在新的坐标系下可被表示为:

                                                                                             

    u_{i} (i=1,2, ..., d)相互正交的特性可知:.于是有:

                                                                                            

    我们打算:x_{n}在M<D维子空间的投影点来尽可能地逼近它在D维空间中的位置。不失一般性,假设M维子空间由正交基的前M个基构成,于是得到如下的近似点:

                                                                                    

    注意,这里需要说明的一点是,近似点\widetilde{x}_{n}的M+1至D的分量由剩余的正交基的线性组合来产生,这里bi对所有近似样本都取一样的值。至此,我们可以得到数据集的重构误差:

                                                                                        

    最小化上述重构误差,得到: ,j = 1,2, ..., M;   ,     j = M+1, ..., D. 于是得到:

                                                                             

    进一步,重构误差可以化简为:

                                                                     

    类似地,考虑基的正交性和单位模的约束,不难得到:

                                                                                                 

    因此,为了使得重构误差最小化,应该选择最大的M的特征值对应的特征向量作为投影向量

    实验结果

    • Mnist

                      

                                         

                    

    • Nature image

                                     

                

                         gray_img                                  1st_pc                                      5 pcs                                         25-pc

    展开全文
  • CRF总结

    2020-02-01 15:00:12
    表示1.1 一般表示1.2联合表示1.3 矩阵表示实例2 推断参考文献 CRF 是无向图模型 它是一个判别式模型 建模了每个状态和整个观测序列的依赖 1.表示 1.1 一般表示 g=s f=t 1.2联合表示 1.3 矩阵表示 实例 2 ...

    • CRF 是无向图模型code
      • 它是一个判别式模型
      • 建模了每个状态和整个观测序列的依赖

    https://www.unclewang.info/learn/machine-learning/756/
    https://blog.csdn.net/u012421852/article/details/80287567

    计算下Z(矩阵)

    import numpy as np
    
    y0=1#start
    y4=1#stop
    
    
    

    从start到stop的所有路径的规范化因子Z,其实就是上面所有路径的非规范化概率之和

    class CCRF(object):
        """
        条件随机场的矩阵表示实现
        """
        def __init__(self,M):
            self.M=M#条件随机场的矩阵形式的存储体
            self.Z=None#规范化因子
            self.MP=[]#矩阵乘积
            
            self.work()
            return
            
        def work(self):
            print('work......')
            self.MP=np.full(shape=(np.shape(self.M[0])),fill_value=1.0)
    #         print(self.MP)
            for i in range(np.shape(self.M)[0]):#四个矩阵就循环四次
                print('\nML=\n',self.MP)
                print('M%d=\n'%i,self.M[i])
                self.MP=np.dot(self.MP,self.M[i])#矩阵乘法
                print('dot=\n',self.MP)
            
        def ZValue(self):
            return self.MP[0,0]
    
    def CCRF_manual():
        M1 = np.array([[0.5, 0.5],[0,   0]])#a01 a02-A
        M2 = np.array([[0.3, 0.7],[0.7, 0.3]])#b11,b12,b21,b22-B
        M3 = np.array([[0.5, 0.5],[0.6, 0.4]])
        M4 = np.array([[1, 0],[1, 0]])
            
        M=[]
        M.append(M1)
        M.append(M2)
        M.append(M3)
        M.append(M4)
        M=np.array(M)
        print('CRF 矩阵:\n',M)
        crf=CCRF(M)
        ret=crf.ZValue()
        print('从start到stop的规范因子Z:',ret)
        
    if __name__=='__main__':
        CCRF_manual()
    
    
    CRF 矩阵:
     [[[0.5 0.5]
      [0.  0. ]]
    
     [[0.3 0.7]
      [0.7 0.3]]
    
     [[0.5 0.5]
      [0.6 0.4]]
    
     [[1.  0. ]
      [1.  0. ]]]
    work......
    
    ML=
     [[1. 1.]
     [1. 1.]]
    M0=
     [[0.5 0.5]
     [0.  0. ]]
    dot=
     [[0.5 0.5]
     [0.5 0.5]]
    
    ML=
     [[0.5 0.5]
     [0.5 0.5]]
    M1=
     [[0.3 0.7]
     [0.7 0.3]]
    dot=
     [[0.5 0.5]
     [0.5 0.5]]
    
    ML=
     [[0.5 0.5]
     [0.5 0.5]]
    M2=
     [[0.5 0.5]
     [0.6 0.4]]
    dot=
     [[0.55 0.45]
     [0.55 0.45]]
    
    ML=
     [[0.55 0.45]
     [0.55 0.45]]
    M3=
     [[1. 0.]
     [1. 0.]]
    dot=
     [[1. 0.]
     [1. 0.]]
    从start到stop的规范因子Z: 1.0
    

    1.1 一般参数形式

    在这里插入图片描述
    在这里插入图片描述

    	import torch
    	import torch.nn as nn
    
    
    	sequence_len = 3;
    	y_size = 2;
    	k=5
    	l=4
    	#转移
    	#每个t有k组,每个y有2种状态,y1->y2,y2->y3,序列长3(k,i=1,2,y_i->y_i+1)
    	t=torch.tensor( [[[[0,1],[0,0]],[[0,1],[0,0]]],
    	                 [[[1,0],[0,0]],[[0,0],[0,0]]],
    	                 [[[0,0],[0,0]],[[0,0],[1,0]]],
    	                 [[[0,0],[1,0]],[[0,0],[0,0]]],
    	                 [[[0,0],[0,0]],[[0,0],[0,1]]]],dtype=float);
    	lamb=torch.tensor([1,0.5,1,1,0.2])
    	# 发射
    	# 序列长3,每个y和x出现的情况(l,t(y),状态)
    	s=torch.tensor( [[[1,0],[0,0],[0,0]],
    	                 [[0,1],[0,1],[0,0]],
    	                 [[0,0],[1,0],[1,0]],
    	                 [[0,0],[0,0],[0,1]]],dtype=float)
    	mu = torch.tensor([1, 0.5, 0.8, 0.5])
    	#比上面多了个开始y0和结束y4
    	def P_y_x_condition(y):# 参数形式
    	        sumt=0
    	        sums=0
    	        for i in range(k):
    	            for j in range(len(y)-1):
    	                sumt+=lamb[i]*t[i,j,y[j],y[j+1]]
    	                # print(i,j,lamb[i]*t[i,j,y[j],y[j+1]])
    	        for i in range(l):
    	            for j in range(len(y)):
    	                sums+=mu[i]*s[i,j,y[j]]
    	        print(sums+sumt)
    	        return torch.exp(sums+sumt)
    	    
    	y=[0,1,1]
    	print("p(y|x)=p(y1=1,y2=2,y3=3|x)=",P_y_x_condition(y))
    
    tensor(3.2000, dtype=torch.float64)
    p(y|x)=p(y1=1,y2=2,y3=3|x)= tensor(24.5325, dtype=torch.float64)
    

    1.2 简化形式

    在这里插入图片描述

    • 这里也引入了起点,下面代码中引入了起点和终点(只要起点就行)
    f=torch.tensor([ [[[0,0],[0,0]],[[0,1],[0,0]],[[0,1],[0,0]],[[0,0],[0,0]]],
                     [[[0,0],[0,0]],[[1,0],[0,0]],[[0,0],[0,0]],[[0,0],[0,0]]],
                     [[[0,0],[0,0]],[[0,0],[0,0]],[[0,0],[1,0]],[[0,0],[0,0]]],
                     [[[0,0],[0,0]],[[0,0],[1,0]],[[0,0],[0,0]],[[0,0],[0,0]]],
                     [[[0,0],[0,0]],[[0,0],[0,0]],[[0,0],[0,1]],[[0,0],[0,0]]],
                     [[[1,0],[1,0]],[[0,0],[0,0]],[[0,0],[0,0]],[[0,0],[0,0]]],
                     [[[0,1],[0,1]],[[0,1],[0,1]],[[0,0],[0,0]],[[0,0],[0,0]]],
                     [[[0,0],[0,0]],[[1,0],[1,0]],[[1,0],[1,0]],[[0,0],[0,0]]],
                     [[[0,0],[0,0]],[[0,0],[0,0]],[[0,1],[0,1]],[[0,0],[0,0]]]],dtype=float);
    w=torch.tensor([1,0.5,1,1,0.2,1, 0.5, 0.8, 0.5])
    def P_y_x_condition_with_f( y):
            sum=0
            for i in range(k+l):
                for j in range(len(y)-1):
                    sum+=w[i]*f[i,j,y[j],y[j+1]]
            print(sum)
            return torch.exp(sum)
    p_y_x_con=P_y_x_condition_with_f([0,0,1,1,0])
    print("p(y|x)=p(y1=1,y2=2,y3=3|x)=",p_y_x_con)
    
    tensor(3.2000, dtype=torch.float64)
    p(y|x)=p(y1=1,y2=2,y3=3|x)= tensor(24.5325, dtype=torch.float64)
    

    Z

    在这里插入图片描述

    1.3 矩阵形式

    在这里插入图片描述
    a01表示从start=y0=1到y1=1的概率,
    b21表示从y1=2到y2=1的概率
    在这里插入图片描述

    w=torch.tensor([1,0.5,1,1,0.2,1, 0.5, 0.8, 0.5])
    M=f;
    # print(M[0])
    for i in range(k+l):
        M[i]=w[i]*f[i]
    print(torch.sum(M,axis=0))
    M=torch.exp(torch.sum(M,axis=0))
    print("M(i,y_i-1,y_i):\n",M)
    # 因为y0=0,yn+1=0
    # 所以可以令M[0,1,0],M[0,1,1],M[3,0,1],M[3,1,1]=0
    # M[0,1,0]=M[0,1,1]=M[3,0,1]=M[3,1,1]=0
    # print("M(i,y_i-1,y_i):\n",M)#与上图对应上了
    
    
    tensor([[[1.0000, 0.5000],
             [1.0000, 0.5000]],
    
            [[1.3000, 1.5000],
             [1.8000, 0.5000]],
    
            [[0.8000, 1.5000],
             [1.8000, 0.7000]],
    
            [[0.0000, 0.0000],
             [0.0000, 0.0000]]], dtype=torch.float64)
    M(i,y_i-1,y_i):
     tensor([[[2.7183, 1.6487],
             [2.7183, 1.6487]],
    
            [[3.6693, 4.4817],
             [6.0496, 1.6487]],
    
            [[2.2255, 4.4817],
             [6.0496, 2.0138]],
    
            [[1.0000, 1.0000],
             [1.0000, 1.0000]]], dtype=torch.float64)
    

    1.3.2 Z

    Z=(M1(x)M2(x)...Mn+1(x))start,stopZ=(M_1(x)M_2(x)...M_{n+1}(x))_{start,stop}
    从start到stop对应于y=(1,1,1),y=(1,1,2), …, y=(2,2,2)个路径的非规范化概率分别是:

    • a01b11c11,a01b11c12,a01b12c21,a01b12c22

        a02b21c11,a01b21c12,a02b22c21,a02b22c22
      

    然后按式11.12求规范化因子,通过计算矩阵乘积M1(x) M2(x) M3(x) M4(x)可知,其第一行第一列的元素为

    • a01b11c11+ a01b11c12 + a01b12c21+ a01b12c22 +a02b21c11 + a01b21c12+ a02b22c21 + a02b22c22

    恰好等于从start到stop的所有路径的非规范化概率之和,即规范化因子Z(x)。

    def Z_M(M):
        z=M[0]
        for i in range(1,sequence_len+1):
            z=torch.matmul(z,M[i])
        return z[0,0]
    print(Z_M(M))
    
    
    tensor(253.9492, dtype=torch.float64)
    
    def P_y_x_condition_with_M(y):
        p=1;
        for i in range(len(y)-1):
            p*=M[i,y[i],y[i+1]]
        print(p)
        return p/Z_M(M)
    p_y_x_con=P_y_x_condition_with_M([0,0,1,1,0])
    print("p(y|x)=p(y1=1,y2=2,y3=3|x)=",p_y_x_con)
    
    tensor(24.5325, dtype=torch.float64)
    p(y|x)=p(y1=1,y2=2,y3=3|x)= tensor(0.0966, dtype=torch.float64)
    

    2.维特比算法

    在这里插入图片描述

    print(torch.log(M))
    
    tensor([[[1.0000, 0.5000],
             [1.0000, 0.5000]],
    
            [[1.3000, 1.5000],
             [1.8000, 0.5000]],
    
            [[0.8000, 1.5000],
             [1.8000, 0.7000]],
    
            [[0.0000, 0.0000],
             [0.0000, 0.0000]]], dtype=torch.float64)
    
    def Viterbi_M():
        delta=torch.zeros(3,2)
        logM=torch.log(M)
        delta[0]=logM[0,0]
        torch.max(delta[0].reshape(y_size,1)+logM[1],axis=0)
        indices=[]
        for i in range(1,sequence_len):
            print(delta[i-1].reshape(y_size,1)+logM[i])
            delta[i],indice=torch.max(delta[i-1].reshape(y_size,1)+logM[i],axis=0)
            indices.append(indice)        
        print(delta)
    #     print(indices)
        path=torch.zeros(sequence_len,dtype=torch.int)
    #     print(path)
        path[sequence_len-1]=torch.argmax(delta[sequence_len-1])
    #     print(path)
        for i in range(sequence_len-2,-1,-1):
            
            path[i]=indices[i][path[i+1]]
    #     print(path)
        return path
        
    Viterbi_M()
    
    tensor([[2.3000, 2.5000],
            [2.3000, 1.0000]], dtype=torch.float64)
    tensor([[3.1000, 3.8000],
            [4.3000, 3.2000]], dtype=torch.float64)
    tensor([[1.0000, 0.5000],
            [2.3000, 2.5000],
            [4.3000, 3.8000]])
    
    
    
    
    
    tensor([0, 1, 0], dtype=torch.int32)
    

    3.前向算法

    在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    • 一般

    α0(y0x)={1y0=start=10y0!=startαi+1(yi+1x)=αi(yix)Mi+1(yi+1,yix)\alpha_0(y_0|x)=\begin{cases}1&y_0=start=1\\0&y_0!=start\end{cases}\\ 这个是一个值:\alpha_{i+1}(y_{i+1}|x)=\alpha_i(y_i|x)M_{i+1}(y_{i+1},y_i|x)

    • 矩阵形式

    αi(x)=(αi(yi=1x)αi(yi=2x)...αi(yi=m1x)αi(yi=mx))Tαi+1T(x)=αiT(x)Mi+1(x)M1=M[0],M2=M[1],M3=M[2],M4=M[3]这是一个向量:\alpha_i(x)=(\alpha_i(y_i=1|x)\alpha_i(y_i=2|x)...\alpha_i(y_i=m-1|x)\alpha_i(y_i=m|x))^T\\ \alpha_{i+1}^T(x)=\alpha_i^T(x)M_{i+1}(x)\\ M_1=M[0],M_2=M[1],M_3=M[2],M_4=M[3]

    M[0,1,0]=M[0,1,1]=M[3,0,1]=M[3,1,1]=0
    def alpha():
        alpha=torch.zeros(sequence_len+2,y_size,dtype=float)
        alpha[0,0]=1
        for i in range(sequence_len+1):
            alpha[i+1]=torch.matmul(alpha[i].reshape(1,y_size),M[i])
        print(alpha)
        return alpha
    alpha=alpha()
    
    tensor([[  1.0000,   0.0000],
            [  2.7183,   1.6487],
            [ 19.9484,  14.9008],
            [134.5403, 119.4088],
            [253.9492,   0.0000]], dtype=torch.float64)
    

    4.后向算法

    βi(yix)=Mi+1(yi,yi+1x)βi+1(yi+1x)β0(y0x)={1yn+1=stop=10yn+1!=stopβi(x)=Mi+1(x)βi+1(x)Z(x)=αnT(x)1=1Tβ1(x)\beta_i(y_i|x)=M_{i+1}(y_i,y_{i+1}|x)\beta_{i+1}(y_{i+1}|x)\\ \beta_0(y_0|x)=\begin{cases}1&y_{n+1}=stop=1\\0&y_{n+1}!=stop\end{cases}\\ 向量形式:\\ \beta_i(x)=M_{i+1}(x)\beta_{i+1}(x)\\ Z(x)=\alpha_n^T(x)·1=1^T·\beta_1(x)

    def beta():
        beta=torch.zeros(sequence_len+2,y_size,dtype=float)
        beta[sequence_len+1,0]=1
        for i in range(sequence_len,-1,-1):
    #         print(M[i],beta[i+1].reshape(y_size,1))
            beta[i]=torch.matmul(M[i],beta[i+1].reshape(y_size,1)).reshape(y_size)
        print(beta)
        return beta
    beta=beta()
    
    tensor([[253.9492,   0.0000],
            [ 60.7485,  53.8707],
            [  6.7072,   8.0634],
            [  1.0000,   1.0000],
            [  1.0000,   0.0000]], dtype=torch.float64)
    
    def Z_alpha(alpha):
        return torch.sum(alpha[sequence_len+1])
    print(Z_alpha(alpha))
    
    tensor(253.9492, dtype=torch.float64)
    
    def Z_beta(beta):
    #     print(beta)
        return torch.sum(beta[0])
    
    print(Z_beta(betta))
    
    tensor(253.9492, dtype=torch.float64)
    

    5.使用前向后向的概率计算

    p(yix)=αiT(yix)βi(yix)Z(x)p(yi1,yix)=αi1T(yix)Mi(yi1,yix)βi(yix)Z(x)这是一个值p(y_i|x)=\frac{\alpha_i^T(y_i|x)\beta_i(y_i|x)}{Z(x)}\\ p(y_{i-1},y_i|x)=\frac{\alpha_{i-1}^T(y_i|x)M_i(y_{i-1},y_i|x)\beta_i(y_i|x)}{Z(x)}

    推导:
    p(yt=ix)=Σy1,y2,...,yt1,yt,...,yTp(yx)=Σy1,y2,...,yt1Σyt,...,yTp(yx)=Σy1,y2,...,yt1Σyt,...,yT1ZΠt=1TΦt(yt1,yt,x)=1ZΣy1,y2,...,yt1Πt=1tΦt(yt1,yt,x)Σyt,...,yTΠt=t+1TΦt(yt1,yt,x)=1ZΔleftΔrightαt(i)=Δleft=Σy1,y2,...,yt1Πt=1tΦt(yt1,yt,x)=Σy1,y2,...,yt1Φ1(y0,y1,x)Φ2(y1,y2,x)...Φt1(yt2,yt1,x)Φt(yt1,yt=i,x)=Σyt1Φ(yt1,yt,x)Σyt2Φ(yt2,yt1,x)...Σy1Φ(y1,y2,x)Σy0Φ1(y0,y1,x)βt(i)=Δright=Σyt,...,yTΠt=t+1TΦt(yt1,yt,x)p(y_t=i|x)=\Sigma_{y_1,y_2,...,y_{t-1},y_t,...,y_T}p(y|x)\\ =\Sigma_{y_1,y_2,...,y_{t-1}}\Sigma_{y_t,...,y_T}p(y|x)\\ =\Sigma_{y_1,y_2,...,y_{t-1}}\Sigma_{y_t,...,y_T}\frac{1}{Z}\Pi_{t'=1}^T\Phi_{t'}(y_{t'-1},y_{t'},x)\\ =\frac{1}{Z}\Sigma_{y_1,y_2,...,y_{t-1}}\Pi_{t'=1}^{t}\Phi_{t'}(y_{t'-1},y_{t'},x)\Sigma_{y_t,...,y_T}\Pi_{t'=t+1}^T\Phi_{t'}(y_{t'-1},y_{t'},x)\\ =\frac{1}{Z}\Delta_{left}\Delta_{right}\\ \alpha_t(i)=\Delta_{left}=\Sigma_{y_1,y_2,...,y_{t-1}}\Pi_{t'=1}^{t}\Phi_{t'}(y_{t'-1},y_{t'},x)\\ =\Sigma_{y_1,y_2,...,y_{t-1}}\Phi_1(y_0,y_1,x)\Phi_2(y_1,y_2,x)...\Phi_{t-1}(y_{t-2},y_{t-1},x)\Phi_t(y_{t-1},y_t=i,x)\\ =\Sigma_{y_{t-1}}\Phi(y_{t-1},y_{t},x)\Sigma_{y_{t-2}}\Phi(y_{t-2},y_{t-1},x)...\Sigma_{y_1}\Phi(y_1,y_2,x)\Sigma_{y_0}\Phi_1(y_0,y_1,x)\\ \beta_t(i)=\Delta_{right}=\Sigma_{y_t,...,y_T}\Pi_{t'=t+1}^T\Phi_{t'}(y_{t'-1},y_{t'},x)

    def p_y_x_condition_alpha_beta(alpha,beta):
        #p(y_i|x)
        p_y_x=alpha*beta/Z_alpha(alpha)
        
    #     print(alpha[2].reshape(1,y_size)*beta[2].reshape(y_size,1))
        return p_y_x
            
            
        
    y=[0,1,1]
    p_y_x_condition_alpha_beta(alpha,beta)
    
    tensor([[1.0000, 0.0000],
            [0.6503, 0.3497],
            [0.5269, 0.4731],
            [0.5298, 0.4702],
            [1.0000, 0.0000]], dtype=torch.float64)
    
    def p_y12_x_condition_alpha_beta(alpha,beta):
        p=M.clone().detach()
        for i in range(sequence_len+1):
            p[i]=alpha[i].reshape(y_size,1)*p[i]*beta[i+1]
        return p/Z_alpha(alpha);
            
    p_y12_x_condition_alpha_beta(alpha,beta)
    
    tensor([[[0.6503, 0.3497],
             [0.0000, 0.0000]],
    
            [[0.2634, 0.3868],
             [0.2634, 0.0863]],
    
            [[0.1748, 0.3520],
             [0.3550, 0.1182]],
    
            [[0.5298, 0.0000],
             [0.4702, 0.0000]]], dtype=torch.float64)
    

    6.期望计算

    在这里插入图片描述

    def E_fk_py_x(k,alpha,beta):#E_{p(y|x)}(f_k)
        return torch.sum(f[k]*p_y12_x_condition_alpha_beta(alpha,beta))
    E_fk_py_x(1,alpha,beta)
    
    tensor(0.1317, dtype=torch.float64)
    

    7.参数估计(学习)

    θ^=argmaxΠi=1Np(y(i)x(i))λ^,η^=argmaxλ,ηΠi=1Np(y(i)x(i))Σi=1Nlogp(y(i)x(i))=Σi=1N(log(Z)+Σt=1T(λTf(yt1,yt,x)+ηTg(yt,x)))=LLλ=Σi=1Nlogp(y(i)x(i))=Σi=1N(λlog(Z)+Σt=1Tf(yt1,yt,x))logpartitionfunction:λlog(Z)=(E(Σt=1Tf(yt1,yt,x(i)))=ΣyP(yx(i))Σt=1Tf(yt1,yt,x(i))=Σt=1TΣyP(yx(i))f(yt1,yt,x(i))=Σt=1TΣy1,y2,...,yt2Σyt1ΣytΣyt+1,yt+2,...,yTP(yx(i))f(yt1,yt,x(i))=Σt=1TΣyt1Σyt(Σy1,y2,...,yt2Σyt+1,yt+2,...,yTP(yx(i))f(yt1,yt,x(i)))=Σt=1TΣyt1ΣytP(yt1,ytx(i))f(yt1,yt,x(i))\hat{\theta}=argmax\Pi_{i=1}^N p(y^{(i)}|x^{(i)})\\ \hat{\lambda},\hat{\eta}=argmax_{\lambda,\eta}\Pi_{i=1}^N p(y^{(i)}|x^{(i)})\\ \Sigma_{i=1}^Nlog p(y^{(i)}|x^{(i)})=\Sigma_{i=1}^N(-log(Z)+\Sigma_{t=1}^T(\lambda^Tf(y_{t-1},y_t,x)+\eta^Tg(y_t,x)))\\ =L\\ \frac{\partial L}{\partial \lambda}=\Sigma_{i=1}^Nlog p(y^{(i)}|x^{(i)})=\Sigma_{i=1}^N(-\frac{\partial }{\partial \lambda} log(Z)+\Sigma_{t=1}^Tf(y_{t-1},y_t,x))\\ log-partition function:\\ \frac{\partial }{\partial \lambda} log(Z)\\ =(积分就是期望)E(\Sigma_{t=1}^Tf(y_{t-1},y_t,x^{(i)}))\\ =\Sigma_y P(y|x^{(i)})\Sigma_{t=1}^T f(y_{t-1},y_t,x^{(i)})\\ =\Sigma_{t=1}^T\Sigma_y P(y|x^{(i)}) f(y_{t-1},y_t,x^{(i)})\\ =\Sigma_{t=1}^T\Sigma_{y_1,y_2,...,y_{t-2}}\Sigma_{y_{t-1}}\Sigma_{y_t}\Sigma_{y_{t+1},y_{t+2},...,y_T} P(y|x^{(i)}) f(y_{t-1},y_t,x^{(i)})\\ =\Sigma_{t=1}^T\Sigma_{y_{t-1}}\Sigma_{y_t} (\Sigma_{y_1,y_2,...,y_{t-2}}\Sigma_{y_{t+1},y_{t+2},...,y_T}P(y|x^{(i)}) f(y_{t-1},y_t,x^{(i)}))\\ =\Sigma_{t=1}^T\Sigma_{y_{t-1}}\Sigma_{y_t}P(y_{t-1},y_t|x^{(i)}) f(y_{t-1},y_t,x^{(i)})
    p(yi1,yix)=αi1T(yix)Mi(yi1,yix)βi(yix)Z(x)p(y_{i-1},y_i|x)=\frac{\alpha_{i-1}^T(y_i|x)M_i(y_{i-1},y_i|x)\beta_i(y_i|x)}{Z(x)}

    7.1 梯度上升

    λt+1=λt+stepLληt+1=ηt+stepLη\lambda^{t+1}=\lambda^t+step*\frac{\partial L}{\partial \lambda}\\ \eta^{t+1}=\eta^t+step*\frac{\partial L}{\partial \eta}

    def delta_log_L(self,alpha,beta,y):
        # print(self.f[:,3,[0,0,1,1],[0,1,1,0]])
        #y=[0,1,1]
        delta=torch.sum(self.f[:,len(y),[0]+y,y+[9]],axis=(1))-torch.sum(self.f* self.p_y12_x_condition_alpha_beta(alpha, beta),axis=(1,2,3))
        return delta
    
    def predict(self,x):
        self.sequence_len = len(x)
        self.get_ts(x)
        self.M = self.f2M()
        return self.Viterbi_M()
    
    
    def train(self,traindata):
        delta=0
        batch_size=100
        num_batch=int(len(traindata[0])/batch_size)
        for e in range(num_batch):
            delta=0
            for i in range(batch_size):
    
                x = traindata[0][e*batch_size+i]
                y = traindata[1][e*batch_size+i]
                self.sequence_len =len(x)
                # print(x)
                self.get_ts(x)
                self.M=self.f2M()
                alpha = self.alpha()
                beta = self.beta()
                    delta += self.delta_log_L(alpha, beta, y)
                    print(delta)
                    print(self.Viterbi_M())
                    print(y)
                self.w = self.w + 0.0001 * delta
    
    • ◼实际上, 梯度上升收敛非常慢

    • ⚫ 替代选择:

      • ◆ 共轭梯度方法
      • ◆ 内存受限拟牛顿法
    • 目前的实现速度贼慢……以后再改

    参考文献

    1. 国科大prml课程
    2. 国科大nlp课程
    3. 条件随机场CRF(一)从随机场到线性链条件随机场
    4. 统计学习方法(李航)
    5. 白板推导CRF
    6. 一个crf实现(用了他的特征函数)
    展开全文
  • 以PML方法为研究实例,提出了分层积分系数矩阵方法,该方法可以显著改善离散化误差,大幅增加观测视场范围,降低协方差误差对测量结果的影响,提高湍流轮廓线的反演精度。数值模拟结果表明,基于分层积分系数矩阵的...
  • 并利用深度学习算法实现桥梁结构健康监测类别预测,同时基于线性共轭梯度对Hessian优化进行改进,利用半正定高斯—牛顿曲率矩阵替换不确定Hessian矩阵,进行二次目标组合,以实现深度学习算法效率提升。实验结果表明...
  • C#数值计算算法编程 代码

    热门讨论 2009-12-11 11:31:58
    本书内容丰富,讲解细致,实例丰富,适合涉及科学与工程数值计算工作的科研人员、工程技术人员、管理人员,以及大专院校相关专业的师生参考阅读。 第1章 C#与数值计算 1.1 数值计算中存在的问题 1.2 用C#实现数值...
  • 8.2.2共轭梯度法 8.3拟牛顿法 本章小结 第9章约束优化方法 9.1约束优化方法简介 9.2随机方向法 9.3复合形法 9.4可行方向法 9.5惩罚函数法 本章小结 第10章二次规划 10.1基本概念 10.2拉格朗日...
  • 7.1.2 模板实例化 7.1.3 模板参数 7.1.4 类型等价 7.1.5 用户定义的特化 7.1.6 特化顺序 7.2 函数模板 7.2.1 函数模板参数 7.2.2 函数模板重载 7.2.3 特化 7.2.4 类模板作为函数模板...
  • 组合数学及其算法

    热门讨论 2011-10-14 20:52:32
    1.2 组合问题典型实例 1.2.1 分派问题 1. 2.2 染色问题 1.2.3 幻方问题 1.2.4 36军官问题 1.2.5 中国邮路问题 习 题 第二章 排列与组合 2.1 两个基本计数原理 2.2 无重集的排列与组合 2.3 重...
  • 解线性方程组的直接法§3.1 高斯消元法§3.2 列主元消元法与三角分解§3.3 直接三角分解法§3.4 向量和矩阵范数§3.5 方程组直接方法的误差估计应用:小行星轨道问题习题三第四章 线性方程组的迭代解法§4.1 ...
  • 12.3.2 共轭先验分布 521 12.4 其他算法 524 12.4.1 Metropolis算法 524 12.4.2 Metropolis-Hasting算法 525 12.4.3 格子Gibbs抽样 525 12.5 带时间序列误差的线性回归 526 12.6 缺失值和异常值 530 12.6.1 ...
  • 范例1-8 查找矩阵的马鞍点 19 ∷相关函数:Get_Saddle函数 1.1.9 对角矩阵建立 21 范例1-9 对角矩阵建立 21 ∷相关函数:Store函数 1.1.10 三对角矩阵的建立 22 范例1-10 三对角矩阵的建立 22 ∷相关函数:...
  • C 开发金典

    2013-06-20 16:20:03
    范例1-8 查找矩阵的马鞍点 19 ∷相关函数:Get_Saddle函数 1.1.9 对角矩阵建立 21 范例1-9 对角矩阵建立 21 ∷相关函数:Store函数 1.1.10 三对角矩阵的建立 22 范例1-10 三对角矩阵的建立 22 ∷相关函数:...
  • C语言通用范例开发金典.part2.rar

    热门讨论 2012-08-31 14:18:18
    范例1-8 查找矩阵的马鞍点 19 ∷相关函数:Get_Saddle函数 1.1.9 对角矩阵建立 21 范例1-9 对角矩阵建立 21 ∷相关函数:Store函数 1.1.10 三对角矩阵的建立 22 范例1-10 三对角矩阵的建立 22 ∷相关函数:...

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

共轭矩阵实例