D'un traducteur: il s'agit d'une traduction du matériel de Rakshit Vasudev, qui étudie depuis longtemps DataScience et utilise le langage Python. L'auteur parle de la puissante bibliothèque Numpy, qui vous permet de mettre en œuvre de nombreuses fonctionnalités d'apprentissage automatique et de travailler avec des mégadonnées.
Numpy est une bibliothèque mathématique pour Python. Il vous permet d'effectuer toutes sortes de calculs efficacement et rapidement. Il étend considérablement les fonctionnalités de Python grâce aux solutions spéciales qui y sont utilisées. Cet article parle des fonctionnalités de base de Numpy, et ce n'est que la première partie; d'autres seront publiés un peu plus tard. Cet article est destiné à ceux qui commencent tout juste à apprendre le numpy et à entrer dans le monde courageux des mathématiques en Python.
Skillbox recommande: Le cours pratique de Python Developer from scratch .
Nous vous rappelons: pour tous les lecteurs de «Habr» - une remise de 10 000 roubles lors de l'inscription à un cours Skillbox en utilisant le code promo «Habr».
Importer une bibliothèque
import numpy as np
À ce stade, nous disons à Python que np est la référence pour Numpy, qui continuera d'être utilisé.
Créez maintenant un tableau python et un tableau np.
Il n'y a pas beaucoup de différence dans le retrait.
print(a) print(A) ==================================================================== [1, 2, 3, 4, 5, 6, 7, 8, 9] [1 2 3 4 5 6 7 8 9]
Eh bien, pourquoi est-il préférable d'utiliser un tableau numpy au lieu de celui habituel? La réponse est que np nous permettra de faire des calculs plus rapidement et de modifier l'architecture globale de l'application.
np.arange ()
np.arange(0,10,2) ==================================================================== array([0, 2, 4, 6, 8])
([démarrer], arrêter, [étape]) ordonne les numéros. C'est ce que cela signifie pour une voiture.
Nous créons une liste np, en commençant de 0 à 10, mais n'incluons pas 10, et augmentons les nombres de 2 à chaque fois.
Ainsi, nous obtenons ceci:
tableau ([0, 2, 4, 6, 8])
Il est important de se rappeler que le dernier chiffre n'est pas inclus dans la liste.
Un autre exemple:
np.arange(2,29,5) ==================================================================== array([2, 7, 12, 17, 22, 27])
Ce tableau peut également être appelé matrice ou vecteur. Par conséquent, ne vous inquiétez pas lorsque je dis, par exemple: "La forme de la matrice est 2 * 3." Tout cela signifie que notre tableau finira par ressembler à ceci:
array([2, 7, 12], [17, 22, 27])
Parlons maintenant d'un paramètre tel que la forme du tableau np par défaut. La forme ici est un attribut. Un exemple de son utilisation est ci-dessous.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.shape ==================================================================== (9,)
Il s'agit d'une matrice de nombres, où dans une rangée il n'y a que 9 éléments. En principe, une matrice 1 * 9 est idéale, non?
Fondamentalement, oui, et pour cela, reshape () entre en jeu. Il s'agit d'une méthode qui redimensionne la matrice d'origine comme nous le souhaiterions.
Voici un exemple d'utilisation de reshape () dans la pratique.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.reshape(1,9) ==================================================================== array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
Notez que remodeler renvoie une matrice multidimensionnelle. Ceci est indiqué par deux crochets au début. [[1, 2, 3, 4, 5, 6, 7, 8, 9]] est une matrice potentiellement multidimensionnelle, contrairement à [1, 2, 3, 4, 5, 6, 7, 8, 9].
Un autre exemple:
B = [1, 2, 3, 4, 5, 6, 7, 8, 9] B.reshape(3,3) ==================================================================== array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
Si nous prenons le paramètre de forme pour B, alors ce sera (3.3):
B.shape ==================================================================== (3,3)
Passons à np.zeros ()
Qu'est-ce qui est énoncé dans ce code?
np.zeros((4,3)) ==================================================================== ???????????
A savoir: ici une matrice au format 3 * 4 remplie de zéros est donnée. Voici la conclusion:
np.zeros((4,3)) ==================================================================== array([[0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.]])
np.zeros ((n, m)) renvoie une matrice au format n * m remplie de zéros. Tout est simple.
Que fait np.eye ()?
Nous renvoie une matrice unitaire avec certaines caractéristiques.
np.eye(5) ==================================================================== array([[1., 0., 0., 0., 0.], [0., 1., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 0., 0., 1., 0.], [0., 0., 0., 0., 1.]])
Comment multiplier deux matrices?
Pas de problème: on utilise pour cela np.dot () Cette fonction est un produit scalaire si des vecteurs et le produit matriciel (le plus ordinaire) lui sont passés.
Exemple: A = (2,3) & B = (3,2). Ici, le nombre de colonnes dans A est 3. Le nombre de lignes dans B est 3. Puisque les caractéristiques coïncident, la multiplication est possible.
Nous avons préparé des matrices pour la multiplication. Ensuite - nous agissons.
Ajoutons maintenant les éléments individuels à la matrice.
np.sum () ajoute des éléments à la matrice.
Cependant, nous avons deux options.
1. Pliez en rangées
6 - la somme de la première ligne (1, 2, 3).
15 - seconde (4, 5, 6).
24 - troisième (7, 8, 9).
2. Pliez en colonnes
12 - la somme de la première colonne (1, 4, 7).
15 - selon le second (2, 5, 7).
18 - selon le troisième (3, 6, 9).
Ci-dessous, une vidéo créée par l'auteur, où tout ce qui est décrit ci-dessus est expliqué de nouveau, plus clairement.
Skillbox recommande: