Fourier Transform intuition in Signal Processing - Mini Project: Build & Apply

Fourier Transform Intuition

📖 Scenario: Imagine you are a music producer who wants to understand the different notes in a sound clip. The sound is a mix of different waves, and you want to find out which waves (frequencies) make up the sound.

🎯 Goal: You will create a simple signal made of two waves, set a sampling rate, apply the Fourier Transform to find the frequencies, and then print the main frequencies found.

📋 What You'll Learn

Create a signal with two sine waves of different frequencies

Set a sampling rate variable

Use the Fourier Transform to find frequency components

Print the main frequencies detected

💡 Why This Matters

🌍 Real World

Fourier Transform helps analyze sounds, images, and signals by breaking them into simple waves. This is useful in music, medicine, and engineering.

💼 Career

Understanding Fourier Transform is key for roles in signal processing, audio engineering, data analysis, and machine learning.

1

Create a signal with two sine waves

Create a variable sampling_rate and set it to 1000. Then create a variable t as a list of 1000 time points from 0 to 1 second (not including 1). Next, create a variable signal which is the sum of two sine waves: one with frequency 5 Hz and another with frequency 20 Hz, both sampled at t. Use the math module's sin and pi functions.

Signal Processing

# Create sampling_rate, t, and signal variables
# Your code here

Hint

Use list comprehension to create t and signal. Remember frequency times time inside the sine function.

2

Import numpy and prepare for Fourier Transform

Import the numpy module as np. Then convert the signal list into a numpy array called signal_np.

Signal Processing

import math
sampling_rate = 1000
t = [i / sampling_rate for i in range(1000)]
signal = [math.sin(2 * math.pi * 5 * x) + math.sin(2 * math.pi * 20 * x) for x in t]
# Import numpy as np and convert signal to numpy array
# Your code here

Hint

Use np.array() to convert the list to a numpy array.

3

Apply Fourier Transform to the signal

Use np.fft.fft on signal_np and store the result in fft_result. Then calculate the frequencies using np.fft.fftfreq with the length of signal_np and the sampling interval 1 / sampling_rate. Store frequencies in frequencies. Finally, create a variable magnitude which is the absolute value of fft_result.

Signal Processing

import math
import numpy as np
sampling_rate = 1000
t = [i / sampling_rate for i in range(1000)]
signal = [math.sin(2 * math.pi * 5 * x) + math.sin(2 * math.pi * 20 * x) for x in t]
signal_np = np.array(signal)
# Compute fft_result, frequencies, and magnitude
# Your code here

Hint

Use np.fft.fft and np.fft.fftfreq with correct parameters.

4

Print the main frequencies found

Find the indices where frequencies are positive. Then find the top two frequencies with the highest magnitude among these positive frequencies. Print these two frequencies rounded to integers in ascending order, separated by a space.

Signal Processing

import math
import numpy as np
sampling_rate = 1000
t = [i / sampling_rate for i in range(1000)]
signal = [math.sin(2 * math.pi * 5 * x) + math.sin(2 * math.pi * 20 * x) for x in t]
signal_np = np.array(signal)
fft_result = np.fft.fft(signal_np)
frequencies = np.fft.fftfreq(len(signal_np), 1 / sampling_rate)
magnitude = np.abs(fft_result)
# Print the two main frequencies found
# Your code here

Hint

Use np.where to get positive frequencies, then argsort to find top magnitudes.

Practice

1. What does the Fourier Transform do to a signal?

easy

A. Breaks it into simple waves of different frequencies

B. Changes the signal into a random noise

C. Removes all frequencies except the highest

D. Converts the signal into a single number

Solution

1. Step 1: Understand the purpose of Fourier Transform

   The Fourier Transform breaks a complex signal into simpler parts called sine and cosine waves.

2. Step 2: Identify what the transform reveals

   It shows the different frequencies that make up the original signal.

3. Final Answer:

   Breaks it into simple waves of different frequencies -> Option A

4. Quick Check:

   Fourier Transform = signal broken into frequencies [OK]

Hint: Fourier Transform splits signals into frequency waves [OK]

Common Mistakes:

• Thinking it removes frequencies instead of showing them
• Believing it converts signal to a single number
• Confusing it with noise generation

2. Which of the following is the correct syntax to compute the Fourier Transform of a signal array signal using NumPy in Python?

easy

A. np.fft.fft(signal)

B. np.fft.transform(signal)

C. np.fourier(signal)

D. np.fft.fourier_transform(signal)

Solution

1. Step 1: Recall NumPy FFT function name

   NumPy uses np.fft.fft() to compute the Fourier Transform of a signal.

2. Step 2: Check other options for correctness

   Other options are not valid NumPy functions for Fourier Transform.

3. Final Answer:

   np.fft.fft(signal) -> Option A

4. Quick Check:

   NumPy FFT function = np.fft.fft() [OK]

Hint: Use np.fft.fft() for Fourier Transform in NumPy [OK]

Common Mistakes:

• Using incorrect function names like np.fft.transform
• Confusing Fourier Transform with other NumPy functions
• Misspelling 'fft'

3. Given the Python code:

import numpy as np
signal = np.array([1, 0, -1, 0])
ft = np.fft.fft(signal)
print(np.round(ft, 2))

What is the output?

medium

A. [0.+0.j 0.+0.j 0.+0.j 0.+0.j]

B. [0.+0.j 0.+2.j 0.+0.j 0.-2.j]

C. [0.+0.j 2.+0.j 0.+0.j 2.+0.j]

D. [0.+0.j 1.-1.j 0.+0.j 1.+1.j]

Solution

1. Step 1: Compute FFT of the signal [1, 0, -1, 0]

   The FFT of this 4-point signal results in complex values representing frequency components.

2. Step 2: Calculate or recall FFT output

   The FFT output is [0.+0.j, 0.+2.j, 0.+0.j, 0.-2.j] after rounding to 2 decimals.

3. Final Answer:

   [0.+0.j 0.+2.j 0.+0.j 0.-2.j] -> Option B

4. Quick Check:

   FFT of [1,0,-1,0] = [0, 2j, 0, -2j] [OK]

Hint: FFT output shows complex frequency components [OK]

Common Mistakes:

• Ignoring imaginary parts in FFT output
• Mixing up real and imaginary values
• Assuming FFT output is all real numbers

4. The following code attempts to compute the Fourier Transform but gives an error:

import numpy as np
signal = [1, 2, 3, 4]
ft = np.fft.fft(signal, n='4')
print(ft)

What is the error and how to fix it?

medium

A. Error: print statement syntax wrong, fix by adding parentheses

B. Error: signal must be a NumPy array, fix by converting signal to np.array

C. Error: np.fft.fft does not accept 'n' parameter, remove it

D. Error: 'n' must be an integer, fix by removing quotes: n=4

Solution

1. Step 1: Identify the error cause

   The parameter n expects an integer, but a string '4' is given causing a type error.

2. Step 2: Fix the error

   Remove quotes around 4 to pass an integer: n=4.

3. Final Answer:

   Error: 'n' must be an integer, fix by removing quotes: n=4 -> Option D

4. Quick Check:

   Parameter types must match function signature [OK]

Hint: Pass integer, not string, for numeric parameters [OK]

Common Mistakes:

• Passing string instead of integer for 'n'
• Not converting list to NumPy array (not error here)
• Misreading error as print syntax issue

5. You have a noisy audio signal sampled at 1000 Hz. You want to remove frequencies above 300 Hz using Fourier Transform. Which steps correctly describe this process?

hard

A. Remove frequencies above 300 Hz directly from time signal, then compute FFT

B. Apply inverse FFT first, then remove frequencies above 300 Hz

C. Compute FFT, zero out frequencies above 300 Hz, then apply inverse FFT

D. Compute FFT, keep only frequencies above 300 Hz, then apply inverse FFT

Solution

1. Step 1: Use FFT to convert time signal to frequency domain

   Compute the Fourier Transform to see all frequency components.

2. Step 2: Filter frequencies above 300 Hz

   Set frequency components above 300 Hz to zero to remove noise.

3. Step 3: Convert back to time domain

   Apply inverse FFT to get the cleaned time signal without high frequencies.

4. Final Answer:

   Compute FFT, zero out frequencies above 300 Hz, then apply inverse FFT -> Option C

5. Quick Check:

   Filter in frequency domain, then inverse FFT [OK]

Hint: Filter frequencies in FFT, then inverse transform [OK]

Common Mistakes:

• Filtering in time domain instead of frequency domain
• Applying inverse FFT before filtering
• Keeping unwanted frequencies instead of zeroing them