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()
