Les personnes qui ont entendu dire que python est bon pour le calcul numérique et l'apprentissage automatique, et ont commencé python, mais c'est un peu difficile, mais C ++ est plus rapide du tout. Les personnes qui ont entendu le nom de numpy mais ne l'ont jamais utilisé. J'ai essayé d'utiliser numpy, mais le point est une version avancée du package math? Quelqu'un qui pense. Pour ces personnes, je vais vous apprendre à utiliser correctement numpy!
Si vous avez installé python en utilisant anaconda, vous avez probablement déjà numpy. Il est possible que numpy soit inclus en fonction de la méthode d'installation. Alors vérifions d'abord si numpy est inclus.
Tapez python dans le terminal (invite de commande pour Windows) pour lancer la console python. Dans la console python
> import numpy
S'il n'y a pas d'erreur lors de la saisie, il est installé. Si vous obtenez une erreur comme "No Module Named numpy", il n'est pas installé et vous devez l'installer. Dans le terminal (pas la console python)
$ pip install numpy
Vous pouvez l'installer avec.
À partir de là, nous examinerons spécifiquement la programmation utilisant numpy, mais numpy est
> import numpy as np
Est importé. Cela signifie importer le module numpy avec le nom np.
Les bases de numpy commencent par la création d'un tableau. L'arrangement avec le contenu «1,2,3» est
> arr = np.asarray([1,2,3])
> arr
array([1, 2, 3])
Tu peux le faire.
De plus, vous pouvez spécifier le type du tableau en spécifiant dtype. Les types fréquemment utilisés incluent «np.int32», «np.float32» et «np.float64». Pour l'utiliser pour créer un tableau de type np.int32
> arr = np.asarray([1,2,3], dtype=np.int32)
> arr
array([1, 2, 3], dtype=int32)
ça ira. Pour changer le type d'une baie déjà existante
> i_arr = np.asarray([1,2,3], dtype=np.int32)
> f_arr = i_arr.astype(np.float32)
> f_arr
array([ 1., 2., 3.], dtype=float32)
ça ira. À ce stade, le tableau d'origine «i_arr» ne change pas.
> i_arr
array([1, 2, 3], dtype=int32)
Pour créer un tableau multidimensionnel
> arr = np.asarray([[1,2,3], [4,5,6]])
> arr
array([[1, 2, 3],
[4, 5, 6]])
ça ira. Vous pouvez spécifier et modifier le type comme dans le cas d'unidimensionnel. L'élément shape contient la forme du tableau.
> arr.shape
(2, 3)
Il s'agit d'un type de tuple. À propos, la forme du tableau unidimensionnel est
> arr = np.asarray([1,2,3])
> arr.shape
(3,)
Sera. Il s'agit d'un type de tuple avec un seul élément.
Vous pouvez facilement créer des tableaux spéciaux avec numpy.
> #Un tableau avec tous les 0 éléments
> np.zeros((2, 3))
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
> #Un tableau avec les 1 éléments
> np.ones((2, 3))
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
> #Élément[0-1)Initialisez aléatoirement dans la plage de
> np.random.rand(2, 3)
array([[ 0.24025569, 0.48947483, 0.61541917],
[ 0.01197138, 0.6885749 , 0.48316059]])
> #Générer des éléments selon une distribution normale
> np.random.randn(2, 3)
array([[ 0.23397941, -1.58230063, -0.46831152],
[ 1.01000451, -0.21079169, 0.80247674]])
Il existe de nombreuses autres fonctions qui génèrent des tableaux. Si vous voulez ce type d'arrangement, vous pouvez le trouver sur google.
La puissance de numpy est qu'il est très facile de calculer entre les tableaux.
> a = np.asarray([[1,2,3],[4,5,6]])
Contre
> 3 * a
array([[ 3, 6, 9],
[12, 15, 18]])
Ce sera. La multiplication scalaire du tableau multipliera chaque élément par une constante. Si vous ajoutez un scalaire
> 3 + a
array([[4, 5, 6],
[7, 8, 9]])
Et sont ajoutés à chaque élément. Calcul entre les tableaux
> b = np.asarray([[2,3,4],[5,6,7]])
> a + b
array([[ 3, 5, 7],
[ 9, 11, 13]])
> a * b
array([[ 2, 6, 12],
[20, 30, 42]])
Dans le calcul des tableaux de la même forme, les éléments à la même position sont calculés et le tableau de cette forme est renvoyé. Parfois, des tableaux de formes différentes peuvent être calculés.
> v = np.asarray([2,1,3])
> a * v
array([[ 2, 2, 9],
[ 8, 5, 18]])
> a + v
array([[3, 3, 6],
[6, 6, 9]])
Dans le calcul d'un tableau bidimensionnel et d'un tableau unidimensionnel, le résultat du calcul de chaque ligne du tableau bidimensionnel en tant que tableau unidimensionnel lorsque le nombre de colonnes du tableau bidimensionnel est égal à la longueur du tableau unidimensionnel est Je reviendrai. Par conséquent, le tableau a la même forme que le tableau à deux dimensions.
Il est également possible d'effectuer des opérations en utilisant un tableau à deux dimensions comme une seule matrice.
> M = np.asarray([[1,2,3], [2,3,4]])
> N = np.asarray([[1,2],[3,4], [5,6]])
Pour trouver le produit de deux tableaux de
> M.dot(N)
array([[22, 28],
[31, 40]])
ça ira. Ici, nous multiplions la matrice $ 2 \ fois 3 $ par la matrice $ 3 \ fois 2 $, donc la matrice $ 2 \ fois 2 $ est retournée.
numpy vous permet de placer des tableaux dans diverses fonctions. A ce moment, la fonction agit sur chaque élément. Par exemple
> a = np.asarray([[1,2], [3,1])
> np.log(a)
array([[ 0. , 0.69314718],
[ 1.09861229, 0. ]])
Ce sera. À ce stade, le tableau d'origine ne change pas.
En outre, il existe la plupart des fonctions possibles telles que la fonction triangulaire, ʻexp, sqrt` et ainsi de suite.
numpy est également efficace pour collecter des statistiques sur les tableaux. Les 100 premiers génèrent ce nombre aléatoire.
> arr = np.random.rand(100)
Prendre la moyenne de la séquence
> np.mean(arr)
0.52133315138159586
ça ira. Les valeurs maximale et minimale sont
> np.max(arr)
0.98159897843423383
> np.min(arr)
0.031486992721019846
Tu peux l'avoir. L'écart type est
> np.std(arr)
0.2918171894076691
Pour obtenir la somme
> np.sum(arr)
52.133315138159588
ça ira. Vous pouvez également spécifier dans quelle direction les statistiques doivent être prises pour un tableau à deux dimensions. Par exemple
> arr = np.asarray([[1,2,3], [2,3,4]])
> np.sum(arr, axis=0)
array([3, 5, 7])
> np.sum(arr, axis=1)
array([6, 9])
Ce sera.
En incluant ce qui précède, utilisons numpy pour calculer le code permettant de faire la moyenne des distances euclidiennes depuis les origines de 100 vecteurs dans l'espace tridimensionnel.
Tout d'abord, supposons que le tableau data est un tableau de la forme (100, 3), la première colonne est les coordonnées $ x $, la deuxième colonne est les coordonnées $ y $ et la troisième colonne est les coordonnées $ z $. ici
> data = np.random.randn(100, 3)
Généré en tant que. Distance euclidienne
d(x,y,z) = \sqrt{x^2+y^2+z^3}
Donc, tout d'abord, chaque élément est auto-monté.
> squared = data**2
Additionnez ensuite les lignes.
> squared_sum = np.sum(squared, axis=1)
A ce moment, squared_sum devient un tableau unidimensionnel. Par contre, si vous prenez la racine carrée, vous pouvez trouver la distance euclidienne de chaque point.
> dist = np.sqrt(squared_sum)
Si vous prenez la moyenne de cette distance
> np.mean(dist)
1.5423905808984208
est devenu. (Étant donné que les données sont générées de manière aléatoire, le résultat sera légèrement différent.)
Si vous exécutez ce code sans utiliser numpy, vous pouvez utiliser la boucle for pour calculer chacun des 100 points et utiliser la boucle for pour chaque point à mesure que la dimension augmente. Non seulement le code est compliqué, mais il ralentit également l'exécution. De cette façon, l'idée de base de numpy est de calculer un grand tableau à la fois. En conséquence, numpy peut effectuer des opérations complexes qui sont incroyablement rapides pour python.
Au fait, cette fois, j'ai calculé un par un pour la pratique, mais numpy a une fonction appelée np.linalg.norm, donc vous pouvez facilement calculer la distance euclidienne.
C'est tout pour l'utilisation de base de numpy, mais numpy a beaucoup plus de fonctions. Par exemple, la fonction np.where qui trouve l'index d'un élément qui remplit les conditions.
Non limité à numpy, je pense que le moyen le plus rapide de s'améliorer est d'écrire et d'expérimenter python tout en googlé, alors faites de votre mieux même si vous êtes confus au début!
Recommended Posts