SciPy in Python-zelfstudie:Wat is | Voorbeelden van bibliotheek en functies

SciPy in Python

SciPy in Python is een open-source bibliotheek die wordt gebruikt voor het oplossen van wiskundige, wetenschappelijke, technische en technische problemen. Het stelt gebruikers in staat om de gegevens te manipuleren en de gegevens te visualiseren met behulp van een breed scala aan Python-opdrachten op hoog niveau. SciPy is gebouwd op de Python NumPy-extensie. SciPy wordt ook uitgesproken als "Sigh Pi."

Subpakketten van SciPy:

• Bestandsinvoer/uitvoer – scipy.io
• Speciale functie – scipy.special
• Lineaire algebra-bewerking – scipy.linalg
• Interpolatie – scipy.interpolate
• Optimalisatie en pasvorm – scipy.optimize
• Statistieken en willekeurige getallen – scipy.stats
• Numerieke integratie – scipy.integrate
• Fast Fourier-transformaties – scipy.fftpack
• Signaalverwerking – scipy.signal
• Beeldmanipulatie – scipy.ndimage

In deze Python SciPy-tutorial leer je:

• Wat is SciPy?
• Waarom SciPy gebruiken
• Numpy VS SciPy
• SciPy – Installatie en omgeving instellen
• Bestandsinvoer / uitvoerpakket:
• Speciale functiepakket:
• Lineaire algebra met SciPy:
• Discrete Fourier-transformatie – scipy.fftpack
• Optimalisatie en pasvorm in SciPy – scipy.optimize
• Nelder –Mead-algoritme:
• Beeldverwerking met SciPy – scipy.ndimage

Waarom SciPy gebruiken

• SciPy bevat verschillende subpakketten die helpen bij het oplossen van de meest voorkomende problemen met betrekking tot wetenschappelijke berekeningen.
• SciPy-pakket in Python is de meest gebruikte wetenschappelijke bibliotheek, op de tweede plaats na GNU Scientific Library voor C/C++ of Matlab's.
• Gemakkelijk te gebruiken en te begrijpen, evenals snelle rekenkracht.
• Het kan werken op een array van NumPy-bibliotheken.

Numpy VS SciPy

Numpy:

• Numpy is geschreven in C en wordt gebruikt voor wiskundige of numerieke berekeningen.
• Het is sneller dan andere Python-bibliotheken
• Numpy is de meest bruikbare bibliotheek voor Data Science om basisberekeningen uit te voeren.
• Numpy bevat niets anders dan het array-gegevenstype dat de meest elementaire bewerkingen uitvoert, zoals sorteren, vormgeven, indexeren, enz.

SciPy:

• SciPy is bovenop de NumPy gebouwd
• SciPy-module in Python is een volledig uitgeruste versie van lineaire algebra, terwijl Numpy slechts een paar functies bevat.
• De meeste nieuwe Data Science-functies zijn beschikbaar in Scipy in plaats van Numpy.

SciPy – Installatie en omgeving instellen

Je kunt SciPy ook in Windows installeren via pip

Python3 -m pip install --user numpy scipy 

Installeer Scipy op Linux

sudo apt-get install  python-scipy python-numpy

Installeer SciPy op Mac

sudo port install py35-scipy py35-numpy

Voordat we beginnen met het leren van SciPy Python, moet je de basisfunctionaliteit kennen, evenals verschillende typen van een array van NumPy

De standaardmanier om SciPy-modules en Numpy te importeren:

from scipy import special   #same for other modules
import numpy as np

Bestandsinvoer / uitvoerpakket:

Scipy, I/O-pakket, heeft een breed scala aan functies voor het werken met verschillende bestandsindelingen, namelijk Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV en binair formaat.

Laten we een voorbeeld van een Python SciPy-bestandsformaat nemen dat regelmatig wordt gebruikt in MatLab:

 import numpy as np
 from scipy import io as sio
 array = np.ones((4, 4))
 sio.savemat('example.mat', {'ar': array}) 
 data = sio.loadmat(‘example.mat', struct_as_record=True)
 data['ar']

Uitvoer:

array([[ 1., 1., 1., 1.],
           [ 1., 1., 1., 1.],
           [ 1., 1., 1., 1.],
           [ 1., 1., 1., 1.]])

Code Uitleg

• Lijn 1 &2: Importeer de essentiële SciPy-bibliotheek in Python met I/O-pakket en Numpy.
• Lijn 3 :Maak 4 x 4, dimensionale one's array
• Lijn 4 :array opslaan in example.mat het dossier.
• Lijn 5: Gegevens ophalen van example.mat bestand
• Lijn 6 :Afdrukuitvoer.

Speciale functiepakket

• scipy.special pakket bevat talrijke functies van wiskundige fysica.
• Speciale SciPy-functie omvat Kubieke Wortel, Exponentieel, Log-som Exponentieel, Lambert, Permutatie en Combinaties, Gamma, Bessel, Hypergeometrisch, Kelvin, Bèta, Parabolische cilinder, Relatieve Fout Exponentieel, enz..
• Voor een beschrijving van al deze functies in één regel typt u in de Python-console:

help(scipy.special)	
Output : 
NAME
    scipy.special

DESCRIPTION
    ========================================
    Special functions (:mod:`scipy.special`)
    ========================================
     
    .. module:: scipy.special
     
    Nearly all of the functions below are universal functions and follow
    broadcasting and automatic array-looping rules. Exceptions are noted.

Kubieke wortelfunctie:

De functie Kubieke Wortel vindt de derdemachtswortel van waarden.

Syntaxis:

scipy.special.cbrt(x)

Voorbeeld:

from scipy.special import cbrt
#Find cubic root of 27 & 64 using cbrt() function
cb = cbrt([27, 64])
#print value of cb
print(cb)

Uitvoer: array([3., 4.])

Exponentiële functie:

Exponentiële functie berekent de 10**x elementsgewijs.

Voorbeeld:

from scipy.special import exp10
#define exp10 function and pass value in its
exp = exp10([1,10])
print(exp)

Uitgang:[1.e+01 1.e+10]

Permutaties en combinaties:

SciPy biedt ook functionaliteit om permutaties en combinaties te berekenen.

Combinaties – scipy.special.comb(N,k)

Voorbeeld:

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)

Uitgang:15,0

Permutaties –

scipy.special.perm(N,k)

Voorbeeld:

from scipy.special import perm
#find permutation of 5, 2 using perm (N, k) function
per = perm(5, 2, exact = True)
print(per)

Uitgang:20

Log Sum Exponentiële Functie

Log Sum Exponential berekent de log van het exponentiële invoerelement van de som.

Syntaxis :

scipy.special.logsumexp(x) 

Bessel-functie

N-de berekeningsfunctie voor gehele orde

Syntaxis :

scipy.special.jn()

Lineaire algebra met SciPy

• Lineaire Algebra van SciPy is een implementatie van BLAS- en ATLAS LAPACK-bibliotheken.
• De prestaties van lineaire algebra zijn erg snel vergeleken met BLAS en LAPACK.
• Lineaire algebra-routine accepteert een tweedimensionaal array-object en de uitvoer is ook een tweedimensionale array.

Laten we nu wat testen doen met scipy.linalg,

determinant berekenen van een tweedimensionale 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 )

Uitvoer: -7,0

Inverse matrix –

scipy.linalg.inv()

Inverse Matrix van Scipy berekent de inverse van elke vierkante matrix.

Eens kijken,

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 )

Uitvoer:

array( [[-0.28571429,  0.71428571],
       [ 0.42857143, -0.57142857]] )

Eigenwaarden en Eigenvector

scipy.linalg.eig()

• Het meest voorkomende probleem in lineaire algebra zijn eigenwaarden en eigenvector die eenvoudig kunnen worden opgelost met eig() functie.
• Laten we nu de eigenwaarde van (X . vinden) ) en corresponderende eigenvector van een tweedimensionale vierkante matrix.

Voorbeeld

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)

Uitvoer:

[ 9.+0.j -1.+0.j] #eigenvalues
 [ [ 0.70710678 -0.5547002 ] #eigenvectors
   [ 0.70710678  0.83205029] ]

Discrete Fourier-transformatie – scipy.fftpack

• DFT is een wiskundige techniek die wordt gebruikt bij het omzetten van ruimtelijke gegevens in frequentiegegevens.
• FFT (Fast Fourier Transformation) is een algoritme voor het berekenen van DFT
• FFT wordt toegepast op een multidimensionale array.
• Frequentie definieert het aantal signalen of golflengten in een bepaalde tijdsperiode.

Voorbeeld: Neem een ​​golf en laat zien met behulp van de Matplotlib-bibliotheek. we nemen een eenvoudig periodiek functievoorbeeld van 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()

Uitvoer:

Dit kun je zien. De frequentie is 5 Hz en het signaal wordt binnen 1/5 seconden herhaald - het is een oproep als een bepaalde tijdsperiode.

Laten we nu deze sinusvormige golf gebruiken met behulp van de DFT-toepassing.

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()

Uitvoer:

• Je kunt duidelijk zien dat de uitvoer een eendimensionale array is.
• Invoer met complexe waarden is nul op twee punten na.
• In het DFT-voorbeeld visualiseren we de grootte van het signaal.

Optimalisatie en pasvorm in SciPy – scipy.optimize

• Optimalisatie biedt een handig algoritme voor het minimaliseren van curve-aanpassing, multidimensionaal of scalair en wortelaanpassing.
• Laten we een voorbeeld nemen van een scalaire functie, om de minimale scalaire functie te vinden.

%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) 

Uitvoer:

Optimalisatie succesvol beëindigd.

Huidige functiewaarde:-23.241676

Iteraties:4

Functie-evaluaties:18

Gradiëntevaluaties:6

array([-1.67096375])

• In dit voorbeeld wordt optimalisatie gedaan met behulp van het algoritme voor hellingsdaling vanaf het beginpunt
• Maar het mogelijke probleem is lokale minima in plaats van globale minima. Als we geen buur van globale minima vinden, moeten we globale optimalisatie toepassen en de globale minima-functie vinden die wordt gebruikt als basinhopping() die lokale optimalisatie combineert.

optimize.basinhopping(function, 0)

Uitgang:

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-algoritme:

• Nelder-Mead-algoritme selecteert via methodeparameter.
• Het biedt de meest rechttoe rechtaan manier van minimalisatie voor een eerlijk gedragen functie.
• Nelder – Mead-algoritme wordt niet gebruikt voor gradiëntevaluaties omdat het langer kan duren om de oplossing te vinden.

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")

Uitvoer:

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])

Beeldverwerking met SciPy – scipy.ndimage

• scipy.ndimage is een submodule van SciPy die meestal wordt gebruikt voor het uitvoeren van een afbeeldinggerelateerde bewerking
• ndimage betekent de "n" dimensionale afbeelding.
• SciPy-beeldverwerking biedt geometrische transformatie (roteren, bijsnijden, spiegelen), beeldfiltering (scherp en de nosing), weergavebeeld, beeldsegmentatie, classificatie en extractie van kenmerken.
• DIVERS-pakket in SciPy bevat kant-en-klare afbeeldingen die kunnen worden gebruikt om een ​​beeldmanipulatietaak uit te voeren

Voorbeeld: Laten we een voorbeeld van geometrische transformatie van afbeeldingen nemen

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()

Uitvoer:

Nu gaan we Omlaag draaien huidige afbeelding:

#Flip Down using scipy misc.face image  
flip_down = np.flipud(misc.face())
plt.imshow(flip_down)
plt.show()

Uitvoer:

Voorbeeld: Rotatie van afbeelding met 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()

Uitvoer:

Integratie met Scipy – Numerieke integratie

• Als we een functie integreren waar analytische integratie niet mogelijk is, moeten we kiezen voor numerieke integratie
• SciPy biedt functionaliteit om functies te integreren met numerieke integratie.
• scipy.integrate bibliotheek heeft enkele integratie, dubbele, drievoudige, meervoudige, Gaussiaanse kwadraten, Romberg, Trapezium- en Simpson-regels.

Voorbeeld: Neem nu een voorbeeld van Single Integration

Hier een is de bovengrens en b is de ondergrens

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)

Uitvoer:

(0.33333333333333337, 3.700743415417189e-15)

Hier retourneert de functie twee waarden, waarbij de eerste waarde integratie is en de tweede waarde de geschatte fout in integraal.

Voorbeeld:Neem nu een SciPy-voorbeeld van dubbele integratie. We vinden de dubbele integratie van de volgende vergelijking,

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)

Uitvoer:

(3.0, 9.657432734515774e-14)

Je hebt die bovenstaande uitvoer gezien als dezelfde vorige.

Samenvatting

• SciPy (uitgesproken als "Sigh Pi") is een op Open Source Python gebaseerde bibliotheek, die wordt gebruikt in wiskunde, wetenschappelijk computergebruik, engineering en technisch computergebruik.
• SciPy bevat verschillende subpakketten die helpen bij het oplossen van de meest voorkomende problemen met betrekking tot wetenschappelijke berekeningen.
• SciPy is bovenop de NumPy gebouwd

Pakketnaam	Beschrijving
scipy.io	Bestandsinvoer/uitvoer
scipy.special	Speciale functie
scipy.linalg	Lineaire algebra-bewerking
scipy.interpolate	Interpolatie
scipy.optimize	Optimalisatie en pasvorm
scipy.stats	Statistieken en willekeurige getallen
scipy.integrate	Numerieke integratie
scipy.fftpack	Snelle Fourier-transformaties
scipy.signaal	Signaalverwerking
scipy.ndimage	Beeldmanipulatie –