Scienza dei dati

Vettori, matrici e array Python con NumPy

Vettori, matrici e array Python con NumPy
In questa lezione, esamineremo alcuni suggerimenti e trucchi per giocare con vettori, matrici e array usando la libreria NumPy in Python. Questa lezione è un ottimo punto di partenza se stai iniziando a Data Science e hai bisogno di una panoramica matematica introduttiva di questi componenti e di come possiamo giocarci usando NumPy nel codice.

La libreria NumPy ci consente di eseguire varie operazioni che devono essere eseguite su strutture dati spesso utilizzate in Machine Learning e Data Science come vettori, matrici e array. Mostreremo solo le operazioni più comuni con NumPy che vengono utilizzate in molte pipeline di Machine Learning. Infine, tieni presente che NumPy è solo un modo per eseguire le operazioni, quindi le operazioni matematiche che mostriamo sono l'obiettivo principale di questa lezione e non il pacchetto NumPy stesso. Iniziamo.

Cos'è un vettore??

Secondo Google, un vettore è una quantità che ha una direzione e una grandezza, in particolare per determinare la posizione di un punto nello spazio rispetto a un altro.

I vettori sono molto importanti nell'apprendimento automatico in quanto non descrivono solo la grandezza ma anche la direzione delle caratteristiche. Possiamo creare un vettore in NumPy con il seguente frammento di codice:

importa numpy come np
vettore_riga = np.matrice([1,2,3])
print(row_vector)

Nel frammento di codice sopra, abbiamo creato un vettore di riga. Possiamo anche creare un vettore colonna come:

importa numpy come np
col_vector = np.matrice([[1],[2],[3]])
print(col_vector)

Fare una matrice

Una matrice può essere semplicemente intesa come un array bidimensionale. Possiamo creare una matrice con NumPy creando un array multidimensionale:

matrice = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
stampa (matrice)

Sebbene la matrice sia esattamente simile all'array multidimensionale, la struttura dati a matrice non è raccomandata per due ragioni:

  1. L'array è lo standard quando si tratta del pacchetto NumPy
  2. La maggior parte delle operazioni con NumPy restituisce array e non una matrice

Utilizzo di una matrice sparsa

Per ricordare, una matrice sparsa è quella in cui la maggior parte degli elementi è zero. Ora, uno scenario comune nell'elaborazione dei dati e nell'apprendimento automatico è l'elaborazione di matrici in cui la maggior parte degli elementi è zero. Ad esempio, considera una matrice le cui righe descrivono ogni video su Youtube e le colonne rappresentano ogni utente registrato. Ogni valore rappresenta se l'utente ha guardato o meno un video. Naturalmente, la maggior parte dei valori in questa matrice sarà zero. Il vantaggio con matrice sparsa è che non memorizza i valori che sono zero. Ciò si traduce in un enorme vantaggio computazionale e anche nell'ottimizzazione dello storage.

Creiamo una matrice spark qui:

da scipy import sparse
matrice_originale = np.array([[1, 0, 3], [0, 0, 6], [7, 0, 0]])
sparse_matrix = sparse.csr_matrix(original_matrix)
print(sparse_matrix)

Per capire come funziona il codice, esamineremo l'output qui:

Nel codice sopra, abbiamo usato una funzione di NumPy per creare a Riga sparsa compressa matrice in cui gli elementi diversi da zero sono rappresentati utilizzando gli indici a base zero. Esistono vari tipi di matrice sparsa, come:

Non ci immergeremo in altre matrici sparse qui, ma sappiamo che ognuno dei loro usi è specifico e nessuno può essere definito "migliore".

Applicazione di operazioni a tutti gli elementi del vettore

È uno scenario comune quando è necessario applicare un'operazione comune a più elementi vettoriali. Questo può essere fatto definendo una lambda e quindi vettorizzando la stessa. Vediamo alcuni frammenti di codice per lo stesso:

matrice = np.Vettore([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
mul_5 = lambda x: x * 5
vectorized_mul_5 = np.vettorizzare(mul_5)
vectorized_mul_5(matrice)

Per capire come funziona il codice, esamineremo l'output qui:

Nel frammento di codice sopra, abbiamo usato la funzione vectorize che fa parte della libreria NumPy, per trasformare una semplice definizione lambda in una funzione in grado di elaborare ogni singolo elemento del vettore. È importante notare che vettorizzare è solo un ciclo sugli elementi e non ha alcun effetto sulle prestazioni del programma. NumPy consente anche trasmissione, il che significa che invece del codice complesso sopra, avremmo potuto semplicemente fare:

matrice * 5

E il risultato sarebbe stato esattamente lo stesso. Volevo mostrare prima la parte complessa, altrimenti avresti saltato la sezione!

Media, varianza e deviazione standard

Con NumPy è facile eseguire operazioni relative alla statistica descrittiva sui vettori. La media di un vettore può essere calcolata come:

np.media (matrice)

La varianza di un vettore può essere calcolata come:

np.var(matrice)

La deviazione standard di un vettore può essere calcolata come:

np.standard (matrice)

L'output dei comandi precedenti sulla matrice data è fornito qui:

Trasposizione di una matrice

La trasposizione è un'operazione molto comune di cui sentirai parlare ogni volta che sei circondato da matrici. La trasposizione è solo un modo per scambiare i valori di colonna e riga di una matrice. Si prega di notare che a il vettore non può essere trasposto poiché un vettore è solo una raccolta di valori senza che tali valori siano classificati in righe e colonne. Si noti che la conversione di un vettore riga in un vettore colonna non è una trasposizione (basata sulle definizioni dell'algebra lineare, che non rientra nell'ambito di questa lezione).

Per ora, troveremo la pace semplicemente trasponendo una matrice. È molto semplice accedere alla trasposta di una matrice con NumPy:

matrice.T

L'output del comando precedente sulla matrice data è fornito qui:

La stessa operazione può essere eseguita su un vettore riga per convertirlo in un vettore colonna.

Appiattire una matrice

Possiamo convertire una matrice in un array unidimensionale se desideriamo elaborare i suoi elementi in modo lineare. Questo può essere fatto con il seguente frammento di codice:

matrice.appiattire()

L'output del comando precedente sulla matrice data è fornito qui:

Nota che la matrice appiattita è una matrice unidimensionale, semplicemente lineare alla moda.

Calcolo di autovalori e autovettori

Gli autovettori sono molto comunemente usati nei pacchetti di Machine Learning. Quindi, quando una funzione di trasformazione lineare viene presentata come una matrice, allora X, Autovettori sono i vettori che cambiano solo nella scala del vettore ma non nella sua direzione. Possiamo dire che:

Xv = γv

Qui, X è la matrice quadrata e contiene gli autovalori. Inoltre, v contiene gli autovettori. Con NumPy è facile calcolare Autovalori e Autovettori. Ecco il frammento di codice in cui dimostriamo lo stesso:

evalue, vettore = np.linalg.eig (matrice)

L'output del comando precedente sulla matrice data è fornito qui:

Prodotti scalari di vettori

Dot Products of Vector è un modo per moltiplicare 2 vettori. Ti parla di quanti vettori sono nella stessa direzione?, al contrario del prodotto vettoriale che ti dice il contrario, quanto piccoli sono i vettori nella stessa direzione (chiamata ortogonale). Possiamo calcolare il prodotto scalare di due vettori come indicato nel frammento di codice qui:

a = np.matrice([3, 5, 6])
b = np.matrice([23, 15, 1])
np.punto (a, b)

L'output del comando precedente sugli array dati è fornito qui:

Addizione, sottrazione e moltiplicazione di matrici

L'aggiunta e la sottrazione di più matrici è un'operazione abbastanza semplice nelle matrici. Ci sono due modi in cui questo può essere fatto. Diamo un'occhiata allo snippet di codice per eseguire queste operazioni. Allo scopo di mantenere questo semplice, useremo la stessa matrice due volte:

np.add(matrice, matrice)

Successivamente, due matrici possono essere sottratte come:

np.sottrai(matrice, matrice)

L'output del comando precedente sulla matrice data è fornito qui:

Come previsto, ciascuno degli elementi nella matrice viene aggiunto/sottratto con l'elemento corrispondente. Moltiplicare una matrice è simile a trovare il prodotto scalare come abbiamo fatto in precedenza:

np.punto (matrice, matrice)

Il codice sopra troverà il vero valore di moltiplicazione di due matrici, dato come:

matrice * matrice

L'output del comando precedente sulla matrice data è fornito qui:

Conclusione

In questa lezione, abbiamo svolto molte operazioni matematiche relative a vettori, matrici e array che sono comunemente usati Elaborazione dei dati, statistica descrittiva e scienza dei dati. Questaèuna lezione veloce che copre solo le sezioni piùcomuni e piùimportanti dell'ampia varietà di concetti ma queste operazioni dovrebbero dare un'idea molto buona di cosa possono essere eseguite tutte le operazioni quando si tratta di queste strutture di dati.

Per favore condividi il tuo feedback liberamente sulla lezione su Twitter con @linuxhint e @sbmaggarwal (sono io!).

Come utilizzare AutoKey per automatizzare i giochi Linux
AutoKey è un'utilità di automazione desktop per Linux e X11, programmata in Python 3, GTK e Qt. Utilizzando la sua funzionalità di scripting e MACRO, ...
Come mostrare il contatore FPS nei giochi Linux
I giochi Linux hanno avuto una grande spinta quando Valve ha annunciato il supporto Linux per il client Steam e i loro giochi nel 2012. Da allora, mol...
Come scaricare e giocare a Sid Meier's Civilization VI su Linux
Introduzione al gioco Civilization 6 è una versione moderna del concetto classico introdotto nella serie dei giochi Age of Empires. L'idea era abbasta...