Académique Documents
Professionnel Documents
Culture Documents
#!/usr/bin/python3
import numpy as np
import matplotlib.pyplot as plt
pas d'extrapolation, la fonction retourne Interpolation linéaire avec trois manières d'extrapoler :
des valeurs NaN ; avec une valeur constante ;
extrapolation par une valeur constante,
extrapolation périodique ;
soit la valeur la plus proche (xp 0 à
extrapolation linéaire.
gauche, xp n – 1 à droite), soit une
valeur fixée arbitrairement (éventuellement 0) ;
soit en prolongeant la fonction avec la loi sur le segment [xp 0 ; xp 1] à gauche, [xp n – 2 ; xp n
– 1] à droite ;
soit en considérant que la fonction est périodique de période xp n – 1 – xp 0.
La fonction numpy.interp()
où
xp et yp sont des séquences (vecteurs, listes, n-uplets) de réels, la liste des points
décrivant la fonction ;
x est la séquence de valeurs auxquelles on s'intéresse.
Par défaut, l'extrapolation se fait par des valeurs constantes, yp 0 et yp n – 1. On peut indiquer que la fonction
a une période avec l'argument period. Par exemple :
import numpy as np
import matplotlib.pyplot as plt
# **********************
# * numpy.interp() *
# * avec option period *
# **********************
plt.plot(x, y, "y-")
plt.plot(xp, yp, "r+")
Le module scipy.interpolate
Le module SciPy fournit d'autres méthodes. Pour cela, il faut charger le module :
f = interpolate.interp1d(xp, yp)
y = f(x)
fill_value="extrapolate"
Pour extrapoler avec une valeur constante, par exemple des zéros, il faut utiliser deux paramètres :
fill_value=0, bounds_error=False
En absence de ces paramètres, une valeur de x en dehors de l'intervalle des xp génère une erreur. Si l'on
veut extrapoler avec les valeurs aux extrémités, on écrit :
Par exemple :
f = interpolate.BarycentricInterpolator(xp, yp)
y = f.__call__(x)
y = interpolate.barycentric_interpolate(xp, yp, x)
f = interpolate.KroghInterpolator(xp, yp)
y = f.__call__(x)
y = interpolate.Krogh_interpolate(xp, yp, x)
f = interpolate.KroghInterpolator(xp, yp)
y_n = f.derivative(x, n) # dérivée n-ième
y_N = f.derivatives(x, N) # dérivées première à n-ième ;
# notez le « s » au nom de la fonction
On peut avoir une interpolation par un polynôme cubique par parties PCHIP (piecewise cubic hermite
interpolating polynomial) avec la classe interpolate.PchipInterpolator ou la fonction
interpolate.pchip_interpolate() :
f = interpolate.Akima1DInterpolator(xp, yp)
y = f.__call__(x)
f_n = f.derivative(n) # construit la fonction dérivée n-ième
F_n = f.antiderivative(n) # construit la n-ième primitive
racines = f.roots() # racines du polynôme
Code source
import numpy as np
from scipy import interpolate
import matplotlib.pyplot as plt
xp = np.linspace(0, 2*np.pi, 5)
yp = np.sin(xp)
# ***************
# * CubicSpline *
# ***************
# **********************
# * Interp1d quadratic *
# **********************
# *********
# * Pchip *
# *********
# ***********
# * Akima1D *
# ***********
# *********
# * Tracé *
# *********
plt.savefig("comparaison_interpolation_scipy_interpolate_polynomes.svg
", format="svg")
Lissage
La bibliothèque SciPy dispose de fonctions de traitement du signal, dont des fonctions de lissage.
La fonction la plus simple est scipy.signal.medfilt(y, h) qui, pour chaque point du tenseur
y, calcule la médiane sur une fenêtre de largeur h points ; la valeur par défaut pour la fenêtre est h = 3. Par
exemple, pour une courbe (filtrage d'un tenseur d'ordre 1) :
import numpy as np
import scipy.signal as signal
import matplotlib.pyplot as plt
#
Généra
tion
d'un
signal
gaussi
en Comparaison des filtres médian, de Savitzky-Golay, de Butterworth et de Fourier mis en
bruité œuvre dans la bibliothèque SciPy pour Python.
y =
0.1*np
.exp(-
(10*(x
- 1)*x
+
0.125)
) +
epsilo
n*np.r
andom.
normal
(x)
#
Lissag
e
ylisse
=
signal
.medfi
lt(y,
7)
#
Affich
age
fig =
plt.fi
gure(f
igsize
= [10, 6])
plt.plot(x, y, "b.")
plt.plot(x, ylisse, "k-", linewidth="0.5")
# Lissage
ylisse = signal.savgol_filter(y, 7, 3)
L'algorithme permet également d'obtenir une dérivée n-ième (n inférieur à p) avec la syntaxe
scipy.signal.savgol_filter(y, h, p,n )
Le lissage peut être vu comme un filtre passe-bas : le bruit correspond à des fréquences élevées. On peut
donc utiliser d'autres fonctions de filtre.
Un des plus simples est le filtre de Butterworth. Il faut dans un premier temps générer les caractéristiques du
filtre, avec la fonction scipy.signal.butter() ; puis déterminer les conditions initiales du filtre
avec scipy.signal.lfilter_zi() ; enfin appliquer ce filtre au signal avec la fonction
scipy.signal.lfilter(). Un filtre de Butterworth a deux paramètres :
l'ordre, qui détermine la vitesse d'atténuation lorsque la fréquence s'élève ; un filtre d'ordre
1 décroît à –6 dB/octave, un filtre d'ordre 2 à –12 dB/octave, etc.
la fréquence de coupure ws ; on doit avoir 0 < ws < 1 (1 est la fréquence de Nyquist).
Par exemple :
# Lissage
(b, a) = signal.butter(2, 0.3)
zi = signal.lfilter_zi(b, a)
ylisse = signal.lfilter(b, a, y, zi=zi*y[0])
Si l'on veut donner un sens physique à la fréquence de coupure, il faut préciser la fréquence
d'échantillonnage ƒs (sample frequency) ; la fréquence de coupure ws est alors exprimée dans la même unité
et l'on doit avoir 0 < ws < ƒs. La fréquence ws correspond à une atténuation d'un facteur .
Dans l'exemple précédent, nous avons len(y) = 50 points ; en supposant que la fenêtre représente une
seconde, nous avons une fréquence d'échantillonnage de ƒs = 50/1 = 50. Si nous voulons filtrer des
phénomènes qui se répètent cinq fois dans la fenêtre, nous prenons ws = 5 et donc nous générons le filtre de
Butterworth d'ordre 1 par :
# Lissage
(b, a) = signal.butter(1, 5, fs=len(y))
...
Puisque le lissage est essentiellement un filtre passe-bas, nous pouvons envisager d'utiliser la transformée de
Fourier et de mettre à 0 les fréquences élevées du spectre avant de faire la transformée de Fourier inverse.
Le plus simple et le plus rapide consiste à utiliser la transformée de Fourier rapide (FFT, fast Fourier
transform). La fonction scipy.fft.fft() mise en œuvre dans le module fft de SciPy place
cependant les fréquences élevées au centre du spectre ; pour faciliter le filtrage, il faut décaler les
coefficients (shift) pour mettre les fréquences élevées à l'extérieur (au début et à la fin du vecteur), on peut
ainsi facilement les mettre à 0 par tranchage (slicing). Cela utilise les fonctions
scipy.fft.fftshift() pour réordonner les coefficients, puis scipy.fft.ifftshift()
pour les remettre dans l'ordre initial.
# Lissage
ff = fft.fftshift(fft.fft(y))) # calcule la transformée de
Fourier rapide et ordonne les coefficients
ff[-25:] = 0 # atténuation du spectre aux extrémités
ff[:25] = 0
ylissef = fft.ifft(fft.ifftshift(ff)) # réordonne les
coefficients et calcule transformée de Fourier inverse
Par ailleurs, la transformée de Fourier rapide est plus efficace pour certaines longueurs de signal. La
fonction scipy.fft.next_fast_len() permet de trouver la longueur de signal optimale la plus
proche. Le code optimisé devient donc :
# Lissage
L = len(y) # calcule la longueur du signal
ff = fft.fftshift(fft.fft(y, fft.next_fast_len(L, real=True))) #
calcule la transformée de Fourier rapide de manière optimisée
# en ajoutant des 0 en queue de signal, et ordonne les
coefficients
ff[-25:] = 0 # atténuation du spectre aux extrémités
ff[:25] = 0
ylissef = fft.ifft(fft.ifftshift(ff))[:L] # réordonne les
coefficients et calcule la transformée de Fourier inverse,
# et élimine les 0 ajoutés artificiellement pour optimiser
Dans le cas présent, le signal est à valeurs réelles et non pas complexes. Nous pouvons donc utiliser les
fonctions scipy.fft.rfft() et scipy.fft.irfft(). Dans ce cas-là, la transformée de Fourier
n'a pas de coefficients à indice négatif, il suffit donc de mettre à zéro les derniers coefficients, sans avoir
besoin de changer leur ordre. Le code est alors :
# Lissage
L = len(y) # calcule la longueur du signal
ff = fft.rfft(y, fft.next_fast_len(L, real=True)) # calcule la
transformée de Fourier rapide de manière optimisée
# en ajoutant des 0 en queue de signal
ff[-25:] = 0 # atténuation du spectre à la fin
ylissef = fft.irfft(ff)[:L] # calcule la transformée de Fourier
inverse,
# et élimine les 0 ajoutés artificiellement pour optimiser
Remarque : la bibliothèque numpy dispose également d'un moule fft qui reprend les fonctions de
scipy.fft. Cependant, Il ne dispose pas de toutes les fonctions, il manque en particulier les
fonctions d'optimisation (fft.next_fast_len()) et de réordonnancement
(fft.fftshift() et fft.ifftshift()).
Notes et références
Récupérée de « https://fr.wikibooks.org/w/index.php?
title=Python_pour_le_calcul_scientifique/Interpolation,_extrapolation_et_lissage&oldid=703324 »
Les textes sont disponibles sous licence Creative Commons attribution partage à l’identique ; d’autres termes
peuvent s’appliquer.
Voyez les termes d’utilisation pour plus de détails.