Question

我目前正在使用一些拉曼光谱数据，我正在尝试纠正由于荧光偏斜引起的数据。请看下面的图表：

enter image description here

我非常接近实现我的目标。正如你所看到的，我试图在我的所有数据中拟合多项式，而我应该只是在局部最小值处拟合多项式。

理想情况下，我希望有一个多项式拟合，当从我的原始数据中减去时，会产生类似这样的结果：

enter image description here

是否有任何内置的库已经执行此操作？

如果没有，可以为我推荐任何简单的算法？

Answer 1

我找到了一个问题的答案，只是为每个偶然发现的人分享。

有一种称为＆＃34;非对称最小二乘平滑＆＃34; P. Eilers和H. Boelens在2005年。这篇论文是免费的，你可以在google上找到它。

def baseline_als(y, lam, p, niter=10):
  L = len(y)
  D = sparse.csc_matrix(np.diff(np.eye(L), 2))
  w = np.ones(L)
  for i in xrange(niter):
    W = sparse.spdiags(w, 0, L, L)
    Z = W + lam * D.dot(D.transpose())
    z = spsolve(Z, w*y)
    w = p * (y > z) + (1-p) * (y < z)
  return z

Answer 2

以下代码适用于Python 3.6。

这是根据公认的正确答案进行调整，以避免密集矩阵diff计算（很容易导致内存问题）并使用range（不是xrange）

import numpy as np
from scipy import sparse
from scipy.sparse.linalg import spsolve

def baseline_als(y, lam, p, niter=10):
  L = len(y)
  D = sparse.diags([1,-2,1],[0,-1,-2], shape=(L,L-2))
  w = np.ones(L)
  for i in range(niter):
    W = sparse.spdiags(w, 0, L, L)
    Z = W + lam * D.dot(D.transpose())
    z = spsolve(Z, w*y)
    w = p * (y > z) + (1-p) * (y < z)
  return z

Answer 3

有一个可用于基线校正/移除的python库。它具有Modpoly，IModploy和Zhang fit算法，当您将原始值输入为python列表或pandas系列并指定多项式时，可以返回基线校正结果。

将库安装为pip install BaselineRemoval。下面是一个示例

from BaselineRemoval import BaselineRemoval

input_array=[10,20,1.5,5,2,9,99,25,47]
polynomial_degree=2 #only needed for Modpoly and IModPoly algorithm

baseObj=BaselineRemoval(input_array)
Modpoly_output=baseObj.ModPoly(polynomial_degree)
Imodpoly_output=baseObj.IModPoly(polynomial_degree)
Zhangfit_output=baseObj.ZhangFit()

print('Original input:',input_array)
print('Modpoly base corrected values:',Modpoly_output)
print('IModPoly base corrected values:',Imodpoly_output)
print('ZhangFit base corrected values:',Zhangfit_output)

Original input: [10, 20, 1.5, 5, 2, 9, 99, 25, 47]
Modpoly base corrected values: [-1.98455800e-04  1.61793368e+01  1.08455179e+00  5.21544654e+00
  7.20210508e-02  2.15427531e+00  8.44622093e+01 -4.17691125e-03
  8.75511661e+00]
IModPoly base corrected values: [-0.84912125 15.13786196 -0.11351367  3.89675187 -1.33134142  0.70220645
 82.99739548 -1.44577432  7.37269705]
ZhangFit base corrected values: [ 8.49924691e+00  1.84994576e+01 -3.31739230e-04  3.49854060e+00
  4.97412948e-01  7.49628529e+00  9.74951576e+01  2.34940300e+01
  4.54929023e+01

Answer 4

我在之前的评论中使用了 glinka 引用的算法版本，这是对相对 recent paper 中发布的惩罚加权线性平方方法的改进。我使用了 Rustam Guliev's 代码来构建这个：

from scipy import sparse
from scipy.sparse import linalg
import numpy as np
from numpy.linalg import norm


def baseline_arPLS(y, ratio=1e-6, lam=100, niter=10, full_output=False):
    L = len(y)

    diag = np.ones(L - 2)
    D = sparse.spdiags([diag, -2*diag, diag], [0, -1, -2], L, L - 2)

    H = lam * D.dot(D.T)  # The transposes are flipped w.r.t the Algorithm on pg. 252

    w = np.ones(L)
    W = sparse.spdiags(w, 0, L, L)

    crit = 1
    count = 0

    while crit > ratio:
        z = linalg.spsolve(W + H, W * y)
        d = y - z
        dn = d[d < 0]

        m = np.mean(dn)
        s = np.std(dn)

        w_new = 1 / (1 + np.exp(2 * (d - (2*s - m))/s))

        crit = norm(w_new - w) / norm(w)

        w = w_new
        W.setdiag(w)  # Do not create a new matrix, just update diagonal values

        count += 1

        if count > niter:
            print('Maximum number of iterations exceeded')
            break

    if full_output:
        info = {'num_iter': count, 'stop_criterion': crit}
        return z, d, info
    else:
        return z

为了测试算法，我创建了一个类似于论文图 3 所示的光谱，首先生成了一个由多个高斯峰组成的模拟光谱：

def spectra_model(x):
    coeff = np.array([100, 200, 100])
    mean = np.array([300, 750, 800])

    stdv = np.array([15, 30, 15])

    terms = []
    for ind in range(len(coeff)):
        term = coeff[ind] * np.exp(-((x - mean[ind]) / stdv[ind])**2)
        terms.append(term)

    spectra = sum(terms)

    return spectra

x_vals = np.arange(1, 1001)
spectra_sim = spectra_model(x_vals)

然后，我使用直接取自论文的 4 个点创建了一个三阶插值多项式：

from scipy.interpolate import CubicSpline
x_poly = np.array([0, 250, 700, 1000])
y_poly = np.array([200, 180, 230, 200])

poly = CubicSpline(x_poly, y_poly)
baseline = poly(x_vals)

noise = np.random.randn(len(x_vals)) * 0.1
spectra_base = spectra_sim + baseline + noise

最后，我使用基线校正算法从改变的光谱 (spectra_base) 中减去基线：

 _, spectra_arPLS, info = baseline_arPLS(spectra_base, lam=1e4, niter=10,
                                         full_output=True)

结果是（作为参考，我与 Rustam Guliev's 使用 lam = 1e4 和 p = 0.001 的纯 ALS 实现进行了比较）：

Answer 5

我知道这是一个古老的问题，但几个月前我对它进行了解决，并使用了辣.sparse例程实现了相应的答案。

# Baseline removal                                                                                            

def baseline_als(y, lam, p, niter=10):                                                                        

    s  = len(y)                                                                                               
    # assemble difference matrix                                                                              
    D0 = sparse.eye( s )                                                                                      
    d1 = [numpy.ones( s-1 ) * -2]                                                                             
    D1 = sparse.diags( d1, [-1] )                                                                             
    d2 = [ numpy.ones( s-2 ) * 1]                                                                             
    D2 = sparse.diags( d2, [-2] )                                                                             

    D  = D0 + D2 + D1                                                                                         
    w  = np.ones( s )                                                                                         
    for i in range( niter ):                                                                                  
        W = sparse.diags( [w], [0] )                                                                          
        Z =  W + lam*D.dot( D.transpose() )                                                                   
        z = spsolve( Z, w*y )                                                                                 
        w = p * (y > z) + (1-p) * (y < z)                                                                     

    return z

干杯，

佩德罗。

Answer 6

最近，我需要使用此方法。答案中的代码效果很好，但是显然会过度使用内存。因此，这是我的版本，具有优化的内存使用情况。

def baseline_als_optimized(y, lam, p, niter=10):
    L = len(y)
    D = sparse.diags([1,-2,1],[0,-1,-2], shape=(L,L-2))
    D = lam * D.dot(D.transpose()) # Precompute this term since it does not depend on `w`
    w = np.ones(L)
    W = sparse.spdiags(w, 0, L, L)
    for i in range(niter):
        W.setdiag(w) # Do not create a new matrix, just update diagonal values
        Z = W + D
        z = spsolve(Z, w*y)
        w = p * (y > z) + (1-p) * (y < z)
    return z

根据我的基准测试结果，它也快了约1.5倍。

%%timeit -n 1000 -r 10 y = randn(1000)
baseline_als(y, 10000, 0.05) # function from @jpantina's answer
# 20.5 ms ± 382 µs per loop (mean ± std. dev. of 10 runs, 1000 loops each)

%%timeit -n 1000 -r 10 y = randn(1000)
baseline_als_optimized(y, 10000, 0.05)
# 13.3 ms ± 874 µs per loop (mean ± std. dev. of 10 runs, 1000 loops each)

注意1：原始文章说：

为强调算法的基本简单性，迭代次数已固定为10。在实际应用中，应检查权重是否显示任何变化；如果没有，那就已经实现了收敛。

因此，这意味着停止迭代的更正确方法是检查||w_new - w|| < tolerance

注意2：另一个有用的引号（来自@glycoaddict的评论）给出了如何选择参数值的想法。

有两个参数：p用于不对称，λ用于平滑。两者都必须调整到手头的数据。我们发现一般来说，0.001≤p≤0.1是一个很好的选择（对于具有正峰值的信号），而102≤λ≤109是个不错的选择，但是可能会发生例外。在任何情况下，都应该在对数λ近似线性的栅格上改变λ。通常，目视检查足以获得良好的参数值。

Python基线校正库

6 个答案: