共轭矩阵实例

python矩阵运算,转置,逆运算,共轭矩阵实例
2020-09-16 21:42:30
主要介绍了python矩阵运算,转置,逆运算,共轭矩阵实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
收起

python 共轭转置_python矩阵运算,转置,逆运算,共轭矩阵实例

2020-12-08 12:19:41

#先定义两个矩阵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

收起

展开全文

matlab 转置

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...
收起
C#版数值计算算法教材及实例代码
2011-05-13 11:17:43
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

收起

展开全文

PCA

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 ...


文章目录
计算下Z（矩阵）
1.1 一般参数形式
1.2 简化形式
Z
1.3 矩阵形式
1.3.2 Z
2.维特比算法
3.前向算法
4.后向算法
5.使用前向后向的概率计算
6.期望计算
7.参数估计（学习）
7.1 梯度上升
参考文献


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=(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.前向算法


一般

 $\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)$ 

矩阵形式

 $这是一个向量：\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.后向算法
 $\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(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(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.参数估计（学习）
 $\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(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 梯度上升
 $\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



◼实际上, 梯度上升收敛非常慢


⚫ 替代选择:

◆ 共轭梯度方法
◆ 内存受限拟牛顿法



目前的实现速度贼慢……以后再改


参考文献

国科大prml课程
国科大nlp课程
条件随机场CRF(一)从随机场到线性链条件随机场
统计学习方法（李航）
白板推导CRF
一个crf实现（用了他的特征函数）

收起

展开全文

宽视场湍流轮廓线测量方法研究
2021-01-27 04:45:35
以PML方法为研究实例，提出了分层积分系数矩阵方法，该方法可以显著改善离散化误差，大幅增加观测视场范围，降低协方差误差对测量结果的影响，提高湍流轮廓线的反演精度。数值模拟结果表明，基于分层积分系数矩阵的...
收起
论文研究-桥梁结构的未标记模态特征稀疏编码深度学习监测.pdf
2019-07-22 19:24:33
并利用深度学习算法实现桥梁结构健康监测类别预测，同时基于线性共轭梯度对Hessian优化进行改进，利用半正定高斯—牛顿曲率矩阵替换不确定Hessian矩阵，进行二次目标组合，以实现深度学习算法效率提升。实验结果表明...
收起
深度学习稀疏编码无线传感器
C#数值计算算法编程代码
热门讨论 2009-12-11 11:31:58
本书内容丰富，讲解细致，实例丰富，适合涉及科学与工程数值计算工作的科研人员、工程技术人员、管理人员，以及大专院校相关专业的师生参考阅读。第1章 C#与数值计算 1.1 数值计算中存在的问题 1.2 用C#实现数值...
收起
《MATLAB优化算法张岩吴水根著》源码
2018-06-04 09:34:14
8．2．2共轭梯度法 8．3拟牛顿法本章小结第9章约束优化方法 9．1约束优化方法简介 9．2随机方向法 9．3复合形法 9．4可行方向法 9．5惩罚函数法本章小结第10章二次规划 10．1基本概念 10．2拉格朗日...
收起
C++和面向对象数值计算
2013-02-05 18:56:51
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 类模板作为函数模板...
收起
C++ 数值计算
组合数学及其算法
热门讨论 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 重...
收起
《数值分析》作者: 钟尔杰,黄廷祝出版时间: 2004年
2019-06-07 19:00:18
解线性方程组的直接法§3．1 高斯消元法§3．2 列主元消元法与三角分解§3．3 直接三角分解法§3．4 向量和矩阵范数§3．5 方程组直接方法的误差估计应用：小行星轨道问题习题三第四章线性方程组的迭代解法§4．1 ...
收起
金融时间序列分析（中文第3版）Ruey S. Tray 清晰带书签
2018-10-05 17:06:14
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 ...
收起
时间序列
C开发金典随书源码：含数据结构数值计算分析图形图像处理目录和文件操作系统调用方面的范例
2013-10-25 13:12:12
范例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 ∷相关函数：...
收起

python矩阵运算,转置,逆运算,共轭矩阵实例

python 共轭转置_python矩阵运算,转置,逆运算,共轭矩阵实例

matlab中关于矩阵转置的学习日记

GPU高性能计算之CUDA》实例

《GPU高性能计算之CUDA》实例

基于Visual C#的DirectX开发实例教程

C#版数值计算算法教材及实例代码

PCA与SVD

Outline

预备知识

SVD

PCA

实验结果

CRF总结

文章目录

计算下Z（矩阵）

1.1 一般参数形式

1.2 简化形式

Z

1.3 矩阵形式

1.3.2 Z

2.维特比算法

3.前向算法

4.后向算法

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

6.期望计算

7.参数估计（学习）

7.1 梯度上升

参考文献

宽视场湍流轮廓线测量方法研究

论文研究-桥梁结构的未标记模态特征稀疏编码深度学习监测.pdf

C#数值计算算法编程 代码

《MATLAB优化算法 张岩 吴水根著》源码

C++和面向对象数值计算

组合数学及其算法

《数值分析》作者: 钟尔杰,黄廷祝 出版时间: 2004年

金融时间序列分析（中文第3版）Ruey S. Tray 清晰带书签

C开发金典随书源码：含数据结构 数值计算分析 图形图像处理 目录和文件操作 系统调用方面的范例

C 开发金典

C语言通用范例开发金典.part2.rar

共轭矩阵实例

RPS：剪刀石头布-源码

Delta Lake 在 Soul 的应用实践

MySQL 数据库权限管理（用户高级管理和精确访问控制）

【Python-随到随学】FLask第二周

面部识别脑-源码

结合稀疏的GPS探测数据和社交媒体数据计算城市交通拥堵

计算机专业，想要学习java，给点建议？

螺旋桨-源码

【硬核】一线Python程序员实战经验分享（1）

函数计算镜像加速：从分钟到秒的跨越

专高三day011PickerView

HTML5设计原理

PAT 1006

Could not find resource com/wxy/dao/adminMapper.xml

基于python的服务器巡检及数据分析

多域多任务传输深度网络的预测用户点击功能识别图像

云存储在淘宝网的实际应用—详解TFS

第11天PickerView和AutoSize

SM2的P7结构体简单分析

自动化测试Python3+Selenium3+Unittest

C#数值计算算法编程代码

《MATLAB优化算法张岩吴水根著》源码

《数值分析》作者: 钟尔杰,黄廷祝出版时间: 2004年

C开发金典随书源码：含数据结构数值计算分析图形图像处理目录和文件操作系统调用方面的范例