SciPy în Python Tutorial: Ce este, Bibliotecă, Funcție și 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 altceva decât tipul de date matrice care efectuează operația cea mai de bază, cum ar fi sortarea, modelarea, indexarea 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.]])

Explicarea codului

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 basinhopping() 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ă.
Procesarea imaginii SciPy oferă transformare geometrică (rotire, decupare, răsturnare), filtrare a imaginii (sharp and de nosing), afișare a imaginii, segmentare a imaginii, clasificare și extracție de caracteristici.
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ă.

Rezumat

SciPy (pronunțat ca „Sigh Pi”) este o sursă deschisă Pythonbibliotecă bazată pe bază de date, care este utilizată în matematică, calcul științific, inginerie și calcul tehnic.
SciPy conține varietăți de subpachete care ajută la rezolvarea celei mai frecvente probleme legate de calculul științific.
SciPy este construit în partea de sus a NumPy

Nume pachet	Description
scipy.io	Intrare/ieșire fișier
scipy.special	Funcție specială
scipy.linalg	Algebră liniară OperaTION
scipy.interpolare	Interpolare
scipy.optimize	Optimizare și potrivire
scipy.stats	Statistici și numere aleatorii
scipy.integra	Integrare numerică
scipy.fftpack	Transformate Fourier rapide
scipy.semnal	Signal Prelucrare
scipy.ndimage	Manipularea imaginii -

S-ar putea sa-ti placa:

SciPy în Python

De ce să folosiți SciPy

Numpy VS SciPy

NumPy

SciPy

SciPy – Instalare și configurare a mediului

Pachetul de intrare/ieșire fișier

ARTICOLE SIMILARE

Pachet cu funcții speciale

Funcția rădăcină cubică

Functie exponentiala:

Permutări și combinații

Funcția exponențială a sumei jurnalului

Funcția Bessel

Algebră liniară cu SciPy

Valori proprii și vector propriu

Transformată Fourier discretă – scipy.fftpack

Optimizare și potrivire în SciPy – scipy.optimize

Algoritmul Nelder – Mead:

Procesarea imaginii cu SciPy – scipy.ndimage

Integrare cu Scipy – Integrare numerică

Rezumat