Hướng dẫn fourier transform python - trăn biến hình fourier

Biến đổi Fourier là một công cụ mạnh mẽ để phân tích tín hiệu và được sử dụng trong mọi thứ, từ xử lý âm thanh đến nén hình ảnh. SCIPY cung cấp một triển khai trưởng thành trong mô -đun

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 và trong hướng dẫn này, bạn sẽ học cách sử dụng nó.Fourier transform is a powerful tool for analyzing signals and is used in everything from audio processing to image compression. SciPy provides a mature implementation in its
>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 module, and in this tutorial, you’ll learn how to use it.

Show

Mô -đun

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 ban đầu có vẻ đáng sợ vì có nhiều chức năng, thường có tên tương tự và tài liệu sử dụng rất nhiều thuật ngữ kỹ thuật mà không cần giải thích. Tin tốt là bạn chỉ cần hiểu một vài khái niệm cốt lõi để bắt đầu sử dụng mô -đun.

Đừng lo lắng nếu bạn không thoải mái với toán học! Bạn có thể cảm nhận được thuật toán thông qua các ví dụ cụ thể và sẽ có các liên kết để tiếp tục tài nguyên nếu bạn muốn đi sâu vào các phương trình. Để giới thiệu trực quan về cách thức hoạt động của Fourier Transform, bạn có thể thích video 3Blue1Brown.

Trong hướng dẫn này, bạn sẽ học:

  • Làm thế nào và khi nào để sử dụng biến đổi FourierFourier transform
  • Cách chọn chức năng chính xác từ
    >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5 cho trường hợp sử dụng của bạn
    >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5
    for your use case
  • Cách xem và sửa đổi phổ tần số của tín hiệufrequency spectrum of a signal
  • Những biến đổi khác nhau có sẵn trong
    >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5transforms are available in
    >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5

Nếu bạn thích một bản tóm tắt của hướng dẫn này để giữ sau khi bạn đọc xong, thì hãy tải xuống bảng gian lận bên dưới. Nó có những giải thích về tất cả các chức năng trong mô -đun

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 cũng như sự cố của các loại biến đổi khác nhau có sẵn:

Mô -đun >>> import scipy, matplotlib >>> print(scipy.__file__) /usr/local/lib/python3.6/dist-packages/scipy/__init__.py >>> print(matplotlib.__file__) /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py 5

Biến đổi Fourier là một công cụ quan trọng trong nhiều ứng dụng, đặc biệt là trong máy tính khoa học và khoa học dữ liệu. Như vậy, SCIPY từ lâu đã cung cấp một triển khai của nó và các biến đổi liên quan của nó. Ban đầu, SCIPY đã cung cấp mô -đun

import numpy as np
from matplotlib import pyplot as plt

SAMPLE_RATE = 44100  # Hertz
DURATION = 5  # Seconds

def generate_sine_wave(freq, sample_rate, duration):
    x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
    frequencies = x * freq
    # 2pi because np.sin takes radians
    y = np.sin((2 * np.pi) * frequencies)
    return x, y

# Generate a 2 hertz sine wave that lasts for 5 seconds
x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
plt.plot(x, y)
plt.show()
1, nhưng họ đã cập nhật việc triển khai của họ và chuyển nó sang mô -đun
>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5.

Scipy được đóng gói đầy đủ chức năng. Để giới thiệu tổng quát hơn về thư viện, hãy xem Python khoa học: Sử dụng SCIPY để tối ưu hóa.

Cài đặt Scipy và Matplotlib

Trước khi bạn có thể bắt đầu, bạn sẽ cần cài đặt Scipy và Matplotlib. Bạn có thể làm điều này một trong hai cách:

  1. Cài đặt với Anaconda: Tải xuống và cài đặt phiên bản cá nhân Anaconda. Nó đi kèm với scipy và matplotlib, vì vậy một khi bạn làm theo các bước trong trình cài đặt, bạn đã hoàn thành! Download and install the Anaconda Individual Edition. It comes with SciPy and Matplotlib, so once you follow the steps in the installer, you’re done!

  2. Cài đặt với

    import numpy as np
    from matplotlib import pyplot as plt
    
    SAMPLE_RATE = 44100  # Hertz
    DURATION = 5  # Seconds
    
    def generate_sine_wave(freq, sample_rate, duration):
        x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
        frequencies = x * freq
        # 2pi because np.sin takes radians
        y = np.sin((2 * np.pi) * frequencies)
        return x, y
    
    # Generate a 2 hertz sine wave that lasts for 5 seconds
    x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
    plt.plot(x, y)
    plt.show()
    
    3: Nếu bạn đã cài đặt
    import numpy as np
    from matplotlib import pyplot as plt
    
    SAMPLE_RATE = 44100  # Hertz
    DURATION = 5  # Seconds
    
    def generate_sine_wave(freq, sample_rate, duration):
        x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
        frequencies = x * freq
        # 2pi because np.sin takes radians
        y = np.sin((2 * np.pi) * frequencies)
        return x, y
    
    # Generate a 2 hertz sine wave that lasts for 5 seconds
    x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
    plt.plot(x, y)
    plt.show()
    
    3, thì bạn có thể cài đặt thư viện bằng lệnh sau:
    If you already have
    import numpy as np
    from matplotlib import pyplot as plt
    
    SAMPLE_RATE = 44100  # Hertz
    DURATION = 5  # Seconds
    
    def generate_sine_wave(freq, sample_rate, duration):
        x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
        frequencies = x * freq
        # 2pi because np.sin takes radians
        y = np.sin((2 * np.pi) * frequencies)
        return x, y
    
    # Generate a 2 hertz sine wave that lasts for 5 seconds
    x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
    plt.plot(x, y)
    plt.show()
    
    3 installed, then you can install the libraries with the following command:

    $ python -m pip install -U scipy matplotlib
    

Bạn có thể xác minh cài đặt hoạt động bằng cách nhập

import numpy as np
from matplotlib import pyplot as plt

SAMPLE_RATE = 44100  # Hertz
DURATION = 5  # Seconds

def generate_sine_wave(freq, sample_rate, duration):
    x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
    frequencies = x * freq
    # 2pi because np.sin takes radians
    y = np.sin((2 * np.pi) * frequencies)
    return x, y

# Generate a 2 hertz sine wave that lasts for 5 seconds
x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
plt.plot(x, y)
plt.show()
5 vào thiết bị đầu cuối của mình và chạy mã sau:

>>>

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py

Mã này nhập Scipy và matplotlib và in vị trí của các mô -đun. Máy tính của bạn có thể sẽ hiển thị các đường dẫn khác nhau, nhưng miễn là nó in một đường dẫn, việc cài đặt đã hoạt động.

Scipy hiện đã được cài đặt! Bây giờ, thời gian để xem xét sự khác biệt giữa

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 và
import numpy as np
from matplotlib import pyplot as plt

SAMPLE_RATE = 44100  # Hertz
DURATION = 5  # Seconds

def generate_sine_wave(freq, sample_rate, duration):
    x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
    frequencies = x * freq
    # 2pi because np.sin takes radians
    y = np.sin((2 * np.pi) * frequencies)
    return x, y

# Generate a 2 hertz sine wave that lasts for 5 seconds
x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
plt.plot(x, y)
plt.show()
1.

>>> import scipy, matplotlib >>> print(scipy.__file__) /usr/local/lib/python3.6/dist-packages/scipy/__init__.py >>> print(matplotlib.__file__) /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py 5 so với import numpy as np from matplotlib import pyplot as plt SAMPLE_RATE = 44100 # Hertz DURATION = 5 # Seconds def generate_sine_wave(freq, sample_rate, duration): x = np.linspace(0, duration, sample_rate * duration, endpoint=False) frequencies = x * freq # 2pi because np.sin takes radians y = np.sin((2 * np.pi) * frequencies) return x, y # Generate a 2 hertz sine wave that lasts for 5 seconds x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION) plt.plot(x, y) plt.show() 1

Khi nhìn vào tài liệu SCIPY, bạn có thể bắt gặp hai mô -đun trông rất giống nhau:

  1. >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5
  2. import numpy as np
    from matplotlib import pyplot as plt
    
    SAMPLE_RATE = 44100  # Hertz
    DURATION = 5  # Seconds
    
    def generate_sine_wave(freq, sample_rate, duration):
        x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
        frequencies = x * freq
        # 2pi because np.sin takes radians
        y = np.sin((2 * np.pi) * frequencies)
        return x, y
    
    # Generate a 2 hertz sine wave that lasts for 5 seconds
    x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
    plt.plot(x, y)
    plt.show()
    
    1

Mô -đun

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 mới hơn và nên được ưu tiên hơn
import numpy as np
from matplotlib import pyplot as plt

SAMPLE_RATE = 44100  # Hertz
DURATION = 5  # Seconds

def generate_sine_wave(freq, sample_rate, duration):
    x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
    frequencies = x * freq
    # 2pi because np.sin takes radians
    y = np.sin((2 * np.pi) * frequencies)
    return x, y

# Generate a 2 hertz sine wave that lasts for 5 seconds
x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
plt.plot(x, y)
plt.show()
1. Bạn có thể đọc thêm về sự thay đổi trong Ghi chú phát hành cho SCIPY 1.4.0, nhưng ở đây, một bản tóm tắt nhanh chóng:

  • >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5 có API cải tiến.
  • >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5 cho phép sử dụng nhiều công nhân, có thể cung cấp tốc độ tăng tốc trong một số tình huống.
  • import numpy as np
    from matplotlib import pyplot as plt
    
    SAMPLE_RATE = 44100  # Hertz
    DURATION = 5  # Seconds
    
    def generate_sine_wave(freq, sample_rate, duration):
        x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
        frequencies = x * freq
        # 2pi because np.sin takes radians
        y = np.sin((2 * np.pi) * frequencies)
        return x, y
    
    # Generate a 2 hertz sine wave that lasts for 5 seconds
    x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
    plt.plot(x, y)
    plt.show()
    
    1 được coi là di sản và SCIPY khuyến nghị sử dụng
    >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5 thay thế.

Trừ khi bạn có lý do chính đáng để sử dụng

import numpy as np
from matplotlib import pyplot as plt

SAMPLE_RATE = 44100  # Hertz
DURATION = 5  # Seconds

def generate_sine_wave(freq, sample_rate, duration):
    x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
    frequencies = x * freq
    # 2pi because np.sin takes radians
    y = np.sin((2 * np.pi) * frequencies)
    return x, y

# Generate a 2 hertz sine wave that lasts for 5 seconds
x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
plt.plot(x, y)
plt.show()
1, bạn nên gắn bó với
>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5.

>>> import scipy, matplotlib >>> print(scipy.__file__) /usr/local/lib/python3.6/dist-packages/scipy/__init__.py >>> print(matplotlib.__file__) /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py 5 so với normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767) plt.plot(normalized_tone[:1000]) plt.show() 1

Việc triển khai SCIPY Fast Fourier Transform (FFT) chứa nhiều tính năng hơn và có nhiều khả năng nhận được các bản sửa lỗi hơn so với việc triển khai Numpy. Nếu được lựa chọn, bạn nên sử dụng triển khai SCIPY.

Numpy duy trì việc triển khai FFT để tương thích ngược mặc dù các tác giả tin rằng chức năng như Fourier Transforms được đặt tốt nhất trong SCIPY. Xem Câu hỏi thường gặp SCIPY để biết thêm chi tiết.

Biến đổi Fourier

Phân tích Fourier là một lĩnh vực nghiên cứu làm thế nào một hàm toán học có thể được phân tách thành một loạt các hàm lượng giác đơn giản hơn. Biến đổi Fourier là một công cụ từ trường này để phân tách một hàm thành tần số thành phần của nó.mathematical function can be decomposed into a series of simpler trigonometric functions. The Fourier transform is a tool from this field for decomposing a function into its component frequencies.

Được rồi, định nghĩa đó khá dày đặc. Đối với các mục đích của hướng dẫn này, biến đổi Fourier là một công cụ cho phép bạn lấy tín hiệu và xem sức mạnh của từng tần số trong đó. Hãy xem các thuật ngữ quan trọng trong câu đó:

  • Một tín hiệu là thông tin thay đổi theo thời gian. Ví dụ: dấu vết âm thanh, video và điện áp là tất cả các ví dụ về tín hiệu.signal is information that changes over time. For example, audio, video, and voltage traces are all examples of signals.
  • Tần số là tốc độ mà một cái gì đó lặp lại. Ví dụ, đồng hồ đánh dấu vào tần số của một hertz (Hz) hoặc một lần lặp lại mỗi giây.frequency is the speed at which something repeats. For example, clocks tick at a frequency of one hertz (Hz), or one repetition per second.
  • Sức mạnh, trong trường hợp này, chỉ có nghĩa là sức mạnh của mỗi tần số., in this case, just means the strength of each frequency.

Hình ảnh sau đây là một minh chứng trực quan về tần số và sức mạnh trên một số sóng hình sin:

Hướng dẫn fourier transform python - trăn biến hình fourier

Các đỉnh của sóng hình sin tần số cao gần nhau hơn so với các sóng hình sin tần số thấp vì chúng lặp lại thường xuyên hơn. Sóng sin công suất thấp có các đỉnh nhỏ hơn so với hai sóng hình sin còn lại.high-frequency sine wave are closer together than those of the low-frequency sine wave since they repeat more frequently. The low-power sine wave has smaller peaks than the other two sine waves.

Để làm cho cụ thể hơn này, hãy tưởng tượng bạn đã sử dụng biến đổi Fourier trên một bản ghi âm của ai đó chơi ba nốt trên cây đàn piano cùng một lúc. Phổ tần số kết quả sẽ hiển thị ba đỉnh, một cho mỗi ghi chú. Nếu người chơi một ghi chú nhẹ nhàng hơn những người khác, thì sức mạnh của tần số ghi chú đó sẽ thấp hơn hai ghi chú còn lại.frequency spectrum would show three peaks, one for each of the notes. If the person played one note more softly than the others, then the power of that note’s frequency would be lower than the other two.

Ở đây, những gì ví dụ piano đó trông giống như trực quan:

Hướng dẫn fourier transform python - trăn biến hình fourier

Ghi chú cao nhất trên piano được chơi yên tĩnh hơn hai nốt còn lại, do đó phổ tần số kết quả cho ghi chú đó có cực đại thấp hơn.

Tại sao bạn cần biến đổi Fourier?

Biến đổi Fourier là hữu ích trong nhiều ứng dụng. Ví dụ, Shazam và các dịch vụ nhận dạng âm nhạc khác sử dụng chuyển đổi Fourier để xác định các bài hát. Nén JPEG sử dụng một biến thể của biến đổi Fourier để loại bỏ các thành phần tần số cao của hình ảnh. Nhận dạng giọng nói sử dụng biến đổi Fourier và các biến đổi liên quan để khôi phục các từ được nói từ âm thanh thô.

Nói chung, bạn cần biến đổi Fourier nếu bạn cần nhìn vào tần số trong tín hiệu. Nếu làm việc với tín hiệu trong miền thời gian là khó khăn, thì việc sử dụng biến đổi Fourier để di chuyển nó vào miền tần số là đáng để thử. Trong phần tiếp theo, bạn sẽ xem xét sự khác biệt giữa các miền thời gian và tần số.

Miền thời gian so với miền tần số

Trong suốt phần còn lại của hướng dẫn, bạn sẽ thấy miền thời gian và miền tần số. Hai thuật ngữ này đề cập đến hai cách nhìn vào tín hiệu khác nhau, hoặc là tần số thành phần của nó hoặc là thông tin thay đổi theo thời gian.time domain and frequency domain. These two terms refer to two different ways of looking at a signal, either as its component frequencies or as information that varies over time.

Trong miền thời gian, tín hiệu là một sóng thay đổi biên độ (trục y) theo thời gian (trục x). Bạn rất có thể được sử dụng để nhìn thấy các biểu đồ trong miền thời gian, chẳng hạn như bản này:

Hướng dẫn fourier transform python - trăn biến hình fourier

Đây là hình ảnh của một số âm thanh, đó là tín hiệu miền thời gian. Trục ngang biểu thị thời gian và trục dọc biểu thị biên độ.time-domain signal. The horizontal axis represents time, and the vertical axis represents amplitude.

Trong miền tần số, một tín hiệu được biểu diễn dưới dạng một loạt các tần số (trục x) mà mỗi tần số có một công suất liên quan (trục y). Hình ảnh sau đây là tín hiệu âm thanh trên sau khi được chuyển đổi Fourier:

Hướng dẫn fourier transform python - trăn biến hình fourier

Ở đây, tín hiệu âm thanh từ trước được biểu thị bằng tần số cấu thành của nó. Mỗi tần số dọc theo phía dưới có một công suất liên quan, tạo ra phổ mà bạn nhìn thấy.

Để biết thêm thông tin về miền tần số, hãy xem mục Thuật ngữ Deepai.

Các loại biến đổi Fourier

Biến đổi Fourier có thể được chia thành các loại biến đổi khác nhau. Phân khu cơ bản nhất dựa trên loại dữ liệu mà biến đổi hoạt động trên: các hàm liên tục hoặc các hàm riêng biệt. Hướng dẫn này sẽ chỉ đối phó với Biến đổi Fourier rời rạc (DFT).discrete Fourier transform (DFT).

Bạn thường thấy các thuật ngữ DFT và FFT được sử dụng thay thế cho nhau, ngay cả trong hướng dẫn này. Tuy nhiên, họ không phải là điều tương tự. Biến đổi Fourier nhanh (FFT) là một thuật toán để tính toán biến đổi Fourier rời rạc (DFT), trong khi DFT là chính biến đổi.fast Fourier transform (FFT) is an algorithm for computing the discrete Fourier transform (DFT), whereas the DFT is the transform itself.

Một điểm khác biệt khác mà bạn sẽ thấy được thực hiện trong thư viện

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 là giữa các loại đầu vào khác nhau.
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
3 chấp nhận đầu vào có giá trị phức tạp và
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4 chấp nhận đầu vào có giá trị thực. Bỏ qua phía trước đến phần bằng cách sử dụng biến đổi Fourier nhanh (FFT) để giải thích về các số phức tạp và thực.

Hai biến đổi khác có liên quan chặt chẽ với DFT: biến đổi cosin rời rạc (DCT) và biến đổi hình sin rời rạc (DST). Bạn sẽ tìm hiểu về những người trong phần biến đổi cosin và hình sin rời rạc.discrete cosine transform (DCT) and the discrete sine transform (DST). You’ll learn about those in the section The Discrete Cosine and Sine Transforms.

Ví dụ thực tế: loại bỏ tiếng ồn không mong muốn khỏi âm thanh

Để giúp xây dựng sự hiểu biết của bạn về biến đổi Fourier và những gì bạn có thể làm với nó, bạn sẽ lọc một số âm thanh. Đầu tiên, bạn sẽ tạo một tín hiệu âm thanh với tiếng vang cao trong đó, và sau đó bạn sẽ loại bỏ tiếng vang bằng cách sử dụng biến đổi Fourier.

Tạo tín hiệu

Sóng sin đôi khi được gọi là âm thuần vì chúng đại diện cho một tần số duy nhất. Bạn sẽ sử dụng sóng hình sin để tạo âm thanh vì chúng sẽ tạo thành các đỉnh riêng biệt trong phổ tần số kết quả.pure tones because they represent a single frequency. You’ll use sine waves to generate the audio since they will form distinct peaks in the resulting frequency spectrum.

Một điều tuyệt vời khác về sóng hình sin là chúng rất đơn giản để tạo ra sự vô dụng. Nếu bạn đã sử dụng Numpy trước đây, thì bạn có thể kiểm tra điều gì là Numpy?

Ở đây, một số mã tạo ra sóng hình sin:

import numpy as np
from matplotlib import pyplot as plt

SAMPLE_RATE = 44100  # Hertz
DURATION = 5  # Seconds

def generate_sine_wave(freq, sample_rate, duration):
    x = np.linspace(0, duration, sample_rate * duration, endpoint=False)
    frequencies = x * freq
    # 2pi because np.sin takes radians
    y = np.sin((2 * np.pi) * frequencies)
    return x, y

# Generate a 2 hertz sine wave that lasts for 5 seconds
x, y = generate_sine_wave(2, SAMPLE_RATE, DURATION)
plt.plot(x, y)
plt.show()

Sau khi bạn nhập Numpy và Matplotlib, bạn xác định hai hằng số:

  1. normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)
    
    plt.plot(normalized_tone[:1000])
    plt.show()
    
    5 xác định số lượng điểm dữ liệu mà tín hiệu sử dụng để biểu thị sóng hình sin mỗi giây. Vì vậy, nếu tín hiệu có tốc độ mẫu là 10 Hz và là sóng hình sin năm giây, thì nó sẽ có các điểm dữ liệu
    normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)
    
    plt.plot(normalized_tone[:1000])
    plt.show()
    
    6.
    determines how many data points the signal uses to represent the sine wave per second. So if the signal had a sample rate of 10 Hz and was a five-second sine wave, then it would have
    normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)
    
    plt.plot(normalized_tone[:1000])
    plt.show()
    
    6 data points.
  2. normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)
    
    plt.plot(normalized_tone[:1000])
    plt.show()
    
    7 là chiều dài của mẫu được tạo.
    is the length of the generated sample.

Tiếp theo, bạn xác định một hàm để tạo sóng hình sin vì bạn sẽ sử dụng nó nhiều lần sau đó. Hàm có tần số,

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
8 và sau đó trả về các giá trị
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
9 và
from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
0 mà bạn sẽ sử dụng để vẽ sóng.

Tốc độ X của sóng hình sin cách đều nhau giữa

from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
1 và
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
7, do đó, mã sử dụng Numpy tựa
from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
3 để tạo ra chúng. Nó có giá trị bắt đầu, giá trị cuối và số lượng mẫu để tạo. Cài đặt
from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
4 rất quan trọng đối với phép biến đổi Fourier hoạt động đúng vì nó giả định tín hiệu là định kỳ.

from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
5 tính toán các giá trị của hàm sin tại mỗi tọa độ X. Kết quả được nhân với tần số để tạo sóng sin dao động ở tần số đó và sản phẩm được nhân với 2π để chuyển đổi các giá trị đầu vào thành radian.

Sau khi bạn xác định chức năng, bạn sử dụng nó để tạo sóng hình sin hai hertz kéo dài năm giây và vẽ nó bằng matplotlib. Cốt truyện sóng hình sin của bạn sẽ trông giống như thế này:

Hướng dẫn fourier transform python - trăn biến hình fourier

Trục X biểu thị thời gian tính bằng giây và vì có hai đỉnh cho mỗi giây, bạn có thể thấy rằng sóng hình sin dao động hai lần mỗi giây. Sóng sin này quá thấp một tần số để có thể nghe được, vì vậy trong phần tiếp theo, bạn sẽ tạo ra một số sóng hình sin tần số cao hơn và bạn sẽ thấy cách trộn chúng.

Trộn tín hiệu âm thanh

Tin tốt là sự pha trộn tín hiệu âm thanh chỉ bao gồm hai bước:

  1. Thêm các tín hiệu cùng nhau
  2. Bình thường hóa kết quả the result

Trước khi bạn có thể trộn các tín hiệu với nhau, bạn cần tạo chúng:

_, nice_tone = generate_sine_wave(400, SAMPLE_RATE, DURATION)
_, noise_tone = generate_sine_wave(4000, SAMPLE_RATE, DURATION)
noise_tone = noise_tone * 0.3

mixed_tone = nice_tone + noise_tone

Không có gì mới trong ví dụ mã này. Nó tạo ra một giai điệu trung bình và một âm cao được gán cho các biến

from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
6 và
from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
7, tương ứng. Bạn sẽ sử dụng âm cao tốc độ làm nhiễu không mong muốn của bạn, vì vậy nó được nhân với
from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
8 để giảm sức mạnh của nó. Mã sau đó thêm các âm này lại với nhau. Lưu ý rằng bạn sử dụng dấu gạch dưới (
from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
9) để loại bỏ các giá trị
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
9 được trả về bởi
from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
1.

Bước tiếp theo là bình thường hóa hoặc chia tỷ lệ tín hiệu để phù hợp với định dạng đích. Do cách bạn lưu trữ âm thanh sau, định dạng mục tiêu của bạn là số nguyên 16 bit, có phạm vi từ -32768 đến 32767:normalization, or scaling the signal to fit into the target format. Due to how you’ll store the audio later, your target format is a 16-bit integer, which has a range from -32768 to 32767:

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()

Ở đây, mã quy mô

from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
2 để làm cho nó vừa khít với số nguyên 16 bit và sau đó chuyển nó vào loại dữ liệu đó bằng cách sử dụng Numpy tựa
from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
3. Chia
from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
2 cho giá trị tối đa của nó mở rộng nó thành giữa
from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
5 và
from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
6. Khi tín hiệu này được nhân với
from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
7, nó được chia tỷ lệ giữa
from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
8 và
from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
7, gần như là phạm vi của
from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()
3. Mã chỉ vẽ các mẫu
yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
1 đầu tiên để bạn có thể thấy cấu trúc của tín hiệu rõ ràng hơn.

Cốt truyện của bạn sẽ trông giống như thế này:

Hướng dẫn fourier transform python - trăn biến hình fourier

Tín hiệu trông giống như một sóng hình sin bị biến dạng. Làn sóng hình sin bạn thấy là âm 400 Hz bạn đã tạo và độ méo là âm 4000 Hz. Nếu bạn nhìn kỹ, thì bạn có thể thấy độ méo có hình dạng của sóng hình sin.

Để nghe âm thanh, bạn cần lưu trữ nó theo định dạng mà trình phát âm thanh có thể đọc. Cách dễ nhất để làm điều đó là sử dụng phương thức SCIPY WAVFILE.WRITE để lưu trữ nó trong tệp WAV. Số nguyên 16 bit là một loại dữ liệu tiêu chuẩn cho các tệp WAV, vì vậy bạn sẽ bình thường hóa tín hiệu của mình thành số nguyên 16 bit:

from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)

Mã này sẽ ghi vào một tệp

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
2 trong thư mục nơi bạn chạy tập lệnh Python của mình. Sau đó, bạn có thể nghe tệp này bằng bất kỳ trình phát âm thanh hoặc thậm chí với Python. Bạn có thể nghe thấy một giai điệu thấp hơn và giai điệu cao hơn. Đây là những sóng hình sin 400 Hz và 4000 Hz mà bạn đã trộn.

Khi bạn đã hoàn thành bước này, bạn đã sẵn sàng mẫu âm thanh của mình. Bước tiếp theo là loại bỏ giai điệu cao cấp bằng cách sử dụng biến đổi Fourier!

Sử dụng Fast Fourier Transform (FFT)

Đó là thời gian để sử dụng FFT trên âm thanh được tạo của bạn. FFT là một thuật toán thực hiện biến đổi Fourier và có thể tính toán phổ tần số cho tín hiệu trong miền thời gian, như âm thanh của bạn:

from scipy.fft import fft, fftfreq

# Number of samples in normalized_tone
N = SAMPLE_RATE * DURATION

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

plt.plot(xf, np.abs(yf))
plt.show()

Mã này sẽ tính toán biến đổi Fourier của âm thanh được tạo và vẽ nó. Trước khi phá vỡ nó, hãy xem cốt truyện mà nó tạo ra:

Hướng dẫn fourier transform python - trăn biến hình fourier

Bạn có thể thấy hai đỉnh trong tần số dương và gương của các đỉnh đó theo tần số âm. Các đỉnh tần số tích cực ở mức 400 Hz và 4000 Hz, tương ứng với các tần số mà bạn đưa vào âm thanh.

Biến đổi Fourier đã lấy tín hiệu phức tạp, phức tạp của bạn và biến nó thành các tần số mà nó chứa. Vì bạn chỉ đặt hai tần số, chỉ có hai tần số xuất hiện. Đối xứng dương tính tiêu cực là một tác dụng phụ của việc đưa đầu vào có giá trị thực vào biến đổi Fourier, nhưng bạn sẽ nghe nhiều hơn về điều đó sau.real-valued input into the Fourier transform, but you’ll hear more about that later.

Trong một vài dòng đầu tiên, bạn nhập các chức năng từ

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 mà bạn sẽ sử dụng sau và xác định một biến,
yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
4, lưu trữ tổng số mẫu trong tín hiệu.

Sau đó là phần quan trọng nhất, tính toán biến đổi Fourier:

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

Mã gọi hai chức năng rất quan trọng:

  1. normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)
    
    plt.plot(normalized_tone[:1000])
    plt.show()
    
    3 Tính toán biến đổi. calculates the transform itself.

  2. yf = fft(normalized_tone)
    xf = fftfreq(N, 1 / SAMPLE_RATE)
    
    6 Tính toán tần số ở trung tâm của mỗi thùng trong đầu ra của
    normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)
    
    plt.plot(normalized_tone[:1000])
    plt.show()
    
    3. Nếu không có điều này, sẽ không có cách nào để vẽ trục x trên phổ tần số của bạn.
    calculates the frequencies in the center of each bin in the output of
    normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)
    
    plt.plot(normalized_tone[:1000])
    plt.show()
    
    3. Without this, there would be no way to plot the x-axis on your frequency spectrum.

Một thùng là một loạt các giá trị đã được nhóm lại, giống như trong một biểu đồ. Để biết thêm thông tin về các thùng, hãy xem câu hỏi trao đổi ngăn xếp xử lý tín hiệu này. Đối với các mục đích của hướng dẫn này, bạn có thể nghĩ về chúng chỉ là các giá trị đơn lẻ.bin is a range of values that have been grouped, like in a histogram. For more information on bins, see this Signal Processing Stack Exchange question. For the purposes of this tutorial, you can think of them as just single values.

Khi bạn có các giá trị kết quả từ biến đổi Fourier và tần số tương ứng của chúng, bạn có thể vẽ chúng:

plt.plot(xf, np.abs(yf))
plt.show()

Phần thú vị của mã này là việc xử lý bạn làm cho

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
8 trước khi vẽ nó. Bạn gọi
yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
9 trên
yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
8 vì các giá trị của nó rất phức tạp.complex.

Một số phức là một số có hai phần, một phần thực và một phần tưởng tượng. Có nhiều lý do tại sao nó rất hữu ích để xác định các số như thế này, nhưng tất cả những gì bạn cần biết ngay bây giờ là chúng tồn tại.complex number is a number that has two parts, a real part and an imaginary part. There are many reasons why it’s useful to define numbers like this, but all you need to know right now is that they exist.

Các nhà toán học thường viết các số phức tạp trong mẫu A + BI, trong đó A là phần thực và B là phần tưởng tượng. I After B có nghĩa là B là một số tưởng tượng.

Để biết thêm về những con số phức tạp, hãy xem khóa học Khan Academy hoặc Toán học là trang thú vị.

Vì các số phức có hai phần, việc vẽ đồ thị theo tần số trên trục hai chiều đòi hỏi bạn phải tính toán một giá trị duy nhất từ ​​chúng. Đây là nơi

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
9 xuất hiện. Nó tính toán √ (a² + b²) cho các số phức, đây là cường độ tổng thể cho hai số lại với nhau và quan trọng là một giá trị duy nhất.

Làm cho nó nhanh hơn với normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767) plt.plot(normalized_tone[:1000]) plt.show() 4

Phổ tần số mà

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
3 xuất ra đã được phản ánh về trục y sao cho nửa âm là một gương của nửa dương. Sự đối xứng này được gây ra bởi việc nhập các số thực (không phải là số phức tạp) cho biến đổi.real numbers (not complex numbers) to the transform.

Bạn có thể sử dụng tính đối xứng này để làm cho Fourier biến đổi của bạn nhanh hơn bằng cách chỉ tính một nửa của nó.

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 thực hiện hack tốc độ này dưới dạng
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4.

Điều tuyệt vời về

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4 là nó là một sự thay thế thả vào cho
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
3. Hãy nhớ mã FFT từ trước:

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)

Trao đổi trong

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4, mã vẫn giống nhau, chỉ với một vài thay đổi chính:

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
0

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4 chỉ trả về một nửa đầu ra mà
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
3 làm, nó sử dụng một chức năng khác để có được ánh xạ tần số,
yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
1 thay vì
yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
6.

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4 vẫn tạo ra đầu ra phức tạp, vì vậy mã để vẽ kết quả của nó vẫn giữ nguyên. Tuy nhiên, cốt truyện sẽ trông giống như sau vì các tần số âm sẽ biến mất:

Hướng dẫn fourier transform python - trăn biến hình fourier

Bạn có thể thấy rằng hình ảnh trên chỉ là mặt tích cực của phổ tần số mà

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
3 tạo ra.
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4 không bao giờ tính toán một nửa âm của phổ tần số, giúp nó nhanh hơn so với sử dụng
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
3.

Sử dụng

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4 có thể nhanh tới gấp đôi so với sử dụng
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
3, nhưng một số độ dài đầu vào nhanh hơn các chiều khác. Nếu bạn biết bạn sẽ chỉ làm việc với các số thực, thì đó là một hack tốc độ đáng để biết.

Bây giờ bạn có phổ tần số của tín hiệu, bạn có thể chuyển sang lọc nó.

Lọc tín hiệu

Một điều tuyệt vời về biến đổi Fourier là nó có thể đảo ngược, do đó, bất kỳ thay đổi nào bạn thực hiện đối với tín hiệu trong miền tần số sẽ được áp dụng khi bạn chuyển đổi nó trở lại miền thời gian. Bạn sẽ tận dụng điều này để lọc âm thanh của mình và thoát khỏi tần số cao.

Các giá trị được trả về bởi

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4 đại diện cho công suất của mỗi thùng tần số. Nếu bạn đặt công suất của một thùng đã cho thành 0, thì các tần số trong thùng đó sẽ không còn có trong tín hiệu miền thời gian kết quả.

Sử dụng độ dài

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
00, tần số tối đa và thực tế là các thùng tần số được đặt cách đều nhau, bạn có thể xử lý chỉ số tần số đích của mục tiêu:

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
1

Sau đó, bạn có thể đặt

yf = fft(normalized_tone)
xf = fftfreq(N, 1 / SAMPLE_RATE)
8 thành
from scipy.io.wavfile import write

# Remember SAMPLE_RATE = 44100 Hz is our playback rate
write("mysinewave.wav", SAMPLE_RATE, normalized_tone)
1 tại các chỉ số xung quanh tần số mục tiêu để loại bỏ nó:

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
2

Mã của bạn sẽ tạo ra cốt truyện sau:

Hướng dẫn fourier transform python - trăn biến hình fourier

Vì chỉ có một đỉnh cao, có vẻ như nó đã hoạt động! Tiếp theo, bạn sẽ áp dụng biến đổi Fourier nghịch đảo để quay lại miền thời gian.

Áp dụng FFT nghịch đảo

Áp dụng FFT nghịch đảo tương tự như áp dụng FFT:

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
3

Vì bạn đang sử dụng

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4, bạn cần sử dụng
>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
04 để áp dụng nghịch đảo. Tuy nhiên, nếu bạn đã sử dụng
normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
3, thì hàm nghịch đảo sẽ là
>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
06. Cốt truyện của bạn bây giờ sẽ trông như thế này:

Hướng dẫn fourier transform python - trăn biến hình fourier

Như bạn có thể thấy, bây giờ bạn có một sóng hình sin dao động ở mức 400 Hz và bạn đã loại bỏ thành công nhiễu 4000 Hz.

Một lần nữa, bạn cần bình thường hóa tín hiệu trước khi ghi nó vào một tệp. Bạn có thể làm điều đó giống như lần trước:

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
4

Khi bạn nghe tập tin này, bạn sẽ nghe thấy tiếng ồn khó chịu đã biến mất!

Tránh những cạm bẫy lọc

Ví dụ trên là nhiều cho mục đích giáo dục hơn là sử dụng trong thế giới thực. Việc sao chép quá trình trên một tín hiệu trong thế giới thực, chẳng hạn như một bản nhạc, có thể giới thiệu nhiều tiếng vang hơn là loại bỏ.

Trong thế giới thực, bạn nên lọc tín hiệu bằng cách sử dụng các chức năng thiết kế bộ lọc trong gói

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
07. Lọc là một chủ đề phức tạp liên quan đến rất nhiều toán học. Để giới thiệu tốt, hãy xem hướng dẫn của nhà khoa học và kỹ sư về xử lý tín hiệu số.

Các biến đổi cosin và hình sin rời rạc

Một hướng dẫn về mô -đun

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 sẽ hoàn thành mà không cần nhìn vào biến đổi cosin rời rạc (DCT) và biến đổi hình sin rời rạc (DST). Hai biến đổi này có liên quan chặt chẽ với biến đổi Fourier nhưng hoạt động hoàn toàn trên các số thực. Điều đó có nghĩa là chúng lấy một hàm có giá trị thực như một đầu vào và tạo ra một hàm có giá trị thực khác như một đầu ra.

SCIPY thực hiện các biến đổi này là

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
09 và
>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
10. Các biến thể
>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
11 và
>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
12 là các phiên bản nghịch đảo và N chiều của các hàm, tương ứng.

DCT và DST giống như hai nửa cùng nhau tạo nên biến đổi Fourier. Điều này khá đúng vì toán học phức tạp hơn rất nhiều, nhưng nó là một mô hình tinh thần hữu ích.

Vì vậy, nếu DCT và DST giống như một nửa của một biến đổi Fourier, thì tại sao chúng lại hữu ích?

Đối với một điều, họ nhanh hơn một phép biến đổi Fourier đầy đủ vì họ thực hiện một nửa công việc. Chúng có thể thậm chí còn nhanh hơn

normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)

plt.plot(normalized_tone[:1000])
plt.show()
4. Trên hết, họ làm việc hoàn toàn với số thực, vì vậy bạn không bao giờ phải lo lắng về những con số phức tạp.

Trước khi bạn có thể học cách lựa chọn giữa chúng, bạn cần hiểu các chức năng chẵn và lẻ. Ngay cả các hàm cũng đối xứng về trục y, trong khi các hàm lẻ là đối xứng về nguồn gốc. Để tưởng tượng điều này một cách trực quan, hãy xem các sơ đồ sau:Even functions are symmetrical about the y-axis, whereas odd functions are symmetrical about the origin. To imagine this visually, take a look at the following diagrams:

Hướng dẫn fourier transform python - trăn biến hình fourier

Bạn có thể thấy rằng hàm chẵn đối xứng về trục y. Hàm lẻ là đối xứng về y = -x, được mô tả là đối xứng về nguồn gốc.symmetrical about the origin.

Khi bạn tính toán một phép biến đổi Fourier, bạn giả vờ rằng chức năng mà bạn tính toán nó là vô hạn. Biến đổi Fourier đầy đủ (DFT) giả định hàm đầu vào lặp lại vô hạn. Tuy nhiên, DCT và DST giả định hàm được mở rộng thông qua đối xứng. DCT giả định hàm được mở rộng với tính đối xứng thậm chí và DST giả định rằng nó mở rộng với đối xứng lẻ.

Hình ảnh sau đây minh họa cách mỗi biến đổi tưởng tượng chức năng mở rộng đến vô cùng:

Hướng dẫn fourier transform python - trăn biến hình fourier

Trong hình trên, DFT lặp lại hàm như là. DCT phản ánh hàm theo chiều dọc để mở rộng nó và DST phản ánh nó theo chiều ngang.

Lưu ý rằng sự đối xứng được ngụ ý bởi DST dẫn đến các bước nhảy lớn trong chức năng. Chúng được gọi là sự không liên tục và tạo ra các thành phần tần số cao hơn trong phổ tần số kết quả. Vì vậy, trừ khi bạn biết dữ liệu của bạn có tính đối xứng kỳ lạ, bạn nên sử dụng DCT thay vì DST.discontinuities and produce more high-frequency components in the resulting frequency spectrum. So unless you know your data has odd symmetry, you should use the DCT instead of the DST.

DCT được sử dụng rất phổ biến. Có nhiều ví dụ hơn, nhưng các tiêu chuẩn JPEG, MP3 và Webm đều sử dụng DCT.

Sự kết luận

Biến đổi Fourier là một khái niệm mạnh mẽ mà sử dụng trong nhiều lĩnh vực khác nhau, từ toán học thuần túy đến kỹ thuật âm thanh và thậm chí là tài chính. Bây giờ bạn đã quen thuộc với biến đổi Fourier rời rạc và được trang bị tốt để áp dụng nó để lọc các vấn đề bằng cách sử dụng mô -đun

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5.discrete Fourier transform and are well equipped to apply it to filtering problems using the
>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 module.

Trong hướng dẫn này, bạn đã học được:

  • Làm thế nào và khi nào để sử dụng biến đổi FourierFourier transform
  • Cách chọn chức năng chính xác từ
    >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5 cho trường hợp sử dụng của bạn
    >>> import scipy, matplotlib
    >>> print(scipy.__file__)
    /usr/local/lib/python3.6/dist-packages/scipy/__init__.py
    >>> print(matplotlib.__file__)
    /usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
    
    5
    for your use case
  • Sự khác biệt là gì giữa miền thời gian và miền tần sốtime domain and the frequency domain
  • Cách xem và sửa đổi phổ tần số của tín hiệufrequency spectrum of a signal
  • Làm thế nào sử dụng
    normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)
    
    plt.plot(normalized_tone[:1000])
    plt.show()
    
    4 có thể tăng tốc mã của bạn
    normalized_tone = np.int16((mixed_tone / mixed_tone.max()) * 32767)
    
    plt.plot(normalized_tone[:1000])
    plt.show()
    
    4
    can speed up your code

Trong phần cuối cùng, bạn cũng đã tìm hiểu về biến đổi cosin rời rạc và biến đổi hình sin rời rạc. Bạn đã thấy những chức năng để gọi để sử dụng chúng và bạn đã học khi sử dụng cái này hơn cái kia.discrete cosine transform and the discrete sine transform. You saw what functions to call to use them, and you learned when to use one over the other.

Nếu bạn thích một bản tóm tắt của hướng dẫn này, thì bạn có thể tải xuống bảng cheat bên dưới. Nó có những giải thích về tất cả các chức năng trong mô -đun

>>> import scipy, matplotlib
>>> print(scipy.__file__)
/usr/local/lib/python3.6/dist-packages/scipy/__init__.py
>>> print(matplotlib.__file__)
/usr/local/lib/python3.6/dist-packages/matplotlib/__init__.py
5 cũng như sự cố của các loại biến đổi khác nhau có sẵn:

Tiếp tục khám phá chủ đề hấp dẫn này và thử nghiệm các biến đổi, và chắc chắn chia sẻ những khám phá của bạn trong các ý kiến ​​dưới đây!