SciPy inn Python Opplæring: Hva er, bibliotek, funksjon og eksempler
SciPy inn Python
SciPy inn Python er et åpen kildekode-bibliotek som brukes til å løse matematiske, vitenskapelige, tekniske og tekniske problemer. Det lar brukere manipulere dataene og visualisere dataene ved hjelp av et bredt spekter av høynivå Python kommandoer. SciPy er bygget på Python NumPy-utvidelse. SciPy uttales også som "Sigh Pi."
Underpakker av SciPy:
- Filinndata/utdata – scipy.io
- Spesialfunksjon – scipy.special
- Lineær algebra Operasjon – scipy.linalg
- Interpolering – scipy.interpolere
- Optimalisering og passform – scipy.optimize
- Statistikk og tilfeldige tall – scipy.stats
- Numerisk integrasjon – scipy.integrate
- Raske Fourier-transformasjoner – scipy.fftpack
- Signal Behandler – scipy.signal
- Bildemanipulering – scipy.ndimage
Hvorfor bruke SciPy
- SciPy inneholder varianter av underpakker som bidrar til å løse det vanligste problemet knyttet til Scientific Computation.
- SciPy-pakke inn Python er det mest brukte vitenskapelige biblioteket bare nest etter GNU Scientific Library for C/C++ eller Matlabs.
- Enkel å bruke og forstå samt rask beregningskraft.
- Den kan operere på en rekke NumPy-biblioteker.
Numpy VS SciPy
Klumpete
- Numpy skrives i C og brukes til matematisk eller numerisk beregning.
- Det er raskere enn andre Python Bibliotekene
- Numpy er det mest nyttige biblioteket for datavitenskap for å utføre grunnleggende beregninger.
- Numpy inneholder ingenting annet enn array-datatype som utfører den mest grunnleggende operasjonen som sortering, forming, indeksering, etc.
SciPy
- SciPy er bygget i toppen av NumPy
- SciPy-modul i Python er en fullverdig versjon av Linear Algebra mens Numpy bare inneholder noen få funksjoner.
- De fleste nye Data Science-funksjonene er tilgjengelige i Scipy i stedet for Numpy.
SciPy – Installasjon og miljøoppsett
Du kan også installere SciPy i Windows via pip
Python3 -m pip install --user numpy scipy
Installer Scipy på Linux
sudo apt-get install python-scipy python-numpy
Installer SciPy på Mac
sudo port install py35-scipy py35-numpy
Før vi begynner å lære SciPy Python, må du kjenne grunnleggende funksjonalitet så vel som ulike typer av en rekke nusset
Standardmåten for å importere SciPy-moduler og Numpy:
from scipy import special #same for other modules import numpy as np
File Input / Output-pakke
Scipy, I/O-pakke, har et bredt spekter av funksjoner for arbeid med forskjellige filformater som er Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV og binærformat.
La oss ta ett filformat Python SciPy-eksempel som brukes regelmessig i 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']
Utgang:
array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]])
Kode Forklaring
- Linje 1 og 2: Importer det essensielle SciPy-biblioteket inn Python med I/O-pakke og Numpy.
- Linje 3: Lag 4 x 4, dimensjonal ens array
- Linje 4: Lagre array i eksempel.mat filen.
- Linje 5: Få data fra eksempel.mat fil
- Linje 6: Utskrift.
Spesialfunksjonspakke
- scipy.special pakken inneholder en rekke funksjoner i matematisk fysikk.
- SciPy spesialfunksjon inkluderer kubikkrot, eksponentiell, logsum eksponentiell, Lambert, permutasjon og kombinasjoner, gamma, bessel, hypergeometrisk, kelvin, beta, parabolsylinder, relativ feil eksponentiell, etc.
- For en linjebeskrivelse, skriv inn alle disse funksjonene Python konsoll:
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.
Kubisk rotfunksjon
Cubic Root-funksjonen finner kubikkroten av verdier.
Syntaks:
scipy.special.cbrt(x)
Eksempel:
from scipy.special import cbrt #Find cubic root of 27 & 64 using cbrt() function cb = cbrt([27, 64]) #print value of cb print(cb)
Utgang: array([3., 4.])
Eksponentiell funksjon:
Eksponentiell funksjon beregner 10**x elementvis.
Eksempel:
from scipy.special import exp10 #define exp10 function and pass value in its exp = exp10([1,10]) print(exp)
Utgang: [1.e+01 1.e+10]
Permutasjoner og kombinasjoner
SciPy gir også funksjonalitet for å beregne permutasjoner og kombinasjoner.
Kombinasjoner – scipy.special.comb(N,k)
Eksempel:
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)
Utgang: 15.0
Permutasjoner –
scipy.special.perm(N,k)
Eksempel:
from scipy.special import perm #find permutation of 5, 2 using perm (N, k) function per = perm(5, 2, exact = True) print(per)
Utgang: 20
Loggsum eksponentiell funksjon
Log Sum Exponential beregner loggen for sum eksponentielt inngangselement.
Syntaks:
scipy.special.logsumexp(x)
Bessel funksjon
N-te heltallsrekkefølge beregningsfunksjon
Syntaks:
scipy.special.jn()
Lineær algebra med SciPy
- Linear Algebra of SciPy er en implementering av BLAS- og ATLAS LAPACK-biblioteker.
- Ytelsen til Lineær Algebra er veldig rask sammenlignet med BLAS og LAPACK.
- Lineær algebra-rutine godtar todimensjonale matriseobjekter og utdata er også en todimensjonal matrise.
La oss nå ta en test med scipy.linalg,
beregning avgjørende faktor av en todimensjonal matrise,
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 )
Utgang: -7.0
Invers matrise –
scipy.linalg.inv()
Inverse Matrix of Scipy beregner inversen av en hvilken som helst kvadratisk matrise.
La oss se,
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 )
Utgang:
array( [[-0.28571429, 0.71428571], [ 0.42857143, -0.57142857]] )
Egenverdier og egenvektor
scipy.linalg.eig()
- Det vanligste problemet i lineær algebra er egenverdier og egenvektor som enkelt kan løses ved hjelp av eig()funksjon.
- La oss nå finne egenverdien til (X) og korresponderer egenvektor til en todimensjonal kvadratmatrise.
Eksempel
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)
Utgang:
[ 9.+0.j -1.+0.j] #eigenvalues [ [ 0.70710678 -0.5547002 ] #eigenvectors [ 0.70710678 0.83205029] ]
Diskret Fourier Transform – scipy.fftpack
- DFT er en matematisk teknikk som brukes til å konvertere romlige data til frekvensdata.
- FFT (Fast Fourier Transformation) er en algoritme for beregning av DFT
- FFT brukes på en flerdimensjonal matrise.
- Frekvens definerer antall signaler eller bølgelengder i en bestemt tidsperiode.
Eksempel: Ta en bølge og vis med Matplotlib-biblioteket. vi tar enkle periodiske funksjonseksempel på 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()
Utgang:
Du kan se dette. Frekvensen er 5 Hz og signalet gjentas etter 1/5 sekund – det kalles som en bestemt tidsperiode.
La oss nå bruke denne sinusbølgen ved hjelp av DFT-applikasjonen.
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()
Utgang:
- Du kan tydelig se at utdata er en endimensjonal matrise.
- Inndata som inneholder komplekse verdier er null bortsett fra to punkter.
- I DFT-eksempel visualiserer vi størrelsen på signalet.
Optimalisering og tilpasning i SciPy – scipy.optimize
- Optimalisering gir en nyttig algoritme for å minimere kurvetilpasning, flerdimensjonal eller skalar og rottilpasning.
- La oss ta et eksempel på en skalar funksjon,for å finne minimum skalarfunksjon.
%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)
Utgang:
Optimaliseringen ble avsluttet.
Nåværende funksjonsverdi: -23.241676
Iterasjoner: 4
Funksjonsevalueringer: 18
Gradientevalueringer: 6
array([-1.67096375])
- I dette eksemplet gjøres optimalisering ved hjelp av gradientnedstigningsalgoritmen fra startpunktet
- Men det mulige problemet er lokale minima i stedet for globale minima. Hvis vi ikke finner en nabo til globale minima, må vi bruke global optimalisering og finne global minimafunksjon brukt som Basinhopping() som kombinerer lokal optimizer.
optimize.basinhopping(funksjon, 0)
Utgang:
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-algoritmen velger gjennom metodeparameter.
- Det gir den mest enkle måten å minimere for rettferdig oppført funksjon.
- Nelder – Mead-algoritmen brukes ikke til gradientevalueringer fordi det kan ta lengre tid å finne løsningen.
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")
Utgang:
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])
Bildebehandling med SciPy – scipy.ndimage
- scipy.ndimage er en undermodul av SciPy som for det meste brukes til å utføre en bilderelatert operasjon
- ndimage betyr det "n"-dimensjonale bildet.
- SciPy Image Processing gir geometrisk transformasjon (rotere, beskjære, vende), bildefiltrering (skarp og de nosing), visningsbilde, bildesegmentering, klassifisering og funksjonsekstraksjon.
- MISC-pakke i SciPy inneholder forhåndsbygde bilder som kan brukes til å utføre bildemanipulasjonsoppgaver
Eksempel: La oss ta et geometrisk transformasjonseksempel på bilder
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()
Utgang:
Nå vi Vipp ned nåværende bilde:
#Flip Down using scipy misc.face image flip_down = np.flipud(misc.face()) plt.imshow(flip_down) plt.show()
Utgang:
Eksempel: Rotasjon av bilde ved hjelp av 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()
Utgang:
Integrasjon med Scipy – Numerisk integrasjon
- Når vi integrerer en funksjon der analytisk integrering ikke er mulig, må vi vende oss for numerisk integrasjon
- SciPy gir funksjonalitet for å integrere funksjon med numerisk integrasjon.
- scipy.integrate biblioteket har enkel integrering, dobbel, trippel, multippel, Gaussisk kvadrat, Romberg, Trapes og Simpsons regler.
Eksempel: Ta nå et eksempel på Enkel integrasjon
Her a er øvre grense og b er den nedre grensen
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)
Utgang:
(0.33333333333333337, 3.700743415417189e-15)
Her returnerer funksjonen to verdier, der den første verdien er integrasjon og den andre verdien er estimert feil i integralet.
Eksempel: Ta nå et SciPy-eksempel på dobbel integrasjon. Vi finner dobbeltintegrasjonen av følgende ligning,
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)
Utgang:
(3.0, 9.657432734515774e-14)
Du har sett utgangen ovenfor som samme forrige.
Oppsummering
- SciPy (uttales som "Sigh Pi") er en åpen kildekode Python-basert bibliotek, som brukes i matematikk, vitenskapelig databehandling, ingeniørvitenskap og teknisk databehandling.
- SciPy inneholder varianter av underpakker som bidrar til å løse det vanligste problemet knyttet til Scientific Computation.
- SciPy er bygget i toppen av NumPy
Pakkenavn | Description |
---|---|
scipy.io | Filinngang/utgang |
scipy.special | Spesiell funksjon |
scipy.linalg | Lineær algebra Operasjon |
scipy.interpolere | interpole |
scipy.optimize | Optimalisering og passform |
scipy.stats | Statistikk og tilfeldige tall |
scipy.integrate | Numerisk integrasjon |
scipy.fftpack | Raske Fourier-transformasjoner |
scipy.signal | Signal i prosess |
scipy.ndimage | Bildemanipulering – |