सजा में आवेग प्रतिक्रिया flipping

Question

एक संकेत पर दृढ़ विश्वास के दौरान, हमें प्रक्रिया के दौरान आवेग प्रतिक्रिया को फ्लिप करने की आवश्यकता क्यों है?

Comments

इस उत्तर का उत्तरार्ध आपको समझने में मदद कर सकता है।

— दिलीप सरवटे

@ DilipSarwate के शानदार उत्तर को पढ़ने के अलावा, यह एक अच्छी तरह से पेपर की एक शीट लेने के लिए और आवेग प्रतिक्रिया के समय-स्थानांतरित और स्केल किए गए संस्करणों को जोड़कर एलटीआई सिस्टम के आउटपुट की गणना करने के लिए एक अच्छा व्यायाम है।

— एच.डी.

ध्यान दें कि आप या तो तर्क फ्लिप कर सकते हैं - परिणाम समान है।

— वकजह

Answer 1

एक अलग सवाल के जवाब से अनुकूलित (जैसा कि एक टिप्पणी में उल्लेख किया गया है) इस उम्मीद में कि यह सवाल कम्युनिटी विकी द्वारा बार-बार शीर्ष प्रश्नों में से एक के रूप में नहीं मिलेगा।

एक रैखिक (समय-अपरिवर्तनीय) प्रणाली द्वारा आवेग प्रतिक्रिया का कोई "फ़्लिपिंग" नहीं है। एक रेखीय समय-अपरिवर्तनीय प्रणाली का उत्पादन आवेग प्रतिक्रिया के स्केल और समय-विलंबित संस्करणों का योग है, न कि "फ़्लिप" आवेग प्रतिक्रिया।

हम स्केल्ड यूनिट पल्स सिग्नल के योग में इनपुट सिग्नल को तोड़ते हैं। इकाई पल्स संकेत करने के लिए प्रणाली की प्रतिक्रिया है आवेग प्रतिक्रिया या नाड़ी प्रतिक्रिया और इसलिए स्केलिंग संपत्ति द्वारा एकल इनपुट मूल्य , या, यदि आप एक प्रतिक्रिया बनाता है ⋯ , 0 , 0 , 1 , 0 , 0 , $x$$\cdots, ~0, ~0, ~1, ~0, ~0, \cdots$

$$h[0], ~h[1], \cdots, ~h[n], \cdots$$ एक्स [ 0 ] ( ⋯ , 0 , 0 , 1 , 0 , 0 , ⋯ ) = ⋯ 0 , 0 , एक्स [ 0 ] , 0 , 0 , ⋯ एक्स [ 0 ] ज [ 0 ] , एक्स [ 0 ] एच [ 1 ] , ⋯ , x $x[0]$ $$x[0](\cdots, ~0, ~0, ~1, ~0,~ 0, \cdots) = \cdots ~0, ~0, ~x[0], ~0, ~0, \cdots$$ $$x[0]h[0], ~~x[0]h[1], \cdots, ~~x[0]h[n], \cdots$$

इसी प्रकार, एकल इनपुट मान या बनाता है एक प्रतिक्रिया बनाता है की प्रतिक्रिया में देरी पर ध्यान दें । हम इस शिरा में आगे जारी रख सकते हैं, लेकिन अधिक सारणीबद्ध रूप में स्विच करना और समय में ठीक से संरेखित विभिन्न आउटपुट दिखाना सबसे अच्छा है। हमारे पास है एक्स [ 1 ] ( ⋯ , 0 , 0 , 0 , 1 , 0 , ⋯ ) = ⋯ 0 , 0 , 0 , एक्स [ 1 ] , 0 , ⋯ 0 , एक्स [ 1 ] ज [ 0 ] , एक्स [ 1 ] ज [ 1 ] , ⋯ $x[1]$

$$x[1](\cdots, ~0, ~0, ~0, ~1,~ 0, \cdots) = \cdots ~0, ~0, ~0, ~x[1], ~0, \cdots$$ एक्स [ 1 ] समय → 0 1 2 ⋯ एन एन + 1 ⋯ एक्स [ 0 ] एक्स [ 0 ] ज [ 0 ] एक्स [ 0 ] एच [ १ ] x [ ० ] एच $$0, x[1]h[0], ~~x[1]h[1], \cdots, ~~x[1]h[n-1], x[1]h[n] \cdots$$ $x[1]$ yएक्स $$\begin{array}{l|l|l|l|l|l|l|l} \text{time} \to & 0 &1 &2 & \cdots & n & n+1 & \cdots \\ \hline x[0] & x[0]h[0] &x[0]h[1] &x[0]h[2] & \cdots &x[0]h[n] & x[0]h[n+1] & \cdots\\ \hline x[1] & 0 & x[1]h[0] &x[1]h[1] & \cdots &x[1]h[n-1] & x[1]h[n] & \cdots\\ \hline x[2] & 0 & 0 &x[2]h[0] & \cdots &x[2]h[n-2] & x[2]h[n-1] & \cdots\\ \hline \vdots & \vdots & \vdots & \vdots & \ddots & \\ \hline x[m] & 0 &0 & 0 & \cdots & x[m]h[n-m] & x[m]h[n-m+1] & \cdots \\ \hline \vdots & \vdots & \vdots & \vdots & \ddots \end{array}$$ \ ddots \ end {सरणी} उपरोक्त सरणी में पंक्तियाँ आवेग प्रतिक्रिया के ठीक स्केल और विलंबित संस्करण हैं जो इनपुट संकेत में प्रतिक्रिया तक जोड़ते हैं । $y$$x$ लेकिन अगर आप एक और अधिक विशिष्ट प्रश्न पूछते हैं जैसे कि

समय पर आउटपुट क्या है ?$n$

तब आप -th कॉलम को सिंक करने के लिए प्रिय दृढ़ संकल्प सूत्र जो छात्रों की पीढ़ियों को प्रभावित करता है क्योंकि आवेग प्रतिक्रिया "समय पर फ़्लिप" या पीछे की ओर भागती हुई प्रतीत होती है। लेकिन, जो लोग भूल जाते हैं, वह यह है कि इसके बजाय हम लिख सकते थे ताकि यह ऐसा इनपुट है जो लगता है कि "खत्म हो गया" या समय के साथ पीछे की ओर दौड़ रहा है! दूसरे शब्दों में, यह मनुष्य हैवाई [ एन $n$

$$\begin{align*} y[n] &= x[0]h[n] + x[1]h[n-1] + x[2]h[n-2] + \cdots + x[m]h[n-m] + \cdots\\ &= \sum_{m=0}^{\infty} x[m]h[n-m], \end{align*}$$ $$\begin{align*} y[n] &= x[n]h[0] + x[n-1]h[1] + x[n-2]h[2] + \cdots + x[0]h[n] + \cdots\\ &= \sum_{m=0}^{\infty} x[n-m]h[m], \end{align*}$$ जो समय पर प्रतिक्रिया की गणना करते समय आवेग प्रतिक्रिया (या इनपुट) को पलटा देते हैं, जबकि सूत्रीकरण सूत्र का उपयोग करते हैं, लेकिन सिस्टम स्वयं किसी प्रकार का कुछ नहीं करता है।$n$

Answer 2

यहां एक C / C ++ उदाहरण दिया गया है जो दर्शाता है कि आवेग प्रतिक्रिया का उपयोग बिना रिवर्स में किया जा सकता है। यदि आप convolve_scatter()फ़ंक्शन का निरीक्षण करते हैं, तो कोई भी चर कहीं भी नकारा नहीं जाता है। यह प्रकीर्णन प्रकीर्णन है जहाँ प्रत्येक इनपुट सैंपल को मेमोरी में कई आउटपुट सैंपल में बिखेर (सममित) किया जाता है, आवेग प्रतिक्रिया द्वारा दिए गए वेट का उपयोग करते हुए। यह बेकार है क्योंकि आउटपुट नमूनों को कई बार पढ़ना और लिखना होगा।

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

#include <stdio.h>

const int Nx = 5; 
const int x[Nx] = {1, 0, 0, 0, 2};
const int Ny = 3; 
const int y[Ny] = {1, 2, 3};
const int Nz = Nx+Ny-1;
int z[Nz];

void convolve_scatter() { // z = x conv y
  for (int k = 0; k < Nz; k++) {
    z[k] = 0;
  }
  for (int n = 0; n < Nx; n++) {
    for (int m = 0; m < Ny; m++) {
      z[n+m] += x[n]*y[m]; // No IR reversal
    }
  }
}

void convolve_gather() { // z = x conv y
  for (int k = 0; k < Nz; k++) {
    int accu = 0;
    for (int m = 0; m < Ny; m++) {
      int n = k+m - Ny + 1;
      if (n >= 0 && n < Nx) {
        accu += x[n]*y[Ny-m-1]; // IR reversed here
      }
    }
    z[k] = accu;
  }
}

void print() {
  for (int k = 0; k < Nz; k++) {
    printf("%d ", z[k]);
  }
  printf("\n");
}

int main() {
  convolve_scatter();
  print();
  convolve_gather();
  print();
}

यह दृश्यों को दर्शाता है:

1 0 0 0 2
1 2 3

और दोनों कनवल्शन मेथड आउटपुट का उपयोग करना:

1 2 3 0 2 4 6

मैं बिखरने की विधि का उपयोग करके किसी की कल्पना नहीं कर सकता, जब तक कि फिल्टर अलग-अलग नहीं होता है, उस स्थिति में दो विधियां अलग-अलग परिणाम उत्पन्न करेंगी और एक अधिक उपयुक्त हो सकती है।

Comments

दिलचस्प! तो अंतिम निष्कर्ष क्या है, मुझे देखने में दिलचस्पी है

— असफल वैज्ञानिक

आपकी वास्तु चिंता दिलचस्प है। उपलब्ध कैश, SIMD निर्देश (SSE, AVX) और मल्टी कोर आर्किटेक्चर को ध्यान में रखते हुए , बिखरी हुई विधि समानांतर संगणना के लिए अधिक उपयुक्त लगती है? लेकिन मैंने हालांकि एक विस्तृत विश्लेषण नहीं किया है ...

— Fat32

@ Fat32 मुझे न तो! आपका मतलब है कि जमावड़ा जमा होने से कई गुना काम करने वाले लोगों के लिए अड़चन बन सकती है? कि प्रत्येक कोर को अपने स्वयं के संचयकर्ता को कम करके समाप्त किया जा सकता है और अंत में उन्हें संक्षेप में प्रस्तुत किया जा सकता है। मुझे लगता है कि यह ओवरहेड बिखरे हुए कनवल्शन में लिखी गई अतिरिक्त मेमोरी की तुलना में बहुत अधिक नहीं होगा।

— ओली नीमितालो

वास्तव में मैं सभा प्रपत्र अड़चन की तुलना में बिखरे हुए फॉर्म की दक्षता से अधिक चिंतित था। मेरे वर्तमान सी फ़िल्टरिंग कोड एकत्रित रूप में (शायद सबसे अधिक) हैं, लेकिन जब एएसएम कोड की बात आती है, तो मैं उन्हें सिमड एसएसई एक्सटेंशन में लिखने की प्रवृत्ति रखता हूं जो अधिक है बिखरे हुए रूप में उपयुक्त। मुझे अपने टेट्स को अपडेट करना होगा , हालाँकि :-))) मेमोरी आईओ निश्चित रूप से रजिस्टर संचय की तुलना में एक मुद्दा है। और शायद मुझे बार-बार मेमोरी आईओ का दंड याद आ रहा है ...

— Fat32

किसी को बिखरने और इकट्ठा होने से बेहतर शब्द पता है? मुझे यकीन नहीं है कि अगर ये विरल सजा गुठली के लिए आरक्षित हैं।

— ओली नीमितालो

Answer 3

यह बिंदुवार गणना के लिए केवल 'फ़्लिप' है।

@Dipip समझाता है कि अभिन्न अभिन्न / योग का प्रतिनिधित्व करता है, लेकिन यह समझाने के लिए कि दो इनपुट कार्यों में से एक (अक्सर h(t)) गणना प्रयोजनों के लिए क्यों फ़्लिप किया जाता है, इनपुट x[n]और आवेग प्रतिक्रिया के साथ एक असतत समय प्रणाली पर विचार करें h[n]:

• आप अपने इनपुट फ़ंक्शन को ले सकते हैं x[n], और प्रत्येक गैर-शून्य * नमूने के लिए नमूना x[n]से स्केल किए गए आवेग प्रतिक्रिया की गणना करते हैं nऔर जब तक समय-शिफ्ट h[n]शून्य से कम नहीं हो जाता है (एक कारण मानकर h[n])। इसमें या तो 'फ़्लिपिंग' (या अधिक सटीक 'टाइम-रिवर्सल') शामिल होगा x[n]या नहीं h[n]। हालाँकि, अंत में आपको प्रत्येक गैर-शून्य के लिए आवेग प्रतिक्रिया के इन सभी स्केल किए गए + शिफ्ट किए गए os ईकोस ’को जोड़ना / जोड़ना होगा x[n]।

• या , सुविधा के लिए, आप समय की उत्पत्ति (आमतौर पर 0) के बारे में कार्यों में से एक को उल्टा कर सकते हैं, जिससे आपकी गणना {गुणा, गुणा, जोड़, ...} के बजाय {गुणा, जोड़, गुणा, कर सकती है। , जोड़ें, ...}। यह एक ही आउटपुट सिग्नल में परिणाम करता है क्योंकि यह सटीक रूप से एक ही गुणा करेगा और संचालन को जोड़ देगा। उदाहरण के लिए, समय पर गैर-शून्य इनपुट सिग्नल से आउटपुट योगदान के बारे में सोचें x[0]। जब kसमीकरण के लिए = 0 समीकरण आवेग प्रत्यावर्तन केवल समय-उलट जाएगा, लेकिन स्थानांतरित नहीं किया जाएगा, जिससे हमें पहला नमूना प्रतिक्रिया मिलेगी , जिसके लिए है । फिर, एक-एक करके वेतन वृद्धि सही समय के कदम पर स्थानांतरित हो जाएगी , जैसे कि समय उलट

  $$\sum_{k=-\infty}^{\infty} x[k]h[n-k]$$ h[n]x[n]x[0]h[0]kh[n]h[n]s दूसरी प्रविष्टि ( h[1]) अब शीर्ष पर रखी x[0]जाएगी, जिसके गुणा होने की प्रतीक्षा की जा रही है। यह x[0]h[1]समय पर वांछित योगदान देगा n=1, जैसा कि पिछले पद्धति में किया गया है।

---

* मैं कहता हूं कि गैर-शून्य x[n]क्योंकि आवेग प्रतिक्रिया शून्य से स्केल की जाती है, इस प्रकार अंतिम आउटपुट में कुछ भी योगदान नहीं होता है ।

$$\forall x[n] = 0$$ h[n]y[n]

Comments

"आप अपना इनपुट फ़ंक्शन x [n] ले सकते हैं, और प्रत्येक गैर-शून्य * नमूना x [n] के लिए नमूना n से स्केल किए गए आवेग प्रतिक्रिया की गणना करते हैं और जब तक समय-शिफ्ट h [n] शून्य तक मर जाता है (एक ग्रहण करना कारण h [n]) "क्या पांच हैं जो इस वाक्य में सभी समान संख्या में हैं या क्या वे अलग हैं? $n$

— दिलीप सरवटे

@Dilip। सभी n समान हैं, सिवाय 'टाइम-शिफ्ट किए हुए h [n]', जिसका अर्थ 'h [nk]' है, जहां 'k' सिग्नल x के वांछित बिंदु पर आवेग प्रतिक्रिया को स्थानांतरित करने के लिए उपयोग किया जाने वाला स्थिरांक है [n] ]। यानी: h [n-2] x [2] पर सिग्नल की प्रतिक्रिया की गणना के लिए।

— abc

Answer 4

इंडेक्स सी [एन] पर, [एन] और बी [एन] का कनविक्शन, ऐसा है:

"c [n] सभी उत्पादों ([[k] b [m]) का एक योग है जैसे कि m + k = n," इसलिए m = n - k या k = n - m, जिसका अर्थ है कि अनुक्रमों में से एक फ़्लिप किया जाना है।

अब कनवल्शन इस तरह का व्यवहार क्यों करता है? बहुपद के साथ इसका संबंध होने के कारण।

दो बहुपद के गुणन के परिणामस्वरूप गुणन के साथ एक नए बहुपद में परिणाम होता है। उत्पाद बहुपद के सह-प्रभावकारक अभिसरण के संचालन को परिभाषित करते हैं। अब, सिग्नल प्रोसेसिंग में, ट्रांसफर फ़ंक्शंस- लाप्लास ट्रांसफ़ॉर्म या जेड-ट्रांसफ़ॉर्म ये पॉलीओनियम्स हैं, जिनमें प्रत्येक सह-कुशल एक अलग समय-देरी के अनुरूप है। उत्पाद और गुणकों के सह-गुणकों का मिलान इस तथ्य के परिणामस्वरूप होता है कि 'एक प्रतिनिधित्व में गुणा परिणत प्रतिनिधित्व में दृढ़ संकल्प से मेल खाता है'।

Answer 5

सजा के दौरान, आवेग प्रतिक्रिया का कोई भी "फ्लिप" नहीं होना चाहिए ...

हालाँकि, यदि आप किसी भी चरण परिवर्तन को रोकना चाहते हैं, तो आप आवेग प्रतिक्रिया के साथ एक संकेत को परिवर्तित कर सकते हैं और फिर आवेग प्रतिक्रिया को उल्टा कर सकते हैं और चरण प्रभाव को रद्द करने के लिए फिर से सीधा कर सकते हैं।

ऑफ़लाइन प्रसंस्करण में, आप पहले निष्कर्ष के बाद संकेत को आसानी से उलट सकते हैं, उसी निष्कर्ष पर पहुंच सकते हैं (जैसा कि टिप्पणियां सुझाव देती हैं)।

Comments

वह कनवल्शन में अभेद्य प्रतिक्रिया पर "टाइम रिवर्सल" की बात कर रहा है: । जैसा कि किसी और ने पहले ही बताया है, आपको आवेग प्रतिक्रिया को फ्लिप करने की ज़रूरत नहीं है ; आप या तो टर्म (यानी ) फ्लिप कर सकते हैं । मुझे लगता है कि वह यह पता लगाने की कोशिश कर रहा है कि उस "फ्लिप-एंड-स्लाइड" कार्रवाई की गुणात्मक व्याख्या क्या है। ज ( टी ) एक्स ( टी ) * ज ( टी ) = ज ( टी ) * एक्स ( टी $y(t) = \int_{-\infty}^{\infty}x(\tau) h(t-\tau) d\tau$$h(t)$$x(t) * h(t) = h(t) * x(t)$

— जेसन आर

@JasonR आह, वूप्स! कभी-कभी यह देखना मुश्किल होता है कि सवाल क्या है। इज़हाक, एक बार जब आप उस उत्तर को समझ जाते हैं जिसे आप खोज रहे थे, तो आप समझेंगे कि मैं कहाँ जा रहा था। अभी के लिए मुझे अनदेखा करो!

— 3

Answer 6

बस कनवल्लुशन इंटीग्रल लिखने के बजाय हैंडवॉइंग अर्थात् सभी तर्कों के जोड़े पर और के उत्पाद को एकीकृत करता है जो योग हैं ।

$$\int_{-\infty}^\infty f(\tau) g(t-\tau) d\tau$$ $$\iint\nolimits_{t_1+t_2 = t} f(t_1) \, g(t_2) \, dt_1\, dt_2$$ $f$$g$$t$

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

$$\iint_{t_1,t_2} f(t_1)\,g(t_2)\,\delta(t-t_1-t_2)\,dt_1\,dt_2$$ ∫ टी 1 च ( टी 1 $$\int_{t_1}f(t_1)\, dt_1\int_{t_2}g(t_2) \delta(t-t_1-t_2) \,dt_2$$ $$\int_{t_1}f(t_1)\,dt_1\,g(t-t_1)$$ जो नाम बदलने के एक बिट के साथ मूल अभिन्न है।