Fonctionnement du tableau NumPy (3)

Dans la continuité de Dernière fois, l'histoire de NumPy continue sans discipline sexuelle.

Pourquoi utiliser NumPy en premier lieu

Cela s'appelle l'analyse des données, mais que sont les données en premier lieu? Les données sont une collection de nombres. En regardant autour de nous, le nombre total de livres sur le bureau, les assiettes sur la table et les pommes alignées au Yahyakuya est fini. Par exemple, il y a 14 livres, 22 assiettes, 56 pommes au total, etc.

Un tel nombre limité et fini de choses peut être combiné en un à tout moment si nécessaire. L'ensemble des choses dans le monde que nous vivons et expérimentons est donc constitué d'un nombre fini de choses.

Une collection d'objets est une collection. Lorsque le nombre total d'objets auxquels vous pensez est petit, la perception de chaque objet et la perception de l'ensemble entier ne sont pas si différentes. Cependant, à mesure que le nombre d'objets inclus dans un concept augmente, la manière de reconnaître le tout comme un devient différente. Par exemple, en termes de nombres naturels, il existe une différence entre la reconnaissance de chaque nombre naturel et la reconnaissance du nombre entier naturel comme un seul symbole. La manière de reconnaître ce tout comme un est la base de la théorie des ensembles.

Considérons maintenant la théorie des ensembles et l'algèbre linéaire. L'espace vectoriel en algèbre linéaire fait référence à la structure mathématique d'une collection d'éléments appelée vecteur. En gros, l'algèbre linéaire est la mathématique des vecteurs et des matrices, mais il est essentiel de prendre en charge une bibliothèque dédiée pour gérer ces vecteurs, matrices et tableaux multidimensionnels qui les composent. Par conséquent, maîtriser NumPy signifie également maîtriser la structure et la manipulation des données réelles à analyser.

Enregistrer l'objet ndarray

Les fonctions np.save et np.load peuvent entrer et sortir des objets ndarray sous forme de fichiers. De plus, np.savetxt et np.loadtxt créent le fichier au format texte.

De plus, si vous pouvez utiliser des pandas, vous pouvez utiliser des fonctions d'ordre supérieur read_csv, read_table, write_csv, write_table.

arr = np.arange(10)
#=> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.save('hoge', arr) #Économisez avec hoge, extension.npy
arr2 = np.load('hoge.npy') #Charger l'objet enregistré
arr2
#=> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) #Restauration réussie

np.savetxt('fuga.txt', arr) #Enregistrer sous forme de texte
arr3 = np.loadtxt('fuga.txt') #Lire à partir du texte
arr3
#=> array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.])

Calcul matriciel

Comme mentionné ci-dessus, le calcul de l'algèbre linéaire est une position importante dans les calculs de tableaux tels que NumPy.

La fonction de remodelage est une fonction très utile lors de la génération d'un tableau multidimensionnel.

x = np.array([1,2,3,4,5,6]).reshape([2,3])
#=> array([[1, 2, 3],
#          [4, 5, 6]])

y = np.array([6,23,-1,7,8,9]).reshape([3,2])
#=> array([[ 6, 23],
#          [-1,  7],
#          [ 8,  9]])

x.dot(y) #Trouvez le produit intérieur
#=> array([[ 28,  64],
#          [ 67, 181]])
from numpy.linalg import inv, qr, pinv, eig

x = np.random.randn(5,5)
x.T #Déplacer
#=> array([[ 0.1797343 , -1.48685211,  1.89995885, -1.48818535,  0.22707072],
#          [ 0.16362348,  0.73820851,  0.6830228 , -0.28744869,  1.60110706],
#          [-0.25212006, -0.75832623,  1.08510935,  0.36069392, -0.25172285],
#          [-1.23742215, -0.27616976,  1.09778477, -0.79290683,  1.88819678],
#          [ 1.25424329, -0.44571606, -0.37970879,  0.25329534, -0.0571783 ]])

mat = x.T.dot(x)
mat #Inverser et trouver le produit intérieur
#=> array([[ 8.119134  ,  1.02085855,  2.54992915,  3.88270879, -0.22322061],
#          [ 1.02085855,  3.68441518, -0.36661744,  3.59459509, -0.54751549],
#          [ 2.54992915, -0.36661744,  2.00954999,  0.95132328, -0.28449209],
#          [ 3.88270879,  3.59459509,  0.95132328,  7.00660306, -2.15457716],
#          [-0.22322061, -0.54751549, -0.28449209, -2.15457716,  1.98339569]])

inv(mat) #Renvoie l'inverse d'une matrice carrée
#=> array([[ 0.34294894,  0.13024165, -0.30841121, -0.30883099, -0.30517266],
#          [ 0.13024165,  0.87379103,  0.25904943, -0.69902729, -0.46633355],
#          [-0.30841121,  0.25904943,  0.98083558, -0.06094767,  0.11128055],
#          [-0.30883099, -0.69902729, -0.06094767,  0.91304207,  0.75537864],
#          [-0.30517266, -0.46633355,  0.11128055,  0.75537864,  1.17764414]])

q, r = qr(mat) #Démontage QR
q
#=> array([[-0.86261627,  0.28238894,  0.35807769,  0.08420784, -0.20208678],
#          [-0.10846098, -0.74407004,  0.01429817,  0.58226198, -0.30880827],
#          [-0.27091687,  0.2393467 , -0.87410947,  0.31594231,  0.0736905 ],
#          [-0.41251786, -0.54595751, -0.16208726, -0.50524429,  0.50021529],
#          [ 0.02371604,  0.10611234,  0.28501978,  0.54661567,  0.7798415 ]])

r
#=> array([[-9.41221986, -2.67672118, -3.10345255, -6.93833754,  1.26485136],
#          [ 0.        , -4.56152677,  0.92426978, -5.40443517,  1.66303293],
#          [ 0.        , -0.        , -1.08401917, -1.13963141,  1.07545497],
#          [ 0.        ,  0.        ,  0.        , -1.997258  ,  1.7452655 ],
#          [-0.        , -0.        , -0.        , -0.        ,  0.66220471]])

pinv(mat) #Renvoie un pseudo inverse de Moore Penrose
#=> array([[ 0.34294894,  0.13024165, -0.30841121, -0.30883099, -0.30517266],
#          [ 0.13024165,  0.87379103,  0.25904943, -0.69902729, -0.46633355],
#          [-0.30841121,  0.25904943,  0.98083558, -0.06094767,  0.11128055],
#          [-0.30883099, -0.69902729, -0.06094767,  0.91304207,  0.75537864],
#          [-0.30517266, -0.46633355,  0.11128055,  0.75537864,  1.17764414]])

np.trace(mat) #Renvoie la somme des composantes diagonales
#=> 22.80309791710043

eig(mat) #Renvoie les valeurs propres et les vecteurs propres pour une matrice carrée
#=> (array([ 13.3600683 ,   5.95602662,   2.24791381,   0.81881059,   0.4202786 ]),
#    array([[-0.64467006, -0.63086541,  0.20659265,  0.31642236, -0.20881982],
#          [-0.31183983,  0.5014887 ,  0.55973159, -0.32086736, -0.48477798],
#          [-0.19333292, -0.33433927, -0.32170008, -0.86424035, -0.02091191],
#          [-0.65225524,  0.42536152, -0.20774674,  0.04440243,  0.59033922],
#          [ 0.15601897, -0.24042203,  0.70524491, -0.21917587,  0.61028427]]))

Résumé

Cette fois, j'ai expliqué les fonctions fréquentes de l'algèbre linéaire, qui sont particulièrement importantes. C'est la partie fondamentale du calcul scientifique, alors étudions-le bien.

Recommended Posts

Fonctionnement du tableau NumPy (3)
Fonctionnement du tableau NumPy (1)
calcul de tableau numpy python
Créer un tableau numpy python
Calcul de tableau multidimensionnel sans Numpy
À propos du tableau Numpy et d'un tableau
Accès en indice au tableau numpy python
Calcul de tableau multidimensionnel sans Numpy Partie 2
Application Python: Numpy Partie 3: Double tableau
Extraire plusieurs éléments avec le tableau Numpy
Inverser le tableau booléen numpy dans tilda
pratique numpy 1
Numpy [basique]
numpy partie 1
Principes de base de NumPy
Mémorandum Numpy _ Matrice
astuces numpy
Python / numpy> fichier de liste (tableau numpy) sauvegarde / chargement
À propos de numpy
Axe NumPy
Utilisez Numpy
numpy partie 2
Différence entre le tableau Numpy 1D [x] et le tableau 2D [x, 1]
Ajouter des lignes à un tableau vide avec numpy
La forme du tableau unidimensionnel de numpy était compliquée
[Python numpy] Spécifiez dynamiquement l'index du tableau
Vitesse de calcul de l'indexation pour un tableau quadratique numpy