सीधे दो स्पेक्ट्रा के बीच उप-शिफ्ट की तुलना करें - और विश्वसनीय त्रुटियां प्राप्त करें

Question

मेरे पास एक ही खगोलीय वस्तु के दो स्पेक्ट्रा हैं। आवश्यक प्रश्न यह है: मैं इन स्पेक्ट्रा के बीच सापेक्ष बदलाव की गणना कैसे कर सकता हूं और उस पारी पर सटीक त्रुटि प्राप्त कर सकता हूं?

कुछ और विवरण अगर आप अभी भी मेरे साथ हैं। प्रत्येक स्पेक्ट्रम एक एक्स मूल्य (तरंग दैर्ध्य), y मान (प्रवाह) और त्रुटि के साथ एक सरणी होगा। वेवलेंथ शिफ्ट सब-पिक्सल होने वाला है। मान लें कि पिक्सेल नियमित रूप से दूरी पर हैं और केवल पूरे स्पेक्ट्रम पर लागू एक एकल तरंग दैर्ध्य पारी होने जा रही है। तो अंतिम उत्तर कुछ इस तरह होगा: 0.35 +/- 0.25 पिक्सेल।

दो स्पेक्ट्रा बहुत सारे फीचर्स रहित होते हैं जो कि कुछ जटिल अवशोषण सुविधाओं (डिप्स) द्वारा नियंत्रित होते हैं जो आसानी से मॉडल नहीं करते हैं (और आवधिक नहीं हैं)। मैं एक ऐसी विधि खोजना चाहता हूं जो सीधे दो स्पेक्ट्रा की तुलना करती है।

हर किसी की पहली वृत्ति एक क्रॉस-सह-संबंध करना है, लेकिन सबपिक्सल शिफ्ट के साथ, आपको स्पेक्ट्रा (पहले चौरसाई करके) के बीच अंतर करना होगा - साथ ही, त्रुटियों को सही होने के लिए बुरा लगता है।

मेरा वर्तमान दृष्टिकोण एक गाऊसी कर्नेल के साथ बातचीत करके डेटा को सुचारू करना है, फिर सुचारू परिणाम को फैलाने के लिए, और दो स्प्लेन्ड स्पेक्ट्रा की तुलना करना है - लेकिन मुझे इस पर भरोसा नहीं है (विशेष रूप से त्रुटियों)।

किसी को भी ठीक से ऐसा करने का एक तरीका पता है?

यहां एक छोटा अजगर कार्यक्रम है जो दो खिलौना स्पेक्ट्रा का उत्पादन करेगा जो 0.4 पिक्सेल (खिलौना 1 में लिखा है) और खिलौना 2। कासी) जिसे आप खेल सकते हैं। भले ही यह खिलौना मॉडल एक सरल गाऊसी विशेषता का उपयोग करता है, यह मानकर कि वास्तविक डेटा एक साधारण मॉडल के साथ फिट नहीं हो सकता है।

import numpy as np
import random as ra
import scipy.signal as ss
arraysize = 1000
fluxlevel = 100.0
noise = 2.0
signal_std = 15.0
signal_depth = 40.0
gaussian = lambda x: np.exp(-(mu-x)**2/ (2 * signal_std))
mu = 500.1
np.savetxt('toy1.ascii', zip(np.arange(arraysize), np.array([ra.normalvariate(fluxlevel, noise) for x in range(arraysize)] - gaussian(np.arange(arraysize)) * signal_depth), np.ones(arraysize) * noise))
mu = 500.5
np.savetxt('toy2.ascii', zip(np.arange(arraysize), np.array([ra.normalvariate(fluxlevel, noise) for x in range(arraysize)] - gaussian(np.arange(arraysize)) * signal_depth), np.ones(arraysize) * noise))

Comments

अगर मैं सही ढंग से समझता हूं कि समस्या छवि पंजीकरण के समान है, तो सिवाय इसके कि आपके पास एक अक्ष में एक रैखिक उप-पिक्सेल बदलाव हो। शायद चरण सहसंबंध जैसी मानक छवि पंजीकरण तकनीकों का प्रयास करें?

— पॉल आर

यदि आपके पास एक सिग्नल में शुद्ध देरी है (यानी वेवलेंथ पैरामीटर में बदलाव जिसे आप बोलते हैं), तो आप फ़ूरियर ट्रांसफॉर्म प्रॉपर्टी का फायदा उठाने में सक्षम हो सकते हैं, जो समय की देरी को फ़्रीक्वेंसी डोमेन में एक रैखिक चरण ऑफसेट में बदल देता है। यह काम कर सकता है यदि दो नमूने अलग-अलग माप शोर या हस्तक्षेप से दूषित नहीं होते हैं।

— जेसन आर

यह धागा उपयोगी हो सकता है- dsp.stackexchange.com/questions/2321/…

— जिम क्ले

क्या आपके पास परीक्षण करने के लिए वास्तविक डेटा है? आपके द्वारा दिया गया शोर मान क्रॉस-सहसंबंध के लिए उप-नमूना सटीक होने के लिए बहुत अधिक है। उदाहरण के लिए, यह शोर 2.0 और ऑफसेट 0.7 (= 1000.7 प्लॉट के एक्स-एक्सिस) पर कई रन के साथ पाता है, उदाहरण के लिए: i.stack.imgur.com/UK5JD.png

— 12:57

Answer 1

मुझे लगता है कि क्रॉस-सहसंबंध का उपयोग करना और चोटी को प्रक्षेपित करना ठीक काम करेगा। जैसा कि क्रॉस-सहसंबंध व्यर्थ से पहले अप-सैंपलिंग में वर्णित है ? क्रॉस-सहसंबंध से पहले इंटरपोलिंग या अपसंस्कृति वास्तव में आपको कोई और जानकारी नहीं देती है। उप-नमूना शिखर के बारे में जानकारी इसके चारों ओर के नमूनों में निहित है। आपको बस इसे न्यूनतम त्रुटि के साथ निकालने की आवश्यकता है। मैंने यहां कुछ नोट इकट्ठे किए ।

सबसे सरल विधि द्विघात / परवलयिक प्रक्षेप है, जिसके बारे में मेरे यहाँ एक पायथन उदाहरण है । यह निश्चित रूप से सटीक है कि यदि आपका स्पेक्ट्रम एक गाऊसी खिड़की पर आधारित है , या यदि शिखर नमूनों के बीच के मध्य बिंदु पर बिल्कुल गिरता है, लेकिन अन्यथा कुछ त्रुटि है । तो आपके मामले में आप शायद कुछ बेहतर उपयोग करना चाहते हैं।

यहां अधिक जटिल, लेकिन अधिक सटीक अनुमान लगाने वालों की सूची दी गई है । "उपरोक्त विधियों में से, क्विन के दूसरे अनुमानक में सबसे कम आरएमएस त्रुटि है।"

मुझे गणित की जानकारी नहीं है, लेकिन इस पत्र में कहा गया है कि उनके परवलयिक प्रक्षेप में एफएफटी बिन की चौड़ाई का 5% सैद्धांतिक सटीकता है।

क्रॉस-सहसंबंध आउटपुट पर एफएफटी प्रक्षेप का उपयोग करने से कोई पूर्वाग्रह त्रुटि नहीं होती है , इसलिए यदि आप वास्तव में अच्छी सटीकता चाहते हैं तो यह सबसे अच्छा है। यदि आपको सटीकता और गणना की गति को संतुलित करने की आवश्यकता है, तो कुछ एफएफटी प्रक्षेप करने की सिफारिश की जाती है और फिर "अच्छा पर्याप्त" परिणाम प्राप्त करने के लिए अन्य अनुमानकों में से एक के साथ इसका पालन करें।

यह सिर्फ पैराबोलिक फिट का उपयोग करता है, लेकिन यह शोर कम होने पर ऑफसेट के लिए सही मूल्य का उत्पादन करता है:

def parabolic_polyfit(f, x, n):
    a, b, c = polyfit(arange(x-n//2, x+n//2+1), f[x-n//2:x+n//2+1], 2)
    xv = -0.5 * b/a
    yv = a * xv**2 + b * xv + c

    return (xv, yv)

arraysize = 1001
fluxlevel = 100.0
noise = 0.3 # 2.0 is too noisy for sub-sample accuracy
signal_std = 15.0
signal_depth = 40.0
gaussian = lambda x: np.exp(-(mu-x)**2/ (2 * signal_std))
mu = 500.1
a_flux = np.array([ra.normalvariate(fluxlevel, noise) for x in range(arraysize)] - gaussian(np.arange(arraysize)) * signal_depth)
mu = 500.8
b_flux = np.array([ra.normalvariate(fluxlevel, noise) for x in range(arraysize)] - gaussian(np.arange(arraysize)) * signal_depth)

a_flux -= np.mean(a_flux)
b_flux -= np.mean(b_flux)

corr = ss.fftconvolve(b_flux, a_flux[::-1])

peak = np.argmax(corr)
px, py = parabolic_polyfit(corr, peak, 13)

px = px - (len(a_flux) - 1)
print px

आपके नमूने में शोर ऐसे परिणाम पैदा करता है जो एक पूरे नमूने से अधिक भिन्न होते हैं, इसलिए मैंने इसे कम कर दिया। शिखर के अधिक बिंदुओं का उपयोग करके वक्र को पकड़ना कुछ हद तक अनुमान को कसने में मदद करता है, लेकिन मुझे यकीन नहीं है कि यह सांख्यिकीय रूप से मान्य है, और यह वास्तव में निचले-शोर की स्थिति के लिए अनुमान को बदतर बना देता है।

शोर = 0.2 और 3-बिंदु फिट के साथ, यह ऑफसेट = 0.4 के लिए 0.398 और 0.402 जैसे मूल्य देता है।

शोर = 2.0 और 13-बिंदु फिट के साथ, यह ऑफसेट = 0.4 के लिए 0.156 और 0.595 जैसे मान देता है।

Comments

मैं छवि पंजीकरण के लिए इस सटीक समस्या को हल करने की कोशिश कर रहा हूं। मुझे उप-पिक्सेल सटीकता की आवश्यकता है (0.1 शायद काफी अच्छा होगा) लेकिन सबसे महत्वपूर्ण बात यह है कि कोई पूर्वाग्रह नहीं है, इसलिए प्रक्षेप तरीके काम नहीं करते हैं। क्या इसके लिए कोई अच्छा (और अजगर में लागू?) तरीके हैं? शून्य-पैडिंग विधि काम करेगी, लेकिन व्यावहारिक होना बहुत महंगा है।

— केफ्लेविच

@kelavich: क्या आपने सभी प्रक्षेप तरीकों का परीक्षण किया है और अस्वीकार्य पूर्वाग्रह पाया है? अनुशंसित दृष्टिकोण एक कम त्रुटि वाले प्रक्षेप के बाद कुछ शून्य-पैडिंग का संयोजन है। मुझे किसी अन्य विधि का पता नहीं है, लेकिन मुझे यकीन है कि यह आपको बहुत सटीकता प्रदान करेगा।

— 23

हां, मुझे रैखिक और दूसरे क्रम के प्रक्षेप में अस्वीकार्य पूर्वाग्रह मिला है। मैंने एफएफटी शून्य-पैडिंग की कोशिश की है, लेकिन परिणाम उच्च आवृत्ति रिंगिंग पर हावी है ... कोई भी मौका जिससे आप शून्य-पैडिंग उदाहरण जोड़ सकते हैं?

— केफ्लेविच