SciPy in Python Tutorial: Was ist, Bibliothek, Funktion & Beispiele

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 Verarbeitung
scipy.ndimage	Bildbearbeitung -