Python Inter B3 - 4

Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning
on utilisait contour plot. Ici tout ce qu’on a faire c’est passe le tableau Z qui est un tableau de 100lignes et
100 colonnes
import matplotlib.pyplot as plt
import numpy as np
X = np.linspace(0, 5, 100)
Y = np.linspace(0, 5, 100)
X, Y = np.meshgrid(X, Y)
# Matrice f(X, Y) = sin(X) + cos(Y) * np.cos(x)

f = lambdax, y : np.sin(x) + np.cos(x+y) * np.cos(x)
plt.imshow(f(X, Y))
plt.colorbar()
plt.title('f(x, y) = sin(x) + cos(y) * np.cos(x) ')
plt.show()
Exercice : graphe
Modifier le code de l’exercice précédent afin d’afficher sur une seule et même figure les différentes
variables qu’on a pour notre dateset de la fleur d’iris.
#Solution
from sklearn.Dataset s importload_iris
iris = load_iris()
x = iris.data
n = x.shape[1]
plt.figure(figsize=(12, 8))
…#Code ici
plt.show()
Chapitre 9 : Scipy : Machine Learning

Scipy contient des modules très puissants pour le machine Learning, l'analyse de données, les time séries,
etc. Cette section vous montre quelques unes des fonctions les plus utiles pour faire des calculs
scientifiques. La documentation de scipy disponible sur internet présente une multitude de petits modules
qui permettent de faire des opérations sciatiques bien précises.
III.1. Interpolation
Lors de l’acquisition des signaux, il arrive parfois qu’il manque des
données, dûà la fréquence d’échantillonnage ou aux caractéristiques
descapteursutilisés. Ce qui va nous produire des Dataset s qui
manquent de valeurs. Nous pouvons résoudre le problème en
supprimant les valeurs manquantes mais l’analyse devient donc très
peu satisfaisante. L’idéale est de réaliser une interpolation afin de
compléter les données manquantes.
Interpoler un signal est parfois très utile s'il vous manque des données dans un Dataset. Mais c'est une
technique dangereuse, qui peut parfois transformer la réalité des choses ! Il faut donc déterminer la
45 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

méthode d’interpolation (linéaire, cubique, quadratique, …) qui correspond mieux aux données de notre
Dataset.
Imaginons que nous ayons un capteur qui nous donne les points suivants :
import numpy as np
# Création d'un Dataset

x = np.linspace(0, 10, 10)
y = x**2
plt.scatter(x, y)
plt.show()
Si nous souhaitons placer plus de point entre les points bleus, nous allons
donc faire une interpolation en utilisant le module interpol1d qui est
l’intérieur du package scipy.interpolate. Cette fonction va nous
permettre de générer une autre fonction f( ) qui est notre fonction
d’interpolation. L’attribut kind permet de définir le typez
d’interpolation que souhaite effectuer. L‘interpolation plus basique
est l’interpolation linéaire qui trace une ligne entre deux points et
c’est elle que nous nous utiliserons dans cet exemple. On peut donc
utiliser cette nouvelle fonction f( ) en lui définissant un nouvel axe
pour lequel on peu décider d’avoir 30 points ou plus au lieu de 10.
import numpy as np
from scipy.interpolate import interp1d

y = x**2
f = interp1d(x, y, kind='linear') #nouvelle fonction
new_x = np.linspace(0, 10, 30) #nouvel axe des abscisses
resultat = f(new_x) #on enregistre la fonction du nouvel axe dans une variable
resultat
plt.scatter(x, y) #on affiche la 1ere fonction sur laquelle on va supperposer la
fonction interpolée
plt.scatter(new_x, resultat, c='r') #on affiche la fonction interpolée en rouge
plt.show()
Il est important d’afficher le signal original et le signal interpolé pour se rassurer que le signal interpolé
est conforme au signal d’origine. Ainsi, le choix du type d’interpolation est important.
Imaginons maintenant que nous ayons le signal suivant :


import numpy as np

y = np.sin(x)
plt.scatter(x, y)
plt.show()
Si nous utilisons une interpolation linéaire, on se rend bien compte que le résultat n’est pas vraiment
conforma à la réalité.
import numpy as np
from scipy.interpolate import interp1d

y = np.sin(x)
# création de la fonction interpolation f

f = interp1d(x, y, kind='linear')
# résultats de la fonction interpolation f sur de nouvelles données

new_x = np.linspace(0, 10, 50)
resultat = f(new_x)
# visualisation avec matplotlib

plt.scatter(x, y)
plt.scatter(new_x, resultat, c='r')
plt.show()
Il faut donc prendre une interpolation qui va permettre de suivre qu maximum le signal d’origine. Ici on
peut utiliser l’interpolation cubique.
import numpy as np
from scipy.interpolate importinterp1d

y = np.sin(x)

f = interp1d(x, y, kind='cubic')
# résultats de la fonction interpolation f sur de nouvelles données

resultat = f(new_x)
plt.scatter(x, y)
plt.scatter(new_x, resultat, c='r')
plt.show()
Ici, on obtient une interpolation qui reflète plus la réalité. On peut aussi utiliser la fonction plot pour avoir
des traits continus plutôt que des points.
import numpy as np
from scipy.interpolate importinterp1d

y = np.sin(x)

f = interp1d(x, y, kind='cubic')
# résultats de la fonction interpolation f sur de nouvelles

données


result = f(new_x)

plt.scatter(x, y)
plt.plot(new_x, result, c='r')
plt.show()
Vous pouvez avoir une description de tous les types d’interpolation (linear, nearest, zero, slinear,
quadratic, cubic, previous, next) sur le site internet de scipyhttps://scipy.org/. Vous pourrez également
faire des interpolations en 2D.
III.2. Optimisation
Les problèmes d’optimisation renvoient le plus souvent aux notions d’optimisation. On trouve beaucoup
de fonctions dans le module optimize. Certaines permettent de faire des minimisations locales, ou
globales, d'autres permette de développer des modèles statistiques avec la méthode des moindres carrés.
On trouve également des fonctions pour faire de la programmation linéaire qui permet de résoudre
certains problèmes d’optimisation tout en respectant certaines contraintes.
a.1) curve_fit
La fonction curve_fit permet d’optimiser le placement d’une courbe à l’intérieur d’un nuage de points.
Imaginons qu’on a ce Dataset qui est polynôme de degré trois auquel est greffé un peu de bruit et que
nous souhaitons développer un modèle statistique qui entre bien dans ce nuage de point. On peut donc
utiliser la fonction curve_fit qui se sert de la méthode des moindres carrés pour trouver les meilleurs
paramètres a, b c, … d’un modèle qu’on aura fournis a notre fonction.
import numpy as np
# Création d'un Dataset avec du bruit "normal"

y = 1/3*x**3 - 3/5 * x**2 + 2 + np.random.randn(x.shape[0])/20
plt.scatter(x, y)
plt.show()
Donc pour utiliser cette fonction il faut d’abord définir un modèle. On

créer donc un modèle f qui est fonction de différents paramètres : x, a, b, c et d. on va donc donner ce
modèle a la fonction curve_fit. On commencer par importer le module optimize pour utiliser la fonction
curve_fit a laquelle on donne le modèle et les données (x et y) qu’il ya dans notre Dataset. Cette fonction
retourne deux tableaux numpy : params qui contient les différentes paramètres de notre modèle (a, b, c, et
d) et param_cov qui contient les différentes covariances qu’il y’a entre ses paramètres (c’est a matrice de
covariance du modèle).
import numpy as np
from scipy import optimize
# Création d'un Dataset avec du bruit "normal"

y = 1/3*x**3 - 3/5 * x**2 + 2 + np.random.randn(x.shape[0])/20

# Définition d'un modèle statistique sensé "coller" au Dataset ci-dessus

deff (x, a, b, c, d):
returna * x**3 + b * x**2 + c * x + d
# curve_fit permet de trouver les paramètres du modèle f grâceà la méthode des moindres carrés
params, param_cov = optimize.curve_fit(f, x, y)
print(params) #paramètre du modèle
print(params_cov)#covariance être es paramètres
# Visualisation des résultats.

plt.scatter(x, y)
plt.plot(x, f(x, params[0], params[1], params[2], params[3]), c='g', lw=3)
plt.show()
a.2) Minimisation 1D
La fonction optimize.minimize est utile pour trouver un minimum local dans une fonction à N
dimensions.
import numpy as np
# Définition d'une fonction a 1 Dimension

deff (x):
returnx**2 + 15*np.sin(x)
# Visualisation de la fonction
x = np.linspace(-10, 10, 100)
plt.plot(x, f(x))
plt.show()
Pour utiliser cette fonction il faut définir un point de départ x0 (-8 par exemple) a partir duquel la fonction
va exécuter un algorithme de minimisation qui va peut a peu converger vers le premier minimum qu’il va
trouver.
import numpy as np
# Définition d'une fonction a 1 Dimension

deff (x):
returnx**2 + 15*np.sin(x)
x = np.linspace(-10, 10, 100)
# Définition d'un point x0 pour l'algorithme de minimisation

x0=-8
result = optimize.minimize(f, x0=x0).x # résultat de la
minimisation
# result = coordonné de x0
# Visualisation du résultat
plt.plot(x, f(x), lw=3, zorder=-1) # on trace la Courbe de la fonction
plt.scatter(x0, f(x0), s=200, marker='+', c='g', zorder=1, label='initial') #
on place le point initial
plt.scatter(result, f(result), s=100, c='r', zorder=1, label='final') # on
place le point final
plt.legend()
plt.show()
La on obtient le minimum local, or nous cherchons le minimum global.

On peut donc choisir un autre point de départ x0 = -5.

a.3) Minimisation 2D
La fonction minimize peut être utilisée sur des fonctions à 2D ou 3D, …. si nous prenons notre dernière
fonction sur matplotlib que nous avons visualisé à l’aide d’un contourplot. On peur voir dans ce graphe la
présence de maximums et de minimums.
import numpy as np
# Définition d'une fonction 2D. X est un tableau numpy a 2-Dimension

deff (x):
return np.sin(x[0]) + np.cos(x[0]+x[1])*np.cos(x[0])
# Génération de la fonction sur un espace 2D.

x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
x, y = np.meshgrid(x, y)
plt.contour(x, y, f(np.array([x, y])), 20)
#plt.contour(x, y, f(np.array([x, y])), 20, colors='black')
plt.show()
On va donc essayez de trouver le minimum dans cette fonction. Ici nous on va initialiser la fonction avec
points x0 = (0, 0) (étant donné que nous sommes en 2D).
import numpy as np
# Définition d'une fonction 2D. X est un tableau numpy a 2-

Dimension
deff (x):
return np.sin(x[0]) + np.cos(x[0]+x[1])*np.cos(x[0])
# Génération de la fonction sur un espace 2D.

x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
x, y = np.meshgrid(x, y)
#plt.contour(x, y, f(np.array([x, y])), 20, colors='black')
# Placement d'un point x0 initial aux coordonnées (0,0)

x0 = np.zeros((2, 1))
# Minimisation de la fonction
result = optimize.minimize(f, x0=x0).x
print('le minimum est aux coordonnées', result) # imprimer le résultat
# Visualisation du résultat
plt.contour(x, y, f(np.array([x, y])), 20) # on dessine la fonction 2D
plt.scatter(x0[0], x0[1], marker='+', c='r', s=100, label='initial') # on place le Point de départ
plt.scatter(result[0], result[1], c='g', s=100, label='final') # on place le Point final
plt.legend()
plt.show()
A l’aide de matplotlib on peut afficher les deux points sur le même

graphe.
III.3. Traitement du signal

Le module scipy.signal contient beaucoup de fonctions de
convolution et de filtres pour faire du traitement du signal. La

fonction signal.detrend est parfaite pour éliminer une tendance linéaire dans un signal. Utile pour
beaucoup d'applications !
import numpy as np
# Création d'un Dataset avec une tendance linéaire

y = x + 4*np.sin(x) +np.random.randn(x.shape[0])
plt.plot(x, y)
plt.show()
Essayons d’éliminer la tendance linéaire du signal :

import numpy as np
from scipy import signal
# Création d'un Dataset avec une tendance linéaire

y = x + 4*np.sin(x) +np.random.randn(x.shape[0])
# Élimination de la tendance linéaire

new_y = signal.detrend(y)
# Visualisation des résultats

plt.plot(x, y, label='originel')
plt.plot(x, new_y, label='detrend')
plt.legend()
plt.show()
a.1) Transformation de Fourier (FFT)

Le module scipy.fftpack contient des fonctions très puissantes et simples d'utilisation pour effectuer des
transformations de Fourier. La transformation de Fourier est une technique mathématique puissante et
normalement complexe à mettre en œuvre. Heureusement scipy.fftpack rend cette technique très simple a
implémenter.La transformation de Fourier permet d'analyser les fréquences qui composent un signal
périodique (qui se répété avec le temps). Cette opération produit un graphique que l'on appelle Spectre.
Une fois le Spectre généré, il est possible de filtrer les bruits indésirables, ou bien de sélectionner
seulement certaines fréquences, ou d'en atténuer d'autres... les possibilités sont infinies.
Dans l’image ci dessous nous avons trois signaux périodiques ayant chacun sa propre fréquence. Si nous
combinons ses trois signaux nous obtenons le signal du milieu (c’est ce genre de signaux que nous avons
autour de nous : le son, le rythme cardiaque, les ondes, …) qui est une combinaison de fréquence. La
transformation de fourrier permet d’extraire chaque fréquence qui compose un tel signal, le résultat
obtenu est appelé un spectre de fréquences ayant en abscisses les fréquences et en ordonné les amplitudes.
Le signal tout à droite a trois piques qui représentent chacune la fréquence de l’un des signaux qu’on avait
à gauche.

Pour obtenir un tel spectre on va chargerle module fftpack a l‘intérieur duquel on va utiliser deux
fonctionfft( ) et fftfreq( ). On commence par générer le signal :
import numpy as np
# Création d'un signal périodique noyé dans du bruit.

x = np.linspace(0, 30, 1000)
y = 3*np.sin(x) + 2*np.sin(5*x) + np.sin(10*x) #signal composé des 3 signaux
plt.plot(x, y)
plt.show()
On importe le module fftpack de scipy pour générer le spectre:

import numpy as np
from scipy import fftpack

x = np.linspace(0, 30, 1000)
y = 3*np.sin(x) + 2*np.sin(5*x) + np.sin(10*x) #signal composé des 3
signaux
# création des variables Fourier et Fréquences, qui permettent de

construire le spectre du signal.
fourier = fftpack.fft(y)
power = np.abs(fourier) # la variable power est créée pour éliminer les
amplitudes négatives
frequence = fftpack.fftfreq(y.size)
freq = np.abs(frequence) # la variable freq est créée pour éliminer les fréquences négatives
plt.plot(freq, power) #on affiche le spectre des fréquences
plt.xlabel('Frequences')
plt.ylabel('Amplitudes')
plt.show()
Dans l'exemple ci-dessous, ajoutons du bruit au signal et nous comment filtrer un signal noyé dans du
bruit.
import numpy as np

x = np.linspace(0, 30, 1000)
y = 3*np.sin(x) + 2*np.sin(5*x) + np.sin(10*x) +
np.random.random(x.shape[0])*10
plt.plot(x, y)
plt.show()
L’idée ici est de retrouver le signal de départ. On va donc procéder au filtrage du signal bruité en 3
étapes :

On commence par transformer ce signal en spectre de fréquences comme dans l’exemple précédant :
import numpy as np

x = np.linspace(0, 30, 1000)

power = np.abs(fourier) # la variable power est créée pour éliminer
les amplitudes négatives
plt.plot(freq, power) #on affiche le spectre des fréquences
plt.show()
On constate sur le spectre qu’il ya des fréquences parasites. Nous allons donc utiliser le boolean indexing
pour supprimer toutes ses fréquences qui sont inferieur à un seuil que nous allons lire sur l’axe des
amplitudes afin de garder nos 3 pics.
import numpy as np

x = np.linspace(0, 30, 1000)

power = np.abs(fourier) # la variable power est créée pour éliminer
les amplitudes négatives
freq = np.abs(frequence) # la variable freq est créée pour éliminer
les fréquences négatives
# filtre du spectre avec du boolean indexing de Numpy

fourier[power<400] = 0#on supprime toutes les fréquences dont l'amplitude est < a 400
plt.plot(freq, np.abs(fourier)) #on affiche le spectre des fréquences filtrées

plt.show()

On va utiliser la transformer de fourrier inverse pour revenir dans le monde du réel et afficher de nouveau
les signaux temporels.
import numpy as np

x = np.linspace(0, 30, 1000)
# création des variables Fourier et Fréquences, qui permettent

de construire le spectre du signal.
power = np.abs(fourier) # la variable power est créée pour
éliminer les amplitudes négatives

fourier[power<400] = 0#on supprimes toutes les fréquences dont l'amplitude est < a 400
# Transformation de Fourier Inverse: génère un nouveau signal temporel depuis le spectre filtré
filtered_signal = fftpack.ifft(fourier) #transformation de fourrier inverse

plt.plot(x, y, lw=0.5, label='signal originel')
plt.plot(x, filtered_signal, lw=3, label='signal filtré')
plt.legend()
plt.xlabel('Periode')
plt.ylabel('Amplitude')
plt.show()
On constate que le signal n’est pas aligné sur l’axe (0,0), on peut donc utiliser la fonction detrend pour
ajuster la ligne de base.
import numpy as np
from scipy import signal

x = np.linspace(0, 30, 1000)
y = 3*np.sin(x) + 2*np.sin(5*x) + np.sin(10*x) + np.random.random(x.shape[0])*10
# création des variables Fourier et Fréquences, qui permettent de construire le spectre du signal.
power = np.abs(fourier) # la variable power est créée pour éliminer les amplitudes négatives

fourier[power<400] = 0#on supprimes toutes les fréquences dont l'amplitude est < a 400
# Transformation de Fourier Inverse: génère un

nouveau signal temporel depuis le spectre filtré
filtered_signal = fftpack.ifft(fourier)
# Élimination de la tendance linéaire

new_y = signal.detrend(filtered_signal)

plt.plot(x, y, lw=0.5, label='signal originel')
plt.plot(x, filtered_signal, lw=3, label='signal
filtré')
plt.plot(x, new_y, label='signal detrend')
#ajustement de la ligne de base

plt.legend()
plt.xlabel('Periode')
plt.ylabel('Amplitude')
plt.show()
III.4. image processing : ndimage

scipy.ndimage propose de nombreuses actions pour le traitement d'images: convolutions, filtres de
Gauss, méthode de mesures, et morphologie.
La morphologie est une technique qui permet de transformer une matrice (et donc une image) par le
déplacement d'une structure sur chaque pixel de l'image. Lorsqu'un pixel "blanc" est visité, la structure
peut effectuer une opération:
1. de dilation: imprime des pixels
2. d'érosion : efface des pixels
Cette technique peut-être utile pour nettoyer une image des artefacts qui peuvent la composer.
On peut utiliser ces techniques de morphologies pour enlever des petits artefacts qu’on retrouve sur une
image. Nous modélisons une image dans laquelle nous incrustons de petits artefacts que nous allons
essayez d’enlever avec l’image processing.
import numpy as np
# Création d'une image avec quelques artefacts

np.random.seed(0)
X = np.zeros((32, 32)) #on cree une matrice carré de 32 par 32
X[10:-10, 10:-10] = 1#on fait du slicing pour modifier le milieu du carré
X[np.random.randint(0,32,30),np.random.randint(0,32,30)] = 1#ajout d'artefacts aléatoires
plt.imshow(X)
plt.show()
On importe ndimage pour utiliser les techniques de morphologie. On va utiliser la fonction

binary_opening qui est une technique de morphologie qui est une combinaison de la dilation et de
l’érosion.
import numpy as np
from scipy import ndimage
# Création d'une image avec quelques artefacts

np.random.seed(0)
X = np.zeros((32, 32)) #on cree une matrice carré de 32 par 32
X[10:-10, 10:-10] = 1#on fait du slicing pour modifier le milieu du carré

X[np.random.randint(0,32,30),np.random.randint(0,32,30)] = 1#ajout d'artefacts aléatoires
# opération de binary_opening = érosion puis dilation

open_X = ndimage.binary_opening(X) #dilation + erosion
plt.imshow(open_X)
plt.show()
III.5. Application : Image processing (cas réel)

Nous allons maintenait appliquer ces techniques sur une image réel rechargée sur internet. Pour y
parvenir nous allons réaliser trois opérations :
 Extraire les bactéries de l’arrière plan de l’image
 Utiliser les techniques de morphologie pour enlever les artefacts présents sur l’image
 Une fois que l’image est bien nettoyée, on va utiliser une fonction de ndimage pour mesurer la
taille (relative) de chaque bactérie présente sur la photo et nous présenterons les résultats dans un
graphique matplolib.
# importer l'image avec pyplot

image = plt.imread('bacteria.png')#on importe l’image présente dans le répertoire
image = image[:,:,0] # réduire l'image en 2D, on prend une seule dimension
plt.imshow(image, cmap='gray') # afficher l'image
plt.show()
print(image.shape) # (507, 537)
Une fois l’image importée sur deux dimensions, on va pouvoir commencer le traitement. On va
commencer par extraire les bactéries de l’arrière plan, pour cela nous allons utiliser du boolean indexing
avec numpy. On crée une copie de notre image que nous allons aplatir sur une seule dimension avant de
créer l’histogramme.

import numpy as np

image = plt.imread('bacteria.png')
image = image[:,:,0] # réduire l'image en 2D, on prend une seule dimension
#plt.imshow(image, cmap='gray') # afficher l'image
#plt.show()
# copy de l'image, puis création d'un histogramme

image_2 = np.copy(image) # copy de l'image
plt.hist(image_2.ravel(), bins=255) # création d'un histogramme avec
l'image aplatie
plt.xlabel('Valeur de Pixels')
plt.ylabel('Nbre d’apparitions')
plt.show()
On va supprimer les tendances claires (blanches) et grise pour ne garder les sombres qui correspondes a
nos bactéries. N va donc utiliser du boolean indexing pour fileter toutes les valeurs des pixels supérieurs
0.6 et ne garder que celles inferieurs qui correspondent aux sombres. L’image obtenue est un masque
parce que le résultat du boolean indexing est en fait une fonction logique qui retourne True ou False.

image = image[:,:,0] # réduire l'image en 2D
# boolean indexing: création d'une image binaire

image= image<0.6
plt.imshow(image)
plt.show()
On constate l’apparition de quelques artefacts, on peut utiliser la fonction

binary_opening vue précédemment pour essayer de les éliminer.


image= image<0.6
# morphologie utilisée pour enlever les artefacts

open_image = ndimage.binary_opening(image)
plt.imshow(open_image)
plt.show()
On va utiliser la fonction label de ndimage pour segmenter cette l’image et mettre une étiquette sur
chaque bactérie qu’on peut voir. Label renvoie deux variables : label_image qui va contenir notre image
sur laquelle on a mis une étiquette sur chaque bactérie qu’on peut voir et n_labels qui va contenir le
chaque étiquette qu’on a pu placer sur l’image.


image= image<0.6

# Segmentation de l'image: label_image contient les différents labels et n_labels

est le nombre de labels
label_image, n_labels = ndimage.label(open_image)
print(f'il y a {n_labels} groupes') #il y a 53 groupes
# Visualisation de l'image étiquetée

plt.imshow(label_image)
plt.show()
On peut voir que 53 petites groupes ont été créés. On peut donc
afficher l’image étiqueté.
On va utiliser la fonction sum de ndimage pour compter tous les
pixels qu’il y’a dans chaque grouper. Donc on va pourvoir
mesurer la taille (relative) de chaque bactérie qu’il y’a sur cette
photo.


image= image<0.6

# Segmentation de l'image: label_image contient les différents labels

et n_labels est le nombre de labels
label_image, n_labels = ndimage.label(open_image)
print(f'il y a {n_labels} groupes') #il y a 53 groupes
# Mesure de la taille de chaque groupe de label_images (fait la somme

des pixels)
sizes = ndimage.sum(open_image, label_image, range(n_labels))

plt.scatter(range(n_labels), sizes)
plt.xlabel('bactérie ID')
plt.ylabel('taille relative')
plt.show()
A partir de là nous avons un Dataset, on peut commencer à calculer une moyenne, faire des statistiques,
…
C’est génial de pouvoir créer de tels graphiques à partir des images téléchargées sur internet.

Python Inter B3 - 4

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Python Inter B3 - 4

Transféré par

Droits d'auteur :

Formats disponibles

Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

# Matrice f(X, Y) = sin(X) + cos(Y) * np.cos(x)

Chapitre 9 : Scipy : Machine Learning

45 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

# Création d'un Dataset

# Création d'un Dataset

Imaginons maintenant que nous ayons le signal suivant :

46 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

import matplotlib.pyplot as plt

# Création d'un Dataset

# Création d'un Dataset

# création de la fonction interpolation f

# résultats de la fonction interpolation f sur de nouvelles données

# visualisation avec matplotlib

# Création d'un Dataset

# création de la fonction interpolation f

# résultats de la fonction interpolation f sur de nouvelles données

# Création d'un Dataset

# création de la fonction interpolation f

# résultats de la fonction interpolation f sur de nouvelles

47 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

new_x = np.linspace(0, 10, 50)

# visualisation avec matplotlib

# Création d'un Dataset avec du bruit "normal"

Donc pour utiliser cette fonction il faut d’abord définir un modèle. On

# Création d'un Dataset avec du bruit "normal"

48 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

# Définition d'un modèle statistique sensé "coller" au Dataset ci-dessus

# Visualisation des résultats.

# Définition d'une fonction a 1 Dimension

# Définition d'une fonction a 1 Dimension

# Définition d'un point x0 pour l'algorithme de minimisation

La on obtient le minimum local, or nous cherchons le minimum global.

49 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

# Définition d'une fonction 2D. X est un tableau numpy a 2-Dimension

# Génération de la fonction sur un espace 2D.

# Définition d'une fonction 2D. X est un tableau numpy a 2-

# Génération de la fonction sur un espace 2D.

# Placement d'un point x0 initial aux coordonnées (0,0)

A l’aide de matplotlib on peut afficher les deux points sur le même

III.3. Traitement du signal

50 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

# Création d'un Dataset avec une tendance linéaire

Essayons d’éliminer la tendance linéaire du signal :

# Création d'un Dataset avec une tendance linéaire

# Élimination de la tendance linéaire

# Visualisation des résultats

a.1) Transformation de Fourier (FFT)

51 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

# Création d'un signal périodique noyé dans du bruit.

On importe le module fftpack de scipy pour générer le spectre:

# Création d'un signal périodique noyé dans du bruit.

# création des variables Fourier et Fréquences, qui permettent de

# Création d'un signal périodique noyé dans du bruit.

52 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

# Création d'un signal périodique noyé dans du bruit.

# création des variables Fourier et Fréquences, qui permettent de

# Création d'un signal périodique noyé dans du bruit.

# création des variables Fourier et Fréquences, qui permettent de

# filtre du spectre avec du boolean indexing de Numpy

plt.plot(freq, np.abs(fourier)) #on affiche le spectre des fréquences filtrées

53 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

# Création d'un signal périodique noyé dans du bruit.