SciPy oktatóanyag: Mi a SciPy? (példákkal)

SciPy be Python

SciPy be Python egy nyílt forráskódú könyvtár, amelyet matematikai, tudományos, mérnöki és műszaki problémák megoldására használnak. Lehetővé teszi a felhasználók számára az adatok kezelését és az adatok megjelenítését a magas szintű eszközök széles skálájával Python parancsokat. A SciPy a Python NumPy kiterjesztés. A SciPy-t „Sigh Pi”-ként is ejtik.

A SciPy alcsomagjai:

• Fájl bemenet/kimenet – scipy.io
• Különleges funkció - scipy.különleges
• Lineáris algebra Operació – scipy.linalg
• Interpoláció – scipy.interpolál
• Optimalizálás és illeszkedés - scipy.optimize
• Statisztikák és véletlen számok – scipy.stats
• Numerikus integráció – scipy.integrál
• Gyors Fourier transzformációk – scipy.fftpack
• Signal Feldolgozás – scipy.jel
• Képkezelés – scipy.ndimage

Miért használja a SciPy-t?

• A SciPy különféle alcsomagokat tartalmaz, amelyek segítenek megoldani a tudományos számításokkal kapcsolatos leggyakoribb problémákat.
• SciPy csomag be Python a leggyakrabban használt tudományos könyvtár, csak a második a GNU Scientific Library C/C++ vagy a Matlab-é.
• Könnyen használható és érthető, valamint gyors számítási teljesítmény.
• Működhet a NumPy könyvtár tömbjén.

Numpy VS SciPy

Hülye

• A Numpy C-ben van írva, és matematikai vagy numerikus számításokhoz használható.
• Gyorsabb, mint a többi Python könyvtárak
• A Numpy a Data Science leghasznosabb könyvtára az alapvető számítások elvégzéséhez.
• A Numpy nem tartalmaz mást, csak tömb adattípust, amely a legalapvetőbb műveleteket, például a rendezést, az sha-t vagy a sha-t végzi.ping, indexelés stb.

SciPy

• A SciPy a NumPy tetejére épült
• SciPy modul be Python a Linear Algebra teljes értékű változata, míg a Numpy csak néhány funkciót tartalmaz.
• A legtöbb új Data Science szolgáltatás a Numpy helyett a Scipyben érhető el.

SciPy – Telepítés és környezetbeállítás

A SciPy-t is telepítheti Windows pip-n keresztül

Python3 -m pip install --user numpy scipy 

Telepítse a Scipyt Linuxra

sudo apt-get install  python-scipy python-numpy

Telepítse a SciPy-t Mac-re

sudo port install py35-scipy py35-numpy

Mielőtt elkezdenénk tanulni a SciPy-t Python, ismernie kell az alapvető funkciókat, valamint a tömb különböző típusait numpy

A SciPy modulok és a Numpy szabványos importálása:

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

Fájl bemeneti / kimeneti csomag

A Scipy I/O csomag számos funkcióval rendelkezik a különféle fájlformátumokkal való munkához, amelyek Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV és bináris formátumúak.

Vegyünk egy fájlformátumot Python SciPy példa, amelyet a MatLab rendszeresen használ:

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

Code Magyarázat

• 1. és 2. sor: Importálja az alapvető SciPy könyvtárat Python I/O csomaggal és Numpyval.
• vonal 3: 4 x 4-es, dimenziós tömb létrehozása
• vonal 4: Tömb tárolása példa.mat fájlt.
• 5 vonal: Adatok lekérése innen példa.mat filé
• vonal 6: Nyomtatási kimenet.

Különleges funkció csomag

• scipy.különleges A csomag a matematikai fizika számos funkcióját tartalmazza.
• A SciPy speciális funkciói közé tartozik a köbgyök, az exponenciális, a naplóösszeg exponenciális, a lambert, a permutáció és kombinációk, a gamma, a Bessel, a hipergeometrikus, a kelvin, a béta, a parabolikus henger, a relatív hiba exponenciális stb.
• Az összes funkció egysoros leírásához írja be: Python konzol:

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.

Köbös gyökérfüggvény

A Cubic Root függvény megkeresi az értékek kockagyökét.

Syntax:

scipy.special.cbrt(x)

Példa:

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: tömb([3., 4.])

Exponenciális függvény:

Az exponenciális függvény elemenként számítja ki a 10**x-et.

Példa:

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]

Permutációk és kombinációk

A SciPy lehetőséget ad a permutációk és kombinációk kiszámítására is.

Kombinációk - scipy.special.comb(N,k)

Példa:

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

Permutációk –

scipy.special.perm(N,k)

Példa:

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

Naplóösszeg exponenciális függvény

A Log Sum Exponential kiszámítja az összeg exponenciális bemeneti elem naplóját.

Szintaxis:

scipy.special.logsumexp(x) 

Bessel-funkció

N-edik egész sorszámú számítási függvény

Szintaxis:

scipy.special.jn()

Lineáris algebra SciPy-val

• A SciPy lineáris algebra a BLAS és ATLAS LAPACK könyvtárak megvalósítása.
• A Lineáris Algebra teljesítménye nagyon gyors a BLAS-hoz és a LAPACK-hoz képest.
• A lineáris algebra rutin kétdimenziós tömbobjektumot fogad el, és a kimenet is egy kétdimenziós tömb.

Most csináljunk egy tesztet vele scipy.linalg,

Számító döntő egy kétdimenziós mátrixból,

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

Inverz mátrix –

scipy.linalg.inv()

A Scipy inverz mátrixa kiszámítja bármely négyzetmátrix inverzét.

Lássuk,

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

Sajátértékek és sajátvektor

scipy.linalg.eig()

• A lineáris algebra leggyakoribb problémája a sajátértékek és a sajátvektor, amelyek segítségével könnyen megoldható eig()funkciót.
• Most keressük meg a sajátértékét (X) és egy kétdimenziós négyzetmátrix sajátvektorának felel meg.

Példa

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

Diszkrét Fourier transzformáció – scipy.fftpack

• A DFT egy matematikai technika, amelyet a térbeli adatok frekvenciaadatokká alakítására használnak.
• Az FFT (Fast Fourier Transformation) a DFT kiszámítására szolgáló algoritmus
• Az FFT-t többdimenziós tömbre alkalmazzák.
• A frekvencia határozza meg a jelek számát vagy hullámhosszát egy adott időtartamban.

Példa: Vegyünk egy hullámot, és mutassuk meg a Matplotlib könyvtár használatával. vesszük a sin(20 × 2πt) egyszerű periodikus függvényé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:

Ezt láthatod. A frekvencia 5 Hz, és a jele 1/5 másodpercen belül ismétlődik – ez egy meghatározott időtartam.

Használjuk most ezt a szinuszos hullámot a DFT alkalmazás segítségével.

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:

• Jól látható, hogy a kimenet egy egydimenziós tömb.
• A komplex értékeket tartalmazó bemenet két pont kivételével nulla.
• A DFT példában megjelenítjük a jel nagyságát.

Optimalizálás és illeszkedés a SciPy-be – scipy.optimize

• Az optimalizálás hasznos algoritmust biztosít a görbeillesztés, a többdimenziós vagy skaláris és gyökérillesztés minimalizálására.
• Vegyünk egy példát skaláris függvény,hogy megtaláljuk a minimális skalárfüggvényt.

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

Az optimalizálás sikeresen befejeződött.

A függvény aktuális értéke: -23.241676

Iterációk: 4

Funkcióértékelések: 18

Gradiens értékelések: 6

tömb([-1.67096375])

• Ebben a példában az optimalizálás a gradiens süllyedés algoritmusával történik a kezdeti ponttól
• De a lehetséges probléma a helyi minimumok a globális minimumok helyett. Ha nem találunk szomszédot a globális minimumoknak, akkor globális optimalizálást kell alkalmazni, és meg kell találnunk a globális minimumok függvényét mosdóboltping() amely egyesíti a helyi optimalizálót.

optimalizálás.basinhopping(függvény, 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 algoritmus:

• A Nelder-Mead algoritmus a metódusparaméteren keresztül választ ki.
• Ez biztosítja a legegyszerűbb módot a tisztességes viselkedés minimalizálására.
• Nelder – A Mead algoritmust nem használják gradiens kiértékeléshez, mert hosszabb időt vehet igénybe a megoldás megtalálása.

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

Képfeldolgozás SciPy segítségével – scipy.ndimage

• A scipy.ndimage a SciPy egyik almodulja, amelyet leginkább képpel kapcsolatos műveletek végrehajtására használnak
• ndimage az „n” dimenziós képet jelenti.
• A SciPy képfeldolgozás geometriai transzformációt (forgatás, vágás, tükrözés), képszűrést (élesítés és simítás), képmegjelenítést, képszegmentálást, osztályozást és egyéb funkciókat biztosít.tracCIÓ.
• MISC csomag a SciPy-ben előre elkészített képeket tartalmaz, amelyek képkezelési feladatok végrehajtására használhatók

Példa: Vegyünk egy példát a képek geometriai transzformációjára

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:

Most mi Lehajtható jelenlegi kép:

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

output:

Példa: Kép elforgatása Scipy segítségével,

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:

Integráció Scipy-vel – Numerikus integráció

• Ha olyan függvényt integrálunk, ahol az analitikus integráció nem lehetséges, akkor a numerikus integrációhoz kell fordulnunk.
• A SciPy funkcionalitást biztosít a funkció és a numerikus integráció integrálásához.
• scipy.integrál A könyvtárnak van egyszeres integrációja, kettős, hármas, többszörös, Gauss-kvadrát, Romberg, trapéz és Simpson-szabályok.

Példa: Most vegyünk egy példát Egyetlen integráció

Itt a a felső határ és b az alsó határ

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)

Itt a függvény két értéket ad vissza, amelyekben az első érték az integráció, a második pedig az integrál becsült hibája.

Példa: Most vegyünk egy SciPy példát kettős integráció. Megtaláljuk a következő egyenlet kettős integrálását,

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)

Láttad a fenti kimenetet, mint az előzőt.

GYIK