SciPy dentro Python Tutorial: cos'è, libreria, funzioni ed esempi

By: Anna Blake Anna Blake
Hours aggiornato

SciPy dentro Python

SciPy dentro Python è una libreria open source utilizzata per risolvere problemi matematici, scientifici, ingegneristici e tecnici. Consente agli utenti di manipolare i dati e visualizzarli utilizzando un'ampia gamma di strumenti di alto livello Python comandi. SciPy è basato su Python Estensione NumPy. SciPy è anche pronunciato come “Sigh Pi”.

Sottopacchetti di SciPy:

Perché usare SciPy

  • SciPy contiene una varietà di sottopacchetti che aiutano a risolvere i problemi più comuni relativi al calcolo scientifico.
  • Pacchetto SciPy in Python è la libreria scientifica più utilizzata, seconda solo alla GNU Scientific Library per C/C++ o quello di Matlab.
  • Facile da usare e comprendere, nonché veloce potenza di calcolo.
  • Può operare su una serie di librerie NumPy.

Numpy VS SciPy

numpy

  • Numpy è scritto in C e viene utilizzato per calcoli matematici o numerici.
  • È più veloce di altri Python Biblioteche
  • Numpy è la libreria più utile per Data Science per eseguire calcoli di base.
  • Numpy non contiene altro che il tipo di dati array che esegue le operazioni più elementari come l'ordinamento, la modellazione, l'indicizzazione, ecc.

SciPy

  • SciPy è integrato in NumPy
  • Modulo SciPy dentro Python è una versione completa di Algebra lineare mentre Numpy contiene solo alcune funzionalità.
  • La maggior parte delle nuove funzionalità di Data Science sono disponibili in Scipy anziché in Numpy.

SciPy: installazione e configurazione dell'ambiente

Puoi anche installare SciPy in Windows tramite pip

Python3 -m pip install --user numpy scipy

Installa Scipy su Linux

sudo apt-get install  python-scipy python-numpy

Installa SciPy sul Mac

sudo port install py35-scipy py35-numpy

Prima di iniziare a imparare SciPy Python, è necessario conoscere le funzionalità di base e i diversi tipi di un array di NumPy

Il modo standard per importare moduli SciPy e Numpy:

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

Pacchetto di input/output file

Scipy, pacchetto I/O, ha una vasta gamma di funzioni per lavorare con diversi formati di file che sono Matlab, Arff, Wave, Matrix Market, IDL, NetCDF, TXT, CSV e formato binario.

Prendiamo un formato di file Python Esempio di SciPy come quelli utilizzati regolarmente in 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']

Produzione:

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

Spiegazione del codice

  • Linea 1 e 2: Importa la libreria SciPy essenziale in Python con pacchetto I/O e Numpy.
  • Linea 3: Crea un array dimensionale 4 x 4
  • Linea 4: memorizza l'array in esempio.mat file.
  • Linea 5: Ottieni dati da esempio.mat filetto
  • Linea 6: Stampa.

ARTICOLI CORRELATI

Pacchetto funzioni speciali

  • scipy.special il pacchetto contiene numerose funzioni di fisica matematica.
  • La funzione speciale di SciPy include radice cubica, esponenziale, logsum esponenziale, Lambert, permutazioni e combinazioni, gamma, Bessel, ipergeometrico, Kelvin, beta, cilindro parabolico, errore relativo esponenziale, ecc.
  • Per una descrizione in una riga di tutte queste funzioni, digitare Python consolle:
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.

Funzione di radice cubica

La funzione Radice cubica trova la radice cubica dei valori.

Sintassi:

scipy.special.cbrt(x)

Esempio:

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

Produzione: matrice([3., 4.])

Funzione esponenziale:

La funzione esponenziale calcola 10**x elemento per elemento.

Esempio:

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

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

Permutazioni e combinazioni

SciPy offre anche funzionalità per calcolare permutazioni e combinazioni.

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

Esempio:

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)

Produzione: 15.0

Permutazioni – 

scipy.special.perm(N,k)

Esempio:

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

Produzione: 20

Funzione esponenziale della somma logaritmica

Log Sum Exponential calcola il logaritmo dell'elemento di input somma esponenziale.

Sintassi:

scipy.special.logsumexp(x)

Funzione di Bessel

Funzione di calcolo dell'ennesimo ordine intero

Sintassi:

scipy.special.jn()

Algebra lineare con SciPy

  • Algebra lineare di SciPy è un'implementazione delle librerie BLAS e ATLAS LAPACK.
  • Le prestazioni di Algebra lineare sono molto veloci rispetto a BLAS e LAPACK.
  • La routine di algebra lineare accetta oggetti array bidimensionali e anche l'output è un array bidimensionale.

Ora facciamo qualche prova con scipy.linalg,

Calcolo determinante di una 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 )

Produzione: all'7.0 ottobre

Matrice Inversa – 

scipy.linalg.inv()

Matrice inversa di Scipy calcola l'inverso di qualsiasi matrice quadrata.

Vediamo,

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 )

Produzione:

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

Autovalori e autovettore

scipy.linalg.eig()

  • Il problema più comune nell'algebra lineare sono gli autovalori e gli autovettori che possono essere facilmente risolti utilizzando eig()funzione.
  • Ora troviamo l'autovalore di (X) e corrispondono all'autovettore di una matrice quadrata bidimensionale.

Esempio

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)

Produzione:

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

Trasformata discreta di Fourier – scipy.fftpack

  • DFT è una tecnica matematica utilizzata per convertire i dati spaziali in dati di frequenza.
  • FFT (Fast Fourier Transformation) è un algoritmo per il calcolo della DFT
  • La FFT viene applicata a un array multidimensionale.
  • La frequenza definisce il numero di segnali o lunghezze d'onda in un particolare periodo di tempo.

Esempio: Prendi un'onda e mostra utilizzando la libreria Matplotlib. prendiamo l'esempio di una semplice funzione periodica 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()

Produzione:

Trasformata discreta di Fourier

Puoi vedere questo. La frequenza è 5 Hz e il suo segnale si ripete in 1/5 di secondo: viene chiamato un periodo di tempo particolare.

Ora utilizziamo questa onda sinusoidale con l'aiuto dell'applicazione 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()

Produzione:

Trasformata discreta di Fourier

  • Puoi vedere chiaramente che l'output è un array unidimensionale.
  • Gli input contenenti valori complessi sono zero, tranne due punti.
  • Nell'esempio DFT visualizziamo l'entità del segnale.

Ottimizzazione e adattamento in SciPy – scipy.optimize

  • L'ottimizzazione fornisce un algoritmo utile per la minimizzazione dell'adattamento della curva, multidimensionale o scalare e dell'adattamento della radice.
  • Facciamo un esempio di una funzione scalare,per trovare la funzione scalare minima.
%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)

Produzione:

Ottimizzazione e adattamento in SciPy

Ottimizzazione terminata correttamente.

Valore della funzione corrente: -23.241676

Iterazioni: 4

Valutazioni funzionali: 18

Valutazioni del gradiente: 6

matrice([-1.67096375])

  • In questo esempio, l'ottimizzazione viene eseguita con l'aiuto dell'algoritmo di discesa del gradiente dal punto iniziale
  • Ma il possibile problema sono i minimi locali anziché i minimi globali. Se non troviamo un vicino dei minimi globali, dobbiamo applicare l'ottimizzazione globale e trovare la funzione dei minimi globali utilizzata come salto del bacino() che combina l'ottimizzatore locale.

ottimizzare.basinhopping(funzione, 0)

Produzione:

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

Algoritmo di Nelder-Mead:

  • L'algoritmo di Nelder-Mead seleziona tramite il parametro del metodo.
  • Fornisce il modo più semplice di minimizzazione per una funzione dal comportamento equo.
  • L'algoritmo Nelder – Mead non viene utilizzato per le valutazioni del gradiente perché potrebbe richiedere più tempo per trovare la soluzione.
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")

Produzione:

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

Elaborazione delle immagini con SciPy – scipy.ndimage

  • scipy.ndimage è un sottomodulo di SciPy che viene utilizzato principalmente per eseguire un'operazione relativa alle immagini
  • ndimage indica l'immagine dimensionale “n”.
  • SciPy Image Processing fornisce trasformazione geometrica (ruotare, ritagliare, capovolgere), filtraggio delle immagini (nitidezza e denosamento), visualizzazione dell'immagine, segmentazione dell'immagine, classificazione ed estrazione delle caratteristiche.
  • Pacchetto MISC in SciPy contiene immagini predefinite che possono essere utilizzate per eseguire attività di manipolazione delle immagini

Esempio: Prendiamo un esempio di trasformazione geometrica delle immagini

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

Produzione:

Elaborazione delle immagini con SciPy

Ora noi Capovolgimento immagine corrente:

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

Produzione:

Elaborazione delle immagini con SciPy

Esempio: Rotazione dell'immagine utilizzando 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()

Produzione:

Elaborazione delle immagini con SciPy

Integrazione con Scipy – Integrazione Numerica

  • Quando integriamo qualsiasi funzione in cui l'integrazione analitica non è possibile, dobbiamo ricorrere all'integrazione numerica
  • SciPy fornisce funzionalità per integrare la funzione con l'integrazione numerica.
  • scipy.integrate la libreria contiene le regole di integrazione singola, doppia, tripla, multipla, gaussiana quadrata, di Romberg, trapezoidale e di Simpson.

Esempio: Ora facciamo un esempio di Integrazione unica

Integrazione con Scipy

Qui a è il limite superiore e b è il limite inferiore

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)

Produzione:

(0.33333333333333337, 3.700743415417189e-15)

Qui la funzione restituisce due valori, in cui il primo valore è l'integrazione e il secondo valore è l'errore stimato nell'integrale.

Esempio: ora prendiamo un esempio di SciPy doppia integrazione. Troviamo la doppia integrazione della seguente equazione,

Integrazione con 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)

Produzione:

(3.0, 9.657432734515774e-14)

Hai visto l'output sopra come lo stesso precedente.

Sintesi

  • SciPy (pronunciato come "Sigh Pi") è un open source Pythonbasata su libreria, utilizzata in matematica, calcolo scientifico, ingegneria e calcolo tecnico.
  • SciPy contiene una varietà di sottopacchetti che aiutano a risolvere i problemi più comuni relativi al calcolo scientifico.
  • SciPy è integrato in NumPy
Nome pacchetto Descrizione
scipy.io Ingresso/uscita file
scipy.special Funzione speciale
scipy.linalg Algebra lineare Operaproduzione
scipy.interpolare Interpolazione
scipy.ottimizzare Ottimizzazione e adattamento
scipy.stats Statistiche e numeri casuali
scipy.integrate Integrazione numerica
scipy.fftpack Trasformate veloci di Fourier
scipy.signal Signal Lavorazione
scipy.ndimage Manipolazione delle immagini –

Riassumi questo post con: