SciPy dans Python Tutoriel : Qu'est-ce que c'est, bibliothèque, fonction et exemples
Anna Blake
SciPy dans Python
SciPy dans Python est une bibliothèque open source utilisée pour résoudre des problèmes mathématiques, scientifiques, d'ingénierie et techniques. Il permet aux utilisateurs de manipuler les données et de les visualiser à l'aide d'un large éventail d'outils de haut niveau. Python commandes. SciPy est construit sur le Python Extension NumPy. SciPy se prononce également « Sigh Pi ».
Sous-packages de SciPy :
- Entrée/sortie de fichier – scipy.io
- Fonction spéciale - scipy.spécial
- Algèbre linéaire Operation – scipy.linalg
- Interpolation – scipy.interpoler
- Optimisation et ajustement – scipy.optimiser
- Statistiques et nombres aléatoires – scipy.stats
- Intégration numérique - scipy.intégrer
- Transformées de Fourier rapides – scipy.fftpack
- Signal Traitement - scipy.signal
- Manipulation d'images – scipy.ndimage
Pourquoi utiliser SciPy
- SciPy contient une variété de sous-packages qui aident à résoudre le problème le plus courant lié au calcul scientifique.
- Paquet SciPy dans Python est la bibliothèque scientifique la plus utilisée, juste derrière la bibliothèque scientifique GNU pour C/C++ ou celui de Matlab.
- Facile à utiliser et à comprendre ainsi qu’une puissance de calcul rapide.
- Il peut fonctionner sur un tableau de bibliothèques NumPy.
Numpy contre SciPy
Numpy
- Numpy est écrit en C et utilisé pour les calculs mathématiques ou numériques.
- C'est plus rapide que les autres Python Bibliothèques
- Numpy est la bibliothèque la plus utile pour la science des données pour effectuer des calculs de base.
- Numpy ne contient rien d'autre qu'un type de données tableau qui effectue les opérations les plus élémentaires comme le tri, la mise en forme, l'indexation, etc.
SciPy
- SciPy est construit au-dessus de NumPy
- Module SciPy dans Python est une version complète de l'algèbre linéaire tandis que Numpy ne contient que quelques fonctionnalités.
- La plupart des nouvelles fonctionnalités de Data Science sont disponibles dans Scipy plutôt que dans Numpy.
SciPy – Installation et configuration de l’environnement
Vous pouvez également installer SciPy dans Windows via pip
Python3 -m pip install --user numpy scipy
Installer Scipy sur Linux
sudo apt-get install python-scipy python-numpy
Installer SciPy sur Mac
sudo port install py35-scipy py35-numpy
Avant de commencer à apprendre SciPy Python, vous devez connaître les fonctionnalités de base ainsi que les différents types d'une gamme de NumPy
La manière standard d'importer des modules SciPy et Numpy :
from scipy import special #same for other modules import numpy as np
Package d'entrée/sortie de fichier
Scipy, package d'E/S, dispose d'un large éventail de fonctions pour travailler avec différents formats de fichiers qui sont Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV et le format binaire.
Prenons un format de fichier Python Exemple SciPy qui sont régulièrement utilisés dans MatLab :
import numpy as np
from scipy import io as sio
array = np.ones((4, 4))
sio.savemat('example.mat', {'ar': array})
data = sio.loadmat(‘example.mat', struct_as_record=True)
data['ar']
Sortie :
array([[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]])
Explication du code
- Ligne 1 & 2 : Importez la bibliothèque SciPy essentielle dans Python avec le package d'E/S et Numpy.
- Ligne 3: Créer un tableau dimensionnel de 4 x 4
- Ligne 4: Stocker le tableau dans exemple.mat fichier.
- Ligne 5: Obtenir des données de exemple.mat filet
- Ligne 6: Sortie d'impression.
Pack de fonctions spéciales
- scipy.spécial Le package contient de nombreuses fonctions de physique mathématique.
- La fonction spéciale de SciPy comprend la racine cubique, l'exponentielle, l'exponentielle de la somme logarithmique, Lambert, la permutation et les combinaisons, Gamma, Bessel, hypergéométrique, Kelvin, bêta, cylindre parabolique, exponentielle d'erreur relative, etc.
- Pour une description en une ligne de toutes ces fonctions, tapez Python console:
help(scipy.special)
Output:
NAME
scipy.special
DESCRIPTION
========================================
Special functions (:mod:`scipy.special`)
========================================
.. module:: scipy.special
Nearly all of the functions below are universal functions and follow
broadcasting and automatic array-looping rules. Exceptions are noted.
Fonction racine cubique
La fonction Racine cubique trouve la racine cubique des valeurs.
syntaxe:
scipy.special.cbrt(x)
Mise en situation :
from scipy.special import cbrt #Find cubic root of 27 & 64 using cbrt() function cb = cbrt([27, 64]) #print value of cb print(cb)
Sortie : tableau([3., 4.])
Fonction exponentielle:
La fonction exponentielle calcule le 10**x élément par élément.
Mise en situation :
from scipy.special import exp10 #define exp10 function and pass value in its exp = exp10([1,10]) print(exp)
Sortie : [1.e+01 1.e+10]
Permutations et combinaisons
SciPy offre également des fonctionnalités pour calculer les permutations et les combinaisons.
Combinaisons - scipy.special.comb(N,k)
Mise en situation :
from scipy.special import comb #find combinations of 5, 2 values using comb(N, k) com = comb(5, 2, exact = False, repetition=True) print(com)
Sortie : 15.0
Permutations –
scipy.special.perm(N,k)
Mise en situation :
from scipy.special import perm #find permutation of 5, 2 using perm (N, k) function per = perm(5, 2, exact = True) print(per)
Sortie : 20
Fonction exponentielle de la somme du journal
Log Sum Exponential calcule le journal de l'élément d'entrée somme exponentielle.
Syntaxe :
scipy.special.logsumexp(x)
Fonction Bessel
Fonction de calcul du nième ordre entier
Syntaxe :
scipy.special.jn()
Algèbre linéaire avec SciPy
- L'algèbre linéaire de SciPy est une implémentation des bibliothèques BLAS et ATLAS LAPACK.
- Les performances de l'algèbre linéaire sont très rapides par rapport à BLAS et LAPACK.
- La routine d'algèbre linéaire accepte un objet tableau à deux dimensions et la sortie est également un tableau à deux dimensions.
Faisons maintenant quelques tests avec scipy.linalg,
Calculateur déterminant d'une matrice bidimensionnelle,
from scipy import linalg import numpy as np #define square matrix two_d_array = np.array([ [4,5], [3,2] ]) #pass values to det() function linalg.det( two_d_array )
Sortie : - 7.0
Matrice inverse –
scipy.linalg.inv()
La matrice inverse de Scipy calcule l'inverse de n'importe quelle matrice carrée.
Voyons,
from scipy import linalg import numpy as np # define square matrix two_d_array = np.array([ [4,5], [3,2] ]) #pass value to function inv() linalg.inv( two_d_array )
Sortie :
array( [[-0.28571429, 0.71428571],
[ 0.42857143, -0.57142857]] )
Valeurs propres et vecteur propre
scipy.linalg.eig()
- Le problème le plus courant en algèbre linéaire est celui des valeurs propres et du vecteur propre qui peuvent être facilement résolus en utilisant eig()la fonction.
- Trouvons maintenant la valeur propre de (X) et correspondent au vecteur propre d'une matrice carrée bidimensionnelle.
Exemple
from scipy import linalg import numpy as np #define two dimensional array arr = np.array([[5,4],[6,3]]) #pass value into function eg_val, eg_vect = linalg.eig(arr) #get eigenvalues print(eg_val) #get eigenvectors print(eg_vect)
Sortie :
[ 9.+0.j -1.+0.j] #eigenvalues [ [ 0.70710678 -0.5547002 ] #eigenvectors [ 0.70710678 0.83205029] ]
Transformée de Fourier discrète – scipy.fftpack
- DFT est une technique mathématique utilisée pour convertir des données spatiales en données de fréquence.
- FFT (Fast Fourier Transformation) est un algorithme de calcul de DFT
- FFT est appliqué à un tableau multidimensionnel.
- La fréquence définit le nombre de signaux ou de longueurs d'onde au cours d'une période de temps particulière.
Mise en situation : Faites une vague et montrez-la en utilisant la bibliothèque Matplotlib. nous prenons un exemple de fonction périodique simple de sin(20 × 2πt)
%matplotlib inline
from matplotlib import pyplot as plt
import numpy as np
#Frequency in terms of Hertz
fre = 5
#Sample rate
fre_samp = 50
t = np.linspace(0, 2, 2 * fre_samp, endpoint = False )
a = np.sin(fre * 2 * np.pi * t)
figure, axis = plt.subplots()
axis.plot(t, a)
axis.set_xlabel ('Time (s)')
axis.set_ylabel ('Signal amplitude')
plt.show()
Sortie :
Vous pouvez voir ça. La fréquence est de 5 Hz et son signal se répète toutes les 1/5 secondes – c'est ce qu'on appelle une période de temps particulière.
Utilisons maintenant cette onde sinusoïdale à l'aide de l'application DFT.
from scipy import fftpack
A = fftpack.fft(a)
frequency = fftpack.fftfreq(len(a)) * fre_samp
figure, axis = plt.subplots()
axis.stem(frequency, np.abs(A))
axis.set_xlabel('Frequency in Hz')
axis.set_ylabel('Frequency Spectrum Magnitude')
axis.set_xlim(-fre_samp / 2, fre_samp/ 2)
axis.set_ylim(-5, 110)
plt.show()
Sortie :
- Vous pouvez clairement voir que la sortie est un tableau unidimensionnel.
- Les entrées contenant des valeurs complexes sont nulles sauf deux points.
- Dans l'exemple DFT, nous visualisons l'amplitude du signal.
Optimisation et ajustement dans SciPy – scipy.optimize
- L'optimisation fournit un algorithme utile pour minimiser l'ajustement de courbe, l'ajustement multidimensionnel ou scalaire et racine.
- Prenons un exemple de une fonction scalaire,pour trouver la fonction scalaire minimale.
%matplotlib inline
import matplotlib.pyplot as plt
from scipy import optimize
import numpy as np
def function(a):
return a*2 + 20 * np.sin(a)
plt.plot(a, function(a))
plt.show()
#use BFGS algorithm for optimization
optimize.fmin_bfgs(function, 0)
Sortie :
L'optimisation s'est terminée avec succès.
Valeur de fonction actuelle : -23.241676
Itérations : 4
Évaluations fonctionnelles : 18
Évaluations de dégradé : 6
tableau([-1.67096375])
- Dans cet exemple, l'optimisation est effectuée à l'aide de l'algorithme de descente de gradient à partir du point initial
- Mais le problème possible réside dans les minimums locaux plutôt que dans les minimums globaux. Si nous ne trouvons pas de voisin des minima globaux, alors nous devons appliquer une optimisation globale et trouver la fonction des minima globaux utilisée comme saut de bassin() qui combine un optimiseur local.
optimiser.basinhopping(fonction, 0)
Sortie :
fun: -23.241676238045315
lowest_optimization_result:
fun: -23.241676238045315
hess_inv: array([[0.05023331]])
jac: array([4.76837158e-07])
message: 'Optimization terminated successfully.'
nfev: 15
nit: 3
njev: 5
status: 0
success: True
x: array([-1.67096375])
message: ['requested number of basinhopping iterations completed successfully']
minimization_failures: 0
nfev: 1530
nit: 100
njev: 510
x: array([-1.67096375])
Algorithme Nelder-Mead :
- L'algorithme de Nelder-Mead sélectionne via le paramètre de méthode.
- Il fournit le moyen de minimisation le plus simple pour un fonctionnement équitable.
- L'algorithme de Nelder – Mead n'est pas utilisé pour les évaluations de gradient car la recherche de la solution peut prendre plus de temps.
import numpy as np
from scipy.optimize import minimize
#define function f(x)
def f(x):
return .4*(1 - x[0])**2
optimize.minimize(f, [2, -1], method="Nelder-Mead")
Sortie :
final_simplex: (array([[ 1. , -1.27109375],
[ 1. , -1.27118835],
[ 1. , -1.27113762]]), array([0., 0., 0.]))
fun: 0.0
message: 'Optimization terminated successfully.'
nfev: 147
nit: 69
status: 0
success: True
x: array([ 1. , -1.27109375])
Traitement d'images avec SciPy – scipy.ndimage
- scipy.ndimage est un sous-module de SciPy qui est principalement utilisé pour effectuer une opération liée à l'image
- ndimage signifie l’image à « n » dimensions.
- SciPy Image Processing fournit une transformation géométrique (rotation, recadrage, retournement), un filtrage d'image (netteté et dénosage), une image d'affichage, une segmentation d'image, une classification et une extraction de caractéristiques.
- Forfait DIVERS dans SciPy contient des images prédéfinies qui peuvent être utilisées pour effectuer des tâches de manipulation d'images
Mise en situation : Prenons un exemple de transformation géométrique d'images
from scipy import misc from matplotlib import pyplot as plt import numpy as np #get face image of panda from misc package panda = misc.face() #plot or show image of face plt.imshow( panda ) plt.show()
Sortie :
Maintenant nous Rabattable Image actuelle:
#Flip Down using scipy misc.face image flip_down = np.flipud(misc.face()) plt.imshow(flip_down) plt.show()
Sortie :
Mise en situation : Rotation de l'image à l'aide de Scipy,
from scipy import ndimage, misc from matplotlib import pyplot as plt panda = misc.face() #rotatation function of scipy for image – image rotated 135 degree panda_rotate = ndimage.rotate(panda, 135) plt.imshow(panda_rotate) plt.show()
Sortie :
Intégration avec Scipy – Intégration numérique
- Lorsque nous intégrons une fonction pour laquelle l’intégration analytique n’est pas possible, nous devons nous tourner vers l’intégration numérique.
- SciPy fournit des fonctionnalités pour intégrer une fonction avec une intégration numérique.
- scipy.intégrer La bibliothèque a des règles d'intégration simple, double, triple, multiple, quadrate gaussien, Romberg, trapézoïdale et Simpson.
Mise en situation : Prenons maintenant un exemple de Intégration unique
Ici a est la limite supérieure et b est la limite inférieure
from scipy import integrate # take f(x) function as f f = lambda x : x**2 #single integration with a = 0 & b = 1 integration = integrate.quad(f, 0 , 1) print(integration)
Sortie :
(0.33333333333333337, 3.700743415417189e-15)
Ici, la fonction renvoie deux valeurs, dans lesquelles la première valeur est l'intégration et la deuxième valeur est l'erreur estimée en intégrale.
Exemple : prenons maintenant un exemple SciPy de double intégration. On retrouve la double intégration de l’équation suivante,
from scipy import integrate import numpy as np #import square root function from math lib from math import sqrt # set fuction f(x) f = lambda x, y : 64 *x*y # lower limit of second integral p = lambda x : 0 # upper limit of first integral q = lambda y : sqrt(1 - 2*y**2) # perform double integration integration = integrate.dblquad(f , 0 , 2/4, p, q) print(integration)
Sortie :
(3.0, 9.657432734515774e-14)
Vous avez vu la sortie ci-dessus comme la même précédente.
Résumé
- SciPy (prononcé comme « Sigh Pi ») est un logiciel Open Source Python-bibliothèque basée sur les mathématiques, le calcul scientifique, l'ingénierie et le calcul technique.
- SciPy contient une variété de sous-packages qui aident à résoudre le problème le plus courant lié au calcul scientifique.
- SciPy est construit au-dessus de NumPy
| Nom du forfait | Description |
|---|---|
| scipy.io | Entrée/sortie de fichier |
| scipy.spécial | Fonction spéciale |
| scipy.linalg | Algèbre linéaire Operaproduction |
| scipy.interpoler | interpolation |
| scipy.optimiser | Optimisation et ajustement |
| scipy.stats | Statistiques et nombres aléatoires |
| scipy.intégrer | Intégration numérique |
| scipy.fftpack | Transformations de Fourier rapides |
| scipy.signal | Signal Gestion |
| scipy.ndimage | Manipulation d'images – |
