Spectrogram visualization in Signal Processing - Step-by-Step Execution

Concept Flow - Spectrogram visualization

Input Signal

↓

Windowing: Split signal into chunks

↓

Apply FFT on each chunk

↓

Calculate magnitude (power) spectrum

↓

Stack spectra over time

↓

Display as 2D image: Time vs Frequency vs Intensity

The signal is split into small time windows, each window is transformed to frequency data, then all frequency data are combined over time to form the spectrogram image.

Execution Sample

Signal Processing

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import spectrogram

f, t, Sxx = spectrogram(signal, fs=fs)
plt.pcolormesh(t, f, 10 * np.log10(Sxx))
plt.ylabel('Frequency [Hz]')
plt.xlabel('Time [sec]')
plt.title('Spectrogram')
plt.colorbar(label='Intensity [dB]')
plt.show()

This code computes and plots the spectrogram of a signal showing how frequency content changes over time.

Execution Table

Step	Action	Input/Variable	Output/Result
1	Receive input signal	signal (array), fs (sampling rate)	signal array ready
2	Split signal into windows	signal array	windows (chunks of signal)
3	Apply FFT on each window	windows	frequency spectra per window
4	Calculate power spectrum	frequency spectra	magnitude squared spectra (Sxx)
5	Stack spectra over time	Sxx	2D array (frequency x time)
6	Convert power to dB scale	Sxx	10 * log10(Sxx)
7	Plot spectrogram	time (t), frequency (f), power dB	color mesh image showing intensity
8	Show plot	plot object	visual spectrogram displayed
9	End	N/A	Spectrogram visualization complete

💡 All windows processed and spectrogram displayed

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
signal	raw input	unchanged	unchanged	unchanged	unchanged	unchanged	unchanged
windows	N/A	array of chunks	unchanged	unchanged	unchanged	unchanged	unchanged
frequency spectra	N/A	N/A	FFT results per window	unchanged	unchanged	unchanged	unchanged
Sxx (power spectrum)	N/A	N/A	N/A	magnitude squared	stacked 2D array	unchanged	unchanged
Sxx dB	N/A	N/A	N/A	N/A	N/A	10 * log10(Sxx)	unchanged
plot	N/A	N/A	N/A	N/A	N/A	created	displayed

Key Moments - 3 Insights

Why do we split the signal into windows before applying FFT?

Splitting into windows lets us see how frequencies change over time. The execution_table step 2 shows signal split into chunks, enabling time-local frequency analysis.

Why convert power spectrum to decibels (dB)?

Decibels make it easier to see differences in power on a logarithmic scale. Step 6 in execution_table shows this conversion for better visualization contrast.

What does the color in the spectrogram represent?

Color shows the intensity (power) of frequencies at each time window. Step 7 shows plotting with power in dB mapped to color.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the signal split into smaller chunks?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Check the 'Action' column for 'Split signal into windows'

According to variable_tracker, what is the state of 'Sxx' after Step 5?

A Raw input signal

B Stacked 2D array of power spectra

C FFT results per window

D Power spectrum converted to dB

💡 Hint

Look at the 'Sxx (power spectrum)' row under 'After Step 5'

If we skip converting power to dB (Step 6), how would the spectrogram plot change?

A Plot would be identical

B Plot would not show any frequencies

C Colors would represent raw power, possibly less contrast

D Plot would show time on y-axis instead

💡 Hint

Refer to Step 6 and 7 in execution_table about power conversion and plotting

Concept Snapshot

Spectrogram visualization:
- Split signal into short windows
- Apply FFT to each window
- Compute power spectrum (magnitude squared)
- Stack spectra over time to form 2D array
- Convert power to dB scale for better contrast
- Plot time vs frequency with color showing intensity

Full Transcript

Spectrogram visualization breaks a signal into small time windows. Each window is transformed using FFT to get frequency content. The power spectrum is calculated by squaring the magnitude of FFT results. These spectra are stacked over time to form a 2D array showing frequency vs time. The power values are converted to decibels to improve visual contrast. Finally, the spectrogram is displayed as a color image where colors represent intensity of frequencies at each time window. This helps us see how frequencies in the signal change over time.

Practice

1. What does a spectrogram primarily show in signal processing?

easy

A. How signal frequencies change over time

B. The total energy of a signal

C. The raw amplitude values of a signal

D. The phase shift of a signal

Solution

1. Step 1: Understand spectrogram purpose

   A spectrogram is a visual tool that shows frequency content of a signal as it changes over time.

2. Step 2: Compare options to definition

   Only How signal frequencies change over time describes frequency changes over time, which matches the spectrogram's function.

3. Final Answer:

   How signal frequencies change over time -> Option A

4. Quick Check:

   Spectrogram = frequency over time [OK]

Hint: Spectrogram = frequency vs time graph [OK]

Common Mistakes:

• Confusing spectrogram with waveform plot
• Thinking it shows only amplitude
• Mixing phase information with frequency

2. Which Python library is commonly used to create spectrograms?

easy

A. matplotlib

B. pandas

C. scikit-learn

D. numpy

Solution

1. Step 1: Identify libraries for plotting

   matplotlib is widely used for plotting graphs including spectrograms.

2. Step 2: Check other libraries' main uses

   pandas is for data frames, scikit-learn for machine learning, numpy for arrays but not direct plotting.

3. Final Answer:

   matplotlib -> Option A

4. Quick Check:

   Plotting spectrogram = matplotlib [OK]

Hint: Plotting graphs? Think matplotlib [OK]

Common Mistakes:

• Choosing numpy for plotting directly
• Confusing pandas with plotting library
• Selecting scikit-learn which is for ML

3. Given this Python code snippet, what is the shape of the output spectrogram array?

import numpy as np
from scipy.signal import spectrogram

fs = 1280  # Sampling frequency
x = np.sin(2 * np.pi * 50 * np.linspace(0, 1, fs))
f, t, Sxx = spectrogram(x, fs)
print(Sxx.shape)

medium

A. (1000, 1000)

B. (129, 9)

C. (50, 1000)

D. (1000, 129)

Solution

1. Step 1: Understand spectrogram output dimensions

   The spectrogram function returns frequency bins and time bins. For default parameters, frequency bins are nfft/2+1 (default nfft=256), so 129 frequency bins.

2. Step 2: Calculate time bins

   With 1 second signal sampled at 1280 Hz and default windowing, time bins are 9 segments.

3. Final Answer:

   (129, 9) -> Option B

4. Quick Check:

   Frequency bins = 129, Time bins = 9 [OK]

Hint: Spectrogram shape = (freq_bins, time_bins) [OK]

Common Mistakes:

• Assuming output shape matches input length
• Confusing frequency bins with sampling rate
• Mixing up rows and columns in output

4. Identify the error in this code snippet for plotting a spectrogram:

import matplotlib.pyplot as plt
from scipy.signal import spectrogram

fs = 500
x = [1, 2, 3, 4, 5]
f, t, Sxx = spectrogram(x, fs)
plt.specgram(Sxx)
plt.show()

medium

A. Using plt.specgram instead of plt.plot

B. Missing import for numpy

C. Sampling frequency fs is too high

D. Passing Sxx instead of x to plt.specgram

Solution

1. Step 1: Understand spectrogram output and plotting

   The spectrogram function returns frequencies, times, and the spectrogram matrix Sxx. plt.specgram expects raw signal, not Sxx.

2. Step 2: Identify misuse of plt.specgram

   Passing Sxx (already spectrogram data) to plt.specgram causes error; should plot Sxx with plt.imshow or pass raw signal to plt.specgram.

3. Final Answer:

   Passing Sxx instead of x to plt.specgram -> Option D

4. Quick Check:

   Plot raw signal with plt.specgram, not spectrogram matrix [OK]

Hint: plt.specgram needs raw signal, not spectrogram data [OK]

Common Mistakes:

• Passing spectrogram matrix to plt.specgram
• Confusing plt.specgram with plt.imshow
• Ignoring correct input types for plotting

5. You want a spectrogram with smoother frequency resolution but less time detail. Which parameter should you increase?

hard

A. Sampling frequency (fs)

B. Overlap between windows (noverlap)

C. Window size (nperseg)

D. FFT length (nfft) smaller than window size

Solution

1. Step 1: Understand window size effect on spectrogram

   Larger window size increases frequency resolution but reduces time resolution (smoother frequency, less time detail).

2. Step 2: Evaluate other parameters

   Increasing overlap smooths time axis but does not improve frequency resolution as much. Sampling frequency affects max frequency, not resolution. nfft smaller than window size is invalid.

3. Final Answer:

   Window size (nperseg) -> Option C

4. Quick Check:

   Increase window size for better frequency resolution [OK]

Hint: Bigger window = better frequency, worse time detail [OK]

Common Mistakes:

• Increasing overlap to improve frequency resolution
• Changing sampling frequency to affect resolution
• Setting nfft smaller than window size