SciPy in Python Handledning: Vad är, bibliotek, funktion och exempel

SciPy in Python

SciPy in Python är ett bibliotek med öppen källkod som används för att lösa matematiska, vetenskapliga, tekniska och tekniska problem. Det tillåter användare att manipulera data och visualisera data med ett brett utbud av högnivåer Python kommandon. SciPy bygger på Python NumPy-förlängning. SciPy uttalas också som "Sigh Pi."

Underpaket av SciPy:

Filinmatning/utmatning – scipy.io
Specialfunktion – scipy.special
Linjär algebra Operation – scipy.linalg
Interpolation – scipy.interpolera
Optimering och passform – scipy.optimize
Statistik och slumptal – scipy.stats
Numerisk integration – scipy.integrera
Snabba Fourier-transformationer – scipy.fftpack
Signal Bearbetning – scipy.signal
Bildmanipulation – scipy.ndimage

Varför använda SciPy

SciPy innehåller olika underpaket som hjälper till att lösa det vanligaste problemet relaterat till Scientific Computation.
SciPy paket in Python är det mest använda vetenskapliga biblioteket bara näst efter GNU Scientific Library för C/C++ eller Matlabs.
Lätt att använda och förstå samt snabb beräkningskraft.
Det kan fungera på en mängd NumPy-bibliotek.

Numpy VS SciPy

numpy

Numpy skrivs i C och används för matematiska eller numeriska beräkningar.
Det är snabbare än andra Python bibliotek
Numpy är det mest användbara biblioteket för Data Science för att utföra grundläggande beräkningar.
Numpy innehåller inget annat än arraydatatyp som utför den mest grundläggande operationen som sortering, formning, indexering, etc.

SciPy

SciPy är byggt i toppen av NumPy
SciPy-modul in Python är en fullfjädrad version av linjär algebra medan Numpy bara innehåller ett fåtal funktioner.
De flesta nya Data Science-funktioner är tillgängliga i Scipy snarare än Numpy.

SciPy – Installation och miljöinställningar

Du kan också installera SciPy i Windows via pip

Python3 -m pip install --user numpy scipy

Installera Scipy på Linux

sudo apt-get install  python-scipy python-numpy

Installera SciPy i Mac

sudo port install py35-scipy py35-numpy

Innan vi börjar lära oss SciPy Python, måste du känna till grundläggande funktionalitet såväl som olika typer av en array av numpy

Standardsättet att importera SciPy-moduler och Numpy:

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

File Input / Output-paket

Scipy, I/O-paket, har ett brett utbud av funktioner för arbete med olika filformat som är Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV och binärt format.

Låt oss ta ett filformat Python SciPy-exempel som regelbundet används 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']

Produktion:

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

Kodförklaring

Rad 1 och 2: Importera det viktiga SciPy-biblioteket till Python med I/O-paket och Numpy.
Linje 3: Skapa 4 x 4, dimensionell ens array
Linje 4: Lagra array i exempel.mat fil.
Linje 5: Få data från exempel.mat fil
Linje 6: Utskrift.

Specialfunktionspaket

scipy.special paketet innehåller många funktioner i matematisk fysik.
SciPy specialfunktion inkluderar Cubic Root, Exponential, Log Sum Exponential, Lambert, Permutation and Combinations, Gamma, Bessel, hypergeometric, Kelvin, beta, parabolic cylinder, Relative Error Exponential, etc.
För en beskrivning av alla dessa funktioner, skriv in Python trösta:

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 hittar kubikroten av värden.

Syntax:

scipy.special.cbrt(x)

Exempelvis:

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

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

Exponentiell funktion:

Exponentiell funktion beräknar 10**x elementvis.

Exempelvis:

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

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

Permutationer och kombinationer

SciPy ger också funktionalitet för att beräkna permutationer och kombinationer.

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

Exempelvis:

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)

Produktion: 15.0

Permutationer –

scipy.special.perm(N,k)

Exempelvis:

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

Produktion: 20

Log Sum Exponential Funktion

Log Sum Exponential beräknar loggen för summa exponentiellt indataelement.

Syntax:

scipy.special.logsumexp(x)

Bessel funktion

N:te heltalsordningens beräkningsfunktion

Syntax:

scipy.special.jn()

Linjär algebra med SciPy

Linear Algebra of SciPy är en implementering av BLAS- och ATLAS LAPACK-bibliotek.
Prestandan för linjär algebra är mycket snabb jämfört med BLAS och LAPACK.
Linjär algebra-rutin accepterar tvådimensionella arrayobjekt och utdata är också en tvådimensionell array.

Nu ska vi göra ett test med scipy.linalg,

beräkning determinant av en tvådimensionell matris,

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 )

Produktion: -7.0

Invers matris –

scipy.linalg.inv()

Invers Matrix of Scipy beräknar inversen av en kvadratisk matris.

Låt 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 )

Produktion:

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

Egenvärden och egenvektor

scipy.linalg.eig()

Det vanligaste problemet inom linjär algebra är egenvärden och egenvektor som enkelt kan lösas med hjälp av eig()funktion.
Låt oss nu hitta egenvärdet för (X) och motsvarande egenvektor för en tvådimensionell kvadratisk matris.

Exempelvis

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)

Produktion:

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

Diskret Fourier Transform – scipy.fftpack

DFT är en matematisk teknik som används för att omvandla rumslig data till frekvensdata.
FFT (Fast Fourier Transformation) är en algoritm för beräkning av DFT
FFT appliceras på en flerdimensionell array.
Frekvens definierar antalet signaler eller våglängder i en viss tidsperiod.

Exempelvis: Ta en våg och visa med Matplotlib-biblioteket. vi tar enkla periodiska funktioner exempel 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()

Produktion:

Du kan se detta. Frekvensen är 5 Hz och dess signal upprepas på 1/5 sekund – det är anrop som en viss tidsperiod.

Låt oss nu använda denna sinusvåg med hjälp av DFT-applikationen.

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

Produktion:

Du kan tydligt se att utdata är en endimensionell array.
Indata som innehåller komplexa värden är noll utom två punkter.
I DFT-exemplet visualiserar vi signalens storlek.

Optimering och passning i SciPy – scipy.optimize

Optimering ger en användbar algoritm för minimering av kurvanpassning, flerdimensionell eller skalär och rotanpassning.
Låt oss ta ett exempel på en skalär funktion,för att hitta minsta skalär funktion.

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

Produktion:

Optimeringen avslutades framgångsrikt.

Nuvarande funktionsvärde: -23.241676

Iterationer: 4

Funktionsutvärderingar: 18

Gradientutvärderingar: 6

array([-1.67096375])

I det här exemplet görs optimering med hjälp av gradient descent-algoritmen från startpunkten
Men den möjliga frågan är lokala minima istället för globala minima. Om vi inte hittar en granne till globala minima, måste vi tillämpa global optimering och hitta global minimafunktion som används som basinhopping() som kombinerar lokal optimerare.

optimize.basinhopping(funktion, 0)

Produktion:

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

Nelder-Mead-algoritmen väljer genom metodparameter.
Det ger det enklaste sättet att minimera för en rättvis funktion.
Nelder – Mead-algoritm används inte för gradientutvärderingar eftersom det kan ta längre tid att hitta 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")

Produktion:

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

Bildbehandling med SciPy – scipy.ndimage

scipy.ndimage är en undermodul till SciPy som mest används för att utföra en bildrelaterad operation
ndimage betyder den "n"-dimensionella bilden.
SciPy Image Processing tillhandahåller geometriska transformationer (rotera, beskära, vända), bildfiltrering (skarp och de nosing), visningsbild, bildsegmentering, klassificering och extraktion av funktioner.
MISC-paket i SciPy innehåller förbyggda bilder som kan användas för att utföra bildmanipuleringsuppgifter

Exempelvis: Låt oss ta ett exempel på geometrisk transformation av 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()

Produktion:

Nu vi Flip-down aktuell bild:

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

Produktion:

Exempelvis: Rotation av bild med 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()

Produktion:

Integration med Scipy – Numerisk integration

När vi integrerar någon funktion där analytisk integrering inte är möjlig måste vi vända oss till numerisk integration
SciPy tillhandahåller funktionalitet för att integrera funktion med numerisk integration.
scipy.integrera biblioteket har enkel integration, dubbel, trippel, multipel, Gaussisk kvadrat, Romberg, Trapets och Simpsons regler.

Exempelvis: Ta nu ett exempel på Enkel integration

Här a är den övre gränsen och b är den nedre gränsen

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)

Produktion:

(0.33333333333333337, 3.700743415417189e-15)

Funktionen här returnerar två värden, där det första värdet är integration och det andra värdet är uppskattat fel i integralen.

Exempel: Ta nu ett SciPy-exempel på dubbel integration. Vi finner den dubbla integrationen av följande ekvation,

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)

Produktion:

(3.0, 9.657432734515774e-14)

Du har sett ovanstående utdata som samma föregående.

Sammanfattning

SciPy (uttalas som "Sigh Pi") är en öppen källkod Python-baserat bibliotek, som används i matematik, vetenskaplig beräkning, teknik och teknisk beräkning.
SciPy innehåller olika underpaket som hjälper till att lösa det vanligaste problemet relaterat till Scientific Computation.
SciPy är byggt i toppen av NumPy

Paket Namn	Systembeskrivningar
scipy.io	Filinmatning/utmatning
scipy.special	Särskild funktion
scipy.linalg	Linjär algebra Operation
scipy.interpolera	Interpole
scipy.optimize	Optimering och passform
scipy.stats	Statistik och slumptal
scipy.integrera	Numerisk integration
scipy.fftpack	Snabb Fourier-transformation
scipy.signal	Signal Bearbetning
scipy.ndimage	Bildmanipulation –

SciPy in Python

Varför använda SciPy

Numpy VS SciPy

numpy

SciPy

SciPy – Installation och miljöinställningar

File Input / Output-paket

RELATERADE ARTIKLAR

Specialfunktionspaket

Cubic Root Funktion

Exponentiell funktion:

Permutationer och kombinationer

Log Sum Exponential Funktion

Bessel funktion

Linjär algebra med SciPy

Egenvärden och egenvektor

Diskret Fourier Transform – scipy.fftpack

Optimering och passning i SciPy – scipy.optimize

Nelder – Mead Algoritm:

Bildbehandling med SciPy – scipy.ndimage

Integration med Scipy – Numerisk integration

Sammanfattning

Anmäl dig till nyhetsbrevet