Apprentissage Automatique et Réseaux Neuronaux - page 68
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
4.2 Construction et indexation de tableaux NumPy (L04 : Calcul scientifique en Python)
4.2 Construction et indexation de tableaux NumPy (L04 : Calcul scientifique en Python)
Dans la deuxième vidéo, j'aimerais discuter de la construction et de l'indexation de tableaux non-Python. Les routines de construction de tableaux sont des blocs de construction ou des fonctions utiles pour créer des tableaux. Ils sont utiles lorsque vous avez besoin d'un tableau d'espace réservé que vous pourrez ensuite remplir avec des valeurs spécifiques. Permettez-moi de démontrer ce que je veux dire.
Pour créer un tableau rempli du numéro un, nous pouvons utiliser la fonction ones. Par exemple, ones((3, 3)) générera un tableau 3x3 avec tous les éléments mis à un. Vous pouvez également spécifier différentes dimensions, telles que les uns ((3, 4)), ce qui créera une matrice 3x4 remplie de uns. La fonction ones accepte divers arguments, y compris le paramètre dtype, qui détermine le type de données du tableau (la valeur par défaut est float64 pour les machines 64 bits). Vous pouvez le définir sur int64 pour créer un tableau d'entiers. De plus, vous pouvez spécifier le paramètre order, qui contrôle la disposition du tableau en mémoire. La valeur par défaut est C, représentant le style ligne principale, mais vous pouvez choisir F pour la disposition de style Fortran. Cependant, pour cette classe, vous n'avez pas à vous soucier de ces détails, car ils sont plus pertinents pour combiner NumPy avec du code C ou Fortran.
De même, la fonction zéros peut être utilisée pour créer un tableau rempli de zéros. Vous pouvez l'utiliser de la même manière que ceux. N'oubliez pas que si vous souhaitez en savoir plus sur ces fonctions, vous pouvez utiliser la fonction d'aide ou utiliser un point d'interrogation (?) dans Jupyter Lab ou IPython.
Il y a aussi la fonction vide, qui crée un tableau vide sans initialiser ses valeurs. Dans la plupart des cas, vous n'aurez pas à vous soucier des détails de cette fonction, car elle crée simplement un tableau avec des valeurs arbitraires. La fonction d'identité crée une matrice d'identité, où les éléments diagonaux sont des uns et les autres sont des zéros. Il peut être utilisé pour créer une matrice diagonale avec des valeurs spécifiques.
Passant à l'indexation, l'indexation de base dans les tableaux NumPy est similaire à l'indexation dans les listes Python. Vous pouvez accéder aux éléments à l'aide de crochets. Par exemple, array[0] renvoie le premier élément, array[1] renvoie le deuxième élément, etc. Le découpage est également possible, tout comme avec les listes Python. Par exemple, array[1:4] renverra une tranche du tableau de l'index 1 à 3 (hors index 4).
Lorsque vous traitez des tableaux à deux dimensions, vous pouvez utiliser une notation par virgule pour indexer les deux dimensions. Le premier index spécifie la ligne, tandis que le second index spécifie la colonne. Par exemple, array[0, 0] renvoie l'élément de la première ligne et de la première colonne, array[1, 2] renvoie l'élément de la deuxième ligne et de la troisième colonne, etc.
L'indexation négative peut être utilisée pour accéder aux éléments à partir de la fin d'un tableau. Par exemple, array[-1, -1] renverra le dernier élément du tableau. De même, array[-1, -2] renverra l'avant-dernier élément. Cela peut être utile lorsque vous travaillez avec de grands tableaux, car vous n'avez pas à suivre la longueur du tableau.
Pour récupérer une ligne ou une colonne entière, vous pouvez omettre l'un des indices. Par exemple, array[0, :] renvoie l'intégralité de la première ligne et array[:, 1] renvoie l'intégralité de la deuxième colonne. Cela équivaut à spécifier la plage d'indices (par exemple, array[0, 0:3] pour la première ligne). Le découpage fonctionne dans les deux dimensions, vous permettant de sélectionner des parties spécifiques du tableau. Par exemple, array[1:3, 2:4] renvoie un sous-tableau composé des lignes 1 et 2 (à l'exclusion de la ligne 3) et des colonnes 2 et 3 (à l'exclusion de la colonne 4).
L'indexation booléenne est une autre fonctionnalité puissante de NumPy. Vous pouvez utiliser un tableau booléen pour indexer un tableau, en sélectionnant uniquement les éléments qui correspondent aux valeurs True dans le tableau booléen. Par exemple, supposons que nous ayons un tableau appelé tableau avec la forme (3, 3) :
Nous pouvons créer un tableau booléen basé sur une condition, telle que tableau > 5, qui renverra le tableau booléen suivant :En plus de l'indexation de base, NumPy fournit des techniques d'indexation avancées, telles que l'indexation de tableaux d'entiers et l'utilisation de tableaux comme indices. Ces techniques permettent des opérations d'indexation plus complexes et non contiguës sur les tableaux. Cependant, ce sont des sujets plus avancés et peuvent ne pas être nécessaires pour la manipulation de tableau de base.
4.3 NumPy Array Math et fonctions universelles (L04 : Calcul scientifique en Python)
4.3 NumPy Array Math et fonctions universelles (L04 : Calcul scientifique en Python)
Après avoir investi un temps considérable dans la création d'une course et l'indexation de valeurs individuelles dans un tableau, passons à un sujet plus intrigant : tableau non payant, mathématiques et fonctions universelles.
Les fonctions universelles, souvent abrégées en Ufunk ou Frank, sont un concept puissant en programmation. Une fonction universelle (Ufunk) est une forme abrégée d'une fonction universelle, qui permet un travail plus efficace et pratique avec les tableaux Numpy. Il introduit un concept appelé vectorisation.
La vectorisation consiste à effectuer une opération mathématique ou arithmétique sur une séquence d'objets, comme un tableau. Au lieu d'exécuter l'opération individuellement sur chaque élément du tableau, la vectorisation nous permet d'effectuer l'opération en parallèle, en profitant du manque de dépendances entre les éléments.
Par exemple, considérons la tâche d'ajouter un nombre à chaque élément d'un tableau. Avec une boucle for Python, nous parcourrions chaque élément et appellerions une fonction d'addition. Cependant, avec la vectorisation, nous pouvons effectuer l'addition sur l'ensemble du tableau simultanément, sans avoir besoin d'une boucle. Cela améliore considérablement l'efficacité.
Dans Numpy, la vectorisation est réalisée à l'aide de fonctions universelles (Ufunk). Il y a plus de 60 Ufunk implémentés dans Numpy, chacun servant un objectif spécifique. Il est recommandé de se référer à la documentation officielle pour une liste complète des Ufunk disponibles.
Pour illustrer le concept, concentrons-nous sur l'addition élément par élément, une opération courante. Supposons que nous ayons un tableau à deux dimensions implémenté sous la forme d'une liste de listes en Python. Si nous voulons ajouter 1 à chaque élément, nous utiliserons généralement des boucles imbriquées ou des compréhensions de liste. Cependant, ces approches peuvent être inefficaces, en particulier pour les grands réseaux.
Dans Numpy, nous pouvons utiliser le Ufunk "np.add" pour ajouter le nombre 1 à l'ensemble du tableau de manière vectorisée. Cela élimine le besoin de boucles explicites et améliore considérablement les performances.
Il convient de mentionner que Numpy exploite la surcharge des opérateurs, ce qui permet une utilisation intuitive d'Ufunk. Par exemple, l'utilisation de l'opérateur "+" entre un tableau et un nombre appelle automatiquement l'Ufunk "np.add".
Un autre Ufunk utile est "np.square", qui met au carré chaque élément d'un tableau. Les fonctions Ufunk peuvent être unaires (fonctionnant sur une seule valeur) ou binaires (prenant deux arguments). La documentation officielle de Numpy fournit plus de détails sur l'Ufunk disponible.
Passons à un cas plus intéressant, explorons l'utilisation d'Ufunk en conjonction avec la méthode "reduce". L'opération "réduire" applique une opération le long d'un axe spécifié, réduisant plusieurs valeurs en une seule valeur. Par exemple, nous pouvons calculer les sommes des colonnes en utilisant "np.add" avec la méthode "reduce".
Dans ce scénario, nous survolons l'axe spécifié (axe 0 dans ce cas) et combinons les éléments à l'aide de l'opération spécifiée. L'opération "réduire" est généralement associée à des concepts tels que "réduire la carte" et Hadoop, où les calculs sont répartis sur plusieurs nœuds, puis combinés pour produire le résultat final.
Bien que cela puisse sembler écrasant, la compréhension de ces concepts permet une programmation plus efficace et efficiente avec Numpy. En tirant parti d'Ufunk et de la vectorisation, nous pouvons effectuer facilement des opérations complexes sur des tableaux et optimiser notre code pour de meilleures performances.
N'oubliez pas de vous référer à la documentation officielle de Numpy pour une liste complète des Ufunk disponibles, ainsi que des exemples et des directives d'utilisation. Explorer les possibilités d'Ufunk élargira votre boîte à outils et vous aidera à aborder diverses tâches de calcul dans de futurs projets.
Ainsi, dans NumPy, nous avons une fonction appelée reduce, qui nous permet d'effectuer des opérations de réduction le long d'un axe spécifié d'un tableau. L'opération de réduction combine plusieurs valeurs en une seule valeur. Par défaut, la réduction est appliquée le long du premier axe (axe 0) du tableau.
Prenons un exemple pour mieux comprendre ce concept. Considérez le tableau suivant :
Pour ce faire, nous pouvons utiliser la fonction np.add, qui effectue une addition élément par élément. Nous passons np.add comme argument de la fonction à réduire, indiquant que nous voulons ajouter les valeurs le long de l'axe spécifié.
Voici à quoi ressemble le code :
La sortie sera :Cette approche est plus efficace que d'itérer manuellement sur les colonnes et d'ajouter les valeurs une par une. L'opération vectorisée fournie par NumPy nous permet d'effectuer le calcul en parallèle, en profitant d'algorithmes sous-jacents optimisés.
Gardez à l'esprit que reduce peut être utilisé avec diverses autres fonctions en plus de np.add, selon l'opération que vous souhaitez effectuer. Le concept de réduction est puissant et peut être appliqué à de nombreux scénarios différents.
4.4 Diffusion NumPy (L04 : Calcul scientifique en Python)
4.4 Diffusion NumPy (L04 : Calcul scientifique en Python)
NumPy offre une fonctionnalité fascinante connue sous le nom de "diffusion", qui introduit des dimensions implicites et nous permet d'effectuer des opérations qui seraient généralement impossibles dans les limites de l'algèbre linéaire stricte. Ce concept de diffusion permet plus de flexibilité et de commodité lorsque vous travaillez avec des baies.
En tirant parti de la diffusion, NumPy peut aligner automatiquement des tableaux avec différentes formes, en les élargissant essentiellement pour correspondre et effectuer des opérations par élément. Cette création de dimension implicite nous permet d'exécuter de manière transparente des opérations sur des tableaux de différentes tailles, ce qui donne un code concis et efficace.
Dans le contexte de l'algèbre linéaire, où le strict respect des règles mathématiques régit les opérations, la diffusion fournit un outil puissant pour simplifier les calculs complexes. Il nous permet d'effectuer des calculs sur des tableaux aux formes disparates, éliminant ainsi le besoin de remodelage manuel ou de bouclage à travers les éléments.
Grâce à la diffusion, nous pouvons appliquer sans effort des opérations sur des tableaux avec des dimensions implicites, obtenant des résultats qui pourraient autrement nécessiter une manipulation manuelle importante. Cette capacité élargit la portée de ce que nous pouvons accomplir avec NumPy, ce qui en fait une bibliothèque polyvalente et indispensable pour le calcul scientifique et l'analyse de données.
4.5 Indexation avancée NumPy -- Vues et copies de la mémoire (L04 : Calcul scientifique en Python)
4.5 Indexation avancée NumPy -- Vues et copies de la mémoire (L04 : Calcul scientifique en Python)
Dans cette cinquième vidéo, nous approfondirons à nouveau le sujet de l'indexation. Cependant, contrairement à la vidéo initiale où nous avons couvert l'indexation de base, nous allons maintenant explorer l'indexation avancée. Ce segment présentera des concepts tels que les vues de mémoire et la création de copies de mémoire, qui sont des pratiques cruciales pour éviter les erreurs involontaires, telles que l'écrasement par erreur des valeurs de tableau. Comprendre cela est essentiel car cela nous aide à prévenir les bogues et les comportements inattendus dans NumPy.
Maintenant, commençons. Dans la section précédente, nous avons discuté d'un aspect des tableaux NumPy appelés "vues". Les vues sont créées lorsque nous utilisons une indexation régulière ou des opérations de découpage de base. Ces vues agissent comme des dimensions implicites, nous permettant d'effectuer des opérations qui ne sont pas réalisables dans le cadre mathématique strict de l'algèbre linéaire. Cependant, travailler avec des vues peut être risqué car nous pourrions accidentellement modifier le tableau d'origine sans nous en rendre compte.
Pour illustrer cela, prenons un exemple simple. Supposons que nous ayons un tableau à deux dimensions avec deux lignes et trois colonnes. Pour plus de commodité, j'affecterai la première ligne à une variable distincte appelée "première_ligne". Maintenant, voici le point crucial : l'affectation de la première ligne à une variable crée une vue, pas un nouvel objet. Cela signifie que cette variable pointe simplement vers l'emplacement du tableau d'origine en mémoire. Par conséquent, si nous modifions les valeurs de cette variable, nous modifierons également les valeurs correspondantes dans le tableau d'origine.
Pour illustrer cela, incrémentons chaque élément de la variable "first_row" de 99. L'exécution de cette opération modifiera non seulement les valeurs de la variable, mais écrasera également les valeurs de la première ligne du tableau d'origine. Ce comportement indique que nous travaillons avec une vue plutôt qu'avec un objet indépendant. Ne pas en être conscient peut être dangereux, car il est facile d'écraser involontairement des valeurs dans le tableau d'origine tout en travaillant avec une vue.
D'un autre côté, les vues peuvent être incroyablement utiles pour l'efficacité de la mémoire car elles nous permettent d'éviter les copies de tableau inutiles. Cependant, il existe des situations où nous pouvons vouloir créer explicitement une copie d'un tableau. Pour cela, nous pouvons utiliser la fonction "copier", qui génère un nouveau tableau avec les mêmes valeurs que l'original. Dans l'exemple fourni, je crée une copie de la deuxième ligne du tableau à l'aide de la fonction "copy". En faisant cela, toute modification apportée à la variable "first_row" n'affectera pas le tableau d'origine.
Il est important de noter que bien que le découpage et l'indexation basée sur des nombres entiers créent des vues mémoire, il existe un autre type d'indexation appelé "indexation fantaisie" qui produit des copies du tableau. L'indexation sophistiquée consiste à utiliser plusieurs indices entiers pour sélectionner des éléments spécifiques dans un tableau. Cette fonctionnalité est appelée "fantaisie" car elle n'est pas prise en charge dans les listes Python classiques. Cependant, NumPy nous permet d'effectuer ce type d'indexation, qui peut être assez puissant.
Par exemple, dans une liste Python normale, nous ne pouvons pas récupérer simultanément les premier et troisième éléments. Pourtant, dans NumPy, nous pouvons y parvenir en utilisant une indexation sophistiquée. De même, nous pouvons utiliser une indexation sophistiquée pour sélectionner des colonnes spécifiques dans un tableau à deux dimensions. Il convient de noter que l'indexation sophistiquée aboutit toujours à une copie du tableau, pas à une vue.
La distinction entre les vues et les copies est liée aux considérations d'efficacité dans NumPy. Le découpage nous permet de mettre en cache certaines valeurs en mémoire, optimisant ainsi les performances. Cependant, la mise en œuvre de ce mécanisme de mise en cache avec une indexation sophistiquée n'est pas simple car nous ne pouvons pas extraire un bloc de mémoire contigu. Au lieu de cela, nous sélectionnons des valeurs individuelles, ce qui conduit à la création d'un nouveau tableau. Ce comportement explique pourquoi l'indexation sophistiquée produit des copies plutôt que des vues.
Un autre aspect intéressant de l'indexation sophistiquée est qu'elle nous permet de réorganiser l'ordre des colonnes dans un tableau. En spécifiant les index de colonne souhaités à l'aide d'une indexation sophistiquée, nous pouvons mélanger les colonnes selon les besoins.
Les masques booléens dans NumPy sont un moyen efficace et puissant de filtrer les tableaux en fonction de certaines conditions. Un masque booléen est simplement un tableau NumPy de valeurs booléennes (Vrai ou Faux) qui a la même forme que le tableau d'origine. En appliquant le masque booléen au tableau d'origine, nous pouvons sélectionner les éléments qui satisfont la condition donnée et ignorer le reste.
Pour créer un masque booléen, nous définissons d'abord une condition qui renvoie une valeur booléenne pour chaque élément du tableau. Par exemple, disons que nous avons un tableau appelé arr :
Pour appliquer le masque booléen et récupérer les éléments qui satisfont la condition, nous pouvons simplement utiliser le masque comme index pour le tableau :
Les masques booléens peuvent être combinés à l'aide d'opérateurs logiques tels que & (et), | (ou), et ~ (pas) pour créer des conditions plus complexes. Par exemple:
Les masques booléens sont particulièrement utiles lorsque vous travaillez avec de grands ensembles de données ou effectuez un filtrage et une analyse des données. Ils permettent des opérations efficaces et concises sur les tableaux sans avoir besoin de boucles explicites ou de vérifications de condition.
Outre le filtrage des tableaux, les masques booléens peuvent également être utilisés pour l'affectation des éléments. En attribuant de nouvelles valeurs aux éléments sélectionnés via le masque booléen, nous pouvons modifier des parties spécifiques du tableau en fonction d'une condition.
Dans l'ensemble, les masques booléens offrent un moyen flexible et efficace de manipuler et de filtrer les tableaux NumPy en fonction de conditions spécifiées, ce qui en fait un outil précieux dans le traitement et l'analyse des données.
4.5 Indexation avancée NumPy -- Vues et copies de la mémoire (L04 : Calcul scientifique en Python)
4.5 Indexation avancée NumPy -- Vues et copies de la mémoire (L04 : Calcul scientifique en Python)
Dans cette cinquième vidéo, nous approfondirons à nouveau le sujet de l'indexation. Cependant, contrairement à la vidéo initiale où nous avons couvert l'indexation de base, nous allons maintenant explorer l'indexation avancée. Ce segment présentera des concepts tels que les vues de mémoire et la création de copies de mémoire, qui sont des pratiques cruciales pour éviter les erreurs involontaires, telles que l'écrasement par erreur des valeurs de tableau. Comprendre cela est essentiel car cela nous aide à prévenir les bogues et les comportements inattendus dans NumPy.
Maintenant, commençons. Dans la section précédente, nous avons discuté d'un aspect des tableaux NumPy appelés "vues". Les vues sont créées lorsque nous utilisons une indexation régulière ou des opérations de découpage de base. Ces vues agissent comme des dimensions implicites, nous permettant d'effectuer des opérations qui ne sont pas réalisables dans le cadre mathématique strict de l'algèbre linéaire. Cependant, travailler avec des vues peut être risqué car nous pourrions accidentellement modifier le tableau d'origine sans nous en rendre compte.
Pour illustrer cela, prenons un exemple simple. Supposons que nous ayons un tableau à deux dimensions avec deux lignes et trois colonnes. Pour plus de commodité, j'affecterai la première ligne à une variable distincte appelée "première_ligne". Maintenant, voici le point crucial : l'affectation de la première ligne à une variable crée une vue, pas un nouvel objet. Cela signifie que cette variable pointe simplement vers l'emplacement du tableau d'origine en mémoire. Par conséquent, si nous modifions les valeurs de cette variable, nous modifierons également les valeurs correspondantes dans le tableau d'origine.
Pour illustrer cela, incrémentons chaque élément de la variable "first_row" de 99. L'exécution de cette opération modifiera non seulement les valeurs de la variable, mais écrasera également les valeurs de la première ligne du tableau d'origine. Ce comportement indique que nous travaillons avec une vue plutôt qu'avec un objet indépendant. Ne pas en être conscient peut être dangereux, car il est facile d'écraser involontairement des valeurs dans le tableau d'origine tout en travaillant avec une vue.
D'un autre côté, les vues peuvent être incroyablement utiles pour l'efficacité de la mémoire car elles nous permettent d'éviter les copies de tableau inutiles. Cependant, il existe des situations où nous pouvons vouloir créer explicitement une copie d'un tableau. Pour cela, nous pouvons utiliser la fonction "copier", qui génère un nouveau tableau avec les mêmes valeurs que l'original. Dans l'exemple fourni, je crée une copie de la deuxième ligne du tableau à l'aide de la fonction "copy". En faisant cela, toute modification apportée à la variable "first_row" n'affectera pas le tableau d'origine.
Il est important de noter que bien que le découpage et l'indexation basée sur des nombres entiers créent des vues mémoire, il existe un autre type d'indexation appelé "indexation fantaisie" qui produit des copies du tableau. L'indexation sophistiquée consiste à utiliser plusieurs indices entiers pour sélectionner des éléments spécifiques dans un tableau. Cette fonctionnalité est appelée "fantaisie" car elle n'est pas prise en charge dans les listes Python classiques. Cependant, NumPy nous permet d'effectuer ce type d'indexation, qui peut être assez puissant.
Par exemple, dans une liste Python normale, nous ne pouvons pas récupérer simultanément les premier et troisième éléments. Pourtant, dans NumPy, nous pouvons y parvenir en utilisant une indexation sophistiquée. De même, nous pouvons utiliser une indexation sophistiquée pour sélectionner des colonnes spécifiques dans un tableau à deux dimensions. Il convient de noter que l'indexation sophistiquée aboutit toujours à une copie du tableau, pas à une vue.
La distinction entre les vues et les copies est liée aux considérations d'efficacité dans NumPy. Le découpage nous permet de mettre en cache certaines valeurs en mémoire, optimisant ainsi les performances. Cependant, la mise en œuvre de ce mécanisme de mise en cache avec une indexation sophistiquée n'est pas simple car nous ne pouvons pas extraire un bloc de mémoire contigu. Au lieu de cela, nous sélectionnons des valeurs individuelles, ce qui conduit à la création d'un nouveau tableau. Ce comportement explique pourquoi l'indexation sophistiquée produit des copies plutôt que des vues.
Un autre aspect intéressant de l'indexation sophistiquée est qu'elle nous permet de réorganiser l'ordre des colonnes dans un tableau. En spécifiant les index de colonne souhaités à l'aide d'une indexation sophistiquée, nous pouvons mélanger les colonnes selon les besoins.
Les masques booléens dans NumPy sont un moyen efficace et puissant de filtrer les tableaux en fonction de certaines conditions. Un masque booléen est simplement un tableau NumPy de valeurs booléennes (Vrai ou Faux) qui a la même forme que le tableau d'origine. En appliquant le masque booléen au tableau d'origine, nous pouvons sélectionner les éléments qui satisfont la condition donnée et ignorer le reste.
Pour créer un masque booléen, nous définissons d'abord une condition qui renvoie une valeur booléenne pour chaque élément du tableau. Par exemple, disons que nous avons un tableau appelé arr :
Pour appliquer le masque booléen et récupérer les éléments qui satisfont la condition, nous pouvons simplement utiliser le masque comme index pour le tableau :
Les masques booléens peuvent être combinés à l'aide d'opérateurs logiques tels que & (et), | (ou), et ~ (pas) pour créer des conditions plus complexes. Par exemple:
Les masques booléens sont particulièrement utiles lorsque vous travaillez avec de grands ensembles de données ou effectuez un filtrage et une analyse des données. Ils permettent des opérations efficaces et concises sur les tableaux sans avoir besoin de boucles explicites ou de vérifications de condition.
Outre le filtrage des tableaux, les masques booléens peuvent également être utilisés pour l'affectation des éléments. En attribuant de nouvelles valeurs aux éléments sélectionnés via le masque booléen, nous pouvons modifier des parties spécifiques du tableau en fonction d'une condition.
Dans l'ensemble, les masques booléens offrent un moyen flexible et efficace de manipuler et de filtrer les tableaux NumPy en fonction de conditions spécifiées, ce qui en fait un outil précieux dans le traitement et l'analyse des données.
4.6 Générateurs de nombres aléatoires NumPy (L04 : Calcul scientifique en Python)
4.6 Générateurs de nombres aléatoires NumPy (L04 : Calcul scientifique en Python)
Dans cette vidéo, nous donnerons un bref aperçu des générateurs de nombres aléatoires dans NumPy. Bien que nous ne couvrirons pas toutes les différentes méthodes de génération de nombres aléatoires dans NumPy, nous nous concentrerons sur la compréhension des générateurs de nombres aléatoires et leur utilité pratique.
Commençons par un exemple simple. Nous commencerons par importer NumPy, qui est la bibliothèque que nous utiliserons pour la génération de nombres aléatoires. NumPy a un module aléatoire qui contient diverses fonctions pour dessiner des nombres aléatoires. Bien que la documentation à laquelle nous allons faire référence soit un peu datée, elle fournit une liste utile des différentes fonctions et de leurs descriptions.
Une fonction couramment utilisée est random.rand, qui génère des échantillons aléatoires à partir d'une distribution uniforme. En spécifiant la forme du tableau souhaité (par exemple, 2x3), cette fonction produira un tableau à deux dimensions rempli de nombres aléatoires à partir d'une distribution uniforme.
NumPy propose également d'autres fonctions, telles que random.random, qui génère des flottants aléatoires dans l'intervalle semi-ouvert [0, 1). Vous pouvez également tirer des échantillons aléatoires de différentes distributions, comme la distribution normale standard, à l'aide de la fonction random.randn.
Parfois, nous pouvons vouloir nous assurer que notre code produit les mêmes résultats aléatoires à chaque fois qu'il est exécuté. Ceci est utile pour la reproductibilité, en particulier lors du partage de code ou de la comparaison de différentes méthodes. Pour ce faire, nous pouvons définir une graine aléatoire au début de notre code ou de notre cahier. La graine est un nombre arbitraire qui garantit que la même séquence de nombres aléatoires est générée à chaque fois.
En définissant une graine aléatoire, les nombres aléatoires générés resteront constants pendant plusieurs exécutions du code. Cependant, il est important de noter que si nous tirons un autre échantillon aléatoire, les résultats seront différents car il s'agit toujours d'un processus aléatoire.
Avoir des résultats cohérents peut être particulièrement utile dans les applications d'apprentissage automatique, telles que le brassage des données ou le test des implémentations. Par exemple, lors du fractionnement d'un ensemble de données, la définition d'une graine aléatoire garantit que le fractionnement est le même à chaque fois. Cela permet une comparaison et une évaluation précises des différentes méthodes.
Pour gérer le caractère aléatoire de manière plus granulaire, nous pouvons utiliser un objet d'état aléatoire dans NumPy. L'objet d'état aléatoire possède son propre générateur de nombres aléatoires, permettant un contrôle précis de l'endroit où le caractère aléatoire est appliqué. En créant plusieurs objets d'état aléatoires, nous pouvons avoir différentes sources d'aléatoire dans notre code. Ceci est particulièrement avantageux lorsque nous voulons que certaines parties du code produisent des résultats cohérents tandis que d'autres parties génèrent des nombres aléatoires variables.
Alors que l'ancienne classe random_state est encore largement utilisée, la communauté NumPy recommande désormais d'utiliser le nouveau générateur aléatoire. Ce nouveau générateur utilise une méthode différente pour générer des nombres aléatoires, mais pour la plupart des applications simples, le choix entre les deux ne fera pas de différence notable. Ce qui importe le plus, c'est de définir une graine aléatoire pour la reproductibilité.
Il est important de se rappeler que les générateurs de nombres aléatoires dans le code ne sont pas vraiment aléatoires mais pseudo-aléatoires. Ils utilisent des algorithmes pour produire des séquences de nombres qui imitent le hasard. Dans notre contexte, l'accent est mis sur la cohérence et la reproductibilité plutôt que sur l'algorithme spécifique utilisé pour la génération de nombres aléatoires.
En conclusion, lorsque vous travaillez avec des générateurs de nombres aléatoires dans NumPy, le choix du générateur lui-même n'est pas critique. Ce qui est essentiel, c'est de définir une graine aléatoire pour garantir des résultats cohérents et reproductibles. Cela devient particulièrement utile lors du partage de code, de la soumission de devoirs ou de la comparaison de différentes méthodes.
4.7 Remodeler les tableaux NumPy (L04 : calcul scientifique en Python)
4.7 Remodeler les tableaux NumPy (L04 : calcul scientifique en Python)
Enfin, nous approchons de la conclusion de la série NumPy. Avec seulement trois vidéos restantes, nous avons atteint un sujet important : remodeler les tableaux NumPy. Le remodelage des tableaux est crucial lorsque nous devons transformer nos données dans la forme souhaitée, comme convertir une matrice en vecteur ou vice versa. J'ai brièvement mentionné ce concept dans la conférence d'introduction, où j'ai discuté de MNIST. Pour illustrer ce processus, considérons un exemple simplifié.
Imaginez que nous ayons un tableau de dimensions 28 par 28, représentant une image. Normalement, chaque élément du tableau correspondrait à une valeur de pixel. Cependant, par souci de simplicité, supposons que chaque élément n'est qu'un seul chiffre. Nous avons donc un tableau 28 par 28 représentant une image numérique. Cependant, si nous voulons utiliser ce tableau comme vecteur de caractéristiques pour un classificateur, nous devons le remodeler en un seul vecteur long avec 784 éléments (28 * 28). Chaque exemple de formation sera une image, et chaque image aura 784 caractéristiques.
Le remodelage d'un tableau peut être effectué à l'aide de la fonction reshape de NumPy. Par exemple, nous pouvons remodeler un vecteur 1, 2, 3, 4, 5, 6 en une matrice 2 par 3 :
Lors du remodelage d'un tableau, une vue mémoire est créée plutôt qu'un nouveau tableau. Cette vue mémoire nous permet de manipuler le tableau remodelé sans dupliquer les données. Pour vérifier cela, nous pouvons utiliser la fonction np.may_share_memory, bien qu'elle ne fournisse pas toujours un résultat précis à 100 %.
L'utilisation de -1 comme dimension dans le remodelage est une fonctionnalité pratique dans NumPy. Il agit comme un espace réservé, permettant à la méthode de déterminer la dimension appropriée en fonction du nombre total d'éléments. Par exemple, si nous avons un vecteur avec six éléments et que nous le remodelons en utilisant -1, 2, le -1 sera remplacé par 3 car il n'y a qu'une seule façon d'organiser trois lignes avec deux colonnes pour obtenir six éléments. Ce concept d'espace réservé fonctionne avec un nombre arbitraire de dimensions.
De plus, nous pouvons utiliser la fonction reshape pour aplatir un tableau. En spécifiant une seule valeur comme dimension (par exemple, reshape(6)), nous pouvons transformer le tableau en un vecteur unidimensionnel. En pratique, l'utilisation de -1 est plus pratique car elle élimine le besoin de se souvenir de la taille. Par exemple, reshape(-1) obtient le même résultat que reshape(6) pour un tableau à six éléments.
Il existe plusieurs façons d'aplatir un tableau dans NumPy. La fonction reshape avec -1 crée une vue mémoire, tandis que la fonction flatten aplatit également un tableau mais crée une copie. Une autre fonction, ravel, est également utilisée pour aplatir les tableaux. Déterminer les différences entre ces fonctions serait un bon quiz d'auto-évaluation.
Enfin, nous pouvons concaténer des tableaux dans NumPy, en les combinant le long d'axes spécifiés. Lors de la concaténation de tableaux le long du premier axe, cela revient à ajouter des éléments dans des listes Python. Par exemple, si nous avons deux tableaux avec un axe, les concaténer le long de cet axe s'empilera l'un en dessous de l'autre.
Le remodelage des tableaux NumPy est essentiel pour manipuler les données dans la forme souhaitée. Comprendre les différentes méthodes, espaces réservés et techniques de concaténation nous permet de travailler efficacement avec des tableaux et d'optimiser notre code. Dans la vidéo suivante, je discuterai des opérateurs et des masques de comparaison NumPy, qui sont des outils puissants lorsqu'ils sont combinés avec le remodelage.
4.8 Opérateurs et masques de comparaison NumPy (L04 : Calcul scientifique en Python)
4.8 Opérateurs et masques de comparaison NumPy (L04 : Calcul scientifique en Python)
Dans NumPy, les opérateurs de comparaison et les masques de sélection offrent une grande flexibilité et peuvent être très agréables à utiliser. Dans une vidéo précédente, nous avons présenté les masques et les opérateurs de comparaison, mais explorons maintenant quelques astuces supplémentaires que vous pouvez utiliser lorsque vous travaillez avec eux.
Commençons par un exemple simple. Supposons que nous ayons un tableau NumPy [1, 2, 3, 4] pour plus de simplicité. Nous pouvons définir un masque pour sélectionner certaines valeurs du tableau. Ce masque sera un tableau booléen, ce qui signifie qu'il contiendra des valeurs True ou False. Nous pouvons créer le masque en spécifiant une condition, telle que la sélection de valeurs supérieures à deux. Le tableau de masque résultant aura la même forme que le tableau d'origine, avec des valeurs True indiquant les positions où la condition est vraie et des valeurs False indiquant les positions où la condition est fausse.
En Python, il existe une relation pratique entre les valeurs booléennes et les entiers : True équivaut à 1 et False équivaut à 0. Cette relation nous permet d'effectuer des opérations intéressantes. Par exemple, nous pouvons utiliser l'instruction if pour vérifier si une condition est vraie en écrivant simplement if condition:. On peut aussi utiliser l'opérateur not pour vérifier si une condition est fausse en écrivant if not condition:. Ces approches fournissent un code plus lisible par rapport à la comparaison explicite de la condition avec True ou False.
Une autre fonctionnalité utile est la possibilité de compter le nombre d'éléments dans un tableau qui correspondent à une certaine condition. En appliquant l'opérateur de somme à un masque, nous pouvons compter le nombre de valeurs True dans le masque. Par exemple, si nous avons un masque qui sélectionne des valeurs supérieures à deux, nous pouvons compter le nombre de ces valeurs en appelant sum(mask). De même, nous pouvons compter le nombre de valeurs False en soustrayant la somme du nombre total d'éléments du tableau.
Pour compter le nombre de valeurs négatives dans un tableau, nous pouvons utiliser la fonction d'inversion NumPy, qui inverse les valeurs booléennes dans le masque. En appliquant invert à un masque puis en appelant sum, nous pouvons compter le nombre de valeurs False (qui représentent désormais les valeurs négatives).
Binariser un tableau, c'est-à-dire le convertir en une représentation binaire, est une autre opération courante. Nous pouvons y parvenir en attribuant une valeur spécifique aux positions où une condition est vraie et une autre valeur aux positions où la condition est fausse. Cependant, taper toute l'opération peut être fastidieux. Heureusement, NumPy fournit la fonction where, qui simplifie ce processus. La fonction where prend une condition, et pour les positions où la condition est vraie, elle affecte la première valeur, et pour les positions où la condition est fausse, elle affecte la seconde valeur. En utilisant where, nous pouvons facilement binariser un tableau avec une seule ligne de code.
En plus des opérateurs de comparaison, NumPy propose des opérateurs logiques tels que et, ou, xor et non. Ces opérateurs peuvent être combinés avec des masques pour créer des conditions plus complexes. Par exemple, nous pouvons sélectionner des valeurs supérieures à trois ou inférieures à deux en utilisant l'opérateur ou . En combinant plusieurs conditions à l'aide d'opérateurs logiques, nous pouvons créer des masques de sélection complexes qui répondent à nos besoins.
Ces masques booléens, opérateurs logiques et opérateurs de comparaison dans NumPy sont extrêmement utiles lorsque vous travaillez avec des ensembles de données et implémentez des règles d'arbre de décision. Nous explorerons ces concepts plus en détail dans les prochaines vidéos. Dans la vidéo suivante, nous approfondirons les concepts de base de l'algèbre linéaire dans NumPy. Restez à l'écoute!
4.9 Les bases de l'algèbre linéaire NumPy (L04 : Calcul scientifique en Python)
4.9 Les bases de l'algèbre linéaire NumPy (L04 : Calcul scientifique en Python)
Dans cette vidéo, je voudrais approfondir certains concepts fondamentaux de l'algèbre linéaire, en particulier dans le contexte de NumPy. Bien que nous n'utilisions pas beaucoup l'algèbre linéaire dans ce cours, il est essentiel de comprendre les opérations de base telles que les produits scalaires vectoriels et la multiplication matricielle. Comme je l'ai mentionné plus tôt, l'utilisation de la notation d'algèbre linéaire nous permet d'écrire du code plus efficace et concis.
Commençons par considérer un tableau unidimensionnel comme un vecteur ligne. Alternativement, nous pouvons le définir comme un vecteur composé d'une seule ligne avec plusieurs éléments. D'autre part, un vecteur colonne peut être créé en remodelant le vecteur ligne pour avoir une colonne et plusieurs éléments. Essentiellement, il représente la représentation du vecteur colonne. Notamment, l'utilisation de crochets n'est pas nécessaire dans ce contexte.
Au lieu de remodeler explicitement le vecteur, nous pouvons obtenir le même résultat en ajoutant un nouvel axe à l'aide de la fonction newaxis de NumPy. En ajoutant deux nouveaux axes, nous pouvons même créer un tenseur 3D. Une autre approche consiste à utiliser le mot-clé None, qui a le même objectif que newaxis. Ces trois méthodes, à savoir remodelage, nouvel axe et Aucun, atteignent toutes l'objectif d'ajouter un axe supplémentaire si nécessaire.
En continuant, nous rencontrons la notation d'algèbre linéaire de base pour la multiplication matricielle. En algèbre linéaire, la multiplication matricielle équivaut au calcul de plusieurs produits scalaires. Par exemple, si nous avons les vecteurs [1, 2, 3] et [1, 2, 3], leur produit scalaire donne 14. De même, le produit scalaire de [4, 5, 6] et [1, 2, 3] donne 32. Dans NumPy, nous pouvons effectuer une multiplication matricielle à l'aide de la fonction matmul. Alternativement, l'opérateur @ peut être utilisé pour plus de commodité. Cependant, il est important de noter qu'en algèbre linéaire, nous ne pouvons pas multiplier directement les matrices et les vecteurs. Néanmoins, nous pouvons considérer un vecteur colonne comme une matrice, en particulier une matrice 3x1. Cette approche nous permet de multiplier une matrice par un vecteur, ce qui n'est pas possible en algèbre linéaire stricte. Ainsi, NumPy offre plus de flexibilité par rapport à l'algèbre linéaire traditionnelle.
De plus, NumPy fournit la fonction point pour la multiplication matricielle, qui est largement recommandée en raison de son implémentation efficace sur la plupart des machines. Cette fonction nous permet d'écrire du code plus facilement, en particulier lorsqu'il s'agit de vecteurs de ligne. Il sert de raccourci ou de surcharge d'opérateur pour la multiplication matricielle dans NumPy. Il convient de noter que la fonction point peut gérer diverses combinaisons de matrices et de vecteurs, en effectuant soit des produits scalaires, soit une multiplication matricielle basée sur les formes d'entrée.
En ce qui concerne les performances, les fonctions matmul et dot ont une vitesse similaire. Le choix entre eux peut dépendre de la machine spécifique. Néanmoins, la fonction point est généralement privilégiée dans la pratique. De plus, l'opération de transposition joue un rôle similaire à l'opération de transposition en algèbre linéaire, renversant efficacement la matrice. Au lieu d'utiliser explicitement la fonction de transposition, nous pouvons utiliser l'attribut T pour plus de brièveté.
Bien que NumPy inclue un type de matrice pour les tableaux à deux dimensions, il n'est pas couramment utilisé au sein de la communauté NumPy. Les tableaux multidimensionnels réguliers remplissent cette fonction dans la plupart des cas. Le type matriciel est limité à deux dimensions et introduit une complexité inutile. Il est conseillé d'éviter de l'utiliser sauf si cela est spécifiquement requis.
Enfin, nous abordons brièvement SciPy, une bibliothèque impressionnante qui englobe un large éventail de fonctionnalités supplémentaires au-delà de NumPy. Cette bibliothèque contient de nombreux algorithmes spécialisés pour le calcul scientifique, tels que les opérations d'algèbre linéaire, les transformées de Fourier, les techniques d'interpolation, les algorithmes d'optimisation, les fonctions statistiques, etc. Bien qu'il soit basé sur NumPy, SciPy sert d'extension, fournissant des outils spécialisés pour divers calculs scientifiques. Dans ce cours, nous explorerons des algorithmes spécifiques au sein de SciPy en fonction des besoins. Vous n'avez pas besoin de mémoriser tous les détails ; Je présenterai et expliquerai les algorithmes pertinents au fur et à mesure que nous les rencontrerons.
Avec cela, nous concluons notre discussion sur NumPy et SciPy pour le calcul scientifique en Python. Dans la prochaine vidéo, nous poursuivrons notre voyage en informatique scientifique en explorant matplotlib, une puissante bibliothèque de traçage.
4.10 Matplotlib (L04 : Calcul scientifique en Python)
4.10 Matplotlib (L04 : Calcul scientifique en Python)
Enfin, nous sommes arrivés à la fin de la leçon quatre, qui a été assez longue. Cependant, j'espère que les concepts abordés à propos de NumPy vous ont été utiles. À l'avenir, nous utiliserons largement NumPy dans nos devoirs pour mettre en œuvre des algorithmes d'apprentissage automatique. Par conséquent, il est crucial que vous deveniez compétent et familiarisé avec NumPy à ce stade.
Passant au dernier sujet de la quatrième conférence, nous explorerons matplotlib, qui est une bibliothèque de traçage populaire pour Python. Bien qu'il existe plusieurs bibliothèques de traçage disponibles de nos jours, matplotlib reste la plus largement utilisée. Personnellement, c'est aussi ma bibliothèque de traçage préférée, et son nom est inspiré de Metalab. La syntaxe de matplotlib est assez similaire à MATLAB, ce que certaines personnes apprécient et d'autres non. Par exemple, je n'aimais pas utiliser MATLAB pendant mes études supérieures, mais je trouve que matplotlib est un excellent outil.
Même si vous n'êtes pas un fan de MATLAB, je pense que matplotlib est relativement facile à utiliser. De plus, il s'intègre facilement à NumPy, ce qui est un avantage supplémentaire. Alors, commençons avec matplotlib. Je dois mentionner que personnellement, je ne mémorise pas toutes les manières spéciales d'accomplir des tâches dans matplotlib car il s'agit d'une bibliothèque de bas niveau. Cela signifie qu'il offre un haut niveau d'options de personnalisation, mais toutes ne sont pas intuitives. Par conséquent, je me retrouve souvent à chercher des choses. Lorsque j'ai besoin de faire quelque chose de spécifique, je visite la galerie matplotlib, qui présente divers exemples. Par exemple, si je veux créer un graphique à tiges, je le recherche simplement dans la galerie, trouve l'exemple et l'adapte à mes données. Cette approche est généralement suffisante pour mes besoins. Cependant, si vous préférez des didacticiels plus détaillés, vous pouvez également explorer le site Web matplotlib.org, qui propose des didacticiels explicatifs sur différents aspects de matplotlib.
Pour commencer, lorsque vous travaillez avec matplotlib dans Jupyter Lab ou Jupyter Notebooks, vous pouvez utiliser la fonction inline pour afficher des tracés dans le notebook lui-même. Cela signifie que les tracés seront affichés directement dans le cahier, évitant ainsi le besoin d'une fenêtre séparée. Bien qu'il existe d'autres moyens d'y parvenir, je recommande personnellement d'utiliser l'approche en ligne car elle est plus fiable sur différents ordinateurs. Pour activer le mode inline, vous pouvez utiliser la commande magique suivante : %matplotlib inline. Vous pouvez également ajouter un point-virgule à la fin de vos instructions de tracé, ce qui aboutit généralement au même résultat. Cependant, il est conseillé d'utiliser plt.show() pour afficher les tracés, car l'astuce du point-virgule peut ne pas fonctionner correctement sur certains ordinateurs.
Passons maintenant à la création de graphiques simples à l'aide de matplotlib. Par exemple, nous pouvons commencer par tracer une courbe sinusoïdale. Pour ce faire, nous pouvons utiliser la fonction np.linspace pour générer 100 valeurs allant de zéro à dix, puis tracer ces valeurs par rapport à np.sin, qui est la fonction sinus. Le moyen le plus simple de créer un tracé consiste à utiliser la fonction plt.plot, où plt est l'abréviation de matplotlib.pyplot. Nous pouvons ajuster les plages d'axes du tracé à l'aide des fonctions plt.xlim et plt.ylim pour définir les limites de l'axe des x et de l'axe des y, respectivement. De plus, nous pouvons ajouter des étiquettes aux axes x et y en utilisant les fonctions plt.xlabel et plt.ylabel. Enfin, pour afficher le tracé, nous pouvons utiliser la fonction plt.show() ou ajouter un point-virgule à la fin des instructions de tracé pour supprimer les sorties indésirables.
En plus d'un seul tracé, nous pouvons également créer plusieurs tracés dans la même figure. Par exemple, nous pouvons tracer à la fois une courbe sinusoïdale et une courbe cosinusoïdale dans des sous-parcelles distinctes. Pour ce faire, nous pouvons créer deux figures à l'aide de la fonction plt.subplots, puis tracer les courbes sinus et cosinus respectives dans chaque sous-parcelle. La fonction plt.subplots renvoie un objet figure et un tableau d'objets axes, que nous pouvons utiliser pour personnaliser chaque sous-parcelle individuellement.
Voici un exemple d'extrait de code qui illustre la création de plusieurs sous-parcelles :
Dans cet exemple, nous utilisons la fonction plt.subplots pour créer une figure avec 2 sous-parcelles disposées verticalement (2, 1). La fonction renvoie un objet figure fig et un tableau d'objets axes axs dont les dimensions correspondent à la disposition de sous-parcelle spécifiée. Nous pouvons accéder à chaque sous-parcelle en indexant le tableau axs.À l'intérieur des blocs de code spécifiques à la sous-parcelle, nous utilisons la fonction de tracé pour tracer les courbes respectives, puis personnalisons le titre, l'étiquette de l'axe des x et l'étiquette de l'axe des y de chaque sous-parcelle à l'aide des fonctions set_title, set_xlabel et set_ylabel, respectivement.
La fonction tight_layout est appelée pour ajuster l'espacement entre les sous-parcelles, assurant une meilleure lisibilité. Enfin, nous utilisons plt.show() pour afficher la figure contenant les sous-parcelles.
Vous pouvez essayer d'exécuter ce code dans votre environnement Jupyter Notebook ou Jupyter Lab pour voir la figure résultante avec les courbes sinus et cosinus affichées dans des sous-parcelles distinctes.
Ceci est juste un exemple de base de création de sous-parcelles, et il existe de nombreuses autres options de personnalisation disponibles dans matplotlib pour rendre vos parcelles plus informatives et visuellement attrayantes. Vous pouvez explorer la documentation et la galerie matplotlib pour d'autres exemples et des explications détaillées.