Méthode SVD Numpy

La décomposition de valeur singulière est l'un des concepts les plus importants de l'algèbre linéaire. Comprendre la décomposition de valeur singulière (SVD) implique la familiarité avec les concepts connexes, tels que les matrices, les types de matrice et les transformations matricielles. En raison des liens entre la décomposition de la valeur singulière d'une matrice et d'autres sujets algébriques linéaires, l'apprentissage de l'idée est devenu plus difficile. Dans cet article, vous découvrirez la définition de la décomposition de la valeur singulière et des exemples détaillés de décomposition matricielle 2 * 2 et 3 * 3. L'approche SVD sera complètement expliquée dans ce post. Vous pouvez trouver tout le matériel nécessaire ici, en commençant par l'introduction et en passant à de nombreux exemples.

Qu'est-ce que la décomposition de la valeur singulière?

Lorsqu'une matrice est prise en compte en trois matrices différentes, il se décomposerait en valeurs singulières. Ce concept est connu sous le nom de SVD, qui signifie une décomposition de valeur singulière. En conséquence, lorsque la matrice «One» est prise en compte dans le produit de trois matrices, la décomposition de la valeur singulière de la matrice «un» peut être écrite comme un = UDVT. Dans ce cas, les colonnes U et V sont orthonormales, tandis que la matrice D est diagonale, ayant de véritables entrées positives.

Syntaxe de la méthode SVD

La syntaxe de la méthode SVD a quelques paramètres.

Maintenant, vous avez une compréhension de base de la méthode SVD et de sa syntaxe. Discutons de quelques exemples d'utilisation de la fonction.

Exemple 1

Dans le premier exemple de cet article, nous vous fournirons l'exemple de code appliquant la méthode SVD. Voyons le code ligne par ligne.

Dans la capture d'écran suivante, vous pouvez voir que nous avons importé la bibliothèque Numpy qui est disponible en Python. Cela se fait avec un simple code «Importer Numpy», et nous écrivons généralement ceci dans la première ligne du code. Après cela, nous avons créé le tableau nommé «arr_data» en utilisant le Numpy.Méthode du tableau. Le tableau contient [1, 2, 3, 4, 5], [11, 22, 33, 11, 23], [6, 8, 10, 2, 4] et [5, 7, 3, 5, 3 ] valeurs.

Après cela, nous avons utilisé deux instructions d'impression pour afficher le tableau d'origine. Dans la ligne suivante du code, nous avons utilisé le Numpy.linla.Méthode SVD sur le tableau créé ci-dessus. Ici, nous avons défini le paramètre full_matrices sur «false». Dans la dernière section, deux autres déclarations imprimées () sont utilisées. Une déclaration d'impression pour afficher le «facteur du tableau créé par SVD:» et la deuxième instruction d'impression pour afficher le résultat sur l'écran de sortie.

Importer Numpy
ar_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)
Print ("Voici le tableau d'origine:")
imprimer (ar_data)
U, s, v = numpy.linalg.svd (ar_data, full_matrices = false)
print ("\ nfactor du tableau créé par SVD:")
print ("\ nu =", u, "\ n \ ns =", s, "\ n \ nv =", v)

L'écran de résultat est attaché, dans lequel vous pouvez voir le tableau d'origine et le facteur de ce tableau en utilisant la méthode SVD.

Exemple 2

Voici le deuxième exemple de cet article dans lequel le même concept est appliqué mais sur un tableau différent contenant des valeurs différentes. Dans la deuxième ligne du code, vous pouvez voir que nous avons créé un tableau nommé "arr_val" avec le Numpy.Méthode du tableau. Le tableau contient [7, 1, 2], [3, 7, 3] et [2, 4, 7]. Après cela, le tableau d'origine s'affiche, vous pouvez donc facilement voir la différence entre le tableau d'origine et le résultat généré. Le Numpy.linalg.La méthode SVD est appliquée par la suite sur le tableau spécifié, et le résultat s'affiche.

Importer Numpy
arr_val = numpy.Array ([[7, 1, 2], [3, 7, 3],
[2, 4, 7]], dtype = numpy.float32)
Imprimer («Voici le tableau d'origine:»)
print (ar_val)
U, s, v = numpy.linalg.svd (ar_val, full_matrices = false)
Print («\ nfactor du tableau créé par méthode SVD:»)
print ("\ nu =", u, "\ n \ ns =", s, "\ n \ nv =", v)

Voici la sortie dans laquelle vous pouvez voir le tableau d'origine et le facteur de ce tableau calculé par la méthode SVD.

Exemple 3

Ici, un tableau différent est stocké dans «ar_3^rd», Et ses valeurs sont [12, 3], [4, 7]. Le reste du code de ce programme est presque le même que ci-dessus. Vous pouvez comparer la sortie générée par ce code et la sortie donnée par les exemples précédents. La sortie diffère en fonction du réseau d'entrée fourni avec la forme et la taille.

Importer Numpy
ar_3rd = numpy.Array ([[12, 3], [4, 7]], dtype = Numpy.float32)
Imprimer («Voici le tableau d'origine:»)
imprimer (ar_3rd)
U, s, v = numpy.linalg.svd (ar_3rd, full_matrices = false)
Print («\ nfactor du tableau créé par méthode SVD:»)
print ("\ nu =", u, "\ n \ ns =", s, "\ n \ nv =", v)

Voici le résultat suivant:

Exemple 4

Ceci est le dernier exemple de cet article, et ici, nous utilisons deux tableaux 2D distincts. Voyons le code ligne par ligne dans la capture d'écran suivante.

Ici, nous avons commencé par l'importation du Numpy et du Numpy.modules Linalg qui fournissent toutes les fonctionnalités requises pour l'algèbre linéaire. Après cela, deux tableaux 2D sont créés avec le Numpy.aléatoire.Méthode Randn. Ces tableaux sont stockés dans les variables «first_arr» et «seconc_arr». Suivant cela, une déclaration d'impression est utilisée pour afficher les tableaux d'origine. La ligne de codage pour cela est "Imprimer (" Voici les tableaux d'origine: \ n ", premier_arr)" et "Imprimer (" Voici les tableaux d'origine: \ n ", second_arr)".

Maintenant, nous avons utilisé le GNL.Méthode SVD sur le tableau donné et définissez l'option full_matrices sur «true». Dans la dernière section, quatre autres déclarations d'impression sont utilisées. La première instruction d'impression affichera le texte «Ici, vous pouvez voir la forme de toutes les valeurs renvoyées:», et le reste des instructions d'impression affichera la forme des valeurs renvoyées par la fonction exécutée. Voir la capture d'écran du code complet ci-dessous:

Importer Numpy
Importer Numpy.Linalg comme GNL
first_arr = numpy.aléatoire.Randn (2, 5) + 1J * Numpy.aléatoire.Randn (2, 5)
second_arr = b = numpy.aléatoire.Randn (2, 5, 7, 3) + 1J * Numpy.aléatoire.Randn (2, 5, 7, 3)
print ("Voici les tableaux d'origine: \ n", first_arr)
print ("Voici les tableaux d'origine: \ n", second_arr)
u, s, vh = lng.svd (first_arr, full_matrices = true)
print ("Ici, vous pouvez voir la forme de toutes les valeurs renvoyées: \ n")
imprimer ("u =", u.forme)
imprimer ("s =", s.forme)
print ("vh =", vh.forme)

Les captures d'écran de sortie complètes suivantes du code précédent sont jointes pour votre référence:

Conclusion

SVD est largement utilisé pour résoudre des problèmes de physique, de statistiques, d'apprentissage automatique et d'autres domaines. Nous avons couvert la définition et la syntaxe de la méthode SVD dans ce bref essai. De plus, diverses instances de décompositions de matrice 2 * 2 et 3 * 3 sont utilisées pour illustrer le point principal du post. Vous pouvez utiliser cette page comme ressource pour apprendre les principes fondamentaux de l'approche SVD et pourquoi il est utilisé si souvent de nos jours.