SciPy ind Python Selvstudium: Hvad er, bibliotek, funktion og eksempler

SciPy ind Python

SciPy ind Python er et open source-bibliotek, der bruges til at løse matematiske, videnskabelige, tekniske og tekniske problemer. Det giver brugerne mulighed for at manipulere dataene og visualisere dataene ved hjælp af en bred vifte af højt niveau Python kommandoer. SciPy er bygget på Python NumPy-udvidelse. SciPy udtales også som "Sigh Pi."

Underpakker af SciPy:

Fil input/output – scipy.io
Særlig funktion – scipy.special
Lineær algebra Operation - scipy.linalg
Interpolation – scipy.interpolere
Optimering og pasform – scipy.optimize
Statistik og tilfældige tal – scipy.stats
Numerisk integration – scipy.integrate
Hurtige Fourier-transformationer – scipy.fftpack
Signal Behandling – scipy.signal
Billedmanipulation - scipy.ndimage

Hvorfor bruge SciPy

SciPy indeholder varianter af underpakker, som hjælper med at løse det mest almindelige problem relateret til videnskabelig beregning.
SciPy pakke ind Python er det mest brugte videnskabelige bibliotek kun næst efter GNU Scientific Library for C/C++ eller Matlabs.
Nem at bruge og forstå samt hurtig beregningskraft.
Det kan fungere på en række NumPy-biblioteker.

Numpy VS SciPy

numpy

Numpy skrives i C og bruges til matematisk eller numerisk beregning.
Det er hurtigere end andre Python Biblioteker
Numpy er det mest nyttige bibliotek for Data Science til at udføre grundlæggende beregninger.
Numpy indeholder intet andet end array-datatype, som udfører den mest grundlæggende handling som sortering, formgivning, indeksering osv.

SciPy

SciPy er bygget i toppen af NumPy
SciPy-modul i Python er en fuldt udstyret version af Linear Algebra, mens Numpy kun indeholder nogle få funktioner.
De fleste nye Data Science-funktioner er tilgængelige i Scipy i stedet for Numpy.

SciPy – Installation og miljøopsætning

Du kan også installere SciPy i Windows via pip

Python3 -m pip install --user numpy scipy

Installer Scipy på Linux

sudo apt-get install  python-scipy python-numpy

Installer SciPy på Mac

sudo port install py35-scipy py35-numpy

Før vi begynder at lære SciPy Python, skal du kende grundlæggende funktionalitet såvel som forskellige typer af en række nusset

Standardmåden at importere SciPy-moduler og Numpy:

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

Filinput/outputpakke

Scipy, I/O-pakke, har en lang række funktioner til arbejde med forskellige filformater som er Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV og binært format.

Lad os tage et filformat Python SciPy-eksempel som regelmæssigt bruges i 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']

Output:

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

Kode Forklaring

Linje 1 og 2: Importer det væsentlige SciPy-bibliotek ind Python med I/O-pakke og Numpy.
Linje 3: Opret 4 x 4, dimensionelt ens array
Linje 4: Gem array i eksempel.mat fil.
Linje 5: Hent data fra eksempel.mat fil
Linje 6: Udskriv output.

Specialfunktionspakke

scipy.special pakken indeholder adskillige funktioner i matematisk fysik.
SciPy specialfunktion inkluderer Cubic Root, Exponential, Log Sum Exponential, Lambert, Permutation og Kombinationer, Gamma, Bessel, hypergeometrisk, Kelvin, beta, parabolsk cylinder, Relative Error Exponential osv.
For en linjebeskrivelse skal du indtaste alle disse funktioner Python konsol:

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.

Cubic Root Funktion

Cubic Root-funktionen finder kubikroden af værdier.

Syntaks:

scipy.special.cbrt(x)

Eksempel:

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

Output: array([3., 4.])

Eksponentiel funktion:

Eksponentiel funktion beregner 10**x element-vis.

Eksempel:

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

Output: [1.e+01 1.e+10]

Permutationer og kombinationer

SciPy giver også funktionalitet til at beregne permutationer og kombinationer.

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

Eksempel:

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)

Output: 15.0

Permutationer –

scipy.special.perm(N,k)

Eksempel:

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

Output: 20

Log Sum eksponentiel funktion

Log Sum Exponential beregner loggen for sum eksponentielt inputelement.

Syntaks:

scipy.special.logsumexp(x)

Bessel funktion

Beregningsfunktion for N. heltal

Syntaks:

scipy.special.jn()

Lineær algebra med SciPy

Linear Algebra of SciPy er en implementering af BLAS- og ATLAS LAPACK-biblioteker.
Lineær Algebras ydeevne er meget hurtig sammenlignet med BLAS og LAPACK.
Lineær algebrarutine accepterer et todimensionelt arrayobjekt, og output er også et todimensionelt array.

Lad os nu lave en test med scipy.linalg,

beregning determinanten af en todimensionel matrix,

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 )

Output: -7.0

Invers matrix –

scipy.linalg.inv()

Inverse Matrix of Scipy beregner den inverse af enhver kvadratisk matrix.

Lad os se,

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 )

Output:

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

Egenværdier og egenvektor

scipy.linalg.eig()

Det mest almindelige problem i lineær algebra er egenværdier og egenvektor, som nemt kan løses vha eig()funktion.
Lad os nu finde egenværdien af (X) og svarer til egenvektor for en todimensionel kvadratisk matrix.

Eksempel

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)

Output:

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

Diskret Fourier Transform – scipy.fftpack

DFT er en matematisk teknik, som bruges til at konvertere rumlige data til frekvensdata.
FFT (Fast Fourier Transformation) er en algoritme til beregning af DFT
FFT anvendes på et multidimensionelt array.
Frekvens definerer antallet af signaler eller bølgelængder i en bestemt tidsperiode.

Eksempel: Tag en bølge og vis ved hjælp af Matplotlib-biblioteket. vi tager et simpelt periodisk funktionseksempel på 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()

Output:

Du kan se dette. Frekvensen er 5 Hz, og dets signal gentages på 1/5 sekund – det er opkald som en bestemt tidsperiode.

Lad os nu bruge denne sinusbølge ved hjælp af DFT-applikation.

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

Output:

Du kan tydeligt se, at output er et endimensionelt array.
Input, der indeholder komplekse værdier, er nul undtagen to punkter.
I DFT-eksemplet visualiserer vi signalets størrelse.

Optimering og tilpasning til SciPy – scipy.optimize

Optimering giver en nyttig algoritme til minimering af kurvetilpasning, multidimensional eller skalar- og rodtilpasning.
Lad os tage et eksempel på en skalar funktion,for at finde minimum skalarfunktion.

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

Output:

Optimeringen blev afsluttet.

Nuværende funktionsværdi: -23.241676

Gentagelser: 4

Funktionsevalueringer: 18

Gradientevalueringer: 6

array([-1.67096375])

I dette eksempel udføres optimering ved hjælp af gradient descent-algoritmen fra startpunktet
Men det mulige problem er lokale minima i stedet for globale minima. Hvis vi ikke finder en nabo til globale minima, så er vi nødt til at anvende global optimering og finde globale minima-funktion, der bruges som bassinhopping() som kombinerer lokal optimizer.

optimize.basinhopping(funktion, 0)

Output:

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

Nelder-Mead algoritme vælger gennem metode parameter.
Det giver den mest ligetil måde at minimere på for en fair opført funktion.
Nelder – Mead-algoritmen bruges ikke til gradientevalueringer, fordi det kan tage længere tid at finde løsningen.

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

Output:

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

Billedbehandling med SciPy – scipy.ndimage

scipy.ndimage er et undermodul af SciPy, som mest bruges til at udføre en billedrelateret operation
ndimage betyder det "n" dimensionelle billede.
SciPy Image Processing giver geometrisk transformation (roter, beskær, vend), billedfiltrering (skarp og de nosing), displaybillede, billedsegmentering, klassificering og ekstraktion af funktioner.
MISC-pakke i SciPy indeholder forudbyggede billeder, som kan bruges til at udføre billedmanipulationsopgaver

Eksempel: Lad os tage et geometrisk transformationseksempel på billeder

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

Output:

Nu er vi Flip ned nuværende billede:

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

Output:

Eksempel: Rotation af billede ved hjælp af 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()

Output:

Integration med Scipy – Numerisk integration

Når vi integrerer en funktion, hvor analytisk integration ikke er mulig, er vi nødt til at vende os til numerisk integration
SciPy giver funktionalitet til at integrere funktion med numerisk integration.
scipy.integrate biblioteket har enkelt integration, dobbelt, tredobbelt, multiplum, Gaussisk kvadrat, Romberg, Trapez og Simpsons regler.

Eksempel: Tag nu et eksempel på Enkelt integration

Her a er den øvre grænse og b er den nedre grænse

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)

Output:

(0.33333333333333337, 3.700743415417189e-15)

Her returnerer funktionen to værdier, hvor den første værdi er integration og den anden værdi er estimeret fejl i integralet.

Eksempel: Tag nu et SciPy eksempel på dobbelt integration. Vi finder den dobbelte integration af følgende ligning,

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)

Output:

(3.0, 9.657432734515774e-14)

Du har set ovenstående output som samme forrige.

Resumé

SciPy (udtales som "Sigh Pi") er en Open Source Python-baseret bibliotek, som bruges i matematik, videnskabelig databehandling, teknik og teknisk databehandling.
SciPy indeholder varianter af underpakker, som hjælper med at løse det mest almindelige problem relateret til videnskabelig beregning.
SciPy er bygget i toppen af NumPy

Package Name	Description
scipy.io	Fil input/output
scipy.special	Specialfunktion
scipy.linalg	Lineær algebra Operation
scipy.interpolere	interpolation
scipy.optimize	Optimering og pasform
scipy.stats	Statistik og tilfældige tal
scipy.integrate	Numerisk integration
scipy.fftpack	Hurtige Fourier-transformationer
scipy.signal	Signal Behandles
scipy.ndimage	Billedmanipulation -

Du kan lide:

SciPy ind Python

Hvorfor bruge SciPy

Numpy VS SciPy

numpy

SciPy

SciPy – Installation og miljøopsætning

Filinput/outputpakke

RELATEREDE ARTIKLER

Specialfunktionspakke

Cubic Root Funktion

Eksponentiel funktion:

Permutationer og kombinationer

Log Sum eksponentiel funktion

Bessel funktion

Lineær algebra med SciPy

Egenværdier og egenvektor

Diskret Fourier Transform – scipy.fftpack

Optimering og tilpasning til SciPy – scipy.optimize

Nelder-Mead-algoritme:

Billedbehandling med SciPy – scipy.ndimage

Integration med Scipy – Numerisk integration

Resumé