Python Tutorial: cos’è SciPy e come usare la libreria SciPy in Python

Python è un linguaggio evoluto che deve la sua potenza, e la sua popolarità alle librerie.

SciPy è una di queste, forse quella in grado di esprimere la maggiore versatilità del linguaggio.

Questo tutorial su funzioni SciPy spiega le basi di SciPy, come la sua architettura e ambiente, vediamolo insieme.

Estimated reading time: 8 minuti

SciPy, una libreria scientifica Open Source per Python, con licenza BSD per matematica, scienza e ingegneria. La libreria di funzioni SciPy dipende da NumPy, che fornisce una manipolazione degli array N-dimensionale comoda e veloce. La libreria SciPy fornisce molte pratiche numeriche user-friendly ed efficienti come le routine per l’integrazione e l’ottimizzazione numerica.

Questo tutorial SciPy spiega le basi di SciPy, come la sua architettura, e l’ambiente. Tutto questo è spiegato con l’aiuto di esempi per una migliore comprensione.

Sub-pacchetti SciPy

SciPy è organizzato in sotto-pacchetti che coprono diversi domini di calcolo scientifico. Questi sono riassunti nella seguente tabella ?

Struttura dei dati

La struttura dati di base utilizzata da SciPy è un array multidimensionale fornito dal modulo NumPy. NumPy fornisce alcune funzioni per l’algebra lineare, le trasformate di Fourier e la generazione di numeri casuali, ma non con la generalità delle funzioni equivalenti in SciPy.

Per impostazione predefinita, tutte le funzioni NumPy sono disponibili tramite lo spazio dei nomi SciPy. Non è necessario importare esplicitamente le funzioni NumPy, quando SciPy viene importato. L’oggetto principale di NumPy è l’array multidimensionale omogeneo. È una tabella di elementi (di solito numeri), tutti dello stesso tipo, indicizzati da una tupla di numeri interi positivi. In NumPy, le dimensioni sono chiamate assi. Il numero di axes è definito come rank.

Ora, rivediamo le funzionalità di base di Vettori e Matrici in NumPy. Poiché SciPy è costruito su array NumPy, è necessaria la comprensione delle basi NumPy.

Vettori di NumPy

Un vettore può essere creato in diversi modi. Vediamo qui di seguito alcuni esempi

Conversione di oggetti simili a array Python in NumPy

Consideriamo il seguente esempio.

import numpy as np
list = [1,2,3,4]
arr = np.array(list)
print arr

L’output del programma di cui sopra sarà il seguente.

[1 2 3 4]

Creazione di Array NumPy

NumPy ha funzioni integrate per la creazione di array. Vediamo qui di seguito queste funzioni.

Usando ZEROS()

La funzione zeros crea un array con tutti valori a zero. Il dtype predefinito è float64. Consideriamo il seguente esempio.

import numpy as np
print np.zeros((2, 3))

L’output del programma di cui sopra sarà il seguente.

array([[ 0., 0., 0.],
[ 0., 0., 0.]])

Funzione ones()

La funzione ones() creerà un array riempito con valori a 1. È identico a zero per tutti gli altri aspetti. Consideriamo il seguente esempio.

import numpy as np
print np.ones((2, 3))

L’output del programma di cui sopra sarà il seguente.

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

Funzione arange()

La funzione arange() creerà matrici con valori che incrementano regolarmente. Consideriamo il seguente esempio.

import numpy as np
print np.arange(7)

Il programma di cui sopra genererà il seguente output.

array([0, 1, 2, 3, 4, 5, 6])

Definizione del tipo di dati dei valori

Consideriamo il seguente esempio.

import numpy as np
arr = np.arange(2, 10, dtype = np.float)
print arr
print "Array Data Type :",arr.dtype

Il programma di cui sopra genererà il seguente output.

[ 2., 3., 4., 5., 6., 7., 8., 9.]
Array Data Type : float64

Funzione linspace()

La funzione linspace() crea matrici con un numero specificato di elementi, che saranno intervalli equamente tra i valori di inizio e fine specificati. Consideriamo il seguente esempio.

import numpy as np
print np.linspace(1., 4., 6)

Il programma di cui sopra genererà il seguente output.

array([ 1. , 1.6, 2.2, 2.8, 3.4, 4. ])

Matrix

Una matrix è un array 2D che mantiene la sua natura 2-D attraverso le operazioni. Ha alcuni operatori speciali, come * (la moltiplicazione a matrice) e ** (potenza matrice). Consideriamo il seguente esempio.

import numpy as np
print np.matrix('1 2; 3 4')

Il programma di cui sopra genererà il seguente output.

matrix([[1, 2],
[3, 4]])

La Conjugate Transpose di Matrix

Questa funzione restituisce la trasposizione coniugata (complessa) della matrice. Consideriamo il seguente esempio.

import numpy as np
mat = np.matrix('1 2; 3 4')
print mat.H

Il programma di cui sopra genererà il seguente output.

matrix([[1, 3],
        [2, 4]])

La trasposta di Matrix

Questa funzione restituisce la trasposizione della matrice. Consideriamo il seguente esempio.

import numpy as np
mat = np.matrix('1 2; 3 4')
mat.T

Il programma di cui sopra genererà il seguente output.

matrix([[1, 3],
        [2, 4]])

Quando trasponiamo una matrice, facciamo una nuova matrice le cui righe sono le colonne dell’originale. Una trasposizione coniugata, invece, intercambia la riga e l’indice di colonna per ogni elemento della matrice. L’inverso di una matrice è una matrice che, se moltiplicata con la matrice originale, si traduce in una matrice di identità.

K-means clustering

Il clustering dei media K è un metodo per trovare cluster e centri cluster in un insieme di dati non etichettati. Intuitivamente, potremmo pensare a un cluster come a un gruppo di punti dati, le cui distanze tra i punti sono piccole rispetto alle distanze da punti al di fuori del cluster. Dato un primo insieme di centri K, l’algoritmo K-means itera i seguenti due passaggi

• Per ogni centro, il sottoinsieme di punti di allenamento (il suo cluster) che è più vicino ad esso è identificato rispetto a qualsiasi altro centro.
• La media di ogni caratteristica per i punti dati in ciascun cluster viene calcolata e questo vettore significato diventa il nuovo centro per quel cluster.

Questi due passaggi sono iterati fino a quando i centri non si muovono più o le assegnazioni non cambiano più. Quindi, un nuovo punto x può essere assegnato al cluster del prototipo più vicino. La libreria SciPy fornisce una buona implementazione dell’algoritmo K-Means attraverso il pacchetto cluster. Cerchiamo di capire come usarlo.

Implementazione di K-Means in SciPy

Capiremo come implementare K-Means in SciPy.

Importazione K-Means

Vedremo l’implementazione e l’utilizzo di ogni funzione importata.

from SciPy.cluster.vq import kmeans,vq,whiten

Generazione dei dati

Dobbiamo simulare alcuni dati per esplorare il clustering.

from numpy import vstack,array
from numpy.random import rand

# data generation with three features
data = vstack((rand(100,3) + array([.5,.5,.5]),rand(100,3)))

Ora, dobbiamo verificare i dati. Il programma di cui sopra genererà il seguente output.

array([[ 1.48598868e+00, 8.17445796e-01, 1.00834051e+00],
       [ 8.45299768e-01, 1.35450732e+00, 8.66323621e-01],
       [ 1.27725864e+00, 1.00622682e+00, 8.43735610e-01],
       …………….

Normalizzare un gruppo di osservazioni su base per caratteristica. Prima di eseguire K-Means, è utile ridimensionare ogni dimensione della caratteristica del set di osservazione con pulizia. Ogni caratteristica è divisa per la sua deviazione standard in tutte le osservazioni per dargli la varianza dell’unità.

PULIRE i dati

Dobbiamo usare il seguente codice per pulire i dati.

# whitening of data
data = whiten(data)

Calcola K-Means con tre cluster

Ora calcoliamo K-Means con tre cluster utilizzando il seguente codice.

# computing K-Means with K = 3 (2 clusters)
centroids,_ = kmeans(data,3)

Il codice sopra esegue K-Means su un insieme di vettori di osservazione che formano cluster K. L’algoritmo K-Means regola i centroidi fino a quando non è possibile compiere progressi sufficienti, cioè il cambiamento di distorsione, poiché l’ultima iterazione è inferiore a una soglia. Qui, possiamo osservare il centroide del cluster stampando la variabile centroidi utilizzando il codice indicato di seguito.

print(centroids)

Il codice di cui sopra genererà il seguente output.

print(centroids)[ [ 2.26034702  1.43924335  1.3697022 ]
                  [ 2.63788572  2.81446462  2.85163854]
                  [ 0.73507256  1.30801855  1.44477558] ]

Assegnare ogni valore a un cluster utilizzando il codice indicato di seguito.

# assign each sample to a cluster
clx,_ = vq(data,centroids)

La funzione vq confronta ogni vettore di osservazione nella ‘M’ da ‘N’ ob array con i centroidi e assegna l’osservazione al cluster più vicino. Restituisce il cluster di ogni osservazione e la distorsione. Possiamo anche controllare la distorsione. Controlliamo il cluster di ogni osservazione utilizzando il seguente codice.

# check clusters of observation
print clx

Il codice di cui sopra genererà il seguente output.

array([1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 2, 0, 2, 0, 1, 1, 1,
0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0,
0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
0, 1,  0, 0, 0, 0, 1, 0, 0, 1, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 0, 0,
2, 2, 2, 1, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
2, 2, 0, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], dtype=int32)

I valori distinti 0, 1, 2 dell’array precedente indicano i cluster.

Costanti SciPy

Il packet scipy.constants fornisce diverse costanti. Dobbiamo importare la costante richiesta e usarli secondo il requisito. Vediamo come queste variabili costanti vengono importate e utilizzate.

Per cominciare, confrontiamo il valore ‘pi’ considerando l’esempio seguente.

#Import pi constant from both the packages
from scipy.constants import pi
from math import pi

print("sciPy - pi = %.16f"%scipy.constants.pi)
print("math - pi = %.16f"%math.pi)

Il programma di cui sopra genererà il seguente output.

sciPy - pi = 3.1415926535897931
math - pi = 3.1415926535897931

Elenco delle costanti disponibili

Le seguenti tabelle descrivono in breve le varie costanti.

Le costanti matematiche

CostantI fisiche

La tabella seguente elenca le costanti fisiche più comunemente utilizzate.

Unità

La seguente tabella contiene l’elenco delle unità SI.

Queste unità vanno da yotta, zetta, exa, peta, tera…kilo, hector, …nano, pico, … a zepto.

altre costanti importanti

La seguente tabella elenca altre costanti importanti utilizzate in SciPy.

Per ottenere quale chiave per quale funzione, si usa il metodo scipy.constants.find(). Consideriamo il seguente esempio.

import scipy.constants
res = scipy.constants.physical_constants["alpha particle mass"]
print res

Il programma di cui sopra genererà il seguente output.

[
   'alpha particle mass',
   'alpha particle mass energy equivalent',
   'alpha particle mass energy equivalent in MeV',
   'alpha particle mass in u',
   'electron to alpha particle mass ratio'
]

Questo metodo restituisce l’elenco delle chiavi, nient’altro che la parola chiave non corrisponde.

Ercole Palmeri