mirror of
https://github.com/SheffieldML/GPy.git
synced 2026-05-15 06:52:39 +02:00
SDE: removed some unnecessary comments.
This commit is contained in:
Alex Grigorievskiy
parent
9824e02a78
commit
6af11edb6d
2 changed files with 2 additions and 126 deletions
|
|
@ -3415,10 +3415,6 @@ class ContDescrStateSpace(DescreteStateSpace):
|
|||
|
||||
#Q_noise = Q_noise_1
|
||||
|
||||
# Return
|
||||
#import pdb; pdb.set_trace()
|
||||
#if dt != 0:
|
||||
# Q_noise = Q_noise + np.eye(Q_noise.shape[0])*1e-8
|
||||
Q_noise = 0.5*(Q_noise + Q_noise.T) # Symmetrize
|
||||
return A, Q_noise,None, dA, dQ
|
||||
|
||||
|
|
@ -3624,123 +3620,3 @@ def balance_ss_model(F,L,Qc,H,Pinf,P0,dF=None,dQc=None,dPinf=None,dP0=None):
|
|||
# (F,L,Qc,H,Pinf,P0,dF,dQc,dPinf,dP0)
|
||||
|
||||
return bF, bL, bQc, bH, bPinf, bP0, bdF, bdQc, bdPinf, bdP0
|
||||
|
||||
#def psd_matrix_inverse(k,Q, U=None,S=None, p_largest_cond_num=None, regularization_type=2):
|
||||
# """
|
||||
# Function inverts positive definite matrix and regularizes the inverse.
|
||||
# Regularization is useful when original matrix is badly conditioned.
|
||||
# Function is currently used only in SparseGP code.
|
||||
#
|
||||
# Inputs:
|
||||
# ------------------------------
|
||||
# k: int
|
||||
# Iteration umber. Used for information only. Value -1 corresponds to P_inf_inv.
|
||||
#
|
||||
# Q: matrix
|
||||
# To be inverted
|
||||
#
|
||||
# U,S: matrix. vector
|
||||
# SVD components of Q
|
||||
#
|
||||
# p_largest_cond_num: float
|
||||
# Largest condition value for the inverted matrix. If cond. number is smaller than that
|
||||
# no regularization happen.
|
||||
#
|
||||
# regularization_type: 1 or 2
|
||||
# Regularization type.
|
||||
# """
|
||||
# #import pdb; pdb.set_trace()
|
||||
## if (k == 0) or (k == -1): # -1 - P_inf_inv computation
|
||||
## import pdb; pdb.set_trace()
|
||||
#
|
||||
# if p_largest_cond_num is None:
|
||||
# raise ValueError("psd_matrix_inverse: None p_largest_cond_num")
|
||||
#
|
||||
# if U is None or S is None:
|
||||
# (U, S, Vh) = sp.linalg.svd( Q, full_matrices=False, compute_uv=True, overwrite_a=False, check_finite=False)
|
||||
# if S[0] < (1e-4):
|
||||
# #import pdb; pdb.set_trace()
|
||||
# warnings.warn("""state_space_main psd_matrix_inverse: largest singular value is too small {0:e}.
|
||||
# condition number is {1:e} Maybe somethigng is wrong
|
||||
# """.format(S[0], S[0]/S[-1]))
|
||||
# S = S + (1e-4 - S[0]) # make the S[0] at least 1e-4
|
||||
#
|
||||
# current_conditional_number = S[0]/S[-1]
|
||||
# if (current_conditional_number > p_largest_cond_num):
|
||||
# if (regularization_type == 1):
|
||||
# regularizer = S[0] / p_largest_cond_num
|
||||
# # the second computation of SVD is done to compute more precisely singular
|
||||
# # vectors of small singular values, since small singular values become large.
|
||||
# # It is not very clear how this step is useful but test is here.
|
||||
# (U, S, Vh) = sp.linalg.svd( Q + regularizer*np.eye(Q.shape[0]),
|
||||
# full_matrices=False, compute_uv=True, overwrite_a=False, check_finite=False)
|
||||
#
|
||||
# Q_inverse_r = np.dot( U * 1.0/S , U.T ) # Assume Q_inv is positive definite
|
||||
#
|
||||
# # In this case, RBF kernel we get complx eigenvalues. Probably
|
||||
# # for small eigenvalue corresponding eigenvectors are not very orthogonal.
|
||||
# ##########Q_inverse = np.dot( Vh.T * ( 1.0/(S + regularizer)) , U.T )
|
||||
# elif (regularization_type == 2):
|
||||
#
|
||||
# new_border_value = np.sqrt(current_conditional_number)/2
|
||||
# if p_largest_cond_num >= new_border_value: # this type of regularization works
|
||||
# regularizer = ( S[0] / p_largest_cond_num / 2.0 )**2
|
||||
#
|
||||
# Q_inverse_r = np.dot( U * ( S/(S**2 + regularizer)) , U.T ) # Assume Q_inv is positive definite
|
||||
# else:
|
||||
#
|
||||
# better_curr_cond_num = new_border_value
|
||||
# warnings.warn("""state_space_main psd_matrix_inverse: reg_type = 2 can't be done completely.
|
||||
# Current conditionakl number {0:e} is reduced to {1:e} by reg_type = 1""".format(current_conditional_number, better_curr_cond_num))
|
||||
#
|
||||
# regularizer = S[0] / better_curr_cond_num
|
||||
# # the second computation of SVD is done to compute more precisely singular
|
||||
# # vectors of small singular values, since small singular values become large.
|
||||
# # It is not very clear how this step is useful but test is here.
|
||||
# (U, S, Vh) = sp.linalg.svd( Q + regularizer*np.eye(Q.shape[0]),
|
||||
# full_matrices=False, compute_uv=True, overwrite_a=False, check_finite=False)
|
||||
#
|
||||
# regularizer = ( S[0] / p_largest_cond_num / 2.0 )**2
|
||||
#
|
||||
# Q_inverse_r = np.dot( U * ( S/(S**2 + regularizer)) , U.T ) # Assume Q_inv is positive definite
|
||||
#
|
||||
# assert regularizer*10 < S[0], "regularizer is not << S[0]"
|
||||
# assert regularizer > 10*S[-1], "regularizer is not >> S[-1]"
|
||||
#
|
||||
## Old version ->
|
||||
## lamda_star = np.sqrt(current_conditional_number)
|
||||
## if 2*p_largest_cond_num >= lamda_star:
|
||||
## lamda = current_conditional_number / 2 / p_largest_cond_num
|
||||
##
|
||||
## regularizer = (S[-1] * lamda)**2
|
||||
##
|
||||
## Q_inverse_r = np.dot( U * ( S/(S**2 + regularizer)) , U.T ) # Assume Q_inv is positive definite
|
||||
## else:
|
||||
## better_curr_cond_num = (2*p_largest_cond_num)**2 / 2 # division by 2 just in case here
|
||||
## warnings.warn("""state_space_main psd_matrix_inverse: reg_type = 2 can't be done completely.
|
||||
## Current conditionakl number {0:e} is reduced to {1:e} by reg_type = 1""".format(current_conditional_number, better_curr_cond_num))
|
||||
##
|
||||
## regularizer = S[0] / better_curr_cond_num
|
||||
## # the second computation of SVD is done to compute more precisely singular
|
||||
## # vectors of small singular values, since small singular values become large.
|
||||
## # It is not very clear how this step is useful but test is here.
|
||||
## (U, S, Vh) = sp.linalg.svd( Q + regularizer*np.eye(Q.shape[0]),
|
||||
## full_matrices=False, compute_uv=True, overwrite_a=False, check_finite=False)
|
||||
##
|
||||
## lamda = better_curr_cond_num / 2 / p_largest_cond_num
|
||||
##
|
||||
## regularizer = (S[-1] * lamda)**2
|
||||
##
|
||||
## Q_inverse_r = np.dot( U * ( S/(S**2 + regularizer)) , U.T ) # Assume Q_inv is positive definite
|
||||
##
|
||||
## assert lamda > 10, "Some assumptions are incorrect if this is not satisfied."
|
||||
## Old version <-
|
||||
# else:
|
||||
# raise ValueError("AQcompute_batch_Python:Q_inverse: Invalid regularization type")
|
||||
#
|
||||
# else:
|
||||
# Q_inverse_r = np.dot( U * 1.0/S , U.T ) # Assume Q_inv is positive definite
|
||||
# # When checking conditional number 2 times difference is ok.
|
||||
# Q_inverse_r = 0.5*(Q_inverse_r + Q_inverse_r.T)
|
||||
#
|
||||
# return Q_inverse_r
|
||||
|
|
@ -100,8 +100,8 @@ class StateSpace(Model):
|
|||
|
||||
# Get the model matrices from the kernel
|
||||
(F,L,Qc,H,P_inf, P0, dFt,dQct,dP_inft, dP0t) = self.kern.sde()
|
||||
#Qc = Qc + np.eye(Qc.shape[0]) * 1e-8
|
||||
#import pdb; pdb.set_trace()
|
||||
|
||||
|
||||
# necessary parameters
|
||||
measurement_dim = self.output_dim
|
||||
grad_params_no = dFt.shape[2]+1 # we also add measurement noise as a parameter
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue