पायथन बेसलाइन सुधार पुस्तकालय

Question

मैं वर्तमान में कुछ रमन स्पेक्ट्र्रा डेटा के साथ काम कर रहा हूं, और मैं फ्लोरोसेंस स्कूइंग के कारण अपने डेटा को सही करने की कोशिश कर रहा हूं। नीचे ग्राफ पर एक नज़र डालें:

मैं बहुत प्राप्त करने मैं क्या चाहते हैं उसके पास हूँ। जैसा कि आप देख सकते हैं, मैं अपने सभी डेटा में बहुपद फिट करने की कोशिश कर रहा हूं, जबकि मुझे वास्तव में स्थानीय मिनीमा में बहुपद को फिट करना चाहिए। यह पहले से ही है कि

वहाँ किसी भी libs में निर्माण कर रहे हैं:

आदर्श रूप में मैं एक बहुपद फिटिंग जो जब अपने मूल डेटा से घटाया कुछ इस तरह में परिणाम होगा करना चाहते हैं?

यदि नहीं, तो कोई साधारण एल्गोरिदम मेरे लिए सिफारिश कर सकता है?

Answer 1

मुझे अपने प्रश्न का उत्तर मिला, बस इस पर ठोकर खाने वाले हर किसी के लिए साझा करना।

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

मैं जानता हूँ कि यह एक पुराने सवाल है, लेकिन मैं कुछ महीने पहले इस पर stumpled और बराबर जवाब spicy.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 

चीयर्स,

पेड्रो।