Scipy trova picchi

Il linguaggio di programmazione Python è un linguaggio di programmazione di alto livello che offre una vasta gamma di funzioni utili per tutti i tipi di calcoli matematici, statistici e scientifici. Possiamo svolgere qualsiasi funzione semplice e complessa utilizzando le funzioni e i metodi delle librerie Python. Questa guida si occupa della funzione Scipy find_peaks () per l'analisi dell'elaborazione del segnale. Più specificamente, questa guida si concentra su come calcolare e identificare i picchi incorporati in un segnale.

Cos'è Scipy trova picchi?

La libreria Scipy offre una funzione find_peaks () da utilizzare per trovare i massimi, i minimi o il picco di un segnale. La funzione find_peaks () viene utilizzata con i segnali per analizzarli. Viene utilizzato per trovare il picco, i minimi o i massimi del segnale di una funzione matematica. Trova i picchi all'interno dei segnali indicati in base alle proprietà di picco. Confrontando i valori dei valori vicini, questa funzione Scipy analizza i dati sotto forma di un array unidimensionale per identificare tutti i massimi locali. Comprendiamo la sintassi della funzione find_peaks () e quindi passiamo alla sezione Esempio per apprendere come funziona la funzione Find_peaks () in un programma Python.

Sintassi di Scipy Trova i picchi funzione

Stiamo per sfruttare la funzione find_peaks () fornita dalla libreria Scipy e dal suo pacchetto di segnale. Come abbiamo discusso in precedenza, la funzione find_peaks () viene utilizzata per elaborare un segnale specifico per estrarre l'intensità o la posizione di più picchi di segnale. Vedere la sintassi della seguente funzione:

Il parametro "picco" viene utilizzato per definire il segnale con picchi. Il parametro "altezza" viene utilizzato per definire l'altezza dei picchi. Il parametro "soglia" è un ndarray o solo un numero che definisce la soglia dei picchi. Il parametro "distanza" viene utilizzato per definire la distanza orizzontale minima tra i picchi vicini. Il parametro "prominenza" viene utilizzato per definire la prominenza dei picchi. Il parametro "larghezza" definisce la larghezza dei picchi. Il parametro "Wlen" viene utilizzato per calcolare le prominenze del picco. Il parametro "rel_height" viene utilizzato per calcolare la larghezza dei picchi. Infine, il parametro "Plateau_Size" viene utilizzato per definire la parte superiore piatta dei picchi. La funzione find_peaks () restituisce un ndarray che contiene tutti gli indici di picco che soddisfano le condizioni indicate insieme alle loro proprietà. Ora, esploriamo alcuni utili esempi di programmazione per imparare a implementare la funzione find_peaks.

Esempio 1:

Dall'economia alle scienze dei dati all'elettronica, lavorare con i picchi dei segnali ha un significato fondamentale in tutti i campi di spicco. Come precedentemente discusso, il picco di scoperta non riguarda solo la ricerca del picco di un segnale elettronico ma i minimi o i massimi di qualsiasi funzione matematica. Dal momento che sappiamo l'importanza di avere una funzione affidabile e rapida che ci aiuta a trovare il valore e la posizione dei minimi e dei massimi, usiamo la funzione find_peaks () per il calcolo automatico e veloce. Considera il programma di esempio nel seguente frammento di codice:

Importa Numpy come NP
Importa matplotlib.Pyplot come Plt
da Scipy.Signal Import Find_peaks
#****** Dichiarazione di dati ******
x = np.Linspace (0, 100, 200)
y = x*np.casuale.Randn (200) ** 2
#****** Peak trova ******
Peaks = find_peaks (y, altezza = 2, soglia = 2, distanza = 2)
H = Peaks [1] ['Peak_heights']
pp = x [picchi [0]]
#****** MIMINA Trovare ******
y2 = y*-2
Minima = find_peaks (y2)
min_pos = x [minima [0]]
min_height = y2 [minima [0]]
#****** Ploting dei dati ******
Plt.Trama (x, y)
Plt.SPIREST (pp, h, color = 'r', etichetta = 'maxima')
Plt.SPIREST (MIN_POPS, MIN_HEIGHT*-1, etichetta = 'minima')
Plt.leggenda()
Plt.griglia()
Plt.spettacolo()

Tre librerie vengono importate nel programma: Numpy, Scipy e Matplotlib. La biblioteca numpy viene utilizzata per dichiarare gli array numpy. La libreria Scipy viene utilizzata per chiamare la funzione find_peaks (). E la libreria matplotlib viene utilizzata per tracciare il grafico.

Come puoi vedere, abbiamo raggruppato le righe del codice in base alla funzione che stanno eseguendo. Innanzitutto, abbiamo la sezione "Dichiarazione dei dati" in cui definiamo i dati per la funzione find_peaks (). La seconda sezione è "Peak Finding" in cui utilizziamo la funzione find_peaks () passando i dati dichiarati recentemente.

La terza sezione del programma è la "scoperta di minimi" in cui calcoliamo i minimi e i massimi dei dati dati. L'ultima sezione è la "trama dei dati" in cui tracciamo i dati utilizzando il PLT.Plot () e PLT.Show () funzioni. Per vedere il grafico generato dal programma dato, consultare il seguente output generato:

Esempio 2:

Lavorare con i segnali non è solo importante per il campo della scienza dei dati o dell'elettronica, ma può anche essere utilizzato nel campo medico. L'elaborazione del segnale elettronico è più comunemente utilizzata e ha una maggiore importanza nel campo medico che in qualsiasi altro campo. In questo esempio, sfrutteremo la funzione elettrocardiogramma per interpretare un segnale elettronico. Vedere il codice di esempio nel seguente frammento di codice:

Importa matplotlib.Pyplot come Plt
da Scipy.Signal Import Find_peaks
da Scipy.elettrocardiogramma di importazione misc
#****** Peak trova ******
x = elettrocardiogramma () [1000: 3000]
picchi, _ = find_peaks (x, altezza = 1)
#****** Ploting dei dati ******
Plt.Trama (x)
Plt.diagramma (picchi, x [picchi], "x")
Plt.Trama (NP.zeros_like (x), "-", color = "grigio")
Plt.spettacolo()

La libreria Matplotlib è inclusa nel programma per tracciare il grafico. La libreria Scipy viene utilizzata per chiamare il pacchetto Signal e Misc in modo che le funzioni Find_peaks e elettrocardiogramma possano essere chiamate dal rispettivo pacchetto. Ora, proprio come nell'esempio precedente, segmeniamo il programma in sezioni. La prima sezione è la sezione "Peak Finding" in cui utilizziamo le funzioni find_peaks () ed elettrocardiogramma () per trovare i picchi dell'elettrocardiogramma generato. L'ultima sezione è la sezione "Plottura dei dati" in cui tracciamo il grafico. Ora, vediamo il grafico tracciato nel seguente output:

Esempio 3:

Eseguiamo un altro esempio in modo da poter vedere chiaramente come funziona la funzione findpeaks (). Considera il codice di esempio seguente:

Importa Numpy come NP
Dal segnale di importazione di Scipy
Importa matplotlib.Pyplot come Plt
#****** Dichiarazione di dati ******
data = np.Linspace (0, 4 * NP.PI, 100)
sig = np.sin (dati) + 0.4 * np.peccato (1.8 * Dati)
#****** Peak trova ******
sp, _ = segnale.find_peaks (SIG)
Promin = segnale.Peak_prominces (SIG, SP) [0]
H = Sig [sp] - Promin
#****** Ploting dei dati ******
Plt.trama (sig)
Plt.trama (sp, sig [sp], "*")
Plt.vlines (x = sp, ymin = h, ymax = sig [sp])
Plt.spettacolo()

Ancora una volta, il programma è segmentato in sezioni diverse, poiché ogni sezione svolge una funzione diversa. I dati sono dichiarati nella sezione "Dichiarazione dei dati". La funzione di ricerca di picco viene eseguita nella sezione "Peak Ritroramenti". Infine, il grafico è tracciato nella sezione "Ploting Data". Ora, controlliamo il grafico tracciato nel seguente output:

Conclusione

Questa guida si occupa della funzione di elaborazione e analisi dei segnali utilizzando la funzione find_peaks (). Find_peaks () è una funzione di elaborazione del segnale definita nella libreria Scipy di Python. Viene utilizzato per trovare i picchi del segnale, dei massimi e dei minimi di qualsiasi funzione matematica. Abbiamo esplorato alcuni esempi semplici e complessi per capire come la funzione find_peaks () può essere implementata in un programma Python. Ci siamo concentrati specificamente sul calcolo e sulla ricerca dei picchi contenuti nei dati dati e non sulla ricerca di massimi o minimi dei dati dati.