SciPy sisään Python Opetusohjelma: Mikä on, kirjasto, funktio ja esimerkit
Anna Blake
SciPy sisään Python
SciPy sisään Python on avoimen lähdekoodin kirjasto, jota käytetään matemaattisten, tieteellisten, tekniikan ja teknisten ongelmien ratkaisemiseen. Sen avulla käyttäjät voivat käsitellä tietoja ja visualisoida tietoja käyttämällä laajaa valikoimaa korkean tason laitteita Python komentoja. SciPy on rakennettu Python NumPy-laajennus. SciPy lausutaan myös nimellä "Sigh Pi".
SciPyn alapaketit:
- Tiedoston syöttö/tulostus – scipy.io
- Erikoistoiminto - scipy.special
- Lineaarialgebra Operasuhde – scipy.linalg
- Interpolointi - scipy.interpolate
- Optimointi ja istuvuus - scipy.optimize
- Tilastot ja satunnaisluvut - scipy.stats
- Numeerinen integrointi - scipy.integrate
- Nopeat Fourier-muunnokset - scipy.fftpack
- Signal Käsittely – scipy.signal
- Kuvankäsittely - scipy.ndimage
Miksi käyttää SciPyä
- SciPy sisältää erilaisia alipaketteja, jotka auttavat ratkaisemaan yleisimmät tieteelliseen laskemiseen liittyvät ongelmat.
- SciPy-paketti mukana Python on eniten käytetty tieteellinen kirjasto vain toiseksi GNU Scientific Libraryn jälkeen C/C++ tai Matlabista.
- Helppokäyttöinen ja ymmärrettävä sekä nopea laskentateho.
- Se voi toimia NumPy-kirjaston ryhmässä.
Numpy VS SciPy
Nöpö
- Numpy on kirjoitettu C-kielellä ja sitä käytetään matemaattiseen tai numeeriseen laskemiseen.
- Se on nopeampi kuin muut Python kirjastot
- Numpy on hyödyllisin Data Sciencen kirjasto peruslaskelmien suorittamiseen.
- Numpy sisältää vain taulukkotietotyyppiä, joka suorittaa perustoiminnot, kuten lajittelun, muotoilun, indeksoinnin jne.
SciPy
- SciPy on rakennettu NumPyn päälle
- SciPy-moduuli sisään Python on täysin varusteltu versio Linear Algebrasta, kun taas Numpy sisältää vain muutamia ominaisuuksia.
- Useimmat uudet Data Science -ominaisuudet ovat saatavilla Scipyssä Numpyn sijaan.
SciPy – Asennus ja ympäristön asetukset
Voit myös asentaa SciPyn sisään Windows pipin kautta
Python3 -m pip install --user numpy scipy
Asenna Scipy Linuxiin
sudo apt-get install python-scipy python-numpy
Asenna SciPy Maciin
sudo port install py35-scipy py35-numpy
Ennen kuin aloitamme SciPyn oppimisen Python, sinun on tiedettävä perustoiminnot sekä erilaiset joukon tyypit nuhjuinen
Tavallinen tapa tuoda SciPy-moduulit ja Numpy:
from scipy import special #same for other modules import numpy as np
Tiedoston syöttö/tulostuspaketti
Scipy, I/O-paketti, sisältää laajan valikoiman toimintoja työskentelyyn eri tiedostomuotojen kanssa, jotka ovat Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV ja binäärimuoto.
Otetaan yksi tiedostomuoto Python SciPy-esimerkki, jota käytetään säännöllisesti MatLabissa:
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']
lähtö:
array([[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]])
Koodin selitys
- Rivit 1 ja 2: Tuo tärkeä SciPy-kirjasto sisään Python I/O-paketilla ja Numpylla.
- line 3: Luo 4 x 4-ulotteinen joukko
- line 4: Tallenna joukko sisään esimerkki.matto tiedosto.
- Rivi 5: Hae tiedot osoitteesta esimerkki.matto tiedosto
- line 6: Tulostustuloste.
Erikoistoimintopaketti
- scipy.special paketti sisältää lukuisia matemaattisen fysiikan toimintoja.
- SciPy-erikoistoiminto sisältää kuutiojuuren, eksponentiaalisen, log-summan eksponentiaalisen, Lambertin, permutoinnin ja yhdistelmät, gamman, Besselin, hypergeometrisen, kelvinin, beeta-, parabolisylinterin, suhteellisen virheen eksponentiaalisen jne.
- Jos haluat kuvailla kaikki nämä toiminnot yhdellä rivillä, kirjoita Python konsoli:
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.
Kuutiojuurifunktio
Kuutiojuurifunktio etsii arvojen kuutiojuuren.
Syntaksi:
scipy.special.cbrt(x)
Esimerkiksi:
from scipy.special import cbrt #Find cubic root of 27 & 64 using cbrt() function cb = cbrt([27, 64]) #print value of cb print(cb)
lähtö: array([3., 4.])
Eksponentti funktio:
Eksponentiaalinen funktio laskee 10**x elementtikohtaisesti.
Esimerkiksi:
from scipy.special import exp10 #define exp10 function and pass value in its exp = exp10([1,10]) print(exp)
lähtö: [1.e+01 1.e+10]
Permutaatiot ja yhdistelmät
SciPy tarjoaa myös toiminnot permutaatioiden ja yhdistelmien laskemiseen.
Yhdistelmät - scipy.special.comb(N,k)
Esimerkiksi:
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)
lähtö: 15.0
Permutaatiot -
scipy.special.perm(N,k)
Esimerkiksi:
from scipy.special import perm #find permutation of 5, 2 using perm (N, k) function per = perm(5, 2, exact = True) print(per)
lähtö: 20
Lokisumman eksponentiaalinen funktio
Log Sum Exponential laskee eksponentiaalisen summan syöteelementin lokin.
Syntaksi :
scipy.special.logsumexp(x)
Besselin toiminto
N:nnen kokonaisluvun laskentafunktio
Syntaksi :
scipy.special.jn()
Lineaarinen algebra SciPyn kanssa
- SciPyn lineaarinen algebra on BLAS- ja ATLAS LAPACK -kirjastojen toteutus.
- Lineaarialgebran suorituskyky on erittäin nopea verrattuna BLASiin ja LAPACKiin.
- Lineaarinen algebra-rutiini hyväksyy kaksiulotteisen taulukon objektin ja tulos on myös kaksiulotteinen taulukko.
Tehdään nyt testi scipy.linalg,
laskettaessa määräävä tekijä kaksiulotteisesta matriisista,
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 )
lähtö: -7.0
Käänteinen matriisi -
scipy.linalg.inv()
Scipyn käänteismatriisi laskee minkä tahansa neliömatriisin käänteisarvon.
Katsotaan,
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 )
lähtö:
array( [[-0.28571429, 0.71428571],
[ 0.42857143, -0.57142857]] )
Ominaisarvot ja ominaisvektori
scipy.linalg.eig()
- Lineaarialgebran yleisin ongelma on ominaisarvot ja ominaisvektori, jotka voidaan helposti ratkaista käyttämällä eig()toiminto.
- Etsitään nyt ominaisarvon (X) ja vastaavat kaksiulotteisen neliömatriisin ominaisvektoria.
esimerkki
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)
lähtö:
[ 9.+0.j -1.+0.j] #eigenvalues [ [ 0.70710678 -0.5547002 ] #eigenvectors [ 0.70710678 0.83205029] ]
Diskreetti Fourier-muunnos – scipy.fftpack
- DFT on matemaattinen tekniikka, jota käytetään paikkatietojen muuntamiseen taajuustiedoiksi.
- FFT (Fast Fourier Transformation) on algoritmi DFT:n laskemiseen
- FFT:tä sovelletaan moniulotteiseen taulukkoon.
- Taajuus määrittää signaalin määrän tai aallonpituuden tietyllä ajanjaksolla.
Esimerkiksi: Ota aalto ja näytä käyttämällä Matplotlib-kirjastoa. otamme yksinkertaisen jaksollisen funktion esimerkin 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()
lähtö:
Voit nähdä tämän. Taajuus on 5 Hz ja sen signaali toistuu 1/5 sekunnissa – se on kutsu tiettynä ajanjaksona.
Käyttäkäämme nyt tätä siniaaltoa DFT-sovelluksen avulla.
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()
lähtö:
- Voit selvästi nähdä, että tulos on yksiulotteinen matriisi.
- Kompleksiarvoja sisältävä syöte on nolla kahta pistettä lukuun ottamatta.
- DFT-esimerkissä visualisoimme signaalin suuruuden.
Optimointi ja sovitus SciPyssä – scipy.optimize
- Optimointi tarjoaa hyödyllisen algoritmin käyräsovituksen, moniulotteisen tai skalaari- ja juurisovituksen minimoimiseen.
- Otetaan esimerkki skalaarifunktio,löytääksesi minimiskalaarifunktion.
%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)
lähtö:
Optimointi lopetettiin onnistuneesti.
Nykyinen funktion arvo: -23.241676
Iteraatiot: 4
Toiminnan arvioinnit: 18
Gradientin arvioinnit: 6
array([-1.67096375])
- Tässä esimerkissä optimointi tehdään gradientin laskeutumisalgoritmin avulla alkupisteestä
- Mutta mahdollinen ongelma on paikalliset minimit globaalien minimien sijaan. Jos emme löydä globaalien minimien naapuria, meidän on käytettävä globaalia optimointia ja löydettävä globaali minimifunktio, jota käytetään pesuallas () joka yhdistää paikallisen optimoijan.
optimoi.basinhopping(funktio, 0)
lähtö:
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-algoritmi:
- Nelder-Mead-algoritmi valitsee menetelmäparametrin kautta.
- Se tarjoaa yksinkertaisimman tavan minimoida reilun käyttäytymisen.
- Nelder – Mead-algoritmia ei käytetä gradienttiarviointiin, koska ratkaisun löytäminen voi kestää kauemmin.
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")
lähtö:
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])
Kuvankäsittely SciPyllä – scipy.ndimage
- scipy.ndimage on SciPyn alimoduuli, jota käytetään useimmiten kuviin liittyvien toimintojen suorittamiseen
- ndimage tarkoittaa "n"-ulotteista kuvaa.
- SciPy Image Processing tarjoaa geometrisen muunnoksen (kierrä, rajaa, käännä), kuvan suodatuksen (terävä ja poista), näyttökuvan, kuvan segmentoinnin, luokittelun ja ominaisuuksien poimimisen.
- MISC-paketti SciPy sisältää valmiita kuvia, joita voidaan käyttää kuvankäsittelytehtävän suorittamiseen
Esimerkiksi: Otetaan esimerkki kuvien geometrisesta muunnoksesta
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()
lähtö:
Nyt me Kääntö alas nykyinen kuva:
#Flip Down using scipy misc.face image flip_down = np.flipud(misc.face()) plt.imshow(flip_down) plt.show()
lähtö:
Esimerkiksi: Kuvan kääntäminen Scipyllä,
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()
lähtö:
Integrointi Scipyn kanssa – Numeerinen integrointi
- Kun integroimme minkä tahansa funktion, jossa analyyttinen integrointi ei ole mahdollista, meidän on turvauduttava numeeriseen integrointiin
- SciPy tarjoaa toiminnot funktion integroimiseksi numeeriseen integrointiin.
- scipy.integrate kirjastossa on yksi integraatio, kaksois-, kolmois-, moninkertainen, Gaussin kvadraatin, Rombergin, puolisuunnikkaan ja Simpsonin säännöt.
Esimerkiksi: Ota nyt esimerkki Yksittäinen integraatio
Tässä a on yläraja ja b on alaraja
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)
lähtö:
(0.33333333333333337, 3.700743415417189e-15)
Tässä funktio palauttaa kaksi arvoa, joista ensimmäinen arvo on integrointi ja toinen arvo on arvioitu virhe integraalissa.
Esimerkki: Ota nyt SciPy-esimerkki kaksoisintegraatio. Löydämme seuraavan yhtälön kaksoisintegroinnin,
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)
lähtö:
(3.0, 9.657432734515774e-14)
Olet nähnyt yllä olevan tulosteen samana edellisenä.
Yhteenveto
- SciPy (lausutaan "Sigh Pi") on avoin lähdekoodi Python-pohjainen kirjasto, jota käytetään matematiikassa, tieteellisessä laskennassa, tekniikassa ja teknisessä laskennassa.
- SciPy sisältää erilaisia alipaketteja, jotka auttavat ratkaisemaan yleisimmät tieteelliseen laskemiseen liittyvät ongelmat.
- SciPy on rakennettu NumPyn päälle
| Paketin nimi | Tuotetiedot |
|---|---|
| scipy.io | Tiedoston syöttö/tulostus |
| scipy.special | Erityistoiminto |
| scipy.linalg | Lineaarialgebra OperaTUKSEN |
| scipy.interpolate | interpolointi |
| scipy.optimize | Optimointi ja istuvuus |
| scipy.stats | Tilastot ja satunnaisluvut |
| scipy.integrate | Numeerinen integrointi |
| scipy.fftpack | Nopeat Fourier-muunnokset |
| scipy.signal | Signal Käsittely |
| scipy.ndimage | Kuvankäsittely - |
