def covariance_from_internal_jacobian(internal_values, constr): r"""Jacobian of ``covariance_from_internal``. The following result is motivated by https://tinyurl.com/y4pbfxst, which is shortly presented again here. For notation see the explaination at the beginning of the module. Explaination of the result -------------------------- We want to differentiate the graph internal --> cholesky --> cov --> external Define :math:`x' := \text{vec}(X)` and :math:`c' := \text{vec}(S)`, where :math:`X` denotes the Cholesky factor of the covariance matrix :math:`S`. We then first differentiate the part "cholesky --> cov" using the result stated in the tinyurl above to get .. math:: J' := \frac{\mathrm{d}c'}{\mathrm{d}x'} = (I + K)(X \otimes I) \,, where :math:`K` denotes the commutation matrix. Using this intermediate result we can compute the jacobian as .. math:: \frac{\mathrm{d}c}{\mathrm{d}x} = L J' D \,, where :math:`c := \text{external}` and :math:`x := \text{internal}`. Args: internal_values (np.ndarray): Cholesky factors stored in an "internal" format. Returns: deriv: The Jacobian matrix. """ chol = chol_params_to_lower_triangular_matrix(internal_values) dim = len(chol) K = _commutation_matrix(dim) L = _elimination_matrix(dim) left = np.eye(dim**2) + K right = np.kron(chol, np.eye(dim)) intermediate = left @ right deriv = L @ intermediate @ L.T return deriv
def covariance_from_internal(internal_values, constr): """Undo a cholesky reparametrization.""" chol = chol_params_to_lower_triangular_matrix(internal_values) cov = chol @ chol.T return cov[np.tril_indices(len(chol))]
def sdcorr_from_internal(internal_values, constr): """Undo a cholesky reparametrization.""" chol = chol_params_to_lower_triangular_matrix(internal_values) cov = chol @ chol.T return cov_matrix_to_sdcorr_params(cov)
def sdcorr_from_internal_jacobian(internal_values, constr): r"""Derivative of ``sdcorr_from_internal``. The following result is motivated by https://tinyurl.com/y6ytlyd9; however since the question was formulated with an error the result here is adjusted slightly. In particular, in the answer by user 'greg', the matrix :math:`A` should have been defined as :math:`A = \text{diag}(||x_1||, \dots, ||x_n||)` , where :math:`||x_i||` denotes the euclidian norm of the the i-th row of :math:`X` (the Cholesky factor). For notation see the explaination at the beginning of the module or the question on the tinyurl. The variable names in this function are chosen to be consistent with the tinyurl link. Explaination on the result -------------------------- We want to differentiate the graph internal --> cholesky --> cov --> corr-mat --> mod. corr-mat --> external where mod. corr-mat denotes the modified correlation matrix which has the standard deviations stored on its diagonal. Let :math:`x := \text{internal}` and :math:`p := \text{external}`. Then we want to compute the quantity .. math:: \frac{\mathrm{d} p}{\mathrm{d} x} . As before we consider an intermediate result first. Namely we define :math:`A` as above, :math:`V := A^{-1}` and :math:`P := V S V + A - I`. The attentive reader might now notice that :math:`P` is the modified correlation matrix. At last we write :math:`x' := \text{vec}(X)` and :math:`p' := \text{vec}(P)`. Using the result stated in the tinyurl above, adjusted for the different matrix :math:`A`, we can compute the quantity :math:`(\mathrm{d} p'/ \mathrm{d} x')`. Finally, since we can define transformation matrices :math:`T` and :math:`L` to get :math:`p = T p'` and :math:`x = L x'` (where :math:`L` denotes the elimination matrix with corresponding duplication matrix :math:`D`), we can get our final result as .. math:: \frac{\mathrm{d}p}{\mathrm{d}x} = T \frac{\mathrm{d}p'}{\mathrm{d}x'} D Args: internal_values (np.ndarray): Cholesky factors stored in an "internal" format. Returns: deriv: The Jacobian matrix. """ X = chol_params_to_lower_triangular_matrix(internal_values) dim = len(X) identity = np.eye(dim) S = X @ X.T # the wrong formulation in the tinyurl stated: A = np.multiply(I, X) A = np.sqrt(np.multiply(identity, S)) V = np.linalg.inv(A) K = _commutation_matrix(dim) Y = np.diag(identity.ravel("F")) # with the wrong formulation in the tinyurl we would have had U = Y norms = np.sqrt((X**2).sum(axis=1).reshape(-1, 1)) XX = X / norms U = Y @ np.kron(identity, XX) @ K N = np.kron(identity, X) @ K + np.kron(X, identity) VS = V @ S B = np.kron(V, V) H = np.kron(VS, identity) J = np.kron(identity, VS) intermediate = U + B @ N - (H + J) @ B @ U T = _transformation_matrix(dim) D = _duplication_matrix(dim) deriv = T @ intermediate @ D return deriv
def test_chol_params_to_lower_triangular_matrix(): calculated = chol_params_to_lower_triangular_matrix(pd.Series([1, 2, 3])) expected = np.array([[1, 0], [2, 3]]) aaae(calculated, expected)