Signal Processing

A constant signal has all its energy at DC (frequency 0). No oscillation means no frequency content above DC. This is the frequency-domain definition of "flat."

[1,0,1,0] oscillates at the Nyquist rate — it flips every sample. That's frequency k=2 in a 4-point DFT (which is N/2 = the Nyquist bin). Energy appears at DC (the mean is 0.5) and at Nyquist.

[1,-1,1,-1] is a pure Nyquist-rate oscillation. All energy is at bin k=2 (N/2). Compare with [1,0,1,0] which had energy split between DC and Nyquist because its mean was nonzero.

This is why we only need to plot bins 0 to N/2 — the upper half is a mirror image. The "negative frequencies" X[N-k] are just the conjugates of the positive frequencies X[k]. This also means a real N-point signal has only N/2 + 1 independent frequency components.

An impulse contains equal energy at all frequencies — it's the "white" signal of the time domain. This is the Fourier dual of the all-ones result from Exercise 1.1: constant in one domain means impulse in the other.

Parseval's theorem guarantees energy is preserved across the DFT. You can compute signal energy in whichever domain is more convenient. The 1/N factor compensates for the DFT's unnormalized convention.

With 256 levels spanning a range of 2, each level covers 0.0078125 units. Any input value within one step is rounded to the same output — this rounding is the quantization error.

This is tiny — but remember, it's the noise power. The RMS noise amplitude is √(5.086×10^-6) ≈ 0.00226, which is about 0.23% of the full range. Clearly audible if your signal is quiet.

~50 dB is mediocre by modern standards. Old telephone systems used 8-bit μ-law encoding. CD audio uses 16 bits (96 dB), and professional audio uses 24 bits (144 dB).

Doubling the bit depth adds 6.02 × 8 = 48.16 dB. This is why CD audio (16-bit, 98 dB) sounds dramatically better than old 8-bit systems (~50 dB). The human ear has a dynamic range of about 120 dB, so 16 bits covers most of it.

Line 5 is the bug. The signal power for a full-scale sinusoid is X_max²/2 (the RMS squared), not X_max² (the peak squared). Using peak power instead of RMS power inflates the SNR by 3 dB. The corrected line should be const signalPower = xmax * xmax / 2;.

This is a classic mistake. The 6.02B + 1.76 formula already assumes a full-scale sinusoid with power = X_max²/2. If you derive SNR from scratch, you must use RMS signal power.

In practice nobody uses 15-bit ADCs. You'd use 16 bits and get 98 dB — the extra headroom is cheap and useful. But the math shows that 15 bits is the theoretical minimum for 90 dB.

The optimal 1-bit quantizer for Gaussian maps everything below 0 to -0.7979 and everything above 0 to +0.7979. The distortion is σ² - 2/π ≈ 0.3634, or about 36.3% of the signal variance. Terrible, but it's the best 1 bit can do.

After one iteration: r₁ = -1.5, r₂ = 2.333. The next step would compute b = (-1.5+2.333)/2 = 0.417, shifting the boundary left because the negative cluster is denser. You keep iterating until the levels stop changing.

Compare with the distortion before the update (using original levels r₁=-1, r₂=2): MSE = (4+1+0+1+1+0+4)/7 = 11/7 ≈ 1.571. One Lloyd-Max iteration reduced distortion from 1.571 to 1.381 — a 12% improvement. The algorithm converges when the levels and boundaries stop changing.

At very low bit rates, the Gaussian PDF within the active range [-2σ, 2σ] doesn't vary enough for non-uniform spacing to help significantly. The Lloyd-Max gain over uniform grows with the number of levels. At 8 bits (256 levels), Lloyd-Max can gain ~1-2 dB over uniform for Gaussian input. The real payoff of non-uniform quantization is for highly non-uniform distributions (like speech amplitude, which follows a Laplacian).

Companding = compression + expanding. The log compressor makes small values bigger and large values smaller, effectively spreading the dense-near-zero PDF into a more uniform shape. Uniform quantization of this spread-out signal is equivalent to non-uniform quantization of the original — more levels near zero, fewer at the extremes. It's a practical approximation to Lloyd-Max that doesn't require knowledge of the exact input distribution.

Each FFT bin spans ~43 Hz. The lowest piano note (A0) is 27.5 Hz and the next semitone (A#0) is 29.1 Hz — a gap of only 1.6 Hz. At 43 Hz resolution, you can't distinguish adjacent notes in the bass register. You'd need N ≥ 44100/1.6 ≈ 27563 for semitone resolution at A0.

23 ms is near the "sweet spot" for speech — long enough to capture a few pitch periods (speech fundamental is ~80-300 Hz) but short enough that the vocal tract shape doesn't change much within one frame. Most speech processing uses 20-30 ms windows.

The Hann window has 2x the mainlobe width of rectangular — you lose frequency resolution. But the sidelobes drop from -13 dB (rectangular) to -31 dB (Hann), dramatically reducing spectral leakage. In practice, you almost always prefer the Hann (or Hamming) window because leakage from strong signals masks weak signals more than a slightly wider mainlobe does.

With 50% overlap (hop = N/2), you get roughly 2 × (total_samples / N) frames. The overlap helps because each sample contributes to two adjacent frames, improving the time-domain smoothness of the spectrogram.

We only keep the positive frequencies because of conjugate symmetry (Chapter 1). The spectrogram is a 257 × 124 matrix, often displayed as a heatmap with frequency on the y-axis and time on the x-axis. Each cell is |X[k, m]|² (power) or 10·log10(|X[k,m]|²) (dB).

Frame → Window → FFT → Magnitude² → Log (dB)

Framing chops the signal into overlapping chunks. Windowing tapers each frame to reduce spectral leakage. FFT converts each windowed frame to the frequency domain. Taking |X|² gives the power spectrum. Log scaling compresses the dynamic range for display and downstream processing.

The approximation captures the local averages (scaled by √2 for energy preservation). The detail coefficients are equal here because both pairs differ by 2. The √2 normalization ensures energy is preserved: ∑|x|² = ∑|a|² + ∑|d|².

Parseval's theorem for wavelets. The √2 normalization is precisely what makes this work. Without it (using simple averages and differences), you'd need to track scaling factors manually.

Perfect reconstruction. This is the key property of orthogonal wavelets — you can decompose, process in the wavelet domain (e.g., zero out small detail coefficients for denoising), and reconstruct without losing information.

javascript
function haarDecompose(x) {
  const s = Math.SQRT2;
  const approx = [], detail = [];
  for (let k = 0; k < x.length; k += 2) {
    approx.push((x[k] + x[k+1]) / s);
    detail.push((x[k] - x[k+1]) / s);
  }
  return [approx, detail];
}

The key insight is sparsity. Real signals (edges, tones, transients) are sparse in the wavelet domain — their energy concentrates in a few large coefficients. White noise has equal power at all frequencies, so in the wavelet domain it spreads into many small coefficients. Thresholding keeps the large (signal) coefficients and zeros out the small (noise) ones. This is the foundation of JPEG2000 and many medical image denoising algorithms.

1000 Hz ≈ 1000 mel. This is by design — the mel scale was calibrated so that 1000 mel ≈ 1000 Hz. Below this point, mel tracks Hz almost linearly. Above it, the relationship becomes logarithmic.

7000 Hz of physical bandwidth (1000-8000) maps to only 1840 mel — less than 2x the 1000 mel that the first 1000 Hz gets. This compression at high frequencies is why mel filterbanks place many narrow filters below 1000 Hz and fewer wide filters above it.

In Hz, the first few filters are spaced ~100 Hz apart (near-linear below 1000 Hz), but the last few are spaced ~600+ Hz apart (logarithmic above 1000 Hz). This perceptually-motivated non-uniform spacing is the key feature of mel filterbanks.

y[n] = x[n] - 0.97·x[n-1] is approximately a first difference (derivative), which is a high-pass filter. Speech has a natural spectral tilt of about -6 dB/octave (the glottal pulse spectrum rolls off). Pre-emphasis flattens this tilt, giving the FFT and mel filters a more uniform energy distribution across frequencies. Without it, the low-frequency bins dominate and the high-frequency formant information is buried in noise.

Adjacent mel filters overlap, so their outputs are correlated. Correlated features are wasteful — a diagonal Gaussian classifier (common in GMM-HMMs) needs uncorrelated features. The DCT is like a PCA for this specific case: it decorrelates the log-mel features and concentrates most of the information in the first few coefficients. Keeping only 13 of 26 MFCCs reduces dimensionality by 50% with minimal information loss. Modern neural nets (Whisper, wav2vec) often skip the DCT and use log-mel features directly because they can learn to decorrelate internally.

Pre-emphasis → Frame+Window → FFT → Mel filterbank → Log → DCT

This pipeline has been standard since Davis & Mermelstein (1980). Modern systems sometimes add delta and delta-delta (velocity and acceleration) features, and may replace DCT with neural feature learning. But the core pipeline — pre-emphasis through mel filterbank — remains universal.

x=3 is 1σ from μ₁=2 but 2σ from μ₂=5. The Gaussian drops much faster at 2σ (e^-2 vs e^-0.5), so C₁ is strongly favored. The Bayes decision boundary is at x = 3.5 (the midpoint, since variances are equal and priors are equal).

The boundary shifted from 3.5 (equal priors) to 3.22 — toward C₁. This makes sense: since C₂ is more likely a priori (0.7 vs 0.3), we give C₂ more territory. A point at x=3.3 would be classified as C₂ even though it's closer to μ₁=2 than to μ₂=5, because C₂'s higher prior tips the balance.

When S_W is a scaled identity, the Fisher direction is simply the line connecting the class means. With equal spherical covariance, there's no need to "de-correlate" — the mean direction is already optimal. The ratio 4:3 means we project onto a line tilted at arctan(4/3) ≈ 53.1° from the x-axis.

The S_W^-1 term is what distinguishes Fisher from naive "connect the means." If S_W has eigenvalue 10 along one axis and eigenvalue 1 along another, S_W^-1 has eigenvalues 0.1 and 1 — it shrinks the high-variance direction and stretches the low-variance one. This tips the Fisher direction toward the axis where the classes are narrow, even if the means are more separated along the wide axis. It's the same logic as Mahalanobis distance: an inch of separation in a narrow direction is worth more than a foot of separation in a wide one.

Line 5 (and line 6) have the bug. The Gaussian exponent should be -d²/(2σ²), but the code uses 2*sigma instead of 2*sigma*sigma. The parameter sigma is the standard deviation, so the variance is σ². Dividing by 2σ instead of 2σ² changes the effective variance and gives wrong posteriors whenever σ ≠ 1.

When σ = 1, the bug is invisible because 2σ = 2σ² = 2. This is a classic unit test failure: the test passed with σ=1 but the code is wrong for all other variances. Always test with σ ≠ 1.

A margin of 0.4 means the nearest point to the boundary is 0.2 units away on each side. If we scaled w to [6, 8] and b to -4, the hyperplane would be identical but ||w|| = 10, giving a margin of 0.2. The margin depends on the normalized distance, so we minimize ||w|| to maximize the margin.

The point (1,1) is exactly 1 unit from the hyperplane. Since the margin is 0.4 (half-margin = 0.2), this point is well outside the margin — it's NOT a support vector. A support vector would be at distance 1/||w|| = 0.2 from the hyperplane.

(1, 0) gives w·x + b = 3 + 0 - 2 = 1, so |w·x + b| = 1. This point lies exactly on the positive margin plane (w·x + b = +1). It's a support vector — remove it and the hyperplane might change. All other points have |w·x + b| > 1, meaning they're safely inside their class region and don't constrain the optimization.

The kernel trick: instead of computing the expensive mapping φ and then the dot product in 3D, we compute (a·b)² directly in the original 2D space. Same result, much cheaper. For degree-d polynomials in n dimensions, the mapped space has O(n^d) dimensions, but the kernel computation is still O(n). This is why SVMs can operate in effectively infinite-dimensional spaces (e.g., RBF kernel).

javascript
function margin(w) {
  const norm = Math.sqrt(w.reduce((s, v) => s + v * v, 0));
  return 2 / norm;
}

The RBF kernel measures similarity — K=1 for identical points, K→0 as distance grows. With σ=1, points at distance √2 ≈ 1.41 apart have K ≈ 0.37. The parameter σ controls the "reach": larger σ = smoother decision boundary, smaller σ = more wiggly (potentially overfitting).

25 ms at 16 kHz gives exactly 400 samples. This is a common choice in speech processing. The frame should be long enough to capture 2-3 pitch periods (human pitch: 80-300 Hz, period: 3.3-12.5 ms) but short enough that the vocal tract is roughly stationary.

The overlap is frame_size - hop = 400 - 160 = 240 samples, which is 60% overlap. This is more aggressive than the typical 50% overlap from Chapter 4, giving smoother temporal features at the cost of more frames to process.

3 seconds of audio at 10 ms hop gives approximately 300 frames. Each frame produces one feature vector, so our downstream classifier sees a sequence of 298 feature vectors — one every 10 ms.

Zero-padding from 400 to 512 doesn't add information — it just interpolates the spectrum more finely (smaller spacing between bins). The frequency resolution is still determined by the original 400 samples: Δf = f_s/400 = 40 Hz. But the FFT bins are spaced at f_s/512 = 31.25 Hz.

39-dimensional feature vectors are the classic MFCC configuration used by virtually every pre-deep-learning speech recognizer (HTK, Kaldi). Each of the 298 frames produces a 39-D vector, so the complete feature matrix for 3 seconds of audio is 298 × 39.

3 seconds of raw audio at 16 kHz, 16-bit = 96 KB. After MFCC extraction: 45.4 KB. That's only 2.3x compression — MFCCs aren't about compression, they're about representation. The 39 dimensions capture the perceptually relevant information (vocal tract shape, pitch dynamics) while discarding speaker-specific details and noise.

javascript
function featurePipelineDims(durationSec, fs, frameSec, hopSec, nfft, nMel, nMfcc, deltas) {
  const totalSamples = Math.round(durationSec * fs);
  const frameSamples = Math.round(frameSec * fs);
  const hopSamples = Math.round(hopSec * fs);
  const nFrames = Math.floor((totalSamples - frameSamples) / hopSamples) + 1;
  const featDim = nMfcc * (deltas ? 3 : 1);
  return { nFrames, featDim, matrixSize: nFrames * featDim };
}

The mel filterbank deliberately blurs high frequencies because the human auditory system does the same. Below ~1 kHz, we can distinguish frequencies ~3 Hz apart. Above ~4 kHz, our resolution drops to ~100+ Hz. Narrow mel filters at low frequencies capture the fine pitch and formant structure that matters for speech intelligibility. Wide mel filters at high frequencies average out spectral detail that humans can't perceive anyway. The result is a compact, perceptually relevant representation.