Python dans le Trading Algorithmique - page 22
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
Visualisation des données avec matplotlib en 1 heure
Visualisation des données avec matplotlib en 1 heure
Dans cette vidéo, l'instructeur présente l'importance de la visualisation des données dans l'apprentissage automatique et explique comment cela peut aider à donner un sens à de grandes quantités de données collectées. Les deux principales bibliothèques Python pour la visualisation de données, Matplotlib et Seaborn, sont abordées dans le cours.
L'instructeur déclare que le cours est principalement conçu pour les ingénieurs en apprentissage automatique, les ingénieurs de données et les scientifiques des données qui souhaitent apprendre Python. Pour illustrer l'utilisation de Matplotlib, un exemple simple de tracé d'une courbe est fourni. La philosophie de Matplotlib s'articule autour de l'exploitation du langage existant, Python, qui est devenu la norme pour la construction de modèles d'apprentissage automatique et la gestion des données. En combinant Matplotlib avec d'autres packages Python, les utilisateurs peuvent profiter des nombreux packages disponibles pour diverses tâches.
La vidéo souligne l'importance d'utiliser le package NumPy aux côtés de Matplotlib pour le calcul scientifique. Alors que Matplotlib peut fonctionner sans NumPy, l'utilisation de NumPy peut considérablement économiser du temps et des efforts. NumPy fournit un puissant objet tableau multidimensionnel et des fonctions pour le manipuler. Un exemple est démontré dans la vidéo, où une courbe de 100 points est générée à l'aide de NumPy pour calculer les coordonnées x et y. Cette approche s'avère beaucoup plus rapide que d'effectuer l'opération en utilisant Python pur. De plus, la vidéo couvre le traçage de deux courbes sur le même graphique à des fins de comparaison, le traçage des données à partir d'un fichier en extrayant et en organisant les données à l'aide de code Python, et le traçage de points au lieu d'éléments de manière linéaire.
Le tutoriel se penche sur la création de différents types de graphiques à barres à l'aide de la bibliothèque Matplotlib. La fonction dédiée à la création de graphiques à barres, "bar", est introduite, qui prend la coordonnée x pour chaque barre et la hauteur de chaque barre comme paramètres d'entrée. En ajustant les paramètres optionnels, les utilisateurs peuvent créer divers effets et même générer des barres horizontales à l'aide de la fonction "barh". Le didacticiel couvre également le traçage de plusieurs graphiques à barres sur le même graphique et la création de barres empilées à l'aide d'un paramètre spécial dans la fonction "bar". De plus, la vidéo aborde brièvement la création de diagrammes circulaires à l'aide de la fonction "camembert".
Diverses fonctions utilisées dans la visualisation de données avec Matplotlib sont expliquées dans le tutoriel. La première fonction couverte est celle des histogrammes, qui sont des représentations graphiques des distributions de probabilité. La fonction "hist" et ses paramètres sont discutés, permettant aux utilisateurs de tracer facilement des données sous forme d'histogrammes. La deuxième fonction couverte est celle des boîtes à moustaches, qui facilitent la comparaison des distributions de valeurs. La vidéo explique les composants d'une boîte à moustaches, y compris les quartiles, la médiane, la moyenne et les quantités statistiques d'un ensemble de données, et montre comment les générer à l'aide de la fonction "boîte à moustaches". Enfin, le didacticiel couvre la modification des tracés en utilisant différentes couleurs et styles, tels que la définition de couleurs à l'aide de triplets, de quadruplés ou de noms de couleurs HTML, ainsi que la définition de la couleur d'un tracé de courbe.
La vidéo continue en expliquant comment ajouter de la couleur aux nuages de points, aux graphiques à barres et aux graphiques à secteurs à l'aide du paramètre "couleur". Ce paramètre permet aux utilisateurs de contrôler les couleurs de points individuels ou de modifier la couleur commune à tous les points. La vidéo aborde également l'importation de bibliothèques sous forme de modules, l'utilisation d'alias pour faciliter le codage et la clarification de la représentation des variables. Il est souligné que presque tout dans Matplotlib et Python implique des fonctions, telles que la fonction "pi" et la fonction "show".
Ensuite, le didacticiel couvre les schémas de couleurs personnalisés et les motifs de ligne lors de la création de boîtes à moustaches, de marqueurs et de formes de ligne. Il illustre la création de marqueurs personnalisés à l'aide de formes prédéfinies et la définition de marqueurs personnalisés à l'aide de symboles textuels mathématiques. De plus, il explique comment modifier facilement les paramètres par défaut de Matplotlib à l'aide de l'objet de configuration centralisé, permettant aux utilisateurs d'adapter le style visuel, comme un fond noir et des annotations blanches, à différents contextes d'utilisation.
Le présentateur explique comment enregistrer un graphique dans un fichier à l'aide de la fonction "savefig" de Matplotlib. Ils couvrent également l'ajout d'annotations à un graphique, y compris un titre, des étiquettes pour les axes x et y, une boîte délimitée et des flèches. La vidéo montre le processus d'ajout de ces annotations pour améliorer la clarté visuelle et la compréhension du graphique. De plus, il montre comment contrôler manuellement l'espacement des graduations dans Matplotlib pour des ajustements précis. La vidéo met en évidence les différentes fonctions disponibles dans Matplotlib pour annoter les graphiques et les rendre plus explicites pour les lecteurs.
Ensuite, l'instructeur discute de la visualisation des données avec Matplotlib et présente Seaborn, une interface de haut niveau pour Matplotlib. Seaborn fournit des paramètres et des fonctionnalités différents par rapport à Matplotlib. L'instructeur montre comment créer des visualisations à l'aide de l'ensemble de données et des cartes de couleurs intégrés de Seaborn. La vidéo se termine en présentant des exemples de création d'un graphique factoriel et d'utilisation de cartes de couleurs pour tracer les données. Grâce à ces exemples, les téléspectateurs ont un aperçu de l'utilisation de différentes fonctions et outils dans Matplotlib et Seaborn pour améliorer leurs compétences en visualisation de données.
La vidéo explique comment mettre à l'échelle des tracés à l'aide de la fonction "set_context" de Seaborn. Cette fonction permet aux utilisateurs de contrôler les éléments du tracé, tels que la taille, en fonction du contexte dans lequel le tracé sera affiché. Il clarifie ensuite la distinction entre les deux types de fonctions de Seaborn : les fonctions au niveau des axes et les fonctions au niveau des figures. Les fonctions au niveau des axes opèrent au niveau des axes et renvoient l'objet axes, tandis que les fonctions au niveau des figures créent des tracés qui incluent des axes organisés de manière significative. Enfin, la vidéo fournit des conseils sur la définition des axes pour une boîte à moustaches à l'aide de l'objet de sous-parcelles d'axe Matplotlib.
Ce didacticiel vidéo complet couvre un large éventail de sujets liés à la visualisation de données avec Matplotlib et Seaborn. Il commence par présenter l'importance de la visualisation des données dans l'apprentissage automatique et l'utilisation de Matplotlib en tant que bibliothèque puissante. Il montre comment tracer des courbes, créer des graphiques à barres, générer des histogrammes et des boîtes à moustaches et personnaliser les couleurs, les marqueurs et les styles de ligne. Le didacticiel couvre également l'enregistrement de graphiques, l'ajout d'annotations et la manipulation de l'espacement des graduations. De plus, il présente Seaborn comme un outil de visualisation alternatif avec son propre ensemble de caractéristiques et de fonctionnalités. En suivant ce didacticiel, les utilisateurs peuvent améliorer leurs compétences en visualisation de données et communiquer efficacement leurs résultats à l'aide de ces puissantes bibliothèques Python.
Tutoriel Deep Learning avec Python, TensorFlow et Keras
Tutoriel Deep Learning avec Python, TensorFlow et Keras
Bonjour à tous et bienvenue dans une mise à jour très attendue sur l'apprentissage en profondeur et Python avec TensorFlow, ainsi qu'un nouveau tutoriel Chaos. Cela fait plus de deux ans que j'ai couvert pour la dernière fois l'apprentissage profond de base en Python, et pendant ce temps, il y a eu des progrès significatifs. Se lancer dans l'apprentissage en profondeur et travailler avec des modèles d'apprentissage en profondeur est devenu beaucoup plus simple et plus accessible.
Si vous souhaitez vous plonger dans le code TensorFlow de niveau inférieur et les détails complexes, vous pouvez toujours vous référer à l'ancienne vidéo. Cependant, si vous souhaitez vous lancer dans l'apprentissage en profondeur, vous n'avez plus besoin de passer par là, car nous avons maintenant des API de haut niveau conviviales comme Chaos qui reposent sur TensorFlow. Ces API rendent l'apprentissage en profondeur incroyablement simple, permettant à quiconque, même sans connaissance préalable de l'apprentissage en profondeur, de suivre.
Dans ce didacticiel, nous allons parcourir rapidement les réseaux de neurones. Pour commencer, comprenons les composants de base d'un réseau de neurones. L'objectif principal de tout modèle d'apprentissage automatique, y compris les réseaux de neurones, est de mapper les entrées aux sorties. Par exemple, étant donné les entrées X1, X2 et X3, nous cherchons à déterminer si la sortie correspond à un chien ou à un chat. Dans ce cas, la couche de sortie est constituée de deux neurones représentant la possibilité d'être un chien ou un chat.
Pour réaliser cette cartographie, nous pouvons utiliser une seule couche cachée, où chaque entrée, X1, X2 et X3, est connectée aux neurones de la couche cachée. Chacune de ces connexions a un poids unique qui lui est associé. Cependant, si nous nous limitions à une seule couche cachée, les relations entre les entrées et la sortie seraient linéaires. Pour capturer les relations non linéaires, qui sont courantes dans les problèmes complexes, nous avons besoin de deux ou plusieurs couches cachées. Un réseau neuronal avec deux ou plusieurs couches cachées est souvent appelé réseau neuronal profond.
Ajoutons un autre calque caché, en le connectant entièrement au calque précédent. Chaque connexion entre les couches a son propre poids unique. En fin de compte, la sortie est dérivée de la couche finale, où chaque connexion à la couche de sortie possède un poids unique. Au niveau d'un neurone individuel, le neurone reçoit des entrées, qui peuvent être soit les valeurs de la couche d'entrée (X1, X2, X3), soit des entrées d'autres neurones. Ces entrées sont additionnées, compte tenu de leurs poids associés. De plus, une fonction d'activation est appliquée pour simuler le déclenchement ou non du neurone. Les fonctions d'activation courantes incluent la fonction d'étape ou la fonction sigmoïde, qui renvoie des valeurs comprises entre 0 et 1. Dans notre réseau de neurones, la couche de sortie utilise une fonction d'activation sigmoïde, attribuant des probabilités à chaque classe (chien ou chat). La fonction Arg max est ensuite utilisée pour déterminer la classe prédite en fonction de la probabilité la plus élevée.
Maintenant que nous avons une compréhension de base des réseaux de neurones, continuons à en créer un à l'aide de TensorFlow. Tout d'abord, assurez-vous que TensorFlow est installé en exécutant la commande "pip install --upgrade tensorflow". Vous pouvez importer TensorFlow en tant que "tf" et vérifier la version actuelle à l'aide de "tf.version". Pour ce tutoriel, Python 3.6 ou supérieur est recommandé, bien que TensorFlow devrait prendre en charge Python 3.7 et les versions ultérieures à l'avenir.
Ensuite, nous allons importer un jeu de données avec lequel travailler. Nous utiliserons l'ensemble de données MNIST, qui se compose d'images 28x28 de chiffres manuscrits allant de 0 à 9. Ces images seront introduites dans le réseau de neurones, et le réseau prédira le chiffre correspondant. Nous allons diviser l'ensemble de données en variables d'apprentissage et de test : X_train, Y_train, X_test et Y_test.
Pour garantir de meilleures performances, nous normaliserons les données. Les valeurs de pixel des images vont actuellement de 0 à 255, nous allons donc les mettre à l'échelle entre 0 et 1 à l'aide de la fonction TF.keras.utils.normalize.
Pour créer le modèle, nous utiliserons l'API Chaos de haut niveau, qui simplifie le processus de création et de formation des réseaux de neurones dans TensorFlow. Chaos fournit un modèle séquentiel appelé Sequential qui nous permet d'empiler les couches les unes après les autres.
Voici un exemple de création d'un modèle de réseau de neurones à l'aide de Chaos :
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
# Create a sequential model
model = Sequential()
# Add a flatten layer to convert the input into a 1D array
model.add(Flatten(input_shape=(28, 28)))
# Add a dense layer with 128 neurons and ReLU activation
model.add(Dense(128, activation='relu'))
# Add another dense layer with 10 neurons for the output and softmax activation
model.add(Dense(10, activation='softmax'))
# Compile the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
Dans le code ci-dessus, nous importons les modules nécessaires de TensorFlow et Chaos. Nous créons un modèle séquentiel et y ajoutons des couches à l'aide de la méthode add. La première couche est une couche Aplatir qui convertit l'entrée 2D (images 28x28) en un tableau 1D. Nous ajoutons ensuite une couche dense avec 128 neurones et une activation ReLU. Enfin, nous ajoutons une couche de sortie avec 10 neurones (correspondant aux 10 chiffres) et une activation softmax.
Après avoir défini le modèle, nous le compilons à l'aide de la méthode compile. Nous spécifions l'optimiseur (dans ce cas, 'adam'), la fonction de perte ('sparse_categorical_crossentropy' pour la classification multi-classes) et les métriques à évaluer lors de la formation.
Maintenant que notre modèle est défini et compilé, nous pouvons continuer à le former sur l'ensemble de données MNIST. Nous allons utiliser la méthode d'ajustement pour former le modèle.
# Train the model model.fit(X_train, Y_train, epochs= 10 , validation_data=(X_test, Y_test))
Dans le code ci-dessus, nous transmettons les données d'entraînement (X_train et Y_train) à la méthode d'ajustement avec le nombre d'époques pour lesquelles s'entraîner. Nous fournissons également les données de validation (X_test et Y_test) pour évaluer les performances du modèle sur des données invisibles lors de la formation.
Après avoir entraîné le modèle, nous pouvons faire des prédictions à l'aide de la méthode de prédiction :
# Make predictions predictions = model.predict(X_test)
Dans le code ci-dessus, nous transmettons les données de test (X_test) à la méthode de prédiction, et elle renvoie les probabilités prédites pour chaque classe.
C'est un bref aperçu de la construction et de la formation d'un réseau de neurones à l'aide de Chaos dans TensorFlow. Vous pouvez explorer plus avant différentes couches, fonctions d'activation, optimiseurs et autres paramètres pour personnaliser votre modèle.
techniques et concepts supplémentaires liés à la construction et à la formation de réseaux de neurones.
Techniques de régularisation :
Dropout : Le dropout est une technique de régularisation utilisée pour éviter le surajustement. Il définit de manière aléatoire une fraction d'unités d'entrée sur 0 à chaque mise à jour pendant la formation, ce qui permet d'éviter que le modèle ne s'appuie trop sur un ensemble particulier de fonctionnalités.
Régularisation L1 et L2 : la régularisation L1 et L2 sont des techniques utilisées pour ajouter une pénalité à la fonction de perte afin d'éviter des poids importants dans le réseau. La régularisation L1 ajoute la valeur absolue des poids à la fonction de perte, encourageant la parcimonie, tandis que la régularisation L2 ajoute les poids au carré à la fonction de perte, encourageant les petits poids.
Fonctions d'activation avancées :
Leaky ReLU : Leaky ReLU est une fonction d'activation qui résout le problème du « ReLU mourant » en autorisant une petite pente pour les entrées négatives. Il introduit une petite pente négative lorsque l'entrée est négative, ce qui aide à empêcher les neurones de mourir pendant l'entraînement.
Unité linéaire exponentielle (ELU) : ELU est une fonction d'activation qui lisse la sortie pour les entrées négatives, permettant à l'activation de prendre des valeurs négatives. Il a été démontré qu'il aide à améliorer l'apprentissage des réseaux de neurones et à réduire le biais en faveur des valeurs positives.
Swish : Swish est une fonction d'activation qui effectue une interpolation douce entre les fonctions linéaires et sigmoïdes. Il a été démontré qu'il fournit de meilleurs résultats par rapport à d'autres fonctions d'activation telles que ReLU et sigmoïde dans certains cas.
Apprentissage par transfert : l'apprentissage par transfert est une technique qui exploite des modèles pré-formés pour résoudre de nouvelles tâches ou améliorer les performances d'un modèle sur une tâche connexe. Au lieu de former un modèle à partir de zéro, vous pouvez utiliser un modèle pré-formé comme point de départ et l'affiner sur votre tâche ou ensemble de données spécifique. Ceci est particulièrement utile lorsque vous disposez de données limitées pour votre tâche spécifique.
Réglage des hyperparamètres : les hyperparamètres sont des paramètres qui ne sont pas appris par le modèle mais qui affectent le processus d'apprentissage, tels que le taux d'apprentissage, la taille du lot, le nombre de couches, etc. Le réglage de ces hyperparamètres peut avoir un impact significatif sur les performances du modèle. Des techniques telles que la recherche de grille, la recherche aléatoire et l'optimisation bayésienne peuvent être utilisées pour rechercher systématiquement l'espace des hyperparamètres et trouver la meilleure combinaison.
Évaluation du modèle : L'évaluation des performances d'un modèle est cruciale pour évaluer son efficacité. Les mesures d'évaluation courantes pour les tâches de classification comprennent l'exactitude, la précision, le rappel, le score F1 et l'aire sous la courbe caractéristique de fonctionnement du récepteur (ROC AUC). Il est important de choisir les métriques appropriées en fonction du problème à résoudre et de la nature des données.
Gestion des ensembles de données déséquilibrés : les ensembles de données déséquilibrés se produisent lorsque la distribution des classes n'est pas égale, ce qui peut entraîner des modèles biaisés. Des techniques telles que le suréchantillonnage de la classe minoritaire, le sous-échantillonnage de la classe majoritaire ou l'utilisation d'une combinaison des deux peuvent aider à résoudre ce problème. De plus, l'utilisation de mesures d'évaluation telles que la précision, le rappel et le score F1 peut fournir une meilleure compréhension des performances du modèle sur des ensembles de données déséquilibrés.
N'oubliez pas que la construction et la formation de réseaux de neurones est un processus itératif. Cela implique l'expérimentation, le réglage fin et l'amélioration continue pour atteindre les résultats souhaités.
Charger vos propres données - Les bases du Deep Learning avec Python, TensorFlow et Keras p.2
Charger vos propres données - Les bases du Deep Learning avec Python, TensorFlow et Keras p.2
Bienvenue à tous dans la partie 2 de notre tutoriel d'apprentissage approfondi sur Python TensorFlow à Karros. Dans ce didacticiel, nous nous concentrerons sur le chargement d'un jeu de données externe. Plus précisément, nous utiliserons l'ensemble de données des chats et des chiens de Microsoft, à l'origine un défi Kaggle. L'objectif est de former un réseau de neurones pour identifier si une image contient un chat ou un chien.
Pour commencer, veuillez télécharger l'ensemble de données sur les chats et les chiens de Microsoft. Une fois que vous avez téléchargé et extrait le jeu de données, vous devriez voir deux répertoires : "chat" et "chien". Ces répertoires contiennent respectivement des images de chats et de chiens. Chaque répertoire doit avoir un nombre substantiel d'échantillons, environ 12 500, fournissant de nombreux exemples pour la formation de notre modèle.
Passons maintenant à la partie codage. Nous devons importer plusieurs bibliothèques : numpy en tant que np, matplotlib.pyplot en tant que plt et OpenCV en tant que cv2. Si vous n'avez pas installé ces bibliothèques, vous pouvez utiliser pip pour les installer.
Ensuite, nous définirons le répertoire de données où se trouve notre jeu de données. Vous pouvez spécifier le chemin d'accès à votre ensemble de données en conséquence. Nous définirons également les catégories comme "chien" et "chat" pour correspondre aux répertoires de notre ensemble de données.
Nous parcourrons chaque catégorie et les images correspondantes à l'aide de la bibliothèque du système d'exploitation. Pour chaque image, nous la convertirons en niveaux de gris à l'aide de la bibliothèque cv2. Nous avons choisi les niveaux de gris car nous pensons que la couleur n'est pas cruciale pour différencier les chats et les chiens dans cette tâche spécifique.
Pour visualiser les images, nous utiliserons matplotlib.pyplot. Nous allons afficher un exemple d'image en utilisant plt.imshow et la carte des couleurs en niveaux de gris. Cette étape nous permet de confirmer que les images sont correctement chargées.
Après avoir vérifié les images, nous procéderons à leur redimensionnement en une forme uniforme. Nous devons décider d'une taille cible, telle que 50x50 pixels, pour assurer la cohérence. Nous allons redimensionner les images à l'aide de la fonction cv2.resize et stocker les tableaux d'images redimensionnés.
Nous allons maintenant créer le jeu de données d'entraînement. Nous initialisons une liste vide appelée "training_data" et définissons une fonction appelée "create_training_data". Dans cette fonction, nous parcourons les images et attribuons des étiquettes numériques (0 pour les chiens, 1 pour les chats) en utilisant l'index de la catégorie dans la liste "catégories".
Pour chaque image, nous la redimensionnons à la taille cible choisie. Nous ajoutons le tableau d'images redimensionné et son étiquette correspondante à la liste training_data. Nous gérons également toutes les exceptions potentielles liées aux images cassées dans l'ensemble de données.
Une fois que nous avons créé l'ensemble de données d'entraînement, nous devons vérifier l'équilibre des données. Dans une tâche de classification binaire comme celle-ci, il est essentiel d'avoir un nombre égal d'échantillons pour chaque classe (50 % de chiens et 50 % de chats). Des données déséquilibrées peuvent conduire à des prédictions de modèle biaisées. Si vos données sont déséquilibrées, vous pouvez utiliser des pondérations de classe pendant l'entraînement pour atténuer ce problème.
Pour garantir le caractère aléatoire et empêcher le modèle d'apprendre l'ordre des images, nous mélangeons les données d'apprentissage à l'aide de la fonction random.shuffle.
Maintenant que nos données sont mélangées, nous pouvons les regrouper dans des variables pour les fonctionnalités (X) et les étiquettes (Y). Nous initialisons des listes vides pour X et Y et parcourons les données d'apprentissage, en ajoutant les fonctionnalités et les étiquettes aux listes respectives. Enfin, nous convertissons X en un tableau NumPy et le remodelons à l'aide de np.array et de la forme de chaque entité.
À ce stade, nous avons préparé nos données pour entraîner le réseau de neurones. Nous sommes maintenant prêts à passer à d'autres étapes, telles que la division des données en ensembles de formation et de validation, la création du modèle et sa formation à l'aide de TensorFlow.
Negative 1 est un espace réservé qui calcule automatiquement la taille en fonction de la longueur du tableau et de la forme de chaque élément. Donc, dans ce cas, nous remodelons le tableau X pour avoir une forme de (-1, taille_image, taille_image). Cela garantit que les données sont au format correct pour être introduites dans le réseau neuronal.
Ensuite, nous devons normaliser les valeurs de pixel des images. Actuellement, les valeurs de pixel vont de 0 à 255, représentant l'intensité de l'échelle de gris. Les réseaux de neurones fonctionnent généralement mieux lorsque les données d'entrée sont normalisées, ce qui signifie que les valeurs sont mises à l'échelle dans une plage plus petite. Nous pouvons y parvenir en divisant les valeurs de pixel par 255,0, ce qui les mettra à l'échelle entre 0 et 1,0. Cela peut être fait en utilisant le code suivant :
x = x / 255.0
Réseaux de neurones convolutifs - Bases du Deep Learning avec Python, TensorFlow et Keras p.3
Réseaux de neurones convolutifs - Bases du Deep Learning avec Python, TensorFlow et Keras p.3
Bonjour à tous et bienvenue dans la troisième partie de notre série de didacticiels Deep Learning with Python, TensorFlow et Keras. Dans cette vidéo, nous nous concentrerons sur les réseaux de neurones convolutifs (CNN) et sur la façon de les appliquer pour classer les chiens par rapport aux chats en utilisant l'ensemble de données que nous avons construit dans la vidéo précédente.
Avant de plonger dans les CNN, voyons rapidement comment ils fonctionnent et pourquoi ils sont utiles pour les données d'image. Les CNN impliquent plusieurs étapes : convolution, mise en commun, puis davantage de convolution et de mise en commun. L'idée principale derrière la convolution est d'extraire des caractéristiques utiles d'une image. Nous utilisons une fenêtre convolutive, généralement représentée sous forme de matrice (par exemple, 3x3), pour numériser l'image et simplifier les informations dans la fenêtre à une seule valeur. La fenêtre se déplace alors et répète ce processus plusieurs fois. La foulée, qui détermine le mouvement de la fenêtre, peut également être ajustée.
Avec Keras, nous pouvons spécifier la taille de la fenêtre et la plupart des autres détails sont pris en charge automatiquement. Si vous souhaitez approfondir les subtilités de l'apprentissage en profondeur, je vous recommande de consulter la série de didacticiels "Apprentissage automatique pratique", où le fonctionnement interne est expliqué plus en détail, en particulier pour le code TensorFlow brut.
La sortie de la couche convolutive est un ensemble de caractéristiques extraites de l'image. Ces fonctionnalités sont ensuite généralement transmises via une couche de regroupement, le type le plus courant étant le regroupement maximal. La mise en commun maximale sélectionne la valeur maximale dans une fenêtre et la déplace à plusieurs reprises, sous-échantillonnant efficacement les données.
L'idée de niveau supérieur derrière les CNN est qu'ils extraient progressivement des fonctionnalités plus complexes de l'image au fur et à mesure que vous progressez dans le réseau. Les couches initiales peuvent identifier les bords et les lignes, tandis que les couches plus profondes peuvent reconnaître des formes plus complexes comme des cercles ou des carrés. Finalement, le réseau peut apprendre à identifier des objets ou des modèles spécifiques.
Pour implémenter un CNN, nous devons importer les bibliothèques nécessaires. Nous importons TensorFlow et les modules Keras que nous utiliserons, tels que Sequential, Dense, Dropout, Activation, Conv2D et MaxPooling2D. Nous importons également du cornichon pour charger notre jeu de données.
Avant d'introduire les données dans le réseau de neurones, nous devrions envisager de les normaliser. Dans notre cas, nous pouvons mettre à l'échelle les données de pixel en les divisant par 255, car les valeurs de pixel vont de 0 à 255. Alternativement, nous pouvons utiliser la fonction de normalisation de chaos.utils pour des scénarios de normalisation plus complexes.
Ensuite, nous commençons à construire notre modèle à l'aide de l'API séquentielle. Nous ajoutons une couche Conv2D avec 64 unités et une taille de fenêtre 3x3. L'input_shape est défini dynamiquement à l'aide de X.shape. Nous ajoutons ensuite une couche d'activation en utilisant la fonction d'activation linéaire rectifiée (ReLU). Ensuite, nous ajoutons une couche de regroupement maximale avec une taille de fenêtre de 2x2.
Nous répétons ce processus en ajoutant une autre couche Conv2D et une couche max pooling correspondante. À ce stade, nous avons un réseau de neurones convolutifs 2D.
Pour transmettre les entités extraites à une couche entièrement connectée, nous devons aplatir les données. Nous ajoutons une couche Flatten avant d'ajouter une dernière couche Dense avec 64 nœuds. Enfin, nous ajoutons une couche de sortie avec un seul nœud et spécifions la fonction d'activation, qui peut être catégorique ou binaire.
Nous compilons le modèle en spécifiant la fonction de perte (entropie croisée catégorielle ou binaire), l'optimiseur (par exemple, Adam) et les métriques pour évaluer les performances du modèle (par exemple, la précision).
Pour former le modèle, nous utilisons la méthode d'ajustement, en transmettant nos données d'entrée X et nos étiquettes Y. Nous pouvons également spécifier la taille du lot (par exemple, 32).
Nous allons utiliser le code suivant pour entraîner le modèle :
model.fit(X, Y, batch_size= 32 , validation_split= 0.1 )
Ce code entraînera le modèle à l'aide des données d'entrée X et des étiquettes correspondantes Y. Nous définissons la taille du lot sur 32, ce qui signifie que le modèle traitera 32 échantillons à la fois pendant l'entraînement. Le paramètre validation_split est défini sur 0,1, ce qui signifie que 10 % des données seront utilisées pour la validation lors de la formation du modèle.
Une fois le modèle formé, nous pouvons évaluer ses performances à l'aide des données de test. Nous pouvons utiliser le code suivant pour évaluer le modèle :
model.evaluate(X_test, Y_test)
Ici, X_test et Y_test représentent respectivement les données de test et les étiquettes. Ce code renverra la valeur de perte et la précision du modèle sur les données de test.
Après avoir évalué le modèle, nous pouvons l'utiliser pour faire des prédictions sur de nouvelles données inédites. Nous pouvons utiliser la fonction predict () pour obtenir les étiquettes prédites pour les nouvelles données. Voici un exemple :
predictions = model.predict(X_new)
predicted_labels = np.argmax(predictions, axis= 1 )
C'est ça! Vous avez maintenant formé un modèle de réseau neuronal convolutif pour classer les chiens et les chats et l'avez utilisé pour faire des prédictions sur de nouvelles données. N'oubliez pas de sauvegarder le modèle formé pour une utilisation future si nécessaire.
Analyser des modèles avec TensorBoard - Deep Learning avec Python, TensorFlow et Keras p.4
Analyser des modèles avec TensorBoard - Deep Learning avec Python, TensorFlow et Keras p.4
Bienvenue à tous dans la partie 4 de la série de didacticiels "Apprentissage approfondi avec Python : TensorFlow et Keras". Dans cette vidéo et la suivante, nous verrons comment analyser et optimiser nos modèles à l'aide de TensorBoard. TensorBoard est un outil puissant qui nous permet de visualiser l'entraînement de nos modèles au fil du temps. Son objectif principal est de nous aider à comprendre divers aspects des performances de notre modèle, tels que l'exactitude, l'exactitude de la validation, la perte et la perte de validation. De plus, il existe des fonctionnalités plus avancées dans TensorBoard que nous pourrions explorer dans de futurs didacticiels.
Avant de plonger dans TensorBoard, abordons un détail mineur. Bien que cela ne soit pas crucial pour ce didacticiel, je tiens à souligner que même les petits modèles ont tendance à consommer une quantité importante de mémoire GPU. Si vous prévoyez d'exécuter plusieurs modèles simultanément, vous pouvez spécifier une fraction de la mémoire GPU que chaque modèle doit utiliser. En procédant ainsi, vous pouvez éviter les problèmes potentiels lors de l'exécution de plusieurs modèles ou lorsque vous rencontrez des contraintes de mémoire. Par exemple, je configure généralement le modèle pour qu'il utilise un tiers de la mémoire GPU. Cette approche s'est avérée utile lors de l'exécution simultanée de plusieurs modèles, comme dans la série "Python Plays GTA" impliquant la détection d'objets et l'auto-conduite. C'est juste une astuce pratique qui peut vous faire gagner du temps et des maux de tête.
Passons maintenant au sujet principal. La première chose que je veux aborder est d'ajouter une fonction d'activation après la couche dense. C'était un oubli de ma part de ne pas l'inclure initialement. L'ajout d'une fonction d'activation est indispensable car sans elle, la couche dense devient une fonction d'activation linéaire, ce qui n'est pas adapté à notre propos. Nous voulons éviter la régression et nous assurer que notre modèle fonctionne de manière optimale. Alors, corrigeons rapidement cela en insérant la fonction d'activation avant la couche dense.
Une fois cette correction effectuée, nous devrions observer une amélioration significative de la précision. Pendant que le modèle s'entraîne, prenons un moment pour explorer la documentation TensorFlow et en savoir plus sur les différents rappels Keras disponibles. Dans notre cas, nous utiliserons le rappel TensorBoard pour s'interfacer avec TensorBoard. Cependant, il convient de noter qu'il existe d'autres rappels utiles, tels que l'arrêt précoce basé sur des paramètres spécifiques, la planification du taux d'apprentissage et le point de contrôle du modèle. Les points de contrôle du modèle sont particulièrement utiles lorsque vous souhaitez enregistrer le modèle à des intervalles spécifiques, tels que la meilleure précision de perte ou de validation. Pour l'instant, concentrons-nous sur le rappel TensorBoard, mais je pourrais aborder brièvement d'autres rappels dans une future vidéo.
Pour utiliser le rappel TensorBoard, nous devons l'importer depuis le module de rappel Keras de TensorFlow. Ajoutez la ligne de code suivante pour importer TensorBoard :
from tensorflow.keras.callbacks import TensorBoard
Maintenant que nous avons importé le module nécessaire, effectuons un peu de ménage. Il est toujours recommandé de donner à votre modèle un nom significatif, en particulier lorsque vous travaillez avec plusieurs modèles. Dans ce cas, nous pouvons nommer notre modèle quelque chose comme "cats_vs_dogs_CNN_64x2". De plus, ajoutons un horodatage au nom pour garantir son unicité. Inclure l'horodatage est utile lors du réentraînement d'un modèle ou pour éviter toute confusion avec les versions du modèle. Ainsi, au début de notre code, définissons le nom du modèle et l'horodatage comme suit :
import time model_name = f"cats_vs_dogs_CNN_64x2_ { int (time.time())} "
tensorboard_callback = TensorBoard(log_dir= f"logs/ {model_name} " )
De plus, Tensor Board nous permet d'analyser et d'optimiser nos modèles en fournissant des visualisations du processus de formation. Il se concentre principalement sur des mesures telles que la précision, la précision de validation, la perte et la perte de validation. Ces mesures nous aident à comprendre les performances de notre modèle au fil du temps et à identifier les domaines à améliorer. Alors que la précision et la perte sont couramment surveillées, la carte tenseur offre des fonctionnalités plus avancées que nous pourrions explorer à l'avenir.
Pour commencer à utiliser la carte tenseur, nous devons d'abord faire un petit ajout à notre code. Bien que cela ne soit pas crucial pour ce didacticiel, il convient de le mentionner. En ajoutant quelques lignes de code, nous pouvons allouer une fraction spécifique de mémoire GPU pour notre modèle. Ceci est avantageux lorsque vous exécutez plusieurs modèles simultanément ou lorsque vous rencontrez des problèmes avec la VRAM. Cela nous permet de contrôler l'allocation du GPU et d'éviter les plantages potentiels ou les débordements de mémoire. Dans notre cas, nous allouons un tiers du GPU au modèle. Cela garantit une exécution fluide et évite tout conflit lorsque vous travaillez avec d'autres modèles ou projets.
Passons à autre chose, concentrons-nous sur la mise en œuvre de la carte tenseur. Tout d'abord, nous devons importer les dépendances nécessaires. Nous importons le module "tensorboard" du package "tensorflow.keras.callbacks". Ce module fournit la fonctionnalité de rappel pour la carte tenseur.
Ensuite, nous voulons attribuer un nom significatif à notre modèle. Donner à chaque modèle un nom distinct est essentiel lorsque vous travaillez avec plusieurs modèles. Cela nous aide à garder une trace des expériences et à éviter toute confusion. Dans ce cas, nous nommons notre modèle "cat's_first_dog_CNN_64x2_good_enough". De plus, nous ajoutons un horodatage au nom en utilisant la valeur d'heure actuelle. Cela garantit l'unicité et empêche tout écrasement accidentel des modèles.
Après avoir nommé notre modèle, nous pouvons définir l'objet de rappel de la carte tenseur. Nous créons une instance de la classe "TensorBoard" et l'affectons à la variable "tensorboard". Nous passons le chemin du répertoire du journal au constructeur. Le répertoire des journaux est l'endroit où Tensor Board stockera les journaux et les données liés à notre modèle. Nous utilisons le formatage de chaîne pour inclure le nom du modèle dans le chemin du répertoire du journal.
Une fois que nous avons l'objet de rappel prêt, nous pouvons l'incorporer dans notre processus de formation de modèle. Dans la méthode "fit" de notre modèle, nous passons l'objet callback au paramètre "callbacks" sous forme de liste. Dans ce cas, nous n'avons qu'un seul rappel, qui est le rappel de la carte du tenseur. Cependant, il convient de noter que vous pouvez inclure plusieurs rappels dans la liste si nécessaire.
Avec le rappel intégré, nous pouvons maintenant entraîner notre modèle. Nous avons fixé le nombre d'époques à 10 pour cet exemple. Cependant, n'hésitez pas à ajuster le nombre d'époques en fonction de vos besoins. Au fur et à mesure que le modèle s'entraîne, la carte Tensor commencera à générer des journaux et des visualisations en fonction des métriques spécifiées.
Pour voir la carte tenseur en action, nous devons ouvrir la fenêtre de commande ou le terminal et naviguer jusqu'au répertoire contenant les fichiers journaux. Une fois dans le bon répertoire, nous exécutons la commande tensor board en tapant "tensorboard --logdir logs" dans l'invite de commande. Cette commande lance le serveur de la carte tenseur et fournit une URL locale où nous pouvons accéder à l'interface de la carte tenseur.
Après avoir démarré la carte tenseur, nous pouvons ouvrir un navigateur Web et entrer l'URL fournie par l'invite de commande. Cela affichera l'interface de la carte du tenseur, où nous pourrons visualiser la progression de la formation de notre modèle. L'interface affiche divers graphiques, y compris la précision dans l'échantillon, la perte dans l'échantillon, la précision hors échantillon et la perte hors échantillon. Nous analysons ces mesures pour surveiller les performances du modèle et prendre des décisions éclairées concernant son optimisation.
En observant les graphiques, nous pouvons identifier des modèles et des tendances dans le comportement du modèle. Par exemple, si la perte de validation commence à augmenter alors que la précision de la validation reste stable ou diminue, cela indique un surajustement. D'autre part, si la précision et la perte de validation s'améliorent avec le temps, cela suggère que le modèle apprend efficacement.
La carte Tensor fournit une plate-forme puissante pour analyser et optimiser les modèles. Ses visualisations offrent des informations précieuses sur le processus de formation et facilitent la prise de décision. En tirant parti de la carte tenseur, nous pouvons rationaliser le processus de développement de modèles et obtenir de meilleurs résultats.
Dans la prochaine partie de cette série de didacticiels, nous approfondirons les fonctionnalités avancées de la carte tensorielle, y compris les histogrammes, les distributions et les incorporations. Ces fonctionnalités offrent une granularité supplémentaire et nous permettent d'acquérir une compréhension plus complète de nos modèles. Restez à l'écoute pour la prochaine vidéo, où nous explorons ces capacités passionnantes.
C'est tout pour ce tutoriel. Merci d'avoir regardé, et je vous verrai dans la prochaine vidéo !
Optimisation avec TensorBoard - Deep Learning avec Python, TensorFlow et Keras p.5
Optimisation avec TensorBoard - Deep Learning avec Python, TensorFlow et Keras p.5
Bonjour à tous et bienvenue dans la cinquième partie de la série de didacticiels Deep Learning avec Python TensorBoard et Keras. Dans ce didacticiel, nous nous concentrerons sur TensorBoard et sur la manière dont nous pouvons l'utiliser pour optimiser les modèles en visualisant différentes tentatives de modèle. Plongeons-y !
Tout d'abord, analysons le modèle et identifions les aspects que nous pouvons modifier pour améliorer ses performances. Bien que notre modèle actuel ait atteint une précision d'environ 79 %, nous pensons que nous pouvons faire mieux. Certains domaines potentiels d'optimisation incluent l'optimiseur, le taux d'apprentissage, le nombre de couches denses, les unités par couche, les unités d'activation, la taille du noyau, la foulée, le taux de décroissance, etc. Avec de nombreuses options à explorer, nous pourrions finir par tester des milliers de modèles. Alors, par où commencer ?
Pour faciliter les choses, commençons par les modifications les plus simples. Nous nous concentrerons sur l'ajustement du nombre de couches, de nœuds par couche et sur l'inclusion ou non d'une couche dense à la fin. Pour le nombre de couches denses, nous considérerons zéro, une ou deux. En ce qui concerne les tailles de calque, nous utiliserons les valeurs 32, 64 et 128. Ces valeurs ne sont que des conventions et vous pouvez en choisir différentes selon vos préférences.
Maintenant, implémentons ces changements dans notre code. Nous définirons certaines variables pour les choix que nous voulons faire, comme le nombre de couches denses et la taille des couches. Nous allons parcourir ces variables pour créer différentes combinaisons de modèles. De plus, nous allons créer un nom pour chaque modèle qui reflète sa configuration.
Une fois que nous avons les configurations du modèle, nous pouvons procéder à leur application dans notre code. Nous mettrons à jour la structure du modèle en conséquence, en tenant compte de la forme d'entrée, des couches convolutionnelles, des couches denses et de la couche de sortie. Nous veillerons également à ce que les tailles de calque soient correctement ajustées.
Avec toutes les modifications apportées, il est temps d'exécuter le code. Cependant, comme la formation de nombreux modèles peut prendre du temps, j'ai déjà exécuté le code et enregistré les résultats. Passons à l'analyse des résultats à l'aide de TensorBoard.
Nous chargeons les journaux TensorBoard et observons les différentes combinaisons de modèles. Les modèles sont organisés en fonction de leurs performances, en particulier la perte de validation. Nous nous concentrons sur les modèles les plus performants et notons leurs configurations.
D'après les résultats, il devient évident que les modèles avec trois couches convolutionnelles et des couches denses nulles fonctionnent toujours bien. Le nombre spécifique de nœuds par couche semble moins important. Cependant, il convient de noter que des couches denses plus grandes, telles que 512 ou 256 nœuds, pourraient donner des résultats encore meilleurs. Pour vérifier cela, vous pouvez tester différentes tailles de couches denses.
Pour résumer, nous avons commencé par explorer diverses configurations de modèles à l'aide de TensorBoard. Nous avons constaté que les modèles avec trois couches convolutives et aucune couche dense fonctionnaient toujours bien. Nous avons également identifié que le nombre de nœuds par couche pourrait être encore optimisé. En testant différentes tailles de couches denses, nous pouvons potentiellement encore améliorer la précision du modèle.
Gardez à l'esprit qu'il ne s'agit que d'un point de départ et que vous pouvez modifier de nombreux autres aspects pour optimiser vos modèles. TensorBoard fournit un outil précieux pour visualiser et analyser ces variations de modèle, vous aidant à prendre des décisions éclairées pour l'amélioration du modèle.
Comment utiliser votre modèle entraîné - Les bases du Deep Learning avec Python, TensorFlow et Keras p.6
Comment utiliser votre modèle entraîné - Les bases du Deep Learning avec Python, TensorFlow et Keras p.6
Bonjour à tous et bienvenue dans la partie 6 de la série de didacticiels Deep Learning en Python avec TensorFlow et Keras !
Dans cette vidéo, nous expliquerons comment utiliser notre modèle formé pour faire des prédictions sur de nouvelles images. De nombreuses personnes ont posé des questions à ce sujet, car elles ont formé et testé avec succès leurs ensembles de données, mais ne savent pas comment utiliser le modèle pour prédire sur des images externes. Alors, plongeons-y !
Tout d'abord, nous devons importer les bibliothèques nécessaires. Nous allons importer cv2 pour le traitement d'image et tensorflow en tant que TF pour travailler avec notre modèle. Nous aurons également besoin de la liste des catégories, qui contient les étiquettes de classe "chien" et "chat" que nous avons utilisées lors de la formation.
Ensuite, nous allons définir une fonction appelée prepare qui prend un chemin de fichier comme paramètre. Cette fonction gérera les étapes de prétraitement requises pour l'image d'entrée. Nous allons redimensionner l'image à une taille spécifique et la convertir en niveaux de gris. L'image sera ensuite renvoyée sous la forme d'un tableau numpy remodelé.
Après cela, nous chargerons notre modèle entraîné à l'aide de la fonction TF.keras.models.load_model(). Auparavant, nous avons enregistré notre modèle en tant que "modèle CNN 64 par 3", nous allons donc le charger en utilisant le même nom.
Maintenant, nous sommes prêts à faire des prédictions. Nous allons définir une variable appelée prédiction et lui attribuer le résultat de l'appel de model.predict() sur notre image préparée. Il est important de noter que la méthode predict() attend une liste en entrée, même si nous prédisons sur une seule image. Nous devons donc transmettre l'image préparée sous forme de liste.
Une fois que nous avons le résultat de la prédiction, nous pouvons l'imprimer. Cependant, la prédiction se présente actuellement sous la forme d'une liste imbriquée. Pour le rendre plus lisible, nous pouvons convertir la valeur de prédiction en entier et l'utiliser comme index pour récupérer l'étiquette de classe correspondante dans la liste des catégories.
Enfin, nous pouvons imprimer l'étiquette de classe prédite, qui indique si l'image est classée comme un chien ou un chat.
Dans ce tutoriel, nous avons utilisé deux images externes pour tester notre modèle : l'une d'un chien avec un cône de honte et l'autre d'une créature inconnue. Ces images ne faisaient pas partie de notre ensemble de données d'entraînement, ce qui garantit que nous faisons des prédictions sur des données invisibles.
Pour l'essayer avec vos propres images de chien et de chat, suivez les étapes décrites dans le code. Gardez à l'esprit que la précision peut varier, mais en moyenne, elle devrait être d'environ 80 %.
C'est tout pour le moment! Je tiens à remercier nos commanditaires récents : Michael, Nick, Rodrigo et Papasan E. Votre soutien est grandement apprécié. Si vous avez des questions, des commentaires ou des suggestions pour de futurs tutoriels, veuillez les laisser ci-dessous. Je suis également ouvert aux idées d'utilisation de réseaux de neurones récurrents, donc si vous avez un ensemble de données simple en tête, faites-le moi savoir.
Je vous verrai dans le prochain tutoriel, où nous explorerons les réseaux de neurones récurrents. D'ici là, bon codage !
Réseaux de neurones récurrents (RNN) - Apprentissage en profondeur avec Python, TensorFlow et Keras p.7
Réseaux de neurones récurrents (RNN) - Apprentissage en profondeur avec Python, TensorFlow et Keras p.7
Bonjour à tous et bienvenue dans la partie 7 de la série de didacticiels Deep Learning with Python TensorFlow in Chaos. Dans cette partie, nous nous concentrerons sur le réseau de neurones récurrent (RNN). Le but d'un RNN est de saisir la signification et l'importance de l'ordre des données. Ceci est particulièrement pertinent dans les données de séries chronologiques, où les données sont organisées temporellement, et dans le traitement du langage naturel, où l'ordre des mots dans une phrase a un sens.
Pour illustrer le concept, considérons l'exemple d'une phrase : "Certaines personnes ont créé un réseau de neurones". Lorsque cette phrase est traitée par un réseau de neurones profonds, qui symbolise généralement les données en les divisant en mots individuels, le réseau peut ne pas capturer le sens correct. Par exemple, la phrase "Un réseau de neurones a créé certaines personnes" a un sens complètement différent. Cela souligne l'importance de l'ordre des mots dans la détermination du sens d'une phrase.
Intéressons-nous maintenant au fonctionnement d'un réseau neuronal récurrent. Le bloc de construction de base d'un RNN est la cellule récurrente, qui est souvent implémentée à l'aide d'une cellule de mémoire longue à court terme (LSTM). Bien que d'autres options comme l'unité récurrente fermée (GRU) existent, la cellule LSTM est couramment utilisée. Dans un RNN, chaque cellule prend des données séquentielles en entrée et en sortie vers la couche suivante ou la cellule suivante de la couche récurrente.
La sortie d'une cellule peut être dirigée de différentes manières. Il peut aller à la couche suivante ou à la cellule suivante de manière unidirectionnelle ou bidirectionnelle. Dans ce didacticiel, nous nous concentrerons sur un RNN unidirectionnel de base. Pour illustrer cela, imaginez une boîte verte représentant une cellule récurrente. Les données de la cellule précédente entrent dans la cellule actuelle, qui effectue des opérations telles que l'oubli d'informations non pertinentes du nœud précédent, l'incorporation de nouvelles données d'entrée et la décision des informations à transmettre à la couche ou au nœud suivant.
Pour mieux visualiser ce processus, considérons une cellule spécifique dans la couche. La case verte représente la cellule actuelle. Les données arrivent de la cellule précédente, s'enroulent et entrent dans la cellule LSTM. Dans la cellule, il y a des opérations pour oublier les informations du nœud précédent, incorporer de nouvelles données d'entrée et déterminer la sortie à transmettre à la couche ou au nœud suivant. Ces opérations permettent collectivement à la cellule LSTM de conserver des informations importantes et de les transmettre aux couches ou nœuds suivants.
La mise en œuvre d'un RNN peut être complexe, en particulier lorsqu'il s'agit de valeurs scalaires. Si vous êtes intéressé par une explication détaillée du fonctionnement des cellules LSTM, je vous recommande de consulter un guide complet qui les explique en profondeur. J'ai inclus un lien vers ce guide dans la version texte du didacticiel pour votre référence.
Passons maintenant à la construction d'un réseau neuronal récurrent de base. Dans ce didacticiel, nous commencerons par un exemple simple utilisant le jeu de données M-NIST. Dans le prochain didacticiel, nous travaillerons avec des données de séries chronologiques plus réalistes, en nous concentrant spécifiquement sur les prix des crypto-monnaies.
Pour commencer, importons les bibliothèques nécessaires. Nous importerons TensorFlow en tant que tf, le modèle séquentiel de tensorflow.keras.models, la couche dense de tensorflow.keras.layers, ainsi que les cellules Dropout et LSTM. Notez que si vous utilisez la version GPU de TensorFlow, il existe également une cellule LSTM optimisée appelée cellule KU DNN LSTM. Cependant, pour ce didacticiel, nous nous en tiendrons à la cellule LSTM habituelle. Si vous utilisez la version CPU de TensorFlow, le calcul peut prendre beaucoup de temps.
Ensuite, nous devons charger le jeu de données. Pour cet exemple, nous utiliserons le jeu de données M-NIST. Nous pouvons facilement le charger à l'aide de la fonction tf.keras.datasets.mnist.load_data(), qui renvoie les données d'entraînement et de test. Décompressons les données en variables : X_train, Y_train, X_test et Y_test.
Tout d'abord, normalisons les données d'entrée en divisant chaque valeur de pixel par 255. Cela mettra les valeurs de pixel à l'échelle dans une plage comprise entre 0 et 1, ce qui convient à l'apprentissage du réseau neuronal. Nous pouvons y parvenir en divisant les données d'entraînement et de test par 255.
X_train = X_train / 255.0 X_test = X_test / 255.0
Ensuite, nous devons convertir les étiquettes cibles en vecteurs codés à chaud. Dans le jeu de données M-NIST, les étiquettes sont des nombres entiers allant de 0 à 9, représentant les chiffres. L'encodage à chaud convertit chaque étiquette en un vecteur binaire de longueur 10, où l'index correspondant au chiffre est défini sur 1 et tous les autres indices sont définis sur 0. Nous pouvons utiliser la fonction to_categorical de tensorflow.keras.utils pour effectuer un -encodage à chaud.
Y_train = to_categorical(Y_train, num_classes=10)
Y_test = to_categorical(Y_test, num_classes=10)
Maintenant, définissons l'architecture de notre réseau de neurones récurrent. Nous allons utiliser le modèle séquentiel de tensorflow.keras.models et y ajouter des couches.
from tensorflow.keras.layers import LSTM, Dense
model = Sequential()
model.add(LSTM(128, input_shape=(X_train.shape[1:]), activation='relu', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
Maintenant, compilons le modèle en spécifiant la fonction de perte, l'optimiseur et la métrique d'évaluation.
model. compile (loss= 'categorical_crossentropy' , optimizer= 'adam' , metrics=[ 'accuracy' ])
Enfin, entraînons le modèle à l'aide des données d'entraînement et évaluons-le sur les données de test.
model.fit(X_train, Y_train, batch_size= 32 , epochs= 10 , validation_data=(X_test, Y_test))
C'est ça! Vous avez maintenant construit un réseau neuronal récurrent utilisant des cellules LSTM pour l'ensemble de données M-NIST. Vous pouvez expérimenter différentes architectures, hyperparamètres et ensembles de données pour explorer davantage les capacités des RNN.
Introduction au RNN prédicteur de crypto-monnaie - Apprentissage en profondeur avec Python, TensorFlow et Keras p.8
Introduction au RNN prédicteur de crypto-monnaie - Apprentissage en profondeur avec Python, TensorFlow et Keras p.8
Bonjour à tous et bienvenue dans un autre didacticiel vidéo d'apprentissage en profondeur avec Python. Dans cette vidéo et les prochaines, nous discuterons de la façon d'appliquer un réseau neuronal récurrent (RNN) à un exemple plus réaliste de travail avec des données séquentielles. Plus précisément, nous travaillerons avec un ensemble de données de séries chronologiques composé de prix et de volumes pour les crypto-monnaies.
Avant de plonger dans les détails, je tiens à préciser que vous pouvez appliquer les mêmes concepts à d'autres types de données séquentielles, telles que les cours des actions ou les données de capteurs. Ainsi, même si vous n'êtes pas intéressé par la finance, vous pouvez toujours suivre et comprendre les concepts.
L'objectif de ce tutoriel est d'utiliser un réseau de neurones récurrent pour prédire le prix futur d'une crypto-monnaie en fonction de son prix et de son volume passés. Nous nous concentrerons sur quatre principales crypto-monnaies : Bitcoin, Litecoin, Ethereum et Bitcoin Cash. L'idée est de prendre les 60 dernières minutes de données de prix et de volume pour chacune de ces crypto-monnaies et de les utiliser comme entrée pour prédire le prix du Litecoin, par exemple, trois minutes dans le futur.
Ce type de problème de prédiction peut également être appliqué à d'autres domaines, tels que la prédiction des pannes de serveur ou du trafic sur le site Web en fonction des données de temps et d'utilisation. Le but ultime est de prédire une classification (par exemple, si le prix va augmenter ou baisser) ou d'effectuer une régression (par exemple, prédire le prix réel ou la variation en pourcentage).
Travailler avec des données séquentielles présente des défis uniques. Premièrement, nous devons prétraiter les données et les convertir en séquences que le réseau neuronal récurrent peut gérer. De plus, nous devons équilibrer et normaliser les données, étant donné que les prix et les volumes des différentes crypto-monnaies peuvent avoir des échelles différentes. La mise à l'échelle des données est plus complexe que dans d'autres domaines, comme les données d'image, où nous divisons simplement par 255.
De plus, l'évaluation des performances du modèle à l'aide de données hors échantillon est un défi différent lorsque l'on travaille avec des données séquentielles. Nous devons couvrir plusieurs aspects, notamment la préparation, la normalisation et l'évaluation des données.
Pour commencer, je vous ai fourni un ensemble de données à télécharger. Vous trouverez le lien de téléchargement dans la description du tutoriel. Une fois que vous avez extrait le fichier zip téléchargé, vous trouverez quatre fichiers, chacun correspondant aux données de prix et de volume d'une crypto-monnaie.
Nous utiliserons la bibliothèque pandas en Python pour lire et manipuler l'ensemble de données. Si vous n'avez pas installé de pandas, vous pouvez le faire en exécutant la commande pip install pandas dans votre terminal ou dans l'invite de commande.
Ensuite, nous lirons l'ensemble de données à l'aide de pandas et examinerons les données. Nous nous concentrerons sur les colonnes de prix et de volume "de clôture" pour chaque crypto-monnaie. Pour fusionner les données de différents fichiers, nous allons définir la colonne "time" comme index pour chaque dataframe. Ensuite, nous allons joindre les dataframes en fonction de leur index partagé.
Une fois que nous avons le dataframe fusionné, nous devons définir certains paramètres. Ceux-ci incluent la longueur de la séquence (le nombre de périodes passées à considérer), la période future (le nombre de périodes dans le futur à prédire) et le ratio à prédire (la crypto-monnaie que nous voulons prédire).
Dans notre cas, nous nous concentrerons sur la prédiction du prix futur du Litecoin (LTC) sur la base des 60 dernières minutes de données, et nous prédirons trois minutes dans le futur. Nous allons également définir une règle de classification, où nous classons la prédiction comme une augmentation ou une diminution des prix en fonction des prix actuels et futurs.
Une fois ces étapes initiales terminées, nous sommes maintenant prêts à prétraiter les données, créer des séquences et former le réseau neuronal récurrent. Nous aborderons ces sujets dans les prochaines vidéos, alors restez à l'écoute.
Si vous souhaitez suivre, assurez-vous de télécharger l'ensemble de données et de configurer les bibliothèques requises. Vous pouvez trouver le code complet et les instructions dans la version textuelle du didacticiel, qui est disponible dans la description.
Nous avons beaucoup à couvrir, nous allons donc le classer en 1, indiquant une hausse des prix. Sinon, si le prix futur est inférieur au prix actuel, nous le classerons comme 0, indiquant une baisse de prix. Il s'agit d'une règle simple que nous utilisons pour la classification, mais vous pouvez expérimenter différentes règles ou même utiliser la régression pour prédire le changement de prix réel.
Maintenant, créons la colonne cible dans notre DataFrame principal. Nous utiliserons la fonction de décalage de pandas pour décaler les valeurs de la colonne "LTCUSD_close" par la période future. Cela nous donnera les prix futurs que nous comparerons avec les prix actuels pour déterminer le classement. Nous affecterons le résultat à une nouvelle colonne appelée "cible".
main_df[ 'target' ] = main_df[ 'LTCUSD_close' ].shift(-future_period)
main_df.dropna(inplace= True )
Ensuite, créons les séquences d'entrée. Nous allons parcourir le DataFrame et créer des séquences de longueur sequence_length, composées des prix et volumes précédents de Bitcoin, Litecoin, Ethereum et Bitcoin Cash. Nous stockerons ces séquences dans une liste appelée "séquences".
for i in range(len(main_df) - sequence_length + 1):
sequence = main_df.iloc[i:i+sequence_length, 1:-1].values.flatten()
sequences.append(sequence)
Enfin, nous convertirons les séquences et les cibles en tableaux numpy pour faciliter la manipulation et la formation.
sequences = np.array(sequences)
targets = np.array(main_df['target'])
Veuillez noter que le code fourni ici est une implémentation partielle et se concentre sur les étapes de prétraitement des données. Vous devrez développer davantage l'architecture du modèle, former le modèle et évaluer ses performances. De plus, vous devrez peut-être ajuster les hyperparamètres et expérimenter différentes techniques pour améliorer la précision du modèle.
N'oubliez pas d'importer les bibliothèques nécessaires, de gérer les données manquantes, de prétraiter les fonctionnalités (normalisation, mise à l'échelle, etc.) et de diviser les données en ensembles d'entraînement et de test avant d'entraîner le modèle.
J'espère que cela vous aidera à comprendre le processus de travail avec des données séquentielles et d'application de réseaux de neurones récurrents pour prédire les prix futurs. Bonne chance avec votre projet d'apprentissage en profondeur !
Normalisation et création de séquences Crypto RNN - Deep Learning w/ Python, TensorFlow et Keras p.9
Normalisation et création de séquences Crypto RNN - Deep Learning w/ Python, TensorFlow et Keras p.9
Bonjour à tous et bienvenue dans un autre épisode de la série de didacticiels Deep Learning with Python, TensorFlow et Chaos. Dans cette vidéo, nous allons continuer à travailler sur notre mini-projet d'implémentation d'un réseau neuronal récurrent (RNN) pour prédire les futurs mouvements de prix d'une crypto-monnaie. Nous utiliserons les séquences des prix et des volumes de la devise, ainsi que trois autres prix et volumes de crypto-monnaie.
Jusqu'à présent, nous avons obtenu les données, les avons fusionnées et créé les cibles. Passons maintenant aux étapes suivantes. Nous devons créer des séquences à partir des données et effectuer des tâches telles que l'équilibrage, la normalisation et la mise à l'échelle. Cependant, avant de plonger dans ces tâches, il est crucial d'aborder la question des tests hors échantillon.
Lorsqu'il s'agit de données de séries temporelles et chronologiques, le mélange et la sélection aléatoire d'une partie en tant que données hors échantillon peuvent conduire à un modèle biaisé. Dans notre cas, avec des séquences de 60 minutes et une fenêtre de prédiction de 3 minutes, la sélection aléatoire des données hors échantillon pourrait entraîner la présence d'exemples similaires dans les ensembles dans l'échantillon et hors échantillon. Cela faciliterait le surajustement du modèle et ses performances médiocres sur des données invisibles.
Pour résoudre ce problème, nous devons sélectionner avec soin les données hors échantillon. Pour les données de séries chronologiques, il est recommandé de choisir un bloc de données du futur comme ensemble hors échantillon. Dans notre cas, nous prendrons les 5 derniers % des données historiques comme données hors échantillon. Cette approche simule la construction du modèle il y a 5 % du temps et le test en avant.
Maintenant, implémentons cette séparation des données hors échantillon. Nous allons trier les données en fonction de l'horodatage et trouver le seuil des 5 % de temps restants. En séparant les données de cette manière, nous nous assurons que l'ensemble hors échantillon contient des données du futur, évitant ainsi les fuites de données et les tests biaisés. Une fois séparés, nous aurons les données de validation et les données d'entraînement.
Avant d'aller plus loin, il est important de noter que nous devons prétraiter à la fois les données de validation et de formation. Nous allons créer des séquences, équilibrer les données, les normaliser, les mettre à l'échelle et effectuer d'autres tâches nécessaires. Pour rationaliser ce processus, créons une fonction appelée preprocess_df qui prend un DataFrame en entrée et effectue toutes ces étapes de prétraitement.
Tout d'abord, nous importons le module de prétraitement de la bibliothèque sklearn. Si vous ne l'avez pas installé, vous pouvez le faire en exécutant pip install sklearn. Ensuite, nous définissons la fonction preprocess_df qui prend un DataFrame en paramètre.
Dans la fonction, nous commençons par supprimer la future colonne inutile du DataFrame. Ensuite, nous parcourons les colonnes du DataFrame et appliquons la transformation de changement en pourcentage. Cette étape de normalisation aide à gérer différentes ampleurs de prix et de volumes entre les crypto-monnaies.
Après avoir normalisé les données, nous supprimons toutes les lignes contenant des valeurs NaN, car elles peuvent causer des problèmes lors de la formation. Ensuite, nous utilisons la fonction preprocessing.scale pour mettre à l'échelle les valeurs entre 0 et 1. Alternativement, vous pouvez implémenter votre propre logique de mise à l'échelle.
Maintenant que nous avons prétraité les données, passons au traitement des données séquentielles. Nous créons une liste vide appelée sequential_data et initialisons un objet deque appelé prev_days avec une longueur maximale de 60. L'objet deque nous permet d'ajouter efficacement de nouveaux éléments et de supprimer automatiquement les anciens lorsqu'il atteint la longueur maximale.
Ensuite, nous parcourons les valeurs du DataFrame, qui contient maintenant les données normalisées et mises à l'échelle. Pour chaque ligne, nous ajoutons les valeurs au deque prev_days. Une fois que le deque atteint une longueur d'au moins 60, nous commençons à remplir le sequential_data
# Create a deque object with a maximum length of max_len
if len(prev_days) < max_len:
prev_days.append([n for n in i[:-1]])
else:
# Append the current values to prev_days
prev_days.append([n for n in i[:-1]])
# Add the sequence to the sequential_data list
sequential_data.append([np.array(prev_days), i[-1]])
# Remove the oldest sequence from prev_days
prev_days.popleft()
Maintenant que nous avons généré les séquences, nous pouvons procéder à l'équilibrage des données. L'équilibrage est important pour éviter tout biais vers une classe spécifique dans nos données d'entraînement. Dans ce cas, nos classes sont les différents mouvements de prix (à la hausse ou à la baisse). Pour équilibrer les données, nous compterons le nombre d'occurrences pour chaque classe et limiterons le nombre de séquences pour que la classe majoritaire corresponde à la classe minoritaire.
sells = []
for seq, target in sequential_data:
if target == 0:
sells.append([seq, target])
elif target == 1:
buys.append([seq, target])
# Determine the minimum number of sequences in buys and sells
lower = min(len(buys), len(sells))
# Balance the data by randomly selecting the required number of sequences from buys and sells
buys = buys[:lower]
sells = sells[:lower]
# Concatenate buys and sells to create balanced_data
balanced_data = buys + sells
# Shuffle the balanced_data
random.shuffle(balanced_data)
Après avoir équilibré les données, nous pouvons les diviser en tableaux d'entités d'entrée (X) et d'étiquettes cibles (y).
y = []
for seq, target in balanced_data:
X.append(seq)
y.append(target)
# Convert X and y to numpy arrays
X = np.array(X)
y = np.array(y)
Maintenant que nous avons X comme entités d'entrée et y comme étiquettes cibles, nous pouvons procéder à la division des données en ensembles d'apprentissage et de validation.
train_x, val_x, train_y, val_y = train_test_split(X, y, test_size=0.2, random_state=42)
Dans le code ci-dessus, nous utilisons la fonction train_test_split de scikit-learn pour diviser les données en ensembles d'apprentissage et de validation. Nous attribuons 80 % des données à l'ensemble d'apprentissage (train_x et train_y) et 20 %
scaler = MinMaxScaler()
train_x = scaler.fit_transform(train_x.reshape(train_x.shape[0], -1))
val_x = scaler.transform(val_x.reshape(val_x.shape[0], -1))
# Reshape the data back to its original shape
train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], -1)
val_x = val_x.reshape(val_x.shape[0], val_x.shape[1], -1)
Avec les données préparées, nous pouvons maintenant construire et former le modèle LSTM :
model.add(LSTM(units=128, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128, return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(units=32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(units=2, activation='softmax'))
# Define the optimizer and compile the model
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# Define early stopping
early_stopping = tf.keras.callbacks.EarlyStopping(patience=3)
# Train the model
history = model.fit(train_x, train_y, validation_data=(val_x, val_y), epochs=20, callbacks=[early_stopping])
Nous définissons l'optimiseur comme Adam avec un taux d'apprentissage de 0,001 et compilons le modèle en utilisant l'entropie croisée catégorique clairsemée comme fonction de perte et la précision comme métrique.
L'arrêt précoce est défini à l'aide du rappel EarlyStopping pour surveiller la perte de validation et arrêter l'entraînement s'il ne s'améliore pas après 3 époques.
Le modèle est entraîné à l'aide de la fonction d'ajustement, en transmettant les données d'entraînement (train_x et train_y), les données de validation (val_x et val_y) et les rappels définis. La formation est effectuée pendant 20 époques.
Vous pouvez ajuster l'architecture du modèle, les hyperparamètres et la configuration de la formation en fonction de vos besoins spécifiques.
test_x = scaler.transform(test_x.reshape(test_x.shape[0], -1))
test_x = test_x.reshape(test_x.shape[0], test_x.shape[1], -1)
loss, accuracy = model.evaluate(test_x, test_y)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy*100:.2f}%')
Ensuite, nous utilisons la méthode d'évaluation du modèle pour calculer la perte et la précision sur les données de test. La méthode d'évaluation prend les données d'entrée de test (test_x) et les étiquettes de vérité terrain correspondantes (test_y). La perte et la précision calculées sont imprimées sur la console.
Pensez à importer les modules nécessaires au début de votre script :
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dropout, BatchNormalization, Dense
Ce code vous permettra de former un modèle LSTM pour votre tâche de classification d'achat/vente, de normaliser les données et d'évaluer les performances du modèle sur l'ensemble de test. N'hésitez pas à faire des ajustements ou des modifications selon vos besoins spécifiques.