Tutorial SciPy: Ce este SciPy? (cu exemple)

SciPy în Python

SciPy în Python este o bibliotecă open-source folosită pentru rezolvarea problemelor matematice, științifice, de inginerie și tehnice. Permite utilizatorilor să manipuleze datele și să le vizualizeze folosind o gamă largă de instrumente de nivel înalt Python comenzi. SciPy este construit pe Python Extensia NumPy. SciPy este, de asemenea, pronunțat ca „Sigh Pi”.

Sub-pachete de SciPy:

• Intrare/ieșire fișier – scipy.io
• Funcție specială - scipy.special
• Algebră liniară Operație – scipy.linalg
• interpolare - scipy.interpolare
• Optimizare și potrivire - scipy.optimize
• Statistici și numere aleatoare - scipy.stats
• Integrare numerică - scipy.integra
• Transformate Fourier rapide - scipy.fftpack
• Signal Prelucrare – scipy.semnal
• Manipularea imaginii - scipy.ndimage

De ce să folosiți SciPy

• SciPy conține varietăți de subpachete care ajută la rezolvarea celei mai frecvente probleme legate de calculul științific.
• Pachetul SciPy în Python este cea mai folosită bibliotecă științifică, a doua după GNU Scientific Library pentru C/C++ sau de la Matlab.
• Ușor de utilizat și de înțeles, precum și putere de calcul rapidă.
• Poate funcționa pe o serie de biblioteci NumPy.

Numpy VS SciPy

NumPy

• Numpy este scris în C și este utilizat pentru calcule matematice sau numerice.
• Este mai rapid decât altele Python Biblioteci
• Numpy este cea mai utilă bibliotecă pentru Data Science pentru a efectua calcule de bază.
• Numpy nu conține nimic altceva decât date de tip array care efectuează cele mai elementare operații, cum ar fi sortarea, sha-ul.ping, indexare etc.

SciPy

• SciPy este construit în partea de sus a NumPy
• Modulul SciPy în Python este o versiune completă a Algebrei liniare, în timp ce Numpy conține doar câteva caracteristici.
• Majoritatea noilor funcții Data Science sunt disponibile în Scipy și nu în Numpy.

SciPy – Instalare și configurare a mediului

De asemenea, puteți instala SciPy în Windows prin pip

Python3 -m pip install --user numpy scipy 

Instalați Scipy pe Linux

sudo apt-get install  python-scipy python-numpy

Instalați SciPy pe Mac

sudo port install py35-scipy py35-numpy

Înainte de a începe să învățăm SciPy Python, trebuie să cunoașteți funcționalitatea de bază, precum și diferite tipuri de matrice de NumPy

Modul standard de a importa module SciPy și Numpy:

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

Pachetul de intrare/ieșire fișier

Scipy, pachet I/O, are o gamă largă de funcții pentru lucrul cu diferite formate de fișiere, care sunt Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV și format binar.

Să luăm un singur format de fișier Python Exemplu SciPy care sunt utilizate în mod regulat în 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']

ieșire:

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

Code Explicație

• Linia 1 și 2: Importați biblioteca esențială SciPy în Python cu pachet I/O și Numpy.
• Line 3: Creați o matrice dimensională 4 x 4
• Line 4: stocați matricea în exemplu.mat fișier.
• Linia 5: Obțineți date de la exemplu.mat fişier
• Line 6: Ieșire tipărită.

Pachet cu funcții speciale

• scipy.special pachetul conține numeroase funcții ale fizicii matematice.
• Funcția specială SciPy include rădăcină cubică, exponențială, log sumă exponențială, Lambert, permutare și combinații, Gamma, Bessel, hipergeometrică, Kelvin, beta, cilindru parabolic, eroare relativă exponențială etc.
• Pentru descrierea pe o linie a tuturor acestor funcții, tastați Python consolă:

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.

Funcția rădăcină cubică

Funcția Cubic Root găsește rădăcina cubă a valorilor.

Sintaxă:

scipy.special.cbrt(x)

Exemplu:

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

ieșire: matrice([3., 4.])

Functie exponentiala:

Funcția exponențială calculează elementul 10**x.

Exemplu:

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

ieșire: [1.e+01 1.e+10]

Permutări și combinații

SciPy oferă, de asemenea, funcționalitate pentru a calcula Permutările și Combinațiile.

combinatii - scipy.special.comb(N,k)

Exemplu:

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)

ieșire: 15.0

Permutări -

scipy.special.perm(N,k)

Exemplu:

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

ieșire: 20

Funcția exponențială a sumei jurnalului

Log Sum Exponential calculează logul elementului de intrare sumă exponențială.

Sintaxa:

scipy.special.logsumexp(x) 

Funcția Bessel

Funcția de calcul de ordinul a n-a întreg

Sintaxa:

scipy.special.jn()

Algebră liniară cu SciPy

• Linear Algebra of SciPy este o implementare a bibliotecilor BLAS și ATLAS LAPACK.
• Performanța Algebrei Liniare este foarte rapidă în comparație cu BLAS și LAPACK.
• Rutina de algebră liniară acceptă obiecte matrice bidimensionale și ieșirea este, de asemenea, o matrice bidimensională.

Acum hai să facem un test cu scipy.linalg,

De calculat determinant a unei matrice bidimensionale,

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 )

ieșire: -7.0

matrice inversă -

scipy.linalg.inv()

Inverse Matrix of Scipy calculează inversul oricărei matrice pătrate.

Să vedem,

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 )

ieșire:

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

Valori proprii și vector propriu

scipy.linalg.eig()

• Cea mai comună problemă în algebra liniară este valorile proprii și vectorul propriu care pot fi rezolvate cu ușurință folosind eig()Funcția.
• Acum să găsim valoarea proprie a (X) și vectorul propriu corespunzător al unei matrice pătrate bidimensionale.

Exemplu

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)

ieșire:

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

Transformată Fourier discretă – scipy.fftpack

• DFT este o tehnică matematică care este utilizată pentru conversia datelor spațiale în date de frecvență.
• FFT (Fast Fourier Transformation) este un algoritm pentru calculul DFT
• FFT se aplică unei matrice multidimensionale.
• Frecvența definește numărul de semnal sau lungimea de undă într-o anumită perioadă de timp.

Exemplu: Ia un val și arată folosind biblioteca Matplotlib. luăm exemplu de funcție periodică simplă a 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()

ieșire:

Puteți vedea asta. Frecvența este de 5 Hz și semnalul său se repetă în 1/5 secunde - este apelul ca o anumită perioadă de timp.

Acum să folosim această undă sinusoidă cu ajutorul aplicației DFT.

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

ieșire:

• Puteți vedea clar că rezultatul este o matrice unidimensională.
• Intrările care conțin valori complexe sunt zero, cu excepția a două puncte.
• În exemplul DFT vizualizăm mărimea semnalului.

Optimizare și potrivire în SciPy – scipy.optimize

• Optimizarea oferă un algoritm util pentru minimizarea potrivirii curbei, multidimensionale sau scalare și a rădăcinii.
• Să luăm un exemplu de o funcție scalară,pentru a găsi funcția scalară minimă.

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

ieșire:

Optimizarea s-a încheiat cu succes.

Valoarea curentă a funcției: -23.241676

Iterații: 4

Evaluări ale funcției: 18

Evaluări gradient: 6

matrice([-1.67096375])

• În acest exemplu, optimizarea se face cu ajutorul algoritmului de coborâre a gradientului din punctul inițial
• Dar posibila problemă este minimele locale în loc de minimele globale. Dacă nu găsim un vecin al minimelor globale, atunci trebuie să aplicăm optimizarea globală și să găsim funcția de minime globale utilizată ca bazinhopping() care combină optimizatorul local.

optimize.basinhopping(funcție, 0)

ieșire:

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

Algoritmul Nelder – Mead:

• Algoritmul Nelder-Mead selectează prin parametrul metodei.
• Oferă cea mai simplă modalitate de minimizare pentru funcția corectă.
• Algoritmul Nelder – Mead nu este utilizat pentru evaluările gradientului, deoarece poate dura mai mult timp pentru a găsi soluția.

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

ieșire:

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

Procesarea imaginii cu SciPy – scipy.ndimage

• scipy.ndimage este un submodul al SciPy care este folosit în principal pentru a efectua o operație legată de imagine
• ndimage înseamnă imaginea „n” dimensională.
• SciPy Image Processing oferă transformări geometrice (rotire, decupare, răsturnare), filtrare a imaginilor (clarificare și eliminare a denivelării), afișare a imaginilor, segmentare a imaginilor, clasificare și funcții similare.tracTION.
• Pachetul MISC în SciPy conține imagini prefabricate care pot fi utilizate pentru a efectua sarcina de manipulare a imaginii

Exemplu: Să luăm un exemplu de transformare geometrică a imaginilor

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

ieșire:

Acum noi Flip-down imagine curenta:

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

ieșire:

Exemplu: Rotirea imaginii folosind 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()

ieșire:

Integrare cu Scipy – Integrare numerică

• Când integrăm orice funcție în care integrarea analitică nu este posibilă, trebuie să apelăm la integrarea numerică
• SciPy oferă funcționalitate pentru integrarea funcției cu integrarea numerică.
• scipy.integra biblioteca are integrare simplă, dublă, triplă, multiplă, pătrată Gaussian, Romberg, Trapezoidal și regulile lui Simpson.

Exemplu: Acum luați un exemplu de Integrare unică

Aici a este limita superioară și b este limita inferioară

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)

ieșire:

(0.33333333333333337, 3.700743415417189e-15)

Aici funcția returnează două valori, în care prima valoare este integrarea și a doua valoare este eroarea estimată în integrală.

Exemplu: Acum luați un exemplu SciPy dubla integrare. Găsim dubla integrare a următoarei ecuații,

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)

ieșire:

(3.0, 9.657432734515774e-14)

Ați văzut acea ieșire de mai sus ca aceeași versiune anterioară.

Întrebări frecvente