SciPy - Kurzanleitung
SciPy, ausgesprochen als Sigh Pi, ist eine wissenschaftliche Python-Open-Source-Version, die unter der BSD-lizenzierten Bibliothek zur Durchführung mathematischer, wissenschaftlicher und technischer Berechnungen vertrieben wird.
Die SciPy-Bibliothek hängt von NumPy ab, das eine bequeme und schnelle Manipulation von N-dimensionalen Arrays bietet. Die SciPy-Bibliothek wurde für die Arbeit mit NumPy-Arrays entwickelt und bietet viele benutzerfreundliche und effiziente numerische Methoden, z. B. Routinen für die numerische Integration und Optimierung. Zusammen laufen sie auf allen gängigen Betriebssystemen, sind schnell zu installieren und kostenlos. NumPy und SciPy sind einfach zu bedienen, aber leistungsstark genug, um von einigen der weltweit führenden Wissenschaftler und Ingenieure abhängig zu sein.
SciPy-Unterpakete
SciPy ist in Unterpakete unterteilt, die verschiedene Bereiche des wissenschaftlichen Rechnens abdecken. Diese sind in der folgenden Tabelle zusammengefasst -
scipy.cluster | Vektorquantisierung / Kmeans |
scipy.constants | Physikalische und mathematische Konstanten |
scipy.fftpack | Fourier-Transformation |
scipy.integrate | Integrationsroutinen |
scipy.interpolate | Interpolation |
scipy.io | Dateneingabe und -ausgabe |
scipy.linalg | Lineare Algebra-Routinen |
scipy.ndimage | n-dimensionales Bildpaket |
scipy.odr | Orthogonale Distanzregression |
scipy.optimize | Optimierung |
scipy.signal | Signalverarbeitung |
scipy.sparse | Spärliche Matrizen |
scipy.spatial | Geodatenstrukturen und Algorithmen |
scipy.special | Alle speziellen mathematischen Funktionen |
scipy.stats | Statistiken |
Datenstruktur
Die von SciPy verwendete grundlegende Datenstruktur ist ein mehrdimensionales Array, das vom NumPy-Modul bereitgestellt wird. NumPy bietet einige Funktionen für lineare Algebra, Fourier-Transformationen und Zufallszahlengenerierung, jedoch nicht mit der Allgemeinheit der äquivalenten Funktionen in SciPy.
Die Standard-Python-Distribution wird mit keinem SciPy-Modul geliefert. Eine einfache Alternative ist die Installation von SciPy mit dem beliebten Python-Paketinstallationsprogramm.
pip install pandas
Wenn wir das installieren Anaconda Python packagePandas werden standardmäßig installiert. Im Folgenden finden Sie die Pakete und Links, mit denen Sie sie unter verschiedenen Betriebssystemen installieren können.
Windows
Anaconda (von https://www.continuum.io) ist eine kostenlose Python-Distribution für den SciPy-Stack. Es ist auch für Linux und Mac verfügbar.
Canopy (https://www.enthought.com/products/canopy/) ist kostenlos sowie für den kommerziellen Vertrieb mit einem vollständigen SciPy-Stack für Windows, Linux und Mac erhältlich.
Python (x,y)- Es handelt sich um eine kostenlose Python-Distribution mit SciPy-Stack und Spyder IDE für Windows. (Herunterladbar vonhttps://python-xy.github.io/)
Linux
Paketmanager der jeweiligen Linux-Distributionen werden verwendet, um ein oder mehrere Pakete im SciPy-Stack zu installieren.
Ubuntu
Wir können den folgenden Pfad verwenden, um Python in Ubuntu zu installieren.
sudo apt-get install python-numpy python-scipy
python-matplotlibipythonipython-notebook python-pandas python-sympy python-nose
Fedora
Wir können den folgenden Pfad verwenden, um Python in Fedora zu installieren.
sudo yum install numpyscipy python-matplotlibipython python-pandas
sympy python-nose atlas-devel
Standardmäßig waren alle NumPy-Funktionen über den SciPy-Namespace verfügbar. Es ist nicht erforderlich, die NumPy-Funktionen explizit zu importieren, wenn SciPy importiert wird. Das Hauptobjekt von NumPy ist das homogene mehrdimensionale Array. Es ist eine Tabelle von Elementen (normalerweise Zahlen) vom gleichen Typ, die durch ein Tupel positiver Ganzzahlen indiziert sind. In NumPy werden Bemaßungen als Achsen bezeichnet. Die Anzahl deraxes heißt als rank.
Lassen Sie uns nun die Grundfunktionalität von Vektoren und Matrizen in NumPy überarbeiten. Da SciPy auf NumPy-Arrays basiert, ist ein Verständnis der NumPy-Grundlagen erforderlich. Da sich die meisten Teile der linearen Algebra nur mit Matrizen befassen.
NumPy Vector
Ein Vektor kann auf verschiedene Arten erstellt werden. Einige von ihnen werden unten beschrieben.
Konvertieren von Python-Array-ähnlichen Objekten in NumPy
Betrachten wir das folgende Beispiel.
import numpy as np
list = [1,2,3,4]
arr = np.array(list)
print arr
Die Ausgabe des obigen Programms ist wie folgt.
[1 2 3 4]
Eigene NumPy-Array-Erstellung
NumPy verfügt über integrierte Funktionen zum Erstellen von Arrays von Grund auf neu. Einige dieser Funktionen werden nachfolgend erläutert.
Verwenden von Nullen ()
Die Funktion Nullen (Form) erstellt ein Array mit 0 Werten mit der angegebenen Form. Der Standard-D-Typ ist float64. Betrachten wir das folgende Beispiel.
import numpy as np
print np.zeros((2, 3))
Die Ausgabe des obigen Programms ist wie folgt.
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
Verwenden von Einsen ()
Die Funktion Einsen (Form) erstellt ein Array mit 1 Werten. Im Übrigen ist es identisch mit Nullen. Betrachten wir das folgende Beispiel.
import numpy as np
print np.ones((2, 3))
Die Ausgabe des obigen Programms ist wie folgt.
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
Verwenden von arange ()
Die Funktion arange () erstellt Arrays mit regelmäßig inkrementierenden Werten. Betrachten wir das folgende Beispiel.
import numpy as np
print np.arange(7)
Das obige Programm erzeugt die folgende Ausgabe.
array([0, 1, 2, 3, 4, 5, 6])
Definieren des Datentyps der Werte
Betrachten wir das folgende Beispiel.
import numpy as np
arr = np.arange(2, 10, dtype = np.float)
print arr
print "Array Data Type :",arr.dtype
Das obige Programm erzeugt die folgende Ausgabe.
[ 2. 3. 4. 5. 6. 7. 8. 9.]
Array Data Type : float64
Verwenden von linspace ()
Die Funktion linspace () erstellt Arrays mit einer bestimmten Anzahl von Elementen, die gleichmäßig zwischen den angegebenen Anfangs- und Endwerten verteilt sind. Betrachten wir das folgende Beispiel.
import numpy as np
print np.linspace(1., 4., 6)
Das obige Programm erzeugt die folgende Ausgabe.
array([ 1. , 1.6, 2.2, 2.8, 3.4, 4. ])
Matrix
Eine Matrix ist ein spezialisiertes 2D-Array, das durch Operationen seine 2D-Natur beibehält. Es hat bestimmte spezielle Operatoren wie * (Matrixmultiplikation) und ** (Matrixleistung). Betrachten wir das folgende Beispiel.
import numpy as np
print np.matrix('1 2; 3 4')
Das obige Programm erzeugt die folgende Ausgabe.
matrix([[1, 2],
[3, 4]])
Konjugieren Sie die Transponierung der Matrix
Diese Funktion gibt die (komplexe) konjugierte Transponierte von zurück self. Betrachten wir das folgende Beispiel.
import numpy as np
mat = np.matrix('1 2; 3 4')
print mat.H
Das obige Programm erzeugt die folgende Ausgabe.
matrix([[1, 3],
[2, 4]])
Matrix transponieren
Diese Funktion gibt die Transponierung von Selbst zurück. Betrachten wir das folgende Beispiel.
import numpy as np
mat = np.matrix('1 2; 3 4')
mat.T
Das obige Programm erzeugt die folgende Ausgabe.
matrix([[1, 3],
[2, 4]])
Wenn wir eine Matrix transponieren, erstellen wir eine neue Matrix, deren Zeilen die Spalten des Originals sind. Eine konjugierte Transposition vertauscht andererseits den Zeilen- und den Spaltenindex für jedes Matrixelement. Die Umkehrung einer Matrix ist eine Matrix, die, wenn sie mit der ursprünglichen Matrix multipliziert wird, zu einer Identitätsmatrix führt.
K-means clusteringist eine Methode zum Auffinden von Clustern und Clusterzentren in einem Satz unbeschrifteter Daten. Intuitiv könnte man sich einen Cluster als - bestehend aus einer Gruppe von Datenpunkten vorstellen, deren Zwischenpunktabstände im Vergleich zu den Abständen zu Punkten außerhalb des Clusters gering sind. Bei einer anfänglichen Menge von K-Zentren wiederholt der K-Mittelwert-Algorithmus die folgenden zwei Schritte:
Für jedes Zentrum wird die Teilmenge der Trainingspunkte (sein Cluster) identifiziert, die näher daran liegt als jedes andere Zentrum.
Der Mittelwert jedes Merkmals für die Datenpunkte in jedem Cluster wird berechnet, und dieser Mittelwertvektor wird zum neuen Zentrum für diesen Cluster.
Diese beiden Schritte werden wiederholt, bis sich die Zentren nicht mehr bewegen oder sich die Zuordnungen nicht mehr ändern. Dann ein neuer Punktxkann dem Cluster des nächstgelegenen Prototyps zugeordnet werden. Die SciPy-Bibliothek bietet eine gute Implementierung des K-Means-Algorithmus über das Cluster-Paket. Lassen Sie uns verstehen, wie man es benutzt.
K-Means-Implementierung in SciPy
Wir werden verstehen, wie K-Means in SciPy implementiert werden.
K-Mittel importieren
Wir werden die Implementierung und Verwendung jeder importierten Funktion sehen.
from SciPy.cluster.vq import kmeans,vq,whiten
Datengenerierung
Wir müssen einige Daten simulieren, um das Clustering zu untersuchen.
from numpy import vstack,array
from numpy.random import rand
# data generation with three features
data = vstack((rand(100,3) + array([.5,.5,.5]),rand(100,3)))
Jetzt müssen wir nach Daten suchen. Das obige Programm erzeugt die folgende Ausgabe.
array([[ 1.48598868e+00, 8.17445796e-01, 1.00834051e+00],
[ 8.45299768e-01, 1.35450732e+00, 8.66323621e-01],
[ 1.27725864e+00, 1.00622682e+00, 8.43735610e-01],
…………….
Normalisieren Sie eine Gruppe von Beobachtungen pro Merkmal. Vor dem Ausführen von K-Means ist es vorteilhaft, jede Merkmalsdimension des Beobachtungssatzes mit Bleaching neu zu skalieren. Jedes Merkmal wird durch seine Standardabweichung über alle Beobachtungen geteilt, um eine Einheitsvarianz zu erhalten.
Weiß die Daten
Wir müssen den folgenden Code verwenden, um die Daten aufzuhellen.
# whitening of data
data = whiten(data)
Berechnen Sie K-Mittelwerte mit drei Clustern
Berechnen wir nun K-Means mit drei Clustern unter Verwendung des folgenden Codes.
# computing K-Means with K = 3 (2 clusters)
centroids,_ = kmeans(data,3)
Der obige Code führt K-Mittelwerte an einem Satz von Beobachtungsvektoren aus, die K-Cluster bilden. Der K-Means-Algorithmus passt die Schwerpunkte an, bis keine ausreichenden Fortschritte erzielt werden können, dh die Änderung der Verzerrung, da die letzte Iteration unter einem bestimmten Schwellenwert liegt. Hier können wir den Schwerpunkt des Clusters beobachten, indem wir die Schwerpunktvariable mit dem unten angegebenen Code drucken.
print(centroids)
Der obige Code generiert die folgende Ausgabe.
print(centroids)[ [ 2.26034702 1.43924335 1.3697022 ]
[ 2.63788572 2.81446462 2.85163854]
[ 0.73507256 1.30801855 1.44477558] ]
Weisen Sie jeden Wert einem Cluster zu, indem Sie den unten angegebenen Code verwenden.
# assign each sample to a cluster
clx,_ = vq(data,centroids)
Das vq Funktion vergleicht jeden Beobachtungsvektor im 'M' mit 'N' obsArray mit den Schwerpunkten und ordnet die Beobachtung dem nächsten Cluster zu. Es gibt den Cluster jeder Beobachtung und die Verzerrung zurück. Wir können auch die Verzerrung überprüfen. Lassen Sie uns den Cluster jeder Beobachtung mit dem folgenden Code überprüfen.
# check clusters of observation
print clx
Der obige Code generiert die folgende Ausgabe.
array([1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 2, 0, 2, 0, 1, 1, 1,
0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0,
0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 0,
2, 2, 2, 1, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], dtype=int32)
Die unterschiedlichen Werte 0, 1, 2 des obigen Arrays geben die Cluster an.
Das SciPy-Konstantenpaket bietet eine breite Palette von Konstanten, die im allgemeinen wissenschaftlichen Bereich verwendet werden.
SciPy-Konstantenpaket
Das scipy.constants packagebietet verschiedene Konstanten. Wir müssen die erforderliche Konstante importieren und sie gemäß der Anforderung verwenden. Lassen Sie uns sehen, wie diese konstanten Variablen importiert und verwendet werden.
Vergleichen wir zunächst den 'pi'-Wert anhand des folgenden Beispiels.
#Import pi constant from both the packages
from scipy.constants import pi
from math import pi
print("sciPy - pi = %.16f"%scipy.constants.pi)
print("math - pi = %.16f"%math.pi)
Das obige Programm erzeugt die folgende Ausgabe.
sciPy - pi = 3.1415926535897931
math - pi = 3.1415926535897931
Liste der verfügbaren Konstanten
In den folgenden Tabellen werden die verschiedenen Konstanten kurz beschrieben.
Mathematische Konstanten
Sr. Nr. | Konstante | Beschreibung |
---|---|---|
1 | Pi | Pi |
2 | golden | Goldener Schnitt |
Physikalische Konstanten
In der folgenden Tabelle sind die am häufigsten verwendeten physikalischen Konstanten aufgeführt.
Sr. Nr. | Konstante & Beschreibung |
---|---|
1 | c Lichtgeschwindigkeit im Vakuum |
2 | speed_of_light Lichtgeschwindigkeit im Vakuum |
3 | h Planck-Konstante |
4 | Planck Planck-Konstante h |
5 | G Newtons Gravitationskonstante |
6 | e Grundgebühr |
7 | R Molare Gaskonstante |
8 | Avogadro Avogadro-Konstante |
9 | k Boltzmann-Konstante |
10 | electron_mass(OR) m_e Elektronische Masse |
11 | proton_mass (OR) m_p Protonenmasse |
12 | neutron_mass(OR)m_n Neutronenmasse |
Einheiten
Die folgende Tabelle enthält die Liste der SI-Einheiten.
Sr. Nr. | Einheit | Wert |
---|---|---|
1 | Milli | 0,001 |
2 | Mikro | 1e-06 |
3 | Kilo | 1000 |
Diese Einheiten reichen von Yotta, Zetta, Exa, Peta, Tera… Kilo, Hector,… Nano, Pico,… bis Zepto.
Andere wichtige Konstanten
In der folgenden Tabelle sind andere wichtige Konstanten aufgeführt, die in SciPy verwendet werden.
Sr. Nr. | Einheit | Wert |
---|---|---|
1 | Gramm | 0,001 kg |
2 | Atommasse | Atommassenkonstante |
3 | Grad | Grad im Bogenmaß |
4 | Minute | Eine Minute in Sekunden |
5 | Tag | Ein Tag in Sekunden |
6 | Zoll | Ein Zoll in Metern |
7 | Mikron | Ein Mikron in Metern |
8 | Lichtjahr | Ein Lichtjahr in Metern |
9 | Geldautomat | Standardatmosphäre in Pascal |
10 | Acre | Ein Morgen in Quadratmetern |
11 | Liter | Ein Liter in Kubikmetern |
12 | Gallone | Eine Gallone in Kubikmetern |
13 | kmh | Kilometer pro Stunde in Metern pro Sekunde |
14 | grad_Fahrenheit | Ein Fahrenheit in Kelvin |
15 | eV | Ein Elektronenvolt in Joule |
16 | hp | Eine Pferdestärke in Watt |
17 | dyn | Ein Dyne in Newton |
18 | lambda2nu | Konvertieren Sie die Wellenlänge in die optische Frequenz |
Sich an all dies zu erinnern, ist ein bisschen schwierig. Der einfache Weg, um herauszufinden, welche Taste für welche Funktion ist, ist mit derscipy.constants.find()Methode. Betrachten wir das folgende Beispiel.
import scipy.constants
res = scipy.constants.physical_constants["alpha particle mass"]
print res
Das obige Programm erzeugt die folgende Ausgabe.
[
'alpha particle mass',
'alpha particle mass energy equivalent',
'alpha particle mass energy equivalent in MeV',
'alpha particle mass in u',
'electron to alpha particle mass ratio'
]
Diese Methode gibt die Liste der Schlüssel zurück, sonst nichts, wenn das Schlüsselwort nicht übereinstimmt.
Fourier Transformationwird auf einem Zeitdomänensignal berechnet, um sein Verhalten im Frequenzbereich zu überprüfen. Die Fourier-Transformation findet ihre Anwendung in Disziplinen wie Signal- und Rauschverarbeitung, Bildverarbeitung, Audiosignalverarbeitung usw. SciPy bietet das fftpack-Modul an, mit dem der Benutzer schnelle Fourier-Transformationen berechnen kann.
Das folgende Beispiel zeigt eine Sinusfunktion, mit der die Fourier-Transformation mit dem fftpack-Modul berechnet wird.
Schnelle Fourier-Transformation
Lassen Sie uns verstehen, wie schnell die Fourier-Transformation im Detail ist.
Eindimensionale diskrete Fourier-Transformation
Die FFT y [k] der Länge N der Länge-N-Sequenz x [n] wird mit fft () berechnet und die inverse Transformation wird mit ifft () berechnet. Betrachten wir das folgende Beispiel
#Importing the fft and inverse fft functions from fftpackage
from scipy.fftpack import fft
#create an array with random n numbers
x = np.array([1.0, 2.0, 1.0, -1.0, 1.5])
#Applying the fft function
y = fft(x)
print y
Das obige Programm erzeugt die folgende Ausgabe.
[ 4.50000000+0.j 2.08155948-1.65109876j -1.83155948+1.60822041j
-1.83155948-1.60822041j 2.08155948+1.65109876j ]
Schauen wir uns ein anderes Beispiel an
#FFT is already in the workspace, using the same workspace to for inverse transform
yinv = ifft(y)
print yinv
Das obige Programm erzeugt die folgende Ausgabe.
[ 1.0+0.j 2.0+0.j 1.0+0.j -1.0+0.j 1.5+0.j ]
Das scipy.fftpackModul ermöglicht die Berechnung schneller Fourier-Transformationen. Zur Veranschaulichung kann ein (verrauschtes) Eingangssignal wie folgt aussehen:
import numpy as np
time_step = 0.02
period = 5.
time_vec = np.arange(0, 20, time_step)
sig = np.sin(2 * np.pi / period * time_vec) + 0.5 *np.random.randn(time_vec.size)
print sig.size
Wir erzeugen ein Signal mit einem Zeitschritt von 0,02 Sekunden. Die letzte Anweisung gibt die Größe des Signalsignals aus. Die Ausgabe wäre wie folgt:
1000
Wir kennen die Signalfrequenz nicht; Wir kennen nur den Abtastzeitschritt des Signalsignals. Das Signal soll von einer realen Funktion stammen, daher ist die Fourier-Transformation symmetrisch. Dasscipy.fftpack.fftfreq() Funktion erzeugt die Abtastfrequenzen und scipy.fftpack.fft() berechnet die schnelle Fourier-Transformation.
Lassen Sie uns dies anhand eines Beispiels verstehen.
from scipy import fftpack
sample_freq = fftpack.fftfreq(sig.size, d = time_step)
sig_fft = fftpack.fft(sig)
print sig_fft
Das obige Programm erzeugt die folgende Ausgabe.
array([
25.45122234 +0.00000000e+00j, 6.29800973 +2.20269471e+00j,
11.52137858 -2.00515732e+01j, 1.08111300 +1.35488579e+01j,
…….])
Diskrete Kosinustransformation
EIN Discrete Cosine Transform (DCT)drückt eine endliche Folge von Datenpunkten als Summe von Kosinusfunktionen aus, die bei verschiedenen Frequenzen schwingen. SciPy bietet ein DCT mit der Funktiondct und eine entsprechende IDCT mit der Funktion idct. Betrachten wir das folgende Beispiel.
from scipy.fftpack import dct
print dct(np.array([4., 3., 5., 10., 5., 3.]))
Das obige Programm erzeugt die folgende Ausgabe.
array([ 60., -3.48476592, -13.85640646, 11.3137085, 6., -6.31319305])
Die inverse diskrete Cosinustransformation rekonstruiert eine Sequenz aus ihren DCT-Koeffizienten (Discrete Cosine Transform). Die idct-Funktion ist die Umkehrung der dct-Funktion. Lassen Sie uns dies anhand des folgenden Beispiels verstehen.
from scipy.fftpack import dct
print idct(np.array([4., 3., 5., 10., 5., 3.]))
Das obige Programm erzeugt die folgende Ausgabe.
array([ 39.15085889, -20.14213562, -6.45392043, 7.13341236,
8.14213562, -3.83035081])
Wenn eine Funktion nicht analytisch integriert werden kann oder sehr schwer analytisch zu integrieren ist, wendet man sich im Allgemeinen numerischen Integrationsmethoden zu. SciPy verfügt über eine Reihe von Routinen zur Durchführung der numerischen Integration. Die meisten von ihnen sind in der gleichen gefundenscipy.integrateBibliothek. In der folgenden Tabelle sind einige häufig verwendete Funktionen aufgeführt.
Sr Nr. | Bedienungsanleitung |
---|---|
1 | quad Einzelne Integration |
2 | dblquad Doppelte Integration |
3 | tplquad Dreifache Integration |
4 | nquad n- fache Mehrfachintegration |
5 | fixed_quad Gaußsche Quadratur, Ordnung n |
6 | quadrature Gaußsche Quadratur zur Toleranz |
7 | romberg Romberg-Integration |
8 | trapz Trapezregel |
9 | cumtrapz Trapezregel zur kumulativen Berechnung des Integrals |
10 | simps Simpsons Regel |
11 | romb Romberg-Integration |
12 | polyint Analytische Polynomintegration (NumPy) |
13 | poly1d Hilfsfunktion für Polyint (NumPy) |
Einzelne Integrale
Die Quad-Funktion ist das Arbeitspferd der Integrationsfunktionen von SciPy. Numerische Integration wird manchmal genanntquadrature, daher der Name. Dies ist normalerweise die Standardauswahl für die Ausführung einzelner Integrale einer Funktion f (x) über einen bestimmten festen Bereich von a bis b.
$$\int_{a}^{b} f(x)dx$$
Die allgemeine Form von Quad ist scipy.integrate.quad(f, a, b), Wobei 'f' der Name der zu integrierenden Funktion ist. Während 'a' und 'b' die unteren bzw. oberen Grenzen sind. Lassen Sie uns ein Beispiel für die Gaußsche Funktion sehen, die über einen Bereich von 0 und 1 integriert ist.
Wir müssen zuerst die Funktion definieren → $f(x) = e^{-x^2}$ Dies kann mit einem Lambda-Ausdruck erfolgen und dann die Quad-Methode für diese Funktion aufrufen.
import scipy.integrate
from numpy import exp
f= lambda x:exp(-x**2)
i = scipy.integrate.quad(f, 0, 1)
print i
Das obige Programm erzeugt die folgende Ausgabe.
(0.7468241328124271, 8.291413475940725e-15)
Die Quad-Funktion gibt die beiden Werte zurück, wobei die erste Zahl der Wert des Integrals und der zweite Wert die Schätzung des absoluten Fehlers im Wert des Integrals ist.
Note- Da quad die Funktion als erstes Argument benötigt, können wir exp nicht direkt als Argument übergeben. Die Quad-Funktion akzeptiert positive und negative Unendlichkeit als Grenzen. Die Quad-Funktion kann standardmäßige vordefinierte NumPy-Funktionen einer einzelnen Variablen wie exp, sin und cos integrieren.
Mehrere Integrale
Die Mechanik für die Doppel- und Dreifachintegration wurde in die Funktionen integriert dblquad, tplquad und nquad. Diese Funktionen integrieren vier bzw. sechs Argumente. Die Grenzen aller inneren Integrale müssen als Funktionen definiert werden.
Doppelintegrale
Die allgemeine Form von dblquadist scipy.integrate.dblquad (func, a, b, gfun, hfun). Wobei func der Name der zu integrierenden Funktion ist, 'a' und 'b' die unteren und oberen Grenzen der x-Variablen sind, während gfun und hfun die Namen der Funktionen sind, die die unteren und oberen Grenzen definieren der y-Variablen.
Lassen Sie uns als Beispiel die Doppelintegralmethode durchführen.
$$\int_{0}^{1/2} dy \int_{0}^{\sqrt{1-4y^2}} 16xy \:dx$$
Wir definieren die Funktionen f, g und h mit den Lambda-Ausdrücken. Beachten Sie, dass selbst wenn g und h Konstanten sind, wie sie in vielen Fällen sein können, sie als Funktionen definiert werden müssen, wie wir es hier für die Untergrenze getan haben.
import scipy.integrate
from numpy import exp
from math import sqrt
f = lambda x, y : 16*x*y
g = lambda x : 0
h = lambda y : sqrt(1-4*y**2)
i = scipy.integrate.dblquad(f, 0, 0.5, g, h)
print i
Das obige Programm erzeugt die folgende Ausgabe.
(0.5, 1.7092350012594845e-14)
Zusätzlich zu den oben beschriebenen Routinen verfügt scipy.integrate über eine Reihe anderer Integrationsroutinen, darunter nquad, das eine n-fache Mehrfachintegration durchführt, sowie andere Routinen, die verschiedene Integrationsalgorithmen implementieren. Quad und dblquad erfüllen jedoch die meisten unserer Anforderungen an die numerische Integration.
In diesem Kapitel werden wir diskutieren, wie Interpolation in SciPy hilft.
Was ist Interpolation?
Bei der Interpolation wird ein Wert zwischen zwei Punkten auf einer Linie oder einer Kurve ermittelt. Um uns daran zu erinnern, was es bedeutet, sollten wir uns den ersten Teil des Wortes "inter" als "enter" vorstellen, was uns daran erinnert, "in" die Daten zu schauen, die wir ursprünglich hatten. Dieses Tool, die Interpolation, ist nicht nur in der Statistik nützlich, sondern auch in der Wissenschaft, in der Wirtschaft oder wenn Werte vorhergesagt werden müssen, die innerhalb von zwei vorhandenen Datenpunkten liegen.
Lassen Sie uns einige Daten erstellen und sehen, wie diese Interpolation mit dem durchgeführt werden kann scipy.interpolate Paket.
import numpy as np
from scipy import interpolate
import matplotlib.pyplot as plt
x = np.linspace(0, 4, 12)
y = np.cos(x**2/3+4)
print x,y
Das obige Programm erzeugt die folgende Ausgabe.
(
array([0., 0.36363636, 0.72727273, 1.09090909, 1.45454545, 1.81818182,
2.18181818, 2.54545455, 2.90909091, 3.27272727, 3.63636364, 4.]),
array([-0.65364362, -0.61966189, -0.51077021, -0.31047698, -0.00715476,
0.37976236, 0.76715099, 0.99239518, 0.85886263, 0.27994201,
-0.52586509, -0.99582185])
)
Jetzt haben wir zwei Arrays. Angenommen, diese beiden Arrays sind die beiden Dimensionen der Punkte im Raum. Zeichnen Sie mit dem folgenden Programm und sehen Sie, wie sie aussehen.
plt.plot(x, y,’o’)
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
1-D-Interpolation
Die interp1d-Klasse in scipy.interpolate ist eine bequeme Methode zum Erstellen einer Funktion basierend auf festen Datenpunkten, die mithilfe linearer Interpolation an einer beliebigen Stelle innerhalb der durch die angegebenen Daten definierten Domäne ausgewertet werden kann.
Lassen Sie uns unter Verwendung der obigen Daten eine Interpolationsfunktion erstellen und einen neuen interpolierten Graphen zeichnen.
f1 = interp1d(x, y,kind = 'linear')
f2 = interp1d(x, y, kind = 'cubic')
Mit der Funktion interp1d haben wir zwei Funktionen f1 und f2 erstellt. Diese Funktionen geben für eine gegebene Eingabe x y zurück. Die dritte Variablenart repräsentiert den Typ der Interpolationstechnik. 'Linear', 'Nearest', 'Zero', 'Slinear', 'Quadratic', 'Cubic' sind einige Interpolationstechniken.
Lassen Sie uns nun eine neue Eingabe mit größerer Länge erstellen, um den deutlichen Unterschied der Interpolation zu erkennen. Wir werden die gleiche Funktion der alten Daten für die neuen Daten verwenden.
xnew = np.linspace(0, 4,30)
plt.plot(x, y, 'o', xnew, f(xnew), '-', xnew, f2(xnew), '--')
plt.legend(['data', 'linear', 'cubic','nearest'], loc = 'best')
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
Splines
Um glatte Kurven durch Datenpunkte zu zeichnen, verwendeten die Zeichner einst dünne, flexible Streifen aus Holz, Hartgummi, Metall oder Kunststoff, die als mechanische Keile bezeichnet wurden. Um einen mechanischen Spline zu verwenden, wurden Stifte an einer vernünftigen Auswahl von Punkten entlang einer Kurve in einem Design platziert, und dann wurde der Spline gebogen, so dass er jeden dieser Stifte berührte.
Bei dieser Konstruktion interpoliert der Spline eindeutig die Kurve an diesen Stiften. Es kann verwendet werden, um die Kurve in anderen Zeichnungen zu reproduzieren. Die Punkte, an denen sich die Stifte befinden, werden als Knoten bezeichnet. Wir können die Form der durch den Spline definierten Kurve ändern, indem wir die Position der Knoten anpassen.
Univariate Spline
Der eindimensionale Glättungs-Spline passt zu einem bestimmten Satz von Datenpunkten. Die UnivariateSpline-Klasse in scipy.interpolate ist eine bequeme Methode zum Erstellen einer Funktion basierend auf der Klasse fester Datenpunkte - scipy.interpolate.UnivariateSpline (x, y, w = Keine, bbox = [Keine, Keine], k = 3, s = Keine, ext = 0, check_finite = False).
Parameters - Nachfolgend sind die Parameter eines univariaten Splines aufgeführt.
Dies passt einen Spline y = spl (x) vom Grad k an die bereitgestellten x, y-Daten an.
'w' - Gibt die Gewichte für die Spline-Anpassung an. Muss positiv sein. Wenn keine (Standard), sind alle Gewichte gleich.
's' - Gibt die Anzahl der Knoten an, indem eine Glättungsbedingung angegeben wird.
'k' - Grad des Glättungssplines. Muss <= 5 sein. Standard ist k = 3, ein kubischer Spline.
Ext - Steuert den Extrapolationsmodus für Elemente, die nicht in dem durch die Knotenfolge festgelegten Intervall liegen.
Wenn ext = 0 oder 'extrapolieren', wird der extrapolierte Wert zurückgegeben.
Wenn ext = 1 oder 'Null' ist, wird 0 zurückgegeben
Wenn ext = 2 oder 'erhöhen', wird ein ValueError ausgelöst
Wenn ext = 3 von 'const' ist, wird der Grenzwert zurückgegeben.
check_finite - Gibt an, ob überprüft werden soll, ob die Eingabearrays nur endliche Zahlen enthalten.
Betrachten wir das folgende Beispiel.
import matplotlib.pyplot as plt
from scipy.interpolate import UnivariateSpline
x = np.linspace(-3, 3, 50)
y = np.exp(-x**2) + 0.1 * np.random.randn(50)
plt.plot(x, y, 'ro', ms = 5)
plt.show()
Verwenden Sie den Standardwert für den Glättungsparameter.
spl = UnivariateSpline(x, y)
xs = np.linspace(-3, 3, 1000)
plt.plot(xs, spl(xs), 'g', lw = 3)
plt.show()
Ändern Sie den Grad der Glättung manuell.
spl.set_smoothing_factor(0.5)
plt.plot(xs, spl(xs), 'b', lw = 3)
plt.show()
Das Scipy.io-Paket (Eingabe und Ausgabe) bietet eine Vielzahl von Funktionen, mit denen Sie verschiedene Dateiformate umgehen können. Einige dieser Formate sind -
- Matlab
- IDL
- Matrix Market
- Wave
- Arff
- Netcdf usw.
Lassen Sie uns die am häufigsten verwendeten Dateiformate im Detail diskutieren -
MATLAB
Im Folgenden finden Sie die Funktionen zum Laden und Speichern einer .mat-Datei.
Sr. Nr. | Bedienungsanleitung |
---|---|
1 | loadmat Lädt eine MATLAB-Datei |
2 | savemat Speichert eine MATLAB-Datei |
3 | whosmat Listet Variablen in einer MATLAB-Datei auf |
Betrachten wir das folgende Beispiel.
import scipy.io as sio
import numpy as np
#Save a mat file
vect = np.arange(10)
sio.savemat('array.mat', {'vect':vect})
#Now Load the File
mat_file_content = sio.loadmat(‘array.mat’)
Print mat_file_content
Das obige Programm erzeugt die folgende Ausgabe.
{
'vect': array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]), '__version__': '1.0',
'__header__': 'MATLAB 5.0 MAT-file Platform: posix, Created on: Sat Sep 30
09:49:32 2017', '__globals__': []
}
Wir können das Array zusammen mit den Meta-Informationen sehen. Wenn Sie den Inhalt einer MATLAB-Datei überprüfen möchten, ohne die Daten in den Speicher einzulesen, verwenden Sie diewhosmat command Wie nachfolgend dargestellt.
import scipy.io as sio
mat_file_content = sio.whosmat(‘array.mat’)
print mat_file_content
Das obige Programm erzeugt die folgende Ausgabe.
[('vect', (1, 10), 'int64')]
SciPy wird mit dem optimierten erstellt ATLAS LAPACK und BLASBibliotheken. Es hat sehr schnelle lineare Algebra-Fähigkeiten. Alle diese linearen Algebra-Routinen erwarten ein Objekt, das in ein zweidimensionales Array konvertiert werden kann. Die Ausgabe dieser Routinen ist ebenfalls ein zweidimensionales Array.
SciPy.linalg vs NumPy.linalg
Eine scipy.linalg enthält alle Funktionen, die in numpy.linalg enthalten sind. Darüber hinaus verfügt scipy.linalg über einige andere erweiterte Funktionen, die nicht in numpy.linalg enthalten sind. Ein weiterer Vorteil der Verwendung von scipy.linalg gegenüber numpy.linalg besteht darin, dass es immer mit BLAS / LAPACK-Unterstützung kompiliert wird, während dies für NumPy optional ist. Daher ist die SciPy-Version möglicherweise schneller, je nachdem, wie NumPy installiert wurde.
Lineare Gleichungen
Das scipy.linalg.solve Feature löst die lineare Gleichung a * x + b * y = Z für die unbekannten x, y-Werte.
Angenommen, es ist erwünscht, die folgenden simultanen Gleichungen zu lösen.
x + 3y + 5z = 10
2x + 5y + z = 8
2x + 3y + 8z = 3
Um die obige Gleichung für die x-, y- und z-Werte zu lösen, können wir den Lösungsvektor unter Verwendung einer inversen Matrix finden, wie unten gezeigt.
$$\begin{bmatrix} x\\ y\\ z \end{bmatrix} = \begin{bmatrix} 1 & 3 & 5\\ 2 & 5 & 1\\ 2 & 3 & 8 \end{bmatrix}^{-1} \begin{bmatrix} 10\\ 8\\ 3 \end{bmatrix} = \frac{1}{25} \begin{bmatrix} -232\\ 129\\ 19 \end{bmatrix} = \begin{bmatrix} -9.28\\ 5.16\\ 0.76 \end{bmatrix}.$$
Es ist jedoch besser, die zu verwenden linalg.solve Befehl, der schneller und numerisch stabiler sein kann.
Die Lösungsfunktion verwendet zwei Eingaben 'a' und 'b', wobei 'a' die Koeffizienten und 'b' den jeweiligen Wert auf der rechten Seite darstellt und das Lösungsarray zurückgibt.
Betrachten wir das folgende Beispiel.
#importing the scipy and numpy packages
from scipy import linalg
import numpy as np
#Declaring the numpy arrays
a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
b = np.array([2, 4, -1])
#Passing the values to the solve function
x = linalg.solve(a, b)
#printing the result array
print x
Das obige Programm erzeugt die folgende Ausgabe.
array([ 2., -2., 9.])
Eine Determinante finden
Die Determinante einer quadratischen Matrix A wird oft als | A | bezeichnet und ist eine Größe, die häufig in der linearen Algebra verwendet wird. In SciPy wird dies mit dem berechnetdet()Funktion. Es nimmt eine Matrix als Eingabe und gibt einen Skalarwert zurück.
Betrachten wir das folgende Beispiel.
#importing the scipy and numpy packages
from scipy import linalg
import numpy as np
#Declaring the numpy array
A = np.array([[1,2],[3,4]])
#Passing the values to the det function
x = linalg.det(A)
#printing the result
print x
Das obige Programm erzeugt die folgende Ausgabe.
-2.0
Eigenwerte und Eigenvektoren
Das Eigenwert-Eigenvektor-Problem ist eine der am häufigsten verwendeten linearen Algebraoperationen. Wir können die Eigenwerte (λ) und die entsprechenden Eigenvektoren (v) einer quadratischen Matrix (A) finden, indem wir die folgende Beziehung betrachten:
Av = λv
scipy.linalg.eigberechnet die Eigenwerte aus einem gewöhnlichen oder verallgemeinerten Eigenwertproblem. Diese Funktion gibt die Eigenwerte und die Eigenvektoren zurück.
Betrachten wir das folgende Beispiel.
#importing the scipy and numpy packages
from scipy import linalg
import numpy as np
#Declaring the numpy array
A = np.array([[1,2],[3,4]])
#Passing the values to the eig function
l, v = linalg.eig(A)
#printing the result for eigen values
print l
#printing the result for eigen vectors
print v
Das obige Programm erzeugt die folgende Ausgabe.
array([-0.37228132+0.j, 5.37228132+0.j]) #--Eigen Values
array([[-0.82456484, -0.41597356], #--Eigen Vectors
[ 0.56576746, -0.90937671]])
Einzelwertzerlegung
Eine Singular Value Decomposition (SVD) kann als Erweiterung des Eigenwertproblems auf Matrizen angesehen werden, die nicht quadratisch sind.
Das scipy.linalg.svd faktorisiert die Matrix 'a' in zwei einheitliche Matrizen 'U' und 'Vh' und ein 1-D-Array 's' von Singularwerten (real, nicht negativ), so dass a == U * S * Vh, wobei 'S. 'ist eine geeignet geformte Matrix von Nullen mit der Hauptdiagonale' s '.
Betrachten wir das folgende Beispiel.
#importing the scipy and numpy packages
from scipy import linalg
import numpy as np
#Declaring the numpy array
a = np.random.randn(3, 2) + 1.j*np.random.randn(3, 2)
#Passing the values to the eig function
U, s, Vh = linalg.svd(a)
# printing the result
print U, Vh, s
Das obige Programm erzeugt die folgende Ausgabe.
(
array([
[ 0.54828424-0.23329795j, -0.38465728+0.01566714j,
-0.18764355+0.67936712j],
[-0.27123194-0.5327436j , -0.57080163-0.00266155j,
-0.39868941-0.39729416j],
[ 0.34443818+0.4110186j , -0.47972716+0.54390586j,
0.25028608-0.35186815j]
]),
array([ 3.25745379, 1.16150607]),
array([
[-0.35312444+0.j , 0.32400401+0.87768134j],
[-0.93557636+0.j , -0.12229224-0.33127251j]
])
)
Das SciPy ndimage-Submodul ist der Bildverarbeitung gewidmet. Ndimage bedeutet hier ein n-dimensionales Bild.
Einige der häufigsten Aufgaben bei der Bildverarbeitung sind: & miuns;
- Eingabe / Ausgabe, Anzeige von Bildern
- Grundlegende Manipulationen - Zuschneiden, Drehen, Drehen usw.
- Bildfilterung - Rauschen, Schärfen usw.
- Bildsegmentierung - Beschriften von Pixeln, die verschiedenen Objekten entsprechen
- Classification
- Merkmalsextraktion
- Registration
Lassen Sie uns diskutieren, wie einige davon mit SciPy erreicht werden können.
Öffnen und Schreiben in Bilddateien
Das misc packagein SciPy kommt mit einigen Bildern. Wir verwenden diese Bilder, um die Bildmanipulationen zu lernen. Betrachten wir das folgende Beispiel.
from scipy import misc
f = misc.face()
misc.imsave('face.png', f) # uses the Image module (PIL)
import matplotlib.pyplot as plt
plt.imshow(f)
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
Alle Bilder in ihrem Rohformat sind die Kombination von Farben, die durch die Zahlen im Matrixformat dargestellt werden. Eine Maschine versteht und manipuliert die Bilder nur anhand dieser Zahlen. RGB ist eine beliebte Darstellungsweise.
Lassen Sie uns die statistischen Informationen des obigen Bildes sehen.
from scipy import misc
face = misc.face(gray = False)
print face.mean(), face.max(), face.min()
Das obige Programm erzeugt die folgende Ausgabe.
110.16274388631184, 255, 0
Jetzt wissen wir, dass das Bild aus Zahlen besteht, sodass jede Änderung des Werts der Zahl das Originalbild verändert. Lassen Sie uns einige geometrische Transformationen am Bild durchführen. Die grundlegende geometrische Operation ist das Zuschneiden
from scipy import misc
face = misc.face(gray = True)
lx, ly = face.shape
# Cropping
crop_face = face[lx / 4: - lx / 4, ly / 4: - ly / 4]
import matplotlib.pyplot as plt
plt.imshow(crop_face)
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
Wir können auch einige grundlegende Vorgänge ausführen, z. B. das Bild wie unten beschrieben auf den Kopf stellen.
# up <-> down flip
from scipy import misc
face = misc.face()
flip_ud_face = np.flipud(face)
import matplotlib.pyplot as plt
plt.imshow(flip_ud_face)
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
Außerdem haben wir die rotate() function, wodurch das Bild um einen bestimmten Winkel gedreht wird.
# rotation
from scipy import misc,ndimage
face = misc.face()
rotate_face = ndimage.rotate(face, 45)
import matplotlib.pyplot as plt
plt.imshow(rotate_face)
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
Filter
Lassen Sie uns diskutieren, wie Filter bei der Bildverarbeitung helfen.
Was ist Filterung in der Bildverarbeitung?
Das Filtern ist eine Technik zum Ändern oder Verbessern eines Bildes. Sie können beispielsweise ein Bild filtern, um bestimmte Funktionen hervorzuheben oder andere Funktionen zu entfernen. Mit der Filterung implementierte Bildverarbeitungsvorgänge umfassen Glätten, Schärfen und Kantenverbesserung.
Das Filtern ist eine Nachbarschaftsoperation, bei der der Wert eines gegebenen Pixels im Ausgabebild durch Anwenden eines Algorithmus auf die Werte der Pixel in der Nachbarschaft des entsprechenden Eingangspixels bestimmt wird. Lassen Sie uns nun einige Operationen mit SciPy ndimage ausführen.
Unschärfe
Unschärfe wird häufig verwendet, um das Bildrauschen zu reduzieren. Wir können eine Filteroperation durchführen und die Änderung im Bild sehen. Betrachten wir das folgende Beispiel.
from scipy import misc
face = misc.face()
blurred_face = ndimage.gaussian_filter(face, sigma=3)
import matplotlib.pyplot as plt
plt.imshow(blurred_face)
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
Der Sigma-Wert gibt den Grad der Unschärfe auf einer Skala von fünf an. Wir können die Änderung der Bildqualität sehen, indem wir den Sigma-Wert einstellen. Weitere Informationen zum Verwischen finden Sie im → DIP-Tutorial (Digital Image Processing).
Kantenerkennung
Lassen Sie uns diskutieren, wie die Kantenerkennung bei der Bildverarbeitung hilft.
Was ist Kantenerkennung?
Die Kantenerkennung ist eine Bildverarbeitungstechnik zum Auffinden der Grenzen von Objekten in Bildern. Es erkennt Diskontinuitäten in der Helligkeit. Die Kantenerkennung wird zur Bildsegmentierung und Datenextraktion in Bereichen wie Bildverarbeitung, Computer Vision und Machine Vision verwendet.
Die am häufigsten verwendeten Kantenerkennungsalgorithmen umfassen
- Sobel
- Canny
- Prewitt
- Roberts
- Fuzzy-Logik-Methoden
Betrachten wir das folgende Beispiel.
import scipy.ndimage as nd
import numpy as np
im = np.zeros((256, 256))
im[64:-64, 64:-64] = 1
im[90:-90,90:-90] = 2
im = ndimage.gaussian_filter(im, 8)
import matplotlib.pyplot as plt
plt.imshow(im)
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
Das Bild sieht aus wie ein quadratischer Farbblock. Jetzt werden wir die Kanten dieser farbigen Blöcke erkennen. Hier bietet ndimage eine Funktion namensSobelum diesen Vorgang auszuführen. NumPy bietet dieHypot Funktion, um die beiden resultierenden Matrizen zu einer zu kombinieren.
Betrachten wir das folgende Beispiel.
import scipy.ndimage as nd
import matplotlib.pyplot as plt
im = np.zeros((256, 256))
im[64:-64, 64:-64] = 1
im[90:-90,90:-90] = 2
im = ndimage.gaussian_filter(im, 8)
sx = ndimage.sobel(im, axis = 0, mode = 'constant')
sy = ndimage.sobel(im, axis = 1, mode = 'constant')
sob = np.hypot(sx, sy)
plt.imshow(sob)
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
Das scipy.optimize packagebietet mehrere häufig verwendete Optimierungsalgorithmen. Dieses Modul enthält folgende Aspekte:
Uneingeschränkte und eingeschränkte Minimierung multivariater Skalarfunktionen (minim ()) unter Verwendung einer Vielzahl von Algorithmen (z. B. BFGS, Nelder-Mead-Simplex, Newton-Konjugat-Gradient, COBYLA oder SLSQP)
Globale (Brute-Force-) Optimierungsroutinen (z. B. Anneal (), Basinhopping ())
Algorithmen zur Minimierung der kleinsten Quadrate (Leastsq ()) und zur Kurvenanpassung (Curve_fit ())
Minimierer für univariate Skalarfunktionen (minim_scalar ()) und Wurzelfinder (newton ())
Multivariate Gleichungssystemlöser (root ()) unter Verwendung einer Vielzahl von Algorithmen (z. B. Hybrid-Powell, Levenberg-Marquardt oder groß angelegte Methoden wie Newton-Krylov)
Unbeschränkte und eingeschränkte Minimierung multivariater Skalarfunktionen
Das minimize() function bietet eine gemeinsame Schnittstelle zu uneingeschränkten und eingeschränkten Minimierungsalgorithmen für multivariate Skalarfunktionen in scipy.optimize. Betrachten Sie zur Demonstration der Minimierungsfunktion das Problem der Minimierung der Rosenbrock-Funktion der NN-Variablen -
$$f(x) = \sum_{i = 1}^{N-1} \:100(x_i - x_{i-1}^{2})$$
Der Minimalwert dieser Funktion ist 0, was erreicht wird, wenn xi = 1 ist.
Nelder-Mead-Simplex-Algorithmus
Im folgenden Beispiel wird die Routine minim () mit dem verwendet Nelder-Mead simplex algorithm (method = 'Nelder-Mead')(ausgewählt über den Methodenparameter). Betrachten wir das folgende Beispiel.
import numpy as np
from scipy.optimize import minimize
def rosen(x):
x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
res = minimize(rosen, x0, method='nelder-mead')
print(res.x)
Das obige Programm erzeugt die folgende Ausgabe.
[7.93700741e+54 -5.41692163e+53 6.28769150e+53 1.38050484e+55 -4.14751333e+54]
Der Simplex-Algorithmus ist wahrscheinlich der einfachste Weg, um eine ziemlich gut verhaltene Funktion zu minimieren. Es erfordert nur Funktionsbewertungen und ist eine gute Wahl für einfache Minimierungsprobleme. Da jedoch keine Gradientenauswertungen verwendet werden, kann es länger dauern, bis das Minimum gefunden ist.
Ein weiterer Optimierungsalgorithmus, der nur Funktionsaufrufe benötigt, um das Minimum zu finden, ist der Powell‘s method, die durch Setzen von method = 'powell' in der Funktion minim () verfügbar ist.
Kleinsten Quadrate
Lösen Sie ein nichtlineares Problem der kleinsten Quadrate mit Grenzen für die Variablen. Bei den Residuen f (x) (eine m-dimensionale reelle Funktion von n reellen Variablen) und der Verlustfunktion rho (s) (eine Skalarfunktion) finden die kleinsten Quadrate ein lokales Minimum der Kostenfunktion F (x). Betrachten wir das folgende Beispiel.
In diesem Beispiel finden wir ein Minimum der Rosenbrock-Funktion ohne Grenzen für die unabhängigen Variablen.
#Rosenbrock Function
def fun_rosenbrock(x):
return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])
from scipy.optimize import least_squares
input = np.array([2, 2])
res = least_squares(fun_rosenbrock, input)
print res
Beachten Sie, dass wir nur den Vektor der Residuen angeben. Der Algorithmus konstruiert die Kostenfunktion als Summe der Quadrate der Residuen, was die Rosenbrock-Funktion ergibt. Das genaue Minimum liegt bei x = [1.0,1.0].
Das obige Programm erzeugt die folgende Ausgabe.
active_mask: array([ 0., 0.])
cost: 9.8669242910846867e-30
fun: array([ 4.44089210e-15, 1.11022302e-16])
grad: array([ -8.89288649e-14, 4.44089210e-14])
jac: array([[-20.00000015,10.],[ -1.,0.]])
message: '`gtol` termination condition is satisfied.'
nfev: 3
njev: 3
optimality: 8.8928864934219529e-14
status: 1
success: True
x: array([ 1., 1.])
Wurzelfindung
Lassen Sie uns verstehen, wie Root Finding in SciPy hilft.
Skalarfunktionen
Wenn man eine Einzelvariablengleichung hat, gibt es vier verschiedene Wurzelfindungsalgorithmen, die ausprobiert werden können. Jeder dieser Algorithmen erfordert die Endpunkte eines Intervalls, in dem eine Wurzel erwartet wird (weil die Funktion die Vorzeichen ändert). Im Allgemeinen,brentq ist die beste Wahl, aber die anderen Methoden können unter bestimmten Umständen oder für akademische Zwecke nützlich sein.
Fixpunktlösung
Ein Problem, das eng mit dem Finden der Nullen einer Funktion zusammenhängt, ist das Problem, einen festen Punkt einer Funktion zu finden. Ein fester Punkt einer Funktion ist der Punkt, an dem die Auswertung der Funktion den Punkt zurückgibt: g (x) = x. Klar der Fixpunkt vonggist die Wurzel von f (x) = g (x) −x. Entsprechend die Wurzel vonffist der feste Punkt von g (x) = f (x) + x. Die Routine fixed_point bietet eine einfache iterative Methode unter Verwendung vonAitkens sequence acceleration den festen Punkt von schätzen gg, wenn ein Ausgangspunkt angegeben ist.
Gleichungssysteme
Das Finden einer Wurzel eines Satzes nichtlinearer Gleichungen kann unter Verwendung der erreicht werden root() function. Es stehen verschiedene Methoden zur Verfügung, darunterhybr (Standardeinstellung) und lm verwenden jeweils die hybrid method of Powell und die Levenberg-Marquardt method aus dem MINPACK.
Das folgende Beispiel betrachtet die transzendentale Gleichung mit einer Variablen.
x2 + 2cos(x) = 0
Eine Wurzel davon kann wie folgt gefunden werden -
import numpy as np
from scipy.optimize import root
def func(x):
return x*2 + 2 * np.cos(x)
sol = root(func, 0.3)
print sol
Das obige Programm erzeugt die folgende Ausgabe.
fjac: array([[-1.]])
fun: array([ 2.22044605e-16])
message: 'The solution converged.'
nfev: 10
qtf: array([ -2.77644574e-12])
r: array([-3.34722409])
status: 1
success: True
x: array([-0.73908513])
Alle Statistikfunktionen befinden sich im Unterpaket scipy.stats und eine ziemlich vollständige Auflistung dieser Funktionen kann unter Verwendung von erhalten werden info(stats)Funktion. Eine Liste der verfügbaren Zufallsvariablen erhalten Sie auch von derdocstringfür das Statistik-Unterpaket. Dieses Modul enthält eine Vielzahl von Wahrscheinlichkeitsverteilungen sowie eine wachsende Bibliothek statistischer Funktionen.
Jede univariate Verteilung hat eine eigene Unterklasse, wie in der folgenden Tabelle beschrieben -
Sr. Nr. | Klasse & Beschreibung |
---|---|
1 | rv_continuous Eine generische kontinuierliche Zufallsvariablenklasse für Unterklassen |
2 | rv_discrete Eine generische diskrete Zufallsvariablenklasse für Unterklassen |
3 | rv_histogram Erzeugt eine Verteilung, die durch ein Histogramm angegeben wird |
Normale kontinuierliche Zufallsvariable
Eine Wahrscheinlichkeitsverteilung, bei der die Zufallsvariable X einen beliebigen Wert annehmen kann, ist eine kontinuierliche Zufallsvariable. Das Schlüsselwort location (loc) gibt den Mittelwert an. Das Schlüsselwort scale (scale) gibt die Standardabweichung an.
Als Beispiel für die rv_continuous Klasse, norm object erbt von ihm eine Sammlung generischer Methoden und vervollständigt sie mit Details, die für diese bestimmte Distribution spezifisch sind.
Um die CDF an mehreren Punkten zu berechnen, können wir eine Liste oder ein NumPy-Array übergeben. Betrachten wir das folgende Beispiel.
from scipy.stats import norm
import numpy as np
print norm.cdf(np.array([1,-1., 0, 1, 3, 4, -2, 6]))
Das obige Programm erzeugt die folgende Ausgabe.
array([ 0.84134475, 0.15865525, 0.5 , 0.84134475, 0.9986501 ,
0.99996833, 0.02275013, 1. ])
Um den Median einer Verteilung zu ermitteln, können wir die Percent Point Function (PPF) verwenden, die die Umkehrung der CDF ist. Lassen Sie uns anhand des folgenden Beispiels verstehen.
from scipy.stats import norm
print norm.ppf(0.5)
Das obige Programm erzeugt die folgende Ausgabe.
0.0
Um eine Folge von Zufallsvariablen zu generieren, sollten wir das Schlüsselwortargument size verwenden, das im folgenden Beispiel gezeigt wird.
from scipy.stats import norm
print norm.rvs(size = 5)
Das obige Programm erzeugt die folgende Ausgabe.
array([ 0.20929928, -1.91049255, 0.41264672, -0.7135557 , -0.03833048])
Die obige Ausgabe ist nicht reproduzierbar. Verwenden Sie die Startfunktion, um dieselben Zufallszahlen zu generieren.
Gleichmäßige Verteilung
Mit der Gleichfunktion kann eine Gleichverteilung erzeugt werden. Betrachten wir das folgende Beispiel.
from scipy.stats import uniform
print uniform.cdf([0, 1, 2, 3, 4, 5], loc = 1, scale = 4)
Das obige Programm erzeugt die folgende Ausgabe.
array([ 0. , 0. , 0.25, 0.5 , 0.75, 1. ])
Diskrete Verteilung erstellen
Lassen Sie uns eine Zufallsstichprobe erstellen und die beobachteten Frequenzen mit den Wahrscheinlichkeiten vergleichen.
Binomialverteilung
Als Beispiel für die rv_discrete class, das binom objecterbt davon eine Sammlung generischer Methoden und vervollständigt sie mit Details, die für diese bestimmte Distribution spezifisch sind. Betrachten wir das folgende Beispiel.
from scipy.stats import uniform
print uniform.cdf([0, 1, 2, 3, 4, 5], loc = 1, scale = 4)
Das obige Programm erzeugt die folgende Ausgabe.
array([ 0. , 0. , 0.25, 0.5 , 0.75, 1. ])
Beschreibende Statistik
Die grundlegenden Statistiken wie Min, Max, Mean und Varianz verwenden das NumPy-Array als Eingabe und geben die entsprechenden Ergebnisse zurück. Einige grundlegende statistische Funktionen finden Sie in derscipy.stats package sind in der folgenden Tabelle beschrieben.
Sr. Nr. | Bedienungsanleitung |
---|---|
1 | describe() Berechnet mehrere beschreibende Statistiken des übergebenen Arrays |
2 | gmean() Berechnet den geometrischen Mittelwert entlang der angegebenen Achse |
3 | hmean() Berechnet den harmonischen Mittelwert entlang der angegebenen Achse |
4 | kurtosis() Berechnet die Kurtosis |
5 | mode() Gibt den Modalwert zurück |
6 | skew() Testet die Schiefe der Daten |
7 | f_oneway() Führt eine Einweg-ANOVA durch |
8 | iqr() Berechnet den Interquartilbereich der Daten entlang der angegebenen Achse |
9 | zscore() Berechnet den z-Wert jedes Werts in der Stichprobe relativ zum Stichprobenmittelwert und zur Standardabweichung |
10 | sem() Berechnet den Standardfehler des Mittelwerts (oder Standardmessfehlers) der Werte im Eingabearray |
Einige dieser Funktionen haben eine ähnliche Version in der scipy.stats.mstats, die für maskierte Arrays funktionieren. Lassen Sie uns dies anhand des folgenden Beispiels verstehen.
from scipy import stats
import numpy as np
x = np.array([1,2,3,4,5,6,7,8,9])
print x.max(),x.min(),x.mean(),x.var()
Das obige Programm erzeugt die folgende Ausgabe.
(9, 1, 5.0, 6.666666666666667)
T-Test
Lassen Sie uns verstehen, wie nützlich T-Test in SciPy ist.
ttest_1samp
Berechnet den T-Test für den Mittelwert EINER Gruppe von Bewertungen. Dies ist ein zweiseitiger Test für die Nullhypothese, dass der erwartete Wert (Mittelwert) einer Stichprobe unabhängiger Beobachtungen 'a' gleich dem angegebenen Populationsmittelwert ist.popmean. Betrachten wir das folgende Beispiel.
from scipy import stats
rvs = stats.norm.rvs(loc = 5, scale = 10, size = (50,2))
print stats.ttest_1samp(rvs,5.0)
Das obige Programm erzeugt die folgende Ausgabe.
Ttest_1sampResult(statistic = array([-1.40184894, 2.70158009]),
pvalue = array([ 0.16726344, 0.00945234]))
Vergleich zweier Proben
In den folgenden Beispielen gibt es zwei Stichproben, die entweder aus derselben oder einer unterschiedlichen Verteilung stammen können, und wir möchten testen, ob diese Stichproben dieselben statistischen Eigenschaften aufweisen.
ttest_ind- Berechnet den T-Test für die Mittelwerte zweier unabhängiger Stichproben. Dies ist ein zweiseitiger Test für die Nullhypothese, dass zwei unabhängige Stichproben identische Durchschnittswerte (erwartete Werte) aufweisen. Bei diesem Test wird davon ausgegangen, dass die Populationen standardmäßig identische Varianzen aufweisen.
Wir können diesen Test verwenden, wenn wir zwei unabhängige Proben aus derselben oder einer unterschiedlichen Population beobachten. Betrachten wir das folgende Beispiel.
from scipy import stats
rvs1 = stats.norm.rvs(loc = 5,scale = 10,size = 500)
rvs2 = stats.norm.rvs(loc = 5,scale = 10,size = 500)
print stats.ttest_ind(rvs1,rvs2)
Das obige Programm erzeugt die folgende Ausgabe.
Ttest_indResult(statistic = -0.67406312233650278, pvalue = 0.50042727502272966)
Sie können dasselbe mit einem neuen Array gleicher Länge, aber mit einem variierten Mittelwert testen. Verwenden Sie einen anderen Wert inloc und testen Sie das gleiche.
CSGraph steht für Compressed Sparse Graph, das sich auf Fast-Graph-Algorithmen konzentriert, die auf Darstellungen mit geringer Matrix basieren.
Diagrammdarstellungen
Lassen Sie uns zunächst verstehen, was ein spärliches Diagramm ist und wie es bei der Darstellung von Diagrammen hilft.
Was genau ist ein spärlicher Graph?
Ein Diagramm ist nur eine Sammlung von Knoten, zwischen denen Verknüpfungen bestehen. Diagramme können fast alles darstellen - soziale Netzwerkverbindungen, bei denen jeder Knoten eine Person ist und mit Bekannten verbunden ist; Bilder, wobei jeder Knoten ein Pixel ist und mit benachbarten Pixeln verbunden ist; Punkte in einer hochdimensionalen Verteilung, an denen jeder Knoten mit seinen nächsten Nachbarn verbunden ist; und praktisch alles andere, was Sie sich vorstellen können.
Eine sehr effiziente Methode zur Darstellung von Graphendaten ist eine spärliche Matrix: Nennen wir sie G. Die Matrix G hat die Größe N x N, und G [i, j] gibt den Wert der Verbindung zwischen Knoten 'i' und Knoten an 'j'. Ein spärlicher Graph enthält meistens Nullen - das heißt, die meisten Knoten haben nur wenige Verbindungen. Diese Eigenschaft stellt sich in den meisten Fällen von Interesse als wahr heraus.
Die Erstellung des Submoduls für spärliche Graphen wurde durch verschiedene Algorithmen motiviert, die beim Scikit-Lernen verwendet wurden.
Isomap - Ein vielfältiger Lernalgorithmus, bei dem die kürzesten Wege in einem Diagramm gefunden werden müssen.
Hierarchical clustering - Ein Clustering-Algorithmus, der auf einem minimalen Spanning Tree basiert.
Spectral Decomposition - Ein Projektionsalgorithmus, der auf Laplacianern mit geringer Dichte basiert.
Stellen Sie sich als konkretes Beispiel vor, wir möchten das folgende ungerichtete Diagramm darstellen:
Dieser Graph hat drei Knoten, wobei die Knoten 0 und 1 durch eine Kante des Gewichts 2 verbunden sind und die Knoten 0 und 2 durch eine Kante des Gewichts 1 verbunden sind. Wir können die dichten, maskierten und spärlichen Darstellungen wie im folgenden Beispiel gezeigt konstruieren Dabei ist zu beachten, dass ein ungerichteter Graph durch eine symmetrische Matrix dargestellt wird.
G_dense = np.array([ [0, 2, 1],
[2, 0, 0],
[1, 0, 0] ])
G_masked = np.ma.masked_values(G_dense, 0)
from scipy.sparse import csr_matrix
G_sparse = csr_matrix(G_dense)
print G_sparse.data
Das obige Programm erzeugt die folgende Ausgabe.
array([2, 1, 2, 1])
Dies ist identisch mit dem vorherigen Diagramm, außer dass die Knoten 0 und 2 durch eine Kante mit einem Gewicht von Null verbunden sind. In diesem Fall führt die obige dichte Darstellung zu Mehrdeutigkeiten - wie können Nichtkanten dargestellt werden, wenn Null ein aussagekräftiger Wert ist? In diesem Fall muss entweder eine maskierte oder eine spärliche Darstellung verwendet werden, um die Mehrdeutigkeit zu beseitigen.
Betrachten wir das folgende Beispiel.
from scipy.sparse.csgraph import csgraph_from_dense
G2_data = np.array
([
[np.inf, 2, 0 ],
[2, np.inf, np.inf],
[0, np.inf, np.inf]
])
G2_sparse = csgraph_from_dense(G2_data, null_value=np.inf)
print G2_sparse.data
Das obige Programm erzeugt die folgende Ausgabe.
array([ 2., 0., 2., 0.])
Wortleitern mit spärlichen Diagrammen
Wortleitern ist ein von Lewis Carroll erfundenes Spiel, bei dem Wörter durch Ändern eines einzelnen Buchstabens bei jedem Schritt verknüpft werden. Zum Beispiel -
APE → APT → AIT → BIT → BIG → BAG → MAG → MAN
Hier sind wir in sieben Schritten von "APE" zu "MAN" gewechselt und haben jedes Mal einen Buchstaben geändert. Die Frage ist: Können wir nach derselben Regel einen kürzeren Weg zwischen diesen Wörtern finden? Dieses Problem wird natürlich als Problem mit spärlichen Graphen ausgedrückt. Die Knoten entsprechen einzelnen Wörtern, und wir stellen Verbindungen zwischen Wörtern her, die sich höchstens um einen Buchstaben unterscheiden.
Eine Liste von Wörtern erhalten
Zunächst müssen wir natürlich eine Liste gültiger Wörter erhalten. Ich verwende Mac und Mac hat ein Wortwörterbuch an der im folgenden Codeblock angegebenen Stelle. Wenn Sie sich in einer anderen Architektur befinden, müssen Sie möglicherweise ein wenig suchen, um Ihr Systemwörterbuch zu finden.
wordlist = open('/usr/share/dict/words').read().split()
print len(wordlist)
Das obige Programm erzeugt die folgende Ausgabe.
235886
Wir wollen uns jetzt Wörter der Länge 3 ansehen, also lassen Sie uns nur die Wörter der richtigen Länge auswählen. Wir werden auch Wörter entfernen, die mit Großbuchstaben (Eigennamen) beginnen oder nicht alphanumerische Zeichen wie Apostrophe und Bindestriche enthalten. Schließlich werden wir später für einen Vergleich sicherstellen, dass alles in Kleinbuchstaben geschrieben ist.
word_list = [word for word in word_list if len(word) == 3]
word_list = [word for word in word_list if word[0].islower()]
word_list = [word for word in word_list if word.isalpha()]
word_list = map(str.lower, word_list)
print len(word_list)
Das obige Programm erzeugt die folgende Ausgabe.
1135
Jetzt haben wir eine Liste mit 1135 gültigen Wörtern aus drei Buchstaben (die genaue Anzahl kann sich je nach verwendeter Liste ändern). Jedes dieser Wörter wird zu einem Knoten in unserem Diagramm, und wir erstellen Kanten, die die Knoten verbinden, die jedem Wortpaar zugeordnet sind, was sich nur um einen Buchstaben unterscheidet.
import numpy as np
word_list = np.asarray(word_list)
word_list.dtype
word_list.sort()
word_bytes = np.ndarray((word_list.size, word_list.itemsize),
dtype = 'int8',
buffer = word_list.data)
print word_bytes.shape
Das obige Programm erzeugt die folgende Ausgabe.
(1135, 3)
Wir werden den Hamming-Abstand zwischen jedem Punkt verwenden, um zu bestimmen, welche Wortpaare verbunden sind. Der Hamming-Abstand misst den Bruchteil der Einträge zwischen zwei Vektoren, die sich unterscheiden: zwei beliebige Wörter mit einem Hamming-Abstand von 1 / N1 / N, wobei NN die Anzahl der Buchstaben ist, die in der Wortleiter verbunden sind.
from scipy.spatial.distance import pdist, squareform
from scipy.sparse import csr_matrix
hamming_dist = pdist(word_bytes, metric = 'hamming')
graph = csr_matrix(squareform(hamming_dist < 1.5 / word_list.itemsize))
Beim Vergleich der Abstände verwenden wir keine Gleichheit, da dies für Gleitkommawerte instabil sein kann. Die Ungleichung erzeugt das gewünschte Ergebnis, solange keine zwei Einträge der Wortliste identisch sind. Nachdem unser Diagramm eingerichtet ist, verwenden wir die Suche nach dem kürzesten Pfad, um den Pfad zwischen zwei beliebigen Wörtern im Diagramm zu finden.
i1 = word_list.searchsorted('ape')
i2 = word_list.searchsorted('man')
print word_list[i1],word_list[i2]
Das obige Programm erzeugt die folgende Ausgabe.
ape, man
Wir müssen überprüfen, ob diese übereinstimmen, denn wenn die Wörter nicht in der Liste enthalten sind, tritt ein Fehler in der Ausgabe auf. Jetzt müssen wir nur noch den kürzesten Weg zwischen diesen beiden Indizes im Diagramm finden. Wir werden verwendendijkstra’s Algorithmus, weil es uns ermöglicht, den Pfad für nur einen Knoten zu finden.
from scipy.sparse.csgraph import dijkstra
distances, predecessors = dijkstra(graph, indices = i1, return_predecessors = True)
print distances[i2]
Das obige Programm erzeugt die folgende Ausgabe.
5.0
Wir sehen also, dass der kürzeste Weg zwischen "Affe" und "Mensch" nur fünf Schritte enthält. Wir können die vom Algorithmus zurückgegebenen Vorgänger verwenden, um diesen Pfad zu rekonstruieren.
path = []
i = i2
while i != i1:
path.append(word_list[i])
i = predecessors[i]
path.append(word_list[i1])
print path[::-1]i2]
Das obige Programm erzeugt die folgende Ausgabe.
['ape', 'ope', 'opt', 'oat', 'mat', 'man']
Das scipy.spatial package kann Triangulationen, Voronoi-Diagramme und konvexe Rümpfe einer Reihe von Punkten berechnen, indem die Qhull library. Darüber hinaus enthält esKDTree implementations für Punktabfragen zum nächsten Nachbarn und Dienstprogramme für Entfernungsberechnungen in verschiedenen Metriken.
Delaunay-Triangulationen
Lassen Sie uns verstehen, was Delaunay-Triangulationen sind und wie sie in SciPy verwendet werden.
Was sind Delaunay-Triangulationen?
In Mathematik und Computergeometrie eine Delaunay-Triangulation für eine gegebene Menge P von diskreten Punkten in einer Ebene ist eine Triangulation DT(P) so dass kein Punkt in P befindet sich innerhalb des Kreises eines Dreiecks in DT (P).
Wir können das gleiche über SciPy berechnen. Betrachten wir das folgende Beispiel.
from scipy.spatial import Delaunay
points = np.array([[0, 4], [2, 1.1], [1, 3], [1, 2]])
tri = Delaunay(points)
import matplotlib.pyplot as plt
plt.triplot(points[:,0], points[:,1], tri.simplices.copy())
plt.plot(points[:,0], points[:,1], 'o')
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
Koplanare Punkte
Lassen Sie uns verstehen, was koplanare Punkte sind und wie sie in SciPy verwendet werden.
Was sind koplanare Punkte?
Koplanare Punkte sind drei oder mehr Punkte, die in derselben Ebene liegen. Denken Sie daran, dass eine Ebene eine flache Oberfläche ist, die sich ohne Ende in alle Richtungen erstreckt. Es wird normalerweise in Mathematiklehrbüchern als vierseitige Figur dargestellt.
Lassen Sie uns sehen, wie wir dies mit SciPy finden können. Betrachten wir das folgende Beispiel.
from scipy.spatial import Delaunay
points = np.array([[0, 0], [0, 1], [1, 0], [1, 1], [1, 1]])
tri = Delaunay(points)
print tri.coplanar
Das obige Programm erzeugt die folgende Ausgabe.
array([[4, 0, 3]], dtype = int32)
Dies bedeutet, dass sich Punkt 4 in der Nähe des Dreiecks 0 und des Scheitelpunkts 3 befindet, jedoch nicht in der Triangulation enthalten ist.
Konvexe Rümpfe
Lassen Sie uns verstehen, was konvexe Rümpfe sind und wie sie in SciPy verwendet werden.
Was sind konvexe Rümpfe?
In der Mathematik ist die convex hull oder convex envelope einer Menge von Punkten X in der euklidischen Ebene oder in einem euklidischen Raum (oder allgemeiner in einem affinen Raum über den Realen) ist der kleinste convex set das enthält X.
Betrachten wir das folgende Beispiel, um es im Detail zu verstehen.
from scipy.spatial import ConvexHull
points = np.random.rand(10, 2) # 30 random points in 2-D
hull = ConvexHull(points)
import matplotlib.pyplot as plt
plt.plot(points[:,0], points[:,1], 'o')
for simplex in hull.simplices:
plt.plot(points[simplex,0], points[simplex,1], 'k-')
plt.show()
Das obige Programm erzeugt die folgende Ausgabe.
ODR steht für Orthogonal Distance Regression, die in den Regressionsstudien verwendet wird. Eine grundlegende lineare Regression wird häufig verwendet, um die Beziehung zwischen den beiden Variablen abzuschätzeny und x indem Sie die Linie mit der besten Anpassung in das Diagramm zeichnen.
Die dafür verwendete mathematische Methode ist bekannt als Least Squaresund zielt darauf ab, die Summe des quadratischen Fehlers für jeden Punkt zu minimieren. Die Schlüsselfrage hier ist, wie Sie den Fehler (auch als Residuum bezeichnet) für jeden Punkt berechnen.
Bei einer linearen Standardregression besteht das Ziel darin, den Y-Wert aus dem X-Wert vorherzusagen. Daher ist es sinnvoll, den Fehler in den Y-Werten zu berechnen (im folgenden Bild als graue Linien dargestellt). Manchmal ist es jedoch sinnvoller, den Fehler sowohl in X als auch in Y zu berücksichtigen (wie durch die gepunkteten roten Linien im folgenden Bild gezeigt).
Zum Beispiel - Wenn Sie wissen, dass Ihre X-Messungen unsicher sind oder wenn Sie sich nicht auf die Fehler einer Variablen gegenüber einer anderen konzentrieren möchten.
Die orthogonale Distanzregression (ODR) ist eine Methode, die dies ermöglicht (orthogonal bedeutet in diesem Zusammenhang senkrecht - berechnet also Fehler senkrecht zur Linie und nicht nur 'vertikal').
scipy.odr Implementierung für univariate Regression
Das folgende Beispiel zeigt die Implementierung von scipy.odr für die univariate Regression.
import numpy as np
import matplotlib.pyplot as plt
from scipy.odr import *
import random
# Initiate some data, giving some randomness using random.random().
x = np.array([0, 1, 2, 3, 4, 5])
y = np.array([i**2 + random.random() for i in x])
# Define a function (quadratic in our case) to fit the data with.
def linear_func(p, x):
m, c = p
return m*x + c
# Create a model for fitting.
linear_model = Model(linear_func)
# Create a RealData object using our initiated data from above.
data = RealData(x, y)
# Set up ODR with the model and data.
odr = ODR(data, linear_model, beta0=[0., 1.])
# Run the regression.
out = odr.run()
# Use the in-built pprint method to give us results.
out.pprint()
Das obige Programm erzeugt die folgende Ausgabe.
Beta: [ 5.51846098 -4.25744878]
Beta Std Error: [ 0.7786442 2.33126407]
Beta Covariance: [
[ 1.93150969 -4.82877433]
[ -4.82877433 17.31417201
]]
Residual Variance: 0.313892697582
Inverse Condition #: 0.146618499389
Reason(s) for Halting:
Sum of squares convergence
Die im Spezialpaket verfügbaren Funktionen sind universelle Funktionen, die auf Rundfunk und automatische Array-Schleife folgen.
Schauen wir uns einige der am häufigsten verwendeten Sonderfunktionen an -
- Kubikwurzelfunktion
- Exponentialfunktion
- Exponentialfunktion des relativen Fehlers
- Log Sum Exponential Function
- Lambert-Funktion
- Permutations- und Kombinationsfunktion
- Gammafunktion
Lassen Sie uns nun jede dieser Funktionen kurz verstehen.
Kubikwurzelfunktion
Die Syntax dieser Kubikwurzelfunktion lautet - scipy.special.cbrt (x). Dadurch wird die elementweise Kubikwurzel von abgerufenx.
Betrachten wir das folgende Beispiel.
from scipy.special import cbrt
res = cbrt([10, 9, 0.1254, 234])
print res
Das obige Programm erzeugt die folgende Ausgabe.
[ 2.15443469 2.08008382 0.50053277 6.16224015]
Exponentialfunktion
Die Syntax der Exponentialfunktion lautet - scipy.special.exp10 (x). Dies berechnet 10 ** x elementweise.
Betrachten wir das folgende Beispiel.
from scipy.special import exp10
res = exp10([2, 9])
print res
Das obige Programm erzeugt die folgende Ausgabe.
[1.00000000e+02 1.00000000e+09]
Exponentialfunktion des relativen Fehlers
Die Syntax für diese Funktion lautet - scipy.special.exprel (x). Es erzeugt den relativen Exponentialfehler (exp (x) - 1) / x.
Wann xist nahe Null, exp (x) ist nahe 1, so dass die numerische Berechnung von exp (x) - 1 unter einem katastrophalen Genauigkeitsverlust leiden kann. Dann wird Ausdruck (x) implementiert, um den Genauigkeitsverlust zu vermeiden, der auftritt, wennx ist nahe Null.
Betrachten wir das folgende Beispiel.
from scipy.special import exprel
res = exprel([-0.25, -0.1, 0, 0.1, 0.25])
print res
Das obige Programm erzeugt die folgende Ausgabe.
[0.88479687 0.95162582 1. 1.05170918 1.13610167]
Log Sum Exponential Function
Die Syntax für diese Funktion lautet - scipy.special.logsumexp (x). Es hilft, das Protokoll der Summe der Exponentiale der Eingabeelemente zu berechnen.
Betrachten wir das folgende Beispiel.
from scipy.special import logsumexp
import numpy as np
a = np.arange(10)
res = logsumexp(a)
print res
Das obige Programm erzeugt die folgende Ausgabe.
9.45862974443
Lambert-Funktion
Die Syntax für diese Funktion lautet - scipy.special.lambertw (x). Es wird auch als Lambert W-Funktion bezeichnet. Die Lambert W-Funktion W (z) ist definiert als die Umkehrfunktion von w * exp (w). Mit anderen Worten ist der Wert von W (z) so, dass z = W (z) * exp (W (z)) für jede komplexe Zahl z ist.
Die Lambert W-Funktion ist eine mehrwertige Funktion mit unendlich vielen Zweigen. Jeder Zweig ergibt eine separate Lösung der Gleichung z = w exp (w). Hier werden die Zweige durch die ganze Zahl k indiziert.
Betrachten wir das folgende Beispiel. Hier ist die Lambert-W-Funktion die Umkehrung von w exp (w).
from scipy.special import lambertw
w = lambertw(1)
print w
print w * np.exp(w)
Das obige Programm erzeugt die folgende Ausgabe.
(0.56714329041+0j)
(1+0j)
Permutationen & Kombinationen
Lassen Sie uns Permutationen und Kombinationen getrennt diskutieren, um sie klar zu verstehen.
Combinations- Die Syntax für Kombinationsfunktionen lautet - scipy.special.comb (N, k). Betrachten wir das folgende Beispiel:
from scipy.special import comb
res = comb(10, 3, exact = False,repetition=True)
print res
Das obige Programm erzeugt die folgende Ausgabe.
220.0
Note- Array-Argumente werden nur für den exakten = falschen Fall akzeptiert. Wenn k> N, N <0 oder k <0 ist, wird eine 0 zurückgegeben.
Permutations- Die Syntax für Kombinationsfunktionen lautet - scipy.special.perm (N, k). Permutationen von N Dingen, die k zu einem Zeitpunkt genommen wurden, dh k-Permutationen von N. Dies wird auch als "Teilpermutationen" bezeichnet.
Betrachten wir das folgende Beispiel.
from scipy.special import perm
res = perm(10, 3, exact = True)
print res
Das obige Programm erzeugt die folgende Ausgabe.
720
Gammafunktion
Die Gammafunktion wird oft als verallgemeinerte Fakultät bezeichnet, da z * Gamma (z) = Gamma (z + 1) und Gamma (n + 1) = n! Für eine natürliche Zahl 'n'.
Die Syntax für Kombinationsfunktionen lautet - scipy.special.gamma (x). Permutationen von N Dingen, die k zu einem Zeitpunkt genommen wurden, dh k-Permutationen von N. Dies wird auch als "Teilpermutationen" bezeichnet.
Die Syntax für Kombinationsfunktionen lautet - scipy.special.gamma (x). Permutationen von N Dingen, die k zu einem Zeitpunkt genommen wurden, dh k-Permutationen von N. Dies wird auch als "Teilpermutationen" bezeichnet.
from scipy.special import gamma
res = gamma([0, 0.5, 1, 5])
print res
Das obige Programm erzeugt die folgende Ausgabe.
[inf 1.77245385 1. 24.]