Metodo Numpy SVD

La decomposizione del valore singolare è uno dei concetti più importanti nell'algebra lineare. Comprendere la decomposizione del valore singolare (SVD) comporta familiarità con concetti correlati, come matrici, tipi di matrice e trasformazioni di matrice. A causa dei collegamenti tra la singolare decomposizione del valore di una matrice e altri argomenti algebrici lineari, l'apprendimento dell'idea è diventato più impegnativo. In questo articolo, scoprirai la definizione di decomposizione del valore singolare ed esempi dettagliati di decomposizione della matrice 2*2 e 3*3. L'approccio SVD sarà spiegato a fondo in questo post. Potresti trovare tutto il materiale necessario qui, a partire dall'introduzione e passando a numerosi esempi.

Cos'è la decomposizione del valore singolare?

Quando una matrice viene presa in considerazione in tre diverse matrici, si dice che si decomponga in valori singolari. Questo concetto è noto come SVD, che sta per una decomposizione di valore singolare. Di conseguenza, quando Matrix "One" viene preso in considerazione nel prodotto di tre matrici, la decomposizione del valore singolare di Matrix "One" può essere scritta come One = UDVT. In questo caso, le colonne U e V sono ortonormali, mentre la matrice D è diagonale, con voci reali positive.

Sintassi del metodo SVD

La sintassi del metodo SVD ha alcuni parametri.

Ora, hai una comprensione di base del metodo SVD e della sua sintassi. Discutiamo alcuni esempi di come usare la funzione.

Esempio 1

Nel primo esempio di questo articolo, ti forniremo il codice di esempio che applica il metodo SVD. Vediamo il codice riga per riga.

Nella seguente screenshot, puoi vedere che abbiamo importato la libreria Numpy disponibile in Python. Viene fatto con un semplice codice "import numpy" e di solito lo scriviamo nella prima riga del codice. Successivamente, abbiamo creato l'array chiamato "arr_data" usando il numpy.Metodo dell'array. L'array contiene [1, 2, 3, 4, 5], [11, 22, 33, 11, 23], [6, 8, 10, 2, 4] e [5, 7, 3, 5, 3 ] valori.

In seguito, abbiamo usato due istruzioni di stampa per visualizzare l'array originale. Nella riga successiva del codice, abbiamo usato il numpy.Linla.Metodo SVD sull'array creato sopra. Qui, abbiamo impostato il parametro full_matrices su "false". Nell'ultima sezione, vengono utilizzate altre due istruzioni di stampa (). Un'istruzione di stampa per visualizzare il "fattore dell'array creato di SVD:" e la seconda istruzione di stampa per mostrare il risultato sulla schermata di output.

importa numpy
arr_data = numpy.Array ([[1, 2, 3, 4, 5], [11, 22, 33, 11, 23],
[6, 8, 10, 2, 4], [5, 7, 3, 5, 3]],
dtype = numpy.float32)
Stampa ("Ecco l'array originale:")
Stampa (arr_data)
U, s, v = numpy.linalg.SVD (arr_data, full_matrices = false)
print ("\ nfactor dell'array creato di SVD:")
print ("\ nu =", u, "\ n \ ns =", s, "\ n \ nv =", v)

La schermata dei risultati è collegata, in cui è possibile vedere l'array originale e il fattore di quell'array usando il metodo SVD.

Esempio 2

Ecco il secondo esempio di questo articolo in cui viene applicato lo stesso concetto ma su un array diverso contenente valori diversi. Nella seconda riga del codice, puoi vedere che abbiamo creato un array chiamato "Arr_val" con il numpy.Metodo dell'array. L'array contiene valori [7, 1, 2], [3, 7, 3] e [2, 4, 7]. Successivamente, viene visualizzato l'array originale, in modo da poter vedere facilmente la differenza tra l'array originale e il risultato generato. Il numpy.linalg.Il metodo SVD viene applicato successivamente sull'array specificato e il risultato viene visualizzato.

Importa numpy
arr_val = numpy.Array ([[7, 1, 2], [3, 7, 3],
[2, 4, 7]], dType = numpy.float32)
Stampa ("Ecco l'array originale:")
Stampa (arr_val)
U, s, v = numpy.linalg.SVD (arr_val, full_matrices = false)
Stampa ("\ nfactor dell'array creato con metodo SVD:")
print (“\ nu =”, u, “\ n \ ns =”, s, “\ n \ nv =”, v)

Ecco l'output in cui è possibile vedere l'array originale e il fattore di quell'array calcolato con il metodo SVD.

Esempio 3

Qui, un array diverso viene archiviato in "arr_3^Rd"E i suoi valori sono [12, 3], [4, 7]. Il resto del codice di questo programma è quasi lo stesso di sopra. È possibile confrontare l'output generato da questo codice e l'output fornito dagli esempi precedenti. L'uscita differisce in base all'array di input fornito con la forma e la dimensione.

Importa numpy
arr_3rd = numpy.Array ([[12, 3], [4, 7]], dType = Numpy.float32)
Stampa ("Ecco l'array originale:")
Stampa (arr_3rd)
U, s, v = numpy.linalg.SVD (arr_3rd, full_matrices = false)
Stampa ("\ nfactor dell'array creato con metodo SVD:")
print (“\ nu =”, u, “\ n \ ns =”, s, “\ n \ nv =”, v)

Ecco il seguente risultato:

Esempio 4

Questo è l'esempio finale di questo articolo e qui stiamo usando due array 2D separati. Vediamo il codice riga per riga nella seguente screenshot.

Qui, abbiamo iniziato con l'importazione di numpy e numpy.moduli linalg che forniscono tutte le funzionalità richieste per l'algebra lineare. Successivamente, due array 2D vengono creati con il numpy.casuale.Metodo Randn. Questi array sono archiviati nelle variabili "First_arr" e "Seconc_arr". Successivamente, un'istruzione di stampa viene utilizzata per visualizzare gli array originali. La linea di codifica per questo è "Stampa (" Ecco gli array originali: \ n ", first_arr)" e "Stampa (" Ecco gli array originali: \ n ", second_arr)".

Ora abbiamo usato il GNL.Metodo SVD sull'array dato e imposta l'opzione Full_Matrices su "True". Nell'ultima sezione, vengono utilizzate altre quattro dichiarazioni di stampa. La prima istruzione di stampa visualizzerà "Qui puoi vedere la forma di tutti i valori restituiti:" Testo e il resto delle istruzioni di stampa visualizzerà la forma dei valori restituiti dalla funzione eseguita. Vedere lo screenshot del codice completo di seguito:

importa numpy
importa numpy.Linalg come GNL
First_arr = numpy.casuale.Randn (2, 5) + 1J*Numpy.casuale.Randn (2, 5)
Second_arr = b = numpy.casuale.Randn (2, 5, 7, 3) + 1J*Numpy.casuale.Randn (2, 5, 7, 3)
Stampa ("Ecco gli array originali: \ n", First_arr)
Stampa ("Ecco gli array originali: \ n", second_arr)
u, s, vh = lng.SVD (First_arr, full_matrices = true)
Stampa ("Qui puoi vedere la forma di tutti i valori restituiti: \ n")
print ("u =", u.forma)
print ("s =", s.forma)
print ("vh =", vh.forma)

Le seguenti schermate di output complete del codice precedente sono allegate per il riferimento:

Conclusione

SVD è ampiamente utilizzato per risolvere i problemi in fisica, statistiche, apprendimento automatico e altri campi. Abbiamo coperto la definizione e la sintassi del metodo SVD in questo breve saggio. Inoltre, sono usate varie istanze di decomposizione di matrice 2*2 e 3*3 per illustrare il punto principale del post. Puoi usare questa pagina come risorsa per apprendere i fondamenti dell'approccio SVD e perché è impiegato così frequentemente al giorno d'oggi.