def updateParams(self,
z,
As,
sigmas,
C,
R,
mu0,
sigma0,
u=None,
ys=None,
computeMarginal=True):
self.parameterCheck(z, As, sigmas, C, R, mu0, sigma0, u=u, ys=ys)
n1Trans, n2Trans, n3Trans = zip(*[
Regression.standardToNat(A, sigma) for A, sigma in zip(As, sigmas)
])
n1Emiss, n2Emiss, n3Emiss = Regression.standardToNat(C, R)
n1Init, n2Init = Normal.standardToNat(mu0, sigma0)
self.updateNatParams(z,
n1Trans,
n2Trans,
n3Trans,
n1Emiss,
n2Emiss,
n3Emiss,
n1Init,
n2Init,
u=u,
ys=ys,
computeMarginal=computeMarginal)
def fullSample( self, stabilize=False, **kwargs ):
if( stabilize == True ):
J11 = np.copy( self.J11 )
J12 = np.copy( self.J12 )
J22 = np.copy( self.J22 )
A, sigma = Regression.natToStandard( -0.5 * self.J11, -0.5 * self.J22, -self.J12.T )
A = stab( A )
n1, n2, n3 = Regression.standardToNat( A, sigma )
self.J11 = -2 * n1
self.J12 = -n3.T
self.J22 = -2 * n2
self.log_Z = 0.5 * np.linalg.slogdet( np.linalg.inv( self.J11 ) )[ 1 ]
ans = super( LDSState, self ).fullSample( **kwargs )
if( stabilize == True ):
self.J11 = J11
self.J12 = J12
self.J22 = J22
self.log_Z = 0.5 * np.linalg.slogdet( np.linalg.inv( self.J11 ) )[ 1 ]
return ans
def log_partition( cls, x=None, params=None, nat_params=None, split=False ):
# Compute A( Ѳ ) - log( h( x ) )
assert ( params is None ) ^ ( nat_params is None )
# Need to multiply each partition by the length of each sequence!!!!
A, sigma, C, R, mu0, sigma0 = params if params is not None else cls.natToStandard( *nat_params )
A1, A2 = Regression.log_partition( params=( A, sigma ), split=True )
A3, A4 = Regression.log_partition( params=( C, R ), split=True )
A5, A6, A7 = Normal.log_partition( params=( mu0, sigma0 ), split=True )
if( split == True ):
return A1, A2, A3, A4, A5, A6, A7
return A1 + A2 + A3 + A4 + A5 + A6 + A7
def transitionStats( cls, x, constParams=None ):
u, t = constParams
lastX, x = x
assert lastX.ndim == 1 and lastX.shape == x.shape
xIn = lastX
xOut = x - u[ t ]
return Regression.sufficientStats( x=( xIn, xOut ) )
def updateParams( self, initialDist, transDist, mu0, sigma0, u, As, sigmas, xs=None, computeMarginal=True ):
self.parameterCheck( initialDist, transDist, mu0, sigma0, u, As, sigmas, xs=xs )
nInit, = Categorical.standardToNat( initialDist )
nTrans, = Transition.standardToNat( transDist )
nat1_0, nat2_0 = Normal.standardToNat( mu0, sigma0 )
nat1Trans, nat2Trans, nat3Trans = zip( *[ Regression.standardToNat( A, sigma ) for A, sigma in zip( As, sigmas ) ] )
self.updateNatParams( nInit, nTrans, nat1_0, nat2_0, nat1Trans, nat2Trans, nat3Trans, u=u, xs=xs )
def sufficientStats( cls, x, constParams=None ):
# Compute T( x ). This is for when we're treating this class as P( x, y | Ѳ )
if( cls.dataN( x ) > 1 ):
t = [ 0, 0, 0, 0, 0, 0, 0, 0 ]
for _x, _ys in zip( *x ):
s = cls.sufficientStats( ( _x, _ys ), constParams=constParams )
for i in range( 8 ):
t[ i ] += s[ i ]
return tuple( t )
( x, ys ) = x
u = constParams
xIn = x[ :-1 ]
xOut = x[ 1: ] - u[ :-1 ]
t1, t2, t3 = Regression.sufficientStats( x=( xIn, xOut ), constParams=constParams )
t4, t5, t6 = Regression.sufficientStats( x=( x, ys ), constParams=constParams )
t7, t8 = Normal.sufficientStats( x=x[ 0 ], constParams=constParams )
return t1, t2, t3, t4, t5, t6, t7, t8
def updateParams(self,
A,
sigma,
C,
R,
mu0,
sigma0,
u=None,
ys=None,
computeMarginal=True):
self.parameterCheck(A, sigma, C, R, mu0, sigma0, u=u, ys=ys)
n1Init, n2Init = Normal.standardToNat(mu0, sigma0)
n1Emiss, n2Emiss, n3Emiss = Regression.standardToNat(C, R)
n1Trans, n2Trans, n3Trans = Regression.standardToNat(A, sigma)
self.updateNatParams(n1Trans,
n2Trans,
n3Trans,
n1Emiss,
n2Emiss,
n3Emiss,
n1Init,
n2Init,
u=u,
ys=ys,
computeMarginal=computeMarginal)
self.fromNatural = False
self._A = A
self._sigma = sigma
self._C = C
self._R = R
self._mu0 = mu0
self._sigma0 = sigma0
def ll( _x ):
x, x1 = np.split( _x, 2 )
return Regression.log_likelihood( ( x, x1 ), nat_params=( n1, n2, n3 ) )
def emissionStats( cls, x, constParams=None ):
_x, y = x
assert _x.ndim == 1
return Regression.sufficientStats( x=( _x, y ) )
def natToStandard( cls, n1, n2, n3, n4, n5, n6, n7, n8 ):
A, sigma = Regression.natToStandard( n1, n2, n3 )
C, R = Regression.natToStandard( n4, n5, n6 )
mu0, sigma0 = Normal.natToStandard( n7, n8 )
return A, sigma, C, R, mu0, sigma0
def standardToNat( cls, A, sigma, C, R, mu0, sigma0 ):
n1, n2, n3 = Regression.standardToNat( A, sigma )
n4, n5, n6 = Regression.standardToNat( C, R )
n7, n8 = Normal.standardToNat( mu0, sigma0 )
return n1, n2, n3, n4, n5, n6, n7, n8