SciPy inn Python Opplæring: Hva er, bibliotek, funksjon og eksempler

SciPy inn Python

SciPy inn Python er et åpen kildekode-bibliotek som brukes til å løse matematiske, vitenskapelige, tekniske og tekniske problemer. Det lar brukere manipulere dataene og visualisere dataene ved hjelp av et bredt spekter av høynivå Python kommandoer. SciPy er bygget på Python NumPy-utvidelse. SciPy uttales også som "Sigh Pi."

Underpakker av SciPy:

Hvorfor bruke SciPy

  • SciPy inneholder varianter av underpakker som bidrar til å løse det vanligste problemet knyttet til Scientific Computation.
  • SciPy-pakke inn Python er det mest brukte vitenskapelige biblioteket bare nest etter GNU Scientific Library for C/C++ eller Matlabs.
  • Enkel å bruke og forstå samt rask beregningskraft.
  • Den kan operere på en rekke NumPy-biblioteker.

Numpy VS SciPy

Klumpete

  • Numpy skrives i C og brukes til matematisk eller numerisk beregning.
  • Det er raskere enn andre Python Bibliotekene
  • Numpy er det mest nyttige biblioteket for datavitenskap for å utføre grunnleggende beregninger.
  • Numpy inneholder ingenting annet enn array-datatype som utfører den mest grunnleggende operasjonen som sortering, forming, indeksering, etc.

SciPy

  • SciPy er bygget i toppen av NumPy
  • SciPy-modul i Python er en fullverdig versjon av Linear Algebra mens Numpy bare inneholder noen få funksjoner.
  • De fleste nye Data Science-funksjonene er tilgjengelige i Scipy i stedet for Numpy.

SciPy – Installasjon og miljøoppsett

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 begynner å lære SciPy Python, må du kjenne grunnleggende funksjonalitet så vel som ulike typer av en rekke nusset

Standardmåten for å importere SciPy-moduler og Numpy:

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

File Input / Output-pakke

Scipy, I/O-pakke, har et bredt spekter av funksjoner for arbeid med forskjellige filformater som er Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV og binærformat.

La oss ta ett filformat Python SciPy-eksempel som brukes regelmessig 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']

Utgang:

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 essensielle SciPy-biblioteket inn Python med I/O-pakke og Numpy.
  • Linje 3: Lag 4 x 4, dimensjonal ens array
  • Linje 4: Lagre array i eksempel.mat filen.
  • Linje 5: Få data fra eksempel.mat fil
  • Linje 6: Utskrift.

Spesialfunksjonspakke

  • scipy.special pakken inneholder en rekke funksjoner i matematisk fysikk.
  • SciPy spesialfunksjon inkluderer kubikkrot, eksponentiell, logsum eksponentiell, Lambert, permutasjon og kombinasjoner, gamma, bessel, hypergeometrisk, kelvin, beta, parabolsylinder, relativ feil eksponentiell, etc.
  • For en linjebeskrivelse, skriv inn alle disse funksjonene Python konsoll:
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.

Kubisk rotfunksjon

Cubic Root-funksjonen finner kubikkroten av verdier.

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)

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

Eksponentiell funksjon:

Eksponentiell funksjon beregner 10**x elementvis.

Eksempel:

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

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

Permutasjoner og kombinasjoner

SciPy gir også funksjonalitet for å beregne permutasjoner og kombinasjoner.

Kombinasjoner – 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)

Utgang: 15.0

Permutasjoner –

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)

Utgang: 20

Loggsum eksponentiell funksjon

Log Sum Exponential beregner loggen for sum eksponentielt inngangselement.

Syntaks:

scipy.special.logsumexp(x) 

Bessel funksjon

N-te heltallsrekkefølge beregningsfunksjon

Syntaks:

scipy.special.jn()

Lineær algebra med SciPy

  • Linear Algebra of SciPy er en implementering av BLAS- og ATLAS LAPACK-biblioteker.
  • Ytelsen til Lineær Algebra er veldig rask sammenlignet med BLAS og LAPACK.
  • Lineær algebra-rutine godtar todimensjonale matriseobjekter og utdata er også en todimensjonal matrise.

La oss nå ta en test med scipy.linalg,

beregning avgjørende faktor av en todimensjonal matrise,

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 )

Utgang: -7.0

Invers matrise –

scipy.linalg.inv()

Inverse Matrix of Scipy beregner inversen av en hvilken som helst kvadratisk matrise.

La oss 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 )

Utgang:

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

Egenverdier og egenvektor

scipy.linalg.eig()

  • Det vanligste problemet i lineær algebra er egenverdier og egenvektor som enkelt kan løses ved hjelp av eig()funksjon.
  • La oss nå finne egenverdien til (X) og korresponderer egenvektor til en todimensjonal kvadratmatrise.

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)

Utgang:

[ 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 teknikk som brukes til å konvertere romlige data til frekvensdata.
  • FFT (Fast Fourier Transformation) er en algoritme for beregning av DFT
  • FFT brukes på en flerdimensjonal matrise.
  • Frekvens definerer antall signaler eller bølgelengder i en bestemt tidsperiode.

Eksempel: Ta en bølge og vis med Matplotlib-biblioteket. vi tar enkle periodiske funksjonseksempel 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()

Utgang:

Diskret Fourier Transform

Du kan se dette. Frekvensen er 5 Hz og signalet gjentas etter 1/5 sekund – det kalles som en bestemt tidsperiode.

La oss nå bruke denne sinusbølgen ved hjelp av DFT-applikasjonen.

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

Utgang:

Diskret Fourier Transform

  • Du kan tydelig se at utdata er en endimensjonal matrise.
  • Inndata som inneholder komplekse verdier er null bortsett fra to punkter.
  • I DFT-eksempel visualiserer vi størrelsen på signalet.

Optimalisering og tilpasning i SciPy – scipy.optimize

  • Optimalisering gir en nyttig algoritme for å minimere kurvetilpasning, flerdimensjonal eller skalar og rottilpasning.
  • La oss ta et eksempel på en skalar funksjon,for å finne minimum skalarfunksjon.
%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) 

Utgang:

Optimalisering og tilpasning i SciPy

Optimaliseringen ble avsluttet.

Nåværende funksjonsverdi: -23.241676

Iterasjoner: 4

Funksjonsevalueringer: 18

Gradientevalueringer: 6

array([-1.67096375])

  • I dette eksemplet gjøres optimalisering ved hjelp av gradientnedstigningsalgoritmen fra startpunktet
  • Men det mulige problemet er lokale minima i stedet for globale minima. Hvis vi ikke finner en nabo til globale minima, må vi bruke global optimalisering og finne global minimafunksjon brukt som Basinhopping() som kombinerer lokal optimizer.

optimize.basinhopping(funksjon, 0)

Utgang:

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-algoritmen velger gjennom metodeparameter.
  • Det gir den mest enkle måten å minimere for rettferdig oppført funksjon.
  • Nelder – Mead-algoritmen brukes ikke til gradientevalueringer fordi det kan ta lengre tid å finne 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")

Utgang:

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

Bildebehandling med SciPy – scipy.ndimage

  • scipy.ndimage er en undermodul av SciPy som for det meste brukes til å utføre en bilderelatert operasjon
  • ndimage betyr det "n"-dimensjonale bildet.
  • SciPy Image Processing gir geometrisk transformasjon (rotere, beskjære, vende), bildefiltrering (skarp og de nosing), visningsbilde, bildesegmentering, klassifisering og funksjonsekstraksjon.
  • MISC-pakke i SciPy inneholder forhåndsbygde bilder som kan brukes til å utføre bildemanipulasjonsoppgaver

Eksempel: La oss ta et geometrisk transformasjonseksempel på bilder

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

Utgang:

Bildebehandling med SciPy

Nå vi Vipp ned nåværende bilde:

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

Utgang:

Bildebehandling med SciPy

Eksempel: Rotasjon av bilde ved hjelp av 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()

Utgang:

Bildebehandling med SciPy

Integrasjon med Scipy – Numerisk integrasjon

  • Når vi integrerer en funksjon der analytisk integrering ikke er mulig, må vi vende oss for numerisk integrasjon
  • SciPy gir funksjonalitet for å integrere funksjon med numerisk integrasjon.
  • scipy.integrate biblioteket har enkel integrering, dobbel, trippel, multippel, Gaussisk kvadrat, Romberg, Trapes og Simpsons regler.

Eksempel: Ta nå et eksempel på Enkel integrasjon

Integrasjon med Scipy

Her a er øvre grense og b er den nedre grensen

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)

Utgang:

(0.33333333333333337, 3.700743415417189e-15)

Her returnerer funksjonen to verdier, der den første verdien er integrasjon og den andre verdien er estimert feil i integralet.

Eksempel: Ta nå et SciPy-eksempel på dobbel integrasjon. Vi finner dobbeltintegrasjonen av følgende ligning,

Integrasjon med Scipy

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)

Utgang:

(3.0, 9.657432734515774e-14)

Du har sett utgangen ovenfor som samme forrige.

Oppsummering

  • SciPy (uttales som "Sigh Pi") er en åpen kildekode Python-basert bibliotek, som brukes i matematikk, vitenskapelig databehandling, ingeniørvitenskap og teknisk databehandling.
  • SciPy inneholder varianter av underpakker som bidrar til å løse det vanligste problemet knyttet til Scientific Computation.
  • SciPy er bygget i toppen av NumPy
Pakkenavn Description
scipy.io Filinngang/utgang
scipy.special Spesiell funksjon
scipy.linalg Lineær algebra Operasjon
scipy.interpolere interpole
scipy.optimize Optimalisering og passform
scipy.stats Statistikk og tilfeldige tall
scipy.integrate Numerisk integrasjon
scipy.fftpack Raske Fourier-transformasjoner
scipy.signal Signal i prosess
scipy.ndimage Bildemanipulering –