From 907ade70ec5f0572af72ffbd7c2c02ee42afe734 Mon Sep 17 00:00:00 2001 From: sshojiro Date: Tue, 19 Jun 2018 16:42:16 +0900 Subject: [PATCH 01/12] Remoted the previous redundunt code to enhance readability Also added TODOs for future correction --- pymcr/rank.py | 35 ++++++++++++++++------------------- 1 file changed, 16 insertions(+), 19 deletions(-) diff --git a/pymcr/rank.py b/pymcr/rank.py index cb07ae0..c55a38d 100644 --- a/pymcr/rank.py +++ b/pymcr/rank.py @@ -43,48 +43,45 @@ def pca(D, n_components=None): assert _np.allclose(W, Wt.T) T = _np.dot(D, W) - return (T, W, s2) + return T, W, s2 + def ind(D_actual, ul_rank=100): - """ Malinowski's indicator function """ + """ TODO: update docstring + Malinowski's indicator function """ n_samples = D_actual.shape[0] n_max_rank = _np.min([ul_rank, _np.min(D_actual.shape)-1]) - error_squared = _np.zeros(n_max_rank) T, W, s2 = pca(D_actual) + D_centered = _standardize(D_actual, with_std=False) - # ! PCA only centers the mean, it does not divide by the standard deviation - # PCA forces data matrices to be normalized. - # Therefore, D_actual also needs to be normalized. - # D_scale = _standardize(D_actual) - D_scale = D_actual - D_actual.mean(axis=0, keepdims=True) - # U, S, _ = _svd(D_actual) - # T = U * S - - error_squared = _np.sum(D_scale**2) - _np.sum(_np.cumsum(T[:,:-1]**2, axis=-1), axis=0) - - indicator = _np.sqrt(error_squared) / (n_samples - _np.arange(1, n_max_rank+1))**2 + # error_squared is equal to projection errors of PCA. + error_squared = _np.sum(D_centered**2) - \ + _np.sum(_np.cumsum(T[:,:-1]**2, axis=-1), axis=0) + # indicator is a standardized statistic + indicator = _np.sqrt(error_squared) / \ + (n_samples - _np.arange(1, n_max_rank+1))**2 + # TODO: replace the code above with the following one # n_samples = D_actual.shape[0] # n_features = D_actual.shape[1] - # assert s2.size == n_features, 'Number of samples must be larger than number of features' # k_vec = _np.arange(n_features) + 1 - # eigen_values = _np.sqrt(s2) - # indicator = _np.sqrt(_np.cumsum(eigen_values) / (n_samples * (n_features - k_vec))) / (n_samples - k_vec)**2 return indicator def rod(D_actual, ul_rank=100): - """ Ratio of derivatives """ + """ TODO: update docstring + Ratio of derivatives """ IND = ind(D_actual, ul_rank) ROD = ( IND[0:(len(IND)-2)] - IND[1:(len(IND)-1)] ) \ / ( IND[1:(len(IND)-1)] - IND[2:len(IND)] ) return ROD + if __name__ == '__main__': D = _np.vstack((_np.eye(3), -_np.eye(3))) - ind(D) \ No newline at end of file + print(ind(D)) \ No newline at end of file From 8c5b4fb9f44c3aa130ac51013e5f708d0cc4bd75 Mon Sep 17 00:00:00 2001 From: sshojiro Date: Tue, 19 Jun 2018 16:42:59 +0900 Subject: [PATCH 02/12] Inserted deepcopy --- pymcr/condition.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/pymcr/condition.py b/pymcr/condition.py index daaee1f..356bfc7 100644 --- a/pymcr/condition.py +++ b/pymcr/condition.py @@ -1,5 +1,7 @@ """ Functions to condition / preprocess data """ import numpy as _np +from copy import deepcopy as _deepcopy + def standardize(X, mean_ctr=True, with_std=True, axis=-1, copy=True): """ @@ -21,12 +23,12 @@ def standardize(X, mean_ctr=True, with_std=True, axis=-1, copy=True): Axis from which to calculate mean and standard deviation copy : bool - Copy data (X) if True, overwite if False + Copy data (X) if True, overwrite if False """ if copy: - Xsc = 1*X + Xsc = _deepcopy(X) else: Xsc = X From bbf8d5b4c75c6ad260686df00e84ace2c433df6e Mon Sep 17 00:00:00 2001 From: sshojiro Date: Wed, 20 Jun 2018 18:37:09 +0900 Subject: [PATCH 03/12] Modified IND function; however, the former implementation may contain the errors --- pymcr/rank.py | 85 ++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 61 insertions(+), 24 deletions(-) diff --git a/pymcr/rank.py b/pymcr/rank.py index c55a38d..f3f095c 100644 --- a/pymcr/rank.py +++ b/pymcr/rank.py @@ -10,7 +10,7 @@ def pca(D, n_components=None): """ - Principle component analysis + Principal component analysis Parameters ---------- @@ -25,13 +25,16 @@ def pca(D, n_components=None): Tuple with 3 items: Scores (T), Loadings (W), eigenvalues (singular values-squared) """ + Dcenter = D - D.mean(axis=0, keepdims=True) if n_components is None: - W, s2, Wt = _svd(_np.dot((D - D.mean(axis=0, keepdims=True)).T, - D - D.mean(axis=0, keepdims=True)), + W, s2, Wt = _svd(_np.dot(Dcenter.T, Dcenter), full_matrices=False) + # Note: s2 contains trivial values. + # Ex) Let D n x d matrix (n >= d), + # s2 is n-length vector, + # though the mathematical rank of the metrics is at most d else: - W, s2, Wt = _svds(_np.dot((D - D.mean(axis=0, keepdims=True)).T, - D - D.mean(axis=0, keepdims=True)), k=n_components) + W, s2, Wt = _svds(_np.dot(Dcenter.T, Dcenter), k=n_components) # svds does not sort by variance; thus, manually sorting from biggest to # smallest variance @@ -40,42 +43,76 @@ def pca(D, n_components=None): Wt = Wt[sort_vec, :] s2 = s2[sort_vec] - assert _np.allclose(W, Wt.T) + # SVD decomposes A into U * S * V^T + # It is thought that U == Wt is false. T = _np.dot(D, W) - + # Note: T.mean(axis=0) is almost zeros return T, W, s2 def ind(D_actual, ul_rank=100): - """ TODO: update docstring - Malinowski's indicator function """ + """ + Malinowski's indicator function + + Parameters + ---------- + D_actual : ndarray [n_sample, n_features] + Data + ul_rank : int + The upper limit of the rank. Too large chemical rank + doesn't have reasonable meaning. + + Returns + ------- + IND, ul_rank-length vector + + """ n_samples = D_actual.shape[0] n_max_rank = _np.min([ul_rank, _np.min(D_actual.shape)-1]) T, W, s2 = pca(D_actual) D_centered = _standardize(D_actual, with_std=False) + # FIXME: + # Correct the definition of IND function, based on the following work: + # "An automated procedure to predict the number of components in spectroscopic data" + # error_squared is equal to projection errors of PCA. - error_squared = _np.sum(D_centered**2) - \ - _np.sum(_np.cumsum(T[:,:-1]**2, axis=-1), axis=0) + square_errors = _np.sum(_np.square(D_centered)) - \ + _np.cumsum(s2[0:n_max_rank], axis=-1) + # indicator is a standardized statistic - indicator = _np.sqrt(error_squared) / \ - (n_samples - _np.arange(1, n_max_rank+1))**2 + l_vector = _np.arange(n_max_rank) + 1 + print(l_vector) + indicator = _np.sqrt(square_errors) / \ + _np.square(n_samples - l_vector) + return indicator, square_errors - # TODO: replace the code above with the following one - # n_samples = D_actual.shape[0] - # n_features = D_actual.shape[1] - # assert s2.size == n_features, 'Number of samples must be larger than number of features' - # k_vec = _np.arange(n_features) + 1 - # eigen_values = _np.sqrt(s2) - # indicator = _np.sqrt(_np.cumsum(eigen_values) / (n_samples * (n_features - k_vec))) / (n_samples - k_vec)**2 - return indicator +def rod(D_actual, ul_rank=100): + """ + Ratio of Derivatives (ROD) + + argmax(ROD) is thought to correspond to the chemical rank of the data. + For example, a mixture spectrum consists of three pure components, + the chemical rank is three. The chemical rank of the mixture spectra + is expected to be three. + + Parameters + ---------- + D_actual : ndarray [n_sample, n_features] + Data + ul_rank : int + The upper limit of the rank. Too large chemical rank + doesn't have reasonable meaning. + + Returns + ------- + ROD, ul_rank-length vector + + """ -def rod(D_actual, ul_rank=100): - """ TODO: update docstring - Ratio of derivatives """ IND = ind(D_actual, ul_rank) ROD = ( IND[0:(len(IND)-2)] - IND[1:(len(IND)-1)] ) \ / ( IND[1:(len(IND)-1)] - IND[2:len(IND)] ) From e9ba396f9365974597e860ee06a7cabb5deea50e Mon Sep 17 00:00:00 2001 From: sshojiro Date: Wed, 20 Jun 2018 18:39:17 +0900 Subject: [PATCH 04/12] Inserted my name to the contributor list --- README.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/README.rst b/README.rst index e760dbf..7ef0d96 100644 --- a/README.rst +++ b/README.rst @@ -238,3 +238,4 @@ Contributors - Charles H Camp Jr - Charles Le Losq (charles.lelosq@anu.edu.au) +- [Shojiro Shibayama](https://github.com/sshojiro) From 6e120271eacdf034353c9835bbee65192c0689c1 Mon Sep 17 00:00:00 2001 From: sshojiro Date: Wed, 20 Jun 2018 18:40:41 +0900 Subject: [PATCH 05/12] Included pca into __all__ --- pymcr/rank.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymcr/rank.py b/pymcr/rank.py index f3f095c..bae8f8b 100644 --- a/pymcr/rank.py +++ b/pymcr/rank.py @@ -5,7 +5,7 @@ from pymcr.condition import standardize as _standardize -__all__ = ['ind', 'rod'] +__all__ = ['ind', 'rod', 'pca'] def pca(D, n_components=None): From 0104cbb2f90c30187406138cc9a5e0b5d04c5781 Mon Sep 17 00:00:00 2001 From: sshojiro Date: Sun, 15 Jul 2018 19:06:14 +0900 Subject: [PATCH 06/12] Added RSD, an indicator to compute chemical rank, involved in IND Added its test to validate the length of the computed vector --- pymcr/rank.py | 25 ++++++++++++++++++++++++- pymcr/tests/test_rank.py | 21 +++++++++++++++++++-- 2 files changed, 43 insertions(+), 3 deletions(-) diff --git a/pymcr/rank.py b/pymcr/rank.py index bae8f8b..788dfbf 100644 --- a/pymcr/rank.py +++ b/pymcr/rank.py @@ -5,7 +5,7 @@ from pymcr.condition import standardize as _standardize -__all__ = ['ind', 'rod', 'pca'] +__all__ = ['rsd', 'ind', 'rod', 'pca'] def pca(D, n_components=None): @@ -42,6 +42,7 @@ def pca(D, n_components=None): W = W[:, sort_vec] Wt = Wt[sort_vec, :] s2 = s2[sort_vec] + # FIXME: T.var(axis=0) is not equal to s2 values. # SVD decomposes A into U * S * V^T # It is thought that U == Wt is false. @@ -50,6 +51,28 @@ def pca(D, n_components=None): return T, W, s2 +def rsd(X): + n_rank = _np.min(X.shape) + + + + + + n_samples = X.shape[0] + # pca = PCA(n_components=n_rank)# FIXME: sklearn PCA is not available + # pca.fit(X) + + + + + T, _, _ = pca(X, n_rank) + variances = T.var(axis=0) + # csum = _np.cumsum(pca.explained_variance_[::-1])[::-1] + csum = _np.cumsum(variances[::-1])[::-1] + rsd_ = _np.sqrt( csum / ( n_samples * (n_rank-1) ) ) + return rsd_ + + def ind(D_actual, ul_rank=100): """ Malinowski's indicator function diff --git a/pymcr/tests/test_rank.py b/pymcr/tests/test_rank.py index 0112ce6..527495c 100644 --- a/pymcr/tests/test_rank.py +++ b/pymcr/tests/test_rank.py @@ -1,7 +1,7 @@ """ Test rank metrics """ import numpy as np -from pymcr.rank import pca +from pymcr.rank import pca, rsd def test_pca_full(): """ Test PCA (full rank)""" @@ -17,6 +17,7 @@ def test_pca_full(): assert np.allclose(np.eye(3), np.abs(W)) assert np.allclose(np.abs(D), np.abs(T)) + def test_pca_n_components(): """ Test PCA (2 components)""" D = np.vstack((np.eye(3), -np.eye(3))) @@ -36,4 +37,20 @@ def test_pca_n_components(): # Sorting now built into pca # assert np.allclose(np.eye(3, 2), np.abs(W[:,np.flipud(np.argsort(s2))])) # assert np.allclose(np.abs(D)[:,:2], np.abs(T[:, np.flipud(np.argsort(s2))])) - + + +def test_rsd_length(): + """ Test if RSD's length is correct """ + X = np.random.randn(10, 100) + n_rank = np.min(X) + len(rsd(X)) == n_rank + + +def test_ind_length(): + """ Test if IND's length is correct """ + pass + + +def test_rod_length(): + """ Test if ROD's length is correct """ + pass From 74295ae30353aaad1a2c9b1461f15e98b52b75bf Mon Sep 17 00:00:00 2001 From: sshojiro Date: Sun, 15 Jul 2018 19:10:46 +0900 Subject: [PATCH 07/12] Eliminate redundant blank rows Renamed clearer variables --- pymcr/rank.py | 20 ++++---------------- 1 file changed, 4 insertions(+), 16 deletions(-) diff --git a/pymcr/rank.py b/pymcr/rank.py index 788dfbf..5d875d6 100644 --- a/pymcr/rank.py +++ b/pymcr/rank.py @@ -53,24 +53,12 @@ def pca(D, n_components=None): def rsd(X): n_rank = _np.min(X.shape) - - - - - n_samples = X.shape[0] - # pca = PCA(n_components=n_rank)# FIXME: sklearn PCA is not available - # pca.fit(X) - - - - - T, _, _ = pca(X, n_rank) - variances = T.var(axis=0) - # csum = _np.cumsum(pca.explained_variance_[::-1])[::-1] + pca_scores, _, _ = pca(X, n_rank) + variances = pca_scores.var(axis=0) csum = _np.cumsum(variances[::-1])[::-1] - rsd_ = _np.sqrt( csum / ( n_samples * (n_rank-1) ) ) - return rsd_ + rsd_values = _np.sqrt( csum / ( n_samples * (n_rank-1) ) ) + return rsd_values def ind(D_actual, ul_rank=100): From c59631f37780ef5526c469efa46781cf84ca13d7 Mon Sep 17 00:00:00 2001 From: sshojiro Date: Sun, 15 Jul 2018 21:42:04 +0900 Subject: [PATCH 08/12] Update IND function using RSD, and ROD Implemented the tests for the length of IND and ROD functions --- pymcr/rank.py | 70 +++++++++++++++++++--------------------- pymcr/tests/test_rank.py | 14 +++++--- 2 files changed, 42 insertions(+), 42 deletions(-) diff --git a/pymcr/rank.py b/pymcr/rank.py index 5d875d6..1b27edc 100644 --- a/pymcr/rank.py +++ b/pymcr/rank.py @@ -51,17 +51,33 @@ def pca(D, n_components=None): return T, W, s2 -def rsd(X): - n_rank = _np.min(X.shape) - n_samples = X.shape[0] - pca_scores, _, _ = pca(X, n_rank) +def rsd(D_actual): + """ + The residual standard deviation (RSD) + + Parameters + ---------- + D_actual: ndarray [n_sample, n_features] + Spectral data matrix + + Returns + ------- + RSD, a measure of the lack of fit of a PCA model to a data set. + RSD is computed over l from 1 to q - 1, + where l is the number of principal components, + q is the value of the rank of X + + """ + n_rank = _np.min(D_actual.shape) + n_samples = D_actual.shape[0] + pca_scores, _, _ = pca(D_actual, n_rank) variances = pca_scores.var(axis=0) csum = _np.cumsum(variances[::-1])[::-1] - rsd_values = _np.sqrt( csum / ( n_samples * (n_rank-1) ) ) - return rsd_values + RSD = _np.sqrt( csum / ( n_samples * (n_rank-1) ) ) + return RSD[1:] -def ind(D_actual, ul_rank=100): +def ind(D_actual): """ Malinowski's indicator function @@ -69,38 +85,20 @@ def ind(D_actual, ul_rank=100): ---------- D_actual : ndarray [n_sample, n_features] Data - ul_rank : int - The upper limit of the rank. Too large chemical rank - doesn't have reasonable meaning. Returns ------- IND, ul_rank-length vector """ - n_samples = D_actual.shape[0] - n_max_rank = _np.min([ul_rank, _np.min(D_actual.shape)-1]) - - T, W, s2 = pca(D_actual) - D_centered = _standardize(D_actual, with_std=False) - - # FIXME: - # Correct the definition of IND function, based on the following work: - # "An automated procedure to predict the number of components in spectroscopic data" - - # error_squared is equal to projection errors of PCA. - square_errors = _np.sum(_np.square(D_centered)) - \ - _np.cumsum(s2[0:n_max_rank], axis=-1) - - # indicator is a standardized statistic - l_vector = _np.arange(n_max_rank) + 1 - print(l_vector) - indicator = _np.sqrt(square_errors) / \ - _np.square(n_samples - l_vector) - return indicator, square_errors + n_rank = _np.min(D_actual.shape)# q + RSD = rsd(D_actual) + denominator = _np.square(_np.arange(n_rank-1, 0, -1))# (q-1)^2, (q-2)^2, ..., 2^2, 1^2 + IND = _np.divide(RSD, denominator) + return IND -def rod(D_actual, ul_rank=100): +def rod(D_actual): """ Ratio of Derivatives (ROD) @@ -114,9 +112,6 @@ def rod(D_actual, ul_rank=100): ---------- D_actual : ndarray [n_sample, n_features] Data - ul_rank : int - The upper limit of the rank. Too large chemical rank - doesn't have reasonable meaning. Returns ------- @@ -124,9 +119,10 @@ def rod(D_actual, ul_rank=100): """ - IND = ind(D_actual, ul_rank) - ROD = ( IND[0:(len(IND)-2)] - IND[1:(len(IND)-1)] ) \ - / ( IND[1:(len(IND)-1)] - IND[2:len(IND)] ) + IND = ind(D_actual) + n_ind = len(IND) + ROD = ( IND[0:(n_ind-2)] - IND[1:(n_ind-1)] ) \ + / ( IND[1:(n_ind-1)] - IND[2:n_ind] ) return ROD diff --git a/pymcr/tests/test_rank.py b/pymcr/tests/test_rank.py index 527495c..230003e 100644 --- a/pymcr/tests/test_rank.py +++ b/pymcr/tests/test_rank.py @@ -1,7 +1,7 @@ """ Test rank metrics """ import numpy as np -from pymcr.rank import pca, rsd +from pymcr.rank import pca, rsd, ind, rod def test_pca_full(): """ Test PCA (full rank)""" @@ -42,15 +42,19 @@ def test_pca_n_components(): def test_rsd_length(): """ Test if RSD's length is correct """ X = np.random.randn(10, 100) - n_rank = np.min(X) - len(rsd(X)) == n_rank + n_rank = np.min(X.shape) + assert len(rsd(X)) == n_rank - 1 def test_ind_length(): """ Test if IND's length is correct """ - pass + X = np.random.randn(10, 100) + n_rank = np.min(X.shape) + assert len(ind(X)) == n_rank - 1 def test_rod_length(): """ Test if ROD's length is correct """ - pass + X = np.random.randn(10, 100) + n_rank = np.min(X.shape) + assert len(rod(X)) == n_rank - 1 - 2 From a29f613afa438f6e3db80f3d8711ae0ce9194723 Mon Sep 17 00:00:00 2001 From: sshojiro Date: Wed, 25 Jul 2018 13:44:34 +0900 Subject: [PATCH 09/12] Updated rank code PCA computation and RSD computation reduce the rank of the spectra by one respectively --- pymcr/rank.py | 18 ++++++++++++------ pymcr/tests/test_rank.py | 24 +++++++++++++++++------- 2 files changed, 29 insertions(+), 13 deletions(-) diff --git a/pymcr/rank.py b/pymcr/rank.py index 1b27edc..0448fe2 100644 --- a/pymcr/rank.py +++ b/pymcr/rank.py @@ -34,6 +34,8 @@ def pca(D, n_components=None): # s2 is n-length vector, # though the mathematical rank of the metrics is at most d else: + if n_components == Dcenter.shape[0]: + n_components -= 1 W, s2, Wt = _svds(_np.dot(Dcenter.T, Dcenter), k=n_components) # svds does not sort by variance; thus, manually sorting from biggest to @@ -63,17 +65,21 @@ def rsd(D_actual): Returns ------- RSD, a measure of the lack of fit of a PCA model to a data set. - RSD is computed over l from 1 to q - 1, + The number of PCA components is q - 1, when the rank of input data is q. + Centering preceding PCA reduces the rank by one. + + RSD is computed over l from 1 to q - 2 by definition, where l is the number of principal components, q is the value of the rank of X """ n_rank = _np.min(D_actual.shape) n_samples = D_actual.shape[0] - pca_scores, _, _ = pca(D_actual, n_rank) + pca_scores, _, _ = pca(D_actual, n_rank-1) + q = pca_scores.shape[1] variances = pca_scores.var(axis=0) csum = _np.cumsum(variances[::-1])[::-1] - RSD = _np.sqrt( csum / ( n_samples * (n_rank-1) ) ) + RSD = _np.sqrt( csum / ( n_samples * (q-1) ) ) return RSD[1:] @@ -92,8 +98,8 @@ def ind(D_actual): """ n_rank = _np.min(D_actual.shape)# q - RSD = rsd(D_actual) - denominator = _np.square(_np.arange(n_rank-1, 0, -1))# (q-1)^2, (q-2)^2, ..., 2^2, 1^2 + RSD = rsd(D_actual)# the length is q-2 + denominator = _np.square(_np.arange(n_rank-2, 0, -1))# (q-1)^2, (q-2)^2, ..., 2^2, 1^2 IND = _np.divide(RSD, denominator) return IND @@ -123,7 +129,7 @@ def rod(D_actual): n_ind = len(IND) ROD = ( IND[0:(n_ind-2)] - IND[1:(n_ind-1)] ) \ / ( IND[1:(n_ind-1)] - IND[2:n_ind] ) - return ROD + return _np.array([0, 0]+list(ROD)) if __name__ == '__main__': diff --git a/pymcr/tests/test_rank.py b/pymcr/tests/test_rank.py index 230003e..0f53f4a 100644 --- a/pymcr/tests/test_rank.py +++ b/pymcr/tests/test_rank.py @@ -3,6 +3,7 @@ from pymcr.rank import pca, rsd, ind, rod + def test_pca_full(): """ Test PCA (full rank)""" D = np.vstack((np.eye(3), -np.eye(3))) @@ -19,7 +20,7 @@ def test_pca_full(): def test_pca_n_components(): - """ Test PCA (2 components)""" + """ Test PCA (2 components) """ D = np.vstack((np.eye(3), -np.eye(3))) # Axis 0 is most variability # Axis 1 is next @@ -40,21 +41,30 @@ def test_pca_n_components(): def test_rsd_length(): - """ Test if RSD's length is correct """ + """ + Test if RSD's length is correct + Note that centering before PCA and RSD computation reduce the rank by one respectively. + """ X = np.random.randn(10, 100) n_rank = np.min(X.shape) - assert len(rsd(X)) == n_rank - 1 + assert len(rsd(X)) == n_rank - 2 def test_ind_length(): - """ Test if IND's length is correct """ + """ + Test if IND's length is correct + Note that centering before PCA and RSD computation reduce the rank by one respectively. + """ X = np.random.randn(10, 100) n_rank = np.min(X.shape) - assert len(ind(X)) == n_rank - 1 + assert len(ind(X)) == n_rank - 2 def test_rod_length(): - """ Test if ROD's length is correct """ + """ + Test if ROD's length is correct + Note that centering before PCA and RSD computation reduce the rank by one respectively. + """ X = np.random.randn(10, 100) n_rank = np.min(X.shape) - assert len(rod(X)) == n_rank - 1 - 2 + assert len(rod(X)) == n_rank - 2 From df8895dee41f88e72c077cbd6a0c49e591b0e4f4 Mon Sep 17 00:00:00 2001 From: sshojiro Date: Wed, 25 Jul 2018 14:04:13 +0900 Subject: [PATCH 10/12] Updated rank notebook along with the update of the indicator definitions --- Examples/Rank.ipynb | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/Examples/Rank.ipynb b/Examples/Rank.ipynb index b64e0b4..2a08992 100644 --- a/Examples/Rank.ipynb +++ b/Examples/Rank.ipynb @@ -16,6 +16,8 @@ "IND(L) = \\frac{ \\sqrt{ \\sum_{i=1}^N\\sum_{a=L+1}^A e_{i,a}^2 }}{ (N-L)^2 } ,\n", "\\\\\n", "ROD(L) = \\frac{IND(L-2) - IND(L-1)}{IND(L-1) - IND(L)} \\quad (L\\geq3),\n", + "\\\\\n", + "ROD(L) = 0 \\quad (L=1, 2),\n", "$\n", "\n", "where $e_{i,a}$, $d_{i,j}$, and $t_{i,a}$ denote PCA projection error, original spectral intensity, and PCA score respectively. $i$, $j$, and $a$ denote the index of sample, the index of wavelength, and the index of PCA score. $L$ denotes the number of components.\n", @@ -24,11 +26,14 @@ "\n", "On another note, $IND(L-1) \\geq IND(L)$ is generally true because the remaining error IND(L) decrease monotonously along with $L$. Thus, ROD(L) basically takes non-negative value.\n", "\n", + "Another old work has introduced various indicators including IND. The equations that appear in the first refernce have some mistakes; therefore, you may look into the second reference to see the accurate definition\n", + "\n", "## Usage\n", "\n", "After computing IND or ROD, one can take the number of components that achieves either the minimum value of IND or the maximum value of ROD.\n", "\n", - "[1] D. Tefera; et al. $\\it{Ind. Eng. Chem. Res.}$ 2017 vol: 56 pp: 10756-10769" + "[1] D. Tefera; et al. $\\it{Ind. Eng. Chem. Res.}$ 2017 vol: 56 pp: 10756-10769\n", + "[2] A. Elbergali; et al. ${\\it Anal. Chim. Acta}$ 1999 vol: 379(1-2) pp: 143-158" ] }, { @@ -37,6 +42,9 @@ "metadata": {}, "outputs": [], "source": [ + "import sys\n", + "sys.path.append('../')\n", + "\n", "from pymcr import rank\n", "from scipy import io\n", "import numpy as np\n", @@ -97,8 +105,8 @@ "outputs": [], "source": [ "# Computation\n", - "IND = rank.ind(Xmix, ul_rank=120)\n", - "ROD = rank.rod(Xmix, ul_rank=120)" + "IND = rank.ind(Xmix)\n", + "ROD = rank.rod(Xmix)" ] }, { @@ -108,7 +116,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -118,7 +126,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -134,7 +142,7 @@ "plt.ylabel('IND')\n", "plt.show()\n", "\n", - "plt.plot(np.arange(3, len(IND)+1), ROD,'o-')\n", + "plt.plot(np.arange(1, len(ROD)+1), ROD,'o-')\n", "plt.xlabel('number of components, $L$')\n", "plt.ylabel('ROD')\n", "plt.show()" @@ -149,15 +157,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "4.665466859162282\n", - "4.665466859162322\n" + "6.373826928554154\n", + "6.373845144610116\n" ] } ], "source": [ "# ROD(L) when L=3\n", "print( (IND[0] - IND[1])/(IND[1] - IND[2]) )\n", - "print( ROD[0] )" + "print( ROD[2] )" ] }, { @@ -169,13 +177,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "71 components are hidden in the `Xmix`\n", - "71 components are hidden in the `Xmix`\n" + "3 components are hidden in the `Xmix`\n", + "56 components are hidden in the `Xmix`\n" ] } ], "source": [ - "print('{} components are hidden in the `Xmix`'.format(np.argmax(ROD)+1+2))\n", + "print('{} components are hidden in the `Xmix`'.format(np.argmax(ROD)+1))\n", "print('{} components are hidden in the `Xmix`'.format(np.argmin(IND)+1))" ] } From cfa12ae420f63135a631aa5fe6187c4f0701e4bb Mon Sep 17 00:00:00 2001 From: sshojiro Date: Wed, 25 Jul 2018 14:32:43 +0900 Subject: [PATCH 11/12] Corrected a denominator value Eliminated the needless path manipulation --- Examples/Rank.ipynb | 11 ++++------- pymcr/rank.py | 2 +- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/Examples/Rank.ipynb b/Examples/Rank.ipynb index 2a08992..a18ef1e 100644 --- a/Examples/Rank.ipynb +++ b/Examples/Rank.ipynb @@ -42,9 +42,6 @@ "metadata": {}, "outputs": [], "source": [ - "import sys\n", - "sys.path.append('../')\n", - "\n", "from pymcr import rank\n", "from scipy import io\n", "import numpy as np\n", @@ -116,7 +113,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -126,7 +123,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -157,8 +154,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "6.373826928554154\n", - "6.373845144610116\n" + "6.37383170689348\n", + "6.373863118233257\n" ] } ], diff --git a/pymcr/rank.py b/pymcr/rank.py index 0448fe2..7407bb0 100644 --- a/pymcr/rank.py +++ b/pymcr/rank.py @@ -79,7 +79,7 @@ def rsd(D_actual): q = pca_scores.shape[1] variances = pca_scores.var(axis=0) csum = _np.cumsum(variances[::-1])[::-1] - RSD = _np.sqrt( csum / ( n_samples * (q-1) ) ) + RSD = _np.sqrt( csum / ( n_samples * (q-2) ) ) return RSD[1:] From 2fe771c37110cd627760575bd904a94e34a09f98 Mon Sep 17 00:00:00 2001 From: sshojiro Date: Wed, 25 Jul 2018 14:36:36 +0900 Subject: [PATCH 12/12] Updated documentation of the indicators --- pymcr/rank.py | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/pymcr/rank.py b/pymcr/rank.py index 7407bb0..c78d00d 100644 --- a/pymcr/rank.py +++ b/pymcr/rank.py @@ -64,13 +64,14 @@ def rsd(D_actual): Returns ------- - RSD, a measure of the lack of fit of a PCA model to a data set. - The number of PCA components is q - 1, when the rank of input data is q. - Centering preceding PCA reduces the rank by one. + RSD : ndarray [n_rank-2, ] + a measure of the lack of fit of a PCA model to a data set. + The number of PCA components is q - 1, when the rank of input data is q. + Centering preceding PCA reduces the rank by one. - RSD is computed over l from 1 to q - 2 by definition, - where l is the number of principal components, - q is the value of the rank of X + RSD is computed over l from 1 to q - 2 by definition, + where l is the number of principal components, + q is the value of the rank of X """ n_rank = _np.min(D_actual.shape) @@ -94,7 +95,10 @@ def ind(D_actual): Returns ------- - IND, ul_rank-length vector + IND : ndarray [n_rank-2, ] + n_rank-2 length vector + Centering before PCA operation and RSD computation reduce the rank of the matrix + by one respectively. """ n_rank = _np.min(D_actual.shape)# q @@ -121,7 +125,10 @@ def rod(D_actual): Returns ------- - ROD, ul_rank-length vector + ROD : ndarray [n_rank-2, ] + n_rank-2 length vector + Centering before PCA operation and RSD computation reduce the rank of the matrix + by one respectively. """