SciPy in Python Tutorial: Was ist, Bibliothek, Funktion & Beispiele
Anna Blake
SciPy in Python
SciPy in Python ist eine Open-Source-Bibliothek zur Lösung mathematischer, wissenschaftlicher, technischer und technischer Probleme. Sie ermöglicht es Benutzern, die Daten zu manipulieren und mithilfe einer breiten Palette hochrangiger Python Befehle. SciPy basiert auf dem Python NumPy-Erweiterung. SciPy wird auch als „Sigh Pi“ ausgesprochen.
Unterpakete von SciPy:
- Dateieingabe/-ausgabe – scipy.io
- Spezialfunktion - scipy.special
- Lineare Algebra Operation – scipy.linalg
- Interpolation – scipy.interpolate
- Optimierung und Passform – scipy.optimize
- Statistik und Zufallszahlen – scipy.stats
- Numerische Integration – scipy.integrieren
- Schnelle Fourier-Transformationen – scipy.fftpack
- Signal Verarbeitung – scipy.signal
- Bildbearbeitung - scipy.ndimage
Warum SciPy verwenden?
- SciPy enthält verschiedene Unterpakete, die bei der Lösung der häufigsten Probleme im Zusammenhang mit wissenschaftlichen Berechnungen helfen.
- SciPy-Paket in Python ist die am häufigsten verwendete Scientific-Bibliothek, gleich nach der GNU Scientific Library für C/C++ oder Matlabs.
- Einfach zu bedienen und zu verstehen sowie schnelle Rechenleistung.
- Es kann auf einem Array der NumPy-Bibliothek ausgeführt werden.
Numpy VS SciPy
Numpy
- Numpy ist in C geschrieben und wird für mathematische oder numerische Berechnungen verwendet.
- Es ist schneller als andere Python Bibliotheken
- Numpy ist die nützlichste Bibliothek für Data Science, um grundlegende Berechnungen durchzuführen.
- Numpy enthält nichts anderes als den Array-Datentyp, der die grundlegendsten Operationen wie Sortieren, Formgeben, Indizieren usw. ausführt.
SciPy
- SciPy ist in NumPy integriert
- SciPy-Modul in Python ist eine voll funktionsfähige Version der linearen Algebra, während Numpy nur wenige Funktionen enthält.
- Die meisten neuen Data Science-Funktionen sind in Scipy und nicht in Numpy verfügbar.
SciPy – Installation und Umgebungseinrichtung
Sie können SciPy auch in installieren Windows über pip
Python3 -m pip install --user numpy scipy
Installieren Sie Scipy unter Linux
sudo apt-get install python-scipy python-numpy
Installieren Sie SciPy auf dem Mac
sudo port install py35-scipy py35-numpy
Bevor wir anfangen, SciPy zu lernen Python, müssen Sie die grundlegende Funktionalität sowie verschiedene Arten von Arrays kennen NumPy
Die Standardmethode zum Importieren von SciPy-Modulen und Numpy:
from scipy import special #same for other modules import numpy as np
Datei-Eingabe-/Ausgabepaket
Scipy, das I/O-Paket, verfügt über eine breite Palette von Funktionen für die Arbeit mit verschiedenen Dateiformaten, darunter Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV und Binärformat.
Nehmen wir ein Dateiformat Python SciPy-Beispiele, die regelmäßig in MatLab verwendet werden:
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']
Ausgang:
array([[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]])
Code Erklärung
- Zeile 1 & 2: Importieren Sie die grundlegende SciPy-Bibliothek in Python mit I/O-Paket und Numpy.
- Linie 3: Erstellen Sie ein 4 x 4-dimensionales Einsen-Array
- Linie 4: Array speichern in example.mat Datei.
- Linie 5: Holen Sie sich Daten von example.mat Datei
- Linie 6: Druckausgabe.
Sonderfunktionspaket
- scipy.special Paket enthält zahlreiche Funktionen der mathematischen Physik.
- Zu den SciPy-Sonderfunktionen gehören Kubikwurzel, Exponential, Logsummen-Exponential, Lambert, Permutation und Kombinationen, Gamma, Bessel, Hypergeometrie, Kelvin, Beta, Parabolzylinder, Relativer-Fehler-Exponential usw.
- Für eine einzeilige Beschreibung aller dieser Funktionen geben Sie ein Python Konsole:
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.
Kubische Wurzelfunktion
Die Kubikwurzelfunktion ermittelt die Kubikwurzel von Werten.
Syntax:
scipy.special.cbrt(x)
Ejemplo:
from scipy.special import cbrt #Find cubic root of 27 & 64 using cbrt() function cb = cbrt([27, 64]) #print value of cb print(cb)
Ausgang: Array([3., 4.])
Exponentialfunktion:
Die Exponentialfunktion berechnet 10**x elementweise.
Ejemplo:
from scipy.special import exp10 #define exp10 function and pass value in its exp = exp10([1,10]) print(exp)
Ausgang: [1.e+01 1.e+10]
Permutationen und Kombinationen
SciPy bietet auch Funktionen zur Berechnung von Permutationen und Kombinationen.
Kombinationen - scipy.special.comb(N,k)
Ejemplo:
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)
Ausgang: 15.0
Permutationen –
scipy.special.perm(N,k)
Ejemplo:
from scipy.special import perm #find permutation of 5, 2 using perm (N, k) function per = perm(5, 2, exact = True) print(per)
Ausgang: 20
Log-Summe-Exponentialfunktion
Log Sum Exponential berechnet den Logarithmus des Summenexponential-Eingabeelements.
Syntax:
scipy.special.logsumexp(x)
Bessel-Funktion
N-te Berechnungsfunktion ganzzahliger Ordnung
Syntax:
scipy.special.jn()
Lineare Algebra mit SciPy
- Die lineare Algebra von SciPy ist eine Implementierung der BLAS- und ATLAS LAPACK-Bibliotheken.
- Die Leistung der linearen Algebra ist im Vergleich zu BLAS und LAPACK sehr schnell.
- Die lineare Algebra-Routine akzeptiert zweidimensionale Array-Objekte und gibt auch ein zweidimensionales Array aus.
Jetzt machen wir einen Test mit scipy.linalg,
Berechnung bestimmend einer zweidimensionalen Matrix,
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 )
Ausgang: -7.0
Inverse Matrix –
scipy.linalg.inv()
Inverse Matrix von Scipy berechnet die Umkehrung jeder quadratischen Matrix.
Mal sehen,
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 )
Ausgang:
array( [[-0.28571429, 0.71428571],
[ 0.42857143, -0.57142857]] )
Eigenwerte und Eigenvektor
scipy.linalg.eig()
- Das häufigste Problem in der linearen Algebra sind Eigenwerte und Eigenvektoren, die mit leicht gelöst werden können eig()Funktion.
- Lassen Sie uns nun den Eigenwert von (X) und entsprechen dem Eigenvektor einer zweidimensionalen quadratischen Matrix.
Beispiel
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)
Ausgang:
[ 9.+0.j -1.+0.j] #eigenvalues [ [ 0.70710678 -0.5547002 ] #eigenvectors [ 0.70710678 0.83205029] ]
Diskrete Fourier-Transformation – scipy.fftpack
- DFT ist eine mathematische Technik, die zur Umwandlung räumlicher Daten in Frequenzdaten verwendet wird.
- FFT (Fast Fourier Transformation) ist ein Algorithmus zur Berechnung der DFT
- FFT wird auf ein mehrdimensionales Array angewendet.
- Die Frequenz definiert die Anzahl der Signale oder Wellenlängen in einem bestimmten Zeitraum.
Ejemplo: Machen Sie eine Welle und zeigen Sie mit der Matplotlib-Bibliothek. Wir nehmen ein einfaches periodisches Funktionsbeispiel von 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()
Ausgang:
Das kann man sehen. Die Frequenz beträgt 5 Hz und das Signal wiederholt sich in 1/5 Sekunde – es handelt sich dabei um einen bestimmten Zeitraum.
Lassen Sie uns nun diese Sinuswelle mithilfe der DFT-Anwendung verwenden.
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()
Ausgang:
- Sie können deutlich erkennen, dass die Ausgabe ein eindimensionales Array ist.
- Eingaben, die komplexe Werte enthalten, sind mit Ausnahme von zwei Punkten Null.
- Im DFT-Beispiel visualisieren wir die Größe des Signals.
Optimierung und Anpassung in SciPy – scipy.optimize
- Die Optimierung bietet einen nützlichen Algorithmus zur Minimierung der Kurvenanpassung, der mehrdimensionalen oder der Skalar- und Wurzelanpassung.
- Nehmen wir ein Beispiel von eine Skalarfunktion,um die minimale Skalarfunktion zu finden.
%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)
Ausgang:
Die Optimierung wurde erfolgreich beendet.
Aktueller Funktionswert: -23.241676
Iterationen: 4
Funktionsauswertungen: 18
Steigungsbewertungen: 6
Array([-1.67096375])
- In diesem Beispiel erfolgt die Optimierung mit Hilfe des Gradientenabstiegsalgorithmus vom Anfangspunkt aus
- Aber das mögliche Problem sind lokale Minima statt globaler Minima. Wenn wir keinen Nachbarn globaler Minima finden, müssen wir die globale Optimierung anwenden und die Funktion „Globale Minima“ finden, die als verwendet wird Beckenhopping() die lokalen Optimierer kombiniert.
optimieren.basinhopping(Funktion, 0)
Ausgang:
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])
Nelder-Mead-Algorithmus:
- Der Nelder-Mead-Algorithmus wählt anhand von Methodenparametern aus.
- Es bietet die einfachste Möglichkeit zur Minimierung für eine fair verhaltene Funktion.
- Der Nelder-Mead-Algorithmus wird nicht für Gradientenauswertungen verwendet, da es länger dauern kann, die Lösung zu finden.
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")
Ausgang:
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])
Bildverarbeitung mit SciPy – scipy.ndimage
- scipy.ndimage ist ein Untermodul von SciPy, das hauptsächlich zur Durchführung einer bildbezogenen Operation verwendet wird
- ndimage bedeutet das „n“-dimensionale Bild.
- SciPy Image Processing bietet geometrische Transformation (Drehen, Zuschneiden, Spiegeln), Bildfilterung (Scharfzeichnen und Entschärfen), Bildanzeige, Bildsegmentierung, Klassifizierung und Merkmalsextraktion.
- MISC-Paket in SciPy enthält vorgefertigte Bilder, die zur Durchführung von Bildbearbeitungsaufgaben verwendet werden können
Ejemplo: Nehmen wir ein Beispiel für die geometrische Transformation von Bildern
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()
Ausgang:
Jetzt wir Flip nach unten aktuelles Bild:
#Flip Down using scipy misc.face image flip_down = np.flipud(misc.face()) plt.imshow(flip_down) plt.show()
Ausgang:
Ejemplo: Bilddrehung mit 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()
Ausgang:
Integration mit Scipy – Numerische Integration
- Wenn wir eine Funktion integrieren, bei der eine analytische Integration nicht möglich ist, müssen wir uns der numerischen Integration zuwenden
- SciPy bietet Funktionen zur Integration von Funktionen mit numerischer Integration.
- scipy.integrieren Die Bibliothek verfügt über Einfachintegration, Doppel-, Dreifach-, Mehrfachintegration, Gauß-Quadrat-, Romberg-, Trapez- und Simpson-Regeln.
Ejemplo: Nehmen Sie nun ein Beispiel Einzelintegration
Hier a ist die Obergrenze und b ist die untere Grenze
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)
Ausgang:
(0.33333333333333337, 3.700743415417189e-15)
Hier gibt die Funktion zwei Werte zurück, wobei der erste Wert die Integration und der zweite Wert der geschätzte Fehler im Integral ist.
Beispiel: Nehmen Sie nun ein SciPy-Beispiel doppelte Integration. Wir finden die doppelte Integration der folgenden Gleichung,
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)
Ausgang:
(3.0, 9.657432734515774e-14)
Sie haben die obige Ausgabe als dieselbe vorherige Ausgabe gesehen.
Zusammenfassung
- SciPy (ausgesprochen „Sigh Pi“) ist eine Open Source Python-basierte Bibliothek, die in der Mathematik, im wissenschaftlichen Rechnen, im Ingenieurwesen und im technischen Rechnen verwendet wird.
- SciPy enthält verschiedene Unterpakete, die bei der Lösung der häufigsten Probleme im Zusammenhang mit wissenschaftlichen Berechnungen helfen.
- SciPy ist in NumPy integriert
| Paketname | BESCHREIBUNG |
|---|---|
| scipy.io | Dateieingabe/-ausgabe |
| scipy.special | Special Function |
| scipy.linalg | Lineare Algebra OperaProduktion |
| scipy.interpolate | Interpolation |
| scipy.optimize | Optimierung und Passform |
| scipy.stats | Statistik und Zufallszahlen |
| scipy.integrieren | Numerische Integration |
| scipy.fftpack | Schnelle Fourier-Transformationen |
| scipy.signal | Signal In Bearbeitung |
| scipy.ndimage | Bildbearbeitung - |