You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: content/manipulation/01_numpy.qmd
+67-28Lines changed: 67 additions & 28 deletions
Original file line number
Diff line number
Diff line change
@@ -12,17 +12,13 @@ categories:
12
12
description: |
13
13
`Numpy` constitue la brique de base de l'écosystème de la _data science_ en
14
14
`Python`. Toutes les librairies de manipulation de données, de modélisation
15
-
et de visualisation reposent, de manière plus ou moins directe, sur `Numpy`.
16
-
Il est donc indispensable de revoir quelques notions sur ce package avant
17
-
d'aller plus loin.
15
+
et de visualisation reposent, de manière plus ou moins directe, sur `Numpy`. Il est donc indispensable de revoir quelques notions sur ce package avant d'aller plus loin.
18
16
description-en: |
19
17
`Numpy` is the cornerstone of the _data science_ ecosystem in `Python`. All data manipulation, modeling, and visualization libraries rely, directly or indirectly, on `Numpy`. It is therefore essential to review some concepts of this package before moving forward.
20
18
image: scatter_numpy.png
21
19
echo: false
22
20
---
23
21
24
-
fffffffff
25
-
26
22
{{< badges
27
23
printMessage="true"
28
24
>}}
@@ -38,8 +34,7 @@ fffffffff
38
34
Ce chapitre constitue une introduction à _Numpy_ pour
39
35
s'assurer que les bases du calcul vectoriel avec `Python`
40
36
soient maîtrisées. La première partie du chapitre
41
-
présente des petits exercices pour pratiquer
42
-
quelques fonctions basiques de `Numpy`. La fin du chapitre présente
37
+
présente des petits exercices pour pratiquer quelques fonctions basiques de `Numpy`. La fin du chapitre présente
43
38
des exercices pratiques d'utilisation de `Numpy` plus approfondis.
44
39
45
40
Il est recommandé de régulièrement se référer à
@@ -79,36 +74,34 @@ We will also set the seed of the random number generator to obtain reproducible
79
74
80
75
```{python}
81
76
#| echo: true
82
-
np.random.seed(12345)
77
+
import numpy as np
78
+
rng = np.random.default_rng(seed=12345)
83
79
```
84
80
85
81
::: {.content-visible when-profile="fr"}
86
82
87
-
::: {.callout-note}
88
-
89
-
Les auteurs de `numpy`[préconisent désormais](https://numpy.org/doc/stable/reference/random/index.html)
90
-
de privilégier l'utilisation de générateurs via la fonction `default_rng()` plutôt que la simple utilisation de `numpy.random`.
83
+
::: {.callout-caution}
91
84
92
-
Afin d'être en phase avec les codes qu'on peut trouver partout sur internet, nous conservons encore `np.random.seed` mais cela peut être amené à évoluer.
85
+
Historiquement, la génération de nombres aléatoires se faisait pas le biais du package `numpy.random`. Néanmoins, les auteurs de `Numpy`[recommandent maintenant](https://numpy.org/doc/stable/reference/random/index.html) d'utiliser plutôt des générateurs pour cela. Les exemples de ce tutoriel adoptent donc cette pratique.
93
86
94
87
:::
95
88
96
89
:::
97
90
98
91
:::: {.content-visible when-profile="en"}
99
92
100
-
::: {.callout-note}
93
+
::: {.callout-caution}
101
94
102
-
The authors of `numpy`[now recommend](https://numpy.org/doc/stable/reference/random/index.html) using generators via the `default_rng()` function rather than simply using `numpy.random`.
103
-
104
-
To stay consistent with the codes found everywhere on the internet, we still use `np.random.seed`, but this may change in the future.
95
+
Historically, random numbers were generated using the `numpy.random` package. However, the authors of `Numpy`[now recommend](https://numpy.org/doc/stable/reference/random/index.html) using generators instead. The examples in this tutorial adopt this practice.
105
96
106
97
:::
107
98
108
99
::::
109
100
110
101
::: {.content-visible when-profile="fr"}
111
102
103
+
104
+
112
105
# Le concept d'_array_
113
106
114
107
Dans le monde de la science des données, comme cela sera évoqué
Il existe aussi des méthodes pratiques pour créer des array:
229
222
230
-
* séquences logiques : `np.arange` (suite) ou `np.linspace` (interpolation linéaire entre deux bornes)
231
-
* séquences ordonnées : _array_ rempli de zéros, de 1 ou d'un nombre désiré : `np.zeros`, `np.ones` ou `np.full`
232
-
* séquences aléatoires : fonctions de génération de nombres aléatoires : `np.rand.uniform`, `np.rand.normal`, etc.
233
-
* tableau sous forme de matrice identité : `np.eye`
223
+
* séquences logiques : `np.arange` (suite) ou `np.linspace` (interpolation linéaire entre deux bornes) ;
224
+
* séquences ordonnées : _array_ rempli de zéros, de 1 ou d'un nombre désiré : `np.zeros`, `np.ones` ou `np.full` ;
225
+
* séquences aléatoires : fonctions de génération de nombres aléatoires : `rng.uniform`, `rng.normal`, etc. où `rng` est un générateur de nombre aléatoires ;
226
+
* tableau sous forme de matrice identité : `np.eye`.
234
227
235
228
Ceci donne ainsi, pour les séquences logiques:
236
229
@@ -239,10 +232,10 @@ Ceci donne ainsi, pour les séquences logiques:
239
232
::: {.content-visible when-profile="en"}
240
233
There are also practical methods for creating arrays:
241
234
242
-
* Logical sequences: `np.arange` (sequence) or `np.linspace` (linear interpolation between two bounds)
243
-
* Ordered sequences: array filled with zeros, ones, or a desired number: `np.zeros`, `np.ones`, or `np.full`
244
-
* Random sequences: random number generation functions: `np.rand.uniform`, `np.rand.normal`, etc.
245
-
* Matrix in the form of an identity matrix: `np.eye`
235
+
* Logical sequences: `np.arange` (sequence) or `np.linspace` (linear interpolation between two bounds);
236
+
* Ordered sequences: array filled with zeros, ones, or a desired number: `np.zeros`, `np.ones`, or `np.full`;
237
+
* Random sequences: random number generation functions: `rng.uniform`, `rng.normal`, etc. where `rng` is a random number generator;
238
+
* Matrix in the form of an identity matrix: `np.eye`.
246
239
247
240
This gives, for logical sequences:
248
241
:::
@@ -432,6 +425,51 @@ The syntax for selecting particular indices from a list also works with arrays.
432
425
{{< include "01_numpy_exercises/_exo2_solution.qmd" >}}
433
426
:::
434
427
428
+
::: {.content-visible when-profile="fr"}
429
+
430
+
La logique se généralise pour les _array_ multidimensionnels. L'indexation se fait alors à plusieurs niveaux. Prenons par exemple un array à 2 dimensions (une matrice en quelques sortes):
431
+
432
+
```{python}
433
+
x = np.array([[1, 2, 3], [4, 5, 6]], np.int32)
434
+
```
435
+
436
+
Si on veut sélectionner la 2e ligne, 3e colonne (l'élément de valeur 6), on fait
437
+
438
+
```{python}
439
+
x[1, 2]
440
+
```
441
+
442
+
Maintenant, pour sélectionner une colonne complète (par exemple la 2e), on peut utiliser le 2e index pour spécifier celle-ci (index 1 en Python puisque l'indexation part de 0) puis `:` sur la première dimension (version raccourcie de `0:N`) pour ne pas discriminer selon cette dimension:
443
+
444
+
```{python}
445
+
x[:,1]
446
+
```
447
+
448
+
Le principe se généralise, mais se complexifie, pour des _array_ imbriqués. Heureusement, ce sont des objets qu'on manipule assez rarement directement, la plupart de nos données numériques étant des tableaux plats (une valeur - l'observation - est le croisement d'une ligne - l'individu - et d'une colonne - la variable).
449
+
450
+
:::
451
+
::: {.content-visible when-profile="en"}
452
+
The same logic applies to multidimensional _arrays_. Indexing then takes place at several levels. Take, for example, a 2-dimensional array (a matrix of sorts):
453
+
454
+
``{python}
455
+
x = np.array([[1, 2, 3], [4, 5, 6]], np.int32)
456
+
````
457
+
458
+
If we want to select the 2nd row, 3rd column (the element with value 6), we do
459
+
460
+
x[1, 2]
461
+
````{python}
462
+
463
+
Now, to select a complete column (e.g. the 2nd), we can use the 2nd index to specify it (index 1 in Python since indexing starts from 0) and then `:` on the first dimension (shortened version of `0:N`) to avoid discriminating according to this dimension:
464
+
465
+
``{python}
466
+
x[:,1]
467
+
```
468
+
469
+
The principle is generalized, but becomes more complex, for nested _arrays_. Fortunately, these are objects we rarely manipulate directly, as most of our numerical data are flat arrays (a value - the observation - is the intersection of a row - the individual - and a column - the variable).
470
+
:::
471
+
472
+
435
473
::: {.content-visible when-profile="fr"}
436
474
437
475
## Sur la performance
@@ -543,7 +581,8 @@ Let's create `x` a multidimensional array and `y` a one-dimensional array with a
543
581
544
582
```{python}
545
583
#| echo: true
546
-
x = np.random.normal(0, size=(3, 4))
584
+
# Assuming rng has been created beforehand
585
+
x = rng.normal(0, size=(3, 4))
547
586
y = np.array([np.nan, 0, 1])
548
587
```
549
588
@@ -605,7 +644,7 @@ To combine arrays, you can use, depending on the case, the functions `np.concate
605
644
606
645
```{python}
607
646
#| echo: true
608
-
x = np.random.normal(size = 10)
647
+
x = rng.normal(size = 10)
609
648
```
610
649
611
650
::: {.content-visible when-profile="fr"}
@@ -650,7 +689,7 @@ For classical descriptive statistics, `Numpy` offers a number of already impleme
Copy file name to clipboardExpand all lines: content/manipulation/01_numpy_exercises/_exo6_en.qmd
+6-6Lines changed: 6 additions & 6 deletions
Original file line number
Diff line number
Diff line change
@@ -1,14 +1,14 @@
1
1
::: {.callout-tip}
2
-
## Exercise (a bit more challenging)
2
+
## Exercise 6 (a bit more challenging)
3
3
4
4
1. Create `X`, a two-dimensional array (i.e., a matrix) with 10 rows and 2 columns. The numbers in the array are random.
5
5
2. Import the `matplotlib.pyplot` module as `plt`. Use `plt.scatter` to plot the data as a scatter plot.
6
6
3. Construct a 10x10 matrix storing, at element $(i,j)$, the Euclidean distance between points $X[i,]$ and $X[j,]$. To do this, you will need to work with dimensions by creating nested arrays using `np.newaxis`:
7
-
+ First, use `X1 = X[:, np.newaxis, :]` to transform the matrix into a nested array. Check the dimensions.
8
-
+ Create `X2` of dimension `(1, 10, 2)` using the same logic.
9
-
+ Deduce, for each point, the distance with other points for each coordinate. Square this distance.
10
-
+ At this stage, you should have an array of dimension `(10, 10, 2)`. The reduction to a matrix is obtained by summing over the last axis. Check the help of `np.sum` on how to sum over the last axis.
11
-
+ Finally, apply the square root to obtain a proper Euclidean distance.
7
+
1. First, use `X1 = X[:, np.newaxis, :]` to transform the matrix into a nested array. Check the dimensions.
8
+
2. Create `X2` of dimension `(1, 10, 2)` using the same logic.
9
+
3. Deduce, for each point, the distance with other points for each coordinate. Square this distance.
10
+
4. At this stage, you should have an array of dimension `(10, 10, 2)`. The reduction to a matrix is obtained by summing over the last axis. Check the help of `np.sum` on how to sum over the last axis.
11
+
5. Finally, apply the square root to obtain a proper Euclidean distance.
12
12
4. Verify that the diagonal elements are zero (distance of a point to itself...).
13
13
5. Now, sort for each point the points with the most similar values. Use `np.argsort` to get the ranking of the closest points for each row.
14
14
6. We are interested in the k-nearest neighbors. For now, set k=2. Use `argpartition` to reorder each row so that the 2 closest neighbors of each point come first, followed by the rest of the row.
Copy file name to clipboardExpand all lines: content/manipulation/01_numpy_exercises/_exo6_fr.qmd
+6-6Lines changed: 6 additions & 6 deletions
Original file line number
Diff line number
Diff line change
@@ -1,17 +1,17 @@
1
1
::: {.callout-tip}
2
-
## Exercice (un peu plus corsé)
2
+
## Exercice 6 (un peu plus corsé)
3
3
4
4
5
5
1. Créer `X` un tableau à deux dimensions (i.e. une matrice) comportant 10 lignes
6
6
et 2 colonnes. Les nombres dans le tableau sont aléatoires.
7
7
2. Importer le module `matplotlib.pyplot` sous le nom `plt`. Utiliser
8
8
`plt.scatter` pour représenter les données sous forme de nuage de points.
9
9
3. Constuire une matrice 10x10 stockant, à l'élément $(i,j)$, la distance euclidienne entre les points $X[i,]$ et $X[j,]$. Pour cela, il va falloir jouer avec les dimensions en créant des tableaux emboîtés à partir par des appels à `np.newaxis` :
10
-
+ En premier lieu, utiliser `X1 = X[:, np.newaxis, :]` pour transformer la matrice en tableau emboîté. Vérifier les dimensions
11
-
+ Créer `X2` de dimension `(1, 10, 2)` à partir de la même logique
12
-
+ En déduire, pour chaque point, la distance avec les autres points pour chaque coordonnées. Elever celle-ci au carré
13
-
+A ce stade, vous devriez avoir un tableau de dimension `(10, 10, 2)`. La réduction à une matrice s'obtient en sommant sur le dernier axe. Regarder dans l'aide de `np.sum` comme effectuer une somme sur le dernier axe.
14
-
+ Enfin, appliquer la racine carrée pour obtenir une distance euclidienne en bonne et due forme.
10
+
1. En premier lieu, utiliser `X1 = X[:, np.newaxis, :]` pour transformer la matrice en tableau emboîté. Vérifier les dimensions
11
+
2. Créer `X2` de dimension `(1, 10, 2)` à partir de la même logique
12
+
3. En déduire, pour chaque point, la distance avec les autres points pour chaque coordonnées. Elever celle-ci au carré
13
+
4.A ce stade, vous devriez avoir un tableau de dimension `(10, 10, 2)`. La réduction à une matrice s'obtient en sommant sur le dernier axe. Regarder dans l'aide de `np.sum` comme effectuer une somme sur le dernier axe.
14
+
5. Enfin, appliquer la racine carrée pour obtenir une distance euclidienne en bonne et due forme.
15
15
4. Vérifier que les termes diagonaux sont bien nuls (distance d'un point à lui-même...)
16
16
5. Il s'agit maintenant de classer, pour chaque point, les points dont les valeurs sont les plus similaires. Utiliser `np.argsort` pour obtenir, pour chaque ligne, le classement des points les plus proches
17
17
6. On va s'intéresser aux k-plus proches voisins. Pour le moment, fixons k=2. Utiliser `argpartition` pour réordonner chaque ligne de manière à avoir les 2 plus proches voisins de chaque point d'abord et le reste de la ligne ensuite
Copy file name to clipboardExpand all lines: content/manipulation/01_numpy_exercises/_exo7_fr.qmd
+2-4Lines changed: 2 additions & 4 deletions
Original file line number
Diff line number
Diff line change
@@ -3,11 +3,9 @@
3
3
4
4
`Google` est devenu célèbre grâce à son algorithme `PageRank`. Celui-ci permet, à partir
5
5
de liens entre sites _web_, de donner un score d'importance à un site _web_ qui va
6
-
être utilisé pour évaluer sa centralité dans un réseau.
7
-
L'objectif de cet exercice est d'utiliser `Numpy` pour mettre en oeuvre un tel
8
-
algorithme à partir d'une matrice d'adjacence qui relie les sites entre eux.
6
+
être utilisé pour évaluer sa centralité dans un réseau. L'objectif de cet exercice est d'utiliser `Numpy` pour mettre en oeuvre un tel algorithme à partir d'une matrice d'adjacence qui relie les sites entre eux.
9
7
10
-
1. Créer la matrice suivante avec `numpy`. L'appeler `M`:
8
+
1. Créer la matrice suivante avec `Numpy`. L'appeler `M`:
0 commit comments