How do I get the frequencies from a signal?

Question

I am look for a way to obtain the frequency from a signal. Here's an example:

signal = [numpy.sin(numpy.pi * x / 2) for x in range(1000)]

This Array will represent the sample of a recorded sound (x = miliseconds)

sin(pi*x/2) => 250 Hrz

How can we go from the signal (list of points), to obtaining the frequencies form this array?

Note: I have read many Stackoverflow threads and watch many youtube videos. I am yet to find an answer. Please use simple words. (I am Thankfull for every answer)

Answer 1

What you're looking for is known as the Fourier Transform

---

A bit of background

Let's start with the formal definition:

The Fourier transform (FT) decomposes a function (often a function of time, or a signal) into its constituent frequencies

This is in essence a mathematical operation that when applied over a signal, gives you an idea of how present each frequency is in the time series. In order to get some intuition behind this, it might be helpful to look at the mathematical definition of the DFT:

Where k here is swept all the way up t N-1 to calculate all the DFT coefficients.

The first thing to notice is that, this definition resembles somewhat that of the correlation of two functions, in this case x(n) and the negative exponential function. While this may seem a little bit abstract, by using Euler's formula and by playing a bit around with the definition, the DFT can be expressed as the correlation with both a sine wave and a cosine wave, which will account for the imaginary and the real parts of the DFT.

So keeping in mind that this is in essence computing a correlation, whenever a corresponding sine or cosine from the decomposition of the complex exponential matches with that of x(n), there will be a peak in X(K), meaning that, such frequency is present in the signal.

---

How can we do the same with numpy?

So having given a very brief theoretical background, let's consider an example to see how this can be implemented in python. Lets consider the following signal:

import numpy as np
import matplotlib.pyplot as plt

Fs = 150.0;  # sampling rate
Ts = 1.0/Fs; # sampling interval
t = np.arange(0,1,Ts) # time vector

ff = 50;   # frequency of the signal
y = np.sin(2*np.pi*ff*t)

plt.plot(t, y)
plt.xlabel('Time')
plt.ylabel('Amplitude')
plt.show()

Now, the DFT can be computed by using np.fft.fft, which as mentioned, will be telling you which is the contribution of each frequency in the signal now in the transformed domain:

n = len(y) # length of the signal
k = np.arange(n)
T = n/Fs
frq = k/T # two sides frequency range
frq = frq[:len(frq)//2] # one side frequency range

Y = np.fft.fft(y)/n # dft and normalization
Y = Y[:n//2]

Now, if we plot the actual spectrum, you will see that we get a peak at the frequency of 50Hz, which in mathematical terms it will be a delta function centred in the fundamental frequency of 50Hz. This can be checked in the following Table of Fourier Transform Pairs table.

So for the above signal, we would get:

plt.plot(frq,abs(Y)) # plotting the spectrum
plt.xlabel('Freq (Hz)')
plt.ylabel('|Y(freq)|')
plt.show()