Scipy Fft

Både numpy og scipy i Python har mange FFT -rutiner (fra grunnleggende til kompleks). Scipy FFT -konseptet vil bli undersøkt grundig i dette innlegget. Vi vil også utforske hvordan du bruker det i praksis. Vi forklarer hva Scipy FFT -funksjonene er og gir deg noen få programmeringseksempler for å komme i gang. Scipy.fft (), scipy.fft rfft (), scipy.FFT Shift (), FftFreq () og FFTConvolve () Metoder vil alle bli dekket i detalj sammen med eksempler i denne artikkelen. Eksemplene er gitt for å avklare emnet for deg, slik at du med letthet kan utføre det i praksis.

Python Scipy FFT -forklaring

Fourier -analysemetoden definerer utelukkende en funksjon som total av periodiske komponenter og henter signalet som er dekket av Python Scipy -modulen kalt Scipy.fft. Funksjonen og dens Fourier Transform (FT) erstattes begge med diskretiserte ekvivalenter for å produsere den diskrete Fourier -transformasjonen.

Ved hjelp av en tidsbasert sekvens er Fourier-transformasjonen, ganske enkelt kalt Fourier, en matematisk funksjon som bestemmer den totale rotasjonshastigheten, dens styrke og syklusforskyvningen for den potensielle syklusen for hvert mønster. Bølgeformer, den primære operasjonene av tid, rom eller annen variabel kan lett transformeres ved hjelp av Fourier -transformasjonen.

Vi vil studere den mest populære Fourier -transformasjonsmetoden med eksempler i følgende underavsnitt.

Eksempel 1:

Vi starter med å beskrive scipy.FFT () -metode ved hjelp av følgende kodestykke. I dette eksemplet kan vi se at scipy.FFT () -metode kan beregne den raske Fourier -transformasjonen ved å motta en rekke verdier og returnere resultatet. Se på hver linje i koden.

Her, i koden, kan du se at de to modulene, Scipy og Numpy, importeres først. Etter det opprettes det en variabel som heter "input_val" er opprettet der en numpy.Array () -metode brukes til å produsere et rutenett med verdier. Etter det kan en annen variabel som heter “res_val” sees der Scipy.FFT -metode brukes der den opprettet “input_val” sendes. Til slutt blir resultatet gitt.

Importer scipy
Importer numpy
input_val = numpy.Array (Numpy.Arange (8))
res_val = scipy.fft (input_val)
print (res_val)

Her er utgangen vedlagt for din referanse:

Eksempel 2:

La oss diskutere Pythons Scipy FFT RFFT -funksjon. Den diskrete Fourier -transformasjonen i en dimensjon av den spesifiserte reelle inngangen beregnes av RFFT () Scipy -modulen til Python -programmeringsspråket.

Utgangen fra RFFT -metoden er av NdArray -typen. Den endelige inngangen hvis aksen ikke er spesifisert, eller inngangen som har blitt null-padded eller avkortet og transformert langs aksen levert av aksen.

La oss ta programmet som et eksempel ved å utføre følgende kode. Prøv å forstå kodeprogrammet fullstendig.

I første linje importeres RFFT -metoden fra scipy.FFT -modul. Etter det blir RFFT -metoden brukt på de opprettede arrayverdiene. Verdiene er 2,4,6 og 8. Resultatet av FFT -metoden lagres i den opprettede variabelen som heter “Magnum”. Til slutt brukes "Print (Magnum)" -uttalelsen for å vise resultatet.

Fra scipy.FFT Import RFFT
magnum = rfft ([2, 4, 6, 8])
trykk (magnum)

Dette er den rette måten å bruke Python Scipy -metoden rfft () og hvordan du beregner den diskrete Fourier -transformasjonen.

Følgende er utgangen som genereres fra forrige kode for din hjelp:

Eksempel 3:

Det tredje eksemplet på denne artikkelen inneholder detaljene om Python Scipy FFT -skift. FFTShift () -metoden produserer y av NdArray -typen. Her er y den forskjøvede matrisen.

La oss vurdere dette eksemplet.

Til å begynne med kan du se at vi importerer de nødvendige bibliotekene. Koden for å gjøre dette er “fra Scipy.FFT Import Fftshift, FFTFREQ ”som du ser i starten av koden som er vedlagt i det følgende. Etter det beregner vi frekvensene ved å bruke den andre linjen i koden. Nå gir vi frekvensene til en metode for fftshift () ved å bruke "res = fftshift (frekvenser)" -kode. Endelig brukes trykket (res) til å vise resultatet for leserne.

Fra scipy.FFT import Fftshift, Fftfreq
frequncies = fftfreq (7,4)
res = fftshift (frequncies)
trykk (res)

Vedlagt er det resulterende skjermbildet. Dette er den beste måten å skifte nullfrekvenskomponenten i spekteret til midtpunktet. Det forskyves i de definerte frekvensene ved å bruke FFTShift () -metoden:

Eksempel 4:

Frekvensen av prøvene styres av Scipy Scipy.FFT -modul. Frekvensbindesentrene blir returnert av "F" -flytesarrayen. Det er i sykluser per enhet. FFTFREQ () -metoden returnerer et Ndarary -objekt med F -verdien.

Følgende er et annet eksempelprogram for å forstå konseptet bedre.

Først importerer vi de nødvendige bibliotekene ved å bruke importuttalelsen. Som sett i følgende kode produserer den et signal og Fourier transformerer det.

Vi importerer de nødvendige bibliotekene (Numpy, FFT og FFTREQ) ved hjelp av importuttalelsene. Etter det lager vi et signal. Det blir deretter transformert ved hjelp av Fourier som vist i følgende kode. Etter det beregner vi prøvefrekvensene og forhåndsdefinerer tiden som "time_st = 0.1". Dette er den anbefalte måten å bruke FFTFREQ () -metoden tilgjengelig i Python Scipy.

Importer numpy
Fra scipy.FFT import FFT
Fra scipy.FFT import Fftfreq
create_sig = numpy.Array ([3, -4, 5, 0, 2, 5, 8, 10], dtype = float)
FT_VAL = FFT (CATED_SIG)
Data_Val = CreateT_SIG.størrelse
time_st = 0.1
freq = fftfreq (data_val, d = time_st)
trykk (freq)

Her er resultatet:

Eksempel 5:

FFT brukes av Scipy's FFTConvolve () -metode i Scipy.Signalmodul for å konvolusjon N-dimensjonale matriser (rask Fourier-transformasjon). Følgende prøveprogrammeringskode demonstrerer FFTConvolve () -ideen. Se følgende vedlagte kode.

Koden ligner veldig på de forrige prøvekodene, bortsett fra at vi brukte FFTConvolve () -metoden her og bestemte støy- og autokorrelasjonsnivåene.

Kjør denne prøvekoden (se følgende vedlagte bilde) og forstå hvordan du bruker FFTConvolve () -metoden for å konvolvere en N-dimensjonal matrise:

Fra scipy.Signalimport fftconvolve
Importer scipy.signal
Importer numpy
Importer matplotlib.Pyplot som Plt
Sig1 = numpy.tilfeldig.standard_rng ()
res = sig1.Standard_normal (500)
AutoCorrelation = FftConvolve (Res, Res [::-1], Mode = 'Full')
fig, (orig_axes, mag_axes) = plt.underplaner (2, 1)
Orig_axes.plot (res)
Orig_axes.set_title ('støy')
MAG_AXES.Plott (Numpy.Arange (-Len (Res)+1, Len (Res)), autokorrelasjon)
MAG_AXES.set_title ('autokorrelasjon')
Fig.tight_layout ()
Fig.forestilling()

Se følgende utgang. Denne utgangen genereres fra forrige kode. Den første grafen viser støyen og den andre grafen viser autokorrelasjonen:

Konklusjon

Scipy FFT er temaet for diskusjon i dette innlegget. For å oppsummere, sendes den enkle 1-D numpy matrisen til scipy.FFT () -metode som beregner den raske Fourier -transformasjonen og returnerer den transformerte matrisen. Vi har forskjellige teknikker inkludert Scipy FFT () Shift (), FftFreq () og FFTConvolve (). Programmeringsprøvene og detaljerte diskusjoner om hver av disse teknikkene er gitt. For ytterligere å forstå det nevnte emnet, se kodene som er gitt i denne artikkelen.