def test_sklearn_mcr_semilearned_both_c_st(): """ Test the special case when C & ST are provided, requiring C-fix ST-fix to be provided """ M = 21 N = 21 P = 101 n_components = 3 C_img = np.zeros((M, N, n_components)) C_img[..., 0] = np.dot(np.ones((M, 1)), np.linspace(0.1, 1, N)[None, :]) C_img[..., 1] = np.dot(np.linspace(0.1, 1, M)[:, None], np.ones((1, N))) C_img[..., 2] = 1 - C_img[..., 0] - C_img[..., 1] C_img = C_img / C_img.sum(axis=-1)[:, :, None] St_known = np.zeros((n_components, P)) St_known[0, 30:50] = 1 St_known[1, 50:70] = 2 St_known[2, 70:90] = 3 St_known += 1 C_known = C_img.reshape((-1, n_components)) D_known = np.dot(C_known, St_known) C_guess = 1 * C_known C_guess[:, 2] = np.abs(np.random.randn(int(M * N))) mcrar = McrAR(max_iter=50, tol_increase=100, tol_n_increase=10, st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=1e-10, fit_kwargs={ 'C': C_guess, 'ST': St_known, 'c_fix': [0, 1], 'st_fix': [0] }) mcrar.fit(D_known, c_first=True) assert_equal(mcrar.C_[:, 0], C_known[:, 0]) assert_equal(mcrar.C_[:, 1], C_known[:, 1]) assert_equal(mcrar.ST_[0, :], St_known[0, :]) # ST-solve first mcrar.fit(D_known, C=C_guess, ST=St_known, c_fix=[0, 1], st_fix=[0], c_first=False) assert_equal(mcrar.C_[:, 0], C_known[:, 0]) assert_equal(mcrar.C_[:, 1], C_known[:, 1]) assert_equal(mcrar.ST_[0, :], St_known[0, :])
def __init__(self, c_regr=OLS(), st_regr=OLS(), c_fit_kwargs={}, st_fit_kwargs={}, c_constraints=[ConstraintNonneg()], st_constraints=[ConstraintNonneg()], max_iter=50, err_fcn=mse, tol_increase=0.0, tol_n_increase=10, tol_err_change=None, tol_n_above_min=10): """ Multivariate Curve Resolution - Alternating Regression """ self.max_iter = max_iter self.tol_increase = tol_increase self.tol_n_increase = tol_n_increase self.tol_err_change = tol_err_change self.tol_n_above_min = tol_n_above_min self.err_fcn = err_fcn self.err = None self.c_constraints = c_constraints self.st_constraints = st_constraints self.c_regressor = self._check_regr(c_regr) self.st_regressor = self._check_regr(st_regr) self.c_fit_kwargs = c_fit_kwargs self.st_fit_kwargs = st_fit_kwargs self.C_ = None self.ST_ = None self.C_opt_ = None self.ST_opt_ = None self.n_iter_opt = None self.n_iter = None self.n_increase = None self.n_above_min = None self.exit_max_iter_reached = False self.exit_tol_increase = False self.exit_tol_n_increase = False self.exit_tol_err_change = False self.exit_tol_n_above_min = False # Saving every C or S^T matrix at each iteration # Could create huge memory usage self._saveall_st = False self._saveall_c = False self._saved_st = [] self._saved_c = []
def test_mcr_tol_err_change(dataset): """ Test MCR exits due error increasing by a value """ C_known, D_known, St_known = dataset mcrar = McrAR(max_iter=50, c_regr='OLS', st_regr='OLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_increase=None, tol_n_increase=None, tol_err_change=1e-20, tol_n_above_min=None) mcrar.fit(D_known, C=C_known) assert mcrar.exit_tol_err_change
def test_sklearn_mcr_c_semilearned(): """ Test when C items are fixed, i.e., enforced to be the same as the input, always """ M = 21 N = 21 P = 101 n_components = 3 C_img = np.zeros((M, N, n_components)) C_img[..., 0] = np.dot(np.ones((M, 1)), np.linspace(0, 1, N)[None, :]) C_img[..., 1] = np.dot(np.linspace(0, 1, M)[:, None], np.ones((1, N))) C_img[..., 2] = 1 - C_img[..., 0] - C_img[..., 1] C_img = C_img / C_img.sum(axis=-1)[:, :, None] St_known = np.zeros((n_components, P)) St_known[0, 30:50] = 1 St_known[1, 50:70] = 2 St_known[2, 70:90] = 3 St_known += 1 C_known = C_img.reshape((-1, n_components)) D_known = np.dot(C_known, St_known) C_guess = 1 * C_known C_guess[:, 2] = np.abs(np.random.randn(int(M * N)) + 0.1) mcrar = McrAR(max_iter=50, tol_increase=100, tol_n_increase=10, st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=1e-10, fit_kwargs={ 'C': C_guess, 'c_fix': [0, 1] }) mcrar.fit(D_known) assert_equal(mcrar.C_[:, 0], C_known[:, 0]) assert_equal(mcrar.C_[:, 1], C_known[:, 1])
def test_mcr_max_iterations(dataset): """ Test MCR exits at max_iter""" C_known, D_known, St_known = dataset # Seeding with a constant of 0.1 for C, actually leads to a bad local # minimum; thus, the err_change gets really small with a relatively bad # error. The tol_err_change is set to None, so it makes it to max_iter. mcrar = McrAR(max_iter=50, c_regr='OLS', st_regr='OLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_increase=None, tol_n_increase=None, tol_err_change=None, tol_n_above_min=None) mcrar.fit(D_known, C=C_known * 0 + 0.1) assert mcrar.exit_max_iter_reached
def test_mcr_tol_increase(dataset): """ Test MCR exits due error increasing above a tolerance fraction""" C_known, D_known, St_known = dataset # Seeding with a constant of 0.1 for C, actually leads to a bad local # minimum; thus, the err_change gets really small with a relatively bad # error. mcrar = McrAR(max_iter=50, c_regr='OLS', st_regr='OLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_increase=0, tol_n_increase=None, tol_err_change=None, tol_n_above_min=None) mcrar.fit(D_known, C=C_known * 0 + 0.1) assert mcrar.exit_tol_increase
def test_mcr_tol_n_above_min(dataset): """ Test MCR exits due to half-terating n times with error above the minimum error. Note: On some CI systems, the minimum err bottoms out; thus, tol_n_above_min needed to be set to 0 to trigger a break. """ C_known, D_known, St_known = dataset mcrar = McrAR(max_iter=50, c_regr='OLS', st_regr='OLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_increase=None, tol_n_increase=None, tol_err_change=None, tol_n_above_min=0) mcrar.fit(D_known, C=C_known * 0 + 0.1) assert mcrar.exit_tol_n_above_min
def test_mcr_st_semilearned(): """ Test when St items are fixed, i.e., enforced to be the same as the input, always """ M = 21 N = 21 P = 101 n_components = 3 C_img = np.zeros((M, N, n_components)) C_img[..., 0] = np.dot(np.ones((M, 1)), np.linspace(0, 1, N)[None, :]) C_img[..., 1] = np.dot(np.linspace(0, 1, M)[:, None], np.ones((1, N))) C_img[..., 2] = 1 - C_img[..., 0] - C_img[..., 1] C_img = C_img / C_img.sum(axis=-1)[:, :, None] St_known = np.zeros((n_components, P)) St_known[0, 30:50] = 1 St_known[1, 50:70] = 2 St_known[2, 70:90] = 3 St_known += 1 C_known = C_img.reshape((-1, n_components)) D_known = np.dot(C_known, St_known) ST_guess = 1 * St_known ST_guess[2, :] = np.random.randn(P) mcrar = McrAR(max_iter=50, tol_increase=100, tol_n_increase=10, st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=1e-10) mcrar.fit(D_known, ST=ST_guess, st_fix=[0, 1]) assert_equal(mcrar.ST_[0, :], St_known[0, :]) assert_equal(mcrar.ST_[1, :], St_known[1, :])
def test_sklearn_mcr_tol_n_increase(dataset): """ Test MCR exits due iterating n times with an increase in error Note: On some CI systems, the minimum err bottoms out; thus, tol_n_above_min needed to be set to 0 to trigger a break. """ C_known, D_known, St_known = dataset mcrar = McrAR(max_iter=50, c_regr='OLS', st_regr='OLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_increase=None, tol_n_increase=0, tol_err_change=None, tol_n_above_min=None, fit_kwargs={'C': C_known * 0 + 0.1}) mcrar.fit(D_known) assert mcrar.exit_tol_n_increase
def test_nonneg(): A = np.array([[1, 2, 3], [-1, -2, -3], [1, 2, 3]]) A_nn = np.array([[1, 2, 3], [0, 0, 0], [1, 2, 3]]) constr_nn = ConstraintNonneg(copy=True) out = constr_nn.transform(A) assert_allclose(A_nn, out) constr_nn = ConstraintNonneg(copy=False) out = constr_nn.transform(A) assert_allclose(A_nn, A)
if __name__ == '__main__': # pragma: no cover M = 21 N = 21 P = 101 n_components = 2 C_img = _np.zeros((M, N, n_components)) C_img[..., 0] = _np.dot(_np.ones((M, 1)), _np.linspace(0, 1, N)[None, :]) C_img[..., 1] = 1 - C_img[..., 0] ST_known = _np.zeros((n_components, P)) ST_known[0, 40:60] = 1 ST_known[1, 60:80] = 2 C_known = C_img.reshape((-1, n_components)) D_known = _np.dot(C_known, ST_known) mcrals = McrAls(max_iter=50, tol_increase=100, tol_n_increase=10, st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=1e-30) mcrals._saveall_st = True mcrals._saveall_c = True # mcrals.fit(D_known, ST=ST_known+1*_np.random.randn(*ST_known.shape), verbose=True) mcrals.fit(D_known, C=C_known * 0 + 1e-1, verbose=True)
Examples to set the different options In the following, we initiate a McrAls object with a st_regr setup with NNLS and c_reg to OLS. One can select regressor with a string, or can import the class and instanstiate mcrals = McrAls(max_iter=100, st_regr='NNLS', c_regr=OLS(), c_constraints=[ConstraintNonneg(), ConstraintNorm()]) """ tic = time.time() mcrals = McrAR(c_regr=linear_model.ElasticNet(alpha=1e-5, l1_ratio=0.75), max_iter=700, tol_err_change=Xe[index, :].max() * 1e-8, st_regr='NNLS', c_constraints=[ConstraintNonneg()]) mcrals.fit(Xe[index, :], ST=S0ica**2) toc = time.time() runningtime_mcrals = toc - tic # How long the decomposition took S0mcr = mcrals.ST_opt_ Amcr = mcrals.C_opt_ Sdmcr = (np.linalg.pinv(Amcr) @ Xd[index, :]) """ Species Identification """ # Comparison with Library Cor = auxiliary_funs.correlation(S0mcr, sources, nica) I = Cor.argmax(1) Ivalues = Cor.max(1) I.sort()
def test_mcr(): M = 21 N = 21 P = 101 n_components = 2 C_img = np.zeros((M,N,n_components)) C_img[...,0] = np.dot(np.ones((M,1)),np.linspace(0,1,N)[None,:]) C_img[...,1] = 1 - C_img[...,0] ST_known = np.zeros((n_components, P)) ST_known[0,40:60] = 1 ST_known[1,60:80] = 2 C_known = C_img.reshape((-1, n_components)) D_known = np.dot(C_known, ST_known) mcrals = McrAls(max_iter=50, tol_increase=100, tol_n_increase=10, st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=1e-10) mcrals._saveall_st = False mcrals._saveall_c = False mcrals.fit(D_known, ST=ST_known) assert_equal(1, mcrals.n_iter_opt) mcrals = McrAls(max_iter=50, tol_increase=100, tol_n_increase=10, c_regr='OLS', st_regr='OLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=1e-10) mcrals.fit(D_known, ST=ST_known) assert_equal(1, mcrals.n_iter_opt) assert ((mcrals.D_ - D_known)**2).mean() < 1e-10 assert ((mcrals.D_opt_ - D_known)**2).mean() < 1e-10 mcrals = McrAls(max_iter=50, tol_increase=100, tol_n_increase=10, c_regr='NNLS', st_regr='NNLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=1e-10) mcrals.fit(D_known, ST=ST_known) assert_equal(1, mcrals.n_iter_opt) assert ((mcrals.D_ - D_known)**2).mean() < 1e-10 assert ((mcrals.D_opt_ - D_known)**2).mean() < 1e-10 mcrals = McrAls(max_iter=50, tol_increase=100, tol_n_increase=10, c_regr='OLS', st_regr='OLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=1e-10) mcrals.fit(D_known, C=C_known) # Turns out some systems get it in 1 iteration, some in 2 # assert_equal(1, mcrals.n_iter_opt) assert_equal(True, mcrals.n_iter_opt<=2) assert ((mcrals.D_ - D_known)**2).mean() < 1e-10 assert ((mcrals.D_opt_ - D_known)**2).mean() < 1e-10 # Seeding with a constant of 0.1 for C, actually leads to a bad local # minimum; thus, the err_change gets really small with a relatively bad # error. This is not really a test, but it does test out breaking # from tol_err_change mcrals = McrAls(max_iter=50, tol_increase=100, tol_n_increase=10, c_regr='OLS', st_regr='OLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=1e-10) mcrals.fit(D_known, C=C_known*0 + 0.1) # Seeding with a constant of 0.1 for C, actually leads to a bad local # minimum; thus, the err_change gets really small with a relatively bad # error. This is not really a test, but it does test out breaking # from tol_err_change mcrals = McrAls(max_iter=50, tol_increase=100, tol_n_increase=10, c_regr='OLS', st_regr='OLS', st_constraints=[ConstraintNonneg()], c_constraints=[ConstraintNonneg(), ConstraintNorm()], tol_err_change=None) mcrals.fit(D_known, C=C_known*0 + 0.1) assert_equal(mcrals.n_iter, 50)
BSS Removal """ tic = time.time() Xd = auxiliary_funs.npass_SGderivative(Xin,1,7,2) #used in pls later #Xd=Xin # Compute ICA ica = FastICA(n_components=nica,tol=1e-8,max_iter=500) ica.fit_transform(Xd.T) # Reconstruct signals, needs the transpose of the matrix Aica = ica.mixing_ # Get estimated miXeg matrix S0ica = (np.linalg.pinv(Aica)@Xin) # Reconstruct signals, needs the transpose of the matrix # Compute MCR mcrals = McrAR(st_regr='NNLS',c_regr=ElasticNet(alpha=1e-4,l1_ratio=0.75),tol_increase=5,tol_n_above_min=500,max_iter=2000,tol_err_change=Xin.mean()*1e-8,c_constraints=[ConstraintNonneg()]) mcrals.fit(Xin, ST= S0ica**2 ) S0mcr = mcrals.ST_opt_; Amcr = mcrals.C_opt_; toc = time.time() runningtime_BSS = toc-tic # How long the decomposition took # Species Identification Cor = auxiliary_funs.correlation(S0mcr,Lnew_h2o,nica).T # with cut-off value # Ivalues = Cor.max(0);#maximum correlation from each column # I = np.where(Ivalues<0.70)[0]; #background values
#Allowed Noise Percentage noise = 5 #manual manual = False D = np.asarray((pd.read_csv('Total_MCR_CuSSZ13.dat', sep='\t', header=None)).values) if manual == False: #Run SVD eigens, explained_variance_ratio = svd.svd(D, nSVD) nPure = np.int(input('Number of Principle Components :')) #Run Simplisma S, C_u, C_c = simplisma.pure(D.T, nPure, noise, True) else: S = np.asarray((pd.read_csv('sopt_5c2.dat', sep='\t', header=None)).values).T #Run MCR mcrals = McrAls(max_iter=50, st_regr='NNLS', c_regr='NNLS', c_constraints=[ConstraintNonneg(), ConstraintNorm()]) mcrals.fit(D, ST=S.T, verbose=True) print('\nFinal MSE: {:.7e}'.format(mcrals.err[-1])) plt.subplot(2, 1, 1) plt.plot(mcrals.ST_opt_.T) plt.subplot(2, 1, 2) plt.plot(mcrals.C_opt_) plt.show()