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:

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:

Diskreetne Fourieri teisendus

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:

Diskreetne Fourieri teisendus

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

SciPy optimeerimine ja sobitamine

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:

Pilditöötlus SciPy abil

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:

Pilditöötlus SciPy abil

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:

Pilditöötlus SciPy abil

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

Integratsioon Scipyga

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,

Integratsioon Scipyga

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 -