SciPy sisse Python Õpetus: mis on, raamatukogu, funktsioon ja näited
SciPy sisse Python
SciPy sisse Python on avatud lähtekoodiga raamatukogu, mida kasutatakse matemaatiliste, teaduslike, inseneri- ja tehniliste probleemide lahendamiseks. See võimaldab kasutajatel andmetega manipuleerida ja andmeid visualiseerida, kasutades laia valikut kõrgetasemelisi seadmeid Python käske. SciPy on üles ehitatud Python NumPy laiendus. SciPy hääldatakse ka kui "Sigh Pi".
SciPy alampaketid:
- Faili sisend/väljund – scipy.io
- Erifunktsioon – scipy.eriline
- Lineaaralgebra Operamine – scipy.linalg
- Interpolatsioon – scipy.interpoleerida
- Optimeerimine ja sobivus – scipy.optimize
- Statistika ja juhuslikud arvud – scipy.stats
- Numbriline integreerimine – scipy.integreerima
- Kiired Fourier' teisendused – scipy.fftpack
- Signal Töötlemine – scipy.signaal
- Pildi manipuleerimine - scipy.ndimage
Miks kasutada SciPyt?
- SciPy sisaldab erinevaid alampakette, mis aitavad lahendada kõige levinumaid teadusliku arvutamisega seotud probleeme.
- SciPy pakend sisse Python on C/ jaoks enimkasutatav teaduslik teek GNU Scientific Library järel teisel kohalC++ või Matlabi oma.
- Lihtne kasutada ja mõista, samuti kiire arvutusvõimsus.
- See võib töötada NumPy teegi massiiviga.
Numpy VS SciPy
Nuhklik
- Numpy on kirjutatud C-keeles ja seda kasutatakse matemaatiliseks või numbriliseks arvutamiseks.
- See on kiirem kui teised Python Raamatukogud
- Numpy on Data Science'i jaoks kõige kasulikum teek põhiliste arvutuste tegemiseks.
- Numpy sisaldab ainult massiivi andmetüüpi, mis täidab kõige elementaarsemaid toiminguid, nagu sortimine, kujundamine, indekseerimine jne.
SciPy
- SciPy on ehitatud NumPy peale
- SciPy moodul sisse Python on Linear Algebra täisfunktsionaalne versioon, samas kui Numpy sisaldab vaid mõnda funktsiooni.
- Enamik uusi Data Science'i funktsioone on saadaval pigem Scipys kui Numpys.
SciPy – installimine ja keskkonna seadistamine
Saate installida ka SciPy Windows pipi kaudu
Python3 -m pip install --user numpy scipy
Installige Scipy Linuxi
sudo apt-get install python-scipy python-numpy
Installige SciPy Maci
sudo port install py35-scipy py35-numpy
Enne kui alustame SciPy õppimist Python, peate teadma nii põhifunktsioone kui ka erinevaid massiivi tüüpe tuim
Standardne viis SciPy moodulite ja Numpy importimiseks:
from scipy import special #same for other modules import numpy as np
Faili sisend-/väljundpakett
Scipy, I/O pakett, omab laias valikus funktsioone tööks erinevate failivormingutega, milleks on Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV ja binaarvorming.
Võtame ühe failivormingu Python SciPy näide, mida MatLabis regulaarselt kasutatakse:
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']
Väljund:
array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]])
Koodi selgitus
- 1. ja 2. rida: Importige oluline SciPy teek Python I/O paketi ja Numpyga.
- Line 3: looge 4 x 4 mõõtmetega massiiv
- Line 4: salvesta massiiv sisse näide.matt faili.
- Rida 5: Hankige andmeid aadressilt näide.matt fail
- Line 6: Prindiväljund.
Erifunktsioonide pakett
- scipy.eriline pakett sisaldab arvukalt matemaatilise füüsika funktsioone.
- SciPy erifunktsioon sisaldab kuupjuurt, eksponentsiaalset, log summa eksponentsiaalset, Lamberti, permutatsiooni ja kombinatsioone, gamma, Besseli, hüpergeomeetrilist, kelvinit, beeta, paraboolsilindrit, suhtelist viga eksponentsiaalset jne.
- Kõigi nende funktsioonide ühe rea kirjeldamiseks tippige sisse Python konsool:
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.
Kuupjuure funktsioon
Kuupjuure funktsioon leiab väärtuste kuupjuure.
süntaksit:
scipy.special.cbrt(x)
Näide:
from scipy.special import cbrt #Find cubic root of 27 & 64 using cbrt() function cb = cbrt([27, 64]) #print value of cb print(cb)
Väljund: massiiv([3., 4.])
Eksponentfunktsioon:
Eksponentfunktsioon arvutab 10**x elemendi kaupa.
Näide:
from scipy.special import exp10 #define exp10 function and pass value in its exp = exp10([1,10]) print(exp)
Väljund: [1.e+01 1.e+10]
Permutatsioonid ja kombinatsioonid
SciPy pakub ka funktsioone permutatsioonide ja kombinatsioonide arvutamiseks.
Kombinatsioonid - scipy.special.comb(N,k)
Näide:
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)
Väljund: 15.0
Permutatsioonid –
scipy.special.perm(N,k)
Näide:
from scipy.special import perm #find permutation of 5, 2 using perm (N, k) function per = perm(5, 2, exact = True) print(per)
Väljund: 20
Logisumma eksponentsiaalne funktsioon
Log Sum Exponential arvutab eksponentsiaalse summa sisendelemendi logi.
Süntaks:
scipy.special.logsumexp(x)
Besseli funktsioon
N-nda täisarvu järjekorra arvutamise funktsioon
Süntaks:
scipy.special.jn()
Lineaarne algebra koos SciPyga
- SciPy lineaaralgebra on BLAS-i ja ATLAS-i LAPACK-i teekide rakendus.
- Lineaaralgebra jõudlus on võrreldes BLASi ja LAPACKiga väga kiire.
- Lineaarne algebra rutiin aktsepteerib kahemõõtmelist massiiviobjekti ja väljund on samuti kahemõõtmeline massiiv.
Teeme nüüd mõne testi scipy.linalg,
Arvutamisel determinant kahemõõtmelisest maatriksist,
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 )
Väljund: -7.0
Pöördmaatriks –
scipy.linalg.inv()
Scipy pöördmaatriks arvutab mis tahes ruutmaatriksi pöördväärtuse.
Vaatame,
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 )
Väljund:
array( [[-0.28571429, 0.71428571], [ 0.42857143, -0.57142857]] )
Omaväärtused ja omavektor
scipy.linalg.eig()
- Lineaaralgebra levinuim probleem on omaväärtused ja omavektor, mida saab hõlpsasti lahendada eig()funktsiooni.
- Nüüd leiame omaväärtuse (X) ja vastavad kahemõõtmelise ruutmaatriksi omavektorile.
Näide
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)
Väljund:
[ 9.+0.j -1.+0.j] #eigenvalues [ [ 0.70710678 -0.5547002 ] #eigenvectors [ 0.70710678 0.83205029] ]
Diskreetne Fourier' teisendus – scipy.fftpack
- DFT on matemaatiline tehnika, mida kasutatakse ruumiandmete teisendamiseks sagedusandmeteks.
- FFT (Fast Fourier Transformation) on DFT arvutamise algoritm
- FFT-d rakendatakse mitmemõõtmelisele massiivile.
- Sagedus määrab signaali või lainepikkuse arvu konkreetsel ajavahemikul.
Näide: Võtke laine ja näidake, kasutades Matplotlibi raamatukogu. võtame lihtsa perioodilise funktsiooni näite 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()
Väljund:
Seda näete. Sagedus on 5 Hz ja selle signaal kordub 1/5 sekundiga – see on kõne kui konkreetne ajavahemik.
Nüüd kasutame seda siinuslainet DFT rakenduse abil.
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()
Väljund:
- Näete selgelt, et väljund on ühemõõtmeline massiiv.
- Kompleksväärtusi sisaldav sisend on null, välja arvatud kaks punkti.
- DFT näites visualiseerime signaali suurust.
Optimeerimine ja sobitamine SciPysse – scipy.optimize
- Optimeerimine pakub kasulikku algoritmi kõvera sobitamise, mitmemõõtmelise või skalaar- ja juursobituse minimeerimiseks.
- Toome näite skalaarfunktsioon,minimaalse skalaarfunktsiooni leidmiseks.
%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)
Väljund:
Optimeerimine lõpetati edukalt.
Funktsiooni praegune väärtus: -23.241676
Iteratsioonid: 4
Funktsioonide hinnangud: 18
Gradiendi hinnangud: 6
massiiv([-1.67096375])
- Selles näites tehakse optimeerimine algpunktist gradiendi laskumise algoritmi abil
- Kuid võimalik probleem on globaalsete miinimumide asemel kohalikud miinimumid. Kui me ei leia globaalsete miinimumide naabrit, peame rakendama globaalset optimeerimist ja leidma globaalsete miinimumide funktsiooni basseinihüppamine () mis ühendab kohaliku optimeerija.
optimeeri.basinhopping(funktsioon, 0)
Väljund:
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-Meadi algoritm:
- Nelder-Meadi algoritm valib meetodi parameetri kaudu.
- See pakub kõige lihtsamat viisi ausa käitumise minimeerimiseks.
- Nelder – Meadi algoritmi gradiendi hindamiseks ei kasutata, kuna lahenduse leidmine võib võtta kauem aega.
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")
Väljund:
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])
Pilditöötlus SciPy abil – scipy.ndimage
- scipy.ndimage on SciPy alammoodul, mida kasutatakse enamasti pildiga seotud operatsioonide sooritamiseks
- ndimage tähendab n-mõõtmelist kujutist.
- SciPy Image Processing pakub geomeetria teisendust (pööramine, kärpimine, ümberpööramine), pildi filtreerimist (terav ja de noseerimine), kuva kujutist, kujutise segmenteerimist, klassifitseerimist ja funktsioonide eraldamist.
- MISC pakett SciPy sisaldab eelehitatud pilte, mida saab kasutada pilditöötlusülesande täitmiseks
Näide: Võtame piltide geomeetrilise teisenduse näite
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()
Väljund:
Nüüd meie Pöörake alla praegune pilt:
#Flip Down using scipy misc.face image flip_down = np.flipud(misc.face()) plt.imshow(flip_down) plt.show()
Väljund:
Näide: Pildi pööramine Scipy abil,
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()
Väljund:
Integratsioon Scipyga – numbriline integratsioon
- Kui integreerime mis tahes funktsiooni, mille analüütiline integreerimine pole võimalik, peame pöörduma numbrilise integratsiooni poole
- SciPy pakub funktsioone funktsioonide integreerimiseks numbrilise integratsiooniga.
- scipy.integreerima raamatukogus on üksikintegratsioon, topelt-, kolmik-, mitmik-, Gaussi kvadraat, Rombergi, trapetsikujulised ja Simpsoni reeglid.
Näide: Võtke nüüd näide Ühekordne integratsioon
Siin a on ülemine piir ja b on alumine piir
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)
Väljund:
(0.33333333333333337, 3.700743415417189e-15)
Siin tagastab funktsioon kaks väärtust, milles esimene väärtus on integratsioon ja teine väärtus on hinnanguline viga integraalis.
Näide: võtke nüüd SciPy näide kahekordne integratsioon. Leiame järgmise võrrandi topeltintegratsiooni,
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)
Väljund:
(3.0, 9.657432734515774e-14)
Olete näinud seda ülaltoodud väljundit nagu sama eelmist.
kokkuvõte
- SciPy (hääldatakse kui "Sigh Pi") on avatud lähtekoodiga programm Python-põhine raamatukogu, mida kasutatakse matemaatikas, teaduslikus andmetöötluses, inseneriteaduses ja tehnilises andmetöötluses.
- SciPy sisaldab erinevaid alampakette, mis aitavad lahendada kõige levinumaid teadusliku arvutamisega seotud probleeme.
- SciPy on ehitatud NumPy peale
Paketi nimi | Kirjeldus |
---|---|
scipy.io | Faili sisend/väljund |
scipy.eriline | Erifunktsioon |
scipy.linalg | Lineaaralgebra Operamine |
scipy.interpoleerida | Interpoleerimine |
scipy.optimize | Optimeerimine ja sobivus |
scipy.stats | Statistika ja juhuslikud arvud |
scipy.integreerima | Numbriline integreerimine |
scipy.fftpack | Kiired Fourier' teisendused |
scipy.signaal | Signal Töötlemine |
scipy.ndimage | Pildi manipuleerimine - |